Shield, Transfer, and Withdraw with Bermuda

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

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

const TOKEN_ABI = [
  'function symbol() view returns (string)',
  'function decimals() view returns (uint8)'
]

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 {
    try {
      wallet?.dispose()
    } finally {
      provider.destroy()
    }
  }
}

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, tokenSpendBudget, confirm, recordHash
}) {
  validateOperation(tokenSpendBudget, confirm, recordHash)
  return withAccounts({ seed, rpcUrl, transactionMaxFee }, async ({ master, shielded }) => {
    if (await master.getTokenBalance(USDT0_PLASMA_TESTNET) < tokenSpendBudget) {
      throw new Error('The public USDt0 balance is below the selected token budget')
    }
    const to = shielded.getAddress()
    if (await confirm({
      kind: 'deposit', to, tokenSpendBudget, exactOutputAmounts: false,
      token: USDT0_PLASMA_TESTNET, pool: BERMUDA_POOL_PLASMA_TESTNET
    }) !== true) throw new Error('Deposit was not confirmed by the application')

    await setDepositAllowance(master, tokenSpendBudget, recordHash)
    let hash
    try {
      hash = await shielded.deposit(
        { token: USDT0_PLASMA_TESTNET, amount: tokenSpendBudget, to },
        { exactOutputAmounts: false }
      )
    } catch (error) {
      if (error instanceof TransactionError &&
          error.reason === TransactionErrorReason.INSUFFICIENT_BALANCE) {
        throw new Error('Insufficient current deposit funding; reconcile recorded operations before retrying', { cause: error })
      }
      throw error
    }
    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]{2496}$/.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]{2496}$/.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 confirm({
      kind: 'transfer', to, amount, relayFee, relayer, token: USDT0_PLASMA_TESTNET
    }) !== 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 = true,
  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 }) => {
    if (await confirm({
      kind: 'withdraw', to, amount, exactOutputAmounts, relayFee, relayer,
      token: USDT0_PLASMA_TESTNET
    }) !== 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 }
  })
}