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

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

@@ -0,0 +1,91 @@
+import {
+  KeylessPublicKey
+} from "./chunk-T573PCIR.mjs";
+import {
+  AccountPublicKey
+} from "./chunk-R4JTQQBX.mjs";
+import {
+  AuthenticationKey
+} from "./chunk-PKUXOBIV.mjs";
+import {
+  AccountAddress
+} from "./chunk-CXLXUSCG.mjs";
+import {
+  Serializer
+} from "./chunk-C7T6GW5P.mjs";
+
+// src/core/crypto/federatedKeyless.ts
+var FederatedKeylessPublicKey = class _FederatedKeylessPublicKey extends AccountPublicKey {
+  constructor(jwkAddress, keylessPublicKey) {
+    super();
+    this.jwkAddress = AccountAddress.from(jwkAddress);
+    this.keylessPublicKey = keylessPublicKey;
+  }
+  /**
+   * Get the authentication key for the federated keyless public key
+   *
+   * @returns AuthenticationKey
+   * @group Implementation
+   * @category Serialization
+   */
+  authKey() {
+    const serializer = new Serializer();
+    serializer.serializeU32AsUleb128(4 /* FederatedKeyless */);
+    serializer.serializeFixedBytes(this.bcsToBytes());
+    return AuthenticationKey.fromSchemeAndBytes({
+      scheme: 2 /* SingleKey */,
+      input: serializer.toUint8Array()
+    });
+  }
+  /**
+   * Verifies a signed data with a public key
+   *
+   * @param args.message message
+   * @param args.signature The signature
+   * @returns true if the signature is valid
+   * @group Implementation
+   * @category Serialization
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
+  verifySignature(args) {
+    throw new Error("Not yet implemented");
+  }
+  serialize(serializer) {
+    this.jwkAddress.serialize(serializer);
+    this.keylessPublicKey.serialize(serializer);
+  }
+  static deserialize(deserializer) {
+    const jwkAddress = AccountAddress.deserialize(deserializer);
+    const keylessPublicKey = KeylessPublicKey.deserialize(deserializer);
+    return new _FederatedKeylessPublicKey(jwkAddress, keylessPublicKey);
+  }
+  static isPublicKey(publicKey) {
+    return publicKey instanceof _FederatedKeylessPublicKey;
+  }
+  /**
+   * Creates a FederatedKeylessPublicKey from the JWT components plus pepper
+   *
+   * @param args.iss the iss of the identity
+   * @param args.uidKey the key to use to get the uidVal in the JWT token
+   * @param args.uidVal the value of the uidKey in the JWT token
+   * @param args.aud the client ID of the application
+   * @param args.pepper The pepper used to maintain privacy of the account
+   * @returns FederatedKeylessPublicKey
+   * @group Implementation
+   * @category Serialization
+   */
+  static create(args) {
+    return new _FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.create(args));
+  }
+  static fromJwtAndPepper(args) {
+    return new _FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.fromJwtAndPepper(args));
+  }
+  static isInstance(publicKey) {
+    return "jwkAddress" in publicKey && publicKey.jwkAddress instanceof AccountAddress && "keylessPublicKey" in publicKey && publicKey.keylessPublicKey instanceof KeylessPublicKey;
+  }
+};
+
+export {
+  FederatedKeylessPublicKey
+};
+//# sourceMappingURL=chunk-6SNGKTWE.mjs.map

package/dist/esm/{chunk-BGSEBFFC.mjs.map → chunk-6SNGKTWE.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/crypto/federatedKeyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccountPublicKey, PublicKey } from \"./publicKey\";\nimport { Deserializer, Serializer } from \"../../bcs\";\nimport { HexInput, AnyPublicKeyVariant, SigningScheme } from \"../../types\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { AccountAddress, AccountAddressInput } from \"../accountAddress\";\nimport { KeylessPublicKey, KeylessSignature } from \"./keyless\";\n\n/**\n * Represents the FederatedKeylessPublicKey public key\n *\n * These keys use an on-chain address as a source of truth for the JWK used to verify signatures.\n *\n * FederatedKeylessPublicKey authentication key is represented in the SDK as `AnyPublicKey`.\n * @group Implementation\n * @category Serialization\n */\nexport class FederatedKeylessPublicKey extends AccountPublicKey {\n  /**\n   * The address that contains the JWK set to be used for verification.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly jwkAddress: AccountAddress;\n\n  /**\n   * The inner public key which contains the standard Keyless public key.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly keylessPublicKey: KeylessPublicKey;\n\n  constructor(jwkAddress: AccountAddressInput, keylessPublicKey: KeylessPublicKey) {\n    super();\n    this.jwkAddress = AccountAddress.from(jwkAddress);\n    this.keylessPublicKey = keylessPublicKey;\n  }\n\n  /**\n   * Get the authentication key for the federated keyless public key\n   *\n   * @returns AuthenticationKey\n   * @group Implementation\n   * @category Serialization\n   */\n  authKey(): AuthenticationKey {\n    const serializer = new Serializer();\n    serializer.serializeU32AsUleb128(AnyPublicKeyVariant.FederatedKeyless);\n    serializer.serializeFixedBytes(this.bcsToBytes());\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: SigningScheme.SingleKey,\n      input: serializer.toUint8Array(),\n    });\n  }\n\n  /**\n   * Verifies a signed data with a public key\n   *\n   * @param args.message message\n   * @param args.signature The signature\n   * @returns true if the signature is valid\n   * @group Implementation\n   * @category Serialization\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this\n  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {\n    throw new Error(\"Not yet implemented\");\n  }\n\n  serialize(serializer: Serializer): void {\n    this.jwkAddress.serialize(serializer);\n    this.keylessPublicKey.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): FederatedKeylessPublicKey {\n    const jwkAddress = AccountAddress.deserialize(deserializer);\n    const keylessPublicKey = KeylessPublicKey.deserialize(deserializer);\n    return new FederatedKeylessPublicKey(jwkAddress, keylessPublicKey);\n  }\n\n  static isPublicKey(publicKey: PublicKey): publicKey is FederatedKeylessPublicKey {\n    return publicKey instanceof FederatedKeylessPublicKey;\n  }\n\n  /**\n   * Creates a FederatedKeylessPublicKey from the JWT components plus pepper\n   *\n   * @param args.iss the iss of the identity\n   * @param args.uidKey the key to use to get the uidVal in the JWT token\n   * @param args.uidVal the value of the uidKey in the JWT token\n   * @param args.aud the client ID of the application\n   * @param args.pepper The pepper used to maintain privacy of the account\n   * @returns FederatedKeylessPublicKey\n   * @group Implementation\n   * @category Serialization\n   */\n  static create(args: {\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    jwkAddress: AccountAddressInput;\n  }): FederatedKeylessPublicKey {\n    return new FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.create(args));\n  }\n\n  static fromJwtAndPepper(args: {\n    jwt: string;\n    pepper: HexInput;\n    jwkAddress: AccountAddressInput;\n    uidKey?: string;\n  }): FederatedKeylessPublicKey {\n    return new FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.fromJwtAndPepper(args));\n  }\n\n  static isInstance(publicKey: PublicKey) {\n    return (\n      \"jwkAddress\" in publicKey &&\n      publicKey.jwkAddress instanceof AccountAddress &&\n      \"keylessPublicKey\" in publicKey &&\n      publicKey.keylessPublicKey instanceof KeylessPublicKey\n    );\n  }\n}\n"],"mappings":"6MAmBO,IAAMA,EAAN,MAAMC,UAAkCC,CAAiB,CAe9D,YAAYC,EAAiCC,EAAoC,CAC/E,MAAM,EACN,KAAK,WAAaC,EAAe,KAAKF,CAAU,EAChD,KAAK,iBAAmBC,CAC1B,CASA,SAA6B,CAC3B,IAAME,EAAa,IAAIC,EACvB,OAAAD,EAAW,uBAA0D,EACrEA,EAAW,oBAAoB,KAAK,WAAW,CAAC,EACzCE,EAAkB,mBAAmB,CAC1C,SACA,MAAOF,EAAW,aAAa,CACjC,CAAC,CACH,CAYA,gBAAgBG,EAAmE,CACjF,MAAM,IAAI,MAAM,qBAAqB,CACvC,CAEA,UAAUH,EAA8B,CACtC,KAAK,WAAW,UAAUA,CAAU,EACpC,KAAK,iBAAiB,UAAUA,CAAU,CAC5C,CAEA,OAAO,YAAYI,EAAuD,CACxE,IAAMP,EAAaE,EAAe,YAAYK,CAAY,EACpDN,EAAmBO,EAAiB,YAAYD,CAAY,EAClE,OAAO,IAAIT,EAA0BE,EAAYC,CAAgB,CACnE,CAEA,OAAO,YAAYQ,EAA8D,CAC/E,OAAOA,aAAqBX,CAC9B,CAcA,OAAO,OAAOQ,EAOgB,CAC5B,OAAO,IAAIR,EAA0BQ,EAAK,WAAYE,EAAiB,OAAOF,CAAI,CAAC,CACrF,CAEA,OAAO,iBAAiBA,EAKM,CAC5B,OAAO,IAAIR,EAA0BQ,EAAK,WAAYE,EAAiB,iBAAiBF,CAAI,CAAC,CAC/F,CAEA,OAAO,WAAWG,EAAsB,CACtC,MACE,eAAgBA,GAChBA,EAAU,sBAAsBP,GAChC,qBAAsBO,GACtBA,EAAU,4BAA4BD,CAE1C,CACF","names":["FederatedKeylessPublicKey","_FederatedKeylessPublicKey","AccountPublicKey","jwkAddress","keylessPublicKey","AccountAddress","serializer","Serializer","AuthenticationKey","args","deserializer","KeylessPublicKey","publicKey"]}
+{"version":3,"sources":["../../src/core/crypto/federatedKeyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccountPublicKey, PublicKey } from \"./publicKey\";\nimport { Deserializer, Serializer } from \"../../bcs\";\nimport { HexInput, AnyPublicKeyVariant, SigningScheme } from \"../../types\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { AccountAddress, AccountAddressInput } from \"../accountAddress\";\nimport { KeylessPublicKey, KeylessSignature } from \"./keyless\";\n\n/**\n * Represents the FederatedKeylessPublicKey public key\n *\n * These keys use an on-chain address as a source of truth for the JWK used to verify signatures.\n *\n * FederatedKeylessPublicKey authentication key is represented in the SDK as `AnyPublicKey`.\n * @group Implementation\n * @category Serialization\n */\nexport class FederatedKeylessPublicKey extends AccountPublicKey {\n  /**\n   * The address that contains the JWK set to be used for verification.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly jwkAddress: AccountAddress;\n\n  /**\n   * The inner public key which contains the standard Keyless public key.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly keylessPublicKey: KeylessPublicKey;\n\n  constructor(jwkAddress: AccountAddressInput, keylessPublicKey: KeylessPublicKey) {\n    super();\n    this.jwkAddress = AccountAddress.from(jwkAddress);\n    this.keylessPublicKey = keylessPublicKey;\n  }\n\n  /**\n   * Get the authentication key for the federated keyless public key\n   *\n   * @returns AuthenticationKey\n   * @group Implementation\n   * @category Serialization\n   */\n  authKey(): AuthenticationKey {\n    const serializer = new Serializer();\n    serializer.serializeU32AsUleb128(AnyPublicKeyVariant.FederatedKeyless);\n    serializer.serializeFixedBytes(this.bcsToBytes());\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: SigningScheme.SingleKey,\n      input: serializer.toUint8Array(),\n    });\n  }\n\n  /**\n   * Verifies a signed data with a public key\n   *\n   * @param args.message message\n   * @param args.signature The signature\n   * @returns true if the signature is valid\n   * @group Implementation\n   * @category Serialization\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this\n  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {\n    throw new Error(\"Not yet implemented\");\n  }\n\n  serialize(serializer: Serializer): void {\n    this.jwkAddress.serialize(serializer);\n    this.keylessPublicKey.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): FederatedKeylessPublicKey {\n    const jwkAddress = AccountAddress.deserialize(deserializer);\n    const keylessPublicKey = KeylessPublicKey.deserialize(deserializer);\n    return new FederatedKeylessPublicKey(jwkAddress, keylessPublicKey);\n  }\n\n  static isPublicKey(publicKey: PublicKey): publicKey is FederatedKeylessPublicKey {\n    return publicKey instanceof FederatedKeylessPublicKey;\n  }\n\n  /**\n   * Creates a FederatedKeylessPublicKey from the JWT components plus pepper\n   *\n   * @param args.iss the iss of the identity\n   * @param args.uidKey the key to use to get the uidVal in the JWT token\n   * @param args.uidVal the value of the uidKey in the JWT token\n   * @param args.aud the client ID of the application\n   * @param args.pepper The pepper used to maintain privacy of the account\n   * @returns FederatedKeylessPublicKey\n   * @group Implementation\n   * @category Serialization\n   */\n  static create(args: {\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    jwkAddress: AccountAddressInput;\n  }): FederatedKeylessPublicKey {\n    return new FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.create(args));\n  }\n\n  static fromJwtAndPepper(args: {\n    jwt: string;\n    pepper: HexInput;\n    jwkAddress: AccountAddressInput;\n    uidKey?: string;\n  }): FederatedKeylessPublicKey {\n    return new FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.fromJwtAndPepper(args));\n  }\n\n  static isInstance(publicKey: PublicKey) {\n    return (\n      \"jwkAddress\" in publicKey &&\n      publicKey.jwkAddress instanceof AccountAddress &&\n      \"keylessPublicKey\" in publicKey &&\n      publicKey.keylessPublicKey instanceof KeylessPublicKey\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBO,IAAM,4BAAN,MAAM,mCAAkC,iBAAiB;AAAA,EAe9D,YAAY,YAAiC,kBAAoC;AAC/E,UAAM;AACN,SAAK,aAAa,eAAe,KAAK,UAAU;AAChD,SAAK,mBAAmB;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,UAA6B;AAC3B,UAAM,aAAa,IAAI,WAAW;AAClC,eAAW,8CAA0D;AACrE,eAAW,oBAAoB,KAAK,WAAW,CAAC;AAChD,WAAO,kBAAkB,mBAAmB;AAAA,MAC1C;AAAA,MACA,OAAO,WAAW,aAAa;AAAA,IACjC,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,gBAAgB,MAAmE;AACjF,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AAAA,EAEA,UAAU,YAA8B;AACtC,SAAK,WAAW,UAAU,UAAU;AACpC,SAAK,iBAAiB,UAAU,UAAU;AAAA,EAC5C;AAAA,EAEA,OAAO,YAAY,cAAuD;AACxE,UAAM,aAAa,eAAe,YAAY,YAAY;AAC1D,UAAM,mBAAmB,iBAAiB,YAAY,YAAY;AAClE,WAAO,IAAI,2BAA0B,YAAY,gBAAgB;AAAA,EACnE;AAAA,EAEA,OAAO,YAAY,WAA8D;AAC/E,WAAO,qBAAqB;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,OAAO,OAAO,MAOgB;AAC5B,WAAO,IAAI,2BAA0B,KAAK,YAAY,iBAAiB,OAAO,IAAI,CAAC;AAAA,EACrF;AAAA,EAEA,OAAO,iBAAiB,MAKM;AAC5B,WAAO,IAAI,2BAA0B,KAAK,YAAY,iBAAiB,iBAAiB,IAAI,CAAC;AAAA,EAC/F;AAAA,EAEA,OAAO,WAAW,WAAsB;AACtC,WACE,gBAAgB,aAChB,UAAU,sBAAsB,kBAChC,sBAAsB,aACtB,UAAU,4BAA4B;AAAA,EAE1C;AACF;","names":[]}

package/dist/esm/chunk-A3TQLIEM.mjs

@@ -0,0 +1,19 @@
+import {
+  waitForIndexer
+} from "./chunk-SDIZSFCQ.mjs";
+
+// src/api/utils.ts
+async function waitForIndexerOnVersion(args) {
+  if (args.minimumLedgerVersion !== void 0) {
+    await waitForIndexer({
+      aptosConfig: args.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorType: args.processorType
+    });
+  }
+}
+
+export {
+  waitForIndexerOnVersion
+};
+//# sourceMappingURL=chunk-A3TQLIEM.mjs.map

package/dist/esm/{chunk-S7RZGC56.mjs.map → chunk-A3TQLIEM.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/api/utils.ts"],"sourcesContent":["import { waitForIndexer } from \"../internal/transaction\";\nimport { ProcessorType } from \"../utils\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { AnyNumber } from \"../types\";\n\n/**\n * Waits for the indexer to reach a specified ledger version, allowing for synchronization with the blockchain.\n * This function is useful for ensuring that your application is working with the most up-to-date data before proceeding.\n *\n * @param args - The parameters for waiting on the indexer.\n * @param args.config - The configuration object for Aptos.\n * @param [args.minimumLedgerVersion] - The minimum ledger version to wait for. If not specified, the function will not wait.\n * @param args.processorType - The type of processor to wait for.\n *\n * @example\n * ```typescript\n * import { Aptos, AptosConfig, Network, ProcessorType } from \"@aptos-labs/ts-sdk\";\n *\n * const config = new AptosConfig({ network: Network.TESTNET });\n * const aptos = new Aptos(config);\n *\n * async function runExample() {\n *   // Wait for the indexer to reach a specific ledger version\n *   await aptos.waitForIndexerOnVersion({\n *     config: config,\n *     minimumLedgerVersion: 1000n, // replace with a real ledger version\n *     processorType: ProcessorType.DEFAULT,\n *   });\n *\n *   console.log(\"Indexer is synced to the specified ledger version.\");\n * }\n * runExample().catch(console.error);\n * ```\n * @group Implementation\n */\nexport async function waitForIndexerOnVersion(args: {\n  config: AptosConfig;\n  minimumLedgerVersion?: AnyNumber;\n  processorType: ProcessorType;\n}) {\n  if (args.minimumLedgerVersion !== undefined) {\n    await waitForIndexer({\n      aptosConfig: args.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: args.processorType,\n    });\n  }\n}\n"],"mappings":"yCAmCA,eAAsBA,EAAwBC,EAI3C,CACGA,EAAK,uBAAyB,QAChC,MAAMC,EAAe,CACnB,YAAaD,EAAK,OAClB,qBAAsBA,EAAK,qBAC3B,cAAeA,EAAK,aACtB,CAAC,CAEL","names":["waitForIndexerOnVersion","args","waitForIndexer"]}
+{"version":3,"sources":["../../src/api/utils.ts"],"sourcesContent":["import { waitForIndexer } from \"../internal/transaction\";\nimport { ProcessorType } from \"../utils\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { AnyNumber } from \"../types\";\n\n/**\n * Waits for the indexer to reach a specified ledger version, allowing for synchronization with the blockchain.\n * This function is useful for ensuring that your application is working with the most up-to-date data before proceeding.\n *\n * @param args - The parameters for waiting on the indexer.\n * @param args.config - The configuration object for Aptos.\n * @param [args.minimumLedgerVersion] - The minimum ledger version to wait for. If not specified, the function will not wait.\n * @param args.processorType - The type of processor to wait for.\n *\n * @example\n * ```typescript\n * import { Aptos, AptosConfig, Network, ProcessorType } from \"@aptos-labs/ts-sdk\";\n *\n * const config = new AptosConfig({ network: Network.TESTNET });\n * const aptos = new Aptos(config);\n *\n * async function runExample() {\n *   // Wait for the indexer to reach a specific ledger version\n *   await aptos.waitForIndexerOnVersion({\n *     config: config,\n *     minimumLedgerVersion: 1000n, // replace with a real ledger version\n *     processorType: ProcessorType.DEFAULT,\n *   });\n *\n *   console.log(\"Indexer is synced to the specified ledger version.\");\n * }\n * runExample().catch(console.error);\n * ```\n * @group Implementation\n */\nexport async function waitForIndexerOnVersion(args: {\n  config: AptosConfig;\n  minimumLedgerVersion?: AnyNumber;\n  processorType: ProcessorType;\n}) {\n  if (args.minimumLedgerVersion !== undefined) {\n    await waitForIndexer({\n      aptosConfig: args.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: args.processorType,\n    });\n  }\n}\n"],"mappings":";;;;;AAmCA,eAAsB,wBAAwB,MAI3C;AACD,MAAI,KAAK,yBAAyB,QAAW;AAC3C,UAAM,eAAe;AAAA,MACnB,aAAa,KAAK;AAAA,MAClB,sBAAsB,KAAK;AAAA,MAC3B,eAAe,KAAK;AAAA,IACtB,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/esm/chunk-AGKEC2IM.mjs

@@ -0,0 +1,250 @@
+import {
+  MultiEd25519PublicKey,
+  MultiEd25519Signature
+} from "./chunk-3TUV6YMI.mjs";
+import {
+  MultiKey,
+  MultiKeySignature
+} from "./chunk-DMFRIING.mjs";
+import {
+  AnyPublicKey,
+  AnySignature
+} from "./chunk-IPUAVRGL.mjs";
+import {
+  Ed25519PublicKey,
+  Ed25519Signature
+} from "./chunk-TFW6N66T.mjs";
+import {
+  getFunctionParts,
+  isValidFunctionInfo
+} from "./chunk-RQS33JAS.mjs";
+import {
+  AccountAddress
+} from "./chunk-CXLXUSCG.mjs";
+import {
+  Serializable
+} from "./chunk-C7T6GW5P.mjs";
+import {
+  Hex
+} from "./chunk-BDM6FBUO.mjs";
+
+// src/transactions/authenticator/account.ts
+var AccountAuthenticator = class extends Serializable {
+  /**
+   * Deserializes an AccountAuthenticator from the provided deserializer.
+   * This function helps in reconstructing the AccountAuthenticator object based on the variant index.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   * @group Implementation
+   * @category Transactions
+   */
+  static deserialize(deserializer) {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case 0 /* Ed25519 */:
+        return AccountAuthenticatorEd25519.load(deserializer);
+      case 1 /* MultiEd25519 */:
+        return AccountAuthenticatorMultiEd25519.load(deserializer);
+      case 2 /* SingleKey */:
+        return AccountAuthenticatorSingleKey.load(deserializer);
+      case 3 /* MultiKey */:
+        return AccountAuthenticatorMultiKey.load(deserializer);
+      case 4 /* NoAccountAuthenticator */:
+        return AccountAuthenticatorNoAccountAuthenticator.load(deserializer);
+      case 5 /* Abstraction */:
+        return AccountAuthenticatorAbstraction.load(deserializer);
+      default:
+        throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
+    }
+  }
+  /**
+   * Determines if the current instance is an Ed25519 account authenticator.
+   *
+   * @returns {boolean} True if the instance is of type AccountAuthenticatorEd25519, otherwise false.
+   * @group Implementation
+   * @category Transactions
+   */
+  isEd25519() {
+    return this instanceof AccountAuthenticatorEd25519;
+  }
+  /**
+   * Determines if the current instance is of type AccountAuthenticatorMultiEd25519.
+   *
+   * @returns {boolean} True if the instance is a multi-signature Ed25519 account authenticator, otherwise false.
+   * @group Implementation
+   * @category Transactions
+   */
+  isMultiEd25519() {
+    return this instanceof AccountAuthenticatorMultiEd25519;
+  }
+  /**
+   * Determines if the current instance is of the type AccountAuthenticatorSingleKey.
+   *
+   * @returns {boolean} True if the instance is an AccountAuthenticatorSingleKey, otherwise false.
+   * @group Implementation
+   * @category Transactions
+   */
+  isSingleKey() {
+    return this instanceof AccountAuthenticatorSingleKey;
+  }
+  /**
+   * Determine if the current instance is of type AccountAuthenticatorMultiKey.
+   *
+   * @returns {boolean} Returns true if the instance is an AccountAuthenticatorMultiKey, otherwise false.
+   * @group Implementation
+   * @category Transactions
+   */
+  isMultiKey() {
+    return this instanceof AccountAuthenticatorMultiKey;
+  }
+};
+var AccountAuthenticatorEd25519 = class _AccountAuthenticatorEd25519 extends AccountAuthenticator {
+  /**
+   * Creates an instance of the class with the specified public keys and signatures.
+   *
+   * @param public_key The public key used for verification.
+   * @param signature The signatures corresponding to the public keys.
+   * @group Implementation
+   * @category Transactions
+   */
+  constructor(public_key, signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+  /**
+   * Serializes the account authenticator data into the provided serializer.
+   * This function captures the multi-key variant, public keys, and signatures for serialization.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category Transactions
+   */
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(0 /* Ed25519 */);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+  /**
+   * Loads an instance of AccountAuthenticatorMultiKey from the provided deserializer.
+   * This function helps in reconstructing the authenticator object using the deserialized public keys and signatures.
+   *
+   * @param deserializer - The deserializer used to extract the necessary data for loading the authenticator.
+   * @group Implementation
+   * @category Transactions
+   */
+  static load(deserializer) {
+    const public_key = Ed25519PublicKey.deserialize(deserializer);
+    const signature = Ed25519Signature.deserialize(deserializer);
+    return new _AccountAuthenticatorEd25519(public_key, signature);
+  }
+};
+var AccountAuthenticatorMultiEd25519 = class _AccountAuthenticatorMultiEd25519 extends AccountAuthenticator {
+  constructor(public_key, signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(1 /* MultiEd25519 */);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+  static load(deserializer) {
+    const public_key = MultiEd25519PublicKey.deserialize(deserializer);
+    const signature = MultiEd25519Signature.deserialize(deserializer);
+    return new _AccountAuthenticatorMultiEd25519(public_key, signature);
+  }
+};
+var AccountAuthenticatorSingleKey = class _AccountAuthenticatorSingleKey extends AccountAuthenticator {
+  constructor(public_key, signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(2 /* SingleKey */);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+  static load(deserializer) {
+    const public_key = AnyPublicKey.deserialize(deserializer);
+    const signature = AnySignature.deserialize(deserializer);
+    return new _AccountAuthenticatorSingleKey(public_key, signature);
+  }
+};
+var AccountAuthenticatorMultiKey = class _AccountAuthenticatorMultiKey extends AccountAuthenticator {
+  constructor(public_keys, signatures) {
+    super();
+    this.public_keys = public_keys;
+    this.signatures = signatures;
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(3 /* MultiKey */);
+    this.public_keys.serialize(serializer);
+    this.signatures.serialize(serializer);
+  }
+  static load(deserializer) {
+    const public_keys = MultiKey.deserialize(deserializer);
+    const signatures = MultiKeySignature.deserialize(deserializer);
+    return new _AccountAuthenticatorMultiKey(public_keys, signatures);
+  }
+};
+var AccountAuthenticatorNoAccountAuthenticator = class _AccountAuthenticatorNoAccountAuthenticator extends AccountAuthenticator {
+  // eslint-disable-next-line class-methods-use-this
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(4 /* NoAccountAuthenticator */);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static load(deserializer) {
+    return new _AccountAuthenticatorNoAccountAuthenticator();
+  }
+};
+var AccountAuthenticatorAbstraction = class _AccountAuthenticatorAbstraction extends AccountAuthenticator {
+  constructor(functionInfo, signingMessageDigest, authenticator) {
+    super();
+    if (!isValidFunctionInfo(functionInfo)) {
+      throw new Error(`Invalid function info ${functionInfo} passed into AccountAuthenticatorAbstraction`);
+    }
+    this.functionInfo = functionInfo;
+    this.authenticator = Hex.fromHexInput(authenticator);
+    this.signingMessageDigest = Hex.fromHexInput(Hex.fromHexInput(signingMessageDigest).toUint8Array());
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(5 /* Abstraction */);
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(this.functionInfo);
+    AccountAddress.fromString(moduleAddress).serialize(serializer);
+    serializer.serializeStr(moduleName);
+    serializer.serializeStr(functionName);
+    serializer.serializeU32AsUleb128(0 /* V1 */);
+    serializer.serializeBytes(this.signingMessageDigest.toUint8Array());
+    serializer.serializeFixedBytes(this.authenticator.toUint8Array());
+  }
+  static load(deserializer) {
+    const moduleAddress = AccountAddress.deserialize(deserializer);
+    const moduleName = deserializer.deserializeStr();
+    const functionName = deserializer.deserializeStr();
+    const variant = deserializer.deserializeUleb128AsU32();
+    if (variant === 0 /* V1 */) {
+      const signingMessageDigest = deserializer.deserializeBytes();
+      const authenticator = deserializer.deserializeFixedBytes(deserializer.remaining());
+      return new _AccountAuthenticatorAbstraction(
+        `${moduleAddress}::${moduleName}::${functionName}`,
+        signingMessageDigest,
+        authenticator
+      );
+    }
+    throw new Error(`Unknown variant index for AccountAuthenticatorAbstraction: ${variant}`);
+  }
+};
+
+export {
+  AccountAuthenticator,
+  AccountAuthenticatorEd25519,
+  AccountAuthenticatorMultiEd25519,
+  AccountAuthenticatorSingleKey,
+  AccountAuthenticatorMultiKey,
+  AccountAuthenticatorNoAccountAuthenticator,
+  AccountAuthenticatorAbstraction
+};
+//# sourceMappingURL=chunk-AGKEC2IM.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/authenticator/account.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { Serializer, Deserializer, Serializable } from \"../../bcs\";\nimport { AnyPublicKey, AnySignature } from \"../../core/crypto\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"../../core/crypto/ed25519\";\nimport { MultiEd25519PublicKey, MultiEd25519Signature } from \"../../core/crypto/multiEd25519\";\nimport { MultiKey, MultiKeySignature } from \"../../core/crypto/multiKey\";\nimport { AccountAuthenticatorVariant, HexInput, MoveFunctionId } from \"../../types\";\nimport { AbstractionAuthDataVariant } from \"../../types/abstraction\";\nimport { AccountAddress, Hex } from \"../../core\";\nimport { getFunctionParts, isValidFunctionInfo } from \"../../utils/helpers\";\n\n/**\n * Represents an account authenticator that can handle multiple authentication variants.\n * This class serves as a base for different types of account authenticators, allowing for serialization\n * and deserialization of various authenticator types.\n *\n * @extends Serializable\n * @group Implementation\n * @category Transactions\n */\nexport abstract class AccountAuthenticator extends Serializable {\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Deserializes an AccountAuthenticator from the provided deserializer.\n   * This function helps in reconstructing the AccountAuthenticator object based on the variant index.\n   *\n   * @param deserializer - The deserializer instance used to read the serialized data.\n   * @group Implementation\n   * @category Transactions\n   */\n  static deserialize(deserializer: Deserializer): AccountAuthenticator {\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case AccountAuthenticatorVariant.Ed25519:\n        return AccountAuthenticatorEd25519.load(deserializer);\n      case AccountAuthenticatorVariant.MultiEd25519:\n        return AccountAuthenticatorMultiEd25519.load(deserializer);\n      case AccountAuthenticatorVariant.SingleKey:\n        return AccountAuthenticatorSingleKey.load(deserializer);\n      case AccountAuthenticatorVariant.MultiKey:\n        return AccountAuthenticatorMultiKey.load(deserializer);\n      case AccountAuthenticatorVariant.NoAccountAuthenticator:\n        return AccountAuthenticatorNoAccountAuthenticator.load(deserializer);\n      case AccountAuthenticatorVariant.Abstraction:\n        return AccountAuthenticatorAbstraction.load(deserializer);\n      default:\n        throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);\n    }\n  }\n\n  /**\n   * Determines if the current instance is an Ed25519 account authenticator.\n   *\n   * @returns {boolean} True if the instance is of type AccountAuthenticatorEd25519, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isEd25519(): this is AccountAuthenticatorEd25519 {\n    return this instanceof AccountAuthenticatorEd25519;\n  }\n\n  /**\n   * Determines if the current instance is of type AccountAuthenticatorMultiEd25519.\n   *\n   * @returns {boolean} True if the instance is a multi-signature Ed25519 account authenticator, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isMultiEd25519(): this is AccountAuthenticatorMultiEd25519 {\n    return this instanceof AccountAuthenticatorMultiEd25519;\n  }\n\n  /**\n   * Determines if the current instance is of the type AccountAuthenticatorSingleKey.\n   *\n   * @returns {boolean} True if the instance is an AccountAuthenticatorSingleKey, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isSingleKey(): this is AccountAuthenticatorSingleKey {\n    return this instanceof AccountAuthenticatorSingleKey;\n  }\n\n  /**\n   * Determine if the current instance is of type AccountAuthenticatorMultiKey.\n   *\n   * @returns {boolean} Returns true if the instance is an AccountAuthenticatorMultiKey, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isMultiKey(): this is AccountAuthenticatorMultiKey {\n    return this instanceof AccountAuthenticatorMultiKey;\n  }\n}\n\n/**\n * Represents an Ed25519 transaction authenticator for multi-signer transactions.\n * This class encapsulates the account's Ed25519 public key and signature.\n *\n * @param public_key - The Ed25519 public key associated with the account.\n * @param signature - The Ed25519 signature for the account.\n * @group Implementation\n * @category Transactions\n */\nexport class AccountAuthenticatorEd25519 extends AccountAuthenticator {\n  public readonly public_key: Ed25519PublicKey;\n\n  public readonly signature: Ed25519Signature;\n\n  /**\n   * Creates an instance of the class with the specified public keys and signatures.\n   *\n   * @param public_key The public key used for verification.\n   * @param signature The signatures corresponding to the public keys.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature) {\n    super();\n    this.public_key = public_key;\n    this.signature = signature;\n  }\n\n  /**\n   * Serializes the account authenticator data into the provided serializer.\n   * This function captures the multi-key variant, public keys, and signatures for serialization.\n   *\n   * @param serializer - The serializer instance used to perform the serialization.\n   * @group Implementation\n   * @category Transactions\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.Ed25519);\n    this.public_key.serialize(serializer);\n    this.signature.serialize(serializer);\n  }\n\n  /**\n   * Loads an instance of AccountAuthenticatorMultiKey from the provided deserializer.\n   * This function helps in reconstructing the authenticator object using the deserialized public keys and signatures.\n   *\n   * @param deserializer - The deserializer used to extract the necessary data for loading the authenticator.\n   * @group Implementation\n   * @category Transactions\n   */\n  static load(deserializer: Deserializer): AccountAuthenticatorEd25519 {\n    const public_key = Ed25519PublicKey.deserialize(deserializer);\n    const signature = Ed25519Signature.deserialize(deserializer);\n    return new AccountAuthenticatorEd25519(public_key, signature);\n  }\n}\n\n/**\n * Represents a transaction authenticator for Multi Ed25519, designed for multi-signer transactions.\n *\n * @param public_key - The MultiEd25519 public key of the account.\n * @param signature - The MultiEd25519 signature of the account.\n * @group Implementation\n * @category Transactions\n */\nexport class AccountAuthenticatorMultiEd25519 extends AccountAuthenticator {\n  public readonly public_key: MultiEd25519PublicKey;\n\n  public readonly signature: MultiEd25519Signature;\n\n  constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature) {\n    super();\n    this.public_key = public_key;\n    this.signature = signature;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.MultiEd25519);\n    this.public_key.serialize(serializer);\n    this.signature.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): AccountAuthenticatorMultiEd25519 {\n    const public_key = MultiEd25519PublicKey.deserialize(deserializer);\n    const signature = MultiEd25519Signature.deserialize(deserializer);\n    return new AccountAuthenticatorMultiEd25519(public_key, signature);\n  }\n}\n\n/**\n * Represents an account authenticator that utilizes a single key for signing.\n * This class is designed to handle authentication using a public key and its corresponding signature.\n *\n * @param public_key - The public key used for authentication.\n * @param signature - The signature associated with the public key.\n * @group Implementation\n * @category Transactions\n */\nexport class AccountAuthenticatorSingleKey extends AccountAuthenticator {\n  public readonly public_key: AnyPublicKey;\n\n  public readonly signature: AnySignature;\n\n  constructor(public_key: AnyPublicKey, signature: AnySignature) {\n    super();\n    this.public_key = public_key;\n    this.signature = signature;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.SingleKey);\n    this.public_key.serialize(serializer);\n    this.signature.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): AccountAuthenticatorSingleKey {\n    const public_key = AnyPublicKey.deserialize(deserializer);\n    const signature = AnySignature.deserialize(deserializer);\n    return new AccountAuthenticatorSingleKey(public_key, signature);\n  }\n}\n\n/**\n * Represents an account authenticator that supports multiple keys and signatures for multi-signature scenarios.\n *\n * @param public_keys - The public keys used for authentication.\n * @param signatures - The signatures corresponding to the public keys.\n * @group Implementation\n * @category Transactions\n */\nexport class AccountAuthenticatorMultiKey extends AccountAuthenticator {\n  public readonly public_keys: MultiKey;\n\n  public readonly signatures: MultiKeySignature;\n\n  constructor(public_keys: MultiKey, signatures: MultiKeySignature) {\n    super();\n    this.public_keys = public_keys;\n    this.signatures = signatures;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.MultiKey);\n    this.public_keys.serialize(serializer);\n    this.signatures.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): AccountAuthenticatorMultiKey {\n    const public_keys = MultiKey.deserialize(deserializer);\n    const signatures = MultiKeySignature.deserialize(deserializer);\n    return new AccountAuthenticatorMultiKey(public_keys, signatures);\n  }\n}\n\n/**\n * AccountAuthenticatorNoAccountAuthenticator for no account authenticator\n * It represents the absence of a public key for transaction simulation.\n * It allows skipping the public/auth key check during the simulation.\n */\nexport class AccountAuthenticatorNoAccountAuthenticator extends AccountAuthenticator {\n  // eslint-disable-next-line class-methods-use-this\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.NoAccountAuthenticator);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  static load(deserializer: Deserializer): AccountAuthenticatorNoAccountAuthenticator {\n    return new AccountAuthenticatorNoAccountAuthenticator();\n  }\n}\n\nexport class AccountAuthenticatorAbstraction extends AccountAuthenticator {\n  public readonly functionInfo: string;\n\n  public readonly signingMessageDigest: Hex;\n\n  public readonly authenticator: Hex;\n\n  constructor(functionInfo: string, signingMessageDigest: HexInput, authenticator: HexInput) {\n    super();\n    if (!isValidFunctionInfo(functionInfo)) {\n      throw new Error(`Invalid function info ${functionInfo} passed into AccountAuthenticatorAbstraction`);\n    }\n    this.functionInfo = functionInfo;\n    this.authenticator = Hex.fromHexInput(authenticator);\n    this.signingMessageDigest = Hex.fromHexInput(Hex.fromHexInput(signingMessageDigest).toUint8Array());\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.Abstraction);\n    const { moduleAddress, moduleName, functionName } = getFunctionParts(this.functionInfo as MoveFunctionId);\n    AccountAddress.fromString(moduleAddress).serialize(serializer);\n    serializer.serializeStr(moduleName);\n    serializer.serializeStr(functionName);\n    serializer.serializeU32AsUleb128(AbstractionAuthDataVariant.V1);\n    serializer.serializeBytes(this.signingMessageDigest.toUint8Array());\n    serializer.serializeFixedBytes(this.authenticator.toUint8Array());\n  }\n\n  static load(deserializer: Deserializer): AccountAuthenticatorAbstraction {\n    const moduleAddress = AccountAddress.deserialize(deserializer);\n    const moduleName = deserializer.deserializeStr();\n    const functionName = deserializer.deserializeStr();\n    const variant = deserializer.deserializeUleb128AsU32();\n    if (variant === AbstractionAuthDataVariant.V1) {\n      const signingMessageDigest = deserializer.deserializeBytes();\n      const authenticator = deserializer.deserializeFixedBytes(deserializer.remaining());\n      return new AccountAuthenticatorAbstraction(\n        `${moduleAddress}::${moduleName}::${functionName}`,\n        signingMessageDigest,\n        authenticator,\n      );\n    }\n    throw new Error(`Unknown variant index for AccountAuthenticatorAbstraction: ${variant}`);\n  }\n}\n"],"mappings":"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","names":[]}

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-AKXCFBYF.mjs.map

@@ -0,0 +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":";;;;;;;;;;;;;;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":[]}

package/dist/esm/chunk-APM7OSLS.mjs

@@ -0,0 +1,122 @@
+// src/core/crypto/poseidon.ts
+import {
+  poseidon1,
+  poseidon2,
+  poseidon3,
+  poseidon4,
+  poseidon5,
+  poseidon6,
+  poseidon7,
+  poseidon8,
+  poseidon9,
+  poseidon10,
+  poseidon11,
+  poseidon12,
+  poseidon13,
+  poseidon14,
+  poseidon15,
+  poseidon16
+} from "poseidon-lite";
+var numInputsToPoseidonFunc = [
+  poseidon1,
+  poseidon2,
+  poseidon3,
+  poseidon4,
+  poseidon5,
+  poseidon6,
+  poseidon7,
+  poseidon8,
+  poseidon9,
+  poseidon10,
+  poseidon11,
+  poseidon12,
+  poseidon13,
+  poseidon14,
+  poseidon15,
+  poseidon16
+];
+var BYTES_PACKED_PER_SCALAR = 31;
+var MAX_NUM_INPUT_SCALARS = 16;
+var MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
+function hashStrToField(str, maxSizeBytes) {
+  const textEncoder = new TextEncoder();
+  const strBytes = textEncoder.encode(str);
+  return hashBytesWithLen(strBytes, maxSizeBytes);
+}
+function hashBytesWithLen(bytes, maxSizeBytes) {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);
+  return poseidonHash(packed);
+}
+function padAndPackBytesNoLen(bytes, maxSizeBytes) {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);
+  return packBytes(paddedStrBytes);
+}
+function padAndPackBytesWithLen(bytes, maxSizeBytes) {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
+}
+function packBytes(bytes) {
+  if (bytes.length > MAX_NUM_INPUT_BYTES) {
+    throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
+  }
+  return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
+}
+function chunkUint8Array(array, chunkSize) {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.subarray(i, i + chunkSize));
+  }
+  return result;
+}
+function bytesToBigIntLE(bytes) {
+  let result = BigInt(0);
+  for (let i = bytes.length - 1; i >= 0; i -= 1) {
+    result = result << BigInt(8) | BigInt(bytes[i]);
+  }
+  return result;
+}
+function bigIntToBytesLE(value, length) {
+  let val = BigInt(value);
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i += 1) {
+    bytes[i] = Number(val & BigInt(255));
+    val >>= BigInt(8);
+  }
+  return bytes;
+}
+function padUint8ArrayWithZeros(inputArray, paddedSize) {
+  if (paddedSize < inputArray.length) {
+    throw new Error("Padded size must be greater than or equal to the input array size.");
+  }
+  const paddedArray = new Uint8Array(paddedSize);
+  paddedArray.set(inputArray);
+  for (let i = inputArray.length; i < paddedSize; i += 1) {
+    paddedArray[i] = 0;
+  }
+  return paddedArray;
+}
+function poseidonHash(inputs) {
+  if (inputs.length > numInputsToPoseidonFunc.length) {
+    throw new Error(
+      `Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`
+    );
+  }
+  return numInputsToPoseidonFunc[inputs.length - 1](inputs);
+}
+
+export {
+  hashStrToField,
+  padAndPackBytesWithLen,
+  bytesToBigIntLE,
+  bigIntToBytesLE,
+  poseidonHash
+};
+//# sourceMappingURL=chunk-APM7OSLS.mjs.map