@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/dist/esm/chunk-T573PCIR.mjs

@@ -1,700 +0,0 @@
-import {
-  bigIntToBytesLE,
-  bytesToBigIntLE,
-  hashStrToField,
-  poseidonHash
-} from "./chunk-APM7OSLS.mjs";
-import {
-  Proof
-} from "./chunk-3IWV2Q3K.mjs";
-import {
-  EphemeralPublicKey,
-  EphemeralSignature
-} from "./chunk-UOHCJOXI.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-TFW6N66T.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  Signature
-} from "./chunk-KLUO6XPE.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-PKUXOBIV.mjs";
-import {
-  memoizeAsync
-} from "./chunk-BEYIOC2H.mjs";
-import {
-  getAptosFullNode
-} from "./chunk-XQFUKBY7.mjs";
-import {
-  KeylessError
-} from "./chunk-32UQAST6.mjs";
-import {
-  getErrorMessage
-} from "./chunk-RQS33JAS.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-import {
-  Serializable,
-  Serializer
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex,
-  hexToAsciiString
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/crypto/keyless.ts
-import { jwtDecode } from "jwt-decode";
-import { sha3_256 } from "@noble/hashes/sha3";
-var EPK_HORIZON_SECS = 1e7;
-var MAX_AUD_VAL_BYTES = 120;
-var MAX_UID_KEY_BYTES = 30;
-var MAX_UID_VAL_BYTES = 330;
-var MAX_ISS_VAL_BYTES = 120;
-var MAX_EXTRA_FIELD_BYTES = 350;
-var MAX_JWT_HEADER_B64_BYTES = 300;
-var MAX_COMMITED_EPK_BYTES = 93;
-var _KeylessPublicKey = class _KeylessPublicKey extends AccountPublicKey {
-  /**
-   * 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(3 /* Keyless */);
-    serializer.serializeFixedBytes(this.bcsToBytes());
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 2 /* 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.
-   * @returns true if the signature is valid; otherwise, false.
-   * @group Implementation
-   * @category Serialization
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args) {
-    throw new Error("Not yet implemented");
-  }
-  /**
-   * 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;
-  }
-};
-/**
- * The number of bytes that `idCommitment` should be
- * @group Implementation
- * @category Serialization
- */
-_KeylessPublicKey.ID_COMMITMENT_LENGTH = 32;
-var KeylessPublicKey = _KeylessPublicKey;
-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);
-}
-var KeylessSignature = class _KeylessSignature extends Signature {
-  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) }),
-            0 /* Groth16 */
-          ),
-          expHorizonSecs: 0
-        }),
-        0 /* 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;
-  }
-};
-var EphemeralCertificate = class _EphemeralCertificate extends Signature {
-  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 0 /* ZkProof */:
-        return new _EphemeralCertificate(ZeroKnowledgeSig.deserialize(deserializer), variant);
-      default:
-        throw new Error(`Unknown variant index for EphemeralCertificate: ${variant}`);
-    }
-  }
-};
-var G1Bytes = class _G1Bytes extends Serializable {
-  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);
-  }
-};
-var G2Bytes = class _G2Bytes extends Serializable {
-  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);
-  }
-};
-var Groth16Zkp = class _Groth16Zkp extends Proof {
-  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 });
-  }
-};
-var ZkProof = class _ZkProof extends Serializable {
-  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 0 /* Groth16 */:
-        return new _ZkProof(Groth16Zkp.deserialize(deserializer), variant);
-      default:
-        throw new Error(`Unknown variant index for ZkProof: ${variant}`);
-    }
-  }
-};
-var ZeroKnowledgeSig = class _ZeroKnowledgeSig extends Signature {
-  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 });
-  }
-};
-var KeylessConfiguration = class _KeylessConfiguration {
-  constructor(verificationKey, maxExpHorizonSecs) {
-    this.verificationKey = verificationKey;
-    this.maxExpHorizonSecs = maxExpHorizonSecs;
-  }
-  static create(res, maxExpHorizonSecs) {
-    return new _KeylessConfiguration(
-      new Groth16VerificationKey({
-        alphaG1: res.alpha_g1,
-        betaG2: res.beta_g2,
-        deltaG2: res.delta_g2,
-        gammaAbcG1: res.gamma_abc_g1,
-        gammaG2: res.gamma_g2
-      }),
-      maxExpHorizonSecs
-    );
-  }
-};
-var Groth16VerificationKey = class _Groth16VerificationKey {
-  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
-    });
-  }
-};
-async function getKeylessConfig(args) {
-  const { aptosConfig } = args;
-  try {
-    return await memoizeAsync(
-      async () => {
-        const config = await getKeylessConfigurationResource(args);
-        const vk = await getGroth16VerificationKeyResource(args);
-        return KeylessConfiguration.create(vk, Number(config.max_exp_horizon_secs));
-      },
-      `keyless-configuration-${aptosConfig.network}`,
-      1e3 * 60 * 5
-      // 5 minutes
-    )();
-  } catch (error) {
-    if (error instanceof KeylessError) {
-      throw error;
-    }
-    throw KeylessError.fromErrorType({
-      type: 25 /* FULL_NODE_OTHER */,
-      error
-    });
-  }
-}
-function getIssAudAndUidVal(args) {
-  const { jwt, uidKey = "sub" } = args;
-  let jwtPayload;
-  try {
-    jwtPayload = jwtDecode(jwt);
-  } catch (error) {
-    throw KeylessError.fromErrorType({
-      type: 12 /* JWT_PARSING_ERROR */,
-      details: `Failed to parse JWT - ${getErrorMessage(error)}`
-    });
-  }
-  if (typeof jwtPayload.iss !== "string") {
-    throw KeylessError.fromErrorType({
-      type: 12 /* JWT_PARSING_ERROR */,
-      details: "JWT is missing 'iss' in the payload. This should never happen."
-    });
-  }
-  if (typeof jwtPayload.aud !== "string") {
-    throw KeylessError.fromErrorType({
-      type: 12 /* JWT_PARSING_ERROR */,
-      details: "JWT is missing 'aud' in the payload or 'aud' is an array of values."
-    });
-  }
-  const uidVal = jwtPayload[uidKey];
-  return { iss: jwtPayload.iss, aud: jwtPayload.aud, uidVal };
-}
-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: 22 /* FULL_NODE_CONFIG_LOOKUP_ERROR */,
-      error
-    });
-  }
-}
-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: 23 /* FULL_NODE_VERIFICATION_KEY_LOOKUP_ERROR */,
-      error
-    });
-  }
-}
-async function getKeylessJWKs(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;
-  }
-  const jwkMap = /* @__PURE__ */ 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;
-}
-var MoveJWK = class _MoveJWK extends Serializable {
-  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);
-  }
-  static deserialize(deserializer) {
-    const kid = deserializer.deserializeStr();
-    const kty = deserializer.deserializeStr();
-    const alg = deserializer.deserializeStr();
-    const n = deserializer.deserializeStr();
-    const e = deserializer.deserializeStr();
-    return new _MoveJWK({ kid, kty, alg, n, e });
-  }
-};
-function parseJwtHeader(jwtHeader) {
-  try {
-    const header = JSON.parse(jwtHeader);
-    if (header.kid === void 0) {
-      throw new Error("JWT header missing kid");
-    }
-    return header;
-  } catch (error) {
-    throw new Error("Failed to parse JWT header.");
-  }
-}
-
-export {
-  EPK_HORIZON_SECS,
-  MAX_AUD_VAL_BYTES,
-  MAX_UID_KEY_BYTES,
-  MAX_UID_VAL_BYTES,
-  MAX_ISS_VAL_BYTES,
-  MAX_EXTRA_FIELD_BYTES,
-  MAX_JWT_HEADER_B64_BYTES,
-  MAX_COMMITED_EPK_BYTES,
-  KeylessPublicKey,
-  KeylessSignature,
-  EphemeralCertificate,
-  Groth16Zkp,
-  ZkProof,
-  ZeroKnowledgeSig,
-  KeylessConfiguration,
-  Groth16VerificationKey,
-  getKeylessConfig,
-  getIssAudAndUidVal,
-  getKeylessJWKs,
-  MoveJWK,
-  parseJwtHeader
-};
-//# sourceMappingURL=chunk-T573PCIR.mjs.map