Sign EVM Transactions

Learn how to sign Ethereum transactions using Dynamic’s Node SDK

Overview

This guide teaches you how to sign EVM transactions using Dynamic’s Node SDK. You’ll learn how to prepare transactions, sign them securely, and send them to the blockchain.

Prerequisites

Before you begin, make sure you have:

• Created an EVM wallet
• Set up your authenticated client

Step 1: Set Up Your Environment

First, install the required dependencies:

bun add viem

Step 2: Prepare Your Transaction

Create a transaction using viem’s transaction preparation utilities:

import { authenticatedEvmClient } from './client';
import { http } from 'viem';
import { base } from 'viem/chains';
import { parseEther } from 'viem/utils';

const evmClient = await authenticatedEvmClient();

// Create a viem public client for transaction preparation
const publicClient = evmClient.createViemPublicClient({
  chain: base,
  rpcUrl: 'https://mainnet.base.org',
});

// Define your transaction
const transactionRequest = {
  to: '0xRecipientAddress' as `0x${string}`,
  value: parseEther('0.1'), // 0.1 ETH
  // Add other transaction parameters as needed
  // data: '0x...', // For contract interactions
  // gas: 21000n, // Optional gas limit
};

// Prepare the transaction (this will estimate gas, get nonce, etc.)
const preparedTx = await publicClient.prepareTransactionRequest({
  ...transactionRequest,
  chain,
  account: '0xYourWalletAddress' as `0x${string}`,
});

console.log('Transaction prepared:', preparedTx);

Step 3: Key Share Management for Signing

The approach for signing transactions depends on how you created your wallet:

With Automatic Backup (Recommended)

If you created your wallet with backUpToDynamic: true, you can sign directly without retrieving key shares:

// ✅ Simple signing - no externalServerKeyShares needed
const signedTx = await evmClient.signTransaction({
  walletMetadata,
  transaction: preparedTx,
  password: 'your-wallet-password', // Only if wallet was created with password
});

console.log('Transaction signed:', signedTx);

With Manual Backup

If you created your wallet with backUpToDynamic: false, you must retrieve and provide external key shares:

// Retrieve your stored key shares from your secrets vault
const externalServerKeyShares = await vault.read(`wallet:${accountAddress}/shares`);

// Sign the transaction with external key shares
const signedTx = await evmClient.signTransaction({
  walletMetadata,
  externalServerKeyShares,
  transaction: preparedTx,
});

console.log('Transaction signed:', signedTx);

Password Handling Notes:

• If your wallet was created without a password, omit the password parameter
• If your wallet was created with a password, you must provide it for all operations
• The password parameter is always optional in the API, but required if the wallet is password-protected

Step 4: Send the Transaction

Send the signed transaction to the network:

import { createWalletClient } from 'viem';

const walletClient = createWalletClient({
  chain: base,
  transport: http('https://mainnet.base.org'),
  account: '0xYourWalletAddress' as `0x${string}`,
});

const txHash = await walletClient.sendRawTransaction({
  serializedTransaction: signedTx,
});

console.log('Transaction hash:', txHash);
console.log('Block explorer URL:', `https://basescan.org/tx/${txHash}`);

Complete Example: Send ETH

Here’s a complete example that sends ETH from one address to another:

import { authenticatedEvmClient } from './client';
import { http, createWalletClient } from 'viem';
import { base } from 'viem/chains';
import { parseEther } from 'viem/utils';

export const sendEth = async ({
  fromAddress,
  toAddress,
  amount,
  password,
}: {
  fromAddress: string;
  toAddress: string;
  amount: string; // Amount in ETH (e.g., "0.1")
  password?: string;
}) => {
  const evmClient = await authenticatedEvmClient();

  // Load walletMetadata + shares from where you persisted them at creation time
  const walletMetadata = JSON.parse(await redis.get(`wallet:${fromAddress}`));
  const externalServerKeyShares = await vault.read(`wallet:${fromAddress}/shares`);

  // Create public client for transaction preparation
  const publicClient = evmClient.createViemPublicClient({
    chain: base,
    rpcUrl: 'https://mainnet.base.org',
  });

  // Prepare transaction
  const preparedTx = await publicClient.prepareTransactionRequest({
    to: toAddress as `0x${string}`,
    value: parseEther(amount),
    chain: base,
    account: fromAddress as `0x${string}`,
  });

  // Sign transaction
  const signedTx = await evmClient.signTransaction({
    walletMetadata,
    externalServerKeyShares,
    transaction: preparedTx,
    password,
  });

  // Send transaction
  const walletClient = createWalletClient({
    chain: base,
    transport: http('https://mainnet.base.org'),
    account: fromAddress as `0x${string}`,
  });

  const txHash = await walletClient.sendRawTransaction({
    serializedTransaction: signedTx,
  });

  return txHash;
};

// Usage
const txHash = await sendEth({
  fromAddress: '0xYourWalletAddress',
  toAddress: '0xRecipientAddress',
  amount: '0.1',
  password: 'your-password',
});

console.log('Transaction sent:', txHash);

Step 5: Handle Transaction Errors

Implement proper error handling for transaction signing and sending:

try {
  const signedTx = await evmClient.signTransaction({
    walletMetadata,
    externalServerKeyShares,
    transaction: preparedTx,
  });

  const txHash = await walletClient.sendRawTransaction({
    serializedTransaction: signedTx,
  });

  console.log('Transaction successful:', txHash);
} catch (error) {
  if (error.message.includes('insufficient funds')) {
    console.error('Insufficient balance for transaction');
  } else if (error.message.includes('nonce')) {
    console.error('Nonce error - transaction may have been sent already');
  } else if (error.message.includes('gas')) {
    console.error('Gas estimation failed');
  } else {
    console.error('Transaction failed:', error.message);
  }
}

Best Practices

1. Gas Estimation: Always let viem estimate gas automatically unless you have specific requirements
2. Nonce Management: Use viem’s transaction preparation to handle nonces automatically
3. Error Handling: Implement comprehensive error handling for different failure scenarios
4. Transaction Monitoring: Monitor transaction status after sending
5. Security: Never expose key shares in client-side code

Common Transaction Types

Simple ETH Transfer

const transactionRequest = {
  to: '0xRecipientAddress',
  value: parseEther('0.1'),
};

Contract Interaction

const transactionRequest = {
  to: '0xContractAddress',
  data: '0xFunctionSelector...', // Contract function call data
  value: parseEther('0'), // For payable functions
};

Gas Optimization

const transactionRequest = {
  to: '0xRecipientAddress',
  value: parseEther('0.1'),
  gas: 21000n, // Explicit gas limit for simple transfers
};

Next Steps

Now that you can sign transactions, you can:

• Sign messages
• Verify message signatures
• Import private keys
• Use imported wallets