@aptos-labs/ts-sdk
Version:
Aptos TypeScript SDK
803 lines • 29.4 kB
TypeScript
import { AccountPublicKey, PublicKey } from "./publicKey.js";
import { Signature } from "./signature.js";
import { Deserializer, Serializable, Serializer } from "../../bcs/index.js";
import { HexInput, EphemeralCertificateVariant, ZkpVariant, LedgerVersionArg } from "../../types/index.js";
import { EphemeralPublicKey, EphemeralSignature } from "./ephemeral.js";
import { AuthenticationKey } from "../authenticationKey.js";
import { Proof } from "./proof.js";
import { Groth16VerificationKeyResponse, KeylessConfigurationResponse, MoveAnyStruct } from "../../types/keyless.js";
import { AptosConfig } from "../../api/aptosConfig.js";
import { AccountAddressInput } from "../accountAddress.js";
import { FederatedKeylessPublicKey } from "./federatedKeyless.js";
import { WeierstrassPoint } from "@noble/curves/abstract/weierstrass.js";
import { Fp2 } from "@noble/curves/abstract/tower.js";
import "./keylessRegistration.js";
/**
* @group Implementation
* @category Serialization
*/
export declare const EPK_HORIZON_SECS = 10000000;
/**
* @group Implementation
* @category Serialization
*/
export declare const MAX_AUD_VAL_BYTES = 120;
/**
* @group Implementation
* @category Serialization
*/
export declare const MAX_UID_KEY_BYTES = 30;
/**
* @group Implementation
* @category Serialization
*/
export declare const MAX_UID_VAL_BYTES = 330;
/**
* @group Implementation
* @category Serialization
*/
export declare const MAX_ISS_VAL_BYTES = 120;
/**
* @group Implementation
* @category Serialization
*/
export declare const MAX_EXTRA_FIELD_BYTES = 350;
/**
* @group Implementation
* @category Serialization
*/
export declare const MAX_JWT_HEADER_B64_BYTES = 300;
/**
* @group Implementation
* @category Serialization
*/
export declare 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 declare class KeylessPublicKey extends AccountPublicKey {
/**
* The number of bytes that `idCommitment` should be
* @group Implementation
* @category Serialization
*/
static readonly ID_COMMITMENT_LENGTH: number;
/**
* The value of the 'iss' claim on the JWT which identifies the OIDC provider.
* @group Implementation
* @category Serialization
*/
readonly iss: string;
/**
* A value representing a cryptographic commitment to a user identity.
*
* It is calculated from the aud, uidKey, uidVal, pepper.
* @group Implementation
* @category Serialization
*/
readonly idCommitment: Uint8Array;
/**
* 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
*/
constructor(iss: string, idCommitment: HexInput);
/**
* 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(): AuthenticationKey;
/**
* 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: {
message: HexInput;
signature: Signature;
jwk: MoveJWK;
keylessConfig: KeylessConfiguration;
}): boolean;
/**
* 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
*/
verifySignatureAsync(args: {
aptosConfig: AptosConfig;
message: HexInput;
signature: Signature;
options?: {
throwErrorWithReason?: boolean;
};
}): Promise<boolean>;
/**
* 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): void;
/**
* 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: Deserializer): KeylessPublicKey;
/**
* 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: Deserializer): KeylessPublicKey;
/**
* 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: PublicKey): publicKey is 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: {
iss: string;
uidKey: string;
uidVal: string;
aud: string;
pepper: HexInput;
}): KeylessPublicKey;
/**
* 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.
*
* SECURITY: `jwtDecode` is a decode-only library — it does NOT verify the
* JWT signature. The cryptographic binding between the JWT and the user's
* identity is enforced on-chain by the keyless verifier (which validates
* the JWT signature against the JWK set published on-chain). Callers MUST
* therefore obtain `jwt` directly from a trusted IdP redirect/OAuth flow;
* do not accept arbitrary user-supplied JWT strings here, since a tampered
* JWT will derive a different account address than the chain expects.
*
* @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: {
jwt: string;
pepper: HexInput;
uidKey?: string;
}): KeylessPublicKey;
/**
* 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: PublicKey): boolean;
}
export declare function verifyKeylessSignature(args: {
publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
aptosConfig: AptosConfig;
message: HexInput;
signature: Signature;
keylessConfig?: KeylessConfiguration;
jwk?: MoveJWK;
options?: {
throwErrorWithReason?: boolean;
};
}): Promise<boolean>;
/**
* 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 declare function verifyKeylessSignatureWithJwkAndConfig(args: {
publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
message: HexInput;
signature: Signature;
keylessConfig: KeylessConfiguration;
jwk: MoveJWK;
}): void;
/**
* 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 declare function fetchJWK(args: {
aptosConfig: AptosConfig;
publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
kid: string;
}): Promise<MoveJWK>;
/**
* Represents a signature of a message signed via a Keyless Account, utilizing proofs or a JWT token for authentication.
* @group Implementation
* @category Serialization
*/
export declare class KeylessSignature extends Signature {
/**
* The inner signature ZeroKnowledgeSignature or OpenIdSignature
* @group Implementation
* @category Serialization
*/
readonly ephemeralCertificate: EphemeralCertificate;
/**
* The jwt header in the token used to create the proof/signature. In json string representation.
* @group Implementation
* @category Serialization
*/
readonly jwtHeader: string;
/**
* The expiry timestamp in seconds of the EphemeralKeyPair used to sign
* @group Implementation
* @category Serialization
*/
readonly expiryDateSecs: number;
/**
* The ephemeral public key used to verify the signature
* @group Implementation
* @category Serialization
*/
readonly ephemeralPublicKey: EphemeralPublicKey;
/**
* The signature resulting from signing with the private key of the EphemeralKeyPair
* @group Implementation
* @category Serialization
*/
readonly ephemeralSignature: EphemeralSignature;
constructor(args: {
jwtHeader: string;
ephemeralCertificate: EphemeralCertificate;
expiryDateSecs: number;
ephemeralPublicKey: EphemeralPublicKey;
ephemeralSignature: EphemeralSignature;
});
/**
* Get the kid of the JWT used to derive the Keyless Account used to sign.
*
* @returns the kid as a string
*/
getJwkKid(): string;
serialize(serializer: Serializer): void;
static deserialize(deserializer: Deserializer): KeylessSignature;
static getSimulationSignature(): KeylessSignature;
static isSignature(signature: Signature): signature is 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 declare class EphemeralCertificate extends Signature {
readonly signature: Signature;
/**
* Index of the underlying enum variant
* @group Implementation
* @category Serialization
*/
readonly variant: EphemeralCertificateVariant;
constructor(signature: Signature, variant: EphemeralCertificateVariant);
/**
* Get the public key in bytes (Uint8Array).
*
* @returns Uint8Array representation of the public key
* @group Implementation
* @category Serialization
*/
toUint8Array(): Uint8Array;
serialize(serializer: Serializer): void;
static deserialize(deserializer: Deserializer): EphemeralCertificate;
}
/**
* 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
*/
declare class G1Bytes extends Serializable {
private static readonly B;
data: Uint8Array;
constructor(data: HexInput);
serialize(serializer: Serializer): void;
static deserialize(deserializer: Deserializer): G1Bytes;
toArray(): string[];
/**
* Converts the G1 bytes to a projective point.
* @returns The projective point.
*/
toProjectivePoint(): WeierstrassPoint<bigint>;
}
/**
* 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
*/
declare class G2Bytes extends Serializable {
/**
* The constant b value used in G2 point calculations
*/
private static readonly B;
data: Uint8Array;
constructor(data: HexInput);
serialize(serializer: Serializer): void;
static deserialize(deserializer: Deserializer): G2Bytes;
toArray(): [string, string][];
toProjectivePoint(): WeierstrassPoint<Fp2>;
}
/**
* 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 declare class Groth16Zkp extends Proof {
/**
* The bytes of G1 proof point a
* @group Implementation
* @category Serialization
*/
a: G1Bytes;
/**
* The bytes of G2 proof point b
* @group Implementation
* @category Serialization
*/
b: G2Bytes;
/**
* The bytes of G1 proof point c
* @group Implementation
* @category Serialization
*/
c: G1Bytes;
constructor(args: {
a: HexInput;
b: HexInput;
c: HexInput;
});
serialize(serializer: Serializer): void;
static deserialize(deserializer: Deserializer): Groth16Zkp;
toSnarkJsJson(): {
protocol: string;
curve: string;
pi_a: string[];
pi_b: [string, string][];
pi_c: string[];
};
}
/**
* 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 declare class Groth16ProofAndStatement extends Serializable {
/**
* The Groth16 proof
* @group Implementation
* @category Serialization
*/
proof: Groth16Zkp;
/**
* The public inputs hash as a 32 byte Uint8Array
* @group Implementation
* @category Serialization
*/
publicInputsHash: Uint8Array;
/**
* The domain separator prefix used when hashing.
* @group Implementation
* @category Account (On-Chain Model)
*/
readonly domainSeparator = "APTOS::Groth16ProofAndStatement";
constructor(proof: Groth16Zkp, publicInputsHash: HexInput | bigint);
serialize(serializer: Serializer): void;
static deserialize(deserializer: Deserializer): Groth16ProofAndStatement;
hash(): Uint8Array;
}
/**
* Represents a container for different types of zero-knowledge proofs.
*
* @extends Serializable
* @group Implementation
* @category Serialization
*/
export declare class ZkProof extends Serializable {
readonly proof: Proof;
/**
* Index of the underlying enum variant
* @group Implementation
* @category Serialization
*/
readonly variant: ZkpVariant;
constructor(proof: Proof, variant: ZkpVariant);
serialize(serializer: Serializer): void;
static deserialize(deserializer: Deserializer): ZkProof;
}
/**
* Represents a zero-knowledge signature, encapsulating the proof and its associated metadata.
*
* @extends Signature
* @group Implementation
* @category Serialization
*/
export declare class ZeroKnowledgeSig extends Signature {
/**
* The proof
* @group Implementation
* @category Serialization
*/
readonly proof: ZkProof;
/**
* The max lifespan of the proof
* @group Implementation
* @category Serialization
*/
readonly expHorizonSecs: number;
/**
* 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
*/
readonly extraField?: string;
/**
* The 'aud' value of the recovery service which is set when recovering an account.
* @group Implementation
* @category Serialization
*/
readonly overrideAudVal?: string;
/**
* The training wheels signature
* @group Implementation
* @category Serialization
*/
readonly trainingWheelsSignature?: EphemeralSignature;
constructor(args: {
proof: ZkProof;
expHorizonSecs: number;
extraField?: string;
overrideAudVal?: string;
trainingWheelsSignature?: EphemeralSignature;
});
/**
* 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: Uint8Array): ZeroKnowledgeSig;
serialize(serializer: Serializer): void;
static deserialize(deserializer: Deserializer): ZeroKnowledgeSig;
}
/**
* 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 declare class KeylessConfiguration {
/**
* The verification key used to verify Groth16 proofs on chain
* @group Implementation
* @category Serialization
*/
readonly verificationKey: Groth16VerificationKey;
/**
* The maximum lifespan of an ephemeral key pair. This is configured on chain.
* @group Implementation
* @category Serialization
*/
readonly maxExpHorizonSecs: number;
/**
* The public key of the training wheels account.
* @group Implementation
* @category Serialization
*/
readonly trainingWheelsPubkey?: EphemeralPublicKey;
/**
* The maximum number of bytes that can be used for the extra field.
* @group Implementation
* @category Serialization
*/
readonly maxExtraFieldBytes: number;
/**
* The maximum number of bytes that can be used for the JWT header.
* @group Implementation
* @category Serialization
*/
readonly maxJwtHeaderB64Bytes: number;
/**
* The maximum number of bytes that can be used for the issuer value.
* @group Implementation
* @category Serialization
*/
readonly maxIssValBytes: number;
/**
* The maximum number of bytes that can be used for the committed ephemeral public key.
* @group Implementation
* @category Serialization
*/
readonly maxCommitedEpkBytes: number;
constructor(args: {
verificationKey: Groth16VerificationKey;
trainingWheelsPubkey?: HexInput;
maxExpHorizonSecs?: number;
maxExtraFieldBytes?: number;
maxJwtHeaderB64Bytes?: number;
maxIssValBytes?: number;
maxCommitedEpkBytes?: number;
});
/**
* 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: Groth16VerificationKeyResponse, config: KeylessConfigurationResponse): KeylessConfiguration;
}
/**
* Represents the verification key stored on-chain used to verify Groth16 proofs.
* @group Implementation
* @category Serialization
*/
export declare class Groth16VerificationKey {
/**
* The `alpha * G`, where `G` is the generator of G1
* @group Implementation
* @category Serialization
*/
readonly alphaG1: G1Bytes;
/**
* The `alpha * H`, where `H` is the generator of G2
* @group Implementation
* @category Serialization
*/
readonly betaG2: G2Bytes;
/**
* The `delta * H`, where `H` is the generator of G2
* @group Implementation
* @category Serialization
*/
readonly deltaG2: G2Bytes;
/**
* The `gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H`, where H is the generator of G1
* @group Implementation
* @category Serialization
*/
readonly gammaAbcG1: [G1Bytes, G1Bytes];
/**
* The `gamma * H`, where `H` is the generator of G2
* @group Implementation
* @category Serialization
*/
readonly gammaG2: G2Bytes;
constructor(args: {
alphaG1: HexInput;
betaG2: HexInput;
deltaG2: HexInput;
gammaAbcG1: [HexInput, HexInput];
gammaG2: HexInput;
});
/**
* 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(): Uint8Array;
serialize(serializer: Serializer): void;
/**
* 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: Groth16VerificationKeyResponse): Groth16VerificationKey;
/**
* 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: {
publicInputsHash: bigint;
groth16Proof: Groth16Zkp;
}): boolean;
/**
* 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(): {
protocol: string;
curve: string;
nPublic: number;
vk_alpha_1: string[];
vk_beta_2: [string, string][];
vk_gamma_2: [string, string][];
vk_delta_2: [string, string][];
IC: string[][];
};
}
/**
* 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 declare function getKeylessConfig(args: {
aptosConfig: AptosConfig;
options?: LedgerVersionArg;
}): Promise<KeylessConfiguration>;
/**
* Parses a JWT and returns the 'iss', 'aud', and 'uid' values.
*
* SECURITY: This function decodes claims without verifying the JWT signature.
* The keyless on-chain verifier is the authority that binds a JWT to its IdP;
* the SDK only uses these claims to derive the keyless account address and
* package the JWT for the prover service. Callers must source `jwt` from a
* trusted IdP redirect flow.
*
* @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 declare function getIssAudAndUidVal(args: {
jwt: string;
uidKey?: string;
}): {
iss: string;
aud: string;
uidVal: string;
};
/**
* 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 declare function getKeylessJWKs(args: {
aptosConfig: AptosConfig;
jwkAddr?: AccountAddressInput;
options?: LedgerVersionArg;
useCache?: boolean;
}): Promise<Map<string, MoveJWK[]>>;
export declare class MoveJWK extends Serializable {
kid: string;
kty: string;
alg: string;
e: string;
n: string;
constructor(args: {
kid: string;
kty: string;
alg: string;
e: string;
n: string;
});
serialize(serializer: Serializer): void;
static fromMoveStruct(struct: MoveAnyStruct): MoveJWK;
toScalar(): bigint;
static deserialize(deserializer: Deserializer): MoveJWK;
}
interface JwtHeader {
kid: string;
}
/**
* 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 declare function parseJwtHeader(jwtHeader: string): JwtHeader;
export {};
//# sourceMappingURL=keyless.d.ts.map