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

package/dist/esm/chunk-MD4TZ4HA.mjs

@@ -0,0 +1,125 @@
+import {
+  AbstractKeylessAccount
+} from "./chunk-SW4ASQPY.mjs";
+import {
+  KeylessPublicKey,
+  getIssAudAndUidVal
+} from "./chunk-ZZWD23YW.mjs";
+import {
+  Deserializer
+} from "./chunk-NUT2VOX2.mjs";
+import {
+  Hex
+} from "./chunk-BDM6FBUO.mjs";
+
+// src/account/KeylessAccount.ts
+var KeylessAccount = class _KeylessAccount extends AbstractKeylessAccount {
+  // Use the static constructor 'create' instead.
+  /**
+   * Use the static generator `create(...)` instead.
+   * Creates an instance of the KeylessAccount with an optional proof.
+   *
+   * @param args - The parameters for creating a KeylessAccount.
+   * @param args.address - Optional account address associated with the KeylessAccount.
+   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+   * @param args.iss - A JWT issuer.
+   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
+   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.
+   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
+   * OIDC registration with the identity provider.
+   * @param args.pepper - A hexadecimal input used for additional security.
+   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+   * @param args.proofFetchCallback - Optional callback function for fetching proof.
+   * @param args.jwt - A JSON Web Token used for authentication.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  constructor(args) {
+    const publicKey = KeylessPublicKey.create(args);
+    super({ publicKey, ...args });
+    this.publicKey = publicKey;
+  }
+  /**
+   * Serializes the transaction data into a format suitable for transmission or storage.
+   * This function ensures that both the transaction bytes and the proof are properly serialized.
+   *
+   * @param serializer - The serializer instance used to convert the transaction data into bytes.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  serialize(serializer) {
+    super.serialize(serializer);
+  }
+  /**
+   * Deserializes the provided deserializer to create a KeylessAccount instance.
+   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
+   *
+   * @param deserializer - The deserializer instance used to retrieve the serialized data.
+   * @returns A KeylessAccount instance created from the deserialized data.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  static deserialize(deserializer) {
+    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } = AbstractKeylessAccount.partialDeserialize(deserializer);
+    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
+    return new _KeylessAccount({
+      address,
+      proof,
+      ephemeralKeyPair,
+      iss,
+      uidKey,
+      uidVal,
+      aud,
+      pepper,
+      jwt,
+      verificationKeyHash
+    });
+  }
+  /**
+   * Deserialize bytes using this account's information.
+   *
+   * @param bytes The bytes being interpreted.
+   * @returns
+   */
+  static fromBytes(bytes) {
+    return _KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));
+  }
+  /**
+   * Creates a KeylessAccount instance using the provided parameters.
+   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
+   * This is used instead of the KeylessAccount constructor.
+   *
+   * @param args - The parameters for creating a KeylessAccount.
+   * @param args.address - Optional account address associated with the KeylessAccount.
+   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+   * @param args.jwt - A JSON Web Token used for authentication.
+   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+   * @param args.pepper - A hexadecimal input used for additional security.
+   * @param args.uidKey - Optional key for user identification, defaults to "sub".
+   * @param args.proofFetchCallback - Optional callback function for fetching proof.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  static create(args) {
+    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = "sub", proofFetchCallback, verificationKey } = args;
+    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
+    return new _KeylessAccount({
+      address,
+      proof,
+      ephemeralKeyPair,
+      iss,
+      uidKey,
+      uidVal,
+      aud,
+      pepper,
+      jwt,
+      proofFetchCallback,
+      verificationKeyHash: verificationKey ? verificationKey.hash() : void 0
+    });
+  }
+};
+
+export {
+  KeylessAccount
+};
+//# sourceMappingURL=chunk-MD4TZ4HA.mjs.map

package/dist/esm/{chunk-CRFLR3ZY.mjs.map → chunk-MD4TZ4HA.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/account/KeylessAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { HexInput } from \"../types\";\nimport { AccountAddress } from \"../core/accountAddress\";\nimport { getIssAudAndUidVal, Groth16VerificationKey, KeylessPublicKey, ZeroKnowledgeSig } from \"../core/crypto\";\n\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\nimport { Deserializer, Serializer } from \"../bcs\";\nimport { AbstractKeylessAccount, ProofFetchCallback } from \"./AbstractKeylessAccount\";\nimport { Hex } from \"../core/hex\";\n\n/**\n * Account implementation for the Keyless authentication scheme.\n *\n * Used to represent a Keyless based account and sign transactions with it.\n *\n * Use `KeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.\n *\n * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,\n * EphemeralKeyPair, and corresponding proof.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class KeylessAccount extends AbstractKeylessAccount {\n  /**\n   * The KeylessPublicKey associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly publicKey: KeylessPublicKey;\n\n  // Use the static constructor 'create' instead.\n\n  /**\n   * Use the static generator `create(...)` instead.\n   * Creates an instance of the KeylessAccount with an optional proof.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.iss - A JWT issuer.\n   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.\n   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.\n   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's\n   * OIDC registration with the identity provider.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  constructor(args: {\n    address?: AccountAddress;\n    ephemeralKeyPair: EphemeralKeyPair;\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    proofFetchCallback?: ProofFetchCallback;\n    jwt: string;\n    verificationKeyHash?: HexInput;\n  }) {\n    const publicKey = KeylessPublicKey.create(args);\n    super({ publicKey, ...args });\n    this.publicKey = publicKey;\n  }\n\n  /**\n   * Serializes the transaction data into a format suitable for transmission or storage.\n   * This function ensures that both the transaction bytes and the proof are properly serialized.\n   *\n   * @param serializer - The serializer instance used to convert the transaction data into bytes.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  serialize(serializer: Serializer): void {\n    super.serialize(serializer);\n  }\n\n  /**\n   * Deserializes the provided deserializer to create a KeylessAccount instance.\n   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.\n   *\n   * @param deserializer - The deserializer instance used to retrieve the serialized data.\n   * @returns A KeylessAccount instance created from the deserialized data.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static deserialize(deserializer: Deserializer): KeylessAccount {\n    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } =\n      AbstractKeylessAccount.partialDeserialize(deserializer);\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      verificationKeyHash,\n    });\n  }\n\n  /**\n   * Deserialize bytes using this account's information.\n   *\n   * @param bytes The bytes being interpreted.\n   * @returns\n   */\n  static fromBytes(bytes: HexInput): KeylessAccount {\n    return KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));\n  }\n\n  /**\n   * Creates a KeylessAccount instance using the provided parameters.\n   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.\n   * This is used instead of the KeylessAccount constructor.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.uidKey - Optional key for user identification, defaults to \"sub\".\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static create(args: {\n    address?: AccountAddress;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    pepper: HexInput;\n    uidKey?: string;\n    proofFetchCallback?: ProofFetchCallback;\n    verificationKey?: Groth16VerificationKey;\n  }): KeylessAccount {\n    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = \"sub\", proofFetchCallback, verificationKey } = args;\n\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      proofFetchCallback,\n      verificationKeyHash: verificationKey ? verificationKey.hash() : undefined,\n    });\n  }\n}\n"],"mappings":"2KAwBO,IAAMA,EAAN,MAAMC,UAAuBC,CAAuB,CA6BzD,YAAYC,EAYT,CACD,IAAMC,EAAYC,EAAiB,OAAOF,CAAI,EAC9C,MAAM,CAAE,UAAAC,EAAW,GAAGD,CAAK,CAAC,EAC5B,KAAK,UAAYC,CACnB,CAUA,UAAUE,EAA8B,CACtC,MAAM,UAAUA,CAAU,CAC5B,CAWA,OAAO,YAAYC,EAA4C,CAC7D,GAAM,CAAE,QAAAC,EAAS,MAAAC,EAAO,iBAAAC,EAAkB,IAAAC,EAAK,OAAAC,EAAQ,OAAAC,EAAQ,oBAAAC,CAAoB,EACjFZ,EAAuB,mBAAmBK,CAAY,EAClD,CAAE,IAAAQ,EAAK,IAAAC,EAAK,OAAAC,CAAO,EAAIC,EAAmB,CAAE,IAAAP,EAAK,OAAAC,CAAO,CAAC,EAC/D,OAAO,IAAIX,EAAe,CACxB,QAAAO,EACA,MAAAC,EACA,iBAAAC,EACA,IAAAK,EACA,OAAAH,EACA,OAAAK,EACA,IAAAD,EACA,OAAAH,EACA,IAAAF,EACA,oBAAAG,CACF,CAAC,CACH,CAQA,OAAO,UAAUK,EAAiC,CAChD,OAAOlB,EAAe,YAAY,IAAImB,EAAaC,EAAI,qBAAqBF,CAAK,CAAC,CAAC,CACrF,CAkBA,OAAO,OAAOhB,EASK,CACjB,GAAM,CAAE,QAAAK,EAAS,MAAAC,EAAO,IAAAE,EAAK,iBAAAD,EAAkB,OAAAG,EAAQ,OAAAD,EAAS,MAAO,mBAAAU,EAAoB,gBAAAC,CAAgB,EAAIpB,EAEzG,CAAE,IAAAY,EAAK,IAAAC,EAAK,OAAAC,CAAO,EAAIC,EAAmB,CAAE,IAAAP,EAAK,OAAAC,CAAO,CAAC,EAC/D,OAAO,IAAIX,EAAe,CACxB,QAAAO,EACA,MAAAC,EACA,iBAAAC,EACA,IAAAK,EACA,OAAAH,EACA,OAAAK,EACA,IAAAD,EACA,OAAAH,EACA,IAAAF,EACA,mBAAAW,EACA,oBAAqBC,EAAkBA,EAAgB,KAAK,EAAI,MAClE,CAAC,CACH,CACF","names":["KeylessAccount","_KeylessAccount","AbstractKeylessAccount","args","publicKey","KeylessPublicKey","serializer","deserializer","address","proof","ephemeralKeyPair","jwt","uidKey","pepper","verificationKeyHash","iss","aud","uidVal","getIssAudAndUidVal","bytes","Deserializer","Hex","proofFetchCallback","verificationKey"]}
+{"version":3,"sources":["../../src/account/KeylessAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { HexInput } from \"../types\";\nimport { AccountAddress } from \"../core/accountAddress\";\nimport { getIssAudAndUidVal, Groth16VerificationKey, KeylessPublicKey, ZeroKnowledgeSig } from \"../core/crypto\";\n\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\nimport { Deserializer, Serializer } from \"../bcs\";\nimport { AbstractKeylessAccount, ProofFetchCallback } from \"./AbstractKeylessAccount\";\nimport { Hex } from \"../core/hex\";\n\n/**\n * Account implementation for the Keyless authentication scheme.\n *\n * Used to represent a Keyless based account and sign transactions with it.\n *\n * Use `KeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.\n *\n * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,\n * EphemeralKeyPair, and corresponding proof.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class KeylessAccount extends AbstractKeylessAccount {\n  /**\n   * The KeylessPublicKey associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly publicKey: KeylessPublicKey;\n\n  // Use the static constructor 'create' instead.\n\n  /**\n   * Use the static generator `create(...)` instead.\n   * Creates an instance of the KeylessAccount with an optional proof.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.iss - A JWT issuer.\n   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.\n   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.\n   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's\n   * OIDC registration with the identity provider.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  constructor(args: {\n    address?: AccountAddress;\n    ephemeralKeyPair: EphemeralKeyPair;\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    proofFetchCallback?: ProofFetchCallback;\n    jwt: string;\n    verificationKeyHash?: HexInput;\n  }) {\n    const publicKey = KeylessPublicKey.create(args);\n    super({ publicKey, ...args });\n    this.publicKey = publicKey;\n  }\n\n  /**\n   * Serializes the transaction data into a format suitable for transmission or storage.\n   * This function ensures that both the transaction bytes and the proof are properly serialized.\n   *\n   * @param serializer - The serializer instance used to convert the transaction data into bytes.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  serialize(serializer: Serializer): void {\n    super.serialize(serializer);\n  }\n\n  /**\n   * Deserializes the provided deserializer to create a KeylessAccount instance.\n   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.\n   *\n   * @param deserializer - The deserializer instance used to retrieve the serialized data.\n   * @returns A KeylessAccount instance created from the deserialized data.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static deserialize(deserializer: Deserializer): KeylessAccount {\n    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } =\n      AbstractKeylessAccount.partialDeserialize(deserializer);\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      verificationKeyHash,\n    });\n  }\n\n  /**\n   * Deserialize bytes using this account's information.\n   *\n   * @param bytes The bytes being interpreted.\n   * @returns\n   */\n  static fromBytes(bytes: HexInput): KeylessAccount {\n    return KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));\n  }\n\n  /**\n   * Creates a KeylessAccount instance using the provided parameters.\n   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.\n   * This is used instead of the KeylessAccount constructor.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.uidKey - Optional key for user identification, defaults to \"sub\".\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static create(args: {\n    address?: AccountAddress;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    pepper: HexInput;\n    uidKey?: string;\n    proofFetchCallback?: ProofFetchCallback;\n    verificationKey?: Groth16VerificationKey;\n  }): KeylessAccount {\n    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = \"sub\", proofFetchCallback, verificationKey } = args;\n\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      proofFetchCallback,\n      verificationKeyHash: verificationKey ? verificationKey.hash() : undefined,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAwBO,IAAM,iBAAN,MAAM,wBAAuB,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA6BzD,YAAY,MAYT;AACD,UAAM,YAAY,iBAAiB,OAAO,IAAI;AAC9C,UAAM,EAAE,WAAW,GAAG,KAAK,CAAC;AAC5B,SAAK,YAAY;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,UAAU,YAA8B;AACtC,UAAM,UAAU,UAAU;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAO,YAAY,cAA4C;AAC7D,UAAM,EAAE,SAAS,OAAO,kBAAkB,KAAK,QAAQ,QAAQ,oBAAoB,IACjF,uBAAuB,mBAAmB,YAAY;AACxD,UAAM,EAAE,KAAK,KAAK,OAAO,IAAI,mBAAmB,EAAE,KAAK,OAAO,CAAC;AAC/D,WAAO,IAAI,gBAAe;AAAA,MACxB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,UAAU,OAAiC;AAChD,WAAO,gBAAe,YAAY,IAAI,aAAa,IAAI,qBAAqB,KAAK,CAAC,CAAC;AAAA,EACrF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,OAAO,OAAO,MASK;AACjB,UAAM,EAAE,SAAS,OAAO,KAAK,kBAAkB,QAAQ,SAAS,OAAO,oBAAoB,gBAAgB,IAAI;AAE/G,UAAM,EAAE,KAAK,KAAK,OAAO,IAAI,mBAAmB,EAAE,KAAK,OAAO,CAAC;AAC/D,WAAO,IAAI,gBAAe;AAAA,MACxB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,qBAAqB,kBAAkB,gBAAgB,KAAK,IAAI;AAAA,IAClE,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/esm/chunk-MFFBZ43D.mjs

@@ -0,0 +1,45 @@
+import {
+  Serializable
+} from "./chunk-C7T6GW5P.mjs";
+
+// src/transactions/instances/identifier.ts
+var Identifier = class _Identifier extends Serializable {
+  /**
+   * Creates an instance of the class with a specified identifier.
+   *
+   * @param identifier - The unique identifier for the instance.
+   * @group Implementation
+   * @category Transactions
+   */
+  constructor(identifier) {
+    super();
+    this.identifier = identifier;
+  }
+  /**
+   * Serializes the identifier of the current instance using the provided serializer.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category Transactions
+   */
+  serialize(serializer) {
+    serializer.serializeStr(this.identifier);
+  }
+  /**
+   * Deserializes an identifier from the provided deserializer.
+   * This function is useful for reconstructing an Identifier object from a serialized format.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   * @group Implementation
+   * @category Transactions
+   */
+  static deserialize(deserializer) {
+    const identifier = deserializer.deserializeStr();
+    return new _Identifier(identifier);
+  }
+};
+
+export {
+  Identifier
+};
+//# sourceMappingURL=chunk-MFFBZ43D.mjs.map

package/dist/esm/{chunk-N6YTF76Q.mjs.map → chunk-MFFBZ43D.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/transactions/instances/identifier.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\n\n/**\n * Represents an Identifier that can be serialized and deserialized.\n * This class is used to denote the module \"name\" in \"ModuleId\" and\n * the \"function name\" in \"EntryFunction\".\n *\n * @extends Serializable\n * @group Implementation\n * @category Transactions\n */\nexport class Identifier extends Serializable {\n  public identifier: string;\n\n  /**\n   * Creates an instance of the class with a specified identifier.\n   *\n   * @param identifier - The unique identifier for the instance.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(identifier: string) {\n    super();\n    this.identifier = identifier;\n  }\n\n  /**\n   * Serializes the identifier of the current instance using the provided serializer.\n   *\n   * @param serializer - The serializer instance used to perform the serialization.\n   * @group Implementation\n   * @category Transactions\n   */\n  public serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.identifier);\n  }\n\n  /**\n   * Deserializes an identifier from the provided deserializer.\n   * This function is useful for reconstructing an Identifier object from a serialized format.\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): Identifier {\n    const identifier = deserializer.deserializeStr();\n    return new Identifier(identifier);\n  }\n}\n"],"mappings":"yCAeO,IAAMA,EAAN,MAAMC,UAAmBC,CAAa,CAU3C,YAAYC,EAAoB,CAC9B,MAAM,EACN,KAAK,WAAaA,CACpB,CASO,UAAUC,EAA8B,CAC7CA,EAAW,aAAa,KAAK,UAAU,CACzC,CAUA,OAAO,YAAYC,EAAwC,CACzD,IAAMF,EAAaE,EAAa,eAAe,EAC/C,OAAO,IAAIJ,EAAWE,CAAU,CAClC,CACF","names":["Identifier","_Identifier","Serializable","identifier","serializer","deserializer"]}
+{"version":3,"sources":["../../src/transactions/instances/identifier.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\n\n/**\n * Represents an Identifier that can be serialized and deserialized.\n * This class is used to denote the module \"name\" in \"ModuleId\" and\n * the \"function name\" in \"EntryFunction\".\n *\n * @extends Serializable\n * @group Implementation\n * @category Transactions\n */\nexport class Identifier extends Serializable {\n  public identifier: string;\n\n  /**\n   * Creates an instance of the class with a specified identifier.\n   *\n   * @param identifier - The unique identifier for the instance.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(identifier: string) {\n    super();\n    this.identifier = identifier;\n  }\n\n  /**\n   * Serializes the identifier of the current instance using the provided serializer.\n   *\n   * @param serializer - The serializer instance used to perform the serialization.\n   * @group Implementation\n   * @category Transactions\n   */\n  public serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.identifier);\n  }\n\n  /**\n   * Deserializes an identifier from the provided deserializer.\n   * This function is useful for reconstructing an Identifier object from a serialized format.\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): Identifier {\n    const identifier = deserializer.deserializeStr();\n    return new Identifier(identifier);\n  }\n}\n"],"mappings":";;;;;AAeO,IAAM,aAAN,MAAM,oBAAmB,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAU3C,YAAY,YAAoB;AAC9B,UAAM;AACN,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,UAAU,YAA8B;AAC7C,eAAW,aAAa,KAAK,UAAU;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAO,YAAY,cAAwC;AACzD,UAAM,aAAa,aAAa,eAAe;AAC/C,WAAO,IAAI,YAAW,UAAU;AAAA,EAClC;AACF;","names":[]}

package/dist/esm/chunk-MLGROHE6.mjs

@@ -0,0 +1,192 @@
+import {
+  generateTransaction
+} from "./chunk-D3IWXA33.mjs";
+import {
+  lookupOriginalAccountAddress
+} from "./chunk-YGFWUFZY.mjs";
+import {
+  FederatedKeylessAccount
+} from "./chunk-IARAGRKO.mjs";
+import {
+  KeylessAccount
+} from "./chunk-MD4TZ4HA.mjs";
+import {
+  FederatedKeylessPublicKey
+} from "./chunk-YD3KHXBD.mjs";
+import {
+  Groth16Zkp,
+  KeylessPublicKey,
+  ZeroKnowledgeSig,
+  ZkProof,
+  getKeylessConfig
+} from "./chunk-ZZWD23YW.mjs";
+import {
+  EphemeralSignature
+} from "./chunk-MX2R6BBJ.mjs";
+import {
+  postAptosPepperService,
+  postAptosProvingService
+} from "./chunk-6T3V5LXK.mjs";
+import {
+  KeylessError
+} from "./chunk-32UQAST6.mjs";
+import {
+  MoveVector
+} from "./chunk-KSK3XIGF.mjs";
+import {
+  Hex
+} from "./chunk-BDM6FBUO.mjs";
+import {
+  FIREBASE_AUTH_ISS_PATTERN
+} from "./chunk-5QHMFYVL.mjs";
+
+// src/internal/keyless.ts
+import { jwtDecode } from "jwt-decode";
+async function getPepper(args) {
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey = "sub", derivationPath } = args;
+  const body = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    uid_key: uidKey,
+    derivation_path: derivationPath
+  };
+  const { data } = await postAptosPepperService({
+    aptosConfig,
+    path: "fetch",
+    body,
+    originMethod: "getPepper",
+    overrides: { WITH_CREDENTIALS: false }
+  });
+  return Hex.fromHexInput(data.pepper).toUint8Array();
+}
+async function getProof(args) {
+  const {
+    aptosConfig,
+    jwt,
+    ephemeralKeyPair,
+    pepper = await getPepper(args),
+    uidKey = "sub",
+    maxExpHorizonSecs = (await getKeylessConfig({ aptosConfig })).maxExpHorizonSecs
+  } = args;
+  if (Hex.fromHexInput(pepper).toUint8Array().length !== KeylessAccount.PEPPER_LENGTH) {
+    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);
+  }
+  const decodedJwt = jwtDecode(jwt);
+  if (typeof decodedJwt.iat !== "number") {
+    throw new Error("iat was not found");
+  }
+  if (maxExpHorizonSecs < ephemeralKeyPair.expiryDateSecs - decodedJwt.iat) {
+    throw Error(`The EphemeralKeyPair is too long lived.  It's lifespan must be less than ${maxExpHorizonSecs}`);
+  }
+  const json = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    exp_horizon_secs: maxExpHorizonSecs,
+    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
+    uid_key: uidKey
+  };
+  const { data } = await postAptosProvingService({
+    aptosConfig,
+    path: "prove",
+    body: json,
+    originMethod: "getProof",
+    overrides: { WITH_CREDENTIALS: false }
+  });
+  const proofPoints = data.proof;
+  const groth16Zkp = new Groth16Zkp({
+    a: proofPoints.a,
+    b: proofPoints.b,
+    c: proofPoints.c
+  });
+  const signedProof = new ZeroKnowledgeSig({
+    proof: new ZkProof(groth16Zkp, 0 /* Groth16 */),
+    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),
+    expHorizonSecs: maxExpHorizonSecs
+  });
+  return signedProof;
+}
+async function deriveKeylessAccount(args) {
+  const { aptosConfig, jwt, jwkAddress, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;
+  const { verificationKey, maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });
+  const proofPromise = getProof({ ...args, pepper, maxExpHorizonSecs });
+  const proof = proofFetchCallback ? proofPromise : await proofPromise;
+  if (jwkAddress !== void 0) {
+    const publicKey2 = FederatedKeylessPublicKey.fromJwtAndPepper({ jwt, pepper, jwkAddress, uidKey });
+    const address2 = await lookupOriginalAccountAddress({
+      aptosConfig,
+      authenticationKey: publicKey2.authKey().derivedAddress()
+    });
+    return FederatedKeylessAccount.create({
+      ...args,
+      address: address2,
+      proof,
+      pepper,
+      proofFetchCallback,
+      jwkAddress,
+      verificationKey
+    });
+  }
+  const publicKey = KeylessPublicKey.fromJwtAndPepper({ jwt, pepper, uidKey });
+  const address = await lookupOriginalAccountAddress({
+    aptosConfig,
+    authenticationKey: publicKey.authKey().derivedAddress()
+  });
+  return KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback, verificationKey });
+}
+async function updateFederatedKeylessJwkSetTransaction(args) {
+  const { aptosConfig, sender, iss, options } = args;
+  let { jwksUrl } = args;
+  if (jwksUrl === void 0) {
+    if (FIREBASE_AUTH_ISS_PATTERN.test(iss)) {
+      jwksUrl = "https://www.googleapis.com/service_accounts/v1/jwk/securetoken@system.gserviceaccount.com";
+    } else {
+      jwksUrl = iss.endsWith("/") ? `${iss}.well-known/jwks.json` : `${iss}/.well-known/jwks.json`;
+    }
+  }
+  let response;
+  try {
+    response = await fetch(jwksUrl);
+    if (!response.ok) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+  } catch (error) {
+    let errorMessage;
+    if (error instanceof Error) {
+      errorMessage = `${error.message}`;
+    } else {
+      errorMessage = `error unknown - ${error}`;
+    }
+    throw KeylessError.fromErrorType({
+      type: 14 /* JWK_FETCH_FAILED_FEDERATED */,
+      details: `Failed to fetch JWKS at ${jwksUrl}: ${errorMessage}`
+    });
+  }
+  const jwks = await response.json();
+  return generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress,
+    data: {
+      function: "0x1::jwks::update_federated_jwk_set",
+      functionArguments: [
+        iss,
+        MoveVector.MoveString(jwks.keys.map((key) => key.kid)),
+        MoveVector.MoveString(jwks.keys.map((key) => key.alg)),
+        MoveVector.MoveString(jwks.keys.map((key) => key.e)),
+        MoveVector.MoveString(jwks.keys.map((key) => key.n))
+      ]
+    },
+    options
+  });
+}
+
+export {
+  getPepper,
+  getProof,
+  deriveKeylessAccount,
+  updateFederatedKeylessJwkSetTransaction
+};
+//# sourceMappingURL=chunk-MLGROHE6.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internal/keyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file contains the underlying implementations for exposed API surface in\n * the {@link api/keyless}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * keyless namespace and without having a dependency cycle error.\n * @group Implementation\n */\nimport { jwtDecode, JwtPayload } from \"jwt-decode\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { postAptosPepperService, postAptosProvingService } from \"../client\";\nimport {\n  AccountAddressInput,\n  EphemeralSignature,\n  Groth16Zkp,\n  Hex,\n  KeylessPublicKey,\n  MoveJWK,\n  ZeroKnowledgeSig,\n  ZkProof,\n  getKeylessConfig,\n} from \"../core\";\nimport { HexInput, ZkpVariant } from \"../types\";\nimport { Account, EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from \"../account\";\nimport { PepperFetchRequest, PepperFetchResponse, ProverRequest, ProverResponse } from \"../types/keyless\";\nimport { lookupOriginalAccountAddress } from \"./account\";\nimport { FederatedKeylessPublicKey } from \"../core/crypto/federatedKeyless\";\nimport { FederatedKeylessAccount } from \"../account/FederatedKeylessAccount\";\nimport { MoveVector } from \"../bcs\";\nimport { generateTransaction } from \"./transactionSubmission\";\nimport { InputGenerateTransactionOptions, SimpleTransaction } from \"../transactions\";\nimport { KeylessError, KeylessErrorType } from \"../errors\";\nimport { FIREBASE_AUTH_ISS_PATTERN } from \"../utils/const\";\n\n/**\n * Retrieves a pepper value based on the provided configuration and authentication details.\n *\n * @param args - The arguments required to fetch the pepper.\n * @param args.aptosConfig - The configuration object for Aptos.\n * @param args.jwt - The JSON Web Token used for authentication.\n * @param args.ephemeralKeyPair - The ephemeral key pair used for the operation.\n * @param args.uidKey - An optional unique identifier key (defaults to \"sub\").\n * @param args.derivationPath - An optional derivation path for the key.\n * @returns A Uint8Array containing the fetched pepper value.\n * @group Implementation\n */\nexport async function getPepper(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  derivationPath?: string;\n}): Promise<Uint8Array> {\n  const { aptosConfig, jwt, ephemeralKeyPair, uidKey = \"sub\", derivationPath } = args;\n\n  const body = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),\n    exp_date_secs: ephemeralKeyPair.expiryDateSecs,\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    uid_key: uidKey,\n    derivation_path: derivationPath,\n  };\n  const { data } = await postAptosPepperService<PepperFetchRequest, PepperFetchResponse>({\n    aptosConfig,\n    path: \"fetch\",\n    body,\n    originMethod: \"getPepper\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n  return Hex.fromHexInput(data.pepper).toUint8Array();\n}\n\n/**\n * Generates a zero-knowledge proof based on the provided parameters.\n * This function is essential for creating a signed proof that can be used in various cryptographic operations.\n *\n * @param args - The parameters required to generate the proof.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.jwt - The JSON Web Token used for authentication.\n * @param args.ephemeralKeyPair - The ephemeral key pair used for generating the proof.\n * @param args.pepper - An optional hex input used to enhance security (default is generated if not provided).\n * @param args.uidKey - An optional string that specifies the unique identifier key (defaults to \"sub\").\n * @throws Error if the pepper length is not valid or if the ephemeral key pair's lifespan exceeds the maximum allowed.\n * @group Implementation\n */\nexport async function getProof(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  pepper?: HexInput;\n  uidKey?: string;\n  maxExpHorizonSecs?: number;\n}): Promise<ZeroKnowledgeSig> {\n  const {\n    aptosConfig,\n    jwt,\n    ephemeralKeyPair,\n    pepper = await getPepper(args),\n    uidKey = \"sub\",\n    maxExpHorizonSecs = (await getKeylessConfig({ aptosConfig })).maxExpHorizonSecs,\n  } = args;\n  if (Hex.fromHexInput(pepper).toUint8Array().length !== KeylessAccount.PEPPER_LENGTH) {\n    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);\n  }\n  const decodedJwt = jwtDecode<JwtPayload>(jwt);\n  if (typeof decodedJwt.iat !== \"number\") {\n    throw new Error(\"iat was not found\");\n  }\n  if (maxExpHorizonSecs < ephemeralKeyPair.expiryDateSecs - decodedJwt.iat) {\n    throw Error(`The EphemeralKeyPair is too long lived.  It's lifespan must be less than ${maxExpHorizonSecs}`);\n  }\n  const json = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    exp_date_secs: ephemeralKeyPair.expiryDateSecs,\n    exp_horizon_secs: maxExpHorizonSecs,\n    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),\n    uid_key: uidKey,\n  };\n\n  const { data } = await postAptosProvingService<ProverRequest, ProverResponse>({\n    aptosConfig,\n    path: \"prove\",\n    body: json,\n    originMethod: \"getProof\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n\n  const proofPoints = data.proof;\n  const groth16Zkp = new Groth16Zkp({\n    a: proofPoints.a,\n    b: proofPoints.b,\n    c: proofPoints.c,\n  });\n\n  const signedProof = new ZeroKnowledgeSig({\n    proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),\n    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),\n    expHorizonSecs: maxExpHorizonSecs,\n  });\n  return signedProof;\n}\n\n/**\n * Parameters for deriving a keyless account\n */\nexport type DeriveKeylessAccountParams = {\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  jwkAddress?: AccountAddressInput;\n  uidKey?: string;\n  pepper?: HexInput;\n  proofFetchCallback?: ProofFetchCallback;\n};\n\n/**\n * Derives a keyless account by fetching the necessary proof and looking up the original account address.\n * This function helps in creating a keyless account that can be used without managing private keys directly.\n *\n * @param args - The arguments required to derive the keyless account.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.jwt - The JSON Web Token used for authentication.\n * @param args.ephemeralKeyPair - The ephemeral key pair used for cryptographic operations.\n * @param args.uidKey - An optional unique identifier key for the user.\n * @param args.pepper - An optional hexadecimal input used for additional security.\n * @param args.proofFetchCallback - An optional callback function to handle the proof fetch outcome.\n * @returns A keyless account object.\n * @group Implementation\n */\nexport async function deriveKeylessAccount(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  pepper?: HexInput;\n  proofFetchCallback?: ProofFetchCallback;\n}): Promise<KeylessAccount>;\n\nexport async function deriveKeylessAccount(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  jwkAddress: AccountAddressInput;\n  uidKey?: string;\n  pepper?: HexInput;\n  proofFetchCallback?: ProofFetchCallback;\n}): Promise<FederatedKeylessAccount>;\n\nexport async function deriveKeylessAccount(\n  args: {\n    aptosConfig: AptosConfig;\n  } & DeriveKeylessAccountParams,\n): Promise<KeylessAccount | FederatedKeylessAccount> {\n  const { aptosConfig, jwt, jwkAddress, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;\n  const { verificationKey, maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });\n\n  const proofPromise = getProof({ ...args, pepper, maxExpHorizonSecs });\n  // If a callback is provided, pass in the proof as a promise to KeylessAccount.create.  This will make the proof be fetched in the\n  // background and the callback will handle the outcome of the fetch.  This allows the developer to not have to block on the proof fetch\n  // allowing for faster rendering of UX.\n  //\n  // If no callback is provided, the just await the proof fetch and continue synchronously.\n  const proof = proofFetchCallback ? proofPromise : await proofPromise;\n\n  // Look up the original address to handle key rotations and then instantiate the account.\n  if (jwkAddress !== undefined) {\n    const publicKey = FederatedKeylessPublicKey.fromJwtAndPepper({ jwt, pepper, jwkAddress, uidKey });\n    const address = await lookupOriginalAccountAddress({\n      aptosConfig,\n      authenticationKey: publicKey.authKey().derivedAddress(),\n    });\n\n    return FederatedKeylessAccount.create({\n      ...args,\n      address,\n      proof,\n      pepper,\n      proofFetchCallback,\n      jwkAddress,\n      verificationKey,\n    });\n  }\n\n  const publicKey = KeylessPublicKey.fromJwtAndPepper({ jwt, pepper, uidKey });\n  const address = await lookupOriginalAccountAddress({\n    aptosConfig,\n    authenticationKey: publicKey.authKey().derivedAddress(),\n  });\n  return KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback, verificationKey });\n}\n\nexport interface JWKS {\n  keys: MoveJWK[];\n}\n\nexport async function updateFederatedKeylessJwkSetTransaction(args: {\n  aptosConfig: AptosConfig;\n  sender: Account;\n  iss: string;\n  jwksUrl?: string;\n  options?: InputGenerateTransactionOptions;\n}): Promise<SimpleTransaction> {\n  const { aptosConfig, sender, iss, options } = args;\n\n  let { jwksUrl } = args;\n\n  if (jwksUrl === undefined) {\n    if (FIREBASE_AUTH_ISS_PATTERN.test(iss)) {\n      jwksUrl = \"https://www.googleapis.com/service_accounts/v1/jwk/securetoken@system.gserviceaccount.com\";\n    } else {\n      jwksUrl = iss.endsWith(\"/\") ? `${iss}.well-known/jwks.json` : `${iss}/.well-known/jwks.json`;\n    }\n  }\n\n  let response: Response;\n\n  try {\n    response = await fetch(jwksUrl);\n    if (!response.ok) {\n      throw new Error(`${response.status} ${response.statusText}`);\n    }\n  } catch (error) {\n    let errorMessage: string;\n    if (error instanceof Error) {\n      errorMessage = `${error.message}`;\n    } else {\n      errorMessage = `error unknown - ${error}`;\n    }\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.JWK_FETCH_FAILED_FEDERATED,\n      details: `Failed to fetch JWKS at ${jwksUrl}: ${errorMessage}`,\n    });\n  }\n\n  const jwks: JWKS = await response.json();\n  return generateTransaction({\n    aptosConfig,\n    sender: sender.accountAddress,\n    data: {\n      function: \"0x1::jwks::update_federated_jwk_set\",\n      functionArguments: [\n        iss,\n        MoveVector.MoveString(jwks.keys.map((key) => key.kid)),\n        MoveVector.MoveString(jwks.keys.map((key) => key.alg)),\n        MoveVector.MoveString(jwks.keys.map((key) => key.e)),\n        MoveVector.MoveString(jwks.keys.map((key) => key.n)),\n      ],\n    },\n    options,\n  });\n}\n"],"mappings":"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","names":["publicKey","address"]}

package/dist/esm/chunk-MWXBQ6HR.mjs

@@ -0,0 +1,15 @@
+import {
+  Deserializer
+} from "./chunk-NUT2VOX2.mjs";
+
+// src/utils/normalizeBundle.ts
+function normalizeBundle(cls, value) {
+  const serializedBytes = value.bcsToBytes();
+  const deserializer = new Deserializer(serializedBytes);
+  return cls.deserialize(deserializer);
+}
+
+export {
+  normalizeBundle
+};
+//# sourceMappingURL=chunk-MWXBQ6HR.mjs.map

package/dist/esm/{chunk-4YLUM62M.mjs.map → chunk-MWXBQ6HR.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/normalizeBundle.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Deserializer, Serializable } from \"../bcs\";\n/**\n * @group Implementation\n * @category Utils\n */\nexport type DeserializableClass<T extends Serializable> = {\n  /**\n   * Deserializes a serialized object using the provided deserializer.\n   * This function allows you to reconstruct an object from its serialized form.\n   *\n   * @param deserializer - An instance of the Deserializer used to read the serialized data.\n   * @group Implementation\n   * @category Utils\n   */\n  deserialize(deserializer: Deserializer): T;\n};\n\n/**\n * Normalizes an instance of a class by deserializing it from its byte representation.\n * This function allows the `instanceof` operator to work correctly when the input objects originate from a different bundle.\n *\n * @param cls - The class of the object to normalize.\n * @param value - The instance to normalize.\n * @group Implementation\n * @category Utils\n */\nexport function normalizeBundle<T extends Serializable>(cls: DeserializableClass<T>, value: T) {\n  const serializedBytes = value.bcsToBytes();\n  const deserializer = new Deserializer(serializedBytes);\n  return cls.deserialize(deserializer);\n}\n"],"mappings":"yCA6BO,SAASA,EAAwCC,EAA6BC,EAAU,CAC7F,IAAMC,EAAkBD,EAAM,WAAW,EACnCE,EAAe,IAAIC,EAAaF,CAAe,EACrD,OAAOF,EAAI,YAAYG,CAAY,CACrC","names":["normalizeBundle","cls","value","serializedBytes","deserializer","Deserializer"]}
+{"version":3,"sources":["../../src/utils/normalizeBundle.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Deserializer, Serializable } from \"../bcs\";\n/**\n * @group Implementation\n * @category Utils\n */\nexport type DeserializableClass<T extends Serializable> = {\n  /**\n   * Deserializes a serialized object using the provided deserializer.\n   * This function allows you to reconstruct an object from its serialized form.\n   *\n   * @param deserializer - An instance of the Deserializer used to read the serialized data.\n   * @group Implementation\n   * @category Utils\n   */\n  deserialize(deserializer: Deserializer): T;\n};\n\n/**\n * Normalizes an instance of a class by deserializing it from its byte representation.\n * This function allows the `instanceof` operator to work correctly when the input objects originate from a different bundle.\n *\n * @param cls - The class of the object to normalize.\n * @param value - The instance to normalize.\n * @group Implementation\n * @category Utils\n */\nexport function normalizeBundle<T extends Serializable>(cls: DeserializableClass<T>, value: T) {\n  const serializedBytes = value.bcsToBytes();\n  const deserializer = new Deserializer(serializedBytes);\n  return cls.deserialize(deserializer);\n}\n"],"mappings":";;;;;AA6BO,SAAS,gBAAwC,KAA6B,OAAU;AAC7F,QAAM,kBAAkB,MAAM,WAAW;AACzC,QAAM,eAAe,IAAI,aAAa,eAAe;AACrD,SAAO,IAAI,YAAY,YAAY;AACrC;","names":[]}

package/dist/esm/chunk-MX2R6BBJ.mjs

@@ -0,0 +1,150 @@
+import {
+  Ed25519PublicKey,
+  Ed25519Signature
+} from "./chunk-HRUI6AWF.mjs";
+import {
+  PublicKey
+} from "./chunk-R4JTQQBX.mjs";
+import {
+  Signature
+} from "./chunk-KLUO6XPE.mjs";
+import {
+  Deserializer
+} from "./chunk-NUT2VOX2.mjs";
+import {
+  Hex
+} from "./chunk-BDM6FBUO.mjs";
+
+// src/core/crypto/ephemeral.ts
+var EphemeralPublicKey = class _EphemeralPublicKey extends PublicKey {
+  /**
+   * Creates an instance of EphemeralPublicKey using the provided public key.
+   * This constructor ensures that only supported signature types are accepted.
+   *
+   * @param publicKey - The public key to be used for the ephemeral public key.
+   * @throws Error if the signature type is unsupported.
+   * @group Implementation
+   * @category Serialization
+   */
+  constructor(publicKey) {
+    super();
+    const publicKeyType = publicKey.constructor.name;
+    switch (publicKeyType) {
+      case Ed25519PublicKey.name:
+        this.publicKey = publicKey;
+        this.variant = 0 /* Ed25519 */;
+        break;
+      default:
+        throw new Error(`Unsupported key for EphemeralPublicKey - ${publicKeyType}`);
+    }
+  }
+  /**
+   * Verifies a signed message using the ephemeral public key.
+   *
+   * @param args - The arguments for the verification.
+   * @param args.message - The message that was signed.
+   * @param args.signature - The signature that was signed by the private key of the ephemeral public key.
+   * @returns true if the signature is valid, otherwise false.
+   * @group Implementation
+   * @category Serialization
+   */
+  verifySignature(args) {
+    const { message, signature } = args;
+    return this.publicKey.verifySignature({ message, signature: signature.signature });
+  }
+  /**
+   * Serializes the current instance, specifically handling the Ed25519 signature type.
+   * This function ensures that the signature is properly serialized using the provided serializer.
+   *
+   * @param serializer - The serializer instance used to serialize the signature.
+   * @throws Error if the signature type is unknown.
+   * @group Implementation
+   * @category Serialization
+   */
+  serialize(serializer) {
+    if (this.publicKey instanceof Ed25519PublicKey) {
+      serializer.serializeU32AsUleb128(0 /* Ed25519 */);
+      this.publicKey.serialize(serializer);
+    } else {
+      throw new Error("Unknown public key type");
+    }
+  }
+  /**
+   * Deserializes an EphemeralSignature from the provided deserializer.
+   * This function allows you to retrieve an EphemeralSignature based on the deserialized data.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   * @group Implementation
+   * @category Serialization
+   */
+  static deserialize(deserializer) {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case 0 /* Ed25519 */:
+        return new _EphemeralPublicKey(Ed25519PublicKey.deserialize(deserializer));
+      default:
+        throw new Error(`Unknown variant index for EphemeralPublicKey: ${index}`);
+    }
+  }
+  /**
+   * Determines if the provided public key is an instance of `EphemeralPublicKey`.
+   *
+   * @param publicKey - The public key to check.
+   * @returns A boolean indicating whether the public key is an ephemeral type.
+   * @group Implementation
+   * @category Serialization
+   */
+  static isPublicKey(publicKey) {
+    return publicKey instanceof _EphemeralPublicKey;
+  }
+};
+var EphemeralSignature = class _EphemeralSignature extends Signature {
+  constructor(signature) {
+    super();
+    const signatureType = signature.constructor.name;
+    switch (signatureType) {
+      case Ed25519Signature.name:
+        this.signature = signature;
+        break;
+      default:
+        throw new Error(`Unsupported signature for EphemeralSignature - ${signatureType}`);
+    }
+  }
+  /**
+   * Deserializes an ephemeral signature from a hexadecimal input.
+   * This function allows you to convert a hexadecimal representation of an ephemeral signature into its deserialized form for
+   * further processing.
+   *
+   * @param hexInput - The hexadecimal input representing the ephemeral signature.
+   * @group Implementation
+   * @category Serialization
+   */
+  static fromHex(hexInput) {
+    const data = Hex.fromHexInput(hexInput);
+    const deserializer = new Deserializer(data.toUint8Array());
+    return _EphemeralSignature.deserialize(deserializer);
+  }
+  serialize(serializer) {
+    if (this.signature instanceof Ed25519Signature) {
+      serializer.serializeU32AsUleb128(0 /* Ed25519 */);
+      this.signature.serialize(serializer);
+    } else {
+      throw new Error("Unknown signature type");
+    }
+  }
+  static deserialize(deserializer) {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case 0 /* Ed25519 */:
+        return new _EphemeralSignature(Ed25519Signature.deserialize(deserializer));
+      default:
+        throw new Error(`Unknown variant index for EphemeralSignature: ${index}`);
+    }
+  }
+};
+
+export {
+  EphemeralPublicKey,
+  EphemeralSignature
+};
+//# sourceMappingURL=chunk-MX2R6BBJ.mjs.map