Web3 & DApp Development Fundamentals · Leçon

Gérer les transactions et les événements

Apprenez à envoyer des transactions depuis votre DApp, à gérer leurs confirmations et à écouter les événements des contrats intelligents pour mettre à jour l’interface.

Gérer les transactions et les événements est une leçon Web3 & DApp Development Fundamentals gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Web3 & DApp Development Fundamentals, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Web3 & DApp Development Fundamentals comprend 3 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Making DApps Dynamic

So far, you've learned how to connect your DApp to the blockchain and read data. But what if you want to change data or perform actions?

This lesson teaches you how to send transactions from your DApp to modify blockchain state and how to listen for real-time updates using smart contract events.

What is a Blockchain Transaction?

A blockchain transaction is a signed message that changes the state of the blockchain. Every transaction costs a small fee called gas, paid in Ether (ETH).

Common DApp transactions include:

Sending Ether to another address.
Calling a smart contract function that writes or modifies data.
Deploying a new smart contract.

Sending Transactions from Your DApp

To send a transaction that calls a smart contract function, your DApp needs to:

Connect to a blockchain provider (e.g., MetaMask).
Get a signer (the connected user's wallet).
Call the desired contract function, passing any required parameters.

The user's wallet will then prompt them to confirm and sign the transaction.

Calling a Write Function Example

Here's how you might call a simple setValue function on a smart contract using Ethers.js. Remember, contract refers to your instantiated contract object.

// Assuming 'contract' is an Ethers.js Contract instance
// and 'signer' is obtained from the connected wallet.

async function updateValue(newValue) {
  try {
    const tx = await contract.connect(signer).setValue(newValue);
    console.log("Transaction sent: ", tx.hash);
    // Wait for the transaction to be mined
    await tx.wait();
    console.log("Transaction confirmed!");
  } catch (error) {
    console.error("Error sending transaction:", error);
  }
}

Waiting for Transaction Confirmation

After sending a transaction, it's not immediately processed. It goes into a transaction pool and waits to be included in a block by a miner or validator.

The await tx.wait() call is crucial. It pauses your DApp's execution until the transaction is mined and confirmed on the blockchain, ensuring your UI reflects the latest state.

Understanding Transaction Receipts

When tx.wait() resolves, it returns a transaction receipt. This receipt contains important information about the transaction's outcome:

blockHash and blockNumber: Where it was included.
gasUsed: The actual gas consumed.
status: Indicates if the transaction was successful (1) or failed (0).

Always check the status to ensure the contract call executed as expected!

Introducing Smart Contract Events

Smart contract events are a powerful mechanism for your contracts to 'broadcast' information to external applications (like your DApp) when something significant happens.

Think of them as logs or notifications that DApps can listen to. They are a cost-effective way to communicate data from the blockchain without storing it directly on-chain.

Emitting Events in Solidity

In Solidity, you first define an event with its parameters, then use the emit keyword to trigger it within a function. Here's a simple example:

pragma solidity ^0.8.0;

contract MyContract {
  uint public value;

  // Define an event
  event ValueChanged(address indexed user, uint oldValue, uint newValue);

  function setValue(uint _newValue) public {
    uint _oldValue = value;
    value = _newValue;
    // Emit the event
    emit ValueChanged(msg.sender, _oldValue, _newValue);
  }
}

Listening for Events in Your DApp

Your DApp can subscribe to specific events emitted by a contract. When an event occurs, your DApp receives the event data, allowing you to update the UI or trigger other actions in real-time.

This avoids constant 'polling' (repeatedly asking the blockchain for updates), making your DApp more efficient.

// Assuming 'contract' is an Ethers.js Contract instance

contract.on("ValueChanged", (user, oldValue, newValue, event) => {
  console.log(`Value changed by ${user}`);
  console.log(`From ${oldValue} to ${newValue}`);
  // Update your DApp's UI here, e.g., display the new value
  updateDisplay(newValue);
});

console.log("Listening for ValueChanged events...");

Quick Check: Tx & Events

When calling a smart contract function that modifies state from your DApp, what is the primary purpose of using await tx.wait()?

Recap & Next Steps

You've learned how to make your DApps truly interactive!

You can now send transactions to modify blockchain state.
You know how to wait for confirmation and handle transaction receipts.
You understand how smart contract events provide real-time updates to your DApp.

These skills are fundamental for building dynamic and responsive decentralized applications. Keep practicing to master DApp interaction!

Questions Fréquemment Posées

La leçon « Gérer les transactions et les événements » est-elle gratuite ?

Oui — le texte complet de « Gérer les transactions et les événements » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Web3 & DApp Development Fundamentals, passe à CoddyKit PRO. Le cours Web3 & DApp Development Fundamentals comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Gérer les transactions et les événements » ?

Apprenez à envoyer des transactions depuis votre DApp, à gérer leurs confirmations et à écouter les événements des contrats intelligents pour mettre à jour l’interface. Tu pratiques Web3 & DApp Development Fundamentals avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Web3 & DApp Development Fundamentals ?

Aucune expérience préalable n'est requise. Web3 & DApp Development Fundamentals sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 3.

Combien de temps prend la leçon « Gérer les transactions et les événements » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Web3 & DApp Development Fundamentals ?

Oui. Chaque leçon Web3 & DApp Development Fundamentals inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

React et frameworks Web3
Intégrer des portefeuilles
Gérer les transactions et les événements

← Retour à Web3 & DApp Development Fundamentals