@aptos-labs/ts-sdk 6.3.1 → 7.0.0

package/dist/esm/chunk-KDMSOCZY.mjs

@@ -1,2 +0,0 @@
-var h=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var j=(g,b,d,c)=>{for(var a=c>1?void 0:c?i(b,d):b,e=g.length-1,f;e>=0;e--)(f=g[e])&&(a=(c?f(b,d,a):f(a))||a);return c&&a&&h(b,d,a),a};export{j as a};
-//# sourceMappingURL=chunk-KDMSOCZY.mjs.map

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

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

package/dist/esm/chunk-KKPH2JUV.mjs

@@ -1,2 +0,0 @@
-import{a as r,b as t,d as B,f as s}from"./chunk-RUKFK3OC.mjs";import{a as l,b as n,c as o,d as z,e as u,f as c,g as d,h as I,i as p,j as U,k as v,l as m,m as S,n as F,o as h,p as A,q as b,r as y}from"./chunk-X2TPNKLV.mjs";var N=class i extends r{constructor(e){super(),B(e),this.value=e}serialize(e){e.serializeBool(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(5),e.serialize(this)}deserialize(e){return new a(e.deserializeU256())}static deserialize(e){return new i(e.deserializeBool())}},_=class i extends r{constructor(e){super(),s(e,0,l),this.value=e}serialize(e){e.serializeU8(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(0),e.serialize(this)}static deserialize(e){return new i(e.deserializeU8())}},g=class i extends r{constructor(e){super(),s(e,0,n),this.value=e}serialize(e){e.serializeU16(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(6),e.serialize(this)}static deserialize(e){return new i(e.deserializeU16())}},M=class i extends r{constructor(e){super(),s(e,0,o),this.value=e}serialize(e){e.serializeU32(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(7),e.serialize(this)}static deserialize(e){return new i(e.deserializeU32())}},x=class i extends r{constructor(e){super(),s(e,BigInt(0),z),this.value=BigInt(e)}serialize(e){e.serializeU64(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(1),e.serialize(this)}static deserialize(e){return new i(e.deserializeU64())}},T=class i extends r{constructor(e){super(),s(e,BigInt(0),u),this.value=BigInt(e)}serialize(e){e.serializeU128(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(2),e.serialize(this)}static deserialize(e){return new i(e.deserializeU128())}},a=class i extends r{constructor(e){super(),s(e,BigInt(0),c),this.value=BigInt(e)}serialize(e){e.serializeU256(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(8),e.serialize(this)}static deserialize(e){return new i(e.deserializeU256())}},E=class i extends r{constructor(e){super(),s(e,d,I),this.value=e}serialize(e){e.serializeI8(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(10),e.serialize(this)}static deserialize(e){return new i(e.deserializeI8())}},D=class i extends r{constructor(e){super(),s(e,p,U),this.value=e}serialize(e){e.serializeI16(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(11),e.serialize(this)}static deserialize(e){return new i(e.deserializeI16())}},w=class i extends r{constructor(e){super(),s(e,v,m),this.value=e}serialize(e){e.serializeI32(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(12),e.serialize(this)}static deserialize(e){return new i(e.deserializeI32())}},X=class i extends r{constructor(e){super(),s(e,S,F),this.value=BigInt(e)}serialize(e){e.serializeI64(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(13),e.serialize(this)}static deserialize(e){return new i(e.deserializeI64())}},R=class i extends r{constructor(e){super(),s(e,h,A),this.value=BigInt(e)}serialize(e){e.serializeI128(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(14),e.serialize(this)}static deserialize(e){return new i(e.deserializeI128())}},G=class i extends r{constructor(e){super(),s(e,b,y),this.value=BigInt(e)}serialize(e){e.serializeI256(this.value)}serializeForEntryFunction(e){t(e,this)}serializeForScriptFunction(e){e.serializeU32AsUleb128(15),e.serialize(this)}static deserialize(e){return new i(e.deserializeI256())}};export{N as a,_ as b,g as c,M as d,x as e,T as f,a as g,E as h,D as i,w as j,X as k,R as l,G as m};
-//# sourceMappingURL=chunk-KKPH2JUV.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/bcs/serializable/movePrimitives.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\nimport {\n  MAX_U128_BIG_INT,\n  MAX_U16_NUMBER,\n  MAX_U32_NUMBER,\n  MAX_U64_BIG_INT,\n  MAX_U8_NUMBER,\n  MAX_U256_BIG_INT,\n  MIN_I8_NUMBER,\n  MAX_I8_NUMBER,\n  MIN_I16_NUMBER,\n  MAX_I16_NUMBER,\n  MIN_I32_NUMBER,\n  MAX_I32_NUMBER,\n  MIN_I64_BIG_INT,\n  MAX_I64_BIG_INT,\n  MIN_I128_BIG_INT,\n  MAX_I128_BIG_INT,\n  MIN_I256_BIG_INT,\n  MAX_I256_BIG_INT,\n} from \"../consts\";\nimport { Deserializer } from \"../deserializer\";\nimport {\n  Serializable,\n  Serializer,\n  ensureBoolean,\n  serializeEntryFunctionBytesCompat,\n  validateNumberInRange,\n} from \"../serializer\";\nimport { TransactionArgument } from \"../../transactions/instances/transactionArgument\";\nimport { AnyNumber, Uint16, Uint32, Uint8, Int8, Int16, Int32, ScriptTransactionArgumentVariants } from \"../../types\";\n\n/**\n * Represents a boolean value that can be serialized and deserialized.\n * This class extends the Serializable class and provides methods to serialize\n * the boolean value for different contexts, such as entry functions and script functions.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class Bool extends Serializable implements TransactionArgument {\n  public readonly value: boolean;\n\n  /**\n   * Constructs a new instance with a specified value.\n   * This ensures that the value is validated to be within the acceptable range.\n   *\n   * @param value - The number to be validated and assigned, which must be between 0 and MAX_U256_BIG_INT.\n   * @group Implementation\n   * @category BCS\n   */\n  constructor(value: boolean) {\n    super();\n\n    /**\n     * Ensures that the provided value is of type boolean.\n     * This function throws an error if the value is not a boolean, helping to enforce type safety in your code.\n     *\n     * @param value - The value to be checked for boolean type.\n     * @throws {Error} Throws an error if the value is not a boolean.\n     * @group Implementation\n     * @category BCS\n     */\n    ensureBoolean(value);\n    this.value = value;\n  }\n\n  /**\n   * Serializes the value using the provided serializer.\n   * This function is essential for converting the value into a format suitable for transmission or storage.\n   *\n   * @param serializer - The serializer instance used to perform the serialization.\n   * @group Implementation\n   * @category BCS\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeBool(this.value);\n  }\n\n  /**\n   * Serializes the current instance for use in an entry function by converting it to a byte sequence.\n   * This allows the instance to be properly formatted for serialization in transactions.\n   * Uses serializeAsBytes when available, with a fallback for older Serializer versions.\n   *\n   * @param serializer - The serializer instance used to serialize the byte sequence.\n   * @group Implementation\n   * @category BCS\n   */\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  /**\n   * Serializes the current instance for use in a script function.\n   * This allows for the conversion of the instance into a format suitable for transmission or storage.\n   *\n   * @param serializer - The serializer used to perform the serialization.\n   * @group Implementation\n   * @category BCS\n   */\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.Bool);\n    serializer.serialize(this);\n  }\n\n  /**\n   * Deserializes a U256 value from the provided deserializer.\n   *\n   * @param deserializer - The deserializer instance used to read the U256 data.\n   * @group Implementation\n   * @category BCS\n   */\n\n  deserialize(deserializer: Deserializer) {\n    return new U256(deserializer.deserializeU256());\n  }\n\n  static deserialize(deserializer: Deserializer): Bool {\n    return new Bool(deserializer.deserializeBool());\n  }\n}\n\n/**\n * Represents an unsigned 8-bit integer (U8) value.\n * This class extends the Serializable class and provides methods for serialization and deserialization of U8 values.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class U8 extends Serializable implements TransactionArgument {\n  public readonly value: Uint8;\n\n  constructor(value: Uint8) {\n    super();\n    validateNumberInRange(value, 0, MAX_U8_NUMBER);\n    this.value = value;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU8(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U8);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): U8 {\n    return new U8(deserializer.deserializeU8());\n  }\n}\n\n/**\n * Represents a 16-bit unsigned integer (U16) value.\n * This class extends the Serializable class and provides methods for serialization\n * and deserialization of the U16 value.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class U16 extends Serializable implements TransactionArgument {\n  public readonly value: Uint16;\n\n  constructor(value: Uint16) {\n    super();\n    validateNumberInRange(value, 0, MAX_U16_NUMBER);\n    this.value = value;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU16(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U16);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): U16 {\n    return new U16(deserializer.deserializeU16());\n  }\n}\n\n/**\n * Represents a 32-bit unsigned integer (U32) that can be serialized and deserialized.\n * This class ensures that the value is within the valid range for a U32.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class U32 extends Serializable implements TransactionArgument {\n  public readonly value: Uint32;\n\n  constructor(value: Uint32) {\n    super();\n    validateNumberInRange(value, 0, MAX_U32_NUMBER);\n    this.value = value;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U32);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): U32 {\n    return new U32(deserializer.deserializeU32());\n  }\n}\n\n/**\n * Represents a 64-bit unsigned integer (U64) and provides methods for serialization.\n *\n * This class ensures that the value is within the valid range for a U64 and provides\n * functionality to serialize the value for various use cases, including entry functions\n * and script functions.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class U64 extends Serializable implements TransactionArgument {\n  public readonly value: bigint;\n\n  constructor(value: AnyNumber) {\n    super();\n    validateNumberInRange(value, BigInt(0), MAX_U64_BIG_INT);\n    this.value = BigInt(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU64(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U64);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): U64 {\n    return new U64(deserializer.deserializeU64());\n  }\n}\n\n/**\n * Represents a 128-bit unsigned integer value.\n * This class provides methods for serialization and deserialization\n * of U128 values, ensuring that the values are within the valid range.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class U128 extends Serializable implements TransactionArgument {\n  public readonly value: bigint;\n\n  constructor(value: AnyNumber) {\n    super();\n    validateNumberInRange(value, BigInt(0), MAX_U128_BIG_INT);\n    this.value = BigInt(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU128(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U128);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): U128 {\n    return new U128(deserializer.deserializeU128());\n  }\n}\n\n/**\n * Represents a 256-bit unsigned integer (U256) that extends the Serializable class.\n * This class provides methods for serialization and deserialization of U256 values,\n * ensuring that the values are within the valid range.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class U256 extends Serializable implements TransactionArgument {\n  public readonly value: bigint;\n\n  constructor(value: AnyNumber) {\n    super();\n    validateNumberInRange(value, BigInt(0), MAX_U256_BIG_INT);\n    this.value = BigInt(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU256(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U256);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): U256 {\n    return new U256(deserializer.deserializeU256());\n  }\n}\n\n/**\n * Represents an 8-bit signed integer (I8) value.\n * This class extends the Serializable class and provides methods for serialization and deserialization of I8 values.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class I8 extends Serializable implements TransactionArgument {\n  public readonly value: Int8;\n\n  constructor(value: Int8) {\n    super();\n    validateNumberInRange(value, MIN_I8_NUMBER, MAX_I8_NUMBER);\n    this.value = value;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeI8(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I8);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): I8 {\n    return new I8(deserializer.deserializeI8());\n  }\n}\n\n/**\n * Represents a 16-bit signed integer (I16) value.\n * This class extends the Serializable class and provides methods for serialization\n * and deserialization of the I16 value.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class I16 extends Serializable implements TransactionArgument {\n  public readonly value: Int16;\n\n  constructor(value: Int16) {\n    super();\n    validateNumberInRange(value, MIN_I16_NUMBER, MAX_I16_NUMBER);\n    this.value = value;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeI16(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I16);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): I16 {\n    return new I16(deserializer.deserializeI16());\n  }\n}\n\n/**\n * Represents a 32-bit signed integer (I32) that can be serialized and deserialized.\n * This class ensures that the value is within the valid range for an I32.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class I32 extends Serializable implements TransactionArgument {\n  public readonly value: Int32;\n\n  constructor(value: Int32) {\n    super();\n    validateNumberInRange(value, MIN_I32_NUMBER, MAX_I32_NUMBER);\n    this.value = value;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeI32(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I32);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): I32 {\n    return new I32(deserializer.deserializeI32());\n  }\n}\n\n/**\n * Represents a 64-bit signed integer (I64) and provides methods for serialization.\n *\n * This class ensures that the value is within the valid range for an I64 and provides\n * functionality to serialize the value for various use cases, including entry functions\n * and script functions.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class I64 extends Serializable implements TransactionArgument {\n  public readonly value: bigint;\n\n  constructor(value: AnyNumber) {\n    super();\n    validateNumberInRange(value, MIN_I64_BIG_INT, MAX_I64_BIG_INT);\n    this.value = BigInt(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeI64(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I64);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): I64 {\n    return new I64(deserializer.deserializeI64());\n  }\n}\n\n/**\n * Represents a 128-bit signed integer value.\n * This class provides methods for serialization and deserialization\n * of I128 values, ensuring that the values are within the valid range.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class I128 extends Serializable implements TransactionArgument {\n  public readonly value: bigint;\n\n  constructor(value: AnyNumber) {\n    super();\n    validateNumberInRange(value, MIN_I128_BIG_INT, MAX_I128_BIG_INT);\n    this.value = BigInt(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeI128(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I128);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): I128 {\n    return new I128(deserializer.deserializeI128());\n  }\n}\n\n/**\n * Represents a 256-bit signed integer (I256) that extends the Serializable class.\n * This class provides methods for serialization and deserialization of I256 values,\n * ensuring that the values are within the valid range.\n *\n * @extends Serializable\n * @group Implementation\n * @category BCS\n */\nexport class I256 extends Serializable implements TransactionArgument {\n  public readonly value: bigint;\n\n  constructor(value: AnyNumber) {\n    super();\n    validateNumberInRange(value, MIN_I256_BIG_INT, MAX_I256_BIG_INT);\n    this.value = BigInt(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeI256(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializeEntryFunctionBytesCompat(serializer, this);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I256);\n    serializer.serialize(this);\n  }\n\n  static deserialize(deserializer: Deserializer): I256 {\n    return new I256(deserializer.deserializeI256());\n  }\n}\n"],"mappings":"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","names":["Bool","_Bool","Serializable","value","ensureBoolean","serializer","serializeEntryFunctionBytesCompat","deserializer","U256","U8","_U8","validateNumberInRange","MAX_U8_NUMBER","U16","_U16","MAX_U16_NUMBER","U32","_U32","MAX_U32_NUMBER","U64","_U64","MAX_U64_BIG_INT","U128","_U128","MAX_U128_BIG_INT","_U256","MAX_U256_BIG_INT","I8","_I8","MIN_I8_NUMBER","MAX_I8_NUMBER","I16","_I16","MIN_I16_NUMBER","MAX_I16_NUMBER","I32","_I32","MIN_I32_NUMBER","MAX_I32_NUMBER","I64","_I64","MIN_I64_BIG_INT","MAX_I64_BIG_INT","I128","_I128","MIN_I128_BIG_INT","MAX_I128_BIG_INT","I256","_I256","MIN_I256_BIG_INT","MAX_I256_BIG_INT"]}

package/dist/esm/chunk-LVZ7QMUH.mjs

@@ -1,2 +0,0 @@
-import{b as o}from"./chunk-GJYLYE6R.mjs";import{b as r}from"./chunk-STY74NUA.mjs";var a=class a{static formatPrivateKey(e,p){let i=a.AIP80_PREFIXES[p],t=e;return typeof t=="string"&&t.startsWith(i)&&(t=t.split("-")[2]),`${i}${r.fromHexInput(t).toString()}`}static parseHexInput(e,p,i){let t,n=a.AIP80_PREFIXES[p];if(typeof e=="string")if(!i&&!e.startsWith(n))t=r.fromHexInput(e),i!==!1&&o("[Aptos SDK] It is recommended that private keys are AIP-80 compliant (https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md). You can fix the private key by formatting it with `PrivateKey.formatPrivateKey(privateKey: string, type: 'ed25519' | 'secp256k1'): string`.");else if(e.startsWith(n))t=r.fromHexString(e.split("-")[2]);else throw i?new Error("Invalid HexString input while parsing private key. Must AIP-80 compliant string."):new Error("Invalid HexString input while parsing private key.");else t=r.fromHexInput(e);return t}};a.AIP80_PREFIXES={ed25519:"ed25519-priv-",secp256k1:"secp256k1-priv-",secp256r1:"secp256r1-priv-"};var s=a;export{s as a};
-//# sourceMappingURL=chunk-LVZ7QMUH.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/privateKey.ts"],"sourcesContent":["import { HexInput, PrivateKeyVariants } from \"../../types\";\nimport { Hex } from \"../hex\";\nimport { PublicKey } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { warnIfDevelopment } from \"../../utils/helpers\";\n\n/**\n * Represents a private key used for signing messages and deriving the associated public key.\n * @group Implementation\n * @category Serialization\n */\nexport interface PrivateKey {\n  /**\n   * Sign the given message with the private key to create a signature.\n   * @param message - The message to be signed, provided in HexInput format.\n   * @returns A Signature object representing the signed message.\n   * @group Implementation\n   * @category Serialization\n   */\n  sign(message: HexInput): Signature;\n\n  /**\n   * Derive the public key associated with the private key.\n   * @group Implementation\n   * @category Serialization\n   */\n  publicKey(): PublicKey;\n\n  /**\n   * Get the private key in bytes (Uint8Array).\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array;\n}\n\nexport class PrivateKey {\n  /**\n   * The AIP-80 compliant prefixes for each private key type. Append this to a private key's hex representation\n   * to get an AIP-80 compliant string.\n   *\n   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)\n   */\n  public static readonly AIP80_PREFIXES = {\n    [PrivateKeyVariants.Ed25519]: \"ed25519-priv-\",\n    [PrivateKeyVariants.Secp256k1]: \"secp256k1-priv-\",\n    [PrivateKeyVariants.Secp256r1]: \"secp256r1-priv-\",\n  };\n\n  /**\n   * Format a HexInput to an AIP-80 compliant string.\n   *\n   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)\n   *\n   * @param privateKey - The HexString or Uint8Array format of the private key.\n   * @param privateKeyType - The private key type\n   */\n  public static formatPrivateKey(privateKey: HexInput, type: PrivateKeyVariants): string {\n    const aip80Prefix = PrivateKey.AIP80_PREFIXES[type];\n\n    // Remove the prefix if it exists\n    let formattedPrivateKey = privateKey;\n    if (typeof formattedPrivateKey === \"string\" && formattedPrivateKey.startsWith(aip80Prefix)) {\n      formattedPrivateKey = formattedPrivateKey.split(\"-\")[2];\n    }\n\n    return `${aip80Prefix}${Hex.fromHexInput(formattedPrivateKey).toString()}`;\n  }\n\n  /**\n   * Parse a HexInput that may be a HexString, Uint8Array, or a AIP-80 compliant string to a Hex instance.\n   *\n   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)\n   *\n   * @param value - A HexString, Uint8Array, or a AIP-80 compliant string.\n   * @param privateKeyType - The private key type\n   * @param strict - If true, the value MUST be compliant with AIP-80.\n   */\n  public static parseHexInput(value: HexInput, type: PrivateKeyVariants, strict?: boolean): Hex {\n    let data: Hex;\n\n    const aip80Prefix = PrivateKey.AIP80_PREFIXES[type];\n    if (typeof value === \"string\") {\n      if (!strict && !value.startsWith(aip80Prefix)) {\n        // HexString input\n        data = Hex.fromHexInput(value);\n        // If the strictness is false, the user has opted into non-AIP-80 compliant private keys.\n        if (strict !== false) {\n          warnIfDevelopment(\n            \"[Aptos SDK] It is recommended that private keys are AIP-80 compliant (https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md). You can fix the private key by formatting it with `PrivateKey.formatPrivateKey(privateKey: string, type: 'ed25519' | 'secp256k1'): string`.\",\n          );\n        }\n      } else if (value.startsWith(aip80Prefix)) {\n        // AIP-80 Compliant String input\n        data = Hex.fromHexString(value.split(\"-\")[2]);\n      } else {\n        if (strict) {\n          // The value does not start with the AIP-80 prefix, and strict is true.\n          throw new Error(\"Invalid HexString input while parsing private key. Must AIP-80 compliant string.\");\n        }\n\n        // This condition should never be reached.\n        throw new Error(\"Invalid HexString input while parsing private key.\");\n      }\n    } else {\n      // The value is an Uint8Array\n      data = Hex.fromHexInput(value);\n    }\n\n    return data;\n  }\n}\n"],"mappings":"kFAoCO,IAAMA,EAAN,MAAMA,CAAW,CAqBtB,OAAc,iBAAiBC,EAAsBC,EAAkC,CACrF,IAAMC,EAAcH,EAAW,eAAeE,CAAI,EAG9CE,EAAsBH,EAC1B,OAAI,OAAOG,GAAwB,UAAYA,EAAoB,WAAWD,CAAW,IACvFC,EAAsBA,EAAoB,MAAM,GAAG,EAAE,CAAC,GAGjD,GAAGD,CAAW,GAAGE,EAAI,aAAaD,CAAmB,EAAE,SAAS,CAAC,EAC1E,CAWA,OAAc,cAAcE,EAAiBJ,EAA0BK,EAAuB,CAC5F,IAAIC,EAEEL,EAAcH,EAAW,eAAeE,CAAI,EAClD,GAAI,OAAOI,GAAU,SACnB,GAAI,CAACC,GAAU,CAACD,EAAM,WAAWH,CAAW,EAE1CK,EAAOH,EAAI,aAAaC,CAAK,EAEzBC,IAAW,IACbE,EACE,uRACF,UAEOH,EAAM,WAAWH,CAAW,EAErCK,EAAOH,EAAI,cAAcC,EAAM,MAAM,GAAG,EAAE,CAAC,CAAC,MAE5C,OAAIC,EAEI,IAAI,MAAM,kFAAkF,EAI9F,IAAI,MAAM,oDAAoD,OAItEC,EAAOH,EAAI,aAAaC,CAAK,EAG/B,OAAOE,CACT,CACF,EA3EaR,EAOY,eAAiB,CACrC,QAA6B,gBAC7B,UAA+B,kBAC/B,UAA+B,iBAClC,EAXK,IAAMU,EAANV","names":["_PrivateKey","privateKey","type","aip80Prefix","formattedPrivateKey","Hex","value","strict","data","warnIfDevelopment","PrivateKey"]}

package/dist/esm/chunk-M65PXVDO.mjs

@@ -1,2 +0,0 @@
-import{b as a}from"./chunk-STY74NUA.mjs";import{c as n}from"./chunk-X2TPNKLV.mjs";var f=new TextDecoder,o=10*1024*1024,d=class l{constructor(e){this.buffer=new ArrayBuffer(e.length),new Uint8Array(this.buffer).set(e,0),this.offset=0}static fromHex(e){let i=a.hexInputToUint8Array(e);return new l(i)}read(e){if(this.offset+e>this.buffer.byteLength)throw new Error("Reached to the end of buffer");let i=new Uint8Array(this.buffer,this.offset,e);return this.offset+=e,i}remaining(){return this.buffer.byteLength-this.offset}assertFinished(){if(this.remaining()!==0)throw new Error("Buffer has remaining bytes")}deserializeStr(){let e=this.deserializeBytes();return f.decode(e)}deserializeOptionStr(){return this.deserializeOption("string")}deserializeOption(e,i){if(this.deserializeBool()){if(e==="string")return this.deserializeStr();if(e==="bytes")return this.deserializeBytes();if(e==="fixedBytes"){if(i===void 0)throw new Error("Fixed bytes length not provided");return this.deserializeFixedBytes(i)}return this.deserialize(e)}}deserializeBytes(){let e=this.deserializeUleb128AsU32();if(e>o)throw new Error(`Deserialization error: byte array length ${e} exceeds maximum allowed ${o}`);return this.read(e).slice()}deserializeFixedBytes(e){return this.read(e).slice()}deserializeBool(){let e=this.read(1)[0];if(e!==1&&e!==0)throw new Error("Invalid boolean value");return e===1}deserializeU8(){return this.read(1)[0]}deserializeU16(){let e=this.read(2);return new DataView(e.buffer,e.byteOffset,e.byteLength).getUint16(0,!0)}deserializeU32(){let e=this.read(4);return new DataView(e.buffer,e.byteOffset,e.byteLength).getUint32(0,!0)}deserializeU64(){let e=this.deserializeU32(),i=this.deserializeU32();return BigInt(BigInt(i)<<BigInt(32)|BigInt(e))}deserializeU128(){let e=this.deserializeU64(),i=this.deserializeU64();return BigInt(i<<BigInt(64)|e)}deserializeU256(){let e=this.deserializeU128(),i=this.deserializeU128();return BigInt(i<<BigInt(128)|e)}deserializeI8(){let e=this.read(1);return new DataView(e.buffer,e.byteOffset,e.byteLength).getInt8(0)}deserializeI16(){let e=this.read(2);return new DataView(e.buffer,e.byteOffset,e.byteLength).getInt16(0,!0)}deserializeI32(){let e=this.read(4);return new DataView(e.buffer,e.byteOffset,e.byteLength).getInt32(0,!0)}deserializeI64(){let e=this.deserializeU32(),i=this.deserializeU32(),t=BigInt(BigInt(i)<<BigInt(32)|BigInt(e)),r=BigInt(1)<<BigInt(63);return t>=r?t-(BigInt(1)<<BigInt(64)):t}deserializeI128(){let e=this.deserializeU64(),i=this.deserializeU64(),t=BigInt(i<<BigInt(64)|e),r=BigInt(1)<<BigInt(127);return t>=r?t-(BigInt(1)<<BigInt(128)):t}deserializeI256(){let e=this.deserializeU128(),i=this.deserializeU128(),t=BigInt(i<<BigInt(128)|e),r=BigInt(1)<<BigInt(255);return t>=r?t-(BigInt(1)<<BigInt(256)):t}deserializeUleb128AsU32(){let e=BigInt(0),i=0,t=5,r=0;for(;r<t;){let s=this.deserializeU8();if(r+=1,e|=BigInt(s&127)<<BigInt(i),e>n)throw new Error("Overflow while parsing uleb128-encoded uint32 value");if((s&128)===0)break;i+=7}if(r===t&&e>n)throw new Error("Overflow while parsing uleb128-encoded uint32 value");return Number(e)}deserialize(e){return e.deserialize(this)}deserializeVector(e){let i=this.deserializeUleb128AsU32(),t=new Array;for(let r=0;r<i;r+=1)t.push(this.deserialize(e));return t}};export{d as a};
-//# sourceMappingURL=chunk-M65PXVDO.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/bcs/deserializer.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { MAX_U32_NUMBER } from \"./consts\";\nimport { Uint8, Uint16, Uint32, Uint64, Uint128, Uint256, HexInput } from \"../types\";\nimport { Hex } from \"../core/hex\";\n\n/**\n * Shared TextDecoder instance for string deserialization to avoid repeated instantiation.\n */\nconst TEXT_DECODER = new TextDecoder();\n\n/**\n * Maximum allowed length for deserialized byte arrays and strings.\n * This prevents memory exhaustion attacks from malformed BCS data.\n * Set to 10MB which should be sufficient for any legitimate use case.\n */\nconst MAX_DESERIALIZE_BYTES_LENGTH = 10 * 1024 * 1024; // 10MB\n\n/**\n * This interface exists to define Deserializable<T> inputs for functions that\n * deserialize a byte buffer into a type T.\n * It is not intended to be implemented or extended, because Typescript has no support\n * for static methods in interfaces.\n *\n * @template T - The type that this will deserialize into.\n * @group Implementation\n * @category BCS\n */\nexport interface Deserializable<T> {\n  /**\n   * Deserializes the buffered bytes into an instance of the specified class type.\n   * This function provides an alternative syntax for deserialization, allowing users to call\n   * `deserializer.deserialize(MyClass)` instead of `MyClass.deserialize(deserializer)`.\n   *\n   * @param deserializer - The deserializer instance with the buffered bytes.\n   * @returns The deserialized value of class type T.\n   * @example\n   * ```typescript\n   * const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));\n   * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function\n   * // value is now an instance of MyClass\n   * // equivalent to `const value = MyClass.deserialize(deserializer)`\n   * ```\n   * @group Implementation\n   * @category BCS\n   */\n  deserialize(deserializer: Deserializer): T;\n}\n\n/**\n * A class that provides methods for deserializing various data types from a byte buffer.\n * It supports deserialization of primitive types, strings, and complex objects using a BCS (Binary Common Serialization) layout.\n * @group Implementation\n * @category BCS\n */\nexport class Deserializer {\n  private buffer: ArrayBuffer;\n\n  private offset: number;\n\n  /**\n   * Creates a new instance of the class with a copy of the provided data buffer.\n   * This prevents outside mutation of the buffer.\n   *\n   * @param data - The data to be copied into the internal buffer as a Uint8Array.\n   * @group Implementation\n   * @category BCS\n   */\n  constructor(data: Uint8Array) {\n    // copies data to prevent outside mutation of buffer.\n    this.buffer = new ArrayBuffer(data.length);\n    new Uint8Array(this.buffer).set(data, 0);\n    this.offset = 0;\n  }\n\n  static fromHex(hex: HexInput): Deserializer {\n    const data = Hex.hexInputToUint8Array(hex);\n    return new Deserializer(data);\n  }\n\n  /**\n   * Reads a specified number of bytes from the buffer and advances the offset.\n   * Returns a view into the buffer rather than copying for better performance.\n   *\n   * SECURITY NOTE: This returns a view, not a copy. Callers that expose the result\n   * externally MUST call .slice() to create a copy. Internal numeric deserializers\n   * (deserializeU8, deserializeU16, etc.) only read values and don't expose the view.\n   * deserializeBytes() and deserializeFixedBytes() call .slice() before returning.\n   *\n   * @param length - The number of bytes to read from the buffer.\n   * @throws Throws an error if the read operation exceeds the buffer's length.\n   * @group Implementation\n   * @category BCS\n   */\n  private read(length: number): Uint8Array {\n    if (this.offset + length > this.buffer.byteLength) {\n      throw new Error(\"Reached to the end of buffer\");\n    }\n\n    // Use subarray to return a view instead of slice which copies\n    // SECURITY: View is safe because numeric deserializers only read values,\n    // and byte deserializers call .slice() before returning to caller\n    const bytes = new Uint8Array(this.buffer, this.offset, length);\n    this.offset += length;\n    return bytes;\n  }\n\n  /**\n   * Returns the number of bytes remaining in the buffer.\n   *\n   * This information is useful to determine if there's more data to be read.\n   *\n   * @returns The number of bytes remaining in the buffer.\n   * @group Implementation\n   * @category BCS\n   */\n  remaining(): number {\n    return this.buffer.byteLength - this.offset;\n  }\n\n  /**\n   * Asserts that the buffer has no remaining bytes.\n   *\n   * @throws {Error} Throws an error if there are remaining bytes in the buffer.\n   * @group Implementation\n   * @category BCS\n   */\n  assertFinished(): void {\n    if (this.remaining() !== 0) {\n      throw new Error(\"Buffer has remaining bytes\");\n    }\n  }\n\n  /**\n   * Deserializes a UTF-8 encoded string from a byte array. It first reads the length of the string in bytes,\n   * followed by the actual byte content, and decodes it into a string.\n   *\n   * BCS layout for \"string\": string_length | string_content\n   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.\n   *\n   * @example\n   * ```typescript\n   * const deserializer = new Deserializer(new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));\n   * assert(deserializer.deserializeStr() === \"1234abcd\");\n   * ```\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeStr(): string {\n    const value = this.deserializeBytes();\n    return TEXT_DECODER.decode(value);\n  }\n\n  /**\n   * @deprecated use `deserializeOption(\"string\")` instead.\n   *\n   * The BCS layout for Optional<String> is 0 if none, else 1 followed by the string length and string content.\n   * @returns The deserialized string if it exists, otherwise undefined.\n   * @example\n   * ```typescript\n   * const deserializer = new Deserializer(new Uint8Array([0x00]));\n   * assert(deserializer.deserializeOptionStr() === undefined);\n   * const deserializer = new Deserializer(new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));\n   * assert(deserializer.deserializeOptionStr() === \"1234abcd\");\n   * ```\n   */\n  deserializeOptionStr(): string | undefined {\n    return this.deserializeOption(\"string\");\n  }\n\n  /**\n   * Deserializes an optional value from the buffer.\n   *\n   * The BCS layout for Optional<T> starts with a boolean byte (0 if none, 1 if some),\n   * followed by the value if present.\n   *\n   * @template T - The type of the value to deserialize\n   * @param type - Either a Deserializable class or one of the string literals: \"string\", \"bytes\", or \"fixedBytes\"\n   * @param len - Required length when type is \"fixedBytes\", ignored otherwise\n   * @returns The deserialized value if present, undefined otherwise\n   *\n   * @throws {Error} When \"fixedBytes\" is specified without a length\n   *\n   * @example\n   * ```typescript\n   * // Deserialize an optional string\n   * const deserializer = new Deserializer(new Uint8Array([1, 3, 97, 98, 99]));\n   * const optStr = deserializer.deserializeOption(\"string\");\n   * // optStr === \"abc\"\n   *\n   * // Deserialize an optional custom type\n   * const deserializer = new Deserializer(new Uint8Array([0]));\n   * const optValue = deserializer.deserializeOption(MyClass);\n   * // optValue === undefined\n   *\n   * // Deserialize optional bytes\n   * const deserializer = new Deserializer(new Uint8Array([1, 3, 1, 2, 3]));\n   * const optBytes = deserializer.deserializeOption(\"bytes\");\n   * // optBytes === Uint8Array[1, 2, 3]\n   *\n   * // Deserialize optional fixed bytes\n   * const deserializer = new Deserializer(new Uint8Array([1, 1, 2, 3, 4]));\n   * const optBytes = deserializer.deserializeOption(\"fixedBytes\", 4);\n   * // optBytes === Uint8Array[1, 2, 3, 4]\n   * ```\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeOption(type: \"string\"): string | undefined;\n  deserializeOption(type: \"bytes\"): Uint8Array | undefined;\n  deserializeOption(type: \"fixedBytes\", len: number): Uint8Array | undefined;\n  deserializeOption<T>(type: Deserializable<T>): T | undefined;\n  deserializeOption<T>(\n    type: Deserializable<T> | \"string\" | \"bytes\" | \"fixedBytes\",\n    len?: number,\n  ): T | string | Uint8Array | undefined {\n    const exists = this.deserializeBool();\n    if (!exists) return undefined;\n\n    if (type === \"string\") {\n      return this.deserializeStr();\n    }\n    if (type === \"bytes\") {\n      return this.deserializeBytes();\n    }\n    if (type === \"fixedBytes\") {\n      if (len === undefined) {\n        throw new Error(\"Fixed bytes length not provided\");\n      }\n      return this.deserializeFixedBytes(len);\n    }\n\n    return this.deserialize(type);\n  }\n\n  /**\n   * Deserializes an array of bytes.\n   *\n   * The BCS layout for \"bytes\" consists of a bytes_length followed by the bytes themselves, where bytes_length is a u32 integer\n   * encoded as a uleb128 integer, indicating the length of the bytes array.\n   *\n   * @returns {Uint8Array} The deserialized array of bytes (a copy, safe to modify).\n   * @throws {Error} If the length exceeds the maximum allowed (10MB) to prevent memory exhaustion.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeBytes(): Uint8Array {\n    const len = this.deserializeUleb128AsU32();\n    // Security: Prevent memory exhaustion from malformed data\n    if (len > MAX_DESERIALIZE_BYTES_LENGTH) {\n      throw new Error(\n        `Deserialization error: byte array length ${len} exceeds maximum allowed ${MAX_DESERIALIZE_BYTES_LENGTH}`,\n      );\n    }\n    // Return a copy so caller can safely modify without affecting buffer\n    return this.read(len).slice();\n  }\n\n  /**\n   * Deserializes an array of bytes of a specified length.\n   *\n   * @param len - The number of bytes to read from the source.\n   * @returns {Uint8Array} The deserialized array of bytes (a copy, safe to modify).\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeFixedBytes(len: number): Uint8Array {\n    // Return a copy so caller can safely modify without affecting buffer\n    return this.read(len).slice();\n  }\n\n  /**\n   * Deserializes a boolean value from a byte stream.\n   *\n   * The BCS layout for a boolean uses one byte, where \"0x01\" represents true and \"0x00\" represents false.\n   * An error is thrown if the byte value is not valid.\n   *\n   * @returns The deserialized boolean value.\n   * @throws Throws an error if the boolean value is invalid.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeBool(): boolean {\n    const bool = this.read(1)[0];\n    if (bool !== 1 && bool !== 0) {\n      throw new Error(\"Invalid boolean value\");\n    }\n    return bool === 1;\n  }\n\n  /**\n   * Deserializes a uint8 number from the binary data.\n   *\n   * BCS layout for \"uint8\": One byte. Binary format in little-endian representation.\n   *\n   * @returns {number} The deserialized uint8 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeU8(): Uint8 {\n    return this.read(1)[0];\n  }\n\n  /**\n   * Deserializes a uint16 number from a binary format in little-endian representation.\n   *\n   * BCS layout for \"uint16\": Two bytes.\n   * @example\n   * ```typescript\n   * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));\n   * assert(deserializer.deserializeU16() === 4660);\n   * ```\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeU16(): Uint16 {\n    const bytes = this.read(2);\n    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint16(0, true);\n  }\n\n  /**\n   * Deserializes a uint32 number from a binary format in little-endian representation.\n   *\n   * BCS layout for \"uint32\": Four bytes.\n   * @example\n   * ```typescript\n   * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));\n   * assert(deserializer.deserializeU32() === 305419896);\n   * ```\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeU32(): Uint32 {\n    const bytes = this.read(4);\n    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, true);\n  }\n\n  /**\n   * Deserializes a uint64 number.\n   *\n   * This function combines two 32-bit values to return a 64-bit unsigned integer in little-endian representation.\n   * @example\n   * ```typescript\n   * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));\n   * assert(deserializer.deserializeU64() === 1311768467750121216);\n   * ```\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeU64(): Uint64 {\n    const low = this.deserializeU32();\n    const high = this.deserializeU32();\n\n    // combine the two 32-bit values and return (little endian)\n    return BigInt((BigInt(high) << BigInt(32)) | BigInt(low));\n  }\n\n  /**\n   * Deserializes a uint128 number from its binary representation.\n   * This function combines two 64-bit values to return a single uint128 value in little-endian format.\n   *\n   * @returns {BigInt} The deserialized uint128 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeU128(): Uint128 {\n    const low = this.deserializeU64();\n    const high = this.deserializeU64();\n\n    // combine the two 64-bit values and return (little endian)\n    return BigInt((high << BigInt(64)) | low);\n  }\n\n  /**\n   * Deserializes a uint256 number from its binary representation.\n   *\n   * The BCS layout for \"uint256\" consists of thirty-two bytes in little-endian format.\n   *\n   * @returns {BigInt} The deserialized uint256 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeU256(): Uint256 {\n    const low = this.deserializeU128();\n    const high = this.deserializeU128();\n\n    // combine the two 128-bit values and return (little endian)\n    return BigInt((high << BigInt(128)) | low);\n  }\n\n  /**\n   * Deserializes an 8-bit signed integer from the binary data.\n   * BCS layout for \"int8\": One byte. Binary format in little-endian representation.\n   *\n   * @returns {number} The deserialized int8 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeI8(): number {\n    const bytes = this.read(1);\n    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getInt8(0);\n  }\n\n  /**\n   * Deserializes a 16-bit signed integer from a binary format in little-endian representation.\n   * BCS layout for \"int16\": Two bytes.\n   *\n   * @returns {number} The deserialized int16 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeI16(): number {\n    const bytes = this.read(2);\n    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getInt16(0, true);\n  }\n\n  /**\n   * Deserializes a 32-bit signed integer from a binary format in little-endian representation.\n   * BCS layout for \"int32\": Four bytes.\n   *\n   * @returns {number} The deserialized int32 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeI32(): number {\n    const bytes = this.read(4);\n    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getInt32(0, true);\n  }\n\n  /**\n   * Deserializes a 64-bit signed integer.\n   * This function combines two 32-bit values to return a 64-bit signed integer in little-endian representation.\n   *\n   * @returns {bigint} The deserialized int64 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeI64(): bigint {\n    const low = this.deserializeU32();\n    const high = this.deserializeU32();\n\n    // combine the two 32-bit values (little endian)\n    const unsigned = BigInt((BigInt(high) << BigInt(32)) | BigInt(low));\n\n    // Convert from unsigned to signed using two's complement\n    const signBit = BigInt(1) << BigInt(63);\n    if (unsigned >= signBit) {\n      return unsigned - (BigInt(1) << BigInt(64));\n    }\n    return unsigned;\n  }\n\n  /**\n   * Deserializes a 128-bit signed integer from its binary representation.\n   * This function combines two 64-bit values to return a single int128 value in little-endian format.\n   *\n   * @returns {bigint} The deserialized int128 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeI128(): bigint {\n    const low = this.deserializeU64();\n    const high = this.deserializeU64();\n\n    // combine the two 64-bit values (little endian)\n    const unsigned = BigInt((high << BigInt(64)) | low);\n\n    // Convert from unsigned to signed using two's complement\n    const signBit = BigInt(1) << BigInt(127);\n    if (unsigned >= signBit) {\n      return unsigned - (BigInt(1) << BigInt(128));\n    }\n    return unsigned;\n  }\n\n  /**\n   * Deserializes a 256-bit signed integer from its binary representation.\n   * BCS layout for \"int256\": Thirty-two bytes in little-endian format.\n   *\n   * @returns {bigint} The deserialized int256 number.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeI256(): bigint {\n    const low = this.deserializeU128();\n    const high = this.deserializeU128();\n\n    // combine the two 128-bit values (little endian)\n    const unsigned = BigInt((high << BigInt(128)) | low);\n\n    // Convert from unsigned to signed using two's complement\n    const signBit = BigInt(1) << BigInt(255);\n    if (unsigned >= signBit) {\n      return unsigned - (BigInt(1) << BigInt(256));\n    }\n    return unsigned;\n  }\n\n  /**\n   * Deserializes a uleb128 encoded uint32 number.\n   *\n   * This function is used for interpreting lengths of variable-length sequences and tags of enum values in BCS encoding.\n   *\n   * @throws {Error} Throws an error if the parsed value exceeds the maximum uint32 number.\n   * @throws {Error} Throws an error if the uleb128 encoding is malformed (too many bytes).\n   * @returns {number} The deserialized uint32 value.\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeUleb128AsU32(): Uint32 {\n    let value: bigint = BigInt(0);\n    let shift = 0;\n    // Maximum 5 bytes for uleb128-encoded u32 (7 bits per byte, 5*7=35 bits > 32 bits needed)\n    const MAX_ULEB128_BYTES = 5;\n    let bytesRead = 0;\n\n    while (bytesRead < MAX_ULEB128_BYTES) {\n      const byte = this.deserializeU8();\n      bytesRead += 1;\n\n      value |= BigInt(byte & 0x7f) << BigInt(shift);\n\n      // Early overflow check before continuing\n      if (value > MAX_U32_NUMBER) {\n        throw new Error(\"Overflow while parsing uleb128-encoded uint32 value\");\n      }\n\n      if ((byte & 0x80) === 0) {\n        break;\n      }\n\n      shift += 7;\n    }\n\n    // If we read MAX_ULEB128_BYTES and the last byte had continuation bit set, it's malformed\n    if (bytesRead === MAX_ULEB128_BYTES && value > MAX_U32_NUMBER) {\n      throw new Error(\"Overflow while parsing uleb128-encoded uint32 value\");\n    }\n\n    return Number(value);\n  }\n\n  /**\n   * Helper function that primarily exists to support alternative syntax for deserialization.\n   * That is, if we have a `const deserializer: new Deserializer(...)`, instead of having to use\n   * `MyClass.deserialize(deserializer)`, we can call `deserializer.deserialize(MyClass)`.\n   *\n   * @example const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));\n   * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function\n   * // value is now an instance of MyClass\n   * // equivalent to `const value = MyClass.deserialize(deserializer)`\n   * @param cls The BCS-deserializable class to deserialize the buffered bytes into.\n   *\n   * @returns the deserialized value of class type T\n   * @group Implementation\n   * @category BCS\n   */\n  deserialize<T>(cls: Deserializable<T>): T {\n    // NOTE: `deserialize` in `cls.deserialize(this)` here is a static method defined in `cls`,\n    // It is separate from the `deserialize` instance method defined here in Deserializer.\n    return cls.deserialize(this);\n  }\n\n  /**\n   * Deserializes an array of BCS Deserializable values given an existing Deserializer instance with a loaded byte buffer.\n   *\n   * @param cls The BCS-deserializable class to deserialize the buffered bytes into.\n   * @returns An array of deserialized values of type T.\n   * @example\n   * // serialize a vector of addresses\n   * const addresses = new Array<AccountAddress>(\n   *   AccountAddress.from(\"0x1\"),\n   *   AccountAddress.from(\"0x2\"),\n   *   AccountAddress.from(\"0xa\"),\n   *   AccountAddress.from(\"0xb\"),\n   * );\n   * const serializer = new Serializer();\n   * serializer.serializeVector(addresses);\n   * const serializedBytes = serializer.toUint8Array();\n   *\n   * // deserialize the bytes into an array of addresses\n   * const deserializer = new Deserializer(serializedBytes);\n   * const deserializedAddresses = deserializer.deserializeVector(AccountAddress);\n   * // deserializedAddresses is now an array of AccountAddress instances\n   * @group Implementation\n   * @category BCS\n   */\n  deserializeVector<T>(cls: Deserializable<T>): Array<T> {\n    const length = this.deserializeUleb128AsU32();\n    const vector = new Array<T>();\n    for (let i = 0; i < length; i += 1) {\n      vector.push(this.deserialize(cls));\n    }\n    return vector;\n  }\n}\n"],"mappings":"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","names":["TEXT_DECODER","MAX_DESERIALIZE_BYTES_LENGTH","Deserializer","_Deserializer","data","hex","Hex","length","bytes","value","type","len","bool","low","high","unsigned","signBit","shift","MAX_ULEB128_BYTES","bytesRead","byte","MAX_U32_NUMBER","cls","vector","i"]}

package/dist/esm/chunk-MKTR4U2R.mjs

@@ -1,2 +0,0 @@
-import{n as u,x as n}from"./chunk-G5OONGWS.mjs";import{a as c}from"./chunk-ODNZJSOC.mjs";import{b as i}from"./chunk-TBIK7DML.mjs";import{c as p}from"./chunk-DPHBSAZQ.mjs";var g=10*1e3;async function m(e){let{aptosConfig:o}=e,s=`ledger-info-${o.network}`;return c(async()=>{let{data:t}=await i({aptosConfig:o,originMethod:"getLedgerInfo",path:""});return t},s,g)()}async function T(e){let{aptosConfig:o,limit:s}=e;return(await a({aptosConfig:o,query:{query:u,variables:{limit:s}},originMethod:"getChainTopUserTransactions"})).user_transactions}async function a(e){let{aptosConfig:o,query:s,originMethod:t}=e,{data:r}=await p({aptosConfig:o,originMethod:t??"queryIndexer",path:"",body:s,overrides:{WITH_CREDENTIALS:!1}});return r}async function f(e){let{aptosConfig:o}=e;return(await a({aptosConfig:o,query:{query:n},originMethod:"getProcessorStatuses"})).processor_status}async function q(e){let o=await f({aptosConfig:e.aptosConfig});return BigInt(o[0].last_success_version)}async function P(e){let{aptosConfig:o,processorType:s}=e;return(await a({aptosConfig:o,query:{query:n,variables:{where_condition:{processor:{_eq:s}}}},originMethod:"getProcessorStatus"})).processor_status[0]}export{m as a,T as b,a as c,f as d,q as e,P as f};
-//# sourceMappingURL=chunk-MKTR4U2R.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/general.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file contains the underlying implementations for exposed API surface in\n * the {@link api/general}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * general namespace and without having a dependency cycle error.\n * @group Implementation\n */\n\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { getAptosFullNode, postAptosIndexer } from \"../client\";\nimport { GetChainTopUserTransactionsResponse, GetProcessorStatusResponse, GraphqlQuery, LedgerInfo } from \"../types\";\nimport { GetChainTopUserTransactionsQuery, GetProcessorStatusQuery } from \"../types/generated/operations\";\nimport { GetChainTopUserTransactions, GetProcessorStatus } from \"../types/generated/queries\";\nimport { ProcessorType } from \"../utils/const\";\nimport { memoizeAsync } from \"../utils/memoize\";\n\n/**\n * Cache TTL for ledger info in milliseconds (10 seconds).\n * Ledger info changes frequently but we can cache briefly to reduce redundant calls\n * when building multiple transactions in quick succession.\n */\nconst LEDGER_INFO_CACHE_TTL_MS = 10 * 1000;\n\n/**\n * Retrieves information about the current ledger.\n * Results are cached for 10 seconds to reduce redundant network calls during\n * rapid transaction building.\n *\n * @param args - The arguments for retrieving ledger information.\n * @param args.aptosConfig - The configuration object for connecting to the Aptos network.\n * @group Implementation\n */\nexport async function getLedgerInfo(args: { aptosConfig: AptosConfig }): Promise<LedgerInfo> {\n  const { aptosConfig } = args;\n  const cacheKey = `ledger-info-${aptosConfig.network}`;\n\n  return memoizeAsync(\n    async () => {\n      const { data } = await getAptosFullNode<{}, LedgerInfo>({\n        aptosConfig,\n        originMethod: \"getLedgerInfo\",\n        path: \"\",\n      });\n      return data;\n    },\n    cacheKey,\n    LEDGER_INFO_CACHE_TTL_MS,\n  )();\n}\n\n/**\n * Retrieves the top user transactions for a specific blockchain chain.\n *\n * @param args - The arguments for the function.\n * @param args.aptosConfig - The configuration object for Aptos.\n * @param args.limit - The maximum number of transactions to retrieve.\n * @returns An array of user transactions.\n * @group Implementation\n */\nexport async function getChainTopUserTransactions(args: {\n  aptosConfig: AptosConfig;\n  limit: number;\n}): Promise<GetChainTopUserTransactionsResponse> {\n  const { aptosConfig, limit } = args;\n  const graphqlQuery = {\n    query: GetChainTopUserTransactions,\n    variables: { limit },\n  };\n\n  const data = await queryIndexer<GetChainTopUserTransactionsQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getChainTopUserTransactions\",\n  });\n\n  return data.user_transactions;\n}\n\n/**\n * Executes a GraphQL query against the Aptos indexer and retrieves the resulting data.\n *\n * @param args - The arguments for the query.\n * @param args.aptosConfig - The configuration settings for the Aptos client.\n * @param args.query - The GraphQL query to be executed.\n * @param args.originMethod - An optional string to specify the origin method for tracking purposes.\n * @returns The data returned from the query execution.\n * @group Implementation\n */\nexport async function queryIndexer<T extends {}>(args: {\n  aptosConfig: AptosConfig;\n  query: GraphqlQuery;\n  originMethod?: string;\n}): Promise<T> {\n  const { aptosConfig, query, originMethod } = args;\n  const { data } = await postAptosIndexer<GraphqlQuery, T>({\n    aptosConfig,\n    originMethod: originMethod ?? \"queryIndexer\",\n    path: \"\",\n    body: query,\n    overrides: { WITH_CREDENTIALS: false },\n  });\n  return data;\n}\n\n/**\n * Retrieves the current statuses of processors.\n *\n * @param args - The arguments for the function.\n * @param args.aptosConfig - The configuration object for Aptos.\n * @returns The statuses of the processors.\n * @group Implementation\n */\nexport async function getProcessorStatuses(args: { aptosConfig: AptosConfig }): Promise<GetProcessorStatusResponse> {\n  const { aptosConfig } = args;\n\n  const graphqlQuery = {\n    query: GetProcessorStatus,\n  };\n\n  const data = await queryIndexer<GetProcessorStatusQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getProcessorStatuses\",\n  });\n\n  return data.processor_status;\n}\n\n/**\n * Retrieves the last success version from the indexer.\n *\n * @param args - The arguments for the function.\n * @param args.aptosConfig - The configuration object for Aptos.\n * @returns The last success version as a BigInt.\n * @group Implementation\n */\nexport async function getIndexerLastSuccessVersion(args: { aptosConfig: AptosConfig }): Promise<bigint> {\n  const response = await getProcessorStatuses({ aptosConfig: args.aptosConfig });\n  return BigInt(response[0].last_success_version);\n}\n\n/**\n * Retrieves the status of a specified processor in the Aptos network.\n * This function allows you to check the current operational status of a processor, which can be useful for monitoring and troubleshooting.\n *\n * @param args - The arguments for the function.\n * @param args.aptosConfig - The configuration object for connecting to the Aptos network.\n * @param args.processorType - The type of processor whose status you want to retrieve.\n * @returns The status of the specified processor.\n * @group Implementation\n */\nexport async function getProcessorStatus(args: {\n  aptosConfig: AptosConfig;\n  processorType: ProcessorType;\n}): Promise<GetProcessorStatusResponse[0]> {\n  const { aptosConfig, processorType } = args;\n\n  const whereCondition: { processor: { _eq: string } } = {\n    processor: { _eq: processorType },\n  };\n\n  const graphqlQuery = {\n    query: GetProcessorStatus,\n    variables: {\n      where_condition: whereCondition,\n    },\n  };\n\n  const data = await queryIndexer<GetProcessorStatusQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getProcessorStatus\",\n  });\n\n  return data.processor_status[0];\n}\n"],"mappings":"2KAwBA,IAAMA,EAA2B,GAAK,IAWtC,eAAsBC,EAAcC,EAAyD,CAC3F,GAAM,CAAE,YAAAC,CAAY,EAAID,EAClBE,EAAW,eAAeD,EAAY,OAAO,GAEnD,OAAOE,EACL,SAAY,CACV,GAAM,CAAE,KAAAC,CAAK,EAAI,MAAMC,EAAiC,CACtD,YAAAJ,EACA,aAAc,gBACd,KAAM,EACR,CAAC,EACD,OAAOG,CACT,EACAF,EACAJ,CACF,EAAE,CACJ,CAWA,eAAsBQ,EAA4BN,EAGD,CAC/C,GAAM,CAAE,YAAAC,EAAa,MAAAM,CAAM,EAAIP,EAY/B,OANa,MAAMQ,EAA+C,CAChE,YAAAP,EACA,MAPmB,CACnB,MAAOQ,EACP,UAAW,CAAE,MAAAF,CAAM,CACrB,EAKE,aAAc,6BAChB,CAAC,GAEW,iBACd,CAYA,eAAsBC,EAA2BR,EAIlC,CACb,GAAM,CAAE,YAAAC,EAAa,MAAAS,EAAO,aAAAC,CAAa,EAAIX,EACvC,CAAE,KAAAI,CAAK,EAAI,MAAMQ,EAAkC,CACvD,YAAAX,EACA,aAAcU,GAAgB,eAC9B,KAAM,GACN,KAAMD,EACN,UAAW,CAAE,iBAAkB,EAAM,CACvC,CAAC,EACD,OAAON,CACT,CAUA,eAAsBS,EAAqBb,EAAyE,CAClH,GAAM,CAAE,YAAAC,CAAY,EAAID,EAYxB,OANa,MAAMQ,EAAsC,CACvD,YAAAP,EACA,MANmB,CACnB,MAAOa,CACT,EAKE,aAAc,sBAChB,CAAC,GAEW,gBACd,CAUA,eAAsBC,EAA6Bf,EAAqD,CACtG,IAAMgB,EAAW,MAAMH,EAAqB,CAAE,YAAab,EAAK,WAAY,CAAC,EAC7E,OAAO,OAAOgB,EAAS,CAAC,EAAE,oBAAoB,CAChD,CAYA,eAAsBC,EAAmBjB,EAGE,CACzC,GAAM,CAAE,YAAAC,EAAa,cAAAiB,CAAc,EAAIlB,EAmBvC,OANa,MAAMQ,EAAsC,CACvD,YAAAP,EACA,MATmB,CACnB,MAAOa,EACP,UAAW,CACT,gBAPmD,CACrD,UAAW,CAAE,IAAKI,CAAc,CAClC,CAME,CACF,EAKE,aAAc,oBAChB,CAAC,GAEW,iBAAiB,CAAC,CAChC","names":["LEDGER_INFO_CACHE_TTL_MS","getLedgerInfo","args","aptosConfig","cacheKey","memoizeAsync","data","getAptosFullNode","getChainTopUserTransactions","limit","queryIndexer","GetChainTopUserTransactions","query","originMethod","postAptosIndexer","getProcessorStatuses","GetProcessorStatus","getIndexerLastSuccessVersion","response","getProcessorStatus","processorType"]}

package/dist/esm/chunk-NECL5FCQ.mjs

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

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

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

package/dist/esm/chunk-NHRPXEUE.mjs

@@ -1,2 +0,0 @@
-import{a as r}from"./chunk-RUKFK3OC.mjs";import{b as t}from"./chunk-STY74NUA.mjs";var o=class extends r{toUint8Array(){return this.bcsToBytes()}toString(){let i=this.toUint8Array();return t.fromHexInput(i).toString()}};export{o as a};
-//# sourceMappingURL=chunk-NHRPXEUE.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/signature.ts"],"sourcesContent":["import { Serializable } from \"../../bcs\";\nimport { Hex } from \"../hex\";\n\n/**\n * An abstract representation of a crypto signature,\n * associated with a specific signature scheme, e.g., Ed25519 or Secp256k1.\n *\n * This class represents the product of signing a message directly from a\n * PrivateKey and can be verified against a CryptoPublicKey.\n * @group Implementation\n * @category Serialization\n */\nexport abstract class Signature extends Serializable {\n  /**\n   * Get the raw signature bytes\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    return this.bcsToBytes();\n  }\n\n  /**\n   * Get the signature as a hex string with a 0x prefix e.g. 0x123456...\n   * @returns The hex string representation of the signature.\n   * @group Implementation\n   * @category Serialization\n   */\n  toString(): string {\n    const bytes = this.toUint8Array();\n    return Hex.fromHexInput(bytes).toString();\n  }\n}\n\n/**\n * An abstract representation of an account signature,\n * associated to a specific authentication scheme e.g. Ed25519 or SingleKey\n *\n * This is the product of signing a message through an account,\n * and can be verified against an AccountPublicKey.\n * @group Implementation\n * @category Serialization\n */\n// export abstract class AccountSignature extends Serializable {\n//   /**\n//    * Get the raw signature bytes\n//    */\n//   abstract toUint8Array(): Uint8Array;\n//\n//   /**\n//    * Get the signature as a hex string with a 0x prefix e.g. 0x123456...\n//    */\n//   toString(): string {\n//     const bytes = this.toUint8Array();\n//     return Hex.fromHexInput(bytes).toString();\n//   }\n// }\n"],"mappings":"kFAYO,IAAeA,EAAf,cAAiCC,CAAa,CAMnD,cAA2B,CACzB,OAAO,KAAK,WAAW,CACzB,CAQA,UAAmB,CACjB,IAAMC,EAAQ,KAAK,aAAa,EAChC,OAAOC,EAAI,aAAaD,CAAK,EAAE,SAAS,CAC1C,CACF","names":["Signature","Serializable","bytes","Hex"]}

package/dist/esm/chunk-NNXTS2GB.mjs

@@ -1,2 +0,0 @@
-import{a as d}from"./chunk-ODNZJSOC.mjs";import{b as s}from"./chunk-TBIK7DML.mjs";import{b as r}from"./chunk-6T2OBPIF.mjs";async function g(o){let{aptosConfig:e,accountAddress:t}=o,{data:n}=await s({aptosConfig:e,originMethod:"getInfo",path:`accounts/${r.from(t).toString()}`});return n}async function f(o){return o.options?.ledgerVersion!==void 0?c(o):d(async()=>c(o),`module-${o.accountAddress}-${o.moduleName}`,1e3*60*5)()}async function c(o){let{aptosConfig:e,accountAddress:t,moduleName:n,options:i}=o,{data:u}=await s({aptosConfig:e,originMethod:"getModule",path:`accounts/${r.from(t).toString()}/module/${n}`,params:{ledger_version:i?.ledgerVersion}});return u}export{g as a,f as b};
-//# sourceMappingURL=chunk-NNXTS2GB.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/utils/utils.ts"],"sourcesContent":["import { AccountAddress, AccountAddressInput } from \"../../core/accountAddress\";\nimport { MoveModuleBytecode, LedgerVersionArg, AccountData } from \"../../types/types\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport { getAptosFullNode } from \"../../client\";\nimport { memoizeAsync } from \"../../utils/memoize\";\n\n/**\n * Retrieves account information for a specified account address.\n *\n * @param args - The arguments for retrieving account information.\n * @param args.aptosConfig - The configuration object for Aptos.\n * @param args.accountAddress - The address of the account to retrieve information for.\n * @group Implementation\n */\nexport async function getInfo(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<AccountData> {\n  const { aptosConfig, accountAddress } = args;\n  const { data } = await getAptosFullNode<{}, AccountData>({\n    aptosConfig,\n    originMethod: \"getInfo\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}`,\n  });\n  return data;\n}\n\n/**\n * Queries for a move module given an account address and module name.\n * This function can help you retrieve the module's ABI and other relevant information.\n *\n * @param args - The arguments for retrieving the module.\n * @param args.aptosConfig - The configuration for the Aptos client.\n * @param args.accountAddress - The account address in hex-encoded 32 byte format.\n * @param args.moduleName - The name of the module to retrieve.\n * @param args.options - Optional parameters for the request.\n * @param args.options.ledgerVersion - Specifies the ledger version of transactions. By default, the latest version will be used.\n * @returns The move module.\n * @group Implementation\n */\nexport async function getModule(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  moduleName: string;\n  options?: LedgerVersionArg;\n}): Promise<MoveModuleBytecode> {\n  // We don't memoize the account module by ledger version, as it's not a common use case, this would be handled\n  // by the developer directly\n  if (args.options?.ledgerVersion !== undefined) {\n    return getModuleInner(args);\n  }\n\n  return memoizeAsync(\n    async () => getModuleInner(args),\n    `module-${args.accountAddress}-${args.moduleName}`,\n    1000 * 60 * 5, // 5 minutes\n  )();\n}\n\n/**\n * Retrieves the bytecode of a specified module from a given account address.\n *\n * @param args - The parameters for retrieving the module bytecode.\n * @param args.aptosConfig - The configuration for connecting to the Aptos network.\n * @param args.accountAddress - The address of the account from which to retrieve the module.\n * @param args.moduleName - The name of the module to retrieve.\n * @param args.options - Optional parameters for specifying the ledger version.\n * @param args.options.ledgerVersion - The specific ledger version to query.\n * @group Implementation\n */\nasync function getModuleInner(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  moduleName: string;\n  options?: LedgerVersionArg;\n}): Promise<MoveModuleBytecode> {\n  const { aptosConfig, accountAddress, moduleName, options } = args;\n\n  const { data } = await getAptosFullNode<{}, MoveModuleBytecode>({\n    aptosConfig,\n    originMethod: \"getModule\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,\n    params: { ledger_version: options?.ledgerVersion },\n  });\n  return data;\n}\n"],"mappings":"2HAcA,eAAsBA,EAAQC,EAGL,CACvB,GAAM,CAAE,YAAAC,EAAa,eAAAC,CAAe,EAAIF,EAClC,CAAE,KAAAG,CAAK,EAAI,MAAMC,EAAkC,CACvD,YAAAH,EACA,aAAc,UACd,KAAM,YAAYI,EAAe,KAAKH,CAAc,EAAE,SAAS,CAAC,EAClE,CAAC,EACD,OAAOC,CACT,CAeA,eAAsBG,EAAUN,EAKA,CAG9B,OAAIA,EAAK,SAAS,gBAAkB,OAC3BO,EAAeP,CAAI,EAGrBQ,EACL,SAAYD,EAAeP,CAAI,EAC/B,UAAUA,EAAK,cAAc,IAAIA,EAAK,UAAU,GAChD,IAAO,GAAK,CACd,EAAE,CACJ,CAaA,eAAeO,EAAeP,EAKE,CAC9B,GAAM,CAAE,YAAAC,EAAa,eAAAC,EAAgB,WAAAO,EAAY,QAAAC,CAAQ,EAAIV,EAEvD,CAAE,KAAAG,CAAK,EAAI,MAAMC,EAAyC,CAC9D,YAAAH,EACA,aAAc,YACd,KAAM,YAAYI,EAAe,KAAKH,CAAc,EAAE,SAAS,CAAC,WAAWO,CAAU,GACrF,OAAQ,CAAE,eAAgBC,GAAS,aAAc,CACnD,CAAC,EACD,OAAOP,CACT","names":["getInfo","args","aptosConfig","accountAddress","data","getAptosFullNode","AccountAddress","getModule","getModuleInner","memoizeAsync","moduleName","options"]}

package/dist/esm/chunk-NP2IAUME.mjs

@@ -1,2 +0,0 @@
-var r=(e=>(e[e.Independent=0]="Independent",e[e.FollowsDomain=1]="FollowsDomain",e))(r||{}),t=(n=>(n.Expired="expired",n.InGracePeriod="in_grace_period",n.Active="active",n))(t||{});export{r as a,t as b};
-//# sourceMappingURL=chunk-NP2IAUME.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/types/ans.ts"],"sourcesContent":["import { type GetANSNameResponse } from \"./indexer\";\n\nexport type RawANSName = GetANSNameResponse[0];\n\n/**\n * The token standard for the ANS name. v1 is the original token standard, v2 is\n * the new token standard. v1 has been deprecated.\n */\nexport type AnsTokenStandard = \"v1\" | \"v2\";\n\n/**\n * Policy for determining how subdomains expire in relation to their parent domain.\n */\nexport enum SubdomainExpirationPolicy {\n  /**\n   * The subdomain will expire independently of the domain. The owner of the\n   * domain can manually set when the subdomain expires.\n   */\n  Independent = 0,\n  /**\n   * The subdomain will expire at the same time as the domain.\n   */\n  FollowsDomain = 1,\n}\n\n/**\n * The status of the name.\n */\nexport enum ExpirationStatus {\n  /**\n   * The name no longer functions as a primary or target name. It is open to\n   * being claimed by the public.\n   */\n  Expired = \"expired\",\n  /**\n   * The name is past it's expiration date, but only claimable by the current\n   * owner of the name. It does not function as a primary or target name.\n   */\n  InGracePeriod = \"in_grace_period\",\n  /**\n   * The name is in good standing.\n   */\n  Active = \"active\",\n}\n\nexport interface AnsName extends RawANSName {\n  /**\n   * The domain name. ie \"aptos.apt\" would have a domain of \"aptos\"\n   */\n  domain: string;\n  /**\n   * The subdomain name, if the name is a subdomain. ie \"name.aptos.apt\" would have a subdomain of \"name\"\n   */\n  subdomain?: string;\n  /**\n   * The expiration timestamp of the name in milliseconds since epoch. Note, if\n   * the name is not a subdomain, this will be the same as the domain expiration\n   * timestamp.\n   */\n  expiration_timestamp: string;\n  /**\n   * The expiration timestamp of the domain in milliseconds since epoch.\n   */\n  domain_expiration_timestamp: string;\n  /**\n   * This is a derived date value. It takes into consideration if the name is a\n   * subdomain and its expiration policy.\n   */\n  expiration: Date;\n\n  /**\n   * The status of the name's expiration.\n   *\n   * 1. Expired: The name has expired and is no longer resolvable.\n   * 2. InGracePeriod: The name is within the grace period and is still\n   *    resolvable if it is renewed.\n   * 3. Active: The name is active and is resolvable.\n   *\n   * @see {@link ExpirationStatus}\n   */\n  expiration_status: ExpirationStatus;\n  /**\n   * The address that the name points to. For example, if you send a transaction\n   * to \"aptos.apt\" with a target address of \"0x1\", the registered_address will\n   * be \"0x1\".\n   */\n  registered_address?: string;\n  /**\n   * The token standard for the name. See {@link AnsTokenStandard} for more details.\n   */\n  token_standard: AnsTokenStandard;\n  /**\n   * If the name is registered as a primary name for _any_ account. It is\n   * possible to have multiple primary names returned in a single query.\n   */\n  is_primary: boolean;\n  /**\n   * The address of the wallet that owns the name.\n   */\n  owner_address?: string;\n  /**\n   * The expiration policy for the subdomain. See {@link SubdomainExpirationPolicy} for more details.\n   */\n  subdomain_expiration_policy: SubdomainExpirationPolicy;\n  /**\n   * Whether the name is in the renewable period. This incorporates leading time\n   * before the name expires and the grace period after the name expires.\n   */\n  isInRenewablePeriod: boolean;\n}\n"],"mappings":"AAaO,IAAKA,OAKVA,IAAA,YAAc,GAAd,cAIAA,IAAA,cAAgB,GAAhB,gBATUA,OAAA,IAeAC,OAKVA,EAAA,QAAU,UAKVA,EAAA,cAAgB,kBAIhBA,EAAA,OAAS,SAdCA,OAAA","names":["SubdomainExpirationPolicy","ExpirationStatus"]}

package/dist/esm/chunk-NPWYZVHE.mjs

@@ -1,2 +0,0 @@
-import{a as u,c as r}from"./chunk-2EBXCCLB.mjs";import{e as t}from"./chunk-KKPH2JUV.mjs";import{b as o}from"./chunk-6T2OBPIF.mjs";import{a as i}from"./chunk-RUKFK3OC.mjs";var c=class extends i{constructor(e){super();this.accountAddress=o.ONE;this.moduleName=new r("account");this.structName=new r("RotationProofChallenge");this.sequenceNumber=new t(e.sequenceNumber),this.originator=e.originator,this.currentAuthKey=e.currentAuthKey,this.newPublicKey=u.U8(e.newPublicKey.toUint8Array())}serialize(e){e.serialize(this.accountAddress),e.serialize(this.moduleName),e.serialize(this.structName),e.serialize(this.sequenceNumber),e.serialize(this.originator),e.serialize(this.currentAuthKey),e.serialize(this.newPublicKey)}};export{c as a};
-//# sourceMappingURL=chunk-NPWYZVHE.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/instances/rotationProofChallenge.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Serializer, Serializable } from \"../../bcs/serializer\";\nimport { AccountAddress } from \"../../core/accountAddress\";\nimport { AnyNumber } from \"../../types\";\nimport { PublicKey } from \"../../core/crypto\";\nimport { MoveString, MoveVector, U64, U8 } from \"../../bcs\";\n\n/**\n * Represents a challenge required for the account owner to sign in order to rotate the authentication key.\n * @group Implementation\n * @category Transactions\n */\nexport class RotationProofChallenge extends Serializable {\n  // Resource account address\n  public readonly accountAddress: AccountAddress = AccountAddress.ONE;\n\n  // Module name, i.e: 0x1::account\n  public readonly moduleName: MoveString = new MoveString(\"account\");\n\n  // The rotation proof challenge struct name that live under the module\n  public readonly structName: MoveString = new MoveString(\"RotationProofChallenge\");\n\n  // Signer's address\n  public readonly originator: AccountAddress;\n\n  // Signer's current authentication key\n  public readonly currentAuthKey: AccountAddress;\n\n  // New public key to rotate to\n  public readonly newPublicKey: MoveVector<U8>;\n\n  // Sequence number of the account\n  public readonly sequenceNumber: U64;\n\n  /**\n   * Initializes a new instance of the class with the specified parameters.\n   * This constructor sets up the necessary attributes for managing account keys.\n   *\n   * @param args - The parameters required to create the instance.\n   * @param args.sequenceNumber - The sequence number associated with the transaction.\n   * @param args.originator - The account address of the originator.\n   * @param args.currentAuthKey - The current authentication key of the account.\n   * @param args.newPublicKey - The new public key to be set for the account.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(args: {\n    sequenceNumber: AnyNumber;\n    originator: AccountAddress;\n    currentAuthKey: AccountAddress;\n    newPublicKey: PublicKey;\n  }) {\n    super();\n    this.sequenceNumber = new U64(args.sequenceNumber);\n    this.originator = args.originator;\n    this.currentAuthKey = args.currentAuthKey;\n    this.newPublicKey = MoveVector.U8(args.newPublicKey.toUint8Array());\n  }\n\n  /**\n   * Serializes the properties of the current instance for transmission or storage.\n   * This function helps in converting the instance data into a format suitable for serialization.\n   *\n   * @param serializer - The serializer used to serialize the instance properties.\n   * @param serializer.accountAddress - The account address to serialize.\n   * @param serializer.moduleName - The module name to serialize.\n   * @param serializer.structName - The struct name to serialize.\n   * @param serializer.sequenceNumber - The sequence number to serialize.\n   * @param serializer.originator - The originator to serialize.\n   * @param serializer.currentAuthKey - The current authentication key to serialize.\n   * @param serializer.newPublicKey - The new public key to serialize.\n   * @group Implementation\n   * @category Transactions\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serialize(this.accountAddress);\n    serializer.serialize(this.moduleName);\n    serializer.serialize(this.structName);\n    serializer.serialize(this.sequenceNumber);\n    serializer.serialize(this.originator);\n    serializer.serialize(this.currentAuthKey);\n    serializer.serialize(this.newPublicKey);\n  }\n}\n"],"mappings":"2KAcO,IAAMA,EAAN,cAAqCC,CAAa,CAkCvD,YAAYC,EAKT,CACD,MAAM,EAtCR,KAAgB,eAAiCC,EAAe,IAGhE,KAAgB,WAAyB,IAAIC,EAAW,SAAS,EAGjE,KAAgB,WAAyB,IAAIA,EAAW,wBAAwB,EAiC9E,KAAK,eAAiB,IAAIC,EAAIH,EAAK,cAAc,EACjD,KAAK,WAAaA,EAAK,WACvB,KAAK,eAAiBA,EAAK,eAC3B,KAAK,aAAeI,EAAW,GAAGJ,EAAK,aAAa,aAAa,CAAC,CACpE,CAiBA,UAAUK,EAA8B,CACtCA,EAAW,UAAU,KAAK,cAAc,EACxCA,EAAW,UAAU,KAAK,UAAU,EACpCA,EAAW,UAAU,KAAK,UAAU,EACpCA,EAAW,UAAU,KAAK,cAAc,EACxCA,EAAW,UAAU,KAAK,UAAU,EACpCA,EAAW,UAAU,KAAK,cAAc,EACxCA,EAAW,UAAU,KAAK,YAAY,CACxC,CACF","names":["RotationProofChallenge","Serializable","args","AccountAddress","MoveString","U64","MoveVector","serializer"]}

package/dist/esm/chunk-NTMFADQ7.mjs

@@ -1,2 +0,0 @@
-import{h as e}from"./chunk-WZZ7PJ3X.mjs";async function i(o){o.minimumLedgerVersion!==void 0&&await e({aptosConfig:o.config,minimumLedgerVersion:o.minimumLedgerVersion,processorType:o.processorType})}export{i as a};
-//# sourceMappingURL=chunk-NTMFADQ7.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/utils.ts"],"sourcesContent":["import { waitForIndexer } from \"../internal/transaction\";\nimport { ProcessorType } from \"../utils\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { AnyNumber } from \"../types\";\n\n/**\n * Waits for the indexer to reach a specified ledger version, allowing for synchronization with the blockchain.\n * This function is useful for ensuring that your application is working with the most up-to-date data before proceeding.\n *\n * @param args - The parameters for waiting on the indexer.\n * @param args.config - The configuration object for Aptos.\n * @param [args.minimumLedgerVersion] - The minimum ledger version to wait for. If not specified, the function will not wait.\n * @param args.processorType - The type of processor to wait for.\n *\n * @example\n * ```typescript\n * import { Aptos, AptosConfig, Network, ProcessorType } from \"@aptos-labs/ts-sdk\";\n *\n * const config = new AptosConfig({ network: Network.TESTNET });\n * const aptos = new Aptos(config);\n *\n * async function runExample() {\n *   // Wait for the indexer to reach a specific ledger version\n *   await aptos.waitForIndexerOnVersion({\n *     config: config,\n *     minimumLedgerVersion: 1000n, // replace with a real ledger version\n *     processorType: ProcessorType.DEFAULT,\n *   });\n *\n *   console.log(\"Indexer is synced to the specified ledger version.\");\n * }\n * runExample().catch(console.error);\n * ```\n * @group Implementation\n */\nexport async function waitForIndexerOnVersion(args: {\n  config: AptosConfig;\n  minimumLedgerVersion?: AnyNumber;\n  processorType: ProcessorType;\n}) {\n  if (args.minimumLedgerVersion !== undefined) {\n    await waitForIndexer({\n      aptosConfig: args.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: args.processorType,\n    });\n  }\n}\n"],"mappings":"yCAmCA,eAAsBA,EAAwBC,EAI3C,CACGA,EAAK,uBAAyB,QAChC,MAAMC,EAAe,CACnB,YAAaD,EAAK,OAClB,qBAAsBA,EAAK,qBAC3B,cAAeA,EAAK,aACtB,CAAC,CAEL","names":["waitForIndexerOnVersion","args","waitForIndexer"]}

package/dist/esm/chunk-ODNZJSOC.mjs

@@ -1,2 +0,0 @@
-var m=new Set;function l(s){if(!s||typeof s!="string")throw new Error("Cache key must be a non-empty string");if(s.length<10)throw new Error(`Cache key "${s}" is too short. Keys should be at least 10 characters and include a namespace prefix.`);let e=s.match(/^([a-z]+-[a-z]+-)/i);e&&m.add(e[1])}var n=new Map,a=null;function u(){a===null&&(a=setInterval(()=>{let s=Date.now(),e=[];n.forEach((t,i)=>{t.ttlMs!==void 0&&s-t.timestamp>t.ttlMs&&e.push(i)}),e.forEach(t=>n.delete(t)),n.size===0&&a!==null&&(clearInterval(a),a=null)},6e4),typeof a=="object"&&"unref"in a&&a.unref())}function f(){if(n.size>=1e3){let s=Math.ceil(100),e=Array.from(n.entries()).sort((t,i)=>t[1].lastAccess-i[1].lastAccess);for(let t=0;t<s&&t<e.length;t+=1)n.delete(e[t][0])}}function d(s,e,t){return l(e),async(...i)=>{let r=Date.now();if(n.has(e)){let o=n.get(e);if(t===void 0||r-o.timestamp<=t)return o.lastAccess=r,o.value;n.delete(e)}let c=await s(...i);return f(),n.set(e,{value:c,timestamp:r,lastAccess:r,ttlMs:t}),u(),c}}function h(s,e,t){return l(e),(...i)=>{let r=Date.now();if(n.has(e)){let o=n.get(e);if(t===void 0||r-o.timestamp<=t)return o.lastAccess=r,o.value;n.delete(e)}let c=s(...i);return f(),n.set(e,{value:c,timestamp:r,lastAccess:r,ttlMs:t}),u(),c}}function p(){n.clear()}function E(){return n.size}export{d as a,h as b,p as c,E as d};
-//# sourceMappingURL=chunk-ODNZJSOC.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/memoize.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Maximum number of entries to keep in the cache to prevent unbounded memory growth.\n * When this limit is exceeded, the oldest entries are evicted.\n */\nconst MAX_CACHE_SIZE = 1000;\n\n/**\n * Interval in milliseconds for periodic cleanup of expired cache entries.\n */\nconst CLEANUP_INTERVAL_MS = 60000; // 1 minute\n\n/**\n * Minimum required key length to help ensure uniqueness.\n * Keys should include a namespace prefix (e.g., \"module-abi-\", \"ledger-info-\").\n */\nconst MIN_KEY_LENGTH = 10;\n\n/**\n * Set of known cache key prefixes to help detect potential collisions.\n * Each caller should use a unique prefix.\n */\nconst knownKeyPrefixes = new Set<string>();\n\n/**\n * Validates a cache key for basic security requirements.\n * @param key - The cache key to validate\n * @throws Error if the key is invalid\n */\nfunction validateCacheKey(key: string): void {\n  if (!key || typeof key !== \"string\") {\n    throw new Error(\"Cache key must be a non-empty string\");\n  }\n  if (key.length < MIN_KEY_LENGTH) {\n    throw new Error(\n      `Cache key \"${key}\" is too short. Keys should be at least ${MIN_KEY_LENGTH} characters and include a namespace prefix.`,\n    );\n  }\n  // Extract prefix (everything before the last hyphen or the first 10 chars)\n  const prefixMatch = key.match(/^([a-z]+-[a-z]+-)/i);\n  if (prefixMatch) {\n    knownKeyPrefixes.add(prefixMatch[1]);\n  }\n}\n\n/**\n * Cache entry structure with value, timestamp, and last access time for LRU eviction.\n */\ninterface CacheEntry<T> {\n  value: T;\n  timestamp: number;\n  lastAccess: number;\n  ttlMs?: number;\n}\n\n/**\n * The global cache Map shared across all functions with LRU eviction support.\n * SECURITY: All cache keys should include a unique namespace prefix to prevent\n * collisions between different caching use cases (e.g., \"module-abi-\", \"ledger-info-\").\n * @group Implementation\n * @category Utils\n */\nconst cache = new Map<string, CacheEntry<any>>();\n\n/**\n * Track whether cleanup interval is set up.\n */\nlet cleanupIntervalId: ReturnType<typeof setInterval> | null = null;\n\n/**\n * Sets up periodic cleanup of expired cache entries if not already running.\n * This prevents memory leaks from accumulating expired entries.\n */\nfunction ensureCleanupInterval(): void {\n  if (cleanupIntervalId === null) {\n    cleanupIntervalId = setInterval(() => {\n      const now = Date.now();\n      const keysToDelete: string[] = [];\n\n      cache.forEach((entry, key) => {\n        // Remove entries that have expired\n        if (entry.ttlMs !== undefined && now - entry.timestamp > entry.ttlMs) {\n          keysToDelete.push(key);\n        }\n      });\n\n      keysToDelete.forEach((key) => cache.delete(key));\n\n      // If cache is empty, stop the cleanup interval to avoid unnecessary overhead\n      if (cache.size === 0 && cleanupIntervalId !== null) {\n        clearInterval(cleanupIntervalId);\n        cleanupIntervalId = null;\n      }\n    }, CLEANUP_INTERVAL_MS);\n\n    // Ensure the interval doesn't prevent Node.js from exiting\n    if (typeof cleanupIntervalId === \"object\" && \"unref\" in cleanupIntervalId) {\n      cleanupIntervalId.unref();\n    }\n  }\n}\n\n/**\n * Evicts the least recently used entries when cache exceeds maximum size.\n */\nfunction evictIfNeeded(): void {\n  if (cache.size >= MAX_CACHE_SIZE) {\n    // Find and remove the least recently accessed entries (remove ~10% of cache)\n    const entriesToRemove = Math.ceil(MAX_CACHE_SIZE * 0.1);\n    const entries = Array.from(cache.entries()).sort((a, b) => a[1].lastAccess - b[1].lastAccess);\n\n    for (let i = 0; i < entriesToRemove && i < entries.length; i += 1) {\n      cache.delete(entries[i][0]);\n    }\n  }\n}\n\n/**\n * A memoize higher-order function to cache the response of an async function.\n * This function helps to improve performance by avoiding repeated calls to the same async function with the same arguments\n * within a specified time-to-live (TTL).\n *\n * Features:\n * - LRU eviction when cache exceeds MAX_CACHE_SIZE entries\n * - Periodic cleanup of expired entries to prevent memory leaks\n *\n * @param func The async function to cache the result of.\n * @param key The cache key used to store the result.\n * @param ttlMs The time-to-live in milliseconds for cached data.\n * @returns The cached or latest result.\n * @group Implementation\n * @category Utils\n */\nexport function memoizeAsync<T>(\n  func: (...args: any[]) => Promise<T>,\n  key: string,\n  ttlMs?: number,\n): (...args: any[]) => Promise<T> {\n  // Validate key format on first call to catch misuse early\n  validateCacheKey(key);\n\n  return async (...args: any[]) => {\n    const now = Date.now();\n\n    // Check if the cached result exists and is within TTL\n    if (cache.has(key)) {\n      const entry = cache.get(key)!;\n      if (ttlMs === undefined || now - entry.timestamp <= ttlMs) {\n        // Update last access time for LRU\n        entry.lastAccess = now;\n        return entry.value;\n      }\n      // Entry expired, remove it\n      cache.delete(key);\n    }\n\n    // If not cached or TTL expired, compute the result\n    const result = await func(...args);\n\n    // Evict old entries if needed before adding new one\n    evictIfNeeded();\n\n    // Cache the result with a timestamp\n    cache.set(key, { value: result, timestamp: now, lastAccess: now, ttlMs });\n\n    // Ensure cleanup is running\n    ensureCleanupInterval();\n\n    return result;\n  };\n}\n\n/**\n * Caches the result of a function call to improve performance on subsequent calls with the same arguments.\n *\n * Features:\n * - LRU eviction when cache exceeds MAX_CACHE_SIZE entries\n * - Periodic cleanup of expired entries to prevent memory leaks\n *\n * @param key - The key to cache on, all accesses by this key will return the cached value.\n * @param func - The function whose result will be cached.\n * @param ttlMs - The time-to-live in milliseconds for cached data.\n * @returns A memoized version of the provided function that returns the cached result if available and within TTL.\n * @group Implementation\n * @category Utils\n */\nexport function memoize<T>(func: (...args: any[]) => T, key: string, ttlMs?: number): (...args: any[]) => T {\n  // Validate key format on first call to catch misuse early\n  validateCacheKey(key);\n\n  return (...args: any[]) => {\n    const now = Date.now();\n\n    // Check if the cached result exists and is within TTL\n    if (cache.has(key)) {\n      const entry = cache.get(key)!;\n      if (ttlMs === undefined || now - entry.timestamp <= ttlMs) {\n        // Update last access time for LRU\n        entry.lastAccess = now;\n        return entry.value;\n      }\n      // Entry expired, remove it\n      cache.delete(key);\n    }\n\n    // If not cached or TTL expired, compute the result\n    const result = func(...args);\n\n    // Evict old entries if needed before adding new one\n    evictIfNeeded();\n\n    // Cache the result with a timestamp\n    cache.set(key, { value: result, timestamp: now, lastAccess: now, ttlMs });\n\n    // Ensure cleanup is running\n    ensureCleanupInterval();\n\n    return result;\n  };\n}\n\n/**\n * Clears all entries from the memoization cache.\n * Useful for testing or when you need to force fresh data.\n * @group Implementation\n * @category Utils\n */\nexport function clearMemoizeCache(): void {\n  cache.clear();\n}\n\n/**\n * Returns the current size of the memoization cache.\n * Useful for monitoring and debugging.\n * @group Implementation\n * @category Utils\n */\nexport function getMemoizeCacheSize(): number {\n  return cache.size;\n}\n"],"mappings":"AAwBA,IAAMA,EAAmB,IAAI,IAO7B,SAASC,EAAiBC,EAAmB,CAC3C,GAAI,CAACA,GAAO,OAAOA,GAAQ,SACzB,MAAM,IAAI,MAAM,sCAAsC,EAExD,GAAIA,EAAI,OAAS,GACf,MAAM,IAAI,MACR,cAAcA,CAAG,uFACnB,EAGF,IAAMC,EAAcD,EAAI,MAAM,oBAAoB,EAC9CC,GACFH,EAAiB,IAAIG,EAAY,CAAC,CAAC,CAEvC,CAmBA,IAAMC,EAAQ,IAAI,IAKdC,EAA2D,KAM/D,SAASC,GAA8B,CACjCD,IAAsB,OACxBA,EAAoB,YAAY,IAAM,CACpC,IAAME,EAAM,KAAK,IAAI,EACfC,EAAyB,CAAC,EAEhCJ,EAAM,QAAQ,CAACK,EAAOP,IAAQ,CAExBO,EAAM,QAAU,QAAaF,EAAME,EAAM,UAAYA,EAAM,OAC7DD,EAAa,KAAKN,CAAG,CAEzB,CAAC,EAEDM,EAAa,QAASN,GAAQE,EAAM,OAAOF,CAAG,CAAC,EAG3CE,EAAM,OAAS,GAAKC,IAAsB,OAC5C,cAAcA,CAAiB,EAC/BA,EAAoB,KAExB,EAAG,GAAmB,EAGlB,OAAOA,GAAsB,UAAY,UAAWA,GACtDA,EAAkB,MAAM,EAG9B,CAKA,SAASK,GAAsB,CAC7B,GAAIN,EAAM,MAAQ,IAAgB,CAEhC,IAAMO,EAAkB,KAAK,KAAK,GAAoB,EAChDC,EAAU,MAAM,KAAKR,EAAM,QAAQ,CAAC,EAAE,KAAK,CAACS,EAAGC,IAAMD,EAAE,CAAC,EAAE,WAAaC,EAAE,CAAC,EAAE,UAAU,EAE5F,QAASC,EAAI,EAAGA,EAAIJ,GAAmBI,EAAIH,EAAQ,OAAQG,GAAK,EAC9DX,EAAM,OAAOQ,EAAQG,CAAC,EAAE,CAAC,CAAC,CAE9B,CACF,CAkBO,SAASC,EACdC,EACAf,EACAgB,EACgC,CAEhC,OAAAjB,EAAiBC,CAAG,EAEb,SAAUiB,IAAgB,CAC/B,IAAMZ,EAAM,KAAK,IAAI,EAGrB,GAAIH,EAAM,IAAIF,CAAG,EAAG,CAClB,IAAMO,EAAQL,EAAM,IAAIF,CAAG,EAC3B,GAAIgB,IAAU,QAAaX,EAAME,EAAM,WAAaS,EAElD,OAAAT,EAAM,WAAaF,EACZE,EAAM,MAGfL,EAAM,OAAOF,CAAG,CAClB,CAGA,IAAMkB,EAAS,MAAMH,EAAK,GAAGE,CAAI,EAGjC,OAAAT,EAAc,EAGdN,EAAM,IAAIF,EAAK,CAAE,MAAOkB,EAAQ,UAAWb,EAAK,WAAYA,EAAK,MAAAW,CAAM,CAAC,EAGxEZ,EAAsB,EAEfc,CACT,CACF,CAgBO,SAASC,EAAWJ,EAA6Bf,EAAagB,EAAuC,CAE1G,OAAAjB,EAAiBC,CAAG,EAEb,IAAIiB,IAAgB,CACzB,IAAMZ,EAAM,KAAK,IAAI,EAGrB,GAAIH,EAAM,IAAIF,CAAG,EAAG,CAClB,IAAMO,EAAQL,EAAM,IAAIF,CAAG,EAC3B,GAAIgB,IAAU,QAAaX,EAAME,EAAM,WAAaS,EAElD,OAAAT,EAAM,WAAaF,EACZE,EAAM,MAGfL,EAAM,OAAOF,CAAG,CAClB,CAGA,IAAMkB,EAASH,EAAK,GAAGE,CAAI,EAG3B,OAAAT,EAAc,EAGdN,EAAM,IAAIF,EAAK,CAAE,MAAOkB,EAAQ,UAAWb,EAAK,WAAYA,EAAK,MAAAW,CAAM,CAAC,EAGxEZ,EAAsB,EAEfc,CACT,CACF,CAQO,SAASE,GAA0B,CACxClB,EAAM,MAAM,CACd,CAQO,SAASmB,GAA8B,CAC5C,OAAOnB,EAAM,IACf","names":["knownKeyPrefixes","validateCacheKey","key","prefixMatch","cache","cleanupIntervalId","ensureCleanupInterval","now","keysToDelete","entry","evictIfNeeded","entriesToRemove","entries","a","b","i","memoizeAsync","func","ttlMs","args","result","memoize","clearMemoizeCache","getMemoizeCacheSize"]}

package/dist/esm/chunk-P5HCJN3A.mjs

@@ -1,2 +0,0 @@
-var s={mainnet:"https://api.mainnet.aptoslabs.com/v1/graphql",testnet:"https://api.testnet.aptoslabs.com/v1/graphql",devnet:"https://api.devnet.aptoslabs.com/v1/graphql",shelbynet:"https://api.shelbynet.shelby.xyz/v1/graphql",netna:"https://api.netna.staging.aptoslabs.com/v1/graphql",local:"http://127.0.0.1:8090/v1/graphql"},p={mainnet:"https://api.mainnet.aptoslabs.com/v1",testnet:"https://api.testnet.aptoslabs.com/v1",devnet:"https://api.devnet.aptoslabs.com/v1",shelbynet:"https://api.shelbynet.shelby.xyz/v1",netna:"https://api.netna.staging.aptoslabs.com/v1",local:"http://127.0.0.1:8080/v1"},a={devnet:"https://faucet.devnet.aptoslabs.com",shelbynet:"https://faucet.shelbynet.shelby.xyz",netna:"https://faucet-dev-netna-us-central1-410192433417.us-central1.run.app",local:"http://127.0.0.1:8081"},n={mainnet:"https://api.mainnet.aptoslabs.com/keyless/pepper/v0",testnet:"https://api.testnet.aptoslabs.com/keyless/pepper/v0",devnet:"https://api.devnet.aptoslabs.com/keyless/pepper/v0",shelbynet:"https://api.shelbynet.aptoslabs.com/keyless/pepper/v0",netna:"https://api.devnet.aptoslabs.com/keyless/pepper/v0",local:"https://api.devnet.aptoslabs.com/keyless/pepper/v0"},o={mainnet:"https://api.mainnet.aptoslabs.com/keyless/prover/v0",testnet:"https://api.testnet.aptoslabs.com/keyless/prover/v0",devnet:"https://api.devnet.aptoslabs.com/keyless/prover/v0",shelbynet:"https://api.shelbynet.aptoslabs.com/keyless/prover/v0",netna:"https://api.devnet.aptoslabs.com/keyless/prover/v0",local:"https://api.devnet.aptoslabs.com/keyless/prover/v0"},e=(t=>(t.MAINNET="mainnet",t.TESTNET="testnet",t.DEVNET="devnet",t.SHELBYNET="shelbynet",t.NETNA="netna",t.LOCAL="local",t.CUSTOM="custom",t))(e||{}),l={mainnet:1,testnet:2,local:4},r={mainnet:"mainnet",testnet:"testnet",devnet:"devnet",shelbynet:"shelbynet",netna:"netna",local:"local",custom:"custom"};export{s as a,p as b,a as c,n as d,o as e,e as f,l as g,r as h};
-//# sourceMappingURL=chunk-P5HCJN3A.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/apiEndpoints.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * @group Implementation\n * @category Network\n */\nexport const NetworkToIndexerAPI: Record<string, string> = {\n  mainnet: \"https://api.mainnet.aptoslabs.com/v1/graphql\",\n  testnet: \"https://api.testnet.aptoslabs.com/v1/graphql\",\n  devnet: \"https://api.devnet.aptoslabs.com/v1/graphql\",\n  shelbynet: \"https://api.shelbynet.shelby.xyz/v1/graphql\",\n  netna: \"https://api.netna.staging.aptoslabs.com/v1/graphql\",\n  local: \"http://127.0.0.1:8090/v1/graphql\",\n};\n\n/**\n * @group Implementation\n * @category Network\n */\nexport const NetworkToNodeAPI: Record<string, string> = {\n  mainnet: \"https://api.mainnet.aptoslabs.com/v1\",\n  testnet: \"https://api.testnet.aptoslabs.com/v1\",\n  devnet: \"https://api.devnet.aptoslabs.com/v1\",\n  shelbynet: \"https://api.shelbynet.shelby.xyz/v1\",\n  netna: \"https://api.netna.staging.aptoslabs.com/v1\",\n  local: \"http://127.0.0.1:8080/v1\",\n};\n\n/**\n * @group Implementation\n * @category Network\n */\nexport const NetworkToFaucetAPI: Record<string, string> = {\n  devnet: \"https://faucet.devnet.aptoslabs.com\",\n  shelbynet: \"https://faucet.shelbynet.shelby.xyz\",\n  netna: \"https://faucet-dev-netna-us-central1-410192433417.us-central1.run.app\",\n  local: \"http://127.0.0.1:8081\",\n};\n\n/**\n * @group Implementation\n * @category Network\n */\nexport const NetworkToPepperAPI: Record<string, string> = {\n  mainnet: \"https://api.mainnet.aptoslabs.com/keyless/pepper/v0\",\n  testnet: \"https://api.testnet.aptoslabs.com/keyless/pepper/v0\",\n  devnet: \"https://api.devnet.aptoslabs.com/keyless/pepper/v0\",\n  shelbynet: \"https://api.shelbynet.aptoslabs.com/keyless/pepper/v0\",\n  netna: \"https://api.devnet.aptoslabs.com/keyless/pepper/v0\",\n  // Use the devnet service for local environment\n  local: \"https://api.devnet.aptoslabs.com/keyless/pepper/v0\",\n};\n\n/**\n * @group Implementation\n * @category Network\n */\nexport const NetworkToProverAPI: Record<string, string> = {\n  mainnet: \"https://api.mainnet.aptoslabs.com/keyless/prover/v0\",\n  testnet: \"https://api.testnet.aptoslabs.com/keyless/prover/v0\",\n  devnet: \"https://api.devnet.aptoslabs.com/keyless/prover/v0\",\n  shelbynet: \"https://api.shelbynet.aptoslabs.com/keyless/prover/v0\",\n  netna: \"https://api.devnet.aptoslabs.com/keyless/prover/v0\",\n  // Use the devnet service for local environment\n  local: \"https://api.devnet.aptoslabs.com/keyless/prover/v0\",\n};\n\n/**\n * Different network environments for connecting to services, ranging from production to development setups.\n * @group Implementation\n * @category Network\n */\nexport enum Network {\n  MAINNET = \"mainnet\",\n  TESTNET = \"testnet\",\n  DEVNET = \"devnet\",\n  SHELBYNET = \"shelbynet\",\n  NETNA = \"netna\",\n  LOCAL = \"local\",\n  CUSTOM = \"custom\",\n}\n\n/**\n * @group Implementation\n * @category Network\n */\nexport const NetworkToChainId: Record<string, number> = {\n  mainnet: 1,\n  testnet: 2,\n  local: 4,\n};\n\n/**\n * @group Implementation\n * @category Network\n */\nexport const NetworkToNetworkName: Record<string, Network> = {\n  mainnet: Network.MAINNET,\n  testnet: Network.TESTNET,\n  devnet: Network.DEVNET,\n  shelbynet: Network.SHELBYNET,\n  netna: Network.NETNA,\n  local: Network.LOCAL,\n  custom: Network.CUSTOM,\n};\n"],"mappings":"AAOO,IAAMA,EAA8C,CACzD,QAAS,+CACT,QAAS,+CACT,OAAQ,8CACR,UAAW,8CACX,MAAO,qDACP,MAAO,kCACT,EAMaC,EAA2C,CACtD,QAAS,uCACT,QAAS,uCACT,OAAQ,sCACR,UAAW,sCACX,MAAO,6CACP,MAAO,0BACT,EAMaC,EAA6C,CACxD,OAAQ,sCACR,UAAW,sCACX,MAAO,wEACP,MAAO,uBACT,EAMaC,EAA6C,CACxD,QAAS,sDACT,QAAS,sDACT,OAAQ,qDACR,UAAW,wDACX,MAAO,qDAEP,MAAO,oDACT,EAMaC,EAA6C,CACxD,QAAS,sDACT,QAAS,sDACT,OAAQ,qDACR,UAAW,wDACX,MAAO,qDAEP,MAAO,oDACT,EAOYC,OACVA,EAAA,QAAU,UACVA,EAAA,QAAU,UACVA,EAAA,OAAS,SACTA,EAAA,UAAY,YACZA,EAAA,MAAQ,QACRA,EAAA,MAAQ,QACRA,EAAA,OAAS,SAPCA,OAAA,IAcCC,EAA2C,CACtD,QAAS,EACT,QAAS,EACT,MAAO,CACT,EAMaC,EAAgD,CAC3D,QAAS,UACT,QAAS,UACT,OAAQ,SACR,UAAW,YACX,MAAO,QACP,MAAO,QACP,OAAQ,QACV","names":["NetworkToIndexerAPI","NetworkToNodeAPI","NetworkToFaucetAPI","NetworkToPepperAPI","NetworkToProverAPI","Network","NetworkToChainId","NetworkToNetworkName"]}

package/dist/esm/chunk-Q5ESW36C.mjs

@@ -1,2 +0,0 @@
-var u=(o=>(o.JSON="application/json",o.BCS="application/x-bcs",o.BCS_SIGNED_TRANSACTION="application/x.aptos.signed_transaction+bcs",o.BCS_VIEW_FUNCTION="application/x.aptos.view_function+bcs",o))(u||{}),a=(e=>(e[e.Bool=0]="Bool",e[e.U8=1]="U8",e[e.U64=2]="U64",e[e.U128=3]="U128",e[e.Address=4]="Address",e[e.Signer=5]="Signer",e[e.Vector=6]="Vector",e[e.Struct=7]="Struct",e[e.U16=8]="U16",e[e.U32=9]="U32",e[e.U256=10]="U256",e[e.I8=11]="I8",e[e.I16=12]="I16",e[e.I32=13]="I32",e[e.I64=14]="I64",e[e.I128=15]="I128",e[e.I256=16]="I256",e[e.Reference=254]="Reference",e[e.Generic=255]="Generic",e))(a||{}),d=(n=>(n[n.U8=0]="U8",n[n.U64=1]="U64",n[n.U128=2]="U128",n[n.Address=3]="Address",n[n.U8Vector=4]="U8Vector",n[n.Bool=5]="Bool",n[n.U16=6]="U16",n[n.U32=7]="U32",n[n.U256=8]="U256",n[n.Serialized=9]="Serialized",n[n.I8=10]="I8",n[n.I16=11]="I16",n[n.I32=12]="I32",n[n.I64=13]="I64",n[n.I128=14]="I128",n[n.I256=15]="I256",n))(d||{}),l=(o=>(o[o.Script=0]="Script",o[o.EntryFunction=2]="EntryFunction",o[o.Multisig=3]="Multisig",o[o.Payload=4]="Payload",o))(l||{}),c=(i=>(i[i.V1=0]="V1",i))(c||{}),_=(p=>(p[p.Script=0]="Script",p[p.EntryFunction=1]="EntryFunction",p[p.Empty=2]="Empty",p))(_||{}),x=(i=>(i[i.V1=0]="V1",i))(x||{}),h=(g=>(g[g.MultiAgentTransaction=0]="MultiAgentTransaction",g[g.FeePayerTransaction=1]="FeePayerTransaction",g))(h||{}),v=(t=>(t[t.Ed25519=0]="Ed25519",t[t.MultiEd25519=1]="MultiEd25519",t[t.MultiAgent=2]="MultiAgent",t[t.FeePayer=3]="FeePayer",t[t.SingleSender=4]="SingleSender",t))(v||{}),M=(r=>(r[r.Ed25519=0]="Ed25519",r[r.MultiEd25519=1]="MultiEd25519",r[r.SingleKey=2]="SingleKey",r[r.MultiKey=3]="MultiKey",r[r.NoAccountAuthenticator=4]="NoAccountAuthenticator",r[r.Abstraction=5]="Abstraction",r))(M||{}),b=(p=>(p.Ed25519="ed25519",p.Secp256k1="secp256k1",p.Secp256r1="secp256r1",p))(b||{}),m=(r=>(r[r.Ed25519=0]="Ed25519",r[r.Secp256k1=1]="Secp256k1",r[r.Secp256r1=2]="Secp256r1",r[r.Keyless=3]="Keyless",r[r.FederatedKeyless=4]="FederatedKeyless",r[r.SlhDsaSha2_128s=5]="SlhDsaSha2_128s",r))(m||{});function G(s){switch(s){case 0:return"ed25519";case 1:return"secp256k1";case 2:return"secp256r1";case 3:return"keyless";case 4:return"federated_keyless";case 5:return"slh_dsa_sha2_128s";default:throw new Error("Unknown public key variant")}}var R=(t=>(t[t.Ed25519=0]="Ed25519",t[t.Secp256k1=1]="Secp256k1",t[t.WebAuthn=2]="WebAuthn",t[t.Keyless=3]="Keyless",t[t.SlhDsaSha2_128s=4]="SlhDsaSha2_128s",t))(R||{}),S=(i=>(i[i.Ed25519=0]="Ed25519",i))(S||{}),k=(i=>(i[i.Ed25519=0]="Ed25519",i))(k||{}),f=(i=>(i[i.ZkProof=0]="ZkProof",i))(f||{}),C=(i=>(i[i.Groth16=0]="Groth16",i))(C||{}),I=(y=>(y.Pending="pending_transaction",y.User="user_transaction",y.Genesis="genesis_transaction",y.BlockMetadata="block_metadata_transaction",y.StateCheckpoint="state_checkpoint_transaction",y.Validator="validator_transaction",y.BlockEpilogue="block_epilogue_transaction",y))(I||{});function O(s){return s.type==="pending_transaction"}function N(s){return s.type==="user_transaction"}function P(s){return s.type==="genesis_transaction"}function D(s){return s.type==="block_metadata_transaction"}function A(s){return s.type==="state_checkpoint_transaction"}function q(s){return s.type==="validator_transaction"}function w(s){return s.type==="block_epilogue_transaction"}function H(s){return"signature"in s&&s.type==="ed25519_signature"}function j(s){return"signature"in s&&s.signature==="secp256k1_ecdsa_signature"}function L(s){return s.type==="multi_agent_signature"}function K(s){return s.type==="fee_payer_signature"}function $(s){return s.type==="multi_ed25519_signature"}function z(s){return s.type==="single_sender"}var E=(p=>(p.PRIVATE="private",p.PUBLIC="public",p.FRIEND="friend",p))(E||{}),T=(o=>(o.STORE="store",o.DROP="drop",o.KEY="key",o.COPY="copy",o))(T||{}),U=(g=>(g.VALIDATOR="validator",g.FULL_NODE="full_node",g))(U||{}),W=(o=>(o[o.Ed25519=0]="Ed25519",o[o.MultiEd25519=1]="MultiEd25519",o[o.SingleKey=2]="SingleKey",o[o.MultiKey=3]="MultiKey",o))(W||{}),F=(g=>(g[g.Ed25519=0]="Ed25519",g[g.Secp256k1Ecdsa=2]="Secp256k1Ecdsa",g))(F||{}),B=(t=>(t[t.DeriveAuid=251]="DeriveAuid",t[t.DeriveObjectAddressFromObject=252]="DeriveObjectAddressFromObject",t[t.DeriveObjectAddressFromGuid=253]="DeriveObjectAddressFromGuid",t[t.DeriveObjectAddressFromSeed=254]="DeriveObjectAddressFromSeed",t[t.DeriveResourceAccountAddress=255]="DeriveResourceAccountAddress",t))(B||{});export{u as a,a as b,d as c,l as d,c as e,_ as f,x as g,h,v as i,M as j,b as k,m as l,G as m,R as n,S as o,k as p,f as q,C as r,I as s,O as t,N as u,P as v,D as w,A as x,q as y,w as z,H as A,j as B,L as C,K as D,$ as E,z as F,E as G,T as H,U as I,W as J,F as K,B as L};
-//# sourceMappingURL=chunk-Q5ESW36C.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/types/types.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { AptosConfig } from \"../api\";\nimport { InputSubmitTransactionData } from \"../transactions\";\nimport { Network } from \"../utils/apiEndpoints\";\nimport { OrderBy, TokenStandard } from \"./indexer\";\n\n/**\n * Different MIME types used for data interchange in transactions and responses.\n */\nexport enum MimeType {\n  /**\n   * JSON representation, used for transaction submission and accept type JSON output\n   */\n  JSON = \"application/json\",\n  /**\n   * BCS representation, used for accept type BCS output\n   */\n  BCS = \"application/x-bcs\",\n  /**\n   * BCS representation, used for transaction submission in BCS input\n   */\n  BCS_SIGNED_TRANSACTION = \"application/x.aptos.signed_transaction+bcs\",\n  BCS_VIEW_FUNCTION = \"application/x.aptos.view_function+bcs\",\n}\n\n/**\n * Hexadecimal data input for functions, supporting both string and Uint8Array formats.\n */\nexport type HexInput = string | Uint8Array;\n\n/**\n * Variants of type tags used in the system, encompassing various data types and structures.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/language_storage.rs#L27}\n */\nexport enum TypeTagVariants {\n  Bool = 0,\n  U8 = 1,\n  U64 = 2,\n  U128 = 3,\n  Address = 4,\n  Signer = 5,\n  Vector = 6,\n  Struct = 7,\n  U16 = 8,\n  U32 = 9,\n  U256 = 10,\n  I8 = 11,\n  I16 = 12,\n  I32 = 13,\n  I64 = 14,\n  I128 = 15,\n  I256 = 16,\n  Reference = 254, // This is specifically a placeholder and does not represent a real type\n  Generic = 255, // This is specifically a placeholder and does not represent a real type\n}\n\n/**\n * Variants of script transaction arguments used in Rust, encompassing various data types for transaction processing.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/transaction_argument.rs#L11}\n */\nexport enum ScriptTransactionArgumentVariants {\n  U8 = 0,\n  U64 = 1,\n  U128 = 2,\n  Address = 3,\n  U8Vector = 4,\n  Bool = 5,\n  U16 = 6,\n  U32 = 7,\n  U256 = 8,\n  Serialized = 9,\n  // NOTE: Added in bytecode version v9, do not reorder!\n  I8 = 10,\n  I16 = 11,\n  I32 = 12,\n  I64 = 13,\n  I128 = 14,\n  I256 = 15,\n}\n\n/**\n * The payload for various transaction types in the system.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L478}\n */\nexport enum TransactionPayloadVariants {\n  Script = 0,\n  EntryFunction = 2,\n  Multisig = 3,\n  Payload = 4,\n}\n\n/**\n * The inner payload type to support orderless transactions and all future transaction types.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L478}\n */\nexport enum TransactionInnerPayloadVariants {\n  V1 = 0,\n}\n\n/**\n * Executable types for transactions, which can be either a script or an entry function.\n *\n * Empty is reserved for Multisig voting transactions, which do not have an executable payload.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L685}\n */\nexport enum TransactionExecutableVariants {\n  Script = 0,\n  EntryFunction = 1,\n  Empty = 2,\n}\n\n/**\n * Variants of transaction extra configurations, which can include additional settings or parameters.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L737}\n */\nexport enum TransactionExtraConfigVariants {\n  V1 = 0,\n}\n\n/**\n * Variants of transactions used in the system.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L440}\n */\nexport enum TransactionVariants {\n  MultiAgentTransaction = 0,\n  FeePayerTransaction = 1,\n}\n\n/**\n * Variants of transaction authenticators used in the system.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L44}\n */\nexport enum TransactionAuthenticatorVariant {\n  Ed25519 = 0,\n  MultiEd25519 = 1,\n  MultiAgent = 2,\n  FeePayer = 3,\n  SingleSender = 4,\n}\n\n/**\n * Variants of account authenticators used in transactions.\n * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L414}\n */\nexport enum AccountAuthenticatorVariant {\n  Ed25519 = 0,\n  MultiEd25519 = 1,\n  SingleKey = 2,\n  MultiKey = 3,\n  NoAccountAuthenticator = 4,\n  Abstraction = 5,\n}\n\n/**\n * Variants of private keys that can comply with the AIP-80 standard.\n * {@link https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md}\n */\nexport enum PrivateKeyVariants {\n  Ed25519 = \"ed25519\",\n  Secp256k1 = \"secp256k1\",\n  Secp256r1 = \"secp256r1\",\n}\n\n/**\n * Variants of public keys used in cryptographic operations.\n */\nexport enum AnyPublicKeyVariant {\n  Ed25519 = 0,\n  Secp256k1 = 1,\n  Secp256r1 = 2,\n  Keyless = 3,\n  FederatedKeyless = 4,\n  /**\n   * Post-quantum signature scheme (SLH-DSA-SHA2-128s).\n   * Note: Full implementation not yet available in this SDK.\n   */\n  SlhDsaSha2_128s = 5,\n}\n\nexport function anyPublicKeyVariantToString(variant: AnyPublicKeyVariant): string {\n  switch (variant) {\n    case AnyPublicKeyVariant.Ed25519:\n      return \"ed25519\";\n    case AnyPublicKeyVariant.Secp256k1:\n      return \"secp256k1\";\n    case AnyPublicKeyVariant.Secp256r1:\n      return \"secp256r1\";\n    case AnyPublicKeyVariant.Keyless:\n      return \"keyless\";\n    case AnyPublicKeyVariant.FederatedKeyless:\n      return \"federated_keyless\";\n    case AnyPublicKeyVariant.SlhDsaSha2_128s:\n      return \"slh_dsa_sha2_128s\";\n    default:\n      throw new Error(\"Unknown public key variant\");\n  }\n}\n\n/**\n * Variants of signature types used for cryptographic operations.\n */\nexport enum AnySignatureVariant {\n  Ed25519 = 0,\n  Secp256k1 = 1,\n  WebAuthn = 2,\n  Keyless = 3,\n  /**\n   * Post-quantum signature scheme (SLH-DSA-SHA2-128s).\n   * Note: Full implementation not yet available in this SDK.\n   */\n  SlhDsaSha2_128s = 4,\n}\n\n/**\n * Variants of ephemeral public keys used in cryptographic operations.\n */\nexport enum EphemeralPublicKeyVariant {\n  Ed25519 = 0,\n}\n\n/**\n * Variants of ephemeral signatures used for secure communication.\n */\nexport enum EphemeralSignatureVariant {\n  Ed25519 = 0,\n}\n\n/**\n * Variants of ephemeral certificates used in secure transactions.\n */\nexport enum EphemeralCertificateVariant {\n  ZkProof = 0,\n}\n\n/**\n * Variants of zero-knowledge proofs used in cryptographic operations.\n */\nexport enum ZkpVariant {\n  Groth16 = 0,\n}\n\n/**\n * BCS types\n */\nexport type Uint8 = number;\n\n/**\n * A 16-bit unsigned integer.\n */\nexport type Uint16 = number;\n\n/**\n * A 32-bit unsigned integer.\n */\nexport type Uint32 = number;\n\n/**\n * A 64-bit unsigned integer value.\n */\nexport type Uint64 = bigint;\n\n/**\n * A 128-bit unsigned integer used for precise arithmetic operations.\n */\nexport type Uint128 = bigint;\n\n/**\n * A 256-bit unsigned integer used for precise numerical calculations.\n */\nexport type Uint256 = bigint;\n\n/**\n * A signed 8-bit integer.\n */\nexport type Int8 = number;\n\n/**\n * A signed 16-bit integer.\n */\nexport type Int16 = number;\n\n/**\n * A signed 32-bit integer.\n */\nexport type Int32 = number;\n\n/**\n * A signed 64-bit integer.\n */\nexport type Int64 = bigint;\n\n/**\n * A signed 128-bit integer.\n */\nexport type Int128 = bigint;\n\n/**\n * A signed 256-bit integer.\n */\nexport type Int256 = bigint;\n\n/**\n * A number or a bigint value.\n */\nexport type AnyNumber = number | bigint;\n\n/**\n * Configuration options for initializing the SDK, allowing customization of its behavior and interaction with the Aptos network.\n */\nexport type AptosSettings = {\n  readonly network?: Network;\n\n  readonly fullnode?: string;\n\n  readonly faucet?: string;\n\n  readonly indexer?: string;\n\n  readonly pepper?: string;\n\n  readonly prover?: string;\n\n  readonly clientConfig?: ClientConfig;\n\n  readonly client?: Client;\n\n  readonly fullnodeConfig?: FullNodeConfig;\n\n  readonly indexerConfig?: IndexerConfig;\n\n  readonly faucetConfig?: FaucetConfig;\n\n  readonly transactionGenerationConfig?: TransactionGenerationConfig;\n\n  readonly pluginSettings?: PluginSettings;\n};\n\n/**\n * Defines the parameters for paginating query results, including the starting position and maximum number of items to return.\n * @param offset Specifies the starting position of the query result. Default is 0.\n * @param limit Specifies the maximum number of items to return. Default is 25.\n */\nexport interface PaginationArgs {\n  offset?: AnyNumber;\n  limit?: number;\n}\n\n/**\n * Defines the parameters for paginating query results, including the starting position and maximum number of items to return.\n * @param cursor Specifies the starting position of the query result. Default is at the beginning if undefined.  This is not a number and must come from the API.\n * @param limit Specifies the maximum number of items to return. Default is 25.\n */\nexport interface CursorPaginationArgs {\n  cursor?: string;\n  limit?: number;\n}\n\n/**\n * Represents the arguments for specifying a token standard.\n *\n * @param tokenStandard - Optional standard of the token.\n */\nexport interface TokenStandardArg {\n  tokenStandard?: TokenStandard;\n}\n\nexport interface OrderByArg<T extends {}> {\n  orderBy?: OrderBy<T>;\n}\n\nexport interface WhereArg<T extends {}> {\n  where?: T;\n}\n\n/**\n * QUERY TYPES\n */\n\n/**\n * A configuration object for requests to the server, including API key, extra headers, and cookie handling options.\n *\n * Security Note: Consider implementing client-side rate limiting in your application to prevent\n * accidental API abuse. You can use libraries like 'bottleneck' or 'p-queue' to limit request rates.\n *\n * @example\n * ```typescript\n * import Bottleneck from 'bottleneck';\n *\n * // Create a limiter that allows 10 requests per second\n * const limiter = new Bottleneck({ minTime: 100, maxConcurrent: 5 });\n *\n * // Wrap your Aptos calls with the limiter\n * const result = await limiter.schedule(() => aptos.getAccountInfo({ accountAddress }));\n * ```\n */\nexport type ClientConfig = ClientHeadersType & {\n  WITH_CREDENTIALS?: boolean;\n  API_KEY?: string;\n  http2?: boolean;\n};\n\n/**\n * A configuration object for a Fullnode, allowing for the inclusion of extra headers in requests.\n */\nexport type FullNodeConfig = ClientHeadersType;\n\n/**\n * An Indexer configuration object for sending requests with additional headers.\n */\nexport type IndexerConfig = ClientHeadersType;\n\n/**\n * A configuration object for a faucet, including optional authentication and headers for requests.\n */\nexport type FaucetConfig = ClientHeadersType & {\n  AUTH_TOKEN?: string;\n};\n\n/**\n * A configuration object for default parameters for transaction generation.\n */\nexport type TransactionGenerationConfig = {\n  defaultMaxGasAmount?: number;\n  defaultTxnExpirySecFromNow?: number;\n};\n\n/**\n * General type definition for client headers.\n */\nexport type ClientHeadersType = {\n  HEADERS?: Record<string, string | number | boolean>;\n};\n\n/**\n * Config for plugins. This can be used to override certain client behavior.\n */\nexport type PluginConfig = {\n  /**\n   * If given, this will be used for submitting transactions instead of the default\n   * implementation (which submits transactions directly via a node).\n   */\n  TRANSACTION_SUBMITTER?: TransactionSubmitter;\n\n  /**\n   * If true, we won't use the TRANSACTION_SUBMITTER if set.\n   */\n  IGNORE_TRANSACTION_SUBMITTER?: boolean;\n};\n\nexport type PluginSettings = Omit<PluginConfig, \"IGNORE_TRANSACTION_SUBMITTER\">;\n\n/**\n * You can implement this interface and set it in {@link PluginSettings} when building a\n * client to override the default transaction submission behavior. This is useful if\n * you'd like to submit transactions via a gas station for example.\n *\n * @example\n * ```typescript\n * class MyGasStationClient implements TransactionSubmitter {\n *   async submitTransaction(\n *     args: { aptosConfig: AptosConfig } & InputSubmitTransactionData,\n *   ): Promise<PendingTransactionResponse> {\n *     // TODO: Implement the logic to submit the transaction to the gas station\n *   }\n * }\n *\n * const network = Network.MAINNET;\n * const myGasStationClient = new MyGasStationClient(network);\n * const config = new AptosConfig({\n *   network,\n *   pluginConfig: {\n *     transactionSubmitter: myGasStationClient,\n *   },\n * });\n * const aptos = new Aptos(config);\n * ```\n */\nexport interface TransactionSubmitter {\n  /**\n   * Submit a transaction to the Aptos blockchain or something that will do it on your\n   * behalf, for example a gas station. See the comments of {@link TransactionSubmitter} for more.\n   *\n   * @param args - The arguments for submitting the transaction.\n   * @param args.aptosConfig - The configuration for connecting to the Aptos network.\n   * @param args.transaction - The Aptos transaction data to be submitted.\n   * @param args.senderAuthenticator - The account authenticator of the transaction sender.\n   * @param args.secondarySignerAuthenticators - Optional. Authenticators for additional signers in a multi-signer transaction.\n   * @param args.pluginParams - Optional. Additional parameters for the plugin.\n   * @param args.transactionSubmitter - Optional. An override for the transaction submitter.\n   *\n   * @returns PendingTransactionResponse - The response containing the status of the submitted transaction.\n   * @group Implementation\n   */\n  submitTransaction(\n    args: {\n      aptosConfig: AptosConfig;\n    } & Omit<InputSubmitTransactionData, \"transactionSubmitter\">,\n  ): Promise<PendingTransactionResponse>;\n}\n\n/**\n * Represents a client for making requests to a service provider.\n *\n * @param Req - The type of the request payload.\n * @param Res - The type of the response payload.\n */\nexport interface ClientRequest<Req> {\n  url: string;\n  method: \"GET\" | \"POST\";\n  originMethod?: string;\n  body?: Req;\n  contentType?: string;\n  params?: any;\n  overrides?: ClientConfig & FullNodeConfig & IndexerConfig & FaucetConfig;\n  headers?: Record<string, any>;\n  http2?: boolean;\n}\n\nexport interface ClientResponse<Res> {\n  status: number;\n  statusText: string;\n  data: Res;\n  config?: any;\n  request?: any;\n  response?: any;\n  headers?: any;\n}\n\nexport interface Client {\n  /**\n   * Sends a request to the specified URL with the given options.\n   *\n   * @param requestOptions - The options for the request.\n   * @param requestOptions.url - The URL to send the request to.\n   * @param requestOptions.method - The HTTP method to use, either \"GET\" or \"POST\".\n   * @param requestOptions.path - An optional path to append to the URL.\n   * @param requestOptions.body - The body of the request, applicable for POST requests.\n   * @param requestOptions.contentType - The content type of the request body.\n   * @param requestOptions.acceptType - The expected content type of the response.\n   * @param requestOptions.params - Optional parameters to include in the request.\n   * @param requestOptions.originMethod - An optional method to specify the origin of the request.\n   * @param requestOptions.overrides - Optional configuration overrides for the request.\n   */\n  provider<Req, Res>(requestOptions: ClientRequest<Req>): Promise<ClientResponse<Res>>;\n}\n\n/**\n * The API request type\n *\n * @param url - the url to make the request to, i.e. https://fullnode.devnet.aptoslabs.com/v1\n * @param method - the request method \"GET\" | \"POST\"\n * @param endpoint (optional) - the endpoint to make the request to, i.e. transactions\n * @param body (optional) - the body of the request\n * @param contentType (optional) - the content type to set the `content-type` header to,\n * by default is set to `application/json`\n * @param params (optional) - query params to add to the request\n * @param originMethod (optional) - the local method the request came from\n * @param overrides (optional) - a `ClientConfig` object type to override request data\n */\nexport type AptosRequest = {\n  url: string;\n  method: \"GET\" | \"POST\";\n  path?: string;\n  body?: any;\n  contentType?: string;\n  acceptType?: string;\n  params?: Record<string, string | AnyNumber | boolean | undefined>;\n  originMethod?: string;\n  overrides?: ClientConfig & FullNodeConfig & IndexerConfig & FaucetConfig;\n};\n\n/**\n * The API response type\n *\n * @param status - the response status. i.e. 200\n * @param statusText - the response message\n * @param data the response data\n * @param url the url the request was made to\n * @param headers the response headers\n * @param config (optional) - the request object\n * @param request (optional) - the request object\n */\nexport interface AptosResponse<Req, Res> {\n  status: number;\n  statusText: string;\n  data: Res;\n  url: string;\n  headers: any;\n  config?: any;\n  request?: Req;\n}\n\n/**\n * The ledger version of transactions, defaulting to the latest version if not specified.\n */\nexport type LedgerVersionArg = {\n  ledgerVersion?: AnyNumber;\n};\n\n/**\n * RESPONSE TYPES\n */\n\n/**\n * The output of the estimate gas API, including the deprioritized estimate for the gas unit price.\n */\nexport type GasEstimation = {\n  /**\n   * The deprioritized estimate for the gas unit price\n   */\n  deprioritized_gas_estimate?: number;\n  /**\n   * The current estimate for the gas unit price\n   */\n  gas_estimate: number;\n  /**\n   * The prioritized estimate for the gas unit price\n   */\n  prioritized_gas_estimate?: number;\n};\n\nexport type MoveResource<T = {}> = {\n  type: MoveStructId;\n  data: T;\n};\n\n/**\n * The data associated with an account, including its sequence number.\n */\nexport type AccountData = {\n  sequence_number: string;\n  authentication_key: string;\n};\n\n/**\n * A Move module containing an address.\n */\nexport type MoveModuleBytecode = {\n  bytecode: string;\n  abi?: MoveModule;\n};\n\n/**\n * TRANSACTION TYPES\n */\n\n/**\n * Different types of transaction responses that can occur in the system.\n */\nexport enum TransactionResponseType {\n  Pending = \"pending_transaction\",\n  User = \"user_transaction\",\n  Genesis = \"genesis_transaction\",\n  BlockMetadata = \"block_metadata_transaction\",\n  StateCheckpoint = \"state_checkpoint_transaction\",\n  Validator = \"validator_transaction\",\n  BlockEpilogue = \"block_epilogue_transaction\",\n}\n\n/**\n * The response for a transaction, which can be either pending or committed.\n */\nexport type TransactionResponse = PendingTransactionResponse | CommittedTransactionResponse;\n\n/**\n * The response for a committed transaction, which can be one of several transaction types.\n */\nexport type CommittedTransactionResponse =\n  | UserTransactionResponse\n  | GenesisTransactionResponse\n  | BlockMetadataTransactionResponse\n  | StateCheckpointTransactionResponse\n  | ValidatorTransactionResponse\n  | BlockEpilogueTransactionResponse;\n\n/**\n * Determine if the given transaction response is currently pending.\n *\n * @param response - The transaction response to evaluate.\n * @returns A boolean indicating whether the transaction is pending.\n */\nexport function isPendingTransactionResponse(response: TransactionResponse): response is PendingTransactionResponse {\n  return response.type === TransactionResponseType.Pending;\n}\n\n/**\n * Determines if the given transaction response is a user transaction.\n *\n * @param response - The transaction response to evaluate.\n * @returns A boolean indicating whether the transaction is of type User.\n */\nexport function isUserTransactionResponse(response: TransactionResponse): response is UserTransactionResponse {\n  return response.type === TransactionResponseType.User;\n}\n\n/**\n * Determines if the given transaction response is a Genesis transaction.\n *\n * @param response - The transaction response to evaluate.\n * @returns A boolean indicating whether the transaction is a Genesis transaction.\n */\nexport function isGenesisTransactionResponse(response: TransactionResponse): response is GenesisTransactionResponse {\n  return response.type === TransactionResponseType.Genesis;\n}\n\n/**\n * Determine if the given transaction response is of type BlockMetadata.\n *\n * @param response - The transaction response to evaluate.\n * @returns A boolean indicating whether the response is a BlockMetadata transaction.\n */\nexport function isBlockMetadataTransactionResponse(\n  response: TransactionResponse,\n): response is BlockMetadataTransactionResponse {\n  return response.type === TransactionResponseType.BlockMetadata;\n}\n\n/**\n * Determines if the provided transaction response is a state checkpoint transaction.\n *\n * @param response - The transaction response to evaluate.\n * @returns A boolean indicating whether the transaction response is of type StateCheckpoint.\n */\nexport function isStateCheckpointTransactionResponse(\n  response: TransactionResponse,\n): response is StateCheckpointTransactionResponse {\n  return response.type === TransactionResponseType.StateCheckpoint;\n}\n\n/**\n * Determine if the given transaction response is of type Validator.\n *\n * @param response - The transaction response to evaluate.\n * @returns A boolean indicating whether the transaction response is a Validator type.\n */\nexport function isValidatorTransactionResponse(\n  response: TransactionResponse,\n): response is ValidatorTransactionResponse {\n  return response.type === TransactionResponseType.Validator;\n}\n\n/**\n * Determines if the given transaction response is of the type Block Epilogue.\n *\n * @param response - The transaction response to evaluate.\n * @returns A boolean indicating whether the response is a Block Epilogue transaction.\n */\nexport function isBlockEpilogueTransactionResponse(\n  response: TransactionResponse,\n): response is BlockEpilogueTransactionResponse {\n  return response.type === TransactionResponseType.BlockEpilogue;\n}\n\n/**\n * The response for a pending transaction, indicating that the transaction is still being processed.\n */\nexport type PendingTransactionResponse = {\n  type: TransactionResponseType.Pending;\n  hash: string;\n  sender: string;\n  sequence_number: string;\n  max_gas_amount: string;\n  gas_unit_price: string;\n  expiration_timestamp_secs: string;\n  payload: TransactionPayloadResponse;\n  signature?: TransactionSignature;\n};\n\n/**\n * The response structure for a user transaction.\n */\nexport type UserTransactionResponse = {\n  type: TransactionResponseType.User;\n  version: string;\n  hash: string;\n  state_change_hash: string;\n  event_root_hash: string;\n  state_checkpoint_hash: string | null;\n  gas_used: string;\n  /**\n   * Whether the transaction was successful\n   */\n  success: boolean;\n  /**\n   * The VM status of the transaction, can tell useful information in a failure\n   */\n  vm_status: string;\n  accumulator_root_hash: string;\n  /**\n   * Final state of resources changed by the transaction\n   */\n  changes: Array<WriteSetChange>;\n  sender: string;\n  sequence_number: string;\n  replay_protection_nonce: string;\n  max_gas_amount: string;\n  gas_unit_price: string;\n  expiration_timestamp_secs: string;\n  payload: TransactionPayloadResponse;\n  signature?: TransactionSignature;\n  /**\n   * Events generated by the transaction\n   */\n  events: Array<Event>;\n  timestamp: string;\n};\n\n/**\n * The response for a genesis transaction, indicating the type of transaction.\n */\nexport type GenesisTransactionResponse = {\n  type: TransactionResponseType.Genesis;\n  version: string;\n  hash: string;\n  state_change_hash: string;\n  event_root_hash: string;\n  state_checkpoint_hash?: string;\n  gas_used: string;\n  /**\n   * Whether the transaction was successful\n   */\n  success: boolean;\n  /**\n   * The VM status of the transaction, can tell useful information in a failure\n   */\n  vm_status: string;\n  accumulator_root_hash: string;\n  /**\n   * Final state of resources changed by the transaction\n   */\n  changes: Array<WriteSetChange>;\n  payload: GenesisPayload;\n  /**\n   * Events emitted during genesis\n   */\n  events: Array<Event>;\n};\n\n/**\n * The structure representing a blockchain block with its height.\n */\nexport type BlockMetadataTransactionResponse = {\n  type: TransactionResponseType.BlockMetadata;\n  version: string;\n  hash: string;\n  state_change_hash: string;\n  event_root_hash: string;\n  state_checkpoint_hash: string | null;\n  gas_used: string;\n  /**\n   * Whether the transaction was successful\n   */\n  success: boolean;\n  /**\n   * The VM status of the transaction, can tell useful information in a failure\n   */\n  vm_status: string;\n  accumulator_root_hash: string;\n  /**\n   * Final state of resources changed by the transaction\n   */\n  changes: Array<WriteSetChange>;\n  id: string;\n  epoch: string;\n  round: string;\n  /**\n   * The events emitted at the block creation\n   */\n  events: Array<Event>;\n  /**\n   * Previous block votes\n   */\n  previous_block_votes_bitvec: Array<number>;\n  proposer: string;\n  /**\n   * The indices of the proposers who failed to propose\n   */\n  failed_proposer_indices: Array<number>;\n  timestamp: string;\n};\n\n/**\n * The response for a state checkpoint transaction, indicating the type of transaction.\n */\nexport type StateCheckpointTransactionResponse = {\n  type: TransactionResponseType.StateCheckpoint;\n  version: string;\n  hash: string;\n  state_change_hash: string;\n  event_root_hash: string;\n  state_checkpoint_hash: string | null;\n  gas_used: string;\n  /**\n   * Whether the transaction was successful\n   */\n  success: boolean;\n  /**\n   * The VM status of the transaction, can tell useful information in a failure\n   */\n  vm_status: string;\n  accumulator_root_hash: string;\n  /**\n   * Final state of resources changed by the transaction\n   */\n  changes: Array<WriteSetChange>;\n  timestamp: string;\n};\n\n/**\n * The response for a validator transaction, indicating the type of transaction.\n */\nexport type ValidatorTransactionResponse = {\n  type: TransactionResponseType.Validator;\n  version: string;\n  hash: string;\n  state_change_hash: string;\n  event_root_hash: string;\n  state_checkpoint_hash: string | null;\n  gas_used: string;\n  /**\n   * Whether the transaction was successful\n   */\n  success: boolean;\n  /**\n   * The VM status of the transaction, can tell useful information in a failure\n   */\n  vm_status: string;\n  accumulator_root_hash: string;\n  /**\n   * Final state of resources changed by the transaction\n   */\n  changes: Array<WriteSetChange>;\n  /**\n   * The events emitted by the validator transaction\n   */\n  events: Array<Event>;\n  timestamp: string;\n};\n\n/**\n * Describes the gas state of the block, indicating whether the block gas limit has been reached.\n */\nexport type BlockEndInfo = {\n  block_gas_limit_reached: boolean;\n  block_output_limit_reached: boolean;\n  block_effective_block_gas_units: number;\n  block_approx_output_size: number;\n};\n\n/**\n * A transaction executed at the end of a block that tracks data from the entire block.\n */\nexport type BlockEpilogueTransactionResponse = {\n  type: TransactionResponseType.BlockEpilogue;\n  version: string;\n  hash: string;\n  state_change_hash: string;\n  event_root_hash: string;\n  state_checkpoint_hash: string | null;\n  gas_used: string;\n  /**\n   * Whether the transaction was successful\n   */\n  success: boolean;\n  /**\n   * The VM status of the transaction, can tell useful information in a failure\n   */\n  vm_status: string;\n  accumulator_root_hash: string;\n  /**\n   * Final state of resources changed by the transaction\n   */\n  changes: Array<WriteSetChange>;\n  timestamp: string;\n  block_end_info: BlockEndInfo | null;\n};\n\n/**\n * WRITESET CHANGE TYPES\n */\n\n/**\n * A union type that encompasses both script and direct write sets for data operations.\n */\nexport type WriteSetChange =\n  | WriteSetChangeDeleteModule\n  | WriteSetChangeDeleteResource\n  | WriteSetChangeDeleteTableItem\n  | WriteSetChangeWriteModule\n  | WriteSetChangeWriteResource\n  | WriteSetChangeWriteTableItem;\n\n/**\n * The structure for a module deletion change in a write set.\n */\nexport type WriteSetChangeDeleteModule = {\n  type: string;\n  address: string;\n  /**\n   * State key hash\n   */\n  state_key_hash: string;\n  module: MoveModuleId;\n};\n\n/**\n * The payload for a resource deletion in a write set change.\n */\nexport type WriteSetChangeDeleteResource = {\n  type: string;\n  address: string;\n  state_key_hash: string;\n  resource: string;\n};\n\n/**\n * The payload for a write set change that deletes a table item.\n */\nexport type WriteSetChangeDeleteTableItem = {\n  type: string;\n  state_key_hash: string;\n  handle: string;\n  key: string;\n  data?: DeletedTableData;\n};\n\n/**\n * The structure for a write module change in a write set.\n */\nexport type WriteSetChangeWriteModule = {\n  type: string;\n  address: string;\n  state_key_hash: string;\n  data: MoveModuleBytecode;\n};\n\n/**\n * The resource associated with a write set change, identified by its type.\n */\nexport type WriteSetChangeWriteResource = {\n  type: string;\n  address: string;\n  state_key_hash: string;\n  data: MoveResource;\n};\n\n/**\n * The structure for a write operation on a table in a write set change.\n */\nexport type WriteSetChangeWriteTableItem = {\n  type: string;\n  state_key_hash: string;\n  handle: string;\n  key: string;\n  value: string;\n  data?: DecodedTableData;\n};\n\n/**\n * The decoded data for a table, including its key in JSON format.\n */\nexport type DecodedTableData = {\n  /**\n   * Key of table in JSON\n   */\n  key: any;\n  /**\n   * Type of key\n   */\n  key_type: string;\n  /**\n   * Value of table in JSON\n   */\n  value: any;\n  /**\n   * Type of value\n   */\n  value_type: string;\n};\n\n/**\n * Data for a deleted table entry.\n */\nexport type DeletedTableData = {\n  /**\n   * Deleted key\n   */\n  key: any;\n  /**\n   * Deleted key type\n   */\n  key_type: string;\n};\n\n/**\n * The payload for a transaction response, which can be an entry function, script, or multisig payload.\n */\nexport type TransactionPayloadResponse = EntryFunctionPayloadResponse | ScriptPayloadResponse | MultisigPayloadResponse;\n\n/**\n * The response payload for an entry function, containing the type of the entry.\n */\nexport type EntryFunctionPayloadResponse = {\n  type: string;\n  function: MoveFunctionId;\n  /**\n   * Type arguments of the function\n   */\n  type_arguments: Array<string>;\n  /**\n   * Arguments of the function\n   */\n  arguments: Array<any>;\n};\n\n/**\n * The payload for a script response, containing the type of the script.\n */\nexport type ScriptPayloadResponse = {\n  type: string;\n  code: MoveScriptBytecode;\n  /**\n   * Type arguments of the function\n   */\n  type_arguments: Array<string>;\n  /**\n   * Arguments of the function\n   */\n  arguments: Array<any>;\n};\n\n/**\n * The response payload for a multisig transaction, containing the type of the transaction.\n */\nexport type MultisigPayloadResponse = {\n  type: string;\n  multisig_address: string;\n  transaction_payload?: EntryFunctionPayloadResponse;\n};\n\n/**\n * The payload for the genesis block containing the type of the payload.\n */\nexport type GenesisPayload = {\n  type: string;\n  write_set: WriteSet;\n};\n\n/**\n * The bytecode for a Move script.\n */\nexport type MoveScriptBytecode = {\n  bytecode: string;\n  abi?: MoveFunction;\n};\n\n/**\n * JSON representations of transaction signatures returned from the node API.\n */\nexport type TransactionSignature =\n  | TransactionEd25519Signature\n  | TransactionSecp256k1Signature\n  | TransactionMultiEd25519Signature\n  | TransactionMultiAgentSignature\n  | TransactionFeePayerSignature\n  | TransactionSingleSenderSignature;\n\n/**\n * Determine if the provided signature is an Ed25519 signature.\n * This function checks for the presence of the \"signature\" property\n * and verifies that its value is \"ed25519_signature\".\n *\n * @param signature - The transaction signature to be checked.\n * @returns A boolean indicating whether the signature is an Ed25519 signature.\n */\nexport function isEd25519Signature(signature: TransactionSignature): signature is TransactionEd25519Signature {\n  return \"signature\" in signature && signature.type === \"ed25519_signature\";\n}\n\n/**\n * Determine if the provided signature is a valid secp256k1 ECDSA signature.\n *\n * @param signature - The transaction signature to validate.\n * @returns A boolean indicating whether the signature is a secp256k1 ECDSA signature.\n */\nexport function isSecp256k1Signature(signature: TransactionSignature): signature is TransactionFeePayerSignature {\n  return \"signature\" in signature && signature.signature === \"secp256k1_ecdsa_signature\";\n}\n\n/**\n * Determine if the provided transaction signature is a multi-agent signature.\n *\n * @param signature - The transaction signature to evaluate.\n * @returns A boolean indicating whether the signature is a multi-agent signature.\n */\nexport function isMultiAgentSignature(signature: TransactionSignature): signature is TransactionMultiAgentSignature {\n  return signature.type === \"multi_agent_signature\";\n}\n\n/**\n * Determine if the provided signature is a fee payer signature.\n *\n * @param signature - The transaction signature to evaluate.\n * @returns A boolean indicating whether the signature is a fee payer signature.\n */\nexport function isFeePayerSignature(signature: TransactionSignature): signature is TransactionFeePayerSignature {\n  return signature.type === \"fee_payer_signature\";\n}\n\n/**\n * Determine if the provided signature is of type \"multi_ed25519_signature\".\n *\n * @param signature - The transaction signature to check.\n * @returns A boolean indicating whether the signature is a multi-ed25519 signature.\n */\nexport function isMultiEd25519Signature(\n  signature: TransactionSignature,\n): signature is TransactionMultiEd25519Signature {\n  return signature.type === \"multi_ed25519_signature\";\n}\n\n/**\n * Determine if the provided signature is of type \"single_sender\".\n *\n * @param signature - The transaction signature to check.\n * @returns A boolean indicating whether the signature is a single-sender signature.\n */\nexport function isSingleSenderSignature(\n  signature: TransactionSignature,\n): signature is TransactionSingleSenderSignature {\n  return signature.type === \"single_sender\";\n}\n\n/**\n * The signature for a transaction using the Ed25519 algorithm.\n */\nexport type TransactionEd25519Signature = {\n  type: string;\n  public_key: string;\n  signature: \"ed25519_signature\";\n};\n\n/**\n * The structure for a Secp256k1 signature in a transaction.\n */\nexport type TransactionSecp256k1Signature = {\n  type: string;\n  public_key: string;\n  signature: \"secp256k1_ecdsa_signature\";\n};\n\n/**\n * The structure for a multi-signature transaction using Ed25519.\n */\nexport type TransactionSingleSenderSignature = {\n  type: \"single_sender\";\n  public_key: { value: string; type: string };\n  signature: { value: string; type: string };\n};\n\n/**\n * The structure for a multi-signature transaction using Ed25519.\n */\nexport type TransactionMultiEd25519Signature = {\n  type: \"multi_ed25519_signature\";\n  /**\n   * The public keys for the Ed25519 signature\n   */\n  public_keys: Array<string>;\n  /**\n   * Signature associated with the public keys in the same order\n   */\n  signatures: Array<string>;\n  /**\n   * The number of signatures required for a successful transaction\n   */\n  threshold: number;\n  bitmap: string;\n};\n\n/**\n * The structure for a multi-agent signature in a transaction.\n */\nexport type TransactionMultiAgentSignature = {\n  type: \"multi_agent_signature\";\n  sender: AccountSignature;\n  /**\n   * The other involved parties' addresses\n   */\n  secondary_signer_addresses: Array<string>;\n  /**\n   * The associated signatures, in the same order as the secondary addresses\n   */\n  secondary_signers: Array<AccountSignature>;\n};\n\n/**\n * The signature of the fee payer in a transaction.\n */\nexport type TransactionFeePayerSignature = {\n  type: \"fee_payer_signature\";\n  sender: AccountSignature;\n  /**\n   * The other involved parties' addresses\n   */\n  secondary_signer_addresses: Array<string>;\n  /**\n   * The associated signatures, in the same order as the secondary addresses\n   */\n  secondary_signers: Array<AccountSignature>;\n  fee_payer_address: string;\n  fee_payer_signer: AccountSignature;\n};\n\n/**\n * The union of all single account signatures, including Ed25519, Secp256k1, and MultiEd25519 signatures.\n */\nexport type AccountSignature =\n  | TransactionEd25519Signature\n  | TransactionSecp256k1Signature\n  | TransactionMultiEd25519Signature;\n\nexport type WriteSet = ScriptWriteSet | DirectWriteSet;\n\n/**\n * The set of properties for writing scripts, including the type of script.\n */\nexport type ScriptWriteSet = {\n  type: string;\n  execute_as: string;\n  script: ScriptPayloadResponse;\n};\n\n/**\n * The set of direct write operations, identified by a type string.\n */\nexport type DirectWriteSet = {\n  type: string;\n  changes: Array<WriteSetChange>;\n  events: Array<Event>;\n};\n\n/**\n * The structure for an event's unique identifier, including its creation number.\n */\n\n/**\n * The structure for an event, identified by a unique GUID.\n */\nexport type EventGuid = {\n  creation_number: string;\n  account_address: string;\n};\n\nexport type Event = {\n  guid: EventGuid;\n  sequence_number: string;\n  type: string;\n  /**\n   * The JSON representation of the event\n   */\n  data: any;\n};\n\n/**\n * A number representing a Move uint8 type.\n */\nexport type MoveUint8Type = number;\n\n/**\n * A 16-bit unsigned integer used in the Move programming language.\n */\nexport type MoveUint16Type = number;\n\n/**\n * A 32-bit unsigned integer type used in Move programming.\n */\nexport type MoveUint32Type = number;\n\n/**\n * A string representation of a 64-bit unsigned integer used in Move programming.\n */\nexport type MoveUint64Type = string;\n\n/**\n * A string representing a 128-bit unsigned integer in the Move programming language.\n */\nexport type MoveUint128Type = string;\n\n/**\n * A string representation of a 256-bit unsigned integer used in Move programming.\n */\nexport type MoveUint256Type = string;\n\n/**\n * A number representing a Move int8 type.\n */\nexport type MoveInt8Type = number;\n\n/**\n * A 16-bit signed integer used in the Move programming language.\n */\nexport type MoveInt16Type = number;\n\n/**\n * A 32-bit signed integer type used in Move programming.\n */\nexport type MoveInt32Type = number;\n\n/**\n * A string representation of a 64-bit signed integer used in Move programming.\n */\nexport type MoveInt64Type = string;\n\n/**\n * A string representing a 128-bit signed integer in the Move programming language.\n */\nexport type MoveInt128Type = string;\n\n/**\n * A string representation of a 256-bit signed integer used in Move programming.\n */\nexport type MoveInt256Type = string;\n\n/**\n * A string representing a Move address.\n */\nexport type MoveAddressType = string;\n\n/**\n * The type for identifying objects to be moved within the system.\n */\nexport type MoveObjectType = string;\n\n/**\n * The type for move options, which can be a MoveType, null, or undefined.\n */\nexport type MoveOptionType = MoveType | null | undefined;\n\n/**\n * A structure representing a move with a name.\n */\nexport type MoveStructId = `${string}::${string}::${string}`;\n\n/**\n * The move function containing its name. Same as MoveStructId since it reads weird to take a StructId for a Function.\n */\nexport type MoveFunctionId = MoveStructId;\n\n// TODO: Add support for looking up ABI to add proper typing\nexport type MoveStructType = {};\n\n/**\n * A union type that encompasses various data types used in Move, including primitive types, address types, object types, and\n * arrays of MoveType.\n */\nexport type MoveType =\n  | boolean\n  | string\n  | MoveUint8Type\n  | MoveUint16Type\n  | MoveUint32Type\n  | MoveUint64Type\n  | MoveUint128Type\n  | MoveUint256Type\n  | MoveInt8Type\n  | MoveInt16Type\n  | MoveInt32Type\n  | MoveInt64Type\n  | MoveInt128Type\n  | MoveInt256Type\n  | MoveAddressType\n  | MoveObjectType\n  | MoveStructType\n  | Array<MoveType>;\n\n/**\n * Possible Move values acceptable by move functions (entry, view)\n *\n * Map of a Move value to the corresponding TypeScript value\n *\n * `Bool -> boolean`\n *\n * `u8, u16, u32 -> number`\n *\n * `u64, u128, u256 -> string`\n *\n * `i8, i16, i32 -> number`\n *\n * `i64, i128, i256 -> string`\n *\n * `String -> string`\n *\n * `Address -> 0x${string}`\n *\n * `Struct - 0x${string}::${string}::${string}`\n *\n * `Object -> 0x${string}`\n *\n * `Vector -> Array<MoveValue>`\n *\n * `Option -> MoveValue | null | undefined`\n */\nexport type MoveValue =\n  | boolean\n  | string\n  | MoveUint8Type\n  | MoveUint16Type\n  | MoveUint32Type\n  | MoveUint64Type\n  | MoveUint128Type\n  | MoveUint256Type\n  | MoveInt8Type\n  | MoveInt16Type\n  | MoveInt32Type\n  | MoveInt64Type\n  | MoveInt128Type\n  | MoveInt256Type\n  | MoveAddressType\n  | MoveObjectType\n  | MoveStructId\n  | MoveOptionType\n  | Array<MoveValue>;\n\n/**\n * A string representation of a Move module, formatted as `module_name::function_name`.\n * Module names are case-sensitive.\n */\nexport type MoveModuleId = `${string}::${string}`;\n\n/**\n * Specifies the visibility levels for move functions, controlling access permissions.\n */\nexport enum MoveFunctionVisibility {\n  PRIVATE = \"private\",\n  PUBLIC = \"public\",\n  FRIEND = \"friend\",\n}\n\n/**\n * Abilities related to moving items within the system.\n */\nexport enum MoveAbility {\n  STORE = \"store\",\n  DROP = \"drop\",\n  KEY = \"key\",\n  COPY = \"copy\",\n}\n\n/**\n * Move abilities associated with the generic type parameter of a function.\n */\nexport type MoveFunctionGenericTypeParam = {\n  constraints: Array<MoveAbility>;\n};\n\n/**\n * A field in a Move struct, identified by its name.\n */\nexport type MoveStructField = {\n  name: string;\n  type: string;\n};\n\n/**\n * A Move module\n */\nexport type MoveModule = {\n  address: string;\n  name: string;\n  /**\n   * Friends of the module\n   */\n  friends: Array<MoveModuleId>;\n  /**\n   * Public functions of the module\n   */\n  exposed_functions: Array<MoveFunction>;\n  /**\n   * Structs of the module\n   */\n  structs: Array<MoveStruct>;\n};\n\n/**\n * A move struct\n */\nexport type MoveStruct = {\n  name: string;\n  /**\n   * Whether the struct is a native struct of Move\n   */\n  is_native: boolean;\n  /**\n   * Whether the struct is a module event (aka v2 event). This will be false for v1\n   * events because the value is derived from the #[event] attribute on the struct in\n   * the Move source code. This attribute is only relevant for v2 events.\n   */\n  is_event: boolean;\n  /**\n   * True if the struct is an enum (e.g. enum MyEnum { A, B, C }), false if it is a\n   * regular struct (e.g. struct MyStruct { a: u8, b: u8 }).\n   */\n  is_enum: boolean;\n  /**\n   * Abilities associated with the struct\n   */\n  abilities: Array<MoveAbility>;\n  /**\n   * Generic types associated with the struct\n   */\n  generic_type_params: Array<MoveFunctionGenericTypeParam>;\n  /**\n   * Fields associated with the struct\n   */\n  fields: Array<MoveStructField>;\n};\n\n/**\n * Move function\n */\nexport type MoveFunction = {\n  name: string;\n  visibility: MoveFunctionVisibility;\n  /**\n   * Whether the function can be called as an entry function directly in a transaction\n   */\n  is_entry: boolean;\n  /**\n   * Whether the function is a view function or not\n   */\n  is_view: boolean;\n  /**\n   * Generic type params associated with the Move function\n   */\n  generic_type_params: Array<MoveFunctionGenericTypeParam>;\n  /**\n   * Parameters associated with the move function\n   */\n  params: Array<string>;\n  /**\n   * Return type of the function\n   */\n  return: Array<string>;\n};\n\n/**\n * Roles that can be assigned within the system, indicating different levels of access and functionality.\n */\nexport enum RoleType {\n  VALIDATOR = \"validator\",\n  FULL_NODE = \"full_node\",\n}\n\n/**\n * Information about the current blockchain ledger, including its chain ID.\n */\nexport type LedgerInfo = {\n  /**\n   * Chain ID of the current chain\n   */\n  chain_id: number;\n  epoch: string;\n  ledger_version: string;\n  oldest_ledger_version: string;\n  ledger_timestamp: string;\n  node_role: RoleType;\n  oldest_block_height: string;\n  block_height: string;\n  /**\n   * Git hash of the build of the API endpoint.  Can be used to determine the exact\n   * software version used by the API endpoint.\n   */\n  git_hash?: string;\n};\n\n/**\n * A Block type\n */\nexport type Block = {\n  block_height: string;\n  block_hash: string;\n  block_timestamp: string;\n  first_version: string;\n  last_version: string;\n  /**\n   * The transactions in the block in sequential order\n   */\n  transactions?: Array<TransactionResponse>;\n};\n\n// REQUEST TYPES\n\n/**\n * The request payload for the GetTableItem API.\n */\nexport type TableItemRequest = {\n  key_type: MoveValue;\n  value_type: MoveValue;\n  /**\n   * The value of the table item's key\n   */\n  key: any;\n};\n\n/**\n * A list of supported Authentication Key schemes in Aptos, consisting of combinations of signing schemes and derive schemes.\n */\nexport type AuthenticationKeyScheme = SigningScheme | DeriveScheme;\n\n/**\n * Different schemes for signing keys used in cryptographic operations.\n */\nexport enum SigningScheme {\n  /**\n   * For Ed25519PublicKey\n   */\n  Ed25519 = 0,\n  /**\n   * For MultiEd25519PublicKey\n   */\n  MultiEd25519 = 1,\n  /**\n   * For SingleKey ecdsa\n   */\n  SingleKey = 2,\n\n  MultiKey = 3,\n}\n\n/**\n * Specifies the signing schemes available for cryptographic operations.\n */\nexport enum SigningSchemeInput {\n  /**\n   * For Ed25519PublicKey\n   */\n  Ed25519 = 0,\n  /**\n   * For Secp256k1Ecdsa\n   */\n  Secp256k1Ecdsa = 2,\n}\n\n/**\n * Specifies the schemes for deriving account addresses from various data sources.\n */\nexport enum DeriveScheme {\n  /**\n   * Derives an address using an AUID, used for objects\n   */\n  DeriveAuid = 251,\n  /**\n   * Derives an address from another object address\n   */\n  DeriveObjectAddressFromObject = 252,\n  /**\n   * Derives an address from a GUID, used for objects\n   */\n  DeriveObjectAddressFromGuid = 253,\n  /**\n   * Derives an address from seed bytes, used for named objects\n   */\n  DeriveObjectAddressFromSeed = 254,\n  /**\n   * Derives an address from seed bytes, used for resource accounts\n   */\n  DeriveResourceAccountAddress = 255,\n}\n\n/**\n * Options for configuring the behavior of the waitForTransaction() function.\n */\nexport type WaitForTransactionOptions = {\n  timeoutSecs?: number;\n  checkSuccess?: boolean;\n  // Default behavior is to wait for the indexer. Set this to false to disable waiting.\n  waitForIndexer?: boolean;\n};\n\n/**\n * Input type to generate an account using the Ed25519 signing scheme.\n */\nexport type GenerateAccountWithEd25519 = {\n  scheme: SigningSchemeInput.Ed25519;\n  legacy: boolean;\n};\n\n/**\n * Input type to generate an account with a Single Signer using Secp256k1.\n */\nexport type GenerateAccountWithSingleSignerSecp256k1Key = {\n  scheme: SigningSchemeInput.Secp256k1Ecdsa;\n  legacy?: false;\n};\n\nexport type GenerateAccount = GenerateAccountWithEd25519 | GenerateAccountWithSingleSignerSecp256k1Key;\n"],"mappings":"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","names":["MimeType","TypeTagVariants","ScriptTransactionArgumentVariants","TransactionPayloadVariants","TransactionInnerPayloadVariants","TransactionExecutableVariants","TransactionExtraConfigVariants","TransactionVariants","TransactionAuthenticatorVariant","AccountAuthenticatorVariant","PrivateKeyVariants","AnyPublicKeyVariant","anyPublicKeyVariantToString","variant","AnySignatureVariant","EphemeralPublicKeyVariant","EphemeralSignatureVariant","EphemeralCertificateVariant","ZkpVariant","TransactionResponseType","isPendingTransactionResponse","response","isUserTransactionResponse","isGenesisTransactionResponse","isBlockMetadataTransactionResponse","isStateCheckpointTransactionResponse","isValidatorTransactionResponse","isBlockEpilogueTransactionResponse","isEd25519Signature","signature","isSecp256k1Signature","isMultiAgentSignature","isFeePayerSignature","isMultiEd25519Signature","isSingleSenderSignature","MoveFunctionVisibility","MoveAbility","RoleType","SigningScheme","SigningSchemeInput","DeriveScheme"]}

package/dist/esm/chunk-QE5MOGUI.mjs

@@ -1,2 +0,0 @@
-import{c as r}from"./chunk-GJYLYE6R.mjs";import{spawn as c}from"child_process";import l from"tree-kill";import{platform as h}from"os";var e=class{constructor(t){this.MAXIMUM_WAIT_TIME_SEC=75;this.READINESS_ENDPOINT="http://127.0.0.1:8070/";this.showStdout=!0;this.process=null;this.extraArgs=[];this.showStdout=t?.showStdout??!0,this.extraArgs=t?.extraArgs??[]}async stop(){await new Promise((t,o)=>{this.process?.pid&&l(this.process.pid,s=>{s?o(s):t(!0)})})}async run(){await this.checkIfProcessIsUp()||(this.start(),await this.waitUntilProcessIsUp())}start(){let o=["aptos","node","run-localnet","--force-restart","--assume-yes","--with-indexer-api",...this.extraArgs],s=h(),i={env:{...process.env,ENABLE_KEYLESS_DEFAULT:"1"},...s==="win32"&&{shell:!0}};this.process=c("npx",o,i),this.process.stdout?.on("data",a=>{let n=a.toString();this.showStdout&&console.log(n)})}async waitUntilProcessIsUp(){let t=await this.checkIfProcessIsUp(),o=Date.now()/1e3,s=o;for(;!t&&o+this.MAXIMUM_WAIT_TIME_SEC>s;)await r(1e3),t=await this.checkIfProcessIsUp(),s=Date.now()/1e3;if(!t)throw new Error("Process failed to start");return!0}async checkIfProcessIsUp(){try{return(await fetch(this.READINESS_ENDPOINT)).status===200}catch{return!1}}};export{e as a};
-//# sourceMappingURL=chunk-QE5MOGUI.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/cli/localNode.ts"],"sourcesContent":["import { ChildProcessWithoutNullStreams, spawn } from \"node:child_process\";\nimport kill from \"tree-kill\";\nimport { platform } from \"node:os\";\n\nimport { sleep } from \"../utils/helpers\";\n\n/**\n * Represents a local node for running a localnet environment.\n * This class provides methods to start, stop, and check the status of the localnet process.\n * It manages the lifecycle of the node process and ensures that it is operational before executing tests.\n * @group Implementation\n * @category CLI\n */\nexport class LocalNode {\n  readonly MAXIMUM_WAIT_TIME_SEC = 75;\n\n  readonly READINESS_ENDPOINT = \"http://127.0.0.1:8070/\";\n\n  showStdout: boolean = true;\n\n  process: ChildProcessWithoutNullStreams | null = null;\n\n  extraArgs: string[] = [];\n\n  constructor(args?: { showStdout?: boolean; extraArgs?: string[] }) {\n    this.showStdout = args?.showStdout ?? true;\n    this.extraArgs = args?.extraArgs ?? [];\n  }\n\n  /**\n   * Kills the current process and all its descendant processes.\n   *\n   * @returns {Promise<void>} A promise that resolves to true if the process was successfully killed.\n   * @throws {Error} If there is an error while attempting to kill the process.\n   * @group Implementation\n   * @category CLI\n   */\n  async stop(): Promise<void> {\n    await new Promise((resolve, reject) => {\n      if (!this.process?.pid) return;\n\n      /**\n       * Terminates the process associated with the given process ID.\n       *\n       * @param pid - The process ID of the process to be terminated.\n       * @param callback - A function that is called after the termination attempt is complete.\n       * @param callback.err - An error object if the termination failed; otherwise, null.\n       * @param callback.resolve - A boolean indicating whether the termination was successful.\n       * @group Implementation\n       * @category CLI\n       */\n      kill(this.process.pid, (err) => {\n        if (err) {\n          reject(err);\n        } else {\n          resolve(true);\n        }\n      });\n    });\n  }\n\n  /**\n   * Runs a localnet and waits for the process to be up.\n   * If the local node process is already running, it returns without starting the process.\n   *\n   * @returns {Promise<void>} A promise that resolves when the process is up.\n   * @group Implementation\n   * @category CLI\n   */\n  async run(): Promise<void> {\n    const nodeIsUp = await this.checkIfProcessIsUp();\n    if (nodeIsUp) {\n      return;\n    }\n    this.start();\n    await this.waitUntilProcessIsUp();\n  }\n\n  /**\n   * Starts the localnet by running the Aptos node with the specified command-line arguments.\n   *\n   * @returns {void}\n   *\n   * @throws {Error} If there is an issue starting the localnet.\n   * @group Implementation\n   * @category CLI\n   */\n  start(): void {\n    const cliCommand = \"npx\";\n    const cliArgs = [\n      \"aptos\",\n      \"node\",\n      \"run-localnet\",\n      \"--force-restart\",\n      \"--assume-yes\",\n      \"--with-indexer-api\",\n      ...this.extraArgs,\n    ];\n\n    const currentPlatform = platform();\n    const spawnConfig = {\n      env: { ...process.env, ENABLE_KEYLESS_DEFAULT: \"1\" },\n      ...(currentPlatform === \"win32\" && { shell: true }),\n    };\n\n    this.process = spawn(cliCommand, cliArgs, spawnConfig);\n\n    this.process.stdout?.on(\"data\", (data: any) => {\n      const str = data.toString();\n      // Print local node output log\n      if (this.showStdout) {\n        console.log(str);\n      }\n    });\n  }\n\n  /**\n   * Waits for the localnet process to be operational within a specified maximum wait time.\n   * This function continuously checks if the process is up and will throw an error if it fails to start.\n   *\n   * @returns Promise<boolean> - Resolves to true if the process is up, otherwise throws an error.\n   * @group Implementation\n   * @category CLI\n   */\n  async waitUntilProcessIsUp(): Promise<boolean> {\n    let operational = await this.checkIfProcessIsUp();\n    const start = Date.now() / 1000;\n    let last = start;\n\n    while (!operational && start + this.MAXIMUM_WAIT_TIME_SEC > last) {\n      await sleep(1000);\n\n      operational = await this.checkIfProcessIsUp();\n      last = Date.now() / 1000;\n    }\n\n    // If we are here it means something blocks the process to start.\n    // Might worth checking if another process is running on port 8080\n    if (!operational) {\n      throw new Error(\"Process failed to start\");\n    }\n\n    return true;\n  }\n\n  /**\n   * Checks if the localnet is up by querying the readiness endpoint.\n   *\n   * @returns Promise<boolean> - A promise that resolves to true if the localnet is up, otherwise false.\n   * @group Implementation\n   * @category CLI\n   */\n  async checkIfProcessIsUp(): Promise<boolean> {\n    try {\n      // Query readiness endpoint\n      const data = await fetch(this.READINESS_ENDPOINT);\n      if (data.status === 200) {\n        return true;\n      }\n      return false;\n    } catch {\n      return false;\n    }\n  }\n}\n"],"mappings":"yCAAA,OAAyC,SAAAA,MAAa,gBACtD,OAAOC,MAAU,YACjB,OAAS,YAAAC,MAAgB,KAWlB,IAAMC,EAAN,KAAgB,CAWrB,YAAYC,EAAuD,CAVnE,KAAS,sBAAwB,GAEjC,KAAS,mBAAqB,yBAE9B,gBAAsB,GAEtB,aAAiD,KAEjD,eAAsB,CAAC,EAGrB,KAAK,WAAaA,GAAM,YAAc,GACtC,KAAK,UAAYA,GAAM,WAAa,CAAC,CACvC,CAUA,MAAM,MAAsB,CAC1B,MAAM,IAAI,QAAQ,CAACC,EAASC,IAAW,CAChC,KAAK,SAAS,KAYnBC,EAAK,KAAK,QAAQ,IAAMC,GAAQ,CAC1BA,EACFF,EAAOE,CAAG,EAEVH,EAAQ,EAAI,CAEhB,CAAC,CACH,CAAC,CACH,CAUA,MAAM,KAAqB,CACR,MAAM,KAAK,mBAAmB,IAI/C,KAAK,MAAM,EACX,MAAM,KAAK,qBAAqB,EAClC,CAWA,OAAc,CAEZ,IAAMI,EAAU,CACd,QACA,OACA,eACA,kBACA,eACA,qBACA,GAAG,KAAK,SACV,EAEMC,EAAkBC,EAAS,EAC3BC,EAAc,CAClB,IAAK,CAAE,GAAG,QAAQ,IAAK,uBAAwB,GAAI,EACnD,GAAIF,IAAoB,SAAW,CAAE,MAAO,EAAK,CACnD,EAEA,KAAK,QAAUG,EAAM,MAAYJ,EAASG,CAAW,EAErD,KAAK,QAAQ,QAAQ,GAAG,OAASE,GAAc,CAC7C,IAAMC,EAAMD,EAAK,SAAS,EAEtB,KAAK,YACP,QAAQ,IAAIC,CAAG,CAEnB,CAAC,CACH,CAUA,MAAM,sBAAyC,CAC7C,IAAIC,EAAc,MAAM,KAAK,mBAAmB,EAC1CC,EAAQ,KAAK,IAAI,EAAI,IACvBC,EAAOD,EAEX,KAAO,CAACD,GAAeC,EAAQ,KAAK,sBAAwBC,GAC1D,MAAMC,EAAM,GAAI,EAEhBH,EAAc,MAAM,KAAK,mBAAmB,EAC5CE,EAAO,KAAK,IAAI,EAAI,IAKtB,GAAI,CAACF,EACH,MAAM,IAAI,MAAM,yBAAyB,EAG3C,MAAO,EACT,CASA,MAAM,oBAAuC,CAC3C,GAAI,CAGF,OADa,MAAM,MAAM,KAAK,kBAAkB,GACvC,SAAW,GAItB,MAAQ,CACN,MAAO,EACT,CACF,CACF","names":["spawn","kill","platform","LocalNode","args","resolve","reject","kill","err","cliArgs","currentPlatform","platform","spawnConfig","spawn","data","str","operational","start","last","sleep"]}

package/dist/esm/chunk-RB2GC7FW.mjs

@@ -1,2 +0,0 @@
-import{a}from"./chunk-RUKFK3OC.mjs";var e=class extends a{};export{e as a};
-//# sourceMappingURL=chunk-RB2GC7FW.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/proof.ts"],"sourcesContent":["import { Serializable } from \"../../bcs\";\n\n/**\n * An abstract representation of a cryptographic proof associated with specific\n * zero-knowledge proof schemes, such as Groth16 and PLONK.\n * @group Implementation\n * @category Serialization\n */\nexport abstract class Proof extends Serializable {}\n"],"mappings":"oCAQO,IAAeA,EAAf,cAA6BC,CAAa,CAAC","names":["Proof","Serializable"]}

package/dist/esm/chunk-RUKFK3OC.mjs

@@ -1,2 +0,0 @@
-import{m as E}from"./chunk-TAHLOBRG.mjs";import{b as x}from"./chunk-STY74NUA.mjs";import{a as y,b as c,c as l,d as h,e as u,f as U,g as b,h as z,i as g,j as A,k as p,l as _,m as w,n as d,o as N,p as m,q as T,r as M}from"./chunk-X2TPNKLV.mjs";import{a as n}from"./chunk-KDMSOCZY.mjs";var R=class{bcsToBytes(){let e=new s;return this.serialize(e),e.toUint8Array()}bcsToHex(){let e=this.bcsToBytes();return x.fromHexInput(e)}toStringWithoutPrefix(){return this.bcsToHex().toStringWithoutPrefix()}toString(){return`0x${this.toStringWithoutPrefix()}`}};function $(r,e){if(typeof r.serializeAsBytes=="function")r.serializeAsBytes(e);else{let i=e.bcsToBytes();r.serializeBytes(i)}}var V=256,B=[],X=8;function W(){let r=B.pop();return r?(r.reset(),r):new s}function F(r){B.length<X&&B.push(r)}var s=class{constructor(e=64){if(e<=0)throw new Error("Length needs to be greater than 0");this.buffer=new ArrayBuffer(e),this.dataView=new DataView(this.buffer),this.offset=0}ensureBufferWillHandleSize(e){let i=this.offset+e;if(this.buffer.byteLength>=i)return;let t=Math.max(Math.floor(this.buffer.byteLength*1.5),i+V),a=new ArrayBuffer(t);new Uint8Array(a).set(new Uint8Array(this.buffer,0,this.offset)),this.buffer=a,this.dataView=new DataView(this.buffer)}appendToBuffer(e){this.ensureBufferWillHandleSize(e.length),new Uint8Array(this.buffer,this.offset).set(e),this.offset+=e.length}serializeWithFunction(e,i,t){this.ensureBufferWillHandleSize(i),e.apply(this.dataView,[this.offset,t,!0]),this.offset+=i}serializeStr(e){this.serializeBytes(E.encode(e))}serializeBytes(e){this.serializeU32AsUleb128(e.length),this.appendToBuffer(e)}serializeFixedBytes(e){this.appendToBuffer(e)}serializeBool(e){S(e);let i=e?1:0;this.appendToBuffer(new Uint8Array([i]))}serializeU8(e){this.appendToBuffer(new Uint8Array([e]))}serializeU16(e){this.serializeWithFunction(DataView.prototype.setUint16,2,e)}serializeU32(e){this.serializeWithFunction(DataView.prototype.setUint32,4,e)}serializeU64(e){let i=BigInt(e)&BigInt(l),t=BigInt(e)>>BigInt(32);this.serializeU32(Number(i)),this.serializeU32(Number(t))}serializeU128(e){let i=BigInt(e)&h,t=BigInt(e)>>BigInt(64);this.serializeU64(i),this.serializeU64(t)}serializeU256(e){let i=BigInt(e)&u,t=BigInt(e)>>BigInt(128);this.serializeU128(i),this.serializeU128(t)}serializeI8(e){this.serializeWithFunction(DataView.prototype.setInt8,1,e)}serializeI16(e){this.serializeWithFunction(DataView.prototype.setInt16,2,e)}serializeI32(e){this.serializeWithFunction(DataView.prototype.setInt32,4,e)}serializeI64(e){let i=BigInt(e),t=i<0?(BigInt(1)<<BigInt(64))+i:i,a=t&BigInt(l),f=t>>BigInt(32);this.serializeU32(Number(a)),this.serializeU32(Number(f))}serializeI128(e){let i=BigInt(e),t=i<0?(BigInt(1)<<BigInt(128))+i:i,a=t&h,f=t>>BigInt(64);this.serializeU64(a),this.serializeU64(f)}serializeI256(e){let i=BigInt(e),t=i<0?(BigInt(1)<<BigInt(256))+i:i,a=t&u,f=t>>BigInt(128);this.serializeU128(a),this.serializeU128(f)}serializeU32AsUleb128(e){let i=e,t=[];for(;i>>>7;)t.push(i&127|128),i>>>=7;t.push(i),this.appendToBuffer(new Uint8Array(t))}toUint8Array(){return new Uint8Array(this.buffer,0,this.offset).slice()}reset(){this.offset>0&&new Uint8Array(this.buffer,0,this.offset).fill(0),this.offset=0}getOffset(){return this.offset}toUint8ArrayView(){return new Uint8Array(this.buffer,0,this.offset)}serialize(e){e.serialize(this)}serializeAsBytes(e){let i=W();try{e.serialize(i);let t=i.toUint8ArrayView();this.serializeBytes(t)}finally{F(i)}}serializeVector(e){this.serializeU32AsUleb128(e.length),e.forEach(i=>{i.serialize(this)})}serializeOption(e,i){let t=e!==void 0;this.serializeBool(t),t&&(typeof e=="string"?this.serializeStr(e):e instanceof Uint8Array?i!==void 0?this.serializeFixedBytes(e):this.serializeBytes(e):e.serialize(this))}serializeOptionStr(e){e===void 0?this.serializeU32AsUleb128(0):(this.serializeU32AsUleb128(1),this.serializeStr(e))}};n([o(0,y)],s.prototype,"serializeU8",1),n([o(0,c)],s.prototype,"serializeU16",1),n([o(0,l)],s.prototype,"serializeU32",1),n([o(BigInt(0),h)],s.prototype,"serializeU64",1),n([o(BigInt(0),u)],s.prototype,"serializeU128",1),n([o(BigInt(0),U)],s.prototype,"serializeU256",1),n([o(b,z)],s.prototype,"serializeI8",1),n([o(g,A)],s.prototype,"serializeI16",1),n([o(p,_)],s.prototype,"serializeI32",1),n([o(w,d)],s.prototype,"serializeI64",1),n([o(N,m)],s.prototype,"serializeI128",1),n([o(T,M)],s.prototype,"serializeI256",1),n([o(0,l)],s.prototype,"serializeU32AsUleb128",1);function S(r){if(typeof r!="boolean")throw new Error(`${r} is not a boolean value`)}var D=(r,e,i)=>`${r} is out of range: [${e}, ${i}]`;function G(r,e,i){let t=BigInt(r);if(t>BigInt(i)||t<BigInt(e))throw new Error(D(r,e,i))}function o(r,e){return(i,t,a)=>{let f=a.value;return a.value=function(I){return G(I,r,e),f.apply(this,[I])},a}}export{R as a,$ as b,s as c,S as d,D as e,G as f};
-//# sourceMappingURL=chunk-RUKFK3OC.mjs.map