@aptos-labs/ts-sdk 1.14.0-zeta.2 → 1.14.0-zeta.4

package/dist/esm/chunk-RX4VG2AT.mjs

@@ -1,314 +0,0 @@
-import {
-  Signature
-} from "./chunk-FDWJNY4U.mjs";
-import {
-  convertSigningMessage
-} from "./chunk-NMKCJNQM.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-FXKSE3ZP.mjs";
-import {
-  CKDPriv,
-  HARDENED_OFFSET,
-  deriveKey,
-  isValidHardenedPath,
-  mnemonicToSeed,
-  splitPath
-} from "./chunk-PU5AFUX3.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-UEBBLQJ5.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/crypto/ed25519.ts
-import { ed25519 } from "@noble/curves/ed25519";
-var L = [
-  237,
-  211,
-  245,
-  92,
-  26,
-  99,
-  18,
-  88,
-  214,
-  156,
-  247,
-  162,
-  222,
-  249,
-  222,
-  20,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  16
-];
-var _Ed25519PublicKey = class _Ed25519PublicKey extends AccountPublicKey {
-  /**
-   * 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 !== _Ed25519PublicKey.LENGTH) {
-      throw new Error(`PublicKey length should be ${_Ed25519PublicKey.LENGTH}`);
-    }
-    this.key = hex;
-  }
-  // region AccountPublicKey
-  /**
-   * Verifies a signed data with a public key
-   * @param args.message a signed message as a Hex string or Uint8Array
-   * @param args.signature the signature of the message
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (!(signature instanceof Ed25519Signature)) {
-      return false;
-    }
-    const messageToVerify = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
-    const signatureBytes = signature.toUint8Array();
-    const publicKeyBytes = this.key.toUint8Array();
-    if (!signature.isCanonicalSignature()) {
-      return false;
-    }
-    return ed25519.verify(signatureBytes, messageBytes, publicKeyBytes);
-  }
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 0 /* Ed25519 */,
-      input: this.toUint8Array()
-    });
-  }
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array() {
-    return this.key.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.key.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Ed25519PublicKey(bytes);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof Ed25519PublicKey` instead.
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _Ed25519PublicKey;
-  }
-};
-/**
- * Length of an Ed25519 public key
- */
-_Ed25519PublicKey.LENGTH = 32;
-var Ed25519PublicKey = _Ed25519PublicKey;
-var _Ed25519PrivateKey = class _Ed25519PrivateKey extends Serializable {
-  // region Constructors
-  /**
-   * Create a new PrivateKey instance from a Uint8Array or String.
-   *
-   * @param hexInput HexInput (string or Uint8Array)
-   */
-  constructor(hexInput) {
-    super();
-    const privateKeyHex = Hex.fromHexInput(hexInput);
-    if (privateKeyHex.toUint8Array().length !== _Ed25519PrivateKey.LENGTH) {
-      throw new Error(`PrivateKey length should be ${_Ed25519PrivateKey.LENGTH}`);
-    }
-    this.signingKey = privateKeyHex;
-  }
-  /**
-   * Generate a new random private key.
-   *
-   * @returns Ed25519PrivateKey
-   */
-  static generate() {
-    const keyPair = ed25519.utils.randomPrivateKey();
-    return new _Ed25519PrivateKey(keyPair);
-  }
-  /**
-   * Derives a private key from a mnemonic seed phrase.
-   *
-   * To derive multiple keys from the same phrase, change the path
-   *
-   * IMPORTANT: Ed25519 supports hardened derivation only (since it lacks a key homomorphism,
-   * so non-hardened derivation cannot work)
-   *
-   * @param path the BIP44 path
-   * @param mnemonics the mnemonic seed phrase
-   */
-  static fromDerivationPath(path, mnemonics) {
-    if (!isValidHardenedPath(path)) {
-      throw new Error(`Invalid derivation path ${path}`);
-    }
-    return _Ed25519PrivateKey.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
-   * @param offset the offset used for key derivation, defaults to 0x80000000
-   * @returns
-   */
-  static fromDerivationPathInner(path, seed, offset = HARDENED_OFFSET) {
-    const { key, chainCode } = deriveKey(_Ed25519PrivateKey.SLIP_0010_SEED, seed);
-    const segments = splitPath(path).map((el) => parseInt(el, 10));
-    const { key: privateKey } = segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
-      key,
-      chainCode
-    });
-    return new _Ed25519PrivateKey(privateKey);
-  }
-  // endregion
-  // region PrivateKey
-  /**
-   * Derive the Ed25519PublicKey for this private key.
-   *
-   * @returns Ed25519PublicKey
-   */
-  publicKey() {
-    const bytes = ed25519.getPublicKey(this.signingKey.toUint8Array());
-    return new Ed25519PublicKey(bytes);
-  }
-  /**
-   * Sign the given message with the private key.
-   *
-   * @param message a message as a string or Uint8Array
-   * @returns Signature
-   */
-  sign(message) {
-    const messageToSign = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToSign).toUint8Array();
-    const signatureBytes = ed25519.sign(messageBytes, this.signingKey.toUint8Array());
-    return new Ed25519Signature(signatureBytes);
-  }
-  /**
-   * Get the private key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the private key
-   */
-  toUint8Array() {
-    return this.signingKey.toUint8Array();
-  }
-  /**
-   * Get the private key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the private key
-   */
-  toString() {
-    return this.signingKey.toString();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Ed25519PrivateKey(bytes);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof Ed25519PrivateKey` instead.
-   */
-  static isPrivateKey(privateKey) {
-    return privateKey instanceof _Ed25519PrivateKey;
-  }
-};
-/**
- * Length of an Ed25519 private key
- */
-_Ed25519PrivateKey.LENGTH = 32;
-/**
- * The Ed25519 key seed to use for BIP-32 compatibility
- * See more {@link https://github.com/satoshilabs/slips/blob/master/slip-0010.md}
- */
-_Ed25519PrivateKey.SLIP_0010_SEED = "ed25519 seed";
-var Ed25519PrivateKey = _Ed25519PrivateKey;
-var _Ed25519Signature = class _Ed25519Signature extends Signature {
-  // region Constructors
-  constructor(hexInput) {
-    super();
-    const data = Hex.fromHexInput(hexInput);
-    if (data.toUint8Array().length !== _Ed25519Signature.LENGTH) {
-      throw new Error(`Signature length should be ${_Ed25519Signature.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 bytes = deserializer.deserializeBytes();
-    return new _Ed25519Signature(bytes);
-  }
-  /**
-   * Checks if an ED25519 signature is non-canonical.
-   *
-   * Comes from Aptos Core
-   * https://github.com/aptos-labs/aptos-core/blob/main/crates/aptos-crypto/src/ed25519/ed25519_sigs.rs#L47-L85
-   */
-  isCanonicalSignature() {
-    const s = this.toUint8Array().slice(32);
-    for (let i = s.length - 1; i >= 0; i -= 1) {
-      if (s[i] < L[i]) {
-        return true;
-      }
-      if (s[i] > L[i]) {
-        return false;
-      }
-    }
-    return false;
-  }
-  // endregion
-};
-/**
- * Length of an Ed25519 signature
- */
-_Ed25519Signature.LENGTH = 64;
-var Ed25519Signature = _Ed25519Signature;
-
-export {
-  Ed25519PublicKey,
-  Ed25519PrivateKey,
-  Ed25519Signature
-};
-//# sourceMappingURL=chunk-RX4VG2AT.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-SS3NUM5L.mjs

@@ -1,94 +0,0 @@
-import {
-  sleep
-} from "./chunk-GGMTQAQP.mjs";
-
-// src/cli/localNode.ts
-import { spawn } from "child_process";
-import kill from "tree-kill";
-var LocalNode = class {
-  constructor() {
-    this.MAXIMUM_WAIT_TIME_SEC = 75;
-    this.READINESS_ENDPOINT = "http://127.0.0.1:8070/";
-    this.process = null;
-  }
-  /**
-   * kills all the descendent processes
-   * of the node process, including the node process itself
-   */
-  stop() {
-    if (!this.process?.pid)
-      return;
-    kill(this.process.pid);
-  }
-  /**
-   * Runs a local testnet and waits for process to be up.
-   *
-   * If local node process is already up it returns and does
-   * not start the process
-   */
-  async run() {
-    const nodeIsUp = await this.checkIfProcessIsUp();
-    if (nodeIsUp) {
-      return;
-    }
-    this.start();
-    await this.waitUntilProcessIsUp();
-  }
-  /**
-   * Starts the local testnet by running the aptos node run-local-testnet command
-   */
-  start() {
-    const cliCommand = "npx";
-    const cliArgs = ["aptos", "node", "run-local-testnet", "--force-restart", "--assume-yes", "--with-indexer-api"];
-    const childProcess = spawn(cliCommand, cliArgs);
-    this.process = childProcess;
-    childProcess.stderr?.on("data", (data) => {
-      const str = data.toString();
-      console.log(str);
-    });
-    childProcess.stdout?.on("data", (data) => {
-      const str = data.toString();
-      console.log(str);
-    });
-  }
-  /**
-   * Waits for the local testnet process to be up
-   *
-   * @returns Promise<boolean>
-   */
-  async waitUntilProcessIsUp() {
-    let operational = await this.checkIfProcessIsUp();
-    const start = Date.now() / 1e3;
-    let last = start;
-    while (!operational && start + this.MAXIMUM_WAIT_TIME_SEC > last) {
-      await sleep(1e3);
-      operational = await this.checkIfProcessIsUp();
-      last = Date.now() / 1e3;
-    }
-    if (!operational) {
-      throw new Error("Process failed to start");
-    }
-    return true;
-  }
-  /**
-   * Checks if the local testnet is up
-   *
-   * @returns Promise<boolean>
-   */
-  async checkIfProcessIsUp() {
-    try {
-      const data = await fetch(this.READINESS_ENDPOINT);
-      if (data.status === 200) {
-        return true;
-      }
-      return false;
-    } catch (err) {
-      return false;
-    }
-  }
-};
-
-export {
-  LocalNode
-};
-//# sourceMappingURL=chunk-SS3NUM5L.mjs.map

package/dist/esm/chunk-ST4QXIMI.mjs

@@ -1,37 +0,0 @@
-import {
-  fundAccount
-} from "./chunk-KVSQ57HU.mjs";
-import {
-  waitForIndexer
-} from "./chunk-TBHU6ZW6.mjs";
-
-// src/api/faucet.ts
-var Faucet = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * This creates an account if it does not exist and mints the specified amount of
-   * coins into that account
-   *
-   * @example
-   * const transaction = await aptos.fundAccount({accountAddress:"0x123", amount: 100})
-   *
-   * @param args.accountAddress Address of the account to fund
-   * @param args.amount Amount of tokens to fund the account with
-   * @param args.options Configuration options for waitForTransaction
-   * @returns Transaction hash of the transaction that funded the account
-   */
-  async fundAccount(args) {
-    const fundTxn = await fundAccount({ aptosConfig: this.config, ...args });
-    if (args.options?.waitForIndexer !== false) {
-      await waitForIndexer({ aptosConfig: this.config, minimumLedgerVersion: BigInt(fundTxn.version) });
-    }
-    return fundTxn;
-  }
-};
-
-export {
-  Faucet
-};
-//# sourceMappingURL=chunk-ST4QXIMI.mjs.map

package/dist/esm/chunk-TBHU6ZW6.mjs

@@ -1,215 +0,0 @@
-import {
-  memoizeAsync
-} from "./chunk-EYHRMZPO.mjs";
-import {
-  getIndexerLastSuccessVersion,
-  getProcessorStatus
-} from "./chunk-LYMY63SO.mjs";
-import {
-  getAptosFullNode,
-  paginateWithCursor
-} from "./chunk-LYK4TQZO.mjs";
-import {
-  sleep
-} from "./chunk-GGMTQAQP.mjs";
-import {
-  AptosApiError
-} from "./chunk-PCLNX6FS.mjs";
-import {
-  DEFAULT_TXN_TIMEOUT_SEC
-} from "./chunk-NFJCQRVK.mjs";
-
-// src/internal/transaction.ts
-async function getTransactions(args) {
-  const { aptosConfig, options } = args;
-  return paginateWithCursor({
-    aptosConfig,
-    originMethod: "getTransactions",
-    path: "transactions",
-    params: { start: options?.offset, limit: options?.limit }
-  });
-}
-async function getGasPriceEstimation(args) {
-  const { aptosConfig } = args;
-  return memoizeAsync(
-    async () => {
-      const { data } = await getAptosFullNode({
-        aptosConfig,
-        originMethod: "getGasPriceEstimation",
-        path: "estimate_gas_price"
-      });
-      return data;
-    },
-    `gas-price-${aptosConfig.network}`,
-    1e3 * 60 * 5
-    // 5 minutes
-  )();
-}
-async function getTransactionByVersion(args) {
-  const { aptosConfig, ledgerVersion } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getTransactionByVersion",
-    path: `transactions/by_version/${ledgerVersion}`
-  });
-  return data;
-}
-async function getTransactionByHash(args) {
-  const { aptosConfig, transactionHash } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    path: `transactions/by_hash/${transactionHash}`,
-    originMethod: "getTransactionByHash"
-  });
-  return data;
-}
-async function isTransactionPending(args) {
-  const { aptosConfig, transactionHash } = args;
-  try {
-    const transaction = await getTransactionByHash({ aptosConfig, transactionHash });
-    return transaction.type === "pending_transaction" /* Pending */;
-  } catch (e) {
-    if (e?.status === 404) {
-      return true;
-    }
-    throw e;
-  }
-}
-async function longWaitForTransaction(args) {
-  const { aptosConfig, transactionHash } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    path: `transactions/wait_by_hash/${transactionHash}`,
-    originMethod: "longWaitForTransaction"
-  });
-  return data;
-}
-async function waitForTransaction(args) {
-  const { aptosConfig, transactionHash, options } = args;
-  const timeoutSecs = options?.timeoutSecs ?? DEFAULT_TXN_TIMEOUT_SEC;
-  const checkSuccess = options?.checkSuccess ?? true;
-  let isPending = true;
-  let timeElapsed = 0;
-  let lastTxn;
-  let lastError;
-  let backoffIntervalMs = 200;
-  const backoffMultiplier = 1.5;
-  function handleAPIError(e) {
-    const isAptosApiError = e instanceof AptosApiError;
-    if (!isAptosApiError) {
-      throw e;
-    }
-    lastError = e;
-    const isRequestError = e.status !== 404 && e.status >= 400 && e.status < 500;
-    if (isRequestError) {
-      throw e;
-    }
-  }
-  try {
-    lastTxn = await getTransactionByHash({ aptosConfig, transactionHash });
-    isPending = lastTxn.type === "pending_transaction" /* Pending */;
-  } catch (e) {
-    handleAPIError(e);
-  }
-  if (isPending) {
-    const startTime = Date.now();
-    try {
-      lastTxn = await longWaitForTransaction({ aptosConfig, transactionHash });
-      isPending = lastTxn.type === "pending_transaction" /* Pending */;
-    } catch (e) {
-      handleAPIError(e);
-    }
-    timeElapsed = (Date.now() - startTime) / 1e3;
-  }
-  while (isPending) {
-    if (timeElapsed >= timeoutSecs) {
-      break;
-    }
-    try {
-      lastTxn = await getTransactionByHash({ aptosConfig, transactionHash });
-      isPending = lastTxn.type === "pending_transaction" /* Pending */;
-      if (!isPending) {
-        break;
-      }
-    } catch (e) {
-      handleAPIError(e);
-    }
-    await sleep(backoffIntervalMs);
-    timeElapsed += backoffIntervalMs / 1e3;
-    backoffIntervalMs *= backoffMultiplier;
-  }
-  if (lastTxn === void 0) {
-    if (lastError) {
-      throw lastError;
-    } else {
-      throw new WaitForTransactionError(
-        `Fetching transaction ${transactionHash} failed and timed out after ${timeoutSecs} seconds`,
-        lastTxn
-      );
-    }
-  }
-  if (lastTxn.type === "pending_transaction" /* Pending */) {
-    throw new WaitForTransactionError(
-      `Transaction ${transactionHash} timed out in pending state after ${timeoutSecs} seconds`,
-      lastTxn
-    );
-  }
-  if (!checkSuccess) {
-    return lastTxn;
-  }
-  if (!lastTxn.success) {
-    throw new FailedTransactionError(
-      `Transaction ${transactionHash} failed with an error: ${lastTxn.vm_status}`,
-      lastTxn
-    );
-  }
-  return lastTxn;
-}
-async function waitForIndexer(args) {
-  const { aptosConfig, processorType } = args;
-  const minimumLedgerVersion = BigInt(args.minimumLedgerVersion);
-  const timeoutMilliseconds = 3e3;
-  const startTime = (/* @__PURE__ */ new Date()).getTime();
-  let indexerVersion = BigInt(-1);
-  while (indexerVersion < minimumLedgerVersion) {
-    if ((/* @__PURE__ */ new Date()).getTime() - startTime > timeoutMilliseconds) {
-      throw new Error("waitForLastSuccessIndexerVersionSync timeout");
-    }
-    if (processorType === void 0) {
-      indexerVersion = await getIndexerLastSuccessVersion({ aptosConfig });
-    } else {
-      const processor = await getProcessorStatus({ aptosConfig, processorType });
-      indexerVersion = processor.last_success_version;
-    }
-    if (indexerVersion >= minimumLedgerVersion) {
-      break;
-    }
-    await sleep(200);
-  }
-}
-var WaitForTransactionError = class extends Error {
-  constructor(message, lastSubmittedTransaction) {
-    super(message);
-    this.lastSubmittedTransaction = lastSubmittedTransaction;
-  }
-};
-var FailedTransactionError = class extends Error {
-  constructor(message, transaction) {
-    super(message);
-    this.transaction = transaction;
-  }
-};
-
-export {
-  getTransactions,
-  getGasPriceEstimation,
-  getTransactionByVersion,
-  getTransactionByHash,
-  isTransactionPending,
-  longWaitForTransaction,
-  waitForTransaction,
-  waitForIndexer,
-  WaitForTransactionError,
-  FailedTransactionError
-};
-//# sourceMappingURL=chunk-TBHU6ZW6.mjs.map