@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0-zeta.0

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/typeTag/parser.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  StructTag,\n  TypeTag,\n  TypeTagAddress,\n  TypeTagBool,\n  TypeTagGeneric,\n  TypeTagReference,\n  TypeTagSigner,\n  TypeTagStruct,\n  TypeTagU128,\n  TypeTagU16,\n  TypeTagU256,\n  TypeTagU32,\n  TypeTagU64,\n  TypeTagU8,\n  TypeTagVector,\n} from \".\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"../instances/identifier\";\n\n/**\n * Determines if the provided string is a valid Move identifier, which can only contain alphanumeric characters and underscores.\n * @param str - The string to validate as a Move identifier.\n * @group Implementation\n * @category Transactions\n */\nfunction isValidIdentifier(str: string) {\n  return !!str.match(/^[_a-zA-Z0-9]+$/);\n}\n\n/**\n * Determines if the provided character is a whitespace character. This function only works for single characters.\n * @param char - The character to check for whitespace.\n * @group Implementation\n * @category Transactions\n */\nfunction isValidWhitespaceCharacter(char: string) {\n  return !!char.match(/\\s/);\n}\n\n/**\n * Determines if a given string represents a generic type from the ABI, specifically in the format T0, T1, etc.\n * @param str - The string to evaluate for generic type format.\n * @group Implementation\n * @category Transactions\n */\nfunction isGeneric(str: string) {\n  return !!str.match(/^T[0-9]+$/);\n}\n\n/**\n * Determines if the provided string is a reference type, which is indicated by starting with an ampersand (&).\n * @param str - The string to evaluate for reference type.\n * @group Implementation\n * @category Transactions\n */\nfunction isRef(str: string) {\n  return !!str.match(/^&.+$/);\n}\n\n/**\n * Determines if the provided string represents a primitive type.\n * @param str - The string to evaluate as a potential primitive type.\n * @returns A boolean indicating whether the string is a primitive type.\n * @group Implementation\n * @category Transactions\n */\nfunction isPrimitive(str: string) {\n  switch (str) {\n    case \"signer\":\n    case \"address\":\n    case \"bool\":\n    case \"u8\":\n    case \"u16\":\n    case \"u32\":\n    case \"u64\":\n    case \"u128\":\n    case \"u256\":\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Consumes all whitespace characters in a string starting from a specified position.\n *\n * @param tagStr - The string from which to consume whitespace.\n * @param pos - The position in the string to start consuming whitespace from.\n * @returns The new position in the string after consuming whitespace.\n * @group Implementation\n * @category Transactions\n */\nfunction consumeWhitespace(tagStr: string, pos: number) {\n  let i = pos;\n  for (; i < tagStr.length; i += 1) {\n    const innerChar = tagStr[i];\n\n    if (!isValidWhitespaceCharacter(innerChar)) {\n      // If it's not colons, and it's an invalid character, we will stop here\n      break;\n    }\n  }\n  return i;\n}\n\n/**\n * State for TypeTag parsing, maintained on a stack to track the current parsing state.\n * @group Implementation\n * @category Transactions\n */\ntype TypeTagState = {\n  savedExpectedTypes: number;\n  savedStr: string;\n  savedTypes: Array<TypeTag>;\n};\n\n/**\n * Error types related to parsing type tags, indicating various issues encountered during the parsing process.\n * @group Implementation\n * @category Transactions\n */\nexport enum TypeTagParserErrorType {\n  InvalidTypeTag = \"unknown type\",\n  UnexpectedGenericType = \"unexpected generic type\",\n  UnexpectedTypeArgumentClose = \"unexpected '>'\",\n  UnexpectedWhitespaceCharacter = \"unexpected whitespace character\",\n  UnexpectedComma = \"unexpected ','\",\n  TypeArgumentCountMismatch = \"type argument count doesn't match expected amount\",\n  MissingTypeArgumentClose = \"no matching '>' for '<'\",\n  MissingTypeArgument = \"no type argument before ','\",\n  UnexpectedPrimitiveTypeArguments = \"primitive types not expected to have type arguments\",\n  UnexpectedVectorTypeArgumentCount = \"vector type expected to have exactly one type argument\",\n  UnexpectedStructFormat = \"unexpected struct format, must be of the form 0xaddress::module_name::struct_name\",\n  InvalidModuleNameCharacter = \"module name must only contain alphanumeric or '_' characters\",\n  InvalidStructNameCharacter = \"struct name must only contain alphanumeric or '_' characters\",\n  InvalidAddress = \"struct address must be valid\",\n}\n\n/**\n * Represents an error that occurs during the parsing of a type tag.\n * This error extends the built-in Error class and provides additional context\n * regarding the specific type tag that failed to parse and the reason for the failure.\n *\n * @param typeTagStr - The type tag string that failed to be parsed.\n * @param invalidReason - The reason why the type tag string is considered invalid.\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagParserError extends Error {\n  /**\n   * Constructs an error indicating a failure to parse a type tag.\n   * This error provides details about the specific type tag that could not be parsed and the reason for the failure.\n   *\n   * @param typeTagStr - The string representation of the type tag that failed to parse.\n   * @param invalidReason - The reason why the type tag is considered invalid.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType) {\n    super(`Failed to parse typeTag '${typeTagStr}', ${invalidReason}`);\n  }\n}\n\n/**\n * Parses a type string into a structured representation of type tags, accommodating various formats including generics and\n * nested types.\n *\n * This function can help you accurately interpret type strings, which can include simple types, standalone structs, and complex\n * nested generics.\n * It supports multiple generics, spacing within generics, and nested generics of varying depths.\n * All types are made of a few parts they're either:\n * 1. A simple type e.g. u8\n * 2. A standalone struct e.g. 0x1::account::Account\n * 3. A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin>\n *\n * There are a few more special cases that need to be handled, however.\n * 1. Multiple generics e.g. 0x1::pair::Pair<u8, u16>\n * 2. Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16>\n * 3. Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8>\n * 4. Generics for types in ABIs are filled in with placeholders e.g. T1, T2, T3\n * @param typeStr - The string representation of the type to be parsed.\n * @param options - Optional settings for parsing behavior.\n * @param options.allowGenerics - A flag indicating whether to allow generics in the parsing process.\n * @returns The parsed type tag representation.\n * @throws TypeTagParserError if the type string is malformed or does not conform to expected formats.\n * @group Implementation\n * @category Transactions\n */\nexport function parseTypeTag(typeStr: string, options?: { allowGenerics?: boolean }) {\n  const allowGenerics = options?.allowGenerics ?? false;\n\n  const saved: Array<TypeTagState> = [];\n  // This represents the internal types for a type tag e.g. '0x1::coin::Coin<innerTypes>'\n  let innerTypes: Array<TypeTag> = [];\n  // This represents the current parsed types in a comma list e.g. 'u8, u8'\n  let curTypes: Array<TypeTag> = [];\n  // This represents the current character index\n  let cur: number = 0;\n  // This represents the current working string as a type or struct name\n  let currentStr: string = \"\";\n  let expectedTypes: number = 1;\n\n  // Iterate through each character, and handle the border conditions\n  while (cur < typeStr.length) {\n    const char = typeStr[cur];\n\n    if (char === \"<\") {\n      // Start of a type argument, push current state onto a stack\n      saved.push({\n        savedExpectedTypes: expectedTypes,\n        savedStr: currentStr,\n        savedTypes: curTypes,\n      });\n\n      // Clear current state\n      currentStr = \"\";\n      curTypes = [];\n      expectedTypes = 1;\n    } else if (char === \">\") {\n      // Process last type, if there is no type string, then don't parse it\n      if (currentStr !== \"\") {\n        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n        curTypes.push(newType);\n      }\n\n      // Pop off stack outer type, if there's nothing left, there were too many '>'\n      const savedPop = saved.pop();\n      if (savedPop === undefined) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedTypeArgumentClose);\n      }\n\n      // If the expected types don't match the number of commas, then we also fail\n      if (expectedTypes !== curTypes.length) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.TypeArgumentCountMismatch);\n      }\n\n      // Add in the new created type, shifting the current types to the inner types\n      const { savedStr, savedTypes, savedExpectedTypes } = savedPop;\n      innerTypes = curTypes;\n      curTypes = savedTypes;\n      currentStr = savedStr;\n      expectedTypes = savedExpectedTypes;\n    } else if (char === \",\") {\n      // Comma means we need to start parsing a new tag, push the previous one to the curTypes\n\n      // No top level commas (not in a type <> are allowed)\n      if (saved.length === 0) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedComma);\n      }\n      // If there was no actual value before the comma, then it's missing a type argument\n      if (currentStr.length === 0) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.MissingTypeArgument);\n      }\n\n      // Process characters before as a type\n      const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n\n      // parse type tag and push it on the types\n      innerTypes = [];\n      curTypes.push(newType);\n      currentStr = \"\";\n      expectedTypes += 1;\n    } else if (isValidWhitespaceCharacter(char)) {\n      // This means we should save what we have and everything else should skip until the next\n      let parsedTypeTag = false;\n      if (currentStr.length !== 0) {\n        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n\n        // parse type tag and push it on the types\n        innerTypes = [];\n        curTypes.push(newType);\n        currentStr = \"\";\n        parsedTypeTag = true;\n      }\n\n      // Skip ahead on any more whitespace\n      cur = consumeWhitespace(typeStr, cur);\n\n      // The next space MUST be a comma, or a closing > if there was something parsed before\n      // e.g. `u8 u8` is invalid but `u8, u8` is valid\n      const nextChar = typeStr[cur];\n      if (cur < typeStr.length && parsedTypeTag && nextChar !== \",\" && nextChar !== \">\") {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedWhitespaceCharacter);\n      }\n\n      // eslint-disable-next-line no-continue\n      continue;\n    } else {\n      // Any other characters just append to the current string\n      currentStr += char;\n    }\n\n    cur += 1;\n  }\n\n  // This prevents a missing '>' on type arguments\n  if (saved.length > 0) {\n    throw new TypeTagParserError(typeStr, TypeTagParserErrorType.MissingTypeArgumentClose);\n  }\n\n  // This prevents 'u8, u8' as an input\n  switch (curTypes.length) {\n    case 0:\n      return parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n    case 1:\n      if (currentStr === \"\") {\n        return curTypes[0];\n      }\n      throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedComma);\n    default:\n      throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedWhitespaceCharacter);\n  }\n}\n\n/**\n * Parses a type tag with internal types associated, allowing for the inclusion of generics if specified. This function helps in\n * constructing the appropriate type tags based on the provided string representation and associated types.\n *\n * @param str - The string representation of the type tag to parse.\n * @param types - An array of TypeTag instances that represent internal types associated with the type tag.\n * @param allowGenerics - A boolean indicating whether generics are allowed in the parsing of the type tag.\n * @group Implementation\n * @category Transactions\n */\nfunction parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: boolean): TypeTag {\n  const trimmedStr = str.trim();\n  const lowerCaseTrimmed = trimmedStr.toLowerCase();\n  if (isPrimitive(lowerCaseTrimmed)) {\n    if (types.length > 0) {\n      throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n    }\n  }\n\n  switch (trimmedStr.toLowerCase()) {\n    case \"signer\":\n      return new TypeTagSigner();\n    case \"bool\":\n      return new TypeTagBool();\n    case \"address\":\n      return new TypeTagAddress();\n    case \"u8\":\n      return new TypeTagU8();\n    case \"u16\":\n      return new TypeTagU16();\n    case \"u32\":\n      return new TypeTagU32();\n    case \"u64\":\n      return new TypeTagU64();\n    case \"u128\":\n      return new TypeTagU128();\n    case \"u256\":\n      return new TypeTagU256();\n    case \"vector\":\n      if (types.length !== 1) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedVectorTypeArgumentCount);\n      }\n      return new TypeTagVector(types[0]);\n    default:\n      // Reference will have to handle the inner type\n      if (isRef(trimmedStr)) {\n        const actualType = trimmedStr.substring(1);\n        return new TypeTagReference(parseTypeTagInner(actualType, types, allowGenerics));\n      }\n\n      // Generics are always expected to be T0 or T1\n      if (isGeneric(trimmedStr)) {\n        if (allowGenerics) {\n          return new TypeTagGeneric(Number(trimmedStr.split(\"T\")[1]));\n        }\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedGenericType);\n      }\n\n      // If the value doesn't contain a colon, then we'll assume it isn't trying to be a struct\n      if (!trimmedStr.match(/:/)) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidTypeTag);\n      }\n\n      // Parse for a struct tag\n      // eslint-disable-next-line no-case-declarations\n      const structParts = trimmedStr.split(\"::\");\n      if (structParts.length !== 3) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedStructFormat);\n      }\n\n      // Validate struct address\n      // eslint-disable-next-line no-case-declarations\n      let address: AccountAddress;\n      try {\n        address = AccountAddress.fromString(structParts[0]);\n      } catch (error: any) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidAddress);\n      }\n\n      // Validate identifier characters\n      if (!isValidIdentifier(structParts[1])) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidModuleNameCharacter);\n      }\n      if (!isValidIdentifier(structParts[2])) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidStructNameCharacter);\n      }\n\n      return new TypeTagStruct(\n        new StructTag(address, new Identifier(structParts[1]), new Identifier(structParts[2]), types),\n      );\n  }\n}\n"],"mappings":"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","names":["TypeTagParserErrorType"]}

package/dist/esm/chunk-BSCOVLWS.mjs

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

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

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

package/dist/esm/chunk-BU43ZFDJ.mjs

@@ -1,281 +0,0 @@
-import {
-  getIndexerLastSuccessVersion,
-  getProcessorStatus
-} from "./chunk-YK66QBML.mjs";
-import {
-  memoizeAsync
-} from "./chunk-BEYIOC2H.mjs";
-import {
-  getAptosFullNode,
-  paginateWithCursor
-} from "./chunk-XQFUKBY7.mjs";
-import {
-  AptosApiError
-} from "./chunk-32UQAST6.mjs";
-import {
-  sleep
-} from "./chunk-RQS33JAS.mjs";
-import {
-  DEFAULT_TXN_TIMEOUT_SEC
-} from "./chunk-5QHMFYVL.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 {
-  /**
-   * Constructs an instance of the class with a specified message and transaction response.
-   *
-   * @param message - The message associated with the transaction.
-   * @param lastSubmittedTransaction - The transaction response object containing details about the transaction.
-   * @group Implementation
-   */
-  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-BU43ZFDJ.mjs.map