@t2000/cli 5.5.0 → 5.6.0

package/dist/{chunk-FORXEDQJ.js → chunk-MPXYF2CX.js}

@@ -16,521 +16,846 @@ import {
   toBase58,
   toBase64,
   toHex
-} from "./chunk-HRGEZK3M.js";
+} from "./chunk-I2DCISQP.js";
 
-// ../../node_modules/.pnpm/valibot@1.3.1_typescript@5.9.3/node_modules/valibot/dist/index.mjs
-var store$4;
-// @__NO_SIDE_EFFECTS__
-function getGlobalConfig(config$1) {
-  return {
-    lang: config$1?.lang ?? store$4?.lang,
-    message: config$1?.message,
-    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
-    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
-  };
-}
-var store$3;
-// @__NO_SIDE_EFFECTS__
-function getGlobalMessage(lang) {
-  return store$3?.get(lang);
-}
-var store$2;
-// @__NO_SIDE_EFFECTS__
-function getSchemaMessage(lang) {
-  return store$2?.get(lang);
-}
-var store$1;
-// @__NO_SIDE_EFFECTS__
-function getSpecificMessage(reference, lang) {
-  return store$1?.get(reference)?.get(lang);
-}
-// @__NO_SIDE_EFFECTS__
-function _stringify(input) {
-  const type = typeof input;
-  if (type === "string") return `"${input}"`;
-  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
-  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-  return type;
-}
-function _addIssue(context, label, dataset, config$1, other) {
-  const input = other && "input" in other ? other.input : dataset.value;
-  const expected = other?.expected ?? context.expects ?? null;
-  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
-  const issue = {
-    kind: context.kind,
-    type: context.type,
-    input,
-    expected,
-    received,
-    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
-    requirement: context.requirement,
-    path: other?.path,
-    issues: other?.issues,
-    lang: config$1.lang,
-    abortEarly: config$1.abortEarly,
-    abortPipeEarly: config$1.abortPipeEarly
-  };
-  const isSchema = context.kind === "schema";
-  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
-  if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
-  if (isSchema) dataset.typed = false;
-  if (dataset.issues) dataset.issues.push(issue);
-  else dataset.issues = [issue];
-}
-// @__NO_SIDE_EFFECTS__
-function _getStandardProps(context) {
-  return {
-    version: 1,
-    vendor: "valibot",
-    validate(value$1) {
-      return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/type-tag-serializer.mjs
+var VECTOR_REGEX = /^vector<(.+)>$/;
+var STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+var TypeTagSerializer = class TypeTagSerializer2 {
+  static parseFromStr(str, normalizeAddress = false) {
+    if (str === "address") return { address: null };
+    else if (str === "bool") return { bool: null };
+    else if (str === "u8") return { u8: null };
+    else if (str === "u16") return { u16: null };
+    else if (str === "u32") return { u32: null };
+    else if (str === "u64") return { u64: null };
+    else if (str === "u128") return { u128: null };
+    else if (str === "u256") return { u256: null };
+    else if (str === "signer") return { signer: null };
+    const vectorMatch = str.match(VECTOR_REGEX);
+    if (vectorMatch) return { vector: TypeTagSerializer2.parseFromStr(vectorMatch[1], normalizeAddress) };
+    const structMatch = str.match(STRUCT_REGEX);
+    if (structMatch) return { struct: {
+      address: normalizeAddress ? normalizeSuiAddress(structMatch[1]) : structMatch[1],
+      module: structMatch[2],
+      name: structMatch[3],
+      typeParams: structMatch[5] === void 0 ? [] : TypeTagSerializer2.parseStructTypeArgs(structMatch[5], normalizeAddress)
+    } };
+    throw new Error(`Encountered unexpected token when parsing type args for ${str}`);
+  }
+  static parseStructTypeArgs(str, normalizeAddress = false) {
+    return splitGenericParameters(str).map((tok) => TypeTagSerializer2.parseFromStr(tok, normalizeAddress));
+  }
+  static tagToString(tag) {
+    if ("bool" in tag) return "bool";
+    if ("u8" in tag) return "u8";
+    if ("u16" in tag) return "u16";
+    if ("u32" in tag) return "u32";
+    if ("u64" in tag) return "u64";
+    if ("u128" in tag) return "u128";
+    if ("u256" in tag) return "u256";
+    if ("address" in tag) return "address";
+    if ("signer" in tag) return "signer";
+    if ("vector" in tag) return `vector<${TypeTagSerializer2.tagToString(tag.vector)}>`;
+    if ("struct" in tag) {
+      const struct = tag.struct;
+      const typeParams = struct.typeParams.map(TypeTagSerializer2.tagToString).join(", ");
+      return `${struct.address}::${struct.module}::${struct.name}${typeParams ? `<${typeParams}>` : ""}`;
     }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function _isValidObjectKey(object$1, key) {
-  return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
-}
-// @__NO_SIDE_EFFECTS__
-function _joinExpects(values$1, separator) {
-  const list = [...new Set(values$1)];
-  if (list.length > 1) return `(${list.join(` ${separator} `)})`;
-  return list[0] ?? "never";
-}
-var ValiError = class extends Error {
-  /**
-  * Creates a Valibot error with useful information.
-  *
-  * @param issues The error issues.
-  */
-  constructor(issues) {
-    super(issues[0].message);
-    this.name = "ValiError";
-    this.issues = issues;
+    throw new Error("Invalid TypeTag");
   }
 };
-// @__NO_SIDE_EFFECTS__
-function check(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "check",
-    reference: check,
-    async: false,
-    expects: null,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "input", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function integer(message$1) {
-  return {
-    kind: "validation",
-    type: "integer",
-    reference: integer,
-    async: false,
-    expects: null,
-    requirement: Number.isInteger,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function transform(operation) {
-  return {
-    kind: "transformation",
-    type: "transform",
-    reference: transform,
-    async: false,
-    operation,
-    "~run"(dataset) {
-      dataset.value = this.operation(dataset.value);
-      return dataset;
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function getFallback(schema, dataset, config$1) {
-  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
-}
-// @__NO_SIDE_EFFECTS__
-function getDefault(schema, dataset, config$1) {
-  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
-}
-// @__NO_SIDE_EFFECTS__
-function is(schema, input) {
-  return !schema["~run"]({ value: input }, { abortEarly: true }).issues;
+
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/bcs.mjs
+function unsafe_u64(options) {
+  return bcs.u64({
+    name: "unsafe_u64",
+    ...options
+  }).transform({
+    input: (val) => val,
+    output: (val) => Number(val)
+  });
 }
-// @__NO_SIDE_EFFECTS__
-function array(item, message$1) {
-  return {
-    kind: "schema",
-    type: "array",
-    reference: array,
-    expects: "Array",
-    async: false,
-    item,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (Array.isArray(input)) {
-        dataset.typed = true;
-        dataset.value = [];
-        for (let key = 0; key < input.length; key++) {
-          const value$1 = input[key];
-          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
-          if (itemDataset.issues) {
-            const pathItem = {
-              type: "array",
-              origin: "value",
-              input,
-              key,
-              value: value$1
-            };
-            for (const issue of itemDataset.issues) {
-              if (issue.path) issue.path.unshift(pathItem);
-              else issue.path = [pathItem];
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) dataset.issues = itemDataset.issues;
-            if (config$1.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!itemDataset.typed) dataset.typed = false;
-          dataset.value.push(itemDataset.value);
-        }
-      } else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  };
+function optionEnum(type) {
+  return bcs.enum("Option", {
+    None: null,
+    Some: type
+  });
 }
-// @__NO_SIDE_EFFECTS__
-function bigint(message$1) {
-  return {
-    kind: "schema",
-    type: "bigint",
-    reference: bigint,
-    expects: "bigint",
-    async: false,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (typeof dataset.value === "bigint") dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  };
+var Address = bcs.bytes(SUI_ADDRESS_LENGTH).transform({
+  validate: (val) => {
+    const address = typeof val === "string" ? val : toHex(val);
+    if (!address || !isValidSuiAddress(normalizeSuiAddress(address))) throw new Error(`Invalid Sui address ${address}`);
+  },
+  input: (val) => typeof val === "string" ? fromHex(normalizeSuiAddress(val)) : val,
+  output: (val) => normalizeSuiAddress(toHex(val))
+});
+var ObjectDigest = bcs.byteVector().transform({
+  name: "ObjectDigest",
+  input: (value) => fromBase58(value),
+  output: (value) => toBase58(new Uint8Array(value)),
+  validate: (value) => {
+    if (fromBase58(value).length !== 32) throw new Error("ObjectDigest must be 32 bytes");
+  }
+});
+var SuiObjectRef = bcs.struct("SuiObjectRef", {
+  objectId: Address,
+  version: bcs.u64(),
+  digest: ObjectDigest
+});
+var SharedObjectRef = bcs.struct("SharedObjectRef", {
+  objectId: Address,
+  initialSharedVersion: bcs.u64(),
+  mutable: bcs.bool()
+});
+var ObjectArg = bcs.enum("ObjectArg", {
+  ImmOrOwnedObject: SuiObjectRef,
+  SharedObject: SharedObjectRef,
+  Receiving: SuiObjectRef
+});
+var Owner = bcs.enum("Owner", {
+  AddressOwner: Address,
+  ObjectOwner: Address,
+  Shared: bcs.struct("Shared", { initialSharedVersion: bcs.u64() }),
+  Immutable: null,
+  ConsensusAddressOwner: bcs.struct("ConsensusAddressOwner", {
+    startVersion: bcs.u64(),
+    owner: Address
+  })
+});
+var Reservation = bcs.enum("Reservation", { MaxAmountU64: bcs.u64() });
+var WithdrawalType = bcs.enum("WithdrawalType", { Balance: bcs.lazy(() => TypeTag) });
+var WithdrawFrom = bcs.enum("WithdrawFrom", {
+  Sender: null,
+  Sponsor: null
+});
+var FundsWithdrawal = bcs.struct("FundsWithdrawal", {
+  reservation: Reservation,
+  typeArg: WithdrawalType,
+  withdrawFrom: WithdrawFrom
+});
+var CallArg = bcs.enum("CallArg", {
+  Pure: bcs.struct("Pure", { bytes: bcs.byteVector().transform({
+    input: (val) => typeof val === "string" ? fromBase64(val) : val,
+    output: (val) => toBase64(new Uint8Array(val))
+  }) }),
+  Object: ObjectArg,
+  FundsWithdrawal
+});
+var InnerTypeTag = bcs.enum("TypeTag", {
+  bool: null,
+  u8: null,
+  u64: null,
+  u128: null,
+  address: null,
+  signer: null,
+  vector: bcs.lazy(() => InnerTypeTag),
+  struct: bcs.lazy(() => StructTag),
+  u16: null,
+  u32: null,
+  u256: null
+});
+var TypeTag = InnerTypeTag.transform({
+  input: (typeTag) => typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag, true) : typeTag,
+  output: (typeTag) => TypeTagSerializer.tagToString(typeTag)
+});
+var Argument = bcs.enum("Argument", {
+  GasCoin: null,
+  Input: bcs.u16(),
+  Result: bcs.u16(),
+  NestedResult: bcs.tuple([bcs.u16(), bcs.u16()])
+});
+var ProgrammableMoveCall = bcs.struct("ProgrammableMoveCall", {
+  package: Address,
+  module: bcs.string(),
+  function: bcs.string(),
+  typeArguments: bcs.vector(TypeTag),
+  arguments: bcs.vector(Argument)
+});
+var Command = bcs.enum("Command", {
+  MoveCall: ProgrammableMoveCall,
+  TransferObjects: bcs.struct("TransferObjects", {
+    objects: bcs.vector(Argument),
+    address: Argument
+  }),
+  SplitCoins: bcs.struct("SplitCoins", {
+    coin: Argument,
+    amounts: bcs.vector(Argument)
+  }),
+  MergeCoins: bcs.struct("MergeCoins", {
+    destination: Argument,
+    sources: bcs.vector(Argument)
+  }),
+  Publish: bcs.struct("Publish", {
+    modules: bcs.vector(bcs.byteVector().transform({
+      input: (val) => typeof val === "string" ? fromBase64(val) : val,
+      output: (val) => toBase64(new Uint8Array(val))
+    })),
+    dependencies: bcs.vector(Address)
+  }),
+  MakeMoveVec: bcs.struct("MakeMoveVec", {
+    type: optionEnum(TypeTag).transform({
+      input: (val) => val === null ? { None: true } : { Some: val },
+      output: (val) => val.Some ?? null
+    }),
+    elements: bcs.vector(Argument)
+  }),
+  Upgrade: bcs.struct("Upgrade", {
+    modules: bcs.vector(bcs.byteVector().transform({
+      input: (val) => typeof val === "string" ? fromBase64(val) : val,
+      output: (val) => toBase64(new Uint8Array(val))
+    })),
+    dependencies: bcs.vector(Address),
+    package: Address,
+    ticket: Argument
+  })
+});
+var ProgrammableTransaction = bcs.struct("ProgrammableTransaction", {
+  inputs: bcs.vector(CallArg),
+  commands: bcs.vector(Command)
+});
+var TransactionKind = bcs.enum("TransactionKind", {
+  ProgrammableTransaction,
+  ChangeEpoch: null,
+  Genesis: null,
+  ConsensusCommitPrologue: null
+});
+var ValidDuring = bcs.struct("ValidDuring", {
+  minEpoch: bcs.option(bcs.u64()),
+  maxEpoch: bcs.option(bcs.u64()),
+  minTimestamp: bcs.option(bcs.u64()),
+  maxTimestamp: bcs.option(bcs.u64()),
+  chain: ObjectDigest,
+  nonce: bcs.u32()
+});
+var TransactionExpiration = bcs.enum("TransactionExpiration", {
+  None: null,
+  Epoch: unsafe_u64(),
+  ValidDuring
+});
+var StructTag = bcs.struct("StructTag", {
+  address: Address,
+  module: bcs.string(),
+  name: bcs.string(),
+  typeParams: bcs.vector(InnerTypeTag)
+});
+var GasData = bcs.struct("GasData", {
+  payment: bcs.vector(SuiObjectRef),
+  owner: Address,
+  price: bcs.u64(),
+  budget: bcs.u64()
+});
+var TransactionDataV1 = bcs.struct("TransactionDataV1", {
+  kind: TransactionKind,
+  sender: Address,
+  gasData: GasData,
+  expiration: TransactionExpiration
+});
+var TransactionData = bcs.enum("TransactionData", { V1: TransactionDataV1 });
+var IntentScope = bcs.enum("IntentScope", {
+  TransactionData: null,
+  TransactionEffects: null,
+  CheckpointSummary: null,
+  PersonalMessage: null
+});
+var IntentVersion = bcs.enum("IntentVersion", { V0: null });
+var AppId = bcs.enum("AppId", { Sui: null });
+var Intent = bcs.struct("Intent", {
+  scope: IntentScope,
+  version: IntentVersion,
+  appId: AppId
+});
+function IntentMessage(T) {
+  return bcs.struct(`IntentMessage<${T.name}>`, {
+    intent: Intent,
+    value: T
+  });
+}
+var CompressedSignature = bcs.enum("CompressedSignature", {
+  ED25519: bcs.bytes(64),
+  Secp256k1: bcs.bytes(64),
+  Secp256r1: bcs.bytes(64),
+  ZkLogin: bcs.byteVector(),
+  Passkey: bcs.byteVector()
+});
+var PublicKey = bcs.enum("PublicKey", {
+  ED25519: bcs.bytes(32),
+  Secp256k1: bcs.bytes(33),
+  Secp256r1: bcs.bytes(33),
+  ZkLogin: bcs.byteVector(),
+  Passkey: bcs.bytes(33)
+});
+var MultiSigPkMap = bcs.struct("MultiSigPkMap", {
+  pubKey: PublicKey,
+  weight: bcs.u8()
+});
+var MultiSigPublicKey = bcs.struct("MultiSigPublicKey", {
+  pk_map: bcs.vector(MultiSigPkMap),
+  threshold: bcs.u16()
+});
+var MultiSig = bcs.struct("MultiSig", {
+  sigs: bcs.vector(CompressedSignature),
+  bitmap: bcs.u16(),
+  multisig_pk: MultiSigPublicKey
+});
+var base64String = bcs.byteVector().transform({
+  input: (val) => typeof val === "string" ? fromBase64(val) : val,
+  output: (val) => toBase64(new Uint8Array(val))
+});
+var SenderSignedTransaction = bcs.struct("SenderSignedTransaction", {
+  intentMessage: IntentMessage(TransactionData),
+  txSignatures: bcs.vector(base64String)
+});
+var SenderSignedData = bcs.vector(SenderSignedTransaction, { name: "SenderSignedData" });
+var PasskeyAuthenticator = bcs.struct("PasskeyAuthenticator", {
+  authenticatorData: bcs.byteVector(),
+  clientDataJson: bcs.string(),
+  userSignature: bcs.byteVector()
+});
+var MoveObjectType = bcs.enum("MoveObjectType", {
+  Other: StructTag,
+  GasCoin: null,
+  StakedSui: null,
+  Coin: TypeTag,
+  AccumulatorBalanceWrapper: null
+});
+var TypeOrigin = bcs.struct("TypeOrigin", {
+  moduleName: bcs.string(),
+  datatypeName: bcs.string(),
+  package: Address
+});
+var UpgradeInfo = bcs.struct("UpgradeInfo", {
+  upgradedId: Address,
+  upgradedVersion: bcs.u64()
+});
+var MovePackage = bcs.struct("MovePackage", {
+  id: Address,
+  version: bcs.u64(),
+  moduleMap: bcs.map(bcs.string(), bcs.byteVector()),
+  typeOriginTable: bcs.vector(TypeOrigin),
+  linkageTable: bcs.map(Address, UpgradeInfo)
+});
+var MoveObject = bcs.struct("MoveObject", {
+  type: MoveObjectType,
+  hasPublicTransfer: bcs.bool(),
+  version: bcs.u64(),
+  contents: bcs.byteVector()
+});
+var Data = bcs.enum("Data", {
+  Move: MoveObject,
+  Package: MovePackage
+});
+var ObjectInner = bcs.struct("ObjectInner", {
+  data: Data,
+  owner: Owner,
+  previousTransaction: ObjectDigest,
+  storageRebate: bcs.u64()
+});
+
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/effects.mjs
+var PackageUpgradeError = bcs.enum("PackageUpgradeError", {
+  UnableToFetchPackage: bcs.struct("UnableToFetchPackage", { packageId: Address }),
+  NotAPackage: bcs.struct("NotAPackage", { objectId: Address }),
+  IncompatibleUpgrade: null,
+  DigestDoesNotMatch: bcs.struct("DigestDoesNotMatch", { digest: bcs.byteVector() }),
+  UnknownUpgradePolicy: bcs.struct("UnknownUpgradePolicy", { policy: bcs.u8() }),
+  PackageIDDoesNotMatch: bcs.struct("PackageIDDoesNotMatch", {
+    packageId: Address,
+    ticketId: Address
+  })
+});
+var ModuleId = bcs.struct("ModuleId", {
+  address: Address,
+  name: bcs.string()
+});
+var MoveLocation = bcs.struct("MoveLocation", {
+  module: ModuleId,
+  function: bcs.u16(),
+  instruction: bcs.u16(),
+  functionName: bcs.option(bcs.string())
+});
+var CommandArgumentError = bcs.enum("CommandArgumentError", {
+  TypeMismatch: null,
+  InvalidBCSBytes: null,
+  InvalidUsageOfPureArg: null,
+  InvalidArgumentToPrivateEntryFunction: null,
+  IndexOutOfBounds: bcs.struct("IndexOutOfBounds", { idx: bcs.u16() }),
+  SecondaryIndexOutOfBounds: bcs.struct("SecondaryIndexOutOfBounds", {
+    resultIdx: bcs.u16(),
+    secondaryIdx: bcs.u16()
+  }),
+  InvalidResultArity: bcs.struct("InvalidResultArity", { resultIdx: bcs.u16() }),
+  InvalidGasCoinUsage: null,
+  InvalidValueUsage: null,
+  InvalidObjectByValue: null,
+  InvalidObjectByMutRef: null,
+  SharedObjectOperationNotAllowed: null,
+  InvalidArgumentArity: null,
+  InvalidTransferObject: null,
+  InvalidMakeMoveVecNonObjectArgument: null,
+  ArgumentWithoutValue: null,
+  CannotMoveBorrowedValue: null,
+  CannotWriteToExtendedReference: null,
+  InvalidReferenceArgument: null
+});
+var TypeArgumentError = bcs.enum("TypeArgumentError", {
+  TypeNotFound: null,
+  ConstraintNotSatisfied: null
+});
+var ExecutionFailureStatus = bcs.enum("ExecutionFailureStatus", {
+  InsufficientGas: null,
+  InvalidGasObject: null,
+  InvariantViolation: null,
+  FeatureNotYetSupported: null,
+  MoveObjectTooBig: bcs.struct("MoveObjectTooBig", {
+    objectSize: bcs.u64(),
+    maxObjectSize: bcs.u64()
+  }),
+  MovePackageTooBig: bcs.struct("MovePackageTooBig", {
+    objectSize: bcs.u64(),
+    maxObjectSize: bcs.u64()
+  }),
+  CircularObjectOwnership: bcs.struct("CircularObjectOwnership", { object: Address }),
+  InsufficientCoinBalance: null,
+  CoinBalanceOverflow: null,
+  PublishErrorNonZeroAddress: null,
+  SuiMoveVerificationError: null,
+  MovePrimitiveRuntimeError: bcs.option(MoveLocation),
+  MoveAbort: bcs.tuple([MoveLocation, bcs.u64()]),
+  VMVerificationOrDeserializationError: null,
+  VMInvariantViolation: null,
+  FunctionNotFound: null,
+  ArityMismatch: null,
+  TypeArityMismatch: null,
+  NonEntryFunctionInvoked: null,
+  CommandArgumentError: bcs.struct("CommandArgumentError", {
+    argIdx: bcs.u16(),
+    kind: CommandArgumentError
+  }),
+  TypeArgumentError: bcs.struct("TypeArgumentError", {
+    argumentIdx: bcs.u16(),
+    kind: TypeArgumentError
+  }),
+  UnusedValueWithoutDrop: bcs.struct("UnusedValueWithoutDrop", {
+    resultIdx: bcs.u16(),
+    secondaryIdx: bcs.u16()
+  }),
+  InvalidPublicFunctionReturnType: bcs.struct("InvalidPublicFunctionReturnType", { idx: bcs.u16() }),
+  InvalidTransferObject: null,
+  EffectsTooLarge: bcs.struct("EffectsTooLarge", {
+    currentSize: bcs.u64(),
+    maxSize: bcs.u64()
+  }),
+  PublishUpgradeMissingDependency: null,
+  PublishUpgradeDependencyDowngrade: null,
+  PackageUpgradeError: bcs.struct("PackageUpgradeError", { upgradeError: PackageUpgradeError }),
+  WrittenObjectsTooLarge: bcs.struct("WrittenObjectsTooLarge", {
+    currentSize: bcs.u64(),
+    maxSize: bcs.u64()
+  }),
+  CertificateDenied: null,
+  SuiMoveVerificationTimedout: null,
+  SharedObjectOperationNotAllowed: null,
+  InputObjectDeleted: null,
+  ExecutionCancelledDueToSharedObjectCongestion: bcs.struct("ExecutionCancelledDueToSharedObjectCongestion", { congested_objects: bcs.vector(Address) }),
+  AddressDeniedForCoin: bcs.struct("AddressDeniedForCoin", {
+    address: Address,
+    coinType: bcs.string()
+  }),
+  CoinTypeGlobalPause: bcs.struct("CoinTypeGlobalPause", { coinType: bcs.string() }),
+  ExecutionCancelledDueToRandomnessUnavailable: null,
+  MoveVectorElemTooBig: bcs.struct("MoveVectorElemTooBig", {
+    valueSize: bcs.u64(),
+    maxScaledSize: bcs.u64()
+  }),
+  MoveRawValueTooBig: bcs.struct("MoveRawValueTooBig", {
+    valueSize: bcs.u64(),
+    maxScaledSize: bcs.u64()
+  }),
+  InvalidLinkage: null,
+  InsufficientBalanceForWithdraw: null,
+  NonExclusiveWriteInputObjectModified: bcs.struct("NonExclusiveWriteInputObjectModified", { id: Address })
+});
+var ExecutionStatus = bcs.enum("ExecutionStatus", {
+  Success: null,
+  Failure: bcs.struct("Failure", {
+    error: ExecutionFailureStatus,
+    command: bcs.option(bcs.u64())
+  })
+});
+var GasCostSummary = bcs.struct("GasCostSummary", {
+  computationCost: bcs.u64(),
+  storageCost: bcs.u64(),
+  storageRebate: bcs.u64(),
+  nonRefundableStorageFee: bcs.u64()
+});
+var TransactionEffectsV1 = bcs.struct("TransactionEffectsV1", {
+  status: ExecutionStatus,
+  executedEpoch: bcs.u64(),
+  gasUsed: GasCostSummary,
+  modifiedAtVersions: bcs.vector(bcs.tuple([Address, bcs.u64()])),
+  sharedObjects: bcs.vector(SuiObjectRef),
+  transactionDigest: ObjectDigest,
+  created: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
+  mutated: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
+  unwrapped: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
+  deleted: bcs.vector(SuiObjectRef),
+  unwrappedThenDeleted: bcs.vector(SuiObjectRef),
+  wrapped: bcs.vector(SuiObjectRef),
+  gasObject: bcs.tuple([SuiObjectRef, Owner]),
+  eventsDigest: bcs.option(ObjectDigest),
+  dependencies: bcs.vector(ObjectDigest)
+});
+var VersionDigest = bcs.tuple([bcs.u64(), ObjectDigest]);
+var ObjectIn = bcs.enum("ObjectIn", {
+  NotExist: null,
+  Exist: bcs.tuple([VersionDigest, Owner])
+});
+var AccumulatorAddress = bcs.struct("AccumulatorAddress", {
+  address: Address,
+  ty: TypeTag
+});
+var AccumulatorOperation = bcs.enum("AccumulatorOperation", {
+  Merge: null,
+  Split: null
+});
+var AccumulatorValue = bcs.enum("AccumulatorValue", {
+  Integer: bcs.u64(),
+  IntegerTuple: bcs.tuple([bcs.u64(), bcs.u64()]),
+  EventDigest: bcs.vector(bcs.tuple([bcs.u64(), ObjectDigest]))
+});
+var AccumulatorWriteV1 = bcs.struct("AccumulatorWriteV1", {
+  address: AccumulatorAddress,
+  operation: AccumulatorOperation,
+  value: AccumulatorValue
+});
+var ObjectOut = bcs.enum("ObjectOut", {
+  NotExist: null,
+  ObjectWrite: bcs.tuple([ObjectDigest, Owner]),
+  PackageWrite: VersionDigest,
+  AccumulatorWriteV1
+});
+var IDOperation = bcs.enum("IDOperation", {
+  None: null,
+  Created: null,
+  Deleted: null
+});
+var EffectsObjectChange = bcs.struct("EffectsObjectChange", {
+  inputState: ObjectIn,
+  outputState: ObjectOut,
+  idOperation: IDOperation
+});
+var UnchangedConsensusKind = bcs.enum("UnchangedConsensusKind", {
+  ReadOnlyRoot: VersionDigest,
+  MutateConsensusStreamEnded: bcs.u64(),
+  ReadConsensusStreamEnded: bcs.u64(),
+  Cancelled: bcs.u64(),
+  PerEpochConfig: null
+});
+var TransactionEffectsV2 = bcs.struct("TransactionEffectsV2", {
+  status: ExecutionStatus,
+  executedEpoch: bcs.u64(),
+  gasUsed: GasCostSummary,
+  transactionDigest: ObjectDigest,
+  gasObjectIndex: bcs.option(bcs.u32()),
+  eventsDigest: bcs.option(ObjectDigest),
+  dependencies: bcs.vector(ObjectDigest),
+  lamportVersion: bcs.u64(),
+  changedObjects: bcs.vector(bcs.tuple([Address, EffectsObjectChange])),
+  unchangedConsensusObjects: bcs.vector(bcs.tuple([Address, UnchangedConsensusKind])),
+  auxDataDigest: bcs.option(ObjectDigest)
+});
+var TransactionEffects = bcs.enum("TransactionEffects", {
+  V1: TransactionEffectsV1,
+  V2: TransactionEffectsV2
+});
+
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/pure.mjs
+function pureBcsSchemaFromTypeName(name) {
+  switch (name) {
+    case "u8":
+      return bcs.u8();
+    case "u16":
+      return bcs.u16();
+    case "u32":
+      return bcs.u32();
+    case "u64":
+      return bcs.u64();
+    case "u128":
+      return bcs.u128();
+    case "u256":
+      return bcs.u256();
+    case "bool":
+      return bcs.bool();
+    case "string":
+      return bcs.string();
+    case "id":
+    case "address":
+      return Address;
+  }
+  const generic = name.match(/^(vector|option)<(.+)>$/);
+  if (generic) {
+    const [kind, inner] = generic.slice(1);
+    if (kind === "vector") return bcs.vector(pureBcsSchemaFromTypeName(inner));
+    else return bcs.option(pureBcsSchemaFromTypeName(inner));
+  }
+  throw new Error(`Invalid Pure type name: ${name}`);
 }
+
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/index.mjs
+var suiBcs = {
+  ...bcs,
+  U8: bcs.u8(),
+  U16: bcs.u16(),
+  U32: bcs.u32(),
+  U64: bcs.u64(),
+  U128: bcs.u128(),
+  U256: bcs.u256(),
+  ULEB128: bcs.uleb128(),
+  Bool: bcs.bool(),
+  String: bcs.string(),
+  Address,
+  AppId,
+  Argument,
+  CallArg,
+  Command,
+  CompressedSignature,
+  Data,
+  GasData,
+  Intent,
+  IntentMessage,
+  IntentScope,
+  IntentVersion,
+  MoveObject,
+  MoveObjectType,
+  MovePackage,
+  MultiSig,
+  MultiSigPkMap,
+  MultiSigPublicKey,
+  Object: ObjectInner,
+  ObjectArg,
+  ObjectDigest,
+  Owner,
+  PasskeyAuthenticator,
+  ProgrammableMoveCall,
+  ProgrammableTransaction,
+  PublicKey,
+  SenderSignedData,
+  SenderSignedTransaction,
+  SharedObjectRef,
+  StructTag,
+  SuiObjectRef,
+  TransactionData,
+  TransactionDataV1,
+  TransactionEffects,
+  TransactionExpiration,
+  TransactionKind,
+  TypeOrigin,
+  TypeTag,
+  UpgradeInfo
+};
+
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/utils/constants.mjs
+var MIST_PER_SUI = BigInt(1e9);
+var MOVE_STDLIB_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000001";
+var SUI_FRAMEWORK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000002";
+var SUI_CLOCK_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
+var SUI_TYPE_ARG = `${SUI_FRAMEWORK_ADDRESS}::sui::SUI`;
+var SUI_SYSTEM_STATE_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000005";
+var SUI_RANDOM_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000008";
+var SUI_DENY_LIST_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000403";
+
+// ../../node_modules/.pnpm/valibot@1.3.1_typescript@5.9.3/node_modules/valibot/dist/index.mjs
+var store$4;
 // @__NO_SIDE_EFFECTS__
-function boolean(message$1) {
+function getGlobalConfig(config$1) {
   return {
-    kind: "schema",
-    type: "boolean",
-    reference: boolean,
-    expects: "boolean",
-    async: false,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (typeof dataset.value === "boolean") dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
   };
 }
+var store$3;
 // @__NO_SIDE_EFFECTS__
-function lazy(getter) {
-  return {
-    kind: "schema",
-    type: "lazy",
-    reference: lazy,
-    expects: "unknown",
-    async: false,
-    getter,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      return this.getter(dataset.value)["~run"](dataset, config$1);
-    }
-  };
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
 }
+var store$2;
 // @__NO_SIDE_EFFECTS__
-function literal(literal_, message$1) {
-  return {
-    kind: "schema",
-    type: "literal",
-    reference: literal,
-    expects: /* @__PURE__ */ _stringify(literal_),
-    async: false,
-    literal: literal_,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (dataset.value === this.literal) dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  };
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
 }
+var store$1;
 // @__NO_SIDE_EFFECTS__
-function nullable(wrapped, default_) {
-  return {
-    kind: "schema",
-    type: "nullable",
-    reference: nullable,
-    expects: `(${wrapped.expects} | null)`,
-    async: false,
-    wrapped,
-    default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (dataset.value === null) {
-        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-        if (dataset.value === null) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped["~run"](dataset, config$1);
-    }
-  };
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
 }
 // @__NO_SIDE_EFFECTS__
-function nullish(wrapped, default_) {
-  return {
-    kind: "schema",
-    type: "nullish",
-    reference: nullish,
-    expects: `(${wrapped.expects} | null | undefined)`,
-    async: false,
-    wrapped,
-    default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (dataset.value === null || dataset.value === void 0) {
-        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-        if (dataset.value === null || dataset.value === void 0) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped["~run"](dataset, config$1);
-    }
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
   };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema) dataset.typed = false;
+  if (dataset.issues) dataset.issues.push(issue);
+  else dataset.issues = [issue];
 }
 // @__NO_SIDE_EFFECTS__
-function number(message$1) {
+function _getStandardProps(context) {
   return {
-    kind: "schema",
-    type: "number",
-    reference: number,
-    expects: "number",
-    async: false,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
+    version: 1,
+    vendor: "valibot",
+    validate(value$1) {
+      return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function object(entries$1, message$1) {
+function _isValidObjectKey(object$1, key) {
+  return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects(values$1, separator) {
+  const list = [...new Set(values$1)];
+  if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+  return list[0] ?? "never";
+}
+var ValiError = class extends Error {
+  /**
+  * Creates a Valibot error with useful information.
+  *
+  * @param issues The error issues.
+  */
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function check(requirement, message$1) {
   return {
-    kind: "schema",
-    type: "object",
-    reference: object,
-    expects: "Object",
+    kind: "validation",
+    type: "check",
+    reference: check,
     async: false,
-    entries: entries$1,
+    expects: null,
+    requirement,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const key in this.entries) {
-          const valueSchema = this.entries[key];
-          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
-            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key,
-                value: value$1
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path) issue.path.unshift(pathItem);
-                else issue.path = [pathItem];
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) dataset.issues = valueDataset.issues;
-              if (config$1.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!valueDataset.typed) dataset.typed = false;
-            dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config$1, {
-              input: void 0,
-              expected: `"${key}"`,
-              path: [{
-                type: "object",
-                origin: "key",
-                input,
-                key,
-                value: input[key]
-              }]
-            });
-            if (config$1.abortEarly) break;
-          }
-        }
-      } else _addIssue(this, "type", dataset, config$1);
+      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "input", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function optional(wrapped, default_) {
+function integer(message$1) {
   return {
-    kind: "schema",
-    type: "optional",
-    reference: optional,
-    expects: `(${wrapped.expects} | undefined)`,
+    kind: "validation",
+    type: "integer",
+    reference: integer,
     async: false,
-    wrapped,
-    default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
+    expects: null,
+    requirement: Number.isInteger,
+    message: message$1,
     "~run"(dataset, config$1) {
-      if (dataset.value === void 0) {
-        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-        if (dataset.value === void 0) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped["~run"](dataset, config$1);
+      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config$1);
+      return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function picklist(options, message$1) {
+function transform(operation) {
   return {
-    kind: "schema",
-    type: "picklist",
-    reference: picklist,
-    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    kind: "transformation",
+    type: "transform",
+    reference: transform,
     async: false,
-    options,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (this.options.includes(dataset.value)) dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
+    operation,
+    "~run"(dataset) {
+      dataset.value = this.operation(dataset.value);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function record(key, value$1, message$1) {
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+// @__NO_SIDE_EFFECTS__
+function is(schema, input) {
+  return !schema["~run"]({ value: input }, { abortEarly: true }).issues;
+}
+// @__NO_SIDE_EFFECTS__
+function array(item, message$1) {
   return {
     kind: "schema",
-    type: "record",
-    reference: record,
-    expects: "Object",
+    type: "array",
+    reference: array,
+    expects: "Array",
     async: false,
-    key,
-    value: value$1,
+    item,
     message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
     "~run"(dataset, config$1) {
       const input = dataset.value;
-      if (input && typeof input === "object") {
+      if (Array.isArray(input)) {
         dataset.typed = true;
-        dataset.value = {};
-        for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
-          const entryValue = input[entryKey];
-          const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
-          if (keyDataset.issues) {
-            const pathItem = {
-              type: "object",
-              origin: "key",
-              input,
-              key: entryKey,
-              value: entryValue
-            };
-            for (const issue of keyDataset.issues) {
-              issue.path = [pathItem];
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) dataset.issues = keyDataset.issues;
-            if (config$1.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
-          if (valueDataset.issues) {
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value$1 = input[key];
+          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+          if (itemDataset.issues) {
             const pathItem = {
-              type: "object",
+              type: "array",
               origin: "value",
               input,
-              key: entryKey,
-              value: entryValue
+              key,
+              value: value$1
             };
-            for (const issue of valueDataset.issues) {
+            for (const issue of itemDataset.issues) {
               if (issue.path) issue.path.unshift(pathItem);
               else issue.path = [pathItem];
               dataset.issues?.push(issue);
             }
-            if (!dataset.issues) dataset.issues = valueDataset.issues;
+            if (!dataset.issues) dataset.issues = itemDataset.issues;
             if (config$1.abortEarly) {
               dataset.typed = false;
               break;
             }
           }
-          if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
-          if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+          if (!itemDataset.typed) dataset.typed = false;
+          dataset.value.push(itemDataset.value);
         }
       } else _addIssue(this, "type", dataset, config$1);
       return dataset;
@@ -538,1066 +863,751 @@ function record(key, value$1, message$1) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function string(message$1) {
+function bigint(message$1) {
   return {
     kind: "schema",
-    type: "string",
-    reference: string,
-    expects: "string",
+    type: "bigint",
+    reference: bigint,
+    expects: "bigint",
     async: false,
     message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
     "~run"(dataset, config$1) {
-      if (typeof dataset.value === "string") dataset.typed = true;
+      if (typeof dataset.value === "bigint") dataset.typed = true;
       else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function tuple(items, message$1) {
+function boolean(message$1) {
   return {
     kind: "schema",
-    type: "tuple",
-    reference: tuple,
-    expects: "Array",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
     async: false,
-    items,
     message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
     "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (Array.isArray(input)) {
-        dataset.typed = true;
-        dataset.value = [];
-        for (let key = 0; key < this.items.length; key++) {
-          const value$1 = input[key];
-          const itemDataset = this.items[key]["~run"]({ value: value$1 }, config$1);
-          if (itemDataset.issues) {
-            const pathItem = {
-              type: "array",
-              origin: "value",
-              input,
-              key,
-              value: value$1
-            };
-            for (const issue of itemDataset.issues) {
-              if (issue.path) issue.path.unshift(pathItem);
-              else issue.path = [pathItem];
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) dataset.issues = itemDataset.issues;
-            if (config$1.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!itemDataset.typed) dataset.typed = false;
-          dataset.value.push(itemDataset.value);
-        }
-      } else _addIssue(this, "type", dataset, config$1);
+      if (typeof dataset.value === "boolean") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function _subIssues(datasets) {
-  let issues;
-  if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
-  else issues = dataset.issues;
-  return issues;
+function lazy(getter) {
+  return {
+    kind: "schema",
+    type: "lazy",
+    reference: lazy,
+    expects: "unknown",
+    async: false,
+    getter,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      return this.getter(dataset.value)["~run"](dataset, config$1);
+    }
+  };
 }
 // @__NO_SIDE_EFFECTS__
-function union(options, message$1) {
+function literal(literal_, message$1) {
   return {
     kind: "schema",
-    type: "union",
-    reference: union,
-    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+    type: "literal",
+    reference: literal,
+    expects: /* @__PURE__ */ _stringify(literal_),
     async: false,
-    options,
+    literal: literal_,
     message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
     "~run"(dataset, config$1) {
-      let validDataset;
-      let typedDatasets;
-      let untypedDatasets;
-      for (const schema of this.options) {
-        const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
-        if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
-        else typedDatasets = [optionDataset];
-        else {
-          validDataset = optionDataset;
-          break;
+      if (dataset.value === this.literal) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function nullable(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "nullable",
+    reference: nullable,
+    expects: `(${wrapped.expects} | null)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === null) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === null) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function nullish(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "nullish",
+    reference: nullish,
+    expects: `(${wrapped.expects} | null | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === null || dataset.value === void 0) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === null || dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
         }
-        else if (untypedDatasets) untypedDatasets.push(optionDataset);
-        else untypedDatasets = [optionDataset];
       }
-      if (validDataset) return validDataset;
-      if (typedDatasets) {
-        if (typedDatasets.length === 1) return typedDatasets[0];
-        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
-        dataset.typed = true;
-      } else if (untypedDatasets?.length === 1) return untypedDatasets[0];
-      else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
-      return dataset;
+      return this.wrapped["~run"](dataset, config$1);
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function unknown() {
+function number(message$1) {
   return {
     kind: "schema",
-    type: "unknown",
-    reference: unknown,
-    expects: "unknown",
+    type: "number",
+    reference: number,
+    expects: "number",
     async: false,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset) {
-      dataset.typed = true;
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
 }
-function parse(schema, input, config$1) {
-  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
-  if (dataset.issues) throw new ValiError(dataset.issues);
-  return dataset.value;
-}
 // @__NO_SIDE_EFFECTS__
-function pipe(...pipe$1) {
+function object(entries$1, message$1) {
   return {
-    ...pipe$1[0],
-    pipe: pipe$1,
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      for (const item of pipe$1) if (item.kind !== "metadata") {
-        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
-          dataset.typed = false;
-          break;
-        }
-        if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
-      }
-      return dataset;
-    }
-  };
-}
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/data/internal.mjs
-function safeEnum(options) {
-  return union(Object.keys(options).map((key) => withKind(key, object({ [key]: options[key] }))));
-}
-function withKind(key, schema) {
-  return pipe(object({
-    ...schema.entries,
-    $kind: optional(literal(key))
-  }), transform((value) => ({
-    ...value,
-    $kind: key
-  })));
-}
-var SuiAddress = pipe(string(), transform((value) => normalizeSuiAddress(value)), check(isValidSuiAddress));
-var ObjectID = SuiAddress;
-var BCSBytes = string();
-var JsonU64 = pipe(union([string(), pipe(number(), integer())]), check((val) => {
-  try {
-    BigInt(val);
-    return BigInt(val) >= 0 && BigInt(val) <= 18446744073709551615n;
-  } catch {
-    return false;
-  }
-}, "Invalid u64"));
-var U32 = pipe(number(), integer(), check((val) => val >= 0 && val < 2 ** 32, "Invalid u32"));
-var ObjectRefSchema = object({
-  objectId: SuiAddress,
-  version: JsonU64,
-  digest: string()
-});
-var ArgumentSchema = union([
-  withKind("GasCoin", object({ GasCoin: literal(true) })),
-  withKind("Input", object({
-    Input: pipe(number(), integer()),
-    type: optional(union([
-      literal("pure"),
-      literal("object"),
-      literal("withdrawal")
-    ]))
-  })),
-  withKind("Result", object({ Result: pipe(number(), integer()) })),
-  withKind("NestedResult", object({ NestedResult: tuple([pipe(number(), integer()), pipe(number(), integer())]) }))
-]);
-var GasDataSchema = object({
-  budget: nullable(JsonU64),
-  price: nullable(JsonU64),
-  owner: nullable(SuiAddress),
-  payment: nullable(array(ObjectRefSchema))
-});
-var StructTagSchema = object({
-  address: string(),
-  module: string(),
-  name: string(),
-  typeParams: array(string())
-});
-var OpenSignatureBodySchema = union([
-  object({ $kind: literal("address") }),
-  object({ $kind: literal("bool") }),
-  object({ $kind: literal("u8") }),
-  object({ $kind: literal("u16") }),
-  object({ $kind: literal("u32") }),
-  object({ $kind: literal("u64") }),
-  object({ $kind: literal("u128") }),
-  object({ $kind: literal("u256") }),
-  object({ $kind: literal("unknown") }),
-  object({
-    $kind: literal("vector"),
-    vector: lazy(() => OpenSignatureBodySchema)
-  }),
-  object({
-    $kind: literal("datatype"),
-    datatype: object({
-      typeName: string(),
-      typeParameters: array(lazy(() => OpenSignatureBodySchema))
-    })
-  }),
-  object({
-    $kind: literal("typeParameter"),
-    index: pipe(number(), integer())
-  })
-]);
-var OpenSignatureSchema = object({
-  reference: nullable(union([
-    literal("mutable"),
-    literal("immutable"),
-    literal("unknown")
-  ])),
-  body: OpenSignatureBodySchema
-});
-var ProgrammableMoveCallSchema = object({
-  package: ObjectID,
-  module: string(),
-  function: string(),
-  typeArguments: array(string()),
-  arguments: array(ArgumentSchema),
-  _argumentTypes: optional(nullable(array(OpenSignatureSchema)))
-});
-var $Intent = object({
-  name: string(),
-  inputs: record(string(), union([ArgumentSchema, array(ArgumentSchema)])),
-  data: record(string(), unknown())
-});
-var CommandSchema = safeEnum({
-  MoveCall: ProgrammableMoveCallSchema,
-  TransferObjects: object({
-    objects: array(ArgumentSchema),
-    address: ArgumentSchema
-  }),
-  SplitCoins: object({
-    coin: ArgumentSchema,
-    amounts: array(ArgumentSchema)
-  }),
-  MergeCoins: object({
-    destination: ArgumentSchema,
-    sources: array(ArgumentSchema)
-  }),
-  Publish: object({
-    modules: array(BCSBytes),
-    dependencies: array(ObjectID)
-  }),
-  MakeMoveVec: object({
-    type: nullable(string()),
-    elements: array(ArgumentSchema)
-  }),
-  Upgrade: object({
-    modules: array(BCSBytes),
-    dependencies: array(ObjectID),
-    package: ObjectID,
-    ticket: ArgumentSchema
-  }),
-  $Intent
-});
-var ObjectArgSchema = safeEnum({
-  ImmOrOwnedObject: ObjectRefSchema,
-  SharedObject: object({
-    objectId: ObjectID,
-    initialSharedVersion: JsonU64,
-    mutable: boolean()
-  }),
-  Receiving: ObjectRefSchema
-});
-var ReservationSchema = safeEnum({ MaxAmountU64: JsonU64 });
-var WithdrawalTypeArgSchema = safeEnum({ Balance: string() });
-var WithdrawFromSchema = safeEnum({
-  Sender: literal(true),
-  Sponsor: literal(true)
-});
-var FundsWithdrawalArgSchema = object({
-  reservation: ReservationSchema,
-  typeArg: WithdrawalTypeArgSchema,
-  withdrawFrom: WithdrawFromSchema
-});
-var CallArgSchema = safeEnum({
-  Object: ObjectArgSchema,
-  Pure: object({ bytes: BCSBytes }),
-  UnresolvedPure: object({ value: unknown() }),
-  UnresolvedObject: object({
-    objectId: ObjectID,
-    version: optional(nullable(JsonU64)),
-    digest: optional(nullable(string())),
-    initialSharedVersion: optional(nullable(JsonU64)),
-    mutable: optional(nullable(boolean()))
-  }),
-  FundsWithdrawal: FundsWithdrawalArgSchema
-});
-var NormalizedCallArg = safeEnum({
-  Object: ObjectArgSchema,
-  Pure: object({ bytes: BCSBytes })
-});
-var ValidDuringSchema = object({
-  minEpoch: nullable(JsonU64),
-  maxEpoch: nullable(JsonU64),
-  minTimestamp: nullable(JsonU64),
-  maxTimestamp: nullable(JsonU64),
-  chain: string(),
-  nonce: U32
-});
-var TransactionExpiration = safeEnum({
-  None: literal(true),
-  Epoch: JsonU64,
-  ValidDuring: ValidDuringSchema
-});
-var TransactionDataSchema = object({
-  version: literal(2),
-  sender: nullish(SuiAddress),
-  expiration: nullish(TransactionExpiration),
-  gasData: GasDataSchema,
-  inputs: array(CallArgSchema),
-  commands: array(CommandSchema)
-});
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/utils.mjs
-function getIdFromCallArg(arg) {
-  if (typeof arg === "string") return normalizeSuiAddress(arg);
-  if (arg.Object) {
-    if (arg.Object.ImmOrOwnedObject) return normalizeSuiAddress(arg.Object.ImmOrOwnedObject.objectId);
-    if (arg.Object.Receiving) return normalizeSuiAddress(arg.Object.Receiving.objectId);
-    return normalizeSuiAddress(arg.Object.SharedObject.objectId);
-  }
-  if (arg.UnresolvedObject) return normalizeSuiAddress(arg.UnresolvedObject.objectId);
-}
-function isArgument(value) {
-  return is(ArgumentSchema, value);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
 }
-function remapCommandArguments(command, inputMapping, commandMapping) {
-  const remapArg = (arg) => {
-    switch (arg.$kind) {
-      case "Input": {
-        const newInputIndex = inputMapping.get(arg.Input);
-        if (newInputIndex === void 0) throw new Error(`Input ${arg.Input} not found in input mapping`);
-        return {
-          ...arg,
-          Input: newInputIndex
-        };
-      }
-      case "Result": {
-        const newCommandIndex = commandMapping.get(arg.Result);
-        if (newCommandIndex !== void 0) return {
-          ...arg,
-          Result: newCommandIndex
-        };
-        return arg;
-      }
-      case "NestedResult": {
-        const newCommandIndex = commandMapping.get(arg.NestedResult[0]);
-        if (newCommandIndex !== void 0) return {
-          ...arg,
-          NestedResult: [newCommandIndex, arg.NestedResult[1]]
-        };
-        return arg;
+// @__NO_SIDE_EFFECTS__
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
       }
-      default:
-        return arg;
+      return this.wrapped["~run"](dataset, config$1);
     }
   };
-  switch (command.$kind) {
-    case "MoveCall":
-      command.MoveCall.arguments = command.MoveCall.arguments.map(remapArg);
-      break;
-    case "TransferObjects":
-      command.TransferObjects.objects = command.TransferObjects.objects.map(remapArg);
-      command.TransferObjects.address = remapArg(command.TransferObjects.address);
-      break;
-    case "SplitCoins":
-      command.SplitCoins.coin = remapArg(command.SplitCoins.coin);
-      command.SplitCoins.amounts = command.SplitCoins.amounts.map(remapArg);
-      break;
-    case "MergeCoins":
-      command.MergeCoins.destination = remapArg(command.MergeCoins.destination);
-      command.MergeCoins.sources = command.MergeCoins.sources.map(remapArg);
-      break;
-    case "MakeMoveVec":
-      command.MakeMoveVec.elements = command.MakeMoveVec.elements.map(remapArg);
-      break;
-    case "Upgrade":
-      command.Upgrade.ticket = remapArg(command.Upgrade.ticket);
-      break;
-    case "$Intent": {
-      const inputs = command.$Intent.inputs;
-      command.$Intent.inputs = {};
-      for (const [key, value] of Object.entries(inputs)) command.$Intent.inputs[key] = Array.isArray(value) ? value.map(remapArg) : remapArg(value);
-      break;
+}
+// @__NO_SIDE_EFFECTS__
+function picklist(options, message$1) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (this.options.includes(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
     }
-    case "Publish":
-      break;
-  }
+  };
 }
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/type-tag-serializer.mjs
-var VECTOR_REGEX = /^vector<(.+)>$/;
-var STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
-var TypeTagSerializer = class TypeTagSerializer2 {
-  static parseFromStr(str, normalizeAddress = false) {
-    if (str === "address") return { address: null };
-    else if (str === "bool") return { bool: null };
-    else if (str === "u8") return { u8: null };
-    else if (str === "u16") return { u16: null };
-    else if (str === "u32") return { u32: null };
-    else if (str === "u64") return { u64: null };
-    else if (str === "u128") return { u128: null };
-    else if (str === "u256") return { u256: null };
-    else if (str === "signer") return { signer: null };
-    const vectorMatch = str.match(VECTOR_REGEX);
-    if (vectorMatch) return { vector: TypeTagSerializer2.parseFromStr(vectorMatch[1], normalizeAddress) };
-    const structMatch = str.match(STRUCT_REGEX);
-    if (structMatch) return { struct: {
-      address: normalizeAddress ? normalizeSuiAddress(structMatch[1]) : structMatch[1],
-      module: structMatch[2],
-      name: structMatch[3],
-      typeParams: structMatch[5] === void 0 ? [] : TypeTagSerializer2.parseStructTypeArgs(structMatch[5], normalizeAddress)
-    } };
-    throw new Error(`Encountered unexpected token when parsing type args for ${str}`);
-  }
-  static parseStructTypeArgs(str, normalizeAddress = false) {
-    return splitGenericParameters(str).map((tok) => TypeTagSerializer2.parseFromStr(tok, normalizeAddress));
-  }
-  static tagToString(tag) {
-    if ("bool" in tag) return "bool";
-    if ("u8" in tag) return "u8";
-    if ("u16" in tag) return "u16";
-    if ("u32" in tag) return "u32";
-    if ("u64" in tag) return "u64";
-    if ("u128" in tag) return "u128";
-    if ("u256" in tag) return "u256";
-    if ("address" in tag) return "address";
-    if ("signer" in tag) return "signer";
-    if ("vector" in tag) return `vector<${TypeTagSerializer2.tagToString(tag.vector)}>`;
-    if ("struct" in tag) {
-      const struct = tag.struct;
-      const typeParams = struct.typeParams.map(TypeTagSerializer2.tagToString).join(", ");
-      return `${struct.address}::${struct.module}::${struct.name}${typeParams ? `<${typeParams}>` : ""}`;
+// @__NO_SIDE_EFFECTS__
+function record(key, value$1, message$1) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+          const entryValue = input[entryKey];
+          const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+          if (keyDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "key",
+              input,
+              key: entryKey,
+              value: entryValue
+            };
+            for (const issue of keyDataset.issues) {
+              issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = keyDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+          if (valueDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "value",
+              input,
+              key: entryKey,
+              value: entryValue
+            };
+            for (const issue of valueDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = valueDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+          if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
     }
-    throw new Error("Invalid TypeTag");
-  }
-};
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/bcs.mjs
-function unsafe_u64(options) {
-  return bcs.u64({
-    name: "unsafe_u64",
-    ...options
-  }).transform({
-    input: (val) => val,
-    output: (val) => Number(val)
-  });
+  };
 }
-function optionEnum(type) {
-  return bcs.enum("Option", {
-    None: null,
-    Some: type
-  });
+// @__NO_SIDE_EFFECTS__
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
 }
-var Address = bcs.bytes(SUI_ADDRESS_LENGTH).transform({
-  validate: (val) => {
-    const address = typeof val === "string" ? val : toHex(val);
-    if (!address || !isValidSuiAddress(normalizeSuiAddress(address))) throw new Error(`Invalid Sui address ${address}`);
-  },
-  input: (val) => typeof val === "string" ? fromHex(normalizeSuiAddress(val)) : val,
-  output: (val) => normalizeSuiAddress(toHex(val))
-});
-var ObjectDigest = bcs.byteVector().transform({
-  name: "ObjectDigest",
-  input: (value) => fromBase58(value),
-  output: (value) => toBase58(new Uint8Array(value)),
-  validate: (value) => {
-    if (fromBase58(value).length !== 32) throw new Error("ObjectDigest must be 32 bytes");
-  }
-});
-var SuiObjectRef = bcs.struct("SuiObjectRef", {
-  objectId: Address,
-  version: bcs.u64(),
-  digest: ObjectDigest
-});
-var SharedObjectRef = bcs.struct("SharedObjectRef", {
-  objectId: Address,
-  initialSharedVersion: bcs.u64(),
-  mutable: bcs.bool()
-});
-var ObjectArg = bcs.enum("ObjectArg", {
-  ImmOrOwnedObject: SuiObjectRef,
-  SharedObject: SharedObjectRef,
-  Receiving: SuiObjectRef
-});
-var Owner = bcs.enum("Owner", {
-  AddressOwner: Address,
-  ObjectOwner: Address,
-  Shared: bcs.struct("Shared", { initialSharedVersion: bcs.u64() }),
-  Immutable: null,
-  ConsensusAddressOwner: bcs.struct("ConsensusAddressOwner", {
-    startVersion: bcs.u64(),
-    owner: Address
-  })
-});
-var Reservation = bcs.enum("Reservation", { MaxAmountU64: bcs.u64() });
-var WithdrawalType = bcs.enum("WithdrawalType", { Balance: bcs.lazy(() => TypeTag) });
-var WithdrawFrom = bcs.enum("WithdrawFrom", {
-  Sender: null,
-  Sponsor: null
-});
-var FundsWithdrawal = bcs.struct("FundsWithdrawal", {
-  reservation: Reservation,
-  typeArg: WithdrawalType,
-  withdrawFrom: WithdrawFrom
-});
-var CallArg = bcs.enum("CallArg", {
-  Pure: bcs.struct("Pure", { bytes: bcs.byteVector().transform({
-    input: (val) => typeof val === "string" ? fromBase64(val) : val,
-    output: (val) => toBase64(new Uint8Array(val))
-  }) }),
-  Object: ObjectArg,
-  FundsWithdrawal
-});
-var InnerTypeTag = bcs.enum("TypeTag", {
-  bool: null,
-  u8: null,
-  u64: null,
-  u128: null,
-  address: null,
-  signer: null,
-  vector: bcs.lazy(() => InnerTypeTag),
-  struct: bcs.lazy(() => StructTag),
-  u16: null,
-  u32: null,
-  u256: null
-});
-var TypeTag = InnerTypeTag.transform({
-  input: (typeTag) => typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag, true) : typeTag,
-  output: (typeTag) => TypeTagSerializer.tagToString(typeTag)
-});
-var Argument = bcs.enum("Argument", {
-  GasCoin: null,
-  Input: bcs.u16(),
-  Result: bcs.u16(),
-  NestedResult: bcs.tuple([bcs.u16(), bcs.u16()])
-});
-var ProgrammableMoveCall = bcs.struct("ProgrammableMoveCall", {
-  package: Address,
-  module: bcs.string(),
-  function: bcs.string(),
-  typeArguments: bcs.vector(TypeTag),
-  arguments: bcs.vector(Argument)
-});
-var Command = bcs.enum("Command", {
-  MoveCall: ProgrammableMoveCall,
-  TransferObjects: bcs.struct("TransferObjects", {
-    objects: bcs.vector(Argument),
-    address: Argument
-  }),
-  SplitCoins: bcs.struct("SplitCoins", {
-    coin: Argument,
-    amounts: bcs.vector(Argument)
-  }),
-  MergeCoins: bcs.struct("MergeCoins", {
-    destination: Argument,
-    sources: bcs.vector(Argument)
-  }),
-  Publish: bcs.struct("Publish", {
-    modules: bcs.vector(bcs.byteVector().transform({
-      input: (val) => typeof val === "string" ? fromBase64(val) : val,
-      output: (val) => toBase64(new Uint8Array(val))
-    })),
-    dependencies: bcs.vector(Address)
-  }),
-  MakeMoveVec: bcs.struct("MakeMoveVec", {
-    type: optionEnum(TypeTag).transform({
-      input: (val) => val === null ? { None: true } : { Some: val },
-      output: (val) => val.Some ?? null
-    }),
-    elements: bcs.vector(Argument)
-  }),
-  Upgrade: bcs.struct("Upgrade", {
-    modules: bcs.vector(bcs.byteVector().transform({
-      input: (val) => typeof val === "string" ? fromBase64(val) : val,
-      output: (val) => toBase64(new Uint8Array(val))
-    })),
-    dependencies: bcs.vector(Address),
-    package: Address,
-    ticket: Argument
-  })
-});
-var ProgrammableTransaction = bcs.struct("ProgrammableTransaction", {
-  inputs: bcs.vector(CallArg),
-  commands: bcs.vector(Command)
-});
-var TransactionKind = bcs.enum("TransactionKind", {
-  ProgrammableTransaction,
-  ChangeEpoch: null,
-  Genesis: null,
-  ConsensusCommitPrologue: null
-});
-var ValidDuring = bcs.struct("ValidDuring", {
-  minEpoch: bcs.option(bcs.u64()),
-  maxEpoch: bcs.option(bcs.u64()),
-  minTimestamp: bcs.option(bcs.u64()),
-  maxTimestamp: bcs.option(bcs.u64()),
-  chain: ObjectDigest,
-  nonce: bcs.u32()
-});
-var TransactionExpiration2 = bcs.enum("TransactionExpiration", {
-  None: null,
-  Epoch: unsafe_u64(),
-  ValidDuring
-});
-var StructTag = bcs.struct("StructTag", {
-  address: Address,
-  module: bcs.string(),
-  name: bcs.string(),
-  typeParams: bcs.vector(InnerTypeTag)
-});
-var GasData = bcs.struct("GasData", {
-  payment: bcs.vector(SuiObjectRef),
-  owner: Address,
-  price: bcs.u64(),
-  budget: bcs.u64()
-});
-var TransactionDataV1 = bcs.struct("TransactionDataV1", {
-  kind: TransactionKind,
-  sender: Address,
-  gasData: GasData,
-  expiration: TransactionExpiration2
-});
-var TransactionData = bcs.enum("TransactionData", { V1: TransactionDataV1 });
-var IntentScope = bcs.enum("IntentScope", {
-  TransactionData: null,
-  TransactionEffects: null,
-  CheckpointSummary: null,
-  PersonalMessage: null
-});
-var IntentVersion = bcs.enum("IntentVersion", { V0: null });
-var AppId = bcs.enum("AppId", { Sui: null });
-var Intent = bcs.struct("Intent", {
-  scope: IntentScope,
-  version: IntentVersion,
-  appId: AppId
-});
-function IntentMessage(T) {
-  return bcs.struct(`IntentMessage<${T.name}>`, {
-    intent: Intent,
-    value: T
-  });
+// @__NO_SIDE_EFFECTS__
+function tuple(items, message$1) {
+  return {
+    kind: "schema",
+    type: "tuple",
+    reference: tuple,
+    expects: "Array",
+    async: false,
+    items,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < this.items.length; key++) {
+          const value$1 = input[key];
+          const itemDataset = this.items[key]["~run"]({ value: value$1 }, config$1);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value$1
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = itemDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) dataset.typed = false;
+          dataset.value.push(itemDataset.value);
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
+  else issues = dataset.issues;
+  return issues;
+}
+// @__NO_SIDE_EFFECTS__
+function union(options, message$1) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
+        if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+        else typedDatasets = [optionDataset];
+        else {
+          validDataset = optionDataset;
+          break;
+        }
+        else if (untypedDatasets) untypedDatasets.push(optionDataset);
+        else untypedDatasets = [optionDataset];
+      }
+      if (validDataset) return validDataset;
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) return typedDatasets[0];
+        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+      else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function unknown() {
+  return {
+    kind: "schema",
+    type: "unknown",
+    reference: unknown,
+    expects: "unknown",
+    async: false,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+function parse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  if (dataset.issues) throw new ValiError(dataset.issues);
+  return dataset.value;
+}
+// @__NO_SIDE_EFFECTS__
+function pipe(...pipe$1) {
+  return {
+    ...pipe$1[0],
+    pipe: pipe$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      for (const item of pipe$1) if (item.kind !== "metadata") {
+        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+          dataset.typed = false;
+          break;
+        }
+        if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+      }
+      return dataset;
+    }
+  };
 }
-var CompressedSignature = bcs.enum("CompressedSignature", {
-  ED25519: bcs.bytes(64),
-  Secp256k1: bcs.bytes(64),
-  Secp256r1: bcs.bytes(64),
-  ZkLogin: bcs.byteVector(),
-  Passkey: bcs.byteVector()
-});
-var PublicKey = bcs.enum("PublicKey", {
-  ED25519: bcs.bytes(32),
-  Secp256k1: bcs.bytes(33),
-  Secp256r1: bcs.bytes(33),
-  ZkLogin: bcs.byteVector(),
-  Passkey: bcs.bytes(33)
-});
-var MultiSigPkMap = bcs.struct("MultiSigPkMap", {
-  pubKey: PublicKey,
-  weight: bcs.u8()
-});
-var MultiSigPublicKey = bcs.struct("MultiSigPublicKey", {
-  pk_map: bcs.vector(MultiSigPkMap),
-  threshold: bcs.u16()
-});
-var MultiSig = bcs.struct("MultiSig", {
-  sigs: bcs.vector(CompressedSignature),
-  bitmap: bcs.u16(),
-  multisig_pk: MultiSigPublicKey
-});
-var base64String = bcs.byteVector().transform({
-  input: (val) => typeof val === "string" ? fromBase64(val) : val,
-  output: (val) => toBase64(new Uint8Array(val))
-});
-var SenderSignedTransaction = bcs.struct("SenderSignedTransaction", {
-  intentMessage: IntentMessage(TransactionData),
-  txSignatures: bcs.vector(base64String)
-});
-var SenderSignedData = bcs.vector(SenderSignedTransaction, { name: "SenderSignedData" });
-var PasskeyAuthenticator = bcs.struct("PasskeyAuthenticator", {
-  authenticatorData: bcs.byteVector(),
-  clientDataJson: bcs.string(),
-  userSignature: bcs.byteVector()
-});
-var MoveObjectType = bcs.enum("MoveObjectType", {
-  Other: StructTag,
-  GasCoin: null,
-  StakedSui: null,
-  Coin: TypeTag,
-  AccumulatorBalanceWrapper: null
-});
-var TypeOrigin = bcs.struct("TypeOrigin", {
-  moduleName: bcs.string(),
-  datatypeName: bcs.string(),
-  package: Address
-});
-var UpgradeInfo = bcs.struct("UpgradeInfo", {
-  upgradedId: Address,
-  upgradedVersion: bcs.u64()
-});
-var MovePackage = bcs.struct("MovePackage", {
-  id: Address,
-  version: bcs.u64(),
-  moduleMap: bcs.map(bcs.string(), bcs.byteVector()),
-  typeOriginTable: bcs.vector(TypeOrigin),
-  linkageTable: bcs.map(Address, UpgradeInfo)
-});
-var MoveObject = bcs.struct("MoveObject", {
-  type: MoveObjectType,
-  hasPublicTransfer: bcs.bool(),
-  version: bcs.u64(),
-  contents: bcs.byteVector()
-});
-var Data = bcs.enum("Data", {
-  Move: MoveObject,
-  Package: MovePackage
-});
-var ObjectInner = bcs.struct("ObjectInner", {
-  data: Data,
-  owner: Owner,
-  previousTransaction: ObjectDigest,
-  storageRebate: bcs.u64()
-});
 
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/effects.mjs
-var PackageUpgradeError = bcs.enum("PackageUpgradeError", {
-  UnableToFetchPackage: bcs.struct("UnableToFetchPackage", { packageId: Address }),
-  NotAPackage: bcs.struct("NotAPackage", { objectId: Address }),
-  IncompatibleUpgrade: null,
-  DigestDoesNotMatch: bcs.struct("DigestDoesNotMatch", { digest: bcs.byteVector() }),
-  UnknownUpgradePolicy: bcs.struct("UnknownUpgradePolicy", { policy: bcs.u8() }),
-  PackageIDDoesNotMatch: bcs.struct("PackageIDDoesNotMatch", {
-    packageId: Address,
-    ticketId: Address
-  })
-});
-var ModuleId = bcs.struct("ModuleId", {
-  address: Address,
-  name: bcs.string()
-});
-var MoveLocation = bcs.struct("MoveLocation", {
-  module: ModuleId,
-  function: bcs.u16(),
-  instruction: bcs.u16(),
-  functionName: bcs.option(bcs.string())
-});
-var CommandArgumentError = bcs.enum("CommandArgumentError", {
-  TypeMismatch: null,
-  InvalidBCSBytes: null,
-  InvalidUsageOfPureArg: null,
-  InvalidArgumentToPrivateEntryFunction: null,
-  IndexOutOfBounds: bcs.struct("IndexOutOfBounds", { idx: bcs.u16() }),
-  SecondaryIndexOutOfBounds: bcs.struct("SecondaryIndexOutOfBounds", {
-    resultIdx: bcs.u16(),
-    secondaryIdx: bcs.u16()
-  }),
-  InvalidResultArity: bcs.struct("InvalidResultArity", { resultIdx: bcs.u16() }),
-  InvalidGasCoinUsage: null,
-  InvalidValueUsage: null,
-  InvalidObjectByValue: null,
-  InvalidObjectByMutRef: null,
-  SharedObjectOperationNotAllowed: null,
-  InvalidArgumentArity: null,
-  InvalidTransferObject: null,
-  InvalidMakeMoveVecNonObjectArgument: null,
-  ArgumentWithoutValue: null,
-  CannotMoveBorrowedValue: null,
-  CannotWriteToExtendedReference: null,
-  InvalidReferenceArgument: null
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/data/internal.mjs
+function safeEnum(options) {
+  return union(Object.keys(options).map((key) => withKind(key, object({ [key]: options[key] }))));
+}
+function withKind(key, schema) {
+  return pipe(object({
+    ...schema.entries,
+    $kind: optional(literal(key))
+  }), transform((value) => ({
+    ...value,
+    $kind: key
+  })));
+}
+var SuiAddress = pipe(string(), transform((value) => normalizeSuiAddress(value)), check(isValidSuiAddress));
+var ObjectID = SuiAddress;
+var BCSBytes = string();
+var JsonU64 = pipe(union([string(), pipe(number(), integer())]), check((val) => {
+  try {
+    BigInt(val);
+    return BigInt(val) >= 0 && BigInt(val) <= 18446744073709551615n;
+  } catch {
+    return false;
+  }
+}, "Invalid u64"));
+var U32 = pipe(number(), integer(), check((val) => val >= 0 && val < 2 ** 32, "Invalid u32"));
+var ObjectRefSchema = object({
+  objectId: SuiAddress,
+  version: JsonU64,
+  digest: string()
 });
-var TypeArgumentError = bcs.enum("TypeArgumentError", {
-  TypeNotFound: null,
-  ConstraintNotSatisfied: null
+var ArgumentSchema = union([
+  withKind("GasCoin", object({ GasCoin: literal(true) })),
+  withKind("Input", object({
+    Input: pipe(number(), integer()),
+    type: optional(union([
+      literal("pure"),
+      literal("object"),
+      literal("withdrawal")
+    ]))
+  })),
+  withKind("Result", object({ Result: pipe(number(), integer()) })),
+  withKind("NestedResult", object({ NestedResult: tuple([pipe(number(), integer()), pipe(number(), integer())]) }))
+]);
+var GasDataSchema = object({
+  budget: nullable(JsonU64),
+  price: nullable(JsonU64),
+  owner: nullable(SuiAddress),
+  payment: nullable(array(ObjectRefSchema))
 });
-var ExecutionFailureStatus = bcs.enum("ExecutionFailureStatus", {
-  InsufficientGas: null,
-  InvalidGasObject: null,
-  InvariantViolation: null,
-  FeatureNotYetSupported: null,
-  MoveObjectTooBig: bcs.struct("MoveObjectTooBig", {
-    objectSize: bcs.u64(),
-    maxObjectSize: bcs.u64()
-  }),
-  MovePackageTooBig: bcs.struct("MovePackageTooBig", {
-    objectSize: bcs.u64(),
-    maxObjectSize: bcs.u64()
-  }),
-  CircularObjectOwnership: bcs.struct("CircularObjectOwnership", { object: Address }),
-  InsufficientCoinBalance: null,
-  CoinBalanceOverflow: null,
-  PublishErrorNonZeroAddress: null,
-  SuiMoveVerificationError: null,
-  MovePrimitiveRuntimeError: bcs.option(MoveLocation),
-  MoveAbort: bcs.tuple([MoveLocation, bcs.u64()]),
-  VMVerificationOrDeserializationError: null,
-  VMInvariantViolation: null,
-  FunctionNotFound: null,
-  ArityMismatch: null,
-  TypeArityMismatch: null,
-  NonEntryFunctionInvoked: null,
-  CommandArgumentError: bcs.struct("CommandArgumentError", {
-    argIdx: bcs.u16(),
-    kind: CommandArgumentError
+var StructTagSchema = object({
+  address: string(),
+  module: string(),
+  name: string(),
+  typeParams: array(string())
+});
+var OpenSignatureBodySchema = union([
+  object({ $kind: literal("address") }),
+  object({ $kind: literal("bool") }),
+  object({ $kind: literal("u8") }),
+  object({ $kind: literal("u16") }),
+  object({ $kind: literal("u32") }),
+  object({ $kind: literal("u64") }),
+  object({ $kind: literal("u128") }),
+  object({ $kind: literal("u256") }),
+  object({ $kind: literal("unknown") }),
+  object({
+    $kind: literal("vector"),
+    vector: lazy(() => OpenSignatureBodySchema)
   }),
-  TypeArgumentError: bcs.struct("TypeArgumentError", {
-    argumentIdx: bcs.u16(),
-    kind: TypeArgumentError
+  object({
+    $kind: literal("datatype"),
+    datatype: object({
+      typeName: string(),
+      typeParameters: array(lazy(() => OpenSignatureBodySchema))
+    })
   }),
-  UnusedValueWithoutDrop: bcs.struct("UnusedValueWithoutDrop", {
-    resultIdx: bcs.u16(),
-    secondaryIdx: bcs.u16()
+  object({
+    $kind: literal("typeParameter"),
+    index: pipe(number(), integer())
+  })
+]);
+var OpenSignatureSchema = object({
+  reference: nullable(union([
+    literal("mutable"),
+    literal("immutable"),
+    literal("unknown")
+  ])),
+  body: OpenSignatureBodySchema
+});
+var ProgrammableMoveCallSchema = object({
+  package: ObjectID,
+  module: string(),
+  function: string(),
+  typeArguments: array(string()),
+  arguments: array(ArgumentSchema),
+  _argumentTypes: optional(nullable(array(OpenSignatureSchema)))
+});
+var $Intent = object({
+  name: string(),
+  inputs: record(string(), union([ArgumentSchema, array(ArgumentSchema)])),
+  data: record(string(), unknown())
+});
+var CommandSchema = safeEnum({
+  MoveCall: ProgrammableMoveCallSchema,
+  TransferObjects: object({
+    objects: array(ArgumentSchema),
+    address: ArgumentSchema
   }),
-  InvalidPublicFunctionReturnType: bcs.struct("InvalidPublicFunctionReturnType", { idx: bcs.u16() }),
-  InvalidTransferObject: null,
-  EffectsTooLarge: bcs.struct("EffectsTooLarge", {
-    currentSize: bcs.u64(),
-    maxSize: bcs.u64()
+  SplitCoins: object({
+    coin: ArgumentSchema,
+    amounts: array(ArgumentSchema)
   }),
-  PublishUpgradeMissingDependency: null,
-  PublishUpgradeDependencyDowngrade: null,
-  PackageUpgradeError: bcs.struct("PackageUpgradeError", { upgradeError: PackageUpgradeError }),
-  WrittenObjectsTooLarge: bcs.struct("WrittenObjectsTooLarge", {
-    currentSize: bcs.u64(),
-    maxSize: bcs.u64()
+  MergeCoins: object({
+    destination: ArgumentSchema,
+    sources: array(ArgumentSchema)
   }),
-  CertificateDenied: null,
-  SuiMoveVerificationTimedout: null,
-  SharedObjectOperationNotAllowed: null,
-  InputObjectDeleted: null,
-  ExecutionCancelledDueToSharedObjectCongestion: bcs.struct("ExecutionCancelledDueToSharedObjectCongestion", { congested_objects: bcs.vector(Address) }),
-  AddressDeniedForCoin: bcs.struct("AddressDeniedForCoin", {
-    address: Address,
-    coinType: bcs.string()
+  Publish: object({
+    modules: array(BCSBytes),
+    dependencies: array(ObjectID)
   }),
-  CoinTypeGlobalPause: bcs.struct("CoinTypeGlobalPause", { coinType: bcs.string() }),
-  ExecutionCancelledDueToRandomnessUnavailable: null,
-  MoveVectorElemTooBig: bcs.struct("MoveVectorElemTooBig", {
-    valueSize: bcs.u64(),
-    maxScaledSize: bcs.u64()
+  MakeMoveVec: object({
+    type: nullable(string()),
+    elements: array(ArgumentSchema)
   }),
-  MoveRawValueTooBig: bcs.struct("MoveRawValueTooBig", {
-    valueSize: bcs.u64(),
-    maxScaledSize: bcs.u64()
+  Upgrade: object({
+    modules: array(BCSBytes),
+    dependencies: array(ObjectID),
+    package: ObjectID,
+    ticket: ArgumentSchema
   }),
-  InvalidLinkage: null,
-  InsufficientBalanceForWithdraw: null,
-  NonExclusiveWriteInputObjectModified: bcs.struct("NonExclusiveWriteInputObjectModified", { id: Address })
-});
-var ExecutionStatus = bcs.enum("ExecutionStatus", {
-  Success: null,
-  Failure: bcs.struct("Failure", {
-    error: ExecutionFailureStatus,
-    command: bcs.option(bcs.u64())
-  })
-});
-var GasCostSummary = bcs.struct("GasCostSummary", {
-  computationCost: bcs.u64(),
-  storageCost: bcs.u64(),
-  storageRebate: bcs.u64(),
-  nonRefundableStorageFee: bcs.u64()
-});
-var TransactionEffectsV1 = bcs.struct("TransactionEffectsV1", {
-  status: ExecutionStatus,
-  executedEpoch: bcs.u64(),
-  gasUsed: GasCostSummary,
-  modifiedAtVersions: bcs.vector(bcs.tuple([Address, bcs.u64()])),
-  sharedObjects: bcs.vector(SuiObjectRef),
-  transactionDigest: ObjectDigest,
-  created: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
-  mutated: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
-  unwrapped: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
-  deleted: bcs.vector(SuiObjectRef),
-  unwrappedThenDeleted: bcs.vector(SuiObjectRef),
-  wrapped: bcs.vector(SuiObjectRef),
-  gasObject: bcs.tuple([SuiObjectRef, Owner]),
-  eventsDigest: bcs.option(ObjectDigest),
-  dependencies: bcs.vector(ObjectDigest)
-});
-var VersionDigest = bcs.tuple([bcs.u64(), ObjectDigest]);
-var ObjectIn = bcs.enum("ObjectIn", {
-  NotExist: null,
-  Exist: bcs.tuple([VersionDigest, Owner])
-});
-var AccumulatorAddress = bcs.struct("AccumulatorAddress", {
-  address: Address,
-  ty: TypeTag
-});
-var AccumulatorOperation = bcs.enum("AccumulatorOperation", {
-  Merge: null,
-  Split: null
-});
-var AccumulatorValue = bcs.enum("AccumulatorValue", {
-  Integer: bcs.u64(),
-  IntegerTuple: bcs.tuple([bcs.u64(), bcs.u64()]),
-  EventDigest: bcs.vector(bcs.tuple([bcs.u64(), ObjectDigest]))
+  $Intent
 });
-var AccumulatorWriteV1 = bcs.struct("AccumulatorWriteV1", {
-  address: AccumulatorAddress,
-  operation: AccumulatorOperation,
-  value: AccumulatorValue
+var ObjectArgSchema = safeEnum({
+  ImmOrOwnedObject: ObjectRefSchema,
+  SharedObject: object({
+    objectId: ObjectID,
+    initialSharedVersion: JsonU64,
+    mutable: boolean()
+  }),
+  Receiving: ObjectRefSchema
 });
-var ObjectOut = bcs.enum("ObjectOut", {
-  NotExist: null,
-  ObjectWrite: bcs.tuple([ObjectDigest, Owner]),
-  PackageWrite: VersionDigest,
-  AccumulatorWriteV1
+var ReservationSchema = safeEnum({ MaxAmountU64: JsonU64 });
+var WithdrawalTypeArgSchema = safeEnum({ Balance: string() });
+var WithdrawFromSchema = safeEnum({
+  Sender: literal(true),
+  Sponsor: literal(true)
 });
-var IDOperation = bcs.enum("IDOperation", {
-  None: null,
-  Created: null,
-  Deleted: null
+var FundsWithdrawalArgSchema = object({
+  reservation: ReservationSchema,
+  typeArg: WithdrawalTypeArgSchema,
+  withdrawFrom: WithdrawFromSchema
 });
-var EffectsObjectChange = bcs.struct("EffectsObjectChange", {
-  inputState: ObjectIn,
-  outputState: ObjectOut,
-  idOperation: IDOperation
+var CallArgSchema = safeEnum({
+  Object: ObjectArgSchema,
+  Pure: object({ bytes: BCSBytes }),
+  UnresolvedPure: object({ value: unknown() }),
+  UnresolvedObject: object({
+    objectId: ObjectID,
+    version: optional(nullable(JsonU64)),
+    digest: optional(nullable(string())),
+    initialSharedVersion: optional(nullable(JsonU64)),
+    mutable: optional(nullable(boolean()))
+  }),
+  FundsWithdrawal: FundsWithdrawalArgSchema
 });
-var UnchangedConsensusKind = bcs.enum("UnchangedConsensusKind", {
-  ReadOnlyRoot: VersionDigest,
-  MutateConsensusStreamEnded: bcs.u64(),
-  ReadConsensusStreamEnded: bcs.u64(),
-  Cancelled: bcs.u64(),
-  PerEpochConfig: null
+var NormalizedCallArg = safeEnum({
+  Object: ObjectArgSchema,
+  Pure: object({ bytes: BCSBytes })
 });
-var TransactionEffectsV2 = bcs.struct("TransactionEffectsV2", {
-  status: ExecutionStatus,
-  executedEpoch: bcs.u64(),
-  gasUsed: GasCostSummary,
-  transactionDigest: ObjectDigest,
-  gasObjectIndex: bcs.option(bcs.u32()),
-  eventsDigest: bcs.option(ObjectDigest),
-  dependencies: bcs.vector(ObjectDigest),
-  lamportVersion: bcs.u64(),
-  changedObjects: bcs.vector(bcs.tuple([Address, EffectsObjectChange])),
-  unchangedConsensusObjects: bcs.vector(bcs.tuple([Address, UnchangedConsensusKind])),
-  auxDataDigest: bcs.option(ObjectDigest)
+var ValidDuringSchema = object({
+  minEpoch: nullable(JsonU64),
+  maxEpoch: nullable(JsonU64),
+  minTimestamp: nullable(JsonU64),
+  maxTimestamp: nullable(JsonU64),
+  chain: string(),
+  nonce: U32
 });
-var TransactionEffects = bcs.enum("TransactionEffects", {
-  V1: TransactionEffectsV1,
-  V2: TransactionEffectsV2
+var TransactionExpiration2 = safeEnum({
+  None: literal(true),
+  Epoch: JsonU64,
+  ValidDuring: ValidDuringSchema
+});
+var TransactionDataSchema = object({
+  version: literal(2),
+  sender: nullish(SuiAddress),
+  expiration: nullish(TransactionExpiration2),
+  gasData: GasDataSchema,
+  inputs: array(CallArgSchema),
+  commands: array(CommandSchema)
 });
 
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/pure.mjs
-function pureBcsSchemaFromTypeName(name) {
-  switch (name) {
-    case "u8":
-      return bcs.u8();
-    case "u16":
-      return bcs.u16();
-    case "u32":
-      return bcs.u32();
-    case "u64":
-      return bcs.u64();
-    case "u128":
-      return bcs.u128();
-    case "u256":
-      return bcs.u256();
-    case "bool":
-      return bcs.bool();
-    case "string":
-      return bcs.string();
-    case "id":
-    case "address":
-      return Address;
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/utils.mjs
+function getIdFromCallArg(arg) {
+  if (typeof arg === "string") return normalizeSuiAddress(arg);
+  if (arg.Object) {
+    if (arg.Object.ImmOrOwnedObject) return normalizeSuiAddress(arg.Object.ImmOrOwnedObject.objectId);
+    if (arg.Object.Receiving) return normalizeSuiAddress(arg.Object.Receiving.objectId);
+    return normalizeSuiAddress(arg.Object.SharedObject.objectId);
   }
-  const generic = name.match(/^(vector|option)<(.+)>$/);
-  if (generic) {
-    const [kind, inner] = generic.slice(1);
-    if (kind === "vector") return bcs.vector(pureBcsSchemaFromTypeName(inner));
-    else return bcs.option(pureBcsSchemaFromTypeName(inner));
+  if (arg.UnresolvedObject) return normalizeSuiAddress(arg.UnresolvedObject.objectId);
+}
+function isArgument(value) {
+  return is(ArgumentSchema, value);
+}
+function remapCommandArguments(command, inputMapping, commandMapping) {
+  const remapArg = (arg) => {
+    switch (arg.$kind) {
+      case "Input": {
+        const newInputIndex = inputMapping.get(arg.Input);
+        if (newInputIndex === void 0) throw new Error(`Input ${arg.Input} not found in input mapping`);
+        return {
+          ...arg,
+          Input: newInputIndex
+        };
+      }
+      case "Result": {
+        const newCommandIndex = commandMapping.get(arg.Result);
+        if (newCommandIndex !== void 0) return {
+          ...arg,
+          Result: newCommandIndex
+        };
+        return arg;
+      }
+      case "NestedResult": {
+        const newCommandIndex = commandMapping.get(arg.NestedResult[0]);
+        if (newCommandIndex !== void 0) return {
+          ...arg,
+          NestedResult: [newCommandIndex, arg.NestedResult[1]]
+        };
+        return arg;
+      }
+      default:
+        return arg;
+    }
+  };
+  switch (command.$kind) {
+    case "MoveCall":
+      command.MoveCall.arguments = command.MoveCall.arguments.map(remapArg);
+      break;
+    case "TransferObjects":
+      command.TransferObjects.objects = command.TransferObjects.objects.map(remapArg);
+      command.TransferObjects.address = remapArg(command.TransferObjects.address);
+      break;
+    case "SplitCoins":
+      command.SplitCoins.coin = remapArg(command.SplitCoins.coin);
+      command.SplitCoins.amounts = command.SplitCoins.amounts.map(remapArg);
+      break;
+    case "MergeCoins":
+      command.MergeCoins.destination = remapArg(command.MergeCoins.destination);
+      command.MergeCoins.sources = command.MergeCoins.sources.map(remapArg);
+      break;
+    case "MakeMoveVec":
+      command.MakeMoveVec.elements = command.MakeMoveVec.elements.map(remapArg);
+      break;
+    case "Upgrade":
+      command.Upgrade.ticket = remapArg(command.Upgrade.ticket);
+      break;
+    case "$Intent": {
+      const inputs = command.$Intent.inputs;
+      command.$Intent.inputs = {};
+      for (const [key, value] of Object.entries(inputs)) command.$Intent.inputs[key] = Array.isArray(value) ? value.map(remapArg) : remapArg(value);
+      break;
+    }
+    case "Publish":
+      break;
   }
-  throw new Error(`Invalid Pure type name: ${name}`);
 }
 
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/index.mjs
-var suiBcs = {
-  ...bcs,
-  U8: bcs.u8(),
-  U16: bcs.u16(),
-  U32: bcs.u32(),
-  U64: bcs.u64(),
-  U128: bcs.u128(),
-  U256: bcs.u256(),
-  ULEB128: bcs.uleb128(),
-  Bool: bcs.bool(),
-  String: bcs.string(),
-  Address,
-  AppId,
-  Argument,
-  CallArg,
-  Command,
-  CompressedSignature,
-  Data,
-  GasData,
-  Intent,
-  IntentMessage,
-  IntentScope,
-  IntentVersion,
-  MoveObject,
-  MoveObjectType,
-  MovePackage,
-  MultiSig,
-  MultiSigPkMap,
-  MultiSigPublicKey,
-  Object: ObjectInner,
-  ObjectArg,
-  ObjectDigest,
-  Owner,
-  PasskeyAuthenticator,
-  ProgrammableMoveCall,
-  ProgrammableTransaction,
-  PublicKey,
-  SenderSignedData,
-  SenderSignedTransaction,
-  SharedObjectRef,
-  StructTag,
-  SuiObjectRef,
-  TransactionData,
-  TransactionDataV1,
-  TransactionEffects,
-  TransactionExpiration: TransactionExpiration2,
-  TransactionKind,
-  TypeOrigin,
-  TypeTag,
-  UpgradeInfo
-};
-
 // ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/data/v1.mjs
 var ObjectRef = object({
   digest: string(),
@@ -2233,15 +2243,19 @@ var TransactionDataBuilder = class TransactionDataBuilder2 {
   }
 };
 
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/utils/constants.mjs
-var MIST_PER_SUI = BigInt(1e9);
-var MOVE_STDLIB_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000001";
-var SUI_FRAMEWORK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000002";
-var SUI_CLOCK_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
-var SUI_TYPE_ARG = `${SUI_FRAMEWORK_ADDRESS}::sui::SUI`;
-var SUI_SYSTEM_STATE_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000005";
-var SUI_RANDOM_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000008";
-var SUI_DENY_LIST_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000403";
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/utils/dynamic-fields.mjs
+function deriveDynamicFieldID(parentId, typeTag, key) {
+  const address = suiBcs.Address.serialize(parentId).toBytes();
+  const tag = suiBcs.TypeTag.serialize(typeTag).toBytes();
+  const keyLength = suiBcs.u64().serialize(key.length).toBytes();
+  const hash = blake2b.create({ dkLen: 32 });
+  hash.update(new Uint8Array([240]));
+  hash.update(address);
+  hash.update(keyLength);
+  hash.update(key);
+  hash.update(tag);
+  return `0x${toHex(hash.digest().slice(0, 32))}`;
+}
 
 // ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/client/errors.mjs
 var SuiClientError = class extends Error {
@@ -2274,20 +2288,6 @@ var ObjectError = class ObjectError2 extends SuiClientError {
   }
 };
 
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/utils/dynamic-fields.mjs
-function deriveDynamicFieldID(parentId, typeTag, key) {
-  const address = suiBcs.Address.serialize(parentId).toBytes();
-  const tag = suiBcs.TypeTag.serialize(typeTag).toBytes();
-  const keyLength = suiBcs.u64().serialize(key.length).toBytes();
-  const hash = blake2b.create({ dkLen: 32 });
-  hash.update(new Uint8Array([240]));
-  hash.update(address);
-  hash.update(keyLength);
-  hash.update(key);
-  hash.update(tag);
-  return `0x${toHex(hash.digest().slice(0, 32))}`;
-}
-
 // ../../node_modules/.pnpm/@mysten+utils@0.3.3/node_modules/@mysten/utils/dist/b64.mjs
 function fromBase642(base64String2) {
   return Uint8Array.from(atob(base64String2), (char) => char.charCodeAt(0));
@@ -2777,6 +2777,18 @@ function getNamesFromTypeList(types) {
 }
 
 export {
+  TypeTagSerializer,
+  ExecutionStatus,
+  pureBcsSchemaFromTypeName,
+  suiBcs,
+  deriveDynamicFieldID,
+  MOVE_STDLIB_ADDRESS,
+  SUI_FRAMEWORK_ADDRESS,
+  SUI_CLOCK_OBJECT_ID,
+  SUI_TYPE_ARG,
+  SUI_SYSTEM_STATE_OBJECT_ID,
+  SUI_RANDOM_OBJECT_ID,
+  SUI_DENY_LIST_OBJECT_ID,
   integer,
   is,
   array,
@@ -2805,25 +2817,13 @@ export {
   FundsWithdrawalArgSchema,
   NormalizedCallArg,
   ValidDuringSchema,
-  TransactionExpiration,
+  TransactionExpiration2 as TransactionExpiration,
   getIdFromCallArg,
   isArgument,
-  TypeTagSerializer,
-  ExecutionStatus,
-  pureBcsSchemaFromTypeName,
-  suiBcs,
   serializeV1TransactionData,
   TransactionDataBuilder,
-  MOVE_STDLIB_ADDRESS,
-  SUI_FRAMEWORK_ADDRESS,
-  SUI_CLOCK_OBJECT_ID,
-  SUI_TYPE_ARG,
-  SUI_SYSTEM_STATE_OBJECT_ID,
-  SUI_RANDOM_OBJECT_ID,
-  SUI_DENY_LIST_OBJECT_ID,
   SimulationError,
   ObjectError,
-  deriveDynamicFieldID,
   fromBase642 as fromBase64,
   toBase642 as toBase64,
   chunk,
@@ -2832,4 +2832,4 @@ export {
   findNamesInTransaction,
   replaceNames
 };
-//# sourceMappingURL=chunk-FORXEDQJ.js.map
+//# sourceMappingURL=chunk-MPXYF2CX.js.map