Shield, Transfer, and Withdraw with Bermuda

import WalletManagerBermuda from '@bermuda/wdk-wallet-evm-bermuda'
import { Contract, JsonRpcProvider, ZeroAddress, isAddress } from 'ethers'

const PLASMA_TESTNET_CHAIN_ID = 9746n
const USDT0_PLASMA_TESTNET = '0x502012b361AebCE43b26Ec812B74D9a51dB4D412'
const BERMUDA_POOL_PLASMA_TESTNET = '0xfa3193AD6DEEcaF7D5586d40808E80ad2Ca5A007'

const TOKEN_ABI = [
  'function symbol() view returns (string)',
  'function decimals() view returns (uint8)'
]
const POOL_ABI = [
  'function depositFee() view returns (uint256)',
  'function withdrawFee() view returns (uint256)',
  'function protocolFeeRecipient() view returns (address)'
]

function validateOperation(amount, confirm, recordHash) {
  if (typeof amount !== 'bigint' || amount <= 0n) {
    throw new Error('Amount must be a positive bigint in token base units')
  }
  if (typeof confirm !== 'function' || typeof recordHash !== 'function') {
    throw new Error('Confirmation and durable hash recording are required')
  }
}

async function withAccounts({ seed, rpcUrl, transactionMaxFee }, operation) {
  if (typeof rpcUrl !== 'string' || !rpcUrl) {
    throw new Error('A Plasma testnet RPC URL is required')
  }
  if (typeof transactionMaxFee !== 'bigint' || transactionMaxFee <= 0n) {
    throw new Error('Set a positive estimated network fee threshold in wei')
  }

  const provider = new JsonRpcProvider(rpcUrl)
  let wallet
  try {
    const { chainId } = await provider.getNetwork()
    if (chainId !== PLASMA_TESTNET_CHAIN_ID) {
      throw new Error('This example requires Plasma testnet, chain ID 9746')
    }
    const token = new Contract(USDT0_PLASMA_TESTNET, TOKEN_ABI, provider)
    const [symbol, decimals, poolCode] = await Promise.all([
      token.symbol(),
      token.decimals(),
      provider.getCode(BERMUDA_POOL_PLASMA_TESTNET)
    ])
    if (symbol !== 'USDT0' || decimals !== 6n || poolCode === '0x') {
      throw new Error('The expected testnet token or pool is unavailable')
    }

    wallet = new WalletManagerBermuda(seed, {
      provider: rpcUrl,
      transactionMaxFee
    })
    const master = await wallet.getAccount(0)
    const shielded = await wallet.getBermudaAccount(0, 0)
    return await operation({ master, shielded, provider })
  } finally {
    wallet?.dispose()
    provider.destroy()
  }
}

async function readFeeSchedule(provider) {
  const pool = new Contract(BERMUDA_POOL_PLASMA_TESTNET, POOL_ABI, provider)
  const blockTag = await provider.getBlockNumber()
  const [depositFeeBps, withdrawFeeBps, feeRecipient] = await Promise.all([
    pool.depositFee({ blockTag }),
    pool.withdrawFee({ blockTag }),
    pool.protocolFeeRecipient({ blockTag })
  ])
  return {
    depositFeeBps: feeRecipient === ZeroAddress ? 0n : depositFeeBps,
    withdrawFeeBps: feeRecipient === ZeroAddress ? 0n : withdrawFeeBps,
    feeRecipient,
    blockTag
  }
}

async function recordAndConfirm(master, kind, hash, recordHash) {
  try {
    await recordHash({ kind, hash, chainId: Number(PLASMA_TESTNET_CHAIN_ID) })
  } catch (cause) {
    throw new Error(`${kind} returned ${hash}, but recording failed; reconcile this hash before retrying`, { cause })
  }
  let result
  try {
    result = await master.waitForTransaction(hash, {
      target: 'confirmed',
      timeout: 120_000
    })
  } catch (cause) {
    throw new Error(`${kind} has an unconfirmed outcome: ${hash}; reconcile before retrying`, { cause })
  }
  if (!['confirmed', 'final'].includes(result.finality) || result.success !== true) {
    throw new Error(`${kind} did not confirm successfully: ${hash}`)
  }
  return result
}

async function setDepositAllowance(master, requiredAllowance, recordHash) {
  const current = await master.getAllowance(
    USDT0_PLASMA_TESTNET, BERMUDA_POOL_PLASMA_TESTNET
  )
  if (current === requiredAllowance) return

  // Clear existing authorization before setting the reviewed amount.
  if (current !== 0n) {
    const { hash } = await master.approve({
      token: USDT0_PLASMA_TESTNET,
      spender: BERMUDA_POOL_PLASMA_TESTNET,
      amount: 0n
    })
    await recordAndConfirm(master, 'allowance-reset', hash, recordHash)
    if (await master.getAllowance(USDT0_PLASMA_TESTNET, BERMUDA_POOL_PLASMA_TESTNET) !== 0n) {
      throw new Error('Pool allowance did not reset to zero')
    }
  }

  const { hash } = await master.approve({
    token: USDT0_PLASMA_TESTNET,
    spender: BERMUDA_POOL_PLASMA_TESTNET,
    amount: requiredAllowance
  })
  await recordAndConfirm(master, 'deposit-approval', hash, recordHash)
  const allowance = await master.getAllowance(
    USDT0_PLASMA_TESTNET, BERMUDA_POOL_PLASMA_TESTNET
  )
  if (allowance !== requiredAllowance) {
    throw new Error('Pool allowance differs from the reviewed amount')
  }
}

export async function shieldUsdT0({
  seed, rpcUrl, transactionMaxFee, amount, confirm, recordHash
}) {
  validateOperation(amount, confirm, recordHash)
  return withAccounts({ seed, rpcUrl, transactionMaxFee }, async ({ master, shielded, provider }) => {
    const fees = await readFeeSchedule(provider)
    const protocolFee = BigInt(amount) * BigInt(fees.depositFeeBps) / 10_000n
    const requiredAllowance = amount + protocolFee
    if (await master.getTokenBalance(USDT0_PLASMA_TESTNET) < requiredAllowance) {
      throw new Error('Insufficient public USDt0 balance for amount and observed fee')
    }
    const to = shielded.getAddress()
    if (await confirm({
      kind: 'deposit', to, amount, protocolFee, requiredAllowance,
      token: USDT0_PLASMA_TESTNET, pool: BERMUDA_POOL_PLASMA_TESTNET,
      observedAtBlock: fees.blockTag
    }) !== true) throw new Error('Deposit was not confirmed by the application')

    await setDepositAllowance(master, requiredAllowance, recordHash)
    const latest = await readFeeSchedule(provider)
    if (latest.depositFeeBps !== fees.depositFeeBps ||
        latest.feeRecipient !== fees.feeRecipient) {
      throw new Error('Deposit fee configuration changed; review the operation again')
    }

    const hash = await shielded.deposit({ token: USDT0_PLASMA_TESTNET, amount, to })
    const receipt = await recordAndConfirm(master, 'deposit', hash, recordHash)
    return { hash, receipt, to }
  })
}

function relayOptions(relayFee, relayer, recipientKind) {
  if (typeof relayFee !== 'bigint' || relayFee < 0n) {
    throw new Error('Relay fee must be a nonnegative bigint in token base units')
  }
  if (relayFee === 0n) return {}
  if (recipientKind === 'bermuda') {
    if (typeof relayer !== 'string' || !/^0x[0-9a-fA-F]{448}$/.test(relayer)) {
      throw new Error('A positive transfer fee requires a full Bermuda fee recipient')
    }
  } else if (!isAddress(relayer) || relayer.toLowerCase() === ZeroAddress) {
    throw new Error('A positive withdrawal fee requires a nonzero EVM fee recipient')
  }
  return { relayFee, relayer }
}

export async function transferUsdT0({
  seed, rpcUrl, transactionMaxFee,
  to, amount, relayFee = 0n, relayer, confirm, recordHash
}) {
  validateOperation(amount, confirm, recordHash)
  if (typeof to !== 'string' || !/^0x[0-9a-fA-F]{448}$/.test(to)) {
    throw new Error('Supply the full recipient Bermuda address')
  }
  const options = relayOptions(relayFee, relayer, 'bermuda')
  return withAccounts({ seed, rpcUrl, transactionMaxFee }, async ({ master, shielded }) => {
    if (await shielded.getTokenBalance(USDT0_PLASMA_TESTNET) < amount + relayFee) {
      throw new Error('The discovered shielded balance cannot cover this transfer')
    }
    if (await confirm({ kind: 'transfer', to, amount, relayFee, relayer }) !== true) {
      throw new Error('Transfer was not confirmed by the application')
    }
    const hash = await shielded.transfer({ token: USDT0_PLASMA_TESTNET, to, amount }, options)
    const receipt = await recordAndConfirm(master, 'transfer', hash, recordHash)
    return { hash, receipt }
  })
}

export async function withdrawUsdT0({
  seed, rpcUrl, transactionMaxFee,
  to, amount, exactOutputAmounts = false,
  relayFee = 0n, relayer, confirm, recordHash
}) {
  validateOperation(amount, confirm, recordHash)
  if (!isAddress(to) || to.toLowerCase() === ZeroAddress) {
    throw new Error('Supply the intended nonzero public EVM recipient')
  }
  if (typeof exactOutputAmounts !== 'boolean') {
    throw new Error('Select gross-spend or exact-recipient withdrawal accounting')
  }
  const options = { ...relayOptions(relayFee, relayer, 'evm'), exactOutputAmounts }
  return withAccounts({ seed, rpcUrl, transactionMaxFee }, async ({ master, shielded, provider }) => {
    const fees = await readFeeSchedule(provider)
    if (await confirm({
      kind: 'withdraw', to, amount, exactOutputAmounts, relayFee, relayer,
      observedProtocolFeeBps: fees.withdrawFeeBps,
      observedAtBlock: fees.blockTag
    }) !== true) throw new Error('Withdrawal was not confirmed by the application')

    const hash = await shielded.withdraw({ token: USDT0_PLASMA_TESTNET, to, amount }, options)
    const receipt = await recordAndConfirm(master, 'withdraw', hash, recordHash)
    return { hash, receipt }
  })
}