@exodus/sui-api 1.0.0 → 1.0.2

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

@@ -4,25 +4,21 @@ import {
   array,
   bigint,
   boolean,
-  check,
   integer,
   is,
   lazy,
   literal,
   nullable,
-  nullish,
   number,
   object,
-  optional,
   parse,
   pipe,
   string,
   union,
-  unknown,
 } from '../../valibot.js'
 import { JsonU64, ObjectID, safeEnum, TransactionData } from './internal.js'
 
-const { fromBase64, toBase64 } = vendorLib.utils
+const { toBase64 } = vendorLib.utils
 const { TypeTagSerializer } = vendorLib.bcs
 
 const ObjectRef = object({
@@ -43,36 +39,6 @@ const NormalizedCallArg = safeEnum({
   Object: ObjectArg,
   Pure: array(pipe(number(), integer())),
 })
-const TransactionInput = union([
-  object({
-    kind: literal('Input'),
-    index: pipe(number(), integer()),
-    value: unknown(),
-    type: optional(literal('object')),
-  }),
-  object({
-    kind: literal('Input'),
-    index: pipe(number(), integer()),
-    value: unknown(),
-    type: literal('pure'),
-  }),
-])
-const TransactionExpiration = union([
-  object({ Epoch: pipe(number(), integer()) }),
-  object({ None: nullable(literal(true)) }),
-])
-const StringEncodedBigint = pipe(
-  union([number(), string(), bigint()]),
-  check((val) => {
-    if (!['string', 'number', 'bigint'].includes(typeof val)) return false
-    try {
-      BigInt(val)
-      return true
-    } catch {
-      return false
-    }
-  })
-)
 const TypeTag = union([
   object({ bool: nullable(literal(true)) }),
   object({ u8: nullable(literal(true)) }),
@@ -92,254 +58,6 @@ const StructTag = object({
   name: string(),
   typeParams: array(TypeTag),
 })
-const GasConfig = object({
-  budget: optional(StringEncodedBigint),
-  price: optional(StringEncodedBigint),
-  payment: optional(array(ObjectRef)),
-  owner: optional(string()),
-})
-const TransactionArgumentTypes = [
-  TransactionInput,
-  object({ kind: literal('GasCoin') }),
-  object({ kind: literal('Result'), index: pipe(number(), integer()) }),
-  object({
-    kind: literal('NestedResult'),
-    index: pipe(number(), integer()),
-    resultIndex: pipe(number(), integer()),
-  }),
-]
-const TransactionArgument = union([...TransactionArgumentTypes])
-const MoveCallTransaction = object({
-  kind: literal('MoveCall'),
-  target: pipe(
-    string(),
-    check((target) => target.split('::').length === 3)
-  ),
-  typeArguments: array(string()),
-  arguments: array(TransactionArgument),
-})
-const TransferObjectsTransaction = object({
-  kind: literal('TransferObjects'),
-  objects: array(TransactionArgument),
-  address: TransactionArgument,
-})
-const SplitCoinsTransaction = object({
-  kind: literal('SplitCoins'),
-  coin: TransactionArgument,
-  amounts: array(TransactionArgument),
-})
-const MergeCoinsTransaction = object({
-  kind: literal('MergeCoins'),
-  destination: TransactionArgument,
-  sources: array(TransactionArgument),
-})
-const MakeMoveVecTransaction = object({
-  kind: literal('MakeMoveVec'),
-  type: union([object({ Some: TypeTag }), object({ None: nullable(literal(true)) })]),
-  objects: array(TransactionArgument),
-})
-const PublishTransaction = object({
-  kind: literal('Publish'),
-  modules: array(array(pipe(number(), integer()))),
-  dependencies: array(string()),
-})
-const UpgradeTransaction = object({
-  kind: literal('Upgrade'),
-  modules: array(array(pipe(number(), integer()))),
-  dependencies: array(string()),
-  packageId: string(),
-  ticket: TransactionArgument,
-})
-const TransactionTypes = [
-  MoveCallTransaction,
-  TransferObjectsTransaction,
-  SplitCoinsTransaction,
-  MergeCoinsTransaction,
-  PublishTransaction,
-  UpgradeTransaction,
-  MakeMoveVecTransaction,
-]
-const TransactionType = union([...TransactionTypes])
-const SerializedTransactionDataV1 = object({
-  version: literal(1),
-  sender: optional(string()),
-  expiration: nullish(TransactionExpiration),
-  gasConfig: GasConfig,
-  inputs: array(TransactionInput),
-  transactions: array(TransactionType),
-})
-
-function serializeV1TransactionData(transactionData) {
-  const inputs = transactionData.inputs.map((input, index) => {
-    if (input.Object) {
-      return {
-        kind: 'Input',
-        index,
-        value: {
-          Object: input.Object.ImmOrOwnedObject
-            ? {
-                ImmOrOwned: input.Object.ImmOrOwnedObject,
-              }
-            : input.Object.Receiving
-              ? {
-                  Receiving: {
-                    digest: input.Object.Receiving.digest,
-                    version: input.Object.Receiving.version,
-                    objectId: input.Object.Receiving.objectId,
-                  },
-                }
-              : {
-                  Shared: {
-                    mutable: input.Object.SharedObject.mutable,
-                    initialSharedVersion: input.Object.SharedObject.initialSharedVersion,
-                    objectId: input.Object.SharedObject.objectId,
-                  },
-                },
-        },
-        type: 'object',
-      }
-    }
-
-    if (input.Pure) {
-      return {
-        kind: 'Input',
-        index,
-        value: {
-          Pure: [...fromBase64(input.Pure.bytes)],
-        },
-        type: 'pure',
-      }
-    }
-
-    if (input.UnresolvedPure) {
-      return {
-        kind: 'Input',
-        type: 'pure',
-        index,
-        value: input.UnresolvedPure.value,
-      }
-    }
-
-    if (input.UnresolvedObject) {
-      return {
-        kind: 'Input',
-        type: 'object',
-        index,
-        value: input.UnresolvedObject.objectId,
-      }
-    }
-
-    throw new Error('Invalid input')
-  })
-  return {
-    version: 1,
-    sender: transactionData.sender ?? void 0,
-    expiration:
-      transactionData.expiration?.$kind === 'Epoch'
-        ? { Epoch: Number(transactionData.expiration.Epoch) }
-        : transactionData.expiration
-          ? { None: true }
-          : null,
-    gasConfig: {
-      owner: transactionData.gasData.owner ?? void 0,
-      budget: transactionData.gasData.budget ?? void 0,
-      price: transactionData.gasData.price ?? void 0,
-      payment: transactionData.gasData.payment ?? void 0,
-    },
-    inputs,
-    transactions: transactionData.commands.map((command) => {
-      if (command.MakeMoveVec) {
-        return {
-          kind: 'MakeMoveVec',
-          type:
-            command.MakeMoveVec.type === null
-              ? { None: true }
-              : { Some: TypeTagSerializer.parseFromStr(command.MakeMoveVec.type) },
-          objects: command.MakeMoveVec.elements.map((arg) =>
-            convertTransactionArgument(arg, inputs)
-          ),
-        }
-      }
-
-      if (command.MergeCoins) {
-        return {
-          kind: 'MergeCoins',
-          destination: convertTransactionArgument(command.MergeCoins.destination, inputs),
-          sources: command.MergeCoins.sources.map((arg) => convertTransactionArgument(arg, inputs)),
-        }
-      }
-
-      if (command.MoveCall) {
-        return {
-          kind: 'MoveCall',
-          target: `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`,
-          typeArguments: command.MoveCall.typeArguments,
-          arguments: command.MoveCall.arguments.map((arg) =>
-            convertTransactionArgument(arg, inputs)
-          ),
-        }
-      }
-
-      if (command.Publish) {
-        return {
-          kind: 'Publish',
-          modules: command.Publish.modules.map((mod) => [...fromBase64(mod)]),
-          dependencies: command.Publish.dependencies,
-        }
-      }
-
-      if (command.SplitCoins) {
-        return {
-          kind: 'SplitCoins',
-          coin: convertTransactionArgument(command.SplitCoins.coin, inputs),
-          amounts: command.SplitCoins.amounts.map((arg) => convertTransactionArgument(arg, inputs)),
-        }
-      }
-
-      if (command.TransferObjects) {
-        return {
-          kind: 'TransferObjects',
-          objects: command.TransferObjects.objects.map((arg) =>
-            convertTransactionArgument(arg, inputs)
-          ),
-          address: convertTransactionArgument(command.TransferObjects.address, inputs),
-        }
-      }
-
-      if (command.Upgrade) {
-        return {
-          kind: 'Upgrade',
-          modules: command.Upgrade.modules.map((mod) => [...fromBase64(mod)]),
-          dependencies: command.Upgrade.dependencies,
-          packageId: command.Upgrade.package,
-          ticket: convertTransactionArgument(command.Upgrade.ticket, inputs),
-        }
-      }
-
-      throw new Error(`Unknown transaction ${Object.keys(command)}`)
-    }),
-  }
-}
-
-function convertTransactionArgument(arg, inputs) {
-  if (arg.$kind === 'GasCoin') {
-    return { kind: 'GasCoin' }
-  }
-
-  if (arg.$kind === 'Result') {
-    return { kind: 'Result', index: arg.Result }
-  }
-
-  if (arg.$kind === 'NestedResult') {
-    return { kind: 'NestedResult', index: arg.NestedResult[0], resultIndex: arg.NestedResult[1] }
-  }
-
-  if (arg.$kind === 'Input') {
-    return inputs[arg.Input]
-  }
-
-  throw new Error(`Invalid argument ${Object.keys(arg)}`)
-}
 
 function transactionDataFromV1(data) {
   return parse(TransactionData, {
@@ -525,14 +243,5 @@ function parseV1TransactionArgument(arg) {
   }
 }
 
-export {
-  NormalizedCallArg,
-  ObjectRef,
-  SerializedTransactionDataV1,
-  StructTag,
-  TransactionArgument,
-  TypeTag,
-  serializeV1TransactionData,
-  transactionDataFromV1,
-}
+export { transactionDataFromV1 }
 // # sourceMappingURL=v1.js.map

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

@@ -46,4 +46,4 @@ function getClient(options) {
   return options.client
 }
 
-export { getClient, namedPackagesPlugin }
+export { namedPackagesPlugin }

package/src/vendors/transactions/resolve.js

@@ -92,4 +92,4 @@ function normalizeRawArgument(arg, schema, transactionData) {
   transactionData.inputs[arg.Input] = Inputs.Pure(schema.serialize(input.UnresolvedPure.value))
 }
 
-export { getClient, needsTransactionResolution, resolveTransactionPlugin }
+export { needsTransactionResolution, resolveTransactionPlugin }

package/src/vendors/transactions/utils.js

@@ -1,40 +1,7 @@
 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)
@@ -59,9 +26,5 @@ function getIdFromCallArg(arg) {
   return void 0
 }
 
-function isArgument(value) {
-  return is(Argument, value)
-}
-
-export { extractMutableReference, extractReference, extractStructTag, getIdFromCallArg, isArgument }
+export { getIdFromCallArg }
 // # sourceMappingURL=utils.js.map