@exodus/sui-api 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.5.0](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.4.1...@exodus/sui-api@1.5.0) (2026-11-02)
+
+
+### Features
+
+* **sui-api:** spend sui address balances in sends ([#9144](https://github.com/ExodusMovement/assets/issues/9144)) ([d4b001d](https://github.com/ExodusMovement/assets/commit/d4b001d349cd8418e19638c8ff0f7d58c64e3c49))
+
+
+
+## [1.4.1](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.4.0...@exodus/sui-api@1.4.1) (2026-11-02)
+
+
+### Bug Fixes
+
+* **sui-api:** count sui address balances in balances ([#9140](https://github.com/ExodusMovement/assets/issues/9140)) ([9486138](https://github.com/ExodusMovement/assets/commit/9486138e6cedc7edf88f136bdfc998d735756ece))
+
+
+
 ## [1.4.0](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.3.1...@exodus/sui-api@1.4.0) (2026-10-22)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/sui-api",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Transaction monitors, RPC with the blockchain node, and other networking code for Sui",
   "type": "module",
   "main": "src/index.js",
@@ -24,16 +24,16 @@
     "@exodus/asset-lib": "^5.0.0",
     "@exodus/basic-utils": "^5.1.0",
     "@exodus/crypto": "^1.0.0-rc.26",
-    "@exodus/currency": "^6.0.1",
     "@exodus/models": "^13.0.0",
-    "@exodus/sui-lib": "^1.3.0",
+    "@exodus/sui-lib": "^1.4.0",
     "@exodus/sui-meta": "^1.2.0",
     "lodash": "^4.17.21",
     "minimalistic-assert": "^1.0.1",
     "ms": "^2.1.3"
   },
   "devDependencies": {
-    "@exodus/assets-testing": "^1.0.0"
+    "@exodus/assets-testing": "^1.0.0",
+    "@exodus/currency": "^6.0.1"
   },
   "homepage": "https://github.com/ExodusMovement/assets/tree/master/sui/sui-api",
   "bugs": {
@@ -43,5 +43,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "f210c7a3aa55561320c43aa8d8d5804b49f390d0"
+  "gitHead": "05ed20b7d858ef18380e7108022c9d323a34f5f4"
 }

package/src/address-balance-spend.js

@@ -0,0 +1,48 @@
+const ZERO = BigInt(0)
+
+const min = (a, b) => (a < b ? a : b)
+
+const planBaseSpend = ({ amount, coins, addressBalance, gasBudget }) => {
+  if (addressBalance === ZERO || coins >= amount + gasBudget) {
+    return { fromCoins: amount, fromAddressBalance: ZERO, gasFromAddressBalance: false }
+  }
+
+  if (addressBalance >= amount + gasBudget) {
+    return { fromCoins: ZERO, fromAddressBalance: amount, gasFromAddressBalance: true }
+  }
+
+  if (coins < gasBudget && addressBalance >= gasBudget) {
+    const fromAddressBalance = min(addressBalance - gasBudget, amount)
+    return {
+      fromCoins: amount - fromAddressBalance,
+      fromAddressBalance,
+      gasFromAddressBalance: true,
+    }
+  }
+
+  const fromAddressBalance = min(addressBalance, amount)
+  return {
+    fromCoins: amount - fromAddressBalance,
+    fromAddressBalance,
+    gasFromAddressBalance: false,
+  }
+}
+
+const planTokenSpend = ({
+  amount,
+  coins,
+  addressBalance,
+  gasCoins,
+  gasAddressBalance,
+  gasBudget,
+}) => {
+  const fromAddressBalance = min(addressBalance, amount - min(coins, amount))
+  return {
+    fromCoins: amount - fromAddressBalance,
+    fromAddressBalance,
+    gasFromAddressBalance: gasCoins < gasBudget && gasAddressBalance >= gasBudget,
+  }
+}
+
+export const planSpend = ({ isBaseAsset, ...balances }) =>
+  isBaseAsset ? planBaseSpend(balances) : planTokenSpend(balances)

package/src/api.js

@@ -181,9 +181,10 @@ export class SuiApi {
       variables: { owner: address },
       getConnection: (data) => data.address?.balances,
     })
-    return balances.map(({ coinType, totalBalance }) => ({
+    return balances.map(({ coinType, totalBalance, addressBalance }) => ({
       coinType: toJsonRpcTypeTag(coinType.repr),
       totalBalance,
+      addressBalance,
     }))
   }
 
@@ -214,8 +215,9 @@ export class SuiApi {
     const cached = this.#epoch
     if (cached && SynchronizedTime.now() < cached.startMs + cached.durationMs) return cached
 
-    const { epoch } = await this.#query(LATEST_EPOCH)
+    const { chainIdentifier, epoch } = await this.#query(LATEST_EPOCH)
     this.#epoch = {
+      chainIdentifier,
       epochId: Number(epoch.epochId),
       referenceGasPrice: String(epoch.referenceGasPrice),
       startMs: Number(epoch.systemState.startMs.json),
@@ -224,6 +226,20 @@ export class SuiApi {
     return this.#epoch
   }
 
+  async getValidDuringExpiration() {
+    const { chainIdentifier, epochId } = await this.#getEpoch()
+    return {
+      ValidDuring: {
+        minEpoch: String(epochId),
+        maxEpoch: String(epochId + 1),
+        minTimestamp: null,
+        maxTimestamp: null,
+        chain: chainIdentifier,
+        nonce: Math.floor(Math.random() * 2 ** 32),
+      },
+    }
+  }
+
   async getReferenceGasPrice() {
     const { referenceGasPrice } = await this.#getEpoch()
     return referenceGasPrice

package/src/balances.js

@@ -1,29 +1,29 @@
 import { getStakingBalances } from './staking/staking-balances.js'
 
+const getAddressBalance = ({ asset, accountState }) =>
+  asset.currency.baseUnit(accountState.addressBalances[asset.name] ?? 0)
+
 export const getBalances = ({ asset, accountState }) => {
   const isBaseAsset = asset.name === asset.baseAssetName
+  const addressBalance = getAddressBalance({ asset, accountState })
 
   if (isBaseAsset) {
-    const spendable = accountState.utxos.value
+    const coins = accountState.utxos.value
+    const spendable = coins.add(addressBalance)
     const stakingBalances = getStakingBalances({ asset, stakingInfo: accountState.stakingInfo })
     const { staking, staked, unstaked } = stakingBalances
     return {
       total: spendable.add(staking).add(staked).add(unstaked),
       spendable,
-      stakeable: spendable,
+      stakeable: coins,
       ...stakingBalances,
     }
   }
 
-  if (accountState.tokenUtxos[asset.name]) {
-    return {
-      total: accountState.tokenUtxos[asset.name].value,
-      spendable: accountState.tokenUtxos[asset.name].value,
-    }
-  }
-
+  const coins = accountState.tokenUtxos[asset.name]?.value ?? asset.currency.ZERO
+  const spendable = coins.add(addressBalance)
   return {
-    total: asset.currency.ZERO,
-    spendable: asset.currency.ZERO,
+    total: spendable,
+    spendable,
   }
 }

package/src/basic-account-state.js

@@ -8,6 +8,7 @@ export const createBasicAccountState = () => {
     static defaults = {
       utxos: UtxoCollection.createEmpty({ currency: asset.currency }),
       tokenUtxos: Object.create(null),
+      addressBalances: Object.create(null),
       stakingInfo: EMPTY_STAKING_INFO,
     }
   }

package/src/create-unsigned-tx.js

@@ -1,8 +1,41 @@
 import { UtxoCollection } from '@exodus/models'
+import { coinTypes, vendorLib } from '@exodus/sui-lib'
 import assert from 'minimalistic-assert'
 
+import { planSpend } from './address-balance-spend.js'
 import { Transaction } from './vendors/transactions/index.js'
 
+const { normalizeSuiAddress } = vendorLib.utils
+
+const ZERO = BigInt(0)
+
+const toBaseUnits = (utxos) => BigInt(utxos.value.toBaseString())
+
+const toAddressBalance = ({ accountState, assetName }) =>
+  BigInt(accountState.addressBalances[assetName] ?? 0)
+
+const splitFromCoins = ({ txb, utxos, amount }) => {
+  const coinObjectIds = utxos
+    .toArray()
+    .reverse()
+    .map((coin) => coin.coinObjectId)
+
+  const [inputCoin, ...rest] = coinObjectIds
+  if (rest.length > 0) {
+    txb.mergeCoins(inputCoin, rest)
+  }
+
+  const [coin] = txb.splitCoins(inputCoin, [amount])
+  return coin
+}
+
+const redeemFromAddressBalance = ({ txb, amount, type }) =>
+  txb.moveCall({
+    target: '0x2::coin::redeem_funds',
+    typeArguments: [type],
+    arguments: [txb.withdrawal({ amount, type })],
+  })
+
 export const createUnsignedTxFactory = ({ assetClientInterface, serverApi }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
   return async ({
@@ -19,42 +52,82 @@ export const createUnsignedTxFactory = ({ assetClientInterface, serverApi }) =>
       walletAccount,
     })
 
-    const txb = new Transaction()
+    const isBaseAsset = asset.name === asset.baseAssetName
+    const tokenUtxos = isBaseAsset
+      ? null
+      : accountState.tokenUtxos[asset.name] ||
+        UtxoCollection.createEmpty({ currency: asset.currency })
+
+    const plan = planSpend({
+      isBaseAsset,
+      amount: BigInt(amount),
+      coins: toBaseUnits(isBaseAsset ? accountState.utxos : tokenUtxos),
+      addressBalance: toAddressBalance({ accountState, assetName: asset.name }),
+      gasCoins: toBaseUnits(accountState.utxos),
+      gasAddressBalance: toAddressBalance({ accountState, assetName: asset.baseAssetName }),
+      gasBudget: BigInt(gasBudget),
+    })
 
+    const txb = new Transaction()
     txb.setGasBudget(BigInt(gasBudget))
 
-    if (asset.name === asset.baseAssetName) {
-      txb.transferObjects([txb.splitCoins(txb.gas, [amount])], txb.pure.address(recipientAddress))
-      txb.setSender(senderAddress)
+    const coinType = isBaseAsset ? coinTypes.Base : asset.assetId
+    const coinUtxos = isBaseAsset ? accountState.utxos : tokenUtxos
+    const splitFromGas = isBaseAsset && !plan.gasFromAddressBalance
+    const splitCoinPart = (value) =>
+      splitFromGas
+        ? txb.splitCoins(txb.gas, [value])
+        : splitFromCoins({ txb, utxos: coinUtxos, amount: value })
 
-      return {
-        txData: await serverApi.buildTransaction({ transaction: txb, ...buildOptions }),
-        txMeta: Object.create(null),
-      }
+    const parts = []
+    if (plan.fromCoins > ZERO) {
+      parts.push(splitCoinPart(String(plan.fromCoins)))
     }
 
-    const usedCoins = (
-      accountState.tokenUtxos[asset.name] ||
-      UtxoCollection.createEmpty({ currency: asset.currency })
-    ).toArray()
-
-    usedCoins.reverse()
-
-    const coinObjectIds = usedCoins.map((coin) => coin.coinObjectId)
+    if (plan.fromAddressBalance > ZERO) {
+      parts.push(
+        redeemFromAddressBalance({
+          txb,
+          amount: String(plan.fromAddressBalance),
+          type: coinType,
+        })
+      )
+    }
 
-    const [inputCoin, ...rest] = coinObjectIds
-    if (rest.length > 0) {
-      txb.mergeCoins(inputCoin, rest)
+    if (parts.length === 0) {
+      parts.push(
+        splitFromGas || coinUtxos.size > 0
+          ? splitCoinPart('0')
+          : txb.moveCall({ target: '0x2::coin::zero', typeArguments: [coinType] })
+      )
     }
 
-    const [coin] = txb.splitCoins(inputCoin, [amount])
+    const [coin, ...others] = parts
+    if (others.length > 0) {
+      txb.mergeCoins(coin, others)
+    }
 
     txb.transferObjects([coin], txb.pure.address(recipientAddress))
     txb.setSender(senderAddress)
 
+    const gasFromAddressBalance = plan.gasFromAddressBalance && !buildOptions.onlyTransactionKind
+    if (gasFromAddressBalance) {
+      txb.setGasPayment([])
+      txb.setExpiration(await serverApi.getValidDuringExpiration())
+    }
+
     return {
       txData: await serverApi.buildTransaction({ transaction: txb, ...buildOptions }),
-      txMeta: Object.create(null),
+      txMeta: {
+        addressBalanceWithdrawals:
+          plan.fromAddressBalance > ZERO
+            ? { [asset.name]: String(plan.fromAddressBalance) }
+            : Object.create(null),
+        gasFromAddressBalance,
+        ...(normalizeSuiAddress(senderAddress) === normalizeSuiAddress(recipientAddress) && {
+          selfSendAmount: String(amount),
+        }),
+      },
     }
   }
 }

package/src/get-fee-async.js

@@ -51,7 +51,11 @@ export const getFeeAsyncFactory = ({ assetClientInterface, serverApi, createUnsi
 
     const gasBudget = getGasBudget({ gasUsed, feeAsset })
 
-    const balance = baseAssetAccountState.utxos.value
+    const coins = baseAssetAccountState.utxos.value
+    const addressBalance = feeAsset.currency.baseUnit(
+      baseAssetAccountState.addressBalances[feeAsset.name] ?? 0
+    )
+    const balance = coins.gt(addressBalance) ? coins : addressBalance
 
     if (fee.lt(asset.feeAsset.currency.baseUnit(MIN_GAS_BUDGET))) {
       // sometimes we can receive a negative fee because of storage rebate
@@ -63,6 +67,15 @@ export const getFeeAsyncFactory = ({ assetClientInterface, serverApi, createUnsi
       }
     }
 
+    if (coins.lt(gasBudget) && !addressBalance.lt(gasBudget)) {
+      // gas will come from the address balance, which reserves the whole budget,
+      // so send max must leave the budget there, not just the fee
+      return {
+        fee: gasBudget,
+        gasBudget: gasBudget.toNumber(),
+      }
+    }
+
     if (gasBudget.gt(balance)) {
       // if the gas budget is greater than balance, allow to try to send with fee
       return {

package/src/graphql/json-rpc-shapes.js

@@ -5,7 +5,7 @@ import { getPureBcsSchema } from '../vendors/transactions/serializer.js'
 const { fromBase64, normalizeSuiAddress } = vendorLib.utils
 
 const SPECIAL_ADDRESS_REGEX = /0x0{63}([\dA-Fa-f])(?![\dA-Fa-f])/g
-const NO_GAS_OBJECT_ID = `0x${'0'.repeat(64)}`
+export const NO_GAS_OBJECT_ID = `0x${'0'.repeat(64)}`
 
 export const toJsonRpcTypeTag = (typeTag) =>
   typeTag.replaceAll(SPECIAL_ADDRESS_REGEX, '0x$1').replaceAll(/,\s*/g, ', ')

package/src/graphql/queries.js

@@ -65,7 +65,7 @@ export const ALL_BALANCES = `
     address(address: $owner) {
       balances(first: 50, after: $cursor) {
         pageInfo { hasNextPage endCursor }
-        nodes { coinType { repr } totalBalance }
+        nodes { coinType { repr } totalBalance addressBalance }
       }
     }
   }
@@ -98,6 +98,7 @@ export const MOVE_FUNCTION_PARAMETERS = `
 
 export const LATEST_EPOCH = `
   query {
+    chainIdentifier
     epoch {
       epochId
       referenceGasPrice

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

@@ -134,18 +134,18 @@ export const createStakingApi = ({
     }
   }
 
-  const getMaxStakeAmount = ({ asset, spendable, fee }) =>
-    spendable.sub(fee).sub(estimateFee({ asset })).clampLowerZero()
+  const getMaxStakeAmount = ({ asset, stakeable, fee }) =>
+    stakeable.sub(fee).sub(estimateFee({ asset })).clampLowerZero()
 
   const getLimits = ({ asset, accountState, feeData, operation }) => {
-    const { spendable, staking, staked, unstaked } = getBalances({ asset, accountState })
+    const { stakeable, staking, staked, unstaked } = getBalances({ asset, accountState })
     const estimatedFee = estimateFee({ asset })
 
     switch (operation) {
       case 'stake':
         return {
           min: getMinStakingAmount(feeData),
-          max: getMaxStakeAmount({ asset, spendable, fee: estimatedFee }),
+          max: getMaxStakeAmount({ asset, stakeable, fee: estimatedFee }),
           reserve: estimatedFee,
           estimatedFee,
         }
@@ -165,34 +165,34 @@ export const createStakingApi = ({
   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 { stakeable } = getBalances({ asset, accountState })
     const fee = estimateFee({ asset })
-    const stakeAmount = isMax ? getMaxStakeAmount({ asset, spendable, fee }) : amount
+    const stakeAmount = isMax ? getMaxStakeAmount({ asset, stakeable, 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)
+    if (stakeable.lt(stakeAmount)) {
+      return fail('INSUFFICIENT_BALANCE', stakeAmount.sub(stakeable), asset.name)
     }
 
     const required = stakeAmount.add(fee)
-    if (spendable.lt(required)) {
-      return fail('INSUFFICIENT_FEE_BALANCE', required.sub(spendable), asset.feeAsset.name)
+    if (stakeable.lt(required)) {
+      return fail('INSUFFICIENT_FEE_BALANCE', required.sub(stakeable), asset.feeAsset.name)
     }
 
-    return pass(spendable.sub(required).lt(estimateFee({ asset })) && 'LOW_FEE_BALANCE')
+    return pass(stakeable.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 { stakeable } = getBalances({ asset, accountState })
     const fee = estimateFee({ asset })
-    if (spendable.lt(fee)) {
-      return fail('INSUFFICIENT_FEE_BALANCE', fee.sub(spendable), asset.feeAsset.name)
+    if (stakeable.lt(fee)) {
+      return fail('INSUFFICIENT_FEE_BALANCE', fee.sub(stakeable), asset.feeAsset.name)
     }
 
     return pass()
@@ -264,7 +264,7 @@ export const createStakingApi = ({
   const prepareStake = async ({ asset, accountState, feeData, address, amount, isMax }) => {
     const minStakingAmount = getMinStakingAmount(feeData)
     const validator = stakingSettings.getValidator()
-    const { spendable } = getBalances({ asset, accountState })
+    const { stakeable } = getBalances({ asset, accountState })
     const build = (stakeAmount) =>
       buildStakeTransaction({
         sender: address,
@@ -278,7 +278,7 @@ export const createStakingApi = ({
       transaction: build(isMax ? minStakingAmount : amount),
     })
     const stakeAmount = isMax
-      ? getMaxStakeAmount({ asset, spendable, fee: estimate.gasBudget })
+      ? getMaxStakeAmount({ asset, stakeable, fee: estimate.gasBudget })
       : amount
     if (stakeAmount.lt(minStakingAmount)) {
       reject({
@@ -288,10 +288,10 @@ export const createStakingApi = ({
     }
 
     const required = stakeAmount.add(estimate.gasBudget)
-    if (spendable.lt(required)) {
+    if (stakeable.lt(required)) {
       reject({
         operation: 'stake',
-        check: fail('INSUFFICIENT_FEE_BALANCE', required.sub(spendable), asset.feeAsset.name),
+        check: fail('INSUFFICIENT_FEE_BALANCE', required.sub(stakeable), asset.feeAsset.name),
       })
     }
 
@@ -310,13 +310,13 @@ export const createStakingApi = ({
     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)) {
+    const { stakeable } = getBalances({ asset, accountState })
+    if (stakeable.lt(estimate.gasBudget)) {
       reject({
         operation: 'unstake',
         check: fail(
           'INSUFFICIENT_FEE_BALANCE',
-          estimate.gasBudget.sub(spendable),
+          estimate.gasBudget.sub(stakeable),
           asset.feeAsset.name
         ),
       })

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

@@ -61,7 +61,7 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
 
     const ourWalletAddress = await this.aci.getReceiveAddress({ assetName, walletAccount })
 
-    const { utxos, tokenUtxos, unknownAssetIds } = await this.#getNewAccountState({
+    const { utxos, tokenUtxos, addressBalances, unknownAssetIds } = await this.#getNewAccountState({
       address: ourWalletAddress,
     })
 
@@ -81,6 +81,7 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
       newData: {
         utxos,
         tokenUtxos,
+        addressBalances,
         ...stakingData,
       },
       batch,
@@ -238,9 +239,17 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
   }
 
   #getNewAccountState = async ({ address }) => {
-    const allCoins = await this.#serverApi.getAllCoins({
-      owner: address,
-    })
+    const [allCoins, allBalances] = await Promise.all([
+      this.#serverApi.getAllCoins({ owner: address }),
+      this.#serverApi.getAccountAllBalances({ address }),
+    ])
+
+    const addressBalanceByCoinType = Object.create(null)
+    for (const { coinType, addressBalance } of allBalances) {
+      if (addressBalance && addressBalance !== '0') {
+        addressBalanceByCoinType[coinType] = addressBalance
+      }
+    }
 
     const groupedCoins = allCoins.reduce((acc, coin) => {
       if (!acc[coin.coinType]) {
@@ -252,39 +261,43 @@ export class SuiNoHistoryMonitor extends BaseMonitor {
     }, Object.create(null))
 
     const tokenUtxos = Object.create(null)
+    const addressBalances = Object.create(null)
     let baseUtxos = UtxoCollection.createEmpty({
       currency: this.asset.currency,
     })
 
     const unknownAssetIds = new Set(
-      Object.keys(groupedCoins).filter((coinType) => coinType !== coinTypes.Base)
+      [...Object.keys(groupedCoins), ...Object.keys(addressBalanceByCoinType)].filter(
+        (coinType) => coinType !== coinTypes.Base
+      )
     )
 
     for (const [assetName, asset] of Object.entries(this.assets)) {
       const isBaseAsset = asset.baseAssetName === asset.name
-      if (isBaseAsset) {
-        baseUtxos = this.#formatUtxos({
-          address,
-          coinType: coinTypes.Base,
-          coins: groupedCoins[coinTypes.Base] || [],
-          asset,
-        })
-        continue
-      }
+      const coinType = isBaseAsset ? coinTypes.Base : asset.assetId
+      if (!isBaseAsset && !unknownAssetIds.delete(coinType)) continue
 
-      if (!unknownAssetIds.delete(asset.assetId)) continue
-
-      tokenUtxos[assetName] = this.#formatUtxos({
+      const utxos = this.#formatUtxos({
         address,
-        coinType: asset.assetId,
-        coins: groupedCoins[asset.assetId] || [],
+        coinType,
+        coins: groupedCoins[coinType] || [],
         asset,
       })
+      if (isBaseAsset) {
+        baseUtxos = utxos
+      } else {
+        tokenUtxos[assetName] = utxos
+      }
+
+      if (addressBalanceByCoinType[coinType]) {
+        addressBalances[assetName] = addressBalanceByCoinType[coinType]
+      }
     }
 
     return {
       utxos: baseUtxos,
       tokenUtxos,
+      addressBalances,
       unknownAssetIds: [...unknownAssetIds],
     }
   }

package/src/transform-tx.js

@@ -1,3 +1,4 @@
+import { NO_GAS_OBJECT_ID } from './graphql/json-rpc-shapes.js'
 import { parseStakingCommands } from './staking/staking-transactions.js'
 
 const parseTransaction = ({ transaction, asset }) => {
@@ -49,8 +50,10 @@ export const getFeeAmount = ({ gasUsed, feeAsset }) => {
 
 const parseConfirmations = ({ effects }) => {
   const { status, gasObject } = effects
+  const hasGas =
+    gasObject?.reference?.version || gasObject?.reference?.objectId === NO_GAS_OBJECT_ID
 
-  if (!status?.status || !gasObject?.reference?.version) {
+  if (!status?.status || !hasGas) {
     return {
       confirmations: 0,
       error: 0,

package/src/tx-send.js

@@ -1,4 +1,4 @@
-import { UtxoCollection } from '@exodus/models'
+import { Address, UtxoCollection } from '@exodus/models'
 import { coinTypes, objectTypes, toCoinType } from '@exodus/sui-lib'
 import assert from 'minimalistic-assert'
 import ms from 'ms'
@@ -8,6 +8,7 @@ import { applyStakingTx } from './staking/staking-info.js'
 import { parseStakingCommands } from './staking/staking-transactions.js'
 import { getFeeAmount } from './transform-tx.js'
 
+const ZERO = BigInt(0)
 const LOOKUP_ATTEMPTS = 5
 const LOOKUP_DELAY_MS = ms('3s')
 
@@ -78,12 +79,7 @@ const deriveNewUtxos = ({ mutatedObject, balanceChange, deletedObjects, utxos, a
   }
 }
 
-const getObjectAndBalanceChangesByType = ({
-  objectChanges,
-  balanceChanges,
-  ownerAddress,
-  asset,
-}) => {
+const getObjectAndBalanceChangesByType = ({ objectChanges, balanceChanges, ownerAddress }) => {
   const ownerBalanceChangesByType = balanceChanges.reduce((acc, change) => {
     const { owner, coinType, amount } = change
     if (owner?.AddressOwner !== ownerAddress) {
@@ -95,8 +91,6 @@ const getObjectAndBalanceChangesByType = ({
     return acc
   }, Object.create(null))
 
-  const wasBaseAssetSent = asset.name === asset.baseAssetName
-
   const ownerObjectChangesByType = objectChanges.reduce((acc, change) => {
     const { owner, objectType, type } = change
 
@@ -131,37 +125,110 @@ const getObjectAndBalanceChangesByType = ({
     return acc
   }, Object.create(null))
 
-  const baseObjectsMutated = ownerObjectChangesByType[objectTypes.Base]?.mutated
+  if (!ownerBalanceChangesByType[coinTypes.Base]) {
+    throw new Error('In-decidable state change')
+  }
+
+  return {
+    ownerObjectChangesByType,
+    ownerBalanceChangesByType,
+  }
+}
+
+const addCreatedCoin = ({ utxos, created, value, coinType, ownerAddress, digest, asset }) =>
+  UtxoCollection.fromArray(
+    [
+      ...utxos.toArray(),
+      {
+        address: Address.create(ownerAddress, { path: 'm/0/0' }),
+        txId: digest,
+        digest: created.digest,
+        coinObjectId: created.objectId,
+        version: created.version,
+        coinType,
+        confirmations: 1,
+        value: asset.currency.baseUnit(String(value)),
+      },
+    ],
+    { currency: asset.currency }
+  )
+
+// A self-send's new coin holds the sent amount. Without that amount, a new coin next to
+// no mutated coin holds whatever the coins gained.
+const getCreatedCoinValue = ({ created, mutated, coinChange, selfSendAmount }) => {
+  if (created.length !== 1) return ZERO
+  if (selfSendAmount !== undefined) return BigInt(selfSendAmount)
+  return mutated.length === 0 ? coinChange : ZERO
+}
+
+// The address balance changes by what the transaction declared: its withdrawals, plus
+// the gas cost when gas is paid from it. Coins take the rest of the owner's net change,
+// split between the mutated coin and the coin a self-send created.
+const applyCoinChanges = ({
+  asset,
+  coinType,
+  objectChanges,
+  balanceChange = '0',
+  addressBalanceChange,
+  selfSendAmount,
+  utxos,
+  addressBalance = '0',
+  ownerAddress,
+  digest,
+}) => {
+  const { mutated = [], created = [], deleted = [] } = objectChanges ?? Object.create(null)
+  const newAddressBalance = BigInt(addressBalance) + addressBalanceChange
+  const coinChange = BigInt(balanceChange) - addressBalanceChange
+  const createdCoinValue = getCreatedCoinValue({ created, mutated, coinChange, selfSendAmount })
+  const mutatedCoinChange = coinChange - createdCoinValue
 
   if (
-    !baseObjectsMutated ||
-    baseObjectsMutated.length !== 1 ||
-    !ownerBalanceChangesByType[coinTypes.Base]
+    newAddressBalance < ZERO ||
+    mutated.length > 1 ||
+    createdCoinValue < ZERO ||
+    (selfSendAmount !== undefined && created.length !== 1) ||
+    (mutated.length === 0 && mutatedCoinChange !== ZERO)
   ) {
-    // expect to have 1 mutated object at point because coins were merged
     throw new Error('In-decidable state change')
   }
 
-  if (!wasBaseAssetSent) {
-    const assetId = asset.assetId
-    const coinType = toCoinType(assetId)
+  let newUtxos = utxos
+  if (mutated.length === 1) {
+    newUtxos = deriveNewUtxos({
+      mutatedObject: mutated[0],
+      balanceChange: String(mutatedCoinChange),
+      deletedObjects: deleted,
+      utxos,
+      asset,
+    }).utxos
+  }
+
+  if (createdCoinValue > ZERO) {
+    newUtxos = addCreatedCoin({
+      utxos: newUtxos,
+      created: created[0],
+      value: createdCoinValue,
+      coinType,
+      ownerAddress,
+      digest,
+      asset,
+    })
+  }
 
-    const assetObjectsMutated = ownerObjectChangesByType[coinType]?.mutated
+  return { utxos: newUtxos, addressBalance: String(newAddressBalance) }
+}
 
-    if (
-      !assetObjectsMutated ||
-      assetObjectsMutated.length !== 1 ||
-      !ownerBalanceChangesByType[assetId]
-    ) {
-      // expect to have 1 mutated object at point because coins were merged
-      throw new Error('In-decidable state change')
+const updateAddressBalances = ({ addressBalances, updates }) => {
+  const next = { ...addressBalances }
+  for (const [assetName, value] of Object.entries(updates)) {
+    if (value === '0') {
+      delete next[assetName]
+    } else {
+      next[assetName] = value
     }
   }
 
-  return {
-    ownerObjectChangesByType,
-    ownerBalanceChangesByType,
-  }
+  return next
 }
 
 const getRecipientAddress = ({ balanceChanges, ownerAddress }) => {
@@ -182,7 +249,9 @@ const stringifyFailureReason = (error) => {
 }
 
 // TODO: extract into separate file
-const getStateChanges = async ({ aci, asset, walletAccount, result }) => {
+const getStateChanges = async ({ aci, asset, walletAccount, result, txMeta }) => {
+  const withdrawals = txMeta?.addressBalanceWithdrawals ?? Object.create(null)
+  const withdrawn = (assetName) => BigInt(withdrawals[assetName] ?? 0)
   const { feeAsset, currency: assetCurrency, name: assetName } = asset
   const { objectChanges, balanceChanges, digest, effects } = result
   const { gasUsed, status } = effects
@@ -210,20 +279,33 @@ const getStateChanges = async ({ aci, asset, walletAccount, result }) => {
     objectChanges,
     balanceChanges,
     ownerAddress,
-    asset,
   })
 
   const newAccountState = Object.create(null)
+  const addressBalanceUpdates = Object.create(null)
+  const baseAssetName = asset.baseAsset.name
 
-  const newBaseUtxos = deriveNewUtxos({
-    mutatedObject: ownerObjectChangesByType[objectTypes.Base].mutated[0],
+  const gasCost =
+    BigInt(gasUsed.computationCost) + BigInt(gasUsed.storageCost) - BigInt(gasUsed.storageRebate)
+  const gasFromAddressBalance = txMeta?.gasFromAddressBalance ? gasCost : ZERO
+  const selfSendAmount = txMeta?.selfSendAmount
+
+  const base = applyCoinChanges({
+    asset: asset.baseAsset,
+    coinType: coinTypes.Base,
+    objectChanges: ownerObjectChangesByType[objectTypes.Base],
     balanceChange: ownerBalanceChangesByType[coinTypes.Base],
-    deletedObjects: ownerObjectChangesByType[objectTypes.Base].deleted,
+    addressBalanceChange:
+      -(wasBaseAssetSent ? withdrawn(baseAssetName) : BigInt(0)) - gasFromAddressBalance,
+    selfSendAmount: wasBaseAssetSent ? selfSendAmount : undefined,
     utxos: accountState.utxos,
-    asset: asset.baseAsset,
+    addressBalance: accountState.addressBalances[baseAssetName],
+    ownerAddress,
+    digest,
   })
 
-  newAccountState.utxos = newBaseUtxos.utxos
+  newAccountState.utxos = base.utxos
+  addressBalanceUpdates[baseAssetName] = base.addressBalance
 
   const parsedStaking = wasBaseAssetSent
     ? parseStakingCommands(result.transaction?.data?.transaction)
@@ -233,17 +315,24 @@ const getStateChanges = async ({ aci, asset, walletAccount, result }) => {
   if (wasBaseAssetSent) {
     amount = asset.currency.baseUnit(ownerBalanceChangesByType[coinTypes.Base]).add(fee)
   } else {
-    const coinType = toCoinType(asset.assetId)
-    const newTokenUtxos = deriveNewUtxos({
-      mutatedObject: ownerObjectChangesByType[coinType].mutated[0],
-      balanceChange: ownerBalanceChangesByType[asset.assetId],
-      deletedObjects: ownerObjectChangesByType[coinType].deleted,
-      utxos: accountState.tokenUtxos[asset.name],
+    const token = applyCoinChanges({
       asset,
+      coinType: asset.assetId,
+      objectChanges: ownerObjectChangesByType[toCoinType(asset.assetId)],
+      balanceChange: ownerBalanceChangesByType[asset.assetId],
+      addressBalanceChange: -withdrawn(asset.name),
+      selfSendAmount,
+      utxos:
+        accountState.tokenUtxos[asset.name] ||
+        UtxoCollection.createEmpty({ currency: asset.currency }),
+      addressBalance: accountState.addressBalances[asset.name],
+      ownerAddress,
+      digest,
     })
 
-    newAccountState.tokenUtxos = { [asset.name]: newTokenUtxos.utxos }
-    amount = asset.currency.baseUnit(ownerBalanceChangesByType[asset.assetId])
+    newAccountState.tokenUtxos = { [asset.name]: token.utxos }
+    addressBalanceUpdates[asset.name] = token.addressBalance
+    amount = asset.currency.baseUnit(ownerBalanceChangesByType[asset.assetId] ?? 0)
   }
 
   const staking = parsedStaking && { ...parsedStaking, amount: amount.abs().toBaseString() }
@@ -275,6 +364,10 @@ const getStateChanges = async ({ aci, asset, walletAccount, result }) => {
         }),
       }),
       utxos: newAccountState.utxos,
+      addressBalances: updateAddressBalances({
+        addressBalances: accountState.addressBalances,
+        updates: addressBalanceUpdates,
+      }),
       tokenUtxos: {
         ...accountState.tokenUtxos,
         ...(newAccountState.tokenUtxos && newAccountState.tokenUtxos[asset.name]
@@ -324,6 +417,7 @@ export const txSendFactory = ({
       walletAccount,
       result,
       aci,
+      txMeta: unsignedTx.txMeta,
     })
 
     let batch = aci.createOperationsBatch()

package/src/vendors/transactions/Inputs.js

@@ -14,6 +14,16 @@ function Pure(data) {
 
 const Inputs = {
   Pure,
+  FundsWithdrawal({ amount, type }) {
+    return {
+      $kind: 'FundsWithdrawal',
+      FundsWithdrawal: {
+        reservation: { $kind: 'MaxAmountU64', MaxAmountU64: String(amount) },
+        typeArg: { $kind: 'Balance', Balance: type },
+        withdrawFrom: { $kind: 'Sender', Sender: true },
+      },
+    }
+  },
   ObjectRef({ objectId, digest, version }) {
     return {
       $kind: 'Object',

package/src/vendors/transactions/Transaction.js

@@ -365,6 +365,15 @@ const _Transaction = class _Transaction {
     return { $kind: 'GasCoin', GasCoin: true }
   }
 
+  /** Withdraws `amount` of coin `type` from the sender address balance (SIP-58). */
+  withdrawal({ amount, type = '0x2::sui::SUI' }) {
+    return __privateMethod(this, _Transaction_instances, addInput_fn).call(
+      this,
+      'object',
+      Inputs.FundsWithdrawal({ amount, type })
+    )
+  }
+
   /**
    * Add a new object input to the transaction using the fully-resolved object reference.
    * If you only have an object ID, use `builder.object(id)` instead.

package/src/vendors/transactions/data/internal.js

@@ -156,11 +156,24 @@ const ObjectArg = safeEnum({
   }),
   Receiving: ObjectRef,
 })
+const FundsWithdrawal = object({
+  reservation: safeEnum({
+    MaxAmountU64: JsonU64,
+  }),
+  typeArg: safeEnum({
+    Balance: string(),
+  }),
+  withdrawFrom: safeEnum({
+    Sender: literal(true),
+    Sponsor: literal(true),
+  }),
+})
 const CallArg = safeEnum({
   Object: ObjectArg,
   Pure: object({
     bytes: BCSBytes,
   }),
+  FundsWithdrawal,
   UnresolvedPure: object({
     value: unknown(),
   }),
@@ -176,10 +189,19 @@ const NormalizedCallArg = safeEnum({
   Pure: object({
     bytes: BCSBytes,
   }),
+  FundsWithdrawal,
 })
 const TransactionExpiration = safeEnum({
   None: literal(true),
   Epoch: JsonU64,
+  ValidDuring: object({
+    minEpoch: nullable(JsonU64),
+    maxEpoch: nullable(JsonU64),
+    minTimestamp: nullable(JsonU64),
+    maxTimestamp: nullable(JsonU64),
+    chain: string(),
+    nonce: pipe(number(), integer()),
+  }),
 })
 const TransactionData = object({
   version: literal(2),

package/src/vendors/transactions/data/v2.js

@@ -86,11 +86,24 @@ const ObjectArg = enumUnion({
   }),
   Receiving: ObjectRef,
 })
+const FundsWithdrawal = object({
+  reservation: enumUnion({
+    MaxAmountU64: JsonU64,
+  }),
+  typeArg: enumUnion({
+    Balance: string(),
+  }),
+  withdrawFrom: enumUnion({
+    Sender: literal(true),
+    Sponsor: literal(true),
+  }),
+})
 const CallArg = enumUnion({
   Object: ObjectArg,
   Pure: object({
     bytes: BCSBytes,
   }),
+  FundsWithdrawal,
   UnresolvedPure: object({
     value: unknown(),
   }),
@@ -104,6 +117,14 @@ const CallArg = enumUnion({
 const TransactionExpiration = enumUnion({
   None: literal(true),
   Epoch: JsonU64,
+  ValidDuring: object({
+    minEpoch: nullable(JsonU64),
+    maxEpoch: nullable(JsonU64),
+    minTimestamp: nullable(JsonU64),
+    maxTimestamp: nullable(JsonU64),
+    chain: string(),
+    nonce: pipe(number(), integer()),
+  }),
 })
 const SerializedTransactionDataV2 = object({
   version: literal(2),

package/src/vendors/transactions/resolve.js

@@ -42,9 +42,9 @@ async function resolveTransactionPlugin(transactionData, options, next) {
 
 function validate(transactionData) {
   transactionData.inputs.forEach((input, index) => {
-    if (input.$kind !== 'Object' && input.$kind !== 'Pure') {
+    if (input.$kind !== 'Object' && input.$kind !== 'Pure' && input.$kind !== 'FundsWithdrawal') {
       throw new Error(
-        `Input at index ${index} has not been resolved.  Expected a Pure or Object input, but found ${JSON.stringify(
+        `Input at index ${index} has not been resolved.  Expected a Pure, Object or FundsWithdrawal input, but found ${JSON.stringify(
           input
         )}`
       )