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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/bcs/serializable/moveStructs.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Bool, U128, U16, U256, U32, U64, U8 } from \"./movePrimitives\";\nimport { Serializable, Serializer } from \"../serializer\";\nimport { Deserializable, Deserializer } from \"../deserializer\";\nimport { AnyNumber, HexInput, ScriptTransactionArgumentVariants } from \"../../types\";\nimport { Hex } from \"../../core/hex\";\nimport { EntryFunctionArgument, TransactionArgument } from \"../../transactions/instances/transactionArgument\";\n\n/**\n * This class is the Aptos Typescript SDK representation of a Move `vector<T>`,\n * where `T` represents either a primitive type (`bool`, `u8`, `u64`, ...)\n * or a BCS-serializable struct itself.\n *\n * It is a BCS-serializable, array-like type that contains an array of values of type `T`,\n * where `T` is a class that implements `Serializable`.\n *\n * The purpose of this class is to facilitate easy construction of BCS-serializable\n * Move `vector<T>` types.\n *\n * @example\n * // in Move: `vector<u8> [1, 2, 3, 4];`\n * const vecOfU8s = new MoveVector<U8>([new U8(1), new U8(2), new U8(3), new U8(4)]);\n * // in Move: `std::bcs::to_bytes(vector<u8> [1, 2, 3, 4]);`\n * const bcsBytes = vecOfU8s.toUint8Array();\n *\n * // vector<vector<u8>> [ vector<u8> [1], vector<u8> [1, 2, 3, 4], vector<u8> [5, 6, 7, 8] ];\n * const vecOfVecs = new MoveVector<MoveVector<U8>>([\n *   new MoveVector<U8>([new U8(1)]),\n *   MoveVector.U8([1, 2, 3, 4]),\n *   MoveVector.U8([5, 6, 7, 8]),\n * ]);\n *\n * // vector<Option<u8>> [ std::option::some<u8>(1), std::option::some<u8>(2) ];\n * const vecOfOptionU8s = new MoveVector<MoveOption<U8>>([\n *    MoveOption.U8(1),\n *    MoveOption.U8(2),\n * ]);\n *\n * // vector<MoveString> [ std::string::utf8(b\"hello\"), std::string::utf8(b\"world\") ];\n * const vecOfStrings = new MoveVector([new MoveString(\"hello\"), new MoveString(\"world\")]);\n * const vecOfStrings2 = MoveVector.MoveString([\"hello\", \"world\"]);\n *\n * @params\n * values: an Array<T> of values where T is a class that implements Serializable\n * @returns a `MoveVector<T>` with the values `values`\n */\nexport class MoveVector<T extends Serializable & EntryFunctionArgument>\n  extends Serializable\n  implements TransactionArgument\n{\n  public values: Array<T>;\n\n  constructor(values: Array<T>) {\n    super();\n    this.values = values;\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    const bcsBytes = this.bcsToBytes();\n    serializer.serializeBytes(bcsBytes);\n  }\n\n  /**\n   * NOTE: This function will only work when the inner values in the `MoveVector` are `U8`s.\n   * @param serializer\n   */\n  serializeForScriptFunction(serializer: Serializer): void {\n    // runtime check to ensure that you can't serialize anything other than vector<u8>\n    const isU8 = this.values[0] instanceof U8;\n    // if the inner array is length 0, we can't check the type because it has no instance, so we assume it's a u8\n    // it may not be, but we don't care because regardless of a vector's type,\n    // a zero-length vector is serialized to a single byte value: 0\n    if (!isU8 && this.values[0] !== undefined) {\n      throw new Error(\"Script function arguments only accept u8 vectors\");\n    }\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U8Vector);\n    serializer.serialize(this);\n  }\n\n  /**\n   * Factory method to generate a MoveVector of U8s from an array of numbers.\n   *\n   * @example\n   * const v = MoveVector.U8([1, 2, 3, 4]);\n   * @params values: an array of `numbers` to convert to U8s\n   * @returns a `MoveVector<U8>`\n   */\n  static U8(values: Array<number> | HexInput): MoveVector<U8> {\n    let numbers: Array<number>;\n\n    if (Array.isArray(values) && values.length === 0) {\n      // Handle empty array, since it won't have a \"first value\"\n      numbers = [];\n    } else if (Array.isArray(values) && typeof values[0] === \"number\") {\n      numbers = values;\n    } else if (typeof values === \"string\") {\n      const hex = Hex.fromHexInput(values);\n      numbers = Array.from(hex.toUint8Array());\n    } else if (values instanceof Uint8Array) {\n      numbers = Array.from(values);\n    } else {\n      throw new Error(\"Invalid input type, must be an number[], Uint8Array, or hex string\");\n    }\n\n    return new MoveVector<U8>(numbers.map((v) => new U8(v)));\n  }\n\n  /**\n   * Factory method to generate a MoveVector of U16s from an array of numbers.\n   *\n   * @example\n   * const v = MoveVector.U16([1, 2, 3, 4]);\n   * @params values: an array of `numbers` to convert to U16s\n   * @returns a `MoveVector<U16>`\n   */\n  static U16(values: Array<number>): MoveVector<U16> {\n    return new MoveVector<U16>(values.map((v) => new U16(v)));\n  }\n\n  /**\n   * Factory method to generate a MoveVector of U32s from an array of numbers.\n   *\n   * @example\n   * const v = MoveVector.U32([1, 2, 3, 4]);\n   * @params values: an array of `numbers` to convert to U32s\n   * @returns a `MoveVector<U32>`\n   */\n  static U32(values: Array<number>): MoveVector<U32> {\n    return new MoveVector<U32>(values.map((v) => new U32(v)));\n  }\n\n  /**\n   * Factory method to generate a MoveVector of U64s from an array of numbers or bigints.\n   *\n   * @example\n   * const v = MoveVector.U64([1, 2, 3, 4]);\n   * @params values: an array of numbers of type `number | bigint` to convert to U64s\n   * @returns a `MoveVector<U64>`\n   */\n  static U64(values: Array<AnyNumber>): MoveVector<U64> {\n    return new MoveVector<U64>(values.map((v) => new U64(v)));\n  }\n\n  /**\n   * Factory method to generate a MoveVector of U128s from an array of numbers or bigints.\n   *\n   * @example\n   * const v = MoveVector.U128([1, 2, 3, 4]);\n   * @params values: an array of numbers of type `number | bigint` to convert to U128s\n   * @returns a `MoveVector<U128>`\n   */\n  static U128(values: Array<AnyNumber>): MoveVector<U128> {\n    return new MoveVector<U128>(values.map((v) => new U128(v)));\n  }\n\n  /**\n   * Factory method to generate a MoveVector of U256s from an array of numbers or bigints.\n   *\n   * @example\n   * const v = MoveVector.U256([1, 2, 3, 4]);\n   * @params values: an array of numbers of type `number | bigint` to convert to U256s\n   * @returns a `MoveVector<U256>`\n   */\n  static U256(values: Array<AnyNumber>): MoveVector<U256> {\n    return new MoveVector<U256>(values.map((v) => new U256(v)));\n  }\n\n  /**\n   * Factory method to generate a MoveVector of Bools from an array of booleans.\n   *\n   * @example\n   * const v = MoveVector.Bool([true, false, true, false]);\n   * @params values: an array of `bools` to convert to Bools\n   * @returns a `MoveVector<Bool>`\n   */\n  static Bool(values: Array<boolean>): MoveVector<Bool> {\n    return new MoveVector<Bool>(values.map((v) => new Bool(v)));\n  }\n\n  /**\n   * Factory method to generate a MoveVector of MoveStrings from an array of strings.\n   *\n   * @example\n   * const v = MoveVector.MoveString([\"hello\", \"world\"]);\n   * @params values: an array of `strings` to convert to MoveStrings\n   * @returns a `MoveVector<MoveString>`\n   */\n  static MoveString(values: Array<string>): MoveVector<MoveString> {\n    return new MoveVector<MoveString>(values.map((v) => new MoveString(v)));\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeVector(this.values);\n  }\n\n  /**\n   * Deserialize a MoveVector of type T, specifically where T is a Serializable and Deserializable type.\n   *\n   * NOTE: This only works with a depth of one. Generics will not work.\n   *\n   * NOTE: This will not work with types that aren't of the Serializable class.\n   *\n   * If you're looking for a more flexible deserialization function, you can use the deserializeVector function\n   * in the Deserializer class.\n   *\n   * @example\n   * const vec = MoveVector.deserialize(deserializer, U64);\n   * @params deserializer: the Deserializer instance to use, with bytes loaded into it already.\n   * cls: the class to typecast the input values to, must be a Serializable and Deserializable type.\n   * @returns a MoveVector of the corresponding class T\n   * *\n   */\n  static deserialize<T extends Serializable & EntryFunctionArgument>(\n    deserializer: Deserializer,\n    cls: Deserializable<T>,\n  ): MoveVector<T> {\n    const length = deserializer.deserializeUleb128AsU32();\n    const values = new Array<T>();\n    for (let i = 0; i < length; i += 1) {\n      values.push(cls.deserialize(deserializer));\n    }\n    return new MoveVector(values);\n  }\n}\n\nexport class MoveString extends Serializable implements TransactionArgument {\n  public value: string;\n\n  constructor(value: string) {\n    super();\n    this.value = value;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.value);\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    const bcsBytes = this.bcsToBytes();\n    serializer.serializeBytes(bcsBytes);\n  }\n\n  serializeForScriptFunction(serializer: Serializer): void {\n    // Serialize the string as a fixed byte string, i.e., without the length prefix\n    const textEncoder = new TextEncoder();\n    const fixedStringBytes = textEncoder.encode(this.value);\n    // Put those bytes into a vector<u8> and serialize it as a script function argument\n    const vectorU8 = MoveVector.U8(fixedStringBytes);\n    vectorU8.serializeForScriptFunction(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): MoveString {\n    return new MoveString(deserializer.deserializeStr());\n  }\n}\n\nexport class MoveOption<T extends Serializable & EntryFunctionArgument>\n  extends Serializable\n  implements EntryFunctionArgument\n{\n  private vec: MoveVector<T>;\n\n  public readonly value?: T;\n\n  constructor(value?: T | null) {\n    super();\n    if (typeof value !== \"undefined\" && value !== null) {\n      this.vec = new MoveVector([value]);\n    } else {\n      this.vec = new MoveVector([]);\n    }\n\n    [this.value] = this.vec.values;\n  }\n\n  serializeForEntryFunction(serializer: Serializer): void {\n    const bcsBytes = this.bcsToBytes();\n    serializer.serializeBytes(bcsBytes);\n  }\n\n  /**\n   * Retrieves the inner value of the MoveOption.\n   *\n   * This method is inspired by Rust's `Option<T>.unwrap()`.\n   * In Rust, attempting to unwrap a `None` value results in a panic.\n   *\n   * Similarly, this method will throw an error if the value is not present.\n   *\n   * @example\n   * const option = new MoveOption<Bool>(new Bool(true));\n   * const value = option.unwrap();  // Returns the Bool instance\n   *\n   * @throws {Error} Throws an error if the MoveOption does not contain a value.\n   *\n   * @returns {T} The contained value if present.\n   */\n  unwrap(): T {\n    if (!this.isSome()) {\n      throw new Error(\"Called unwrap on a MoveOption with no value\");\n    } else {\n      return this.vec.values[0];\n    }\n  }\n\n  // Check if the MoveOption has a value.\n  isSome(): boolean {\n    return this.vec.values.length === 1;\n  }\n\n  serialize(serializer: Serializer): void {\n    // serialize 0 or 1\n    // if 1, serialize the value\n    this.vec.serialize(serializer);\n  }\n\n  /**\n   * Factory method to generate a MoveOption<U8> from a `number` or `undefined`.\n   *\n   * @example\n   * MoveOption.U8(1).isSome() === true;\n   * MoveOption.U8().isSome() === false;\n   * MoveOption.U8(undefined).isSome() === false;\n   * @params value: the value used to fill the MoveOption. If `value` is undefined\n   * the resulting MoveOption's .isSome() method will return false.\n   * @returns a MoveOption<U8> with an inner value `value`\n   */\n  static U8(value?: number | null): MoveOption<U8> {\n    return new MoveOption<U8>(value !== null && value !== undefined ? new U8(value) : undefined);\n  }\n\n  /**\n   * Factory method to generate a MoveOption<U16> from a `number` or `undefined`.\n   *\n   * @example\n   * MoveOption.U16(1).isSome() === true;\n   * MoveOption.U16().isSome() === false;\n   * MoveOption.U16(undefined).isSome() === false;\n   * @params value: the value used to fill the MoveOption. If `value` is undefined\n   * the resulting MoveOption's .isSome() method will return false.\n   * @returns a MoveOption<U16> with an inner value `value`\n   */\n  static U16(value?: number | null): MoveOption<U16> {\n    return new MoveOption<U16>(value !== null && value !== undefined ? new U16(value) : undefined);\n  }\n\n  /**\n   * Factory method to generate a MoveOption<U32> from a `number` or `undefined`.\n   *\n   * @example\n   * MoveOption.U32(1).isSome() === true;\n   * MoveOption.U32().isSome() === false;\n   * MoveOption.U32(undefined).isSome() === false;\n   * @params value: the value used to fill the MoveOption. If `value` is undefined\n   * the resulting MoveOption's .isSome() method will return false.\n   * @returns a MoveOption<U32> with an inner value `value`\n   */\n  static U32(value?: number | null): MoveOption<U32> {\n    return new MoveOption<U32>(value !== null && value !== undefined ? new U32(value) : undefined);\n  }\n\n  /**\n   * Factory method to generate a MoveOption<U64> from a `number` or a `bigint` or `undefined`.\n   *\n   * @example\n   * MoveOption.U64(1).isSome() === true;\n   * MoveOption.U64().isSome() === false;\n   * MoveOption.U64(undefined).isSome() === false;\n   * @params value: the value used to fill the MoveOption. If `value` is undefined\n   * the resulting MoveOption's .isSome() method will return false.\n   * @returns a MoveOption<U64> with an inner value `value`\n   */\n  static U64(value?: AnyNumber | null): MoveOption<U64> {\n    return new MoveOption<U64>(value !== null && value !== undefined ? new U64(value) : undefined);\n  }\n\n  /**\n   * Factory method to generate a MoveOption<U128> from a `number` or a `bigint` or `undefined`.\n   *\n   * @example\n   * MoveOption.U128(1).isSome() === true;\n   * MoveOption.U128().isSome() === false;\n   * MoveOption.U128(undefined).isSome() === false;\n   * @params value: the value used to fill the MoveOption. If `value` is undefined\n   * the resulting MoveOption's .isSome() method will return false.\n   * @returns a MoveOption<U128> with an inner value `value`\n   */\n  static U128(value?: AnyNumber | null): MoveOption<U128> {\n    return new MoveOption<U128>(value !== null && value !== undefined ? new U128(value) : undefined);\n  }\n\n  /**\n   * Factory method to generate a MoveOption<U256> from a `number` or a `bigint` or `undefined`.\n   *\n   * @example\n   * MoveOption.U256(1).isSome() === true;\n   * MoveOption.U256().isSome() === false;\n   * MoveOption.U256(undefined).isSome() === false;\n   * @params value: the value used to fill the MoveOption. If `value` is undefined\n   * the resulting MoveOption's .isSome() method will return false.\n   * @returns a MoveOption<U256> with an inner value `value`\n   */\n  static U256(value?: AnyNumber | null): MoveOption<U256> {\n    return new MoveOption<U256>(value !== null && value !== undefined ? new U256(value) : undefined);\n  }\n\n  /**\n   * Factory method to generate a MoveOption<Bool> from a `boolean` or `undefined`.\n   *\n   * @example\n   * MoveOption.Bool(true).isSome() === true;\n   * MoveOption.Bool().isSome() === false;\n   * MoveOption.Bool(undefined).isSome() === false;\n   * @params value: the value used to fill the MoveOption. If `value` is undefined\n   * the resulting MoveOption's .isSome() method will return false.\n   * @returns a MoveOption<Bool> with an inner value `value`\n   */\n  static Bool(value?: boolean | null): MoveOption<Bool> {\n    return new MoveOption<Bool>(value !== null && value !== undefined ? new Bool(value) : undefined);\n  }\n\n  /**\n   * Factory method to generate a MoveOption<MoveString> from a `string` or `undefined`.\n   *\n   * @example\n   * MoveOption.MoveString(\"hello\").isSome() === true;\n   * MoveOption.MoveString(\"\").isSome() === true;\n   * MoveOption.MoveString().isSome() === false;\n   * MoveOption.MoveString(undefined).isSome() === false;\n   * @params value: the value used to fill the MoveOption. If `value` is undefined\n   * the resulting MoveOption's .isSome() method will return false.\n   * @returns a MoveOption<MoveString> with an inner value `value`\n   */\n  static MoveString(value?: string | null): MoveOption<MoveString> {\n    return new MoveOption<MoveString>(value !== null && value !== undefined ? new MoveString(value) : undefined);\n  }\n\n  static deserialize<U extends Serializable & EntryFunctionArgument>(\n    deserializer: Deserializer,\n    cls: Deserializable<U>,\n  ): MoveOption<U> {\n    const vector = MoveVector.deserialize(deserializer, cls);\n    return new MoveOption(vector.values[0]);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/esm/chunk-PU5AFUX3.mjs

@@ -1,52 +0,0 @@
-// src/core/crypto/hdKey.ts
-import { hmac } from "@noble/hashes/hmac";
-import { sha512 } from "@noble/hashes/sha512";
-import * as bip39 from "@scure/bip39";
-var APTOS_HARDENED_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+'\/[0-9]+'?$/;
-var APTOS_BIP44_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+\/[0-9]+$/;
-var KeyType = /* @__PURE__ */ ((KeyType2) => {
-  KeyType2["ED25519"] = "ed25519 seed";
-  return KeyType2;
-})(KeyType || {});
-var HARDENED_OFFSET = 2147483648;
-function isValidBIP44Path(path) {
-  return APTOS_BIP44_REGEX.test(path);
-}
-function isValidHardenedPath(path) {
-  return APTOS_HARDENED_REGEX.test(path);
-}
-var deriveKey = (hashSeed, data) => {
-  const digest = hmac.create(sha512, hashSeed).update(data).digest();
-  return {
-    key: digest.slice(0, 32),
-    chainCode: digest.slice(32)
-  };
-};
-var CKDPriv = ({ key, chainCode }, index) => {
-  const buffer = new ArrayBuffer(4);
-  new DataView(buffer).setUint32(0, index);
-  const indexBytes = new Uint8Array(buffer);
-  const zero = new Uint8Array([0]);
-  const data = new Uint8Array([...zero, ...key, ...indexBytes]);
-  return deriveKey(chainCode, data);
-};
-var removeApostrophes = (val) => val.replace("'", "");
-var splitPath = (path) => path.split("/").slice(1).map(removeApostrophes);
-var mnemonicToSeed = (mnemonic) => {
-  const normalizedMnemonic = mnemonic.trim().split(/\s+/).map((part) => part.toLowerCase()).join(" ");
-  return bip39.mnemonicToSeedSync(normalizedMnemonic);
-};
-
-export {
-  APTOS_HARDENED_REGEX,
-  APTOS_BIP44_REGEX,
-  KeyType,
-  HARDENED_OFFSET,
-  isValidBIP44Path,
-  isValidHardenedPath,
-  deriveKey,
-  CKDPriv,
-  splitPath,
-  mnemonicToSeed
-};
-//# sourceMappingURL=chunk-PU5AFUX3.mjs.map

package/dist/esm/chunk-QMM2KL6C.mjs

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

package/dist/esm/chunk-S7KNZC2A.mjs

@@ -1,45 +0,0 @@
-import {
-  waitForTransaction
-} from "./chunk-UZLU45X7.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  postAptosFaucet
-} from "./chunk-2UN35LUX.mjs";
-import {
-  DEFAULT_TXN_TIMEOUT_SEC
-} from "./chunk-4K4TZF3H.mjs";
-
-// src/internal/faucet.ts
-async function fundAccount(args) {
-  const { aptosConfig, accountAddress, amount, options } = args;
-  const timeout = options?.timeoutSecs || DEFAULT_TXN_TIMEOUT_SEC;
-  const { data } = await postAptosFaucet({
-    aptosConfig,
-    path: "fund",
-    body: {
-      address: AccountAddress.from(accountAddress).toString(),
-      amount
-    },
-    originMethod: "fundAccount"
-  });
-  const txnHash = data.txn_hashes[0];
-  const res = await waitForTransaction({
-    aptosConfig,
-    transactionHash: txnHash,
-    options: {
-      timeoutSecs: timeout,
-      checkSuccess: options?.checkSuccess
-    }
-  });
-  if (res.type === "user_transaction" /* User */) {
-    return res;
-  }
-  throw new Error(`Unexpected transaction received for fund account: ${res.type}`);
-}
-
-export {
-  fundAccount
-};
-//# sourceMappingURL=chunk-S7KNZC2A.mjs.map

package/dist/esm/chunk-SBB4YEPT.mjs

@@ -1,17 +0,0 @@
-// src/bcs/consts.ts
-var MAX_U8_NUMBER = 255;
-var MAX_U16_NUMBER = 65535;
-var MAX_U32_NUMBER = 4294967295;
-var MAX_U64_BIG_INT = 18446744073709551615n;
-var MAX_U128_BIG_INT = 340282366920938463463374607431768211455n;
-var MAX_U256_BIG_INT = 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
-
-export {
-  MAX_U8_NUMBER,
-  MAX_U16_NUMBER,
-  MAX_U32_NUMBER,
-  MAX_U64_BIG_INT,
-  MAX_U128_BIG_INT,
-  MAX_U256_BIG_INT
-};
-//# sourceMappingURL=chunk-SBB4YEPT.mjs.map

package/dist/esm/chunk-SIJELMDP.mjs

@@ -1,29 +0,0 @@
-// src/api/transactionSubmission/helpers.ts
-function ValidateFeePayerDataOnSubmission(target, propertyKey, descriptor) {
-  const originalMethod = descriptor.value;
-  descriptor.value = async function(...args) {
-    const [methodArgs] = args;
-    if (methodArgs.transaction.feePayerAddress && !methodArgs.feePayerAuthenticator) {
-      throw new Error("You are submitting a Fee Payer transaction but missing the feePayerAuthenticator");
-    }
-    return originalMethod.apply(this, args);
-  };
-  return descriptor;
-}
-function ValidateFeePayerDataOnSimulation(target, propertyKey, descriptor) {
-  const originalMethod = descriptor.value;
-  descriptor.value = async function(...args) {
-    const [methodArgs] = args;
-    if (methodArgs.transaction.feePayerAddress && !methodArgs.feePayerPublicKey) {
-      throw new Error("You are simulating a Fee Payer transaction but missing the feePayerPublicKey");
-    }
-    return originalMethod.apply(this, args);
-  };
-  return descriptor;
-}
-
-export {
-  ValidateFeePayerDataOnSubmission,
-  ValidateFeePayerDataOnSimulation
-};
-//# sourceMappingURL=chunk-SIJELMDP.mjs.map

package/dist/esm/chunk-SRKSXJ5U.mjs

@@ -1,242 +0,0 @@
-import {
-  convertSigningMessage
-} from "./chunk-NMKCJNQM.mjs";
-import {
-  PublicKey
-} from "./chunk-L3E7YJBM.mjs";
-import {
-  Signature
-} from "./chunk-6BI4XTJN.mjs";
-import {
-  isValidBIP44Path,
-  mnemonicToSeed
-} from "./chunk-PU5AFUX3.mjs";
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/crypto/secp256k1.ts
-import { sha3_256 } from "@noble/hashes/sha3";
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { HDKey } from "@scure/bip32";
-var _Secp256k1PublicKey = class _Secp256k1PublicKey extends PublicKey {
-  /**
-   * Create a new PublicKey instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   */
-  constructor(hexInput) {
-    super();
-    const hex = Hex.fromHexInput(hexInput);
-    if (hex.toUint8Array().length !== _Secp256k1PublicKey.LENGTH) {
-      throw new Error(`PublicKey length should be ${_Secp256k1PublicKey.LENGTH}`);
-    }
-    this.key = hex;
-  }
-  // region PublicKey
-  /**
-   * Verifies a Secp256k1 signature against the public key
-   *
-   * Note signatures are validated to be canonical as a malleability check
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    const messageToVerify = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
-    const messageSha3Bytes = sha3_256(messageBytes);
-    const signatureBytes = signature.toUint8Array();
-    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true });
-  }
-  toUint8Array() {
-    return this.key.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.key.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Secp256k1PublicKey(bytes);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof Secp256k1PublicKey` instead
-   * @param publicKey
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _Secp256k1PublicKey;
-  }
-  static isInstance(publicKey) {
-    return "key" in publicKey && publicKey.key?.data?.length === _Secp256k1PublicKey.LENGTH;
-  }
-};
-// Secp256k1 ecdsa public keys contain a prefix indicating compression and two 32-byte coordinates.
-_Secp256k1PublicKey.LENGTH = 65;
-var Secp256k1PublicKey = _Secp256k1PublicKey;
-var _Secp256k1PrivateKey = class _Secp256k1PrivateKey extends Serializable {
-  // region Constructors
-  /**
-   * Create a new PrivateKey instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   */
-  constructor(hexInput) {
-    super();
-    const privateKeyHex = Hex.fromHexInput(hexInput);
-    if (privateKeyHex.toUint8Array().length !== _Secp256k1PrivateKey.LENGTH) {
-      throw new Error(`PrivateKey length should be ${_Secp256k1PrivateKey.LENGTH}`);
-    }
-    this.key = privateKeyHex;
-  }
-  /**
-   * Generate a new random private key.
-   *
-   * @returns Secp256k1PrivateKey
-   */
-  static generate() {
-    const hexInput = secp256k1.utils.randomPrivateKey();
-    return new _Secp256k1PrivateKey(hexInput);
-  }
-  /**
-   * Derives a private key from a mnemonic seed phrase.
-   *
-   * @param path the BIP44 path
-   * @param mnemonics the mnemonic seed phrase
-   *
-   * @returns The generated key
-   */
-  static fromDerivationPath(path, mnemonics) {
-    if (!isValidBIP44Path(path)) {
-      throw new Error(`Invalid derivation path ${path}`);
-    }
-    return _Secp256k1PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));
-  }
-  /**
-   * A private inner function so we can separate from the main fromDerivationPath() method
-   * to add tests to verify we create the keys correctly.
-   *
-   * @param path the BIP44 path
-   * @param seed the seed phrase created by the mnemonics
-   *
-   * @returns The generated key
-   */
-  static fromDerivationPathInner(path, seed) {
-    const { privateKey } = HDKey.fromMasterSeed(seed).derive(path);
-    if (privateKey === null) {
-      throw new Error("Invalid key");
-    }
-    return new _Secp256k1PrivateKey(privateKey);
-  }
-  // endregion
-  // region PrivateKey
-  /**
-   * Sign the given message with the private key.
-   *
-   * Note: signatures are canonical, and non-malleable
-   *
-   * @param message a message as a string or Uint8Array
-   * @returns Signature
-   */
-  sign(message) {
-    const messageToSign = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToSign);
-    const messageHashBytes = sha3_256(messageBytes.toUint8Array());
-    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array(), { lowS: true });
-    return new Secp256k1Signature(signature.toCompactRawBytes());
-  }
-  /**
-   * Derive the Secp256k1PublicKey from this private key.
-   *
-   * @returns Secp256k1PublicKey
-   */
-  publicKey() {
-    const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);
-    return new Secp256k1PublicKey(bytes);
-  }
-  /**
-   * Get the private key in bytes (Uint8Array).
-   *
-   * @returns
-   */
-  toUint8Array() {
-    return this.key.toUint8Array();
-  }
-  /**
-   * Get the private key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the private key
-   */
-  toString() {
-    return this.key.toString();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Secp256k1PrivateKey(bytes);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof Secp256k1PrivateKey` instead
-   */
-  static isPrivateKey(privateKey) {
-    return privateKey instanceof _Secp256k1PrivateKey;
-  }
-};
-/**
- * Length of Secp256k1 ecdsa private key
- */
-_Secp256k1PrivateKey.LENGTH = 32;
-var Secp256k1PrivateKey = _Secp256k1PrivateKey;
-var _Secp256k1Signature = class _Secp256k1Signature extends Signature {
-  // region Constructors
-  /**
-   * Create a new Signature instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   */
-  constructor(hexInput) {
-    super();
-    const data = Hex.fromHexInput(hexInput);
-    if (data.toUint8Array().length !== _Secp256k1Signature.LENGTH) {
-      throw new Error(
-        `Signature length should be ${_Secp256k1Signature.LENGTH}, received ${data.toUint8Array().length}`
-      );
-    }
-    this.data = data;
-  }
-  // endregion
-  // region Signature
-  toUint8Array() {
-    return this.data.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.data.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const hex = deserializer.deserializeBytes();
-    return new _Secp256k1Signature(hex);
-  }
-  // endregion
-};
-/**
- * Secp256k1 ecdsa signatures are 256-bit.
- */
-_Secp256k1Signature.LENGTH = 64;
-var Secp256k1Signature = _Secp256k1Signature;
-
-export {
-  Secp256k1PublicKey,
-  Secp256k1PrivateKey,
-  Secp256k1Signature
-};
-//# sourceMappingURL=chunk-SRKSXJ5U.mjs.map

package/dist/esm/chunk-U6N546EH.mjs

@@ -1,43 +0,0 @@
-import {
-  queryIndexer
-} from "./chunk-I5BTSNTY.mjs";
-import {
-  GetObjectData
-} from "./chunk-NFA2AU5E.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-
-// src/internal/object.ts
-async function getObjectData(args) {
-  const { aptosConfig, options } = args;
-  const graphqlQuery = {
-    query: GetObjectData,
-    variables: {
-      where_condition: options?.where,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.orderBy
-    }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getObjectData"
-  });
-  return data.current_objects;
-}
-async function getObjectDataByObjectAddress(args) {
-  const { aptosConfig, objectAddress, options } = args;
-  const address = AccountAddress.from(objectAddress).toStringLong();
-  const whereCondition = {
-    object_address: { _eq: address }
-  };
-  return (await getObjectData({ aptosConfig, options: { ...options, where: whereCondition } }))[0];
-}
-
-export {
-  getObjectData,
-  getObjectDataByObjectAddress
-};
-//# sourceMappingURL=chunk-U6N546EH.mjs.map