@exodus/sui-api 0.1.0

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

@@ -0,0 +1,359 @@
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+/* 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'
+
+const { normalizeSuiAddress, normalizeSuiObjectId, SUI_TYPE_ARG } = vendorLib.utils
+
+const { chunk } = vendorLib.utils
+
+const MAX_OBJECTS_PER_FETCH = 50
+const GAS_SAFE_OVERHEAD = BigInt(1000)
+const MAX_GAS = 5e10
+
+function suiClientResolveTransactionPlugin(client) {
+  return async function resolveTransactionData(transactionData, options, next) {
+    await normalizeInputs(transactionData, client)
+    await resolveObjectReferences(transactionData, client)
+    if (!options.onlyTransactionKind) {
+      await setGasPrice(transactionData, client)
+      await setGasBudget(transactionData, client)
+      await setGasPayment(transactionData, client)
+    }
+
+    return await next()
+  }
+}
+
+async function setGasPrice(transactionData, client) {
+  if (!transactionData.gasConfig.price) {
+    transactionData.gasConfig.price = String(await client.getReferenceGasPrice())
+  }
+}
+
+async function setGasBudget(transactionData, client) {
+  if (transactionData.gasConfig.budget) {
+    return
+  }
+
+  const dryRunResult = await client.dryRunTransactionBlock({
+    transactionBlock: transactionData.build({
+      overrides: {
+        gasData: {
+          budget: String(MAX_GAS),
+          payment: [],
+        },
+      },
+    }),
+  })
+  if (dryRunResult.effects.status.status !== 'success') {
+    throw new Error(
+      `Dry run failed, could not automatically determine a budget: ${dryRunResult.effects.status.error}`,
+      { cause: dryRunResult }
+    )
+  }
+
+  const safeOverhead = GAS_SAFE_OVERHEAD * BigInt(transactionData.gasConfig.price || BigInt(1))
+  const baseComputationCostWithOverhead =
+    BigInt(dryRunResult.effects.gasUsed.computationCost) + safeOverhead
+  const gasBudget =
+    baseComputationCostWithOverhead +
+    BigInt(dryRunResult.effects.gasUsed.storageCost) -
+    BigInt(dryRunResult.effects.gasUsed.storageRebate)
+  transactionData.gasConfig.budget = String(
+    gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead
+  )
+}
+
+async function setGasPayment(transactionData, client) {
+  if (!transactionData.gasConfig.payment) {
+    const coins = await client.getCoins({
+      owner: transactionData.gasConfig.owner || transactionData.sender,
+      coinType: SUI_TYPE_ARG,
+    })
+    const paymentCoins = coins.data
+      .filter((coin) => {
+        const matchingInput = transactionData.inputs.find((input) => {
+          if (input.Object?.ImmOrOwnedObject) {
+            return coin.coinObjectId === input.Object.ImmOrOwnedObject.objectId
+          }
+
+          return false
+        })
+        return !matchingInput
+      })
+      .map((coin) => ({
+        objectId: coin.coinObjectId,
+        digest: coin.digest,
+        version: coin.version,
+      }))
+    if (paymentCoins.length === 0) {
+      throw new Error('No valid gas coins found for the transaction.')
+    }
+
+    transactionData.gasConfig.payment = paymentCoins.map((payment) => parse(ObjectRef, payment))
+  }
+}
+
+async function resolveObjectReferences(transactionData, client) {
+  const objectsToResolve = transactionData.inputs.filter((input) => {
+    return (
+      input.UnresolvedObject &&
+      !(input.UnresolvedObject.version || input.UnresolvedObject?.initialSharedVersion)
+    )
+  })
+  const dedupedIds = [
+    ...new Set(
+      objectsToResolve.map((input) => normalizeSuiObjectId(input.UnresolvedObject.objectId))
+    ),
+  ]
+  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 },
+        })
+      )
+    )
+  )
+    // eslint-disable-next-line unicorn/no-await-expression-member
+    .flat()
+  const responsesById = new Map(
+    dedupedIds.map((id, index) => {
+      return [id, resolved[index]]
+    })
+  )
+  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 = 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]]
+    })
+  )
+  for (const [index, input] of transactionData.inputs.entries()) {
+    if (!input.UnresolvedObject) {
+      continue
+    }
+
+    let updated
+    const id = normalizeSuiAddress(input.UnresolvedObject.objectId)
+    const object = objectsById.get(id)
+    if (input.UnresolvedObject.initialSharedVersion ?? object?.initialSharedVersion) {
+      updated = Inputs.SharedObjectRef({
+        objectId: id,
+        initialSharedVersion:
+          input.UnresolvedObject.initialSharedVersion || object?.initialSharedVersion,
+        mutable: isUsedAsMutable(transactionData, index),
+      })
+    } else if (isUsedAsReceiving(transactionData, index)) {
+      updated = Inputs.ReceivingRef({
+        objectId: id,
+        digest: input.UnresolvedObject.digest ?? object?.digest,
+        version: input.UnresolvedObject.version ?? object?.version,
+      })
+    }
+
+    transactionData.inputs[transactionData.inputs.indexOf(input)] =
+      updated ??
+      Inputs.ObjectRef({
+        objectId: id,
+        digest: input.UnresolvedObject.digest ?? object?.digest,
+        version: input.UnresolvedObject.version ?? object?.version,
+      })
+  }
+}
+
+async function normalizeInputs(transactionData, client) {
+  const { inputs, commands } = transactionData
+  const moveCallsToResolve = []
+  const moveFunctionsToResolve = /* @__PURE__ */ new Set()
+  commands.forEach((command) => {
+    if (command.MoveCall) {
+      if (command.MoveCall._argumentTypes) {
+        return
+      }
+
+      const inputs2 = command.MoveCall.arguments.map((arg) => {
+        if (arg.$kind === 'Input') {
+          return transactionData.inputs[arg.Input]
+        }
+
+        return null
+      })
+      const needsResolution = inputs2.some(
+        (input) => input?.UnresolvedPure || input?.UnresolvedObject
+      )
+      if (needsResolution) {
+        const functionName = `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`
+        moveFunctionsToResolve.add(functionName)
+        moveCallsToResolve.push(command.MoveCall)
+      }
+    }
+  })
+  const moveFunctionParameters = /* @__PURE__ */ new Map()
+  if (moveFunctionsToResolve.size > 0) {
+    await Promise.all(
+      [...moveFunctionsToResolve].map(async (functionName) => {
+        const [packageId, moduleId, functionId] = functionName.split('::')
+        const def = await client.getNormalizedMoveFunction({
+          package: packageId,
+          module: moduleId,
+          function: functionId,
+        })
+        moveFunctionParameters.set(
+          functionName,
+          def.parameters.map((param) => normalizedTypeToMoveTypeSignature(param))
+        )
+      })
+    )
+  }
+
+  if (moveCallsToResolve.length > 0) {
+    await Promise.all(
+      moveCallsToResolve.map(async (moveCall) => {
+        const parameters = moveFunctionParameters.get(
+          `${moveCall.package}::${moveCall.module}::${moveCall.function}`
+        )
+        if (!parameters) {
+          return
+        }
+
+        const hasTxContext = parameters.length > 0 && isTxContext(parameters.at(-1))
+        const params = hasTxContext ? parameters.slice(0, -1) : parameters
+        moveCall._argumentTypes = params
+      })
+    )
+  }
+
+  commands.forEach((command) => {
+    if (!command.MoveCall) {
+      return
+    }
+
+    const moveCall = command.MoveCall
+    const fnName = `${moveCall.package}::${moveCall.module}::${moveCall.function}`
+    const params = moveCall._argumentTypes
+    if (!params) {
+      return
+    }
+
+    if (params.length !== command.MoveCall.arguments.length) {
+      throw new Error(`Incorrect number of arguments for ${fnName}`)
+    }
+
+    params.forEach((param, i) => {
+      const arg = moveCall.arguments[i]
+      if (arg.$kind !== 'Input') return
+      const input = inputs[arg.Input]
+      if (!input.UnresolvedPure && !input.UnresolvedObject) {
+        return
+      }
+
+      const inputValue = input.UnresolvedPure?.value ?? input.UnresolvedObject?.objectId
+      const schema = getPureBcsSchema(param.body)
+      if (schema) {
+        arg.type = 'pure'
+        inputs[inputs.indexOf(input)] = Inputs.Pure(schema.serialize(inputValue))
+        return
+      }
+
+      if (typeof inputValue !== 'string') {
+        throw new TypeError(
+          `Expect the argument to be an object id string, got ${JSON.stringify(
+            inputValue,
+            null,
+            2
+          )}`
+        )
+      }
+
+      arg.type = 'object'
+      const unresolvedObject = input.UnresolvedPure
+        ? {
+            $kind: 'UnresolvedObject',
+            UnresolvedObject: {
+              objectId: inputValue,
+            },
+          }
+        : input
+      inputs[arg.Input] = unresolvedObject
+    })
+  })
+}
+
+function isUsedAsMutable(transactionData, index) {
+  let usedAsMutable = false
+  transactionData.getInputUses(index, (arg, tx) => {
+    if (tx.MoveCall && tx.MoveCall._argumentTypes) {
+      const argIndex = tx.MoveCall.arguments.indexOf(arg)
+      usedAsMutable = tx.MoveCall._argumentTypes[argIndex].ref !== '&' || usedAsMutable
+    }
+
+    if (tx.$kind === 'MakeMoveVec' || tx.$kind === 'MergeCoins' || tx.$kind === 'SplitCoins') {
+      usedAsMutable = true
+    }
+  })
+  return usedAsMutable
+}
+
+function isUsedAsReceiving(transactionData, index) {
+  let usedAsReceiving = false
+  transactionData.getInputUses(index, (arg, tx) => {
+    if (tx.MoveCall && tx.MoveCall._argumentTypes) {
+      const argIndex = tx.MoveCall.arguments.indexOf(arg)
+      usedAsReceiving = isReceivingType(tx.MoveCall._argumentTypes[argIndex]) || usedAsReceiving
+    }
+  })
+  return usedAsReceiving
+}
+
+function isReceivingType(type) {
+  if (typeof type.body !== 'object' || !('datatype' in type.body)) {
+    return false
+  }
+
+  return (
+    type.body.datatype.package === '0x2' &&
+    type.body.datatype.module === 'transfer' &&
+    type.body.datatype.type === 'Receiving'
+  )
+}
+
+export { suiClientResolveTransactionPlugin }
+// # sourceMappingURL=json-rpc-resolver.js.map