@exodus/sui-api 1.2.3 → 1.3.1

package/CHANGELOG.md

@@ -3,6 +3,31 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.3.1](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.3.0...@exodus/sui-api@1.3.1) (2026-10-09)
+
+
+### Bug Fixes
+
+* migrate to @exodus/basic-utils 5 ([#8894](https://github.com/ExodusMovement/assets/issues/8894)) ([ed125f3](https://github.com/ExodusMovement/assets/commit/ed125f3257785c92a3b8f8239a2e9eefe5dc6772))
+
+
+
+## [1.3.0](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.2.3...@exodus/sui-api@1.3.0) (2026-10-05)
+
+
+### Features
+
+* **sui-plugin:** sui native staking via staking api v2 ([#8839](https://github.com/ExodusMovement/assets/issues/8839)) ([8523a23](https://github.com/ExodusMovement/assets/commit/8523a2303deeaa4dc4280829fb5b642191a3ae2e))
+
+
+### Bug Fixes
+
+* disable @exodus/hydra/no-param-reassign-prop-only warnings ([#8531](https://github.com/ExodusMovement/assets/issues/8531)) ([ddae556](https://github.com/ExodusMovement/assets/commit/ddae556361285919fe82cd10a81cfeae79ccc6b5))
+* **lint:** fix no-await-expression-member warnings and upgrade to error ([#8503](https://github.com/ExodusMovement/assets/issues/8503)) ([a7fb2c3](https://github.com/ExodusMovement/assets/commit/a7fb2c3bcb4e6b9e97e7f8bb3b8434b78036fe68))
+* **lint:** migrate lodash to @exodus/basic-utils ([#8514](https://github.com/ExodusMovement/assets/issues/8514)) ([12c574f](https://github.com/ExodusMovement/assets/commit/12c574f1ac8ab0592700df574b2643141237090a))
+
+
+
 ## [1.2.3](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.2.2...@exodus/sui-api@1.2.3) (2026-08-06)
 
 

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@exodus/sui-api",
-  "packageManager": "yarn@4.3.1",
-  "version": "1.2.3",
+  "version": "1.3.1",
   "description": "Transaction monitors, RPC with the blockchain node, and other networking code for Sui",
   "type": "module",
   "main": "src/index.js",
@@ -19,14 +18,12 @@
     "provenance": false
   },
   "scripts": {
-    "test": "run -T exodus-test --jest",
-    "lint": "run -T eslintc .",
-    "lint:fix": "yarn lint --fix"
+    "test": "exodus-test --jest"
   },
   "dependencies": {
     "@exodus/asset-lib": "^5.0.0",
     "@exodus/assets": "^11.1.2",
-    "@exodus/basic-utils": "^3.1.0",
+    "@exodus/basic-utils": "^5.1.0",
     "@exodus/crypto": "^1.0.0-rc.26",
     "@exodus/currency": "^6.0.1",
     "@exodus/models": "^13.0.0",
@@ -50,5 +47,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "52180d93ce2bcafeaf575f9761f9863cc1bf22aa"
+  "gitHead": "41e6c1bb6a3d919f08cc3ee38068159259b335be"
 }

package/src/api.js

@@ -184,11 +184,28 @@ export class SuiApi {
     return coins
   }
 
+  async getStakes({ owner }) {
+    return this.client.getStakes({ owner })
+  }
+
+  async getLatestSuiSystemState() {
+    return this.client.getLatestSuiSystemState()
+  }
+
+  async buildTransaction({ transaction, onlyTransactionKind = false }) {
+    return transaction.build({ client: this.client, onlyTransactionKind })
+  }
+
+  async devInspectTransaction({ sender, transactionBlock }) {
+    return this.client.devInspectTransactionBlock({ sender, transactionBlock })
+  }
+
   async broadcastTx(plainTx) {
     return this.client.executeTransactionBlock({
       transactionBlock: plainTx.bytes,
       signature: plainTx.signature,
       options: {
+        showInput: true,
         showEffects: true,
         showObjectChanges: true,
         showBalanceChanges: true,

package/src/balances.js

@@ -1,10 +1,17 @@
+import { getStakingBalances } from './staking/staking-balances.js'
+
 export const getBalances = ({ asset, accountState }) => {
   const isBaseAsset = asset.name === asset.baseAssetName
 
   if (isBaseAsset) {
+    const spendable = accountState.utxos.value
+    const stakingBalances = getStakingBalances({ asset, stakingInfo: accountState.stakingInfo })
+    const { staking, staked, unstaked } = stakingBalances
     return {
-      total: accountState.utxos.value,
-      spendable: accountState.utxos.value,
+      total: spendable.add(staking).add(staked).add(unstaked),
+      spendable,
+      stakeable: spendable,
+      ...stakingBalances,
     }
   }
 

package/src/basic-account-state.js

@@ -1,11 +1,14 @@
 import { AccountState, UtxoCollection } from '@exodus/models'
 import { asset } from '@exodus/sui-meta'
 
+import { EMPTY_STAKING_INFO } from './staking/staking-info.js'
+
 export const createBasicAccountState = () => {
   return class SuiAccountState extends AccountState {
     static defaults = {
       utxos: UtxoCollection.createEmpty({ currency: asset.currency }),
       tokenUtxos: Object.create(null),
+      stakingInfo: EMPTY_STAKING_INFO,
     }
   }
 }

package/src/index.js

@@ -8,3 +8,7 @@ export { getFeeAsyncFactory } from './get-fee-async.js'
 export { txSendFactory } from './tx-send.js'
 export { createUnsignedTxFactory } from './create-unsigned-tx.js'
 export { createTxFactory } from './tx-create.js'
+export { createStakingSettings } from './staking/staking-settings.js'
+export { EVERSTAKE_VALIDATOR } from './staking/constants.js'
+export { createStakingApi } from './staking/create-staking-api.js'
+export { createStakingProviderClient } from './staking/staking-provider-client.js'

package/src/staking/constants.js

@@ -0,0 +1,18 @@
+import ms from 'ms'
+
+export const EVERSTAKE_VALIDATOR =
+  '0xbba318294a51ddeafa50c335c8e77202170e1f272599a2edc40592100863f638'
+export const EVERSTAKE_VALIDATOR_NAME = 'Everstake'
+
+export const SUI_SYSTEM_PACKAGE = '0x3'
+export const SUI_SYSTEM_MODULE = 'sui_system'
+export const ADD_STAKE_FUNCTION = 'request_add_stake'
+export const WITHDRAW_STAKE_FUNCTION = 'request_withdraw_stake'
+export const ADD_STAKE_TARGET = `${SUI_SYSTEM_PACKAGE}::${SUI_SYSTEM_MODULE}::${ADD_STAKE_FUNCTION}`
+export const WITHDRAW_STAKE_TARGET = `${SUI_SYSTEM_PACKAGE}::${SUI_SYSTEM_MODULE}::${WITHDRAW_STAKE_FUNCTION}`
+export const STAKED_SUI_TYPE = '0x3::staking_pool::StakedSui'
+
+export const STAKING_GAS_BUDGET = 20_000_000
+export const EPOCH_MS = ms('1d')
+
+export const DEFAULT_STAKING_URL = 'https://staking.a.exodus.io'

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

@@ -0,0 +1,441 @@
+import { GAS_BUDGET_SAFETY_FACTOR, MIN_GAS_BUDGET } from '@exodus/sui-lib'
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+import { getFeeAmount } from '../transform-tx.js'
+import { EPOCH_MS, EVERSTAKE_VALIDATOR_NAME, STAKING_GAS_BUDGET } from './constants.js'
+import { getStakeValue } from './staking-balances.js'
+import { createRejectionError, createSubmitError, fail, pass } from './staking-errors.js'
+import { getEpochStartMs } from './staking-info.js'
+import { buildStakeTransaction, buildUnstakeTransaction } from './staking-transactions.js'
+
+const PLAN_TTL_MS = ms('60s')
+const SUPPORTED_OPERATIONS = new Set(['stake', 'unstake'])
+
+const POSITION_STATUS = {
+  Pending: 'activating',
+  Active: 'active',
+  Unstaked: 'withdrawable',
+}
+
+const sum = ({ currency, amounts }) =>
+  amounts.reduce((total, amount) => total.add(amount), currency.ZERO)
+
+export const createStakingApi = ({
+  assetClientInterface,
+  serverApi,
+  getBalances,
+  stakingSettings,
+  notify,
+}) => {
+  assert(assetClientInterface, '`assetClientInterface` required')
+  assert(serverApi, '`serverApi` required')
+  assert(getBalances, '`getBalances` required')
+  assert(stakingSettings, '`stakingSettings` required')
+
+  const toValidatorTarget = (id) => ({
+    kind: 'validator',
+    id,
+    ...(id === stakingSettings.getValidator() && { name: EVERSTAKE_VALIDATOR_NAME }),
+  })
+
+  const getCapabilities = ({ asset }) => ({
+    participation: 'amount',
+    liquid: false,
+    positions: 'multiple',
+    operations: {
+      stake: { amount: 'required', supportsMax: true, positionSelectable: false, multiTx: false },
+      unstake: { amount: 'none', supportsMax: false, positionSelectable: true, multiTx: false },
+    },
+    target: {
+      kind: 'validator',
+      selection: 'fixed',
+      default: toValidatorTarget(stakingSettings.getValidator()),
+    },
+    unbonding: { kind: 'instant' },
+    claimUnstaked: 'none',
+    rewards: {
+      distribution: 'autoCompound',
+      approxFirstRewardMs: 2 * EPOCH_MS,
+      approxIntervalMs: EPOCH_MS,
+    },
+    activation: { approxDurationMs: EPOCH_MS },
+    feeAssetName: asset.feeAsset.name,
+    hardwareWallets: [],
+  })
+
+  const getMinStakingAmount = (feeData) => {
+    assert(feeData?.minStakingAmount, '`feeData.minStakingAmount` required')
+    return feeData.minStakingAmount
+  }
+
+  const estimateFee = ({ asset }) => asset.feeAsset.currency.baseUnit(STAKING_GAS_BUDGET)
+
+  const getPendingOperation = (txLog) => {
+    if (!txLog) return
+    for (const tx of txLog) {
+      const operation = tx.data?.staking?.operation
+      if (operation && tx.pending && !tx.error) return operation
+    }
+  }
+
+  const getAvailableAt = ({ stake, epoch }) =>
+    stake.status === 'Pending' && epoch && stake.stakeActiveEpoch !== null
+      ? getEpochStartMs({ epoch, targetEpoch: stake.stakeActiveEpoch })
+      : undefined
+
+  const getNextRewardAt = ({ stakingInfo }) => {
+    const { stakes, epoch } = stakingInfo
+    if (!epoch) return
+    if (stakes.some(({ status }) => status === 'Active')) {
+      return getEpochStartMs({ epoch, targetEpoch: epoch.epoch + 1 })
+    }
+
+    const activationEpochs = stakes
+      .filter(({ status, stakeActiveEpoch }) => status === 'Pending' && stakeActiveEpoch !== null)
+      .map(({ stakeActiveEpoch }) => stakeActiveEpoch)
+    if (activationEpochs.length === 0) return
+    return getEpochStartMs({ epoch, targetEpoch: Math.min(...activationEpochs) + 1 })
+  }
+
+  const toPosition = ({ asset, stake, epoch }) => {
+    const status = POSITION_STATUS[stake.status]
+    if (!status) throw new Error(`Unknown sui stake status ${stake.status}`)
+
+    const availableAt = getAvailableAt({ stake, epoch })
+    const rewards = asset.currency.baseUnit(stake.estimatedReward)
+    return {
+      id: stake.id,
+      status,
+      amount: getStakeValue({ currency: asset.currency, stake }),
+      target: toValidatorTarget(stake.validator),
+      ...(availableAt && { availableAt }),
+      ...(rewards.isPositive && { rewards }),
+    }
+  }
+
+  const getStakingState = ({ asset, accountState, txLog }) => {
+    const { stakingInfo } = accountState
+    const { staking, staked, unstaking, unstaked, rewards } = getBalances({ asset, accountState })
+    const pendingOperation = getPendingOperation(txLog)
+    const nextRewardAt = getNextRewardAt({ stakingInfo })
+
+    return {
+      loaded: stakingInfo.loaded,
+      isStaking: staking.add(staked).isPositive,
+      hasPosition: [staking, staked, unstaking, unstaked].some((amount) => amount.isPositive),
+      totals: { staking, staked, unstaking, unstaked, rewards },
+      ...(nextRewardAt && { nextRewardAt }),
+      positions: stakingInfo.stakes.map((stake) =>
+        toPosition({ asset, stake, epoch: stakingInfo.epoch })
+      ),
+      target: toValidatorTarget(stakingSettings.getValidator()),
+      ...(pendingOperation && { pendingOperation }),
+    }
+  }
+
+  const getMaxStakeAmount = ({ asset, spendable, fee }) =>
+    spendable.sub(fee).sub(estimateFee({ asset })).clampLowerZero()
+
+  const getLimits = ({ asset, accountState, feeData, operation }) => {
+    const { spendable, staking, staked, unstaked } = getBalances({ asset, accountState })
+    const estimatedFee = estimateFee({ asset })
+
+    switch (operation) {
+      case 'stake':
+        return {
+          min: getMinStakingAmount(feeData),
+          max: getMaxStakeAmount({ asset, spendable, fee: estimatedFee }),
+          reserve: estimatedFee,
+          estimatedFee,
+        }
+      case 'unstake':
+        return { max: staking.add(staked).add(unstaked), estimatedFee }
+      default:
+        return { max: asset.currency.ZERO }
+    }
+  }
+
+  const selectStakes = ({ stakingInfo, positionIds }) => {
+    if (!positionIds) return stakingInfo.stakes
+    const selected = stakingInfo.stakes.filter(({ id }) => positionIds.includes(id))
+    return selected.length === positionIds.length ? selected : []
+  }
+
+  const canStake = ({ asset, accountState, feeData, amount, isMax }) => {
+    assert(isMax || amount, '`amount` or `isMax` required to stake')
+    const minStakingAmount = getMinStakingAmount(feeData)
+    const { spendable } = getBalances({ asset, accountState })
+    const fee = estimateFee({ asset })
+    const stakeAmount = isMax ? getMaxStakeAmount({ asset, spendable, fee }) : amount
+
+    if (stakeAmount.lt(minStakingAmount)) {
+      return fail('BELOW_MINIMUM', minStakingAmount.sub(stakeAmount), asset.name)
+    }
+
+    if (spendable.lt(stakeAmount)) {
+      return fail('INSUFFICIENT_BALANCE', stakeAmount.sub(spendable), asset.name)
+    }
+
+    const required = stakeAmount.add(fee)
+    if (spendable.lt(required)) {
+      return fail('INSUFFICIENT_FEE_BALANCE', required.sub(spendable), asset.feeAsset.name)
+    }
+
+    return pass(spendable.sub(required).lt(estimateFee({ asset })) && 'LOW_FEE_BALANCE')
+  }
+
+  const canUnstake = ({ asset, accountState, positionIds }) => {
+    const stakes = selectStakes({ stakingInfo: accountState.stakingInfo, positionIds })
+    if (stakes.length === 0) return fail('NOTHING_TO_UNSTAKE')
+
+    const { spendable } = getBalances({ asset, accountState })
+    const fee = estimateFee({ asset })
+    if (spendable.lt(fee)) {
+      return fail('INSUFFICIENT_FEE_BALANCE', fee.sub(spendable), asset.feeAsset.name)
+    }
+
+    return pass()
+  }
+
+  const canPerform = ({
+    asset,
+    accountState,
+    txLog,
+    feeData,
+    operation,
+    amount,
+    isMax,
+    positionIds,
+  }) => {
+    if (!SUPPORTED_OPERATIONS.has(operation)) return fail('OPERATION_UNSUPPORTED')
+    if (!accountState.stakingInfo.loaded) return fail('NOT_LOADED')
+    if (getPendingOperation(txLog)) return fail('PENDING_TRANSACTION')
+    if (operation === 'stake') return canStake({ asset, accountState, feeData, amount, isMax })
+    return canUnstake({ asset, accountState, positionIds })
+  }
+
+  const classifyTx = ({ asset, tx }) => {
+    if (asset.name !== asset.baseAsset.name) return
+    const staking = tx.data?.staking
+    if (!staking) return
+
+    return {
+      operation: staking.operation,
+      ...(staking.amount && { amount: asset.currency.baseUnit(staking.amount) }),
+    }
+  }
+
+  const loadState = async ({ asset, walletAccount }) => {
+    const baseAssetName = asset.baseAsset.name
+    const [accountState, txLog, feeData, address] = await Promise.all([
+      assetClientInterface.getAccountState({ assetName: baseAssetName, walletAccount }),
+      assetClientInterface.getTxLog({ assetName: baseAssetName, walletAccount }),
+      assetClientInterface.getFeeData({ assetName: asset.feeAsset.name }),
+      assetClientInterface.getReceiveAddress({ assetName: baseAssetName, walletAccount }),
+    ])
+    return { accountState, txLog, feeData, address: address.toString() }
+  }
+
+  const simulateGas = async ({ asset, sender, transaction }) => {
+    const transactionBlock = await serverApi.buildTransaction({
+      transaction,
+      onlyTransactionKind: true,
+    })
+    const { effects } = await serverApi.devInspectTransaction({ sender, transactionBlock })
+    if (effects.status?.status !== 'success') {
+      throw new Error(`Sui staking simulation failed: ${effects.status?.error ?? 'unknown'}`)
+    }
+
+    const { currency } = asset.feeAsset
+    const fee = getFeeAmount({ gasUsed: effects.gasUsed, feeAsset: asset.feeAsset })
+    const computation = currency.baseUnit(effects.gasUsed.computationCost)
+    const charged = fee.gt(computation) ? fee : computation
+    const budget = Math.ceil(
+      Number(charged.toBaseString({ unit: false })) * GAS_BUDGET_SAFETY_FACTOR
+    )
+    return { fee, gasBudget: currency.baseUnit(Math.max(budget, MIN_GAS_BUDGET)) }
+  }
+
+  const reject = ({ operation, check }) => {
+    throw createRejectionError({ operation, check })
+  }
+
+  const prepareStake = async ({ asset, accountState, feeData, address, amount, isMax }) => {
+    const minStakingAmount = getMinStakingAmount(feeData)
+    const validator = stakingSettings.getValidator()
+    const { spendable } = getBalances({ asset, accountState })
+    const build = (stakeAmount) =>
+      buildStakeTransaction({
+        sender: address,
+        amount: stakeAmount.toBaseString({ unit: false }),
+        validator,
+      })
+
+    const estimate = await simulateGas({
+      asset,
+      sender: address,
+      transaction: build(isMax ? minStakingAmount : amount),
+    })
+    const stakeAmount = isMax
+      ? getMaxStakeAmount({ asset, spendable, fee: estimate.gasBudget })
+      : amount
+    if (stakeAmount.lt(minStakingAmount)) {
+      reject({
+        operation: 'stake',
+        check: fail('BELOW_MINIMUM', minStakingAmount.sub(stakeAmount), asset.name),
+      })
+    }
+
+    const required = stakeAmount.add(estimate.gasBudget)
+    if (spendable.lt(required)) {
+      reject({
+        operation: 'stake',
+        check: fail('INSUFFICIENT_FEE_BALANCE', required.sub(spendable), asset.feeAsset.name),
+      })
+    }
+
+    return {
+      transaction: build(stakeAmount),
+      ...estimate,
+      amount: stakeAmount,
+      staking: { operation: 'stake', validator, amount: stakeAmount.toBaseString({ unit: false }) },
+      notifyAmount: stakeAmount,
+    }
+  }
+
+  const prepareUnstake = async ({ asset, accountState, address, positionIds }) => {
+    const { currency } = asset
+    const stakes = selectStakes({ stakingInfo: accountState.stakingInfo, positionIds })
+    const stakedSuiIds = stakes.map(({ id }) => id)
+    const build = () => buildUnstakeTransaction({ sender: address, stakedSuiIds })
+    const estimate = await simulateGas({ asset, sender: address, transaction: build() })
+    const { spendable } = getBalances({ asset, accountState })
+    if (spendable.lt(estimate.gasBudget)) {
+      reject({
+        operation: 'unstake',
+        check: fail(
+          'INSUFFICIENT_FEE_BALANCE',
+          estimate.gasBudget.sub(spendable),
+          asset.feeAsset.name
+        ),
+      })
+    }
+
+    const validator = stakingSettings.getValidator()
+    const notifyAmount = sum({
+      currency,
+      amounts: stakes
+        .filter((stake) => stake.validator === validator)
+        .map((stake) => currency.baseUnit(stake.principal)),
+    })
+
+    return {
+      transaction: build(),
+      ...estimate,
+      amount: sum({ currency, amounts: stakes.map((stake) => getStakeValue({ currency, stake })) }),
+      staking: { operation: 'unstake', validator, stakedSuiIds },
+      notifyAmount,
+    }
+  }
+
+  const prepare = async ({ asset, walletAccount, operation, amount, isMax, positionIds }) => {
+    const { accountState, txLog, feeData, address } = await loadState({ asset, walletAccount })
+    const check = canPerform({
+      asset,
+      accountState,
+      txLog,
+      feeData,
+      operation,
+      amount,
+      isMax,
+      positionIds,
+    })
+    if (!check.ok) reject({ operation, check })
+
+    const prepared =
+      operation === 'stake'
+        ? await prepareStake({ asset, accountState, feeData, address, amount, isMax })
+        : await prepareUnstake({ asset, accountState, address, positionIds })
+
+    prepared.transaction.setGasBudget(prepared.gasBudget.toBaseString({ unit: false }))
+    const txData = await serverApi.buildTransaction({ transaction: prepared.transaction })
+
+    return {
+      operation,
+      assetName: asset.name,
+      walletAccount: walletAccount.toString(),
+      txs: [
+        {
+          txData,
+          txMeta: {
+            staking: {
+              ...prepared.staking,
+              notifyAmount: prepared.notifyAmount.toBaseString({ unit: false }),
+            },
+          },
+        },
+      ],
+      submit: 'single',
+      amount: prepared.amount,
+      fee: prepared.fee,
+      feeAssetName: asset.feeAsset.name,
+      expiresAt: Date.now() + PLAN_TTL_MS,
+    }
+  }
+
+  const notifyProvider = async ({ asset, walletAccount, unsignedTx, txId }) => {
+    const { operation, validator, notifyAmount } = unsignedTx.txMeta.staking
+    if (BigInt(notifyAmount) === BigInt(0)) return
+    try {
+      const address = await assetClientInterface.getReceiveAddress({
+        assetName: asset.baseAsset.name,
+        walletAccount,
+      })
+      await notify({
+        assetName: asset.name,
+        operation,
+        delegator: address.toString(),
+        validator,
+        amount: notifyAmount,
+        txId,
+      })
+    } catch (error) {
+      console.error('Failed to notify staking service:', error)
+    }
+  }
+
+  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) {
+      reject({ operation: plan.operation, check: fail('PLAN_EXPIRED') })
+    }
+
+    const [unsignedTx] = plan.txs
+    onProgress?.({ index: 0, total: 1 })
+    let txId
+    try {
+      ;({ txId } = await asset.api.sendTx({ asset, walletAccount, unsignedTx }))
+    } catch (error) {
+      throw createSubmitError({ error, txIds: [], failedIndex: 0 })
+    }
+
+    if (notify) void notifyProvider({ asset, walletAccount, unsignedTx, txId })
+
+    return { txIds: [txId] }
+  }
+
+  return {
+    getCapabilities,
+    getLimits,
+    getStakingState,
+    canPerform,
+    classifyTx,
+    prepare,
+    submit,
+  }
+}

package/src/staking/staking-balances.js

@@ -0,0 +1,19 @@
+const sumBy = ({ currency, stakes, toAmount }) =>
+  stakes.reduce((total, stake) => total.add(toAmount(stake)), currency.ZERO)
+
+export const getStakeValue = ({ currency, stake }) =>
+  currency.baseUnit(stake.principal).add(currency.baseUnit(stake.estimatedReward))
+
+export const getStakingBalances = ({ asset, stakingInfo }) => {
+  const { currency } = asset
+  const byStatus = (status) => stakingInfo.stakes.filter((stake) => stake.status === status)
+  const value = (stake) => getStakeValue({ currency, stake })
+
+  return {
+    staking: sumBy({ currency, stakes: byStatus('Pending'), toAmount: value }),
+    staked: sumBy({ currency, stakes: byStatus('Active'), toAmount: value }),
+    unstaking: currency.ZERO,
+    unstaked: sumBy({ currency, stakes: byStatus('Unstaked'), toAmount: value }),
+    rewards: currency.ZERO,
+  }
+}

package/src/staking/staking-errors.js

@@ -0,0 +1,27 @@
+export const fail = (reasonCode, shortfall, shortfallAssetName) => ({
+  ok: false,
+  reasonCode,
+  ...(shortfall && { shortfall, shortfallAssetName }),
+})
+
+export const pass = (warning) => (warning ? { ok: true, warnings: [warning] } : { ok: true })
+
+export const createRejectionError = ({ operation, check }) => {
+  const error = new Error(`Cannot ${operation}: ${check.reasonCode}`)
+  error.name = 'StakingRejectionError'
+  error.reasonCode = check.reasonCode
+  if (check.shortfall) {
+    error.shortfall = check.shortfall
+    error.shortfallAssetName = check.shortfallAssetName
+  }
+
+  return error
+}
+
+export const createSubmitError = ({ error, txIds, failedIndex }) => {
+  const submitError = new Error(error.message, { cause: error })
+  submitError.name = 'StakingSubmitError'
+  submitError.txIds = txIds
+  submitError.failedIndex = failedIndex
+  return submitError
+}

package/src/staking/staking-info.js

@@ -0,0 +1,68 @@
+import { STAKED_SUI_TYPE } from './constants.js'
+
+const STAKE_STATUSES = new Set(['Pending', 'Active', 'Unstaked'])
+
+export const EMPTY_STAKING_INFO = Object.freeze({ loaded: false, stakes: [], epoch: null })
+
+const toStake = ({ validatorAddress, stake }) => {
+  if (!STAKE_STATUSES.has(stake.status)) {
+    throw new Error(`Unknown sui stake status ${stake.status}`)
+  }
+
+  return {
+    id: stake.stakedSuiId,
+    validator: validatorAddress,
+    status: stake.status,
+    principal: stake.principal,
+    estimatedReward: stake.estimatedReward ?? '0',
+    stakeRequestEpoch: Number(stake.stakeRequestEpoch),
+    stakeActiveEpoch: Number(stake.stakeActiveEpoch),
+  }
+}
+
+export const toEpochInfo = (systemState) => ({
+  epoch: Number(systemState.epoch),
+  startMs: Number(systemState.epochStartTimestampMs),
+  durationMs: Number(systemState.epochDurationMs),
+})
+
+export const isEpochExpired = ({ epoch, now }) => !epoch || now >= epoch.startMs + epoch.durationMs
+
+export const toStakingInfo = ({ delegatedStakes, epoch }) => ({
+  loaded: true,
+  stakes: delegatedStakes.flatMap(({ validatorAddress, stakes }) =>
+    stakes.map((stake) => toStake({ validatorAddress, stake }))
+  ),
+  epoch,
+})
+
+export const getEpochStartMs = ({ epoch, targetEpoch }) =>
+  epoch.startMs + (targetEpoch - epoch.epoch) * epoch.durationMs
+
+const isOwnedStakedSui = ({ change, ownerAddress }) =>
+  change.type === 'created' &&
+  change.objectType === STAKED_SUI_TYPE &&
+  change.owner?.AddressOwner === ownerAddress
+
+export const applyStakingTx = ({ stakingInfo, staking, objectChanges, ownerAddress }) => {
+  if (!stakingInfo.loaded) return stakingInfo
+
+  if (staking.operation === 'unstake') {
+    const withdrawn = new Set(staking.stakedSuiIds)
+    return { ...stakingInfo, stakes: stakingInfo.stakes.filter(({ id }) => !withdrawn.has(id)) }
+  }
+
+  const currentEpoch = stakingInfo.epoch?.epoch
+  const created = objectChanges
+    .filter((change) => isOwnedStakedSui({ change, ownerAddress }))
+    .map((change) => ({
+      id: change.objectId,
+      validator: staking.validator,
+      status: 'Pending',
+      principal: staking.amount,
+      estimatedReward: '0',
+      stakeRequestEpoch: currentEpoch ?? null,
+      stakeActiveEpoch: currentEpoch === undefined ? null : currentEpoch + 1,
+    }))
+  return { ...stakingInfo, stakes: [...stakingInfo.stakes, ...created] }
+}

package/src/staking/staking-provider-client.js

@@ -0,0 +1,57 @@
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+const HTTP_POST_TIMEOUT = ms('30s')
+
+const ACTION_BY_OPERATION = {
+  stake: 'start',
+  unstake: 'stop',
+}
+
+const MAX_ERROR_BODY_LENGTH = 200
+
+const readErrorBody = async (response) => {
+  const text = await response.text()
+  return text.slice(0, MAX_ERROR_BODY_LENGTH)
+}
+
+const postJson = async ({ url, body, timeoutMs }) => {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    })
+    if (!response.ok) {
+      throw new Error(`${url} returned ${response.status}: ${await readErrorBody(response)}`)
+    }
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+export const createStakingProviderClient = ({ stakingSettings, timeoutMs = HTTP_POST_TIMEOUT }) => {
+  assert(stakingSettings, '`stakingSettings` required')
+
+  const notify = async ({ assetName, operation, delegator, validator, amount, txId }) => {
+    const type = ACTION_BY_OPERATION[operation]
+    assert(type, `unsupported staking notify operation ${operation}`)
+    assert(assetName, '"assetName" is required')
+    assert(delegator, '"delegator" is required')
+    assert(validator, '"validator" is required')
+    assert(amount, '"amount" is required')
+    assert(txId, '"txId" is required')
+    if (!stakingSettings.isNotifyEnabled()) return
+
+    await postJson({
+      url: `${stakingSettings.getUrl()}/${assetName}/stake`,
+      body: { delegator, actions: [{ type, validator, amount, txId }] },
+      timeoutMs,
+    })
+  }
+
+  return { notify }
+}

package/src/staking/staking-settings.js

@@ -0,0 +1,39 @@
+import { isValidAddress } from '@exodus/sui-lib'
+
+import { DEFAULT_STAKING_URL, EVERSTAKE_VALIDATOR } from './constants.js'
+
+const assertValidator = (validator) => {
+  if (!isValidAddress(validator)) throw new Error(`Invalid sui staking validator ${validator}`)
+  return validator
+}
+
+const assertUrl = (url) => new URL(url).toString().replace(/\/$/, '')
+
+export const createStakingSettings = (
+  { validator = EVERSTAKE_VALIDATOR, notify = Object.create(null) } = Object.create(null)
+) => {
+  const localNotifyEnabled = notify.enabled === true
+  const defaults = {
+    validator: assertValidator(validator),
+    notifyEnabled: localNotifyEnabled,
+    url: assertUrl(notify.url ?? DEFAULT_STAKING_URL),
+  }
+  let current = { ...defaults }
+
+  const applyRemoteConfig = (staking) => {
+    const remote = staking ?? Object.create(null)
+    current = {
+      validator: remote.validator ? assertValidator(remote.validator) : defaults.validator,
+      notifyEnabled: localNotifyEnabled && remote.notifyEnabled !== false,
+      url: remote.url ? assertUrl(remote.url) : defaults.url,
+    }
+  }
+
+  return {
+    isNotifyConfigured: localNotifyEnabled,
+    getValidator: () => current.validator,
+    isNotifyEnabled: () => current.notifyEnabled,
+    getUrl: () => current.url,
+    applyRemoteConfig,
+  }
+}

package/src/staking/staking-transactions.js

@@ -0,0 +1,88 @@
+import { Transaction } from '../vendors/transactions/index.js'
+import {
+  ADD_STAKE_FUNCTION,
+  ADD_STAKE_TARGET,
+  SUI_SYSTEM_MODULE,
+  SUI_SYSTEM_PACKAGE,
+  WITHDRAW_STAKE_FUNCTION,
+  WITHDRAW_STAKE_TARGET,
+} from './constants.js'
+
+const OPERATION_BY_FUNCTION = {
+  [ADD_STAKE_FUNCTION]: 'stake',
+  [WITHDRAW_STAKE_FUNCTION]: 'unstake',
+}
+
+export const buildStakeTransaction = ({ sender, amount, validator }) => {
+  const tx = new Transaction()
+  const [stakeCoin] = tx.splitCoins(tx.gas, [amount])
+  tx.moveCall({
+    target: ADD_STAKE_TARGET,
+    arguments: [tx.object.system(), stakeCoin, tx.pure.address(validator)],
+  })
+  tx.setSender(sender)
+  return tx
+}
+
+export const buildUnstakeTransaction = ({ sender, stakedSuiIds }) => {
+  if (stakedSuiIds.length === 0) throw new Error('stakedSuiIds required to unstake')
+
+  const tx = new Transaction()
+  for (const stakedSuiId of stakedSuiIds) {
+    tx.moveCall({
+      target: WITHDRAW_STAKE_TARGET,
+      arguments: [tx.object.system(), tx.object(stakedSuiId)],
+    })
+  }
+
+  tx.setSender(sender)
+  return tx
+}
+
+const isSuiSystemCall = (moveCall) =>
+  BigInt(moveCall.package) === BigInt(SUI_SYSTEM_PACKAGE) &&
+  moveCall.module === SUI_SYSTEM_MODULE &&
+  Boolean(OPERATION_BY_FUNCTION[moveCall.function])
+
+const getInput = ({ inputs, argument }) =>
+  argument && typeof argument === 'object' && 'Input' in argument
+    ? inputs[argument.Input]
+    : undefined
+
+const getSplitAmount = ({ inputs, commands, argument }) => {
+  const resultIndex = argument?.NestedResult?.[0] ?? argument?.Result
+  const amountArgument = commands[resultIndex]?.SplitCoins?.[1]?.[0]
+  return getInput({ inputs, argument: amountArgument })?.value
+}
+
+export const parseStakingCommands = (programmableTransaction) => {
+  if (programmableTransaction?.kind !== 'ProgrammableTransaction') return
+
+  const { inputs, transactions: commands } = programmableTransaction
+  const moveCalls = commands
+    .map((command) => command.MoveCall)
+    .filter((moveCall) => moveCall && isSuiSystemCall(moveCall))
+  if (moveCalls.length === 0) return
+
+  const operations = new Set(moveCalls.map((moveCall) => OPERATION_BY_FUNCTION[moveCall.function]))
+  if (operations.size > 1) return
+
+  const [operation] = operations
+  if (operation === 'stake') {
+    if (moveCalls.length > 1) return
+    const [, coinArgument, validatorArgument] = moveCalls[0].arguments
+    const amount = getSplitAmount({ inputs, commands, argument: coinArgument })
+    return {
+      operation,
+      validator: getInput({ inputs, argument: validatorArgument })?.value,
+      ...(amount && { amount }),
+    }
+  }
+
+  return {
+    operation,
+    stakedSuiIds: moveCalls.map(
+      (moveCall) => getInput({ inputs, argument: moveCall.arguments[1] }).objectId
+    ),
+  }
+}

package/src/sui-no-history-monitor.js

@@ -6,6 +6,7 @@ import lodash from 'lodash'
 import assert from 'minimalistic-assert'
 import ms from 'ms'
 
+import { isEpochExpired, toEpochInfo, toStakingInfo } from './staking/staking-info.js'
 import { transformTransactions } from './transform-tx.js'
 
 const { isEmpty, unionBy, zipObject } = lodash
@@ -14,8 +15,20 @@ export const UNCONFIRMED_TX_LIMIT = ms('5m')
 
 export class SuiNoHistoryMonitor extends BaseMonitor {
   #serverApi
-
-  constructor({ asset, serverApi, interval = ms('15s'), assetClientInterface, runner, logger }) {
+  #stakingSettings
+  #stakingEnabled
+  #epoch = null
+
+  constructor({
+    asset,
+    serverApi,
+    stakingSettings,
+    stakingEnabled = false,
+    interval = ms('15s'),
+    assetClientInterface,
+    runner,
+    logger,
+  }) {
     super({
       asset,
       interval,
@@ -24,8 +37,11 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
       runner,
     })
     assert(serverApi, 'Sui Node API Client is required!')
+    assert(stakingSettings, 'stakingSettings is required')
 
     this.#serverApi = serverApi
+    this.#stakingSettings = stakingSettings
+    this.#stakingEnabled = stakingEnabled
     this.assets = Object.create(null)
   }
 
@@ -35,6 +51,8 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
     this.#serverApi.setServer({
       rpcUrl: remoteConfig?.rpcUrl || RPC_URL,
     })
+    if (!this.#stakingEnabled) return
+    this.#stakingSettings.applyRemoteConfig(remoteConfig?.staking)
   }
 
   async tick({ refresh, walletAccount }) {
@@ -51,6 +69,10 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
       this.emit('unknown-tokens', unknownAssetIds)
     }
 
+    const stakingData = this.#stakingEnabled
+      ? { stakingInfo: await this.#getStakingInfo({ address: ourWalletAddress }) }
+      : Object.create(null)
+
     let batch = this.aci.createOperationsBatch()
 
     batch = this.aci.updateAccountStateBatch({
@@ -59,6 +81,7 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
       newData: {
         utxos,
         tokenUtxos,
+        ...stakingData,
       },
       batch,
     })
@@ -87,6 +110,22 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
     await this.aci.executeOperationsBatch(batch)
   }
 
+  #getStakingInfo = async ({ address }) => {
+    const [delegatedStakes, epoch] = await Promise.all([
+      this.#serverApi.getStakes({ owner: address }),
+      this.#getEpoch(),
+    ])
+    return toStakingInfo({ delegatedStakes, epoch })
+  }
+
+  #getEpoch = async () => {
+    if (isEpochExpired({ epoch: this.#epoch, now: SynchronizedTime.now() })) {
+      this.#epoch = toEpochInfo(await this.#serverApi.getLatestSuiSystemState())
+    }
+
+    return this.#epoch
+  }
+
   #checkPendingTransactions = ({ pendingTransactions, pendingTxsFromNode }) => {
     const txsToUpdate = []
     const txsToRemove = []

package/src/transform-tx.js

@@ -1,3 +1,5 @@
+import { parseStakingCommands } from './staking/staking-transactions.js'
+
 const parseTransaction = ({ transaction, asset }) => {
   const { data } = transaction
   const {
@@ -68,6 +70,10 @@ export function transformTransactions({ transactionResults, address, feeAsset, a
     const { gasUsed } = effects
 
     const { from, to, coinAmount } = parseTransaction({ transaction, asset })
+    const staking =
+      asset.name === asset.baseAssetName
+        ? parseStakingCommands(transaction.data.transaction)
+        : undefined
     const { confirmations, error } = parseConfirmations({ effects })
     const wasSend = from === address
     const args = Object.create(null)
@@ -88,7 +94,7 @@ export function transformTransactions({ transactionResults, address, feeAsset, a
       selfSend: wasSend && from === to,
       confirmations,
       error,
-      data: Object.create(null),
+      data: staking ? { staking } : Object.create(null),
       currencies: {
         [asset.name]: asset.currency,
         [feeAsset.name]: feeAsset.currency,

package/src/tx-send.js

@@ -2,6 +2,8 @@ import { UtxoCollection } from '@exodus/models'
 import { coinTypes, objectTypes, toCoinType } from '@exodus/sui-lib'
 import assert from 'minimalistic-assert'
 
+import { applyStakingTx } from './staking/staking-info.js'
+import { parseStakingCommands } from './staking/staking-transactions.js'
 import { getFeeAmount } from './transform-tx.js'
 
 const deriveNewUtxos = ({ mutatedObject, balanceChange, deletedObjects, utxos, asset }) => {
@@ -186,6 +188,10 @@ const getStateChanges = async ({ aci, asset, walletAccount, result }) => {
 
   newAccountState.utxos = newBaseUtxos.utxos
 
+  const parsedStaking = wasBaseAssetSent
+    ? parseStakingCommands(result.transaction?.data?.transaction)
+    : undefined
+
   let amount
   if (wasBaseAssetSent) {
     amount = asset.currency.baseUnit(ownerBalanceChangesByType[coinTypes.Base]).add(fee)
@@ -203,23 +209,34 @@ const getStateChanges = async ({ aci, asset, walletAccount, result }) => {
     amount = asset.currency.baseUnit(ownerBalanceChangesByType[asset.assetId])
   }
 
-  const to = getRecipientAddress({ balanceChanges, ownerAddress })
+  const staking = parsedStaking && { ...parsedStaking, amount: amount.abs().toBaseString() }
+  const isUnstake = staking?.operation === 'unstake'
+  const to = staking ? staking.validator : getRecipientAddress({ balanceChanges, ownerAddress })
 
   const tx = {
     txId: digest,
     confirmations: 0,
     coinName: assetName,
-    coinAmount: amount.abs().negate(),
+    coinAmount: isUnstake ? amount.abs() : amount.abs().negate(),
     feeAmount: fee,
     feeCoinName: feeAsset.name,
     selfSend: false,
-    to,
-    data: Object.create(null),
+    ...(to && { to }),
+    ...(isUnstake && { from: [ownerAddress] }),
+    data: staking ? { staking } : Object.create(null),
     currencies: { [assetName]: assetCurrency, [feeAsset.name]: feeAsset.currency },
   }
 
   return {
     accountStateData: {
+      ...(staking && {
+        stakingInfo: applyStakingTx({
+          stakingInfo: accountState.stakingInfo,
+          staking,
+          objectChanges,
+          ownerAddress,
+        }),
+      }),
       utxos: newAccountState.utxos,
       tokenUtxos: {
         ...accountState.tokenUtxos,

package/src/vendors/experimental/cache.js

@@ -5,7 +5,8 @@ var __typeError = (msg) => {
 
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError('Cannot ' + msg)
 var __privateGet = (obj, member, getter) => (
-  __accessCheck(obj, member, 'read from private field'), getter ? getter.call(obj) : member.get(obj)
+  __accessCheck(obj, member, 'read from private field'),
+  getter ? getter.call(obj) : member.get(obj)
 )
 var __privateAdd = (obj, member, value) =>
   member.has(obj)

package/src/vendors/experimental/transports/json-rpc-resolver.js

@@ -1,4 +1,4 @@
-/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+/* eslint-disable @exodus/hydra/no-param-reassign-prop-only */
 /* eslint-disable no-return-await */
 import { vendorLib } from '@exodus/sui-lib'
 
@@ -116,18 +116,15 @@ async function resolveObjectReferences(transactionData, client) {
     ),
   ]
   const objectChunks = dedupedIds.length > 0 ? chunk(dedupedIds, MAX_OBJECTS_PER_FETCH) : []
-  const resolved = (
-    await Promise.all(
-      objectChunks.map((chunk2) =>
-        client.multiGetObjects({
-          ids: chunk2,
-          options: { showOwner: true },
-        })
-      )
+  const resolvedChunks = await Promise.all(
+    objectChunks.map((chunk2) =>
+      client.multiGetObjects({
+        ids: chunk2,
+        options: { showOwner: true },
+      })
     )
   )
-    // eslint-disable-next-line unicorn/no-await-expression-member
-    .flat()
+  const resolved = resolvedChunks.flat()
   const responsesById = new Map(
     dedupedIds.map((id, index) => {
       return [id, resolved[index]]

package/src/vendors/transactions/Commands.js

@@ -1,4 +1,4 @@
-/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+/* eslint-disable @exodus/hydra/no-param-reassign-prop-only */
 import { vendorLib } from '@exodus/sui-lib'
 
 import { parse } from '../valibot.js'

package/src/vendors/transactions/Transaction.js

@@ -22,7 +22,8 @@ var __typeError = (msg) => {
 
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError('Cannot ' + msg)
 var __privateGet = (obj, member, getter) => (
-  __accessCheck(obj, member, 'read from private field'), getter ? getter.call(obj) : member.get(obj)
+  __accessCheck(obj, member, 'read from private field'),
+  getter ? getter.call(obj) : member.get(obj)
 )
 var __privateAdd = (obj, member, value) =>
   member.has(obj)
@@ -36,7 +37,8 @@ var __privateSet = (obj, member, value, setter) => (
   value
 )
 var __privateMethod = (obj, member, method) => (
-  __accessCheck(obj, member, 'access private method'), method
+  __accessCheck(obj, member, 'access private method'),
+  method
 )
 var _serializationPlugins,
   _buildPlugins,

package/src/vendors/transactions/TransactionData.js

@@ -1,4 +1,4 @@
-/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+/* eslint-disable @exodus/hydra/no-param-reassign-prop-only */
 import { vendorLib } from '@exodus/sui-lib'
 
 import { parse } from '../valibot.js'

package/src/vendors/transactions/hash.js

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { hashSync } from '@exodus/crypto/hash'
 
 function hashTypedData(typeTag, data) {
@@ -7,7 +6,6 @@ function hashTypedData(typeTag, data) {
   const dataWithTag = new Uint8Array(typeTagBytes.length + data.length)
   dataWithTag.set(typeTagBytes)
   dataWithTag.set(data, typeTagBytes.length)
-  // eslint-disable-next-line @exodus/import/no-deprecated
   return hashSync('blake2b256', dataWithTag)
 }
 

package/src/vendors/transactions/resolve.js

@@ -88,7 +88,7 @@ function normalizeRawArgument(arg, schema, transactionData) {
     return
   }
 
-  // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+  // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
   transactionData.inputs[arg.Input] = Inputs.Pure(schema.serialize(input.UnresolvedPure.value))
 }
 

package/src/vendors/valibot.js

@@ -1,6 +1,6 @@
 /* eslint-disable unicorn/no-await-expression-member */
 /* eslint-disable sonarjs/no-nested-template-literals */
-/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+/* eslint-disable @exodus/hydra/no-param-reassign-prop-only */
 // src/storages/globalConfig/globalConfig.ts
 
 // @__NO_SIDE_EFFECTS__