;
};
# Transaction lifecycle
This page covers the full round trip of a transaction: building and sending it, waiting for the receipt, and reading its event logs.
## Try it live
Before you send anything, read the live chain state that your transaction will interact with. These calls run from your browser against Sei Mainnet. You do not need to install anything or use a key.
## Sending a transaction
```ts viem theme={null}
import { createWalletClient, http, parseEther } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { sei } from 'viem/chains';
const account = privateKeyToAccount('0xYourPrivateKey');
const walletClient = createWalletClient({ account, chain: sei, transport: http() });
const hash = await walletClient.sendTransaction({
to: '0xRecipient',
value: parseEther('1'),
});
```
```ts ethers theme={null}
import { ethers } from 'ethers';
const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
const wallet = new ethers.Wallet('0xYourPrivateKey', provider);
const tx = await wallet.sendTransaction({
to: '0xRecipient',
value: ethers.parseEther('1'),
});
```
## Waiting for the receipt
```ts viem theme={null}
import { createPublicClient, http } from 'viem';
const client = createPublicClient({ chain: sei, transport: http() });
const receipt = await client.waitForTransactionReceipt({ hash });
console.log('Status:', receipt.status); // 'success' | 'reverted'
console.log('Block:', receipt.blockNumber);
console.log('Gas used:', receipt.gasUsed);
```
```ts ethers theme={null}
const receipt = await tx.wait();
// or wait for a specific number of confirmations:
// const receipt = await tx.wait(1);
console.log('Status:', receipt.status); // 1 = success, 0 = reverted
console.log('Block:', receipt.blockNumber);
console.log('Gas used:', receipt.gasUsed);
```
Sei has instant finality, so the receipt is final as soon as it arrives. One confirmation is sufficient. See [Finality](/evm/evm-parity/finality).
## Decoding event logs from a receipt
After a contract interaction, decode the events that the transaction emitted:
```ts viem theme={null}
import { parseAbi, decodeEventLog } from 'viem';
const ERC20_ABI = parseAbi([
'function transfer(address to, uint256 amount) returns (bool)',
'event Transfer(address indexed from, address indexed to, uint256 value)',
]);
const hash = await walletClient.writeContract({
address: TOKEN,
abi: ERC20_ABI,
functionName: 'transfer',
args: ['0xRecipient', 1_000_000n],
});
const receipt = await client.waitForTransactionReceipt({ hash });
// viem returns typed logs automatically when you pass the ABI to getTransactionReceipt
const typedReceipt = await client.getTransactionReceipt({ hash });
// Or decode manually from raw logs
for (const log of receipt.logs) {
try {
const event = decodeEventLog({ abi: ERC20_ABI, ...log });
console.log('Event:', event.eventName, event.args);
} catch {
// Log from a different contract or unknown ABI
}
}
```
```ts ethers theme={null}
import { ethers } from 'ethers';
const ERC20_ABI = [
'function transfer(address to, uint256 amount) returns (bool)',
'event Transfer(address indexed from, address indexed to, uint256 value)',
];
const contract = new ethers.Contract(TOKEN, ERC20_ABI, wallet);
const tx = await contract.transfer('0xRecipient', 1_000_000n);
const receipt = await tx.wait();
// ethers parses logs automatically when using a Contract instance
for (const log of receipt.logs) {
try {
const parsed = contract.interface.parseLog(log);
if (parsed) {
console.log('Event:', parsed.name, parsed.args);
// e.g. Event: Transfer [ '0xFrom', '0xTo', 1000000n ]
}
} catch {
// Log from a different contract
}
}
```
## Checking for revert
A receipt with `status: 'reverted'` (viem) or `status: 0` (ethers) means that the transaction was included but the execution failed. The transaction still consumed gas.
```ts viem theme={null}
const receipt = await client.waitForTransactionReceipt({ hash });
if (receipt.status === 'reverted') {
// Transaction was mined but execution failed.
// Simulate the call to get the revert reason.
console.error('Transaction reverted at block', receipt.blockNumber);
}
```
## Fetching a past transaction
```ts viem theme={null}
const tx = await client.getTransaction({ hash: '0xTxHash' });
console.log('From:', tx.from);
console.log('To:', tx.to);
console.log('Value:', tx.value);
console.log('Input data:', tx.input);
```
```ts ethers theme={null}
const tx = await provider.getTransaction('0xTxHash');
const receipt = await provider.getTransactionReceipt('0xTxHash');
```
## Getting logs for a specific transaction
To fetch only the events that a specific transaction emitted, instead of decoding them from the receipt, use this pattern:
```ts viem theme={null}
const logs = await client.getContractEvents({
address: TOKEN,
abi: ERC20_ABI,
eventName: 'Transfer',
blockHash: receipt.blockHash,
});
const txLogs = logs.filter((log) => log.transactionHash === hash);
```
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.