Blockchain Smart Contracts with Solidity · บทเรียน

การโต้ตอบกับสัญญาที่นำไปใช้งานแล้ว

ค้นพบวิธีโต้ตอบกับสัญญาอัจฉริยะที่นำไปใช้งานแล้วด้วยการทดสอบ JavaScript และคำสั่งคอนโซล

การโต้ตอบกับสัญญาที่นำไปใช้งานแล้ว เป็นบทเรียน Blockchain Smart Contracts with Solidity ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Blockchain Smart Contracts with Solidity และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Blockchain Smart Contracts with Solidity มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

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!

คำถามที่พบบ่อย

บทเรียน “การโต้ตอบกับสัญญาที่นำไปใช้งานแล้ว” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การโต้ตอบกับสัญญาที่นำไปใช้งานแล้ว” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Blockchain Smart Contracts with Solidity ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Blockchain Smart Contracts with Solidity มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การโต้ตอบกับสัญญาที่นำไปใช้งานแล้ว”

ค้นพบวิธีโต้ตอบกับสัญญาอัจฉริยะที่นำไปใช้งานแล้วด้วยการทดสอบ JavaScript และคำสั่งคอนโซล คุณปฏิบัติ Blockchain Smart Contracts with Solidity ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Blockchain Smart Contracts with Solidity หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Blockchain Smart Contracts with Solidity บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การโต้ตอบกับสัญญาที่นำไปใช้งานแล้ว” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Blockchain Smart Contracts with Solidity นี้ได้ไหม

ได้ บทเรียน Blockchain Smart Contracts with Solidity ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Blockchain Smart Contracts with Solidity