@cubist-labs/cubesigner-sdk 0.1.23

package/dist/src/index.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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 _CubeSigner_env;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ethers = exports.CubeSigner = void 0;
+const env_1 = require("./env");
+const org_1 = require("./org");
+const session_storage_1 = require("./session/session_storage");
+const signer_session_1 = require("./signer_session");
+const management_session_manager_1 = require("./session/management_session_manager");
+const oidc_session_manager_1 = require("./session/oidc_session_manager");
+const util_1 = require("./util");
+const path = __importStar(require("path"));
+/** CubeSigner client */
+class CubeSigner {
+    /** @return {EnvInterface} The CubeSigner environment of this client */
+    get env() {
+        return __classPrivateFieldGet(this, _CubeSigner_env, "f");
+    }
+    /**
+     * Loads an existing management session and creates a CubeSigner instance.
+     * @param {ManagementSessionStorage} storage Optional session storage to load
+     * the session from. If not specified, the management session from the config
+     * directory will be loaded.
+     * @return {Promise<CubeSigner>} New CubeSigner instance
+     */
+    static async loadManagementSession(storage) {
+        const defaultFilePath = path.join((0, util_1.configDir)(), "management-session.json");
+        const sessionMgr = await management_session_manager_1.ManagementSessionManager.loadFromStorage(storage ?? new session_storage_1.JsonFileSessionStorage(defaultFilePath));
+        return new CubeSigner({
+            sessionMgr,
+        });
+    }
+    /**
+     * Loads a signer session from a session storage (e.g., session file).
+     * @param {SignerSessionStorage} storage Optional session storage to load
+     * the session from. If not specified, the signer session from the config
+     * directory will be loaded.
+     * @return {Promise<SignerSession>} New signer session
+     */
+    static async loadSignerSession(storage) {
+        const defaultFilePath = path.join((0, util_1.configDir)(), "signer-session.json");
+        const sss = storage ?? new session_storage_1.JsonFileSessionStorage(defaultFilePath);
+        const env = (await sss.retrieve()).env["Dev-CubeSignerStack"];
+        return await signer_session_1.SignerSession.loadSignerSession(new CubeSigner({ env }), sss);
+    }
+    /**
+     * Loads a signer session from OIDC storage
+     * @param {OidcSessionStorage} storage The storage to load from
+     * @return {Promise<SignerSession>} New signer session
+     */
+    static async loadOidcSession(storage) {
+        const env = (await storage.retrieve()).env;
+        return await signer_session_1.SignerSession.loadOidcSession(new CubeSigner({ env }), storage);
+    }
+    /**
+     * Create a new CubeSigner instance.
+     * @param {CubeSignerOptions} options The options for the CubeSigner instance.
+     */
+    constructor(options) {
+        _CubeSigner_env.set(this, void 0);
+        let env = options.env;
+        if (options.sessionMgr) {
+            this.sessionMgr = options.sessionMgr;
+            env = env ?? this.sessionMgr.env;
+        }
+        __classPrivateFieldSet(this, _CubeSigner_env, env ?? env_1.envs["gamma"], "f");
+    }
+    /**
+     * Authenticate an OIDC user and create a new OIDC session manager for them.
+     * @param {string} oidcToken The OIDC token
+     * @param {string} orgId The id of the organization that the user is in
+     * @param {List<string>} scopes The scopes of the resulting session
+     * @param {OidcSessionStorage} storage The signer session storage
+     * @return {Promise<OidcSessionManager>} The OIDC session manager
+     */
+    async createOidcManager(oidcToken, orgId, scopes, storage) {
+        return await oidc_session_manager_1.OidcSessionManager.create(this.env, storage || new session_storage_1.MemorySessionStorage(), oidcToken, orgId, scopes);
+    }
+    /**
+     * Authenticate an OIDC user and create a new session for them.
+     * @param {string} oidcToken The OIDC token
+     * @param {string} orgId The id of the organization that the user is in
+     * @param {List<string>} scopes The scopes of the resulting session
+     * @param {OidcSessionStorage} storage The signer session storage
+     * @return {Promise<SignerSession>} The signer session
+     */
+    async createOidcSession(oidcToken, orgId, scopes, storage) {
+        const mgr = await this.createOidcManager(oidcToken, orgId, scopes, storage);
+        return await CubeSigner.loadOidcSession(mgr.storage);
+    }
+    /** Retrieves information about the current user. */
+    async aboutMe() {
+        const resp = await (await this.management()).get("/v0/about_me", {
+            parseAs: "json",
+        });
+        const data = (0, util_1.assertOk)(resp);
+        return data;
+    }
+    /**
+     * Creates and sets a new TOTP configuration for the logged-in user,
+     * overriding the existing one (if any).
+     */
+    async resetTotp() {
+        const resp = await (await this.management()).patch("/v0/totp", {
+            parseAs: "json",
+        });
+        return (0, util_1.assertOk)(resp);
+    }
+    /**
+     * Verifies a given TOTP code against the current user's TOTP configuration.
+     * Throws an error if the verification fails.
+     * @param {string} code Current TOTP code
+     */
+    async verifyTotp(code) {
+        const resp = await (await this.management()).get("/v0/totp/verify/{code}", {
+            params: { path: { code } },
+            parseAs: "json",
+        });
+        (0, util_1.assertOk)(resp);
+    }
+    /** Retrieves information about an organization.
+     * @param {string} orgId The ID or name of the organization.
+     * @return {Org} The organization.
+     * */
+    async getOrg(orgId) {
+        const resp = await (await this.management()).get("/v0/org/{org_id}", {
+            params: { path: { org_id: orgId } },
+            parseAs: "json",
+        });
+        const data = (0, util_1.assertOk)(resp);
+        return new org_1.Org(this, data);
+    }
+    /** Get the management client.
+     * @return {Client} The client.
+     * @internal
+     * */
+    async management() {
+        if (!this.sessionMgr) {
+            throw new Error("No management session loaded");
+        }
+        return await this.sessionMgr.client();
+    }
+}
+exports.CubeSigner = CubeSigner;
+_CubeSigner_env = new WeakMap();
+/** Organizations */
+__exportStar(require("./org"), exports);
+/** Keys */
+__exportStar(require("./key"), exports);
+/** Roles */
+__exportStar(require("./role"), exports);
+/** Env */
+__exportStar(require("./env"), exports);
+/** Sessions */
+__exportStar(require("./signer_session"), exports);
+/** Session storage */
+__exportStar(require("./session/session_storage"), exports);
+/** Session manager */
+__exportStar(require("./session/session_manager"), exports);
+/** Management session manager */
+__exportStar(require("./session/management_session_manager"), exports);
+/** OIDC session manager */
+__exportStar(require("./session/oidc_session_manager"), exports);
+/** Signer session manager */
+__exportStar(require("./session/signer_session_manager"), exports);
+/** Export ethers.js Signer */
+exports.ethers = __importStar(require("./ethers"));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { envs, EnvInterface } from \"./env\";\nimport { components, Client } from \"./client\";\nimport { Org } from \"./org\";\nimport { JsonFileSessionStorage, MemorySessionStorage } from \"./session/session_storage\";\nimport { SignerSessionStorage } from \"./session/signer_session_manager\";\nimport { SignerSession } from \"./signer_session\";\nimport {\n  ManagementSessionManager,\n  ManagementSessionStorage,\n} from \"./session/management_session_manager\";\nimport { OidcSessionManager, OidcSessionStorage } from \"./session/oidc_session_manager\";\nimport { assertOk, configDir } from \"./util\";\nimport * as path from \"path\";\n\n/** CubeSigner constructor options */\nexport interface CubeSignerOptions {\n  /** The environment to use */\n  env?: EnvInterface;\n  /** The management authorization token */\n  sessionMgr?: ManagementSessionManager | OidcSessionManager;\n}\n\nexport type UserInfo = components[\"schemas\"][\"UserInfo\"];\nexport type TotpInfo = components[\"responses\"][\"TotpInfo\"][\"content\"][\"application/json\"];\nexport type ConfiguredMfa = components[\"schemas\"][\"ConfiguredMfa\"];\n\n/** CubeSigner client */\nexport class CubeSigner {\n  readonly #env: EnvInterface;\n  readonly sessionMgr?: ManagementSessionManager | OidcSessionManager;\n\n  /** @return {EnvInterface} The CubeSigner environment of this client */\n  get env(): EnvInterface {\n    return this.#env;\n  }\n\n  /**\n   * Loads an existing management session and creates a CubeSigner instance.\n   * @param {ManagementSessionStorage} storage Optional session storage to load\n   * the session from. If not specified, the management session from the config\n   * directory will be loaded.\n   * @return {Promise<CubeSigner>} New CubeSigner instance\n   */\n  static async loadManagementSession(storage?: ManagementSessionStorage): Promise<CubeSigner> {\n    const defaultFilePath = path.join(configDir(), \"management-session.json\");\n    const sessionMgr = await ManagementSessionManager.loadFromStorage(\n      storage ?? new JsonFileSessionStorage(defaultFilePath),\n    );\n    return new CubeSigner(<CubeSignerOptions>{\n      sessionMgr,\n    });\n  }\n\n  /**\n   * Loads a signer session from a session storage (e.g., session file).\n   * @param {SignerSessionStorage} storage Optional session storage to load\n   * the session from. If not specified, the signer session from the config\n   * directory will be loaded.\n   * @return {Promise<SignerSession>} New signer session\n   */\n  static async loadSignerSession(storage?: SignerSessionStorage): Promise<SignerSession> {\n    const defaultFilePath = path.join(configDir(), \"signer-session.json\");\n    const sss = storage ?? new JsonFileSessionStorage(defaultFilePath);\n    const env = (await sss.retrieve()).env[\"Dev-CubeSignerStack\"];\n    return await SignerSession.loadSignerSession(new CubeSigner({ env }), sss);\n  }\n\n  /**\n   * Loads a signer session from OIDC storage\n   * @param {OidcSessionStorage} storage The storage to load from\n   * @return {Promise<SignerSession>} New signer session\n   */\n  static async loadOidcSession(storage: OidcSessionStorage): Promise<SignerSession> {\n    const env = (await storage.retrieve()).env;\n    return await SignerSession.loadOidcSession(new CubeSigner({ env }), storage);\n  }\n\n  /**\n   * Create a new CubeSigner instance.\n   * @param {CubeSignerOptions} options The 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  }\n\n  /**\n   * Authenticate an OIDC user and create a new OIDC session manager for them.\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 {OidcSessionStorage} storage The signer session storage\n   * @return {Promise<OidcSessionManager>} The OIDC session manager\n   */\n  async createOidcManager(\n    oidcToken: string,\n    orgId: string,\n    scopes: Array<string>,\n    storage?: OidcSessionStorage,\n  ): Promise<OidcSessionManager> {\n    return await OidcSessionManager.create(\n      this.env,\n      storage || new MemorySessionStorage(),\n      oidcToken,\n      orgId,\n      scopes,\n    );\n  }\n\n  /**\n   * Authenticate an OIDC user and create a new session for them.\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 {OidcSessionStorage} storage The signer session storage\n   * @return {Promise<SignerSession>} The signer session\n   */\n  async createOidcSession(\n    oidcToken: string,\n    orgId: string,\n    scopes: Array<string>,\n    storage?: OidcSessionStorage,\n  ): Promise<SignerSession> {\n    const mgr = await this.createOidcManager(oidcToken, orgId, scopes, storage);\n    return await CubeSigner.loadOidcSession(mgr.storage);\n  }\n\n  /** Retrieves information about the current user. */\n  async aboutMe(): Promise<UserInfo> {\n    const resp = await (\n      await this.management()\n    ).get(\"/v0/about_me\", {\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    return data;\n  }\n\n  /**\n   * Creates and sets a new TOTP configuration for the logged-in user,\n   * overriding the existing one (if any).\n   */\n  async resetTotp(): Promise<TotpInfo> {\n    const resp = await (\n      await this.management()\n    ).patch(\"/v0/totp\", {\n      parseAs: \"json\",\n    });\n    return assertOk(resp);\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   * @param {string} code Current TOTP code\n   */\n  async verifyTotp(code: string) {\n    const resp = await (\n      await this.management()\n    ).get(\"/v0/totp/verify/{code}\", {\n      params: { path: { code } },\n      parseAs: \"json\",\n    });\n    assertOk(resp);\n  }\n\n  /** Retrieves 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    const resp = await (\n      await this.management()\n    ).get(\"/v0/org/{org_id}\", {\n      params: { path: { org_id: orgId } },\n      parseAs: \"json\",\n    });\n\n    const data = assertOk(resp);\n    return new Org(this, data);\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/** Organizations */\nexport * from \"./org\";\n/** Keys */\nexport * from \"./key\";\n/** Roles */\nexport * from \"./role\";\n/** Env */\nexport * from \"./env\";\n/** Sessions */\nexport * from \"./signer_session\";\n/** Session storage */\nexport * from \"./session/session_storage\";\n/** Session manager */\nexport * from \"./session/session_manager\";\n/** Management session manager */\nexport * from \"./session/management_session_manager\";\n/** OIDC session manager */\nexport * from \"./session/oidc_session_manager\";\n/** Signer session manager */\nexport * from \"./session/signer_session_manager\";\n/** Export ethers.js Signer */\nexport * as ethers from \"./ethers\";\n"]}

package/dist/src/key.d.ts

@@ -0,0 +1,114 @@
+import { CubeSigner, KeyPolicy } from ".";
+import { components } from "./client";
+/** Secp256k1 key type */
+export declare enum Secp256k1 {
+    Evm = "SecpEthAddr",
+    Btc = "SecpBtc",
+    BtcTest = "SecpBtcTest"
+}
+/** BLS key type */
+export declare enum BLS {
+    Eth2Deposited = "BlsPub",
+    Eth2Inactive = "BlsInactive"
+}
+/** Ed25519 key type */
+export declare enum Ed25519 {
+    Solana = "Ed25519SolanaAddr",
+    Sui = "Ed25519SuiAddr",
+    Aptos = "Ed25519AptosAddr"
+}
+/** Key type */
+export type KeyType = Secp256k1 | BLS | Ed25519;
+type KeyInfo = components["schemas"]["KeyInfo"];
+/** Signing keys. */
+export declare class Key {
+    #private;
+    /** The organization that this key is in */
+    readonly orgId: string;
+    /**
+     * The id of the key: "Key#" followed by a unique identifier specific to
+     * the type of key (such as a public key for BLS or an ethereum address for Secp)
+     * @example Key#0x8e3484687e66cdd26cf04c3647633ab4f3570148
+     * */
+    readonly id: string;
+    /** The type of key. */
+    readonly type: KeyType;
+    /**
+     * A unique identifier specific to the type of key, such as a public key or an ethereum address
+     * @example 0x8e3484687e66cdd26cf04c3647633ab4f3570148
+     * */
+    readonly materialId: string;
+    /**
+     * @description Hex-encoded, serialized public key. The format used depends on the key type:
+     * - secp256k1 keys use 65-byte uncompressed SECG format
+     * - BLS keys use 48-byte compressed BLS12-381 (ZCash) format
+     * @example 0x04d2688b6bc2ce7f9879b9e745f3c4dc177908c5cef0c1b64cff19ae7ff27dee623c64fe9d9c325c7fbbc748bbd5f607ce14dd83e28ebbbb7d3e7f2ffb70a79431
+     * */
+    readonly publicKey: string;
+    /** Is the key enabled? */
+    enabled(): Promise<boolean>;
+    /** Enable the key. */
+    enable(): Promise<void>;
+    /** Disable the key. */
+    disable(): Promise<void>;
+    /**
+     * Set new policy (overwriting any policies previously set for this key)
+     * @param {KeyPolicy} policy The new policy to set
+     */
+    setPolicy(policy: KeyPolicy): Promise<void>;
+    /**
+     * Append to existing key policy. This append is not atomic -- it uses {@link policy} to fetch the current policy and then {@link setPolicy} to set the policy -- and should not be used in across concurrent sessions.
+     * @param {KeyPolicy} policy The policy to append to the existing one.
+     */
+    appendPolicy(policy: KeyPolicy): Promise<void>;
+    /**
+     * Get the policy for the org.
+     * @return {Promise<KeyPolicy>} The policy for the org.
+     */
+    policy(): Promise<KeyPolicy>;
+    /**
+     * @description Owner of the key
+     * @example User#c3b9379c-4e8c-4216-bd0a-65ace53cf98f
+     * */
+    owner(): Promise<string>;
+    /** Set the owner of the key. Only the key (or org) owner can change the owner of the key.
+     * @param {string} owner The user-id of the new owner of the key.
+     * */
+    setOwner(owner: string): Promise<void>;
+    /** Create a new key.
+     * @param {CubeSigner} cs The CubeSigner instance to use for signing.
+     * @param {string} orgId The id of the organization to which the key belongs.
+     * @param {KeyInfo} data The JSON response from the API server.
+     * @internal
+     * */
+    constructor(cs: CubeSigner, orgId: string, data: KeyInfo);
+    /** Update the key.
+     * @param {UpdateKeyRequest} request The JSON request to send to the API server.
+     * @return {KeyInfo} The JSON response from the API server.
+     * */
+    private update;
+    /** Create new signing keys.
+     * @param {CubeSigner} cs The CubeSigner instance to use for signing.
+     * @param {string} orgId The id of the organization to which the key belongs.
+     * @param {KeyType} keyType The type of key to create.
+     * @param {number} count The number of keys to create.
+     * @param {string?} ownerId The owner of the keys. Defaults to the session's user.
+     * @return {Key[]} The new keys.
+     * @internal
+     * */
+    static createKeys(cs: CubeSigner, orgId: string, keyType: KeyType, count: number, ownerId?: string): Promise<Key[]>;
+    /** Get a key by id.
+     * @param {CubeSigner} cs The CubeSigner instance to use for signing.
+     * @param {string} orgId The id of the organization to which the key belongs.
+     * @param {string} keyId The id of the key to get.
+     * @return {Key} The key.
+     * @internal
+     * */
+    static getKey(cs: CubeSigner, orgId: string, keyId: string): Promise<Key>;
+    /** Fetches the key information.
+     * @return {KeyInfo} The key information.
+     * @internal
+     * */
+    private fetch;
+}
+export {};

package/dist/src/key.js

@@ -0,0 +1,201 @@
+"use strict";
+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 __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 _Key_cs;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Key = exports.Ed25519 = exports.BLS = exports.Secp256k1 = void 0;
+const util_1 = require("./util");
+/** Secp256k1 key type */
+var Secp256k1;
+(function (Secp256k1) {
+    Secp256k1["Evm"] = "SecpEthAddr";
+    Secp256k1["Btc"] = "SecpBtc";
+    Secp256k1["BtcTest"] = "SecpBtcTest";
+})(Secp256k1 || (exports.Secp256k1 = Secp256k1 = {}));
+/** BLS key type */
+var BLS;
+(function (BLS) {
+    BLS["Eth2Deposited"] = "BlsPub";
+    BLS["Eth2Inactive"] = "BlsInactive";
+})(BLS || (exports.BLS = BLS = {}));
+/** Ed25519 key type */
+var Ed25519;
+(function (Ed25519) {
+    Ed25519["Solana"] = "Ed25519SolanaAddr";
+    Ed25519["Sui"] = "Ed25519SuiAddr";
+    Ed25519["Aptos"] = "Ed25519AptosAddr";
+})(Ed25519 || (exports.Ed25519 = Ed25519 = {}));
+/** Signing keys. */
+class Key {
+    /** Is the key enabled? */
+    async enabled() {
+        const data = await this.fetch();
+        return data.enabled;
+    }
+    /** Enable the key. */
+    async enable() {
+        await this.update({ enabled: true });
+    }
+    /** Disable the key. */
+    async disable() {
+        await this.update({ enabled: false });
+    }
+    /**
+     * Set new policy (overwriting any policies previously set for this key)
+     * @param {KeyPolicy} policy The new policy to set
+     */
+    async setPolicy(policy) {
+        await this.update({ policy: policy });
+    }
+    /**
+     * Append to existing key policy. This append is not atomic -- it uses {@link policy} to fetch the current policy and then {@link setPolicy} to set the policy -- and should not be used in across concurrent sessions.
+     * @param {KeyPolicy} policy The policy to append to the existing one.
+     */
+    async appendPolicy(policy) {
+        const existing = await this.policy();
+        await this.setPolicy([...existing, ...policy]);
+    }
+    /**
+     * Get the policy for the org.
+     * @return {Promise<KeyPolicy>} The policy for the org.
+     */
+    async policy() {
+        const data = await this.fetch();
+        return (data.policy ?? []);
+    }
+    /**
+     * @description Owner of the key
+     * @example User#c3b9379c-4e8c-4216-bd0a-65ace53cf98f
+     * */
+    async owner() {
+        const data = await this.fetch();
+        return data.owner;
+    }
+    /** Set the owner of the key. Only the key (or org) owner can change the owner of the key.
+     * @param {string} owner The user-id of the new owner of the key.
+     * */
+    async setOwner(owner) {
+        await this.update({ owner });
+    }
+    // --------------------------------------------------------------------------
+    // -- INTERNAL --------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    /** Create a new key.
+     * @param {CubeSigner} cs The CubeSigner instance to use for signing.
+     * @param {string} orgId The id of the organization to which the key belongs.
+     * @param {KeyInfo} data The JSON response from the API server.
+     * @internal
+     * */
+    constructor(cs, orgId, data) {
+        /** The CubeSigner instance that this key is associated with */
+        _Key_cs.set(this, void 0);
+        __classPrivateFieldSet(this, _Key_cs, cs, "f");
+        this.orgId = orgId;
+        this.id = data.key_id;
+        this.type = fromSchemaKeyType(data.key_type);
+        this.materialId = data.material_id;
+        this.publicKey = data.public_key;
+    }
+    /** Update the key.
+     * @param {UpdateKeyRequest} request The JSON request to send to the API server.
+     * @return {KeyInfo} The JSON response from the API server.
+     * */
+    async update(request) {
+        const resp = await (await __classPrivateFieldGet(this, _Key_cs, "f").management()).patch("/v0/org/{org_id}/keys/{key_id}", {
+            params: { path: { org_id: this.orgId, key_id: this.id } },
+            body: request,
+            parseAs: "json",
+        });
+        return (0, util_1.assertOk)(resp);
+    }
+    /** Create new signing keys.
+     * @param {CubeSigner} cs The CubeSigner instance to use for signing.
+     * @param {string} orgId The id of the organization to which the key belongs.
+     * @param {KeyType} keyType The type of key to create.
+     * @param {number} count The number of keys to create.
+     * @param {string?} ownerId The owner of the keys. Defaults to the session's user.
+     * @return {Key[]} The new keys.
+     * @internal
+     * */
+    static async createKeys(cs, orgId, keyType, count, ownerId) {
+        const chain_id = 0; // not used anymore
+        const resp = await (await cs.management()).post("/v0/org/{org_id}/keys", {
+            params: { path: { org_id: orgId } },
+            body: {
+                count,
+                chain_id,
+                key_type: keyType,
+                owner: ownerId || null,
+            },
+            parseAs: "json",
+        });
+        const data = (0, util_1.assertOk)(resp);
+        return data.keys.map((k) => new Key(cs, orgId, k));
+    }
+    /** Get a key by id.
+     * @param {CubeSigner} cs The CubeSigner instance to use for signing.
+     * @param {string} orgId The id of the organization to which the key belongs.
+     * @param {string} keyId The id of the key to get.
+     * @return {Key} The key.
+     * @internal
+     * */
+    static async getKey(cs, orgId, keyId) {
+        const resp = await (await cs.management()).get("/v0/org/{org_id}/keys/{key_id}", {
+            params: { path: { org_id: orgId, key_id: keyId } },
+            parseAs: "json",
+        });
+        const data = (0, util_1.assertOk)(resp);
+        return new Key(cs, orgId, data);
+    }
+    /** Fetches the key information.
+     * @return {KeyInfo} The key information.
+     * @internal
+     * */
+    async fetch() {
+        const resp = await (await __classPrivateFieldGet(this, _Key_cs, "f").management()).get("/v0/org/{org_id}/keys/{key_id}", {
+            params: { path: { org_id: this.orgId, key_id: this.id } },
+            parseAs: "json",
+        });
+        const data = (0, util_1.assertOk)(resp);
+        return data;
+    }
+}
+exports.Key = Key;
+_Key_cs = new WeakMap();
+/** Convert a schema key type to a key type.
+ * @param {SchemaKeyType} ty The schema key type.
+ * @return {KeyType} The key type.
+ * @internal
+ * */
+function fromSchemaKeyType(ty) {
+    switch (ty) {
+        case "SecpEthAddr":
+            return Secp256k1.Evm;
+        case "SecpBtc":
+            return Secp256k1.Btc;
+        case "SecpBtcTest":
+            return Secp256k1.BtcTest;
+        case "BlsPub":
+            return BLS.Eth2Deposited;
+        case "BlsInactive":
+            return BLS.Eth2Inactive;
+        case "Ed25519SolanaAddr":
+            return Ed25519.Solana;
+        case "Ed25519SuiAddr":
+            return Ed25519.Sui;
+        case "Ed25519AptosAddr":
+            return Ed25519.Aptos;
+        default:
+            throw new Error(`Unknown key type: ${ty}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key.js","sourceRoot":"","sources":["../../src/key.ts"],"names":[],"mappings":"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","sourcesContent":["import { CubeSigner, KeyPolicy } from \".\";\nimport { components } from \"./client\";\nimport { assertOk } from \"./util\";\n\n/** Secp256k1 key type */\nexport enum Secp256k1 {\n  Evm = \"SecpEthAddr\", // eslint-disable-line no-unused-vars\n  Btc = \"SecpBtc\", // eslint-disable-line no-unused-vars\n  BtcTest = \"SecpBtcTest\", // eslint-disable-line no-unused-vars\n}\n\n/** BLS key type */\nexport enum BLS {\n  Eth2Deposited = \"BlsPub\", // eslint-disable-line no-unused-vars\n  Eth2Inactive = \"BlsInactive\", // eslint-disable-line no-unused-vars\n}\n\n/** Ed25519 key type */\nexport enum Ed25519 {\n  Solana = \"Ed25519SolanaAddr\", // eslint-disable-line no-unused-vars\n  Sui = \"Ed25519SuiAddr\", // eslint-disable-line no-unused-vars\n  Aptos = \"Ed25519AptosAddr\", // eslint-disable-line no-unused-vars\n}\n\n/** Key type */\nexport type KeyType = Secp256k1 | BLS | Ed25519;\n\n/** Schema key type (i.e., key type at the API level) */\ntype SchemaKeyType = components[\"schemas\"][\"KeyType\"];\n\ntype UpdateKeyRequest = components[\"schemas\"][\"UpdateKeyRequest\"];\ntype KeyInfo = components[\"schemas\"][\"KeyInfo\"];\n\n/** Signing keys. */\nexport class Key {\n  /** The CubeSigner instance that this key is associated with */\n  readonly #cs: CubeSigner;\n  /** The organization that this key is in */\n  readonly orgId: string;\n  /**\n   * The id of the key: \"Key#\" followed by a unique identifier specific to\n   * the type of key (such as a public key for BLS or an ethereum address for Secp)\n   * @example Key#0x8e3484687e66cdd26cf04c3647633ab4f3570148\n   * */\n  readonly id: string;\n\n  /** The type of key. */\n  readonly type: KeyType;\n\n  /**\n   * A unique identifier specific to the type of key, such as a public key or an ethereum address\n   * @example 0x8e3484687e66cdd26cf04c3647633ab4f3570148\n   * */\n  readonly materialId: string;\n\n  /**\n   * @description Hex-encoded, serialized public key. The format used depends on the key type:\n   * - secp256k1 keys use 65-byte uncompressed SECG format\n   * - BLS keys use 48-byte compressed BLS12-381 (ZCash) format\n   * @example 0x04d2688b6bc2ce7f9879b9e745f3c4dc177908c5cef0c1b64cff19ae7ff27dee623c64fe9d9c325c7fbbc748bbd5f607ce14dd83e28ebbbb7d3e7f2ffb70a79431\n   * */\n  readonly publicKey: string;\n\n  /** Is the key enabled? */\n  async enabled(): Promise<boolean> {\n    const data = await this.fetch();\n    return data.enabled;\n  }\n\n  /** Enable the key. */\n  async enable() {\n    await this.update({ enabled: true });\n  }\n\n  /** Disable the key. */\n  async disable() {\n    await this.update({ enabled: false });\n  }\n\n  /**\n   * Set new policy (overwriting any policies previously set for this key)\n   * @param {KeyPolicy} policy The new policy to set\n   */\n  async setPolicy(policy: KeyPolicy) {\n    await this.update({ policy: policy as unknown as Record<string, never>[] });\n  }\n\n  /**\n   * Append to existing key policy. This append is not atomic -- it uses {@link policy} to fetch the current policy and then {@link setPolicy} to set the policy -- and should not be used in across concurrent sessions.\n   * @param {KeyPolicy} policy The policy to append to the existing one.\n   */\n  async appendPolicy(policy: KeyPolicy) {\n    const existing = await this.policy();\n    await this.setPolicy([...existing, ...policy]);\n  }\n\n  /**\n   * Get the policy for the org.\n   * @return {Promise<KeyPolicy>} The policy for the org.\n   */\n  async policy(): Promise<KeyPolicy> {\n    const data = await this.fetch();\n    return (data.policy ?? []) as unknown as KeyPolicy;\n  }\n\n  /**\n   * @description Owner of the key\n   * @example User#c3b9379c-4e8c-4216-bd0a-65ace53cf98f\n   * */\n  async owner(): Promise<string> {\n    const data = await this.fetch();\n    return data.owner;\n  }\n\n  /** Set the owner of the key. Only the key (or org) owner can change the owner of the key.\n   * @param {string} owner The user-id of the new owner of the key.\n   * */\n  async setOwner(owner: string) {\n    await this.update({ owner });\n  }\n\n  // --------------------------------------------------------------------------\n  // -- INTERNAL --------------------------------------------------------------\n  // --------------------------------------------------------------------------\n\n  /** Create a new key.\n   * @param {CubeSigner} cs The CubeSigner instance to use for signing.\n   * @param {string} orgId The id of the organization to which the key belongs.\n   * @param {KeyInfo} data The JSON response from the API server.\n   * @internal\n   * */\n  constructor(cs: CubeSigner, orgId: string, data: KeyInfo) {\n    this.#cs = cs;\n    this.orgId = orgId;\n    this.id = data.key_id;\n    this.type = fromSchemaKeyType(data.key_type);\n    this.materialId = data.material_id;\n    this.publicKey = data.public_key;\n  }\n\n  /** Update the key.\n   * @param {UpdateKeyRequest} request The JSON request to send to the API server.\n   * @return {KeyInfo} The JSON response from the API server.\n   * */\n  private async update(request: UpdateKeyRequest): Promise<KeyInfo> {\n    const resp = await (\n      await this.#cs.management()\n    ).patch(\"/v0/org/{org_id}/keys/{key_id}\", {\n      params: { path: { org_id: this.orgId, key_id: this.id } },\n      body: request,\n      parseAs: \"json\",\n    });\n    return assertOk(resp);\n  }\n\n  /** Create new signing keys.\n   * @param {CubeSigner} cs The CubeSigner instance to use for signing.\n   * @param {string} orgId The id of the organization to which the key belongs.\n   * @param {KeyType} keyType The type of key to create.\n   * @param {number} count The number of keys to create.\n   * @param {string?} ownerId The owner of the keys. Defaults to the session's user.\n   * @return {Key[]} The new keys.\n   * @internal\n   * */\n  static async createKeys(\n    cs: CubeSigner,\n    orgId: string,\n    keyType: KeyType,\n    count: number,\n    ownerId?: string,\n  ): Promise<Key[]> {\n    const chain_id = 0; // not used anymore\n    const resp = await (\n      await cs.management()\n    ).post(\"/v0/org/{org_id}/keys\", {\n      params: { path: { org_id: orgId } },\n      body: {\n        count,\n        chain_id,\n        key_type: keyType,\n        owner: ownerId || null,\n      },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    return data.keys.map((k: KeyInfo) => new Key(cs, orgId, k));\n  }\n\n  /** Get a key by id.\n   * @param {CubeSigner} cs The CubeSigner instance to use for signing.\n   * @param {string} orgId The id of the organization to which the key belongs.\n   * @param {string} keyId The id of the key to get.\n   * @return {Key} The key.\n   * @internal\n   * */\n  static async getKey(cs: CubeSigner, orgId: string, keyId: string): Promise<Key> {\n    const resp = await (\n      await cs.management()\n    ).get(\"/v0/org/{org_id}/keys/{key_id}\", {\n      params: { path: { org_id: orgId, key_id: keyId } },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    return new Key(cs, orgId, data);\n  }\n\n  /** Fetches the key information.\n   * @return {KeyInfo} The key information.\n   * @internal\n   * */\n  private async fetch(): Promise<KeyInfo> {\n    const resp = await (\n      await this.#cs.management()\n    ).get(\"/v0/org/{org_id}/keys/{key_id}\", {\n      params: { path: { org_id: this.orgId, key_id: this.id } },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    return data;\n  }\n}\n\n/** Convert a schema key type to a key type.\n * @param {SchemaKeyType} ty The schema key type.\n * @return {KeyType} The key type.\n * @internal\n * */\nfunction fromSchemaKeyType(ty: SchemaKeyType): KeyType {\n  switch (ty) {\n    case \"SecpEthAddr\":\n      return Secp256k1.Evm;\n    case \"SecpBtc\":\n      return Secp256k1.Btc;\n    case \"SecpBtcTest\":\n      return Secp256k1.BtcTest;\n    case \"BlsPub\":\n      return BLS.Eth2Deposited;\n    case \"BlsInactive\":\n      return BLS.Eth2Inactive;\n    case \"Ed25519SolanaAddr\":\n      return Ed25519.Solana;\n    case \"Ed25519SuiAddr\":\n      return Ed25519.Sui;\n    case \"Ed25519AptosAddr\":\n      return Ed25519.Aptos;\n    default:\n      throw new Error(`Unknown key type: ${ty}`);\n  }\n}\n"]}

package/dist/src/mfa.d.ts

@@ -0,0 +1,23 @@
+import { Sign, SignResponse, Role } from ".";
+/**
+ * Wrapper around @type {Sign} and @type {Role} that adds a **single-approval**
+ * multi-factor authorization on top of all sign operations.
+ */
+export declare class Mfa {
+    #private;
+    /**
+     * Auto approve a sign operation that requires MFA.
+     *
+     * @param signFn The sign operation to call
+     * @param {T} args Arguments to the sign operation
+     * @return {Promise<U>} The result of the sign operation.
+     */
+    autoApprove<T extends Array<any>, U>(// eslint-disable-line @typescript-eslint/no-explicit-any
+    signFn: (...args: T) => Promise<SignResponse<U>>, ...args: T): Promise<U>;
+    /**
+     * Constructor.
+     * @param {Sign} sign Sign instance to use for signing
+     * @param {Role} role Role instance to use for MFA approval
+     */
+    constructor(sign: Sign, role: Role);
+}