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, "0'/0/0", {
  provider: 'https://eth.drpc.org'
})

const bridgeProtocol = new Usdt0ProtocolEvm(account, {
  bridgeMaxFee: 1000000000000000n // Standard Ethereum account: source native base units
})

// Standard EVM account
const standardBridgeProtocol = new Usdt0ProtocolEvm(standardAccount)

await standardAccount.approve({
  token: '0x...', // USDt contract address
  spender: '0x...', // OFT or bridge spender address
  amount: 1000000n
})

const result = await standardBridgeProtocol.bridge({
  targetChain: 'arbitrum',
  recipient: '0x...', // Recipient address
  token: '0x...', // USDt contract address
  amount: 1000000n,
  oftContractAddress: '0x...' // Same address used as approval spender
})

console.log('Bridge hash:', result.hash)
console.log('Account transaction fee:', result.fee)
console.log('Bridge fee:', result.bridgeFee)

// ERC-4337 account: approval is bundled automatically
const erc4337BridgeProtocol = new Usdt0ProtocolEvm(erc4337Account)

const result2 = await erc4337BridgeProtocol.bridge({
  targetChain: 'arbitrum',
  recipient: '0x...', // Recipient address
  token: '0x...', // USDt contract address
  amount: 1000000n,
  oftContractAddress: '0x...' // Optional custom OFT contract
}, {
  paymasterToken: { address: '0x...' } // Paymaster token configuration
})

console.log('Bridge hash:', result2.hash) // Single hash for bundled operations
console.log('Account fee:', result2.fee)
console.log('Bridge fee:', result2.bridgeFee)

const quote = await bridgeProtocol.quoteBridge({
  targetChain: 'polygon',
  recipient: '0x...', // Recipient address
  token: '0x...', // USDt contract address
  amount: 1000000n
})

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

// Check if fees are acceptable
if (quote.fee + quote.bridgeFee >= 1000000000000000n) {
  console.log('Bridge fees too high')
} else {
  // Proceed with bridge
  await account.approve({
    token: '0x...', // USDt contract address
    spender: '0x...', // OFT or bridge spender address
    amount: 1000000n
  })

  const result = await bridgeProtocol.bridge({
    targetChain: 'polygon',
    recipient: '0x...', // Recipient address
    token: '0x...', // USDt contract address
    amount: 1000000n,
    oftContractAddress: '0x...' // Same address used as approval spender
  })
}

const chains = await bridgeProtocol.getSupportedChains()
// [{ id: 'ethereum', name: 'Ethereum', type: 'evm', nativeToken: 'ETH' }, ...]

const allTokens = await bridgeProtocol.getSupportedTokens()
const ethereumTokens = await bridgeProtocol.getSupportedTokens({
  fromChain: 'ethereum'
})
const xaut0Tokens = await bridgeProtocol.getSupportedTokens({
  fromToken: 'XAUT0'
})

interface BridgeOptions {
  targetChain: string;              // Destination chain name
  recipient: string;                // Address that will receive bridged tokens
  token: string;                    // Token contract address on source chain
  amount: number | bigint;          // Amount to bridge in token base units
  oftContractAddress?: string;      // Optional custom OFT contract address
  dstEid?: number;                  // Optional destination endpoint ID override
}

interface BridgeResult {
  hash: string;                     // Main bridge transaction hash
  fee: bigint;                      // Account quote fee; unit depends on account gas-payment mode
  bridgeFee: bigint;                // Standard: source native unit; ERC-4337 helper: bridged-token base units
}

interface BridgeProtocolConfig {
  bridgeMaxFee?: number | bigint;    // Reject when the implementation's fee + bridgeFee is at or above this value
}

type Erc4337QuoteConfig = Partial<
  | EvmErc4337WalletPaymasterTokenConfig
  | EvmErc4337WalletSponsorshipPolicyConfig
  | EvmErc4337WalletNativeCoinsConfig
>

type Erc4337BridgeConfig = Erc4337QuoteConfig & {
  bridgeMaxFee?: number | bigint
}

type SwidgeSupportedChain = {
  id: string | number
  name: string
  type: string
  nativeToken: string
}

type SwidgeSupportedToken = {
  token: string
  chain: string | number
  symbol: string
  decimals: number
  address?: string
  name?: string
}

type SwidgeSupportedTokensOptions = {
  fromChain?: string | number
  fromToken?: string
  toChain?: string | number
}

try {
  await account.approve({
    token: '0x...', // USDt contract address
    spender: '0x...', // OFT or bridge spender address
    amount: 1000000n
  })

  const result = await bridgeProtocol.bridge({
    targetChain: 'arbitrum',
    recipient: '0x...', // Recipient address
    token: '0x...', // USDt contract address
    amount: 1000000n,
    oftContractAddress: '0x...' // Same address used as approval spender
  })
} 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() {
  // Create wallet account
  const account = new WalletAccountEvm(seedPhrase, "0'/0/0", {
    provider: 'https://eth.drpc.org'
  })

  // Create bridge protocol
  const bridgeProtocol = new Usdt0ProtocolEvm(account)

  // Get quote first
  const quote = await bridgeProtocol.quoteBridge({
    targetChain: 'arbitrum',
    recipient: '0x...', // Recipient address
    token: '0x...', // USDt contract address
    amount: 1000000n
  })

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

  // Execute bridge
  await account.approve({
    token: '0x...', // USDt contract address
    spender: '0x...', // OFT or bridge spender address
    amount: 1000000n
  })

  const result = await bridgeProtocol.bridge({
    targetChain: 'arbitrum',
    recipient: '0x...', // Recipient address
    token: '0x...', // USDt contract address
    amount: 1000000n,
    oftContractAddress: '0x...' // Optional custom OFT contract
  })

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

  return result
}

async function bridgeToMultipleChains(account, bridgeProtocol) {
  const chains = ['arbitrum', 'polygon', 'ethereum']
  const token = '0x...' // USDt contract address
  const amount = 1000000n
  const recipient = '0x...' // Recipient address

  const results = []

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

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

      // Execute bridge
      await account.approve({
        token,
        spender: '0x...', // OFT or bridge spender address for the source route
        amount
      })

      const result = await bridgeProtocol.bridge({
        targetChain: chain,
        recipient,
        token,
        amount,
        oftContractAddress: '0x...' // Same address used as approval spender
      })

      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() {
  // Create ERC-4337 account
  const account = new WalletAccountEvmErc4337(seedPhrase, "0'/0/0", {
    chainId: 42161,
    provider: 'https://arb1.arbitrum.io/rpc',
    bundlerUrl: 'https://api.candide.dev/public/v3/42161',
    safeModulesVersion: '0.3.0',
    paymasterUrl: 'https://api.candide.dev/public/v3/42161',
    paymasterAddress: '0x8b1f6cb5d062aa2ce8d581942bbb960420d875ba',
    paymasterToken: { address: '0x...' } // Paymaster token configuration
  })

  // Create bridge protocol
  const bridgeProtocol = new Usdt0ProtocolEvm(account)

  // The protocol bundles approval and the helper call in one UserOperation.
  const result = await bridgeProtocol.bridge({
    targetChain: 'polygon',
    recipient: '0x...', // Recipient address
    token: '0x...', // USDt contract address
    amount: 1000000n,
    oftContractAddress: '0x...' // Optional custom OFT contract
  }, {
    paymasterToken: { address: '0x...' } // Paymaster token configuration
  })

  console.log('ERC-4337 bridge result:', result)
  return result
}