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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/keyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n// eslint-disable-next-line max-classes-per-file\nimport { JwtPayload, jwtDecode } from \"jwt-decode\";\nimport { sha3_256 } from \"@noble/hashes/sha3\";\nimport { AccountPublicKey, PublicKey } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { Deserializer, Serializable, Serializer } from \"../../bcs\";\nimport { Hex, hexToAsciiString } from \"../hex\";\nimport {\n  HexInput,\n  EphemeralCertificateVariant,\n  AnyPublicKeyVariant,\n  SigningScheme,\n  ZkpVariant,\n  LedgerVersionArg,\n  MoveResource,\n} from \"../../types\";\nimport { EphemeralPublicKey, EphemeralSignature } from \"./ephemeral\";\nimport { bigIntToBytesLE, bytesToBigIntLE, hashStrToField, poseidonHash } from \"./poseidon\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Proof } from \"./proof\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"./ed25519\";\nimport {\n  Groth16VerificationKeyResponse,\n  KeylessConfigurationResponse,\n  MoveAnyStruct,\n  PatchedJWKsResponse,\n} from \"../../types/keyless\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport { getAptosFullNode } from \"../../client\";\nimport { memoizeAsync } from \"../../utils/memoize\";\nimport { AccountAddress, AccountAddressInput } from \"../accountAddress\";\nimport { getErrorMessage } from \"../../utils\";\nimport { KeylessError, KeylessErrorType } from \"../../errors\";\n\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const EPK_HORIZON_SECS = 10000000;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_AUD_VAL_BYTES = 120;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_UID_KEY_BYTES = 30;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_UID_VAL_BYTES = 330;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_ISS_VAL_BYTES = 120;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_EXTRA_FIELD_BYTES = 350;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_JWT_HEADER_B64_BYTES = 300;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_COMMITED_EPK_BYTES = 93;\n\n/**\n * Represents a Keyless Public Key used for authentication.\n *\n * This class encapsulates the public key functionality for keyless authentication,\n * including methods for generating and verifying signatures, as well as serialization\n * and deserialization of the key. The KeylessPublicKey is represented in the SDK\n * as `AnyPublicKey`.\n * @group Implementation\n * @category Serialization\n */\nexport class KeylessPublicKey extends AccountPublicKey {\n  /**\n   * The number of bytes that `idCommitment` should be\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly ID_COMMITMENT_LENGTH: number = 32;\n\n  /**\n   * The value of the 'iss' claim on the JWT which identifies the OIDC provider.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly iss: string;\n\n  /**\n   * A value representing a cryptographic commitment to a user identity.\n   *\n   * It is calculated from the aud, uidKey, uidVal, pepper.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly idCommitment: Uint8Array;\n\n  /**\n   * Constructs an instance with the specified parameters for cryptographic operations.\n   *\n   * @param args - The parameters required to initialize the instance.\n   * @param args.alphaG1 - The hex representation of the alpha G1 value.\n   * @param args.betaG2 - The hex representation of the beta G2 value.\n   * @param args.deltaG2 - The hex representation of the delta G2 value.\n   * @param args.gammaAbcG1 - An array containing two hex representations for gamma ABC G1 values.\n   * @param args.gammaG2 - The hex representation of the gamma G2 value.\n   * @group Implementation\n   * @category Serialization\n   */\n  // TODO: Fix the JSDoc for the below values\n  constructor(iss: string, idCommitment: HexInput) {\n    super();\n    const idcBytes = Hex.fromHexInput(idCommitment).toUint8Array();\n    if (idcBytes.length !== KeylessPublicKey.ID_COMMITMENT_LENGTH) {\n      throw new Error(`Id Commitment length in bytes should be ${KeylessPublicKey.ID_COMMITMENT_LENGTH}`);\n    }\n    this.iss = iss;\n    this.idCommitment = idcBytes;\n  }\n\n  /**\n   * Get the authentication key for the keyless public key.\n   *\n   * @returns AuthenticationKey - The authentication key derived from the keyless public key.\n   * @group Implementation\n   * @category Serialization\n   */\n  authKey(): AuthenticationKey {\n    const serializer = new Serializer();\n    serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Keyless);\n    serializer.serializeFixedBytes(this.bcsToBytes());\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: SigningScheme.SingleKey,\n      input: serializer.toUint8Array(),\n    });\n  }\n\n  /**\n   * Verifies the validity of a signature for a given message.\n   *\n   * @param args - The arguments for signature verification.\n   * @param args.message - The message that was signed.\n   * @param args.signature - The signature to verify against the message.\n   * @returns true if the signature is valid; otherwise, false.\n   * @group Implementation\n   * @category Serialization\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this\n  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {\n    throw new Error(\"Not yet implemented\");\n  }\n\n  /**\n   * Serializes the current instance into a format suitable for transmission or storage.\n   * This function ensures that all relevant fields are properly serialized, including the proof and optional fields.\n   *\n   * @param serializer - The serializer instance used to perform the serialization.\n   * @param serializer.proof - The proof to be serialized.\n   * @param serializer.expHorizonSecs - The expiration horizon in seconds.\n   * @param serializer.extraField - An optional additional field for serialization.\n   * @param serializer.overrideAudVal - An optional override value for auditing.\n   * @param serializer.trainingWheelsSignature - An optional signature for training wheels.\n   * @group Implementation\n   * @category Serialization\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.iss);\n    serializer.serializeBytes(this.idCommitment);\n  }\n\n  /**\n   * Deserializes a ZeroKnowledgeSig object from the provided deserializer.\n   * This function allows you to reconstruct a ZeroKnowledgeSig instance from its serialized form.\n   *\n   * @param deserializer - The deserializer instance used to read the serialized data.\n   * @returns A new instance of ZeroKnowledgeSig.\n   * @group Implementation\n   * @category Serialization\n   */\n  static deserialize(deserializer: Deserializer): KeylessPublicKey {\n    const iss = deserializer.deserializeStr();\n    const addressSeed = deserializer.deserializeBytes();\n    return new KeylessPublicKey(iss, addressSeed);\n  }\n\n  /**\n   * Loads a KeylessPublicKey instance from the provided deserializer.\n   * This function is used to deserialize the necessary components to create a KeylessPublicKey.\n   *\n   * @param deserializer - The deserializer used to extract the string and byte data.\n   * @param deserializer.deserializeStr - A method to deserialize a string value.\n   * @param deserializer.deserializeBytes - A method to deserialize byte data.\n   * @returns A new instance of KeylessPublicKey.\n   * @group Implementation\n   * @category Serialization\n   */\n  static load(deserializer: Deserializer): KeylessPublicKey {\n    const iss = deserializer.deserializeStr();\n    const addressSeed = deserializer.deserializeBytes();\n    return new KeylessPublicKey(iss, addressSeed);\n  }\n\n  /**\n   * Determines if the provided public key is an instance of KeylessPublicKey.\n   *\n   * @param publicKey - The public key to check.\n   * @returns A boolean indicating whether the public key is a KeylessPublicKey instance.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isPublicKey(publicKey: PublicKey): publicKey is KeylessPublicKey {\n    return publicKey instanceof KeylessPublicKey;\n  }\n\n  /**\n   * Creates a KeylessPublicKey from the JWT components plus pepper\n   *\n   * @param args.iss the iss of the identity\n   * @param args.uidKey the key to use to get the uidVal in the JWT token\n   * @param args.uidVal the value of the uidKey in the JWT token\n   * @param args.aud the client ID of the application\n   * @param args.pepper The pepper used to maintain privacy of the account\n   * @returns KeylessPublicKey\n   * @group Implementation\n   * @category Serialization\n   */\n  static create(args: {\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n  }): KeylessPublicKey {\n    computeIdCommitment(args);\n    return new KeylessPublicKey(args.iss, computeIdCommitment(args));\n  }\n\n  /**\n   * Creates a KeylessPublicKey instance from a JWT and a pepper value.\n   * This function is useful for generating a public key that can be used for authentication based on the provided JWT claims and pepper.\n   *\n   * @param args - The arguments for creating the KeylessPublicKey.\n   * @param args.jwt - The JSON Web Token to decode.\n   * @param args.pepper - The pepper value used in the key creation process.\n   * @param args.uidKey - An optional key to retrieve the unique identifier from the JWT payload, defaults to \"sub\".\n   * @returns A KeylessPublicKey instance created from the provided JWT and pepper.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromJwtAndPepper(args: { jwt: string; pepper: HexInput; uidKey?: string }): KeylessPublicKey {\n    const { jwt, pepper, uidKey = \"sub\" } = args;\n    const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);\n    if (typeof jwtPayload.iss !== \"string\") {\n      throw new Error(\"iss was not found\");\n    }\n    if (typeof jwtPayload.aud !== \"string\") {\n      throw new Error(\"aud was not found or an array of values\");\n    }\n    const uidVal = jwtPayload[uidKey];\n    return KeylessPublicKey.create({ iss: jwtPayload.iss, uidKey, uidVal, aud: jwtPayload.aud, pepper });\n  }\n\n  /**\n   * Checks if the provided public key is a valid instance by verifying its structure and types.\n   *\n   * @param publicKey - The public key to validate.\n   * @returns A boolean indicating whether the public key is a valid instance.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isInstance(publicKey: PublicKey) {\n    return (\n      \"iss\" in publicKey &&\n      typeof publicKey.iss === \"string\" &&\n      \"idCommitment\" in publicKey &&\n      publicKey.idCommitment instanceof Uint8Array\n    );\n  }\n}\n\nfunction computeIdCommitment(args: { uidKey: string; uidVal: string; aud: string; pepper: HexInput }): Uint8Array {\n  const { uidKey, uidVal, aud, pepper } = args;\n\n  const fields = [\n    bytesToBigIntLE(Hex.fromHexInput(pepper).toUint8Array()),\n    hashStrToField(aud, MAX_AUD_VAL_BYTES),\n    hashStrToField(uidVal, MAX_UID_VAL_BYTES),\n    hashStrToField(uidKey, MAX_UID_KEY_BYTES),\n  ];\n\n  return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ID_COMMITMENT_LENGTH);\n}\n\n/**\n * Represents a signature of a message signed via a Keyless Account, utilizing proofs or a JWT token for authentication.\n * @group Implementation\n * @category Serialization\n */\nexport class KeylessSignature extends Signature {\n  /**\n   * The inner signature ZeroKnowledgeSignature or OpenIdSignature\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly ephemeralCertificate: EphemeralCertificate;\n\n  /**\n   * The jwt header in the token used to create the proof/signature.  In json string representation.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly jwtHeader: string;\n\n  /**\n   * The expiry timestamp in seconds of the EphemeralKeyPair used to sign\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly expiryDateSecs: number;\n\n  /**\n   * The ephemeral public key used to verify the signature\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly ephemeralPublicKey: EphemeralPublicKey;\n\n  /**\n   * The signature resulting from signing with the private key of the EphemeralKeyPair\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly ephemeralSignature: EphemeralSignature;\n\n  constructor(args: {\n    jwtHeader: string;\n    ephemeralCertificate: EphemeralCertificate;\n    expiryDateSecs: number;\n    ephemeralPublicKey: EphemeralPublicKey;\n    ephemeralSignature: EphemeralSignature;\n  }) {\n    super();\n    const { jwtHeader, ephemeralCertificate, expiryDateSecs, ephemeralPublicKey, ephemeralSignature } = args;\n    this.jwtHeader = jwtHeader;\n    this.ephemeralCertificate = ephemeralCertificate;\n    this.expiryDateSecs = expiryDateSecs;\n    this.ephemeralPublicKey = ephemeralPublicKey;\n    this.ephemeralSignature = ephemeralSignature;\n  }\n\n  /**\n   * Get the kid of the JWT used to derive the Keyless Account used to sign.\n   *\n   * @returns the kid as a string\n   */\n  getJwkKid(): string {\n    return parseJwtHeader(this.jwtHeader).kid;\n  }\n\n  serialize(serializer: Serializer): void {\n    this.ephemeralCertificate.serialize(serializer);\n    serializer.serializeStr(this.jwtHeader);\n    serializer.serializeU64(this.expiryDateSecs);\n    this.ephemeralPublicKey.serialize(serializer);\n    this.ephemeralSignature.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): KeylessSignature {\n    const ephemeralCertificate = EphemeralCertificate.deserialize(deserializer);\n    const jwtHeader = deserializer.deserializeStr();\n    const expiryDateSecs = deserializer.deserializeU64();\n    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);\n    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);\n    return new KeylessSignature({\n      jwtHeader,\n      expiryDateSecs: Number(expiryDateSecs),\n      ephemeralCertificate,\n      ephemeralPublicKey,\n      ephemeralSignature,\n    });\n  }\n\n  static getSimulationSignature(): KeylessSignature {\n    return new KeylessSignature({\n      jwtHeader: \"{}\",\n      ephemeralCertificate: new EphemeralCertificate(\n        new ZeroKnowledgeSig({\n          proof: new ZkProof(\n            new Groth16Zkp({ a: new Uint8Array(32), b: new Uint8Array(64), c: new Uint8Array(32) }),\n            ZkpVariant.Groth16,\n          ),\n          expHorizonSecs: 0,\n        }),\n        EphemeralCertificateVariant.ZkProof,\n      ),\n      expiryDateSecs: 0,\n      ephemeralPublicKey: new EphemeralPublicKey(new Ed25519PublicKey(new Uint8Array(32))),\n      ephemeralSignature: new EphemeralSignature(new Ed25519Signature(new Uint8Array(64))),\n    });\n  }\n\n  static isSignature(signature: Signature): signature is KeylessSignature {\n    return signature instanceof KeylessSignature;\n  }\n}\n\n/**\n * Represents an ephemeral certificate containing a signature, specifically a ZeroKnowledgeSig.\n * This class can be extended to support additional signature types, such as OpenIdSignature.\n *\n * @extends Signature\n * @group Implementation\n * @category Serialization\n */\nexport class EphemeralCertificate extends Signature {\n  public readonly signature: Signature;\n\n  /**\n   * Index of the underlying enum variant\n   * @group Implementation\n   * @category Serialization\n   */\n  private readonly variant: EphemeralCertificateVariant;\n\n  constructor(signature: Signature, variant: EphemeralCertificateVariant) {\n    super();\n    this.signature = signature;\n    this.variant = variant;\n  }\n\n  /**\n   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    return this.signature.toUint8Array();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(this.variant);\n    this.signature.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): EphemeralCertificate {\n    const variant = deserializer.deserializeUleb128AsU32();\n    switch (variant) {\n      case EphemeralCertificateVariant.ZkProof:\n        return new EphemeralCertificate(ZeroKnowledgeSig.deserialize(deserializer), variant);\n      default:\n        throw new Error(`Unknown variant index for EphemeralCertificate: ${variant}`);\n    }\n  }\n}\n\n/**\n * Represents a fixed-size byte array of 32 bytes, extending the Serializable class.\n * This class is used for handling and serializing G1 bytes in cryptographic operations.\n *\n * @extends Serializable\n * @group Implementation\n * @category Serialization\n */\nclass G1Bytes extends Serializable {\n  data: Uint8Array;\n\n  constructor(data: HexInput) {\n    super();\n    this.data = Hex.fromHexInput(data).toUint8Array();\n    if (this.data.length !== 32) {\n      throw new Error(\"Input needs to be 32 bytes\");\n    }\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.data);\n  }\n\n  static deserialize(deserializer: Deserializer): G1Bytes {\n    const bytes = deserializer.deserializeFixedBytes(32);\n    return new G1Bytes(bytes);\n  }\n}\n\n/**\n * Represents a 64-byte G2 element in a cryptographic context.\n * This class provides methods for serialization and deserialization of G2 bytes.\n *\n * @extends Serializable\n * @group Implementation\n * @category Serialization\n */\nclass G2Bytes extends Serializable {\n  data: Uint8Array;\n\n  constructor(data: HexInput) {\n    super();\n    this.data = Hex.fromHexInput(data).toUint8Array();\n    if (this.data.length !== 64) {\n      throw new Error(\"Input needs to be 64 bytes\");\n    }\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.data);\n  }\n\n  static deserialize(deserializer: Deserializer): G2Bytes {\n    const bytes = deserializer.deserializeFixedBytes(64);\n    return new G2Bytes(bytes);\n  }\n}\n\n/**\n * Represents a Groth16 zero-knowledge proof, consisting of three proof points in compressed serialization format.\n * The points are the compressed serialization of affine representation of the proof.\n *\n * @extends Proof\n * @group Implementation\n * @category Serialization\n */\nexport class Groth16Zkp extends Proof {\n  /**\n   * The bytes of G1 proof point a\n   * @group Implementation\n   * @category Serialization\n   */\n  a: G1Bytes;\n\n  /**\n   * The bytes of G2 proof point b\n   * @group Implementation\n   * @category Serialization\n   */\n  b: G2Bytes;\n\n  /**\n   * The bytes of G1 proof point c\n   * @group Implementation\n   * @category Serialization\n   */\n  c: G1Bytes;\n\n  constructor(args: { a: HexInput; b: HexInput; c: HexInput }) {\n    super();\n    const { a, b, c } = args;\n    this.a = new G1Bytes(a);\n    this.b = new G2Bytes(b);\n    this.c = new G1Bytes(c);\n  }\n\n  serialize(serializer: Serializer): void {\n    this.a.serialize(serializer);\n    this.b.serialize(serializer);\n    this.c.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): Groth16Zkp {\n    const a = G1Bytes.deserialize(deserializer).bcsToBytes();\n    const b = G2Bytes.deserialize(deserializer).bcsToBytes();\n    const c = G1Bytes.deserialize(deserializer).bcsToBytes();\n    return new Groth16Zkp({ a, b, c });\n  }\n}\n\n/**\n * Represents a container for different types of zero-knowledge proofs.\n *\n * @extends Serializable\n * @group Implementation\n * @category Serialization\n */\nexport class ZkProof extends Serializable {\n  public readonly proof: Proof;\n\n  /**\n   * Index of the underlying enum variant\n   * @group Implementation\n   * @category Serialization\n   */\n  private readonly variant: ZkpVariant;\n\n  constructor(proof: Proof, variant: ZkpVariant) {\n    super();\n    this.proof = proof;\n    this.variant = variant;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(this.variant);\n    this.proof.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): ZkProof {\n    const variant = deserializer.deserializeUleb128AsU32();\n    switch (variant) {\n      case ZkpVariant.Groth16:\n        return new ZkProof(Groth16Zkp.deserialize(deserializer), variant);\n      default:\n        throw new Error(`Unknown variant index for ZkProof: ${variant}`);\n    }\n  }\n}\n\n/**\n * Represents a zero-knowledge signature, encapsulating the proof and its associated metadata.\n *\n * @extends Signature\n * @group Implementation\n * @category Serialization\n */\nexport class ZeroKnowledgeSig extends Signature {\n  /**\n   * The proof\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly proof: ZkProof;\n\n  /**\n   * The max lifespan of the proof\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly expHorizonSecs: number;\n\n  /**\n   * A key value pair on the JWT token that can be specified on the signature which would reveal the value on chain.\n   * Can be used to assert identity or other attributes.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly extraField?: string;\n\n  /**\n   * The 'aud' value of the recovery service which is set when recovering an account.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly overrideAudVal?: string;\n\n  /**\n   * The training wheels signature\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly trainingWheelsSignature?: EphemeralSignature;\n\n  constructor(args: {\n    proof: ZkProof;\n    expHorizonSecs: number;\n    extraField?: string;\n    overrideAudVal?: string;\n    trainingWheelsSignature?: EphemeralSignature;\n  }) {\n    super();\n    const { proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal } = args;\n    this.proof = proof;\n    this.expHorizonSecs = expHorizonSecs;\n    this.trainingWheelsSignature = trainingWheelsSignature;\n    this.extraField = extraField;\n    this.overrideAudVal = overrideAudVal;\n  }\n\n  /**\n   * Deserialize a ZeroKnowledgeSig object from its BCS serialization in bytes.\n   *\n   * @param bytes - The bytes representing the serialized ZeroKnowledgeSig.\n   * @returns ZeroKnowledgeSig - The deserialized ZeroKnowledgeSig object.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromBytes(bytes: Uint8Array): ZeroKnowledgeSig {\n    return ZeroKnowledgeSig.deserialize(new Deserializer(bytes));\n  }\n\n  serialize(serializer: Serializer): void {\n    this.proof.serialize(serializer);\n    serializer.serializeU64(this.expHorizonSecs);\n    serializer.serializeOption(this.extraField);\n    serializer.serializeOption(this.overrideAudVal);\n    serializer.serializeOption(this.trainingWheelsSignature);\n  }\n\n  static deserialize(deserializer: Deserializer): ZeroKnowledgeSig {\n    const proof = ZkProof.deserialize(deserializer);\n    const expHorizonSecs = Number(deserializer.deserializeU64());\n    const extraField = deserializer.deserializeOption(\"string\");\n    const overrideAudVal = deserializer.deserializeOption(\"string\");\n    const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);\n    return new ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });\n  }\n}\n\n/**\n * Represents the on-chain configuration for how Keyless accounts operate.\n *\n * @remarks\n * This class encapsulates the verification key and the maximum lifespan of ephemeral key pairs,\n * which are essential for the functionality of Keyless accounts.\n * @group Implementation\n * @category Serialization\n */\nexport class KeylessConfiguration {\n  /**\n   * The verification key used to verify Groth16 proofs on chain\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly verificationKey: Groth16VerificationKey;\n\n  /**\n   * The maximum lifespan of an ephemeral key pair.  This is configured on chain.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly maxExpHorizonSecs: number;\n\n  constructor(verificationKey: Groth16VerificationKey, maxExpHorizonSecs: number) {\n    this.verificationKey = verificationKey;\n    this.maxExpHorizonSecs = maxExpHorizonSecs;\n  }\n\n  static create(res: Groth16VerificationKeyResponse, maxExpHorizonSecs: number): KeylessConfiguration {\n    return new KeylessConfiguration(\n      new Groth16VerificationKey({\n        alphaG1: res.alpha_g1,\n        betaG2: res.beta_g2,\n        deltaG2: res.delta_g2,\n        gammaAbcG1: res.gamma_abc_g1,\n        gammaG2: res.gamma_g2,\n      }),\n      maxExpHorizonSecs,\n    );\n  }\n}\n\n/**\n * Represents the verification key stored on-chain used to verify Groth16 proofs.\n * @group Implementation\n * @category Serialization\n */\nexport class Groth16VerificationKey {\n  // The docstrings below are borrowed from ark-groth16\n\n  /**\n   * The `alpha * G`, where `G` is the generator of G1\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly alphaG1: G1Bytes;\n\n  /**\n   * The `alpha * H`, where `H` is the generator of G2\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly betaG2: G2Bytes;\n\n  /**\n   * The `delta * H`, where `H` is the generator of G2\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly deltaG2: G2Bytes;\n\n  /**\n   * The `gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H`, where H is the generator of G1\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly gammaAbcG1: [G1Bytes, G1Bytes];\n\n  /**\n   * The `gamma * H`, where `H` is the generator of G2\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly gammaG2: G2Bytes;\n\n  constructor(args: {\n    alphaG1: HexInput;\n    betaG2: HexInput;\n    deltaG2: HexInput;\n    gammaAbcG1: [HexInput, HexInput];\n    gammaG2: HexInput;\n  }) {\n    const { alphaG1, betaG2, deltaG2, gammaAbcG1, gammaG2 } = args;\n    this.alphaG1 = new G1Bytes(alphaG1);\n    this.betaG2 = new G2Bytes(betaG2);\n    this.deltaG2 = new G2Bytes(deltaG2);\n    this.gammaAbcG1 = [new G1Bytes(gammaAbcG1[0]), new G1Bytes(gammaAbcG1[1])];\n    this.gammaG2 = new G2Bytes(gammaG2);\n  }\n\n  /**\n   * Calculates the hash of the serialized form of the verification key.\n   * This is useful for comparing verification keys or using them as unique identifiers.\n   *\n   * @returns The SHA3-256 hash of the serialized verification key as a Uint8Array\n   */\n  public hash(): Uint8Array {\n    const serializer = new Serializer();\n    this.serialize(serializer);\n    return sha3_256.create().update(serializer.toUint8Array()).digest();\n  }\n\n  serialize(serializer: Serializer): void {\n    this.alphaG1.serialize(serializer);\n    this.betaG2.serialize(serializer);\n    this.deltaG2.serialize(serializer);\n    this.gammaAbcG1[0].serialize(serializer);\n    this.gammaAbcG1[1].serialize(serializer);\n    this.gammaG2.serialize(serializer);\n  }\n\n  /**\n   * Converts a Groth16VerificationKeyResponse object into a Groth16VerificationKey instance.\n   *\n   * @param res - The Groth16VerificationKeyResponse object containing the verification key data.\n   * @param res.alpha_g1 - The alpha G1 value from the response.\n   * @param res.beta_g2 - The beta G2 value from the response.\n   * @param res.delta_g2 - The delta G2 value from the response.\n   * @param res.gamma_abc_g1 - The gamma ABC G1 value from the response.\n   * @param res.gamma_g2 - The gamma G2 value from the response.\n   * @returns A Groth16VerificationKey instance constructed from the provided response data.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromGroth16VerificationKeyResponse(res: Groth16VerificationKeyResponse): Groth16VerificationKey {\n    return new Groth16VerificationKey({\n      alphaG1: res.alpha_g1,\n      betaG2: res.beta_g2,\n      deltaG2: res.delta_g2,\n      gammaAbcG1: res.gamma_abc_g1,\n      gammaG2: res.gamma_g2,\n    });\n  }\n}\n\n/**\n * Retrieves the configuration parameters for Keyless Accounts on the blockchain, including the verifying key and the maximum\n * expiry horizon.\n *\n * @param args - The arguments for retrieving the keyless configuration.\n * @param args.aptosConfig - The Aptos configuration object containing network details.\n * @param args.options - Optional parameters for the request.\n * @param args.options.ledgerVersion - The ledger version to query; if not provided, the latest version will be used.\n * @returns KeylessConfiguration - The configuration object containing the verifying key and maximum expiry horizon.\n * @group Implementation\n * @category Serialization\n */\nexport async function getKeylessConfig(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<KeylessConfiguration> {\n  const { aptosConfig } = args;\n  try {\n    return await memoizeAsync(\n      async () => {\n        const config = await getKeylessConfigurationResource(args);\n        const vk = await getGroth16VerificationKeyResource(args);\n        return KeylessConfiguration.create(vk, Number(config.max_exp_horizon_secs));\n      },\n      `keyless-configuration-${aptosConfig.network}`,\n      1000 * 60 * 5, // 5 minutes\n    )();\n  } catch (error) {\n    if (error instanceof KeylessError) {\n      throw error;\n    }\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.FULL_NODE_OTHER,\n      error,\n    });\n  }\n}\n\n/**\n * Parses a JWT and returns the 'iss', 'aud', and 'uid' values.\n *\n * @param args - The arguments for parsing the JWT.\n * @param args.jwt - The JWT to parse.\n * @param args.uidKey - The key to use for the 'uid' value; defaults to 'sub'.\n * @returns The 'iss', 'aud', and 'uid' values from the JWT.\n */\nexport function getIssAudAndUidVal(args: { jwt: string; uidKey?: string }): {\n  iss: string;\n  aud: string;\n  uidVal: string;\n} {\n  const { jwt, uidKey = \"sub\" } = args;\n  let jwtPayload: JwtPayload & { [key: string]: string };\n  try {\n    jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);\n  } catch (error) {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.JWT_PARSING_ERROR,\n      details: `Failed to parse JWT - ${getErrorMessage(error)}`,\n    });\n  }\n  if (typeof jwtPayload.iss !== \"string\") {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.JWT_PARSING_ERROR,\n      details: \"JWT is missing 'iss' in the payload. This should never happen.\",\n    });\n  }\n  if (typeof jwtPayload.aud !== \"string\") {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.JWT_PARSING_ERROR,\n      details: \"JWT is missing 'aud' in the payload or 'aud' is an array of values.\",\n    });\n  }\n  const uidVal = jwtPayload[uidKey];\n  return { iss: jwtPayload.iss, aud: jwtPayload.aud, uidVal };\n}\n\n/**\n * Retrieves the KeylessConfiguration set on chain.\n *\n * @param args - The arguments for retrieving the configuration.\n * @param args.aptosConfig - The configuration for connecting to the Aptos network.\n * @param args.options - Optional parameters for the request.\n * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.\n * @returns KeylessConfigurationResponse - The response containing the keyless configuration data.\n * @group Implementation\n * @category Serialization\n */\nasync function getKeylessConfigurationResource(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<KeylessConfigurationResponse> {\n  const { aptosConfig, options } = args;\n  const resourceType = \"0x1::keyless_account::Configuration\";\n  try {\n    const { data } = await getAptosFullNode<{}, MoveResource<KeylessConfigurationResponse>>({\n      aptosConfig,\n      originMethod: \"getKeylessConfigurationResource\",\n      path: `accounts/${AccountAddress.from(\"0x1\").toString()}/resource/${resourceType}`,\n      params: { ledger_version: options?.ledgerVersion },\n    });\n    return data.data;\n  } catch (error) {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.FULL_NODE_CONFIG_LOOKUP_ERROR,\n      error,\n    });\n  }\n}\n\n/**\n * Retrieves the Groth16VerificationKey set on the blockchain.\n *\n * @param args - The arguments for retrieving the verification key.\n * @param args.aptosConfig - The Aptos configuration object.\n * @param args.options - Optional parameters for the request.\n * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.\n * @returns Groth16VerificationKeyResponse - The response containing the Groth16 verification key data.\n * @group Implementation\n * @category Serialization\n */\nasync function getGroth16VerificationKeyResource(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<Groth16VerificationKeyResponse> {\n  const { aptosConfig, options } = args;\n  const resourceType = \"0x1::keyless_account::Groth16VerificationKey\";\n  try {\n    const { data } = await getAptosFullNode<{}, MoveResource<Groth16VerificationKeyResponse>>({\n      aptosConfig,\n      originMethod: \"getGroth16VerificationKeyResource\",\n      path: `accounts/${AccountAddress.from(\"0x1\").toString()}/resource/${resourceType}`,\n      params: { ledger_version: options?.ledgerVersion },\n    });\n    return data.data;\n  } catch (error) {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.FULL_NODE_VERIFICATION_KEY_LOOKUP_ERROR,\n      error,\n    });\n  }\n}\n\nexport async function getKeylessJWKs(args: {\n  aptosConfig: AptosConfig;\n  jwkAddr?: AccountAddressInput;\n  options?: LedgerVersionArg;\n}): Promise<Map<string, MoveJWK[]>> {\n  const { aptosConfig, jwkAddr, options } = args;\n  let resource: MoveResource<PatchedJWKsResponse>;\n  if (!jwkAddr) {\n    const resourceType = \"0x1::jwks::PatchedJWKs\";\n    const { data } = await getAptosFullNode<{}, MoveResource<PatchedJWKsResponse>>({\n      aptosConfig,\n      originMethod: \"getKeylessJWKs\",\n      path: `accounts/0x1/resource/${resourceType}`,\n      params: { ledger_version: options?.ledgerVersion },\n    });\n    resource = data;\n  } else {\n    const resourceType = \"0x1::jwks::FederatedJWKs\";\n    const { data } = await getAptosFullNode<{}, MoveResource<PatchedJWKsResponse>>({\n      aptosConfig,\n      originMethod: \"getKeylessJWKs\",\n      path: `accounts/${AccountAddress.from(jwkAddr).toString()}/resource/${resourceType}`,\n      params: { ledger_version: options?.ledgerVersion },\n    });\n    resource = data;\n  }\n\n  // Create a map of issuer to JWK arrays\n  const jwkMap = new Map<string, MoveJWK[]>();\n  for (const entry of resource.data.jwks.entries) {\n    const jwks: MoveJWK[] = [];\n    for (const jwkStruct of entry.jwks) {\n      const { data: jwkData } = jwkStruct.variant;\n      const deserializer = new Deserializer(Hex.fromHexInput(jwkData).toUint8Array());\n      const jwk = MoveJWK.deserialize(deserializer);\n      jwks.push(jwk);\n    }\n    jwkMap.set(hexToAsciiString(entry.issuer), jwks);\n  }\n\n  return jwkMap;\n}\n\nexport class MoveJWK extends Serializable {\n  public kid: string;\n\n  public kty: string;\n\n  public alg: string;\n\n  public e: string;\n\n  public n: string;\n\n  constructor(args: { kid: string; kty: string; alg: string; e: string; n: string }) {\n    super();\n    const { kid, kty, alg, e, n } = args;\n    this.kid = kid;\n    this.kty = kty;\n    this.alg = alg;\n    this.e = e;\n    this.n = n;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.kid);\n    serializer.serializeStr(this.kty);\n    serializer.serializeStr(this.alg);\n    serializer.serializeStr(this.e);\n    serializer.serializeStr(this.n);\n  }\n\n  static fromMoveStruct(struct: MoveAnyStruct): MoveJWK {\n    const { data } = struct.variant;\n    const deserializer = new Deserializer(Hex.fromHexInput(data).toUint8Array());\n    return MoveJWK.deserialize(deserializer);\n  }\n\n  static deserialize(deserializer: Deserializer): MoveJWK {\n    const kid = deserializer.deserializeStr();\n    const kty = deserializer.deserializeStr();\n    const alg = deserializer.deserializeStr();\n    const n = deserializer.deserializeStr();\n    const e = deserializer.deserializeStr();\n    return new MoveJWK({ kid, kty, alg, n, e });\n  }\n}\n\ninterface JwtHeader {\n  kid: string; // Key ID\n}\n/**\n * Safely parses the JWT header.\n * @param jwtHeader The JWT header string\n * @returns Parsed JWT header as an object.\n */\nexport function parseJwtHeader(jwtHeader: string): JwtHeader {\n  try {\n    const header = JSON.parse(jwtHeader);\n    if (header.kid === undefined) {\n      throw new Error(\"JWT header missing kid\");\n    }\n    return header;\n  } catch (error) {\n    throw new Error(\"Failed to parse JWT header.\");\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/esm/chunk-TDLL7QX5.mjs

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/AccountUtils.ts"],"sourcesContent":["import { Deserializer, Serializer } from \"../bcs\";\nimport { AnyPublicKeyVariant, HexInput, SigningScheme } from \"../types\";\nimport { MultiKeyAccount } from \"./MultiKeyAccount\";\nimport { Account } from \"./Account\";\nimport { Ed25519Account } from \"./Ed25519Account\";\nimport { isSingleKeySigner, SingleKeyAccount, SingleKeySignerOrLegacyEd25519Account } from \"./SingleKeyAccount\";\nimport { KeylessAccount } from \"./KeylessAccount\";\nimport { FederatedKeylessAccount } from \"./FederatedKeylessAccount\";\nimport { AbstractKeylessAccount } from \"./AbstractKeylessAccount\";\nimport {\n  AccountAddress,\n  Ed25519PrivateKey,\n  getIssAudAndUidVal,\n  Hex,\n  MultiKey,\n  Secp256k1PrivateKey,\n  ZeroKnowledgeSig,\n} from \"../core\";\nimport { deserializeSchemeAndAddress } from \"./utils\";\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\n\nfunction serializeKeylessAccountCommon(account: AbstractKeylessAccount, serializer: Serializer): void {\n  serializer.serializeStr(account.jwt);\n  serializer.serializeStr(account.uidKey);\n  serializer.serializeFixedBytes(account.pepper);\n  account.ephemeralKeyPair.serialize(serializer);\n  if (account.proof === undefined) {\n    throw new Error(\"Cannot serialize - proof undefined\");\n  }\n  account.proof.serialize(serializer);\n  serializer.serializeOption(account.verificationKeyHash, 32);\n}\n\nfunction deserializeKeylessAccountCommon(deserializer: Deserializer): {\n  jwt: string;\n  uidKey: string;\n  pepper: Uint8Array;\n  ephemeralKeyPair: EphemeralKeyPair;\n  proof: ZeroKnowledgeSig;\n  verificationKeyHash?: Uint8Array;\n} {\n  const jwt = deserializer.deserializeStr();\n  const uidKey = deserializer.deserializeStr();\n  const pepper = deserializer.deserializeFixedBytes(31);\n  const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);\n  const proof = ZeroKnowledgeSig.deserialize(deserializer);\n  const verificationKeyHash = deserializer.deserializeOption(\"fixedBytes\", 32);\n  return { jwt, uidKey, pepper, ephemeralKeyPair, proof, verificationKeyHash };\n}\n\n/**\n * Utility functions for working with accounts.\n */\nexport namespace AccountUtils {\n  export function toBytes(account: Account): Uint8Array {\n    const serializer = new Serializer();\n    serializer.serializeU32AsUleb128(account.signingScheme);\n    account.accountAddress.serialize(serializer);\n    switch (account.signingScheme) {\n      case SigningScheme.Ed25519:\n        (account as Ed25519Account).privateKey.serialize(serializer);\n        return serializer.toUint8Array();\n      case SigningScheme.SingleKey: {\n        if (!isSingleKeySigner(account)) {\n          throw new Error(\"Account is not a SingleKeySigner\");\n        }\n        const anyPublicKey = account.getAnyPublicKey();\n        serializer.serializeU32AsUleb128(anyPublicKey.variant);\n        switch (anyPublicKey.variant) {\n          case AnyPublicKeyVariant.Keyless: {\n            const keylessAccount = account as KeylessAccount;\n            serializeKeylessAccountCommon(keylessAccount, serializer);\n            return serializer.toUint8Array();\n          }\n          case AnyPublicKeyVariant.FederatedKeyless: {\n            const federatedKeylessAccount = account as FederatedKeylessAccount;\n            serializeKeylessAccountCommon(federatedKeylessAccount, serializer);\n            federatedKeylessAccount.publicKey.jwkAddress.serialize(serializer);\n            serializer.serializeBool(federatedKeylessAccount.audless);\n            return serializer.toUint8Array();\n          }\n          case AnyPublicKeyVariant.Secp256k1:\n          case AnyPublicKeyVariant.Ed25519: {\n            const singleKeyAccount = account as SingleKeyAccount;\n            singleKeyAccount.privateKey.serialize(serializer);\n            return serializer.toUint8Array();\n          }\n          default: {\n            throw new Error(`Invalid public key variant: ${anyPublicKey.variant}`);\n          }\n        }\n      }\n      case SigningScheme.MultiKey: {\n        const multiKeyAccount = account as MultiKeyAccount;\n        multiKeyAccount.publicKey.serialize(serializer);\n        serializer.serializeU32AsUleb128(multiKeyAccount.signers.length);\n        multiKeyAccount.signers.forEach((signer) => {\n          serializer.serializeFixedBytes(toBytes(signer));\n        });\n        return serializer.toUint8Array();\n      }\n      default:\n        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${account.signingScheme}`);\n    }\n  }\n\n  export function toHexStringWithoutPrefix(account: Account): string {\n    return Hex.hexInputToStringWithoutPrefix(toBytes(account));\n  }\n\n  export function toHexString(account: Account): string {\n    return Hex.hexInputToString(toBytes(account));\n  }\n\n  export function deserialize(deserializer: Deserializer): Account {\n    const { address, signingScheme } = deserializeSchemeAndAddress(deserializer);\n    switch (signingScheme) {\n      case SigningScheme.Ed25519: {\n        const privateKey = Ed25519PrivateKey.deserialize(deserializer);\n        return new Ed25519Account({ privateKey, address });\n      }\n      case SigningScheme.SingleKey: {\n        const variantIndex = deserializer.deserializeUleb128AsU32();\n        switch (variantIndex) {\n          case AnyPublicKeyVariant.Ed25519: {\n            const privateKey = Ed25519PrivateKey.deserialize(deserializer);\n            return new SingleKeyAccount({ privateKey, address });\n          }\n          case AnyPublicKeyVariant.Secp256k1: {\n            const privateKey = Secp256k1PrivateKey.deserialize(deserializer);\n            return new SingleKeyAccount({ privateKey, address });\n          }\n          case AnyPublicKeyVariant.Keyless: {\n            const keylessComponents = deserializeKeylessAccountCommon(deserializer);\n            const jwtClaims = getIssAudAndUidVal(keylessComponents);\n            return new KeylessAccount({ ...keylessComponents, ...jwtClaims });\n          }\n          case AnyPublicKeyVariant.FederatedKeyless: {\n            const keylessComponents = deserializeKeylessAccountCommon(deserializer);\n            const jwkAddress = AccountAddress.deserialize(deserializer);\n            const audless = deserializer.deserializeBool();\n            const jwtClaims = getIssAudAndUidVal(keylessComponents);\n            return new FederatedKeylessAccount({ ...keylessComponents, ...jwtClaims, jwkAddress, audless });\n          }\n          default:\n            throw new Error(`Unsupported public key variant ${variantIndex}`);\n        }\n      }\n      case SigningScheme.MultiKey: {\n        const multiKey = MultiKey.deserialize(deserializer);\n        const length = deserializer.deserializeUleb128AsU32();\n        const signers = new Array<SingleKeySignerOrLegacyEd25519Account>();\n        for (let i = 0; i < length; i += 1) {\n          const signer = deserialize(deserializer);\n          if (!isSingleKeySigner(signer) && !(signer instanceof Ed25519Account)) {\n            throw new Error(\n              \"Deserialization of MultiKeyAccount failed. Signer is not a SingleKeySigner or Ed25519Account\",\n            );\n          }\n          signers.push(signer);\n        }\n        return new MultiKeyAccount({ multiKey, signers, address });\n      }\n      default:\n        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${signingScheme}`);\n    }\n  }\n\n  export function keylessAccountFromHex(hex: HexInput): KeylessAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof KeylessAccount)) {\n      throw new Error(\"Deserialization of KeylessAccount failed\");\n    }\n    return account;\n  }\n\n  export function federatedKeylessAccountFromHex(hex: HexInput): FederatedKeylessAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof FederatedKeylessAccount)) {\n      throw new Error(\"Deserialization of FederatedKeylessAccount failed\");\n    }\n    return account;\n  }\n\n  export function multiKeyAccountFromHex(hex: HexInput): MultiKeyAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof MultiKeyAccount)) {\n      throw new Error(\"Deserialization of MultiKeyAccount failed\");\n    }\n    return account;\n  }\n\n  export function singleKeyAccountFromHex(hex: HexInput): SingleKeyAccount {\n    const account = fromHex(hex);\n    if (!(account instanceof SingleKeyAccount)) {\n      throw new Error(\"Deserialization of SingleKeyAccount failed\");\n    }\n    return account;\n  }\n\n  export function ed25519AccountFromHex(hex: HexInput): Ed25519Account {\n    const account = fromHex(hex);\n    if (!(account instanceof Ed25519Account)) {\n      throw new Error(\"Deserialization of Ed25519Account failed\");\n    }\n    return account;\n  }\n\n  export function fromHex(hex: HexInput): Account {\n    return deserialize(Deserializer.fromHex(hex));\n  }\n\n  export function fromBytes(bytes: Uint8Array): Account {\n    return fromHex(bytes);\n  }\n}\n"],"mappings":"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","names":["AccountUtils"]}