0Pricing
Blockchain Smart Contracts with Solidity · Lezione

Interazione con i contratti distribuiti

Scopra come interagire con gli smart contract distribuiti utilizzando test JavaScript e comandi della console.

Interazione con i contratti distribuiti è una lezione Blockchain Smart Contracts with Solidity gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Blockchain Smart Contracts with Solidity, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Blockchain Smart Contracts with Solidity include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

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!

Domande Frequenti

La lezione «Interazione con i contratti distribuiti» è gratuita?

Sì — il testo completo di «Interazione con i contratti distribuiti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Blockchain Smart Contracts with Solidity, passa a CoddyKit PRO. Il corso Blockchain Smart Contracts with Solidity include 4 lezioni in totale.

Cosa imparerò in «Interazione con i contratti distribuiti»?

Scopra come interagire con gli smart contract distribuiti utilizzando test JavaScript e comandi della console. Eserciti Blockchain Smart Contracts with Solidity con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Blockchain Smart Contracts with Solidity?

Non è richiesta alcuna esperienza precedente. Blockchain Smart Contracts with Solidity su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Interazione con i contratti distribuiti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Blockchain Smart Contracts with Solidity?

Sì. Ogni lezione Blockchain Smart Contracts with Solidity include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Configurazione di Hardhat o Truffle
  2. Compilazione e deployment dei contratti
  3. Interazione con i contratti distribuiti
  4. Scrittura ed esecuzione dei test dei contract
← Torna a Blockchain Smart Contracts with Solidity