@aptos-labs/ts-sdk 1.34.0 → 1.35.0-zeta.1

package/dist/esm/chunk-6T3V5LXK.mjs

@@ -0,0 +1,119 @@
+import {
+  aptosBinaryRequest,
+  aptosRequest
+} from "./chunk-G34CJDST.mjs";
+
+// src/client/post.ts
+async function post(options) {
+  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
+  const url = aptosConfig.getRequestUrl(type);
+  return aptosRequest(
+    {
+      url,
+      method: "POST",
+      originMethod,
+      path,
+      body,
+      contentType,
+      acceptType,
+      params,
+      overrides
+    },
+    aptosConfig,
+    options.type
+  );
+}
+async function postBinary(options) {
+  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
+  const url = aptosConfig.getRequestUrl(type);
+  return aptosBinaryRequest(
+    {
+      url,
+      method: "POST",
+      originMethod,
+      path,
+      body,
+      contentType,
+      acceptType,
+      params,
+      overrides
+    },
+    aptosConfig,
+    options.type
+  );
+}
+async function postAptosFullNode(options) {
+  const { aptosConfig } = options;
+  return post({
+    ...options,
+    type: "Fullnode" /* FULLNODE */,
+    overrides: {
+      ...aptosConfig.clientConfig,
+      ...aptosConfig.fullnodeConfig,
+      ...options.overrides,
+      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS }
+    }
+  });
+}
+async function postBinaryAptosFullNode(options) {
+  const { aptosConfig } = options;
+  return postBinary({
+    ...options,
+    type: "Fullnode" /* FULLNODE */,
+    overrides: {
+      ...aptosConfig.clientConfig,
+      ...aptosConfig.fullnodeConfig,
+      ...options.overrides,
+      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS }
+    }
+  });
+}
+async function postAptosIndexer(options) {
+  const { aptosConfig } = options;
+  return post({
+    ...options,
+    type: "Indexer" /* INDEXER */,
+    overrides: {
+      ...aptosConfig.clientConfig,
+      ...aptosConfig.indexerConfig,
+      ...options.overrides,
+      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.indexerConfig?.HEADERS }
+    }
+  });
+}
+async function postAptosFaucet(options) {
+  const { aptosConfig } = options;
+  const modifiedAptosConfig = {
+    ...aptosConfig,
+    clientConfig: { ...aptosConfig.clientConfig }
+  };
+  delete modifiedAptosConfig?.clientConfig?.API_KEY;
+  return post({
+    ...options,
+    type: "Faucet" /* FAUCET */,
+    overrides: {
+      ...modifiedAptosConfig.clientConfig,
+      ...modifiedAptosConfig.faucetConfig,
+      ...options.overrides,
+      HEADERS: { ...modifiedAptosConfig.clientConfig?.HEADERS, ...modifiedAptosConfig.faucetConfig?.HEADERS }
+    }
+  });
+}
+async function postAptosPepperService(options) {
+  return post({ ...options, type: "Pepper" /* PEPPER */ });
+}
+async function postAptosProvingService(options) {
+  return post({ ...options, type: "Prover" /* PROVER */ });
+}
+
+export {
+  post,
+  postBinary,
+  postAptosFullNode,
+  postBinaryAptosFullNode,
+  postAptosIndexer,
+  postAptosFaucet,
+  postAptosPepperService,
+  postAptosProvingService
+};
+//# sourceMappingURL=chunk-6T3V5LXK.mjs.map

package/dist/esm/chunk-6T3V5LXK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/post.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { 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 POST request, including the API client configuration.\n * @group Implementation\n * @category Client\n */\nexport type PostRequestOptions = {\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   * The body of the request, should match the content type of the request\n   * @group Implementation\n   * @category Client\n   */\n  body?: any;\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 posting a request to Aptos, excluding the type field.\n * @group Implementation\n * @category Client\n */\nexport type PostAptosRequestOptions = Omit<PostRequestOptions, \"type\">;\n\n/**\n * Executes a POST request to the specified URL with the provided options.\n *\n * @param options - The options for the POST request.\n * @param options.type - The type of the request.\n * @param options.originMethod - The original method that initiated the request.\n * @param options.path - The path for the request.\n * @param options.body - The body content to be sent with the request.\n * @param options.acceptType - The type of response expected from the server.\n * @param options.contentType - The content type of the request body.\n * @param options.params - Additional parameters to include in the request.\n * @param options.aptosConfig - Configuration settings for the Aptos request.\n * @param options.overrides - Any overrides for the default request behavior.\n * @returns The response from the POST request.\n * @group Implementation\n * @category Client\n */\nexport async function post<Req extends {}, Res extends {}>(\n  options: PostRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;\n  const url = aptosConfig.getRequestUrl(type);\n\n  return aptosRequest<Req, Res>(\n    {\n      url,\n      method: \"POST\",\n      originMethod,\n      path,\n      body,\n      contentType,\n      acceptType,\n      params,\n      overrides,\n    },\n    aptosConfig,\n    options.type,\n  );\n}\n\n/**\n * Executes a POST request to the specified URL with the provided options.\n *\n * @param options - The options for the POST request.\n * @param options.type - The type of the request.\n * @param options.originMethod - The original method that initiated the request.\n * @param options.path - The path for the request.\n * @param options.body - The body content to be sent with the request.\n * @param options.acceptType - The type of response expected from the server.\n * @param options.contentType - The content type of the request body.\n * @param options.params - Additional parameters to include in the request.\n * @param options.aptosConfig - Configuration settings for the Aptos request.\n * @param options.overrides - Any overrides for the default request behavior.\n * @returns The response from the POST request.\n * @group Implementation\n * @category Client\n * @experimental\n */\nexport async function postBinary<Req extends {}>(options: PostRequestOptions): Promise<AptosResponse<Req, Buffer>> {\n  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;\n  const url = aptosConfig.getRequestUrl(type);\n\n  return aptosBinaryRequest<Req>(\n    {\n      url,\n      method: \"POST\",\n      originMethod,\n      path,\n      body,\n      contentType,\n      acceptType,\n      params,\n      overrides,\n    },\n    aptosConfig,\n    options.type,\n  );\n}\n\n/**\n * Sends a request to the Aptos full node using the specified options.\n * This function allows you to interact with the Aptos blockchain by sending requests to the full node.\n *\n * @param options - The options for the request.\n * @param options.aptosConfig - Configuration settings for the Aptos client.\n * @param options.aptosConfig.clientConfig - Client-specific configuration settings.\n * @param options.aptosConfig.fullnodeConfig - Full node-specific configuration settings.\n * @param options.overrides - Additional overrides for the request.\n * @group Implementation\n * @category Client\n */\nexport async function postAptosFullNode<Req extends {}, Res extends {}>(\n  options: PostAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  const { aptosConfig } = options;\n\n  return post<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 * Sends a request to the Aptos full node using the specified options.\n * This function allows you to interact with the Aptos blockchain by sending requests to the full node.\n *\n * @param options - The options for the request.\n * @param options.aptosConfig - Configuration settings for the Aptos client.\n * @param options.aptosConfig.clientConfig - Client-specific configuration settings.\n * @param options.aptosConfig.fullnodeConfig - Full node-specific configuration settings.\n * @param options.overrides - Additional overrides for the request.\n * @group Implementation\n * @category Client\n * @experimental\n */\nexport async function postBinaryAptosFullNode<Req extends {}>(\n  options: PostAptosRequestOptions,\n): Promise<AptosResponse<Req, Buffer>> {\n  const { aptosConfig } = options;\n\n  return postBinary<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 * Sends a request to the Aptos indexer with the specified options.\n * This function allows you to interact with the Aptos indexer and customize the request using various configurations.\n *\n * @param options - The options for the request to the Aptos indexer.\n * @param options.aptosConfig - Configuration settings specific to the Aptos client and indexer.\n * @param options.aptosConfig.clientConfig - The client configuration settings.\n * @param options.aptosConfig.indexerConfig - The indexer configuration settings.\n * @param options.overrides - Additional overrides for the request.\n * @param options.overrides.HEADERS - Custom headers to include in the request.\n * @group Implementation\n * @category Client\n */\nexport async function postAptosIndexer<Req extends {}, Res extends {}>(\n  options: PostAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  const { aptosConfig } = options;\n\n  return post<Req, Res>({\n    ...options,\n    type: AptosApiType.INDEXER,\n    overrides: {\n      ...aptosConfig.clientConfig,\n      ...aptosConfig.indexerConfig,\n      ...options.overrides,\n      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.indexerConfig?.HEADERS },\n    },\n  });\n}\n\n/**\n * Sends a request to the Aptos faucet to obtain test tokens.\n * This function modifies the provided configuration to ensure that the API_KEY is not included in the request.\n *\n * Note that only devnet has a publicly accessible faucet. For testnet, you must use\n * the minting page at https://aptos.dev/network/faucet.\n *\n * @param options - The options for the request.\n * @param options.aptosConfig - The configuration settings for the Aptos client.\n * @param options.aptosConfig.clientConfig - The client-specific configuration settings.\n * @param options.aptosConfig.clientConfig.HEADERS - Optional headers to include in the request.\n * @param options.aptosConfig.faucetConfig - The configuration settings specific to the faucet.\n * @param options.overrides - Additional overrides for the request configuration.\n * @group Implementation\n * @category Client\n */\nexport async function postAptosFaucet<Req extends {}, Res extends {}>(\n  options: PostAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  const { aptosConfig } = options;\n  // Faucet does not support API_KEY\n  // Create a new object with the desired modification\n  const modifiedAptosConfig = {\n    ...aptosConfig,\n    clientConfig: { ...aptosConfig.clientConfig },\n  };\n  // Delete API_KEY config\n  delete modifiedAptosConfig?.clientConfig?.API_KEY;\n\n  return post<Req, Res>({\n    ...options,\n    type: AptosApiType.FAUCET,\n    overrides: {\n      ...modifiedAptosConfig.clientConfig,\n      ...modifiedAptosConfig.faucetConfig,\n      ...options.overrides,\n      HEADERS: { ...modifiedAptosConfig.clientConfig?.HEADERS, ...modifiedAptosConfig.faucetConfig?.HEADERS },\n    },\n  });\n}\n\n/**\n * Makes a post request to the pepper service.\n *\n * @param options - The options for the request.\n * @param options.url - The URL to which the request is sent.\n * @param options.headers - The headers to include in the request.\n * @param options.body - The body of the request.\n * @returns A promise that resolves to the response from the pepper service.\n * @group Implementation\n * @category Client\n */\nexport async function postAptosPepperService<Req extends {}, Res extends {}>(\n  options: PostAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  return post<Req, Res>({ ...options, type: AptosApiType.PEPPER });\n}\n\n/**\n * Sends a request to the Aptos proving service with the specified options.\n *\n * @param options - The options for the request to the Aptos proving service.\n * @param options.type - The type of the request, which should be set to AptosApiType.PROVER.\n * @param options.data - The data to be included in the request.\n * @group Implementation\n * @category Client\n */\nexport async function postAptosProvingService<Req extends {}, Res extends {}>(\n  options: PostAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  return post<Req, Res>({ ...options, type: AptosApiType.PROVER });\n}\n"],"mappings":";;;;;;AA8FA,eAAsB,KACpB,SACkC;AAClC,QAAM,EAAE,MAAM,cAAc,MAAM,MAAM,YAAY,aAAa,QAAQ,aAAa,UAAU,IAAI;AACpG,QAAM,MAAM,YAAY,cAAc,IAAI;AAE1C,SAAO;AAAA,IACL;AAAA,MACE;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,EACV;AACF;AAoBA,eAAsB,WAA2B,SAAkE;AACjH,QAAM,EAAE,MAAM,cAAc,MAAM,MAAM,YAAY,aAAa,QAAQ,aAAa,UAAU,IAAI;AACpG,QAAM,MAAM,YAAY,cAAc,IAAI;AAE1C,SAAO;AAAA,IACL;AAAA,MACE;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,EACV;AACF;AAcA,eAAsB,kBACpB,SACkC;AAClC,QAAM,EAAE,YAAY,IAAI;AAExB,SAAO,KAAe;AAAA,IACpB,GAAG;AAAA,IACH;AAAA,IACA,WAAW;AAAA,MACT,GAAG,YAAY;AAAA,MACf,GAAG,YAAY;AAAA,MACf,GAAG,QAAQ;AAAA,MACX,SAAS,EAAE,GAAG,YAAY,cAAc,SAAS,GAAG,YAAY,gBAAgB,QAAQ;AAAA,IAC1F;AAAA,EACF,CAAC;AACH;AAeA,eAAsB,wBACpB,SACqC;AACrC,QAAM,EAAE,YAAY,IAAI;AAExB,SAAO,WAAgB;AAAA,IACrB,GAAG;AAAA,IACH;AAAA,IACA,WAAW;AAAA,MACT,GAAG,YAAY;AAAA,MACf,GAAG,YAAY;AAAA,MACf,GAAG,QAAQ;AAAA,MACX,SAAS,EAAE,GAAG,YAAY,cAAc,SAAS,GAAG,YAAY,gBAAgB,QAAQ;AAAA,IAC1F;AAAA,EACF,CAAC;AACH;AAeA,eAAsB,iBACpB,SACkC;AAClC,QAAM,EAAE,YAAY,IAAI;AAExB,SAAO,KAAe;AAAA,IACpB,GAAG;AAAA,IACH;AAAA,IACA,WAAW;AAAA,MACT,GAAG,YAAY;AAAA,MACf,GAAG,YAAY;AAAA,MACf,GAAG,QAAQ;AAAA,MACX,SAAS,EAAE,GAAG,YAAY,cAAc,SAAS,GAAG,YAAY,eAAe,QAAQ;AAAA,IACzF;AAAA,EACF,CAAC;AACH;AAkBA,eAAsB,gBACpB,SACkC;AAClC,QAAM,EAAE,YAAY,IAAI;AAGxB,QAAM,sBAAsB;AAAA,IAC1B,GAAG;AAAA,IACH,cAAc,EAAE,GAAG,YAAY,aAAa;AAAA,EAC9C;AAEA,SAAO,qBAAqB,cAAc;AAE1C,SAAO,KAAe;AAAA,IACpB,GAAG;AAAA,IACH;AAAA,IACA,WAAW;AAAA,MACT,GAAG,oBAAoB;AAAA,MACvB,GAAG,oBAAoB;AAAA,MACvB,GAAG,QAAQ;AAAA,MACX,SAAS,EAAE,GAAG,oBAAoB,cAAc,SAAS,GAAG,oBAAoB,cAAc,QAAQ;AAAA,IACxG;AAAA,EACF,CAAC;AACH;AAaA,eAAsB,uBACpB,SACkC;AAClC,SAAO,KAAe,EAAE,GAAG,SAAS,4BAA0B,CAAC;AACjE;AAWA,eAAsB,wBACpB,SACkC;AAClC,SAAO,KAAe,EAAE,GAAG,SAAS,4BAA0B,CAAC;AACjE;","names":[]}

package/dist/esm/chunk-7J37IHNP.mjs

@@ -0,0 +1,70 @@
+import {
+  convertCallArgument,
+  fetchMoveFunctionAbi,
+  standardizeTypeTags
+} from "./chunk-OOQS6BEP.mjs";
+import {
+  getFunctionParts
+} from "./chunk-RQS33JAS.mjs";
+
+// src/transactions/scriptComposer/index.ts
+import { ScriptComposerWasm } from "@aptos-labs/script-composer-pack";
+var AptosScriptComposer = class _AptosScriptComposer {
+  constructor(aptosConfig) {
+    this.config = aptosConfig;
+    this.builder = void 0;
+  }
+  // Initializing the wasm needed for the script composer, must be called
+  // before using the composer.
+  async init() {
+    if (!_AptosScriptComposer.transactionComposer) {
+      const module = await import("@aptos-labs/script-composer-pack");
+      const { TransactionComposer, initSync } = module;
+      if (!ScriptComposerWasm.isInitialized) {
+        ScriptComposerWasm.init();
+      }
+      initSync({ module: ScriptComposerWasm.wasm });
+      _AptosScriptComposer.transactionComposer = TransactionComposer;
+    }
+    this.builder = _AptosScriptComposer.transactionComposer.single_signer();
+  }
+  // Add a move function invocation to the TransactionComposer.
+  //
+  // Similar to how to create an entry function, the difference is that input arguments could
+  // either be a `CallArgument` which represents an abstract value returned from a previous Move call
+  // or the regular entry function arguments.
+  //
+  // The function would also return a list of `CallArgument` that can be passed on to future calls.
+  async addBatchedCalls(input) {
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(input.function);
+    const nodeUrl = this.config.getRequestUrl("Fullnode" /* FULLNODE */);
+    await this.builder.load_module(nodeUrl, `${moduleAddress}::${moduleName}`);
+    if (input.typeArguments !== void 0) {
+      await Promise.all(input.typeArguments.map((typeTag) => this.builder.load_type_tag(nodeUrl, typeTag.toString())));
+    }
+    const typeArguments = standardizeTypeTags(input.typeArguments);
+    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
+    if (typeArguments.length !== functionAbi.typeParameters.length) {
+      throw new Error(
+        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`
+      );
+    }
+    const functionArguments = input.functionArguments.map(
+      (arg, i) => convertCallArgument(arg, functionName, functionAbi, i, typeArguments)
+    );
+    return this.builder.add_batched_call(
+      `${moduleAddress}::${moduleName}`,
+      functionName,
+      typeArguments.map((arg) => arg.toString()),
+      functionArguments
+    );
+  }
+  build() {
+    return this.builder.generate_batched_calls(true);
+  }
+};
+
+export {
+  AptosScriptComposer
+};
+//# sourceMappingURL=chunk-7J37IHNP.mjs.map

package/dist/esm/{chunk-CSG67JHZ.mjs.map → chunk-7J37IHNP.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/transactions/scriptComposer/index.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ScriptComposerWasm } from \"@aptos-labs/script-composer-pack\";\nimport { AptosApiType, getFunctionParts } from \"../../utils\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport { InputBatchedFunctionData } from \"../types\";\nimport { fetchMoveFunctionAbi, standardizeTypeTags } from \"../transactionBuilder\";\nimport { CallArgument } from \"../../types\";\nimport { convertCallArgument } from \"../transactionBuilder/remoteAbi\";\n\n/**\n * A wrapper class around TransactionComposer, which is a WASM library compiled\n * from aptos-core/aptos-move/script-composer.\n * This class allows the SDK caller to build a transaction that invokes multiple Move functions\n * and allow for arguments to be passed around.\n * */\nexport class AptosScriptComposer {\n  private config: AptosConfig;\n\n  private builder?: any;\n\n  private static transactionComposer?: any;\n\n  constructor(aptosConfig: AptosConfig) {\n    this.config = aptosConfig;\n    this.builder = undefined;\n  }\n\n  // Initializing the wasm needed for the script composer, must be called\n  // before using the composer.\n  async init() {\n    if (!AptosScriptComposer.transactionComposer) {\n      const module = await import(\"@aptos-labs/script-composer-pack\");\n      const { TransactionComposer, initSync } = module;\n      if (!ScriptComposerWasm.isInitialized) {\n        ScriptComposerWasm.init();\n      }\n      initSync({ module: ScriptComposerWasm.wasm });\n      AptosScriptComposer.transactionComposer = TransactionComposer;\n    }\n    this.builder = AptosScriptComposer.transactionComposer.single_signer();\n  }\n\n  // Add a move function invocation to the TransactionComposer.\n  //\n  // Similar to how to create an entry function, the difference is that input arguments could\n  // either be a `CallArgument` which represents an abstract value returned from a previous Move call\n  // or the regular entry function arguments.\n  //\n  // The function would also return a list of `CallArgument` that can be passed on to future calls.\n  async addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]> {\n    const { moduleAddress, moduleName, functionName } = getFunctionParts(input.function);\n    const nodeUrl = this.config.getRequestUrl(AptosApiType.FULLNODE);\n\n    // Load the calling module into the builder.\n    await this.builder.load_module(nodeUrl, `${moduleAddress}::${moduleName}`);\n\n    // Load the calling type arguments into the loader.\n    if (input.typeArguments !== undefined) {\n      await Promise.all(input.typeArguments.map((typeTag) => this.builder.load_type_tag(nodeUrl, typeTag.toString())));\n    }\n    const typeArguments = standardizeTypeTags(input.typeArguments);\n    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);\n    // Check the type argument count against the ABI\n    if (typeArguments.length !== functionAbi.typeParameters.length) {\n      throw new Error(\n        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,\n      );\n    }\n\n    const functionArguments: CallArgument[] = input.functionArguments.map((arg, i) =>\n      convertCallArgument(arg, functionName, functionAbi, i, typeArguments),\n    );\n\n    return this.builder.add_batched_call(\n      `${moduleAddress}::${moduleName}`,\n      functionName,\n      typeArguments.map((arg) => arg.toString()),\n      functionArguments,\n    );\n  }\n\n  build(): Uint8Array {\n    return this.builder.generate_batched_calls(true);\n  }\n}\n"],"mappings":"gGAGA,OAAS,sBAAAA,MAA0B,mCAc5B,IAAMC,EAAN,MAAMC,CAAoB,CAO/B,YAAYC,EAA0B,CACpC,KAAK,OAASA,EACd,KAAK,QAAU,MACjB,CAIA,MAAM,MAAO,CACX,GAAI,CAACD,EAAoB,oBAAqB,CAC5C,IAAME,EAAS,KAAM,QAAO,kCAAkC,EACxD,CAAE,oBAAAC,EAAqB,SAAAC,CAAS,EAAIF,EACrCG,EAAmB,eACtBA,EAAmB,KAAK,EAE1BD,EAAS,CAAE,OAAQC,EAAmB,IAAK,CAAC,EAC5CL,EAAoB,oBAAsBG,CAC5C,CACA,KAAK,QAAUH,EAAoB,oBAAoB,cAAc,CACvE,CASA,MAAM,gBAAgBM,EAA0D,CAC9E,GAAM,CAAE,cAAAC,EAAe,WAAAC,EAAY,aAAAC,CAAa,EAAIC,EAAiBJ,EAAM,QAAQ,EAC7EK,EAAU,KAAK,OAAO,wBAAmC,EAG/D,MAAM,KAAK,QAAQ,YAAYA,EAAS,GAAGJ,CAAa,KAAKC,CAAU,EAAE,EAGrEF,EAAM,gBAAkB,QAC1B,MAAM,QAAQ,IAAIA,EAAM,cAAc,IAAKM,GAAY,KAAK,QAAQ,cAAcD,EAASC,EAAQ,SAAS,CAAC,CAAC,CAAC,EAEjH,IAAMC,EAAgBC,EAAoBR,EAAM,aAAa,EACvDS,EAAc,MAAMC,EAAqBT,EAAeC,EAAYC,EAAc,KAAK,MAAM,EAEnG,GAAII,EAAc,SAAWE,EAAY,eAAe,OACtD,MAAM,IAAI,MACR,0CAA0CA,EAAY,eAAe,MAAM,cAAcF,EAAc,MAAM,EAC/G,EAGF,IAAMI,EAAoCX,EAAM,kBAAkB,IAAI,CAACY,EAAKC,IAC1EC,EAAoBF,EAAKT,EAAcM,EAAaI,EAAGN,CAAa,CACtE,EAEA,OAAO,KAAK,QAAQ,iBAClB,GAAGN,CAAa,KAAKC,CAAU,GAC/BC,EACAI,EAAc,IAAKK,GAAQA,EAAI,SAAS,CAAC,EACzCD,CACF,CACF,CAEA,OAAoB,CAClB,OAAO,KAAK,QAAQ,uBAAuB,EAAI,CACjD,CACF","names":["ScriptComposerWasm","AptosScriptComposer","_AptosScriptComposer","aptosConfig","module","TransactionComposer","initSync","ScriptComposerWasm","input","moduleAddress","moduleName","functionName","getFunctionParts","nodeUrl","typeTag","typeArguments","standardizeTypeTags","functionAbi","fetchMoveFunctionAbi","functionArguments","arg","i","convertCallArgument"]}
+{"version":3,"sources":["../../src/transactions/scriptComposer/index.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ScriptComposerWasm } from \"@aptos-labs/script-composer-pack\";\nimport { AptosApiType, getFunctionParts } from \"../../utils\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport { InputBatchedFunctionData } from \"../types\";\nimport { fetchMoveFunctionAbi, standardizeTypeTags } from \"../transactionBuilder\";\nimport { CallArgument } from \"../../types\";\nimport { convertCallArgument } from \"../transactionBuilder/remoteAbi\";\n\n/**\n * A wrapper class around TransactionComposer, which is a WASM library compiled\n * from aptos-core/aptos-move/script-composer.\n * This class allows the SDK caller to build a transaction that invokes multiple Move functions\n * and allow for arguments to be passed around.\n * */\nexport class AptosScriptComposer {\n  private config: AptosConfig;\n\n  private builder?: any;\n\n  private static transactionComposer?: any;\n\n  constructor(aptosConfig: AptosConfig) {\n    this.config = aptosConfig;\n    this.builder = undefined;\n  }\n\n  // Initializing the wasm needed for the script composer, must be called\n  // before using the composer.\n  async init() {\n    if (!AptosScriptComposer.transactionComposer) {\n      const module = await import(\"@aptos-labs/script-composer-pack\");\n      const { TransactionComposer, initSync } = module;\n      if (!ScriptComposerWasm.isInitialized) {\n        ScriptComposerWasm.init();\n      }\n      initSync({ module: ScriptComposerWasm.wasm });\n      AptosScriptComposer.transactionComposer = TransactionComposer;\n    }\n    this.builder = AptosScriptComposer.transactionComposer.single_signer();\n  }\n\n  // Add a move function invocation to the TransactionComposer.\n  //\n  // Similar to how to create an entry function, the difference is that input arguments could\n  // either be a `CallArgument` which represents an abstract value returned from a previous Move call\n  // or the regular entry function arguments.\n  //\n  // The function would also return a list of `CallArgument` that can be passed on to future calls.\n  async addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]> {\n    const { moduleAddress, moduleName, functionName } = getFunctionParts(input.function);\n    const nodeUrl = this.config.getRequestUrl(AptosApiType.FULLNODE);\n\n    // Load the calling module into the builder.\n    await this.builder.load_module(nodeUrl, `${moduleAddress}::${moduleName}`);\n\n    // Load the calling type arguments into the loader.\n    if (input.typeArguments !== undefined) {\n      await Promise.all(input.typeArguments.map((typeTag) => this.builder.load_type_tag(nodeUrl, typeTag.toString())));\n    }\n    const typeArguments = standardizeTypeTags(input.typeArguments);\n    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);\n    // Check the type argument count against the ABI\n    if (typeArguments.length !== functionAbi.typeParameters.length) {\n      throw new Error(\n        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,\n      );\n    }\n\n    const functionArguments: CallArgument[] = input.functionArguments.map((arg, i) =>\n      convertCallArgument(arg, functionName, functionAbi, i, typeArguments),\n    );\n\n    return this.builder.add_batched_call(\n      `${moduleAddress}::${moduleName}`,\n      functionName,\n      typeArguments.map((arg) => arg.toString()),\n      functionArguments,\n    );\n  }\n\n  build(): Uint8Array {\n    return this.builder.generate_batched_calls(true);\n  }\n}\n"],"mappings":";;;;;;;;;;AAGA,SAAS,0BAA0B;AAc5B,IAAM,sBAAN,MAAM,qBAAoB;AAAA,EAO/B,YAAY,aAA0B;AACpC,SAAK,SAAS;AACd,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA,EAIA,MAAM,OAAO;AACX,QAAI,CAAC,qBAAoB,qBAAqB;AAC5C,YAAM,SAAS,MAAM,OAAO,kCAAkC;AAC9D,YAAM,EAAE,qBAAqB,SAAS,IAAI;AAC1C,UAAI,CAAC,mBAAmB,eAAe;AACrC,2BAAmB,KAAK;AAAA,MAC1B;AACA,eAAS,EAAE,QAAQ,mBAAmB,KAAK,CAAC;AAC5C,2BAAoB,sBAAsB;AAAA,IAC5C;AACA,SAAK,UAAU,qBAAoB,oBAAoB,cAAc;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,gBAAgB,OAA0D;AAC9E,UAAM,EAAE,eAAe,YAAY,aAAa,IAAI,iBAAiB,MAAM,QAAQ;AACnF,UAAM,UAAU,KAAK,OAAO,uCAAmC;AAG/D,UAAM,KAAK,QAAQ,YAAY,SAAS,GAAG,aAAa,KAAK,UAAU,EAAE;AAGzE,QAAI,MAAM,kBAAkB,QAAW;AACrC,YAAM,QAAQ,IAAI,MAAM,cAAc,IAAI,CAAC,YAAY,KAAK,QAAQ,cAAc,SAAS,QAAQ,SAAS,CAAC,CAAC,CAAC;AAAA,IACjH;AACA,UAAM,gBAAgB,oBAAoB,MAAM,aAAa;AAC7D,UAAM,cAAc,MAAM,qBAAqB,eAAe,YAAY,cAAc,KAAK,MAAM;AAEnG,QAAI,cAAc,WAAW,YAAY,eAAe,QAAQ;AAC9D,YAAM,IAAI;AAAA,QACR,0CAA0C,YAAY,eAAe,MAAM,cAAc,cAAc,MAAM;AAAA,MAC/G;AAAA,IACF;AAEA,UAAM,oBAAoC,MAAM,kBAAkB;AAAA,MAAI,CAAC,KAAK,MAC1E,oBAAoB,KAAK,cAAc,aAAa,GAAG,aAAa;AAAA,IACtE;AAEA,WAAO,KAAK,QAAQ;AAAA,MAClB,GAAG,aAAa,KAAK,UAAU;AAAA,MAC/B;AAAA,MACA,cAAc,IAAI,CAAC,QAAQ,IAAI,SAAS,CAAC;AAAA,MACzC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,QAAoB;AAClB,WAAO,KAAK,QAAQ,uBAAuB,IAAI;AAAA,EACjD;AACF;","names":[]}

package/dist/esm/chunk-AEMQUDMU.mjs

@@ -0,0 +1,239 @@
+import {
+  FederatedKeylessAccount
+} from "./chunk-IARAGRKO.mjs";
+import {
+  KeylessAccount
+} from "./chunk-MD4TZ4HA.mjs";
+import {
+  MultiKeyAccount
+} from "./chunk-IORAMQ2Y.mjs";
+import {
+  deserializeSchemeAndAddress
+} from "./chunk-56UCIGTO.mjs";
+import {
+  SingleKeyAccount,
+  isSingleKeySigner
+} from "./chunk-XHQMSKZP.mjs";
+import {
+  Ed25519Account
+} from "./chunk-RTNVJKNX.mjs";
+import {
+  EphemeralKeyPair
+} from "./chunk-TQLOZKH4.mjs";
+import {
+  MultiKey
+} from "./chunk-NFBLI3BS.mjs";
+import {
+  Secp256k1PrivateKey
+} from "./chunk-CPZPXG7O.mjs";
+import {
+  ZeroKnowledgeSig,
+  getIssAudAndUidVal
+} from "./chunk-ZZWD23YW.mjs";
+import {
+  Ed25519PrivateKey
+} from "./chunk-HRUI6AWF.mjs";
+import {
+  AccountAddress
+} from "./chunk-CXLXUSCG.mjs";
+import {
+  Deserializer
+} from "./chunk-NUT2VOX2.mjs";
+import {
+  Serializer
+} from "./chunk-C7T6GW5P.mjs";
+import {
+  Hex
+} from "./chunk-BDM6FBUO.mjs";
+
+// src/account/AccountUtils.ts
+function serializeKeylessAccountCommon(account, serializer) {
+  serializer.serializeStr(account.jwt);
+  serializer.serializeStr(account.uidKey);
+  serializer.serializeFixedBytes(account.pepper);
+  account.ephemeralKeyPair.serialize(serializer);
+  if (account.proof === void 0) {
+    throw new Error("Cannot serialize - proof undefined");
+  }
+  account.proof.serialize(serializer);
+  serializer.serializeOption(account.verificationKeyHash, 32);
+}
+function deserializeKeylessAccountCommon(deserializer) {
+  const jwt = deserializer.deserializeStr();
+  const uidKey = deserializer.deserializeStr();
+  const pepper = deserializer.deserializeFixedBytes(31);
+  const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
+  const proof = ZeroKnowledgeSig.deserialize(deserializer);
+  const verificationKeyHash = deserializer.deserializeOption("fixedBytes", 32);
+  return { jwt, uidKey, pepper, ephemeralKeyPair, proof, verificationKeyHash };
+}
+var AccountUtils;
+((AccountUtils2) => {
+  function toBytes(account) {
+    const serializer = new Serializer();
+    serializer.serializeU32AsUleb128(account.signingScheme);
+    account.accountAddress.serialize(serializer);
+    switch (account.signingScheme) {
+      case 0 /* Ed25519 */:
+        account.privateKey.serialize(serializer);
+        return serializer.toUint8Array();
+      case 2 /* SingleKey */: {
+        if (!isSingleKeySigner(account)) {
+          throw new Error("Account is not a SingleKeySigner");
+        }
+        const anyPublicKey = account.getAnyPublicKey();
+        serializer.serializeU32AsUleb128(anyPublicKey.variant);
+        switch (anyPublicKey.variant) {
+          case 3 /* Keyless */: {
+            const keylessAccount = account;
+            serializeKeylessAccountCommon(keylessAccount, serializer);
+            return serializer.toUint8Array();
+          }
+          case 4 /* FederatedKeyless */: {
+            const federatedKeylessAccount = account;
+            serializeKeylessAccountCommon(federatedKeylessAccount, serializer);
+            federatedKeylessAccount.publicKey.jwkAddress.serialize(serializer);
+            serializer.serializeBool(federatedKeylessAccount.audless);
+            return serializer.toUint8Array();
+          }
+          case 1 /* Secp256k1 */:
+          case 0 /* Ed25519 */: {
+            const singleKeyAccount = account;
+            singleKeyAccount.privateKey.serialize(serializer);
+            return serializer.toUint8Array();
+          }
+          default: {
+            throw new Error(`Invalid public key variant: ${anyPublicKey.variant}`);
+          }
+        }
+      }
+      case 3 /* MultiKey */: {
+        const multiKeyAccount = account;
+        multiKeyAccount.publicKey.serialize(serializer);
+        serializer.serializeU32AsUleb128(multiKeyAccount.signers.length);
+        multiKeyAccount.signers.forEach((signer) => {
+          serializer.serializeFixedBytes(toBytes(signer));
+        });
+        return serializer.toUint8Array();
+      }
+      default:
+        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${account.signingScheme}`);
+    }
+  }
+  AccountUtils2.toBytes = toBytes;
+  function toHexStringWithoutPrefix(account) {
+    return Hex.hexInputToStringWithoutPrefix(toBytes(account));
+  }
+  AccountUtils2.toHexStringWithoutPrefix = toHexStringWithoutPrefix;
+  function toHexString(account) {
+    return Hex.hexInputToString(toBytes(account));
+  }
+  AccountUtils2.toHexString = toHexString;
+  function deserialize(deserializer) {
+    const { address, signingScheme } = deserializeSchemeAndAddress(deserializer);
+    switch (signingScheme) {
+      case 0 /* Ed25519 */: {
+        const privateKey = Ed25519PrivateKey.deserialize(deserializer);
+        return new Ed25519Account({ privateKey, address });
+      }
+      case 2 /* SingleKey */: {
+        const variantIndex = deserializer.deserializeUleb128AsU32();
+        switch (variantIndex) {
+          case 0 /* Ed25519 */: {
+            const privateKey = Ed25519PrivateKey.deserialize(deserializer);
+            return new SingleKeyAccount({ privateKey, address });
+          }
+          case 1 /* Secp256k1 */: {
+            const privateKey = Secp256k1PrivateKey.deserialize(deserializer);
+            return new SingleKeyAccount({ privateKey, address });
+          }
+          case 3 /* Keyless */: {
+            const keylessComponents = deserializeKeylessAccountCommon(deserializer);
+            const jwtClaims = getIssAudAndUidVal(keylessComponents);
+            return new KeylessAccount({ ...keylessComponents, ...jwtClaims });
+          }
+          case 4 /* FederatedKeyless */: {
+            const keylessComponents = deserializeKeylessAccountCommon(deserializer);
+            const jwkAddress = AccountAddress.deserialize(deserializer);
+            const audless = deserializer.deserializeBool();
+            const jwtClaims = getIssAudAndUidVal(keylessComponents);
+            return new FederatedKeylessAccount({ ...keylessComponents, ...jwtClaims, jwkAddress, audless });
+          }
+          default:
+            throw new Error(`Unsupported public key variant ${variantIndex}`);
+        }
+      }
+      case 3 /* MultiKey */: {
+        const multiKey = MultiKey.deserialize(deserializer);
+        const length = deserializer.deserializeUleb128AsU32();
+        const signers = new Array();
+        for (let i = 0; i < length; i += 1) {
+          const signer = deserialize(deserializer);
+          if (!isSingleKeySigner(signer) && !(signer instanceof Ed25519Account)) {
+            throw new Error(
+              "Deserialization of MultiKeyAccount failed. Signer is not a SingleKeySigner or Ed25519Account"
+            );
+          }
+          signers.push(signer);
+        }
+        return new MultiKeyAccount({ multiKey, signers, address });
+      }
+      default:
+        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${signingScheme}`);
+    }
+  }
+  AccountUtils2.deserialize = deserialize;
+  function keylessAccountFromHex(hex) {
+    const account = fromHex(hex);
+    if (!(account instanceof KeylessAccount)) {
+      throw new Error("Deserialization of KeylessAccount failed");
+    }
+    return account;
+  }
+  AccountUtils2.keylessAccountFromHex = keylessAccountFromHex;
+  function federatedKeylessAccountFromHex(hex) {
+    const account = fromHex(hex);
+    if (!(account instanceof FederatedKeylessAccount)) {
+      throw new Error("Deserialization of FederatedKeylessAccount failed");
+    }
+    return account;
+  }
+  AccountUtils2.federatedKeylessAccountFromHex = federatedKeylessAccountFromHex;
+  function multiKeyAccountFromHex(hex) {
+    const account = fromHex(hex);
+    if (!(account instanceof MultiKeyAccount)) {
+      throw new Error("Deserialization of MultiKeyAccount failed");
+    }
+    return account;
+  }
+  AccountUtils2.multiKeyAccountFromHex = multiKeyAccountFromHex;
+  function singleKeyAccountFromHex(hex) {
+    const account = fromHex(hex);
+    if (!(account instanceof SingleKeyAccount)) {
+      throw new Error("Deserialization of SingleKeyAccount failed");
+    }
+    return account;
+  }
+  AccountUtils2.singleKeyAccountFromHex = singleKeyAccountFromHex;
+  function ed25519AccountFromHex(hex) {
+    const account = fromHex(hex);
+    if (!(account instanceof Ed25519Account)) {
+      throw new Error("Deserialization of Ed25519Account failed");
+    }
+    return account;
+  }
+  AccountUtils2.ed25519AccountFromHex = ed25519AccountFromHex;
+  function fromHex(hex) {
+    return deserialize(Deserializer.fromHex(hex));
+  }
+  AccountUtils2.fromHex = fromHex;
+  function fromBytes(bytes) {
+    return fromHex(bytes);
+  }
+  AccountUtils2.fromBytes = fromBytes;
+})(AccountUtils || (AccountUtils = {}));
+
+export {
+  AccountUtils
+};
+//# sourceMappingURL=chunk-AEMQUDMU.mjs.map

package/dist/esm/{chunk-O37BZP2G.mjs.map → chunk-AEMQUDMU.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/account/AccountUtils.ts"],"sourcesContent":["import { Deserializer, Serializer } from \"../bcs\";\nimport { AnyPublicKeyVariant, HexInput, SigningScheme } from \"../types\";\nimport { MultiKeyAccount } from \"./MultiKeyAccount\";\nimport { Account } from \"./Account\";\nimport { Ed25519Account } from \"./Ed25519Account\";\nimport { isSingleKeySigner, SingleKeyAccount, SingleKeySignerOrLegacyEd25519Account } from \"./SingleKeyAccount\";\nimport { KeylessAccount } from \"./KeylessAccount\";\nimport { FederatedKeylessAccount } from \"./FederatedKeylessAccount\";\nimport { AbstractKeylessAccount } from \"./AbstractKeylessAccount\";\nimport {\n  AccountAddress,\n  Ed25519PrivateKey,\n  getIssAudAndUidVal,\n  Hex,\n  MultiKey,\n  Secp256k1PrivateKey,\n  ZeroKnowledgeSig,\n} from \"../core\";\nimport { deserializeSchemeAndAddress } from \"./utils\";\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\n\nfunction serializeKeylessAccountCommon(account: AbstractKeylessAccount, serializer: Serializer): void {\n  serializer.serializeStr(account.jwt);\n  serializer.serializeStr(account.uidKey);\n  serializer.serializeFixedBytes(account.pepper);\n  account.ephemeralKeyPair.serialize(serializer);\n  if (account.proof === undefined) {\n    throw new Error(\"Cannot serialize - proof undefined\");\n  }\n  account.proof.serialize(serializer);\n  serializer.serializeOption(account.verificationKeyHash, 32);\n}\n\nfunction deserializeKeylessAccountCommon(deserializer: Deserializer): {\n  jwt: string;\n  uidKey: string;\n  pepper: Uint8Array;\n  ephemeralKeyPair: EphemeralKeyPair;\n  proof: ZeroKnowledgeSig;\n  verificationKeyHash?: Uint8Array;\n} {\n  const jwt = deserializer.deserializeStr();\n  const uidKey = deserializer.deserializeStr();\n  const pepper = deserializer.deserializeFixedBytes(31);\n  const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);\n  const proof = ZeroKnowledgeSig.deserialize(deserializer);\n  const verificationKeyHash = deserializer.deserializeOption(\"fixedBytes\", 32);\n  return { jwt, uidKey, pepper, ephemeralKeyPair, proof, verificationKeyHash };\n}\n\n/**\n * Utility functions for working with accounts.\n */\nexport namespace AccountUtils {\n  export function toBytes(account: Account): Uint8Array {\n    const serializer = new Serializer();\n    serializer.serializeU32AsUleb128(account.signingScheme);\n    account.accountAddress.serialize(serializer);\n    switch (account.signingScheme) {\n      case SigningScheme.Ed25519:\n        (account as Ed25519Account).privateKey.serialize(serializer);\n        return serializer.toUint8Array();\n      case SigningScheme.SingleKey: {\n        if (!isSingleKeySigner(account)) {\n          throw new Error(\"Account is not a SingleKeySigner\");\n        }\n        const anyPublicKey = account.getAnyPublicKey();\n        serializer.serializeU32AsUleb128(anyPublicKey.variant);\n        switch (anyPublicKey.variant) {\n          case AnyPublicKeyVariant.Keyless: {\n            const keylessAccount = account as KeylessAccount;\n            serializeKeylessAccountCommon(keylessAccount, serializer);\n            return serializer.toUint8Array();\n          }\n          case AnyPublicKeyVariant.FederatedKeyless: {\n            const federatedKeylessAccount = account as FederatedKeylessAccount;\n            serializeKeylessAccountCommon(federatedKeylessAccount, serializer);\n            federatedKeylessAccount.publicKey.jwkAddress.serialize(serializer);\n            serializer.serializeBool(federatedKeylessAccount.audless);\n            return serializer.toUint8Array();\n          }\n          case AnyPublicKeyVariant.Secp256k1:\n          case AnyPublicKeyVariant.Ed25519: {\n            const singleKeyAccount = account as SingleKeyAccount;\n            singleKeyAccount.privateKey.serialize(serializer);\n            return serializer.toUint8Array();\n          }\n          default: {\n            throw new Error(`Invalid public key variant: ${anyPublicKey.variant}`);\n          }\n        }\n      }\n      case SigningScheme.MultiKey: {\n        const multiKeyAccount = account as MultiKeyAccount;\n        multiKeyAccount.publicKey.serialize(serializer);\n        serializer.serializeU32AsUleb128(multiKeyAccount.signers.length);\n        multiKeyAccount.signers.forEach((signer) => {\n          serializer.serializeFixedBytes(toBytes(signer));\n        });\n        return serializer.toUint8Array();\n      }\n      default:\n        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${account.signingScheme}`);\n    }\n  }\n\n  export function toHexStringWithoutPrefix(account: Account): string {\n    return Hex.hexInputToStringWithoutPrefix(toBytes(account));\n  }\n\n  export function toHexString(account: Account): string {\n    return Hex.hexInputToString(toBytes(account));\n  }\n\n  export function deserialize(deserializer: Deserializer): Account {\n    const { address, signingScheme } = deserializeSchemeAndAddress(deserializer);\n    switch (signingScheme) {\n      case SigningScheme.Ed25519: {\n        const privateKey = Ed25519PrivateKey.deserialize(deserializer);\n        return new Ed25519Account({ privateKey, address });\n      }\n      case SigningScheme.SingleKey: {\n        const variantIndex = deserializer.deserializeUleb128AsU32();\n        switch (variantIndex) {\n          case AnyPublicKeyVariant.Ed25519: {\n            const privateKey = Ed25519PrivateKey.deserialize(deserializer);\n            return new SingleKeyAccount({ privateKey, address });\n          }\n          case AnyPublicKeyVariant.Secp256k1: {\n            const privateKey = Secp256k1PrivateKey.deserialize(deserializer);\n            return new SingleKeyAccount({ privateKey, address });\n          }\n          case AnyPublicKeyVariant.Keyless: {\n            const keylessComponents = deserializeKeylessAccountCommon(deserializer);\n            const jwtClaims = getIssAudAndUidVal(keylessComponents);\n            return new KeylessAccount({ ...keylessComponents, ...jwtClaims });\n          }\n          case AnyPublicKeyVariant.FederatedKeyless: {\n            const keylessComponents = deserializeKeylessAccountCommon(deserializer);\n            const jwkAddress = AccountAddress.deserialize(deserializer);\n            const audless = deserializer.deserializeBool();\n            const jwtClaims = getIssAudAndUidVal(keylessComponents);\n            return new FederatedKeylessAccount({ ...keylessComponents, ...jwtClaims, jwkAddress, audless });\n          }\n          default:\n            throw new Error(`Unsupported public key variant ${variantIndex}`);\n        }\n      }\n      case SigningScheme.MultiKey: {\n        const multiKey = MultiKey.deserialize(deserializer);\n        const length = deserializer.deserializeUleb128AsU32();\n        const signers = new Array<SingleKeySignerOrLegacyEd25519Account>();\n        for (let i = 0; i < length; i += 1) {\n          const signer = deserialize(deserializer);\n          if (!isSingleKeySigner(signer) && !(signer instanceof Ed25519Account)) {\n            throw new Error(\n              \"Deserialization of MultiKeyAccount failed. Signer is not a SingleKeySigner or Ed25519Account\",\n            );\n          }\n          signers.push(signer);\n        }\n        return new MultiKeyAccount({ multiKey, signers, address });\n      }\n      default:\n        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${signingScheme}`);\n    }\n  }\n\n  export function keylessAccountFromHex(hex: HexInput): KeylessAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof KeylessAccount)) {\n      throw new Error(\"Deserialization of KeylessAccount failed\");\n    }\n    return account;\n  }\n\n  export function federatedKeylessAccountFromHex(hex: HexInput): FederatedKeylessAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof FederatedKeylessAccount)) {\n      throw new Error(\"Deserialization of FederatedKeylessAccount failed\");\n    }\n    return account;\n  }\n\n  export function multiKeyAccountFromHex(hex: HexInput): MultiKeyAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof MultiKeyAccount)) {\n      throw new Error(\"Deserialization of MultiKeyAccount failed\");\n    }\n    return account;\n  }\n\n  export function singleKeyAccountFromHex(hex: HexInput): SingleKeyAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof SingleKeyAccount)) {\n      throw new Error(\"Deserialization of SingleKeyAccount failed\");\n    }\n    return account;\n  }\n\n  export function ed25519AccountFromHex(hex: HexInput): Ed25519Account {\n    const account = fromHex(hex);\n    if (!(account instanceof Ed25519Account)) {\n      throw new Error(\"Deserialization of Ed25519Account failed\");\n    }\n    return account;\n  }\n\n  export function fromHex(hex: HexInput): Account {\n    return deserialize(Deserializer.fromHex(hex));\n  }\n\n  export function fromBytes(bytes: Uint8Array): Account {\n    return fromHex(bytes);\n  }\n}\n"],"mappings":"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","names":["serializeKeylessAccountCommon","account","serializer","deserializeKeylessAccountCommon","deserializer","jwt","uidKey","pepper","ephemeralKeyPair","EphemeralKeyPair","proof","ZeroKnowledgeSig","verificationKeyHash","AccountUtils","toBytes","Serializer","isSingleKeySigner","anyPublicKey","federatedKeylessAccount","multiKeyAccount","signer","toHexStringWithoutPrefix","Hex","toHexString","deserialize","address","signingScheme","deserializeSchemeAndAddress","privateKey","Ed25519PrivateKey","Ed25519Account","variantIndex","SingleKeyAccount","Secp256k1PrivateKey","keylessComponents","jwtClaims","getIssAudAndUidVal","KeylessAccount","jwkAddress","AccountAddress","audless","FederatedKeylessAccount","multiKey","MultiKey","length","signers","i","MultiKeyAccount","keylessAccountFromHex","hex","fromHex","federatedKeylessAccountFromHex","multiKeyAccountFromHex","singleKeyAccountFromHex","ed25519AccountFromHex","Deserializer","fromBytes","bytes"]}
+{"version":3,"sources":["../../src/account/AccountUtils.ts"],"sourcesContent":["import { Deserializer, Serializer } from \"../bcs\";\nimport { AnyPublicKeyVariant, HexInput, SigningScheme } from \"../types\";\nimport { MultiKeyAccount } from \"./MultiKeyAccount\";\nimport { Account } from \"./Account\";\nimport { Ed25519Account } from \"./Ed25519Account\";\nimport { isSingleKeySigner, SingleKeyAccount, SingleKeySignerOrLegacyEd25519Account } from \"./SingleKeyAccount\";\nimport { KeylessAccount } from \"./KeylessAccount\";\nimport { FederatedKeylessAccount } from \"./FederatedKeylessAccount\";\nimport { AbstractKeylessAccount } from \"./AbstractKeylessAccount\";\nimport {\n  AccountAddress,\n  Ed25519PrivateKey,\n  getIssAudAndUidVal,\n  Hex,\n  MultiKey,\n  Secp256k1PrivateKey,\n  ZeroKnowledgeSig,\n} from \"../core\";\nimport { deserializeSchemeAndAddress } from \"./utils\";\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\n\nfunction serializeKeylessAccountCommon(account: AbstractKeylessAccount, serializer: Serializer): void {\n  serializer.serializeStr(account.jwt);\n  serializer.serializeStr(account.uidKey);\n  serializer.serializeFixedBytes(account.pepper);\n  account.ephemeralKeyPair.serialize(serializer);\n  if (account.proof === undefined) {\n    throw new Error(\"Cannot serialize - proof undefined\");\n  }\n  account.proof.serialize(serializer);\n  serializer.serializeOption(account.verificationKeyHash, 32);\n}\n\nfunction deserializeKeylessAccountCommon(deserializer: Deserializer): {\n  jwt: string;\n  uidKey: string;\n  pepper: Uint8Array;\n  ephemeralKeyPair: EphemeralKeyPair;\n  proof: ZeroKnowledgeSig;\n  verificationKeyHash?: Uint8Array;\n} {\n  const jwt = deserializer.deserializeStr();\n  const uidKey = deserializer.deserializeStr();\n  const pepper = deserializer.deserializeFixedBytes(31);\n  const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);\n  const proof = ZeroKnowledgeSig.deserialize(deserializer);\n  const verificationKeyHash = deserializer.deserializeOption(\"fixedBytes\", 32);\n  return { jwt, uidKey, pepper, ephemeralKeyPair, proof, verificationKeyHash };\n}\n\n/**\n * Utility functions for working with accounts.\n */\nexport namespace AccountUtils {\n  export function toBytes(account: Account): Uint8Array {\n    const serializer = new Serializer();\n    serializer.serializeU32AsUleb128(account.signingScheme);\n    account.accountAddress.serialize(serializer);\n    switch (account.signingScheme) {\n      case SigningScheme.Ed25519:\n        (account as Ed25519Account).privateKey.serialize(serializer);\n        return serializer.toUint8Array();\n      case SigningScheme.SingleKey: {\n        if (!isSingleKeySigner(account)) {\n          throw new Error(\"Account is not a SingleKeySigner\");\n        }\n        const anyPublicKey = account.getAnyPublicKey();\n        serializer.serializeU32AsUleb128(anyPublicKey.variant);\n        switch (anyPublicKey.variant) {\n          case AnyPublicKeyVariant.Keyless: {\n            const keylessAccount = account as KeylessAccount;\n            serializeKeylessAccountCommon(keylessAccount, serializer);\n            return serializer.toUint8Array();\n          }\n          case AnyPublicKeyVariant.FederatedKeyless: {\n            const federatedKeylessAccount = account as FederatedKeylessAccount;\n            serializeKeylessAccountCommon(federatedKeylessAccount, serializer);\n            federatedKeylessAccount.publicKey.jwkAddress.serialize(serializer);\n            serializer.serializeBool(federatedKeylessAccount.audless);\n            return serializer.toUint8Array();\n          }\n          case AnyPublicKeyVariant.Secp256k1:\n          case AnyPublicKeyVariant.Ed25519: {\n            const singleKeyAccount = account as SingleKeyAccount;\n            singleKeyAccount.privateKey.serialize(serializer);\n            return serializer.toUint8Array();\n          }\n          default: {\n            throw new Error(`Invalid public key variant: ${anyPublicKey.variant}`);\n          }\n        }\n      }\n      case SigningScheme.MultiKey: {\n        const multiKeyAccount = account as MultiKeyAccount;\n        multiKeyAccount.publicKey.serialize(serializer);\n        serializer.serializeU32AsUleb128(multiKeyAccount.signers.length);\n        multiKeyAccount.signers.forEach((signer) => {\n          serializer.serializeFixedBytes(toBytes(signer));\n        });\n        return serializer.toUint8Array();\n      }\n      default:\n        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${account.signingScheme}`);\n    }\n  }\n\n  export function toHexStringWithoutPrefix(account: Account): string {\n    return Hex.hexInputToStringWithoutPrefix(toBytes(account));\n  }\n\n  export function toHexString(account: Account): string {\n    return Hex.hexInputToString(toBytes(account));\n  }\n\n  export function deserialize(deserializer: Deserializer): Account {\n    const { address, signingScheme } = deserializeSchemeAndAddress(deserializer);\n    switch (signingScheme) {\n      case SigningScheme.Ed25519: {\n        const privateKey = Ed25519PrivateKey.deserialize(deserializer);\n        return new Ed25519Account({ privateKey, address });\n      }\n      case SigningScheme.SingleKey: {\n        const variantIndex = deserializer.deserializeUleb128AsU32();\n        switch (variantIndex) {\n          case AnyPublicKeyVariant.Ed25519: {\n            const privateKey = Ed25519PrivateKey.deserialize(deserializer);\n            return new SingleKeyAccount({ privateKey, address });\n          }\n          case AnyPublicKeyVariant.Secp256k1: {\n            const privateKey = Secp256k1PrivateKey.deserialize(deserializer);\n            return new SingleKeyAccount({ privateKey, address });\n          }\n          case AnyPublicKeyVariant.Keyless: {\n            const keylessComponents = deserializeKeylessAccountCommon(deserializer);\n            const jwtClaims = getIssAudAndUidVal(keylessComponents);\n            return new KeylessAccount({ ...keylessComponents, ...jwtClaims });\n          }\n          case AnyPublicKeyVariant.FederatedKeyless: {\n            const keylessComponents = deserializeKeylessAccountCommon(deserializer);\n            const jwkAddress = AccountAddress.deserialize(deserializer);\n            const audless = deserializer.deserializeBool();\n            const jwtClaims = getIssAudAndUidVal(keylessComponents);\n            return new FederatedKeylessAccount({ ...keylessComponents, ...jwtClaims, jwkAddress, audless });\n          }\n          default:\n            throw new Error(`Unsupported public key variant ${variantIndex}`);\n        }\n      }\n      case SigningScheme.MultiKey: {\n        const multiKey = MultiKey.deserialize(deserializer);\n        const length = deserializer.deserializeUleb128AsU32();\n        const signers = new Array<SingleKeySignerOrLegacyEd25519Account>();\n        for (let i = 0; i < length; i += 1) {\n          const signer = deserialize(deserializer);\n          if (!isSingleKeySigner(signer) && !(signer instanceof Ed25519Account)) {\n            throw new Error(\n              \"Deserialization of MultiKeyAccount failed. Signer is not a SingleKeySigner or Ed25519Account\",\n            );\n          }\n          signers.push(signer);\n        }\n        return new MultiKeyAccount({ multiKey, signers, address });\n      }\n      default:\n        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${signingScheme}`);\n    }\n  }\n\n  export function keylessAccountFromHex(hex: HexInput): KeylessAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof KeylessAccount)) {\n      throw new Error(\"Deserialization of KeylessAccount failed\");\n    }\n    return account;\n  }\n\n  export function federatedKeylessAccountFromHex(hex: HexInput): FederatedKeylessAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof FederatedKeylessAccount)) {\n      throw new Error(\"Deserialization of FederatedKeylessAccount failed\");\n    }\n    return account;\n  }\n\n  export function multiKeyAccountFromHex(hex: HexInput): MultiKeyAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof MultiKeyAccount)) {\n      throw new Error(\"Deserialization of MultiKeyAccount failed\");\n    }\n    return account;\n  }\n\n  export function singleKeyAccountFromHex(hex: HexInput): SingleKeyAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof SingleKeyAccount)) {\n      throw new Error(\"Deserialization of SingleKeyAccount failed\");\n    }\n    return account;\n  }\n\n  export function ed25519AccountFromHex(hex: HexInput): Ed25519Account {\n    const account = fromHex(hex);\n    if (!(account instanceof Ed25519Account)) {\n      throw new Error(\"Deserialization of Ed25519Account failed\");\n    }\n    return account;\n  }\n\n  export function fromHex(hex: HexInput): Account {\n    return deserialize(Deserializer.fromHex(hex));\n  }\n\n  export function fromBytes(bytes: Uint8Array): Account {\n    return fromHex(bytes);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAS,8BAA8B,SAAiC,YAA8B;AACpG,aAAW,aAAa,QAAQ,GAAG;AACnC,aAAW,aAAa,QAAQ,MAAM;AACtC,aAAW,oBAAoB,QAAQ,MAAM;AAC7C,UAAQ,iBAAiB,UAAU,UAAU;AAC7C,MAAI,QAAQ,UAAU,QAAW;AAC/B,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACA,UAAQ,MAAM,UAAU,UAAU;AAClC,aAAW,gBAAgB,QAAQ,qBAAqB,EAAE;AAC5D;AAEA,SAAS,gCAAgC,cAOvC;AACA,QAAM,MAAM,aAAa,eAAe;AACxC,QAAM,SAAS,aAAa,eAAe;AAC3C,QAAM,SAAS,aAAa,sBAAsB,EAAE;AACpD,QAAM,mBAAmB,iBAAiB,YAAY,YAAY;AAClE,QAAM,QAAQ,iBAAiB,YAAY,YAAY;AACvD,QAAM,sBAAsB,aAAa,kBAAkB,cAAc,EAAE;AAC3E,SAAO,EAAE,KAAK,QAAQ,QAAQ,kBAAkB,OAAO,oBAAoB;AAC7E;AAKO,IAAU;AAAA,CAAV,CAAUA,kBAAV;AACE,WAAS,QAAQ,SAA8B;AACpD,UAAM,aAAa,IAAI,WAAW;AAClC,eAAW,sBAAsB,QAAQ,aAAa;AACtD,YAAQ,eAAe,UAAU,UAAU;AAC3C,YAAQ,QAAQ,eAAe;AAAA,MAC7B;AACE,QAAC,QAA2B,WAAW,UAAU,UAAU;AAC3D,eAAO,WAAW,aAAa;AAAA,MACjC,wBAA8B;AAC5B,YAAI,CAAC,kBAAkB,OAAO,GAAG;AAC/B,gBAAM,IAAI,MAAM,kCAAkC;AAAA,QACpD;AACA,cAAM,eAAe,QAAQ,gBAAgB;AAC7C,mBAAW,sBAAsB,aAAa,OAAO;AACrD,gBAAQ,aAAa,SAAS;AAAA,UAC5B,sBAAkC;AAChC,kBAAM,iBAAiB;AACvB,0CAA8B,gBAAgB,UAAU;AACxD,mBAAO,WAAW,aAAa;AAAA,UACjC;AAAA,UACA,+BAA2C;AACzC,kBAAM,0BAA0B;AAChC,0CAA8B,yBAAyB,UAAU;AACjE,oCAAwB,UAAU,WAAW,UAAU,UAAU;AACjE,uBAAW,cAAc,wBAAwB,OAAO;AACxD,mBAAO,WAAW,aAAa;AAAA,UACjC;AAAA,UACA;AAAA,UACA,sBAAkC;AAChC,kBAAM,mBAAmB;AACzB,6BAAiB,WAAW,UAAU,UAAU;AAChD,mBAAO,WAAW,aAAa;AAAA,UACjC;AAAA,UACA,SAAS;AACP,kBAAM,IAAI,MAAM,+BAA+B,aAAa,OAAO,EAAE;AAAA,UACvE;AAAA,QACF;AAAA,MACF;AAAA,MACA,uBAA6B;AAC3B,cAAM,kBAAkB;AACxB,wBAAgB,UAAU,UAAU,UAAU;AAC9C,mBAAW,sBAAsB,gBAAgB,QAAQ,MAAM;AAC/D,wBAAgB,QAAQ,QAAQ,CAAC,WAAW;AAC1C,qBAAW,oBAAoB,QAAQ,MAAM,CAAC;AAAA,QAChD,CAAC;AACD,eAAO,WAAW,aAAa;AAAA,MACjC;AAAA,MACA;AACE,cAAM,IAAI,MAAM,kEAAkE,QAAQ,aAAa,EAAE;AAAA,IAC7G;AAAA,EACF;AAlDO,EAAAA,cAAS;AAoDT,WAAS,yBAAyB,SAA0B;AACjE,WAAO,IAAI,8BAA8B,QAAQ,OAAO,CAAC;AAAA,EAC3D;AAFO,EAAAA,cAAS;AAIT,WAAS,YAAY,SAA0B;AACpD,WAAO,IAAI,iBAAiB,QAAQ,OAAO,CAAC;AAAA,EAC9C;AAFO,EAAAA,cAAS;AAIT,WAAS,YAAY,cAAqC;AAC/D,UAAM,EAAE,SAAS,cAAc,IAAI,4BAA4B,YAAY;AAC3E,YAAQ,eAAe;AAAA,MACrB,sBAA4B;AAC1B,cAAM,aAAa,kBAAkB,YAAY,YAAY;AAC7D,eAAO,IAAI,eAAe,EAAE,YAAY,QAAQ,CAAC;AAAA,MACnD;AAAA,MACA,wBAA8B;AAC5B,cAAM,eAAe,aAAa,wBAAwB;AAC1D,gBAAQ,cAAc;AAAA,UACpB,sBAAkC;AAChC,kBAAM,aAAa,kBAAkB,YAAY,YAAY;AAC7D,mBAAO,IAAI,iBAAiB,EAAE,YAAY,QAAQ,CAAC;AAAA,UACrD;AAAA,UACA,wBAAoC;AAClC,kBAAM,aAAa,oBAAoB,YAAY,YAAY;AAC/D,mBAAO,IAAI,iBAAiB,EAAE,YAAY,QAAQ,CAAC;AAAA,UACrD;AAAA,UACA,sBAAkC;AAChC,kBAAM,oBAAoB,gCAAgC,YAAY;AACtE,kBAAM,YAAY,mBAAmB,iBAAiB;AACtD,mBAAO,IAAI,eAAe,EAAE,GAAG,mBAAmB,GAAG,UAAU,CAAC;AAAA,UAClE;AAAA,UACA,+BAA2C;AACzC,kBAAM,oBAAoB,gCAAgC,YAAY;AACtE,kBAAM,aAAa,eAAe,YAAY,YAAY;AAC1D,kBAAM,UAAU,aAAa,gBAAgB;AAC7C,kBAAM,YAAY,mBAAmB,iBAAiB;AACtD,mBAAO,IAAI,wBAAwB,EAAE,GAAG,mBAAmB,GAAG,WAAW,YAAY,QAAQ,CAAC;AAAA,UAChG;AAAA,UACA;AACE,kBAAM,IAAI,MAAM,kCAAkC,YAAY,EAAE;AAAA,QACpE;AAAA,MACF;AAAA,MACA,uBAA6B;AAC3B,cAAM,WAAW,SAAS,YAAY,YAAY;AAClD,cAAM,SAAS,aAAa,wBAAwB;AACpD,cAAM,UAAU,IAAI,MAA6C;AACjE,iBAAS,IAAI,GAAG,IAAI,QAAQ,KAAK,GAAG;AAClC,gBAAM,SAAS,YAAY,YAAY;AACvC,cAAI,CAAC,kBAAkB,MAAM,KAAK,EAAE,kBAAkB,iBAAiB;AACrE,kBAAM,IAAI;AAAA,cACR;AAAA,YACF;AAAA,UACF;AACA,kBAAQ,KAAK,MAAM;AAAA,QACrB;AACA,eAAO,IAAI,gBAAgB,EAAE,UAAU,SAAS,QAAQ,CAAC;AAAA,MAC3D;AAAA,MACA;AACE,cAAM,IAAI,MAAM,kEAAkE,aAAa,EAAE;AAAA,IACrG;AAAA,EACF;AApDO,EAAAA,cAAS;AAsDT,WAAS,sBAAsB,KAA+B;AACnE,UAAM,UAAU,QAAQ,GAAG;AAC3B,QAAI,EAAE,mBAAmB,iBAAiB;AACxC,YAAM,IAAI,MAAM,0CAA0C;AAAA,IAC5D;AACA,WAAO;AAAA,EACT;AANO,EAAAA,cAAS;AAQT,WAAS,+BAA+B,KAAwC;AACrF,UAAM,UAAU,QAAQ,GAAG;AAC3B,QAAI,EAAE,mBAAmB,0BAA0B;AACjD,YAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AACA,WAAO;AAAA,EACT;AANO,EAAAA,cAAS;AAQT,WAAS,uBAAuB,KAAgC;AACrE,UAAM,UAAU,QAAQ,GAAG;AAC3B,QAAI,EAAE,mBAAmB,kBAAkB;AACzC,YAAM,IAAI,MAAM,2CAA2C;AAAA,IAC7D;AACA,WAAO;AAAA,EACT;AANO,EAAAA,cAAS;AAQT,WAAS,wBAAwB,KAAiC;AACvE,UAAM,UAAU,QAAQ,GAAG;AAC3B,QAAI,EAAE,mBAAmB,mBAAmB;AAC1C,YAAM,IAAI,MAAM,4CAA4C;AAAA,IAC9D;AACA,WAAO;AAAA,EACT;AANO,EAAAA,cAAS;AAQT,WAAS,sBAAsB,KAA+B;AACnE,UAAM,UAAU,QAAQ,GAAG;AAC3B,QAAI,EAAE,mBAAmB,iBAAiB;AACxC,YAAM,IAAI,MAAM,0CAA0C;AAAA,IAC5D;AACA,WAAO;AAAA,EACT;AANO,EAAAA,cAAS;AAQT,WAAS,QAAQ,KAAwB;AAC9C,WAAO,YAAY,aAAa,QAAQ,GAAG,CAAC;AAAA,EAC9C;AAFO,EAAAA,cAAS;AAIT,WAAS,UAAU,OAA4B;AACpD,WAAO,QAAQ,KAAK;AAAA,EACtB;AAFO,EAAAA,cAAS;AAAA,GA/JD;","names":["AccountUtils"]}

package/dist/esm/chunk-AKXCFBYF.mjs

@@ -0,0 +1,49 @@
+import {
+  AccountPublicKey
+} from "./chunk-R4JTQQBX.mjs";
+import {
+  Signature
+} from "./chunk-KLUO6XPE.mjs";
+import {
+  AuthenticationKey
+} from "./chunk-PKUXOBIV.mjs";
+import {
+  Hex
+} from "./chunk-BDM6FBUO.mjs";
+
+// src/core/crypto/abstraction.ts
+var AbstractSignature = class _AbstractSignature extends Signature {
+  constructor(value) {
+    super();
+    this.value = Hex.fromHexInput(value);
+  }
+  serialize(serializer) {
+    serializer.serializeBytes(this.value.toUint8Array());
+  }
+  static deserialize(deserializer) {
+    return new _AbstractSignature(deserializer.deserializeBytes());
+  }
+};
+var AbstractPublicKey = class extends AccountPublicKey {
+  constructor(accountAddress) {
+    super();
+    this.accountAddress = accountAddress;
+  }
+  authKey() {
+    return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });
+  }
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  verifySignature(args) {
+    throw new Error("This function is not implemented for AbstractPublicKey.");
+  }
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  serialize(serializer) {
+    throw new Error("This function is not implemented for AbstractPublicKey.");
+  }
+};
+
+export {
+  AbstractSignature,
+  AbstractPublicKey
+};
+//# sourceMappingURL=chunk-AKXCFBYF.mjs.map

package/dist/esm/{chunk-DBIZE7G6.mjs.map → chunk-AKXCFBYF.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/crypto/abstraction.ts"],"sourcesContent":["import { Deserializer, Serializer } from \"../../bcs\";\nimport { HexInput } from \"../../types\";\nimport { AccountAddress } from \"../accountAddress\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Hex } from \"../hex\";\nimport { AccountPublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\n\nexport class AbstractSignature extends Signature {\n  readonly value: Hex;\n\n  constructor(value: HexInput) {\n    super();\n    this.value = Hex.fromHexInput(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.value.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): AbstractSignature {\n    return new AbstractSignature(deserializer.deserializeBytes());\n  }\n}\n\nexport class AbstractPublicKey extends AccountPublicKey {\n  readonly accountAddress: AccountAddress;\n\n  constructor(accountAddress: AccountAddress) {\n    super();\n    this.accountAddress = accountAddress;\n  }\n\n  authKey(): AuthenticationKey {\n    return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });\n  }\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  verifySignature(args: VerifySignatureArgs): boolean {\n    throw new Error(\"This function is not implemented for AbstractPublicKey.\");\n  }\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  serialize(serializer: Serializer): void {\n    throw new Error(\"This function is not implemented for AbstractPublicKey.\");\n  }\n}\n"],"mappings":"oKAQO,IAAMA,EAAN,MAAMC,UAA0BC,CAAU,CAG/C,YAAYC,EAAiB,CAC3B,MAAM,EACN,KAAK,MAAQC,EAAI,aAAaD,CAAK,CACrC,CAEA,UAAUE,EAA8B,CACtCA,EAAW,eAAe,KAAK,MAAM,aAAa,CAAC,CACrD,CAEA,OAAO,YAAYC,EAA+C,CAChE,OAAO,IAAIL,EAAkBK,EAAa,iBAAiB,CAAC,CAC9D,CACF,EAEaC,EAAN,cAAgCC,CAAiB,CAGtD,YAAYC,EAAgC,CAC1C,MAAM,EACN,KAAK,eAAiBA,CACxB,CAEA,SAA6B,CAC3B,OAAO,IAAIC,EAAkB,CAAE,KAAM,KAAK,eAAe,aAAa,CAAE,CAAC,CAC3E,CAGA,gBAAgBC,EAAoC,CAClD,MAAM,IAAI,MAAM,yDAAyD,CAC3E,CAGA,UAAUN,EAA8B,CACtC,MAAM,IAAI,MAAM,yDAAyD,CAC3E,CACF","names":["AbstractSignature","_AbstractSignature","Signature","value","Hex","serializer","deserializer","AbstractPublicKey","AccountPublicKey","accountAddress","AuthenticationKey","args"]}
+{"version":3,"sources":["../../src/core/crypto/abstraction.ts"],"sourcesContent":["import { Deserializer, Serializer } from \"../../bcs\";\nimport { HexInput } from \"../../types\";\nimport { AccountAddress } from \"../accountAddress\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Hex } from \"../hex\";\nimport { AccountPublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\n\nexport class AbstractSignature extends Signature {\n  readonly value: Hex;\n\n  constructor(value: HexInput) {\n    super();\n    this.value = Hex.fromHexInput(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.value.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): AbstractSignature {\n    return new AbstractSignature(deserializer.deserializeBytes());\n  }\n}\n\nexport class AbstractPublicKey extends AccountPublicKey {\n  readonly accountAddress: AccountAddress;\n\n  constructor(accountAddress: AccountAddress) {\n    super();\n    this.accountAddress = accountAddress;\n  }\n\n  authKey(): AuthenticationKey {\n    return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });\n  }\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  verifySignature(args: VerifySignatureArgs): boolean {\n    throw new Error(\"This function is not implemented for AbstractPublicKey.\");\n  }\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  serialize(serializer: Serializer): void {\n    throw new Error(\"This function is not implemented for AbstractPublicKey.\");\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAQO,IAAM,oBAAN,MAAM,2BAA0B,UAAU;AAAA,EAG/C,YAAY,OAAiB;AAC3B,UAAM;AACN,SAAK,QAAQ,IAAI,aAAa,KAAK;AAAA,EACrC;AAAA,EAEA,UAAU,YAA8B;AACtC,eAAW,eAAe,KAAK,MAAM,aAAa,CAAC;AAAA,EACrD;AAAA,EAEA,OAAO,YAAY,cAA+C;AAChE,WAAO,IAAI,mBAAkB,aAAa,iBAAiB,CAAC;AAAA,EAC9D;AACF;AAEO,IAAM,oBAAN,cAAgC,iBAAiB;AAAA,EAGtD,YAAY,gBAAgC;AAC1C,UAAM;AACN,SAAK,iBAAiB;AAAA,EACxB;AAAA,EAEA,UAA6B;AAC3B,WAAO,IAAI,kBAAkB,EAAE,MAAM,KAAK,eAAe,aAAa,EAAE,CAAC;AAAA,EAC3E;AAAA;AAAA,EAGA,gBAAgB,MAAoC;AAClD,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AAAA;AAAA,EAGA,UAAU,YAA8B;AACtC,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AACF;","names":[]}