Web3 & DApp Development Fundamentals · Lektion

Transaktionen senden

In die Chain schreiben

Transaktionen senden ist eine kostenlose Web3 & DApp Development Fundamentals-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Web3 & DApp Development Fundamentals-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Web3 & DApp Development Fundamentals-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Writing to the Chain

Changing contract state — transferring tokens, minting, voting — requires a transaction. Transactions must be signed and cost gas.

For this you need a signer, not just a provider.

A Contract with a Signer

To send transactions, create the contract with a signer or connect an existing instance to one:

const contract = new ethers.Contract(
  address,
  abi,
  signer
);
// or
const writable = readOnly.connect(signer);

Now state-changing functions become available.

const contract = new ethers.Contract(
  address,
  abi,
  signer
);
// or
const writable = readOnly.connect(signer);

Sending a Transaction

Calling a write function sends a transaction and returns a transaction response immediately — before it is mined:

const tx = await contract.transfer(
  recipient,
  ethers.parseUnits("10", 18)
);
console.log("Sent:", tx.hash);

The hash identifies the pending transaction.

const tx = await contract.transfer(
  recipient,
  ethers.parseUnits("10", 18)
);
console.log("Sent:", tx.hash);

Waiting for Confirmation

The transaction is not final until it is mined. Wait for the receipt:

const receipt = await tx.wait();
console.log("Mined in block:", receipt.blockNumber);
console.log("Status:", receipt.status);

A status of 1 means success; 0 means it reverted.

const receipt = await tx.wait();
console.log("Mined in block:", receipt.blockNumber);
console.log("Status:", receipt.status);

Waiting for More Blocks

For higher confidence against reorgs, wait for several confirmations:

// Wait for 3 confirmations
const receipt = await tx.wait(3);

More confirmations mean it is increasingly unlikely the transaction will be reversed.

// Wait for 3 confirmations
const receipt = await tx.wait(3);

Sending ETH with a Call

Payable functions accept ETH. Pass a value override as the last argument:

const tx = await contract.deposit({
  value: ethers.parseEther("0.5"),
});
await tx.wait();

The value is in wei; parseEther converts from a human amount.

const tx = await contract.deposit({
  value: ethers.parseEther("0.5"),
});
await tx.wait();

Estimating Gas

Before sending, you can estimate how much gas a call will use:

const gas = await contract.transfer
  .estimateGas(recipient, amount);
console.log("Estimated gas:", gas);

If the function would revert, estimation throws — a useful early warning.

const gas = await contract.transfer
  .estimateGas(recipient, amount);
console.log("Estimated gas:", gas);

Setting Gas Overrides

You can override gas parameters when needed, for example on EIP-1559 chains:

const tx = await contract.transfer(recipient, amount, {
  gasLimit: 100000,
  maxFeePerGas: ethers.parseUnits("30", "gwei"),
  maxPriorityFeePerGas: ethers.parseUnits("2", "gwei"),
});

Usually the wallet picks sensible defaults, so override only when you must.

const tx = await contract.transfer(recipient, amount, {
  gasLimit: 100000,
  maxFeePerGas: ethers.parseUnits("30", "gwei"),
  maxPriorityFeePerGas: ethers.parseUnits("2", "gwei"),
});

Handling Failures

Transactions can fail by reverting, being underpriced, or by user rejection in a wallet. Wrap sends in try/catch:

try {
  const tx = await contract.transfer(to, amount);
  await tx.wait();
} catch (err) {
  console.error("Transaction failed:", err.shortMessage);
}

try {
  const tx = await contract.transfer(to, amount);
  await tx.wait();
} catch (err) {
  console.error("Transaction failed:", err.shortMessage);
}

Nonces and Ordering

Each account has a nonce — a counter ensuring transactions execute in order. ethers manages it automatically, but if you send many transactions quickly you may set it manually to avoid collisions:

const tx = await contract.mint({ nonce: 42 });

Mismatched nonces cause transactions to get stuck or replaced.

const tx = await contract.mint({ nonce: 42 });

Reading Events from a Receipt

After mining, you can inspect the events emitted by your transaction from the receipt logs:

const receipt = await tx.wait();
for (const log of receipt.logs) {
  const parsed = contract.interface.parseLog(log);
  if (parsed) console.log(parsed.name, parsed.args);
}

This confirms the contract did what you expected.

const receipt = await tx.wait();
for (const log of receipt.logs) {
  const parsed = contract.interface.parseLog(log);
  if (parsed) console.log(parsed.name, parsed.args);
}

Quick Check

Test your understanding of sending transactions.

Recap

You learned to send state-changing transactions.

Writes require a signer; attach one with connect or at construction.
A write call returns a pending tx; tx.wait() gives the mined receipt.
Check receipt.status; wait for more confirmations against reorgs.
Send ETH via a value override; estimate cost with estimateGas.
Handle failures with try/catch and mind the account nonce.

Häufig gestellte Fragen

Ist die Lektion „Transaktionen senden“ kostenlos?

Ja — der vollständige Text von „Transaktionen senden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Web3 & DApp Development Fundamentals-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Web3 & DApp Development Fundamentals-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Transaktionen senden“?

In die Chain schreiben Du übst Web3 & DApp Development Fundamentals mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Web3 & DApp Development Fundamentals zu starten?

Keine Vorkenntnisse erforderlich. Web3 & DApp Development Fundamentals auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Transaktionen senden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Web3 & DApp Development Fundamentals-Lektion Code schreiben und ausführen?

Ja. Jede Web3 & DApp Development Fundamentals-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Web3 & DApp Development Fundamentals