@exodus/sui-api 1.3.1 → 1.4.0

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/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'
   )