@exodus/sui-api 0.1.0

package/src/vendors/transactions/plugins/NamedPackagesPlugin.js

@@ -0,0 +1,49 @@
+import { ClientCache } from '../../experimental/cache.js'
+import { findNamesInTransaction, MvrClient, replaceNames } from '../../experimental/mvr.js'
+
+const cacheMap = /* @__PURE__ */ new WeakMap()
+const namedPackagesPlugin = (options) => {
+  let mvrClient
+  if (options) {
+    const overrides = options.overrides ?? {
+      packages: Object.create(null),
+      types: Object.create(null),
+    }
+    if (!cacheMap.has(overrides)) {
+      cacheMap.set(overrides, new ClientCache())
+    }
+
+    mvrClient = new MvrClient({
+      cache: cacheMap.get(overrides),
+      url: options.url,
+      pageSize: options.pageSize,
+      overrides,
+    })
+  }
+
+  return async (transactionData, buildOptions, next) => {
+    const names = findNamesInTransaction(transactionData)
+    if (names.types.length === 0 && names.packages.length === 0) {
+      return next()
+    }
+
+    const resolved = await (mvrClient || getClient(buildOptions).core.mvr).resolve({
+      types: names.types,
+      packages: names.packages,
+    })
+    replaceNames(transactionData, resolved)
+    await next()
+  }
+}
+
+function getClient(options) {
+  if (!options.client) {
+    throw new Error(
+      `No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`
+    )
+  }
+
+  return options.client
+}
+
+export { getClient, namedPackagesPlugin }

package/src/vendors/transactions/pure.js

@@ -0,0 +1,40 @@
+import { vendorLib } from '@exodus/sui-lib'
+
+const { bcs } = vendorLib
+const { pureBcsSchemaFromTypeName } = vendorLib.bcs
+
+function createPure(makePure) {
+  function pure(typeOrSerializedValue, value) {
+    if (typeof typeOrSerializedValue === 'string') {
+      return makePure(pureBcsSchemaFromTypeName(typeOrSerializedValue).serialize(value))
+    }
+
+    if (typeOrSerializedValue instanceof Uint8Array || bcs.isSerializedBcs(typeOrSerializedValue)) {
+      return makePure(typeOrSerializedValue)
+    }
+
+    throw new Error('tx.pure must be called either a bcs type name, or a serialized bcs value')
+  }
+
+  pure.u8 = (value) => makePure(bcs.U8.serialize(value))
+  pure.u16 = (value) => makePure(bcs.U16.serialize(value))
+  pure.u32 = (value) => makePure(bcs.U32.serialize(value))
+  pure.u64 = (value) => makePure(bcs.U64.serialize(value))
+  pure.u128 = (value) => makePure(bcs.U128.serialize(value))
+  pure.u256 = (value) => makePure(bcs.U256.serialize(value))
+  pure.bool = (value) => makePure(bcs.Bool.serialize(value))
+  pure.string = (value) => makePure(bcs.String.serialize(value))
+  pure.address = (value) => makePure(bcs.Address.serialize(value))
+  pure.id = pure.address
+  pure.vector = (type, value) => {
+    return makePure(bcs.vector(pureBcsSchemaFromTypeName(type)).serialize(value))
+  }
+
+  pure.option = (type, value) => {
+    return makePure(bcs.option(pureBcsSchemaFromTypeName(type)).serialize(value))
+  }
+
+  return pure
+}
+
+export { createPure }

package/src/vendors/transactions/resolve.js

@@ -0,0 +1,95 @@
+import { vendorLib } from '@exodus/sui-lib'
+
+import { suiClientResolveTransactionPlugin } from '../experimental/transports/json-rpc-resolver.js'
+import { Inputs } from './Inputs.js'
+
+const { bcs } = vendorLib
+
+function needsTransactionResolution(data, options) {
+  if (
+    data.inputs.some((input) => {
+      return input.UnresolvedObject || input.UnresolvedPure
+    })
+  ) {
+    return true
+  }
+
+  // eslint-disable-next-line sonarjs/prefer-single-boolean-return
+  if (
+    !options.onlyTransactionKind &&
+    (!data.gasConfig.price || !data.gasConfig.budget || !data.gasConfig.payment)
+  ) {
+    return true
+  }
+
+  return false
+}
+
+async function resolveTransactionPlugin(transactionData, options, next) {
+  normalizeRawArguments(transactionData)
+  if (!needsTransactionResolution(transactionData, options)) {
+    await validate(transactionData)
+    return next()
+  }
+
+  const client = getClient(options)
+  const plugin =
+    client.core?.resolveTransactionPlugin() ?? suiClientResolveTransactionPlugin(client)
+  return plugin(transactionData, options, async () => {
+    await validate(transactionData)
+    await next()
+  })
+}
+
+function validate(transactionData) {
+  transactionData.inputs.forEach((input, index) => {
+    if (input.$kind !== 'Object' && input.$kind !== 'Pure') {
+      throw new Error(
+        `Input at index ${index} has not been resolved.  Expected a Pure or Object input, but found ${JSON.stringify(
+          input
+        )}`
+      )
+    }
+  })
+}
+
+function getClient(options) {
+  if (!options.client) {
+    throw new Error(
+      `No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`
+    )
+  }
+
+  return options.client
+}
+
+function normalizeRawArguments(transactionData) {
+  for (const command of transactionData.commands) {
+    switch (command.$kind) {
+      case 'SplitCoins':
+        command.SplitCoins.amounts.forEach((amount) => {
+          normalizeRawArgument(amount, bcs.U64, transactionData)
+        })
+        break
+      case 'TransferObjects':
+        normalizeRawArgument(command.TransferObjects.address, bcs.Address, transactionData)
+        break
+    }
+  }
+}
+
+function normalizeRawArgument(arg, schema, transactionData) {
+  if (arg.$kind !== 'Input') {
+    return
+  }
+
+  const input = transactionData.inputs[arg.Input]
+  if (input.$kind !== 'UnresolvedPure') {
+    return
+  }
+
+  // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+  transactionData.inputs[arg.Input] = Inputs.Pure(schema.serialize(input.UnresolvedPure.value))
+}
+
+export { getClient, needsTransactionResolution, resolveTransactionPlugin }

package/src/vendors/transactions/serializer.js

@@ -0,0 +1,203 @@
+import { vendorLib } from '@exodus/sui-lib'
+
+const { bcs } = vendorLib
+const { MOVE_STDLIB_ADDRESS, SUI_FRAMEWORK_ADDRESS, normalizeSuiAddress } = vendorLib.utils
+
+const OBJECT_MODULE_NAME = 'object'
+const ID_STRUCT_NAME = 'ID'
+const STD_ASCII_MODULE_NAME = 'ascii'
+const STD_ASCII_STRUCT_NAME = 'String'
+const STD_UTF8_MODULE_NAME = 'string'
+const STD_UTF8_STRUCT_NAME = 'String'
+const STD_OPTION_MODULE_NAME = 'option'
+const STD_OPTION_STRUCT_NAME = 'Option'
+
+function isTxContext(param) {
+  const struct =
+    typeof param.body === 'object' && 'datatype' in param.body ? param.body.datatype : null
+  return (
+    !!struct &&
+    normalizeSuiAddress(struct.package) === normalizeSuiAddress('0x2') &&
+    struct.module === 'tx_context' &&
+    struct.type === 'TxContext'
+  )
+}
+
+function getPureBcsSchema(typeSignature) {
+  if (typeof typeSignature === 'string') {
+    switch (typeSignature) {
+      case 'address':
+        return bcs.Address
+      case 'bool':
+        return bcs.Bool
+      case 'u8':
+        return bcs.U8
+      case 'u16':
+        return bcs.U16
+      case 'u32':
+        return bcs.U32
+      case 'u64':
+        return bcs.U64
+      case 'u128':
+        return bcs.U128
+      case 'u256':
+        return bcs.U256
+      default:
+        throw new Error(`Unknown type signature ${typeSignature}`)
+    }
+  }
+
+  if ('vector' in typeSignature) {
+    if (typeSignature.vector === 'u8') {
+      return bcs.vector(bcs.U8).transform({
+        input: (val) => (typeof val === 'string' ? new TextEncoder().encode(val) : val),
+        output: (val) => val,
+      })
+    }
+
+    const type = getPureBcsSchema(typeSignature.vector)
+    return type ? bcs.vector(type) : null
+  }
+
+  if ('datatype' in typeSignature) {
+    const pkg = normalizeSuiAddress(typeSignature.datatype.package)
+    if (pkg === normalizeSuiAddress(MOVE_STDLIB_ADDRESS)) {
+      if (
+        typeSignature.datatype.module === STD_ASCII_MODULE_NAME &&
+        typeSignature.datatype.type === STD_ASCII_STRUCT_NAME
+      ) {
+        return bcs.String
+      }
+
+      if (
+        typeSignature.datatype.module === STD_UTF8_MODULE_NAME &&
+        typeSignature.datatype.type === STD_UTF8_STRUCT_NAME
+      ) {
+        return bcs.String
+      }
+
+      if (
+        typeSignature.datatype.module === STD_OPTION_MODULE_NAME &&
+        typeSignature.datatype.type === STD_OPTION_STRUCT_NAME
+      ) {
+        const type = getPureBcsSchema(typeSignature.datatype.typeParameters[0])
+        return type ? bcs.vector(type) : null
+      }
+    }
+
+    if (
+      pkg === normalizeSuiAddress(SUI_FRAMEWORK_ADDRESS) &&
+      typeSignature.datatype.module === OBJECT_MODULE_NAME &&
+      typeSignature.datatype.type === ID_STRUCT_NAME
+    ) {
+      return bcs.Address
+    }
+  }
+
+  return null
+}
+
+function normalizedTypeToMoveTypeSignature(type) {
+  if (typeof type === 'object' && 'Reference' in type) {
+    return {
+      ref: '&',
+      body: normalizedTypeToMoveTypeSignatureBody(type.Reference),
+    }
+  }
+
+  if (typeof type === 'object' && 'MutableReference' in type) {
+    return {
+      ref: '&mut',
+      body: normalizedTypeToMoveTypeSignatureBody(type.MutableReference),
+    }
+  }
+
+  return {
+    ref: null,
+    body: normalizedTypeToMoveTypeSignatureBody(type),
+  }
+}
+
+function normalizedTypeToMoveTypeSignatureBody(type) {
+  if (typeof type === 'string') {
+    switch (type) {
+      case 'Address':
+        return 'address'
+      case 'Bool':
+        return 'bool'
+      case 'U8':
+        return 'u8'
+      case 'U16':
+        return 'u16'
+      case 'U32':
+        return 'u32'
+      case 'U64':
+        return 'u64'
+      case 'U128':
+        return 'u128'
+      case 'U256':
+        return 'u256'
+      default:
+        throw new Error(`Unexpected type ${type}`)
+    }
+  }
+
+  if ('Vector' in type) {
+    return { vector: normalizedTypeToMoveTypeSignatureBody(type.Vector) }
+  }
+
+  if ('Struct' in type) {
+    return {
+      datatype: {
+        package: type.Struct.address,
+        module: type.Struct.module,
+        type: type.Struct.name,
+        typeParameters: type.Struct.typeArguments.map(normalizedTypeToMoveTypeSignatureBody),
+      },
+    }
+  }
+
+  if ('TypeParameter' in type) {
+    return { typeParameter: type.TypeParameter }
+  }
+
+  throw new Error(`Unexpected type ${JSON.stringify(type)}`)
+}
+
+function pureBcsSchemaFromOpenMoveTypeSignatureBody(typeSignature) {
+  if (typeof typeSignature === 'string') {
+    switch (typeSignature) {
+      case 'address':
+        return bcs.Address
+      case 'bool':
+        return bcs.Bool
+      case 'u8':
+        return bcs.U8
+      case 'u16':
+        return bcs.U16
+      case 'u32':
+        return bcs.U32
+      case 'u64':
+        return bcs.U64
+      case 'u128':
+        return bcs.U128
+      case 'u256':
+        return bcs.U256
+      default:
+        throw new Error(`Unknown type signature ${typeSignature}`)
+    }
+  }
+
+  if ('vector' in typeSignature) {
+    return bcs.vector(pureBcsSchemaFromOpenMoveTypeSignatureBody(typeSignature.vector))
+  }
+
+  throw new Error(`Expected pure typeSignature, but got ${JSON.stringify(typeSignature)}`)
+}
+
+export {
+  getPureBcsSchema,
+  isTxContext,
+  normalizedTypeToMoveTypeSignature,
+  pureBcsSchemaFromOpenMoveTypeSignatureBody,
+}

package/src/vendors/transactions/utils.js

@@ -0,0 +1,67 @@
+import { vendorLib } from '@exodus/sui-lib'
+
+import { is } from '../valibot.js'
+import { Argument } from './data/internal.js'
+
+const { normalizeSuiAddress } = vendorLib.utils
+
+function extractMutableReference(normalizedType) {
+  return typeof normalizedType === 'object' && 'MutableReference' in normalizedType
+    ? normalizedType.MutableReference
+    : void 0
+}
+
+function extractReference(normalizedType) {
+  return typeof normalizedType === 'object' && 'Reference' in normalizedType
+    ? normalizedType.Reference
+    : void 0
+}
+
+function extractStructTag(normalizedType) {
+  if (typeof normalizedType === 'object' && 'Struct' in normalizedType) {
+    return normalizedType
+  }
+
+  const ref = extractReference(normalizedType)
+  const mutRef = extractMutableReference(normalizedType)
+  if (typeof ref === 'object' && 'Struct' in ref) {
+    return ref
+  }
+
+  if (typeof mutRef === 'object' && 'Struct' in mutRef) {
+    return mutRef
+  }
+
+  return void 0
+}
+
+function getIdFromCallArg(arg) {
+  if (typeof arg === 'string') {
+    return normalizeSuiAddress(arg)
+  }
+
+  if (arg.Object) {
+    if (arg.Object.ImmOrOwnedObject) {
+      return normalizeSuiAddress(arg.Object.ImmOrOwnedObject.objectId)
+    }
+
+    if (arg.Object.Receiving) {
+      return normalizeSuiAddress(arg.Object.Receiving.objectId)
+    }
+
+    return normalizeSuiAddress(arg.Object.SharedObject.objectId)
+  }
+
+  if (arg.UnresolvedObject) {
+    return normalizeSuiAddress(arg.UnresolvedObject.objectId)
+  }
+
+  return void 0
+}
+
+function isArgument(value) {
+  return is(Argument, value)
+}
+
+export { extractMutableReference, extractReference, extractStructTag, getIdFromCallArg, isArgument }
+// # sourceMappingURL=utils.js.map