wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,538 @@
+"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
+});
+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 NormalizedCallArg = (0, import_internal.safeEnum)({
+  Object: ObjectArg,
+  Pure: (0, import_valibot.array)((0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.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 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 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;
+    try {
+      BigInt(val);
+      return true;
+    } catch {
+      return false;
+    }
+  })
+);
+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)) })
+]);
+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)
+});
+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 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)())
+  })
+];
+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)
+});
+const TransferObjectsTransaction = (0, import_valibot.object)({
+  kind: (0, import_valibot.literal)("TransferObjects"),
+  objects: (0, import_valibot.array)(TransactionArgument),
+  address: TransactionArgument
+});
+const SplitCoinsTransaction = (0, import_valibot.object)({
+  kind: (0, import_valibot.literal)("SplitCoins"),
+  coin: TransactionArgument,
+  amounts: (0, import_valibot.array)(TransactionArgument)
+});
+const MergeCoinsTransaction = (0, import_valibot.object)({
+  kind: (0, import_valibot.literal)("MergeCoins"),
+  destination: TransactionArgument,
+  sources: (0, import_valibot.array)(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 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 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 TransactionTypes = [
+  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)
+});
+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)
+            )
+          };
+        }
+        if (command.Publish) {
+          return {
+            kind: "Publish",
+            modules: command.Publish.modules.map(
+              (mod) => Array.from((0, import_bcs.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) => 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") {
+    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
+                  }
+                }
+              };
+            }
+            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, import_bcs.toBase64)(new Uint8Array(value.Pure))
+            }
+          };
+        }
+        if (input.type === "object") {
+          return {
+            UnresolvedObject: {
+              objectId: input.value
+            }
+          };
+        }
+        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)
+              )
+            }
+          };
+        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, import_bcs.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, import_bcs.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 "Result":
+      return { Result: arg.index };
+    case "NestedResult": {
+      return { NestedResult: [arg.index, arg.resultIndex] };
+    }
+    case "Input": {
+      return { Input: arg.index };
+    }
+  }
+}

package/dist/cjs/transactions/data/v2.d.ts

@@ -0,0 +1,153 @@
+import type { EnumInputShape } from "@mysten/bcs";
+import type { GenericSchema, InferOutput } from "valibot";
+export declare const SerializedTransactionDataV2Schema: import("valibot").ObjectSchema<{
+    readonly version: import("valibot").LiteralSchema<2, undefined>;
+    readonly sender: import("valibot").NullishSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>, undefined>;
+    readonly expiration: import("valibot").NullishSchema<GenericSchema<EnumInputShape<{
+        None: true;
+        Epoch: string | number;
+    }>>, undefined>;
+    readonly gasData: import("valibot").ObjectSchema<{
+        readonly budget: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>, undefined>;
+        readonly price: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>, undefined>;
+        readonly owner: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>, undefined>;
+        readonly payment: import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly objectId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>;
+            readonly version: import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>;
+            readonly digest: import("valibot").StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
+    }, undefined>;
+    readonly inputs: import("valibot").ArraySchema<GenericSchema<EnumInputShape<{
+        Object: EnumInputShape<{
+            ImmOrOwnedObject: {
+                objectId: string;
+                version: string | number;
+                digest: string;
+            };
+            SharedObject: {
+                objectId: string;
+                initialSharedVersion: string | number;
+                mutable: boolean;
+            };
+            Receiving: {
+                objectId: string;
+                version: string | number;
+                digest: string;
+            };
+        }>;
+        Pure: {
+            bytes: string;
+        };
+        UnresolvedPure: {
+            value: unknown;
+        };
+        UnresolvedObject: {
+            objectId: string;
+            version?: string | number | null | undefined;
+            digest?: string | null | undefined;
+            initialSharedVersion?: string | number | null | undefined;
+            mutable?: boolean | null | undefined;
+        };
+    }>>, undefined>;
+    readonly commands: import("valibot").ArraySchema<GenericSchema<EnumInputShape<{
+        MoveCall: {
+            package: string;
+            module: string;
+            function: string;
+            typeArguments: string[];
+            arguments: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+        };
+        TransferObjects: {
+            objects: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+            address: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>;
+        };
+        SplitCoins: {
+            coin: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>;
+            amounts: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+        };
+        MergeCoins: {
+            destination: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>;
+            sources: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+        };
+        Publish: {
+            modules: string[];
+            dependencies: string[];
+        };
+        MakeMoveVec: {
+            type: string | null;
+            elements: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+        };
+        Upgrade: {
+            modules: string[];
+            dependencies: string[];
+            package: string;
+            ticket: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>;
+        };
+        $Intent: {
+            name: string;
+            inputs: {
+                [x: string]: EnumInputShape<{
+                    GasCoin: true;
+                    Input: number;
+                    Result: number;
+                    NestedResult: [number, number];
+                }> | EnumInputShape<{
+                    GasCoin: true;
+                    Input: number;
+                    Result: number;
+                    NestedResult: [number, number];
+                }>[];
+            };
+            data: {
+                [x: string]: unknown;
+            };
+        };
+    }>>, undefined>;
+    readonly digest: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export type SerializedTransactionDataV2 = InferOutput<typeof SerializedTransactionDataV2Schema>;