@exodus/ethereum-api 10.0.0 → 10.1.0

package/src/staking/ethereum/staking-adapter.js

@@ -0,0 +1,382 @@
+import { parseUnsignedTx } from '@exodus/ethereum-lib'
+import { TxSet } from '@exodus/models'
+import assert from 'minimalistic-assert'
+
+import {
+  createRejectionError,
+  fail,
+  pass,
+  sumOperationFees,
+  warnIfBelow,
+} from '../evm/staking-errors.js'
+import { stakingProviderClientFactory } from '../staking-provider-client.js'
+import { EthereumStaking } from './api.js'
+import { ETH_STAKING_MIN_AMOUNT } from './min-amount.js'
+import {
+  decodeEthereumStakingFirstUintArg,
+  isEthereumClaimUndelegate,
+  isEthereumDelegate,
+  isEthereumStakingTx,
+  isEthereumUndelegate,
+  isEthereumUndelegatePending,
+} from './staking-utils.js'
+
+export const ETH_STAKING_GAS_LIMITS = Object.freeze({
+  stake: 500_000,
+  unstakeStep: 400_000,
+  claimUnstaked: 350_000,
+})
+
+const VALIDATOR_NAME = 'Everstake'
+const NOTIFIED_ASSET_NAME = 'ethereum'
+
+const getPoolAddress = (asset) => {
+  const addresses = EthereumStaking.addresses[asset.name]
+  assert(addresses, `no Everstake pool for ${asset.name}`)
+  return addresses.EVERSTAKE_ADDRESS_CONTRACT_POOL.toLowerCase()
+}
+
+const getLatestTxTime = ({ txLog, matches }) => {
+  let latest
+  for (const tx of txLog) {
+    if (!matches(tx)) continue
+    const time = new Date(tx.date).getTime()
+    if (latest === undefined || time > latest) latest = time
+  }
+
+  return latest
+}
+
+const addDuration = (time, ...durations) =>
+  time === undefined || durations.some((duration) => typeof duration !== 'number')
+    ? undefined
+    : durations.reduce((total, duration) => total + duration, time)
+
+const toAmount = (asset, value) =>
+  typeof value === 'string' ? asset.currency.defaultUnit(value).abs() : undefined
+
+const isUnstakeTx = (tx) =>
+  Boolean(tx.data?.undelegate || tx.data?.undelegatePending) || isEthereumUndelegate(tx)
+
+const isClaimTx = (tx) => Boolean(tx.data?.claimUndelegate) || isEthereumClaimUndelegate(tx)
+
+const countUnstakeSteps = ({ state, amount }) => {
+  const { pendingBalance, minAmount } = state
+  const leftOver = pendingBalance.sub(amount)
+  const hasPendingStep =
+    pendingBalance.isPositive && !(leftOver.isPositive && leftOver.lt(minAmount))
+  const hasActiveStep = amount.sub(pendingBalance).isPositive
+  return Math.max(Number(hasPendingStep) + Number(hasActiveStep), 1)
+}
+
+const resolveUnstakeAmount = ({ state, intent }) =>
+  intent.isMax ? state.unstakeable : intent.amount
+
+export const createEverstakeStakingAdapter = ({
+  service,
+  stakingProvider = stakingProviderClientFactory(),
+}) => {
+  assert(service, '`service` required')
+
+  const toTarget = (asset) => ({ kind: 'pool', id: getPoolAddress(asset), name: VALIDATOR_NAME })
+
+  const getCapabilities = ({ asset }) => ({
+    participation: 'amount',
+    liquid: false,
+    positions: 'aggregate',
+    operations: {
+      stake: { amount: 'required', supportsMax: true, positionSelectable: false, multiTx: false },
+      unstake: { amount: 'required', supportsMax: true, positionSelectable: false, multiTx: true },
+      claimUnstaked: {
+        amount: 'none',
+        supportsMax: false,
+        positionSelectable: false,
+        multiTx: false,
+      },
+    },
+    target: { kind: 'pool', selection: 'fixed', default: toTarget(asset) },
+    unbonding: { kind: 'queue' },
+    claimUnstaked: 'manual',
+    rewards: { distribution: 'autoCompound' },
+    feeAssetName: asset.feeAsset.name,
+    hardwareWallets: ['ledger'],
+  })
+
+  const toPositions = ({ asset, balances, info, txLog }) => {
+    const stakedAt = getLatestTxTime({ txLog, matches: isEthereumDelegate })
+    const unstakedAt = getLatestTxTime({
+      txLog,
+      matches: (tx) => isUnstakeTx(tx) && !isEthereumUndelegatePending(tx),
+    })
+    const activatesAt = addDuration(stakedAt, info.validatorActivationTime)
+    const withdrawableAt = addDuration(
+      unstakedAt,
+      info.validatorExitTime,
+      info.validatorWithdrawTime ?? 0
+    )
+    const position = (id, status, amount, availableAt) =>
+      amount.isPositive
+        ? [{ id, status, amount, target: toTarget(asset), ...(availableAt && { availableAt }) }]
+        : []
+
+    return [
+      ...position('pending', 'activating', balances.staking, activatesAt),
+      ...position('active', 'active', balances.staked),
+      ...position('withdraw-request-pending', 'deactivating', balances.unstaking, withdrawableAt),
+      ...position('withdraw-request-ready', 'withdrawable', balances.unstaked),
+    ]
+  }
+
+  const readState = ({ asset, accountState, txLog = TxSet.EMPTY }) => {
+    const zero = asset.currency.ZERO
+    const info = accountState.staking?.[asset.name] || {}
+    const loaded = Boolean(accountState.stakingSnapshotOwners?.[asset.name])
+    const balances = asset.api.getBalances({ asset, accountState, txLog })
+    const pendingBalance = info.pendingBalance || zero
+    const activeStakedBalance = info.activeStakedBalance || zero
+    const { staking, staked, unstaking, unstaked } = balances
+
+    return {
+      loaded,
+      isStaking: staked.add(staking).isPositive,
+      hasPosition: [staking, staked, unstaking, unstaked].some((amount) => amount.isPositive),
+      totals: { staking, staked, unstaking, unstaked, rewards: zero },
+      ...(loaded && info.rewardsBalance && { earned: info.rewardsBalance }),
+      positions: toPositions({ asset, balances, info, txLog }),
+      target: toTarget(asset),
+      balances,
+      minAmount: asset.currency.defaultUnit(ETH_STAKING_MIN_AMOUNT),
+      pendingBalance,
+      unstakeable: activeStakedBalance.add(pendingBalance),
+      unclaimedUndelegatedBalance: info.unclaimedUndelegatedBalance || zero,
+      canClaimUndelegatedBalance: Boolean(info.canClaimUndelegatedBalance),
+    }
+  }
+
+  const getGasLimit = ({ operation, state, intent }) => {
+    switch (operation) {
+      case 'stake':
+        return ETH_STAKING_GAS_LIMITS.stake
+      case 'unstake':
+        return (
+          countUnstakeSteps({
+            state,
+            amount: resolveUnstakeAmount({ state, intent }) ?? state.unstakeable,
+          }) * ETH_STAKING_GAS_LIMITS.unstakeStep
+        )
+      case 'claimUnstaked':
+        return ETH_STAKING_GAS_LIMITS.claimUnstaked
+    }
+  }
+
+  const getLimits = ({ asset, operation, state, fee = asset.currency.ZERO }) => {
+    switch (operation) {
+      case 'stake':
+        return {
+          min: state.minAmount,
+          max: state.balances.spendable.sub(fee).clampLowerZero(),
+        }
+      case 'unstake':
+        return { min: state.minAmount, max: state.unstakeable }
+      case 'claimUnstaked':
+        return { max: state.balances.unstaked }
+    }
+  }
+
+  const checkFee = ({ asset, state, fee }) =>
+    fee && state.balances.spendable.lt(fee)
+      ? fail('INSUFFICIENT_FEE_BALANCE', fee.sub(state.balances.spendable), asset.feeAsset.name)
+      : pass()
+
+  const checkStake = ({
+    asset,
+    intent,
+    state,
+    fee = asset.currency.ZERO,
+    estimateOperationFee,
+  }) => {
+    const { spendable } = state.balances
+    const stakeAmount = intent.isMax ? spendable.sub(fee).clampLowerZero() : intent.amount
+    if (!stakeAmount) return fail('BELOW_MINIMUM', state.minAmount, asset.name)
+    if (stakeAmount.lt(state.minAmount)) {
+      return fail('BELOW_MINIMUM', state.minAmount.sub(stakeAmount), asset.name)
+    }
+
+    const required = stakeAmount.add(fee)
+    if (spendable.lt(required)) {
+      return fail('INSUFFICIENT_BALANCE', required.sub(spendable), asset.name)
+    }
+
+    return warnIfBelow({
+      balance: spendable.sub(required),
+      required: sumOperationFees({
+        estimateOperationFee,
+        operations: ['unstake', 'claimUnstaked'],
+      }),
+      warning: 'LOW_FEE_BALANCE',
+    })
+  }
+
+  const checkUnstake = ({ asset, intent, state, fee, estimateOperationFee }) => {
+    const { unstakeable, minAmount } = state
+    if (!unstakeable.isPositive) return fail('NOTHING_TO_UNSTAKE')
+
+    const amount = resolveUnstakeAmount({ state, intent })
+    if (!amount) return fail('UNSTAKE_BELOW_MINIMUM', minAmount, asset.name)
+    if (amount.lt(minAmount)) {
+      return fail('UNSTAKE_BELOW_MINIMUM', minAmount.sub(amount), asset.name)
+    }
+    if (amount.gt(unstakeable)) {
+      return fail('UNSTAKE_EXCEEDS_STAKED', amount.sub(unstakeable), asset.name)
+    }
+
+    const remainder = unstakeable.sub(amount)
+    if (remainder.isPositive && remainder.lt(minAmount)) {
+      return fail('REMAINING_STAKE_BELOW_MINIMUM', minAmount.sub(remainder), asset.name)
+    }
+
+    const feeCheck = checkFee({ asset, state, fee })
+    if (!feeCheck.ok || !fee) return feeCheck
+
+    return warnIfBelow({
+      balance: state.balances.spendable.sub(fee),
+      required: sumOperationFees({ estimateOperationFee, operations: ['claimUnstaked'] }),
+      warning: 'LOW_FEE_BALANCE_FOR_CLAIM',
+    })
+  }
+
+  const checkClaim = ({ asset, state, fee }) => {
+    if (!state.unclaimedUndelegatedBalance.isPositive) return fail('NOTHING_TO_CLAIM')
+    if (!state.canClaimUndelegatedBalance) return fail('UNBONDING_IN_PROGRESS')
+    return checkFee({ asset, state, fee })
+  }
+
+  const checkOperation = ({ asset, operation, intent, state, fee, estimateOperationFee }) => {
+    switch (operation) {
+      case 'stake':
+        return checkStake({ asset, intent, state, fee, estimateOperationFee })
+      case 'unstake':
+        return checkUnstake({ asset, intent, state, fee, estimateOperationFee })
+      case 'claimUnstaked':
+        return checkClaim({ asset, state, fee })
+      default:
+        return fail('OPERATION_UNSUPPORTED')
+    }
+  }
+
+  const rejectUnless = ({ operation, check }) => {
+    if (!check.ok) throw createRejectionError({ operation, check })
+  }
+
+  const buildStake = async ({ asset, walletAccount, intent, state, feeData }) => {
+    const plan = await service.planDelegate({
+      walletAccount,
+      amount: intent.isMax ? state.balances.spendable : intent.amount,
+      feeData,
+      isDelegateAll: Boolean(intent.isMax),
+    })
+    rejectUnless({
+      operation: 'stake',
+      check: checkStake({ asset, intent: { amount: plan.amount }, state, fee: plan.fee }),
+    })
+
+    return plan
+  }
+
+  const buildUnstake = async ({ asset, walletAccount, intent, state, feeData }) => {
+    const plan = await service.planUndelegate({
+      walletAccount,
+      amount: resolveUnstakeAmount({ state, intent }),
+      feeData,
+    })
+    rejectUnless({ operation: 'unstake', check: checkFee({ asset, state, fee: plan.fee }) })
+    return plan
+  }
+
+  const buildClaim = async ({ asset, walletAccount, state, feeData }) => {
+    const plan = await service.planClaimUndelegatedBalance({ walletAccount, feeData })
+    if (!plan) {
+      throw createRejectionError({ operation: 'claimUnstaked', check: fail('NOTHING_TO_CLAIM') })
+    }
+
+    rejectUnless({ operation: 'claimUnstaked', check: checkFee({ asset, state, fee: plan.fee }) })
+    return { ...plan, amount: state.unclaimedUndelegatedBalance }
+  }
+
+  const buildSteps = async ({ asset, walletAccount, operation, intent, state, feeData }) => {
+    switch (operation) {
+      case 'stake':
+        return buildStake({ asset, walletAccount, intent, state, feeData })
+      case 'unstake':
+        return buildUnstake({ asset, walletAccount, intent, state, feeData })
+      case 'claimUnstaked':
+        return buildClaim({ asset, walletAccount, state, feeData })
+      default:
+        throw new Error(`Unsupported ethereum staking operation: ${operation}`)
+    }
+  }
+
+  const simulate = async ({ operation, built, unsignedTxs }) => {
+    if (operation !== 'unstake') return
+    await service.simulateUndelegate({ plan: built, unsignedTxs })
+  }
+
+  const notify = async ({ asset, plan, txIds, delegator }) => {
+    if (asset.name !== NOTIFIED_ASSET_NAME) return
+
+    if (plan.operation === 'stake') {
+      await stakingProvider.notifyStaking({
+        txId: txIds[0],
+        asset: asset.name,
+        delegator,
+        amount: plan.amount.toBaseString(),
+      })
+      return
+    }
+
+    if (plan.operation !== 'unstake') return
+    await Promise.all(
+      plan.txs.map((unsignedTx, index) => {
+        const { data } = parseUnsignedTx({ asset, unsignedTx })
+        return stakingProvider.notifyUnstaking({
+          txId: txIds[index],
+          asset: asset.name,
+          delegator,
+          amount: decodeEthereumStakingFirstUintArg(data).toString(),
+        })
+      })
+    )
+  }
+
+  const classifyTx = ({ asset, tx }) => {
+    if (!isEthereumStakingTx(tx)) return
+
+    const data = tx.data || {}
+    if (isEthereumDelegate(tx)) {
+      const amount = toAmount(asset, data.delegate) ?? tx.coinAmount?.abs()
+      return { operation: 'stake', ...(amount && { amount }) }
+    }
+
+    if (isUnstakeTx(tx)) {
+      const amount = toAmount(asset, data.undelegate) ?? toAmount(asset, data.undelegatePending)
+      return { operation: 'unstake', ...(amount && { amount }) }
+    }
+
+    if (isClaimTx(tx)) {
+      const amount = toAmount(asset, data.claimUndelegate)
+      return { operation: 'claimUnstaked', ...(amount && { amount }) }
+    }
+  }
+
+  return {
+    getCapabilities,
+    readState,
+    getGasLimit,
+    getLimits,
+    checkOperation,
+    buildSteps,
+    simulate,
+    notify,
+    classifyTx,
+  }
+}

package/src/staking/evm/compose-staking-api.js

@@ -0,0 +1,42 @@
+import assert from 'minimalistic-assert'
+
+import { createEvmStakingApi } from './create-evm-staking-api.js'
+
+export const isStakingApiEnabled = (stakingDependencies) =>
+  Boolean(stakingDependencies?.createStakingAdapter) &&
+  stakingDependencies.stakingApiEnabled !== false
+
+export const applyStakingApiOverrides = ({
+  stakingDependencies,
+  overrides = Object.create(null),
+}) => {
+  for (const [assetName, enabled] of Object.entries(overrides)) {
+    assert(typeof enabled === 'boolean', `stakingApiEnabled.${assetName} must be a boolean`)
+    assert(stakingDependencies[assetName], `${assetName} has no staking dependencies`)
+  }
+
+  return Object.fromEntries(
+    Object.entries(stakingDependencies).map(([assetName, dependencies]) => [
+      assetName,
+      assetName in overrides
+        ? { ...dependencies, stakingApiEnabled: overrides[assetName] }
+        : dependencies,
+    ])
+  )
+}
+
+export const composeStakingApi = ({
+  assetClientInterface,
+  legacyStakingApi,
+  stakingDependencies,
+}) => {
+  if (!isStakingApiEnabled(stakingDependencies)) return legacyStakingApi
+
+  return {
+    ...legacyStakingApi,
+    ...createEvmStakingApi({
+      assetClientInterface,
+      adapter: stakingDependencies.createStakingAdapter({ service: legacyStakingApi }),
+    }),
+  }
+}

package/src/staking/evm/create-evm-staking-api.js

@@ -0,0 +1,269 @@
+import { isPendingTxInLog, parseUnsignedTx } from '@exodus/ethereum-lib'
+import { TxSet } from '@exodus/models'
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+import { createRejectionError, createSubmitError, fail } from './staking-errors.js'
+import { createStakingTxs, sendStakingTxs, STAKING_TX_MODE } from './staking-txs.js'
+
+const PLAN_TTL_MS = ms('60s')
+
+const SUBMIT_BY_MODE = {
+  [STAKING_TX_MODE.single]: 'single',
+  [STAKING_TX_MODE.bundle]: 'bundle',
+}
+
+const toIntent = ({ amount, isMax, positionIds, target, enabled }) =>
+  Object.fromEntries(
+    Object.entries({ amount, isMax, positionIds, target, enabled }).filter(
+      ([, value]) => value !== undefined
+    )
+  )
+
+const MODE_BY_SUBMIT = {
+  single: STAKING_TX_MODE.single,
+  bundle: STAKING_TX_MODE.bundle,
+}
+
+const STATE_KEYS = [
+  'loaded',
+  'isStaking',
+  'hasPosition',
+  'totals',
+  'earned',
+  'nextRewardAt',
+  'positions',
+  'target',
+  'autoCompound',
+]
+
+const pickStateKeys = (fullState) =>
+  Object.fromEntries(
+    STATE_KEYS.filter((key) => fullState[key] !== undefined).map((key) => [key, fullState[key]])
+  )
+
+export const createEvmStakingApi = ({ assetClientInterface, adapter }) => {
+  assert(assetClientInterface, '`assetClientInterface` required')
+  assert(adapter, '`adapter` required')
+
+  const getCapabilities = ({ asset }) => adapter.getCapabilities({ asset })
+
+  const isDeclared = ({ asset, operation }) =>
+    Boolean(getCapabilities({ asset }).operations[operation])
+
+  const findPendingOperation = ({ asset, txLog }) => {
+    for (const tx of txLog ?? []) {
+      if (!isPendingTxInLog(tx)) continue
+      const classification = adapter.classifyTx({ asset, tx })
+      if (classification && classification.operation !== 'reward') return classification.operation
+    }
+  }
+
+  const getPendingOperation = ({ asset, txLog, feeAssetTxLog, state }) =>
+    state.pendingOperation ??
+    findPendingOperation({ asset, txLog }) ??
+    findPendingOperation({ asset, txLog: feeAssetTxLog })
+
+  const estimateFee = ({ asset, feeData, operation, state, intent }) => {
+    const gasLimit = adapter.getGasLimit({ asset, operation, state, intent })
+    if (!gasLimit) return
+
+    const { feeAsset } = asset
+    return feeAsset.api.getFee({
+      asset: feeAsset,
+      feeData,
+      gasLimit,
+      amount: feeAsset.currency.ZERO,
+    }).fee
+  }
+
+  const readState = ({ asset, accountState, txLog = TxSet.EMPTY, feeAssetTxLog }) =>
+    adapter.readState({ asset, accountState, txLog, feeAssetTxLog })
+
+  const getStakingState = ({ asset, accountState, txLog, feeAssetTxLog }) => {
+    const fullState = readState({ asset, accountState, txLog, feeAssetTxLog })
+    const pendingOperation = getPendingOperation({ asset, txLog, feeAssetTxLog, state: fullState })
+    return { ...pickStateKeys(fullState), ...(pendingOperation && { pendingOperation }) }
+  }
+
+  const getLimits = ({ asset, accountState, txLog, feeAssetTxLog, feeData, operation }) => {
+    if (!isDeclared({ asset, operation })) return { max: asset.currency.ZERO }
+
+    const state = readState({ asset, accountState, txLog, feeAssetTxLog })
+    const fee = estimateFee({ asset, feeData, operation, state, intent: {} })
+    return {
+      ...adapter.getLimits({ asset, operation, state, fee }),
+      ...(fee && { estimatedFee: fee }),
+    }
+  }
+
+  const canPerform = ({
+    asset,
+    accountState,
+    txLog,
+    feeAssetTxLog,
+    feeData,
+    operation,
+    ...params
+  }) => {
+    const intent = toIntent(params)
+    if (!isDeclared({ asset, operation })) return fail('OPERATION_UNSUPPORTED')
+
+    const state = readState({ asset, accountState, txLog, feeAssetTxLog })
+    if (!state.loaded) return fail('NOT_LOADED')
+    if (getPendingOperation({ asset, txLog, feeAssetTxLog, state })) {
+      return fail('PENDING_TRANSACTION')
+    }
+
+    const fee = estimateFee({ asset, feeData, operation, state, intent })
+    const estimateOperationFee = (laterOperation) =>
+      estimateFee({ asset, feeData, operation: laterOperation, state, intent: {} })
+    return adapter.checkOperation({ asset, operation, intent, state, fee, estimateOperationFee })
+  }
+
+  const classifyTx = ({ asset, tx }) => adapter.classifyTx({ asset, tx })
+
+  const loadState = async ({ asset, walletAccount }) => {
+    const baseAssetName = asset.baseAsset.name
+    const feeAssetName = asset.feeAsset.name
+    const [accountState, txLog, feeAssetTxLog, feeData, address] = await Promise.all([
+      assetClientInterface.getAccountState({ assetName: baseAssetName, walletAccount }),
+      assetClientInterface.getTxLog({ assetName: asset.name, walletAccount }),
+      feeAssetName === asset.name
+        ? undefined
+        : assetClientInterface.getTxLog({ assetName: feeAssetName, walletAccount }),
+      assetClientInterface.getFeeData({ assetName: feeAssetName }),
+      assetClientInterface.getReceiveAddress({ assetName: baseAssetName, walletAccount }),
+    ])
+    return {
+      accountState,
+      txLog,
+      feeAssetTxLog,
+      feeData,
+      address: address.toString().toLowerCase(),
+    }
+  }
+
+  const prepare = async ({ asset, walletAccount, operation, ...params }) => {
+    const intent = toIntent(params)
+    const { accountState, txLog, feeAssetTxLog, feeData, address } = await loadState({
+      asset,
+      walletAccount,
+    })
+    const check = canPerform({
+      asset,
+      accountState,
+      txLog,
+      feeAssetTxLog,
+      feeData,
+      operation,
+      ...intent,
+    })
+    if (!check.ok) throw createRejectionError({ operation, check })
+
+    const state = readState({ asset, accountState, txLog, feeAssetTxLog })
+    const built = await adapter.buildSteps({
+      asset,
+      walletAccount,
+      address,
+      operation,
+      intent,
+      state,
+      feeData,
+    })
+    const createdTxs = await createStakingTxs({
+      asset: asset.baseAsset,
+      walletAccount,
+      fromAddress: address,
+      steps: built.steps,
+      mode: built.mode,
+      gasPrice: built.gasPrice,
+      tipGasPrice: built.tipGasPrice,
+      feeData,
+    })
+    const unsignedTxs = createdTxs.map(({ unsignedTx }) => unsignedTx)
+    await adapter.simulate?.({ asset, operation, built, createdTxs, unsignedTxs })
+
+    return {
+      operation,
+      assetName: asset.name,
+      walletAccount: walletAccount.toString(),
+      txs: unsignedTxs,
+      submit: SUBMIT_BY_MODE[built.mode],
+      amount: built.amount,
+      fee: built.fee,
+      feeAssetName: asset.feeAsset.name,
+      expiresAt: Date.now() + PLAN_TTL_MS,
+    }
+  }
+
+  const notifyProvider = async ({ asset, walletAccount, plan, txIds }) => {
+    if (!adapter.notify) return
+    try {
+      const receiveAddress = await assetClientInterface.getReceiveAddress({
+        assetName: asset.baseAsset.name,
+        walletAccount,
+      })
+      const delegator = receiveAddress.toString().toLowerCase()
+      await adapter.notify({ asset, plan, txIds, delegator })
+    } catch (error) {
+      console.error('Failed to notify staking service:', error)
+    }
+  }
+
+  const isPlanNonceCurrent = async ({ asset, walletAccount, plan }) => {
+    const [firstTx] = plan.txs
+    const { nonce: planNonce } = parseUnsignedTx({ asset: asset.baseAsset, unsignedTx: firstTx })
+    const nonce = await asset.baseAsset.getNonce({
+      asset: asset.baseAsset,
+      fromAddress: firstTx.txMeta.fromAddress,
+      walletAccount,
+    })
+    return nonce === planNonce
+  }
+
+  const submit = async ({ asset, walletAccount, plan, onProgress }) => {
+    assert(plan.assetName === asset.name, 'plan was prepared for another asset')
+    assert(
+      plan.walletAccount === walletAccount.toString(),
+      'plan was prepared for another wallet account'
+    )
+    if (plan.expiresAt && Date.now() > plan.expiresAt) {
+      throw createRejectionError({ operation: plan.operation, check: fail('PLAN_EXPIRED') })
+    }
+
+    const mode = MODE_BY_SUBMIT[plan.submit]
+    assert(mode, `unsupported submit mode ${plan.submit}`)
+
+    if (!(await isPlanNonceCurrent({ asset, walletAccount, plan }))) {
+      throw createRejectionError({ operation: plan.operation, check: fail('PLAN_EXPIRED') })
+    }
+
+    let sent
+    try {
+      sent = await sendStakingTxs({
+        asset: asset.baseAsset,
+        walletAccount,
+        unsignedTxs: plan.txs,
+        mode,
+        onProgress,
+      })
+    } catch (error) {
+      throw createSubmitError({ error, txIds: [], failedIndex: 0 })
+    }
+
+    void notifyProvider({ asset, walletAccount, plan, txIds: sent.txIds })
+
+    return { txIds: sent.txIds, ...(sent.bundleHash && { bundleId: sent.bundleHash }) }
+  }
+
+  return {
+    getCapabilities,
+    getLimits,
+    getStakingState,
+    canPerform,
+    classifyTx,
+    prepare,
+    submit,
+  }
+}