@cubist-labs/cubesigner-sdk 0.1.23

package/dist/src/session/signer_session_manager.js

@@ -0,0 +1,159 @@
+"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 _SignerSessionManager_client;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignerSessionManager = void 0;
+const util_1 = require("../util");
+const session_manager_1 = require("./session_manager");
+const defaultSignerSessionLifetime = {
+    session: 604800,
+    auth: 300,
+    refresh: 86400,
+};
+/** Manager for signer sessions. */
+class SignerSessionManager extends session_manager_1.OrgSessionManager {
+    /**
+     * @return {string} The current auth token.
+     * @internal
+     */
+    async token() {
+        const session = await this.storage.retrieve();
+        return session.token;
+    }
+    /**
+     * Returns a client with the current session and refreshes the current
+     * session. May **UPDATE/MUTATE** self.
+     */
+    async client() {
+        await this.refreshIfNeeded();
+        return __classPrivateFieldGet(this, _SignerSessionManager_client, "f");
+    }
+    /** Revokes the session. */
+    async revoke() {
+        if (!this.cs) {
+            throw new Error("No management session available");
+        }
+        const session = await this.storage.retrieve();
+        const resp = await (await this.cs.management()).del("/v0/org/{org_id}/roles/{role_id}/tokens/{session_id}", {
+            params: {
+                path: {
+                    org_id: session.org_id,
+                    role_id: session.role_id,
+                    session_id: session.session_info.session_id,
+                },
+            },
+            parseAs: "json",
+        });
+        (0, util_1.assertOk)(resp);
+    }
+    /**
+     * Returns whether it's time to refresh this token.
+     * @return {boolean} Whether it's time to refresh this token.
+     * @internal
+     */
+    async isStale() {
+        const session = await this.storage.retrieve();
+        return this.hasExpired(session.session_info.auth_token_exp);
+    }
+    /**
+     * Refreshes the session and **UPDATES/MUTATES** self.
+     */
+    async refresh() {
+        const session = await this.storage.retrieve();
+        const csi = session.session_info;
+        const resp = await __classPrivateFieldGet(this, _SignerSessionManager_client, "f").patch("/v1/org/{org_id}/token/refresh", {
+            params: { path: { org_id: session.org_id } },
+            body: {
+                epoch_num: csi.epoch,
+                epoch_token: csi.epoch_token,
+                other_token: csi.refresh_token,
+            },
+            parseAs: "json",
+        });
+        const data = (0, util_1.assertOk)(resp);
+        await this.storage.save({
+            ...session,
+            session_info: data.session_info,
+            token: data.token,
+        });
+        __classPrivateFieldSet(this, _SignerSessionManager_client, this.createClient(data.token), "f");
+    }
+    /**
+     * Create a new signer session.
+     * @param {CubeSigner} cs The CubeSigner instance
+     * @param {SessionStorage<SignerSessionObject>} storage The session storage to use
+     * @param {string} orgId Org ID
+     * @param {string} roleId Role ID
+     * @param {string} purpose The purpose of the session
+     * @param {SignerSessionLifetime} ttl Lifetime settings
+     * @return {Promise<SignerSessionManager>} New signer session
+     */
+    static async create(cs, storage, orgId, roleId, purpose, ttl) {
+        const resp = await (await cs.management()).post("/v0/org/{org_id}/roles/{role_id}/tokens", {
+            params: { path: { org_id: orgId, role_id: roleId } },
+            body: {
+                purpose,
+                auth_lifetime: ttl?.auth || defaultSignerSessionLifetime.auth,
+                refresh_lifetime: ttl?.refresh || defaultSignerSessionLifetime.refresh,
+                session_lifetime: ttl?.session || defaultSignerSessionLifetime.session,
+            },
+            parseAs: "json",
+        });
+        const data = (0, util_1.assertOk)(resp);
+        const session_info = data.session_info;
+        if (!session_info) {
+            throw new Error("Signer session info missing");
+        }
+        await storage.save({
+            org_id: orgId,
+            role_id: roleId,
+            purpose,
+            token: data.token,
+            session_info,
+            // Keep compatibility with tokens produced by CLI
+            env: {
+                ["Dev-CubeSignerStack"]: cs.env,
+            },
+        });
+        return new SignerSessionManager(cs, orgId, roleId, data.token, storage);
+    }
+    /**
+     * Uses an existing session to create a new signer session manager.
+     * @param {CubeSigner} cs The CubeSigner instance
+     * @param {SessionStorage<SignerSessionObject>} storage The session storage to use
+     * @return {Promise<SingerSession>} New signer session manager
+     */
+    static async loadFromStorage(cs, storage) {
+        const session = await storage.retrieve();
+        return new SignerSessionManager(cs, session.org_id, session.role_id, session.token, storage);
+    }
+    /**
+     * Constructor.
+     * @param {CubeSigner} cs CubeSigner
+     * @param {string} orgId The id of the org associated with this session
+     * @param {string} roleId The id of the role that this session assumes
+     * @param {string} token The authorization token to use
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @internal
+     */
+    constructor(cs, orgId, roleId, token, storage) {
+        super(cs.env, orgId, storage);
+        _SignerSessionManager_client.set(this, void 0);
+        this.cs = cs;
+        this.roleId = roleId;
+        __classPrivateFieldSet(this, _SignerSessionManager_client, this.createClient(token), "f");
+    }
+}
+exports.SignerSessionManager = SignerSessionManager;
+_SignerSessionManager_client = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signer_session_manager.js","sourceRoot":"","sources":["../../../src/session/signer_session_manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { CubeSigner } from \"..\";\nimport { assertOk } from \"../util\";\nimport { components, paths, Client } from \"../client\";\nimport { HasEnv, OrgSessionManager } from \"./session_manager\";\nimport { SessionStorage } from \"./session_storage\";\n\nexport type ClientSessionInfo = components[\"schemas\"][\"ClientSessionInfo\"];\n\nexport type CreateSignerSessionRequest =\n  paths[\"/v0/org/{org_id}/roles/{role_id}/tokens\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type RefreshSignerSessionRequest =\n  paths[\"/v1/org/{org_id}/token/refresh\"][\"patch\"][\"requestBody\"][\"content\"][\"application/json\"];\n\n/** JSON representation of our \"signer session\" file format */\nexport interface SignerSessionObject {\n  /** The organization ID */\n  org_id: string;\n  /** The role ID */\n  role_id: string;\n  /** The purpose of the session token */\n  purpose: string;\n  /** The token to include in Authorization header */\n  token: string;\n  /** Session info */\n  session_info: ClientSessionInfo;\n}\n\nexport interface SignerSessionData extends SignerSessionObject, HasEnv {}\n\n/** Type of storage required for signer sessions */\nexport type SignerSessionStorage = SessionStorage<SignerSessionData>;\n\nexport interface SignerSessionLifetime {\n  /** Session lifetime (in seconds). Defaults to one week (604800). */\n  session?: number;\n  /** Auth token lifetime (in seconds). Defaults to five minutes (300). */\n  auth: number;\n  /** Refresh token lifetime (in seconds). Defaults to one day (86400). */\n  refresh?: number;\n}\n\nconst defaultSignerSessionLifetime: SignerSessionLifetime = {\n  session: 604800,\n  auth: 300,\n  refresh: 86400,\n};\n\n/** Manager for signer sessions. */\nexport class SignerSessionManager extends OrgSessionManager<SignerSessionData> {\n  readonly cs?: CubeSigner;\n  readonly roleId: string;\n  #client: Client;\n\n  /**\n   * @return {string} The current auth token.\n   * @internal\n   */\n  async token(): Promise<string> {\n    const session = await this.storage.retrieve();\n    return session.token;\n  }\n\n  /**\n   * Returns a client with the current session and refreshes the current\n   * session. May **UPDATE/MUTATE** self.\n   */\n  async client(): Promise<Client> {\n    await this.refreshIfNeeded();\n    return this.#client;\n  }\n\n  /** Revokes the session. */\n  async revoke(): Promise<void> {\n    if (!this.cs) {\n      throw new Error(\"No management session available\");\n    }\n    const session = await this.storage.retrieve();\n    const resp = await (\n      await this.cs.management()\n    ).del(\"/v0/org/{org_id}/roles/{role_id}/tokens/{session_id}\", {\n      params: {\n        path: {\n          org_id: session.org_id,\n          role_id: session.role_id,\n          session_id: session.session_info.session_id,\n        },\n      },\n      parseAs: \"json\",\n    });\n    assertOk(resp);\n  }\n\n  /**\n   * Returns whether it's time to refresh this token.\n   * @return {boolean} Whether it's time to refresh this token.\n   * @internal\n   */\n  async isStale(): Promise<boolean> {\n    const session = await this.storage.retrieve();\n    return this.hasExpired(session.session_info.auth_token_exp);\n  }\n\n  /**\n   * Refreshes the session and **UPDATES/MUTATES** self.\n   */\n  async refresh(): Promise<void> {\n    const session = await this.storage.retrieve();\n    const csi = session.session_info;\n    const resp = await this.#client.patch(\"/v1/org/{org_id}/token/refresh\", {\n      params: { path: { org_id: session.org_id } },\n      body: <RefreshSignerSessionRequest>{\n        epoch_num: csi.epoch,\n        epoch_token: csi.epoch_token,\n        other_token: csi.refresh_token,\n      },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    await this.storage.save(<SignerSessionData>{\n      ...session,\n      session_info: data.session_info,\n      token: data.token,\n    });\n    this.#client = this.createClient(data.token);\n  }\n\n  /**\n   * Create a new signer session.\n   * @param {CubeSigner} cs The CubeSigner instance\n   * @param {SessionStorage<SignerSessionObject>} storage The session storage to use\n   * @param {string} orgId Org ID\n   * @param {string} roleId Role ID\n   * @param {string} purpose The purpose of the session\n   * @param {SignerSessionLifetime} ttl Lifetime settings\n   * @return {Promise<SignerSessionManager>} New signer session\n   */\n  static async create(\n    cs: CubeSigner,\n    storage: SignerSessionStorage,\n    orgId: string,\n    roleId: string,\n    purpose: string,\n    ttl?: SignerSessionLifetime,\n  ): Promise<SignerSessionManager> {\n    const resp = await (\n      await cs.management()\n    ).post(\"/v0/org/{org_id}/roles/{role_id}/tokens\", {\n      params: { path: { org_id: orgId, role_id: roleId } },\n      body: {\n        purpose,\n        auth_lifetime: ttl?.auth || defaultSignerSessionLifetime.auth,\n        refresh_lifetime: ttl?.refresh || defaultSignerSessionLifetime.refresh,\n        session_lifetime: ttl?.session || defaultSignerSessionLifetime.session,\n      },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    const session_info = data.session_info;\n    if (!session_info) {\n      throw new Error(\"Signer session info missing\");\n    }\n    await storage.save({\n      org_id: orgId,\n      role_id: roleId,\n      purpose,\n      token: data.token,\n      session_info,\n      // Keep compatibility with tokens produced by CLI\n      env: {\n        [\"Dev-CubeSignerStack\"]: cs.env,\n      },\n    });\n    return new SignerSessionManager(cs, orgId, roleId, data.token, storage);\n  }\n\n  /**\n   * Uses an existing session to create a new signer session manager.\n   * @param {CubeSigner} cs The CubeSigner instance\n   * @param {SessionStorage<SignerSessionObject>} storage The session storage to use\n   * @return {Promise<SingerSession>} New signer session manager\n   */\n  static async loadFromStorage(\n    cs: CubeSigner,\n    storage: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    const session = await storage.retrieve();\n    return new SignerSessionManager(cs, session.org_id, session.role_id, session.token, storage);\n  }\n\n  /**\n   * Constructor.\n   * @param {CubeSigner} cs CubeSigner\n   * @param {string} orgId The id of the org associated with this session\n   * @param {string} roleId The id of the role that this session assumes\n   * @param {string} token The authorization token to use\n   * @param {SignerSessionStorage} storage The session storage to use\n   * @internal\n   */\n  private constructor(\n    cs: CubeSigner,\n    orgId: string,\n    roleId: string,\n    token: string,\n    storage: SignerSessionStorage,\n  ) {\n    super(cs.env, orgId, storage);\n    this.cs = cs;\n    this.roleId = roleId;\n    this.#client = this.createClient(token);\n  }\n}\n"]}

package/dist/src/sign.d.ts

@@ -0,0 +1,114 @@
+import { CubeSigner, Key, SignerSession } from ".";
+import { components, paths } from "./client";
+export type Eth1SignRequest = paths["/v1/org/{org_id}/eth1/sign/{pubkey}"]["post"]["requestBody"]["content"]["application/json"];
+export type Eth2SignRequest = paths["/v1/org/{org_id}/eth2/sign/{pubkey}"]["post"]["requestBody"]["content"]["application/json"];
+export type Eth2StakeRequest = paths["/v1/org/{org_id}/eth2/stake"]["post"]["requestBody"]["content"]["application/json"];
+export type Eth2UnstakeRequest = paths["/v1/org/{org_id}/eth2/unstake/{pubkey}"]["post"]["requestBody"]["content"]["application/json"];
+export type BlobSignRequest = paths["/v1/org/{org_id}/blob/sign/{key_id}"]["post"]["requestBody"]["content"]["application/json"];
+export type BtcSignRequest = paths["/v0/org/{org_id}/btc/sign/{pubkey}"]["post"]["requestBody"]["content"]["application/json"];
+export type SolanaSignRequest = paths["/v1/org/{org_id}/solana/sign/{pubkey}"]["post"]["requestBody"]["content"]["application/json"];
+export type Eth1SignResponse = components["responses"]["Eth1SignResponse"]["content"]["application/json"];
+export type Eth2SignResponse = components["responses"]["Eth2SignResponse"]["content"]["application/json"];
+export type Eth2StakeResponse = components["responses"]["StakeResponse"]["content"]["application/json"];
+export type Eth2UnstakeResponse = components["responses"]["UnstakeResponse"]["content"]["application/json"];
+export type BlobSignResponse = components["responses"]["BlobSignResponse"]["content"]["application/json"];
+export type BtcSignResponse = components["responses"]["BtcSignResponse"]["content"]["application/json"];
+export type SolanaSignResponse = components["responses"]["SolanaSignResponse"]["content"]["application/json"];
+export type MfaRequestInfo = components["responses"]["MfaRequestInfo"]["content"]["application/json"];
+export type AcceptedResponse = components["schemas"]["AcceptedResponse"];
+export type ErrorResponse = components["schemas"]["ErrorResponse"];
+export type BtcSignatureKind = components["schemas"]["BtcSignatureKind"];
+type SignFn<U> = (headers?: HeadersInit) => Promise<U | AcceptedResponse>;
+/**
+ * A response of a signing request.
+ */
+export declare class SignResponse<U> {
+    #private;
+    /** @return {boolean} True if this signing request requires an MFA approval */
+    requiresMfa(): boolean;
+    /** @return {U} The signed data */
+    data(): U;
+    /**
+     * Approves the MFA request.
+     *
+     * Note: This only works for MFA requests that require a single approval.
+     *
+     * @return {SignResponse<U>} The result of signing with the approval
+     */
+    approve(): Promise<SignResponse<U>>;
+    /**
+     * Constructor.
+     *
+     * @param {CubeSigner} cs The CubeSigner instance to use for requests
+     * @param {string} orgId The org id of the corresponding signing request
+     * @param {string} roleId The role id of the corresponding signing request
+     * @param {SignFn} signFn The signing function that this response is from.
+     *                        This argument is used to resend requests with
+     *                        different headers if needed.
+     * @param {U | AcceptedResponse} resp The response as returned by the OpenAPI
+     *                                    client.
+     */
+    constructor(cs: CubeSigner, orgId: string, roleId: string, signFn: SignFn<U>, resp: U | AcceptedResponse);
+}
+/**
+ * Wrapper around sign operations.
+ */
+export declare class Sign {
+    #private;
+    /**
+     * Submit an 'eth1' sign request.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {Eth1SignRequest} req What to sign.
+     * @return {Promise<Eth1SignResponse | AcceptedResponse>} Signature
+     */
+    eth1(key: Key | string, req: Eth1SignRequest): Promise<SignResponse<Eth1SignResponse>>;
+    /**
+     * Submit an 'eth2' sign request.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {Eth2SignRequest} req What to sign.
+     * @return {Promise<Eth2SignResponse | AcceptedResponse>} Signature
+     */
+    eth2(key: Key | string, req: Eth2SignRequest): Promise<SignResponse<Eth2SignResponse>>;
+    /**
+     * Sign a stake request.
+     * @param {Eth2StakeRequest} req The request to sign.
+     * @return {Promise<Eth2StakeResponse | AcceptedResponse>} The response.
+     */
+    stake(req: Eth2StakeRequest): Promise<SignResponse<Eth2StakeResponse>>;
+    /**
+     * Sign an unstake request.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {Eth2UnstakeRequest} req The request to sign.
+     * @return {Promise<Eth2UnstakeResponse | AcceptedResponse>} The response.
+     */
+    unstake(key: Key | string, req: Eth2UnstakeRequest): Promise<SignResponse<Eth2UnstakeResponse>>;
+    /**
+     * Sign a raw blob.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its ID).
+     * @param {BlobSignRequest} req What to sign
+     * @return {Promise<BlobSignResponse | AcceptedResponse>} The response.
+     */
+    blob(key: Key | string, req: BlobSignRequest): Promise<SignResponse<BlobSignResponse>>;
+    /**
+     * Sign a bitcoin message.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {BtcSignRequest} req What to sign
+     * @return {Promise<BtcSignResponse | AcceptedResponse>} The response.
+     */
+    btc(key: Key | string, req: BtcSignRequest): Promise<SignResponse<BtcSignResponse>>;
+    /**
+     * Sign a solana message.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {SolanaSignRequest} req What to sign
+     * @return {Promise<SolanaSignResponse | AcceptedResponse>} The response.
+     */
+    solana(key: Key | string, req: SolanaSignRequest): Promise<SignResponse<SolanaSignResponse>>;
+    /**
+     * Constructor.
+     *
+     * @param {string} orgId Organization ID
+     * @param {SignerSession} ss The signer session to use for signing requests
+     */
+    constructor(orgId: string, ss: SignerSession);
+}
+export {};

package/dist/src/sign.js

@@ -0,0 +1,248 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _SignResponse_cs, _SignResponse_orgId, _SignResponse_roleId, _SignResponse_signFn, _SignResponse_resp, _Sign_orgId, _Sign_ss;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sign = exports.SignResponse = void 0;
+const assert_1 = __importDefault(require("assert"));
+const _1 = require(".");
+const env_1 = require("./env");
+/**
+ * A response of a signing request.
+ */
+class SignResponse {
+    /** @return {boolean} True if this signing request requires an MFA approval */
+    requiresMfa() {
+        return __classPrivateFieldGet(this, _SignResponse_resp, "f").accepted?.MfaRequired !== undefined;
+    }
+    /** @return {U} The signed data */
+    data() {
+        return __classPrivateFieldGet(this, _SignResponse_resp, "f");
+    }
+    /**
+     * Approves the MFA request.
+     *
+     * Note: This only works for MFA requests that require a single approval.
+     *
+     * @return {SignResponse<U>} The result of signing with the approval
+     */
+    async approve() {
+        const mfaRequired = __classPrivateFieldGet(this, _SignResponse_resp, "f").accepted?.MfaRequired;
+        if (!mfaRequired) {
+            throw new Error("Request does not require MFA approval");
+        }
+        const mfaId = mfaRequired.id;
+        const mfaApproval = await _1.Role.mfaApprove(__classPrivateFieldGet(this, _SignResponse_cs, "f"), __classPrivateFieldGet(this, _SignResponse_orgId, "f"), __classPrivateFieldGet(this, _SignResponse_roleId, "f"), mfaId);
+        (0, assert_1.default)(mfaApproval.id === mfaId);
+        (0, assert_1.default)(mfaApproval.receipt);
+        const mfaConf = mfaApproval.receipt?.confirmation;
+        if (!mfaConf) {
+            throw new Error("MfaRequest has not been approved yet");
+        }
+        const headers = {
+            "x-cubist-mfa-id": mfaId,
+            "x-cubist-mfa-confirmation": mfaConf,
+        };
+        return new SignResponse(__classPrivateFieldGet(this, _SignResponse_cs, "f"), __classPrivateFieldGet(this, _SignResponse_orgId, "f"), __classPrivateFieldGet(this, _SignResponse_roleId, "f"), __classPrivateFieldGet(this, _SignResponse_signFn, "f"), await __classPrivateFieldGet(this, _SignResponse_signFn, "f").call(this, headers));
+    }
+    // --------------------------------------------------------------------------
+    // -- INTERNAL --------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    /**
+     * Constructor.
+     *
+     * @param {CubeSigner} cs The CubeSigner instance to use for requests
+     * @param {string} orgId The org id of the corresponding signing request
+     * @param {string} roleId The role id of the corresponding signing request
+     * @param {SignFn} signFn The signing function that this response is from.
+     *                        This argument is used to resend requests with
+     *                        different headers if needed.
+     * @param {U | AcceptedResponse} resp The response as returned by the OpenAPI
+     *                                    client.
+     */
+    constructor(cs, orgId, roleId, signFn, resp) {
+        _SignResponse_cs.set(this, void 0);
+        _SignResponse_orgId.set(this, void 0);
+        _SignResponse_roleId.set(this, void 0);
+        _SignResponse_signFn.set(this, void 0);
+        _SignResponse_resp.set(this, void 0);
+        __classPrivateFieldSet(this, _SignResponse_cs, cs, "f");
+        __classPrivateFieldSet(this, _SignResponse_orgId, orgId, "f");
+        __classPrivateFieldSet(this, _SignResponse_roleId, roleId, "f");
+        __classPrivateFieldSet(this, _SignResponse_signFn, signFn, "f");
+        __classPrivateFieldSet(this, _SignResponse_resp, resp, "f");
+    }
+}
+exports.SignResponse = SignResponse;
+_SignResponse_cs = new WeakMap(), _SignResponse_orgId = new WeakMap(), _SignResponse_roleId = new WeakMap(), _SignResponse_signFn = new WeakMap(), _SignResponse_resp = new WeakMap();
+/**
+ * Wrapper around sign operations.
+ */
+class Sign {
+    /**
+     * Submit an 'eth1' sign request.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {Eth1SignRequest} req What to sign.
+     * @return {Promise<Eth1SignResponse | AcceptedResponse>} Signature
+     */
+    async eth1(key, req) {
+        const pubkey = typeof key === "string" ? key : key.materialId;
+        const sign = async (headers) => {
+            const resp = await (await __classPrivateFieldGet(this, _Sign_ss, "f").client()).post("/v1/org/{org_id}/eth1/sign/{pubkey}", {
+                params: { path: { org_id: __classPrivateFieldGet(this, _Sign_orgId, "f"), pubkey } },
+                body: req,
+                headers: headers,
+                parseAs: "json",
+            });
+            return (0, env_1.assertOk)(resp);
+        };
+        return new SignResponse(__classPrivateFieldGet(this, _Sign_ss, "f").cs, __classPrivateFieldGet(this, _Sign_orgId, "f"), __classPrivateFieldGet(this, _Sign_ss, "f").roleId, sign, await sign());
+    }
+    /**
+     * Submit an 'eth2' sign request.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {Eth2SignRequest} req What to sign.
+     * @return {Promise<Eth2SignResponse | AcceptedResponse>} Signature
+     */
+    async eth2(key, req) {
+        const pubkey = typeof key === "string" ? key : key.materialId;
+        const sign = async (headers) => {
+            const resp = await (await __classPrivateFieldGet(this, _Sign_ss, "f").client()).post("/v1/org/{org_id}/eth2/sign/{pubkey}", {
+                params: { path: { org_id: __classPrivateFieldGet(this, _Sign_orgId, "f"), pubkey } },
+                body: req,
+                headers: headers,
+                parseAs: "json",
+            });
+            return (0, env_1.assertOk)(resp);
+        };
+        return new SignResponse(__classPrivateFieldGet(this, _Sign_ss, "f").cs, __classPrivateFieldGet(this, _Sign_orgId, "f"), __classPrivateFieldGet(this, _Sign_ss, "f").roleId, sign, await sign());
+    }
+    /**
+     * Sign a stake request.
+     * @param {Eth2StakeRequest} req The request to sign.
+     * @return {Promise<Eth2StakeResponse | AcceptedResponse>} The response.
+     */
+    async stake(req) {
+        const sign = async (headers) => {
+            const resp = await (await __classPrivateFieldGet(this, _Sign_ss, "f").client()).post("/v1/org/{org_id}/eth2/stake", {
+                params: { path: { org_id: __classPrivateFieldGet(this, _Sign_orgId, "f") } },
+                body: req,
+                headers: headers,
+                parseAs: "json",
+            });
+            return (0, env_1.assertOk)(resp);
+        };
+        return new SignResponse(__classPrivateFieldGet(this, _Sign_ss, "f").cs, __classPrivateFieldGet(this, _Sign_orgId, "f"), __classPrivateFieldGet(this, _Sign_ss, "f").roleId, sign, await sign());
+    }
+    /**
+     * Sign an unstake request.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {Eth2UnstakeRequest} req The request to sign.
+     * @return {Promise<Eth2UnstakeResponse | AcceptedResponse>} The response.
+     */
+    async unstake(key, req) {
+        const pubkey = typeof key === "string" ? key : key.materialId;
+        const sign = async (headers) => {
+            const resp = await (await __classPrivateFieldGet(this, _Sign_ss, "f").client()).post("/v1/org/{org_id}/eth2/unstake/{pubkey}", {
+                params: { path: { org_id: __classPrivateFieldGet(this, _Sign_orgId, "f"), pubkey } },
+                body: req,
+                headers: headers,
+                parseAs: "json",
+            });
+            return (0, env_1.assertOk)(resp);
+        };
+        return new SignResponse(__classPrivateFieldGet(this, _Sign_ss, "f").cs, __classPrivateFieldGet(this, _Sign_orgId, "f"), __classPrivateFieldGet(this, _Sign_ss, "f").roleId, sign, await sign());
+    }
+    /**
+     * Sign a raw blob.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its ID).
+     * @param {BlobSignRequest} req What to sign
+     * @return {Promise<BlobSignResponse | AcceptedResponse>} The response.
+     */
+    async blob(key, req) {
+        const key_id = typeof key === "string" ? key : key.id;
+        const sign = async (headers) => {
+            const resp = await (await __classPrivateFieldGet(this, _Sign_ss, "f").client()).post("/v1/org/{org_id}/blob/sign/{key_id}", {
+                params: {
+                    path: { org_id: __classPrivateFieldGet(this, _Sign_orgId, "f"), key_id },
+                },
+                body: req,
+                headers: headers,
+                parseAs: "json",
+            });
+            return (0, env_1.assertOk)(resp);
+        };
+        return new SignResponse(__classPrivateFieldGet(this, _Sign_ss, "f").cs, __classPrivateFieldGet(this, _Sign_orgId, "f"), __classPrivateFieldGet(this, _Sign_ss, "f").roleId, sign, await sign());
+    }
+    /**
+     * Sign a bitcoin message.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {BtcSignRequest} req What to sign
+     * @return {Promise<BtcSignResponse | AcceptedResponse>} The response.
+     */
+    async btc(key, req) {
+        const pubkey = typeof key === "string" ? key : key.materialId;
+        const sign = async (headers) => {
+            const resp = await (await __classPrivateFieldGet(this, _Sign_ss, "f").client()).post("/v0/org/{org_id}/btc/sign/{pubkey}", {
+                params: {
+                    path: { org_id: __classPrivateFieldGet(this, _Sign_orgId, "f"), pubkey },
+                },
+                body: req,
+                headers: headers,
+                parseAs: "json",
+            });
+            return (0, env_1.assertOk)(resp);
+        };
+        return new SignResponse(__classPrivateFieldGet(this, _Sign_ss, "f").cs, __classPrivateFieldGet(this, _Sign_orgId, "f"), __classPrivateFieldGet(this, _Sign_ss, "f").roleId, sign, await sign());
+    }
+    /**
+     * Sign a solana message.
+     * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).
+     * @param {SolanaSignRequest} req What to sign
+     * @return {Promise<SolanaSignResponse | AcceptedResponse>} The response.
+     */
+    async solana(key, req) {
+        const pubkey = typeof key === "string" ? key : key.materialId;
+        const sign = async (headers) => {
+            const resp = await (await __classPrivateFieldGet(this, _Sign_ss, "f").client()).post("/v1/org/{org_id}/solana/sign/{pubkey}", {
+                params: { path: { org_id: __classPrivateFieldGet(this, _Sign_orgId, "f"), pubkey } },
+                body: req,
+                headers: headers,
+                parseAs: "json",
+            });
+            return (0, env_1.assertOk)(resp);
+        };
+        return new SignResponse(__classPrivateFieldGet(this, _Sign_ss, "f").cs, __classPrivateFieldGet(this, _Sign_orgId, "f"), __classPrivateFieldGet(this, _Sign_ss, "f").roleId, sign, await sign());
+    }
+    // --------------------------------------------------------------------------
+    // -- INTERNAL --------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    /* eslint-disable require-jsdoc */
+    /**
+     * Constructor.
+     *
+     * @param {string} orgId Organization ID
+     * @param {SignerSession} ss The signer session to use for signing requests
+     */
+    constructor(orgId, ss) {
+        _Sign_orgId.set(this, void 0);
+        _Sign_ss.set(this, void 0);
+        __classPrivateFieldSet(this, _Sign_orgId, orgId, "f");
+        __classPrivateFieldSet(this, _Sign_ss, ss, "f");
+    }
+}
+exports.Sign = Sign;
+_Sign_orgId = new WeakMap(), _Sign_ss = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign.js","sourceRoot":"","sources":["../../src/sign.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from \"assert\";\nimport { CubeSigner, Key, Role, SignerSession } from \".\";\nimport { components, paths } from \"./client\";\nimport { assertOk } from \"./env\";\n\n/* eslint-disable */\nexport type Eth1SignRequest =\n  paths[\"/v1/org/{org_id}/eth1/sign/{pubkey}\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type Eth2SignRequest =\n  paths[\"/v1/org/{org_id}/eth2/sign/{pubkey}\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type Eth2StakeRequest =\n  paths[\"/v1/org/{org_id}/eth2/stake\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type Eth2UnstakeRequest =\n  paths[\"/v1/org/{org_id}/eth2/unstake/{pubkey}\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type BlobSignRequest =\n  paths[\"/v1/org/{org_id}/blob/sign/{key_id}\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type BtcSignRequest =\n  paths[\"/v0/org/{org_id}/btc/sign/{pubkey}\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type SolanaSignRequest =\n  paths[\"/v1/org/{org_id}/solana/sign/{pubkey}\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\n\nexport type Eth1SignResponse =\n  components[\"responses\"][\"Eth1SignResponse\"][\"content\"][\"application/json\"];\nexport type Eth2SignResponse =\n  components[\"responses\"][\"Eth2SignResponse\"][\"content\"][\"application/json\"];\nexport type Eth2StakeResponse =\n  components[\"responses\"][\"StakeResponse\"][\"content\"][\"application/json\"];\nexport type Eth2UnstakeResponse =\n  components[\"responses\"][\"UnstakeResponse\"][\"content\"][\"application/json\"];\nexport type BlobSignResponse =\n  components[\"responses\"][\"BlobSignResponse\"][\"content\"][\"application/json\"];\nexport type BtcSignResponse =\n  components[\"responses\"][\"BtcSignResponse\"][\"content\"][\"application/json\"];\nexport type SolanaSignResponse =\n  components[\"responses\"][\"SolanaSignResponse\"][\"content\"][\"application/json\"];\nexport type MfaRequestInfo =\n  components[\"responses\"][\"MfaRequestInfo\"][\"content\"][\"application/json\"];\n\nexport type AcceptedResponse = components[\"schemas\"][\"AcceptedResponse\"];\nexport type ErrorResponse = components[\"schemas\"][\"ErrorResponse\"];\nexport type BtcSignatureKind = components[\"schemas\"][\"BtcSignatureKind\"];\n/* eslint-enable */\n\ntype SignFn<U> = (headers?: HeadersInit) => Promise<U | AcceptedResponse>;\n\n/**\n * A response of a signing request.\n */\nexport class SignResponse<U> {\n  readonly #cs: CubeSigner;\n  readonly #orgId: string;\n  readonly #roleId: string;\n  readonly #signFn: SignFn<U>;\n  readonly #resp: U | AcceptedResponse;\n\n  /** @return {boolean} True if this signing request requires an MFA approval */\n  requiresMfa(): boolean {\n    return (this.#resp as AcceptedResponse).accepted?.MfaRequired !== undefined;\n  }\n\n  /** @return {U} The signed data */\n  data(): U {\n    return this.#resp as U;\n  }\n\n  /**\n   * Approves the MFA request.\n   *\n   * Note: This only works for MFA requests that require a single approval.\n   *\n   * @return {SignResponse<U>} The result of signing with the approval\n   */\n  async approve(): Promise<SignResponse<U>> {\n    const mfaRequired = (this.#resp as AcceptedResponse).accepted?.MfaRequired;\n    if (!mfaRequired) {\n      throw new Error(\"Request does not require MFA approval\");\n    }\n\n    const mfaId = mfaRequired.id;\n    const mfaApproval = await Role.mfaApprove(this.#cs, this.#orgId, this.#roleId, mfaId);\n    assert(mfaApproval.id === mfaId);\n    assert(mfaApproval.receipt);\n\n    const mfaConf = mfaApproval.receipt?.confirmation;\n    if (!mfaConf) {\n      throw new Error(\"MfaRequest has not been approved yet\");\n    }\n\n    const headers = {\n      \"x-cubist-mfa-id\": mfaId,\n      \"x-cubist-mfa-confirmation\": mfaConf,\n    };\n    return new SignResponse(\n      this.#cs,\n      this.#orgId,\n      this.#roleId,\n      this.#signFn,\n      await this.#signFn(headers),\n    );\n  }\n\n  // --------------------------------------------------------------------------\n  // -- INTERNAL --------------------------------------------------------------\n  // --------------------------------------------------------------------------\n\n  /**\n   * Constructor.\n   *\n   * @param {CubeSigner} cs The CubeSigner instance to use for requests\n   * @param {string} orgId The org id of the corresponding signing request\n   * @param {string} roleId The role id of the corresponding signing request\n   * @param {SignFn} signFn The signing function that this response is from.\n   *                        This argument is used to resend requests with\n   *                        different headers if needed.\n   * @param {U | AcceptedResponse} resp The response as returned by the OpenAPI\n   *                                    client.\n   */\n  constructor(\n    cs: CubeSigner,\n    orgId: string,\n    roleId: string,\n    signFn: SignFn<U>,\n    resp: U | AcceptedResponse,\n  ) {\n    this.#cs = cs;\n    this.#orgId = orgId;\n    this.#roleId = roleId;\n    this.#signFn = signFn;\n    this.#resp = resp;\n  }\n}\n\n/**\n * Wrapper around sign operations.\n */\nexport class Sign {\n  readonly #orgId: string;\n  readonly #ss: SignerSession;\n\n  /**\n   * Submit an 'eth1' sign request.\n   * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).\n   * @param {Eth1SignRequest} req What to sign.\n   * @return {Promise<Eth1SignResponse | AcceptedResponse>} Signature\n   */\n  async eth1(key: Key | string, req: Eth1SignRequest): Promise<SignResponse<Eth1SignResponse>> {\n    const pubkey = typeof key === \"string\" ? (key as string) : key.materialId;\n    const sign = async (headers?: HeadersInit) => {\n      const resp = await (\n        await this.#ss.client()\n      ).post(\"/v1/org/{org_id}/eth1/sign/{pubkey}\", {\n        params: { path: { org_id: this.#orgId, pubkey } },\n        body: req,\n        headers: headers,\n        parseAs: \"json\",\n      });\n      return assertOk(resp);\n    };\n    return new SignResponse(this.#ss.cs, this.#orgId, this.#ss.roleId, sign, await sign());\n  }\n\n  /**\n   * Submit an 'eth2' sign request.\n   * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).\n   * @param {Eth2SignRequest} req What to sign.\n   * @return {Promise<Eth2SignResponse | AcceptedResponse>} Signature\n   */\n  async eth2(key: Key | string, req: Eth2SignRequest): Promise<SignResponse<Eth2SignResponse>> {\n    const pubkey = typeof key === \"string\" ? (key as string) : key.materialId;\n    const sign = async (headers?: HeadersInit) => {\n      const resp = await (\n        await this.#ss.client()\n      ).post(\"/v1/org/{org_id}/eth2/sign/{pubkey}\", {\n        params: { path: { org_id: this.#orgId, pubkey } },\n        body: req,\n        headers: headers,\n        parseAs: \"json\",\n      });\n      return assertOk(resp);\n    };\n    return new SignResponse(this.#ss.cs, this.#orgId, this.#ss.roleId, sign, await sign());\n  }\n\n  /**\n   * Sign a stake request.\n   * @param {Eth2StakeRequest} req The request to sign.\n   * @return {Promise<Eth2StakeResponse | AcceptedResponse>} The response.\n   */\n  async stake(req: Eth2StakeRequest): Promise<SignResponse<Eth2StakeResponse>> {\n    const sign = async (headers?: HeadersInit) => {\n      const resp = await (\n        await this.#ss.client()\n      ).post(\"/v1/org/{org_id}/eth2/stake\", {\n        params: { path: { org_id: this.#orgId } },\n        body: req,\n        headers: headers,\n        parseAs: \"json\",\n      });\n      return assertOk(resp);\n    };\n    return new SignResponse(this.#ss.cs, this.#orgId, this.#ss.roleId, sign, await sign());\n  }\n\n  /**\n   * Sign an unstake request.\n   * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).\n   * @param {Eth2UnstakeRequest} req The request to sign.\n   * @return {Promise<Eth2UnstakeResponse | AcceptedResponse>} The response.\n   */\n  async unstake(\n    key: Key | string,\n    req: Eth2UnstakeRequest,\n  ): Promise<SignResponse<Eth2UnstakeResponse>> {\n    const pubkey = typeof key === \"string\" ? (key as string) : key.materialId;\n    const sign = async (headers?: HeadersInit) => {\n      const resp = await (\n        await this.#ss.client()\n      ).post(\"/v1/org/{org_id}/eth2/unstake/{pubkey}\", {\n        params: { path: { org_id: this.#orgId, pubkey } },\n        body: req,\n        headers: headers,\n        parseAs: \"json\",\n      });\n      return assertOk(resp);\n    };\n    return new SignResponse(this.#ss.cs, this.#orgId, this.#ss.roleId, sign, await sign());\n  }\n\n  /**\n   * Sign a raw blob.\n   * @param {Key | string} key The key to sign with (either {@link Key} or its ID).\n   * @param {BlobSignRequest} req What to sign\n   * @return {Promise<BlobSignResponse | AcceptedResponse>} The response.\n   */\n  async blob(key: Key | string, req: BlobSignRequest): Promise<SignResponse<BlobSignResponse>> {\n    const key_id = typeof key === \"string\" ? (key as string) : key.id;\n    const sign = async (headers?: HeadersInit) => {\n      const resp = await (\n        await this.#ss.client()\n      ).post(\"/v1/org/{org_id}/blob/sign/{key_id}\", {\n        params: {\n          path: { org_id: this.#orgId, key_id },\n        },\n        body: req,\n        headers: headers,\n        parseAs: \"json\",\n      });\n      return assertOk(resp);\n    };\n    return new SignResponse(this.#ss.cs, this.#orgId, this.#ss.roleId, sign, await sign());\n  }\n\n  /**\n   * Sign a bitcoin message.\n   * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).\n   * @param {BtcSignRequest} req What to sign\n   * @return {Promise<BtcSignResponse | AcceptedResponse>} The response.\n   */\n  async btc(key: Key | string, req: BtcSignRequest): Promise<SignResponse<BtcSignResponse>> {\n    const pubkey = typeof key === \"string\" ? (key as string) : key.materialId;\n    const sign = async (headers?: HeadersInit) => {\n      const resp = await (\n        await this.#ss.client()\n      ).post(\"/v0/org/{org_id}/btc/sign/{pubkey}\", {\n        params: {\n          path: { org_id: this.#orgId, pubkey },\n        },\n        body: req,\n        headers: headers,\n        parseAs: \"json\",\n      });\n      return assertOk(resp);\n    };\n    return new SignResponse(this.#ss.cs, this.#orgId, this.#ss.roleId, sign, await sign());\n  }\n\n  /**\n   * Sign a solana message.\n   * @param {Key | string} key The key to sign with (either {@link Key} or its material ID).\n   * @param {SolanaSignRequest} req What to sign\n   * @return {Promise<SolanaSignResponse | AcceptedResponse>} The response.\n   */\n  async solana(\n    key: Key | string,\n    req: SolanaSignRequest,\n  ): Promise<SignResponse<SolanaSignResponse>> {\n    const pubkey = typeof key === \"string\" ? (key as string) : key.materialId;\n    const sign = async (headers?: HeadersInit) => {\n      const resp = await (\n        await this.#ss.client()\n      ).post(\"/v1/org/{org_id}/solana/sign/{pubkey}\", {\n        params: { path: { org_id: this.#orgId, pubkey } },\n        body: req,\n        headers: headers,\n        parseAs: \"json\",\n      });\n      return assertOk(resp);\n    };\n    return new SignResponse(this.#ss.cs, this.#orgId, this.#ss.roleId, sign, await sign());\n  }\n\n  // --------------------------------------------------------------------------\n  // -- INTERNAL --------------------------------------------------------------\n  // --------------------------------------------------------------------------\n\n  /* eslint-disable require-jsdoc */\n\n  /**\n   * Constructor.\n   *\n   * @param {string} orgId Organization ID\n   * @param {SignerSession} ss The signer session to use for signing requests\n   */\n  constructor(orgId: string, ss: SignerSession) {\n    this.#orgId = orgId;\n    this.#ss = ss;\n  }\n}\n"]}