@aptos-labs/ts-sdk 1.27.1-zeta.0 → 1.28.0-zeta.0

package/dist/esm/chunk-WVT25KQR.mjs

@@ -1,51 +0,0 @@
-import {
-  RawTransaction
-} from "./chunk-NGUFBDTH.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.mjs";
-
-// src/transactions/instances/simpleTransaction.ts
-var SimpleTransaction = class _SimpleTransaction extends Serializable {
-  /**
-   * SimpleTransaction represents a simple transaction type of a single signer that
-   * can be submitted to Aptos chain for execution.
-   *
-   * SimpleTransaction metadata contains the Raw Transaction and an optional
-   * sponsor Account Address to pay the gas fees.
-   *
-   * @param rawTransaction The Raw Tranasaction
-   * @param feePayerAddress The sponsor Account Address
-   */
-  constructor(rawTransaction, feePayerAddress) {
-    super();
-    this.rawTransaction = rawTransaction;
-    this.feePayerAddress = feePayerAddress;
-  }
-  serialize(serializer) {
-    this.rawTransaction.serialize(serializer);
-    if (this.feePayerAddress === void 0) {
-      serializer.serializeBool(false);
-    } else {
-      serializer.serializeBool(true);
-      this.feePayerAddress.serialize(serializer);
-    }
-  }
-  static deserialize(deserializer) {
-    const rawTransaction = RawTransaction.deserialize(deserializer);
-    const feepayerPresent = deserializer.deserializeBool();
-    let feePayerAddress;
-    if (feepayerPresent) {
-      feePayerAddress = AccountAddress.deserialize(deserializer);
-    }
-    return new _SimpleTransaction(rawTransaction, feePayerAddress);
-  }
-};
-
-export {
-  SimpleTransaction
-};
-//# sourceMappingURL=chunk-WVT25KQR.mjs.map

package/dist/esm/chunk-XBY4UM6M.mjs

@@ -1,206 +0,0 @@
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-NYELBSVO.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-L3E7YJBM.mjs";
-import {
-  Signature
-} from "./chunk-6BI4XTJN.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-ANOJYMO2.mjs";
-
-// src/core/crypto/multiKey.ts
-function bitCount(byte) {
-  let n = byte;
-  n -= n >> 1 & 1431655765;
-  n = (n & 858993459) + (n >> 2 & 858993459);
-  return (n + (n >> 4) & 252645135) * 16843009 >> 24;
-}
-var MultiKey = class _MultiKey extends AccountPublicKey {
-  // region Constructors
-  constructor(args) {
-    super();
-    const { publicKeys, signaturesRequired } = args;
-    if (signaturesRequired < 1) {
-      throw new Error("The number of required signatures needs to be greater than 0");
-    }
-    if (publicKeys.length < signaturesRequired) {
-      throw new Error(
-        `Provided ${publicKeys.length} public keys is smaller than the ${signaturesRequired} required signatures`
-      );
-    }
-    this.publicKeys = publicKeys.map(
-      (publicKey) => publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey)
-    );
-    this.signaturesRequired = signaturesRequired;
-  }
-  // endregion
-  // region AccountPublicKey
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args) {
-    throw new Error("not implemented");
-  }
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 3 /* MultiKey */,
-      input: this.toUint8Array()
-    });
-  }
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeVector(this.publicKeys);
-    serializer.serializeU8(this.signaturesRequired);
-  }
-  static deserialize(deserializer) {
-    const keys = deserializer.deserializeVector(AnyPublicKey);
-    const signaturesRequired = deserializer.deserializeU8();
-    return new _MultiKey({ publicKeys: keys, signaturesRequired });
-  }
-  // endregion
-  /**
-   * Create a bitmap that holds the mapping from the original public keys
-   * to the signatures passed in
-   *
-   * @param args.bits array of the index mapping to the matching public keys
-   * @returns Uint8array bit map
-   */
-  createBitmap(args) {
-    const { bits } = args;
-    const firstBitInByte = 128;
-    const bitmap = new Uint8Array([0, 0, 0, 0]);
-    const dupCheckSet = /* @__PURE__ */ new Set();
-    bits.forEach((bit, idx) => {
-      if (idx + 1 > this.publicKeys.length) {
-        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);
-      }
-      if (dupCheckSet.has(bit)) {
-        throw new Error(`Duplicate bit ${bit} detected.`);
-      }
-      dupCheckSet.add(bit);
-      const byteOffset = Math.floor(bit / 8);
-      let byte = bitmap[byteOffset];
-      byte |= firstBitInByte >> bit % 8;
-      bitmap[byteOffset] = byte;
-    });
-    return bitmap;
-  }
-  /**
-   * Get the index of the provided public key.
-   *
-   * @param publicKey array of the index mapping to the matching public keys
-   * @returns the corresponding index of the publicKey, if it exists
-   */
-  getIndex(publicKey) {
-    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
-    const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());
-    if (index !== -1) {
-      return index;
-    }
-    throw new Error("Public key not found in MultiKey");
-  }
-};
-var _MultiKeySignature = class _MultiKeySignature extends Signature {
-  /**
-   * Signature for a K-of-N multi-sig transaction.
-   *
-   * @see {@link
-   * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}
-   *
-   * @param args.signatures A list of signatures
-   * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth
-   * signature should be provided in `signatures`. Bits are read from left to right
-   */
-  constructor(args) {
-    super();
-    const { signatures, bitmap } = args;
-    if (signatures.length > _MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
-      throw new Error(`The number of signatures cannot be greater than ${_MultiKeySignature.MAX_SIGNATURES_SUPPORTED}`);
-    }
-    this.signatures = signatures.map(
-      (signature) => signature instanceof AnySignature ? signature : new AnySignature(signature)
-    );
-    if (!(bitmap instanceof Uint8Array)) {
-      this.bitmap = _MultiKeySignature.createBitmap({ bits: bitmap });
-    } else if (bitmap.length !== _MultiKeySignature.BITMAP_LEN) {
-      throw new Error(`"bitmap" length should be ${_MultiKeySignature.BITMAP_LEN}`);
-    } else {
-      this.bitmap = bitmap;
-    }
-    const nSignatures = this.bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);
-    if (nSignatures !== this.signatures.length) {
-      throw new Error(`Expecting ${nSignatures} signatures from the bitmap, but got ${this.signatures.length}`);
-    }
-  }
-  /**
-   * Helper method to create a bitmap out of the specified bit positions
-   * @param args.bits The bitmap positions that should be set. A position starts at index 0.
-   * Valid position should range between 0 and 31.
-   * @example
-   * Here's an example of valid `bits`
-   * ```
-   * [0, 2, 31]
-   * ```
-   * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.
-   * The result bitmap should be 0b1010000000000000000000000000001
-   *
-   * @returns bitmap that is 32bit long
-   */
-  static createBitmap(args) {
-    const { bits } = args;
-    const firstBitInByte = 128;
-    const bitmap = new Uint8Array([0, 0, 0, 0]);
-    const dupCheckSet = /* @__PURE__ */ new Set();
-    bits.forEach((bit) => {
-      if (bit >= _MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
-        throw new Error(`Cannot have a signature larger than ${_MultiKeySignature.MAX_SIGNATURES_SUPPORTED - 1}.`);
-      }
-      if (dupCheckSet.has(bit)) {
-        throw new Error("Duplicate bits detected.");
-      }
-      dupCheckSet.add(bit);
-      const byteOffset = Math.floor(bit / 8);
-      let byte = bitmap[byteOffset];
-      byte |= firstBitInByte >> bit % 8;
-      bitmap[byteOffset] = byte;
-    });
-    return bitmap;
-  }
-  // region Signature
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeVector(this.signatures);
-    serializer.serializeBytes(this.bitmap);
-  }
-  static deserialize(deserializer) {
-    const signatures = deserializer.deserializeVector(AnySignature);
-    const bitmap = deserializer.deserializeBytes();
-    return new _MultiKeySignature({ signatures, bitmap });
-  }
-  // endregion
-};
-/**
- * Number of bytes in the bitmap representing who signed the transaction (32-bits)
- */
-_MultiKeySignature.BITMAP_LEN = 4;
-/**
- * Maximum number of Ed25519 signatures supported
- */
-_MultiKeySignature.MAX_SIGNATURES_SUPPORTED = _MultiKeySignature.BITMAP_LEN * 8;
-var MultiKeySignature = _MultiKeySignature;
-
-export {
-  MultiKey,
-  MultiKeySignature
-};
-//# sourceMappingURL=chunk-XBY4UM6M.mjs.map

package/dist/esm/chunk-XUNU6GVQ.mjs

@@ -1,319 +0,0 @@
-import {
-  TypeTag
-} from "./chunk-P3RTJ6VC.mjs";
-import {
-  ModuleId
-} from "./chunk-YJJTCGDT.mjs";
-import {
-  Identifier
-} from "./chunk-YQPKNTIN.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  MoveVector
-} from "./chunk-PSW5OBY2.mjs";
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-GWS7OLIU.mjs";
-import {
-  EntryFunctionBytes
-} from "./chunk-6AO2MJMN.mjs";
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.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);
-    default:
-      throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`);
-  }
-}
-var TransactionPayload = class extends Serializable {
-  /**
-   * Deserialize a Transaction Payload
-   */
-  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 {
-  constructor(script) {
-    super();
-    this.script = script;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* Script */);
-    this.script.serialize(serializer);
-  }
-  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)
-   * ```
-   */
-  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;
-  }
-  /**
-   * A helper function to build a EntryFunction payload from raw primitive values
-   *
-   * @param module_id Fully qualified module name in format "AccountAddress::module_id" e.g. "0x1::coin"
-   * @param function_name Function name
-   * @param type_args Type arguments that move 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 Arguments to the move function.
-   *
-   * @example
-   * A coin transfer function has three arguments "from", "to" and "amount".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
-   * ```
-   * @returns EntryFunction
-   */
-  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.
-   *
-   */
-  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,)
-   * ```
-   */
-  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.
-   */
-  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.
-   */
-  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-XUNU6GVQ.mjs.map

package/dist/esm/chunk-XUNU6GVQ.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 } 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 */\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    default:\n      throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`);\n  }\n}\n\n/**\n * Representation of the supported Transaction Payload\n * that can serialized and deserialized\n */\nexport abstract class TransactionPayload extends Serializable {\n  /**\n   * Serialize a Transaction Payload\n   */\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Deserialize a Transaction Payload\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 * Representation of a Transaction Payload Script that can serialized and deserialized\n */\nexport class TransactionPayloadScript extends TransactionPayload {\n  public readonly script: Script;\n\n  constructor(script: Script) {\n    super();\n    this.script = script;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionPayloadVariants.Script);\n    this.script.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TransactionPayloadScript {\n    const script = Script.deserialize(deserializer);\n    return new TransactionPayloadScript(script);\n  }\n}\n\n/**\n * Representation of a Transaction Payload Entry Function that can serialized and deserialized\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 * Representation of a Transaction Payload Multi-sig that can serialized and deserialized\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 * Representation of a EntryFunction that can serialized and deserialized\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   */\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   * A helper function to build a EntryFunction payload from raw primitive values\n   *\n   * @param module_id Fully qualified module name in format \"AccountAddress::module_id\" e.g. \"0x1::coin\"\n   * @param function_name Function name\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(script) 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(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)\n   * ```\n   * @returns EntryFunction\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   */\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 * Representation of a Script that can serialized and deserialized\n */\nexport class Script {\n  /**\n   * The move module bytecode\n   */\n  public readonly bytecode: Uint8Array;\n\n  /**\n   * The type arguments that the bytecode function requires.\n   */\n  public readonly type_args: Array<TypeTag>;\n\n  /**\n   * The arguments that the bytecode function requires.\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   */\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 * Representation of a MultiSig that can serialized and deserialized\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   */\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 * Representation of a MultiSig Transaction Payload from `multisig_account.move`\n * that can be serialized and deserialized\n\n * This class exists right now to represent an extensible transaction payload class for\n * transactions used in `multisig_account.move`. Eventually, this class will be able to\n * support script payloads when the `multisig_account.move` module supports them.\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   */\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     */\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-YJJTCGDT.mjs

@@ -1,49 +0,0 @@
-import {
-  Identifier
-} from "./chunk-YQPKNTIN.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.mjs";
-
-// src/transactions/instances/moduleId.ts
-var ModuleId = class _ModuleId extends Serializable {
-  /**
-   * Full name of a module.
-   * @param address The account address. e.g "0x1"
-   * @param name The module name under the "address". e.g "coin"
-   */
-  constructor(address, name) {
-    super();
-    this.address = address;
-    this.name = name;
-  }
-  /**
-   * Converts a string literal to a ModuleId
-   * @param moduleId String literal in format "account_address::module_name", e.g. "0x1::coin"
-   * @returns ModuleId
-   */
-  static fromStr(moduleId) {
-    const parts = moduleId.split("::");
-    if (parts.length !== 2) {
-      throw new Error("Invalid module id.");
-    }
-    return new _ModuleId(AccountAddress.fromString(parts[0]), new Identifier(parts[1]));
-  }
-  serialize(serializer) {
-    this.address.serialize(serializer);
-    this.name.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const address = AccountAddress.deserialize(deserializer);
-    const name = Identifier.deserialize(deserializer);
-    return new _ModuleId(address, name);
-  }
-};
-
-export {
-  ModuleId
-};
-//# sourceMappingURL=chunk-YJJTCGDT.mjs.map