Bridge USD₮0 EVM API Reference

new Usdt0ProtocolEvm(account, config?)

import Usdt0ProtocolEvm from '@tetherto/wdk-protocol-bridge-usdt0-evm'
import { WalletAccountEvm } from '@tetherto/wdk-wallet-evm'

const account = new WalletAccountEvm(seedPhrase, {
  provider: 'https://eth-mainnet.g.alchemy.com/v2/your-api-key'
})

const bridgeProtocol = new Usdt0ProtocolEvm(account, {
  bridgeMaxFee: 1000000000000000n
})

// Standard EVM account
const result = await bridgeProtocol.bridge({
  targetChain: 'arbitrum',
  recipient: '0x...',
  token: '0x...',
  amount: 1000000000000000000n
})

console.log('Bridge hash:', result.hash)
console.log('Approve hash:', result.approveHash)
console.log('Reset allowance hash:', result.resetAllowanceHash)
console.log('Total fee:', result.fee)
console.log('Bridge fee:', result.bridgeFee)

// ERC-4337 account
const result2 = await bridgeProtocol.bridge({
  targetChain: 'arbitrum',
  recipient: '0x...',
  token: '0x...',
  amount: 1000000000000000000n
}, {
  paymasterToken: '0x...',
  bridgeMaxFee: 1000000000000000n
})

console.log('Bridge hash:', result2.hash)
console.log('Total fee:', result2.fee)
console.log('Bridge fee:', result2.bridgeFee)

// Non-EVM destination with overrides
const result3 = await bridgeProtocol.bridge({
  targetChain: 'solana',
  recipient: 'SolanaRecipientAddress...',
  token: '0x...',
  amount: 1000000000000000000n,
  oftContractAddress: '0x...',
  dstEid: 30168
})

const quote = await bridgeProtocol.quoteBridge({
  targetChain: 'polygon',
  recipient: '0x...',
  token: '0x...',
  amount: 1000000000000000000n
})

console.log('Estimated fee:', quote.fee, 'wei')
console.log('Bridge fee:', quote.bridgeFee, 'wei')

if (quote.fee + quote.bridgeFee > 1000000000000000n) {
  console.log('Bridge fees too high')
} else {
  const result = await bridgeProtocol.bridge({
    targetChain: 'polygon',
    recipient: '0x...',
    token: '0x...',
    amount: 1000000000000000000n
  })
}

interface BridgeOptions {
  targetChain: string;
  recipient: string;
  token: string;
  amount: bigint;
  oftContractAddress?: string; // Override OFT contract address
  dstEid?: number;             // Override LayerZero destination endpoint ID
}

interface BridgeResult {
  hash: string;
  fee: bigint;
  bridgeFee: bigint;
  approveHash?: string;
  resetAllowanceHash?: string;
}

interface BridgeProtocolConfig {
  bridgeMaxFee?: bigint;
}

interface EvmErc4337WalletConfig {
  paymasterToken?: string;
}

try {
  const result = await bridgeProtocol.bridge({
    targetChain: 'arbitrum',
    recipient: '0x...',
    token: '0x...',
    amount: 1000000000000000000n
  })
} catch (error) {
  if (error.message.includes('not supported')) {
    console.error('Chain or token not supported')
  }
  if (error.message.includes('Exceeded maximum fee')) {
    console.error('Bridge fee too high')
  }
  if (error.message.includes('must be connected to a provider')) {
    console.error('Wallet not connected to blockchain')
  }
  if (error.message.includes('requires the protocol to be initialized with a non read-only account')) {
    console.error('Cannot bridge with read-only account')
  }
  if (error.message.includes('cannot be equal to the source chain')) {
    console.error('Cannot bridge to the same chain')
  }
}

import Usdt0ProtocolEvm from '@tetherto/wdk-protocol-bridge-usdt0-evm'
import { WalletAccountEvm } from '@tetherto/wdk-wallet-evm'

async function bridgeTokens() {
  const account = new WalletAccountEvm(seedPhrase, {
    provider: 'https://eth-mainnet.g.alchemy.com/v2/your-api-key'
  })

  const bridgeProtocol = new Usdt0ProtocolEvm(account, {
    bridgeMaxFee: 1000000000000000n
  })

  const quote = await bridgeProtocol.quoteBridge({
    targetChain: 'arbitrum',
    recipient: '0x...',
    token: '0x...',
    amount: 1000000000000000000n
  })

  console.log('Bridge quote:', quote)

  const result = await bridgeProtocol.bridge({
    targetChain: 'arbitrum',
    recipient: '0x...',
    token: '0x...',
    amount: 1000000000000000000n
  })

  console.log('Bridge result:', result)
  return result
}

async function bridgeToMultipleChains(bridgeProtocol) {
  const chains = ['arbitrum', 'polygon', 'ethereum']
  const token = '0x...'
  const amount = 1000000000000000000n
  const recipient = '0x...'

  const results = []

  for (const chain of chains) {
    try {
      const quote = await bridgeProtocol.quoteBridge({
        targetChain: chain,
        recipient,
        token,
        amount
      })

      console.log(`Bridge to ${chain}:`, quote)

      const result = await bridgeProtocol.bridge({
        targetChain: chain,
        recipient,
        token,
        amount
      })

      results.push({ chain, result })
      console.log(`Bridge to ${chain} successful:`, result.hash)

    } catch (error) {
      console.error(`Bridge to ${chain} failed:`, error.message)
    }
  }

  return results
}

import { WalletAccountEvmErc4337 } from '@tetherto/wdk-wallet-evm-erc-4337'

async function gaslessBridge() {
  const account = new WalletAccountEvmErc4337(seedPhrase, {
    provider: 'https://arb1.arbitrum.io/rpc',
    paymasterToken: '0x...'
  })

  const bridgeProtocol = new Usdt0ProtocolEvm(account, {
    bridgeMaxFee: 1000000000000000n
  })

  const result = await bridgeProtocol.bridge({
    targetChain: 'polygon',
    recipient: '0x...',
    token: '0x...',
    amount: 1000000000000000000n
  }, {
    paymasterToken: '0x...'
  })

  console.log('Gasless bridge result:', result)
  return result
}