@exodus/sui-api 1.3.1 → 1.4.1

package/src/staking/delegated-stakes.js

@@ -0,0 +1,66 @@
+const EMPTY_EXCHANGE_RATE = Object.freeze({ sui_amount: '0', pool_token_amount: '0' })
+
+const RATE_LOOKBACK_EPOCHS = 7
+
+const getLookbackEpochs = (epoch) => {
+  const first = Math.max(0, epoch - RATE_LOOKBACK_EPOCHS)
+  return Array.from({ length: epoch - first + 1 }, (_, index) => epoch - index)
+}
+
+export const getRateLookupEpochs = (epochs) => [...new Set(epochs.flatMap(getLookbackEpochs))]
+
+export const findRecordedRate = ({ rates, epoch }) =>
+  rates.get(getLookbackEpochs(epoch).find((candidate) => rates.has(candidate)))
+
+const toRate = ({ sui_amount: suiAmount, pool_token_amount: poolTokenAmount }) =>
+  BigInt(suiAmount) === BigInt(0) ? 1 : Number(poolTokenAmount) / Number(suiAmount)
+
+export const estimateReward = ({ principal, activationRate, currentRate }) => {
+  if (!currentRate) return '0'
+  const stakeRate = toRate(activationRate ?? EMPTY_EXCHANGE_RATE)
+  const reward = (stakeRate / toRate(currentRate) - 1) * Number(principal)
+  return String(Math.max(0, Math.round(reward)))
+}
+
+export const getLatestRateEpoch = ({ pool, epoch }) =>
+  pool.deactivationEpoch === null ? epoch : Math.min(epoch, pool.deactivationEpoch)
+
+const toStake = ({ stakedSui, pool, epoch }) => {
+  const activationEpoch = Number(stakedSui.stake_activation_epoch)
+  const stake = {
+    stakedSuiId: stakedSui.id,
+    stakeRequestEpoch: String(activationEpoch - 1),
+    stakeActiveEpoch: String(activationEpoch),
+    principal: stakedSui.principal,
+  }
+
+  if (epoch < activationEpoch) return { ...stake, status: 'Pending' }
+
+  return {
+    ...stake,
+    status: 'Active',
+    estimatedReward: estimateReward({
+      principal: stakedSui.principal,
+      activationRate: pool.rates.get(activationEpoch),
+      currentRate: pool.currentRate,
+    }),
+  }
+}
+
+export const toDelegatedStakes = ({ stakedSuis, poolsById, epoch }) => {
+  const stakesByPool = new Map()
+  for (const stakedSui of stakedSuis) {
+    const pool = poolsById.get(stakedSui.pool_id)
+    if (!pool) throw new Error(`Cannot find rates for staking pool ${stakedSui.pool_id}`)
+
+    const delegatedStake = stakesByPool.get(stakedSui.pool_id) ?? {
+      validatorAddress: pool.validatorAddress,
+      stakingPool: stakedSui.pool_id,
+      stakes: [],
+    }
+    delegatedStake.stakes.push(toStake({ stakedSui, pool, epoch }))
+    stakesByPool.set(stakedSui.pool_id, delegatedStake)
+  }
+
+  return [...stakesByPool.values()]
+}

package/src/staking/staking-transactions.js

@@ -1,4 +1,5 @@
 import { Transaction } from '../vendors/transactions/index.js'
+import { getPureBcsSchema } from '../vendors/transactions/serializer.js'
 import {
   ADD_STAKE_FUNCTION,
   ADD_STAKE_TARGET,
@@ -49,6 +50,14 @@ const getInput = ({ inputs, argument }) =>
     ? inputs[argument.Input]
     : undefined
 
+const ADDRESS_LENGTH = 32
+
+const getAddressValue = (input) => {
+  if (input?.valueType !== null) return input?.value
+  if (input.value.length !== ADDRESS_LENGTH) return
+  return getPureBcsSchema('address').parse(Uint8Array.from(input.value))
+}
+
 const getSplitAmount = ({ inputs, commands, argument }) => {
   const resultIndex = argument?.NestedResult?.[0] ?? argument?.Result
   const amountArgument = commands[resultIndex]?.SplitCoins?.[1]?.[0]
@@ -74,7 +83,7 @@ export const parseStakingCommands = (programmableTransaction) => {
     const amount = getSplitAmount({ inputs, commands, argument: coinArgument })
     return {
       operation,
-      validator: getInput({ inputs, argument: validatorArgument })?.value,
+      validator: getAddressValue(getInput({ inputs, argument: validatorArgument })),
       ...(amount && { amount }),
     }
   }

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/tx-send.js

@@ -1,11 +1,48 @@
 import { UtxoCollection } from '@exodus/models'
 import { coinTypes, objectTypes, toCoinType } from '@exodus/sui-lib'
 import assert from 'minimalistic-assert'
+import ms from 'ms'
 
+import { SuiBroadcastError } from './broadcast-error.js'
 import { applyStakingTx } from './staking/staking-info.js'
 import { parseStakingCommands } from './staking/staking-transactions.js'
 import { getFeeAmount } from './transform-tx.js'
 
+const LOOKUP_ATTEMPTS = 5
+const LOOKUP_DELAY_MS = ms('3s')
+
+const wait = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs))
+
+const findExecutedTransaction = async ({ serverApi, digest, lookupAttempts, lookupDelayMs }) => {
+  for (let attempt = 0; attempt < lookupAttempts; attempt++) {
+    await wait(lookupDelayMs)
+    const [transaction] = await serverApi.getTransactions({ txIds: [digest] }).catch(() => [])
+    if (transaction) return transaction
+  }
+}
+
+const broadcastTransaction = async ({
+  asset,
+  plainTx,
+  serverApi,
+  lookupAttempts,
+  lookupDelayMs,
+}) => {
+  try {
+    return await asset.baseAsset.api.broadcastTx(plainTx)
+  } catch (error) {
+    if (!(error instanceof SuiBroadcastError)) throw error
+    const transaction = await findExecutedTransaction({
+      serverApi,
+      digest: error.digest,
+      lookupAttempts,
+      lookupDelayMs,
+    })
+    if (!transaction) throw error
+    return transaction
+  }
+}
+
 const deriveNewUtxos = ({ mutatedObject, balanceChange, deletedObjects, utxos, asset }) => {
   const utxoArray = utxos.toArray()
 
@@ -252,7 +289,13 @@ const getStateChanges = async ({ aci, asset, walletAccount, result }) => {
   }
 }
 
-export const txSendFactory = ({ assetClientInterface: aci, serverApi, createTx }) => {
+export const txSendFactory = ({
+  assetClientInterface: aci,
+  serverApi,
+  createTx,
+  lookupAttempts = LOOKUP_ATTEMPTS,
+  lookupDelayMs = LOOKUP_DELAY_MS,
+}) => {
   assert(aci, 'assetClientInterface is required')
   assert(serverApi, 'serverApi is required')
   assert(createTx, 'createTx is required')
@@ -268,7 +311,13 @@ export const txSendFactory = ({ assetClientInterface: aci, serverApi, createTx }
       walletAccount,
     })
 
-    const result = await asset.baseAsset.api.broadcastTx(plainTx)
+    const result = await broadcastTransaction({
+      asset,
+      plainTx,
+      serverApi,
+      lookupAttempts,
+      lookupDelayMs,
+    })
 
     const { accountStateData: newData, txLogsByAssetName } = await getStateChanges({
       asset,

package/src/vendors/transactions/resolve.js

@@ -1,7 +1,7 @@
 import { vendorLib } from '@exodus/sui-lib'
 
-import { suiClientResolveTransactionPlugin } from '../experimental/transports/json-rpc-resolver.js'
 import { Inputs } from './Inputs.js'
+import { suiClientResolveTransactionPlugin } from './resolver.js'
 
 const { bcs } = vendorLib
 
@@ -33,8 +33,7 @@ async function resolveTransactionPlugin(transactionData, options, next) {
   }
 
   const client = getClient(options)
-  const plugin =
-    client.core?.resolveTransactionPlugin() ?? suiClientResolveTransactionPlugin(client)
+  const plugin = suiClientResolveTransactionPlugin(client)
   return plugin(transactionData, options, async () => {
     await validate(transactionData)
     await next()

package/src/vendors/{experimental/transports/json-rpc-resolver.js → transactions/resolver.js}

@@ -2,14 +2,10 @@
 /* eslint-disable no-return-await */
 import { vendorLib } from '@exodus/sui-lib'
 
-import { ObjectRef } from '../../transactions/data/internal.js'
-import { Inputs } from '../../transactions/Inputs.js'
-import {
-  getPureBcsSchema,
-  isTxContext,
-  normalizedTypeToMoveTypeSignature,
-} from '../../transactions/serializer.js'
-import { parse } from '../../valibot.js'
+import { parse } from '../valibot.js'
+import { ObjectRef } from './data/internal.js'
+import { Inputs } from './Inputs.js'
+import { getPureBcsSchema, isTxContext } from './serializer.js'
 
 const { normalizeSuiAddress, normalizeSuiObjectId, SUI_TYPE_ARG } = vendorLib.utils
 
@@ -18,6 +14,7 @@ const { chunk } = vendorLib.utils
 const MAX_OBJECTS_PER_FETCH = 50
 const GAS_SAFE_OVERHEAD = BigInt(1000)
 const MAX_GAS = 5e10
+const MAX_GAS_OBJECTS = 256
 
 function suiClientResolveTransactionPlugin(client) {
   return async function resolveTransactionData(transactionData, options, next) {
@@ -35,7 +32,7 @@ function suiClientResolveTransactionPlugin(client) {
 
 async function setGasPrice(transactionData, client) {
   if (!transactionData.gasConfig.price) {
-    transactionData.gasConfig.price = String(await client.getReferenceGasPrice())
+    transactionData.gasConfig.price = await client.getReferenceGasPrice()
   }
 }
 
@@ -44,7 +41,7 @@ async function setGasBudget(transactionData, client) {
     return
   }
 
-  const dryRunResult = await client.dryRunTransactionBlock({
+  const dryRunResult = await client.dryRunTransaction({
     transactionBlock: transactionData.build({
       overrides: {
         gasData: {
@@ -79,7 +76,7 @@ async function setGasPayment(transactionData, client) {
       owner: transactionData.gasConfig.owner || transactionData.sender,
       coinType: SUI_TYPE_ARG,
     })
-    const paymentCoins = coins.data
+    const paymentCoins = coins
       .filter((coin) => {
         const matchingInput = transactionData.inputs.find((input) => {
           if (input.Object?.ImmOrOwnedObject) {
@@ -90,6 +87,8 @@ async function setGasPayment(transactionData, client) {
         })
         return !matchingInput
       })
+      .sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : -1))
+      .slice(0, MAX_GAS_OBJECTS)
       .map((coin) => ({
         objectId: coin.coinObjectId,
         digest: coin.digest,
@@ -117,47 +116,13 @@ async function resolveObjectReferences(transactionData, client) {
   ]
   const objectChunks = dedupedIds.length > 0 ? chunk(dedupedIds, MAX_OBJECTS_PER_FETCH) : []
   const resolvedChunks = await Promise.all(
-    objectChunks.map((chunk2) =>
-      client.multiGetObjects({
-        ids: chunk2,
-        options: { showOwner: true },
-      })
-    )
-  )
-  const resolved = resolvedChunks.flat()
-  const responsesById = new Map(
-    dedupedIds.map((id, index) => {
-      return [id, resolved[index]]
-    })
+    objectChunks.map((chunk2) => client.getObjectRefs({ ids: chunk2 }))
   )
-  const invalidObjects = [...responsesById]
-    .filter(([_, obj]) => obj.error)
-    .map(([_, obj]) => JSON.stringify(obj.error))
-  if (invalidObjects.length > 0) {
-    throw new Error(`The following input objects are invalid: ${invalidObjects.join(', ')}`)
+  const objects = resolvedChunks.flat()
+  const missing = dedupedIds.filter((id, index) => !objects[index])
+  if (missing.length > 0) {
+    throw new Error(`The following input objects are invalid: ${missing.join(', ')}`)
   }
-
-  const objects = resolved.map((object) => {
-    if (object.error || !object.data) {
-      throw new Error(`Failed to fetch object: ${object.error}`)
-    }
-
-    const owner = object.data.owner
-    const initialSharedVersion =
-      owner && typeof owner === 'object'
-        ? 'Shared' in owner
-          ? owner.Shared.initial_shared_version
-          : 'ConsensusAddressOwner' in owner
-            ? owner.ConsensusAddressOwner.start_version
-            : null
-        : null
-    return {
-      objectId: object.data.objectId,
-      digest: object.data.digest,
-      version: object.data.version,
-      initialSharedVersion,
-    }
-  })
   const objectsById = new Map(
     dedupedIds.map((id, index) => {
       return [id, objects[index]]
@@ -228,15 +193,12 @@ async function normalizeInputs(transactionData, client) {
     await Promise.all(
       [...moveFunctionsToResolve].map(async (functionName) => {
         const [packageId, moduleId, functionId] = functionName.split('::')
-        const def = await client.getNormalizedMoveFunction({
+        const parameters = await client.getMoveFunctionParameters({
           package: packageId,
           module: moduleId,
           function: functionId,
         })
-        moveFunctionParameters.set(
-          functionName,
-          def.parameters.map((param) => normalizedTypeToMoveTypeSignature(param))
-        )
+        moveFunctionParameters.set(functionName, parameters)
       })
     )
   }
@@ -346,7 +308,7 @@ function isReceivingType(type) {
   }
 
   return (
-    type.body.datatype.package === '0x2' &&
+    normalizeSuiAddress(type.body.datatype.package) === normalizeSuiAddress('0x2') &&
     type.body.datatype.module === 'transfer' &&
     type.body.datatype.type === 'Receiving'
   )