@cubist-labs/cubesigner-sdk 0.2.28 → 0.3.8

package/dist/esm/src/key.js

@@ -0,0 +1,256 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Key_data;
+/** Secp256k1 key type */
+export var Secp256k1;
+(function (Secp256k1) {
+    Secp256k1["Evm"] = "SecpEthAddr";
+    Secp256k1["Btc"] = "SecpBtc";
+    Secp256k1["BtcTest"] = "SecpBtcTest";
+    Secp256k1["Ava"] = "SecpAvaAddr";
+    Secp256k1["AvaTest"] = "SecpAvaTestAddr";
+})(Secp256k1 || (Secp256k1 = {}));
+/** BLS key type */
+export var Bls;
+(function (Bls) {
+    Bls["Eth2Deposited"] = "BlsPub";
+    Bls["Eth2Inactive"] = "BlsInactive";
+})(Bls || (Bls = {}));
+/** Ed25519 key type */
+export var Ed25519;
+(function (Ed25519) {
+    Ed25519["Solana"] = "Ed25519SolanaAddr";
+    Ed25519["Sui"] = "Ed25519SuiAddr";
+    Ed25519["Aptos"] = "Ed25519AptosAddr";
+    Ed25519["Cardano"] = "Ed25519CardanoAddrVk";
+    Ed25519["Stellar"] = "Ed25519StellarAddr";
+})(Ed25519 || (Ed25519 = {}));
+/** Mnemonic key type */
+export const Mnemonic = "Mnemonic";
+/** Stark key type */
+export const Stark = "Stark";
+/**
+ * Define some additional (backward compatibility) properties
+ * on a `KeyInfoApi` object returned from the remote end.
+ *
+ * @param {KeyInfoApi} key Key information returned from the remote end
+ * @return {KeyInfo} The same `key` object extended with some derived properties.
+ */
+export function toKeyInfo(key) {
+    return {
+        ...key,
+        id: key.key_id,
+        type: key.key_type,
+        publicKey: key.public_key,
+        materialId: key.material_id,
+    };
+}
+/**
+ * A representation of a signing key.
+ */
+export class Key {
+    /** The organization that this key is in */
+    get orgId() {
+        return this.csc.orgId;
+    }
+    /**
+     * The id of the key: "Key#" followed by a unique identifier specific to
+     * the type of key (such as a public key for BLS or an ethereum address for Secp)
+     * @example Key#0x8e3484687e66cdd26cf04c3647633ab4f3570148
+     */
+    get id() {
+        return __classPrivateFieldGet(this, _Key_data, "f").key_id;
+    }
+    /**
+     * A unique identifier specific to the type of key, such as a public key or an ethereum address
+     * @example 0x8e3484687e66cdd26cf04c3647633ab4f3570148
+     */
+    get materialId() {
+        return __classPrivateFieldGet(this, _Key_data, "f").material_id;
+    }
+    /**
+     * @description Hex-encoded, serialized public key. The format used depends on the key type:
+     * - secp256k1 keys use 65-byte uncompressed SECG format
+     * - BLS keys use 48-byte compressed BLS12-381 (ZCash) format
+     * @example 0x04d2688b6bc2ce7f9879b9e745f3c4dc177908c5cef0c1b64cff19ae7ff27dee623c64fe9d9c325c7fbbc748bbd5f607ce14dd83e28ebbbb7d3e7f2ffb70a79431
+     */
+    get publicKey() {
+        return __classPrivateFieldGet(this, _Key_data, "f").public_key;
+    }
+    /**
+     * Get the cached properties of this key. The cached properties reflect the
+     * state of the last fetch or update (e.g., after awaiting `Key.enabled()`
+     * or `Key.disable()`).
+     */
+    get cached() {
+        return __classPrivateFieldGet(this, _Key_data, "f");
+    }
+    /** The type of key. */
+    async type() {
+        const data = await this.fetch();
+        return fromSchemaKeyType(data.key_type);
+    }
+    /** Is the key enabled? */
+    async enabled() {
+        const data = await this.fetch();
+        return data.enabled;
+    }
+    /** Enable the key. */
+    async enable() {
+        await this.update({ enabled: true });
+    }
+    /** Disable the key. */
+    async disable() {
+        await this.update({ enabled: false });
+    }
+    /**
+     * The list roles this key is in.
+     * @param {PageOpts} page Optional pagination options; by default, retrieves all roles this key is in.
+     * @return {Promise<KeyInRoleInfo[]>} Roles this key is in.
+     */
+    async roles(page) {
+        return await this.csc.keyRolesList(this.id, page).fetch();
+    }
+    /**
+     * Set new policy (overwriting any policies previously set for this key)
+     * @param {KeyPolicy} policy The new policy to set
+     */
+    async setPolicy(policy) {
+        await this.update({ policy: policy });
+    }
+    /**
+     * Set key metadata. The metadata must be at most 1024 characters
+     * and must match the following regex: ^[A-Za-z0-9_=+/ \-\.\,]{0,1024}$.
+     *
+     * @param {string} metadata The new metadata to set.
+     */
+    async setMetadata(metadata) {
+        await this.update({ metadata });
+    }
+    /**
+     * Append to existing key policy. This append is not atomic -- it uses {@link policy}
+     * to fetch the current policy and then {@link setPolicy} to set the policy -- and
+     * should not be used in across concurrent sessions.
+     *
+     * @param {KeyPolicy} policy The policy to append to the existing one.
+     */
+    async appendPolicy(policy) {
+        const existing = await this.policy();
+        await this.setPolicy([...existing, ...policy]);
+    }
+    /**
+     * Get the policy for the key.
+     * @return {Promise<KeyPolicy>} The policy for the key.
+     */
+    async policy() {
+        const data = await this.fetch();
+        return (data.policy ?? []);
+    }
+    /**
+     * @description Owner of the key
+     * @example User#c3b9379c-4e8c-4216-bd0a-65ace53cf98f
+     */
+    async owner() {
+        const data = await this.fetch();
+        return data.owner;
+    }
+    /**
+     * Set the owner of the key. Only the key (or org) owner can change the owner of the key.
+     * @param {string} owner The user-id of the new owner of the key.
+     */
+    async setOwner(owner) {
+        await this.update({ owner });
+    }
+    /**
+     * Delete this key.
+     */
+    async delete() {
+        await this.csc.keyDelete(this.id);
+    }
+    // --------------------------------------------------------------------------
+    // -- INTERNAL --------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    /**
+     * Create a new key.
+     *
+     * @param {CubeSignerClient} csc The CubeSigner instance to use for signing.
+     * @param {KeyInfoApi} data The JSON response from the API server.
+     * @internal
+     */
+    constructor(csc, data) {
+        /** The key information */
+        _Key_data.set(this, void 0);
+        this.csc = csc;
+        __classPrivateFieldSet(this, _Key_data, toKeyInfo(data), "f");
+    }
+    /**
+     * Update the key.
+     * @param {UpdateKeyRequest} request The JSON request to send to the API server.
+     * @return {KeyInfo} The JSON response from the API server.
+     * @internal
+     */
+    async update(request) {
+        __classPrivateFieldSet(this, _Key_data, await this.csc.keyUpdate(this.id, request).then(toKeyInfo), "f");
+        return __classPrivateFieldGet(this, _Key_data, "f");
+    }
+    /**
+     * Fetch the key information.
+     *
+     * @return {KeyInfo} The key information.
+     * @internal
+     */
+    async fetch() {
+        __classPrivateFieldSet(this, _Key_data, await this.csc.keyGet(this.id).then(toKeyInfo), "f");
+        return __classPrivateFieldGet(this, _Key_data, "f");
+    }
+}
+_Key_data = new WeakMap();
+/**
+ * Convert a schema key type to a key type.
+ *
+ * @param {SchemaKeyType} ty The schema key type.
+ * @return {KeyType} The key type.
+ * @internal
+ */
+export function fromSchemaKeyType(ty) {
+    switch (ty) {
+        case "SecpEthAddr":
+            return Secp256k1.Evm;
+        case "SecpBtc":
+            return Secp256k1.Btc;
+        case "SecpBtcTest":
+            return Secp256k1.BtcTest;
+        case "SecpAvaAddr":
+            return Secp256k1.Ava;
+        case "SecpAvaTestAddr":
+            return Secp256k1.AvaTest;
+        case "BlsPub":
+            return Bls.Eth2Deposited;
+        case "BlsInactive":
+            return Bls.Eth2Inactive;
+        case "Ed25519SolanaAddr":
+            return Ed25519.Solana;
+        case "Ed25519SuiAddr":
+            return Ed25519.Sui;
+        case "Ed25519AptosAddr":
+            return Ed25519.Aptos;
+        case "Ed25519CardanoAddrVk":
+            return Ed25519.Cardano;
+        case "Ed25519StellarAddr":
+            return Ed25519.Stellar;
+        case "Stark":
+            return Stark;
+        case "Mnemonic":
+            return Mnemonic;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key.js","sourceRoot":"","sources":["../../../src/key.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeyPolicy } from \"./role\";\nimport { PageOpts } from \"./paginator\";\nimport {\n  KeyInfoApi,\n  KeyTypeApi,\n  UpdateKeyRequest,\n  SchemaKeyType,\n  KeyInRoleInfo,\n} from \"./schema_types\";\nimport { CubeSignerClient } from \"./client\";\n\n/** Secp256k1 key type */\nexport enum Secp256k1 {\n  Evm = \"SecpEthAddr\", // eslint-disable-line no-unused-vars\n  Btc = \"SecpBtc\", // eslint-disable-line no-unused-vars\n  BtcTest = \"SecpBtcTest\", // eslint-disable-line no-unused-vars\n  Ava = \"SecpAvaAddr\", // eslint-disable-line no-unused-vars\n  AvaTest = \"SecpAvaTestAddr\", // eslint-disable-line no-unused-vars\n}\n\n/** BLS key type */\nexport enum Bls {\n  Eth2Deposited = \"BlsPub\", // eslint-disable-line no-unused-vars\n  Eth2Inactive = \"BlsInactive\", // eslint-disable-line no-unused-vars\n}\n\n/** Ed25519 key type */\nexport enum Ed25519 {\n  Solana = \"Ed25519SolanaAddr\", // eslint-disable-line no-unused-vars\n  Sui = \"Ed25519SuiAddr\", // eslint-disable-line no-unused-vars\n  Aptos = \"Ed25519AptosAddr\", // eslint-disable-line no-unused-vars\n  Cardano = \"Ed25519CardanoAddrVk\", // eslint-disable-line no-unused-vars\n  Stellar = \"Ed25519StellarAddr\", // eslint-disable-line no-unused-vars\n}\n\n/** Mnemonic key type */\nexport const Mnemonic = \"Mnemonic\" as const;\nexport type Mnemonic = typeof Mnemonic;\n\n/** Stark key type */\nexport const Stark = \"Stark\" as const;\nexport type Stark = typeof Stark;\n\n/** Key type */\nexport type KeyType = Secp256k1 | Bls | Ed25519 | Mnemonic | Stark;\n\n/** Additional properties (for backward compatibility) */\nexport interface KeyInfo extends KeyInfoApi {\n  /** Alias for key_id */\n  id: string;\n  /** Alias for key_type */\n  type: KeyTypeApi;\n  /** Alias for material_id */\n  materialId: string;\n  /** Alias for public_key */\n  publicKey: string;\n}\n\n/**\n * Define some additional (backward compatibility) properties\n * on a `KeyInfoApi` object returned from the remote end.\n *\n * @param {KeyInfoApi} key Key information returned from the remote end\n * @return {KeyInfo} The same `key` object extended with some derived properties.\n */\nexport function toKeyInfo(key: KeyInfoApi): KeyInfo {\n  return {\n    ...key,\n    id: key.key_id,\n    type: key.key_type,\n    publicKey: key.public_key,\n    materialId: key.material_id,\n  };\n}\n\n/**\n * A representation of a signing key.\n */\nexport class Key {\n  /** The CubeSigner instance that this key is associated with */\n  protected readonly csc: CubeSignerClient;\n  /** The key information */\n  #data: KeyInfo;\n\n  /** The organization that this key is in */\n  get orgId() {\n    return this.csc.orgId;\n  }\n\n  /**\n   * The id of the key: \"Key#\" followed by a unique identifier specific to\n   * the type of key (such as a public key for BLS or an ethereum address for Secp)\n   * @example Key#0x8e3484687e66cdd26cf04c3647633ab4f3570148\n   */\n  get id(): string {\n    return this.#data.key_id;\n  }\n\n  /**\n   * A unique identifier specific to the type of key, such as a public key or an ethereum address\n   * @example 0x8e3484687e66cdd26cf04c3647633ab4f3570148\n   */\n  get materialId(): string {\n    return this.#data.material_id;\n  }\n\n  /**\n   * @description Hex-encoded, serialized public key. The format used depends on the key type:\n   * - secp256k1 keys use 65-byte uncompressed SECG format\n   * - BLS keys use 48-byte compressed BLS12-381 (ZCash) format\n   * @example 0x04d2688b6bc2ce7f9879b9e745f3c4dc177908c5cef0c1b64cff19ae7ff27dee623c64fe9d9c325c7fbbc748bbd5f607ce14dd83e28ebbbb7d3e7f2ffb70a79431\n   */\n  get publicKey(): string {\n    return this.#data.public_key;\n  }\n\n  /**\n   * Get the cached properties of this key. The cached properties reflect the\n   * state of the last fetch or update (e.g., after awaiting `Key.enabled()`\n   * or `Key.disable()`).\n   */\n  get cached(): KeyInfo {\n    return this.#data;\n  }\n\n  /** The type of key. */\n  async type(): Promise<KeyType> {\n    const data = await this.fetch();\n    return fromSchemaKeyType(data.key_type);\n  }\n\n  /** Is the key enabled? */\n  async enabled(): Promise<boolean> {\n    const data = await this.fetch();\n    return data.enabled;\n  }\n\n  /** Enable the key. */\n  async enable() {\n    await this.update({ enabled: true });\n  }\n\n  /** Disable the key. */\n  async disable() {\n    await this.update({ enabled: false });\n  }\n\n  /**\n   * The list roles this key is in.\n   * @param {PageOpts} page Optional pagination options; by default, retrieves all roles this key is in.\n   * @return {Promise<KeyInRoleInfo[]>} Roles this key is in.\n   */\n  async roles(page?: PageOpts): Promise<KeyInRoleInfo[]> {\n    return await this.csc.keyRolesList(this.id, page).fetch();\n  }\n\n  /**\n   * Set new policy (overwriting any policies previously set for this key)\n   * @param {KeyPolicy} policy The new policy to set\n   */\n  async setPolicy(policy: KeyPolicy) {\n    await this.update({ policy: policy as unknown as Record<string, never>[] });\n  }\n\n  /**\n   * Set key metadata. The metadata must be at most 1024 characters\n   * and must match the following regex: ^[A-Za-z0-9_=+/ \\-\\.\\,]{0,1024}$.\n   *\n   * @param {string} metadata The new metadata to set.\n   */\n  async setMetadata(metadata: string) {\n    await this.update({ metadata });\n  }\n\n  /**\n   * Append to existing key policy. This append is not atomic -- it uses {@link policy}\n   * to fetch the current policy and then {@link setPolicy} to set the policy -- and\n   * should not be used in across concurrent sessions.\n   *\n   * @param {KeyPolicy} policy The policy to append to the existing one.\n   */\n  async appendPolicy(policy: KeyPolicy) {\n    const existing = await this.policy();\n    await this.setPolicy([...existing, ...policy]);\n  }\n\n  /**\n   * Get the policy for the key.\n   * @return {Promise<KeyPolicy>} The policy for the key.\n   */\n  async policy(): Promise<KeyPolicy> {\n    const data = await this.fetch();\n    return (data.policy ?? []) as unknown as KeyPolicy;\n  }\n\n  /**\n   * @description Owner of the key\n   * @example User#c3b9379c-4e8c-4216-bd0a-65ace53cf98f\n   */\n  async owner(): Promise<string> {\n    const data = await this.fetch();\n    return data.owner;\n  }\n\n  /**\n   * Set the owner of the key. Only the key (or org) owner can change the owner of the key.\n   * @param {string} owner The user-id of the new owner of the key.\n   */\n  async setOwner(owner: string) {\n    await this.update({ owner });\n  }\n\n  /**\n   * Delete this key.\n   */\n  async delete() {\n    await this.csc.keyDelete(this.id);\n  }\n\n  // --------------------------------------------------------------------------\n  // -- INTERNAL --------------------------------------------------------------\n  // --------------------------------------------------------------------------\n\n  /**\n   * Create a new key.\n   *\n   * @param {CubeSignerClient} csc The CubeSigner instance to use for signing.\n   * @param {KeyInfoApi} data The JSON response from the API server.\n   * @internal\n   */\n  constructor(csc: CubeSignerClient, data: KeyInfoApi) {\n    this.csc = csc;\n    this.#data = toKeyInfo(data);\n  }\n\n  /**\n   * Update the key.\n   * @param {UpdateKeyRequest} request The JSON request to send to the API server.\n   * @return {KeyInfo} The JSON response from the API server.\n   * @internal\n   */\n  private async update(request: UpdateKeyRequest): Promise<KeyInfo> {\n    this.#data = await this.csc.keyUpdate(this.id, request).then(toKeyInfo);\n    return this.#data;\n  }\n\n  /**\n   * Fetch the key information.\n   *\n   * @return {KeyInfo} The key information.\n   * @internal\n   */\n  private async fetch(): Promise<KeyInfo> {\n    this.#data = await this.csc.keyGet(this.id).then(toKeyInfo);\n    return this.#data;\n  }\n}\n\n/**\n * Convert a schema key type to a key type.\n *\n * @param {SchemaKeyType} ty The schema key type.\n * @return {KeyType} The key type.\n * @internal\n */\nexport function fromSchemaKeyType(ty: SchemaKeyType): KeyType {\n  switch (ty) {\n    case \"SecpEthAddr\":\n      return Secp256k1.Evm;\n    case \"SecpBtc\":\n      return Secp256k1.Btc;\n    case \"SecpBtcTest\":\n      return Secp256k1.BtcTest;\n    case \"SecpAvaAddr\":\n      return Secp256k1.Ava;\n    case \"SecpAvaTestAddr\":\n      return Secp256k1.AvaTest;\n    case \"BlsPub\":\n      return Bls.Eth2Deposited;\n    case \"BlsInactive\":\n      return Bls.Eth2Inactive;\n    case \"Ed25519SolanaAddr\":\n      return Ed25519.Solana;\n    case \"Ed25519SuiAddr\":\n      return Ed25519.Sui;\n    case \"Ed25519AptosAddr\":\n      return Ed25519.Aptos;\n    case \"Ed25519CardanoAddrVk\":\n      return Ed25519.Cardano;\n    case \"Ed25519StellarAddr\":\n      return Ed25519.Stellar;\n    case \"Stark\":\n      return Stark;\n    case \"Mnemonic\":\n      return Mnemonic;\n  }\n}\n"]}

package/dist/esm/src/mfa.d.ts

@@ -0,0 +1,97 @@
+import { ApiAddFidoChallenge, ApiMfaFidoChallenge, MfaRequestInfo, MfaVote, TotpInfo } from "./schema_types";
+import { CubeSignerApi } from "./api";
+/** MFA receipt */
+export interface MfaReceipt {
+    /** MFA request ID */
+    mfaId: string;
+    /** Corresponding org ID */
+    mfaOrgId: string;
+    /** MFA confirmation code */
+    mfaConf: string;
+}
+/** TOTP challenge that must be answered before user's TOTP is updated */
+export declare class TotpChallenge {
+    #private;
+    /** The id of the challenge */
+    get totpId(): string;
+    /** The new TOTP configuration */
+    get totpUrl(): string;
+    /**
+     * @param {CubeSignerApi} api Used when answering the challenge.
+     * @param {TotpInfo} totpInfo TOTP challenge information.
+     */
+    constructor(api: CubeSignerApi, totpInfo: TotpInfo);
+    /**
+     * Answer the challenge with the code that corresponds to `this.totpUrl`.
+     * @param {string} code 6-digit code that corresponds to `this.totpUrl`.
+     */
+    answer(code: string): Promise<void>;
+}
+/**
+ * Returned after creating a request to add a new FIDO device.
+ * Provides some helper methods for answering this challenge.
+ */
+export declare class AddFidoChallenge {
+    #private;
+    readonly challengeId: string;
+    readonly options: any;
+    /**
+     * Constructor
+     * @param {CubeSignerApi} api The API client used to request to add a FIDO device
+     * @param {ApiAddFidoChallenge} challenge The challenge returned by the remote end.
+     */
+    constructor(api: CubeSignerApi, challenge: ApiAddFidoChallenge);
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to create a credential
+     * based on the the public key credential creation options from this challenge.
+     */
+    createCredentialAndAnswer(): Promise<void>;
+    /**
+     * Answers this challenge using a given credential `cred`;
+     * the credential should be obtained by calling
+     *
+     * ```
+     * const cred = await navigator.credentials.create({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `create` method
+     *                   based on the public key creation options from this challenge.
+     */
+    answer(cred: any): Promise<void>;
+}
+/**
+ * Returned after initiating MFA approval using FIDO.
+ * Provides some helper methods for answering this challenge.
+ */
+export declare class MfaFidoChallenge {
+    #private;
+    readonly mfaId: string;
+    readonly challengeId: string;
+    readonly options: any;
+    /**
+     * @param {CubeSignerApi} api The API client used to initiate MFA approval using FIDO
+     * @param {string} mfaId The MFA request id.
+     * @param {ApiMfaFidoChallenge} challenge The challenge returned by the remote end
+     */
+    constructor(api: CubeSignerApi, mfaId: string, challenge: ApiMfaFidoChallenge);
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to get a credential
+     * based on the the public key credential request options from this challenge.
+     *
+     * @param {MfaVote} vote Approve or reject the MFA request. Defaults to "approve".
+     */
+    createCredentialAndAnswer(vote?: MfaVote): Promise<MfaRequestInfo>;
+    /**
+     * Answers this challenge using a given credential `cred`.
+     * To obtain this credential, for example, call
+     *
+     * ```
+     * const cred = await navigator.credentials.get({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `get` method
+     *                   based on the public key credential request options from this challenge.
+     * @param {MfaVote} vote Approve or reject. Defaults to "approve".
+     */
+    answer(cred: any, vote?: MfaVote): Promise<MfaRequestInfo>;
+}

package/dist/esm/src/mfa.js

@@ -0,0 +1,166 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _TotpChallenge_api, _TotpChallenge_totpInfo, _AddFidoChallenge_api, _MfaFidoChallenge_api;
+import { decodeBase64Url, encodeToBase64Url } from "./util";
+/** TOTP challenge that must be answered before user's TOTP is updated */
+export class TotpChallenge {
+    /** The id of the challenge */
+    get totpId() {
+        return __classPrivateFieldGet(this, _TotpChallenge_totpInfo, "f").totp_id;
+    }
+    /** The new TOTP configuration */
+    get totpUrl() {
+        return __classPrivateFieldGet(this, _TotpChallenge_totpInfo, "f").totp_url;
+    }
+    /**
+     * @param {CubeSignerApi} api Used when answering the challenge.
+     * @param {TotpInfo} totpInfo TOTP challenge information.
+     */
+    constructor(api, totpInfo) {
+        _TotpChallenge_api.set(this, void 0);
+        _TotpChallenge_totpInfo.set(this, void 0);
+        __classPrivateFieldSet(this, _TotpChallenge_api, api, "f");
+        __classPrivateFieldSet(this, _TotpChallenge_totpInfo, totpInfo, "f");
+    }
+    /**
+     * Answer the challenge with the code that corresponds to `this.totpUrl`.
+     * @param {string} code 6-digit code that corresponds to `this.totpUrl`.
+     */
+    async answer(code) {
+        if (!/^\d{1,6}$/.test(code)) {
+            throw new Error(`Invalid TOTP code: ${code}; it must be a 6-digit string`);
+        }
+        await __classPrivateFieldGet(this, _TotpChallenge_api, "f").userTotpResetComplete(this.totpId, code);
+    }
+}
+_TotpChallenge_api = new WeakMap(), _TotpChallenge_totpInfo = new WeakMap();
+/**
+ * Returned after creating a request to add a new FIDO device.
+ * Provides some helper methods for answering this challenge.
+ */
+export class AddFidoChallenge {
+    /**
+     * Constructor
+     * @param {CubeSignerApi} api The API client used to request to add a FIDO device
+     * @param {ApiAddFidoChallenge} challenge The challenge returned by the remote end.
+     */
+    constructor(api, challenge) {
+        _AddFidoChallenge_api.set(this, void 0);
+        __classPrivateFieldSet(this, _AddFidoChallenge_api, api, "f");
+        this.challengeId = challenge.challenge_id;
+        // fix options returned from the server: rename fields and decode base64 fields to uint8[]
+        this.options = {
+            ...challenge.options,
+            challenge: decodeBase64Url(challenge.options.challenge),
+        };
+        if (challenge.options.user) {
+            this.options.user.id = decodeBase64Url(challenge.options.user.id);
+        }
+        for (const credential of this.options.excludeCredentials ?? []) {
+            credential.id = decodeBase64Url(credential.id);
+        }
+    }
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to create a credential
+     * based on the the public key credential creation options from this challenge.
+     */
+    async createCredentialAndAnswer() {
+        const cred = await navigator.credentials.create({ publicKey: this.options });
+        await this.answer(cred);
+    }
+    /**
+     * Answers this challenge using a given credential `cred`;
+     * the credential should be obtained by calling
+     *
+     * ```
+     * const cred = await navigator.credentials.create({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `create` method
+     *                   based on the public key creation options from this challenge.
+     */
+    async answer(cred) {
+        const answer = {
+            id: cred.id,
+            response: {
+                clientDataJSON: encodeToBase64Url(cred.response.clientDataJSON),
+                attestationObject: encodeToBase64Url(cred.response.attestationObject),
+            },
+        };
+        await __classPrivateFieldGet(this, _AddFidoChallenge_api, "f").userFidoRegisterComplete(this.challengeId, answer);
+    }
+}
+_AddFidoChallenge_api = new WeakMap();
+/**
+ * Returned after initiating MFA approval using FIDO.
+ * Provides some helper methods for answering this challenge.
+ */
+export class MfaFidoChallenge {
+    /**
+     * @param {CubeSignerApi} api The API client used to initiate MFA approval using FIDO
+     * @param {string} mfaId The MFA request id.
+     * @param {ApiMfaFidoChallenge} challenge The challenge returned by the remote end
+     */
+    constructor(api, mfaId, challenge) {
+        _MfaFidoChallenge_api.set(this, void 0);
+        __classPrivateFieldSet(this, _MfaFidoChallenge_api, api, "f");
+        this.mfaId = mfaId;
+        this.challengeId = challenge.challenge_id;
+        // fix options returned from the server: rename fields and decode base64 fields into uint8[]
+        this.options = {
+            ...challenge.options,
+            challenge: decodeBase64Url(challenge.options.challenge),
+        };
+        for (const credential of this.options.allowCredentials ?? []) {
+            credential.id = decodeBase64Url(credential.id);
+            if (credential.transports === null) {
+                delete credential.transports;
+            }
+        }
+    }
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to get a credential
+     * based on the the public key credential request options from this challenge.
+     *
+     * @param {MfaVote} vote Approve or reject the MFA request. Defaults to "approve".
+     */
+    async createCredentialAndAnswer(vote) {
+        const cred = await navigator.credentials.get({ publicKey: this.options });
+        return await this.answer(cred, vote);
+    }
+    /**
+     * Answers this challenge using a given credential `cred`.
+     * To obtain this credential, for example, call
+     *
+     * ```
+     * const cred = await navigator.credentials.get({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `get` method
+     *                   based on the public key credential request options from this challenge.
+     * @param {MfaVote} vote Approve or reject. Defaults to "approve".
+     */
+    async answer(cred, vote = "approve") {
+        const answer = {
+            id: cred.id,
+            response: {
+                clientDataJSON: encodeToBase64Url(cred.response.clientDataJSON),
+                authenticatorData: encodeToBase64Url(cred.response.authenticatorData),
+                signature: encodeToBase64Url(cred.response.signature),
+            },
+        };
+        return await __classPrivateFieldGet(this, _MfaFidoChallenge_api, "f").mfaVoteFidoComplete(this.mfaId, vote, this.challengeId, answer);
+    }
+}
+_MfaFidoChallenge_api = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mfa.js","sourceRoot":"","sources":["../../../src/mfa.ts"],"names":[],"mappings":"AAAA,uDAAuD;;;;;;;;;;;;;AAUvD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAa5D,yEAAyE;AACzE,MAAM,OAAO,aAAa;IAIxB,8BAA8B;IAC9B,IAAI,MAAM;QACR,OAAO,uBAAA,IAAI,+BAAU,CAAC,OAAO,CAAC;IAChC,CAAC;IAED,iCAAiC;IACjC,IAAI,OAAO;QACT,OAAO,uBAAA,IAAI,+BAAU,CAAC,QAAQ,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,YAAY,GAAkB,EAAE,QAAkB;QAjBzC,qCAAoB;QACpB,0CAAoB;QAiB3B,uBAAA,IAAI,sBAAQ,GAAG,MAAA,CAAC;QAChB,uBAAA,IAAI,2BAAa,QAAQ,MAAA,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,MAAM,CAAC,IAAY;QACvB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,sBAAsB,IAAI,+BAA+B,CAAC,CAAC;QAC7E,CAAC;QAED,MAAM,uBAAA,IAAI,0BAAK,CAAC,qBAAqB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;CACF;;AAED;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IAK3B;;;;OAIG;IACH,YAAY,GAAkB,EAAE,SAA8B;QATrD,wCAAoB;QAU3B,uBAAA,IAAI,yBAAQ,GAAG,MAAA,CAAC;QAChB,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC,YAAY,CAAC;QAE1C,0FAA0F;QAC1F,IAAI,CAAC,OAAO,GAAG;YACb,GAAG,SAAS,CAAC,OAAO;YACpB,SAAS,EAAE,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC;SACxD,CAAC;QAEF,IAAI,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YAC3B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACpE,CAAC;QAED,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,kBAAkB,IAAI,EAAE,EAAE,CAAC;YAC/D,UAAU,CAAC,EAAE,GAAG,eAAe,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,yBAAyB;QAC7B,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAC7E,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,MAAM,CAAC,IAAS;QACpB,MAAM,MAAM,GAAwB;YAClC,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,QAAQ,EAAE;gBACR,cAAc,EAAE,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;gBAC/D,iBAAiB,EAAE,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC;aACtE;SACF,CAAC;QACF,MAAM,uBAAA,IAAI,6BAAK,CAAC,wBAAwB,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IACrE,CAAC;CACF;;AAED;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IAM3B;;;;OAIG;IACH,YAAY,GAAkB,EAAE,KAAa,EAAE,SAA8B;QAVpE,wCAAoB;QAW3B,uBAAA,IAAI,yBAAQ,GAAG,MAAA,CAAC;QAChB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC,YAAY,CAAC;QAE1C,4FAA4F;QAC5F,IAAI,CAAC,OAAO,GAAG;YACb,GAAG,SAAS,CAAC,OAAO;YACpB,SAAS,EAAE,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC;SACxD,CAAC;QAEF,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,gBAAgB,IAAI,EAAE,EAAE,CAAC;YAC7D,UAAU,CAAC,EAAE,GAAG,eAAe,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YAC/C,IAAI,UAAU,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;gBACnC,OAAO,UAAU,CAAC,UAAU,CAAC;YAC/B,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,yBAAyB,CAAC,IAAc;QAC5C,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAC1E,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,MAAM,CAAC,IAAS,EAAE,OAAgB,SAAS;QAC/C,MAAM,MAAM,GAAwB;YAClC,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,QAAQ,EAAE;gBACR,cAAc,EAAE,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;gBAC/D,iBAAiB,EAAE,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC;gBACrE,SAAS,EAAE,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;aACtD;SACF,CAAC;QACF,OAAO,MAAM,uBAAA,IAAI,6BAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IACzF,CAAC;CACF","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport {\n  ApiAddFidoChallenge,\n  ApiMfaFidoChallenge,\n  MfaRequestInfo,\n  MfaVote,\n  PublicKeyCredential,\n  TotpInfo,\n} from \"./schema_types\";\nimport { decodeBase64Url, encodeToBase64Url } from \"./util\";\nimport { CubeSignerApi } from \"./api\";\n\n/** MFA receipt */\nexport interface MfaReceipt {\n  /** MFA request ID */\n  mfaId: string;\n  /** Corresponding org ID */\n  mfaOrgId: string;\n  /** MFA confirmation code */\n  mfaConf: string;\n}\n\n/** TOTP challenge that must be answered before user's TOTP is updated */\nexport class TotpChallenge {\n  readonly #api: CubeSignerApi;\n  readonly #totpInfo: TotpInfo;\n\n  /** The id of the challenge */\n  get totpId() {\n    return this.#totpInfo.totp_id;\n  }\n\n  /** The new TOTP configuration */\n  get totpUrl() {\n    return this.#totpInfo.totp_url;\n  }\n\n  /**\n   * @param {CubeSignerApi} api Used when answering the challenge.\n   * @param {TotpInfo} totpInfo TOTP challenge information.\n   */\n  constructor(api: CubeSignerApi, totpInfo: TotpInfo) {\n    this.#api = api;\n    this.#totpInfo = totpInfo;\n  }\n\n  /**\n   * Answer the challenge with the code that corresponds to `this.totpUrl`.\n   * @param {string} code 6-digit code that corresponds to `this.totpUrl`.\n   */\n  async answer(code: string) {\n    if (!/^\\d{1,6}$/.test(code)) {\n      throw new Error(`Invalid TOTP code: ${code}; it must be a 6-digit string`);\n    }\n\n    await this.#api.userTotpResetComplete(this.totpId, code);\n  }\n}\n\n/**\n * Returned after creating a request to add a new FIDO device.\n * Provides some helper methods for answering this challenge.\n */\nexport class AddFidoChallenge {\n  readonly #api: CubeSignerApi;\n  readonly challengeId: string;\n  readonly options: any;\n\n  /**\n   * Constructor\n   * @param {CubeSignerApi} api The API client used to request to add a FIDO device\n   * @param {ApiAddFidoChallenge} challenge The challenge returned by the remote end.\n   */\n  constructor(api: CubeSignerApi, challenge: ApiAddFidoChallenge) {\n    this.#api = api;\n    this.challengeId = challenge.challenge_id;\n\n    // fix options returned from the server: rename fields and decode base64 fields to uint8[]\n    this.options = {\n      ...challenge.options,\n      challenge: decodeBase64Url(challenge.options.challenge),\n    };\n\n    if (challenge.options.user) {\n      this.options.user.id = decodeBase64Url(challenge.options.user.id);\n    }\n\n    for (const credential of this.options.excludeCredentials ?? []) {\n      credential.id = decodeBase64Url(credential.id);\n    }\n  }\n\n  /**\n   * Answers this challenge by using the `CredentialsContainer` API to create a credential\n   * based on the the public key credential creation options from this challenge.\n   */\n  async createCredentialAndAnswer() {\n    const cred = await navigator.credentials.create({ publicKey: this.options });\n    await this.answer(cred);\n  }\n\n  /**\n   * Answers this challenge using a given credential `cred`;\n   * the credential should be obtained by calling\n   *\n   * ```\n   * const cred = await navigator.credentials.create({ publicKey: this.options });\n   * ```\n   *\n   * @param {any} cred Credential created by calling the `CredentialContainer`'s `create` method\n   *                   based on the public key creation options from this challenge.\n   */\n  async answer(cred: any) {\n    const answer = <PublicKeyCredential>{\n      id: cred.id,\n      response: {\n        clientDataJSON: encodeToBase64Url(cred.response.clientDataJSON),\n        attestationObject: encodeToBase64Url(cred.response.attestationObject),\n      },\n    };\n    await this.#api.userFidoRegisterComplete(this.challengeId, answer);\n  }\n}\n\n/**\n * Returned after initiating MFA approval using FIDO.\n * Provides some helper methods for answering this challenge.\n */\nexport class MfaFidoChallenge {\n  readonly #api: CubeSignerApi;\n  readonly mfaId: string;\n  readonly challengeId: string;\n  readonly options: any;\n\n  /**\n   * @param {CubeSignerApi} api The API client used to initiate MFA approval using FIDO\n   * @param {string} mfaId The MFA request id.\n   * @param {ApiMfaFidoChallenge} challenge The challenge returned by the remote end\n   */\n  constructor(api: CubeSignerApi, mfaId: string, challenge: ApiMfaFidoChallenge) {\n    this.#api = api;\n    this.mfaId = mfaId;\n    this.challengeId = challenge.challenge_id;\n\n    // fix options returned from the server: rename fields and decode base64 fields into uint8[]\n    this.options = {\n      ...challenge.options,\n      challenge: decodeBase64Url(challenge.options.challenge),\n    };\n\n    for (const credential of this.options.allowCredentials ?? []) {\n      credential.id = decodeBase64Url(credential.id);\n      if (credential.transports === null) {\n        delete credential.transports;\n      }\n    }\n  }\n\n  /**\n   * Answers this challenge by using the `CredentialsContainer` API to get a credential\n   * based on the the public key credential request options from this challenge.\n   *\n   * @param {MfaVote} vote Approve or reject the MFA request. Defaults to \"approve\".\n   */\n  async createCredentialAndAnswer(vote?: MfaVote): Promise<MfaRequestInfo> {\n    const cred = await navigator.credentials.get({ publicKey: this.options });\n    return await this.answer(cred, vote);\n  }\n\n  /**\n   * Answers this challenge using a given credential `cred`.\n   * To obtain this credential, for example, call\n   *\n   * ```\n   * const cred = await navigator.credentials.get({ publicKey: this.options });\n   * ```\n   *\n   * @param {any} cred Credential created by calling the `CredentialContainer`'s `get` method\n   *                   based on the public key credential request options from this challenge.\n   * @param {MfaVote} vote Approve or reject. Defaults to \"approve\".\n   */\n  async answer(cred: any, vote: MfaVote = \"approve\"): Promise<MfaRequestInfo> {\n    const answer = <PublicKeyCredential>{\n      id: cred.id,\n      response: {\n        clientDataJSON: encodeToBase64Url(cred.response.clientDataJSON),\n        authenticatorData: encodeToBase64Url(cred.response.authenticatorData),\n        signature: encodeToBase64Url(cred.response.signature),\n      },\n    };\n    return await this.#api.mfaVoteFidoComplete(this.mfaId, vote, this.challengeId, answer);\n  }\n}\n"]}