@exodus/sui-api 0.1.0

package/src/vendors/transactions/TransactionData.js

@@ -0,0 +1,293 @@
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+import { vendorLib } from '@exodus/sui-lib'
+
+import { parse } from '../valibot.js'
+import { TransactionData } from './data/internal.js'
+import { transactionDataFromV1 } from './data/v1.js'
+import { hashTypedData } from './hash.js'
+
+const { bcs } = vendorLib
+
+const { toBase58, normalizeSuiAddress } = vendorLib.utils
+
+function prepareSuiAddress(address) {
+  return normalizeSuiAddress(address).replace('0x', '')
+}
+
+class TransactionDataBuilder {
+  constructor(clone) {
+    this.version = 2
+    this.sender = clone?.sender ?? null
+    this.expiration = clone?.expiration ?? null
+    this.inputs = clone?.inputs ?? []
+    this.commands = clone?.commands ?? []
+    this.gasData = clone?.gasData ?? {
+      budget: null,
+      price: null,
+      owner: null,
+      payment: null,
+    }
+  }
+
+  static fromKindBytes(bytes) {
+    const kind = bcs.TransactionKind.parse(bytes)
+    const programmableTx = kind.ProgrammableTransaction
+    if (!programmableTx) {
+      throw new Error('Unable to deserialize from bytes.')
+    }
+
+    return TransactionDataBuilder.restore({
+      version: 2,
+      sender: null,
+      expiration: null,
+      gasData: {
+        budget: null,
+        owner: null,
+        payment: null,
+        price: null,
+      },
+      inputs: programmableTx.inputs,
+      commands: programmableTx.commands,
+    })
+  }
+
+  static fromBytes(bytes) {
+    const rawData = bcs.TransactionData.parse(bytes)
+    const data = rawData?.V1
+    const programmableTx = data.kind.ProgrammableTransaction
+    if (!data || !programmableTx) {
+      throw new Error('Unable to deserialize from bytes.')
+    }
+
+    return TransactionDataBuilder.restore({
+      version: 2,
+      sender: data.sender,
+      expiration: data.expiration,
+      gasData: data.gasData,
+      inputs: programmableTx.inputs,
+      commands: programmableTx.commands,
+    })
+  }
+
+  static restore(data) {
+    if (data.version === 2) {
+      return new TransactionDataBuilder(parse(TransactionData, data))
+    }
+
+    return new TransactionDataBuilder(parse(TransactionData, transactionDataFromV1(data)))
+  }
+
+  /**
+   * Generate transaction digest.
+   *
+   * @param bytes BCS serialized transaction data
+   * @returns transaction digest.
+   */
+  static getDigestFromBytes(bytes) {
+    const hash = hashTypedData('TransactionData', bytes)
+    return toBase58(hash)
+  }
+
+  // @deprecated use gasData instead
+  get gasConfig() {
+    return this.gasData
+  }
+
+  // @deprecated use gasData instead
+  set gasConfig(value) {
+    this.gasData = value
+  }
+
+  build({ maxSizeBytes = Infinity, overrides, onlyTransactionKind } = Object.create(null)) {
+    const inputs = this.inputs
+    const commands = this.commands
+    const kind = {
+      ProgrammableTransaction: {
+        inputs,
+        commands,
+      },
+    }
+    if (onlyTransactionKind) {
+      return bcs.TransactionKind.serialize(kind, { maxSize: maxSizeBytes }).toBytes()
+    }
+
+    const expiration = overrides?.expiration ?? this.expiration
+    const sender = overrides?.sender ?? this.sender
+    const gasData = { ...this.gasData, ...overrides?.gasConfig, ...overrides?.gasData }
+    if (!sender) {
+      throw new Error('Missing transaction sender')
+    }
+
+    if (!gasData.budget) {
+      throw new Error('Missing gas budget')
+    }
+
+    if (!gasData.payment) {
+      throw new Error('Missing gas payment')
+    }
+
+    if (!gasData.price) {
+      throw new Error('Missing gas price')
+    }
+
+    const transactionData = {
+      sender: prepareSuiAddress(sender),
+      expiration: expiration || { None: true },
+      gasData: {
+        payment: gasData.payment,
+        owner: prepareSuiAddress(this.gasData.owner ?? sender),
+        price: BigInt(gasData.price),
+        budget: BigInt(gasData.budget),
+      },
+      kind: {
+        ProgrammableTransaction: {
+          inputs,
+          commands,
+        },
+      },
+    }
+    return bcs.TransactionData.serialize(
+      { V1: transactionData },
+      { maxSize: maxSizeBytes }
+    ).toBytes()
+  }
+
+  addInput(type, arg) {
+    const index = this.inputs.length
+    this.inputs.push(arg)
+    return { Input: index, type, $kind: 'Input' }
+  }
+
+  getInputUses(index, fn) {
+    this.mapArguments((arg, command) => {
+      if (arg.$kind === 'Input' && arg.Input === index) {
+        fn(arg, command)
+      }
+
+      return arg
+    })
+  }
+
+  mapCommandArguments(index, fn) {
+    const command = this.commands[index]
+    switch (command.$kind) {
+      case 'MoveCall':
+        command.MoveCall.arguments = command.MoveCall.arguments.map((arg) =>
+          fn(arg, command, index)
+        )
+        break
+      case 'TransferObjects':
+        command.TransferObjects.objects = command.TransferObjects.objects.map((arg) =>
+          fn(arg, command, index)
+        )
+        command.TransferObjects.address = fn(command.TransferObjects.address, command, index)
+        break
+      case 'SplitCoins':
+        command.SplitCoins.coin = fn(command.SplitCoins.coin, command, index)
+        command.SplitCoins.amounts = command.SplitCoins.amounts.map((arg) =>
+          fn(arg, command, index)
+        )
+        break
+      case 'MergeCoins':
+        command.MergeCoins.destination = fn(command.MergeCoins.destination, command, index)
+        command.MergeCoins.sources = command.MergeCoins.sources.map((arg) =>
+          fn(arg, command, index)
+        )
+        break
+      case 'MakeMoveVec':
+        command.MakeMoveVec.elements = command.MakeMoveVec.elements.map((arg) =>
+          fn(arg, command, index)
+        )
+        break
+      case 'Upgrade':
+        command.Upgrade.ticket = fn(command.Upgrade.ticket, command, index)
+        break
+      case '$Intent':
+        const inputs = command.$Intent.inputs
+        command.$Intent.inputs = Object.create(null)
+        for (const [key, value] of Object.entries(inputs)) {
+          command.$Intent.inputs[key] = Array.isArray(value)
+            ? value.map((arg) => fn(arg, command, index))
+            : fn(value, command, index)
+        }
+
+        break
+      case 'Publish':
+        break
+      default:
+        throw new Error(`Unexpected transaction kind: ${command.$kind}`)
+    }
+  }
+
+  mapArguments(fn) {
+    for (const commandIndex of this.commands.keys()) {
+      this.mapCommandArguments(commandIndex, fn)
+    }
+  }
+
+  replaceCommand(index, replacement, resultIndex = index) {
+    if (!Array.isArray(replacement)) {
+      this.commands[index] = replacement
+      return
+    }
+
+    const sizeDiff = replacement.length - 1
+    this.commands.splice(index, 1, ...replacement)
+    if (sizeDiff !== 0) {
+      this.mapArguments((arg, _command, commandIndex) => {
+        if (commandIndex < index + replacement.length) {
+          return arg
+        }
+
+        switch (arg.$kind) {
+          case 'Result':
+            if (arg.Result === index) {
+              arg.Result = resultIndex
+            }
+
+            if (arg.Result > index) {
+              arg.Result += sizeDiff
+            }
+
+            break
+          case 'NestedResult':
+            if (arg.NestedResult[0] === index) {
+              arg.NestedResult[0] = resultIndex
+            }
+
+            if (arg.NestedResult[0] > index) {
+              arg.NestedResult[0] += sizeDiff
+            }
+
+            break
+        }
+
+        return arg
+      })
+    }
+  }
+
+  getDigest() {
+    const bytes = this.build({ onlyTransactionKind: false })
+    return TransactionDataBuilder.getDigestFromBytes(bytes)
+  }
+
+  snapshot() {
+    return parse(TransactionData, this)
+  }
+
+  shallowClone() {
+    return new TransactionDataBuilder({
+      version: this.version,
+      sender: this.sender,
+      expiration: this.expiration,
+      gasData: {
+        ...this.gasData,
+      },
+      inputs: [...this.inputs],
+      commands: [...this.commands],
+    })
+  }
+}
+export { TransactionDataBuilder }
+// # sourceMappingURL=TransactionData.js.map

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

@@ -0,0 +1,218 @@
+import { vendorLib } from '@exodus/sui-lib'
+
+import {
+  array,
+  boolean,
+  check,
+  integer,
+  lazy,
+  literal,
+  nullable,
+  nullish,
+  number,
+  object,
+  optional,
+  pipe,
+  record,
+  string,
+  transform,
+  tuple,
+  union,
+  unknown,
+} from '../../valibot.js'
+
+const { isValidSuiAddress, normalizeSuiAddress } = vendorLib.utils
+
+function safeEnum(options) {
+  const unionOptions = Object.entries(options).map(([key, value]) => object({ [key]: value }))
+  return pipe(
+    union(unionOptions),
+    transform((value) => ({
+      ...value,
+      $kind: Object.keys(value)[0],
+    }))
+  )
+}
+
+const SuiAddress = pipe(
+  string(),
+  transform((value) => normalizeSuiAddress(value)),
+  check(isValidSuiAddress)
+)
+const ObjectID = SuiAddress
+const BCSBytes = string()
+const JsonU64 = pipe(
+  union([string(), pipe(number(), integer())]),
+  check((val) => {
+    try {
+      BigInt(val)
+      return BigInt(val) >= 0 && BigInt(val) <= BigInt(18_446_744_073_709_551_615)
+    } catch {
+      return false
+    }
+  }, 'Invalid u64')
+)
+const ObjectRef = object({
+  objectId: SuiAddress,
+  version: JsonU64,
+  digest: string(),
+})
+const Argument = pipe(
+  union([
+    object({ GasCoin: literal(true) }),
+    object({ Input: pipe(number(), integer()), type: optional(literal('pure')) }),
+    object({ Input: pipe(number(), integer()), type: optional(literal('object')) }),
+    object({ Result: pipe(number(), integer()) }),
+    object({ NestedResult: tuple([pipe(number(), integer()), pipe(number(), integer())]) }),
+  ]),
+  transform((value) => ({
+    ...value,
+    $kind: Object.keys(value)[0],
+  }))
+  // Defined manually to add `type?: 'pure' | 'object'` to Input
+)
+const GasData = object({
+  budget: nullable(JsonU64),
+  price: nullable(JsonU64),
+  owner: nullable(SuiAddress),
+  payment: nullable(array(ObjectRef)),
+})
+const StructTag = object({
+  address: string(),
+  module: string(),
+  name: string(),
+  // type_params in rust, should be updated to use camelCase
+  typeParams: array(string()),
+})
+const OpenMoveTypeSignatureBody = union([
+  literal('address'),
+  literal('bool'),
+  literal('u8'),
+  literal('u16'),
+  literal('u32'),
+  literal('u64'),
+  literal('u128'),
+  literal('u256'),
+  object({ vector: lazy(() => OpenMoveTypeSignatureBody) }),
+  object({
+    datatype: object({
+      package: string(),
+      module: string(),
+      type: string(),
+      typeParameters: array(lazy(() => OpenMoveTypeSignatureBody)),
+    }),
+  }),
+  object({ typeParameter: pipe(number(), integer()) }),
+])
+const OpenMoveTypeSignature = object({
+  ref: nullable(union([literal('&'), literal('&mut')])),
+  body: OpenMoveTypeSignatureBody,
+})
+const ProgrammableMoveCall = object({
+  package: ObjectID,
+  module: string(),
+  function: string(),
+  // snake case in rust
+  typeArguments: array(string()),
+  arguments: array(Argument),
+  _argumentTypes: optional(nullable(array(OpenMoveTypeSignature))),
+})
+const $Intent = object({
+  name: string(),
+  inputs: record(string(), union([Argument, array(Argument)])),
+  data: record(string(), unknown()),
+})
+const Command = safeEnum({
+  MoveCall: ProgrammableMoveCall,
+  TransferObjects: object({
+    objects: array(Argument),
+    address: Argument,
+  }),
+  SplitCoins: object({
+    coin: Argument,
+    amounts: array(Argument),
+  }),
+  MergeCoins: object({
+    destination: Argument,
+    sources: array(Argument),
+  }),
+  Publish: object({
+    modules: array(BCSBytes),
+    dependencies: array(ObjectID),
+  }),
+  MakeMoveVec: object({
+    type: nullable(string()),
+    elements: array(Argument),
+  }),
+  Upgrade: object({
+    modules: array(BCSBytes),
+    dependencies: array(ObjectID),
+    package: ObjectID,
+    ticket: Argument,
+  }),
+  $Intent,
+})
+const ObjectArg = safeEnum({
+  ImmOrOwnedObject: ObjectRef,
+  SharedObject: object({
+    objectId: ObjectID,
+    // snake case in rust
+    initialSharedVersion: JsonU64,
+    mutable: boolean(),
+  }),
+  Receiving: ObjectRef,
+})
+const CallArg = safeEnum({
+  Object: ObjectArg,
+  Pure: object({
+    bytes: BCSBytes,
+  }),
+  UnresolvedPure: object({
+    value: unknown(),
+  }),
+  UnresolvedObject: object({
+    objectId: ObjectID,
+    version: optional(nullable(JsonU64)),
+    digest: optional(nullable(string())),
+    initialSharedVersion: optional(nullable(JsonU64)),
+  }),
+})
+const NormalizedCallArg = safeEnum({
+  Object: ObjectArg,
+  Pure: object({
+    bytes: BCSBytes,
+  }),
+})
+const TransactionExpiration = safeEnum({
+  None: literal(true),
+  Epoch: JsonU64,
+})
+const TransactionData = object({
+  version: literal(2),
+  sender: nullish(SuiAddress),
+  expiration: nullish(TransactionExpiration),
+  gasData: GasData,
+  inputs: array(CallArg),
+  commands: array(Command),
+})
+
+export {
+  $Intent,
+  Argument,
+  BCSBytes,
+  Command,
+  GasData,
+  JsonU64,
+  NormalizedCallArg,
+  ObjectArg,
+  ObjectID,
+  ObjectRef,
+  OpenMoveTypeSignature,
+  OpenMoveTypeSignatureBody,
+  StructTag,
+  SuiAddress,
+  TransactionData,
+  TransactionExpiration,
+  safeEnum,
+}
+// # sourceMappingURL=internal.js.map