Wallet EVM API Reference

new WalletManagerEvm(seedOrSigner, config?)

const wallet = new WalletManagerEvm(seedPhrase, {
  provider: 'https://rpc.mevblocker.io/fast',
  transferMaxFee: 100000000000000, // Maximum ERC-20 transfer fee in wei
  transactionMaxFee: 100000000000000 // Maximum native send/sign fee in wei
})

import { SeedSignerEvm } from '@tetherto/wdk-wallet-evm/signers'

const signer = new SeedSignerEvm(seedPhrase)
const signerWallet = new WalletManagerEvm(signer, {
  provider: 'https://rpc.mevblocker.io/fast'
})

const seedPhrase = WalletManagerEvm.getRandomSeedPhrase()
console.log('Seed phrase:', seedPhrase) // 12 words

const longSeedPhrase = WalletManagerEvm.getRandomSeedPhrase(24)
console.log('Long seed phrase:', longSeedPhrase) // 24 words

const isValid = WalletManagerEvm.isValidSeedPhrase('abandon abandon abandon ...')
console.log('Valid:', isValid)

import { PrivateKeySignerEvm } from '@tetherto/wdk-wallet-evm/signers'

wallet.addSigner('treasury', new PrivateKeySignerEvm(privateKey))

// Get first account (index 0)
const account = await wallet.getAccount(0)

// Get second account (index 1)
const account1 = await wallet.getAccount(1)

// Get first account (default)
const defaultAccount = await wallet.getAccount()

// Derive account 2 from a registered derivable signer
const signerAccount = await wallet.getAccount(2, { signerName: 'hardware-root' })

const treasuryAccount = await wallet.getAccount('treasury')

// Full path: m/44'/60'/0'/0/1
const account = await wallet.getAccountByPath("0'/0/1")

// Custom path: m/44'/60'/0'/0/5
const customAccount = await wallet.getAccountByPath("0'/0/5")

const customSignerAccount = await wallet.getAccountByPath("0'/0/5", {
  signerName: 'hardware-root'
})

const feeRates = await wallet.getFeeRates()
console.log('Normal fee rate:', feeRates.normal, 'wei')
console.log('Fast fee rate:', feeRates.fast, 'wei')

// Use in transaction
const result = await account.sendTransaction({
  to: '0x...',
  value: 1000000000000000000n,
  maxFeePerGas: feeRates.fast
})

// Clean up when done
wallet.dispose()

new WalletAccountEvm(seed, path, config?)
new WalletAccountEvm(signer, config?)

const account = new WalletAccountEvm(seedPhrase, "0'/0/0", {
  provider: 'https://rpc.mevblocker.io/fast',
  transferMaxFee: 100000000000000,
  transactionMaxFee: 100000000000000
})

import { PrivateKeySignerEvm } from '@tetherto/wdk-wallet-evm/signers'

const signerAccount = new WalletAccountEvm(
  new PrivateKeySignerEvm(privateKey),
  { provider: 'https://rpc.mevblocker.io/fast' }
)

const account = WalletAccountEvm.fromPrivateKey(privateKey, {
  provider: 'https://rpc.mevblocker.io/fast'
})

const address = await account.getAddress()
console.log('Account address:', address) // 0x...

const message = 'Hello, Ethereum!'
const signature = await account.sign(message)
console.log('Signature:', signature)

const typedData = {
  domain: {
    name: 'MyDApp',
    version: '1',
    chainId: 1,
    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'
  },
  types: {
    Mail: [
      { name: 'from', type: 'address' },
      { name: 'to', type: 'address' },
      { name: 'contents', type: 'string' }
    ]
  },
  message: {
    from: '0xAlice...',
    to: '0xBob...',
    contents: 'Hello Bob!'
  }
}
const signature = await account.signTypedData(typedData)
console.log('EIP-712 Signature:', signature)

const signedTransaction = await account.signTransaction({
  to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
  value: 1000000000000000000n,
  chainId: 1
})

console.log('Signed transaction:', signedTransaction)

const message = 'Hello, Ethereum!'
const signature = await account.sign(message)
const isValid = await account.verify(message, signature)
console.log('Signature valid:', isValid) // true

const isValid = await account.verifyTypedData(typedData, signature)
console.log('Typed data signature valid:', isValid) // true

// EIP-1559 transaction
const result = await account.sendTransaction({
  to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
  value: 1000000000000000000, // 1 ETH in wei
  maxFeePerGas: 30000000000,
  maxPriorityFeePerGas: 2000000000
})

// Legacy transaction
const legacyResult = await account.sendTransaction({
  to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
  value: 1000000000000000000,
  gasPrice: 20000000000,
  gasLimit: 21000
})

console.log('Transaction hash:', result.hash)
console.log('Transaction fee:', result.fee, 'wei')

const quote = await account.quoteSendTransaction({
  to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
  value: 1000000000000000000
})
console.log('Estimated fee:', quote.fee, 'wei')

const result = await account.transfer({
  token: '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
  recipient: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
  amount: 1000000 // 1 USDT (6 decimals)
})
console.log('Transfer hash:', result.hash)
console.log('Transfer fee:', result.fee, 'wei')

const quote = await account.quoteTransfer({
  token: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
  recipient: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
  amount: 1000000
})
console.log('Transfer fee estimate:', quote.fee, 'wei')

const balance = await account.getBalance()
console.log('Balance:', balance, 'wei')
console.log('Balance in ETH:', balance / 1000000000000000000)

// Get USDT balance
const usdtBalance = await account.getTokenBalance('0xdAC17F958D2ee523a2206206994597C13D831ec7')
console.log('USDT balance:', usdtBalance) // In 6 decimal places
console.log('USDT balance formatted:', usdtBalance / 1000000, 'USDT')

const balances = await account.getTokenBalances([
  '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
  '0x68749665FF8D2d112Fa859AA293F07A622782F38'  // XAUT
])

console.log('USDT:', balances['0xdAC17F958D2ee523a2206206994597C13D831ec7'])
console.log('XAUT:', balances['0x68749665FF8D2d112Fa859AA293F07A622782F38'])

const result = await account.approve({
  token: '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
  spender: '0xSpenderAddress...',
  amount: 1000000n
})
console.log('Approve hash:', result.hash)

const allowance = await account.getAllowance(
  '0xdAC17F958D2ee523a2206206994597C13D831ec7',
  '0xSpenderContract...'
)
console.log('Current allowance:', allowance)

const receipt = await account.getTransactionReceipt('0x...')
if (receipt) {
  console.log('Confirmed in block:', receipt.blockNumber)
  console.log('Status:', receipt.status) // 1 = success, 0 = failed
}

const receipt = await account.getTransaction(transactionHash)

console.log(receipt.finality)      // pending, confirmed, final, or dropped
console.log(receipt.success)       // true or false after execution
console.log(receipt.confirmations)
console.log(receipt.receipt)       // Native ethers receipt, or null

const receipt = await account.waitForTransaction(transactionHash, {
  target: 'final',
  timeout: 180000,
  interval: 4000,
  maxPollErrors: 3
})

if (receipt.finality === 'dropped') {
  console.log('The nonce was consumed by another transaction')
} else if (!receipt.success) {
  console.log('The transaction was included but reverted')
}

const readOnlyAccount = await account.toReadOnlyAccount()

// Can check balances but cannot send transactions
const balance = await readOnlyAccount.getBalance()
// readOnlyAccount.sendTransaction() // Would throw error

const authorization = await account.signAuthorization({
  chainId: 1,
  address: delegateContract,
  nonce: 0
})

// Clean up when done
account.dispose()

console.log('Account index:', account.index) // 0, 1, 2, etc.
console.log('Account path:', account.path) // m/44'/60'/0'/0/0

// ⚠️ SENSITIVE: Handle with care
const { privateKey, publicKey } = account.keyPair
console.log('Public key length:', publicKey.length) // 65 bytes
if (privateKey !== null) {
  console.log('Private key length:', privateKey.length) // 32 bytes
}

new WalletAccountReadOnlyEvm(address, config?)

const readOnlyAccount = new WalletAccountReadOnlyEvm('0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6', {
  provider: 'https://rpc.mevblocker.io/fast'
})

const address = await readOnlyAccount.getAddress()
console.log('Account address:', address) // 0x...

const balance = await readOnlyAccount.getBalance()
console.log('Balance:', balance, 'wei')

const tokenBalance = await readOnlyAccount.getTokenBalance('0xdAC17F958D2ee523a2206206994597C13D831ec7')
console.log('USDT balance:', tokenBalance)

const balances = await readOnlyAccount.getTokenBalances([
  '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
  '0x68749665FF8D2d112Fa859AA293F07A622782F38'  // XAUT
])
console.log('Balances:', balances)

const quote = await readOnlyAccount.quoteSendTransaction({
  to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
  value: 1000000000000000000
})
console.log('Estimated fee:', quote.fee, 'wei')

const quote = await readOnlyAccount.quoteTransfer({
  token: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
  recipient: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
  amount: 1000000
})
console.log('Transfer fee estimate:', quote.fee, 'wei')

const message = 'Hello, Ethereum!'
const signature = await account.sign(message)

const readOnlyAccount = new WalletAccountReadOnlyEvm('0x...', { provider: '...' })
const isValid = await readOnlyAccount.verify(message, signature)
console.log('Signature valid:', isValid) // true

const isValid = await readOnlyAccount.verifyTypedData(typedData, signature)
console.log('Typed data signature valid:', isValid) // true

const delegation = await readOnlyAccount.getDelegation()
console.log('Delegated:', delegation.isDelegated)
console.log('Delegate:', delegation.delegateAddress)

const receipt = await readOnlyAccount.getTransactionReceipt('0x...')
if (receipt) {
  console.log('Transaction confirmed in block:', receipt.blockNumber)
  console.log('Gas used:', receipt.gasUsed)
  console.log('Status:', receipt.status) // 1 = success, 0 = failed
} else {
  console.log('Transaction not yet mined')
}

const allowance = await readOnlyAccount.getAllowance(
  '0xdAC17F958D2ee523a2206206994597C13D831ec7',
  '0xSpenderAddress...'
)
console.log('Allowance:', allowance)

type Finality = 'pending' | 'confirmed' | 'final' | 'dropped'
type WaitForTransactionTarget = 'confirmed' | 'final'

interface TransactionReceipt {
  hash: string
  finality: Finality
  success?: boolean
  block?: number
  fee?: bigint
}

interface WaitForTransactionOptions {
  target?: WaitForTransactionTarget // Default: 'confirmed'
  timeout?: number                  // Milliseconds; EVM default: 120,000
  interval?: number                 // Milliseconds; default: 4,000
  maxPollErrors?: number            // Default: 3
}

interface EvmTransactionDetails {
  confirmations: number
  receipt: EvmTransactionReceipt | null
}

interface EvmTransaction {
  to?: string | null;                       // Recipient address; omit or pass null for contract creation
  value: number | bigint;                    // The amount of ethers to send (in wei)
  data?: string;                             // The transaction's data in hex format (optional)
  gasLimit?: number | bigint;                // Maximum amount of gas this transaction can use (optional)
  gasPrice?: number | bigint;                // Legacy gas price in wei (optional)
  maxFeePerGas?: number | bigint;            // EIP-1559 max fee per gas in wei (optional)
  maxPriorityFeePerGas?: number | bigint;    // EIP-1559 priority fee in wei (optional)
  type?: number;                             // Transaction type, such as 4 for ERC-7702 (optional)
  nonce?: number;                            // Transaction nonce (optional)
  chainId?: number | bigint;                 // Network chain ID (optional)
  authorizationList?: AuthorizationLike[];   // ERC-7702 authorization list for type 4 transactions (optional)
}

interface TransferOptions {
  token: string;                     // ERC20 token contract address
  recipient: string;                 // Recipient's Ethereum address
  amount: number | bigint;           // Amount in token's base units
}

interface TransactionResult {
  hash: string;                      // Transaction hash
  fee: bigint;                       // Transaction fee paid in wei
}

interface TransferResult {
  hash: string;                      // Transfer transaction hash
  fee: bigint;                       // Transfer fee paid in wei
}

interface FeeRates {
  normal: bigint;                    // Normal priority fee rate (base fee × 1.1)
  fast: bigint;                      // Fast priority fee rate (base fee × 2.0)
}

interface KeyPair {
  privateKey: Uint8Array | null;     // Private key as Uint8Array (32 bytes, null after dispose)
  publicKey: Uint8Array;             // Public key as Uint8Array (65 bytes)
}

interface EvmSignerLike extends ISigner {
  readonly isDerivable: boolean;
  readonly index?: number;
  readonly path?: string;
  readonly address?: string;
  readonly keyPair: KeyPair;
  derive(relPath: string): Promise<EvmSignerLike>;
  getAddress(): Promise<string>;
  sign(message: string): Promise<string>;
  signTransaction(unsignedTx: UnsignedEvmTransaction): Promise<string>;
  signTypedData(typedData: TypedData): Promise<string>;
  signAuthorization(auth: AuthorizationRequest): Promise<Authorization>;
  dispose(): void;
}

interface UnsignedEvmTransaction {
  chainId: number;
  nonce: number;
  from: string;
  to: string | null;
  data: string;
  value: number | bigint;
  type: number;
  gasLimit: number | bigint;
  gasPrice?: number | bigint;
  maxFeePerGas?: number | bigint;
  maxPriorityFeePerGas?: number | bigint;
  accessList?: any[];
  maxFeePerBlobGas?: number | bigint;
  blobs?: any[];
  blobVersionedHashes?: string[];
  authorizationList?: AuthorizationLike[];
}

interface TypedData {
  domain: TypedDataDomain;                           // The domain separator
  types: Record<string, TypedDataField[]>;           // The type definitions
  message: Record<string, unknown>;                  // The message data
}

interface TypedDataDomain {
  name?: string;                     // The domain name (e.g., the DApp name)
  version?: string;                  // The domain version
  chainId?: number | bigint;         // The chain ID
  verifyingContract?: string;        // The verifying contract address
  salt?: string;                     // An optional salt
}

interface TypedDataField {
  name: string;                      // The field name
  type: string;                      // The field type (e.g., 'address', 'uint256', 'string')
}

interface EvmWalletConfig {
  provider?: string | Eip1193Provider | Array<string | Eip1193Provider>; // RPC URL, EIP-1193 provider, or ordered failover list
  retries?: number;                                                  // Additional retry attempts for provider arrays
  chainId?: number;                                                  // Network chain ID. Skips automatic detection when provided.
  transferMaxFee?: number | bigint;                                  // Maximum ERC-20 transfer fee in wei
  transactionMaxFee?: number | bigint;                               // Maximum native send/sign fee in wei
}

interface DelegationInfo {
  isDelegated: boolean;              // Whether the account has an active ERC-7702 delegation
  delegateAddress: string | null;    // Delegate contract address, or null when not delegated
}

interface ApproveOptions {
  token: string;                         // ERC20 token contract address
  spender: string;                       // Address allowed to spend tokens
  amount: number | bigint;               // Amount to approve in base units
}

interface EvmTransactionReceipt {
  to: string;                        // Recipient address
  from: string;                      // Sender address
  contractAddress: string | null;    // Contract address if contract creation
  transactionIndex: number;          // Transaction index in block
  gasUsed: bigint;                   // Gas actually used
  logsBloom: string;                 // Bloom filter for logs
  blockHash: string;                 // Block hash containing transaction
  transactionHash: string;           // Transaction hash
  logs: Array<Log>;                  // Event logs
  blockNumber: number;               // Block number
  confirmations: number;             // Number of confirmations
  cumulativeGasUsed: bigint;         // Cumulative gas used in block
  effectiveGasPrice: bigint;         // Effective gas price paid
  status: number;                    // Transaction status (1 = success, 0 = failed)
  type: number;                      // Transaction type (0 = legacy, 2 = EIP-1559)
}