@cubist-labs/cubesigner-sdk 0.3.11 → 0.3.19

package/dist/cjs/src/client.d.ts

@@ -127,6 +127,8 @@ export declare class CubeSignerClient extends CubeSignerApi {
     get users(): () => Promise<{
         email: string;
         id: string;
+        membership: "Alien" | "Member" | "Owner";
+        name?: string | null | undefined;
     }[]>;
     /**
      * Obtain information about the current user.
@@ -217,6 +219,8 @@ export declare class CubeSignerClient extends CubeSignerApi {
     get listUsers(): () => Promise<{
         email: string;
         id: string;
+        membership: "Alien" | "Member" | "Owner";
+        name?: string | null | undefined;
     }[]>;
     /**
      * Approve a pending MFA request using the current session.

package/dist/cjs/src/error.d.ts

@@ -14,6 +14,8 @@ export declare class ErrResponse extends Error {
     readonly url?: string;
     /** CubeSigner error code */
     readonly errorCode?: CsErrCode;
+    /** Request ID */
+    readonly requestId?: string;
     /**
      * @param {Partial<ErrResponse>} init Initializer
      */

package/dist/cjs/src/error.js

@@ -96,4 +96,4 @@ const invalidSessionErrorCodes = [
     "SessionRefreshTokenExpired",
     "SessionPossiblyStolenToken",
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/src/evm/index.d.ts

@@ -0,0 +1,74 @@
+import { CubeSignerResponse, KeyInfo, Eip191SignRequest, Eip712SignRequest, EvmSignRequest, MfaRequestInfo, SignerSession, EvmSignResponse } from "../index";
+/** Options for the signer */
+export interface EvmSignerOptions {
+    /**
+     * The function to call when MFA information is retrieved. If this callback
+     * throws, no transaction is broadcast.
+     */
+    onMfaPoll?: (arg0: MfaRequestInfo) => void;
+    /**
+     * The amount of time (in milliseconds) to wait between checks for MFA
+     * updates. Default is 1000ms
+     */
+    mfaPollIntervalMs?: number;
+}
+/**
+ * Signer using CubeSigner, with basic MFA handling.
+ * @internal
+ */
+export declare class EvmSigner {
+    #private;
+    /** Returns the key address (NOT checksummed) */
+    get address(): string;
+    /** Returns the underlying signer session */
+    get signerSession(): SignerSession;
+    /** Options */
+    get options(): EvmSignerOptions;
+    /**
+     * Create new Signer instance
+     * @param {KeyInfo | string} address The key or the eth address of the account to use.
+     * @param {SignerSession} signerSession The underlying Signer session.
+     * @param {EvmSignerOptions} options The options to use for the Signer instance
+     */
+    constructor(address: KeyInfo | string, signerSession: SignerSession, options?: EvmSignerOptions);
+    /**
+     * Sign a transaction. This method will block if the key requires MFA approval.
+     * @param {EvmSignRequest} req The sign request.
+     * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.
+     */
+    signTransaction(req: EvmSignRequest): Promise<string>;
+    /**
+     * Sign a transaction. This method does not block if the key requires MFA approval, i.e.,
+     * the returned {@link CubeSignerResponse} object either contains a signature or indicates
+     * that MFA is required.
+     *
+     * @param {EvmSignRequest} req The transaction to sign.
+     * @return {CubeSignerResponse<EvmSignResponse>} The response from the CubeSigner remote end.
+     */
+    signEvm(req: EvmSignRequest): Promise<CubeSignerResponse<EvmSignResponse>>;
+    /**
+     * Signs EIP-712 typed data. This uses CubeSigner's EIP-712 signing endpoint.
+     * The key (for this session) must have the `"AllowRawBlobSigning"` or
+     * `"AllowEip712Signing"` policy attached.
+     * @param {Eip712SignRequest} req The EIP712 sign request.
+     * @return {Promise<string>} The signature.
+     */
+    signEip712(req: Eip712SignRequest): Promise<string>;
+    /**
+     * Signs arbitrary messages. This uses CubeSigner's EIP-191 signing endpoint.
+     * The key (for this session) must have the `"AllowRawBlobSigning"` or
+     * `"AllowEip191Signing"` policy attached.
+     * @param {Eip191SignRequest} req The request to sign.
+     * @return {Promise<string>} The signature.
+     */
+    signEip191(req: Eip191SignRequest): Promise<string>;
+    /** @return {KeyInfo} The key corresponding to this address */
+    key(): Promise<KeyInfo>;
+    /**
+     * Sign a transaction from an approved MFA request. The MFA request contains
+     * information about the approved signing request, which this method will execute.
+     * @param {MfaRequestInfo} mfaInfo The approved MFA request.
+     * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.
+     */
+    signTransactionMfaApproved(mfaInfo: MfaRequestInfo): Promise<string>;
+}

package/dist/cjs/src/evm/index.js

@@ -0,0 +1,165 @@
+"use strict";
+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 _EvmSigner_instances, _EvmSigner_address, _EvmSigner_key, _EvmSigner_signerSession, _EvmSigner_options, _EvmSigner_handleMfa;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmSigner = void 0;
+/**
+ * Signer using CubeSigner, with basic MFA handling.
+ * @internal
+ */
+class EvmSigner {
+    /** Returns the key address (NOT checksummed) */
+    get address() {
+        return __classPrivateFieldGet(this, _EvmSigner_address, "f");
+    }
+    /** Returns the underlying signer session */
+    get signerSession() {
+        return __classPrivateFieldGet(this, _EvmSigner_signerSession, "f");
+    }
+    /** Options */
+    get options() {
+        return __classPrivateFieldGet(this, _EvmSigner_options, "f");
+    }
+    /**
+     * Create new Signer instance
+     * @param {KeyInfo | string} address The key or the eth address of the account to use.
+     * @param {SignerSession} signerSession The underlying Signer session.
+     * @param {EvmSignerOptions} options The options to use for the Signer instance
+     */
+    constructor(address, signerSession, options) {
+        _EvmSigner_instances.add(this);
+        /** The address of the account */
+        _EvmSigner_address.set(this, void 0);
+        /** The key to use for signing */
+        _EvmSigner_key.set(this, void 0);
+        /** The underlying session */
+        _EvmSigner_signerSession.set(this, void 0);
+        /** Options */
+        _EvmSigner_options.set(this, void 0);
+        if (typeof address === "string") {
+            __classPrivateFieldSet(this, _EvmSigner_address, address, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _EvmSigner_address, address.materialId, "f");
+            __classPrivateFieldSet(this, _EvmSigner_key, address, "f");
+        }
+        __classPrivateFieldSet(this, _EvmSigner_signerSession, signerSession, "f");
+        __classPrivateFieldSet(this, _EvmSigner_options, {
+            onMfaPoll: options?.onMfaPoll,
+            mfaPollIntervalMs: options?.mfaPollIntervalMs ?? 1000,
+        }, "f");
+    }
+    /**
+     * Sign a transaction. This method will block if the key requires MFA approval.
+     * @param {EvmSignRequest} req The sign request.
+     * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.
+     */
+    async signTransaction(req) {
+        const res = await this.signEvm(req);
+        const data = await __classPrivateFieldGet(this, _EvmSigner_instances, "m", _EvmSigner_handleMfa).call(this, res);
+        return data.rlp_signed_tx;
+    }
+    /**
+     * Sign a transaction. This method does not block if the key requires MFA approval, i.e.,
+     * the returned {@link CubeSignerResponse} object either contains a signature or indicates
+     * that MFA is required.
+     *
+     * @param {EvmSignRequest} req The transaction to sign.
+     * @return {CubeSignerResponse<EvmSignResponse>} The response from the CubeSigner remote end.
+     */
+    async signEvm(req) {
+        return await __classPrivateFieldGet(this, _EvmSigner_signerSession, "f").signEvm(__classPrivateFieldGet(this, _EvmSigner_address, "f"), req);
+    }
+    /**
+     * Signs EIP-712 typed data. This uses CubeSigner's EIP-712 signing endpoint.
+     * The key (for this session) must have the `"AllowRawBlobSigning"` or
+     * `"AllowEip712Signing"` policy attached.
+     * @param {Eip712SignRequest} req The EIP712 sign request.
+     * @return {Promise<string>} The signature.
+     */
+    async signEip712(req) {
+        const res = await __classPrivateFieldGet(this, _EvmSigner_signerSession, "f").signEip712(__classPrivateFieldGet(this, _EvmSigner_address, "f"), req);
+        const data = await __classPrivateFieldGet(this, _EvmSigner_instances, "m", _EvmSigner_handleMfa).call(this, res);
+        return data.signature;
+    }
+    /**
+     * Signs arbitrary messages. This uses CubeSigner's EIP-191 signing endpoint.
+     * The key (for this session) must have the `"AllowRawBlobSigning"` or
+     * `"AllowEip191Signing"` policy attached.
+     * @param {Eip191SignRequest} req The request to sign.
+     * @return {Promise<string>} The signature.
+     */
+    async signEip191(req) {
+        const res = await __classPrivateFieldGet(this, _EvmSigner_signerSession, "f").signEip191(__classPrivateFieldGet(this, _EvmSigner_address, "f"), req);
+        const data = await __classPrivateFieldGet(this, _EvmSigner_instances, "m", _EvmSigner_handleMfa).call(this, res);
+        return data.signature;
+    }
+    /** @return {KeyInfo} The key corresponding to this address */
+    async key() {
+        if (__classPrivateFieldGet(this, _EvmSigner_key, "f") === undefined) {
+            const key = (await __classPrivateFieldGet(this, _EvmSigner_signerSession, "f").keys()).find((k) => k.material_id === __classPrivateFieldGet(this, _EvmSigner_address, "f"));
+            if (key === undefined) {
+                throw new Error(`Cannot access key '${__classPrivateFieldGet(this, _EvmSigner_address, "f")}'`);
+            }
+            __classPrivateFieldSet(this, _EvmSigner_key, key, "f");
+        }
+        return __classPrivateFieldGet(this, _EvmSigner_key, "f");
+    }
+    /**
+     * Sign a transaction from an approved MFA request. The MFA request contains
+     * information about the approved signing request, which this method will execute.
+     * @param {MfaRequestInfo} mfaInfo The approved MFA request.
+     * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.
+     */
+    async signTransactionMfaApproved(mfaInfo) {
+        if (!mfaInfo.request.path.includes("/eth1/sign/")) {
+            throw new Error(`Expected EVM transaction signing request, got ${mfaInfo.request.path}`);
+        }
+        if (!mfaInfo.request.path.includes(__classPrivateFieldGet(this, _EvmSigner_address, "f"))) {
+            throw new Error(`Expected signing request for ${__classPrivateFieldGet(this, _EvmSigner_address, "f")} but got ${mfaInfo.request.path}`);
+        }
+        if (!mfaInfo.receipt) {
+            throw new Error("MFA request is not approved yet");
+        }
+        const resp = await __classPrivateFieldGet(this, _EvmSigner_signerSession, "f").signEvm(__classPrivateFieldGet(this, _EvmSigner_address, "f"), mfaInfo.request.body, {
+            mfaId: mfaInfo.id,
+            mfaOrgId: __classPrivateFieldGet(this, _EvmSigner_signerSession, "f").orgId,
+            mfaConf: mfaInfo.receipt.confirmation,
+        });
+        return resp.data().rlp_signed_tx;
+    }
+}
+exports.EvmSigner = EvmSigner;
+_EvmSigner_address = new WeakMap(), _EvmSigner_key = new WeakMap(), _EvmSigner_signerSession = new WeakMap(), _EvmSigner_options = new WeakMap(), _EvmSigner_instances = new WeakSet(), _EvmSigner_handleMfa = 
+/**
+ * If the sign request requires MFA, this method waits for approvals
+ * @param {CubeSignerResponse<U>} res The response of a sign request
+ * @return {Promise<U>} The sign data after MFA approvals
+ */
+async function _EvmSigner_handleMfa(res) {
+    while (res.requiresMfa()) {
+        await new Promise((resolve) => setTimeout(resolve, __classPrivateFieldGet(this, _EvmSigner_options, "f").mfaPollIntervalMs));
+        const mfaId = res.mfaId();
+        const mfaInfo = await __classPrivateFieldGet(this, _EvmSigner_signerSession, "f").getMfaInfo(mfaId);
+        __classPrivateFieldGet(this, _EvmSigner_options, "f").onMfaPoll?.(mfaInfo);
+        if (mfaInfo.receipt) {
+            res = await res.signWithMfaApproval({
+                mfaId,
+                mfaOrgId: __classPrivateFieldGet(this, _EvmSigner_signerSession, "f").orgId,
+                mfaConf: mfaInfo.receipt.confirmation,
+            });
+        }
+    }
+    return res.data();
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/evm/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CubeSignerResponse,\n  KeyInfo,\n  Eip191SignRequest,\n  Eip712SignRequest,\n  EvmSignRequest,\n  MfaRequestInfo,\n  SignerSession,\n  EvmSignResponse,\n} from \"../index\";\n\n/** Options for the signer */\nexport interface EvmSignerOptions {\n  /**\n   * The function to call when MFA information is retrieved. If this callback\n   * throws, no transaction is broadcast.\n   */\n  onMfaPoll?: (arg0: MfaRequestInfo) => void;\n  /**\n   * The amount of time (in milliseconds) to wait between checks for MFA\n   * updates. Default is 1000ms\n   */\n  mfaPollIntervalMs?: number;\n}\n\n/**\n * Signer using CubeSigner, with basic MFA handling.\n * @internal\n */\nexport class EvmSigner {\n  /** The address of the account */\n  readonly #address: string;\n\n  /** The key to use for signing */\n  #key?: KeyInfo;\n\n  /** The underlying session */\n  readonly #signerSession: SignerSession;\n\n  /** Options */\n  readonly #options: EvmSignerOptions;\n\n  /** Returns the key address (NOT checksummed) */\n  get address() {\n    return this.#address;\n  }\n\n  /** Returns the underlying signer session */\n  get signerSession() {\n    return this.#signerSession;\n  }\n\n  /** Options */\n  get options() {\n    return this.#options;\n  }\n\n  /**\n   * Create new Signer instance\n   * @param {KeyInfo | string} address The key or the eth address of the account to use.\n   * @param {SignerSession} signerSession The underlying Signer session.\n   * @param {EvmSignerOptions} options The options to use for the Signer instance\n   */\n  constructor(address: KeyInfo | string, signerSession: SignerSession, options?: EvmSignerOptions) {\n    if (typeof address === \"string\") {\n      this.#address = address;\n    } else {\n      this.#address = address.materialId;\n      this.#key = address;\n    }\n    this.#signerSession = signerSession;\n    this.#options = <EvmSignerOptions>{\n      onMfaPoll: options?.onMfaPoll,\n      mfaPollIntervalMs: options?.mfaPollIntervalMs ?? 1000,\n    };\n  }\n\n  /**\n   * Sign a transaction. This method will block if the key requires MFA approval.\n   * @param {EvmSignRequest} req The sign request.\n   * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.\n   */\n  async signTransaction(req: EvmSignRequest): Promise<string> {\n    const res = await this.signEvm(req);\n    const data = await this.#handleMfa(res);\n    return data.rlp_signed_tx;\n  }\n\n  /**\n   * Sign a transaction. This method does not block if the key requires MFA approval, i.e.,\n   * the returned {@link CubeSignerResponse} object either contains a signature or indicates\n   * that MFA is required.\n   *\n   * @param {EvmSignRequest} req The transaction to sign.\n   * @return {CubeSignerResponse<EvmSignResponse>} The response from the CubeSigner remote end.\n   */\n  async signEvm(req: EvmSignRequest): Promise<CubeSignerResponse<EvmSignResponse>> {\n    return await this.#signerSession.signEvm(this.#address, req);\n  }\n\n  /**\n   * Signs EIP-712 typed data. This uses CubeSigner's EIP-712 signing endpoint.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` or\n   * `\"AllowEip712Signing\"` policy attached.\n   * @param {Eip712SignRequest} req The EIP712 sign request.\n   * @return {Promise<string>} The signature.\n   */\n  async signEip712(req: Eip712SignRequest): Promise<string> {\n    const res = await this.#signerSession.signEip712(this.#address, req);\n    const data = await this.#handleMfa(res);\n    return data.signature;\n  }\n\n  /**\n   * Signs arbitrary messages. This uses CubeSigner's EIP-191 signing endpoint.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` or\n   * `\"AllowEip191Signing\"` policy attached.\n   * @param {Eip191SignRequest} req The request to sign.\n   * @return {Promise<string>} The signature.\n   */\n  async signEip191(req: Eip191SignRequest): Promise<string> {\n    const res = await this.#signerSession.signEip191(this.#address, req);\n    const data = await this.#handleMfa(res);\n    return data.signature;\n  }\n\n  /** @return {KeyInfo} The key corresponding to this address */\n  async key(): Promise<KeyInfo> {\n    if (this.#key === undefined) {\n      const key = (await this.#signerSession.keys()).find((k) => k.material_id === this.#address);\n      if (key === undefined) {\n        throw new Error(`Cannot access key '${this.#address}'`);\n      }\n      this.#key = key;\n    }\n    return this.#key;\n  }\n\n  /**\n   * Sign a transaction from an approved MFA request. The MFA request contains\n   * information about the approved signing request, which this method will execute.\n   * @param {MfaRequestInfo} mfaInfo The approved MFA request.\n   * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.\n   */\n  async signTransactionMfaApproved(mfaInfo: MfaRequestInfo): Promise<string> {\n    if (!mfaInfo.request.path.includes(\"/eth1/sign/\")) {\n      throw new Error(`Expected EVM transaction signing request, got ${mfaInfo.request.path}`);\n    }\n    if (!mfaInfo.request.path.includes(this.#address)) {\n      throw new Error(\n        `Expected signing request for ${this.#address} but got ${mfaInfo.request.path}`,\n      );\n    }\n    if (!mfaInfo.receipt) {\n      throw new Error(\"MFA request is not approved yet\");\n    }\n\n    const resp = await this.#signerSession.signEvm(\n      this.#address,\n      mfaInfo.request.body as EvmSignRequest,\n      {\n        mfaId: mfaInfo.id,\n        mfaOrgId: this.#signerSession.orgId,\n        mfaConf: mfaInfo.receipt!.confirmation,\n      },\n    );\n    return resp.data().rlp_signed_tx;\n  }\n\n  /**\n   * If the sign request requires MFA, this method waits for approvals\n   * @param {CubeSignerResponse<U>} res The response of a sign request\n   * @return {Promise<U>} The sign data after MFA approvals\n   */\n  async #handleMfa<U>(res: CubeSignerResponse<U>): Promise<U> {\n    while (res.requiresMfa()) {\n      await new Promise((resolve) => setTimeout(resolve, this.#options.mfaPollIntervalMs));\n\n      const mfaId = res.mfaId();\n      const mfaInfo = await this.#signerSession.getMfaInfo(mfaId);\n      this.#options.onMfaPoll?.(mfaInfo);\n      if (mfaInfo.receipt) {\n        res = await res.signWithMfaApproval({\n          mfaId,\n          mfaOrgId: this.#signerSession.orgId,\n          mfaConf: mfaInfo.receipt.confirmation,\n        });\n      }\n    }\n    return res.data();\n  }\n}\n"]}

package/dist/cjs/src/index.d.ts

@@ -197,6 +197,8 @@ export * from "./session/signer_session_manager";
 export * from "./util";
 /** User-export decryption helper */
 export { userExportDecrypt, userExportKeygen } from "./user_export";
+/** Ethers.js helpers */
+export * from "./evm";
 /** CubeSigner SDK package name */
 export declare const NAME: string;
 /** CubeSigner SDK version */

package/dist/cjs/src/index.js

@@ -292,8 +292,10 @@ __exportStar(require("./util"), exports);
 var user_export_1 = require("./user_export");
 Object.defineProperty(exports, "userExportDecrypt", { enumerable: true, get: function () { return user_export_1.userExportDecrypt; } });
 Object.defineProperty(exports, "userExportKeygen", { enumerable: true, get: function () { return user_export_1.userExportKeygen; } });
+/** Ethers.js helpers */
+__exportStar(require("./evm"), exports);
 /** CubeSigner SDK package name */
 exports.NAME = package_json_1.name;
 /** CubeSigner SDK version */
 exports.VERSION = package_json_1.version;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA2C;AAC3C,+BAA2C;AAC3C,qCAA4C;AAC5C,+BAA4B;AAE5B,6EAI0C;AAE1C,qDAAiD;AAEjD,oDAAkD;AAalD;;;;GAIG;AACH,MAAa,UAAU;IAKrB;;;OAGG;IACH,IAAI,GAAG;QACL,IAAI,CAAC,uBAAA,IAAI,uBAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QACD,OAAO,uBAAA,IAAI,uBAAK,CAAC;IACnB,CAAC;IAED,uEAAuE;IACvE,IAAI,GAAG;QACL,OAAO,uBAAA,IAAI,uBAAK,CAAC;IACnB,CAAC;IAED,sBAAsB;IACtB,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;IACxB,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAa;QACpB,uBAAA,IAAI,mBAAQ,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,MAAA,CAAC;IACtC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,OAA6B;QAC9D,OAAO,IAAI,UAAU,CAAoB;YACvC,UAAU,EAAE,MAAM,6CAAoB,CAAC,eAAe,CAAC,OAAO,CAAC;SAChE,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAA6B;QAC1D,OAAO,MAAM,8BAAa,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,YAAY,OAA2B;QA1D9B,kCAAmB;QAE5B,kCAAwB;QAyDtB,IAAI,GAAG,GAAG,OAAO,EAAE,GAAG,CAAC;QACvB,IAAI,OAAO,EAAE,UAAU,EAAE,CAAC;YACxB,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;YACrC,GAAG,GAAG,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QACnC,CAAC;QACD,uBAAA,IAAI,mBAAQ,GAAG,IAAI,UAAI,CAAC,OAAO,CAAC,MAAA,CAAC;QACjC,uBAAA,IAAI,mBAAQ,IAAI,yBAAgB;QAC9B,kFAAkF;QAClF,iFAAiF;QACjF,kFAAkF;QAClF,EAAE;QACF,4EAA4E;QAC5E,4FAA4F;QAC5F,OAAO,EAAE,UAA6C,EACtD,OAAO,EAAE,KAAK,CACf,MAAA,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,QAAQ,CACZ,SAAiB,EACjB,KAAa,EACb,MAAqB,EACrB,SAAyB,EACzB,OAA8B;QAE9B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;QACvE,OAAO,MAAM,6CAAoB,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC;IACjG,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO;QACX,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,CAAC,KAAa,EAAE,KAAa;QACvC,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,KAAa;QACzB,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;IACjD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,UAAU,CAAC,KAAa,EAAE,KAAa;QAC3C,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzD,CAAC;IAED,8DAA8D;IAC9D,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,CAAC,uBAAA,IAAI,uBAAK,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,IAAI,CAAC,uBAAA,IAAI,uBAAK,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,uBAAA,IAAI,uBAAK,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,KAAc;QACzB,OAAO,IAAI,SAAG,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,SAAS,CAAC,KAAa,EAAE,KAAa;QAC1C,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,aAAa,CAAC,KAAa;QAC/B,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,aAAa,EAAE,CAAC;IACvD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,iBAAiB,CAAC,SAAiB,EAAE,KAAa;QACtD,MAAM,UAAU,GAAG,IAAI,gBAAU,CAAC,uBAAA,IAAI,uBAAK,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;QAC/D,OAAO,MAAM,UAAU,CAAC,aAAa,EAAE,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,cAAc,CAAC,KAAa,EAAE,aAA4B;QAC9D,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,SAAS,CACb,SAAiB,EACjB,KAAa,EACb,MAAqB,EACrB,SAAyB,EACzB,UAAuB;QAEvB,MAAM,UAAU,GAAG,IAAI,gBAAU,CAAC,uBAAA,IAAI,uBAAK,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;QAC/D,OAAO,MAAM,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;IACvE,CAAC;CACF;AAzPD,gCAyPC;;AAED,aAAa;AACb,0CAAwB;AACxB,UAAU;AACV,wCAAsB;AACtB,aAAa;AACb,2CAAyB;AACzB,gBAAgB;AAChB,mCAA+F;AAAtF,gGAAA,MAAM,OAAA;AAA4B,sGAAA,YAAY,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAC5E,oBAAoB;AACpB,wCAAsB;AACtB,WAAW;AACX,wCAAsB;AACtB,YAAY;AACZ,yCAAuB;AACvB,UAAU;AACV,wCAAsB;AACtB,WAAW;AACX,wCAAsB;AACtB,iBAAiB;AACjB,8CAA4B;AAC5B,eAAe;AACf,6CAA2B;AAC3B,YAAY;AACZ,iDAA+B;AAC/B,eAAe;AACf,mDAAiC;AACjC,sBAAsB;AACtB,4DAA0C;AAC1C,6BAA6B;AAC7B,mEAAiD;AACjD,YAAY;AACZ,yCAAuB;AACvB,oCAAoC;AACpC,6CAAoE;AAA3D,gHAAA,iBAAiB,OAAA;AAAE,+GAAA,gBAAgB,OAAA;AAE5C,kCAAkC;AACrB,QAAA,IAAI,GAAW,mBAAI,CAAC;AAEjC,6BAA6B;AAChB,QAAA,OAAO,GAAW,sBAAO,CAAC","sourcesContent":["import { envs, EnvInterface } from \"./env\";\nimport { Client, OidcClient } from \"./api\";\nimport { CubeSignerClient } from \"./client\";\nimport { Org } from \"./org\";\n\nimport {\n  SignerSessionStorage,\n  SignerSessionManager,\n  SignerSessionData,\n} from \"./session/signer_session_manager\";\nimport { CubeSignerResponse } from \"./response\";\nimport { SignerSession } from \"./signer_session\";\nimport { MfaReceipt } from \"./mfa\";\nimport { name, version } from \"./../package.json\";\nimport { IdentityProof, MfaRequestInfo, RatchetConfig, UserInfo } from \"./schema_types\";\n\n/** CubeSigner constructor options */\nexport interface CubeSignerOptions {\n  /** The environment to use */\n  env?: EnvInterface;\n  /** The management authorization token */\n  sessionMgr?: SignerSessionManager;\n  /** Optional organization id */\n  orgId?: string;\n}\n\n/**\n * CubeSigner client\n *\n * @deprecated Use {@link Org} or {@link CubeSignerClient} instead.\n */\nexport class CubeSigner {\n  readonly #env: EnvInterface;\n  readonly sessionMgr?: SignerSessionManager;\n  #csc?: CubeSignerClient;\n\n  /**\n   * Underlying {@link CubeSignerClient} instance, if set; otherwise throws.\n   * @internal\n   */\n  get csc(): CubeSignerClient {\n    if (!this.#csc) {\n      throw new Error(\"CubeSignerClient is not set\");\n    }\n    return this.#csc;\n  }\n\n  /** @return {EnvInterface} The CubeSigner environment of this client */\n  get env(): EnvInterface {\n    return this.#env;\n  }\n\n  /** Organization ID */\n  get orgId() {\n    return this.csc.orgId;\n  }\n\n  /**\n   * Set the organization ID\n   * @param {string} orgId The new organization id.\n   */\n  setOrgId(orgId: string) {\n    this.#csc = this.csc.withOrg(orgId);\n  }\n\n  /**\n   * Loads an existing management session and creates a CubeSigner instance.\n   *\n   * @param {SignerSessionStorage} storage Session storage to load the session from.\n   * @return {Promise<CubeSigner>} New CubeSigner instance\n   */\n  static async loadManagementSession(storage: SignerSessionStorage): Promise<CubeSigner> {\n    return new CubeSigner(<CubeSignerOptions>{\n      sessionMgr: await SignerSessionManager.loadFromStorage(storage),\n    });\n  }\n\n  /**\n   * Loads a signer session from a session storage (e.g., session file).\n   * @param {SignerSessionStorage} storage Session storage to load the session from.\n   * @return {Promise<SignerSession>} New signer session\n   */\n  static async loadSignerSession(storage: SignerSessionStorage): Promise<SignerSession> {\n    return await SignerSession.loadSignerSession(storage);\n  }\n\n  /**\n   * Create a new CubeSigner instance.\n   * @param {CubeSignerOptions} options The optional configuration options for the CubeSigner instance.\n   */\n  constructor(options?: CubeSignerOptions) {\n    let env = options?.env;\n    if (options?.sessionMgr) {\n      this.sessionMgr = options.sessionMgr;\n      env = env ?? this.sessionMgr.env;\n    }\n    this.#env = env ?? envs[\"gamma\"];\n    this.#csc = new CubeSignerClient(\n      // HACK: ignore that sessionMgr may be a CognitoSessionManager and pretend that it\n      //       is a SignerSessionManager; that's fine because the CubeSignerClient will\n      //       almost always just call `await token()` on it, which works in both cases.\n      //\n      // This is done here for backward compatibility reasons only; in the future,\n      // we should deprecate this class and people should start using `CubeSingerClient` directly.\n      options?.sessionMgr as unknown as SignerSessionManager,\n      options?.orgId,\n    );\n  }\n\n  /**\n   * Authenticate an OIDC user and create a new session manager for them.\n   *\n   * @param {string} oidcToken The OIDC token\n   * @param {string} orgId The id of the organization that the user is in\n   * @param {List<string>} scopes The scopes of the resulting session\n   * @param {RatchetConfig} lifetimes Lifetimes of the new session.\n   * @param {SignerSessionStorage?} storage Optional signer session storage (defaults to in-memory storage)\n   * @return {Promise<SignerSessionManager>} The signer session manager\n   */\n  async oidcAuth(\n    oidcToken: string,\n    orgId: string,\n    scopes: Array<string>,\n    lifetimes?: RatchetConfig,\n    storage?: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    const resp = await this.oidcLogin(oidcToken, orgId, scopes, lifetimes);\n    return await SignerSessionManager.createFromSessionInfo(this.env, orgId, resp.data(), storage);\n  }\n\n  /**\n   * Retrieves information about the current user.\n   *\n   * @return {Promise<UserInfo>} User information.\n   */\n  async aboutMe(): Promise<UserInfo> {\n    return await this.csc.userGet();\n  }\n\n  /**\n   * Retrieves existing MFA request.\n   *\n   * @param {string} orgId Organization ID\n   * @param {string} mfaId MFA request ID\n   * @return {Promise<MfaRequestInfo>} MFA request information\n   */\n  async mfaGet(orgId: string, mfaId: string): Promise<MfaRequestInfo> {\n    return await this.csc.withOrg(orgId).mfaGet(mfaId);\n  }\n\n  /**\n   * List pending MFA requests accessible to the current user.\n   * @param {string} orgId Organization ID\n   * @return {Promise<MfaRequestInfo[]>} The MFA requests.\n   */\n  async mfaList(orgId: string): Promise<MfaRequestInfo[]> {\n    return await this.csc.withOrg(orgId).mfaList();\n  }\n\n  /**\n   * Approve a pending MFA request.\n   *\n   * @param {string} orgId The org id of the MFA request\n   * @param {string} mfaId The id of the MFA request\n   * @return {Promise<MfaRequestInfo>} The result of the MFA request\n   */\n  async mfaApprove(orgId: string, mfaId: string): Promise<MfaRequestInfo> {\n    return await this.csc.withOrg(orgId).mfaApprove(mfaId);\n  }\n\n  /** Initiate adding a new FIDO device. MFA may be required. */\n  get addFidoStart() {\n    return this.csc.userFidoRegisterInit.bind(this.csc);\n  }\n\n  /**\n   * Creates a request to change user's TOTP. This request returns a new TOTP challenge\n   * that must be answered by calling `resetTotpComplete`\n   */\n  get resetTotpStart() {\n    return this.csc.userTotpResetInit.bind(this.#csc);\n  }\n\n  /**\n   * Answer the TOTP challenge issued by `resetTotpStart`. If successful, user's\n   * TOTP configuration will be updated to that of the TOTP challenge.he TOTP configuration from the challenge.\n   */\n  get resetTotpComplete() {\n    return this.csc.userTotpResetComplete.bind(this.#csc);\n  }\n\n  /**\n   * Verifies a given TOTP code against the current user's TOTP configuration.\n   * Throws an error if the verification fails.\n   */\n  get verifyTotp() {\n    return this.csc.userTotpVerify.bind(this.#csc);\n  }\n\n  /**\n   * Retrieve information about an organization.\n   * @param {string} orgId The ID or name of the organization.\n   * @return {Org} The organization.\n   */\n  async getOrg(orgId?: string): Promise<Org> {\n    return new Org(this.csc.sessionMgr, orgId ?? this.csc.orgId);\n  }\n\n  /**\n   * Deletes a given key.\n   * @param {string} orgId - Organization id\n   * @param {string} keyId - Key id\n   */\n  async deleteKey(orgId: string, keyId: string) {\n    await this.csc.withOrg(orgId).keyDelete(keyId);\n  }\n\n  /**\n   * Get the management client.\n   * @return {Client} The client.\n   * @internal\n   */\n  async management(): Promise<Client> {\n    if (!this.sessionMgr) {\n      throw new Error(\"No management session loaded\");\n    }\n    return await this.sessionMgr.client();\n  }\n\n  /**\n   * Obtain a proof of authentication.\n   *\n   * @param {string} orgId The id of the organization that the user is in\n   * @return {Promise<IdentityProof>} Proof of authentication\n   */\n  async proveIdentity(orgId: string): Promise<IdentityProof> {\n    return await this.csc.withOrg(orgId).identityProve();\n  }\n\n  /**\n   * Exchange an OIDC token for a proof of authentication.\n   *\n   * @param {string} oidcToken The OIDC token\n   * @param {string} orgId The id of the organization that the user is in\n   * @return {Promise<IdentityProof>} Proof of authentication\n   */\n  async oidcProveIdentity(oidcToken: string, orgId: string): Promise<IdentityProof> {\n    const oidcClient = new OidcClient(this.#env, orgId, oidcToken);\n    return await oidcClient.identityProve();\n  }\n\n  /**\n   * Checks if a given identity proof is valid.\n   *\n   * @param {string} orgId The id of the organization that the user is in.\n   * @param {IdentityProof} identityProof The proof of authentication.\n   */\n  async verifyIdentity(orgId: string, identityProof: IdentityProof) {\n    await this.csc.withOrg(orgId).identityVerify(identityProof);\n  }\n\n  /**\n   * Exchange an OIDC token for a CubeSigner session token.\n   * @param {string} oidcToken The OIDC token\n   * @param {string} orgId The id of the organization that the user is in\n   * @param {List<string>} scopes The scopes of the resulting session\n   * @param {RatchetConfig} lifetimes Lifetimes of the new session.\n   * @param {MfaReceipt} mfaReceipt Optional MFA receipt (id + confirmation code)\n   * @return {Promise<CubeSignerResponse<SignerSessionData>>} The session data.\n   */\n  async oidcLogin(\n    oidcToken: string,\n    orgId: string,\n    scopes: Array<string>,\n    lifetimes?: RatchetConfig,\n    mfaReceipt?: MfaReceipt,\n  ): Promise<CubeSignerResponse<SignerSessionData>> {\n    const oidcClient = new OidcClient(this.#env, orgId, oidcToken);\n    return await oidcClient.sessionCreate(scopes, lifetimes, mfaReceipt);\n  }\n}\n\n/** Errors */\nexport * from \"./error\";\n/** API */\nexport * from \"./api\";\n/** Client */\nexport * from \"./client\";\n/** Callbacks */\nexport { Events, EventHandler, ErrorEvent, GlobalEvents, SessionExpiredEvent } from \"./events\";\n/** Organizations */\nexport * from \"./org\";\n/** Keys */\nexport * from \"./key\";\n/** Roles */\nexport * from \"./role\";\n/** Env */\nexport * from \"./env\";\n/** Fido */\nexport * from \"./mfa\";\n/** Pagination */\nexport * from \"./paginator\";\n/** Response */\nexport * from \"./response\";\n/** Types */\nexport * from \"./schema_types\";\n/** Sessions */\nexport * from \"./signer_session\";\n/** Session storage */\nexport * from \"./session/session_storage\";\n/** Signer session manager */\nexport * from \"./session/signer_session_manager\";\n/** Utils */\nexport * from \"./util\";\n/** User-export decryption helper */\nexport { userExportDecrypt, userExportKeygen } from \"./user_export\";\n\n/** CubeSigner SDK package name */\nexport const NAME: string = name;\n\n/** CubeSigner SDK version */\nexport const VERSION: string = version;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA2C;AAC3C,+BAA2C;AAC3C,qCAA4C;AAC5C,+BAA4B;AAE5B,6EAI0C;AAE1C,qDAAiD;AAEjD,oDAAkD;AAalD;;;;GAIG;AACH,MAAa,UAAU;IAKrB;;;OAGG;IACH,IAAI,GAAG;QACL,IAAI,CAAC,uBAAA,IAAI,uBAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QACD,OAAO,uBAAA,IAAI,uBAAK,CAAC;IACnB,CAAC;IAED,uEAAuE;IACvE,IAAI,GAAG;QACL,OAAO,uBAAA,IAAI,uBAAK,CAAC;IACnB,CAAC;IAED,sBAAsB;IACtB,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;IACxB,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAa;QACpB,uBAAA,IAAI,mBAAQ,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,MAAA,CAAC;IACtC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,OAA6B;QAC9D,OAAO,IAAI,UAAU,CAAoB;YACvC,UAAU,EAAE,MAAM,6CAAoB,CAAC,eAAe,CAAC,OAAO,CAAC;SAChE,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAA6B;QAC1D,OAAO,MAAM,8BAAa,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,YAAY,OAA2B;QA1D9B,kCAAmB;QAE5B,kCAAwB;QAyDtB,IAAI,GAAG,GAAG,OAAO,EAAE,GAAG,CAAC;QACvB,IAAI,OAAO,EAAE,UAAU,EAAE,CAAC;YACxB,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;YACrC,GAAG,GAAG,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QACnC,CAAC;QACD,uBAAA,IAAI,mBAAQ,GAAG,IAAI,UAAI,CAAC,OAAO,CAAC,MAAA,CAAC;QACjC,uBAAA,IAAI,mBAAQ,IAAI,yBAAgB;QAC9B,kFAAkF;QAClF,iFAAiF;QACjF,kFAAkF;QAClF,EAAE;QACF,4EAA4E;QAC5E,4FAA4F;QAC5F,OAAO,EAAE,UAA6C,EACtD,OAAO,EAAE,KAAK,CACf,MAAA,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,QAAQ,CACZ,SAAiB,EACjB,KAAa,EACb,MAAqB,EACrB,SAAyB,EACzB,OAA8B;QAE9B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;QACvE,OAAO,MAAM,6CAAoB,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC;IACjG,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO;QACX,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,CAAC,KAAa,EAAE,KAAa;QACvC,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,KAAa;QACzB,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;IACjD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,UAAU,CAAC,KAAa,EAAE,KAAa;QAC3C,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzD,CAAC;IAED,8DAA8D;IAC9D,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,CAAC,uBAAA,IAAI,uBAAK,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,IAAI,CAAC,uBAAA,IAAI,uBAAK,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,uBAAA,IAAI,uBAAK,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,KAAc;QACzB,OAAO,IAAI,SAAG,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,SAAS,CAAC,KAAa,EAAE,KAAa;QAC1C,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,aAAa,CAAC,KAAa;QAC/B,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,aAAa,EAAE,CAAC;IACvD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,iBAAiB,CAAC,SAAiB,EAAE,KAAa;QACtD,MAAM,UAAU,GAAG,IAAI,gBAAU,CAAC,uBAAA,IAAI,uBAAK,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;QAC/D,OAAO,MAAM,UAAU,CAAC,aAAa,EAAE,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,cAAc,CAAC,KAAa,EAAE,aAA4B;QAC9D,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,SAAS,CACb,SAAiB,EACjB,KAAa,EACb,MAAqB,EACrB,SAAyB,EACzB,UAAuB;QAEvB,MAAM,UAAU,GAAG,IAAI,gBAAU,CAAC,uBAAA,IAAI,uBAAK,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;QAC/D,OAAO,MAAM,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;IACvE,CAAC;CACF;AAzPD,gCAyPC;;AAED,aAAa;AACb,0CAAwB;AACxB,UAAU;AACV,wCAAsB;AACtB,aAAa;AACb,2CAAyB;AACzB,gBAAgB;AAChB,mCAA+F;AAAtF,gGAAA,MAAM,OAAA;AAA4B,sGAAA,YAAY,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAC5E,oBAAoB;AACpB,wCAAsB;AACtB,WAAW;AACX,wCAAsB;AACtB,YAAY;AACZ,yCAAuB;AACvB,UAAU;AACV,wCAAsB;AACtB,WAAW;AACX,wCAAsB;AACtB,iBAAiB;AACjB,8CAA4B;AAC5B,eAAe;AACf,6CAA2B;AAC3B,YAAY;AACZ,iDAA+B;AAC/B,eAAe;AACf,mDAAiC;AACjC,sBAAsB;AACtB,4DAA0C;AAC1C,6BAA6B;AAC7B,mEAAiD;AACjD,YAAY;AACZ,yCAAuB;AACvB,oCAAoC;AACpC,6CAAoE;AAA3D,gHAAA,iBAAiB,OAAA;AAAE,+GAAA,gBAAgB,OAAA;AAC5C,wBAAwB;AACxB,wCAAsB;AAEtB,kCAAkC;AACrB,QAAA,IAAI,GAAW,mBAAI,CAAC;AAEjC,6BAA6B;AAChB,QAAA,OAAO,GAAW,sBAAO,CAAC","sourcesContent":["import { envs, EnvInterface } from \"./env\";\nimport { Client, OidcClient } from \"./api\";\nimport { CubeSignerClient } from \"./client\";\nimport { Org } from \"./org\";\n\nimport {\n  SignerSessionStorage,\n  SignerSessionManager,\n  SignerSessionData,\n} from \"./session/signer_session_manager\";\nimport { CubeSignerResponse } from \"./response\";\nimport { SignerSession } from \"./signer_session\";\nimport { MfaReceipt } from \"./mfa\";\nimport { name, version } from \"./../package.json\";\nimport { IdentityProof, MfaRequestInfo, RatchetConfig, UserInfo } from \"./schema_types\";\n\n/** CubeSigner constructor options */\nexport interface CubeSignerOptions {\n  /** The environment to use */\n  env?: EnvInterface;\n  /** The management authorization token */\n  sessionMgr?: SignerSessionManager;\n  /** Optional organization id */\n  orgId?: string;\n}\n\n/**\n * CubeSigner client\n *\n * @deprecated Use {@link Org} or {@link CubeSignerClient} instead.\n */\nexport class CubeSigner {\n  readonly #env: EnvInterface;\n  readonly sessionMgr?: SignerSessionManager;\n  #csc?: CubeSignerClient;\n\n  /**\n   * Underlying {@link CubeSignerClient} instance, if set; otherwise throws.\n   * @internal\n   */\n  get csc(): CubeSignerClient {\n    if (!this.#csc) {\n      throw new Error(\"CubeSignerClient is not set\");\n    }\n    return this.#csc;\n  }\n\n  /** @return {EnvInterface} The CubeSigner environment of this client */\n  get env(): EnvInterface {\n    return this.#env;\n  }\n\n  /** Organization ID */\n  get orgId() {\n    return this.csc.orgId;\n  }\n\n  /**\n   * Set the organization ID\n   * @param {string} orgId The new organization id.\n   */\n  setOrgId(orgId: string) {\n    this.#csc = this.csc.withOrg(orgId);\n  }\n\n  /**\n   * Loads an existing management session and creates a CubeSigner instance.\n   *\n   * @param {SignerSessionStorage} storage Session storage to load the session from.\n   * @return {Promise<CubeSigner>} New CubeSigner instance\n   */\n  static async loadManagementSession(storage: SignerSessionStorage): Promise<CubeSigner> {\n    return new CubeSigner(<CubeSignerOptions>{\n      sessionMgr: await SignerSessionManager.loadFromStorage(storage),\n    });\n  }\n\n  /**\n   * Loads a signer session from a session storage (e.g., session file).\n   * @param {SignerSessionStorage} storage Session storage to load the session from.\n   * @return {Promise<SignerSession>} New signer session\n   */\n  static async loadSignerSession(storage: SignerSessionStorage): Promise<SignerSession> {\n    return await SignerSession.loadSignerSession(storage);\n  }\n\n  /**\n   * Create a new CubeSigner instance.\n   * @param {CubeSignerOptions} options The optional configuration options for the CubeSigner instance.\n   */\n  constructor(options?: CubeSignerOptions) {\n    let env = options?.env;\n    if (options?.sessionMgr) {\n      this.sessionMgr = options.sessionMgr;\n      env = env ?? this.sessionMgr.env;\n    }\n    this.#env = env ?? envs[\"gamma\"];\n    this.#csc = new CubeSignerClient(\n      // HACK: ignore that sessionMgr may be a CognitoSessionManager and pretend that it\n      //       is a SignerSessionManager; that's fine because the CubeSignerClient will\n      //       almost always just call `await token()` on it, which works in both cases.\n      //\n      // This is done here for backward compatibility reasons only; in the future,\n      // we should deprecate this class and people should start using `CubeSingerClient` directly.\n      options?.sessionMgr as unknown as SignerSessionManager,\n      options?.orgId,\n    );\n  }\n\n  /**\n   * Authenticate an OIDC user and create a new session manager for them.\n   *\n   * @param {string} oidcToken The OIDC token\n   * @param {string} orgId The id of the organization that the user is in\n   * @param {List<string>} scopes The scopes of the resulting session\n   * @param {RatchetConfig} lifetimes Lifetimes of the new session.\n   * @param {SignerSessionStorage?} storage Optional signer session storage (defaults to in-memory storage)\n   * @return {Promise<SignerSessionManager>} The signer session manager\n   */\n  async oidcAuth(\n    oidcToken: string,\n    orgId: string,\n    scopes: Array<string>,\n    lifetimes?: RatchetConfig,\n    storage?: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    const resp = await this.oidcLogin(oidcToken, orgId, scopes, lifetimes);\n    return await SignerSessionManager.createFromSessionInfo(this.env, orgId, resp.data(), storage);\n  }\n\n  /**\n   * Retrieves information about the current user.\n   *\n   * @return {Promise<UserInfo>} User information.\n   */\n  async aboutMe(): Promise<UserInfo> {\n    return await this.csc.userGet();\n  }\n\n  /**\n   * Retrieves existing MFA request.\n   *\n   * @param {string} orgId Organization ID\n   * @param {string} mfaId MFA request ID\n   * @return {Promise<MfaRequestInfo>} MFA request information\n   */\n  async mfaGet(orgId: string, mfaId: string): Promise<MfaRequestInfo> {\n    return await this.csc.withOrg(orgId).mfaGet(mfaId);\n  }\n\n  /**\n   * List pending MFA requests accessible to the current user.\n   * @param {string} orgId Organization ID\n   * @return {Promise<MfaRequestInfo[]>} The MFA requests.\n   */\n  async mfaList(orgId: string): Promise<MfaRequestInfo[]> {\n    return await this.csc.withOrg(orgId).mfaList();\n  }\n\n  /**\n   * Approve a pending MFA request.\n   *\n   * @param {string} orgId The org id of the MFA request\n   * @param {string} mfaId The id of the MFA request\n   * @return {Promise<MfaRequestInfo>} The result of the MFA request\n   */\n  async mfaApprove(orgId: string, mfaId: string): Promise<MfaRequestInfo> {\n    return await this.csc.withOrg(orgId).mfaApprove(mfaId);\n  }\n\n  /** Initiate adding a new FIDO device. MFA may be required. */\n  get addFidoStart() {\n    return this.csc.userFidoRegisterInit.bind(this.csc);\n  }\n\n  /**\n   * Creates a request to change user's TOTP. This request returns a new TOTP challenge\n   * that must be answered by calling `resetTotpComplete`\n   */\n  get resetTotpStart() {\n    return this.csc.userTotpResetInit.bind(this.#csc);\n  }\n\n  /**\n   * Answer the TOTP challenge issued by `resetTotpStart`. If successful, user's\n   * TOTP configuration will be updated to that of the TOTP challenge.he TOTP configuration from the challenge.\n   */\n  get resetTotpComplete() {\n    return this.csc.userTotpResetComplete.bind(this.#csc);\n  }\n\n  /**\n   * Verifies a given TOTP code against the current user's TOTP configuration.\n   * Throws an error if the verification fails.\n   */\n  get verifyTotp() {\n    return this.csc.userTotpVerify.bind(this.#csc);\n  }\n\n  /**\n   * Retrieve information about an organization.\n   * @param {string} orgId The ID or name of the organization.\n   * @return {Org} The organization.\n   */\n  async getOrg(orgId?: string): Promise<Org> {\n    return new Org(this.csc.sessionMgr, orgId ?? this.csc.orgId);\n  }\n\n  /**\n   * Deletes a given key.\n   * @param {string} orgId - Organization id\n   * @param {string} keyId - Key id\n   */\n  async deleteKey(orgId: string, keyId: string) {\n    await this.csc.withOrg(orgId).keyDelete(keyId);\n  }\n\n  /**\n   * Get the management client.\n   * @return {Client} The client.\n   * @internal\n   */\n  async management(): Promise<Client> {\n    if (!this.sessionMgr) {\n      throw new Error(\"No management session loaded\");\n    }\n    return await this.sessionMgr.client();\n  }\n\n  /**\n   * Obtain a proof of authentication.\n   *\n   * @param {string} orgId The id of the organization that the user is in\n   * @return {Promise<IdentityProof>} Proof of authentication\n   */\n  async proveIdentity(orgId: string): Promise<IdentityProof> {\n    return await this.csc.withOrg(orgId).identityProve();\n  }\n\n  /**\n   * Exchange an OIDC token for a proof of authentication.\n   *\n   * @param {string} oidcToken The OIDC token\n   * @param {string} orgId The id of the organization that the user is in\n   * @return {Promise<IdentityProof>} Proof of authentication\n   */\n  async oidcProveIdentity(oidcToken: string, orgId: string): Promise<IdentityProof> {\n    const oidcClient = new OidcClient(this.#env, orgId, oidcToken);\n    return await oidcClient.identityProve();\n  }\n\n  /**\n   * Checks if a given identity proof is valid.\n   *\n   * @param {string} orgId The id of the organization that the user is in.\n   * @param {IdentityProof} identityProof The proof of authentication.\n   */\n  async verifyIdentity(orgId: string, identityProof: IdentityProof) {\n    await this.csc.withOrg(orgId).identityVerify(identityProof);\n  }\n\n  /**\n   * Exchange an OIDC token for a CubeSigner session token.\n   * @param {string} oidcToken The OIDC token\n   * @param {string} orgId The id of the organization that the user is in\n   * @param {List<string>} scopes The scopes of the resulting session\n   * @param {RatchetConfig} lifetimes Lifetimes of the new session.\n   * @param {MfaReceipt} mfaReceipt Optional MFA receipt (id + confirmation code)\n   * @return {Promise<CubeSignerResponse<SignerSessionData>>} The session data.\n   */\n  async oidcLogin(\n    oidcToken: string,\n    orgId: string,\n    scopes: Array<string>,\n    lifetimes?: RatchetConfig,\n    mfaReceipt?: MfaReceipt,\n  ): Promise<CubeSignerResponse<SignerSessionData>> {\n    const oidcClient = new OidcClient(this.#env, orgId, oidcToken);\n    return await oidcClient.sessionCreate(scopes, lifetimes, mfaReceipt);\n  }\n}\n\n/** Errors */\nexport * from \"./error\";\n/** API */\nexport * from \"./api\";\n/** Client */\nexport * from \"./client\";\n/** Callbacks */\nexport { Events, EventHandler, ErrorEvent, GlobalEvents, SessionExpiredEvent } from \"./events\";\n/** Organizations */\nexport * from \"./org\";\n/** Keys */\nexport * from \"./key\";\n/** Roles */\nexport * from \"./role\";\n/** Env */\nexport * from \"./env\";\n/** Fido */\nexport * from \"./mfa\";\n/** Pagination */\nexport * from \"./paginator\";\n/** Response */\nexport * from \"./response\";\n/** Types */\nexport * from \"./schema_types\";\n/** Sessions */\nexport * from \"./signer_session\";\n/** Session storage */\nexport * from \"./session/session_storage\";\n/** Signer session manager */\nexport * from \"./session/signer_session_manager\";\n/** Utils */\nexport * from \"./util\";\n/** User-export decryption helper */\nexport { userExportDecrypt, userExportKeygen } from \"./user_export\";\n/** Ethers.js helpers */\nexport * from \"./evm\";\n\n/** CubeSigner SDK package name */\nexport const NAME: string = name;\n\n/** CubeSigner SDK version */\nexport const VERSION: string = version;\n"]}

package/dist/cjs/src/org.d.ts

@@ -1,5 +1,5 @@
 import { CubeSignerClient } from "./client";
-import { OrgInfo, SignerSessionManager, SignerSessionStorage } from ".";
+import { NotificationEndpointConfiguration, OrgInfo, SignerSessionManager, SignerSessionStorage } from ".";
 /** Organization id */
 export type OrgId = string;
 /** Org-wide policy */
@@ -55,6 +55,7 @@ export declare class Org extends CubeSignerClient {
         last_unstake: string;
         last_unstake_day_count: number;
         name?: string | null | undefined;
+        notification_endpoints?: Record<string, never>[] | undefined;
         org_id: string;
         policy?: Record<string, never>[] | undefined;
         totp_failure_limit: number;
@@ -84,6 +85,12 @@ export declare class Org extends CubeSignerClient {
      * @param {OrgPolicy[]} policy The new policy for the org.
      */
     setPolicy(policy: OrgPolicy[]): Promise<void>;
+    /**
+     * Set the notification endpoints for the org.
+     *
+     * @param {NotificationEndpointConfiguration[]} notification_endpoints Endpoints.
+     */
+    setNotificationEndpoints(notification_endpoints: NotificationEndpointConfiguration[]): Promise<void>;
     /**
      * Retrieve the org associated with a session.
      * @param {SessionStorage} storage The session

package/dist/cjs/src/org.js

@@ -70,6 +70,16 @@ class Org extends client_1.CubeSignerClient {
         const p = policy;
         await this.orgUpdate({ policy: p });
     }
+    /**
+     * Set the notification endpoints for the org.
+     *
+     * @param {NotificationEndpointConfiguration[]} notification_endpoints Endpoints.
+     */
+    async setNotificationEndpoints(notification_endpoints) {
+        await this.orgUpdate({
+            notification_endpoints: notification_endpoints,
+        });
+    }
     /**
      * Retrieve the org associated with a session.
      * @param {SessionStorage} storage The session
@@ -92,4 +102,4 @@ class Org extends client_1.CubeSignerClient {
     }
 }
 exports.Org = Org;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org.js","sourceRoot":"","sources":["../../../src/org.ts"],"names":[],"mappings":";;;AAAA,qCAA4C;AAC5C,wBAAwE;AA4CxE;;;;GAIG;AACH,MAAa,GAAI,SAAQ,yBAAgB;IACvC;;;OAGG;IACH,IAAI,EAAE;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,sCAAsC;IACtC,KAAK,CAAC,IAAI;QACR,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,GAAG,CAAC,IAAI,IAAI,SAAS,CAAC;IAC/B,CAAC;IAED,+BAA+B;IAC/B,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,IAAY;QACxB,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACnF,CAAC;QACD,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IACjC,CAAC;IAED,0BAA0B;IAC1B,KAAK,CAAC,OAAO;QACX,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,GAAG,CAAC,OAAO,CAAC;IACrB,CAAC;IAED,sBAAsB;IACtB,KAAK,CAAC,MAAM;QACV,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,uBAAuB;IACvB,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED,kCAAkC;IAClC,KAAK,CAAC,MAAM;QACV,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAA2B,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,SAAS,CAAC,MAAmB;QACjC,MAAM,CAAC,GAAG,MAA4C,CAAC;QACvD,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IACtC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,OAA6B;QAC5D,MAAM,UAAU,GAAG,MAAM,uBAAoB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QACvE,OAAO,IAAI,GAAG,CAAC,IAAI,yBAAgB,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;IACrE,CAAC;IAED;;;;OAIG;IACH,YAAY,GAA4C,EAAE,IAAuB;QAC/E,MAAM,GAAG,GAAG,GAAG,YAAY,yBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAE,GAA4B,CAAC;QAE7F,+DAA+D;QAC/D,MAAM,KAAK,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC;QAC7D,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACpB,CAAC;CACF;AA9FD,kBA8FC","sourcesContent":["import { CubeSignerClient } from \"./client\";\nimport { OrgInfo, SignerSessionManager, SignerSessionStorage } from \".\";\n\n/** Organization id */\nexport type OrgId = string;\n\n/** Org-wide policy */\nexport type OrgPolicy =\n  | SourceIpAllowlistPolicy\n  | OidcAuthSourcesPolicy\n  | OriginAllowlistPolicy\n  | MaxDailyUnstakePolicy;\n\n/**\n * Provides an allowlist of OIDC Issuers and audiences that are allowed to authenticate into this org.\n * @example {\"OidcAuthSources\": { \"https://accounts.google.com\": [ \"1234.apps.googleusercontent.com\" ]}}\n */\nexport interface OidcAuthSourcesPolicy {\n  OidcAuthSources: Record<string, string[]>;\n}\n\n/**\n * Only allow requests from the specified origins.\n * @example {\"OriginAllowlist\": \"*\"}\n */\nexport interface OriginAllowlistPolicy {\n  OriginAllowlist: string[] | \"*\";\n}\n\n/**\n * Restrict signing to specific source IP addresses.\n * @example {\"SourceIpAllowlist\": [\"10.1.2.3/8\", \"169.254.17.1/16\"]}\n */\nexport interface SourceIpAllowlistPolicy {\n  SourceIpAllowlist: string[];\n}\n\n/**\n * Restrict the number of unstakes per day.\n * @example {\"MaxDailyUnstake\": 5 }\n */\nexport interface MaxDailyUnstakePolicy {\n  MaxDailyUnstake: number;\n}\n\n/**\n * An organization.\n *\n * Extends {@link CubeSignerClient} and provides a few org-specific methods on top.\n */\nexport class Org extends CubeSignerClient {\n  /**\n   * @description The org id\n   * @example Org#c3b9379c-4e8c-4216-bd0a-65ace53cf98f\n   */\n  get id(): OrgId {\n    return this.orgId;\n  }\n\n  /**\n   * Obtain information about the current organization.\n   *\n   * Same as {@link orgGet}.\n   */\n  get info() {\n    return this.orgGet.bind(this);\n  }\n\n  /** Human-readable name for the org */\n  async name(): Promise<string | undefined> {\n    const org = await this.orgGet();\n    return org.name ?? undefined;\n  }\n\n  /** Get all keys in the org. */\n  get keys() {\n    return this.orgKeys.bind(this);\n  }\n\n  /**\n   * Set the human-readable name for the org.\n   * @param {string} name The new human-readable name for the org (must be alphanumeric).\n   * @example my_org_name\n   */\n  async setName(name: string) {\n    if (!/^[a-zA-Z0-9_]{3,30}$/.test(name)) {\n      throw new Error(\"Org name must be alphanumeric and between 3 and 30 characters\");\n    }\n    await this.orgUpdate({ name });\n  }\n\n  /** Is the org enabled? */\n  async enabled(): Promise<boolean> {\n    const org = await this.orgGet();\n    return org.enabled;\n  }\n\n  /** Enable the org. */\n  async enable() {\n    await this.orgUpdate({ enabled: true });\n  }\n\n  /** Disable the org. */\n  async disable() {\n    await this.orgUpdate({ enabled: false });\n  }\n\n  /** Get the policy for the org. */\n  async policy(): Promise<OrgPolicy[]> {\n    const org = await this.orgGet();\n    return (org.policy ?? []) as unknown as OrgPolicy[];\n  }\n\n  /**\n   * Set the policy for the org.\n   * @param {OrgPolicy[]} policy The new policy for the org.\n   */\n  async setPolicy(policy: OrgPolicy[]) {\n    const p = policy as unknown as Record<string, never>[];\n    await this.orgUpdate({ policy: p });\n  }\n\n  /**\n   * Retrieve the org associated with a session.\n   * @param {SessionStorage} storage The session\n   * @return {Org} An {@link Org} instance for the org associated with this session.\n   */\n  static async retrieveFromStorage(storage: SignerSessionStorage): Promise<Org> {\n    const sessionMgr = await SignerSessionManager.loadFromStorage(storage);\n    return new Org(new CubeSignerClient(sessionMgr), sessionMgr.orgId);\n  }\n\n  /**\n   * Constructor.\n   * @param {CubeSignerClient | SignerSessionManager} csc The CubeSigner instance.\n   * @param {OrgInfo| string} data Either org id or name or {@link OrgInfo}.\n   */\n  constructor(csc: CubeSignerClient | SignerSessionManager, data?: OrgInfo | string) {\n    const mgr = csc instanceof CubeSignerClient ? csc.sessionMgr : (csc as SignerSessionManager);\n\n    // NOTE: data can be OrgInfo for backward compatibility reasons\n    const orgId = typeof data === \"string\" ? data : data?.org_id;\n    super(mgr, orgId);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org.js","sourceRoot":"","sources":["../../../src/org.ts"],"names":[],"mappings":";;;AAAA,qCAA4C;AAC5C,wBAKW;AA4CX;;;;GAIG;AACH,MAAa,GAAI,SAAQ,yBAAgB;IACvC;;;OAGG;IACH,IAAI,EAAE;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,sCAAsC;IACtC,KAAK,CAAC,IAAI;QACR,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,GAAG,CAAC,IAAI,IAAI,SAAS,CAAC;IAC/B,CAAC;IAED,+BAA+B;IAC/B,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,IAAY;QACxB,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACnF,CAAC;QACD,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IACjC,CAAC;IAED,0BAA0B;IAC1B,KAAK,CAAC,OAAO;QACX,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,GAAG,CAAC,OAAO,CAAC;IACrB,CAAC;IAED,sBAAsB;IACtB,KAAK,CAAC,MAAM;QACV,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,uBAAuB;IACvB,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED,kCAAkC;IAClC,KAAK,CAAC,MAAM;QACV,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAA2B,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,SAAS,CAAC,MAAmB;QACjC,MAAM,CAAC,GAAG,MAA4C,CAAC;QACvD,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IACtC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,wBAAwB,CAAC,sBAA2D;QACxF,MAAM,IAAI,CAAC,SAAS,CAAC;YACnB,sBAAsB,EAAE,sBAA4D;SACrF,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,OAA6B;QAC5D,MAAM,UAAU,GAAG,MAAM,uBAAoB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QACvE,OAAO,IAAI,GAAG,CAAC,IAAI,yBAAgB,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;IACrE,CAAC;IAED;;;;OAIG;IACH,YAAY,GAA4C,EAAE,IAAuB;QAC/E,MAAM,GAAG,GAAG,GAAG,YAAY,yBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAE,GAA4B,CAAC;QAE7F,+DAA+D;QAC/D,MAAM,KAAK,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC;QAC7D,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACpB,CAAC;CACF;AAzGD,kBAyGC","sourcesContent":["import { CubeSignerClient } from \"./client\";\nimport {\n  NotificationEndpointConfiguration,\n  OrgInfo,\n  SignerSessionManager,\n  SignerSessionStorage,\n} from \".\";\n\n/** Organization id */\nexport type OrgId = string;\n\n/** Org-wide policy */\nexport type OrgPolicy =\n  | SourceIpAllowlistPolicy\n  | OidcAuthSourcesPolicy\n  | OriginAllowlistPolicy\n  | MaxDailyUnstakePolicy;\n\n/**\n * Provides an allowlist of OIDC Issuers and audiences that are allowed to authenticate into this org.\n * @example {\"OidcAuthSources\": { \"https://accounts.google.com\": [ \"1234.apps.googleusercontent.com\" ]}}\n */\nexport interface OidcAuthSourcesPolicy {\n  OidcAuthSources: Record<string, string[]>;\n}\n\n/**\n * Only allow requests from the specified origins.\n * @example {\"OriginAllowlist\": \"*\"}\n */\nexport interface OriginAllowlistPolicy {\n  OriginAllowlist: string[] | \"*\";\n}\n\n/**\n * Restrict signing to specific source IP addresses.\n * @example {\"SourceIpAllowlist\": [\"10.1.2.3/8\", \"169.254.17.1/16\"]}\n */\nexport interface SourceIpAllowlistPolicy {\n  SourceIpAllowlist: string[];\n}\n\n/**\n * Restrict the number of unstakes per day.\n * @example {\"MaxDailyUnstake\": 5 }\n */\nexport interface MaxDailyUnstakePolicy {\n  MaxDailyUnstake: number;\n}\n\n/**\n * An organization.\n *\n * Extends {@link CubeSignerClient} and provides a few org-specific methods on top.\n */\nexport class Org extends CubeSignerClient {\n  /**\n   * @description The org id\n   * @example Org#c3b9379c-4e8c-4216-bd0a-65ace53cf98f\n   */\n  get id(): OrgId {\n    return this.orgId;\n  }\n\n  /**\n   * Obtain information about the current organization.\n   *\n   * Same as {@link orgGet}.\n   */\n  get info() {\n    return this.orgGet.bind(this);\n  }\n\n  /** Human-readable name for the org */\n  async name(): Promise<string | undefined> {\n    const org = await this.orgGet();\n    return org.name ?? undefined;\n  }\n\n  /** Get all keys in the org. */\n  get keys() {\n    return this.orgKeys.bind(this);\n  }\n\n  /**\n   * Set the human-readable name for the org.\n   * @param {string} name The new human-readable name for the org (must be alphanumeric).\n   * @example my_org_name\n   */\n  async setName(name: string) {\n    if (!/^[a-zA-Z0-9_]{3,30}$/.test(name)) {\n      throw new Error(\"Org name must be alphanumeric and between 3 and 30 characters\");\n    }\n    await this.orgUpdate({ name });\n  }\n\n  /** Is the org enabled? */\n  async enabled(): Promise<boolean> {\n    const org = await this.orgGet();\n    return org.enabled;\n  }\n\n  /** Enable the org. */\n  async enable() {\n    await this.orgUpdate({ enabled: true });\n  }\n\n  /** Disable the org. */\n  async disable() {\n    await this.orgUpdate({ enabled: false });\n  }\n\n  /** Get the policy for the org. */\n  async policy(): Promise<OrgPolicy[]> {\n    const org = await this.orgGet();\n    return (org.policy ?? []) as unknown as OrgPolicy[];\n  }\n\n  /**\n   * Set the policy for the org.\n   * @param {OrgPolicy[]} policy The new policy for the org.\n   */\n  async setPolicy(policy: OrgPolicy[]) {\n    const p = policy as unknown as Record<string, never>[];\n    await this.orgUpdate({ policy: p });\n  }\n\n  /**\n   * Set the notification endpoints for the org.\n   *\n   * @param {NotificationEndpointConfiguration[]} notification_endpoints Endpoints.\n   */\n  async setNotificationEndpoints(notification_endpoints: NotificationEndpointConfiguration[]) {\n    await this.orgUpdate({\n      notification_endpoints: notification_endpoints as unknown as Record<string, never>[],\n    });\n  }\n\n  /**\n   * Retrieve the org associated with a session.\n   * @param {SessionStorage} storage The session\n   * @return {Org} An {@link Org} instance for the org associated with this session.\n   */\n  static async retrieveFromStorage(storage: SignerSessionStorage): Promise<Org> {\n    const sessionMgr = await SignerSessionManager.loadFromStorage(storage);\n    return new Org(new CubeSignerClient(sessionMgr), sessionMgr.orgId);\n  }\n\n  /**\n   * Constructor.\n   * @param {CubeSignerClient | SignerSessionManager} csc The CubeSigner instance.\n   * @param {OrgInfo| string} data Either org id or name or {@link OrgInfo}.\n   */\n  constructor(csc: CubeSignerClient | SignerSessionManager, data?: OrgInfo | string) {\n    const mgr = csc instanceof CubeSignerClient ? csc.sessionMgr : (csc as SignerSessionManager);\n\n    // NOTE: data can be OrgInfo for backward compatibility reasons\n    const orgId = typeof data === \"string\" ? data : data?.org_id;\n    super(mgr, orgId);\n  }\n}\n"]}