@t2000/cli 0.22.21 → 0.22.23

package/dist/chunk-KHIL2KNW.js

@@ -0,0 +1,4016 @@
+import { createRequire as __createRequire } from 'module'; import { fileURLToPath as __fileURLToPath } from 'url'; import { dirname as __pathDirname } from 'path'; const require = __createRequire(import.meta.url); const __filename = __fileURLToPath(import.meta.url); const __dirname = __pathDirname(__filename);
+import {
+  BcsEnum,
+  BcsStruct,
+  BcsTuple,
+  BcsType,
+  DataLoader,
+  SUI_ADDRESS_LENGTH,
+  bcs,
+  blake2b,
+  chunk,
+  compareBcsBytes,
+  fromBase58,
+  fromBase64,
+  fromHex,
+  init_blake2,
+  init_dist,
+  init_dist2,
+  init_move_registry,
+  init_sui_types,
+  isSerializedBcs,
+  isValidNamedPackage,
+  isValidNamedType,
+  isValidSuiAddress,
+  normalizeStructTag,
+  normalizeSuiAddress,
+  normalizeSuiObjectId,
+  parseStructTag,
+  splitGenericParameters,
+  toBase58,
+  toBase64,
+  toHex
+} from "./chunk-3XUF7GM3.js";
+import {
+  __esm,
+  __export
+} from "./chunk-YPWSCLE3.js";
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/type-tag-serializer.mjs
+function normalizeTypeTag(type) {
+  return TypeTagSerializer.tagToString(TypeTagSerializer.parseFromStr(type));
+}
+var VECTOR_REGEX, STRUCT_REGEX, TypeTagSerializer;
+var init_type_tag_serializer = __esm({
+  "../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/type-tag-serializer.mjs"() {
+    "use strict";
+    init_sui_types();
+    init_dist2();
+    VECTOR_REGEX = /^vector<(.+)>$/;
+    STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+    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}>` : ""}`;
+        }
+        throw new Error("Invalid TypeTag");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.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
+  });
+}
+function IntentMessage(T) {
+  return bcs.struct(`IntentMessage<${T.name}>`, {
+    intent: Intent,
+    value: T
+  });
+}
+var Address, ObjectDigest, SuiObjectRef, SharedObjectRef, ObjectArg, Owner, Reservation, WithdrawalType, WithdrawFrom, FundsWithdrawal, CallArg, InnerTypeTag, TypeTag, Argument, ProgrammableMoveCall, Command, ProgrammableTransaction, TransactionKind, ValidDuring, TransactionExpiration, StructTag, GasData, TransactionDataV1, TransactionData, IntentScope, IntentVersion, AppId, Intent, CompressedSignature, PublicKey, MultiSigPkMap, MultiSigPublicKey, MultiSig, base64String, SenderSignedTransaction, SenderSignedData, PasskeyAuthenticator, MoveObjectType, TypeOrigin, UpgradeInfo, MovePackage, MoveObject, Data, ObjectInner;
+var init_bcs = __esm({
+  "../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/bcs.mjs"() {
+    "use strict";
+    init_sui_types();
+    init_type_tag_serializer();
+    init_dist2();
+    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))
+    });
+    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");
+      }
+    });
+    SuiObjectRef = bcs.struct("SuiObjectRef", {
+      objectId: Address,
+      version: bcs.u64(),
+      digest: ObjectDigest
+    });
+    SharedObjectRef = bcs.struct("SharedObjectRef", {
+      objectId: Address,
+      initialSharedVersion: bcs.u64(),
+      mutable: bcs.bool()
+    });
+    ObjectArg = bcs.enum("ObjectArg", {
+      ImmOrOwnedObject: SuiObjectRef,
+      SharedObject: SharedObjectRef,
+      Receiving: SuiObjectRef
+    });
+    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
+      })
+    });
+    Reservation = bcs.enum("Reservation", { MaxAmountU64: bcs.u64() });
+    WithdrawalType = bcs.enum("WithdrawalType", { Balance: bcs.lazy(() => TypeTag) });
+    WithdrawFrom = bcs.enum("WithdrawFrom", {
+      Sender: null,
+      Sponsor: null
+    });
+    FundsWithdrawal = bcs.struct("FundsWithdrawal", {
+      reservation: Reservation,
+      typeArg: WithdrawalType,
+      withdrawFrom: WithdrawFrom
+    });
+    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
+    });
+    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
+    });
+    TypeTag = InnerTypeTag.transform({
+      input: (typeTag) => typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag, true) : typeTag,
+      output: (typeTag) => TypeTagSerializer.tagToString(typeTag)
+    });
+    Argument = bcs.enum("Argument", {
+      GasCoin: null,
+      Input: bcs.u16(),
+      Result: bcs.u16(),
+      NestedResult: bcs.tuple([bcs.u16(), bcs.u16()])
+    });
+    ProgrammableMoveCall = bcs.struct("ProgrammableMoveCall", {
+      package: Address,
+      module: bcs.string(),
+      function: bcs.string(),
+      typeArguments: bcs.vector(TypeTag),
+      arguments: bcs.vector(Argument)
+    });
+    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
+      })
+    });
+    ProgrammableTransaction = bcs.struct("ProgrammableTransaction", {
+      inputs: bcs.vector(CallArg),
+      commands: bcs.vector(Command)
+    });
+    TransactionKind = bcs.enum("TransactionKind", {
+      ProgrammableTransaction,
+      ChangeEpoch: null,
+      Genesis: null,
+      ConsensusCommitPrologue: null
+    });
+    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()
+    });
+    TransactionExpiration = bcs.enum("TransactionExpiration", {
+      None: null,
+      Epoch: unsafe_u64(),
+      ValidDuring
+    });
+    StructTag = bcs.struct("StructTag", {
+      address: Address,
+      module: bcs.string(),
+      name: bcs.string(),
+      typeParams: bcs.vector(InnerTypeTag)
+    });
+    GasData = bcs.struct("GasData", {
+      payment: bcs.vector(SuiObjectRef),
+      owner: Address,
+      price: bcs.u64(),
+      budget: bcs.u64()
+    });
+    TransactionDataV1 = bcs.struct("TransactionDataV1", {
+      kind: TransactionKind,
+      sender: Address,
+      gasData: GasData,
+      expiration: TransactionExpiration
+    });
+    TransactionData = bcs.enum("TransactionData", { V1: TransactionDataV1 });
+    IntentScope = bcs.enum("IntentScope", {
+      TransactionData: null,
+      TransactionEffects: null,
+      CheckpointSummary: null,
+      PersonalMessage: null
+    });
+    IntentVersion = bcs.enum("IntentVersion", { V0: null });
+    AppId = bcs.enum("AppId", { Sui: null });
+    Intent = bcs.struct("Intent", {
+      scope: IntentScope,
+      version: IntentVersion,
+      appId: AppId
+    });
+    CompressedSignature = bcs.enum("CompressedSignature", {
+      ED25519: bcs.bytes(64),
+      Secp256k1: bcs.bytes(64),
+      Secp256r1: bcs.bytes(64),
+      ZkLogin: bcs.byteVector(),
+      Passkey: bcs.byteVector()
+    });
+    PublicKey = bcs.enum("PublicKey", {
+      ED25519: bcs.bytes(32),
+      Secp256k1: bcs.bytes(33),
+      Secp256r1: bcs.bytes(33),
+      ZkLogin: bcs.byteVector(),
+      Passkey: bcs.bytes(33)
+    });
+    MultiSigPkMap = bcs.struct("MultiSigPkMap", {
+      pubKey: PublicKey,
+      weight: bcs.u8()
+    });
+    MultiSigPublicKey = bcs.struct("MultiSigPublicKey", {
+      pk_map: bcs.vector(MultiSigPkMap),
+      threshold: bcs.u16()
+    });
+    MultiSig = bcs.struct("MultiSig", {
+      sigs: bcs.vector(CompressedSignature),
+      bitmap: bcs.u16(),
+      multisig_pk: MultiSigPublicKey
+    });
+    base64String = bcs.byteVector().transform({
+      input: (val) => typeof val === "string" ? fromBase64(val) : val,
+      output: (val) => toBase64(new Uint8Array(val))
+    });
+    SenderSignedTransaction = bcs.struct("SenderSignedTransaction", {
+      intentMessage: IntentMessage(TransactionData),
+      txSignatures: bcs.vector(base64String)
+    });
+    SenderSignedData = bcs.vector(SenderSignedTransaction, { name: "SenderSignedData" });
+    PasskeyAuthenticator = bcs.struct("PasskeyAuthenticator", {
+      authenticatorData: bcs.byteVector(),
+      clientDataJson: bcs.string(),
+      userSignature: bcs.byteVector()
+    });
+    MoveObjectType = bcs.enum("MoveObjectType", {
+      Other: StructTag,
+      GasCoin: null,
+      StakedSui: null,
+      Coin: TypeTag,
+      AccumulatorBalanceWrapper: null
+    });
+    TypeOrigin = bcs.struct("TypeOrigin", {
+      moduleName: bcs.string(),
+      datatypeName: bcs.string(),
+      package: Address
+    });
+    UpgradeInfo = bcs.struct("UpgradeInfo", {
+      upgradedId: Address,
+      upgradedVersion: bcs.u64()
+    });
+    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)
+    });
+    MoveObject = bcs.struct("MoveObject", {
+      type: MoveObjectType,
+      hasPublicTransfer: bcs.bool(),
+      version: bcs.u64(),
+      contents: bcs.byteVector()
+    });
+    Data = bcs.enum("Data", {
+      Move: MoveObject,
+      Package: MovePackage
+    });
+    ObjectInner = bcs.struct("ObjectInner", {
+      data: Data,
+      owner: Owner,
+      previousTransaction: ObjectDigest,
+      storageRebate: bcs.u64()
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/effects.mjs
+var PackageUpgradeError, ModuleId, MoveLocation, CommandArgumentError, TypeArgumentError, ExecutionFailureStatus, ExecutionStatus, GasCostSummary, TransactionEffectsV1, VersionDigest, ObjectIn, AccumulatorAddress, AccumulatorOperation, AccumulatorValue, AccumulatorWriteV1, ObjectOut, IDOperation, EffectsObjectChange, UnchangedConsensusKind, TransactionEffectsV2, TransactionEffects;
+var init_effects = __esm({
+  "../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/effects.mjs"() {
+    "use strict";
+    init_bcs();
+    init_dist2();
+    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
+      })
+    });
+    ModuleId = bcs.struct("ModuleId", {
+      address: Address,
+      name: bcs.string()
+    });
+    MoveLocation = bcs.struct("MoveLocation", {
+      module: ModuleId,
+      function: bcs.u16(),
+      instruction: bcs.u16(),
+      functionName: bcs.option(bcs.string())
+    });
+    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
+    });
+    TypeArgumentError = bcs.enum("TypeArgumentError", {
+      TypeNotFound: null,
+      ConstraintNotSatisfied: null
+    });
+    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 })
+    });
+    ExecutionStatus = bcs.enum("ExecutionStatus", {
+      Success: null,
+      Failure: bcs.struct("Failure", {
+        error: ExecutionFailureStatus,
+        command: bcs.option(bcs.u64())
+      })
+    });
+    GasCostSummary = bcs.struct("GasCostSummary", {
+      computationCost: bcs.u64(),
+      storageCost: bcs.u64(),
+      storageRebate: bcs.u64(),
+      nonRefundableStorageFee: bcs.u64()
+    });
+    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)
+    });
+    VersionDigest = bcs.tuple([bcs.u64(), ObjectDigest]);
+    ObjectIn = bcs.enum("ObjectIn", {
+      NotExist: null,
+      Exist: bcs.tuple([VersionDigest, Owner])
+    });
+    AccumulatorAddress = bcs.struct("AccumulatorAddress", {
+      address: Address,
+      ty: TypeTag
+    });
+    AccumulatorOperation = bcs.enum("AccumulatorOperation", {
+      Merge: null,
+      Split: null
+    });
+    AccumulatorValue = bcs.enum("AccumulatorValue", {
+      Integer: bcs.u64(),
+      IntegerTuple: bcs.tuple([bcs.u64(), bcs.u64()]),
+      EventDigest: bcs.vector(bcs.tuple([bcs.u64(), ObjectDigest]))
+    });
+    AccumulatorWriteV1 = bcs.struct("AccumulatorWriteV1", {
+      address: AccumulatorAddress,
+      operation: AccumulatorOperation,
+      value: AccumulatorValue
+    });
+    ObjectOut = bcs.enum("ObjectOut", {
+      NotExist: null,
+      ObjectWrite: bcs.tuple([ObjectDigest, Owner]),
+      PackageWrite: VersionDigest,
+      AccumulatorWriteV1
+    });
+    IDOperation = bcs.enum("IDOperation", {
+      None: null,
+      Created: null,
+      Deleted: null
+    });
+    EffectsObjectChange = bcs.struct("EffectsObjectChange", {
+      inputState: ObjectIn,
+      outputState: ObjectOut,
+      idOperation: IDOperation
+    });
+    UnchangedConsensusKind = bcs.enum("UnchangedConsensusKind", {
+      ReadOnlyRoot: VersionDigest,
+      MutateConsensusStreamEnded: bcs.u64(),
+      ReadConsensusStreamEnded: bcs.u64(),
+      Cancelled: bcs.u64(),
+      PerEpochConfig: null
+    });
+    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)
+    });
+    TransactionEffects = bcs.enum("TransactionEffects", {
+      V1: TransactionEffectsV1,
+      V2: TransactionEffectsV2
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.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}`);
+}
+var init_pure = __esm({
+  "../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/pure.mjs"() {
+    "use strict";
+    init_bcs();
+    init_dist2();
+  }
+});
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/index.mjs
+var bcs_exports = {};
+__export(bcs_exports, {
+  BcsEnum: () => BcsEnum,
+  BcsStruct: () => BcsStruct,
+  BcsTuple: () => BcsTuple,
+  BcsType: () => BcsType,
+  TypeTagSerializer: () => TypeTagSerializer,
+  bcs: () => suiBcs,
+  compareBcsBytes: () => compareBcsBytes,
+  pureBcsSchemaFromTypeName: () => pureBcsSchemaFromTypeName
+});
+var suiBcs;
+var init_bcs2 = __esm({
+  "../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/bcs/index.mjs"() {
+    "use strict";
+    init_type_tag_serializer();
+    init_bcs();
+    init_effects();
+    init_pure();
+    init_dist2();
+    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.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/utils/constants.mjs
+var SUI_DECIMALS, MIST_PER_SUI, MOVE_STDLIB_ADDRESS, SUI_FRAMEWORK_ADDRESS, SUI_SYSTEM_ADDRESS, SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_MODULE_NAME, SUI_TYPE_ARG, SUI_SYSTEM_STATE_OBJECT_ID, SUI_RANDOM_OBJECT_ID, SUI_COIN_REGISTRY_OBJECT_ID, SUI_DENY_LIST_OBJECT_ID;
+var init_constants = __esm({
+  "../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/utils/constants.mjs"() {
+    "use strict";
+    SUI_DECIMALS = 9;
+    MIST_PER_SUI = BigInt(1e9);
+    MOVE_STDLIB_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000001";
+    SUI_FRAMEWORK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000002";
+    SUI_SYSTEM_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000003";
+    SUI_CLOCK_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
+    SUI_SYSTEM_MODULE_NAME = "sui_system";
+    SUI_TYPE_ARG = `${SUI_FRAMEWORK_ADDRESS}::sui::SUI`;
+    SUI_SYSTEM_STATE_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000005";
+    SUI_RANDOM_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000008";
+    SUI_COIN_REGISTRY_OBJECT_ID = "0x000000000000000000000000000000000000000000000000000000000000000c";
+    SUI_DENY_LIST_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000403";
+  }
+});
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Transaction.mjs
+init_sui_types();
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/data/internal.mjs
+init_sui_types();
+
+// ../../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());
+    }
+  };
+}
+// @__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;
+  }
+};
+// @__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;
+}
+// @__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;
+    }
+  };
+}
+// @__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;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean(message$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;
+    }
+  };
+}
+// @__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);
+    }
+  };
+}
+// @__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;
+    }
+  };
+}
+// @__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;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number(message$1) {
+  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;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries$1, message$1) {
+  return {
+    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) {
+      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;
+    }
+  };
+}
+// @__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;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__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;
+    }
+  };
+}
+// @__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;
+    }
+  };
+}
+// @__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;
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.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 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.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/data/v1.mjs
+init_type_tag_serializer();
+init_dist2();
+var ObjectRef = object({
+  digest: string(),
+  objectId: string(),
+  version: union([
+    pipe(number(), integer()),
+    string(),
+    bigint()
+  ])
+});
+var ObjectArg2 = safeEnum({
+  ImmOrOwned: ObjectRef,
+  Shared: object({
+    objectId: ObjectID,
+    initialSharedVersion: JsonU64,
+    mutable: boolean()
+  }),
+  Receiving: ObjectRef
+});
+var NormalizedCallArg2 = safeEnum({
+  Object: ObjectArg2,
+  Pure: array(pipe(number(), integer()))
+});
+var TransactionInput = union([object({
+  kind: literal("Input"),
+  index: pipe(number(), integer()),
+  value: unknown(),
+  type: optional(literal("object"))
+}), object({
+  kind: literal("Input"),
+  index: pipe(number(), integer()),
+  value: unknown(),
+  type: literal("pure")
+})]);
+var TransactionExpiration3 = union([object({ Epoch: pipe(number(), integer()) }), object({ None: nullable(literal(true)) })]);
+var StringEncodedBigint = pipe(union([
+  number(),
+  string(),
+  bigint()
+]), check((val) => {
+  if (![
+    "string",
+    "number",
+    "bigint"
+  ].includes(typeof val)) return false;
+  try {
+    BigInt(val);
+    return true;
+  } catch {
+    return false;
+  }
+}));
+var TypeTag2 = union([
+  object({ bool: nullable(literal(true)) }),
+  object({ u8: nullable(literal(true)) }),
+  object({ u64: nullable(literal(true)) }),
+  object({ u128: nullable(literal(true)) }),
+  object({ address: nullable(literal(true)) }),
+  object({ signer: nullable(literal(true)) }),
+  object({ vector: lazy(() => TypeTag2) }),
+  object({ struct: lazy(() => StructTag2) }),
+  object({ u16: nullable(literal(true)) }),
+  object({ u32: nullable(literal(true)) }),
+  object({ u256: nullable(literal(true)) })
+]);
+var StructTag2 = object({
+  address: string(),
+  module: string(),
+  name: string(),
+  typeParams: array(TypeTag2)
+});
+var GasConfig = object({
+  budget: optional(StringEncodedBigint),
+  price: optional(StringEncodedBigint),
+  payment: optional(array(ObjectRef)),
+  owner: optional(string())
+});
+var TransactionArgumentTypes = [
+  TransactionInput,
+  object({ kind: literal("GasCoin") }),
+  object({
+    kind: literal("Result"),
+    index: pipe(number(), integer())
+  }),
+  object({
+    kind: literal("NestedResult"),
+    index: pipe(number(), integer()),
+    resultIndex: pipe(number(), integer())
+  })
+];
+var TransactionArgument = union([...TransactionArgumentTypes]);
+var MoveCallTransaction = object({
+  kind: literal("MoveCall"),
+  target: pipe(string(), check((target) => target.split("::").length === 3)),
+  typeArguments: array(string()),
+  arguments: array(TransactionArgument)
+});
+var TransferObjectsTransaction = object({
+  kind: literal("TransferObjects"),
+  objects: array(TransactionArgument),
+  address: TransactionArgument
+});
+var SplitCoinsTransaction = object({
+  kind: literal("SplitCoins"),
+  coin: TransactionArgument,
+  amounts: array(TransactionArgument)
+});
+var MergeCoinsTransaction = object({
+  kind: literal("MergeCoins"),
+  destination: TransactionArgument,
+  sources: array(TransactionArgument)
+});
+var MakeMoveVecTransaction = object({
+  kind: literal("MakeMoveVec"),
+  type: union([object({ Some: TypeTag2 }), object({ None: nullable(literal(true)) })]),
+  objects: array(TransactionArgument)
+});
+var TransactionType = union([...[
+  MoveCallTransaction,
+  TransferObjectsTransaction,
+  SplitCoinsTransaction,
+  MergeCoinsTransaction,
+  object({
+    kind: literal("Publish"),
+    modules: array(array(pipe(number(), integer()))),
+    dependencies: array(string())
+  }),
+  object({
+    kind: literal("Upgrade"),
+    modules: array(array(pipe(number(), integer()))),
+    dependencies: array(string()),
+    packageId: string(),
+    ticket: TransactionArgument
+  }),
+  MakeMoveVecTransaction
+]]);
+var SerializedTransactionDataV1 = object({
+  version: literal(1),
+  sender: optional(string()),
+  expiration: nullish(TransactionExpiration3),
+  gasConfig: GasConfig,
+  inputs: array(TransactionInput),
+  transactions: array(TransactionType)
+});
+function serializeV1TransactionData(transactionData) {
+  const inputs = transactionData.inputs.map((input, index) => {
+    if (input.Object) return {
+      kind: "Input",
+      index,
+      value: { Object: input.Object.ImmOrOwnedObject ? { ImmOrOwned: input.Object.ImmOrOwnedObject } : input.Object.Receiving ? { Receiving: {
+        digest: input.Object.Receiving.digest,
+        version: input.Object.Receiving.version,
+        objectId: input.Object.Receiving.objectId
+      } } : { Shared: {
+        mutable: input.Object.SharedObject.mutable,
+        initialSharedVersion: input.Object.SharedObject.initialSharedVersion,
+        objectId: input.Object.SharedObject.objectId
+      } } },
+      type: "object"
+    };
+    if (input.Pure) return {
+      kind: "Input",
+      index,
+      value: { Pure: Array.from(fromBase64(input.Pure.bytes)) },
+      type: "pure"
+    };
+    if (input.UnresolvedPure) return {
+      kind: "Input",
+      type: "pure",
+      index,
+      value: input.UnresolvedPure.value
+    };
+    if (input.UnresolvedObject) return {
+      kind: "Input",
+      type: "object",
+      index,
+      value: input.UnresolvedObject.objectId
+    };
+    throw new Error("Invalid input");
+  });
+  return {
+    version: 1,
+    sender: transactionData.sender ?? void 0,
+    expiration: transactionData.expiration?.$kind === "Epoch" ? { Epoch: Number(transactionData.expiration.Epoch) } : transactionData.expiration ? { None: true } : null,
+    gasConfig: {
+      owner: transactionData.gasData.owner ?? void 0,
+      budget: transactionData.gasData.budget ?? void 0,
+      price: transactionData.gasData.price ?? void 0,
+      payment: transactionData.gasData.payment ?? void 0
+    },
+    inputs,
+    transactions: transactionData.commands.map((command) => {
+      if (command.MakeMoveVec) return {
+        kind: "MakeMoveVec",
+        type: command.MakeMoveVec.type === null ? { None: true } : { Some: TypeTagSerializer.parseFromStr(command.MakeMoveVec.type) },
+        objects: command.MakeMoveVec.elements.map((arg) => convertTransactionArgument(arg, inputs))
+      };
+      if (command.MergeCoins) return {
+        kind: "MergeCoins",
+        destination: convertTransactionArgument(command.MergeCoins.destination, inputs),
+        sources: command.MergeCoins.sources.map((arg) => convertTransactionArgument(arg, inputs))
+      };
+      if (command.MoveCall) return {
+        kind: "MoveCall",
+        target: `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`,
+        typeArguments: command.MoveCall.typeArguments,
+        arguments: command.MoveCall.arguments.map((arg) => convertTransactionArgument(arg, inputs))
+      };
+      if (command.Publish) return {
+        kind: "Publish",
+        modules: command.Publish.modules.map((mod) => Array.from(fromBase64(mod))),
+        dependencies: command.Publish.dependencies
+      };
+      if (command.SplitCoins) return {
+        kind: "SplitCoins",
+        coin: convertTransactionArgument(command.SplitCoins.coin, inputs),
+        amounts: command.SplitCoins.amounts.map((arg) => convertTransactionArgument(arg, inputs))
+      };
+      if (command.TransferObjects) return {
+        kind: "TransferObjects",
+        objects: command.TransferObjects.objects.map((arg) => convertTransactionArgument(arg, inputs)),
+        address: convertTransactionArgument(command.TransferObjects.address, inputs)
+      };
+      if (command.Upgrade) return {
+        kind: "Upgrade",
+        modules: command.Upgrade.modules.map((mod) => Array.from(fromBase64(mod))),
+        dependencies: command.Upgrade.dependencies,
+        packageId: command.Upgrade.package,
+        ticket: convertTransactionArgument(command.Upgrade.ticket, inputs)
+      };
+      throw new Error(`Unknown transaction ${Object.keys(command)}`);
+    })
+  };
+}
+function convertTransactionArgument(arg, inputs) {
+  if (arg.$kind === "GasCoin") return { kind: "GasCoin" };
+  if (arg.$kind === "Result") return {
+    kind: "Result",
+    index: arg.Result
+  };
+  if (arg.$kind === "NestedResult") return {
+    kind: "NestedResult",
+    index: arg.NestedResult[0],
+    resultIndex: arg.NestedResult[1]
+  };
+  if (arg.$kind === "Input") return inputs[arg.Input];
+  throw new Error(`Invalid argument ${Object.keys(arg)}`);
+}
+function transactionDataFromV1(data) {
+  return parse(TransactionDataSchema, {
+    version: 2,
+    sender: data.sender ?? null,
+    expiration: data.expiration ? "Epoch" in data.expiration ? { Epoch: data.expiration.Epoch } : { None: true } : null,
+    gasData: {
+      owner: data.gasConfig.owner ?? null,
+      budget: data.gasConfig.budget?.toString() ?? null,
+      price: data.gasConfig.price?.toString() ?? null,
+      payment: data.gasConfig.payment?.map((ref) => ({
+        digest: ref.digest,
+        objectId: ref.objectId,
+        version: ref.version.toString()
+      })) ?? null
+    },
+    inputs: data.inputs.map((input) => {
+      if (input.kind === "Input") {
+        if (is(NormalizedCallArg2, input.value)) {
+          const value = parse(NormalizedCallArg2, input.value);
+          if (value.Object) {
+            if (value.Object.ImmOrOwned) return { Object: { ImmOrOwnedObject: {
+              objectId: value.Object.ImmOrOwned.objectId,
+              version: String(value.Object.ImmOrOwned.version),
+              digest: value.Object.ImmOrOwned.digest
+            } } };
+            if (value.Object.Shared) return { Object: { SharedObject: {
+              mutable: value.Object.Shared.mutable ?? null,
+              initialSharedVersion: value.Object.Shared.initialSharedVersion,
+              objectId: value.Object.Shared.objectId
+            } } };
+            if (value.Object.Receiving) return { Object: { Receiving: {
+              digest: value.Object.Receiving.digest,
+              version: String(value.Object.Receiving.version),
+              objectId: value.Object.Receiving.objectId
+            } } };
+            throw new Error("Invalid object input");
+          }
+          return { Pure: { bytes: toBase64(new Uint8Array(value.Pure)) } };
+        }
+        if (input.type === "object") return { UnresolvedObject: { objectId: input.value } };
+        return { UnresolvedPure: { value: input.value } };
+      }
+      throw new Error("Invalid input");
+    }),
+    commands: data.transactions.map((transaction) => {
+      switch (transaction.kind) {
+        case "MakeMoveVec":
+          return { MakeMoveVec: {
+            type: "Some" in transaction.type ? TypeTagSerializer.tagToString(transaction.type.Some) : null,
+            elements: transaction.objects.map((arg) => parseV1TransactionArgument(arg))
+          } };
+        case "MergeCoins":
+          return { MergeCoins: {
+            destination: parseV1TransactionArgument(transaction.destination),
+            sources: transaction.sources.map((arg) => parseV1TransactionArgument(arg))
+          } };
+        case "MoveCall": {
+          const [pkg, mod, fn] = transaction.target.split("::");
+          return { MoveCall: {
+            package: pkg,
+            module: mod,
+            function: fn,
+            typeArguments: transaction.typeArguments,
+            arguments: transaction.arguments.map((arg) => parseV1TransactionArgument(arg))
+          } };
+        }
+        case "Publish":
+          return { Publish: {
+            modules: transaction.modules.map((mod) => toBase64(Uint8Array.from(mod))),
+            dependencies: transaction.dependencies
+          } };
+        case "SplitCoins":
+          return { SplitCoins: {
+            coin: parseV1TransactionArgument(transaction.coin),
+            amounts: transaction.amounts.map((arg) => parseV1TransactionArgument(arg))
+          } };
+        case "TransferObjects":
+          return { TransferObjects: {
+            objects: transaction.objects.map((arg) => parseV1TransactionArgument(arg)),
+            address: parseV1TransactionArgument(transaction.address)
+          } };
+        case "Upgrade":
+          return { Upgrade: {
+            modules: transaction.modules.map((mod) => toBase64(Uint8Array.from(mod))),
+            dependencies: transaction.dependencies,
+            package: transaction.packageId,
+            ticket: parseV1TransactionArgument(transaction.ticket)
+          } };
+      }
+      throw new Error(`Unknown transaction ${Object.keys(transaction)}`);
+    })
+  });
+}
+function parseV1TransactionArgument(arg) {
+  switch (arg.kind) {
+    case "GasCoin":
+      return { GasCoin: true };
+    case "Result":
+      return { Result: arg.index };
+    case "NestedResult":
+      return { NestedResult: [arg.index, arg.resultIndex] };
+    case "Input":
+      return { Input: arg.index };
+  }
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/utils.mjs
+init_sui_types();
+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 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;
+  }
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/TransactionData.mjs
+init_sui_types();
+init_bcs2();
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/hash.mjs
+init_blake2();
+function hashTypedData(typeTag, data) {
+  const typeTagBytes = Array.from(`${typeTag}::`).map((e) => e.charCodeAt(0));
+  const dataWithTag = new Uint8Array(typeTagBytes.length + data.length);
+  dataWithTag.set(typeTagBytes);
+  dataWithTag.set(data, typeTagBytes.length);
+  return blake2b(dataWithTag, { dkLen: 32 });
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/TransactionData.mjs
+init_dist2();
+function prepareSuiAddress(address) {
+  return normalizeSuiAddress(address).replace("0x", "");
+}
+var TransactionDataBuilder = class TransactionDataBuilder2 {
+  static fromKindBytes(bytes) {
+    const programmableTx = suiBcs.TransactionKind.parse(bytes).ProgrammableTransaction;
+    if (!programmableTx) throw new Error("Unable to deserialize from bytes.");
+    return TransactionDataBuilder2.restore({
+      version: 2,
+      sender: null,
+      expiration: null,
+      gasData: {
+        budget: null,
+        owner: null,
+        payment: null,
+        price: null
+      },
+      inputs: programmableTx.inputs,
+      commands: programmableTx.commands
+    });
+  }
+  static fromBytes(bytes) {
+    const data = suiBcs.TransactionData.parse(bytes)?.V1;
+    const programmableTx = data.kind.ProgrammableTransaction;
+    if (!data || !programmableTx) throw new Error("Unable to deserialize from bytes.");
+    return TransactionDataBuilder2.restore({
+      version: 2,
+      sender: data.sender,
+      expiration: data.expiration,
+      gasData: data.gasData,
+      inputs: programmableTx.inputs,
+      commands: programmableTx.commands
+    });
+  }
+  static restore(data) {
+    if (data.version === 2) return new TransactionDataBuilder2(parse(TransactionDataSchema, data));
+    else return new TransactionDataBuilder2(parse(TransactionDataSchema, transactionDataFromV1(data)));
+  }
+  /**
+  * Generate transaction digest.
+  *
+  * @param bytes BCS serialized transaction data
+  * @returns transaction digest.
+  */
+  static getDigestFromBytes(bytes) {
+    return toBase58(hashTypedData("TransactionData", bytes));
+  }
+  constructor(clone) {
+    this.version = 2;
+    this.sender = clone?.sender ?? null;
+    this.expiration = clone?.expiration ?? null;
+    this.inputs = clone?.inputs ?? [];
+    this.commands = clone?.commands ?? [];
+    this.gasData = clone?.gasData ?? {
+      budget: null,
+      price: null,
+      owner: null,
+      payment: null
+    };
+  }
+  build({ maxSizeBytes = Infinity, overrides, onlyTransactionKind } = {}) {
+    const inputs = this.inputs;
+    const commands = this.commands;
+    const kind = { ProgrammableTransaction: {
+      inputs,
+      commands
+    } };
+    if (onlyTransactionKind) return suiBcs.TransactionKind.serialize(kind, { maxSize: maxSizeBytes }).toBytes();
+    const expiration = overrides?.expiration ?? this.expiration;
+    const sender = overrides?.sender ?? this.sender;
+    const gasData = {
+      ...this.gasData,
+      ...overrides?.gasData
+    };
+    if (!sender) throw new Error("Missing transaction sender");
+    if (!gasData.budget) throw new Error("Missing gas budget");
+    if (!gasData.payment) throw new Error("Missing gas payment");
+    if (!gasData.price) throw new Error("Missing gas price");
+    const transactionData = {
+      sender: prepareSuiAddress(sender),
+      expiration: expiration ? expiration : { None: true },
+      gasData: {
+        payment: gasData.payment,
+        owner: prepareSuiAddress(this.gasData.owner ?? sender),
+        price: BigInt(gasData.price),
+        budget: BigInt(gasData.budget)
+      },
+      kind: { ProgrammableTransaction: {
+        inputs,
+        commands
+      } }
+    };
+    return suiBcs.TransactionData.serialize({ V1: transactionData }, { maxSize: maxSizeBytes }).toBytes();
+  }
+  addInput(type, arg) {
+    const index = this.inputs.length;
+    this.inputs.push(arg);
+    return {
+      Input: index,
+      type,
+      $kind: "Input"
+    };
+  }
+  getInputUses(index, fn) {
+    this.mapArguments((arg, command) => {
+      if (arg.$kind === "Input" && arg.Input === index) fn(arg, command);
+      return arg;
+    });
+  }
+  mapCommandArguments(index, fn) {
+    const command = this.commands[index];
+    switch (command.$kind) {
+      case "MoveCall":
+        command.MoveCall.arguments = command.MoveCall.arguments.map((arg) => fn(arg, command, index));
+        break;
+      case "TransferObjects":
+        command.TransferObjects.objects = command.TransferObjects.objects.map((arg) => fn(arg, command, index));
+        command.TransferObjects.address = fn(command.TransferObjects.address, command, index);
+        break;
+      case "SplitCoins":
+        command.SplitCoins.coin = fn(command.SplitCoins.coin, command, index);
+        command.SplitCoins.amounts = command.SplitCoins.amounts.map((arg) => fn(arg, command, index));
+        break;
+      case "MergeCoins":
+        command.MergeCoins.destination = fn(command.MergeCoins.destination, command, index);
+        command.MergeCoins.sources = command.MergeCoins.sources.map((arg) => fn(arg, command, index));
+        break;
+      case "MakeMoveVec":
+        command.MakeMoveVec.elements = command.MakeMoveVec.elements.map((arg) => fn(arg, command, index));
+        break;
+      case "Upgrade":
+        command.Upgrade.ticket = fn(command.Upgrade.ticket, command, index);
+        break;
+      case "$Intent":
+        const inputs = command.$Intent.inputs;
+        command.$Intent.inputs = {};
+        for (const [key, value] of Object.entries(inputs)) command.$Intent.inputs[key] = Array.isArray(value) ? value.map((arg) => fn(arg, command, index)) : fn(value, command, index);
+        break;
+      case "Publish":
+        break;
+      default:
+        throw new Error(`Unexpected transaction kind: ${command.$kind}`);
+    }
+  }
+  mapArguments(fn) {
+    for (const commandIndex of this.commands.keys()) this.mapCommandArguments(commandIndex, fn);
+  }
+  replaceCommand(index, replacement, resultIndex = index) {
+    if (!Array.isArray(replacement)) {
+      this.commands[index] = replacement;
+      return;
+    }
+    const sizeDiff = replacement.length - 1;
+    this.commands.splice(index, 1, ...structuredClone(replacement));
+    this.mapArguments((arg, _command, commandIndex) => {
+      if (commandIndex < index + replacement.length) return arg;
+      if (typeof resultIndex !== "number") {
+        if (arg.$kind === "Result" && arg.Result === index || arg.$kind === "NestedResult" && arg.NestedResult[0] === index) if (!("NestedResult" in arg) || arg.NestedResult[1] === 0) return parse(ArgumentSchema, structuredClone(resultIndex));
+        else throw new Error(`Cannot replace command ${index} with a specific result type: NestedResult[${index}, ${arg.NestedResult[1]}] references a nested element that cannot be mapped to the replacement result`);
+      }
+      switch (arg.$kind) {
+        case "Result":
+          if (arg.Result === index && typeof resultIndex === "number") arg.Result = resultIndex;
+          if (arg.Result > index) arg.Result += sizeDiff;
+          break;
+        case "NestedResult":
+          if (arg.NestedResult[0] === index && typeof resultIndex === "number") return {
+            $kind: "NestedResult",
+            NestedResult: [resultIndex, arg.NestedResult[1]]
+          };
+          if (arg.NestedResult[0] > index) arg.NestedResult[0] += sizeDiff;
+          break;
+      }
+      return arg;
+    });
+  }
+  replaceCommandWithTransaction(index, otherTransaction, result) {
+    if (result.$kind !== "Result" && result.$kind !== "NestedResult") throw new Error("Result must be of kind Result or NestedResult");
+    this.insertTransaction(index, otherTransaction);
+    this.replaceCommand(index + otherTransaction.commands.length, [], "Result" in result ? { NestedResult: [result.Result + index, 0] } : { NestedResult: [result.NestedResult[0] + index, result.NestedResult[1]] });
+  }
+  insertTransaction(atCommandIndex, otherTransaction) {
+    const inputMapping = /* @__PURE__ */ new Map();
+    const commandMapping = /* @__PURE__ */ new Map();
+    for (let i = 0; i < otherTransaction.inputs.length; i++) {
+      const otherInput = otherTransaction.inputs[i];
+      const id = getIdFromCallArg(otherInput);
+      let existingIndex = -1;
+      if (id !== void 0) {
+        existingIndex = this.inputs.findIndex((input) => getIdFromCallArg(input) === id);
+        if (existingIndex !== -1 && this.inputs[existingIndex].Object?.SharedObject && otherInput.Object?.SharedObject) this.inputs[existingIndex].Object.SharedObject.mutable = this.inputs[existingIndex].Object.SharedObject.mutable || otherInput.Object.SharedObject.mutable;
+      }
+      if (existingIndex !== -1) inputMapping.set(i, existingIndex);
+      else {
+        const newIndex = this.inputs.length;
+        this.inputs.push(otherInput);
+        inputMapping.set(i, newIndex);
+      }
+    }
+    for (let i = 0; i < otherTransaction.commands.length; i++) commandMapping.set(i, atCommandIndex + i);
+    const remappedCommands = [];
+    for (let i = 0; i < otherTransaction.commands.length; i++) {
+      const command = structuredClone(otherTransaction.commands[i]);
+      remapCommandArguments(command, inputMapping, commandMapping);
+      remappedCommands.push(command);
+    }
+    this.commands.splice(atCommandIndex, 0, ...remappedCommands);
+    const sizeDiff = remappedCommands.length;
+    if (sizeDiff > 0) this.mapArguments((arg, _command, commandIndex) => {
+      if (commandIndex >= atCommandIndex && commandIndex < atCommandIndex + remappedCommands.length) return arg;
+      switch (arg.$kind) {
+        case "Result":
+          if (arg.Result >= atCommandIndex) arg.Result += sizeDiff;
+          break;
+        case "NestedResult":
+          if (arg.NestedResult[0] >= atCommandIndex) arg.NestedResult[0] += sizeDiff;
+          break;
+      }
+      return arg;
+    });
+  }
+  getDigest() {
+    const bytes = this.build({ onlyTransactionKind: false });
+    return TransactionDataBuilder2.getDigestFromBytes(bytes);
+  }
+  snapshot() {
+    return parse(TransactionDataSchema, this);
+  }
+  shallowClone() {
+    return new TransactionDataBuilder2({
+      version: this.version,
+      sender: this.sender,
+      expiration: this.expiration,
+      gasData: { ...this.gasData },
+      inputs: [...this.inputs],
+      commands: [...this.commands]
+    });
+  }
+  applyResolvedData(resolved) {
+    if (!this.sender) this.sender = resolved.sender ?? null;
+    if (!this.expiration) this.expiration = resolved.expiration ?? null;
+    if (!this.gasData.budget) this.gasData.budget = resolved.gasData.budget;
+    if (!this.gasData.owner) this.gasData.owner = resolved.gasData.owner ?? null;
+    if (!this.gasData.payment) this.gasData.payment = resolved.gasData.payment;
+    if (!this.gasData.price) this.gasData.price = resolved.gasData.price;
+    for (let i = 0; i < this.inputs.length; i++) {
+      const input = this.inputs[i];
+      const resolvedInput = resolved.inputs[i];
+      switch (input.$kind) {
+        case "UnresolvedPure":
+          if (resolvedInput.$kind !== "Pure") throw new Error(`Expected input at index ${i} to resolve to a Pure argument, but got ${JSON.stringify(resolvedInput)}`);
+          this.inputs[i] = resolvedInput;
+          break;
+        case "UnresolvedObject":
+          if (resolvedInput.$kind !== "Object") throw new Error(`Expected input at index ${i} to resolve to an Object argument, but got ${JSON.stringify(resolvedInput)}`);
+          if (resolvedInput.Object.$kind === "ImmOrOwnedObject" || resolvedInput.Object.$kind === "Receiving") {
+            const original = input.UnresolvedObject;
+            const resolved$1 = resolvedInput.Object.ImmOrOwnedObject ?? resolvedInput.Object.Receiving;
+            if (normalizeSuiAddress(original.objectId) !== normalizeSuiAddress(resolved$1.objectId) || original.version != null && original.version !== resolved$1.version || original.digest != null && original.digest !== resolved$1.digest || original.mutable != null || original.initialSharedVersion != null) throw new Error(`Input at index ${i} did not match unresolved object. ${JSON.stringify(original)} is not compatible with ${JSON.stringify(resolved$1)}`);
+          } else if (resolvedInput.Object.$kind === "SharedObject") {
+            const original = input.UnresolvedObject;
+            const resolved$1 = resolvedInput.Object.SharedObject;
+            if (normalizeSuiAddress(original.objectId) !== normalizeSuiAddress(resolved$1.objectId) || original.initialSharedVersion != null && original.initialSharedVersion !== resolved$1.initialSharedVersion || original.mutable != null && original.mutable !== resolved$1.mutable || original.version != null || original.digest != null) throw new Error(`Input at index ${i} did not match unresolved object. ${JSON.stringify(original)} is not compatible with ${JSON.stringify(resolved$1)}`);
+          } else throw new Error(`Input at index ${i} resolved to an unexpected Object kind: ${JSON.stringify(resolvedInput.Object)}`);
+          this.inputs[i] = resolvedInput;
+          break;
+      }
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Commands.mjs
+init_sui_types();
+init_dist2();
+var TransactionCommands = {
+  MoveCall(input) {
+    const [pkg, mod = "", fn = ""] = "target" in input ? input.target.split("::") : [
+      input.package,
+      input.module,
+      input.function
+    ];
+    return {
+      $kind: "MoveCall",
+      MoveCall: {
+        package: pkg,
+        module: mod,
+        function: fn,
+        typeArguments: input.typeArguments ?? [],
+        arguments: input.arguments ?? []
+      }
+    };
+  },
+  TransferObjects(objects, address) {
+    return {
+      $kind: "TransferObjects",
+      TransferObjects: {
+        objects: objects.map((o) => parse(ArgumentSchema, o)),
+        address: parse(ArgumentSchema, address)
+      }
+    };
+  },
+  SplitCoins(coin, amounts) {
+    return {
+      $kind: "SplitCoins",
+      SplitCoins: {
+        coin: parse(ArgumentSchema, coin),
+        amounts: amounts.map((o) => parse(ArgumentSchema, o))
+      }
+    };
+  },
+  MergeCoins(destination, sources) {
+    return {
+      $kind: "MergeCoins",
+      MergeCoins: {
+        destination: parse(ArgumentSchema, destination),
+        sources: sources.map((o) => parse(ArgumentSchema, o))
+      }
+    };
+  },
+  Publish({ modules, dependencies }) {
+    return {
+      $kind: "Publish",
+      Publish: {
+        modules: modules.map((module) => typeof module === "string" ? module : toBase64(new Uint8Array(module))),
+        dependencies: dependencies.map((dep) => normalizeSuiObjectId(dep))
+      }
+    };
+  },
+  Upgrade({ modules, dependencies, package: packageId, ticket }) {
+    return {
+      $kind: "Upgrade",
+      Upgrade: {
+        modules: modules.map((module) => typeof module === "string" ? module : toBase64(new Uint8Array(module))),
+        dependencies: dependencies.map((dep) => normalizeSuiObjectId(dep)),
+        package: packageId,
+        ticket: parse(ArgumentSchema, ticket)
+      }
+    };
+  },
+  MakeMoveVec({ type, elements }) {
+    return {
+      $kind: "MakeMoveVec",
+      MakeMoveVec: {
+        type: type ?? null,
+        elements: elements.map((o) => parse(ArgumentSchema, o))
+      }
+    };
+  },
+  Intent({ name, inputs = {}, data = {} }) {
+    return {
+      $kind: "$Intent",
+      $Intent: {
+        name,
+        inputs: Object.fromEntries(Object.entries(inputs).map(([key, value]) => [key, Array.isArray(value) ? value.map((o) => parse(ArgumentSchema, o)) : parse(ArgumentSchema, value)])),
+        data
+      }
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/data/v2.mjs
+function enumUnion(options) {
+  return union(Object.entries(options).map(([key, value]) => object({ [key]: value })));
+}
+var Argument2 = enumUnion({
+  GasCoin: literal(true),
+  Input: pipe(number(), integer()),
+  Result: pipe(number(), integer()),
+  NestedResult: tuple([pipe(number(), integer()), pipe(number(), integer())])
+});
+var GasData2 = object({
+  budget: nullable(JsonU64),
+  price: nullable(JsonU64),
+  owner: nullable(SuiAddress),
+  payment: nullable(array(ObjectRefSchema))
+});
+var ProgrammableMoveCall2 = object({
+  package: ObjectID,
+  module: string(),
+  function: string(),
+  typeArguments: array(string()),
+  arguments: array(Argument2)
+});
+var $Intent2 = object({
+  name: string(),
+  inputs: record(string(), union([Argument2, array(Argument2)])),
+  data: record(string(), unknown())
+});
+var Command2 = enumUnion({
+  MoveCall: ProgrammableMoveCall2,
+  TransferObjects: object({
+    objects: array(Argument2),
+    address: Argument2
+  }),
+  SplitCoins: object({
+    coin: Argument2,
+    amounts: array(Argument2)
+  }),
+  MergeCoins: object({
+    destination: Argument2,
+    sources: array(Argument2)
+  }),
+  Publish: object({
+    modules: array(BCSBytes),
+    dependencies: array(ObjectID)
+  }),
+  MakeMoveVec: object({
+    type: nullable(string()),
+    elements: array(Argument2)
+  }),
+  Upgrade: object({
+    modules: array(BCSBytes),
+    dependencies: array(ObjectID),
+    package: ObjectID,
+    ticket: Argument2
+  }),
+  $Intent: $Intent2
+});
+var CallArg2 = enumUnion({
+  Object: enumUnion({
+    ImmOrOwnedObject: ObjectRefSchema,
+    SharedObject: object({
+      objectId: ObjectID,
+      initialSharedVersion: JsonU64,
+      mutable: boolean()
+    }),
+    Receiving: ObjectRefSchema
+  }),
+  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 TransactionExpiration4 = enumUnion({
+  None: literal(true),
+  Epoch: JsonU64,
+  ValidDuring: ValidDuringSchema
+});
+var SerializedTransactionDataV2Schema = object({
+  version: literal(2),
+  sender: nullish(SuiAddress),
+  expiration: nullish(TransactionExpiration4),
+  gasData: GasData2,
+  inputs: array(CallArg2),
+  commands: array(Command2),
+  digest: optional(nullable(string()))
+});
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Inputs.mjs
+init_sui_types();
+init_dist2();
+function Pure(data) {
+  return {
+    $kind: "Pure",
+    Pure: { bytes: data instanceof Uint8Array ? toBase64(data) : data.toBase64() }
+  };
+}
+var Inputs = {
+  Pure,
+  ObjectRef({ objectId, digest, version }) {
+    return {
+      $kind: "Object",
+      Object: {
+        $kind: "ImmOrOwnedObject",
+        ImmOrOwnedObject: {
+          digest,
+          version,
+          objectId: normalizeSuiAddress(objectId)
+        }
+      }
+    };
+  },
+  SharedObjectRef({ objectId, mutable, initialSharedVersion }) {
+    return {
+      $kind: "Object",
+      Object: {
+        $kind: "SharedObject",
+        SharedObject: {
+          mutable,
+          initialSharedVersion,
+          objectId: normalizeSuiAddress(objectId)
+        }
+      }
+    };
+  },
+  ReceivingRef({ objectId, digest, version }) {
+    return {
+      $kind: "Object",
+      Object: {
+        $kind: "Receiving",
+        Receiving: {
+          digest,
+          version,
+          objectId: normalizeSuiAddress(objectId)
+        }
+      }
+    };
+  },
+  FundsWithdrawal({ reservation, typeArg, withdrawFrom }) {
+    return {
+      $kind: "FundsWithdrawal",
+      FundsWithdrawal: {
+        reservation,
+        typeArg,
+        withdrawFrom
+      }
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/resolve.mjs
+init_bcs2();
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/client/core-resolver.mjs
+init_sui_types();
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/client/errors.mjs
+var SuiClientError = class extends Error {
+};
+var SimulationError = class extends SuiClientError {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.executionError = options?.executionError;
+  }
+};
+var ObjectError = class ObjectError2 extends SuiClientError {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  static fromResponse(response, objectId) {
+    switch (response.code) {
+      case "notExists":
+        return new ObjectError2(response.code, `Object ${response.object_id} does not exist`);
+      case "dynamicFieldNotFound":
+        return new ObjectError2(response.code, `Dynamic field not found for object ${response.parent_object_id}`);
+      case "deleted":
+        return new ObjectError2(response.code, `Object ${response.object_id} has been deleted`);
+      case "displayError":
+        return new ObjectError2(response.code, `Display error: ${response.error}`);
+      case "unknown":
+      default:
+        return new ObjectError2(response.code, `Unknown error while loading object${objectId ? ` ${objectId}` : ""}`);
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/client/core-resolver.mjs
+init_constants();
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/serializer.mjs
+init_sui_types();
+init_bcs2();
+init_constants();
+function parseTypeName(typeName) {
+  const parts = typeName.split("::");
+  if (parts.length !== 3) throw new Error(`Invalid type name format: ${typeName}`);
+  return {
+    package: parts[0],
+    module: parts[1],
+    name: parts[2]
+  };
+}
+function isTxContext(param) {
+  if (param.body.$kind !== "datatype") return false;
+  const { package: pkg, module, name } = parseTypeName(param.body.datatype.typeName);
+  return normalizeSuiAddress(pkg) === SUI_FRAMEWORK_ADDRESS && module === "tx_context" && name === "TxContext";
+}
+function getPureBcsSchema(typeSignature) {
+  switch (typeSignature.$kind) {
+    case "address":
+      return suiBcs.Address;
+    case "bool":
+      return suiBcs.Bool;
+    case "u8":
+      return suiBcs.U8;
+    case "u16":
+      return suiBcs.U16;
+    case "u32":
+      return suiBcs.U32;
+    case "u64":
+      return suiBcs.U64;
+    case "u128":
+      return suiBcs.U128;
+    case "u256":
+      return suiBcs.U256;
+    case "vector": {
+      if (typeSignature.vector.$kind === "u8") return suiBcs.byteVector().transform({
+        input: (val) => typeof val === "string" ? new TextEncoder().encode(val) : val,
+        output: (val) => val
+      });
+      const type = getPureBcsSchema(typeSignature.vector);
+      return type ? suiBcs.vector(type) : null;
+    }
+    case "datatype": {
+      const { package: pkg, module, name } = parseTypeName(typeSignature.datatype.typeName);
+      const normalizedPkg = normalizeSuiAddress(pkg);
+      if (normalizedPkg === MOVE_STDLIB_ADDRESS) {
+        if (module === "ascii" && name === "String") return suiBcs.String;
+        if (module === "string" && name === "String") return suiBcs.String;
+        if (module === "option" && name === "Option") {
+          const type = getPureBcsSchema(typeSignature.datatype.typeParameters[0]);
+          return type ? suiBcs.vector(type) : null;
+        }
+      }
+      if (normalizedPkg === SUI_FRAMEWORK_ADDRESS) {
+        if (module === "object" && name === "ID") return suiBcs.Address;
+      }
+      return null;
+    }
+    case "typeParameter":
+    case "unknown":
+      return null;
+  }
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/client/core-resolver.mjs
+init_dist();
+var MAX_OBJECTS_PER_FETCH = 50;
+var GAS_SAFE_OVERHEAD = 1000n;
+var MAX_GAS = 5e10;
+function getClient(options) {
+  if (!options.client) throw new Error(`No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`);
+  return options.client;
+}
+async function coreClientResolveTransactionPlugin(transactionData, options, next) {
+  const client = getClient(options);
+  await normalizeInputs(transactionData, client);
+  await resolveObjectReferences(transactionData, client);
+  if (!options.onlyTransactionKind) await setGasData(transactionData, client);
+  return await next();
+}
+async function setGasData(transactionData, client) {
+  let systemState = null;
+  if (!transactionData.gasData.price) {
+    systemState = (await client.core.getCurrentSystemState()).systemState;
+    transactionData.gasData.price = systemState.referenceGasPrice;
+  }
+  await setGasBudget(transactionData, client);
+  await setGasPayment(transactionData, client);
+  if (!transactionData.expiration) await setExpiration(transactionData, client, systemState);
+}
+async function setGasBudget(transactionData, client) {
+  if (transactionData.gasData.budget) return;
+  const simulateResult = await client.core.simulateTransaction({
+    transaction: transactionData.build({ overrides: { gasData: {
+      budget: String(MAX_GAS),
+      payment: []
+    } } }),
+    include: { effects: true }
+  });
+  if (simulateResult.$kind === "FailedTransaction") {
+    const executionError = simulateResult.FailedTransaction.status.error ?? void 0;
+    throw new SimulationError(`Transaction resolution failed: ${executionError?.message ?? "Unknown error"}`, {
+      cause: simulateResult,
+      executionError
+    });
+  }
+  const gasUsed = simulateResult.Transaction.effects.gasUsed;
+  const safeOverhead = GAS_SAFE_OVERHEAD * BigInt(transactionData.gasData.price || 1n);
+  const baseComputationCostWithOverhead = BigInt(gasUsed.computationCost) + safeOverhead;
+  const gasBudget = baseComputationCostWithOverhead + BigInt(gasUsed.storageCost) - BigInt(gasUsed.storageRebate);
+  transactionData.gasData.budget = String(gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead);
+}
+async function setGasPayment(transactionData, client) {
+  if (!transactionData.gasData.payment) {
+    const gasPayer = transactionData.gasData.owner ?? transactionData.sender;
+    if (!gasPayer) throw new Error("Either a gas owner or sender must be set to determine gas payment.");
+    const normalizedGasPayer = normalizeSuiAddress(gasPayer);
+    let usesGasCoin = false;
+    let withdrawals = 0n;
+    transactionData.mapArguments((arg) => {
+      if (arg.$kind === "GasCoin") usesGasCoin = true;
+      else if (arg.$kind === "Input") {
+        const input = transactionData.inputs[arg.Input];
+        if (input.$kind === "FundsWithdrawal") {
+          const withdrawalOwner = input.FundsWithdrawal.withdrawFrom.Sender ? transactionData.sender : gasPayer;
+          if (withdrawalOwner && normalizeSuiAddress(withdrawalOwner) === normalizedGasPayer) {
+            if (input.FundsWithdrawal.reservation.$kind === "MaxAmountU64") withdrawals += BigInt(input.FundsWithdrawal.reservation.MaxAmountU64);
+          }
+        }
+      }
+      return arg;
+    });
+    const [suiBalance, coins] = await Promise.all([usesGasCoin ? null : client.core.getBalance({ owner: gasPayer }), client.core.listCoins({
+      owner: gasPayer,
+      coinType: SUI_TYPE_ARG
+    })]);
+    if (suiBalance?.balance.addressBalance && BigInt(suiBalance.balance.addressBalance) >= BigInt(transactionData.gasData.budget || "0") + withdrawals) {
+      transactionData.gasData.payment = [];
+      return;
+    }
+    const paymentCoins = coins.objects.filter((coin) => {
+      return !transactionData.inputs.find((input) => {
+        if (input.Object?.ImmOrOwnedObject) return coin.objectId === input.Object.ImmOrOwnedObject.objectId;
+        return false;
+      });
+    }).map((coin) => parse(ObjectRefSchema, {
+      objectId: coin.objectId,
+      digest: coin.digest,
+      version: coin.version
+    }));
+    if (!paymentCoins.length) throw new Error("No valid gas coins found for the transaction.");
+    transactionData.gasData.payment = paymentCoins;
+  }
+}
+async function setExpiration(transactionData, client, existingSystemState) {
+  if (transactionData.expiration || hasVersionedInputs(transactionData)) return;
+  const [systemState, { chainIdentifier }] = await Promise.all([existingSystemState ?? client.core.getCurrentSystemState().then((r) => r.systemState), client.core.getChainIdentifier()]);
+  const currentEpoch = BigInt(systemState.epoch);
+  transactionData.expiration = {
+    $kind: "ValidDuring",
+    ValidDuring: {
+      minEpoch: String(currentEpoch),
+      maxEpoch: String(currentEpoch + 1n),
+      minTimestamp: null,
+      maxTimestamp: null,
+      chain: chainIdentifier,
+      nonce: Math.random() * 4294967296 >>> 0
+    }
+  };
+}
+function hasVersionedInputs(transactionData) {
+  if (transactionData.gasData.payment?.length) return true;
+  return transactionData.inputs.some((input) => input.Object?.ImmOrOwnedObject || input.UnresolvedObject && input.UnresolvedObject.version);
+}
+async function resolveObjectReferences(transactionData, client) {
+  const objectsToResolve = transactionData.inputs.filter((input) => {
+    return input.UnresolvedObject && !(input.UnresolvedObject.version || input.UnresolvedObject?.initialSharedVersion);
+  });
+  const dedupedIds = [...new Set(objectsToResolve.map((input) => normalizeSuiObjectId(input.UnresolvedObject.objectId)))];
+  const objectChunks = dedupedIds.length ? chunk(dedupedIds, MAX_OBJECTS_PER_FETCH) : [];
+  const resolved = (await Promise.all(objectChunks.map((chunkIds) => client.core.getObjects({ objectIds: chunkIds })))).flatMap((result) => result.objects);
+  const responsesById = new Map(dedupedIds.map((id, index) => {
+    return [id, resolved[index]];
+  }));
+  const invalidObjects = Array.from(responsesById).filter(([_, obj]) => obj instanceof Error).map(([_, obj]) => obj.message);
+  if (invalidObjects.length) throw new Error(`The following input objects are invalid: ${invalidObjects.join(", ")}`);
+  const objects = resolved.map((object$1) => {
+    if (object$1 instanceof Error) throw new Error(`Failed to fetch object: ${object$1.message}`);
+    const owner = object$1.owner;
+    const initialSharedVersion = owner && typeof owner === "object" ? owner.$kind === "Shared" ? owner.Shared.initialSharedVersion : owner.$kind === "ConsensusAddressOwner" ? owner.ConsensusAddressOwner.startVersion : null : null;
+    return {
+      objectId: object$1.objectId,
+      digest: object$1.digest,
+      version: object$1.version,
+      initialSharedVersion
+    };
+  });
+  const objectsById = new Map(dedupedIds.map((id, index) => {
+    return [id, objects[index]];
+  }));
+  for (const [index, input] of transactionData.inputs.entries()) {
+    if (!input.UnresolvedObject) continue;
+    let updated;
+    const id = normalizeSuiAddress(input.UnresolvedObject.objectId);
+    const object$1 = objectsById.get(id);
+    if (input.UnresolvedObject.initialSharedVersion ?? object$1?.initialSharedVersion) updated = Inputs.SharedObjectRef({
+      objectId: id,
+      initialSharedVersion: input.UnresolvedObject.initialSharedVersion || object$1?.initialSharedVersion,
+      mutable: input.UnresolvedObject.mutable || isUsedAsMutable(transactionData, index)
+    });
+    else if (isUsedAsReceiving(transactionData, index)) updated = Inputs.ReceivingRef({
+      objectId: id,
+      digest: input.UnresolvedObject.digest ?? object$1?.digest,
+      version: input.UnresolvedObject.version ?? object$1?.version
+    });
+    transactionData.inputs[transactionData.inputs.indexOf(input)] = updated ?? Inputs.ObjectRef({
+      objectId: id,
+      digest: input.UnresolvedObject.digest ?? object$1?.digest,
+      version: input.UnresolvedObject.version ?? object$1?.version
+    });
+  }
+}
+async function normalizeInputs(transactionData, client) {
+  const { inputs, commands } = transactionData;
+  const moveCallsToResolve = [];
+  const moveFunctionsToResolve = /* @__PURE__ */ new Set();
+  commands.forEach((command) => {
+    if (command.MoveCall) {
+      if (command.MoveCall._argumentTypes) return;
+      if (command.MoveCall.arguments.map((arg) => {
+        if (arg.$kind === "Input") return transactionData.inputs[arg.Input];
+        return null;
+      }).some((input) => input?.UnresolvedPure || input?.UnresolvedObject && typeof input?.UnresolvedObject.mutable !== "boolean")) {
+        const functionName = `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`;
+        moveFunctionsToResolve.add(functionName);
+        moveCallsToResolve.push(command.MoveCall);
+      }
+    }
+  });
+  const moveFunctionParameters = /* @__PURE__ */ new Map();
+  if (moveFunctionsToResolve.size > 0) await Promise.all([...moveFunctionsToResolve].map(async (functionName) => {
+    const [packageId, moduleName, name] = functionName.split("::");
+    const { function: def } = await client.core.getMoveFunction({
+      packageId,
+      moduleName,
+      name
+    });
+    moveFunctionParameters.set(functionName, def.parameters);
+  }));
+  if (moveCallsToResolve.length) await Promise.all(moveCallsToResolve.map(async (moveCall) => {
+    const parameters = moveFunctionParameters.get(`${moveCall.package}::${moveCall.module}::${moveCall.function}`);
+    if (!parameters) return;
+    moveCall._argumentTypes = parameters.length > 0 && isTxContext(parameters.at(-1)) ? parameters.slice(0, parameters.length - 1) : parameters;
+  }));
+  commands.forEach((command) => {
+    if (!command.MoveCall) return;
+    const moveCall = command.MoveCall;
+    const fnName = `${moveCall.package}::${moveCall.module}::${moveCall.function}`;
+    const params = moveCall._argumentTypes;
+    if (!params) return;
+    if (params.length !== command.MoveCall.arguments.length) throw new Error(`Incorrect number of arguments for ${fnName}`);
+    params.forEach((param, i) => {
+      const arg = moveCall.arguments[i];
+      if (arg.$kind !== "Input") return;
+      const input = inputs[arg.Input];
+      if (!input.UnresolvedPure && !input.UnresolvedObject) return;
+      const inputValue = input.UnresolvedPure?.value ?? input.UnresolvedObject?.objectId;
+      const schema = getPureBcsSchema(param.body);
+      if (schema) {
+        arg.type = "pure";
+        inputs[inputs.indexOf(input)] = Inputs.Pure(schema.serialize(inputValue));
+        return;
+      }
+      if (typeof inputValue !== "string") throw new Error(`Expect the argument to be an object id string, got ${JSON.stringify(inputValue, null, 2)}`);
+      arg.type = "object";
+      const unresolvedObject = input.UnresolvedPure ? {
+        $kind: "UnresolvedObject",
+        UnresolvedObject: { objectId: inputValue }
+      } : input;
+      inputs[arg.Input] = unresolvedObject;
+    });
+  });
+}
+function isUsedAsMutable(transactionData, index) {
+  let usedAsMutable = false;
+  transactionData.getInputUses(index, (arg, tx) => {
+    if (tx.MoveCall && tx.MoveCall._argumentTypes) {
+      const argIndex = tx.MoveCall.arguments.indexOf(arg);
+      usedAsMutable = tx.MoveCall._argumentTypes[argIndex].reference !== "immutable" || usedAsMutable;
+    }
+    if (tx.$kind === "MakeMoveVec" || tx.$kind === "MergeCoins" || tx.$kind === "SplitCoins" || tx.$kind === "TransferObjects") usedAsMutable = true;
+  });
+  return usedAsMutable;
+}
+function isUsedAsReceiving(transactionData, index) {
+  let usedAsReceiving = false;
+  transactionData.getInputUses(index, (arg, tx) => {
+    if (tx.MoveCall && tx.MoveCall._argumentTypes) {
+      const argIndex = tx.MoveCall.arguments.indexOf(arg);
+      usedAsReceiving = isReceivingType(tx.MoveCall._argumentTypes[argIndex]) || usedAsReceiving;
+    }
+  });
+  return usedAsReceiving;
+}
+var RECEIVING_TYPE = "0x0000000000000000000000000000000000000000000000000000000000000002::transfer::Receiving";
+function isReceivingType(type) {
+  if (type.body.$kind !== "datatype") return false;
+  return type.body.datatype.typeName === RECEIVING_TYPE;
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/resolve.mjs
+function needsTransactionResolution(data, options) {
+  if (data.inputs.some((input) => {
+    return input.UnresolvedObject || input.UnresolvedPure;
+  })) return true;
+  if (!options.onlyTransactionKind) {
+    if (!data.gasData.price || !data.gasData.budget || !data.gasData.payment) return true;
+    if (data.gasData.payment.length === 0 && !data.expiration) return true;
+  }
+  return false;
+}
+async function resolveTransactionPlugin(transactionData, options, next) {
+  normalizeRawArguments(transactionData);
+  if (!needsTransactionResolution(transactionData, options)) {
+    await validate(transactionData);
+    return next();
+  }
+  return (getClient2(options).core?.resolveTransactionPlugin() ?? coreClientResolveTransactionPlugin)(transactionData, options, async () => {
+    await validate(transactionData);
+    await next();
+  });
+}
+function validate(transactionData) {
+  transactionData.inputs.forEach((input, index) => {
+    if (input.$kind !== "Object" && input.$kind !== "Pure" && input.$kind !== "FundsWithdrawal") throw new Error(`Input at index ${index} has not been resolved.  Expected a Pure, Object, or FundsWithdrawal input, but found ${JSON.stringify(input)}`);
+  });
+}
+function getClient2(options) {
+  if (!options.client) throw new Error(`No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`);
+  return options.client;
+}
+function normalizeRawArguments(transactionData) {
+  for (const command of transactionData.commands) switch (command.$kind) {
+    case "SplitCoins":
+      command.SplitCoins.amounts.forEach((amount) => {
+        normalizeRawArgument(amount, suiBcs.U64, transactionData);
+      });
+      break;
+    case "TransferObjects":
+      normalizeRawArgument(command.TransferObjects.address, suiBcs.Address, transactionData);
+      break;
+  }
+}
+function normalizeRawArgument(arg, schema, transactionData) {
+  if (arg.$kind !== "Input") return;
+  const input = transactionData.inputs[arg.Input];
+  if (input.$kind !== "UnresolvedPure") return;
+  transactionData.inputs[arg.Input] = Inputs.Pure(schema.serialize(input.UnresolvedPure.value));
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/object.mjs
+init_constants();
+function createObjectMethods(makeObject) {
+  function object2(value) {
+    return makeObject(value);
+  }
+  object2.system = (options) => {
+    const mutable = options?.mutable;
+    if (mutable !== void 0) return object2(Inputs.SharedObjectRef({
+      objectId: SUI_SYSTEM_STATE_OBJECT_ID,
+      initialSharedVersion: 1,
+      mutable
+    }));
+    return object2({
+      $kind: "UnresolvedObject",
+      UnresolvedObject: {
+        objectId: SUI_SYSTEM_STATE_OBJECT_ID,
+        initialSharedVersion: 1
+      }
+    });
+  };
+  object2.clock = () => object2(Inputs.SharedObjectRef({
+    objectId: SUI_CLOCK_OBJECT_ID,
+    initialSharedVersion: 1,
+    mutable: false
+  }));
+  object2.random = () => object2({
+    $kind: "UnresolvedObject",
+    UnresolvedObject: {
+      objectId: SUI_RANDOM_OBJECT_ID,
+      mutable: false
+    }
+  });
+  object2.denyList = (options) => {
+    return object2({
+      $kind: "UnresolvedObject",
+      UnresolvedObject: {
+        objectId: SUI_DENY_LIST_OBJECT_ID,
+        mutable: options?.mutable
+      }
+    });
+  };
+  object2.option = ({ type, value }) => (tx) => tx.moveCall({
+    typeArguments: [type],
+    target: `${MOVE_STDLIB_ADDRESS}::option::${value === null ? "none" : "some"}`,
+    arguments: value === null ? [] : [tx.object(value)]
+  });
+  return object2;
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/pure.mjs
+init_pure();
+init_bcs2();
+init_dist2();
+function createPure(makePure) {
+  function pure(typeOrSerializedValue, value) {
+    if (typeof typeOrSerializedValue === "string") return makePure(pureBcsSchemaFromTypeName(typeOrSerializedValue).serialize(value));
+    if (typeOrSerializedValue instanceof Uint8Array || isSerializedBcs(typeOrSerializedValue)) return makePure(typeOrSerializedValue);
+    throw new Error("tx.pure must be called either a bcs type name, or a serialized bcs value");
+  }
+  pure.u8 = (value) => makePure(suiBcs.U8.serialize(value));
+  pure.u16 = (value) => makePure(suiBcs.U16.serialize(value));
+  pure.u32 = (value) => makePure(suiBcs.U32.serialize(value));
+  pure.u64 = (value) => makePure(suiBcs.U64.serialize(value));
+  pure.u128 = (value) => makePure(suiBcs.U128.serialize(value));
+  pure.u256 = (value) => makePure(suiBcs.U256.serialize(value));
+  pure.bool = (value) => makePure(suiBcs.Bool.serialize(value));
+  pure.string = (value) => makePure(suiBcs.String.serialize(value));
+  pure.address = (value) => makePure(suiBcs.Address.serialize(value));
+  pure.id = pure.address;
+  pure.vector = (type, value) => {
+    return makePure(suiBcs.vector(pureBcsSchemaFromTypeName(type)).serialize(value));
+  };
+  pure.option = (type, value) => {
+    return makePure(suiBcs.option(pureBcsSchemaFromTypeName(type)).serialize(value));
+  };
+  return pure;
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/client/mvr.mjs
+init_move_registry();
+init_sui_types();
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/version.mjs
+var PACKAGE_VERSION = "2.11.0";
+var TARGETED_RPC_VERSION = "1.69.0";
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/client/mvr.mjs
+init_dist();
+var NAME_SEPARATOR = "/";
+var MVR_API_HEADER = { "Mvr-Source": `@mysten/sui@${PACKAGE_VERSION}` };
+var MvrClient = class {
+  #cache;
+  #url;
+  #pageSize;
+  #overrides;
+  constructor({ cache, url, pageSize = 50, overrides }) {
+    this.#cache = cache;
+    this.#url = url;
+    this.#pageSize = pageSize;
+    this.#overrides = {
+      packages: overrides?.packages,
+      types: overrides?.types
+    };
+    validateOverrides(this.#overrides);
+  }
+  get #mvrPackageDataLoader() {
+    return this.#cache.readSync(["#mvrPackageDataLoader", this.#url ?? ""], () => {
+      const loader = new DataLoader(async (packages) => {
+        if (!this.#url) throw new Error(`MVR Api URL is not set for the current client (resolving ${packages.join(", ")})`);
+        const resolved = await this.#resolvePackages(packages);
+        return packages.map((pkg) => resolved[pkg] ?? /* @__PURE__ */ new Error(`Failed to resolve package: ${pkg}`));
+      });
+      const overrides = this.#overrides?.packages;
+      if (overrides) for (const [pkg, id] of Object.entries(overrides)) loader.prime(pkg, id);
+      return loader;
+    });
+  }
+  get #mvrTypeDataLoader() {
+    return this.#cache.readSync(["#mvrTypeDataLoader", this.#url ?? ""], () => {
+      const loader = new DataLoader(async (types) => {
+        if (!this.#url) throw new Error(`MVR Api URL is not set for the current client (resolving ${types.join(", ")})`);
+        const resolved = await this.#resolveTypes(types);
+        return types.map((type) => resolved[type] ?? /* @__PURE__ */ new Error(`Failed to resolve type: ${type}`));
+      });
+      const overrides = this.#overrides?.types;
+      if (overrides) for (const [type, id] of Object.entries(overrides)) loader.prime(type, id);
+      return loader;
+    });
+  }
+  async #resolvePackages(packages) {
+    if (packages.length === 0) return {};
+    const batches = chunk(packages, this.#pageSize);
+    const results = {};
+    await Promise.all(batches.map(async (batch) => {
+      const data = await this.#fetch("/v1/resolution/bulk", { names: batch });
+      if (!data?.resolution) return;
+      for (const pkg of Object.keys(data?.resolution)) {
+        const pkgData = data.resolution[pkg]?.package_id;
+        if (!pkgData) continue;
+        results[pkg] = pkgData;
+      }
+    }));
+    return results;
+  }
+  async #resolveTypes(types) {
+    if (types.length === 0) return {};
+    const batches = chunk(types, this.#pageSize);
+    const results = {};
+    await Promise.all(batches.map(async (batch) => {
+      const data = await this.#fetch("/v1/struct-definition/bulk", { types: batch });
+      if (!data?.resolution) return;
+      for (const type of Object.keys(data?.resolution)) {
+        const typeData = data.resolution[type]?.type_tag;
+        if (!typeData) continue;
+        results[type] = typeData;
+      }
+    }));
+    return results;
+  }
+  async #fetch(url, body) {
+    if (!this.#url) throw new Error("MVR Api URL is not set for the current client");
+    const response = await fetch(`${this.#url}${url}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...MVR_API_HEADER
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      throw new Error(`Failed to resolve types: ${errorBody?.message}`);
+    }
+    return response.json();
+  }
+  async resolvePackage({ package: name }) {
+    if (!hasMvrName(name)) return { package: name };
+    return { package: await this.#mvrPackageDataLoader.load(name) };
+  }
+  async resolveType({ type }) {
+    if (!hasMvrName(type)) return { type };
+    const mvrTypes = [...extractMvrTypes(type)];
+    const resolvedTypes = await this.#mvrTypeDataLoader.loadMany(mvrTypes);
+    const typeMap = {};
+    for (let i = 0; i < mvrTypes.length; i++) {
+      const resolvedType = resolvedTypes[i];
+      if (resolvedType instanceof Error) throw resolvedType;
+      typeMap[mvrTypes[i]] = resolvedType;
+    }
+    return { type: replaceMvrNames(type, typeMap) };
+  }
+  async resolve({ types = [], packages = [] }) {
+    const mvrTypes = /* @__PURE__ */ new Set();
+    for (const type of types ?? []) extractMvrTypes(type, mvrTypes);
+    const typesArray = [...mvrTypes];
+    const [resolvedTypes, resolvedPackages] = await Promise.all([typesArray.length > 0 ? this.#mvrTypeDataLoader.loadMany(typesArray) : [], packages.length > 0 ? this.#mvrPackageDataLoader.loadMany(packages) : []]);
+    const typeMap = { ...this.#overrides?.types };
+    for (const [i, type] of typesArray.entries()) {
+      const resolvedType = resolvedTypes[i];
+      if (resolvedType instanceof Error) throw resolvedType;
+      typeMap[type] = resolvedType;
+    }
+    const replacedTypes = {};
+    for (const type of types ?? []) replacedTypes[type] = { type: replaceMvrNames(type, typeMap) };
+    const replacedPackages = {};
+    for (const [i, pkg] of (packages ?? []).entries()) {
+      const resolvedPkg = this.#overrides?.packages?.[pkg] ?? resolvedPackages[i];
+      if (resolvedPkg instanceof Error) throw resolvedPkg;
+      replacedPackages[pkg] = { package: resolvedPkg };
+    }
+    return {
+      types: replacedTypes,
+      packages: replacedPackages
+    };
+  }
+};
+function validateOverrides(overrides) {
+  if (overrides?.packages) for (const [pkg, id] of Object.entries(overrides.packages)) {
+    if (!isValidNamedPackage(pkg)) throw new Error(`Invalid package name: ${pkg}`);
+    if (!isValidSuiAddress(normalizeSuiAddress(id))) throw new Error(`Invalid package ID: ${id}`);
+  }
+  if (overrides?.types) for (const [type, val] of Object.entries(overrides.types)) {
+    if (parseStructTag(type).typeParams.length > 0) throw new Error("Type overrides must be first-level only. If you want to supply generic types, just pass each type individually.");
+    if (!isValidSuiAddress(parseStructTag(val).address)) throw new Error(`Invalid type: ${val}`);
+  }
+}
+function extractMvrTypes(type, types = /* @__PURE__ */ new Set()) {
+  if (typeof type === "string" && !hasMvrName(type)) return types;
+  const tag = isStructTag(type) ? type : parseStructTag(type);
+  if (hasMvrName(tag.address)) types.add(`${tag.address}::${tag.module}::${tag.name}`);
+  for (const param of tag.typeParams) extractMvrTypes(param, types);
+  return types;
+}
+function replaceMvrNames(tag, typeCache) {
+  const type = isStructTag(tag) ? tag : parseStructTag(tag);
+  const cacheHit = typeCache[`${type.address}::${type.module}::${type.name}`];
+  return normalizeStructTag({
+    ...type,
+    address: cacheHit ? cacheHit.split("::")[0] : type.address,
+    typeParams: type.typeParams.map((param) => replaceMvrNames(param, typeCache))
+  });
+}
+function hasMvrName(nameOrType) {
+  return nameOrType.includes(NAME_SEPARATOR) || nameOrType.includes("@") || nameOrType.includes(".sui");
+}
+function isStructTag(type) {
+  return typeof type === "object" && "address" in type && "module" in type && "name" in type && "typeParams" in type;
+}
+function findNamesInTransaction(builder) {
+  const packages = /* @__PURE__ */ new Set();
+  const types = /* @__PURE__ */ new Set();
+  for (const command of builder.commands) switch (command.$kind) {
+    case "MakeMoveVec":
+      if (command.MakeMoveVec.type) getNamesFromTypeList([command.MakeMoveVec.type]).forEach((type) => {
+        types.add(type);
+      });
+      break;
+    case "MoveCall":
+      const moveCall = command.MoveCall;
+      const pkg = moveCall.package.split("::")[0];
+      if (hasMvrName(pkg)) {
+        if (!isValidNamedPackage(pkg)) throw new Error(`Invalid package name: ${pkg}`);
+        packages.add(pkg);
+      }
+      getNamesFromTypeList(moveCall.typeArguments ?? []).forEach((type) => {
+        types.add(type);
+      });
+      break;
+    default:
+      break;
+  }
+  return {
+    packages: [...packages],
+    types: [...types]
+  };
+}
+function replaceNames(builder, resolved) {
+  for (const command of builder.commands) {
+    if (command.MakeMoveVec?.type) {
+      if (!hasMvrName(command.MakeMoveVec.type)) continue;
+      if (!resolved.types[command.MakeMoveVec.type]) throw new Error(`No resolution found for type: ${command.MakeMoveVec.type}`);
+      command.MakeMoveVec.type = resolved.types[command.MakeMoveVec.type].type;
+    }
+    const tx = command.MoveCall;
+    if (!tx) continue;
+    const nameParts = tx.package.split("::");
+    const name = nameParts[0];
+    if (hasMvrName(name) && !resolved.packages[name]) throw new Error(`No address found for package: ${name}`);
+    if (hasMvrName(name)) {
+      nameParts[0] = resolved.packages[name].package;
+      tx.package = nameParts.join("::");
+    }
+    const types = tx.typeArguments;
+    if (!types) continue;
+    for (let i = 0; i < types.length; i++) {
+      if (!hasMvrName(types[i])) continue;
+      if (!resolved.types[types[i]]) throw new Error(`No resolution found for type: ${types[i]}`);
+      types[i] = resolved.types[types[i]].type;
+    }
+    tx.typeArguments = types;
+  }
+}
+function getNamesFromTypeList(types) {
+  const names = /* @__PURE__ */ new Set();
+  for (const type of types) if (hasMvrName(type)) {
+    if (!isValidNamedType(type)) throw new Error(`Invalid type with names: ${type}`);
+    names.add(type);
+  }
+  return names;
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/plugins/NamedPackagesPlugin.mjs
+function namedPackagesPlugin() {
+  return async (transactionData, buildOptions, next) => {
+    const names = findNamesInTransaction(transactionData);
+    if (names.types.length === 0 && names.packages.length === 0) return next();
+    if (!buildOptions.client) throw new Error(`Transaction contains MVR names but no client was provided to resolve them. Please pass a client to Transaction#build()`);
+    replaceNames(transactionData, await buildOptions.client.core.mvr.resolve({
+      types: names.types,
+      packages: names.packages
+    }));
+    await next();
+  };
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/intents/CoinWithBalance.mjs
+init_sui_types();
+init_bcs2();
+var COIN_WITH_BALANCE = "CoinWithBalance";
+var SUI_TYPE = normalizeStructTag("0x2::sui::SUI");
+function coinWithBalance({ type = SUI_TYPE, balance, useGasCoin = true }) {
+  let coinResult = null;
+  return (tx) => {
+    if (coinResult) return coinResult;
+    tx.addIntentResolver(COIN_WITH_BALANCE, resolveCoinBalance);
+    const coinType = type === "gas" ? type : normalizeStructTag(type);
+    coinResult = tx.add(TransactionCommands.Intent({
+      name: COIN_WITH_BALANCE,
+      inputs: {},
+      data: {
+        type: coinType === SUI_TYPE && useGasCoin ? "gas" : coinType,
+        balance: BigInt(balance)
+      }
+    }));
+    return coinResult;
+  };
+}
+var CoinWithBalanceData = object({
+  type: string(),
+  balance: bigint()
+});
+async function resolveCoinBalance(transactionData, buildOptions, next) {
+  const coinTypes = /* @__PURE__ */ new Set();
+  const totalByType = /* @__PURE__ */ new Map();
+  if (!transactionData.sender) throw new Error("Sender must be set to resolve CoinWithBalance");
+  for (const command of transactionData.commands) if (command.$kind === "$Intent" && command.$Intent.name === COIN_WITH_BALANCE) {
+    const { type, balance } = parse(CoinWithBalanceData, command.$Intent.data);
+    if (type !== "gas" && balance > 0n) coinTypes.add(type);
+    totalByType.set(type, (totalByType.get(type) ?? 0n) + balance);
+  }
+  const usedIds = /* @__PURE__ */ new Set();
+  for (const input of transactionData.inputs) {
+    if (input.Object?.ImmOrOwnedObject) usedIds.add(input.Object.ImmOrOwnedObject.objectId);
+    if (input.UnresolvedObject?.objectId) usedIds.add(input.UnresolvedObject.objectId);
+  }
+  const coinsByType = /* @__PURE__ */ new Map();
+  const addressBalanceByType = /* @__PURE__ */ new Map();
+  const client = buildOptions.client;
+  if (!client) throw new Error("Client must be provided to build or serialize transactions with CoinWithBalance intents");
+  await Promise.all([...[...coinTypes].map(async (coinType) => {
+    const { coins, addressBalance } = await getCoinsAndBalanceOfType({
+      coinType,
+      balance: totalByType.get(coinType),
+      client,
+      owner: transactionData.sender,
+      usedIds
+    });
+    coinsByType.set(coinType, coins);
+    addressBalanceByType.set(coinType, addressBalance);
+  }), totalByType.has("gas") ? await client.core.getBalance({
+    owner: transactionData.sender,
+    coinType: SUI_TYPE
+  }).then(({ balance }) => {
+    addressBalanceByType.set("gas", BigInt(balance.addressBalance));
+  }) : null]);
+  const mergedCoins = /* @__PURE__ */ new Map();
+  for (const [index, transaction] of transactionData.commands.entries()) {
+    if (transaction.$kind !== "$Intent" || transaction.$Intent.name !== COIN_WITH_BALANCE) continue;
+    const { type, balance } = transaction.$Intent.data;
+    if (balance === 0n) {
+      transactionData.replaceCommand(index, TransactionCommands.MoveCall({
+        target: "0x2::coin::zero",
+        typeArguments: [type === "gas" ? SUI_TYPE : type]
+      }));
+      continue;
+    }
+    const commands = [];
+    if (addressBalanceByType.get(type) >= totalByType.get(type)) commands.push(TransactionCommands.MoveCall({
+      target: "0x2::coin::redeem_funds",
+      typeArguments: [type === "gas" ? SUI_TYPE : type],
+      arguments: [transactionData.addInput("withdrawal", Inputs.FundsWithdrawal({
+        reservation: {
+          $kind: "MaxAmountU64",
+          MaxAmountU64: String(balance)
+        },
+        typeArg: {
+          $kind: "Balance",
+          Balance: type === "gas" ? SUI_TYPE : type
+        },
+        withdrawFrom: {
+          $kind: "Sender",
+          Sender: true
+        }
+      }))]
+    }));
+    else {
+      if (!mergedCoins.has(type)) {
+        const addressBalance = addressBalanceByType.get(type) ?? 0n;
+        const coinType = type === "gas" ? SUI_TYPE : type;
+        let baseCoin;
+        let restCoins;
+        if (type === "gas") {
+          baseCoin = {
+            $kind: "GasCoin",
+            GasCoin: true
+          };
+          restCoins = [];
+        } else [baseCoin, ...restCoins] = coinsByType.get(type).map((coin) => transactionData.addInput("object", Inputs.ObjectRef({
+          objectId: coin.objectId,
+          digest: coin.digest,
+          version: coin.version
+        })));
+        if (addressBalance > 0n) {
+          commands.push(TransactionCommands.MoveCall({
+            target: "0x2::coin::redeem_funds",
+            typeArguments: [coinType],
+            arguments: [transactionData.addInput("withdrawal", Inputs.FundsWithdrawal({
+              reservation: {
+                $kind: "MaxAmountU64",
+                MaxAmountU64: String(addressBalance)
+              },
+              typeArg: {
+                $kind: "Balance",
+                Balance: coinType
+              },
+              withdrawFrom: {
+                $kind: "Sender",
+                Sender: true
+              }
+            }))]
+          }));
+          commands.push(TransactionCommands.MergeCoins(baseCoin, [{
+            $kind: "Result",
+            Result: index + commands.length - 1
+          }, ...restCoins]));
+        } else if (restCoins.length > 0) commands.push(TransactionCommands.MergeCoins(baseCoin, restCoins));
+        mergedCoins.set(type, baseCoin);
+      }
+      commands.push(TransactionCommands.SplitCoins(mergedCoins.get(type), [transactionData.addInput("pure", Inputs.Pure(suiBcs.u64().serialize(balance)))]));
+    }
+    transactionData.replaceCommand(index, commands);
+    transactionData.mapArguments((arg, _command, commandIndex) => {
+      if (commandIndex >= index && commandIndex < index + commands.length) return arg;
+      if (arg.$kind === "Result" && arg.Result === index) return {
+        $kind: "NestedResult",
+        NestedResult: [index + commands.length - 1, 0]
+      };
+      return arg;
+    });
+  }
+  return next();
+}
+async function getCoinsAndBalanceOfType({ coinType, balance, client, owner, usedIds }) {
+  let remainingBalance = balance;
+  const coins = [];
+  const balanceRequest = client.core.getBalance({
+    owner,
+    coinType
+  }).then(({ balance: balance$1 }) => {
+    remainingBalance -= BigInt(balance$1.addressBalance);
+    return balance$1;
+  });
+  const [allCoins, balanceResponse] = await Promise.all([loadMoreCoins(), balanceRequest]);
+  if (BigInt(balanceResponse.balance) < balance) throw new Error(`Insufficient balance of ${coinType} for owner ${owner}. Required: ${balance}, Available: ${balance - remainingBalance}`);
+  return {
+    coins: allCoins,
+    balance: BigInt(balanceResponse.coinBalance),
+    addressBalance: BigInt(balanceResponse.addressBalance),
+    coinBalance: BigInt(balanceResponse.coinBalance)
+  };
+  async function loadMoreCoins(cursor = null) {
+    const { objects, hasNextPage, cursor: nextCursor } = await client.core.listCoins({
+      owner,
+      coinType,
+      cursor
+    });
+    await balanceRequest;
+    if (remainingBalance > 0n) {
+      for (const coin of objects) {
+        if (usedIds.has(coin.objectId)) continue;
+        const coinBalance = BigInt(coin.balance);
+        coins.push(coin);
+        remainingBalance -= coinBalance;
+        if (remainingBalance <= 0) break;
+      }
+      if (hasNextPage) return loadMoreCoins(nextCursor);
+    }
+    return coins;
+  }
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.11.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Transaction.mjs
+init_dist2();
+function createTransactionResult(index, length = Infinity) {
+  const baseResult = {
+    $kind: "Result",
+    get Result() {
+      return typeof index === "function" ? index() : index;
+    }
+  };
+  const nestedResults = [];
+  const nestedResultFor = (resultIndex) => nestedResults[resultIndex] ??= {
+    $kind: "NestedResult",
+    get NestedResult() {
+      return [typeof index === "function" ? index() : index, resultIndex];
+    }
+  };
+  return new Proxy(baseResult, {
+    set() {
+      throw new Error("The transaction result is a proxy, and does not support setting properties directly");
+    },
+    get(target, property) {
+      if (property in target) return Reflect.get(target, property);
+      if (property === Symbol.iterator) return function* () {
+        let i = 0;
+        while (i < length) {
+          yield nestedResultFor(i);
+          i++;
+        }
+      };
+      if (typeof property === "symbol") return;
+      const resultIndex = parseInt(property, 10);
+      if (Number.isNaN(resultIndex) || resultIndex < 0) return;
+      return nestedResultFor(resultIndex);
+    }
+  });
+}
+var TRANSACTION_BRAND = /* @__PURE__ */ Symbol.for("@mysten/transaction");
+function isTransaction(obj) {
+  return !!obj && typeof obj === "object" && obj[TRANSACTION_BRAND] === true;
+}
+var Transaction = class Transaction2 {
+  #serializationPlugins;
+  #buildPlugins;
+  #intentResolvers = /* @__PURE__ */ new Map();
+  #inputSection = [];
+  #commandSection = [];
+  #availableResults = /* @__PURE__ */ new Set();
+  #pendingPromises = /* @__PURE__ */ new Set();
+  #added = /* @__PURE__ */ new Map();
+  /**
+  * Converts from a serialize transaction kind (built with `build({ onlyTransactionKind: true })`) to a `Transaction` class.
+  * Supports either a byte array, or base64-encoded bytes.
+  */
+  static fromKind(serialized) {
+    const tx = new Transaction2();
+    tx.#data = TransactionDataBuilder.fromKindBytes(typeof serialized === "string" ? fromBase64(serialized) : serialized);
+    tx.#inputSection = tx.#data.inputs.slice();
+    tx.#commandSection = tx.#data.commands.slice();
+    tx.#availableResults = new Set(tx.#commandSection.map((_, i) => i));
+    return tx;
+  }
+  /**
+  * Converts from a serialized transaction format to a `Transaction` class.
+  * There are two supported serialized formats:
+  * - A string returned from `Transaction#serialize`. The serialized format must be compatible, or it will throw an error.
+  * - A byte array (or base64-encoded bytes) containing BCS transaction data.
+  */
+  static from(transaction) {
+    const newTransaction = new Transaction2();
+    if (isTransaction(transaction)) newTransaction.#data = TransactionDataBuilder.restore(transaction.getData());
+    else if (typeof transaction !== "string" || !transaction.startsWith("{")) newTransaction.#data = TransactionDataBuilder.fromBytes(typeof transaction === "string" ? fromBase64(transaction) : transaction);
+    else newTransaction.#data = TransactionDataBuilder.restore(JSON.parse(transaction));
+    newTransaction.#inputSection = newTransaction.#data.inputs.slice();
+    newTransaction.#commandSection = newTransaction.#data.commands.slice();
+    newTransaction.#availableResults = new Set(newTransaction.#commandSection.map((_, i) => i));
+    if (!newTransaction.isPreparedForSerialization({ supportedIntents: [COIN_WITH_BALANCE] })) throw new Error("Transaction has unresolved intents or async thunks. Call `prepareForSerialization` before copying.");
+    if (newTransaction.#data.commands.some((cmd) => cmd.$Intent?.name === COIN_WITH_BALANCE)) newTransaction.addIntentResolver(COIN_WITH_BALANCE, resolveCoinBalance);
+    return newTransaction;
+  }
+  addSerializationPlugin(step) {
+    this.#serializationPlugins.push(step);
+  }
+  addBuildPlugin(step) {
+    this.#buildPlugins.push(step);
+  }
+  addIntentResolver(intent, resolver) {
+    if (this.#intentResolvers.has(intent) && this.#intentResolvers.get(intent) !== resolver) throw new Error(`Intent resolver for ${intent} already exists`);
+    this.#intentResolvers.set(intent, resolver);
+  }
+  setSender(sender) {
+    this.#data.sender = sender;
+  }
+  /**
+  * Sets the sender only if it has not already been set.
+  * This is useful for sponsored transaction flows where the sender may not be the same as the signer address.
+  */
+  setSenderIfNotSet(sender) {
+    if (!this.#data.sender) this.#data.sender = sender;
+  }
+  setExpiration(expiration) {
+    this.#data.expiration = expiration ? parse(TransactionExpiration2, expiration) : null;
+  }
+  setGasPrice(price) {
+    this.#data.gasData.price = String(price);
+  }
+  setGasBudget(budget) {
+    this.#data.gasData.budget = String(budget);
+  }
+  setGasBudgetIfNotSet(budget) {
+    if (this.#data.gasData.budget == null) this.#data.gasData.budget = String(budget);
+  }
+  setGasOwner(owner) {
+    this.#data.gasData.owner = owner;
+  }
+  setGasPayment(payments) {
+    this.#data.gasData.payment = payments.map((payment) => parse(ObjectRefSchema, payment));
+  }
+  #data;
+  /** Get a snapshot of the transaction data, in JSON form: */
+  getData() {
+    return this.#data.snapshot();
+  }
+  get [TRANSACTION_BRAND]() {
+    return true;
+  }
+  get pure() {
+    Object.defineProperty(this, "pure", {
+      enumerable: false,
+      value: createPure((value) => {
+        if (isSerializedBcs(value)) return this.#addInput("pure", {
+          $kind: "Pure",
+          Pure: { bytes: value.toBase64() }
+        });
+        return this.#addInput("pure", is(NormalizedCallArg, value) ? parse(NormalizedCallArg, value) : value instanceof Uint8Array ? Inputs.Pure(value) : {
+          $kind: "UnresolvedPure",
+          UnresolvedPure: { value }
+        });
+      })
+    });
+    return this.pure;
+  }
+  constructor() {
+    this.object = createObjectMethods((value) => {
+      if (typeof value === "function") return this.object(this.add(value));
+      if (typeof value === "object" && is(ArgumentSchema, value)) return value;
+      const id = getIdFromCallArg(value);
+      const inserted = this.#data.inputs.find((i) => id === getIdFromCallArg(i));
+      if (inserted?.Object?.SharedObject && typeof value === "object" && value.Object?.SharedObject) inserted.Object.SharedObject.mutable = inserted.Object.SharedObject.mutable || value.Object.SharedObject.mutable;
+      return inserted ? {
+        $kind: "Input",
+        Input: this.#data.inputs.indexOf(inserted),
+        type: "object"
+      } : this.#addInput("object", typeof value === "string" ? {
+        $kind: "UnresolvedObject",
+        UnresolvedObject: { objectId: normalizeSuiAddress(value) }
+      } : value);
+    });
+    this.#data = new TransactionDataBuilder();
+    this.#buildPlugins = [];
+    this.#serializationPlugins = [];
+  }
+  /** Returns an argument for the gas coin, to be used in a transaction. */
+  get gas() {
+    return {
+      $kind: "GasCoin",
+      GasCoin: true
+    };
+  }
+  /**
+  * Add a new object input to the transaction using the fully-resolved object reference.
+  * If you only have an object ID, use `builder.object(id)` instead.
+  */
+  objectRef(...args) {
+    return this.object(Inputs.ObjectRef(...args));
+  }
+  /**
+  * Add a new receiving input to the transaction using the fully-resolved object reference.
+  * If you only have an object ID, use `builder.object(id)` instead.
+  */
+  receivingRef(...args) {
+    return this.object(Inputs.ReceivingRef(...args));
+  }
+  /**
+  * Add a new shared object input to the transaction using the fully-resolved shared object reference.
+  * If you only have an object ID, use `builder.object(id)` instead.
+  */
+  sharedObjectRef(...args) {
+    return this.object(Inputs.SharedObjectRef(...args));
+  }
+  #fork() {
+    const fork = new Transaction2();
+    fork.#data = this.#data;
+    fork.#serializationPlugins = this.#serializationPlugins;
+    fork.#buildPlugins = this.#buildPlugins;
+    fork.#intentResolvers = this.#intentResolvers;
+    fork.#pendingPromises = this.#pendingPromises;
+    fork.#availableResults = new Set(this.#availableResults);
+    fork.#added = this.#added;
+    this.#inputSection.push(fork.#inputSection);
+    this.#commandSection.push(fork.#commandSection);
+    return fork;
+  }
+  add(command) {
+    if (typeof command === "function") {
+      if (this.#added.has(command)) return this.#added.get(command);
+      const fork = this.#fork();
+      const result = command(fork);
+      if (!(result && typeof result === "object" && "then" in result)) {
+        this.#availableResults = fork.#availableResults;
+        this.#added.set(command, result);
+        return result;
+      }
+      const placeholder = this.#addCommand({
+        $kind: "$Intent",
+        $Intent: {
+          name: "AsyncTransactionThunk",
+          inputs: {},
+          data: {
+            resultIndex: this.#data.commands.length,
+            result: null
+          }
+        }
+      });
+      this.#pendingPromises.add(Promise.resolve(result).then((result$1) => {
+        placeholder.$Intent.data.result = result$1;
+      }));
+      const txResult = createTransactionResult(() => placeholder.$Intent.data.resultIndex);
+      this.#added.set(command, txResult);
+      return txResult;
+    } else this.#addCommand(command);
+    return createTransactionResult(this.#data.commands.length - 1);
+  }
+  #addCommand(command) {
+    const resultIndex = this.#data.commands.length;
+    this.#commandSection.push(command);
+    this.#availableResults.add(resultIndex);
+    this.#data.commands.push(command);
+    this.#data.mapCommandArguments(resultIndex, (arg) => {
+      if (arg.$kind === "Result" && !this.#availableResults.has(arg.Result)) throw new Error(`Result { Result: ${arg.Result} } is not available to use in the current transaction`);
+      if (arg.$kind === "NestedResult" && !this.#availableResults.has(arg.NestedResult[0])) throw new Error(`Result { NestedResult: [${arg.NestedResult[0]}, ${arg.NestedResult[1]}] } is not available to use in the current transaction`);
+      if (arg.$kind === "Input" && arg.Input >= this.#data.inputs.length) throw new Error(`Input { Input: ${arg.Input} } references an input that does not exist in the current transaction`);
+      return arg;
+    });
+    return command;
+  }
+  #addInput(type, input) {
+    this.#inputSection.push(input);
+    return this.#data.addInput(type, input);
+  }
+  #normalizeTransactionArgument(arg) {
+    if (isSerializedBcs(arg)) return this.pure(arg);
+    return this.#resolveArgument(arg);
+  }
+  #resolveArgument(arg) {
+    if (typeof arg === "function") {
+      const resolved = this.add(arg);
+      if (typeof resolved === "function") return this.#resolveArgument(resolved);
+      return parse(ArgumentSchema, resolved);
+    }
+    return parse(ArgumentSchema, arg);
+  }
+  splitCoins(coin, amounts) {
+    const command = TransactionCommands.SplitCoins(typeof coin === "string" ? this.object(coin) : this.#resolveArgument(coin), amounts.map((amount) => typeof amount === "number" || typeof amount === "bigint" || typeof amount === "string" ? this.pure.u64(amount) : this.#normalizeTransactionArgument(amount)));
+    this.#addCommand(command);
+    return createTransactionResult(this.#data.commands.length - 1, amounts.length);
+  }
+  mergeCoins(destination, sources) {
+    return this.add(TransactionCommands.MergeCoins(this.object(destination), sources.map((src) => this.object(src))));
+  }
+  publish({ modules, dependencies }) {
+    return this.add(TransactionCommands.Publish({
+      modules,
+      dependencies
+    }));
+  }
+  upgrade({ modules, dependencies, package: packageId, ticket }) {
+    return this.add(TransactionCommands.Upgrade({
+      modules,
+      dependencies,
+      package: packageId,
+      ticket: this.object(ticket)
+    }));
+  }
+  moveCall({ arguments: args, ...input }) {
+    return this.add(TransactionCommands.MoveCall({
+      ...input,
+      arguments: args?.map((arg) => this.#normalizeTransactionArgument(arg))
+    }));
+  }
+  transferObjects(objects, address) {
+    return this.add(TransactionCommands.TransferObjects(objects.map((obj) => this.object(obj)), typeof address === "string" ? this.pure.address(address) : this.#normalizeTransactionArgument(address)));
+  }
+  makeMoveVec({ type, elements }) {
+    return this.add(TransactionCommands.MakeMoveVec({
+      type,
+      elements: elements.map((obj) => this.object(obj))
+    }));
+  }
+  /**
+  * Create a FundsWithdrawal input for withdrawing Balance<T> from an address balance accumulator.
+  * This is used for gas payments from address balances.
+  *
+  * @param options.amount - The Amount to withdraw (u64).
+  * @param options.type - The balance type (e.g., "0x2::sui::SUI"). Defaults to SUI.
+  */
+  withdrawal({ amount, type }) {
+    const input = {
+      $kind: "FundsWithdrawal",
+      FundsWithdrawal: {
+        reservation: {
+          $kind: "MaxAmountU64",
+          MaxAmountU64: String(amount)
+        },
+        typeArg: {
+          $kind: "Balance",
+          Balance: type ?? "0x2::sui::SUI"
+        },
+        withdrawFrom: {
+          $kind: "Sender",
+          Sender: true
+        }
+      }
+    };
+    return this.#addInput("object", input);
+  }
+  /**
+  * @deprecated Use toJSON instead.
+  * For synchronous serialization, you can use `getData()`
+  * */
+  serialize() {
+    return JSON.stringify(serializeV1TransactionData(this.#data.snapshot()));
+  }
+  async toJSON(options = {}) {
+    await this.prepareForSerialization(options);
+    const fullyResolved = this.isFullyResolved();
+    return JSON.stringify(parse(SerializedTransactionDataV2Schema, fullyResolved ? {
+      ...this.#data.snapshot(),
+      digest: this.#data.getDigest()
+    } : this.#data.snapshot()), (_key, value) => typeof value === "bigint" ? value.toString() : value, 2);
+  }
+  /** Build the transaction to BCS bytes, and sign it with the provided keypair. */
+  async sign(options) {
+    const { signer, ...buildOptions } = options;
+    const bytes = await this.build(buildOptions);
+    return signer.signTransaction(bytes);
+  }
+  /**
+  * Checks if the transaction is prepared for serialization to JSON.
+  * This means:
+  *  - All async thunks have been fully resolved
+  *  - All transaction intents have been resolved (unless in supportedIntents)
+  *
+  * Unlike `isFullyResolved()`, this does not require the sender, gas payment,
+  * budget, or object versions to be set.
+  */
+  isPreparedForSerialization(options = {}) {
+    if (this.#pendingPromises.size > 0) return false;
+    if (this.#data.commands.some((cmd) => cmd.$Intent && !options.supportedIntents?.includes(cmd.$Intent.name))) return false;
+    return true;
+  }
+  /**
+  *  Ensures that:
+  *  - All objects have been fully resolved to a specific version
+  *  - All pure inputs have been serialized to bytes
+  *  - All async thunks have been fully resolved
+  *  - All transaction intents have been resolved
+  * 	- The gas payment, budget, and price have been set
+  *  - The transaction sender has been set
+  *
+  *  When true, the transaction will always be built to the same bytes and digest (unless the transaction is mutated)
+  */
+  isFullyResolved() {
+    if (!this.isPreparedForSerialization()) return false;
+    if (!this.#data.sender) return false;
+    if (needsTransactionResolution(this.#data, {})) return false;
+    return true;
+  }
+  /** Build the transaction to BCS bytes. */
+  async build(options = {}) {
+    await this.prepareForSerialization(options);
+    await this.#prepareBuild(options);
+    return this.#data.build({ onlyTransactionKind: options.onlyTransactionKind });
+  }
+  /** Derive transaction digest */
+  async getDigest(options = {}) {
+    await this.prepareForSerialization(options);
+    await this.#prepareBuild(options);
+    return this.#data.getDigest();
+  }
+  /**
+  * Prepare the transaction by validating the transaction data and resolving all inputs
+  * so that it can be built into bytes.
+  */
+  async #prepareBuild(options) {
+    if (!options.onlyTransactionKind && !this.#data.sender) throw new Error("Missing transaction sender");
+    await this.#runPlugins([...this.#buildPlugins, resolveTransactionPlugin], options);
+  }
+  async #runPlugins(plugins, options) {
+    try {
+      const createNext = (i) => {
+        if (i >= plugins.length) return () => {
+        };
+        const plugin = plugins[i];
+        return async () => {
+          const next = createNext(i + 1);
+          let calledNext = false;
+          let nextResolved = false;
+          await plugin(this.#data, options, async () => {
+            if (calledNext) throw new Error(`next() was call multiple times in TransactionPlugin ${i}`);
+            calledNext = true;
+            await next();
+            nextResolved = true;
+          });
+          if (!calledNext) throw new Error(`next() was not called in TransactionPlugin ${i}`);
+          if (!nextResolved) throw new Error(`next() was not awaited in TransactionPlugin ${i}`);
+        };
+      };
+      await createNext(0)();
+    } finally {
+      this.#inputSection = this.#data.inputs.slice();
+      this.#commandSection = this.#data.commands.slice();
+      this.#availableResults = new Set(this.#commandSection.map((_, i) => i));
+    }
+  }
+  async #waitForPendingTasks() {
+    while (this.#pendingPromises.size > 0) {
+      const newPromise = Promise.all(this.#pendingPromises);
+      this.#pendingPromises.clear();
+      this.#pendingPromises.add(newPromise);
+      await newPromise;
+      this.#pendingPromises.delete(newPromise);
+    }
+  }
+  #sortCommandsAndInputs() {
+    const unorderedCommands = this.#data.commands;
+    const unorderedInputs = this.#data.inputs;
+    const orderedCommands = this.#commandSection.flat(Infinity);
+    const orderedInputs = this.#inputSection.flat(Infinity);
+    if (orderedCommands.length !== unorderedCommands.length) throw new Error("Unexpected number of commands found in transaction data");
+    if (orderedInputs.length !== unorderedInputs.length) throw new Error("Unexpected number of inputs found in transaction data");
+    const filteredCommands = orderedCommands.filter((cmd) => cmd.$Intent?.name !== "AsyncTransactionThunk");
+    this.#data.commands = filteredCommands;
+    this.#data.inputs = orderedInputs;
+    this.#commandSection = filteredCommands;
+    this.#inputSection = orderedInputs;
+    this.#availableResults = new Set(filteredCommands.map((_, i) => i));
+    function getOriginalIndex(index) {
+      const command = unorderedCommands[index];
+      if (command.$Intent?.name === "AsyncTransactionThunk") {
+        const result = command.$Intent.data.result;
+        if (result == null) throw new Error("AsyncTransactionThunk has not been resolved");
+        return getOriginalIndex(result.Result);
+      }
+      const updated = filteredCommands.indexOf(command);
+      if (updated === -1) throw new Error("Unable to find original index for command");
+      return updated;
+    }
+    this.#data.mapArguments((arg) => {
+      if (arg.$kind === "Input") {
+        const updated = orderedInputs.indexOf(unorderedInputs[arg.Input]);
+        if (updated === -1) throw new Error("Input has not been resolved");
+        return {
+          ...arg,
+          Input: updated
+        };
+      } else if (arg.$kind === "Result") {
+        const updated = getOriginalIndex(arg.Result);
+        return {
+          ...arg,
+          Result: updated
+        };
+      } else if (arg.$kind === "NestedResult") {
+        const updated = getOriginalIndex(arg.NestedResult[0]);
+        return {
+          ...arg,
+          NestedResult: [updated, arg.NestedResult[1]]
+        };
+      }
+      return arg;
+    });
+    for (const [i, cmd] of unorderedCommands.entries()) if (cmd.$Intent?.name === "AsyncTransactionThunk") try {
+      cmd.$Intent.data.resultIndex = getOriginalIndex(i);
+    } catch {
+    }
+  }
+  async prepareForSerialization(options) {
+    await this.#waitForPendingTasks();
+    this.#sortCommandsAndInputs();
+    const intents = /* @__PURE__ */ new Set();
+    for (const command of this.#data.commands) if (command.$Intent) intents.add(command.$Intent.name);
+    const steps = [...this.#serializationPlugins];
+    for (const intent of intents) {
+      if (options.supportedIntents?.includes(intent)) continue;
+      if (!this.#intentResolvers.has(intent)) throw new Error(`Missing intent resolver for ${intent}`);
+      steps.push(this.#intentResolvers.get(intent));
+    }
+    steps.push(namedPackagesPlugin());
+    await this.#runPlugins(steps, options);
+  }
+};
+
+export {
+  TypeTagSerializer,
+  normalizeTypeTag,
+  init_type_tag_serializer,
+  ExecutionStatus,
+  init_effects,
+  suiBcs,
+  bcs_exports,
+  init_bcs2 as init_bcs,
+  TransactionDataBuilder,
+  SUI_DECIMALS,
+  MIST_PER_SUI,
+  MOVE_STDLIB_ADDRESS,
+  SUI_FRAMEWORK_ADDRESS,
+  SUI_SYSTEM_ADDRESS,
+  SUI_CLOCK_OBJECT_ID,
+  SUI_SYSTEM_MODULE_NAME,
+  SUI_TYPE_ARG,
+  SUI_SYSTEM_STATE_OBJECT_ID,
+  SUI_RANDOM_OBJECT_ID,
+  SUI_COIN_REGISTRY_OBJECT_ID,
+  SUI_DENY_LIST_OBJECT_ID,
+  init_constants,
+  coinWithBalance,
+  ObjectError,
+  coreClientResolveTransactionPlugin,
+  PACKAGE_VERSION,
+  TARGETED_RPC_VERSION,
+  MvrClient,
+  hasMvrName,
+  isTransaction,
+  Transaction
+};
+//# sourceMappingURL=chunk-KHIL2KNW.js.map