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

package/dist/esm/chunk-UZLU45X7.mjs

@@ -1,274 +0,0 @@
-import {
-  getIndexerLastSuccessVersion,
-  getProcessorStatus
-} from "./chunk-I5BTSNTY.mjs";
-import {
-  memoizeAsync
-} from "./chunk-EYHRMZPO.mjs";
-import {
-  getAptosFullNode,
-  paginateWithCursor
-} from "./chunk-HCIGCJ62.mjs";
-import {
-  AptosApiError
-} from "./chunk-LITCPMVC.mjs";
-import {
-  sleep
-} from "./chunk-YPHGPN2P.mjs";
-import {
-  DEFAULT_TXN_TIMEOUT_SEC
-} from "./chunk-4K4TZF3H.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;
-  }
-};
-async function getBlockByVersion(args) {
-  const { aptosConfig, ledgerVersion, options } = args;
-  const { data: block } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getBlockByVersion",
-    path: `blocks/by_version/${ledgerVersion}`,
-    params: { with_transactions: options?.withTransactions }
-  });
-  return fillBlockTransactions({ block, ...args });
-}
-async function getBlockByHeight(args) {
-  const { aptosConfig, blockHeight, options } = args;
-  const { data: block } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getBlockByHeight",
-    path: `blocks/by_height/${blockHeight}`,
-    params: { with_transactions: options?.withTransactions }
-  });
-  return fillBlockTransactions({ block, ...args });
-}
-async function fillBlockTransactions(args) {
-  const { aptosConfig, block, options } = args;
-  if (options?.withTransactions) {
-    block.transactions = block.transactions ?? [];
-    const lastTxn = block.transactions[block.transactions.length - 1];
-    const firstVersion = BigInt(block.first_version);
-    const lastVersion = BigInt(block.last_version);
-    const curVersion = lastTxn?.version;
-    let latestVersion;
-    if (curVersion === void 0) {
-      latestVersion = firstVersion - 1n;
-    } else {
-      latestVersion = BigInt(curVersion);
-    }
-    if (latestVersion === lastVersion) {
-      return block;
-    }
-    const fetchFutures = [];
-    const pageSize = 100n;
-    for (let i = latestVersion + 1n; i < lastVersion; i += BigInt(100)) {
-      fetchFutures.push(
-        getTransactions({
-          aptosConfig,
-          options: {
-            offset: i,
-            limit: Math.min(Number(pageSize), Number(lastVersion - i + 1n))
-          }
-        })
-      );
-    }
-    const responses = await Promise.all(fetchFutures);
-    for (const txns of responses) {
-      block.transactions.push(...txns);
-    }
-  }
-  return block;
-}
-
-export {
-  getTransactions,
-  getGasPriceEstimation,
-  getTransactionByVersion,
-  getTransactionByHash,
-  isTransactionPending,
-  longWaitForTransaction,
-  waitForTransaction,
-  waitForIndexer,
-  WaitForTransactionError,
-  FailedTransactionError,
-  getBlockByVersion,
-  getBlockByHeight
-};
-//# sourceMappingURL=chunk-UZLU45X7.mjs.map

package/dist/esm/chunk-UZXDD3QH.mjs

@@ -1,327 +0,0 @@
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-import {
-  MAX_U128_BIG_INT,
-  MAX_U16_NUMBER,
-  MAX_U256_BIG_INT,
-  MAX_U32_NUMBER,
-  MAX_U64_BIG_INT,
-  MAX_U8_NUMBER
-} from "./chunk-SBB4YEPT.mjs";
-import {
-  __decorateClass
-} from "./chunk-OR7TEZ25.mjs";
-
-// src/bcs/serializer.ts
-var Serializable = class {
-  /**
-   * Serializes a `Serializable` value to its BCS representation.
-   * This function is the Typescript SDK equivalent of `bcs::to_bytes` in Move.
-   * @returns the BCS representation of the Serializable instance as a byte buffer
-   */
-  bcsToBytes() {
-    const serializer = new Serializer();
-    this.serialize(serializer);
-    return serializer.toUint8Array();
-  }
-  /**
-   * Helper function to get a value's BCS-serialized bytes as a Hex instance.
-   * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array
-   */
-  bcsToHex() {
-    const bcsBytes = this.bcsToBytes();
-    return Hex.fromHexInput(bcsBytes);
-  }
-};
-var Serializer = class {
-  // Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.
-  // `length` must be greater than 0.
-  constructor(length = 64) {
-    if (length <= 0) {
-      throw new Error("Length needs to be greater than 0");
-    }
-    this.buffer = new ArrayBuffer(length);
-    this.offset = 0;
-  }
-  ensureBufferWillHandleSize(bytes) {
-    while (this.buffer.byteLength < this.offset + bytes) {
-      const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);
-      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
-      this.buffer = newBuffer;
-    }
-  }
-  appendToBuffer(values) {
-    this.ensureBufferWillHandleSize(values.length);
-    new Uint8Array(this.buffer, this.offset).set(values);
-    this.offset += values.length;
-  }
-  serializeWithFunction(fn, bytesLength, value) {
-    this.ensureBufferWillHandleSize(bytesLength);
-    const dv = new DataView(this.buffer, this.offset);
-    fn.apply(dv, [0, value, true]);
-    this.offset += bytesLength;
-  }
-  /**
-   * Serializes a string. UTF8 string is supported.
-   *
-   * The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer.
-   * Then the string content is serialized as UTF8 encoded bytes.
-   *
-   * BCS layout for "string": string_length | string_content
-   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
-   *
-   * @example
-   * ```ts
-   * const serializer = new Serializer();
-   * serializer.serializeStr("1234abcd");
-   * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
-   * ```
-   */
-  serializeStr(value) {
-    const textEncoder = new TextEncoder();
-    this.serializeBytes(textEncoder.encode(value));
-  }
-  /**
-   * Serializes an array of bytes.
-   *
-   * BCS layout for "bytes": bytes_length | bytes
-   * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
-   */
-  serializeBytes(value) {
-    this.serializeU32AsUleb128(value.length);
-    this.appendToBuffer(value);
-  }
-  /**
-   * Serializes an array of bytes with known length. Therefore, length doesn't need to be
-   * serialized to help deserialization.
-   *
-   * When deserializing, the number of bytes to deserialize needs to be passed in.
-   */
-  serializeFixedBytes(value) {
-    this.appendToBuffer(value);
-  }
-  /**
-   * Serializes a boolean value.
-   *
-   * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
-   */
-  serializeBool(value) {
-    ensureBoolean(value);
-    const byteValue = value ? 1 : 0;
-    this.appendToBuffer(new Uint8Array([byteValue]));
-  }
-  serializeU8(value) {
-    this.appendToBuffer(new Uint8Array([value]));
-  }
-  serializeU16(value) {
-    this.serializeWithFunction(DataView.prototype.setUint16, 2, value);
-  }
-  serializeU32(value) {
-    this.serializeWithFunction(DataView.prototype.setUint32, 4, value);
-  }
-  serializeU64(value) {
-    const low = BigInt(value) & BigInt(MAX_U32_NUMBER);
-    const high = BigInt(value) >> BigInt(32);
-    this.serializeU32(Number(low));
-    this.serializeU32(Number(high));
-  }
-  serializeU128(value) {
-    const low = BigInt(value) & MAX_U64_BIG_INT;
-    const high = BigInt(value) >> BigInt(64);
-    this.serializeU64(low);
-    this.serializeU64(high);
-  }
-  serializeU256(value) {
-    const low = BigInt(value) & MAX_U128_BIG_INT;
-    const high = BigInt(value) >> BigInt(128);
-    this.serializeU128(low);
-    this.serializeU128(high);
-  }
-  serializeU32AsUleb128(val) {
-    let value = val;
-    const valueArray = [];
-    while (value >>> 7 !== 0) {
-      valueArray.push(value & 127 | 128);
-      value >>>= 7;
-    }
-    valueArray.push(value);
-    this.appendToBuffer(new Uint8Array(valueArray));
-  }
-  /**
-   * Returns the buffered bytes
-   */
-  toUint8Array() {
-    return new Uint8Array(this.buffer).slice(0, this.offset);
-  }
-  /**
-   * Serializes a `Serializable` value, facilitating composable serialization.
-   *
-   * @param value The Serializable value to serialize
-   *
-   * @example
-   * // Define the MoveStruct class that implements the Serializable interface
-   * class MoveStruct extends Serializable {
-   *     constructor(
-   *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable
-   *         public collectionName: string,
-   *         public tokenName: string
-   *     ) {}
-   *
-   *     serialize(serializer: Serializer): void {
-   *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object
-   *         serializer.serializeStr(this.collectionName);
-   *         serializer.serializeStr(this.tokenName);
-   *     }
-   * }
-   *
-   * // Construct a MoveStruct
-   * const moveStruct = new MoveStruct(new AccountAddress(...), "MyCollection", "TokenA");
-   *
-   * // Serialize a string, a u64 number, and a MoveStruct instance.
-   * const serializer = new Serializer();
-   * serializer.serializeStr("ExampleString");
-   * serializer.serializeU64(12345678);
-   * serializer.serialize(moveStruct);
-   *
-   * // Get the bytes from the Serializer instance
-   * const serializedBytes = serializer.toUint8Array();
-   *
-   * @returns the serializer instance
-   */
-  serialize(value) {
-    value.serialize(this);
-  }
-  /**
-   * Serializes an array of BCS Serializable values to a serializer instance.
-   * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
-   *
-   * @param values The array of BCS Serializable values
-   * @example
-   * const addresses = new Array<AccountAddress>(
-   *   AccountAddress.from("0x1"),
-   *   AccountAddress.from("0x2"),
-   *   AccountAddress.from("0xa"),
-   *   AccountAddress.from("0xb"),
-   * );
-   * const serializer = new Serializer();
-   * serializer.serializeVector(addresses);
-   * const serializedBytes = serializer.toUint8Array();
-   * // serializedBytes is now the BCS-serialized bytes
-   * // The equivalent value in Move would be:
-   * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
-   */
-  serializeVector(values) {
-    this.serializeU32AsUleb128(values.length);
-    values.forEach((item) => {
-      item.serialize(this);
-    });
-  }
-  /**
-   * Serializes a BCS Serializable values into a serializer instance or undefined.
-   * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
-   *
-   * @param values The array of BCS Serializable values
-   *
-   * @example
-   * ```ts
-   * const serializer = new Serializer();
-   * serializer.serializeOption(new AccountAddress(...));
-   * const serializedBytes = serializer.toUint8Array();
-   * // serializedBytes is now the BCS-serialized byte representation of AccountAddress
-   *
-   * const serializer = new Serializer();
-   * serializer.serializeOption(undefined);
-   * assert(serializer.toUint8Array() === new Uint8Array([0x00]));
-   * ```
-   */
-  serializeOption(value) {
-    const hasValue = value !== void 0;
-    this.serializeBool(hasValue);
-    if (hasValue) {
-      value.serialize(this);
-    }
-  }
-  /**
-   * Serializes an optional string. UTF8 string is supported.
-   *
-   * The existence of the string is encoded first, 0 if undefined and 1 if it exists.
-   * Them the number of bytes in the string content is serialized, as a uleb128-encoded u32 integer.
-   * Then the string content is serialized as UTF8 encoded bytes.
-   *
-   * BCS layout for optional "string": 1 | string_length | string_content
-   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
-   *
-   * BCS layout for undefined: 0
-   * @example
-   * ```ts
-   * const serializer = new Serializer();
-   * serializer.serializeOptionStr("1234abcd");
-   * assert(serializer.toUint8Array() === new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
-   *
-   * const serializer = new Serializer();
-   * serializer.serializeOptionStr(undefined);
-   * assert(serializer.toUint8Array() === new Uint8Array([0]));
-   * ```
-   */
-  serializeOptionStr(value) {
-    if (value === void 0) {
-      this.serializeU32AsUleb128(0);
-    } else {
-      this.serializeU32AsUleb128(1);
-      this.serializeStr(value);
-    }
-  }
-};
-__decorateClass([
-  checkNumberRange(0, MAX_U8_NUMBER)
-], Serializer.prototype, "serializeU8", 1);
-__decorateClass([
-  checkNumberRange(0, MAX_U16_NUMBER)
-], Serializer.prototype, "serializeU16", 1);
-__decorateClass([
-  checkNumberRange(0, MAX_U32_NUMBER)
-], Serializer.prototype, "serializeU32", 1);
-__decorateClass([
-  checkNumberRange(BigInt(0), MAX_U64_BIG_INT)
-], Serializer.prototype, "serializeU64", 1);
-__decorateClass([
-  checkNumberRange(BigInt(0), MAX_U128_BIG_INT)
-], Serializer.prototype, "serializeU128", 1);
-__decorateClass([
-  checkNumberRange(BigInt(0), MAX_U256_BIG_INT)
-], Serializer.prototype, "serializeU256", 1);
-__decorateClass([
-  checkNumberRange(0, MAX_U32_NUMBER)
-], Serializer.prototype, "serializeU32AsUleb128", 1);
-function ensureBoolean(value) {
-  if (typeof value !== "boolean") {
-    throw new Error(`${value} is not a boolean value`);
-  }
-}
-var outOfRangeErrorMessage = (value, min, max) => `${value} is out of range: [${min}, ${max}]`;
-function validateNumberInRange(value, minValue, maxValue) {
-  const valueBigInt = BigInt(value);
-  if (valueBigInt > BigInt(maxValue) || valueBigInt < BigInt(minValue)) {
-    throw new Error(outOfRangeErrorMessage(value, minValue, maxValue));
-  }
-}
-function checkNumberRange(minValue, maxValue) {
-  return (target, propertyKey, descriptor) => {
-    const childFunction = descriptor.value;
-    descriptor.value = function deco(value) {
-      validateNumberInRange(value, minValue, maxValue);
-      return childFunction.apply(this, [value]);
-    };
-    return descriptor;
-  };
-}
-
-export {
-  Serializable,
-  Serializer,
-  ensureBoolean,
-  outOfRangeErrorMessage,
-  validateNumberInRange
-};
-//# sourceMappingURL=chunk-UZXDD3QH.mjs.map

package/dist/esm/chunk-V2LEZDNS.mjs

@@ -1,29 +0,0 @@
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-
-// src/core/account/utils/address.ts
-import { sha3_256 } from "@noble/hashes/sha3";
-var createObjectAddress = (creatorAddress, seed) => {
-  const creatorBytes = creatorAddress.bcsToBytes();
-  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : seed;
-  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, 254 /* DeriveObjectAddressFromSeed */]);
-  return new AccountAddress(sha3_256(bytes));
-};
-var createResourceAddress = (creatorAddress, seed) => {
-  const creatorBytes = creatorAddress.bcsToBytes();
-  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : seed;
-  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, 255 /* DeriveResourceAccountAddress */]);
-  return new AccountAddress(sha3_256(bytes));
-};
-var createTokenAddress = (creatorAddress, collectionName, tokenName) => {
-  const seed = `${collectionName}::${tokenName}`;
-  return createObjectAddress(creatorAddress, seed);
-};
-
-export {
-  createObjectAddress,
-  createResourceAddress,
-  createTokenAddress
-};
-//# sourceMappingURL=chunk-V2LEZDNS.mjs.map

package/dist/esm/chunk-WKNU6EPA.mjs

@@ -1,40 +0,0 @@
-import {
-  getObjectDataByObjectAddress
-} from "./chunk-U6N546EH.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-PSRD6U34.mjs";
-
-// src/api/object.ts
-var AptosObject = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Fetch the object data based on the oabject address
-   *
-   * @example
-   * const object = await aptos.getObjectDataByObjectAddress({objectAddress:"0x123"})
-   *
-   * @param args.objectAddress The object address
-   * @param args.options Configuration options for waitForTransaction
-   *
-   * @returns The object data
-   */
-  async getObjectDataByObjectAddress(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "objects_processor" /* OBJECT_PROCESSOR */
-    });
-    return getObjectDataByObjectAddress({
-      aptosConfig: this.config,
-      ...args
-    });
-  }
-};
-
-export {
-  AptosObject
-};
-//# sourceMappingURL=chunk-WKNU6EPA.mjs.map