wowok 2.1.10 → 2.1.13

package/dist/cjs/transactions/data/v1.js

@@ -1,538 +1,479 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var v1_exports = {};
-__export(v1_exports, {
-  NormalizedCallArg: () => NormalizedCallArg,
-  ObjectRef: () => ObjectRef,
-  SerializedTransactionDataV1: () => SerializedTransactionDataV1,
-  StructTag: () => StructTag,
-  TransactionArgument: () => TransactionArgument,
-  TypeTag: () => TypeTag,
-  serializeV1TransactionData: () => serializeV1TransactionData,
-  transactionDataFromV1: () => transactionDataFromV1
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedTransactionDataV1 = exports.TransactionArgument = exports.StructTag = exports.TypeTag = exports.NormalizedCallArg = exports.ObjectRef = void 0;
+exports.serializeV1TransactionData = serializeV1TransactionData;
+exports.transactionDataFromV1 = transactionDataFromV1;
+const bcs_1 = require("@mysten/bcs");
+const valibot_1 = require("valibot");
+const index_js_1 = require("../../bcs/index.js");
+const internal_js_1 = require("./internal.js");
+exports.ObjectRef = (0, valibot_1.object)({
+    digest: (0, valibot_1.string)(),
+    objectId: (0, valibot_1.string)(),
+    version: (0, valibot_1.union)([(0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()), (0, valibot_1.string)(), (0, valibot_1.bigint)()]),
 });
-module.exports = __toCommonJS(v1_exports);
-var import_bcs = require("@mysten/bcs");
-var import_valibot = require("valibot");
-var import_bcs2 = require("../../bcs/index.js");
-var import_internal = require("./internal.js");
-const ObjectRef = (0, import_valibot.object)({
-  digest: (0, import_valibot.string)(),
-  objectId: (0, import_valibot.string)(),
-  version: (0, import_valibot.union)([(0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()), (0, import_valibot.string)(), (0, import_valibot.bigint)()])
-});
-const ObjectArg = (0, import_internal.safeEnum)({
-  ImmOrOwned: ObjectRef,
-  Shared: (0, import_valibot.object)({
-    objectId: import_internal.ObjectID,
-    initialSharedVersion: import_internal.JsonU64,
-    mutable: (0, import_valibot.boolean)()
-  }),
-  Receiving: ObjectRef
+const ObjectArg = (0, internal_js_1.safeEnum)({
+    ImmOrOwned: exports.ObjectRef,
+    Shared: (0, valibot_1.object)({
+        objectId: internal_js_1.ObjectID,
+        initialSharedVersion: internal_js_1.JsonU64,
+        mutable: (0, valibot_1.boolean)(),
+    }),
+    Receiving: exports.ObjectRef,
 });
-const NormalizedCallArg = (0, import_internal.safeEnum)({
-  Object: ObjectArg,
-  Pure: (0, import_valibot.array)((0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()))
+exports.NormalizedCallArg = (0, internal_js_1.safeEnum)({
+    Object: ObjectArg,
+    Pure: (0, valibot_1.array)((0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)())),
 });
-const TransactionInput = (0, import_valibot.union)([
-  (0, import_valibot.object)({
-    kind: (0, import_valibot.literal)("Input"),
-    index: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()),
-    value: (0, import_valibot.unknown)(),
-    type: (0, import_valibot.optional)((0, import_valibot.literal)("object"))
-  }),
-  (0, import_valibot.object)({
-    kind: (0, import_valibot.literal)("Input"),
-    index: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()),
-    value: (0, import_valibot.unknown)(),
-    type: (0, import_valibot.literal)("pure")
-  })
+const TransactionInput = (0, valibot_1.union)([
+    (0, valibot_1.object)({
+        kind: (0, valibot_1.literal)("Input"),
+        index: (0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()),
+        value: (0, valibot_1.unknown)(),
+        type: (0, valibot_1.optional)((0, valibot_1.literal)("object")),
+    }),
+    (0, valibot_1.object)({
+        kind: (0, valibot_1.literal)("Input"),
+        index: (0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()),
+        value: (0, valibot_1.unknown)(),
+        type: (0, valibot_1.literal)("pure"),
+    }),
 ]);
-const TransactionExpiration = (0, import_valibot.union)([
-  (0, import_valibot.object)({ Epoch: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()) }),
-  (0, import_valibot.object)({ None: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) })
+const TransactionExpiration = (0, valibot_1.union)([
+    (0, valibot_1.object)({ Epoch: (0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()) }),
+    (0, valibot_1.object)({ None: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
 ]);
-const StringEncodedBigint = (0, import_valibot.pipe)(
-  (0, import_valibot.union)([(0, import_valibot.number)(), (0, import_valibot.string)(), (0, import_valibot.bigint)()]),
-  (0, import_valibot.check)((val) => {
-    if (!["string", "number", "bigint"].includes(typeof val)) return false;
+const StringEncodedBigint = (0, valibot_1.pipe)((0, valibot_1.union)([(0, valibot_1.number)(), (0, valibot_1.string)(), (0, valibot_1.bigint)()]), (0, valibot_1.check)((val) => {
+    if (!["string", "number", "bigint"].includes(typeof val))
+        return false;
     try {
-      BigInt(val);
-      return true;
-    } catch {
-      return false;
+        BigInt(val);
+        return true;
     }
-  })
-);
-const TypeTag = (0, import_valibot.union)([
-  (0, import_valibot.object)({ bool: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) }),
-  (0, import_valibot.object)({ u8: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) }),
-  (0, import_valibot.object)({ u64: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) }),
-  (0, import_valibot.object)({ u128: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) }),
-  (0, import_valibot.object)({ address: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) }),
-  (0, import_valibot.object)({ signer: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) }),
-  (0, import_valibot.object)({ vector: (0, import_valibot.lazy)(() => TypeTag) }),
-  (0, import_valibot.object)({ struct: (0, import_valibot.lazy)(() => StructTag) }),
-  (0, import_valibot.object)({ u16: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) }),
-  (0, import_valibot.object)({ u32: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) }),
-  (0, import_valibot.object)({ u256: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) })
+    catch {
+        return false;
+    }
+}));
+exports.TypeTag = (0, valibot_1.union)([
+    (0, valibot_1.object)({ bool: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    (0, valibot_1.object)({ u8: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    (0, valibot_1.object)({ u64: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    (0, valibot_1.object)({ u128: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    (0, valibot_1.object)({ address: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    (0, valibot_1.object)({ signer: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    (0, valibot_1.object)({ vector: (0, valibot_1.lazy)(() => exports.TypeTag) }),
+    (0, valibot_1.object)({ struct: (0, valibot_1.lazy)(() => exports.StructTag) }),
+    (0, valibot_1.object)({ u16: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    (0, valibot_1.object)({ u32: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    (0, valibot_1.object)({ u256: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
 ]);
-const StructTag = (0, import_valibot.object)({
-  address: (0, import_valibot.string)(),
-  module: (0, import_valibot.string)(),
-  name: (0, import_valibot.string)(),
-  typeParams: (0, import_valibot.array)(TypeTag)
+// https://github.com/MystenLabs/sui/blob/cea8742e810142a8145fd83c4c142d61e561004a/external-crates/move/crates/move-core-types/src/language_storage.rs#L140-L147
+exports.StructTag = (0, valibot_1.object)({
+    address: (0, valibot_1.string)(),
+    module: (0, valibot_1.string)(),
+    name: (0, valibot_1.string)(),
+    typeParams: (0, valibot_1.array)(exports.TypeTag),
 });
-const GasConfig = (0, import_valibot.object)({
-  budget: (0, import_valibot.optional)(StringEncodedBigint),
-  price: (0, import_valibot.optional)(StringEncodedBigint),
-  payment: (0, import_valibot.optional)((0, import_valibot.array)(ObjectRef)),
-  owner: (0, import_valibot.optional)((0, import_valibot.string)())
+const GasConfig = (0, valibot_1.object)({
+    budget: (0, valibot_1.optional)(StringEncodedBigint),
+    price: (0, valibot_1.optional)(StringEncodedBigint),
+    payment: (0, valibot_1.optional)((0, valibot_1.array)(exports.ObjectRef)),
+    owner: (0, valibot_1.optional)((0, valibot_1.string)()),
 });
 const TransactionArgumentTypes = [
-  TransactionInput,
-  (0, import_valibot.object)({ kind: (0, import_valibot.literal)("GasCoin") }),
-  (0, import_valibot.object)({ kind: (0, import_valibot.literal)("Result"), index: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()) }),
-  (0, import_valibot.object)({
-    kind: (0, import_valibot.literal)("NestedResult"),
-    index: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()),
-    resultIndex: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)())
-  })
+    TransactionInput,
+    (0, valibot_1.object)({ kind: (0, valibot_1.literal)("GasCoin") }),
+    (0, valibot_1.object)({ kind: (0, valibot_1.literal)("Result"), index: (0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()) }),
+    (0, valibot_1.object)({
+        kind: (0, valibot_1.literal)("NestedResult"),
+        index: (0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()),
+        resultIndex: (0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()),
+    }),
 ];
-const TransactionArgument = (0, import_valibot.union)([...TransactionArgumentTypes]);
-const MoveCallTransaction = (0, import_valibot.object)({
-  kind: (0, import_valibot.literal)("MoveCall"),
-  target: (0, import_valibot.pipe)(
-    (0, import_valibot.string)(),
-    (0, import_valibot.check)((target) => target.split("::").length === 3)
-  ),
-  typeArguments: (0, import_valibot.array)((0, import_valibot.string)()),
-  arguments: (0, import_valibot.array)(TransactionArgument)
+// Generic transaction argument
+exports.TransactionArgument = (0, valibot_1.union)([...TransactionArgumentTypes]);
+const MoveCallTransaction = (0, valibot_1.object)({
+    kind: (0, valibot_1.literal)("MoveCall"),
+    target: (0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.check)((target) => target.split("::").length === 3)),
+    typeArguments: (0, valibot_1.array)((0, valibot_1.string)()),
+    arguments: (0, valibot_1.array)(exports.TransactionArgument),
 });
-const TransferObjectsTransaction = (0, import_valibot.object)({
-  kind: (0, import_valibot.literal)("TransferObjects"),
-  objects: (0, import_valibot.array)(TransactionArgument),
-  address: TransactionArgument
+const TransferObjectsTransaction = (0, valibot_1.object)({
+    kind: (0, valibot_1.literal)("TransferObjects"),
+    objects: (0, valibot_1.array)(exports.TransactionArgument),
+    address: exports.TransactionArgument,
 });
-const SplitCoinsTransaction = (0, import_valibot.object)({
-  kind: (0, import_valibot.literal)("SplitCoins"),
-  coin: TransactionArgument,
-  amounts: (0, import_valibot.array)(TransactionArgument)
+const SplitCoinsTransaction = (0, valibot_1.object)({
+    kind: (0, valibot_1.literal)("SplitCoins"),
+    coin: exports.TransactionArgument,
+    amounts: (0, valibot_1.array)(exports.TransactionArgument),
 });
-const MergeCoinsTransaction = (0, import_valibot.object)({
-  kind: (0, import_valibot.literal)("MergeCoins"),
-  destination: TransactionArgument,
-  sources: (0, import_valibot.array)(TransactionArgument)
+const MergeCoinsTransaction = (0, valibot_1.object)({
+    kind: (0, valibot_1.literal)("MergeCoins"),
+    destination: exports.TransactionArgument,
+    sources: (0, valibot_1.array)(exports.TransactionArgument),
 });
-const MakeMoveVecTransaction = (0, import_valibot.object)({
-  kind: (0, import_valibot.literal)("MakeMoveVec"),
-  type: (0, import_valibot.union)([
-    (0, import_valibot.object)({ Some: TypeTag }),
-    (0, import_valibot.object)({ None: (0, import_valibot.nullable)((0, import_valibot.literal)(true)) })
-  ]),
-  objects: (0, import_valibot.array)(TransactionArgument)
+const MakeMoveVecTransaction = (0, valibot_1.object)({
+    kind: (0, valibot_1.literal)("MakeMoveVec"),
+    type: (0, valibot_1.union)([
+        (0, valibot_1.object)({ Some: exports.TypeTag }),
+        (0, valibot_1.object)({ None: (0, valibot_1.nullable)((0, valibot_1.literal)(true)) }),
+    ]),
+    objects: (0, valibot_1.array)(exports.TransactionArgument),
 });
-const PublishTransaction = (0, import_valibot.object)({
-  kind: (0, import_valibot.literal)("Publish"),
-  modules: (0, import_valibot.array)((0, import_valibot.array)((0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()))),
-  dependencies: (0, import_valibot.array)((0, import_valibot.string)())
+const PublishTransaction = (0, valibot_1.object)({
+    kind: (0, valibot_1.literal)("Publish"),
+    modules: (0, valibot_1.array)((0, valibot_1.array)((0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()))),
+    dependencies: (0, valibot_1.array)((0, valibot_1.string)()),
 });
-const UpgradeTransaction = (0, import_valibot.object)({
-  kind: (0, import_valibot.literal)("Upgrade"),
-  modules: (0, import_valibot.array)((0, import_valibot.array)((0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()))),
-  dependencies: (0, import_valibot.array)((0, import_valibot.string)()),
-  packageId: (0, import_valibot.string)(),
-  ticket: TransactionArgument
+const UpgradeTransaction = (0, valibot_1.object)({
+    kind: (0, valibot_1.literal)("Upgrade"),
+    modules: (0, valibot_1.array)((0, valibot_1.array)((0, valibot_1.pipe)((0, valibot_1.number)(), (0, valibot_1.integer)()))),
+    dependencies: (0, valibot_1.array)((0, valibot_1.string)()),
+    packageId: (0, valibot_1.string)(),
+    ticket: exports.TransactionArgument,
 });
 const TransactionTypes = [
-  MoveCallTransaction,
-  TransferObjectsTransaction,
-  SplitCoinsTransaction,
-  MergeCoinsTransaction,
-  PublishTransaction,
-  UpgradeTransaction,
-  MakeMoveVecTransaction
+    MoveCallTransaction,
+    TransferObjectsTransaction,
+    SplitCoinsTransaction,
+    MergeCoinsTransaction,
+    PublishTransaction,
+    UpgradeTransaction,
+    MakeMoveVecTransaction,
 ];
-const TransactionType = (0, import_valibot.union)([...TransactionTypes]);
-const SerializedTransactionDataV1 = (0, import_valibot.object)({
-  version: (0, import_valibot.literal)(1),
-  sender: (0, import_valibot.optional)((0, import_valibot.string)()),
-  expiration: (0, import_valibot.nullish)(TransactionExpiration),
-  gasConfig: GasConfig,
-  inputs: (0, import_valibot.array)(TransactionInput),
-  transactions: (0, import_valibot.array)(TransactionType)
+const TransactionType = (0, valibot_1.union)([...TransactionTypes]);
+exports.SerializedTransactionDataV1 = (0, valibot_1.object)({
+    version: (0, valibot_1.literal)(1),
+    sender: (0, valibot_1.optional)((0, valibot_1.string)()),
+    expiration: (0, valibot_1.nullish)(TransactionExpiration),
+    gasConfig: GasConfig,
+    inputs: (0, valibot_1.array)(TransactionInput),
+    transactions: (0, valibot_1.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: Array.from((0, import_bcs.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: import_bcs2.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)
-            )
-          };
+    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 (command.Publish) {
-          return {
-            kind: "Publish",
-            modules: command.Publish.modules.map(
-              (mod) => Array.from((0, import_bcs.fromBase64)(mod))
-            ),
-            dependencies: command.Publish.dependencies
-          };
+        if (input.Pure) {
+            return {
+                kind: "Input",
+                index,
+                value: {
+                    Pure: Array.from((0, bcs_1.fromBase64)(input.Pure.bytes)),
+                },
+                type: "pure",
+            };
         }
-        if (command.SplitCoins) {
-          return {
-            kind: "SplitCoins",
-            coin: convertTransactionArgument(
-              command.SplitCoins.coin,
-              inputs
-            ),
-            amounts: command.SplitCoins.amounts.map(
-              (arg) => convertTransactionArgument(arg, inputs)
-            )
-          };
+        if (input.UnresolvedPure) {
+            return {
+                kind: "Input",
+                type: "pure",
+                index,
+                value: input.UnresolvedPure.value,
+            };
         }
-        if (command.TransferObjects) {
-          return {
-            kind: "TransferObjects",
-            objects: command.TransferObjects.objects.map(
-              (arg) => convertTransactionArgument(arg, inputs)
-            ),
-            address: convertTransactionArgument(
-              command.TransferObjects.address,
-              inputs
-            )
-          };
+        if (input.UnresolvedObject) {
+            return {
+                kind: "Input",
+                type: "object",
+                index,
+                value: input.UnresolvedObject.objectId,
+            };
         }
-        if (command.Upgrade) {
-          return {
-            kind: "Upgrade",
-            modules: command.Upgrade.modules.map(
-              (mod) => Array.from((0, import_bcs.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") {
+        throw new Error("Invalid input");
+    });
     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 (0, import_valibot.parse)(import_internal.TransactionDataSchema, {
-    version: 2,
-    sender: data.sender ?? null,
-    expiration: data.expiration ? "Epoch" in data.expiration ? { Epoch: data.expiration.Epoch } : { None: true } : null,
-    gasData: {
-      owner: data.gasConfig.owner ?? null,
-      budget: data.gasConfig.budget?.toString() ?? null,
-      price: data.gasConfig.price?.toString() ?? null,
-      payment: data.gasConfig.payment?.map((ref) => ({
-        digest: ref.digest,
-        objectId: ref.objectId,
-        version: ref.version.toString()
-      })) ?? null
-    },
-    inputs: data.inputs.map((input) => {
-      if (input.kind === "Input") {
-        if ((0, import_valibot.is)(NormalizedCallArg, input.value)) {
-          const value = (0, import_valibot.parse)(NormalizedCallArg, input.value);
-          if (value.Object) {
-            if (value.Object.ImmOrOwned) {
-              return {
-                Object: {
-                  ImmOrOwnedObject: {
-                    objectId: value.Object.ImmOrOwned.objectId,
-                    version: String(
-                      value.Object.ImmOrOwned.version
-                    ),
-                    digest: value.Object.ImmOrOwned.digest
-                  }
-                }
-              };
+        version: 1,
+        sender: transactionData.sender ?? undefined,
+        expiration: transactionData.expiration?.$kind === "Epoch"
+            ? { Epoch: Number(transactionData.expiration.Epoch) }
+            : transactionData.expiration
+                ? { None: true }
+                : null,
+        gasConfig: {
+            owner: transactionData.gasData.owner ?? undefined,
+            budget: transactionData.gasData.budget ?? undefined,
+            price: transactionData.gasData.price ?? undefined,
+            payment: transactionData.gasData.payment ?? undefined,
+        },
+        inputs,
+        transactions: transactionData.commands.map((command) => {
+            if (command.MakeMoveVec) {
+                return {
+                    kind: "MakeMoveVec",
+                    type: command.MakeMoveVec.type === null
+                        ? { None: true }
+                        : {
+                            Some: index_js_1.TypeTagSerializer.parseFromStr(command.MakeMoveVec.type),
+                        },
+                    objects: command.MakeMoveVec.elements.map((arg) => convertTransactionArgument(arg, inputs)),
+                };
             }
-            if (value.Object.Shared) {
-              return {
-                Object: {
-                  SharedObject: {
-                    mutable: value.Object.Shared.mutable ?? null,
-                    initialSharedVersion: value.Object.Shared.initialSharedVersion,
-                    objectId: value.Object.Shared.objectId
-                  }
-                }
-              };
+            if (command.MergeCoins) {
+                return {
+                    kind: "MergeCoins",
+                    destination: convertTransactionArgument(command.MergeCoins.destination, inputs),
+                    sources: command.MergeCoins.sources.map((arg) => convertTransactionArgument(arg, inputs)),
+                };
             }
-            if (value.Object.Receiving) {
-              return {
-                Object: {
-                  Receiving: {
-                    digest: value.Object.Receiving.digest,
-                    version: String(
-                      value.Object.Receiving.version
-                    ),
-                    objectId: value.Object.Receiving.objectId
-                  }
-                }
-              };
+            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)),
+                };
             }
-            throw new Error("Invalid object input");
-          }
-          return {
-            Pure: {
-              bytes: (0, import_bcs.toBase64)(new Uint8Array(value.Pure))
+            if (command.Publish) {
+                return {
+                    kind: "Publish",
+                    modules: command.Publish.modules.map((mod) => Array.from((0, bcs_1.fromBase64)(mod))),
+                    dependencies: command.Publish.dependencies,
+                };
             }
-          };
-        }
-        if (input.type === "object") {
-          return {
-            UnresolvedObject: {
-              objectId: input.value
+            if (command.SplitCoins) {
+                return {
+                    kind: "SplitCoins",
+                    coin: convertTransactionArgument(command.SplitCoins.coin, inputs),
+                    amounts: command.SplitCoins.amounts.map((arg) => convertTransactionArgument(arg, inputs)),
+                };
             }
-          };
-        }
-        return {
-          UnresolvedPure: {
-            value: input.value
-          }
-        };
-      }
-      throw new Error("Invalid input");
-    }),
-    commands: data.transactions.map((transaction) => {
-      switch (transaction.kind) {
-        case "MakeMoveVec":
-          return {
-            MakeMoveVec: {
-              type: "Some" in transaction.type ? import_bcs2.TypeTagSerializer.tagToString(
-                transaction.type.Some
-              ) : null,
-              elements: transaction.objects.map(
-                (arg) => parseV1TransactionArgument(arg)
-              )
+            if (command.TransferObjects) {
+                return {
+                    kind: "TransferObjects",
+                    objects: command.TransferObjects.objects.map((arg) => convertTransactionArgument(arg, inputs)),
+                    address: convertTransactionArgument(command.TransferObjects.address, inputs),
+                };
             }
-          };
-        case "MergeCoins": {
-          return {
-            MergeCoins: {
-              destination: parseV1TransactionArgument(
-                transaction.destination
-              ),
-              sources: transaction.sources.map(
-                (arg) => parseV1TransactionArgument(arg)
-              )
+            if (command.Upgrade) {
+                return {
+                    kind: "Upgrade",
+                    modules: command.Upgrade.modules.map((mod) => Array.from((0, bcs_1.fromBase64)(mod))),
+                    dependencies: command.Upgrade.dependencies,
+                    packageId: command.Upgrade.package,
+                    ticket: convertTransactionArgument(command.Upgrade.ticket, inputs),
+                };
             }
-          };
-        }
-        case "MoveCall": {
-          const [pkg, mod, fn] = transaction.target.split("::");
-          return {
-            MoveCall: {
-              package: pkg,
-              module: mod,
-              function: fn,
-              typeArguments: transaction.typeArguments,
-              arguments: transaction.arguments.map(
-                (arg) => parseV1TransactionArgument(arg)
-              )
-            }
-          };
-        }
-        case "Publish": {
-          return {
-            Publish: {
-              modules: transaction.modules.map(
-                (mod) => (0, import_bcs.toBase64)(Uint8Array.from(mod))
-              ),
-              dependencies: transaction.dependencies
+            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 (0, valibot_1.parse)(internal_js_1.TransactionDataSchema, {
+        version: 2,
+        sender: data.sender ?? null,
+        expiration: data.expiration
+            ? "Epoch" in data.expiration
+                ? { Epoch: data.expiration.Epoch }
+                : { None: true }
+            : null,
+        gasData: {
+            owner: data.gasConfig.owner ?? null,
+            budget: data.gasConfig.budget?.toString() ?? null,
+            price: data.gasConfig.price?.toString() ?? null,
+            payment: data.gasConfig.payment?.map((ref) => ({
+                digest: ref.digest,
+                objectId: ref.objectId,
+                version: ref.version.toString(),
+            })) ?? null,
+        },
+        inputs: data.inputs.map((input) => {
+            if (input.kind === "Input") {
+                if ((0, valibot_1.is)(exports.NormalizedCallArg, input.value)) {
+                    const value = (0, valibot_1.parse)(exports.NormalizedCallArg, input.value);
+                    if (value.Object) {
+                        if (value.Object.ImmOrOwned) {
+                            return {
+                                Object: {
+                                    ImmOrOwnedObject: {
+                                        objectId: value.Object.ImmOrOwned.objectId,
+                                        version: String(value.Object.ImmOrOwned.version),
+                                        digest: value.Object.ImmOrOwned.digest,
+                                    },
+                                },
+                            };
+                        }
+                        if (value.Object.Shared) {
+                            return {
+                                Object: {
+                                    SharedObject: {
+                                        mutable: value.Object.Shared.mutable ?? null,
+                                        initialSharedVersion: value.Object.Shared
+                                            .initialSharedVersion,
+                                        objectId: value.Object.Shared.objectId,
+                                    },
+                                },
+                            };
+                        }
+                        if (value.Object.Receiving) {
+                            return {
+                                Object: {
+                                    Receiving: {
+                                        digest: value.Object.Receiving.digest,
+                                        version: String(value.Object.Receiving.version),
+                                        objectId: value.Object.Receiving.objectId,
+                                    },
+                                },
+                            };
+                        }
+                        throw new Error("Invalid object input");
+                    }
+                    return {
+                        Pure: {
+                            bytes: (0, bcs_1.toBase64)(new Uint8Array(value.Pure)),
+                        },
+                    };
+                }
+                if (input.type === "object") {
+                    return {
+                        UnresolvedObject: {
+                            objectId: input.value,
+                        },
+                    };
+                }
+                return {
+                    UnresolvedPure: {
+                        value: input.value,
+                    },
+                };
             }
-          };
-        }
-        case "SplitCoins": {
-          return {
-            SplitCoins: {
-              coin: parseV1TransactionArgument(transaction.coin),
-              amounts: transaction.amounts.map(
-                (arg) => parseV1TransactionArgument(arg)
-              )
+            throw new Error("Invalid input");
+        }),
+        commands: data.transactions.map((transaction) => {
+            switch (transaction.kind) {
+                case "MakeMoveVec":
+                    return {
+                        MakeMoveVec: {
+                            type: "Some" in transaction.type
+                                ? index_js_1.TypeTagSerializer.tagToString(transaction.type.Some)
+                                : null,
+                            elements: transaction.objects.map((arg) => parseV1TransactionArgument(arg)),
+                        },
+                    };
+                case "MergeCoins": {
+                    return {
+                        MergeCoins: {
+                            destination: parseV1TransactionArgument(transaction.destination),
+                            sources: transaction.sources.map((arg) => parseV1TransactionArgument(arg)),
+                        },
+                    };
+                }
+                case "MoveCall": {
+                    const [pkg, mod, fn] = transaction.target.split("::");
+                    return {
+                        MoveCall: {
+                            package: pkg,
+                            module: mod,
+                            function: fn,
+                            typeArguments: transaction.typeArguments,
+                            arguments: transaction.arguments.map((arg) => parseV1TransactionArgument(arg)),
+                        },
+                    };
+                }
+                case "Publish": {
+                    return {
+                        Publish: {
+                            modules: transaction.modules.map((mod) => (0, bcs_1.toBase64)(Uint8Array.from(mod))),
+                            dependencies: transaction.dependencies,
+                        },
+                    };
+                }
+                case "SplitCoins": {
+                    return {
+                        SplitCoins: {
+                            coin: parseV1TransactionArgument(transaction.coin),
+                            amounts: transaction.amounts.map((arg) => parseV1TransactionArgument(arg)),
+                        },
+                    };
+                }
+                case "TransferObjects": {
+                    return {
+                        TransferObjects: {
+                            objects: transaction.objects.map((arg) => parseV1TransactionArgument(arg)),
+                            address: parseV1TransactionArgument(transaction.address),
+                        },
+                    };
+                }
+                case "Upgrade": {
+                    return {
+                        Upgrade: {
+                            modules: transaction.modules.map((mod) => (0, bcs_1.toBase64)(Uint8Array.from(mod))),
+                            dependencies: transaction.dependencies,
+                            package: transaction.packageId,
+                            ticket: parseV1TransactionArgument(transaction.ticket),
+                        },
+                    };
+                }
             }
-          };
+            throw new Error(`Unknown transaction ${Object.keys(transaction)}`);
+        }),
+    });
+}
+function parseV1TransactionArgument(arg) {
+    switch (arg.kind) {
+        case "GasCoin": {
+            return { GasCoin: true };
         }
-        case "TransferObjects": {
-          return {
-            TransferObjects: {
-              objects: transaction.objects.map(
-                (arg) => parseV1TransactionArgument(arg)
-              ),
-              address: parseV1TransactionArgument(
-                transaction.address
-              )
-            }
-          };
+        case "Result":
+            return { Result: arg.index };
+        case "NestedResult": {
+            return { NestedResult: [arg.index, arg.resultIndex] };
         }
-        case "Upgrade": {
-          return {
-            Upgrade: {
-              modules: transaction.modules.map(
-                (mod) => (0, import_bcs.toBase64)(Uint8Array.from(mod))
-              ),
-              dependencies: transaction.dependencies,
-              package: transaction.packageId,
-              ticket: parseV1TransactionArgument(
-                transaction.ticket
-              )
-            }
-          };
+        case "Input": {
+            return { Input: arg.index };
         }
-      }
-      throw new Error(`Unknown transaction ${Object.keys(transaction)}`);
-    })
-  });
-}
-function parseV1TransactionArgument(arg) {
-  switch (arg.kind) {
-    case "GasCoin": {
-      return { GasCoin: true };
-    }
-    case "Result":
-      return { Result: arg.index };
-    case "NestedResult": {
-      return { NestedResult: [arg.index, arg.resultIndex] };
-    }
-    case "Input": {
-      return { Input: arg.index };
     }
-  }
 }
+//# sourceMappingURL=v1.js.map