0Pricing
Blockchain Smart Contracts with Solidity · Lesson

Interacting with Deployed Contracts

Discover how to interact with your deployed smart contracts using JavaScript tests and console commands.

Interacting with Deployed Contracts is a free Blockchain Smart Contracts with Solidity lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Blockchain Smart Contracts with Solidity learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why Interact with Contracts?

After deploying your smart contract, the real fun begins: interacting with it! This means calling its functions, reading its data, and sending transactions.

Interacting is crucial for:

  • Testing: Ensuring your contract behaves as expected.
  • dApp Frontends: Letting users connect and use your contract.
  • Automation: Building scripts that perform actions on the blockchain.

Your Interaction Toolkit

When working with Hardhat or Truffle, you have powerful tools to interact with deployed contracts:

  • Hardhat Console / Truffle Console: An interactive command line environment for quick tests and debugging.
  • JavaScript Tests: Automated scripts that deploy (or connect to) contracts and verify their behavior.
  • Custom Scripts: Standalone JavaScript files for more complex, repeatable interactions.

We'll focus on the console and JS tests today.

Hardhat Console: The Sandbox

The Hardhat Console provides a convenient way to interact with your contracts and the blockchain directly from your terminal. It uses a Hardhat Runtime Environment (HRE) that already has ethers.js and your compiled contract artifacts loaded.

To start the console, open your terminal in your Hardhat project directory and run:

npx hardhat console

This will launch an interactive JavaScript environment.

Connect to Your Contract

Before you can call functions, you need to "connect" to your deployed contract. This involves getting its address and creating an ethers.js Contract object that represents it.

Here's how you might do it in a Hardhat script (or directly in the console):

const { ethers } = require("hardhat");

async function main() {
  // First, get the ContractFactory for your contract
  const Counter = await ethers.getContractFactory("Counter");

  // Replace with the actual address where your contract is deployed
  const deployedAddress = "0x5FbDB2315678afecb367f032d93F642f64180aa3";

  // Attach to the deployed contract using its address
  const counter = await Counter.attach(deployedAddress);

  console.log("Connected to Counter at:", counter.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

Calling View Functions

Functions marked as view or pure don't change the blockchain state. They are free to call and simply return data. You can call them directly from your contract instance.

Let's read the current count from our Counter contract. Note that ethers.js returns BigNumber objects for large numbers, so we often use .toString() to display them.

const { ethers } = require("hardhat");

async function main() {
  const Counter = await ethers.getContractFactory("Counter");
  const deployedAddress = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
  const counter = await Counter.attach(deployedAddress);

  // Call the getCount view function
  const currentCount = await counter.getCount();
  console.log("Current count is:", currentCount.toString());
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

Sending Transactions

To change the state of your contract (e.g., update a variable, transfer tokens), you need to send a transaction. These calls cost gas and require a signer (your account).

After sending a transaction, you usually await its confirmation to ensure it's mined on the blockchain. Let's increment our counter:

const { ethers } = require("hardhat");

async function main() {
  const Counter = await ethers.getContractFactory("Counter");
  const deployedAddress = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
  const counter = await Counter.attach(deployedAddress);

  console.log("Incrementing count...");
  const tx = await counter.increment();
  await tx.wait(); // Wait for the transaction to be mined

  const newCount = await counter.getCount();
  console.log("Count after increment:", newCount.toString());
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

Automated Interaction Tests

While the console is great for quick checks, automated JavaScript tests are essential for robust development. They allow you to:

  • Define expected behaviors.
  • Run tests repeatedly and quickly.
  • Catch regressions when you make changes.

Hardhat integrates seamlessly with testing frameworks like Mocha and Chai, using ethers.js for contract interaction.

Writing an Interaction Test

A typical Hardhat test file uses describe for test suites and it for individual tests. Inside an it block, you'll connect to your contract and then call its functions, asserting the results.

Remember to replace the deployedAddress with your contract's actual address on your test network.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Counter Contract Interaction", function () {
  let counter;
  const deployedAddress = "0x5FbDB2315678afecb367f032d93F642f64180aa3"; // Your contract address

  before(async function () {
    const CounterFactory = await ethers.getContractFactory("Counter");
    counter = await CounterFactory.attach(deployedAddress);
  });

  it("should read the initial count correctly", async function () {
    const initialCount = await counter.getCount();
    expect(initialCount.toString()).to.equal("0");
  });

  it("should increment the count via transaction", async function () {
    const initialCount = await counter.getCount();
    await counter.increment();
    const finalCount = await counter.getCount();
    expect(finalCount.toString()).to.equal(initialCount.add(1).toString());
  });
});

Smart Interaction Tips

Keep these tips in mind for effective contract interaction:

  • Always Verify Addresses: Double-check the contract address you're interacting with.
  • Understand Gas: State-changing transactions consume gas. Estimate costs for mainnet deployments.
  • Handle Errors: Use try-catch blocks for transactions, as they can revert.
  • Use Events: Listen for contract events to get structured data about transactions.
  • Test Thoroughly: Write comprehensive tests for all critical functions and edge cases.

Quick Check: Interaction Types

You've learned about two main ways to interact with smart contract functions: reading state (view/pure functions) and changing state (transaction functions).

Which of the following statements about these interactions is TRUE?

Recap: Interacting with Contracts

You've successfully learned how to interact with your deployed smart contracts!

  • We explored using the Hardhat Console for immediate, interactive testing.
  • You saw how to connect to a deployed contract instance.
  • We differentiated between calling `view` functions (free, read-only) and sending transactions (costs gas, changes state).
  • Finally, we covered the importance of automated JavaScript tests for reliable contract interaction.

Next, you're ready to explore state management and storage patterns in Solidity!

Frequently asked questions

Is the “Interacting with Deployed Contracts” lesson free?

Yes — the full text of “Interacting with Deployed Contracts” is free to read here on the web, and the Blockchain Smart Contracts with Solidity course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Blockchain Smart Contracts with Solidity course, upgrade to CoddyKit PRO.

What will I learn in “Interacting with Deployed Contracts”?

Discover how to interact with your deployed smart contracts using JavaScript tests and console commands. You practise Blockchain Smart Contracts with Solidity with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Blockchain Smart Contracts with Solidity?

No prior experience is required. Blockchain Smart Contracts with Solidity on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Interacting with Deployed Contracts” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Blockchain Smart Contracts with Solidity lesson?

Yes. Every Blockchain Smart Contracts with Solidity lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Setting Up Hardhat or Truffle
  2. Compiling and Deploying Contracts
  3. Interacting with Deployed Contracts
  4. Writing and Running Contract Tests
← Back to Blockchain Smart Contracts with Solidity