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

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

package/dist/esm/chunk-TLNHRJB2.mjs

@@ -1,155 +0,0 @@
-import {
-  KeylessPublicKey,
-  KeylessSignature
-} from "./chunk-4OYYOYSO.mjs";
-import {
-  Secp256k1PublicKey,
-  Secp256k1Signature
-} from "./chunk-DIYZRGR6.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  Signature
-} from "./chunk-FDWJNY4U.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-FXKSE3ZP.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-UEBBLQJ5.mjs";
-
-// src/core/crypto/singleKey.ts
-var AnyPublicKey = class _AnyPublicKey extends AccountPublicKey {
-  // region Constructors
-  constructor(publicKey) {
-    super();
-    this.publicKey = publicKey;
-    if (publicKey instanceof Ed25519PublicKey) {
-      this.variant = 0 /* Ed25519 */;
-    } else if (publicKey instanceof Secp256k1PublicKey) {
-      this.variant = 1 /* Secp256k1 */;
-    } else if (publicKey instanceof KeylessPublicKey) {
-      this.variant = 3 /* Keyless */;
-    } else {
-      throw new Error("Unsupported public key type");
-    }
-  }
-  // endregion
-  // region AccountPublicKey
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (!(signature instanceof AnySignature)) {
-      return false;
-    }
-    return this.publicKey.verifySignature({
-      message,
-      signature: signature.signature
-    });
-  }
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 2 /* SingleKey */,
-      input: this.toUint8Array()
-    });
-  }
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.publicKey.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let publicKey;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        publicKey = Ed25519PublicKey.deserialize(deserializer);
-        break;
-      case 1 /* Secp256k1 */:
-        publicKey = Secp256k1PublicKey.deserialize(deserializer);
-        break;
-      case 3 /* Keyless */:
-        publicKey = KeylessPublicKey.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
-    }
-    return new _AnyPublicKey(publicKey);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof AnyPublicKey` instead.
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _AnyPublicKey;
-  }
-  /**
-   * @deprecated use `publicKey instanceof Ed25519PublicKey` instead.
-   */
-  isEd25519() {
-    return this.publicKey instanceof Ed25519PublicKey;
-  }
-  /**
-   * @deprecated use `publicKey instanceof Secp256k1PublicKey` instead.
-   */
-  isSecp256k1PublicKey() {
-    return this.publicKey instanceof Secp256k1PublicKey;
-  }
-};
-var AnySignature = class _AnySignature extends Signature {
-  // region Constructors
-  constructor(signature) {
-    super();
-    this.signature = signature;
-    if (signature instanceof Ed25519Signature) {
-      this.variant = 0 /* Ed25519 */;
-    } else if (signature instanceof Secp256k1Signature) {
-      this.variant = 1 /* Secp256k1 */;
-    } else if (signature instanceof KeylessSignature) {
-      this.variant = 3 /* Keyless */;
-    } else {
-      throw new Error("Unsupported signature type");
-    }
-  }
-  // endregion
-  // region AccountSignature
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.signature.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let signature;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        signature = Ed25519Signature.deserialize(deserializer);
-        break;
-      case 1 /* Secp256k1 */:
-        signature = Secp256k1Signature.deserialize(deserializer);
-        break;
-      case 3 /* Keyless */:
-        signature = KeylessSignature.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
-    }
-    return new _AnySignature(signature);
-  }
-  // endregion
-};
-
-export {
-  AnyPublicKey,
-  AnySignature
-};
-//# sourceMappingURL=chunk-TLNHRJB2.mjs.map

package/dist/esm/chunk-U3IUCR2G.mjs

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