@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0-zeta.0

package/dist/esm/chunk-UGFIWCJQ.mjs

@@ -1,130 +0,0 @@
-import {
-  AbstractKeylessAccount
-} from "./chunk-ILTEOGFF.mjs";
-import {
-  FederatedKeylessPublicKey
-} from "./chunk-6SNGKTWE.mjs";
-import {
-  getIssAudAndUidVal
-} from "./chunk-T573PCIR.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-
-// src/account/FederatedKeylessAccount.ts
-var FederatedKeylessAccount = class _FederatedKeylessAccount extends AbstractKeylessAccount {
-  /**
-   * Use the static generator `FederatedKeylessAccount.create(...)` instead.
-   * Creates a KeylessAccount instance using the provided parameters.
-   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.jwkAddress - The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.
-   * @param args.uidKey - Optional key for user identification, defaults to "sub".
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   */
-  constructor(args) {
-    const publicKey = FederatedKeylessPublicKey.create(args);
-    super({ publicKey, ...args });
-    this.publicKey = publicKey;
-    this.audless = args.audless ?? false;
-  }
-  /**
-   * Serializes the transaction data into a format suitable for transmission or storage.
-   * This function ensures that both the transaction bytes and the proof are properly serialized.
-   *
-   * @param serializer - The serializer instance used to convert the transaction data into bytes.
-   */
-  serialize(serializer) {
-    super.serialize(serializer);
-    this.publicKey.jwkAddress.serialize(serializer);
-  }
-  /**
-   * Deserializes the provided deserializer to create a KeylessAccount instance.
-   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
-   *
-   * @param deserializer - The deserializer instance used to retrieve the serialized data.
-   * @returns A KeylessAccount instance created from the deserialized data.
-   */
-  static deserialize(deserializer) {
-    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } = AbstractKeylessAccount.partialDeserialize(deserializer);
-    const jwkAddress = AccountAddress.deserialize(deserializer);
-    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
-    return new _FederatedKeylessAccount({
-      address,
-      proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwt,
-      verificationKeyHash,
-      jwkAddress
-    });
-  }
-  /**
-   * Deserialize bytes using this account's information.
-   *
-   * @param bytes The bytes being interpreted.
-   * @returns
-   */
-  static fromBytes(bytes) {
-    return _FederatedKeylessAccount.deserialize(Deserializer.fromHex(bytes));
-  }
-  /**
-   * Creates a KeylessAccount instance using the provided parameters.
-   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
-   * This is used instead of the KeylessAccount constructor.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.jwkAddress - The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.
-   * @param args.uidKey - Optional key for user identification, defaults to "sub".
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   */
-  static create(args) {
-    const {
-      address,
-      proof,
-      jwt,
-      ephemeralKeyPair,
-      pepper,
-      jwkAddress,
-      uidKey = "sub",
-      proofFetchCallback,
-      verificationKey
-    } = args;
-    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
-    return new _FederatedKeylessAccount({
-      address,
-      proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwkAddress: AccountAddress.from(jwkAddress),
-      jwt,
-      proofFetchCallback,
-      verificationKeyHash: verificationKey ? verificationKey.hash() : void 0
-    });
-  }
-};
-
-export {
-  FederatedKeylessAccount
-};
-//# sourceMappingURL=chunk-UGFIWCJQ.mjs.map

package/dist/esm/chunk-UGFIWCJQ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/FederatedKeylessAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { HexInput } from \"../types\";\nimport { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { getIssAudAndUidVal, Groth16VerificationKey, ZeroKnowledgeSig } from \"../core/crypto\";\n\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\nimport { Deserializer, Serializer } from \"../bcs\";\nimport { FederatedKeylessPublicKey } from \"../core/crypto/federatedKeyless\";\nimport { AbstractKeylessAccount, ProofFetchCallback } from \"./AbstractKeylessAccount\";\n\n/**\n * Account implementation for the FederatedKeyless authentication scheme.\n *\n * Used to represent a FederatedKeyless based account and sign transactions with it.\n *\n * Use `FederatedKeylessAccount.create()` to instantiate a KeylessAccount with a JSON Web Token (JWT), proof, EphemeralKeyPair and the\n * address the JSON Web Key Set (JWKS) are installed that will be used to verify the JWT.\n *\n * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,\n * EphemeralKeyPair, and corresponding proof.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class FederatedKeylessAccount extends AbstractKeylessAccount {\n  /**\n   * The FederatedKeylessPublicKey associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly publicKey: FederatedKeylessPublicKey;\n\n  readonly audless: boolean;\n\n  /**\n   * Use the static generator `FederatedKeylessAccount.create(...)` instead.\n   * Creates a KeylessAccount instance using the provided parameters.\n   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.jwkAddress - The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.\n   * @param args.uidKey - Optional key for user identification, defaults to \"sub\".\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   */\n  constructor(args: {\n    address?: AccountAddress;\n    ephemeralKeyPair: EphemeralKeyPair;\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    jwkAddress: AccountAddress;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    proofFetchCallback?: ProofFetchCallback;\n    jwt: string;\n    verificationKeyHash?: HexInput;\n    audless?: boolean;\n  }) {\n    const publicKey = FederatedKeylessPublicKey.create(args);\n    super({ publicKey, ...args });\n    this.publicKey = publicKey;\n    this.audless = args.audless ?? false;\n  }\n\n  /**\n   * Serializes the transaction data into a format suitable for transmission or storage.\n   * This function ensures that both the transaction bytes and the proof are properly serialized.\n   *\n   * @param serializer - The serializer instance used to convert the transaction data into bytes.\n   */\n  serialize(serializer: Serializer): void {\n    super.serialize(serializer);\n    this.publicKey.jwkAddress.serialize(serializer);\n  }\n\n  /**\n   * Deserializes the provided deserializer to create a KeylessAccount instance.\n   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.\n   *\n   * @param deserializer - The deserializer instance used to retrieve the serialized data.\n   * @returns A KeylessAccount instance created from the deserialized data.\n   */\n  static deserialize(deserializer: Deserializer): FederatedKeylessAccount {\n    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } =\n      AbstractKeylessAccount.partialDeserialize(deserializer);\n    const jwkAddress = AccountAddress.deserialize(deserializer);\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new FederatedKeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      verificationKeyHash,\n      jwkAddress,\n    });\n  }\n\n  /**\n   * Deserialize bytes using this account's information.\n   *\n   * @param bytes The bytes being interpreted.\n   * @returns\n   */\n  static fromBytes(bytes: HexInput): FederatedKeylessAccount {\n    return FederatedKeylessAccount.deserialize(Deserializer.fromHex(bytes));\n  }\n\n  /**\n   * Creates a KeylessAccount instance using the provided parameters.\n   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.\n   * This is used instead of the KeylessAccount constructor.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.jwkAddress - The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.\n   * @param args.uidKey - Optional key for user identification, defaults to \"sub\".\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   */\n  static create(args: {\n    address?: AccountAddress;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    pepper: HexInput;\n    jwkAddress: AccountAddressInput;\n    uidKey?: string;\n    proofFetchCallback?: ProofFetchCallback;\n    verificationKey?: Groth16VerificationKey;\n  }): FederatedKeylessAccount {\n    const {\n      address,\n      proof,\n      jwt,\n      ephemeralKeyPair,\n      pepper,\n      jwkAddress,\n      uidKey = \"sub\",\n      proofFetchCallback,\n      verificationKey,\n    } = args;\n\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new FederatedKeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwkAddress: AccountAddress.from(jwkAddress),\n      jwt,\n      proofFetchCallback,\n      verificationKeyHash: verificationKey ? verificationKey.hash() : undefined,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyBO,IAAM,0BAAN,MAAM,iCAAgC,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAwBlE,YAAY,MAcT;AACD,UAAM,YAAY,0BAA0B,OAAO,IAAI;AACvD,UAAM,EAAE,WAAW,GAAG,KAAK,CAAC;AAC5B,SAAK,YAAY;AACjB,SAAK,UAAU,KAAK,WAAW;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,UAAU,YAA8B;AACtC,UAAM,UAAU,UAAU;AAC1B,SAAK,UAAU,WAAW,UAAU,UAAU;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAO,YAAY,cAAqD;AACtE,UAAM,EAAE,SAAS,OAAO,kBAAkB,KAAK,QAAQ,QAAQ,oBAAoB,IACjF,uBAAuB,mBAAmB,YAAY;AACxD,UAAM,aAAa,eAAe,YAAY,YAAY;AAC1D,UAAM,EAAE,KAAK,KAAK,OAAO,IAAI,mBAAmB,EAAE,KAAK,OAAO,CAAC;AAC/D,WAAO,IAAI,yBAAwB;AAAA,MACjC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,UAAU,OAA0C;AACzD,WAAO,yBAAwB,YAAY,aAAa,QAAQ,KAAK,CAAC;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,OAAO,OAAO,MAUc;AAC1B,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,MACT;AAAA,MACA;AAAA,IACF,IAAI;AAEJ,UAAM,EAAE,KAAK,KAAK,OAAO,IAAI,mBAAmB,EAAE,KAAK,OAAO,CAAC;AAC/D,WAAO,IAAI,yBAAwB;AAAA,MACjC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,YAAY,eAAe,KAAK,UAAU;AAAA,MAC1C;AAAA,MACA;AAAA,MACA,qBAAqB,kBAAkB,gBAAgB,KAAK,IAAI;AAAA,IAClE,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/esm/chunk-UGKZQUGE.mjs

@@ -1,367 +0,0 @@
-import {
-  TypeTag
-} from "./chunk-DDZGHA66.mjs";
-import {
-  ModuleId
-} from "./chunk-FMNMYKYH.mjs";
-import {
-  Identifier
-} from "./chunk-MFFBZ43D.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  MoveVector,
-  Serialized
-} from "./chunk-KSK3XIGF.mjs";
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-QSYWLSSN.mjs";
-import {
-  EntryFunctionBytes
-} from "./chunk-6ASWESA2.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-
-// src/transactions/instances/transactionPayload.ts
-function deserializeFromScriptArgument(deserializer) {
-  const index = deserializer.deserializeUleb128AsU32();
-  switch (index) {
-    case 0 /* U8 */:
-      return U8.deserialize(deserializer);
-    case 1 /* U64 */:
-      return U64.deserialize(deserializer);
-    case 2 /* U128 */:
-      return U128.deserialize(deserializer);
-    case 3 /* Address */:
-      return AccountAddress.deserialize(deserializer);
-    case 4 /* U8Vector */:
-      return MoveVector.deserialize(deserializer, U8);
-    case 5 /* Bool */:
-      return Bool.deserialize(deserializer);
-    case 6 /* U16 */:
-      return U16.deserialize(deserializer);
-    case 7 /* U32 */:
-      return U32.deserialize(deserializer);
-    case 8 /* U256 */:
-      return U256.deserialize(deserializer);
-    case 9 /* Serialized */:
-      return Serialized.deserialize(deserializer);
-    default:
-      throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`);
-  }
-}
-var TransactionPayload = class extends Serializable {
-  /**
-   * Deserialize a Transaction Payload
-   * @group Implementation
-   * @category Transactions
-   */
-  /**
-   * Deserializes a multisig transaction payload from the provided deserializer.
-   * This function enables the reconstruction of a MultiSigTransactionPayload object from its serialized form.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Transactions
-   */
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Script */:
-        return TransactionPayloadScript.load(deserializer);
-      case 2 /* EntryFunction */:
-        return TransactionPayloadEntryFunction.load(deserializer);
-      case 3 /* Multisig */:
-        return TransactionPayloadMultiSig.load(deserializer);
-      default:
-        throw new Error(`Unknown variant index for TransactionPayload: ${index}`);
-    }
-  }
-};
-var TransactionPayloadScript = class _TransactionPayloadScript extends TransactionPayload {
-  /**
-   * Initializes a multi-sig account transaction with the provided payload.
-   *
-   * @param script - The payload of the multi-sig transaction. This can only be an EntryFunction for now, but Script might be
-   * supported in the future.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(script) {
-    super();
-    this.script = script;
-  }
-  /**
-   * Serializes the transaction payload, enabling future support for multiple types of inner transaction payloads.
-   *
-   * @param serializer - The serializer instance used to serialize the transaction data.
-   * @group Implementation
-   * @category Transactions
-   */
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* Script */);
-    this.script.serialize(serializer);
-  }
-  /**
-   * Loads a MultiSig transaction payload from the provided deserializer.
-   * This function helps in reconstructing a MultiSig transaction payload from its serialized form.
-   *
-   * @param deserializer - The deserializer used to read the serialized data.
-   * @group Implementation
-   * @category Transactions
-   */
-  static load(deserializer) {
-    const script = Script.deserialize(deserializer);
-    return new _TransactionPayloadScript(script);
-  }
-};
-var TransactionPayloadEntryFunction = class _TransactionPayloadEntryFunction extends TransactionPayload {
-  constructor(entryFunction) {
-    super();
-    this.entryFunction = entryFunction;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(2 /* EntryFunction */);
-    this.entryFunction.serialize(serializer);
-  }
-  static load(deserializer) {
-    const entryFunction = EntryFunction.deserialize(deserializer);
-    return new _TransactionPayloadEntryFunction(entryFunction);
-  }
-};
-var TransactionPayloadMultiSig = class _TransactionPayloadMultiSig extends TransactionPayload {
-  constructor(multiSig) {
-    super();
-    this.multiSig = multiSig;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(3 /* Multisig */);
-    this.multiSig.serialize(serializer);
-  }
-  static load(deserializer) {
-    const value = MultiSig.deserialize(deserializer);
-    return new _TransactionPayloadMultiSig(value);
-  }
-};
-var EntryFunction = class _EntryFunction {
-  /**
-   * Contains the payload to run a function within a module.
-   * @param module_name Fully qualified module name in format "account_address::module_name" e.g. "0x1::coin"
-   * @param function_name The function name. e.g "transfer"
-   * @param type_args Type arguments that move function requires.
-   *
-   * @example
-   * A coin transfer function has one type argument "CoinType".
-   * ```
-   * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   * @param args arguments to the move function.
-   *
-   * @example
-   * A coin transfer function has three arguments "from", "to" and "amount".
-   * ```
-   * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(module_name, function_name, type_args, args) {
-    this.module_name = module_name;
-    this.function_name = function_name;
-    this.type_args = type_args;
-    this.args = args;
-  }
-  /**
-   * Build an EntryFunction payload from raw primitive values.
-   *
-   * @param module_id - Fully qualified module name in the format "AccountAddress::module_id", e.g., "0x1::coin".
-   * @param function_name - The name of the function to be called.
-   * @param type_args - Type arguments that the Move function requires.
-   * @param args - Arguments to the Move function.
-   *
-   * @example
-   * A coin transfer function has one type argument "CoinType".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   *
-   * A coin transfer function has three arguments "from", "to", and "amount".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   *
-   * @returns EntryFunction
-   * @group Implementation
-   * @category Transactions
-   */
-  static build(module_id, function_name, type_args, args) {
-    return new _EntryFunction(ModuleId.fromStr(module_id), new Identifier(function_name), type_args, args);
-  }
-  serialize(serializer) {
-    this.module_name.serialize(serializer);
-    this.function_name.serialize(serializer);
-    serializer.serializeVector(this.type_args);
-    serializer.serializeU32AsUleb128(this.args.length);
-    this.args.forEach((item) => {
-      item.serializeForEntryFunction(serializer);
-    });
-  }
-  /**
-   * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.
-   * @see EntryFunctionBytes
-   *
-   * NOTE: When you deserialize an EntryFunction payload with this method, the entry function
-   * arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes
-   * in the form of the EntryFunctionBytes class.
-   *
-   * In order to correctly deserialize these arguments as their actual type representations, you
-   * must know the types of the arguments beforehand and deserialize them yourself individually.
-   *
-   * One way you could achieve this is by using the ABIs for an entry function and deserializing each
-   * argument as its given, corresponding type.
-   *
-   * @param deserializer
-   * @returns A deserialized EntryFunction payload for a transaction.
-   *
-   * @group Implementation
-   * @category Transactions
-   */
-  static deserialize(deserializer) {
-    const module_name = ModuleId.deserialize(deserializer);
-    const function_name = Identifier.deserialize(deserializer);
-    const type_args = deserializer.deserializeVector(TypeTag);
-    const length = deserializer.deserializeUleb128AsU32();
-    const args = new Array();
-    for (let i = 0; i < length; i += 1) {
-      const fixedBytesLength = deserializer.deserializeUleb128AsU32();
-      const fixedBytes = EntryFunctionBytes.deserialize(deserializer, fixedBytesLength);
-      args.push(fixedBytes);
-    }
-    return new _EntryFunction(module_name, function_name, type_args, args);
-  }
-};
-var Script = class _Script {
-  /**
-   * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.
-   *
-   * @param bytecode The move module bytecode
-   * @param type_args The type arguments that the bytecode function requires.
-   *
-   * @example
-   * A coin transfer function has one type argument "CoinType".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   * @param args The arguments that the bytecode function requires.
-   *
-   * @example
-   * A coin transfer function has three arguments "from", "to" and "amount".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(bytecode, type_args, args) {
-    this.bytecode = bytecode;
-    this.type_args = type_args;
-    this.args = args;
-  }
-  serialize(serializer) {
-    serializer.serializeBytes(this.bytecode);
-    serializer.serializeVector(this.type_args);
-    serializer.serializeU32AsUleb128(this.args.length);
-    this.args.forEach((item) => {
-      item.serializeForScriptFunction(serializer);
-    });
-  }
-  static deserialize(deserializer) {
-    const bytecode = deserializer.deserializeBytes();
-    const type_args = deserializer.deserializeVector(TypeTag);
-    const length = deserializer.deserializeUleb128AsU32();
-    const args = new Array();
-    for (let i = 0; i < length; i += 1) {
-      const scriptArgument = deserializeFromScriptArgument(deserializer);
-      args.push(scriptArgument);
-    }
-    return new _Script(bytecode, type_args, args);
-  }
-};
-var MultiSig = class _MultiSig {
-  /**
-   * Contains the payload to run a multi-sig account transaction.
-   *
-   * @param multisig_address The multi-sig account address the transaction will be executed as.
-   *
-   * @param transaction_payload The payload of the multi-sig transaction. This is optional when executing a multi-sig
-   *  transaction whose payload is already stored on chain.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(multisig_address, transaction_payload) {
-    this.multisig_address = multisig_address;
-    this.transaction_payload = transaction_payload;
-  }
-  serialize(serializer) {
-    this.multisig_address.serialize(serializer);
-    if (this.transaction_payload === void 0) {
-      serializer.serializeBool(false);
-    } else {
-      serializer.serializeBool(true);
-      this.transaction_payload.serialize(serializer);
-    }
-  }
-  static deserialize(deserializer) {
-    const multisig_address = AccountAddress.deserialize(deserializer);
-    const payloadPresent = deserializer.deserializeBool();
-    let transaction_payload;
-    if (payloadPresent) {
-      transaction_payload = MultiSigTransactionPayload.deserialize(deserializer);
-    }
-    return new _MultiSig(multisig_address, transaction_payload);
-  }
-};
-var MultiSigTransactionPayload = class _MultiSigTransactionPayload extends Serializable {
-  /**
-   * Contains the payload to run a multi-sig account transaction.
-   *
-   * @param transaction_payload The payload of the multi-sig transaction.
-   * This can only be EntryFunction for now but,
-   * Script might be supported in the future.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(transaction_payload) {
-    super();
-    this.transaction_payload = transaction_payload;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0);
-    this.transaction_payload.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    deserializer.deserializeUleb128AsU32();
-    return new _MultiSigTransactionPayload(EntryFunction.deserialize(deserializer));
-  }
-};
-
-export {
-  deserializeFromScriptArgument,
-  TransactionPayload,
-  TransactionPayloadScript,
-  TransactionPayloadEntryFunction,
-  TransactionPayloadMultiSig,
-  EntryFunction,
-  Script,
-  MultiSig,
-  MultiSigTransactionPayload
-};
-//# sourceMappingURL=chunk-UGKZQUGE.mjs.map

package/dist/esm/chunk-UGKZQUGE.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/instances/transactionPayload.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { EntryFunctionBytes } from \"../../bcs/serializable/entryFunctionBytes\";\nimport { Bool, U128, U16, U256, U32, U64, U8 } from \"../../bcs/serializable/movePrimitives\";\nimport { MoveVector, Serialized } from \"../../bcs/serializable/moveStructs\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"./identifier\";\nimport { ModuleId } from \"./moduleId\";\nimport type { EntryFunctionArgument, ScriptFunctionArgument, TransactionArgument } from \"./transactionArgument\";\nimport { MoveModuleId, ScriptTransactionArgumentVariants, TransactionPayloadVariants } from \"../../types\";\nimport { TypeTag } from \"../typeTag\";\n\n/**\n * Deserialize a Script Transaction Argument.\n * This function retrieves and deserializes various types of script transaction arguments based on the provided deserializer.\n *\n * @param deserializer - The deserializer used to read the script transaction argument.\n * @returns The deserialized script transaction argument.\n * @throws Error if the variant index is unknown.\n * @group Implementation\n * @category Transactions\n */\nexport function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument {\n  // index enum variant\n  const index = deserializer.deserializeUleb128AsU32();\n  switch (index) {\n    case ScriptTransactionArgumentVariants.U8:\n      return U8.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U64:\n      return U64.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U128:\n      return U128.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.Address:\n      return AccountAddress.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U8Vector:\n      return MoveVector.deserialize(deserializer, U8);\n    case ScriptTransactionArgumentVariants.Bool:\n      return Bool.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U16:\n      return U16.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U32:\n      return U32.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U256:\n      return U256.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.Serialized:\n      return Serialized.deserialize(deserializer);\n    default:\n      throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`);\n  }\n}\n\n/**\n * Represents a supported Transaction Payload that can be serialized and deserialized.\n *\n * This class serves as a base for different types of transaction payloads, allowing for\n * their serialization into a format suitable for transmission and deserialization back\n * into their original form.\n * @group Implementation\n * @category Transactions\n */\nexport abstract class TransactionPayload extends Serializable {\n  /**\n   * Serialize a Transaction Payload\n   * @group Implementation\n   * @category Transactions\n   */\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Deserialize a Transaction Payload\n   * @group Implementation\n   * @category Transactions\n   */\n\n  /**\n   * Deserializes a multisig transaction payload from the provided deserializer.\n   * This function enables the reconstruction of a MultiSigTransactionPayload object from its serialized form.\n   *\n   * @param deserializer - The deserializer instance used to read the serialized data.\n   * @group Implementation\n   * @category Transactions\n   */\n  static deserialize(deserializer: Deserializer): TransactionPayload {\n    // index enum variant\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case TransactionPayloadVariants.Script:\n        return TransactionPayloadScript.load(deserializer);\n      case TransactionPayloadVariants.EntryFunction:\n        return TransactionPayloadEntryFunction.load(deserializer);\n      case TransactionPayloadVariants.Multisig:\n        return TransactionPayloadMultiSig.load(deserializer);\n      default:\n        throw new Error(`Unknown variant index for TransactionPayload: ${index}`);\n    }\n  }\n}\n\n/**\n * Represents a transaction payload script that can be serialized and deserialized.\n *\n * This class encapsulates a script that defines the logic for a transaction payload.\n *\n * @extends TransactionPayload\n * @group Implementation\n * @category Transactions\n */\nexport class TransactionPayloadScript extends TransactionPayload {\n  public readonly script: Script;\n\n  /**\n   * Initializes a multi-sig account transaction with the provided payload.\n   *\n   * @param script - The payload of the multi-sig transaction. This can only be an EntryFunction for now, but Script might be\n   * supported in the future.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(script: Script) {\n    super();\n    this.script = script;\n  }\n\n  /**\n   * Serializes the transaction payload, enabling future support for multiple types of inner transaction payloads.\n   *\n   * @param serializer - The serializer instance used to serialize the transaction data.\n   * @group Implementation\n   * @category Transactions\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionPayloadVariants.Script);\n    this.script.serialize(serializer);\n  }\n\n  /**\n   * Loads a MultiSig transaction payload from the provided deserializer.\n   * This function helps in reconstructing a MultiSig transaction payload from its serialized form.\n   *\n   * @param deserializer - The deserializer used to read the serialized data.\n   * @group Implementation\n   * @category Transactions\n   */\n  static load(deserializer: Deserializer): TransactionPayloadScript {\n    const script = Script.deserialize(deserializer);\n    return new TransactionPayloadScript(script);\n  }\n}\n\n/**\n * Represents a transaction payload entry function that can be serialized and deserialized.\n *\n * @extends TransactionPayload\n * @group Implementation\n * @category Transactions\n */\nexport class TransactionPayloadEntryFunction extends TransactionPayload {\n  public readonly entryFunction: EntryFunction;\n\n  constructor(entryFunction: EntryFunction) {\n    super();\n    this.entryFunction = entryFunction;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionPayloadVariants.EntryFunction);\n    this.entryFunction.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TransactionPayloadEntryFunction {\n    const entryFunction = EntryFunction.deserialize(deserializer);\n    return new TransactionPayloadEntryFunction(entryFunction);\n  }\n}\n\n/**\n * Represents a multi-signature transaction payload that can be serialized and deserialized.\n * @group Implementation\n * @category Transactions\n */\nexport class TransactionPayloadMultiSig extends TransactionPayload {\n  public readonly multiSig: MultiSig;\n\n  constructor(multiSig: MultiSig) {\n    super();\n    this.multiSig = multiSig;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionPayloadVariants.Multisig);\n    this.multiSig.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TransactionPayloadMultiSig {\n    const value = MultiSig.deserialize(deserializer);\n    return new TransactionPayloadMultiSig(value);\n  }\n}\n\n/**\n * Represents an entry function that can be serialized and deserialized.\n * This class encapsulates the details required to invoke a function within a module,\n * including the module name, function name, type arguments, and function arguments.\n *\n * @param module_name - Fully qualified module name in the format \"account_address::module_name\" (e.g., \"0x1::coin\").\n * @param function_name - The name of the function (e.g., \"transfer\").\n * @param type_args - Type arguments required by the Move function.\n * @param args - Arguments to the Move function.\n * @group Implementation\n * @category Transactions\n */\nexport class EntryFunction {\n  public readonly module_name: ModuleId;\n\n  public readonly function_name: Identifier;\n\n  public readonly type_args: Array<TypeTag>;\n\n  public readonly args: Array<EntryFunctionArgument>;\n\n  /**\n   * Contains the payload to run a function within a module.\n   * @param module_name Fully qualified module name in format \"account_address::module_name\" e.g. \"0x1::coin\"\n   * @param function_name The function name. e.g \"transfer\"\n   * @param type_args Type arguments that move function requires.\n   *\n   * @example\n   * A coin transfer function has one type argument \"CoinType\".\n   * ```\n   * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)\n   * ```\n   * @param args arguments to the move function.\n   *\n   * @example\n   * A coin transfer function has three arguments \"from\", \"to\" and \"amount\".\n   * ```\n   * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)\n   * ```\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(\n    module_name: ModuleId,\n    function_name: Identifier,\n    type_args: Array<TypeTag>,\n    args: Array<EntryFunctionArgument>,\n  ) {\n    this.module_name = module_name;\n    this.function_name = function_name;\n    this.type_args = type_args;\n    this.args = args;\n  }\n\n  /**\n   * Build an EntryFunction payload from raw primitive values.\n   *\n   * @param module_id - Fully qualified module name in the format \"AccountAddress::module_id\", e.g., \"0x1::coin\".\n   * @param function_name - The name of the function to be called.\n   * @param type_args - Type arguments that the Move function requires.\n   * @param args - Arguments to the Move function.\n   *\n   * @example\n   * A coin transfer function has one type argument \"CoinType\".\n   * ```\n   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)\n   * ```\n   *\n   * A coin transfer function has three arguments \"from\", \"to\", and \"amount\".\n   * ```\n   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)\n   * ```\n   *\n   * @returns EntryFunction\n   * @group Implementation\n   * @category Transactions\n   */\n  static build(\n    module_id: MoveModuleId,\n    function_name: string,\n    type_args: Array<TypeTag>,\n    args: Array<EntryFunctionArgument>,\n  ): EntryFunction {\n    return new EntryFunction(ModuleId.fromStr(module_id), new Identifier(function_name), type_args, args);\n  }\n\n  serialize(serializer: Serializer): void {\n    this.module_name.serialize(serializer);\n    this.function_name.serialize(serializer);\n    serializer.serializeVector<TypeTag>(this.type_args);\n    serializer.serializeU32AsUleb128(this.args.length);\n    this.args.forEach((item: EntryFunctionArgument) => {\n      item.serializeForEntryFunction(serializer);\n    });\n  }\n\n  /**\n   * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.\n   * @see EntryFunctionBytes\n   *\n   * NOTE: When you deserialize an EntryFunction payload with this method, the entry function\n   * arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes\n   * in the form of the EntryFunctionBytes class.\n   *\n   * In order to correctly deserialize these arguments as their actual type representations, you\n   * must know the types of the arguments beforehand and deserialize them yourself individually.\n   *\n   * One way you could achieve this is by using the ABIs for an entry function and deserializing each\n   * argument as its given, corresponding type.\n   *\n   * @param deserializer\n   * @returns A deserialized EntryFunction payload for a transaction.\n   *\n   * @group Implementation\n   * @category Transactions\n   */\n  static deserialize(deserializer: Deserializer): EntryFunction {\n    const module_name = ModuleId.deserialize(deserializer);\n    const function_name = Identifier.deserialize(deserializer);\n    const type_args = deserializer.deserializeVector(TypeTag);\n\n    const length = deserializer.deserializeUleb128AsU32();\n    const args: Array<EntryFunctionArgument> = new Array<EntryFunctionBytes>();\n\n    for (let i = 0; i < length; i += 1) {\n      const fixedBytesLength = deserializer.deserializeUleb128AsU32();\n      const fixedBytes = EntryFunctionBytes.deserialize(deserializer, fixedBytesLength);\n      args.push(fixedBytes);\n    }\n\n    return new EntryFunction(module_name, function_name, type_args, args);\n  }\n}\n\n/**\n * Represents a Script that can be serialized and deserialized.\n * Scripts contain the Move bytecode payload that can be submitted to the Aptos chain for execution.\n * @group Implementation\n * @category Transactions\n */\nexport class Script {\n  /**\n   * The move module bytecode\n   * @group Implementation\n   * @category Transactions\n   */\n  public readonly bytecode: Uint8Array;\n\n  /**\n   * The type arguments that the bytecode function requires.\n   * @group Implementation\n   * @category Transactions\n   */\n  public readonly type_args: Array<TypeTag>;\n\n  /**\n   * The arguments that the bytecode function requires.\n   * @group Implementation\n   * @category Transactions\n   */\n  public readonly args: Array<ScriptFunctionArgument>;\n\n  /**\n   * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.\n   *\n   * @param bytecode The move module bytecode\n   * @param type_args The type arguments that the bytecode function requires.\n   *\n   * @example\n   * A coin transfer function has one type argument \"CoinType\".\n   * ```\n   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)\n   * ```\n   * @param args The arguments that the bytecode function requires.\n   *\n   * @example\n   * A coin transfer function has three arguments \"from\", \"to\" and \"amount\".\n   * ```\n   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)\n   * ```\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(bytecode: Uint8Array, type_args: Array<TypeTag>, args: Array<ScriptFunctionArgument>) {\n    this.bytecode = bytecode;\n    this.type_args = type_args;\n    this.args = args;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.bytecode);\n    serializer.serializeVector<TypeTag>(this.type_args);\n    serializer.serializeU32AsUleb128(this.args.length);\n    this.args.forEach((item: ScriptFunctionArgument) => {\n      item.serializeForScriptFunction(serializer);\n    });\n  }\n\n  static deserialize(deserializer: Deserializer): Script {\n    const bytecode = deserializer.deserializeBytes();\n    const type_args = deserializer.deserializeVector(TypeTag);\n    const length = deserializer.deserializeUleb128AsU32();\n    const args = new Array<ScriptFunctionArgument>();\n    for (let i = 0; i < length; i += 1) {\n      // Note that we deserialize directly to the Move value, not its Script argument representation.\n      // We are abstracting away the Script argument representation because knowing about it is\n      // functionally useless.\n      const scriptArgument = deserializeFromScriptArgument(deserializer);\n      args.push(scriptArgument);\n    }\n    return new Script(bytecode, type_args, args);\n  }\n}\n\n/**\n * Represents a MultiSig account that can be serialized and deserialized.\n *\n * This class encapsulates the functionality to manage multi-signature transactions, including the address of the\n * multi-sig account and the associated transaction payload.\n * @group Implementation\n * @category Transactions\n */\nexport class MultiSig {\n  public readonly multisig_address: AccountAddress;\n\n  public readonly transaction_payload?: MultiSigTransactionPayload;\n\n  /**\n   * Contains the payload to run a multi-sig account transaction.\n   *\n   * @param multisig_address The multi-sig account address the transaction will be executed as.\n   *\n   * @param transaction_payload The payload of the multi-sig transaction. This is optional when executing a multi-sig\n   *  transaction whose payload is already stored on chain.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(multisig_address: AccountAddress, transaction_payload?: MultiSigTransactionPayload) {\n    this.multisig_address = multisig_address;\n    this.transaction_payload = transaction_payload;\n  }\n\n  serialize(serializer: Serializer): void {\n    this.multisig_address.serialize(serializer);\n    // Options are encoded with an extra u8 field before the value - 0x0 is none and 0x1 is present.\n    // We use serializeBool below to create this prefix value.\n    if (this.transaction_payload === undefined) {\n      serializer.serializeBool(false);\n    } else {\n      serializer.serializeBool(true);\n      this.transaction_payload.serialize(serializer);\n    }\n  }\n\n  static deserialize(deserializer: Deserializer): MultiSig {\n    const multisig_address = AccountAddress.deserialize(deserializer);\n    const payloadPresent = deserializer.deserializeBool();\n    let transaction_payload;\n    if (payloadPresent) {\n      transaction_payload = MultiSigTransactionPayload.deserialize(deserializer);\n    }\n    return new MultiSig(multisig_address, transaction_payload);\n  }\n}\n\n/**\n * Represents a multi-signature transaction payload that can be serialized and deserialized.\n * This class is designed to encapsulate the transaction payload for multi-sig account transactions\n * as defined in the `multisig_account.move` module. Future enhancements may allow support for script\n * payloads as the `multisig_account.move` module evolves.\n * @group Implementation\n * @category Transactions\n */\nexport class MultiSigTransactionPayload extends Serializable {\n  public readonly transaction_payload: EntryFunction;\n\n  /**\n   * Contains the payload to run a multi-sig account transaction.\n   *\n   * @param transaction_payload The payload of the multi-sig transaction.\n   * This can only be EntryFunction for now but,\n   * Script might be supported in the future.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(transaction_payload: EntryFunction) {\n    super();\n    this.transaction_payload = transaction_payload;\n  }\n\n  serialize(serializer: Serializer): void {\n    /**\n     * We can support multiple types of inner transaction payload in the future.\n     * For now, it's only EntryFunction but if we support more types,\n     * we need to serialize with the right enum values here\n     * @group Implementation\n     * @category Transactions\n     */\n    serializer.serializeU32AsUleb128(0);\n    this.transaction_payload.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): MultiSigTransactionPayload {\n    // TODO: Support other types of payload beside EntryFunction.\n    // This is the enum value indicating which type of payload the multisig tx contains.\n    deserializer.deserializeUleb128AsU32();\n    return new MultiSigTransactionPayload(EntryFunction.deserialize(deserializer));\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/esm/chunk-UIRAXHDH.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-UIRAXHDH.mjs.map

package/dist/esm/chunk-UIRAXHDH.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}