@aptos-labs/ts-sdk 1.37.1 → 1.39.0

package/dist/esm/chunk-VHY6ZATX.mjs

@@ -1,2 +0,0 @@
-import{a as i}from"./chunk-IF4UU2MT.mjs";import{bytesToHex as o,hexToBytes as s}from"@noble/hashes/utils";var g=(n=>(n.TOO_SHORT="too_short",n.INVALID_LENGTH="invalid_length",n.INVALID_HEX_CHARS="invalid_hex_chars",n))(g||{}),a=class e{constructor(t){this.data=t}toUint8Array(){return this.data}toStringWithoutPrefix(){return o(this.data)}toString(){return`0x${this.toStringWithoutPrefix()}`}static fromHexString(t){let r=t;if(r.startsWith("0x")&&(r=r.slice(2)),r.length===0)throw new i("Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.","too_short");if(r.length%2!==0)throw new i("Hex string must be an even number of hex characters.","invalid_length");try{return new e(s(r))}catch(n){throw new i(`Hex string contains invalid hex characters: ${n?.message}`,"invalid_hex_chars")}}static fromHexInput(t){if(t instanceof Buffer)return new e(new Uint8Array(t));if(t instanceof Uint8Array)return new e(t);if(typeof t=="string")return e.fromHexString(t);throw new Error(`Invalid hex input type: ${typeof t}`)}static hexInputToUint8Array(t){return t instanceof Uint8Array?t:e.fromHexString(t).toUint8Array()}static hexInputToString(t){return e.fromHexInput(t).toString()}static hexInputToStringWithoutPrefix(t){return e.fromHexInput(t).toStringWithoutPrefix()}static isValid(t){try{return e.fromHexString(t),{valid:!0}}catch(r){return{valid:!1,invalidReason:r?.invalidReason,invalidReasonMessage:r?.message}}}equals(t){return this.data.length!==t.data.length?!1:this.data.every((r,n)=>r===t.data[n])}},l=e=>new TextDecoder().decode(a.fromHexInput(e).toUint8Array());export{g as a,a as b,l as c};
-//# sourceMappingURL=chunk-VHY6ZATX.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/hex.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bytesToHex, hexToBytes } from \"@noble/hashes/utils\";\nimport { ParsingError, ParsingResult } from \"./common\";\nimport { HexInput } from \"../types\";\n\n/**\n * Provides reasons for parsing failures related to hexadecimal values.\n * @group Implementation\n * @category Serialization\n */\nexport enum HexInvalidReason {\n  TOO_SHORT = \"too_short\",\n  INVALID_LENGTH = \"invalid_length\",\n  INVALID_HEX_CHARS = \"invalid_hex_chars\",\n}\n\n/**\n * NOTE: Do not use this class when working with account addresses; use AccountAddress instead.\n * When accepting hex data as input to a function, prefer to accept HexInput and\n *\n * A helper class for working with hex data. Hex data, when represented as a string,\n * generally looks like this, for example: 0xaabbcc, 45cd32, etc.\n *\n * then use the static helper methods of this class to convert it into the desired\n * format. This enables the greatest flexibility for the developer.\n *\n * Example usage:\n * ```typescript\n * getTransactionByHash(txnHash: HexInput): Promise<Transaction> {\n *   const txnHashString = Hex.fromHexInput(txnHash).toString();\n *   return await getTransactionByHashInner(txnHashString);\n * }\n * ```\n * This call to `Hex.fromHexInput().toString()` converts the HexInput to a hex string\n * with a leading 0x prefix, regardless of what the input format was.\n *\n * Other ways to chain the functions together:\n * - `Hex.fromHexString({ hexInput: \"0x1f\" }).toUint8Array()`\n * - `new Hex([1, 3]).toStringWithoutPrefix()`\n * @group Implementation\n * @category Serialization\n */\nexport class Hex {\n  private readonly data: Uint8Array;\n\n  /**\n   * Create a new Hex instance from a Uint8Array.\n   *\n   * @param data - The Uint8Array containing the data to initialize the Hex instance.\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(data: Uint8Array) {\n    this.data = data;\n  }\n\n  // ===\n  // Methods for representing an instance of Hex as other types.\n  // ===\n\n  /**\n   * Get the inner hex data as a Uint8Array. The inner data is already a Uint8Array, so no conversion takes place.\n   *\n   * @returns Hex data as Uint8Array\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    return this.data;\n  }\n\n  /**\n   * Get the hex data as a string without the 0x prefix.\n   *\n   * @returns Hex string without 0x prefix\n   * @group Implementation\n   * @category Serialization\n   */\n  toStringWithoutPrefix(): string {\n    return bytesToHex(this.data);\n  }\n\n  /**\n   * Get the hex data as a string with the 0x prefix.\n   *\n   * @returns Hex string with 0x prefix\n   * @group Implementation\n   * @category Serialization\n   */\n  toString(): string {\n    return `0x${this.toStringWithoutPrefix()}`;\n  }\n\n  // ===\n  // Methods for creating an instance of Hex from other types.\n  // ===\n\n  /**\n   * Converts a hex string into a Hex instance, allowing for both prefixed and non-prefixed formats.\n   *\n   * @param str - A hex string, with or without the 0x prefix.\n   *\n   * @throws ParsingError - If the hex string is too short, has an odd number of characters, or contains invalid hex characters.\n   *\n   * @returns Hex - The resulting Hex instance created from the provided string.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromHexString(str: string): Hex {\n    let input = str;\n\n    if (input.startsWith(\"0x\")) {\n      input = input.slice(2);\n    }\n\n    if (input.length === 0) {\n      throw new ParsingError(\n        \"Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.\",\n        HexInvalidReason.TOO_SHORT,\n      );\n    }\n\n    if (input.length % 2 !== 0) {\n      throw new ParsingError(\"Hex string must be an even number of hex characters.\", HexInvalidReason.INVALID_LENGTH);\n    }\n\n    try {\n      return new Hex(hexToBytes(input));\n    } catch (error: any) {\n      throw new ParsingError(\n        `Hex string contains invalid hex characters: ${error?.message}`,\n        HexInvalidReason.INVALID_HEX_CHARS,\n      );\n    }\n  }\n\n  /**\n   * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Hex instance.\n   * This function is useful for transforming hexadecimal representations into a structured Hex object for further manipulation.\n   *\n   * @param hexInput - A HexInput which can be a string or Uint8Array.\n   * @returns A Hex instance created from the provided hexInput.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromHexInput(hexInput: HexInput): Hex {\n    if (hexInput instanceof Buffer) return new Hex(new Uint8Array(hexInput));\n    if (hexInput instanceof Uint8Array) return new Hex(hexInput);\n    if (typeof hexInput === \"string\") return Hex.fromHexString(hexInput);\n    throw new Error(`Invalid hex input type: ${typeof hexInput}`);\n  }\n\n  /**\n   * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Uint8Array.\n   *\n   * @param hexInput - A HexInput which can be a string or Uint8Array.\n   * @returns A Uint8Array created from the provided hexInput.\n   */\n  static hexInputToUint8Array(hexInput: HexInput): Uint8Array {\n    if (hexInput instanceof Uint8Array) return hexInput;\n    return Hex.fromHexString(hexInput).toUint8Array();\n  }\n\n  /**\n   * Converts a HexInput (string or Uint8Array) to a hex string with '0x' prefix.\n   *\n   * @param hexInput - The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array\n   * @returns A hex string with '0x' prefix (e.g., \"0x1234\")\n   *\n   * @example\n   * ```typescript\n   * Hex.hexInputToString(\"1234\")        // returns \"0x1234\"\n   * Hex.hexInputToString(\"0x1234\")      // returns \"0x1234\"\n   * Hex.hexInputToString(new Uint8Array([0x12, 0x34])) // returns \"0x1234\"\n   * ```\n   */\n  static hexInputToString(hexInput: HexInput): string {\n    return Hex.fromHexInput(hexInput).toString();\n  }\n\n  /**\n   * Converts a HexInput (string or Uint8Array) to a hex string without '0x' prefix.\n   *\n   * @param hexInput - The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array\n   * @returns A hex string without '0x' prefix (e.g., \"1234\")\n   *\n   * @example\n   * ```typescript\n   * Hex.hexInputToStringWithoutPrefix(\"1234\")        // returns \"1234\"\n   * Hex.hexInputToStringWithoutPrefix(\"0x1234\")      // returns \"1234\"\n   * Hex.hexInputToStringWithoutPrefix(new Uint8Array([0x12, 0x34])) // returns \"1234\"\n   * ```\n   */\n  static hexInputToStringWithoutPrefix(hexInput: HexInput): string {\n    return Hex.fromHexInput(hexInput).toStringWithoutPrefix();\n  }\n\n  // ===\n  // Methods for checking validity.\n  // ===\n\n  /**\n   * Check if the provided string is a valid hexadecimal representation.\n   *\n   * @param str - A hex string representing byte data.\n   *\n   * @returns An object containing:\n   *  - valid: A boolean indicating whether the string is valid.\n   *  - invalidReason: The reason for invalidity if the string is not valid.\n   *  - invalidReasonMessage: A message explaining why the string is invalid.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isValid(str: string): ParsingResult<HexInvalidReason> {\n    try {\n      Hex.fromHexString(str);\n      return { valid: true };\n    } catch (error: any) {\n      return {\n        valid: false,\n        invalidReason: error?.invalidReason,\n        invalidReasonMessage: error?.message,\n      };\n    }\n  }\n\n  /**\n   * Determine if two Hex instances are equal by comparing their underlying byte data.\n   *\n   * @param other The Hex instance to compare to.\n   * @returns true if the Hex instances are equal, false if not.\n   * @group Implementation\n   * @category Serialization\n   */\n  equals(other: Hex): boolean {\n    if (this.data.length !== other.data.length) return false;\n    return this.data.every((value, index) => value === other.data[index]);\n  }\n}\n\nexport const hexToAsciiString = (hex: string) => new TextDecoder().decode(Hex.fromHexInput(hex).toUint8Array());\n"],"mappings":"yCAGA,OAAS,cAAAA,EAAY,cAAAC,MAAkB,sBAShC,IAAKC,OACVA,EAAA,UAAY,YACZA,EAAA,eAAiB,iBACjBA,EAAA,kBAAoB,oBAHVA,OAAA,IAgCCC,EAAN,MAAMC,CAAI,CAUf,YAAYC,EAAkB,CAC5B,KAAK,KAAOA,CACd,CAaA,cAA2B,CACzB,OAAO,KAAK,IACd,CASA,uBAAgC,CAC9B,OAAOC,EAAW,KAAK,IAAI,CAC7B,CASA,UAAmB,CACjB,MAAO,KAAK,KAAK,sBAAsB,CAAC,EAC1C,CAiBA,OAAO,cAAcC,EAAkB,CACrC,IAAIC,EAAQD,EAMZ,GAJIC,EAAM,WAAW,IAAI,IACvBA,EAAQA,EAAM,MAAM,CAAC,GAGnBA,EAAM,SAAW,EACnB,MAAM,IAAIC,EACR,4FACA,WACF,EAGF,GAAID,EAAM,OAAS,IAAM,EACvB,MAAM,IAAIC,EAAa,uDAAwD,gBAA+B,EAGhH,GAAI,CACF,OAAO,IAAIL,EAAIM,EAAWF,CAAK,CAAC,CAClC,OAASG,EAAY,CACnB,MAAM,IAAIF,EACR,+CAA+CE,GAAO,OAAO,GAC7D,mBACF,CACF,CACF,CAWA,OAAO,aAAaC,EAAyB,CAC3C,GAAIA,aAAoB,OAAQ,OAAO,IAAIR,EAAI,IAAI,WAAWQ,CAAQ,CAAC,EACvE,GAAIA,aAAoB,WAAY,OAAO,IAAIR,EAAIQ,CAAQ,EAC3D,GAAI,OAAOA,GAAa,SAAU,OAAOR,EAAI,cAAcQ,CAAQ,EACnE,MAAM,IAAI,MAAM,2BAA2B,OAAOA,CAAQ,EAAE,CAC9D,CAQA,OAAO,qBAAqBA,EAAgC,CAC1D,OAAIA,aAAoB,WAAmBA,EACpCR,EAAI,cAAcQ,CAAQ,EAAE,aAAa,CAClD,CAeA,OAAO,iBAAiBA,EAA4B,CAClD,OAAOR,EAAI,aAAaQ,CAAQ,EAAE,SAAS,CAC7C,CAeA,OAAO,8BAA8BA,EAA4B,CAC/D,OAAOR,EAAI,aAAaQ,CAAQ,EAAE,sBAAsB,CAC1D,CAkBA,OAAO,QAAQL,EAA8C,CAC3D,GAAI,CACF,OAAAH,EAAI,cAAcG,CAAG,EACd,CAAE,MAAO,EAAK,CACvB,OAASI,EAAY,CACnB,MAAO,CACL,MAAO,GACP,cAAeA,GAAO,cACtB,qBAAsBA,GAAO,OAC/B,CACF,CACF,CAUA,OAAOE,EAAqB,CAC1B,OAAI,KAAK,KAAK,SAAWA,EAAM,KAAK,OAAe,GAC5C,KAAK,KAAK,MAAM,CAACC,EAAOC,IAAUD,IAAUD,EAAM,KAAKE,CAAK,CAAC,CACtE,CACF,EAEaC,EAAoBC,GAAgB,IAAI,YAAY,EAAE,OAAOd,EAAI,aAAac,CAAG,EAAE,aAAa,CAAC","names":["bytesToHex","hexToBytes","HexInvalidReason","Hex","_Hex","data","bytesToHex","str","input","ParsingError","hexToBytes","error","hexInput","other","value","index","hexToAsciiString","hex"]}

package/dist/esm/chunk-YVRPD7Z6.mjs

@@ -1,2 +0,0 @@
-import{c as d,d as c}from"./chunk-CICJRLYU.mjs";async function p(e){let{aptosConfig:t,overrides:s,params:r,contentType:n,acceptType:i,path:a,originMethod:o,type:u}=e,R=t.getRequestUrl(u);return d({url:R,method:"GET",originMethod:o,path:a,contentType:n,acceptType:i,params:r,overrides:{...t.clientConfig,...s}},t,e.type)}async function f(e){let{aptosConfig:t,overrides:s,params:r,contentType:n,acceptType:i,path:a,originMethod:o,type:u}=e,R=t.getRequestUrl(u);return c({url:R,method:"GET",originMethod:o,path:a,contentType:n,acceptType:i,params:r,overrides:{...t.clientConfig,...s}},t,e.type)}async function q(e){let{aptosConfig:t}=e;return p({...e,type:"Fullnode",overrides:{...t.clientConfig,...t.fullnodeConfig,...e.overrides,HEADERS:{...t.clientConfig?.HEADERS,...t.fullnodeConfig?.HEADERS}}})}async function A(e){let{aptosConfig:t}=e;return f({...e,type:"Fullnode",overrides:{...t.clientConfig,...t.fullnodeConfig,...e.overrides,HEADERS:{...t.clientConfig?.HEADERS,...t.fullnodeConfig?.HEADERS}}})}async function C(e){return p({...e,type:"Pepper"})}async function h(e){let t=new Array(0),s,r=e.params;do{let n=await p({type:"Fullnode",aptosConfig:e.aptosConfig,originMethod:e.originMethod,path:e.path,params:r,overrides:e.overrides});s=n.headers["x-aptos-cursor"],delete n.headers,t.push(...n.data),r.start=s}while(s!=null);return t}async function x(e){let t=new Array(0),s,r=e.params,n=r.limit;do{let{response:i,cursor:a}=await g({...e});if(s=a,t.push(...i.data),e?.params&&(e.params.start=s),n!==void 0){let o=n-t.length;if(o<=0)break;r.limit=o}}while(s!=null);return t}async function g(e){let t,s={};typeof e.params?.cursor=="string"&&(s.start=e.params.cursor),typeof e.params?.limit=="number"&&(s.limit=e.params.limit);let r=await p({type:"Fullnode",aptosConfig:e.aptosConfig,originMethod:e.originMethod,path:e.path,params:s,overrides:e.overrides});return t=r.headers["x-aptos-cursor"],{response:r,cursor:t}}export{p as a,f as b,q as c,A as d,C as e,h as f,x as g,g as h};
-//# sourceMappingURL=chunk-YVRPD7Z6.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/client/get.ts"],"sourcesContent":["import { AptosConfig } from \"../api/aptosConfig\";\nimport { aptosBinaryRequest, aptosRequest } from \"./core\";\nimport { AptosResponse, AnyNumber, ClientConfig, MimeType } from \"../types\";\nimport { AptosApiType } from \"../utils/const\";\n\n/**\n * Options for making a GET request, including configuration for the API client.\n * @group Implementation\n * @category Client\n */\nexport type GetRequestOptions = {\n  /**\n   * The config for the API client\n   * @group Implementation\n   * @category Client\n   */\n  aptosConfig: AptosConfig;\n  /**\n   * The type of API endpoint to call e.g. fullnode, indexer, etc\n   * @group Implementation\n   * @category Client\n   */\n  type: AptosApiType;\n  /**\n   * The name of the API method\n   * @group Implementation\n   * @category Client\n   */\n  originMethod: string;\n  /**\n   * The URL path to the API method\n   * @group Implementation\n   * @category Client\n   */\n  path: string;\n  /**\n   * The content type of the request body\n   * @group Implementation\n   * @category Client\n   */\n  contentType?: MimeType;\n  /**\n   * The accepted content type of the response of the API\n   * @group Implementation\n   * @category Client\n   */\n  acceptType?: MimeType;\n  /**\n   * The query parameters for the request\n   * @group Implementation\n   * @category Client\n   */\n  params?: Record<string, string | AnyNumber | boolean | undefined>;\n  /**\n   * Specific client overrides for this request to override aptosConfig\n   * @group Implementation\n   * @category Client\n   */\n  overrides?: ClientConfig;\n};\n\n/**\n * Options for making a request to the Aptos API, excluding the \"type\" field.\n * @group Implementation\n * @category Client\n */\nexport type GetAptosRequestOptions = Omit<GetRequestOptions, \"type\">;\n\n/**\n * Executes a GET request to retrieve data based on the provided options.\n *\n * @param options - The options for the GET request.\n * @param options.aptosConfig - The configuration object for Aptos requests.\n * @param options.overrides - Optional overrides for the request configuration.\n * @param options.params - Query parameters to include in the request.\n * @param options.contentType - The content type of the request.\n * @param options.acceptType - The accepted response type.\n * @param options.path - The specific path for the request.\n * @param options.originMethod - The original method of the request.\n * @param options.type - The type of request being made.\n * @returns The response from the GET request.\n * @group Implementation\n * @category Client\n */\nexport async function get<Req extends {}, Res extends {}>(\n  options: GetRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;\n  const url = aptosConfig.getRequestUrl(type);\n\n  return aptosRequest<Req, Res>(\n    {\n      url,\n      method: \"GET\",\n      originMethod,\n      path,\n      contentType,\n      acceptType,\n      params,\n      overrides: {\n        ...aptosConfig.clientConfig,\n        ...overrides,\n      },\n    },\n    aptosConfig,\n    options.type,\n  );\n}\n\n/**\n * Executes a GET request to retrieve data based on the provided options.\n *\n * @param options - The options for the GET request.\n * @param options.aptosConfig - The configuration object for Aptos requests.\n * @param options.overrides - Optional overrides for the request configuration.\n * @param options.params - Query parameters to include in the request.\n * @param options.contentType - The content type of the request.\n * @param options.acceptType - The accepted response type.\n * @param options.path - The specific path for the request.\n * @param options.originMethod - The original method of the request.\n * @param options.type - The type of request being made.\n * @returns The response from the GET request.\n * @group Implementation\n * @category Client\n * @experimental\n */\nexport async function getBinary<Req extends {}>(options: GetRequestOptions): Promise<AptosResponse<Req, Buffer>> {\n  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;\n  const url = aptosConfig.getRequestUrl(type);\n\n  return aptosBinaryRequest<Req>(\n    {\n      url,\n      method: \"GET\",\n      originMethod,\n      path,\n      contentType,\n      acceptType,\n      params,\n      overrides: {\n        ...aptosConfig.clientConfig,\n        ...overrides,\n      },\n    },\n    aptosConfig,\n    options.type,\n  );\n}\n\n/**\n * Retrieves data from the Aptos full node using the provided options.\n *\n * @param options - The options for the request to the Aptos full node.\n * @param options.aptosConfig - Configuration settings specific to the Aptos client and full node.\n * @param options.aptosConfig.clientConfig - The client configuration settings.\n * @param options.aptosConfig.fullnodeConfig - The full node configuration settings.\n * @param options.overrides - Additional overrides for the request.\n * @param options.type - The type of API request being made.\n *\n * @returns A promise that resolves with the response from the Aptos full node.\n * @group Implementation\n * @category Client\n */\nexport async function getAptosFullNode<Req extends {}, Res extends {}>(\n  options: GetAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  const { aptosConfig } = options;\n\n  return get<Req, Res>({\n    ...options,\n    type: AptosApiType.FULLNODE,\n    overrides: {\n      ...aptosConfig.clientConfig,\n      ...aptosConfig.fullnodeConfig,\n      ...options.overrides,\n      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS },\n    },\n  });\n}\n\n/**\n * Retrieves data from the Aptos full node using the provided options.\n *\n * @param options - The options for the request to the Aptos full node.\n * @param options.aptosConfig - Configuration settings specific to the Aptos client and full node.\n * @param options.aptosConfig.clientConfig - The client configuration settings.\n * @param options.aptosConfig.fullnodeConfig - The full node configuration settings.\n * @param options.overrides - Additional overrides for the request.\n * @param options.type - The type of API request being made.\n *\n * @returns A promise that resolves with the response from the Aptos full node.\n * @group Implementation\n * @category Client\n * @experimental\n */\nexport async function getBinaryAptosFullNode<Req extends {}>(\n  options: GetAptosRequestOptions,\n): Promise<AptosResponse<Req, Buffer>> {\n  const { aptosConfig } = options;\n\n  return getBinary<Req>({\n    ...options,\n    type: AptosApiType.FULLNODE,\n    overrides: {\n      ...aptosConfig.clientConfig,\n      ...aptosConfig.fullnodeConfig,\n      ...options.overrides,\n      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS },\n    },\n  });\n}\n\n/**\n * Makes a GET request to the Aptos Pepper service to retrieve data.\n *\n * @param options - The options for the request.\n * @param options.param1 - Description of param1.\n * @param options.param2 - Description of param2.\n * @returns AptosResponse - The response from the Aptos Pepper service.\n * @group Implementation\n * @category Client\n */\nexport async function getAptosPepperService<Req extends {}, Res extends {}>(\n  options: GetAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  return get<Req, Res>({ ...options, type: AptosApiType.PEPPER });\n}\n\n/**\n * This function is a helper for paginating using a function wrapping an API\n * @group Implementation\n * @category Client\n */\nexport async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(\n  options: GetAptosRequestOptions,\n): Promise<Res> {\n  const out: Res = new Array(0) as Res;\n  let cursor: string | undefined;\n  const requestParams = options.params as { start?: string; limit?: number };\n  do {\n    // eslint-disable-next-line no-await-in-loop\n    const response = await get<Req, Res>({\n      type: AptosApiType.FULLNODE,\n      aptosConfig: options.aptosConfig,\n      originMethod: options.originMethod,\n      path: options.path,\n      params: requestParams,\n      overrides: options.overrides,\n    });\n    /**\n     * the cursor is a \"state key\" from the API perspective. Client\n     * should not need to \"care\" what it represents but just use it\n     * to query the next chunk of data.\n     * @group Implementation\n     * @category Client\n     */\n    cursor = response.headers[\"x-aptos-cursor\"];\n    // Now that we have the cursor (if any), we remove the headers before\n    // adding these to the output of this function.\n    delete response.headers;\n    out.push(...response.data);\n    requestParams.start = cursor;\n  } while (cursor !== null && cursor !== undefined);\n  return out;\n}\n\n/// This function is a helper for paginating using a function wrapping an API using offset instead of start\nexport async function paginateWithObfuscatedCursor<Req extends Record<string, any>, Res extends Array<{}>>(\n  options: GetAptosRequestOptions,\n): Promise<Res> {\n  const out: Res = new Array(0) as Res;\n  let cursor: string | undefined;\n  const requestParams = options.params as { start?: string; limit?: number };\n  const totalLimit = requestParams.limit;\n  do {\n    // eslint-disable-next-line no-await-in-loop\n    const { response, cursor: newCursor } = await getPageWithObfuscatedCursor<Req, Res>({ ...options });\n\n    /**\n     * the cursor is a \"state key\" from the API perspective. Client\n     * should not need to \"care\" what it represents but just use it\n     * to query the next chunk of data.\n     */\n    cursor = newCursor;\n    out.push(...response.data);\n    if (options?.params) {\n      options.params.start = cursor;\n    }\n\n    // Re-evaluate length\n    if (totalLimit !== undefined) {\n      const newLimit = totalLimit - out.length;\n      if (newLimit <= 0) {\n        break;\n      }\n      requestParams.limit = newLimit;\n    }\n  } while (cursor !== null && cursor !== undefined);\n  return out;\n}\n\nexport async function getPageWithObfuscatedCursor<Req extends Record<string, any>, Res extends Array<{}>>(\n  options: GetAptosRequestOptions,\n): Promise<{ response: AptosResponse<Req, Res>; cursor: string | undefined }> {\n  let cursor: string | undefined;\n  let requestParams: { start?: string; limit?: number } = {};\n\n  // Drop any other values\n  // TODO: Throw error if cursor is not a string\n  if (typeof options.params?.cursor === \"string\") {\n    requestParams.start = options.params.cursor;\n  }\n  if (typeof options.params?.limit === \"number\") {\n    requestParams.limit = options.params.limit;\n  }\n\n  // eslint-disable-next-line no-await-in-loop\n  const response = await get<Req, Res>({\n    type: AptosApiType.FULLNODE,\n    aptosConfig: options.aptosConfig,\n    originMethod: options.originMethod,\n    path: options.path,\n    params: requestParams,\n    overrides: options.overrides,\n  });\n\n  /**\n   * the cursor is a \"state key\" from the API perspective. Client\n   * should not need to \"care\" what it represents but just use it\n   * to query the next chunk of data.\n   */\n  cursor = response.headers[\"x-aptos-cursor\"];\n  return { response, cursor };\n}\n"],"mappings":"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","names":["get","options","aptosConfig","overrides","params","contentType","acceptType","path","originMethod","type","url","aptosRequest","getBinary","aptosBinaryRequest","getAptosFullNode","getBinaryAptosFullNode","getAptosPepperService","paginateWithCursor","out","cursor","requestParams","response","paginateWithObfuscatedCursor","totalLimit","newCursor","getPageWithObfuscatedCursor","newLimit"]}

package/dist/esm/internal/experimental.d.mts

@@ -1,52 +0,0 @@
-import { AptosConfig } from '../api/aptosConfig.mjs';
-import { LedgerVersionArg } from '../types/types.mjs';
-import { InputViewFunctionData } from '../transactions/types.mjs';
-import '../utils/apiEndpoints.mjs';
-import '../utils/const.mjs';
-import '../types/indexer.mjs';
-import '../types/generated/operations.mjs';
-import '../types/generated/types.mjs';
-import '@aptos-labs/script-composer-pack';
-import '../bcs/serializable/moveStructs.mjs';
-import '../bcs/serializable/movePrimitives.mjs';
-import '../bcs/deserializer.mjs';
-import '../bcs/serializer.mjs';
-import '../core/hex.mjs';
-import '../core/common.mjs';
-import '../transactions/instances/transactionArgument.mjs';
-import '../bcs/serializable/fixedBytes.mjs';
-import '../core/accountAddress.mjs';
-import '../publicKey-pDHBAZlT.mjs';
-import '../core/crypto/signature.mjs';
-import '../transactions/authenticator/account.mjs';
-import '../core/crypto/ed25519.mjs';
-import '../core/crypto/privateKey.mjs';
-import '../core/crypto/multiEd25519.mjs';
-import '../core/crypto/multiKey.mjs';
-import '../core/crypto/singleKey.mjs';
-import '../core/crypto/secp256k1.mjs';
-import '../transactions/instances/rawTransaction.mjs';
-import '../transactions/instances/chainId.mjs';
-import '../transactions/instances/transactionPayload.mjs';
-import '../transactions/instances/identifier.mjs';
-import '../transactions/instances/moduleId.mjs';
-import '../transactions/typeTag/index.mjs';
-import '../transactions/instances/simpleTransaction.mjs';
-import '../transactions/instances/multiAgentTransaction.mjs';
-
-declare function viewBinary(args: {
-    aptosConfig: AptosConfig;
-    payload: InputViewFunctionData;
-    options?: LedgerVersionArg & {
-        convert?: undefined;
-    };
-}): Promise<Uint8Array>;
-declare function viewBinary<T extends {}>(args: {
-    aptosConfig: AptosConfig;
-    payload: InputViewFunctionData;
-    options?: LedgerVersionArg & {
-        convert?: (input: Uint8Array) => T;
-    };
-}): Promise<T>;
-
-export { viewBinary };

package/dist/esm/internal/experimental.mjs

@@ -1,2 +0,0 @@
-import{Yd as a}from"../chunk-URNCRLHO.mjs";import"../chunk-W4BSN6SK.mjs";import"../chunk-UYVPNUH3.mjs";import"../chunk-A5L76YP7.mjs";import"../chunk-7JRZLDWV.mjs";import"../chunk-P5CIZZDK.mjs";import"../chunk-G3MHXDYA.mjs";import"../chunk-KIMU5PYJ.mjs";import"../chunk-FU65NEDT.mjs";import"../chunk-GOXRBEIJ.mjs";import"../chunk-EXXY72UN.mjs";import"../chunk-3AS5BVKL.mjs";import"../chunk-NECL5FCQ.mjs";import"../chunk-4QMXOWHP.mjs";import"../chunk-DFRHNDOS.mjs";import"../chunk-V5IPL4SJ.mjs";import"../chunk-HEYMZZRE.mjs";import"../chunk-DOVH6HPL.mjs";import"../chunk-7CRQNXR5.mjs";import"../chunk-7WPEGMD6.mjs";import"../chunk-BRGQM252.mjs";import"../chunk-C3Q23D22.mjs";import"../chunk-TORMKDQG.mjs";import"../chunk-2RBINVFA.mjs";import"../chunk-KSLLV3ZC.mjs";import"../chunk-IMTC3J2M.mjs";import"../chunk-6QJWFV2M.mjs";import"../chunk-DH32UXHB.mjs";import"../chunk-YOZBVVKL.mjs";import"../chunk-V3MBJJTL.mjs";import"../chunk-M7W6FZ5Z.mjs";import"../chunk-VHNX2NUR.mjs";import"../chunk-7ECCT6PK.mjs";import"../chunk-YVRPD7Z6.mjs";import"../chunk-2DISMLR6.mjs";import"../chunk-L5C44K6H.mjs";import"../chunk-CICJRLYU.mjs";import"../chunk-HGLO5LDS.mjs";import"../chunk-5WNHYEW2.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-H3NZHL45.mjs";import"../chunk-4FBUZY6C.mjs";import"../chunk-DGH7NXHM.mjs";import"../chunk-UQKQH5C7.mjs";import"../chunk-BE3OXYYX.mjs";import"../chunk-4RXKALLC.mjs";import"../chunk-ZKOF4KST.mjs";import"../chunk-RJ7F4JDV.mjs";import"../chunk-DC5IVW4W.mjs";import"../chunk-F2GWK4YJ.mjs";import"../chunk-SZYA6IG4.mjs";import"../chunk-CZOZTNXJ.mjs";import"../chunk-3OLFJ65O.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-B373VRCY.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-VHY6ZATX.mjs";import"../chunk-IF4UU2MT.mjs";import"../chunk-NDXMDJV4.mjs";import"../chunk-KDMSOCZY.mjs";export{a as viewBinary};
-//# sourceMappingURL=experimental.mjs.map

package/dist/esm/internal/experimental.mjs.map

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

package/src/api/experimental.ts

@@ -1,64 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { LedgerVersionArg } from "../types";
-import { AptosConfig } from "./aptosConfig";
-import { InputViewFunctionData } from "../transactions";
-import { viewBinary } from "../internal/experimental";
-
-/**
- * A class to have experimental functionality to the SDK.  Anything used here is subject to change.
- * @group Experimental
- * @experimental
- */
-export class Experimental {
-  /**
-   * Initializes a new instance of the Aptos client with the provided configuration.
-   *
-   * @param config - The configuration settings for the Aptos client.
-   * @param config.network - The network to connect to (e.g., Testnet, Mainnet).
-   * @param config.nodeUrl - The URL of the Aptos node to connect to.
-   * @param config.faucetUrl - The URL of the faucet to use for funding accounts.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * async function runExample() {
-   *     // Create a new Aptos client with Testnet configuration
-   *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify your own network if needed
-   *     const aptos = new Aptos(config);
-   *
-   *     console.log("Aptos client initialized:", aptos);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Experimental
-   * @experimental
-   */
-  constructor(readonly config: AptosConfig) {}
-
-  async viewBinary(args: {
-    payload: InputViewFunctionData;
-    options?: LedgerVersionArg & { convert?: undefined };
-  }): Promise<Uint8Array>;
-  async viewBinary<T extends {}>(args: {
-    payload: InputViewFunctionData;
-    options: LedgerVersionArg & { convert: (input: Uint8Array) => T };
-  }): Promise<T>;
-
-  /**
-   * Returns BCS encoded results of the view function.  It can also convert the results to a specific type, if a
-   * converter is provided.
-   *
-   * @experimental
-   * @group Experimental
-   * @param args
-   */
-  async viewBinary<T extends {} = Uint8Array>(args: {
-    payload: InputViewFunctionData;
-    options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };
-  }): Promise<Uint8Array | T> {
-    return viewBinary<T>({ ...args, aptosConfig: this.config });
-  }
-}

package/src/internal/experimental.ts

@@ -1,55 +0,0 @@
-import { AptosConfig } from "../api/aptosConfig";
-import { generateViewFunctionPayload, InputViewFunctionData } from "../transactions";
-import { LedgerVersionArg, MimeType } from "../types";
-import { Serializer } from "../bcs";
-import { postBinaryAptosFullNode } from "../client";
-
-export async function viewBinary(args: {
-  aptosConfig: AptosConfig;
-  payload: InputViewFunctionData;
-  options?: LedgerVersionArg & { convert?: undefined };
-}): Promise<Uint8Array>;
-
-export async function viewBinary<T extends {}>(args: {
-  aptosConfig: AptosConfig;
-  payload: InputViewFunctionData;
-  options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };
-}): Promise<T>;
-
-/**
- * Reads a binary view function, and converts into the appropriate type if a converter is provided.
- * @experimental
- * @param args
- */
-export async function viewBinary<T extends {} = Uint8Array>(args: {
-  aptosConfig: AptosConfig;
-  payload: InputViewFunctionData;
-  options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };
-}): Promise<Uint8Array | T> {
-  const { aptosConfig, payload, options } = args;
-  const viewFunctionPayload = await generateViewFunctionPayload({
-    ...payload,
-    aptosConfig,
-  });
-
-  const serializer = new Serializer();
-  viewFunctionPayload.serialize(serializer);
-  const bytes = serializer.toUint8Array();
-
-  const { data } = await postBinaryAptosFullNode<Uint8Array>({
-    aptosConfig,
-    path: "view",
-    originMethod: "view",
-    contentType: MimeType.BCS_VIEW_FUNCTION,
-    acceptType: MimeType.BCS,
-    params: { ledger_version: options?.ledgerVersion },
-    body: bytes,
-  });
-
-  const array = new Uint8Array(data);
-  if (options?.convert) {
-    return options.convert(array);
-  }
-
-  return array;
-}

package/src/internal/move/jwks/build/jwk/BuildInfo.yaml

@@ -1,56 +0,0 @@
----
-compiled_package_info:
-  package_name: jwk
-  address_alias_instantiation:
-    Extensions: "0000000000000000000000000000000000000000000000000000000000000001"
-    aptos_framework: "0000000000000000000000000000000000000000000000000000000000000001"
-    aptos_fungible_asset: 000000000000000000000000000000000000000000000000000000000000000a
-    aptos_std: "0000000000000000000000000000000000000000000000000000000000000001"
-    aptos_token: "0000000000000000000000000000000000000000000000000000000000000003"
-    core_resources: 000000000000000000000000000000000000000000000000000000000a550c18
-    std: "0000000000000000000000000000000000000000000000000000000000000001"
-    vm: "0000000000000000000000000000000000000000000000000000000000000000"
-    vm_reserved: "0000000000000000000000000000000000000000000000000000000000000000"
-  source_digest: 3437D4FB002907781F0FE5D46FC4E668C8B8F0420AA77751774AD63B0C2730BF
-  build_flags:
-    dev_mode: false
-    test_mode: false
-    override_std: ~
-    generate_docs: false
-    generate_abis: false
-    generate_move_model: true
-    full_model_generation: false
-    install_dir: ~
-    force_recompilation: false
-    additional_named_addresses: {}
-    architecture: ~
-    fetch_deps_only: false
-    skip_fetch_latest_git_deps: false
-    compiler_config:
-      bytecode_version: 6
-      known_attributes:
-        - bytecode_instruction
-        - deprecated
-        - event
-        - expected_failure
-        - "fmt::skip"
-        - legacy_entry_fun
-        - "lint::allow_unsafe_randomness"
-        - "lint::skip"
-        - native_interface
-        - randomness
-        - resource_group
-        - resource_group_member
-        - test
-        - test_only
-        - verify_only
-        - view
-      skip_attribute_checks: false
-      compiler_version: ~
-      language_version: ~
-      experiments:
-        - optimize=on
-dependencies:
-  - AptosFramework
-  - AptosStdlib
-  - MoveStdlib