@aptos-labs/ts-sdk 1.13.3 → 1.14.0-zeta.1

package/dist/esm/chunk-QFOG4LIN.mjs

@@ -0,0 +1,319 @@
+import {
+  TypeTag
+} from "./chunk-7FO3S6IZ.mjs";
+import {
+  ModuleId
+} from "./chunk-JL2JHVS4.mjs";
+import {
+  Identifier
+} from "./chunk-2TJJWII2.mjs";
+import {
+  AccountAddress
+} from "./chunk-CMNJG4NN.mjs";
+import {
+  EntryFunctionBytes
+} from "./chunk-PIMQHG2J.mjs";
+import {
+  MoveVector
+} from "./chunk-AR7X6GWQ.mjs";
+import {
+  Bool,
+  U128,
+  U16,
+  U256,
+  U32,
+  U64,
+  U8
+} from "./chunk-WK5ZSNE2.mjs";
+import {
+  Serializable
+} from "./chunk-FQQW55X7.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-QFOG4LIN.mjs.map

package/dist/esm/{chunk-DM44OGQH.mjs.map → chunk-QFOG4LIN.mjs.map}

@@ -1 +1 @@
-{"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":["deserializeFromScriptArgument","deserializer","index","U8","U64","U128","AccountAddress","MoveVector","Bool","U16","U32","U256","TransactionPayload","Serializable","TransactionPayloadScript","TransactionPayloadEntryFunction","TransactionPayloadMultiSig","_TransactionPayloadScript","script","serializer","Script","_TransactionPayloadEntryFunction","entryFunction","EntryFunction","_TransactionPayloadMultiSig","multiSig","value","MultiSig","_EntryFunction","module_name","function_name","type_args","args","module_id","ModuleId","Identifier","item","TypeTag","length","i","fixedBytesLength","fixedBytes","EntryFunctionBytes","_Script","bytecode","scriptArgument","_MultiSig","multisig_address","transaction_payload","payloadPresent","MultiSigTransactionPayload","_MultiSigTransactionPayload"]}
+{"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-QMM2KL6C.mjs

@@ -0,0 +1,12 @@
+// src/core/common.ts
+var ParsingError = class extends Error {
+  constructor(message, invalidReason) {
+    super(message);
+    this.invalidReason = invalidReason;
+  }
+};
+
+export {
+  ParsingError
+};
+//# sourceMappingURL=chunk-QMM2KL6C.mjs.map

package/dist/esm/{chunk-FBPNHF54.mjs.map → chunk-QMM2KL6C.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/common.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This error is used to explain why parsing failed.\n */\nexport class ParsingError<T> extends Error {\n  /**\n   * This provides a programmatic way to access why parsing failed. Downstream devs\n   * might want to use this to build their own error messages if the default error\n   * messages are not suitable for their use case. This should be an enum.\n   */\n  public invalidReason: T;\n\n  constructor(message: string, invalidReason: T) {\n    super(message);\n    this.invalidReason = invalidReason;\n  }\n}\n\n/**\n * Whereas ParsingError is thrown when parsing fails, e.g. in a fromString function,\n * this type is returned from \"defensive\" functions like isValid.\n */\nexport type ParsingResult<T> = {\n  /**\n   * True if valid, false otherwise.\n   */\n  valid: boolean;\n\n  /**\n   * If valid is false, this will be a code explaining why parsing failed.\n   */\n  invalidReason?: T;\n\n  /**\n   * If valid is false, this will be a string explaining why parsing failed.\n   */\n  invalidReasonMessage?: string;\n};\n"],"mappings":"AAMO,IAAMA,EAAN,cAA8B,KAAM,CAQzC,YAAYC,EAAiBC,EAAkB,CAC7C,MAAMD,CAAO,EACb,KAAK,cAAgBC,CACvB,CACF","names":["ParsingError","message","invalidReason"]}
+{"version":3,"sources":["../../src/core/common.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This error is used to explain why parsing failed.\n */\nexport class ParsingError<T> extends Error {\n  /**\n   * This provides a programmatic way to access why parsing failed. Downstream devs\n   * might want to use this to build their own error messages if the default error\n   * messages are not suitable for their use case. This should be an enum.\n   */\n  public invalidReason: T;\n\n  constructor(message: string, invalidReason: T) {\n    super(message);\n    this.invalidReason = invalidReason;\n  }\n}\n\n/**\n * Whereas ParsingError is thrown when parsing fails, e.g. in a fromString function,\n * this type is returned from \"defensive\" functions like isValid.\n */\nexport type ParsingResult<T> = {\n  /**\n   * True if valid, false otherwise.\n   */\n  valid: boolean;\n\n  /**\n   * If valid is false, this will be a code explaining why parsing failed.\n   */\n  invalidReason?: T;\n\n  /**\n   * If valid is false, this will be a string explaining why parsing failed.\n   */\n  invalidReasonMessage?: string;\n};\n"],"mappings":";AAMO,IAAM,eAAN,cAA8B,MAAM;AAAA,EAQzC,YAAY,SAAiB,eAAkB;AAC7C,UAAM,OAAO;AACb,SAAK,gBAAgB;AAAA,EACvB;AACF;","names":[]}

package/dist/esm/chunk-RCQMWXEW.mjs

@@ -0,0 +1,35 @@
+import {
+  generateViewFunctionPayload
+} from "./chunk-U7QBZ6PP.mjs";
+import {
+  postAptosFullNode
+} from "./chunk-NXFO2W4G.mjs";
+import {
+  Serializer
+} from "./chunk-FQQW55X7.mjs";
+
+// src/internal/view.ts
+async function view(args) {
+  const { aptosConfig, payload, options } = args;
+  const viewFunctionPayload = await generateViewFunctionPayload({
+    ...payload,
+    aptosConfig
+  });
+  const serializer = new Serializer();
+  viewFunctionPayload.serialize(serializer);
+  const bytes = serializer.toUint8Array();
+  const { data } = await postAptosFullNode({
+    aptosConfig,
+    path: "view",
+    originMethod: "view",
+    contentType: "application/x.aptos.view_function+bcs" /* BCS_VIEW_FUNCTION */,
+    params: { ledger_version: options?.ledgerVersion },
+    body: bytes
+  });
+  return data;
+}
+
+export {
+  view
+};
+//# sourceMappingURL=chunk-RCQMWXEW.mjs.map

package/dist/esm/{chunk-3WUGR46O.mjs.map → chunk-RCQMWXEW.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/internal/view.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { LedgerVersionArg, MimeType, MoveValue } from \"../types\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { generateViewFunctionPayload, InputViewFunctionData } from \"../transactions\";\nimport { Serializer } from \"../bcs\";\nimport { postAptosFullNode } from \"../client\";\n\nexport async function view<T extends Array<MoveValue> = Array<MoveValue>>(args: {\n  aptosConfig: AptosConfig;\n  payload: InputViewFunctionData;\n  options?: LedgerVersionArg;\n}): Promise<T> {\n  const { aptosConfig, payload, options } = args;\n  const viewFunctionPayload = await generateViewFunctionPayload({\n    ...payload,\n    aptosConfig,\n  });\n\n  const serializer = new Serializer();\n  viewFunctionPayload.serialize(serializer);\n  const bytes = serializer.toUint8Array();\n\n  const { data } = await postAptosFullNode<Uint8Array, MoveValue[]>({\n    aptosConfig,\n    path: \"view\",\n    originMethod: \"view\",\n    contentType: MimeType.BCS_VIEW_FUNCTION,\n    params: { ledger_version: options?.ledgerVersion },\n    body: bytes,\n  });\n\n  return data as T;\n}\n"],"mappings":"2HASA,eAAsBA,EAAoDC,EAI3D,CACb,GAAM,CAAE,YAAAC,EAAa,QAAAC,EAAS,QAAAC,CAAQ,EAAIH,EACpCI,EAAsB,MAAMC,EAA4B,CAC5D,GAAGH,EACH,YAAAD,CACF,CAAC,EAEKK,EAAa,IAAIC,EACvBH,EAAoB,UAAUE,CAAU,EACxC,IAAME,EAAQF,EAAW,aAAa,EAEhC,CAAE,KAAAG,CAAK,EAAI,MAAMC,EAA2C,CAChE,YAAAT,EACA,KAAM,OACN,aAAc,OACd,oDACA,OAAQ,CAAE,eAAgBE,GAAS,aAAc,EACjD,KAAMK,CACR,CAAC,EAED,OAAOC,CACT","names":["view","args","aptosConfig","payload","options","viewFunctionPayload","generateViewFunctionPayload","serializer","Serializer","bytes","data","postAptosFullNode"]}
+{"version":3,"sources":["../../src/internal/view.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { LedgerVersionArg, MimeType, MoveValue } from \"../types\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { generateViewFunctionPayload, InputViewFunctionData } from \"../transactions\";\nimport { Serializer } from \"../bcs\";\nimport { postAptosFullNode } from \"../client\";\n\nexport async function view<T extends Array<MoveValue> = Array<MoveValue>>(args: {\n  aptosConfig: AptosConfig;\n  payload: InputViewFunctionData;\n  options?: LedgerVersionArg;\n}): Promise<T> {\n  const { aptosConfig, payload, options } = args;\n  const viewFunctionPayload = await generateViewFunctionPayload({\n    ...payload,\n    aptosConfig,\n  });\n\n  const serializer = new Serializer();\n  viewFunctionPayload.serialize(serializer);\n  const bytes = serializer.toUint8Array();\n\n  const { data } = await postAptosFullNode<Uint8Array, MoveValue[]>({\n    aptosConfig,\n    path: \"view\",\n    originMethod: \"view\",\n    contentType: MimeType.BCS_VIEW_FUNCTION,\n    params: { ledger_version: options?.ledgerVersion },\n    body: bytes,\n  });\n\n  return data as T;\n}\n"],"mappings":";;;;;;;;;;;AASA,eAAsB,KAAoD,MAI3D;AACb,QAAM,EAAE,aAAa,SAAS,QAAQ,IAAI;AAC1C,QAAM,sBAAsB,MAAM,4BAA4B;AAAA,IAC5D,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AAED,QAAM,aAAa,IAAI,WAAW;AAClC,sBAAoB,UAAU,UAAU;AACxC,QAAM,QAAQ,WAAW,aAAa;AAEtC,QAAM,EAAE,KAAK,IAAI,MAAM,kBAA2C;AAAA,IAChE;AAAA,IACA,MAAM;AAAA,IACN,cAAc;AAAA,IACd;AAAA,IACA,QAAQ,EAAE,gBAAgB,SAAS,cAAc;AAAA,IACjD,MAAM;AAAA,EACR,CAAC;AAED,SAAO;AACT;","names":[]}

package/dist/esm/chunk-RFSO3JRG.mjs

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

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

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