@aptos-labs/ts-sdk 6.3.1 → 7.0.1

package/dist/core/crypto/keyless.js

@@ -0,0 +1,1482 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+import { jwtDecode } from "jwt-decode";
+import { sha3_256 } from "@noble/hashes/sha3.js";
+import { AccountPublicKey } from "./publicKey.js";
+import { Signature } from "./signature.js";
+import { Deserializer, Serializable, Serializer } from "../../bcs/index.js";
+import { Hex, hexToAsciiString } from "../hex.js";
+import { EphemeralCertificateVariant, AnyPublicKeyVariant, SigningScheme, ZkpVariant, } from "../../types/index.js";
+import { EphemeralPublicKey, EphemeralSignature } from "./ephemeral.js";
+import { bigIntToBytesLE, bytesToBigIntLE, hashStrToField, padAndPackBytesWithLen, poseidonHash } from "./poseidon.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { Proof } from "./proof.js";
+import { Ed25519PublicKey, Ed25519Signature } from "./ed25519.js";
+import { getAptosFullNode } from "../../client/index.js";
+import { memoizeAsync } from "../../utils/memoize.js";
+import { AccountAddress } from "../accountAddress.js";
+import { base64UrlEncode, base64UrlToBytes, nowInSeconds } from "../../utils/index.js";
+import { KeylessError, KeylessErrorType } from "../../errors/index.js";
+import { bn254 } from "@noble/curves/bn254.js";
+import { bytesToNumberBE } from "@noble/curves/utils.js";
+import { FederatedKeylessPublicKey } from "./federatedKeyless.js";
+import { generateSigningMessage } from "../../transactions/transactionBuilder/signingMessage.js";
+/**
+ * @group Implementation
+ * @category Serialization
+ */
+export const EPK_HORIZON_SECS = 10000000;
+/**
+ * @group Implementation
+ * @category Serialization
+ */
+export const MAX_AUD_VAL_BYTES = 120;
+/**
+ * @group Implementation
+ * @category Serialization
+ */
+export const MAX_UID_KEY_BYTES = 30;
+/**
+ * @group Implementation
+ * @category Serialization
+ */
+export const MAX_UID_VAL_BYTES = 330;
+/**
+ * @group Implementation
+ * @category Serialization
+ */
+export const MAX_ISS_VAL_BYTES = 120;
+/**
+ * @group Implementation
+ * @category Serialization
+ */
+export const MAX_EXTRA_FIELD_BYTES = 350;
+/**
+ * @group Implementation
+ * @category Serialization
+ */
+export const MAX_JWT_HEADER_B64_BYTES = 300;
+/**
+ * @group Implementation
+ * @category Serialization
+ */
+export const MAX_COMMITED_EPK_BYTES = 93;
+/**
+ * Represents a Keyless Public Key used for authentication.
+ *
+ * This class encapsulates the public key functionality for keyless authentication,
+ * including methods for generating and verifying signatures, as well as serialization
+ * and deserialization of the key. The KeylessPublicKey is represented in the SDK
+ * as `AnyPublicKey`.
+ * @group Implementation
+ * @category Serialization
+ */
+export class KeylessPublicKey extends AccountPublicKey {
+    /**
+     * The number of bytes that `idCommitment` should be
+     * @group Implementation
+     * @category Serialization
+     */
+    static ID_COMMITMENT_LENGTH = 32;
+    /**
+     * The value of the 'iss' claim on the JWT which identifies the OIDC provider.
+     * @group Implementation
+     * @category Serialization
+     */
+    iss;
+    /**
+     * A value representing a cryptographic commitment to a user identity.
+     *
+     * It is calculated from the aud, uidKey, uidVal, pepper.
+     * @group Implementation
+     * @category Serialization
+     */
+    idCommitment;
+    /**
+     * Constructs an instance with the specified parameters for cryptographic operations.
+     *
+     * @param args - The parameters required to initialize the instance.
+     * @param args.alphaG1 - The hex representation of the alpha G1 value.
+     * @param args.betaG2 - The hex representation of the beta G2 value.
+     * @param args.deltaG2 - The hex representation of the delta G2 value.
+     * @param args.gammaAbcG1 - An array containing two hex representations for gamma ABC G1 values.
+     * @param args.gammaG2 - The hex representation of the gamma G2 value.
+     * @group Implementation
+     * @category Serialization
+     */
+    // TODO: Fix the JSDoc for the below values
+    constructor(iss, idCommitment) {
+        super();
+        const idcBytes = Hex.fromHexInput(idCommitment).toUint8Array();
+        if (idcBytes.length !== KeylessPublicKey.ID_COMMITMENT_LENGTH) {
+            throw new Error(`Id Commitment length in bytes should be ${KeylessPublicKey.ID_COMMITMENT_LENGTH}`);
+        }
+        this.iss = iss;
+        this.idCommitment = idcBytes;
+    }
+    /**
+     * Get the authentication key for the keyless public key.
+     *
+     * @returns AuthenticationKey - The authentication key derived from the keyless public key.
+     * @group Implementation
+     * @category Serialization
+     */
+    authKey() {
+        const serializer = new Serializer();
+        serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Keyless);
+        serializer.serializeFixedBytes(this.bcsToBytes());
+        return AuthenticationKey.fromSchemeAndBytes({
+            scheme: SigningScheme.SingleKey,
+            input: serializer.toUint8Array(),
+        });
+    }
+    /**
+     * Verifies the validity of a signature for a given message.
+     *
+     * @param args - The arguments for signature verification.
+     * @param args.message - The message that was signed.
+     * @param args.signature - The signature to verify against the message.
+     * @param args.jwk - The JWK to use for verification.
+     * @param args.keylessConfig - The keyless configuration to use for verification.
+     * @returns true if the signature is valid; otherwise, false.
+     * @group Implementation
+     * @category Serialization
+     */
+    verifySignature(args) {
+        try {
+            verifyKeylessSignatureWithJwkAndConfig({ ...args, publicKey: this });
+            return true;
+        }
+        catch (error) {
+            if (error instanceof KeylessError) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Verifies a keyless signature for a given message.  It will fetch the keyless configuration and the JWK to
+     * use for verification from the appropriate network as defined by the aptosConfig.
+     *
+     * @param args.aptosConfig The aptos config to use for fetching the keyless configuration.
+     * @param args.message The message to verify the signature against.
+     * @param args.signature The signature to verify.
+     * @param args.options.throwErrorWithReason Whether to throw an error with the reason for the failure instead of returning false.
+     * @returns true if the signature is valid
+     */
+    async verifySignatureAsync(args) {
+        return verifyKeylessSignature({
+            ...args,
+            publicKey: this,
+        });
+    }
+    /**
+     * Serializes the current instance into a format suitable for transmission or storage.
+     * This function ensures that all relevant fields are properly serialized, including the proof and optional fields.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     * @param serializer.proof - The proof to be serialized.
+     * @param serializer.expHorizonSecs - The expiration horizon in seconds.
+     * @param serializer.extraField - An optional additional field for serialization.
+     * @param serializer.overrideAudVal - An optional override value for auditing.
+     * @param serializer.trainingWheelsSignature - An optional signature for training wheels.
+     * @group Implementation
+     * @category Serialization
+     */
+    serialize(serializer) {
+        serializer.serializeStr(this.iss);
+        serializer.serializeBytes(this.idCommitment);
+    }
+    /**
+     * Deserializes a ZeroKnowledgeSig object from the provided deserializer.
+     * This function allows you to reconstruct a ZeroKnowledgeSig instance from its serialized form.
+     *
+     * @param deserializer - The deserializer instance used to read the serialized data.
+     * @returns A new instance of ZeroKnowledgeSig.
+     * @group Implementation
+     * @category Serialization
+     */
+    static deserialize(deserializer) {
+        const iss = deserializer.deserializeStr();
+        const addressSeed = deserializer.deserializeBytes();
+        return new KeylessPublicKey(iss, addressSeed);
+    }
+    /**
+     * Loads a KeylessPublicKey instance from the provided deserializer.
+     * This function is used to deserialize the necessary components to create a KeylessPublicKey.
+     *
+     * @param deserializer - The deserializer used to extract the string and byte data.
+     * @param deserializer.deserializeStr - A method to deserialize a string value.
+     * @param deserializer.deserializeBytes - A method to deserialize byte data.
+     * @returns A new instance of KeylessPublicKey.
+     * @group Implementation
+     * @category Serialization
+     */
+    static load(deserializer) {
+        const iss = deserializer.deserializeStr();
+        const addressSeed = deserializer.deserializeBytes();
+        return new KeylessPublicKey(iss, addressSeed);
+    }
+    /**
+     * Determines if the provided public key is an instance of KeylessPublicKey.
+     *
+     * @param publicKey - The public key to check.
+     * @returns A boolean indicating whether the public key is a KeylessPublicKey instance.
+     * @group Implementation
+     * @category Serialization
+     */
+    static isPublicKey(publicKey) {
+        return publicKey instanceof KeylessPublicKey;
+    }
+    /**
+     * Creates a KeylessPublicKey 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 KeylessPublicKey
+     * @group Implementation
+     * @category Serialization
+     */
+    static create(args) {
+        computeIdCommitment(args);
+        return new KeylessPublicKey(args.iss, computeIdCommitment(args));
+    }
+    /**
+     * Creates a KeylessPublicKey instance from a JWT and a pepper value.
+     * This function is useful for generating a public key that can be used for authentication based on the provided JWT claims and pepper.
+     *
+     * @param args - The arguments for creating the KeylessPublicKey.
+     * @param args.jwt - The JSON Web Token to decode.
+     * @param args.pepper - The pepper value used in the key creation process.
+     * @param args.uidKey - An optional key to retrieve the unique identifier from the JWT payload, defaults to "sub".
+     * @returns A KeylessPublicKey instance created from the provided JWT and pepper.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromJwtAndPepper(args) {
+        const { jwt, pepper, uidKey = "sub" } = args;
+        const jwtPayload = jwtDecode(jwt);
+        if (typeof jwtPayload.iss !== "string") {
+            throw new Error("iss was not found");
+        }
+        if (typeof jwtPayload.aud !== "string") {
+            throw new Error("aud was not found or an array of values");
+        }
+        const uidVal = jwtPayload[uidKey];
+        return KeylessPublicKey.create({ iss: jwtPayload.iss, uidKey, uidVal, aud: jwtPayload.aud, pepper });
+    }
+    /**
+     * Checks if the provided public key is a valid instance by verifying its structure and types.
+     *
+     * @param publicKey - The public key to validate.
+     * @returns A boolean indicating whether the public key is a valid instance.
+     * @group Implementation
+     * @category Serialization
+     */
+    static isInstance(publicKey) {
+        return ("iss" in publicKey &&
+            typeof publicKey.iss === "string" &&
+            "idCommitment" in publicKey &&
+            publicKey.idCommitment instanceof Uint8Array);
+    }
+}
+export async function verifyKeylessSignature(args) {
+    const { aptosConfig, publicKey, message, signature, jwk, keylessConfig = await getKeylessConfig({ aptosConfig }), options, } = args;
+    try {
+        if (!(signature instanceof KeylessSignature)) {
+            throw KeylessError.fromErrorType({
+                type: KeylessErrorType.SIGNATURE_TYPE_INVALID,
+                details: "Not a keyless signature",
+            });
+        }
+        verifyKeylessSignatureWithJwkAndConfig({
+            message,
+            publicKey,
+            signature,
+            jwk: jwk || (await fetchJWK({ aptosConfig, publicKey, kid: signature.getJwkKid() })),
+            keylessConfig,
+        });
+        return true;
+    }
+    catch (error) {
+        if (options?.throwErrorWithReason) {
+            throw error;
+        }
+        return false;
+    }
+}
+/**
+ * Syncronously verifies a keyless signature for a given message.  You need to provide the keyless configuration and the
+ * JWK to use for verification.
+ *
+ * @param args.message The message to verify the signature against.
+ * @param args.signature The signature to verify.
+ * @param args.keylessConfig The keyless configuration.
+ * @param args.jwk The JWK to use for verification.
+ * @returns true if the signature is valid
+ * @throws KeylessError if the signature is invalid
+ */
+export function verifyKeylessSignatureWithJwkAndConfig(args) {
+    const { publicKey, message, signature, keylessConfig, jwk } = args;
+    const { verificationKey, maxExpHorizonSecs, trainingWheelsPubkey } = keylessConfig;
+    if (!(signature instanceof KeylessSignature)) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.SIGNATURE_TYPE_INVALID,
+            details: "Not a keyless signature",
+        });
+    }
+    if (!(signature.ephemeralCertificate.signature instanceof ZeroKnowledgeSig)) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.SIGNATURE_TYPE_INVALID,
+            details: "Unsupported ephemeral certificate variant",
+        });
+    }
+    const zkSig = signature.ephemeralCertificate.signature;
+    if (!(zkSig.proof.proof instanceof Groth16Zkp)) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.SIGNATURE_TYPE_INVALID,
+            details: "Unsupported proof variant for ZeroKnowledgeSig",
+        });
+    }
+    const groth16Proof = zkSig.proof.proof;
+    if (signature.expiryDateSecs < nowInSeconds()) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.SIGNATURE_EXPIRED,
+            details: "The expiryDateSecs is in the past",
+        });
+    }
+    if (zkSig.expHorizonSecs > maxExpHorizonSecs) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.MAX_EXPIRY_HORIZON_EXCEEDED,
+        });
+    }
+    if (!signature.ephemeralPublicKey.verifySignature({ message, signature: signature.ephemeralSignature })) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.EPHEMERAL_SIGNATURE_VERIFICATION_FAILED,
+        });
+    }
+    const publicInputsHash = getPublicInputsHash({ publicKey, signature, jwk, keylessConfig });
+    if (!verificationKey.verifyProof({ publicInputsHash, groth16Proof })) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.PROOF_VERIFICATION_FAILED,
+        });
+    }
+    if (trainingWheelsPubkey) {
+        if (!zkSig.trainingWheelsSignature) {
+            throw KeylessError.fromErrorType({
+                type: KeylessErrorType.TRAINING_WHEELS_SIGNATURE_MISSING,
+            });
+        }
+        const proofAndStatement = new Groth16ProofAndStatement(groth16Proof, publicInputsHash);
+        if (!trainingWheelsPubkey.verifySignature({
+            message: proofAndStatement.hash(),
+            signature: zkSig.trainingWheelsSignature,
+        })) {
+            throw KeylessError.fromErrorType({
+                type: KeylessErrorType.TRAINING_WHEELS_SIGNATURE_VERIFICATION_FAILED,
+            });
+        }
+    }
+}
+/**
+ * Get the public inputs hash for the keyless signature.
+ *
+ * @param args.signature The signature
+ * @param args.jwk The JWK to use for the public inputs hash
+ * @param args.keylessConfig The keyless configuration which defines the byte lengths to use when hashing fields.
+ * @returns The public inputs hash
+ */
+function getPublicInputsHash(args) {
+    const { publicKey, signature, jwk, keylessConfig } = args;
+    const innerKeylessPublicKey = publicKey instanceof KeylessPublicKey ? publicKey : publicKey.keylessPublicKey;
+    if (!(signature.ephemeralCertificate.signature instanceof ZeroKnowledgeSig)) {
+        throw new Error("Signature is not a ZeroKnowledgeSig");
+    }
+    const proof = signature.ephemeralCertificate.signature;
+    const fields = [];
+    fields.push(...padAndPackBytesWithLen(signature.ephemeralPublicKey.toUint8Array(), keylessConfig.maxCommitedEpkBytes));
+    fields.push(bytesToBigIntLE(innerKeylessPublicKey.idCommitment));
+    fields.push(signature.expiryDateSecs);
+    fields.push(proof.expHorizonSecs);
+    fields.push(hashStrToField(innerKeylessPublicKey.iss, keylessConfig.maxIssValBytes));
+    if (!proof.extraField) {
+        fields.push(0n);
+        fields.push(hashStrToField(" ", keylessConfig.maxExtraFieldBytes));
+    }
+    else {
+        fields.push(1n);
+        fields.push(hashStrToField(proof.extraField, keylessConfig.maxExtraFieldBytes));
+    }
+    const jwtHeaderB64Url = base64UrlEncode(signature.jwtHeader);
+    fields.push(hashStrToField(`${jwtHeaderB64Url}.`, keylessConfig.maxJwtHeaderB64Bytes));
+    fields.push(jwk.toScalar());
+    if (!proof.overrideAudVal) {
+        fields.push(hashStrToField("", MAX_AUD_VAL_BYTES));
+        fields.push(0n);
+    }
+    else {
+        fields.push(hashStrToField(proof.overrideAudVal, MAX_AUD_VAL_BYTES));
+        fields.push(1n);
+    }
+    return poseidonHash(fields);
+}
+/**
+ * Fetches the JWK from the issuer's well-known JWKS endpoint.
+ *
+ * @param args.publicKey The keyless public key which contains the issuer the address to fetch the JWK from (0x1 if not federated).
+ * @param args.kid The kid of the JWK to fetch
+ * @returns A JWK matching the `kid` in the JWT header.
+ * @throws {KeylessError} If the JWK cannot be fetched
+ */
+export async function fetchJWK(args) {
+    const { aptosConfig, publicKey, kid } = args;
+    const keylessPubKey = publicKey instanceof KeylessPublicKey ? publicKey : publicKey.keylessPublicKey;
+    const { iss } = keylessPubKey;
+    let allJWKs;
+    const jwkAddr = publicKey instanceof FederatedKeylessPublicKey ? publicKey.jwkAddress : undefined;
+    try {
+        allJWKs = await getKeylessJWKs({ aptosConfig, jwkAddr });
+    }
+    catch (error) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.FULL_NODE_JWKS_LOOKUP_ERROR,
+            error,
+            details: `Failed to fetch ${jwkAddr ? "Federated" : "Patched"}JWKs ${jwkAddr ? `for address ${jwkAddr}` : "0x1"}`,
+        });
+    }
+    // Find the corresponding JWK set by `iss`
+    const jwksForIssuer = allJWKs.get(iss);
+    if (jwksForIssuer === undefined) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.INVALID_JWT_ISS_NOT_RECOGNIZED,
+            details: `JWKs for issuer ${iss} not found.`,
+        });
+    }
+    // Find the corresponding JWK by `kid`
+    const jwk = jwksForIssuer.find((key) => key.kid === kid);
+    if (jwk === undefined) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.INVALID_JWT_JWK_NOT_FOUND,
+            details: `JWK with kid '${kid}' for issuer '${iss}' not found.`,
+        });
+    }
+    return jwk;
+}
+function computeIdCommitment(args) {
+    const { uidKey, uidVal, aud, pepper } = args;
+    const fields = [
+        bytesToBigIntLE(Hex.fromHexInput(pepper).toUint8Array()),
+        hashStrToField(aud, MAX_AUD_VAL_BYTES),
+        hashStrToField(uidVal, MAX_UID_VAL_BYTES),
+        hashStrToField(uidKey, MAX_UID_KEY_BYTES),
+    ];
+    return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ID_COMMITMENT_LENGTH);
+}
+/**
+ * Represents a signature of a message signed via a Keyless Account, utilizing proofs or a JWT token for authentication.
+ * @group Implementation
+ * @category Serialization
+ */
+export class KeylessSignature extends Signature {
+    /**
+     * The inner signature ZeroKnowledgeSignature or OpenIdSignature
+     * @group Implementation
+     * @category Serialization
+     */
+    ephemeralCertificate;
+    /**
+     * The jwt header in the token used to create the proof/signature.  In json string representation.
+     * @group Implementation
+     * @category Serialization
+     */
+    jwtHeader;
+    /**
+     * The expiry timestamp in seconds of the EphemeralKeyPair used to sign
+     * @group Implementation
+     * @category Serialization
+     */
+    expiryDateSecs;
+    /**
+     * The ephemeral public key used to verify the signature
+     * @group Implementation
+     * @category Serialization
+     */
+    ephemeralPublicKey;
+    /**
+     * The signature resulting from signing with the private key of the EphemeralKeyPair
+     * @group Implementation
+     * @category Serialization
+     */
+    ephemeralSignature;
+    constructor(args) {
+        super();
+        const { jwtHeader, ephemeralCertificate, expiryDateSecs, ephemeralPublicKey, ephemeralSignature } = args;
+        this.jwtHeader = jwtHeader;
+        this.ephemeralCertificate = ephemeralCertificate;
+        this.expiryDateSecs = expiryDateSecs;
+        this.ephemeralPublicKey = ephemeralPublicKey;
+        this.ephemeralSignature = ephemeralSignature;
+    }
+    /**
+     * Get the kid of the JWT used to derive the Keyless Account used to sign.
+     *
+     * @returns the kid as a string
+     */
+    getJwkKid() {
+        return parseJwtHeader(this.jwtHeader).kid;
+    }
+    serialize(serializer) {
+        this.ephemeralCertificate.serialize(serializer);
+        serializer.serializeStr(this.jwtHeader);
+        serializer.serializeU64(this.expiryDateSecs);
+        this.ephemeralPublicKey.serialize(serializer);
+        this.ephemeralSignature.serialize(serializer);
+    }
+    static deserialize(deserializer) {
+        const ephemeralCertificate = EphemeralCertificate.deserialize(deserializer);
+        const jwtHeader = deserializer.deserializeStr();
+        const expiryDateSecs = deserializer.deserializeU64();
+        const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);
+        const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
+        return new KeylessSignature({
+            jwtHeader,
+            expiryDateSecs: Number(expiryDateSecs),
+            ephemeralCertificate,
+            ephemeralPublicKey,
+            ephemeralSignature,
+        });
+    }
+    static getSimulationSignature() {
+        return new KeylessSignature({
+            jwtHeader: "{}",
+            ephemeralCertificate: new EphemeralCertificate(new ZeroKnowledgeSig({
+                proof: new ZkProof(new Groth16Zkp({ a: new Uint8Array(32), b: new Uint8Array(64), c: new Uint8Array(32) }), ZkpVariant.Groth16),
+                expHorizonSecs: 0,
+            }), EphemeralCertificateVariant.ZkProof),
+            expiryDateSecs: 0,
+            ephemeralPublicKey: new EphemeralPublicKey(new Ed25519PublicKey(new Uint8Array(32))),
+            ephemeralSignature: new EphemeralSignature(new Ed25519Signature(new Uint8Array(64))),
+        });
+    }
+    static isSignature(signature) {
+        return signature instanceof KeylessSignature;
+    }
+}
+/**
+ * Represents an ephemeral certificate containing a signature, specifically a ZeroKnowledgeSig.
+ * This class can be extended to support additional signature types, such as OpenIdSignature.
+ *
+ * @extends Signature
+ * @group Implementation
+ * @category Serialization
+ */
+export class EphemeralCertificate extends Signature {
+    signature;
+    /**
+     * Index of the underlying enum variant
+     * @group Implementation
+     * @category Serialization
+     */
+    variant;
+    constructor(signature, variant) {
+        super();
+        this.signature = signature;
+        this.variant = variant;
+    }
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     * @group Implementation
+     * @category Serialization
+     */
+    toUint8Array() {
+        return this.signature.toUint8Array();
+    }
+    serialize(serializer) {
+        serializer.serializeU32AsUleb128(this.variant);
+        this.signature.serialize(serializer);
+    }
+    static deserialize(deserializer) {
+        const variant = deserializer.deserializeUleb128AsU32();
+        switch (variant) {
+            case EphemeralCertificateVariant.ZkProof:
+                return new EphemeralCertificate(ZeroKnowledgeSig.deserialize(deserializer), variant);
+            default:
+                throw new Error(`Unknown variant index for EphemeralCertificate: ${variant}`);
+        }
+    }
+}
+/**
+ * Represents a fixed-size byte array of 32 bytes, extending the Serializable class.
+ * This class is used for handling and serializing G1 bytes in cryptographic operations.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category Serialization
+ */
+class G1Bytes extends Serializable {
+    static B = bn254.fields.Fp.create(3n);
+    data;
+    constructor(data) {
+        super();
+        this.data = Hex.fromHexInput(data).toUint8Array();
+        if (this.data.length !== 32) {
+            throw new Error("Input needs to be 32 bytes");
+        }
+    }
+    serialize(serializer) {
+        serializer.serializeFixedBytes(this.data);
+    }
+    static deserialize(deserializer) {
+        const bytes = deserializer.deserializeFixedBytes(32);
+        return new G1Bytes(bytes);
+    }
+    // Convert the projective coordinates to strings
+    toArray() {
+        const point = this.toProjectivePoint();
+        return [point.x.toString(), point.y.toString(), point.Z.toString()];
+    }
+    /**
+     * Converts the G1 bytes to a projective point.
+     * @returns The projective point.
+     */
+    toProjectivePoint() {
+        const bytes = new Uint8Array(this.data);
+        // Reverse the bytes to convert from little-endian to big-endian.
+        bytes.reverse();
+        // This gets the flag bit to determine which y to use.
+        const yFlag = (bytes[0] & 0x80) >> 7;
+        const { Fp } = bn254.fields;
+        const x = Fp.create(bytesToBn254FpBE(bytes));
+        const y = Fp.sqrt(Fp.add(Fp.pow(x, 3n), G1Bytes.B));
+        const negY = Fp.neg(y);
+        const yToUse = y > negY === (yFlag === 1) ? y : negY;
+        return bn254.G1.Point.fromAffine({
+            x,
+            y: yToUse,
+        });
+    }
+}
+function bytesToBn254FpBE(bytes) {
+    if (bytes.length !== 32) {
+        throw new Error("Input should be 32 bytes");
+    }
+    // Clear the first two bits of the first byte which removes any flags.
+    const result = new Uint8Array(bytes);
+    result[0] &= 0x3f; // 0x3F = 00111111 in binary
+    return bytesToNumberBE(result);
+}
+/**
+ * Represents a 64-byte G2 element in a cryptographic context.
+ * This class provides methods for serialization and deserialization of G2 bytes.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category Serialization
+ */
+class G2Bytes extends Serializable {
+    /**
+     * The constant b value used in G2 point calculations
+     */
+    static B = bn254.fields.Fp2.fromBigTuple([
+        19485874751759354771024239261021720505790618469301721065564631296452457478373n,
+        266929791119991161246907387137283842545076965332900288569378510910307636690n,
+    ]);
+    data;
+    constructor(data) {
+        super();
+        this.data = Hex.fromHexInput(data).toUint8Array();
+        if (this.data.length !== 64) {
+            throw new Error("Input needs to be 64 bytes");
+        }
+    }
+    serialize(serializer) {
+        serializer.serializeFixedBytes(this.data);
+    }
+    static deserialize(deserializer) {
+        const bytes = deserializer.deserializeFixedBytes(64);
+        return new G2Bytes(bytes);
+    }
+    // Convert the projective coordinates to strings
+    toArray() {
+        const point = this.toProjectivePoint();
+        return [
+            [
+                point.x.c0.toString(), // x real part
+                point.x.c1.toString(),
+            ], // x imaginary part
+            [
+                point.y.c0.toString(), // y real part
+                point.y.c1.toString(),
+            ], // y imaginary part
+            [
+                point.Z.c0.toString(), // z real part
+                point.Z.c1.toString(),
+            ], // z imaginary part
+        ];
+    }
+    toProjectivePoint() {
+        const bytes = new Uint8Array(this.data);
+        // Reverse the bytes to convert from little-endian to big-endian for each part of x.
+        const x0 = bytes.slice(0, 32).reverse();
+        const x1 = bytes.slice(32, 64).reverse();
+        // This gets the flag bit to determine which y to use.
+        const yFlag = (x1[0] & 0x80) >> 7;
+        const { Fp2 } = bn254.fields;
+        const x = Fp2.fromBigTuple([bytesToBn254FpBE(x0), bytesToBn254FpBE(x1)]);
+        const y = Fp2.sqrt(Fp2.add(Fp2.pow(x, 3n), G2Bytes.B));
+        const negY = Fp2.neg(y);
+        const isYGreaterThanNegY = y.c1 > negY.c1 || (y.c1 === negY.c1 && y.c0 > negY.c0);
+        const yToUse = isYGreaterThanNegY === (yFlag === 1) ? y : negY;
+        return bn254.G2.Point.fromAffine({
+            x,
+            y: yToUse,
+        });
+    }
+}
+/**
+ * Represents a Groth16 zero-knowledge proof, consisting of three proof points in compressed serialization format.
+ * The points are the compressed serialization of affine representation of the proof.
+ *
+ * @extends Proof
+ * @group Implementation
+ * @category Serialization
+ */
+export class Groth16Zkp extends Proof {
+    /**
+     * The bytes of G1 proof point a
+     * @group Implementation
+     * @category Serialization
+     */
+    a;
+    /**
+     * The bytes of G2 proof point b
+     * @group Implementation
+     * @category Serialization
+     */
+    b;
+    /**
+     * The bytes of G1 proof point c
+     * @group Implementation
+     * @category Serialization
+     */
+    c;
+    constructor(args) {
+        super();
+        const { a, b, c } = args;
+        this.a = new G1Bytes(a);
+        this.b = new G2Bytes(b);
+        this.c = new G1Bytes(c);
+    }
+    serialize(serializer) {
+        this.a.serialize(serializer);
+        this.b.serialize(serializer);
+        this.c.serialize(serializer);
+    }
+    static deserialize(deserializer) {
+        const a = G1Bytes.deserialize(deserializer).bcsToBytes();
+        const b = G2Bytes.deserialize(deserializer).bcsToBytes();
+        const c = G1Bytes.deserialize(deserializer).bcsToBytes();
+        return new Groth16Zkp({ a, b, c });
+    }
+    toSnarkJsJson() {
+        return {
+            protocol: "groth16",
+            curve: "bn128",
+            pi_a: this.a.toArray(),
+            pi_b: this.b.toArray(),
+            pi_c: this.c.toArray(),
+        };
+    }
+}
+/**
+ * Represents a Groth16 proof and statement, consisting of a Groth16 proof and a public inputs hash.
+ * This is used to generate the signing message for the training wheels signature.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category Serialization
+ */
+export class Groth16ProofAndStatement extends Serializable {
+    /**
+     * The Groth16 proof
+     * @group Implementation
+     * @category Serialization
+     */
+    proof;
+    /**
+     * The public inputs hash as a 32 byte Uint8Array
+     * @group Implementation
+     * @category Serialization
+     */
+    publicInputsHash;
+    /**
+     * The domain separator prefix used when hashing.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    domainSeparator = "APTOS::Groth16ProofAndStatement";
+    constructor(proof, publicInputsHash) {
+        super();
+        this.proof = proof;
+        this.publicInputsHash =
+            typeof publicInputsHash === "bigint"
+                ? bigIntToBytesLE(publicInputsHash, 32)
+                : Hex.fromHexInput(publicInputsHash).toUint8Array();
+        if (this.publicInputsHash.length !== 32) {
+            throw new Error("Invalid public inputs hash");
+        }
+    }
+    serialize(serializer) {
+        this.proof.serialize(serializer);
+        serializer.serializeFixedBytes(this.publicInputsHash);
+    }
+    static deserialize(deserializer) {
+        return new Groth16ProofAndStatement(Groth16Zkp.deserialize(deserializer), deserializer.deserializeFixedBytes(32));
+    }
+    hash() {
+        return generateSigningMessage(this.bcsToBytes(), this.domainSeparator);
+    }
+}
+/**
+ * Represents a container for different types of zero-knowledge proofs.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category Serialization
+ */
+export class ZkProof extends Serializable {
+    proof;
+    /**
+     * Index of the underlying enum variant
+     * @group Implementation
+     * @category Serialization
+     */
+    variant;
+    constructor(proof, variant) {
+        super();
+        this.proof = proof;
+        this.variant = variant;
+    }
+    serialize(serializer) {
+        serializer.serializeU32AsUleb128(this.variant);
+        this.proof.serialize(serializer);
+    }
+    static deserialize(deserializer) {
+        const variant = deserializer.deserializeUleb128AsU32();
+        switch (variant) {
+            case ZkpVariant.Groth16:
+                return new ZkProof(Groth16Zkp.deserialize(deserializer), variant);
+            default:
+                throw new Error(`Unknown variant index for ZkProof: ${variant}`);
+        }
+    }
+}
+/**
+ * Represents a zero-knowledge signature, encapsulating the proof and its associated metadata.
+ *
+ * @extends Signature
+ * @group Implementation
+ * @category Serialization
+ */
+export class ZeroKnowledgeSig extends Signature {
+    /**
+     * The proof
+     * @group Implementation
+     * @category Serialization
+     */
+    proof;
+    /**
+     * The max lifespan of the proof
+     * @group Implementation
+     * @category Serialization
+     */
+    expHorizonSecs;
+    /**
+     * A key value pair on the JWT token that can be specified on the signature which would reveal the value on chain.
+     * Can be used to assert identity or other attributes.
+     * @group Implementation
+     * @category Serialization
+     */
+    extraField;
+    /**
+     * The 'aud' value of the recovery service which is set when recovering an account.
+     * @group Implementation
+     * @category Serialization
+     */
+    overrideAudVal;
+    /**
+     * The training wheels signature
+     * @group Implementation
+     * @category Serialization
+     */
+    trainingWheelsSignature;
+    constructor(args) {
+        super();
+        const { proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal } = args;
+        this.proof = proof;
+        this.expHorizonSecs = expHorizonSecs;
+        this.trainingWheelsSignature = trainingWheelsSignature;
+        this.extraField = extraField;
+        this.overrideAudVal = overrideAudVal;
+    }
+    /**
+     * Deserialize a ZeroKnowledgeSig object from its BCS serialization in bytes.
+     *
+     * @param bytes - The bytes representing the serialized ZeroKnowledgeSig.
+     * @returns ZeroKnowledgeSig - The deserialized ZeroKnowledgeSig object.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromBytes(bytes) {
+        return ZeroKnowledgeSig.deserialize(new Deserializer(bytes));
+    }
+    serialize(serializer) {
+        this.proof.serialize(serializer);
+        serializer.serializeU64(this.expHorizonSecs);
+        serializer.serializeOption(this.extraField);
+        serializer.serializeOption(this.overrideAudVal);
+        serializer.serializeOption(this.trainingWheelsSignature);
+    }
+    static deserialize(deserializer) {
+        const proof = ZkProof.deserialize(deserializer);
+        const expHorizonSecs = Number(deserializer.deserializeU64());
+        const extraField = deserializer.deserializeOption("string");
+        const overrideAudVal = deserializer.deserializeOption("string");
+        const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);
+        return new ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
+    }
+}
+/**
+ * Represents the on-chain configuration for how Keyless accounts operate.
+ *
+ * @remarks
+ * This class encapsulates the verification key and the maximum lifespan of ephemeral key pairs,
+ * which are essential for the functionality of Keyless accounts.
+ * @group Implementation
+ * @category Serialization
+ */
+export class KeylessConfiguration {
+    /**
+     * The verification key used to verify Groth16 proofs on chain
+     * @group Implementation
+     * @category Serialization
+     */
+    verificationKey;
+    /**
+     * The maximum lifespan of an ephemeral key pair.  This is configured on chain.
+     * @group Implementation
+     * @category Serialization
+     */
+    maxExpHorizonSecs;
+    /**
+     * The public key of the training wheels account.
+     * @group Implementation
+     * @category Serialization
+     */
+    trainingWheelsPubkey;
+    /**
+     * The maximum number of bytes that can be used for the extra field.
+     * @group Implementation
+     * @category Serialization
+     */
+    maxExtraFieldBytes;
+    /**
+     * The maximum number of bytes that can be used for the JWT header.
+     * @group Implementation
+     * @category Serialization
+     */
+    maxJwtHeaderB64Bytes;
+    /**
+     * The maximum number of bytes that can be used for the issuer value.
+     * @group Implementation
+     * @category Serialization
+     */
+    maxIssValBytes;
+    /**
+     * The maximum number of bytes that can be used for the committed ephemeral public key.
+     * @group Implementation
+     * @category Serialization
+     */
+    maxCommitedEpkBytes;
+    constructor(args) {
+        const { verificationKey, trainingWheelsPubkey, maxExpHorizonSecs = EPK_HORIZON_SECS, maxExtraFieldBytes = MAX_EXTRA_FIELD_BYTES, maxJwtHeaderB64Bytes = MAX_JWT_HEADER_B64_BYTES, maxIssValBytes = MAX_ISS_VAL_BYTES, maxCommitedEpkBytes = MAX_COMMITED_EPK_BYTES, } = args;
+        this.verificationKey = verificationKey;
+        this.maxExpHorizonSecs = maxExpHorizonSecs;
+        if (trainingWheelsPubkey) {
+            this.trainingWheelsPubkey = new EphemeralPublicKey(new Ed25519PublicKey(trainingWheelsPubkey));
+        }
+        this.maxExtraFieldBytes = maxExtraFieldBytes;
+        this.maxJwtHeaderB64Bytes = maxJwtHeaderB64Bytes;
+        this.maxIssValBytes = maxIssValBytes;
+        this.maxCommitedEpkBytes = maxCommitedEpkBytes;
+    }
+    /**
+     * Creates a new KeylessConfiguration instance from a Groth16VerificationKeyResponse and a KeylessConfigurationResponse.
+     * @param res - The Groth16VerificationKeyResponse object containing the verification key data.
+     * @param config - The KeylessConfigurationResponse object containing the configuration data.
+     * @returns A new KeylessConfiguration instance.
+     */
+    static create(res, config) {
+        return new KeylessConfiguration({
+            verificationKey: new Groth16VerificationKey({
+                alphaG1: res.alpha_g1,
+                betaG2: res.beta_g2,
+                deltaG2: res.delta_g2,
+                gammaAbcG1: res.gamma_abc_g1,
+                gammaG2: res.gamma_g2,
+            }),
+            maxExpHorizonSecs: Number(config.max_exp_horizon_secs),
+            trainingWheelsPubkey: config.training_wheels_pubkey.vec[0],
+            maxExtraFieldBytes: config.max_extra_field_bytes,
+            maxJwtHeaderB64Bytes: config.max_jwt_header_b64_bytes,
+            maxIssValBytes: config.max_iss_val_bytes,
+            maxCommitedEpkBytes: config.max_commited_epk_bytes,
+        });
+    }
+}
+/**
+ * Represents the verification key stored on-chain used to verify Groth16 proofs.
+ * @group Implementation
+ * @category Serialization
+ */
+export class Groth16VerificationKey {
+    // The docstrings below are borrowed from ark-groth16
+    /**
+     * The `alpha * G`, where `G` is the generator of G1
+     * @group Implementation
+     * @category Serialization
+     */
+    alphaG1;
+    /**
+     * The `alpha * H`, where `H` is the generator of G2
+     * @group Implementation
+     * @category Serialization
+     */
+    betaG2;
+    /**
+     * The `delta * H`, where `H` is the generator of G2
+     * @group Implementation
+     * @category Serialization
+     */
+    deltaG2;
+    /**
+     * The `gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H`, where H is the generator of G1
+     * @group Implementation
+     * @category Serialization
+     */
+    gammaAbcG1;
+    /**
+     * The `gamma * H`, where `H` is the generator of G2
+     * @group Implementation
+     * @category Serialization
+     */
+    gammaG2;
+    constructor(args) {
+        const { alphaG1, betaG2, deltaG2, gammaAbcG1, gammaG2 } = args;
+        this.alphaG1 = new G1Bytes(alphaG1);
+        this.betaG2 = new G2Bytes(betaG2);
+        this.deltaG2 = new G2Bytes(deltaG2);
+        this.gammaAbcG1 = [new G1Bytes(gammaAbcG1[0]), new G1Bytes(gammaAbcG1[1])];
+        this.gammaG2 = new G2Bytes(gammaG2);
+    }
+    /**
+     * Calculates the hash of the serialized form of the verification key.
+     * This is useful for comparing verification keys or using them as unique identifiers.
+     *
+     * @returns The SHA3-256 hash of the serialized verification key as a Uint8Array
+     */
+    hash() {
+        const serializer = new Serializer();
+        this.serialize(serializer);
+        return sha3_256.create().update(serializer.toUint8Array()).digest();
+    }
+    serialize(serializer) {
+        this.alphaG1.serialize(serializer);
+        this.betaG2.serialize(serializer);
+        this.deltaG2.serialize(serializer);
+        this.gammaAbcG1[0].serialize(serializer);
+        this.gammaAbcG1[1].serialize(serializer);
+        this.gammaG2.serialize(serializer);
+    }
+    /**
+     * Converts a Groth16VerificationKeyResponse object into a Groth16VerificationKey instance.
+     *
+     * @param res - The Groth16VerificationKeyResponse object containing the verification key data.
+     * @param res.alpha_g1 - The alpha G1 value from the response.
+     * @param res.beta_g2 - The beta G2 value from the response.
+     * @param res.delta_g2 - The delta G2 value from the response.
+     * @param res.gamma_abc_g1 - The gamma ABC G1 value from the response.
+     * @param res.gamma_g2 - The gamma G2 value from the response.
+     * @returns A Groth16VerificationKey instance constructed from the provided response data.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromGroth16VerificationKeyResponse(res) {
+        return new Groth16VerificationKey({
+            alphaG1: res.alpha_g1,
+            betaG2: res.beta_g2,
+            deltaG2: res.delta_g2,
+            gammaAbcG1: res.gamma_abc_g1,
+            gammaG2: res.gamma_g2,
+        });
+    }
+    /**
+     * Verifies a Groth16 proof using the verification key given the public inputs hash and the proof.
+     *
+     * @param args.publicInputsHash The public inputs hash
+     * @param args.groth16Proof The Groth16 proof
+     * @returns true if the proof is valid
+     */
+    verifyProof(args) {
+        const { publicInputsHash, groth16Proof } = args;
+        try {
+            // Get proof points
+            const proofA = groth16Proof.a.toProjectivePoint();
+            const proofB = groth16Proof.b.toProjectivePoint();
+            const proofC = groth16Proof.c.toProjectivePoint();
+            // Get verification key points
+            const vkAlpha1 = this.alphaG1.toProjectivePoint();
+            const vkBeta2 = this.betaG2.toProjectivePoint();
+            const vkGamma2 = this.gammaG2.toProjectivePoint();
+            const vkDelta2 = this.deltaG2.toProjectivePoint();
+            const vkIC = this.gammaAbcG1.map((g1) => g1.toProjectivePoint());
+            const { Fp12 } = bn254.fields;
+            // Check that the following pairing equation holds:
+            // e(A_1, B_2) = e(\alpha_1, \beta_2) + e(\ic_0 + public_inputs_hash \ic_1, \gamma_2) + e(C_1, \delta_2)
+            // Where A_1, B_2, C_1 are the proof points and \alpha_1, \beta_2, \gamma_2, \delta_2, \ic_0, \ic_1
+            // are the verification key points
+            // \ic_0 + public_inputs_hash \ic_1
+            const accum = vkIC[0].add(vkIC[1].multiply(publicInputsHash));
+            // e(\ic_0 + public_inputs_hash \ic_1, \gamma_2)
+            const pairingAccumGamma = bn254.pairing(accum, vkGamma2);
+            // e(A_1, B_2)
+            const pairingAB = bn254.pairing(proofA, proofB);
+            // e(\alpha_1, \beta_2)
+            const pairingAlphaBeta = bn254.pairing(vkAlpha1, vkBeta2);
+            // e(C_1, \delta_2)
+            const pairingCDelta = bn254.pairing(proofC, vkDelta2);
+            // Get the result of the right hand side of the pairing equation
+            const product = Fp12.mul(pairingAlphaBeta, Fp12.mul(pairingAccumGamma, pairingCDelta));
+            // Check if the left hand side equals the right hand side
+            return Fp12.eql(pairingAB, product);
+        }
+        catch (error) {
+            throw KeylessError.fromErrorType({
+                type: KeylessErrorType.PROOF_VERIFICATION_FAILED,
+                error,
+                details: "Error encountered when checking zero knowledge relation",
+            });
+        }
+    }
+    /**
+     * Converts the verification key to a JSON format compatible with snarkjs groth16.verify
+     *
+     * @returns An object containing the verification key in snarkjs format
+     * @group Implementation
+     * @category Serialization
+     */
+    toSnarkJsJson() {
+        return {
+            protocol: "groth16",
+            curve: "bn128",
+            nPublic: 1,
+            vk_alpha_1: this.alphaG1.toArray(),
+            vk_beta_2: this.betaG2.toArray(),
+            vk_gamma_2: this.gammaG2.toArray(),
+            vk_delta_2: this.deltaG2.toArray(),
+            IC: this.gammaAbcG1.map((g1) => g1.toArray()),
+        };
+    }
+}
+/**
+ * Retrieves the configuration parameters for Keyless Accounts on the blockchain, including the verifying key and the maximum
+ * expiry horizon.
+ *
+ * @param args - The arguments for retrieving the keyless configuration.
+ * @param args.aptosConfig - The Aptos configuration object containing network details.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.ledgerVersion - The ledger version to query; if not provided, the latest version will be used.
+ * @returns KeylessConfiguration - The configuration object containing the verifying key and maximum expiry horizon.
+ * @group Implementation
+ * @category Serialization
+ */
+export async function getKeylessConfig(args) {
+    const { aptosConfig } = args;
+    try {
+        return await memoizeAsync(async () => {
+            const [config, vk] = await Promise.all([
+                getKeylessConfigurationResource(args),
+                getGroth16VerificationKeyResource(args),
+            ]);
+            return KeylessConfiguration.create(vk, config);
+        }, `keyless-configuration-${aptosConfig.network}`, 1000 * 60 * 5)();
+    }
+    catch (error) {
+        if (error instanceof KeylessError) {
+            throw error;
+        }
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.FULL_NODE_OTHER,
+            error,
+        });
+    }
+}
+/**
+ * Parses a JWT and returns the 'iss', 'aud', and 'uid' values.
+ *
+ * @param args - The arguments for parsing the JWT.
+ * @param args.jwt - The JWT to parse.
+ * @param args.uidKey - The key to use for the 'uid' value; defaults to 'sub'.
+ * @returns The 'iss', 'aud', and 'uid' values from the JWT.
+ */
+export function getIssAudAndUidVal(args) {
+    const { jwt, uidKey = "sub" } = args;
+    let jwtPayload;
+    try {
+        jwtPayload = jwtDecode(jwt);
+    }
+    catch {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.JWT_PARSING_ERROR,
+            // Sanitized error message - don't expose parsing details
+            details: "Invalid JWT format",
+        });
+    }
+    if (typeof jwtPayload.iss !== "string") {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.JWT_PARSING_ERROR,
+            // Sanitized error message - don't expose internal structure
+            details: "Invalid JWT: missing required claim",
+        });
+    }
+    if (typeof jwtPayload.aud !== "string") {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.JWT_PARSING_ERROR,
+            // Sanitized error message - don't expose internal structure
+            details: "Invalid JWT: missing or malformed required claim",
+        });
+    }
+    const uidVal = jwtPayload[uidKey];
+    return { iss: jwtPayload.iss, aud: jwtPayload.aud, uidVal };
+}
+/**
+ * Retrieves the KeylessConfiguration set on chain.
+ *
+ * @param args - The arguments for retrieving the configuration.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos network.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+ * @returns KeylessConfigurationResponse - The response containing the keyless configuration data.
+ * @group Implementation
+ * @category Serialization
+ */
+async function getKeylessConfigurationResource(args) {
+    const { aptosConfig, options } = args;
+    const resourceType = "0x1::keyless_account::Configuration";
+    try {
+        const { data } = await getAptosFullNode({
+            aptosConfig,
+            originMethod: "getKeylessConfigurationResource",
+            path: `accounts/${AccountAddress.from("0x1").toString()}/resource/${resourceType}`,
+            params: { ledger_version: options?.ledgerVersion },
+        });
+        return data.data;
+    }
+    catch (error) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.FULL_NODE_CONFIG_LOOKUP_ERROR,
+            error,
+        });
+    }
+}
+/**
+ * Retrieves the Groth16VerificationKey set on the blockchain.
+ *
+ * @param args - The arguments for retrieving the verification key.
+ * @param args.aptosConfig - The Aptos configuration object.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+ * @returns Groth16VerificationKeyResponse - The response containing the Groth16 verification key data.
+ * @group Implementation
+ * @category Serialization
+ */
+async function getGroth16VerificationKeyResource(args) {
+    const { aptosConfig, options } = args;
+    const resourceType = "0x1::keyless_account::Groth16VerificationKey";
+    try {
+        const { data } = await getAptosFullNode({
+            aptosConfig,
+            originMethod: "getGroth16VerificationKeyResource",
+            path: `accounts/${AccountAddress.from("0x1").toString()}/resource/${resourceType}`,
+            params: { ledger_version: options?.ledgerVersion },
+        });
+        return data.data;
+    }
+    catch (error) {
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.FULL_NODE_VERIFICATION_KEY_LOOKUP_ERROR,
+            error,
+        });
+    }
+}
+/**
+ * Fetches JWKs from the blockchain with optional caching.
+ *
+ * @param args.aptosConfig - The Aptos configuration object.
+ * @param args.jwkAddr - Optional. The address to fetch JWKs from (for federated keyless).
+ * @param args.options - Optional. Ledger version options.
+ * @param args.useCache - Optional. Whether to use cached JWKs. Defaults to true.
+ * @returns A map of issuer to JWK arrays.
+ */
+export async function getKeylessJWKs(args) {
+    const { aptosConfig, jwkAddr, options, useCache = true } = args;
+    // Generate a cache key based on network and address
+    const addrString = jwkAddr ? AccountAddress.from(jwkAddr).toString() : "0x1";
+    const cacheKey = `keyless-jwks-${aptosConfig.network}-${addrString}`;
+    // If caching is enabled and we have a ledger version, don't use cache
+    // (specific ledger versions should always fetch fresh data)
+    if (useCache && !options?.ledgerVersion) {
+        return memoizeAsync(async () => fetchKeylessJWKsInternal({ aptosConfig, jwkAddr, options }), cacheKey, 1000 * 60 * 5)();
+    }
+    return fetchKeylessJWKsInternal({ aptosConfig, jwkAddr, options });
+}
+/**
+ * Internal function to fetch JWKs from the blockchain.
+ */
+async function fetchKeylessJWKsInternal(args) {
+    const { aptosConfig, jwkAddr, options } = args;
+    let resource;
+    if (!jwkAddr) {
+        const resourceType = "0x1::jwks::PatchedJWKs";
+        const { data } = await getAptosFullNode({
+            aptosConfig,
+            originMethod: "getKeylessJWKs",
+            path: `accounts/0x1/resource/${resourceType}`,
+            params: { ledger_version: options?.ledgerVersion },
+        });
+        resource = data;
+    }
+    else {
+        const resourceType = "0x1::jwks::FederatedJWKs";
+        const { data } = await getAptosFullNode({
+            aptosConfig,
+            originMethod: "getKeylessJWKs",
+            path: `accounts/${AccountAddress.from(jwkAddr).toString()}/resource/${resourceType}`,
+            params: { ledger_version: options?.ledgerVersion },
+        });
+        resource = data;
+    }
+    // Create a map of issuer to JWK arrays
+    const jwkMap = new Map();
+    for (const entry of resource.data.jwks.entries) {
+        const jwks = [];
+        for (const jwkStruct of entry.jwks) {
+            const { data: jwkData } = jwkStruct.variant;
+            const deserializer = new Deserializer(Hex.fromHexInput(jwkData).toUint8Array());
+            const jwk = MoveJWK.deserialize(deserializer);
+            jwks.push(jwk);
+        }
+        jwkMap.set(hexToAsciiString(entry.issuer), jwks);
+    }
+    return jwkMap;
+}
+export class MoveJWK extends Serializable {
+    kid;
+    kty;
+    alg;
+    e;
+    n;
+    constructor(args) {
+        super();
+        const { kid, kty, alg, e, n } = args;
+        this.kid = kid;
+        this.kty = kty;
+        this.alg = alg;
+        this.e = e;
+        this.n = n;
+    }
+    serialize(serializer) {
+        serializer.serializeStr(this.kid);
+        serializer.serializeStr(this.kty);
+        serializer.serializeStr(this.alg);
+        serializer.serializeStr(this.e);
+        serializer.serializeStr(this.n);
+    }
+    static fromMoveStruct(struct) {
+        const { data } = struct.variant;
+        const deserializer = new Deserializer(Hex.fromHexInput(data).toUint8Array());
+        return MoveJWK.deserialize(deserializer);
+    }
+    toScalar() {
+        if (this.alg !== "RS256") {
+            throw KeylessError.fromErrorType({
+                type: KeylessErrorType.PROOF_VERIFICATION_FAILED,
+                details: "Failed to convert JWK to scalar when calculating the public inputs hash. Only RSA 256 is supported currently",
+            });
+        }
+        const uint8Array = base64UrlToBytes(this.n);
+        const chunks = chunkInto24Bytes(uint8Array.reverse());
+        const scalars = chunks.map((chunk) => bytesToBigIntLE(chunk));
+        scalars.push(256n); // Add the modulus size
+        return poseidonHash(scalars);
+    }
+    static deserialize(deserializer) {
+        const kid = deserializer.deserializeStr();
+        const kty = deserializer.deserializeStr();
+        const alg = deserializer.deserializeStr();
+        const e = deserializer.deserializeStr();
+        const n = deserializer.deserializeStr();
+        return new MoveJWK({ kid, kty, alg, n, e });
+    }
+}
+function chunkInto24Bytes(data) {
+    const chunks = [];
+    for (let i = 0; i < data.length; i += 24) {
+        const chunk = data.slice(i, Math.min(i + 24, data.length));
+        // Pad last chunk with zeros if needed
+        if (chunk.length < 24) {
+            const paddedChunk = new Uint8Array(24);
+            paddedChunk.set(chunk);
+            chunks.push(paddedChunk);
+        }
+        else {
+            chunks.push(chunk);
+        }
+    }
+    return chunks;
+}
+/**
+ * Safely parses the JWT header.
+ * @param jwtHeader The JWT header string
+ * @returns Parsed JWT header as an object.
+ * @throws KeylessError if the header is invalid or missing required fields
+ */
+export function parseJwtHeader(jwtHeader) {
+    try {
+        const header = JSON.parse(jwtHeader);
+        if (header.kid === undefined) {
+            throw KeylessError.fromErrorType({
+                type: KeylessErrorType.JWT_PARSING_ERROR,
+                // Sanitized error message - don't expose internal structure
+                details: "Invalid JWT header: missing required field",
+            });
+        }
+        return header;
+    }
+    catch (error) {
+        if (error instanceof KeylessError) {
+            throw error;
+        }
+        throw KeylessError.fromErrorType({
+            type: KeylessErrorType.JWT_PARSING_ERROR,
+            // Sanitized error message - don't expose parsing details
+            details: "Invalid JWT header format",
+        });
+    }
+}
+//# sourceMappingURL=keyless.js.map