@cubist-labs/cubesigner-sdk 0.1.77 → 0.2.15

package/dist/src/client.js

@@ -1,21 +1,357 @@
 "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 __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);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-/** Re-export schema.
- * @internal
- * */
-__exportStar(require("./schema"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBUUE7O0tBRUs7QUFDTCwyQ0FBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgY3JlYXRlQ2xpZW50IGZyb20gXCJvcGVuYXBpLWZldGNoXCI7XG5pbXBvcnQgeyBwYXRocyB9IGZyb20gXCIuL3NjaGVtYVwiO1xuXG4vKiogVHlwZSBvZiBodHRwIGNsaWVudC5cbiAqIEBpbnRlcm5hbFxuICogKi9cbmV4cG9ydCB0eXBlIENsaWVudCA9IFJldHVyblR5cGU8dHlwZW9mIGNyZWF0ZUNsaWVudDxwYXRocz4+O1xuXG4vKiogUmUtZXhwb3J0IHNjaGVtYS5cbiAqIEBpbnRlcm5hbFxuICogKi9cbmV4cG9ydCAqIGZyb20gXCIuL3NjaGVtYVwiO1xuIl19
+exports.CubeSignerClient = void 0;
+const signer_session_manager_1 = require("./session/signer_session_manager");
+const cognito_manager_1 = require("./session/cognito_manager");
+const api_1 = require("./api");
+const key_1 = require("./key");
+const role_1 = require("./role");
+const session_storage_1 = require("./session/session_storage");
+/**
+ * Client to use to send requests to CubeSigner services
+ * when authenticating using a CubeSigner session token.
+ */
+class CubeSignerClient extends api_1.CubeSignerApi {
+    /**
+     * Constructor.
+     * @param {SignerSessionManager} sessionMgr The session manager to use
+     * @param {string?} orgId Optional organization ID; if omitted, uses the org ID from the session manager.
+     */
+    constructor(sessionMgr, orgId) {
+        super(sessionMgr, orgId);
+    }
+    /**
+     * Returns a new instance of this class using the same session manager but targeting a different organization.
+     *
+     * @param {string} orgId The organization ID.
+     * @return {CubeSignerClient} A new instance of this class using the same session manager but targeting different organization.
+     */
+    withOrg(orgId) {
+        return orgId ? new CubeSignerClient(this.sessionMgr, orgId) : this;
+    }
+    /**
+     * Loads an existing management session and creates a {@link CubeSignerClient} instance.
+     *
+     * @return {Promise<CubeSignerClient>} New CubeSigner instance
+     */
+    static async loadManagementSession() {
+        const mgr = await cognito_manager_1.CognitoSessionManager.loadManagementSession();
+        // HACK: Ignore that sessionMgr may be a CognitoSessionManager and pretend that it
+        //       is a SignerSessionManager; that's fine because the CubeSignerClient will
+        //       almost always just call `await token()` on it, which works in both cases.
+        // NOTE: This will go away once `cs login` starts producing signer sessions.
+        return new CubeSignerClient(mgr);
+    }
+    /**
+     * Create a new signing key.
+     * @param {KeyType} type The type of key to create.
+     * @param {string?} ownerId The owner of the key. Defaults to the session's user.
+     * @return {Key[]} The new keys.
+     */
+    async createKey(type, ownerId) {
+        return (await this.createKeys(type, 1, ownerId))[0];
+    }
+    /**
+     * Create new signing keys.
+     * @param {KeyType} type 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.
+     */
+    async createKeys(type, count, ownerId) {
+        const keys = await this.keysCreate(type, count, ownerId);
+        return keys.map((k) => new key_1.Key(this, k));
+    }
+    /**
+     * Derive a key of the given type using the given derivation path and mnemonic.
+     * The owner of the derived key will be the owner of the mnemonic.
+     *
+     * @param {KeyType} type Type of key to derive from the mnemonic.
+     * @param {string} derivationPath Mnemonic derivation path used to generate new key.
+     * @param {string} mnemonicId materialId of mnemonic key used to derive the new key.
+     *
+     * @return {Key} newly derived key or undefined if it already exists.
+     */
+    async deriveKey(type, derivationPath, mnemonicId) {
+        return (await this.deriveKeys(type, [derivationPath], mnemonicId))[0];
+    }
+    /**
+     * Derive a set of keys of the given type using the given derivation paths and mnemonic.
+     *
+     * The owner of the derived keys will be the owner of the mnemonic.
+     *
+     * @param {KeyType} type Type of key to derive from the mnemonic.
+     * @param {string[]} derivationPaths Mnemonic derivation paths used to generate new key.
+     * @param {string} mnemonicId materialId of mnemonic key used to derive the new key.
+     *
+     * @return {Key[]} newly derived keys.
+     */
+    async deriveKeys(type, derivationPaths, mnemonicId) {
+        const keys = await this.keysDerive(type, derivationPaths, mnemonicId);
+        return keys.map((k) => new key_1.Key(this, k));
+    }
+    /**
+     * Create a new {@link OidcClient} that will use a given OIDC token for auth.
+     * @param {string} oidcToken The authentication token to use
+     * @return {OidcClient} New OIDC client.
+     */
+    newOidcClient(oidcToken) {
+        return new api_1.OidcClient(this.sessionMgr.env, this.orgId, oidcToken);
+    }
+    /**
+     * Authenticate an OIDC user and create a new session manager for them.
+     *
+     * @param {string} oidcToken The OIDC token
+     * @param {List<string>} scopes The scopes of the resulting session
+     * @param {OidcAuthOptions} options Options.
+     * @return {Promise<SignerSessionManager>} The signer session manager
+     */
+    async oidcAuth(oidcToken, scopes, options) {
+        const oidcClient = this.newOidcClient(oidcToken);
+        const resp = await oidcClient.sessionCreate(scopes, options?.lifetimes, options?.mfaReceipt);
+        return await signer_session_manager_1.SignerSessionManager.loadFromStorage(new session_storage_1.MemorySessionStorage(resp.data()));
+    }
+    /**
+     * Create a new user in the organization and sends an invitation to that user.
+     *
+     * Same as {@link orgUserInvite}.
+     */
+    get createUser() {
+        return this.orgUserInvite.bind(this);
+    }
+    /**
+     * Create a new OIDC user.
+     *
+     * Same as {@link orgUserCreateOidc}.
+     */
+    get createOidcUser() {
+        return this.orgUserCreateOidc.bind(this);
+    }
+    /**
+     * Delete an existing OIDC user.
+     *
+     * Same as {@link orgUserDeleteOidc}.
+     */
+    get deleteOidcUser() {
+        return this.orgUserDeleteOidc.bind(this);
+    }
+    /**
+     * List users in the organization.
+     *
+     * Same as {@link orgUsersList}
+     */
+    get users() {
+        return this.orgUsersList.bind(this);
+    }
+    /**
+     * Obtain information about the current user.
+     *
+     * Same as {@link userGet}
+     */
+    get user() {
+        return this.userGet.bind(this);
+    }
+    /**
+     * Get information about a specific org.
+     *
+     * @param {string?} orgId The ID or name of the org
+     * @return {Promise<OrgInfo>} CubeSigner client for the requested org.
+     */
+    async org(orgId) {
+        return await this.withOrg(orgId).orgGet();
+    }
+    /**
+     * Obtain information about the current user.
+     *
+     * Same as {@link userGet}
+     */
+    get aboutMe() {
+        return this.userGet.bind(this);
+    }
+    /**
+     * Get a key by id.
+     *
+     * @param {string} keyId The id of the key to get.
+     * @return {Key} The key.
+     */
+    async getKey(keyId) {
+        const keyInfo = await this.keyGet(keyId);
+        return new key_1.Key(this, keyInfo);
+    }
+    /**
+     * Get all keys in the org.
+     *
+     * @param {KeyType?} type Optional key type to filter list for.
+     * @param {PageOpts} page Pagination options. Defaults to fetching the entire result set.
+     * @return {Promise<Key[]>} The keys.
+     */
+    async orgKeys(type, page) {
+        const paginator = this.keysList(type, page);
+        const keys = await paginator.fetch();
+        return keys.map((k) => new key_1.Key(this, k));
+    }
+    /**
+     * Create a new role.
+     *
+     * @param {string?} name The name of the role.
+     * @return {Role} The new role.
+     */
+    async createRole(name) {
+        const roleId = await this.roleCreate(name);
+        const roleInfo = await this.roleGet(roleId);
+        return new role_1.Role(this, roleInfo);
+    }
+    /**
+     * Get a role by id or name.
+     *
+     * @param {string} roleId The id or name of the role to get.
+     * @return {Role} The role.
+     */
+    async getRole(roleId) {
+        const roleInfo = await this.roleGet(roleId);
+        return new role_1.Role(this, roleInfo);
+    }
+    /**
+     * List all roles in the org.
+     *
+     * @param {PageOpts} page Pagination options. Defaults to fetching the entire result set.
+     * @return {Role[]} The roles.
+     */
+    async listRoles(page) {
+        const roles = await this.rolesList(page).fetch();
+        return roles.map((r) => new role_1.Role(this, r));
+    }
+    /**
+     * List all users in the org.
+     *
+     * Same as {@link orgUsersList}
+     */
+    get listUsers() {
+        return this.orgUsersList.bind(this);
+    }
+    /**
+     * Approve a pending MFA request.
+     *
+     * Same as {@link mfaApprove}
+     */
+    get approveMfaRequest() {
+        return this.mfaApprove.bind(this);
+    }
+    /**
+     * Approve a pending MFA request using TOTP.
+     *
+     * Same as {@link mfaApproveTotp}
+     */
+    get totpApprove() {
+        return this.mfaApproveTotp.bind(this);
+    }
+    /**
+     * Initiate approval of an existing MFA request using FIDO.
+     *
+     * Returns a {@link MfaFidoChallenge} that must be answered by calling
+     * {@link MfaFidoChallenge.answer} or {@link fidoApproveComplete}.
+     *
+     * Same as {@link mfaApproveFidoInit}
+     */
+    get fidoApproveStart() {
+        return this.mfaApproveFidoInit.bind(this);
+    }
+    /**
+     * Answer the MFA approval with FIDO challenge issued by {@link fidoApproveStart}.
+     *
+     * Same as {@link mfaApproveFidoComplete}
+     */
+    get fidoApproveComplete() {
+        return this.mfaApproveFidoComplete.bind(this);
+    }
+    /**
+     * Get a pending MFA request by its id.
+     *
+     * Same as {@link CubeSignerClient.getMfaInfo}
+     */
+    get getMfaInfo() {
+        return this.mfaGet.bind(this);
+    }
+    /**
+     * List pending MFA requests accessible to the current user.
+     *
+     * Same as {@link CubeSignerClient.mfaList}
+     */
+    get listMfaInfos() {
+        return this.mfaList.bind(this);
+    }
+    /**
+     * Obtain a proof of authentication.
+     *
+     * Same as {@link CubeSignerClient.identityProve}
+     */
+    get proveIdentity() {
+        return this.identityProve.bind(this);
+    }
+    /**
+     * Check if a given proof of OIDC authentication is valid.
+     *
+     * Same as {@link CubeSignerClient.identityVerify}
+     */
+    get verifyIdentity() {
+        return this.identityVerify.bind(this);
+    }
+    /**
+     * Creates a request to add a new FIDO device.
+     *
+     * Returns a {@link AddFidoChallenge} that must be answered by calling {@link AddFidoChallenge.answer}.
+     *
+     * MFA may be required.
+     *
+     * Same as {@link CubeSignerClient.userRegisterFidoInit}
+     */
+    get addFidoStart() {
+        return this.userRegisterFidoInit.bind(this);
+    }
+    /**
+     * Creates a request to change user's TOTP. Returns a {@link TotpChallenge}
+     * that must be answered by calling {@link TotpChallenge.answer} or
+     * {@link resetTotpComplete}.
+     *
+     * Same as {@link userResetTotpInit}
+     */
+    get resetTotpStart() {
+        return this.userResetTotpInit.bind(this);
+    }
+    /**
+     * Answer the TOTP challenge issued by {@link resetTotpStart}. If successful,
+     * user's TOTP configuration will be updated to that of the TOTP challenge.
+     *
+     * Same as {@link userResetTotpComplete}
+     */
+    get resetTotpComplete() {
+        return this.userResetTotpComplete.bind(this);
+    }
+    /**
+     * Verifies a given TOTP code against the current user's TOTP configuration.
+     * Throws an error if the verification fails.
+     *
+     * Same as {@link userVerifyTotp}
+     */
+    get verifyTotp() {
+        return this.userVerifyTotp.bind(this);
+    }
+    /**
+     * Sign a stake request.
+     *
+     * Same as {@link signStake}
+     */
+    get stake() {
+        return this.signStake.bind(this);
+    }
+    /**
+     * Sign an unstake request.
+     *
+     * Same as {@link signUnstake}
+     */
+    get unstake() {
+        return this.signUnstake.bind(this);
+    }
+}
+exports.CubeSignerClient = CubeSignerClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"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","sourcesContent":["import { SignerSessionManager, SignerSessionStorage } from \"./session/signer_session_manager\";\nimport { CognitoSessionManager } from \"./session/cognito_manager\";\nimport { CubeSignerApi, OidcClient } from \"./api\";\nimport { KeyType, Key } from \"./key\";\nimport { OrgInfo, RatchetConfig } from \"./schema_types\";\nimport { MfaReceipt } from \"./mfa\";\nimport { PageOpts } from \"./paginator\";\nimport { Role } from \"./role\";\n\n// used in doc comments\n// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars\nimport { AddFidoChallenge, MfaFidoChallenge, TotpChallenge } from \"./mfa\";\nimport { MemorySessionStorage } from \"./session/session_storage\";\n\n/** Options for logging in with OIDC token */\nexport interface OidcAuthOptions {\n  /** Optional token lifetimes */\n  lifetimes?: RatchetConfig;\n  /** Optional MFA receipt */\n  mfaReceipt?: MfaReceipt;\n  /** Optional storage to use for the returned session (defaults to {@link MemorySessionStorage}) */\n  storage?: SignerSessionStorage;\n}\n\n/**\n * Client to use to send requests to CubeSigner services\n * when authenticating using a CubeSigner session token.\n */\nexport class CubeSignerClient extends CubeSignerApi {\n  /**\n   * Constructor.\n   * @param {SignerSessionManager} sessionMgr The session manager to use\n   * @param {string?} orgId Optional organization ID; if omitted, uses the org ID from the session manager.\n   */\n  constructor(sessionMgr: SignerSessionManager, orgId?: string) {\n    super(sessionMgr, orgId);\n  }\n\n  /**\n   * Returns a new instance of this class using the same session manager but targeting a different organization.\n   *\n   * @param {string} orgId The organization ID.\n   * @return {CubeSignerClient} A new instance of this class using the same session manager but targeting different organization.\n   */\n  withOrg(orgId?: string): CubeSignerClient {\n    return orgId ? new CubeSignerClient(this.sessionMgr, orgId) : this;\n  }\n\n  /**\n   * Loads an existing management session and creates a {@link CubeSignerClient} instance.\n   *\n   * @return {Promise<CubeSignerClient>} New CubeSigner instance\n   */\n  static async loadManagementSession(): Promise<CubeSignerClient> {\n    const mgr = await CognitoSessionManager.loadManagementSession();\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    // NOTE: This will go away once `cs login` starts producing signer sessions.\n    return new CubeSignerClient(mgr as unknown as SignerSessionManager);\n  }\n\n  /**\n   * Create a new signing key.\n   * @param {KeyType} type The type of key to create.\n   * @param {string?} ownerId The owner of the key. Defaults to the session's user.\n   * @return {Key[]} The new keys.\n   */\n  async createKey(type: KeyType, ownerId?: string): Promise<Key> {\n    return (await this.createKeys(type, 1, ownerId))[0];\n  }\n\n  /**\n   * Create new signing keys.\n   * @param {KeyType} type 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   */\n  async createKeys(type: KeyType, count: number, ownerId?: string): Promise<Key[]> {\n    const keys = await this.keysCreate(type, count, ownerId);\n    return keys.map((k) => new Key(this, k));\n  }\n\n  /**\n   * Derive a key of the given type using the given derivation path and mnemonic.\n   * The owner of the derived key will be the owner of the mnemonic.\n   *\n   * @param {KeyType} type Type of key to derive from the mnemonic.\n   * @param {string} derivationPath Mnemonic derivation path used to generate new key.\n   * @param {string} mnemonicId materialId of mnemonic key used to derive the new key.\n   *\n   * @return {Key} newly derived key or undefined if it already exists.\n   */\n  async deriveKey(\n    type: KeyType,\n    derivationPath: string,\n    mnemonicId: string,\n  ): Promise<Key | undefined> {\n    return (await this.deriveKeys(type, [derivationPath], mnemonicId))[0];\n  }\n\n  /**\n   * Derive a set of keys of the given type using the given derivation paths and mnemonic.\n   *\n   * The owner of the derived keys will be the owner of the mnemonic.\n   *\n   * @param {KeyType} type Type of key to derive from the mnemonic.\n   * @param {string[]} derivationPaths Mnemonic derivation paths used to generate new key.\n   * @param {string} mnemonicId materialId of mnemonic key used to derive the new key.\n   *\n   * @return {Key[]} newly derived keys.\n   */\n  async deriveKeys(type: KeyType, derivationPaths: string[], mnemonicId: string): Promise<Key[]> {\n    const keys = await this.keysDerive(type, derivationPaths, mnemonicId);\n    return keys.map((k) => new Key(this, k));\n  }\n\n  /**\n   * Create a new {@link OidcClient} that will use a given OIDC token for auth.\n   * @param {string} oidcToken The authentication token to use\n   * @return {OidcClient} New OIDC client.\n   */\n  newOidcClient(oidcToken: string): OidcClient {\n    return new OidcClient(this.sessionMgr.env, this.orgId, oidcToken);\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 {List<string>} scopes The scopes of the resulting session\n   * @param {OidcAuthOptions} options Options.\n   * @return {Promise<SignerSessionManager>} The signer session manager\n   */\n  async oidcAuth(\n    oidcToken: string,\n    scopes: Array<string>,\n    options?: OidcAuthOptions,\n  ): Promise<SignerSessionManager> {\n    const oidcClient = this.newOidcClient(oidcToken);\n    const resp = await oidcClient.sessionCreate(scopes, options?.lifetimes, options?.mfaReceipt);\n    return await SignerSessionManager.loadFromStorage(new MemorySessionStorage(resp.data()));\n  }\n\n  /**\n   * Create a new user in the organization and sends an invitation to that user.\n   *\n   * Same as {@link orgUserInvite}.\n   */\n  get createUser() {\n    return this.orgUserInvite.bind(this);\n  }\n\n  /**\n   * Create a new OIDC user.\n   *\n   * Same as {@link orgUserCreateOidc}.\n   */\n  get createOidcUser() {\n    return this.orgUserCreateOidc.bind(this);\n  }\n\n  /**\n   * Delete an existing OIDC user.\n   *\n   * Same as {@link orgUserDeleteOidc}.\n   */\n  get deleteOidcUser() {\n    return this.orgUserDeleteOidc.bind(this);\n  }\n\n  /**\n   * List users in the organization.\n   *\n   * Same as {@link orgUsersList}\n   */\n  get users() {\n    return this.orgUsersList.bind(this);\n  }\n\n  /**\n   * Obtain information about the current user.\n   *\n   * Same as {@link userGet}\n   */\n  get user() {\n    return this.userGet.bind(this);\n  }\n\n  /**\n   * Get information about a specific org.\n   *\n   * @param {string?} orgId The ID or name of the org\n   * @return {Promise<OrgInfo>} CubeSigner client for the requested org.\n   */\n  async org(orgId?: string): Promise<OrgInfo> {\n    return await this.withOrg(orgId).orgGet();\n  }\n\n  /**\n   * Obtain information about the current user.\n   *\n   * Same as {@link userGet}\n   */\n  get aboutMe() {\n    return this.userGet.bind(this);\n  }\n\n  /**\n   * Get a key by id.\n   *\n   * @param {string} keyId The id of the key to get.\n   * @return {Key} The key.\n   */\n  async getKey(keyId: string): Promise<Key> {\n    const keyInfo = await this.keyGet(keyId);\n    return new Key(this, keyInfo);\n  }\n\n  /**\n   * Get all keys in the org.\n   *\n   * @param {KeyType?} type Optional key type to filter list for.\n   * @param {PageOpts} page Pagination options. Defaults to fetching the entire result set.\n   * @return {Promise<Key[]>} The keys.\n   */\n  async orgKeys(type?: KeyType, page?: PageOpts): Promise<Key[]> {\n    const paginator = this.keysList(type, page);\n    const keys = await paginator.fetch();\n    return keys.map((k) => new Key(this, k));\n  }\n\n  /**\n   * Create a new role.\n   *\n   * @param {string?} name The name of the role.\n   * @return {Role} The new role.\n   */\n  async createRole(name?: string): Promise<Role> {\n    const roleId = await this.roleCreate(name);\n    const roleInfo = await this.roleGet(roleId);\n    return new Role(this, roleInfo);\n  }\n\n  /**\n   * Get a role by id or name.\n   *\n   * @param {string} roleId The id or name of the role to get.\n   * @return {Role} The role.\n   */\n  async getRole(roleId: string): Promise<Role> {\n    const roleInfo = await this.roleGet(roleId);\n    return new Role(this, roleInfo);\n  }\n\n  /**\n   * List all roles in the org.\n   *\n   * @param {PageOpts} page Pagination options. Defaults to fetching the entire result set.\n   * @return {Role[]} The roles.\n   */\n  async listRoles(page?: PageOpts): Promise<Role[]> {\n    const roles = await this.rolesList(page).fetch();\n    return roles.map((r) => new Role(this, r));\n  }\n\n  /**\n   * List all users in the org.\n   *\n   * Same as {@link orgUsersList}\n   */\n  get listUsers() {\n    return this.orgUsersList.bind(this);\n  }\n\n  /**\n   * Approve a pending MFA request.\n   *\n   * Same as {@link mfaApprove}\n   */\n  get approveMfaRequest() {\n    return this.mfaApprove.bind(this);\n  }\n\n  /**\n   * Approve a pending MFA request using TOTP.\n   *\n   * Same as {@link mfaApproveTotp}\n   */\n  get totpApprove() {\n    return this.mfaApproveTotp.bind(this);\n  }\n\n  /**\n   * Initiate approval of an existing MFA request using FIDO.\n   *\n   * Returns a {@link MfaFidoChallenge} that must be answered by calling\n   * {@link MfaFidoChallenge.answer} or {@link fidoApproveComplete}.\n   *\n   * Same as {@link mfaApproveFidoInit}\n   */\n  get fidoApproveStart() {\n    return this.mfaApproveFidoInit.bind(this);\n  }\n\n  /**\n   * Answer the MFA approval with FIDO challenge issued by {@link fidoApproveStart}.\n   *\n   * Same as {@link mfaApproveFidoComplete}\n   */\n  get fidoApproveComplete() {\n    return this.mfaApproveFidoComplete.bind(this);\n  }\n\n  /**\n   * Get a pending MFA request by its id.\n   *\n   * Same as {@link CubeSignerClient.getMfaInfo}\n   */\n  get getMfaInfo() {\n    return this.mfaGet.bind(this);\n  }\n\n  /**\n   * List pending MFA requests accessible to the current user.\n   *\n   * Same as {@link CubeSignerClient.mfaList}\n   */\n  get listMfaInfos() {\n    return this.mfaList.bind(this);\n  }\n\n  /**\n   * Obtain a proof of authentication.\n   *\n   * Same as {@link CubeSignerClient.identityProve}\n   */\n  get proveIdentity() {\n    return this.identityProve.bind(this);\n  }\n\n  /**\n   * Check if a given proof of OIDC authentication is valid.\n   *\n   * Same as {@link CubeSignerClient.identityVerify}\n   */\n  get verifyIdentity() {\n    return this.identityVerify.bind(this);\n  }\n\n  /**\n   * Creates a request to add a new FIDO device.\n   *\n   * Returns a {@link AddFidoChallenge} that must be answered by calling {@link AddFidoChallenge.answer}.\n   *\n   * MFA may be required.\n   *\n   * Same as {@link CubeSignerClient.userRegisterFidoInit}\n   */\n  get addFidoStart() {\n    return this.userRegisterFidoInit.bind(this);\n  }\n\n  /**\n   * Creates a request to change user's TOTP. Returns a {@link TotpChallenge}\n   * that must be answered by calling {@link TotpChallenge.answer} or\n   * {@link resetTotpComplete}.\n   *\n   * Same as {@link userResetTotpInit}\n   */\n  get resetTotpStart() {\n    return this.userResetTotpInit.bind(this);\n  }\n\n  /**\n   * Answer the TOTP challenge issued by {@link resetTotpStart}. If successful,\n   * user's TOTP configuration will be updated to that of the TOTP challenge.\n   *\n   * Same as {@link userResetTotpComplete}\n   */\n  get resetTotpComplete() {\n    return this.userResetTotpComplete.bind(this);\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   * Same as {@link userVerifyTotp}\n   */\n  get verifyTotp() {\n    return this.userVerifyTotp.bind(this);\n  }\n\n  /**\n   * Sign a stake request.\n   *\n   * Same as {@link signStake}\n   */\n  get stake() {\n    return this.signStake.bind(this);\n  }\n\n  /**\n   * Sign an unstake request.\n   *\n   * Same as {@link signUnstake}\n   */\n  get unstake() {\n    return this.signUnstake.bind(this);\n  }\n}\n"]}

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

@@ -1,7 +1,7 @@
 import { TypedDataDomain, TypedDataField, ethers } from "ethers";
-import { MfaRequestInfo, SignerSession } from "../signer_session";
+import { SignerSession } from "../signer_session";
+import { EvmSignRequest, MfaRequestInfo } from "../schema_types";
 import { KeyInfo } from "../key";
-import { CubeSigner } from "..";
 /** Options for the signer */
 interface SignerOptions {
     /** Optional provider to use */
@@ -16,15 +16,14 @@ interface SignerOptions {
      * updates. Default is 1000ms
      */
     mfaPollIntervalMs?: number;
-    /** Optional management session. Used to check for MFA updates */
-    managementSession?: CubeSigner;
 }
 /**
  * A ethers.js Signer using CubeSigner
  */
 export declare class Signer extends ethers.AbstractSigner {
     #private;
-    /** Create new Signer instance
+    /**
+     * 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 {SignerOptions} options The options to use for the Signer instance
@@ -39,19 +38,29 @@ export declare class Signer extends ethers.AbstractSigner {
      */
     connect(provider: null | ethers.Provider): Signer;
     /**
-     * Signs a transaction. This populates the transaction type to `0x02` (EIP-1559) unless set. This method will block if the key requires MFA approval.
+     * Construct a signing request from a transaction. This populates the transaction
+     * type to `0x02` (EIP-1559) unless set.
+     *
+     * @param {ethers.TransactionRequest} tx The transaction
+     * @return {EvmSignRequest} The EVM sign request to be sent to CubeSigner
+     */
+    evmSignRequestFromTx(tx: ethers.TransactionRequest): Promise<EvmSignRequest>;
+    /**
+     * Sign a transaction. This method will block if the key requires MFA approval.
      * @param {ethers.TransactionRequest} tx The transaction to sign.
      * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.
      */
     signTransaction(tx: ethers.TransactionRequest): Promise<string>;
-    /** Signs arbitrary messages. This uses ethers.js's [hashMessage](https://docs.ethers.org/v6/api/hashing/#hashMessage)
+    /**
+     * Signs arbitrary messages. This uses ethers.js's [hashMessage](https://docs.ethers.org/v6/api/hashing/#hashMessage)
      * to compute the EIP-191 digest and signs this digest using {@link Key#signBlob}.
      * The key (for this session) must have the `"AllowRawBlobSigning"` policy attached.
      * @param {string | Uint8Array} message The message to sign.
      * @return {Promise<string>} The signature.
      */
     signMessage(message: string | Uint8Array): Promise<string>;
-    /** Signs EIP-712 typed data. This uses ethers.js's
+    /**
+     * Signs EIP-712 typed data. This uses ethers.js's
      * [TypedDataEncoder.hash](https://docs.ethers.org/v6/api/hashing/#TypedDataEncoder_hash)
      * to compute the EIP-712 digest and signs this digest using {@link Key#signBlob}.
      * The key (for this session) must have the `"AllowRawBlobSigning"` policy attached.
@@ -61,10 +70,26 @@ export declare class Signer extends ethers.AbstractSigner {
      * @return {Promise<string>} The signature.
      */
     signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
-    /** Sign arbitrary digest. This uses {@link Key#signBlob}.
+    /**
+     * Sign arbitrary digest. This uses {@link Key#signBlob}.
      * @param {string} digest The digest to sign.
      * @return {Promise<string>} The signature.
      */
     private signBlob;
+    /**
+     * Initialize the signing a message using MFA approvals. This method populates
+     * missing fields. If the signing does not require MFA, this method throws.
+     * @param {ethers.TransactionRequest} tx The transaction to send.
+     * @return {string} The MFA id associated with the signing request.
+     */
+    sendTransactionMfaInit(tx: ethers.TransactionRequest): Promise<string>;
+    /**
+     * Send 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 {ethers.TransactionResponse} The result of submitting the transaction
+     */
+    sendTransactionMfaApproved(mfaInfo: MfaRequestInfo): Promise<ethers.TransactionResponse>;
 }
 export {};