@cubist-labs/cubesigner-sdk 0.1.26 → 0.1.77

package/README.md

@@ -71,11 +71,11 @@ session manager:
 
 ```typescript
 // Load session from a JSON file
-const fileStorage = new cs.JsonFileSessionStorage<cs.ManagementSessionInfo>(
+const fileStorage = new cs.JsonFileSessionStorage<cs.CognitoSessionInfo>(
   `${process.env.HOME}/.config/cubesigner/management-session.json`,
 );
 // Create a session manager for a management token
-const sessionMgr = await cs.ManagementSessionManager.loadFromStorage(fileStorage);
+const sessionMgr = await cs.CognitoSessionManager.loadFromStorage(fileStorage);
 new cs.CubeSigner({
   sessionMgr,
 });
@@ -113,7 +113,8 @@ transaction. For that, we need a key of type `Secp256k1.Evm`.
 const secpKey = await org.createKey(cs.Secp256k1.Evm);
 assert((await secpKey.owner()) == me.user_id);
 assert(await secpKey.enabled());
-console.log(`Created '${secpKey.type}' key ${secpKey.id}`);
+assert(await secpKey.type(), cs.Secp256k1.Evm);
+console.log(`Created '${cs.Secp256k1.Evm}' key ${secpKey.id}`);
 ```
 
 ### Create a `Role` and a `SignerSession`
@@ -201,7 +202,7 @@ assert(sig.data().rlp_signed_tx);
 ```typescript
 const { ethers } = require("ethers");
 // Create new Signer
-const ethersSigner = new cs.ethers.Signer(secpKey.materialId, session /*, provider */);
+const ethersSigner = new cs.ethers.Signer(secpKey.materialId, session);
 assert((await ethersSigner.getAddress()) === secpKey.materialId);
 // sign transaction as usual:
 console.log(
@@ -264,22 +265,30 @@ disabled for `BLS` keys, and for other key types it can be enabled by
 attaching an `"AllowRawBlobSigning"` policy:
 
 ```typescript
-console.log("Confirming that raw blob is rejected by default");
-const blobReq = <cs.BlobSignRequest>{
-  message_base64: "L1kE9g59xD3fzYQQSR7340BwU9fGrP6EMfIFcyX/YBc=",
-};
-try {
-  await session.signBlob(secpKey, blobReq);
-  assert(false, "Must be rejected by policy");
-} catch (e) {
-  assert(`${e}`.includes("Raw blob signing not allowed"));
+// Create a new Ed25519 key (e.g., for Cardano) and add it to our session role
+const edKey = await org.createKey(cs.Ed25519.Cardano);
+await role.addKey(edKey);
+console.log(`Created '${await edKey.type()}' key ${edKey.id} and added it to role ${role.id}`);
+
+// Sign raw blobs with our new ed key and the secp we created before
+for (const key of [edKey, secpKey]) {
+  console.log(`Confirming that raw blob with ${await key.type()} is rejected by default`);
+  const blobReq = <cs.BlobSignRequest>{
+    message_base64: "L1kE9g59xD3fzYQQSR7340BwU9fGrP6EMfIFcyX/YBc=",
+  };
+  try {
+    await session.signBlob(key, blobReq);
+    assert(false, "Must be rejected by policy");
+  } catch (e) {
+    assert(`${e}`.includes("Raw blob signing not allowed"));
+  }
+
+  console.log("Signing raw blob after adding 'AllowRawBlobSigning' policy");
+  await key.appendPolicy(["AllowRawBlobSigning"]);
+  const blobSig = await session.signBlob(key, blobReq);
+  console.log(blobSig.data());
+  assert(blobSig.data().signature);
 }
-
-console.log("Signing raw blob after adding 'AllowRawBlobSigning' policy");
-await secpKey.appendPolicy(["AllowRawBlobSigning"]);
-const blobSig = await session.signBlob(secpKey, blobReq);
-console.log(blobSig.data());
-assert(blobSig.data().signature);
 ```
 
 > **Warning**
@@ -343,12 +352,29 @@ export the underlying token:
 const oidcToken = await cubesigner.sessionMgr!.token();
 ```
 
-and then exchange it for either a _signer_ session (i.e., an instance
-of `SignerSession`, required by all signing endpoints, e.g.,
-`signEvm`)
+Before we can use the OIDC token for authentication, we must add an org policy
+to allow the particular issuer/audience pair from the token.
 
 ```typescript
-const oidcSession = await cubesigner.createOidcSession(oidcToken, org.id, ["sign:*"]);
+const oldOrgPolicy = await org.policy();
+const oidcPayload = JSON.parse(atob(oidcToken.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")));
+const oidcAuthSourcesPolicy = {
+  OidcAuthSources: {
+    [oidcPayload.iss]: [oidcPayload.aud],
+  },
+};
+console.log("Setting org policy", oidcAuthSourcesPolicy);
+await org.setPolicy([oidcAuthSourcesPolicy]);
+```
+
+Finally, exchange the OIDC token for either a _signer_ session (i.e., an instance
+of `SignerSession`, required by all signing endpoints, e.g., `signEvm`)
+
+```typescript
+const oidcSession = new cs.SignerSession(
+  // we'll use this session for both signing and approving MFA request, hence the following scopes
+  await cubesigner.oidcAuth(oidcToken, org.id, ["manage:mfa", "sign:*"]),
+);
 ```
 
 or a _management_ session (i.e., and instance of `CubeSigner`,
@@ -357,7 +383,7 @@ information, configuring user MFA methods, etc.).
 
 ```typescript
 const oidcCubeSigner = new cs.CubeSigner({
-  sessionMgr: await cubesigner.createOidcManager(oidcToken, org.id, ["manage:*"]),
+  sessionMgr: await cubesigner.oidcAuth(oidcToken, org.id, ["manage:*"]),
 });
 ```
 
@@ -374,26 +400,56 @@ doesn't matter if that user is native to CubeSigner or a third-party
 OIDC user. For that purpose, in this section we are going to use the
 previously created `oidcCubeSigner` instance.
 
-To set up TOTP, we call the `resetTotp` method which creates a new
-TOTP configuration for the users (overwriting the previous one, if
-any) and returns a [TOTP
-url](https://github.com/google/google-authenticator/wiki/Key-Uri-Format).
+To set up TOTP, we first call the `resetTotpStart` method to initiate a
+TOTP reset procedure.
 
 ```typescript
 console.log(`Setting up TOTP for user ${me.email}`);
-const totpResp = await oidcCubeSigner.resetTotp();
-assert(totpResp.totp_url);
+let totpResetResp = await oidcCubeSigner.resetTotpStart();
+```
+
+If the user has already configured TOTP (or any other form of MFA),
+this response will require multi factor authentication. In that case,
+for example, call `approveTotp` and provide the code for the existing
+TOTP to proceed:
+
+```typescript
+import { authenticator } from "otplib"; // npm install otplib@12.0.1
+
+let totpSecret = process.env["CS_USER_TOTP_SECRET"]!;
+if (totpResetResp.requiresMfa()) {
+  console.log("Resetting TOTP requires MFA");
+  const code = authenticator.generate(totpSecret);
+  totpResetResp = await totpResetResp.approveTotp(oidcSession, code);
+  assert(!totpResetResp.requiresMfa());
+  console.log("MFA approved using existing TOTP");
+}
 ```
 
+The response contains a TOTP challenge, i.e., a new TOTP
+configuration in the form of the standard
+[TOTP url](https://github.com/google/google-authenticator/wiki/Key-Uri-Format).
 From that url, we can generate a QR code to present to the user, or
 create an authenticator for automated testing.
 
 ```typescript
-import { authenticator } from "otplib"; // npm install otplib@12.0.1
+const totpChallenge = totpResetResp.data();
+assert(totpChallenge.totpUrl);
+```
+
+To complete the challenge, we must call `resetTotpComplete` and
+provide the TOTP code matching the TOTP configuration from the challenge:
 
-const totpSecret = new URL(totpResp.totp_url).searchParams.get("secret");
+```typescript norun
+totpSecret = new URL(totpChallenge.totp_url).searchParams.get("secret");
 assert(totpSecret);
+await totpChallenge.answer(authenticator.generate(totpSecret));
+```
 
+After TOTP is configured, we can double check that our authenticator
+is generating the correct code by calling `verifyTotp`
+
+```typescript
 console.log(`Verifying current TOTP code`);
 let code = authenticator.generate(totpSecret);
 await oidcCubeSigner.verifyTotp(code);
@@ -405,7 +461,7 @@ as one of the configured MFA factors.
 ```typescript
 const mfa = (await oidcCubeSigner.aboutMe()).mfa;
 console.log("Configured MFA types", mfa);
-assert(mfa.includes("Totp"));
+assert(mfa.map((m) => m.type).includes("totp"));
 ```
 
 ### Configure MFA policy for signing
@@ -453,6 +509,11 @@ we created.
 console.log("Cleaning up");
 await session.sessionMgr.revoke();
 await role.delete();
+
+// restore the old policy for the sake of repeatability of this example
+// (normally you'd set your org policies once and leave them be)
+console.log("Restoring org policy", oldOrgPolicy);
+await org.setPolicy(oldOrgPolicy);
 ```
 
 As of now, deleting keys is not supported.

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

@@ -1,16 +1,35 @@
 import { TypedDataDomain, TypedDataField, ethers } from "ethers";
-import { SignerSession } from "../signer_session";
+import { MfaRequestInfo, SignerSession } from "../signer_session";
+import { KeyInfo } from "../key";
+import { CubeSigner } from "..";
+/** Options for the signer */
+interface SignerOptions {
+    /** Optional provider to use */
+    provider?: null | ethers.Provider;
+    /**
+     * The function to call when MFA information is retrieved. If this callback
+     * throws, no transaction is broadcast.
+     */
+    onMfaPoll?: (arg0: MfaRequestInfo) => void;
+    /**
+     * The amount of time (in milliseconds) to wait between checks for MFA
+     * updates. Default is 1000ms
+     */
+    mfaPollIntervalMs?: number;
+    /** 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
-     * @param {string} address The address of the account to use.
+     * @param {KeyInfo | string} address The key or the eth address of the account to use.
      * @param {SignerSession} signerSession The underlying Signer session.
-     * @param {null | ethers.Provider} provider The optional provider instance to use.
+     * @param {SignerOptions} options The options to use for the Signer instance
      */
-    constructor(address: string, signerSession: SignerSession, provider?: null | ethers.Provider);
+    constructor(address: KeyInfo | string, signerSession: SignerSession, options?: SignerOptions);
     /** Resolves to the signer address. */
     getAddress(): Promise<string>;
     /**
@@ -20,7 +39,7 @@ 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.
+     * Signs a transaction. This populates the transaction type to `0x02` (EIP-1559) unless set. 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.
      */
@@ -48,3 +67,4 @@ export declare class Signer extends ethers.AbstractSigner {
      */
     private signBlob;
 }
+export {};

package/dist/src/ethers/index.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _Signer_address, _Signer_key, _Signer_signerSession;
+var _Signer_instances, _Signer_address, _Signer_key, _Signer_signerSession, _Signer_onMfaPoll, _Signer_mfaPollIntervalMs, _Signer_managementSession, _Signer_handleMfa;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Signer = void 0;
 const ethers_1 = require("ethers");
@@ -19,20 +19,39 @@ const ethers_1 = require("ethers");
  */
 class Signer extends ethers_1.ethers.AbstractSigner {
     /** Create new Signer instance
-     * @param {string} address The address of the account to use.
+     * @param {KeyInfo | string} address The key or the eth address of the account to use.
      * @param {SignerSession} signerSession The underlying Signer session.
-     * @param {null | ethers.Provider} provider The optional provider instance to use.
+     * @param {SignerOptions} options The options to use for the Signer instance
      */
-    constructor(address, signerSession, provider) {
-        super(provider);
+    constructor(address, signerSession, options) {
+        super(options?.provider);
+        _Signer_instances.add(this);
         /** The address of the account */
         _Signer_address.set(this, void 0);
         /** The key to use for signing */
         _Signer_key.set(this, void 0);
         /** The underlying session */
         _Signer_signerSession.set(this, void 0);
-        __classPrivateFieldSet(this, _Signer_address, address, "f");
+        /**
+         * The function to call when MFA information is retrieved. If this callback
+         * throws, no transaction is broadcast.
+         */
+        _Signer_onMfaPoll.set(this, void 0);
+        /** The amount of time to wait between checks for MFA updates */
+        _Signer_mfaPollIntervalMs.set(this, void 0);
+        /** Optional management session, used for MFA flows */
+        _Signer_managementSession.set(this, void 0);
+        if (typeof address === "string") {
+            __classPrivateFieldSet(this, _Signer_address, address, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Signer_address, address.materialId, "f");
+            __classPrivateFieldSet(this, _Signer_key, address, "f");
+        }
         __classPrivateFieldSet(this, _Signer_signerSession, signerSession, "f");
+        __classPrivateFieldSet(this, _Signer_onMfaPoll, options?.onMfaPoll ?? (( /* _mfaInfo: MfaRequestInfo */) => { }), "f"); // eslint-disable-line @typescript-eslint/no-empty-function
+        __classPrivateFieldSet(this, _Signer_mfaPollIntervalMs, options?.mfaPollIntervalMs ?? 1000, "f");
+        __classPrivateFieldSet(this, _Signer_managementSession, options?.managementSession, "f");
     }
     /** Resolves to the signer address. */
     async getAddress() {
@@ -44,10 +63,10 @@ class Signer extends ethers_1.ethers.AbstractSigner {
      *  @return {Signer} The signer connected to signer.
      */
     connect(provider) {
-        return new Signer(__classPrivateFieldGet(this, _Signer_address, "f"), __classPrivateFieldGet(this, _Signer_signerSession, "f"), provider);
+        return new Signer(__classPrivateFieldGet(this, _Signer_address, "f"), __classPrivateFieldGet(this, _Signer_signerSession, "f"), { provider });
     }
     /**
-     * Signs a transaction. This populates the transaction type to `0x02` (EIP-1559) unless set.
+     * Signs a transaction. This populates the transaction type to `0x02` (EIP-1559) unless set. 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.
      */
@@ -70,8 +89,9 @@ class Signer extends ethers_1.ethers.AbstractSigner {
             chain_id: Number(chainId),
             tx: rpcTx,
         };
-        const sig = await __classPrivateFieldGet(this, _Signer_signerSession, "f").signEvm(__classPrivateFieldGet(this, _Signer_address, "f"), req);
-        return sig.data().rlp_signed_tx;
+        const res = await __classPrivateFieldGet(this, _Signer_signerSession, "f").signEvm(__classPrivateFieldGet(this, _Signer_address, "f"), req);
+        const data = await __classPrivateFieldGet(this, _Signer_instances, "m", _Signer_handleMfa).call(this, res);
+        return data.rlp_signed_tx;
     }
     /** 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}.
@@ -106,17 +126,39 @@ class Signer extends ethers_1.ethers.AbstractSigner {
         };
         // Get the key corresponding to this address
         if (__classPrivateFieldGet(this, _Signer_key, "f") === undefined) {
-            const key = (await __classPrivateFieldGet(this, _Signer_signerSession, "f").keys()).find((k) => k.materialId === __classPrivateFieldGet(this, _Signer_address, "f"));
+            const key = (await __classPrivateFieldGet(this, _Signer_signerSession, "f").keys()).find((k) => k.material_id === __classPrivateFieldGet(this, _Signer_address, "f"));
             if (key === undefined) {
                 throw new Error(`Cannot access key '${__classPrivateFieldGet(this, _Signer_address, "f")}'`);
             }
             __classPrivateFieldSet(this, _Signer_key, key, "f");
         }
-        // sign
-        const result = await __classPrivateFieldGet(this, _Signer_signerSession, "f").signBlob(__classPrivateFieldGet(this, _Signer_key, "f"), blobReq);
-        return result.data().signature;
+        const res = await __classPrivateFieldGet(this, _Signer_signerSession, "f").signBlob(__classPrivateFieldGet(this, _Signer_key, "f").key_id, blobReq);
+        const data = await __classPrivateFieldGet(this, _Signer_instances, "m", _Signer_handleMfa).call(this, res);
+        return data.signature;
     }
 }
 exports.Signer = Signer;
-_Signer_address = new WeakMap(), _Signer_key = new WeakMap(), _Signer_signerSession = new WeakMap();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/ethers/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  JsonRpcApiProvider,\n  TypedDataDomain,\n  TypedDataEncoder,\n  TypedDataField,\n  ethers,\n  getBytes,\n  toBeHex,\n} from \"ethers\";\nimport { BlobSignRequest, EvmSignRequest, SignerSession } from \"../signer_session\";\nimport { Key } from \"../key\";\n\n/**\n * A ethers.js Signer using CubeSigner\n */\nexport class Signer extends ethers.AbstractSigner {\n  /** The address of the account */\n  readonly #address: string;\n\n  /** The key to use for signing */\n  #key?: Key;\n\n  /** The underlying session */\n  readonly #signerSession: SignerSession;\n\n  /** Create new Signer instance\n   * @param {string} address The address of the account to use.\n   * @param {SignerSession} signerSession The underlying Signer session.\n   * @param {null | ethers.Provider} provider The optional provider instance to use.\n   */\n  constructor(address: string, signerSession: SignerSession, provider?: null | ethers.Provider) {\n    super(provider);\n    this.#address = address;\n    this.#signerSession = signerSession;\n  }\n\n  /** Resolves to the signer address. */\n  async getAddress(): Promise<string> {\n    return this.#address;\n  }\n\n  /**\n   *  Returns the signer connected to %%provider%%.\n   *  @param {null | ethers.Provider} provider The optional provider instance to use.\n   *  @return {Signer} The signer connected to signer.\n   */\n  connect(provider: null | ethers.Provider): Signer {\n    return new Signer(this.#address, this.#signerSession, provider);\n  }\n\n  /**\n   * Signs a transaction. This populates the transaction type to `0x02` (EIP-1559) unless set.\n   * @param {ethers.TransactionRequest} tx The transaction to sign.\n   * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.\n   */\n  async signTransaction(tx: ethers.TransactionRequest): Promise<string> {\n    // get the chain id from the network or tx\n    let chainId = tx.chainId;\n    if (chainId === undefined) {\n      const network = await this.provider?.getNetwork();\n      chainId = network?.chainId?.toString() ?? \"1\";\n    }\n\n    // Convert the transaction into a JSON-RPC transaction\n    const rpcTx =\n      this.provider instanceof JsonRpcApiProvider\n        ? this.provider.getRpcTransaction(tx)\n        : // We can just call the getRpcTransaction with a\n          // null receiver since it doesn't actually use it\n          // (and really should be declared static).\n          JsonRpcApiProvider.prototype.getRpcTransaction.call(null, tx);\n    rpcTx.type = toBeHex(tx.type ?? 0x02, 1); // we expect 0x0[0-2]\n\n    const req = <EvmSignRequest>{\n      chain_id: Number(chainId),\n      tx: rpcTx,\n    };\n    const sig = await this.#signerSession.signEvm(this.#address, req);\n    return sig.data().rlp_signed_tx;\n  }\n\n  /** Signs arbitrary messages. This uses ethers.js's [hashMessage](https://docs.ethers.org/v6/api/hashing/#hashMessage)\n   * to compute the EIP-191 digest and signs this digest using {@link Key#signBlob}.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` policy attached.\n   * @param {string | Uint8Array} message The message to sign.\n   * @return {Promise<string>} The signature.\n   */\n  async signMessage(message: string | Uint8Array): Promise<string> {\n    const digest = ethers.hashMessage(message);\n    return this.signBlob(digest);\n  }\n\n  /** Signs EIP-712 typed data. This uses ethers.js's\n   * [TypedDataEncoder.hash](https://docs.ethers.org/v6/api/hashing/#TypedDataEncoder_hash)\n   * to compute the EIP-712 digest and signs this digest using {@link Key#signBlob}.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` policy attached.\n   * @param {TypedDataDomain} domain The domain of the typed data.\n   * @param {Record<string, Array<TypedDataField>>} types The types of the typed data.\n   * @param {Record<string, any>} value The value of the typed data.\n   * @return {Promise<string>} The signature.\n   */\n  async signTypedData(\n    domain: TypedDataDomain,\n    types: Record<string, Array<TypedDataField>>,\n    value: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any\n  ): Promise<string> {\n    const digest = TypedDataEncoder.hash(domain, types, value);\n    return this.signBlob(digest);\n  }\n\n  /** Sign arbitrary digest. This uses {@link Key#signBlob}.\n   * @param {string} digest The digest to sign.\n   * @return {Promise<string>} The signature.\n   */\n  private async signBlob(digest: string): Promise<string> {\n    const blobReq = <BlobSignRequest>{\n      message_base64: Buffer.from(getBytes(digest)).toString(\"base64\"),\n    };\n    // Get the key corresponding to this address\n    if (this.#key === undefined) {\n      const key = (await this.#signerSession.keys()).find((k) => k.materialId === this.#address);\n      if (key === undefined) {\n        throw new Error(`Cannot access key '${this.#address}'`);\n      }\n      this.#key = key;\n    }\n    // sign\n    const result = await this.#signerSession.signBlob(this.#key, blobReq);\n    return result.data().signature;\n  }\n}\n"]}
+_Signer_address = new WeakMap(), _Signer_key = new WeakMap(), _Signer_signerSession = new WeakMap(), _Signer_onMfaPoll = new WeakMap(), _Signer_mfaPollIntervalMs = new WeakMap(), _Signer_managementSession = new WeakMap(), _Signer_instances = new WeakSet(), _Signer_handleMfa = 
+/**
+ * If the sign request requires MFA, this method waits for approvals
+ *
+ * @param {SignResponse<U>} res The response of a sign request
+ * @return {Promise<U>} The sign data after MFA approvals
+ */
+async function _Signer_handleMfa(res) {
+    while (res.requiresMfa()) {
+        await new Promise((resolve) => setTimeout(resolve, __classPrivateFieldGet(this, _Signer_mfaPollIntervalMs, "f")));
+        const mfaId = res.mfaId();
+        const mfaInfo = await __classPrivateFieldGet(this, _Signer_signerSession, "f").getMfaInfo(__classPrivateFieldGet(this, _Signer_managementSession, "f"), mfaId);
+        __classPrivateFieldGet(this, _Signer_onMfaPoll, "f").call(this, mfaInfo);
+        if (mfaInfo.receipt) {
+            res = await res.signWithMfaApproval({
+                mfaId,
+                mfaOrgId: __classPrivateFieldGet(this, _Signer_signerSession, "f").orgId,
+                mfaConf: mfaInfo.receipt.confirmation,
+            });
+        }
+    }
+    return res.data();
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/ethers/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  JsonRpcApiProvider,\n  TypedDataDomain,\n  TypedDataEncoder,\n  TypedDataField,\n  ethers,\n  getBytes,\n  toBeHex,\n} from \"ethers\";\nimport {\n  BlobSignRequest,\n  EvmSignRequest,\n  MfaRequestInfo,\n  SignerSession,\n  SignResponse,\n} from \"../signer_session\";\nimport { KeyInfo } from \"../key\";\nimport { CubeSigner } from \"..\";\n\n/** Options for the signer */\ninterface SignerOptions {\n  /** Optional provider to use */\n  provider?: null | ethers.Provider;\n  /**\n   * The function to call when MFA information is retrieved. If this callback\n   * throws, no transaction is broadcast.\n   */\n  onMfaPoll?: (arg0: MfaRequestInfo) => void;\n  /**\n   * The amount of time (in milliseconds) to wait between checks for MFA\n   * updates. Default is 1000ms\n   */\n  mfaPollIntervalMs?: number;\n  /** Optional management session. Used to check for MFA updates */\n  managementSession?: CubeSigner;\n}\n\n/**\n * A ethers.js Signer using CubeSigner\n */\nexport class Signer extends ethers.AbstractSigner {\n  /** The address of the account */\n  readonly #address: string;\n\n  /** The key to use for signing */\n  #key?: KeyInfo;\n\n  /** The underlying session */\n  readonly #signerSession: SignerSession;\n\n  /**\n   * The function to call when MFA information is retrieved. If this callback\n   * throws, no transaction is broadcast.\n   */\n  readonly #onMfaPoll: (arg0: MfaRequestInfo) => void;\n\n  /** The amount of time to wait between checks for MFA updates */\n  readonly #mfaPollIntervalMs: number;\n\n  /** Optional management session, used for MFA flows */\n  readonly #managementSession?: CubeSigner;\n\n  /** Create new Signer instance\n   * @param {KeyInfo | string} address The key or the eth address of the account to use.\n   * @param {SignerSession} signerSession The underlying Signer session.\n   * @param {SignerOptions} options The options to use for the Signer instance\n   */\n  constructor(address: KeyInfo | string, signerSession: SignerSession, options?: SignerOptions) {\n    super(options?.provider);\n    if (typeof address === \"string\") {\n      this.#address = address;\n    } else {\n      this.#address = address.materialId;\n      this.#key = address as KeyInfo;\n    }\n    this.#signerSession = signerSession;\n    this.#onMfaPoll = options?.onMfaPoll ?? ((/* _mfaInfo: MfaRequestInfo */) => {}); // eslint-disable-line @typescript-eslint/no-empty-function\n    this.#mfaPollIntervalMs = options?.mfaPollIntervalMs ?? 1000;\n    this.#managementSession = options?.managementSession;\n  }\n\n  /** Resolves to the signer address. */\n  async getAddress(): Promise<string> {\n    return this.#address;\n  }\n\n  /**\n   *  Returns the signer connected to %%provider%%.\n   *  @param {null | ethers.Provider} provider The optional provider instance to use.\n   *  @return {Signer} The signer connected to signer.\n   */\n  connect(provider: null | ethers.Provider): Signer {\n    return new Signer(this.#address, this.#signerSession, { provider });\n  }\n\n  /**\n   * Signs a transaction. This populates the transaction type to `0x02` (EIP-1559) unless set. This method will block if the key requires MFA approval.\n   * @param {ethers.TransactionRequest} tx The transaction to sign.\n   * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.\n   */\n  async signTransaction(tx: ethers.TransactionRequest): Promise<string> {\n    // get the chain id from the network or tx\n    let chainId = tx.chainId;\n    if (chainId === undefined) {\n      const network = await this.provider?.getNetwork();\n      chainId = network?.chainId?.toString() ?? \"1\";\n    }\n\n    // Convert the transaction into a JSON-RPC transaction\n    const rpcTx =\n      this.provider instanceof JsonRpcApiProvider\n        ? this.provider.getRpcTransaction(tx)\n        : // We can just call the getRpcTransaction with a\n          // null receiver since it doesn't actually use it\n          // (and really should be declared static).\n          JsonRpcApiProvider.prototype.getRpcTransaction.call(null, tx);\n    rpcTx.type = toBeHex(tx.type ?? 0x02, 1); // we expect 0x0[0-2]\n\n    const req = <EvmSignRequest>{\n      chain_id: Number(chainId),\n      tx: rpcTx,\n    };\n\n    const res = await this.#signerSession.signEvm(this.#address, req);\n    const data = await this.#handleMfa(res);\n    return data.rlp_signed_tx;\n  }\n\n  /** Signs arbitrary messages. This uses ethers.js's [hashMessage](https://docs.ethers.org/v6/api/hashing/#hashMessage)\n   * to compute the EIP-191 digest and signs this digest using {@link Key#signBlob}.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` policy attached.\n   * @param {string | Uint8Array} message The message to sign.\n   * @return {Promise<string>} The signature.\n   */\n  async signMessage(message: string | Uint8Array): Promise<string> {\n    const digest = ethers.hashMessage(message);\n    return this.signBlob(digest);\n  }\n\n  /** Signs EIP-712 typed data. This uses ethers.js's\n   * [TypedDataEncoder.hash](https://docs.ethers.org/v6/api/hashing/#TypedDataEncoder_hash)\n   * to compute the EIP-712 digest and signs this digest using {@link Key#signBlob}.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` policy attached.\n   * @param {TypedDataDomain} domain The domain of the typed data.\n   * @param {Record<string, Array<TypedDataField>>} types The types of the typed data.\n   * @param {Record<string, any>} value The value of the typed data.\n   * @return {Promise<string>} The signature.\n   */\n  async signTypedData(\n    domain: TypedDataDomain,\n    types: Record<string, Array<TypedDataField>>,\n    value: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any\n  ): Promise<string> {\n    const digest = TypedDataEncoder.hash(domain, types, value);\n    return this.signBlob(digest);\n  }\n\n  /** Sign arbitrary digest. This uses {@link Key#signBlob}.\n   * @param {string} digest The digest to sign.\n   * @return {Promise<string>} The signature.\n   */\n  private async signBlob(digest: string): Promise<string> {\n    const blobReq = <BlobSignRequest>{\n      message_base64: Buffer.from(getBytes(digest)).toString(\"base64\"),\n    };\n    // Get the key corresponding to this address\n    if (this.#key === undefined) {\n      const key = (await this.#signerSession.keys()).find((k) => k.material_id === this.#address);\n      if (key === undefined) {\n        throw new Error(`Cannot access key '${this.#address}'`);\n      }\n      this.#key = key;\n    }\n\n    const res = await this.#signerSession.signBlob(this.#key.key_id, blobReq);\n    const data = await this.#handleMfa(res);\n    return data.signature;\n  }\n\n  /**\n   * If the sign request requires MFA, this method waits for approvals\n   *\n   * @param {SignResponse<U>} res The response of a sign request\n   * @return {Promise<U>} The sign data after MFA approvals\n   */\n  async #handleMfa<U>(res: SignResponse<U>): Promise<U> {\n    while (res.requiresMfa()) {\n      await new Promise((resolve) => setTimeout(resolve, this.#mfaPollIntervalMs));\n\n      const mfaId = res.mfaId();\n      const mfaInfo = await this.#signerSession.getMfaInfo(this.#managementSession!, mfaId);\n      this.#onMfaPoll(mfaInfo);\n      if (mfaInfo.receipt) {\n        res = await res.signWithMfaApproval({\n          mfaId,\n          mfaOrgId: this.#signerSession.orgId,\n          mfaConf: mfaInfo.receipt.confirmation,\n        });\n      }\n    }\n    return res.data();\n  }\n}\n"]}

package/dist/src/fido.d.ts

@@ -0,0 +1,76 @@
+import { CubeSigner, MfaRequestInfo, SignerSession } from ".";
+import { components } from "./schema";
+export type ApiAddFidoChallenge = components["responses"]["FidoCreateChallengeResponse"]["content"]["application/json"];
+export type ApiMfaFidoChallenge = components["responses"]["FidoAssertChallenge"]["content"]["application/json"];
+export type PublicKeyCredentialCreationOptions = components["schemas"]["PublicKeyCredentialCreationOptions"];
+export type PublicKeyCredentialRequestOptions = components["schemas"]["PublicKeyCredentialRequestOptions"];
+export type PublicKeyCredentialParameters = components["schemas"]["PublicKeyCredentialParameters"];
+export type PublicKeyCredentialDescriptor = components["schemas"]["PublicKeyCredentialDescriptor"];
+export type AuthenticatorSelectionCriteria = components["schemas"]["AuthenticatorSelectionCriteria"];
+export type PublicKeyCredentialUserEntity = components["schemas"]["PublicKeyCredentialUserEntity"];
+export type PublicKeyCredential = components["schemas"]["PublicKeyCredential"];
+/**
+ * Returned after creating a request to add a new FIDO device.
+ * Provides some helper methods for answering this challenge.
+ */
+export declare class AddFidoChallenge {
+    #private;
+    readonly challengeId: string;
+    readonly options: any;
+    /**
+     * Constructor
+     * @param {CubeSigner} cs CubeSigner instance used to request to add a FIDO device
+     * @param {ApiAddFidoChallenge} challenge The challenge returned by the remote end.
+     */
+    constructor(cs: CubeSigner, challenge: ApiAddFidoChallenge);
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to create a credential
+     * based on the the public key credential creation options from this challenge.
+     */
+    createCredentialAndAnswer(): Promise<void>;
+    /**
+     * Answers this challenge using a given credential `cred`;
+     * the credential should be obtained by calling
+     *
+     * ```
+     * const cred = await navigator.credentials.create({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `create` method
+     *                   based on the public key creation options from this challenge.
+     */
+    answer(cred: any): Promise<void>;
+}
+/**
+ * Returned after initiating MFA approval using FIDO.
+ * Provides some helper methods for answering this challenge.
+ */
+export declare class MfaFidoChallenge {
+    #private;
+    readonly mfaId: string;
+    readonly challengeId: string;
+    readonly options: any;
+    /**
+     * @param {SignerSession} ss The session used to initiate MFA approval using FIDO
+     * @param {string} mfaId The MFA request id.
+     * @param {ApiMfaFidoChallenge} challenge The challenge returned by the remote end
+     */
+    constructor(ss: SignerSession, mfaId: string, challenge: ApiMfaFidoChallenge);
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to get a credential
+     * based on the the public key credential request options from this challenge.
+     */
+    createCredentialAndAnswer(): Promise<MfaRequestInfo>;
+    /**
+     * Answers this challenge using a given credential `cred`.
+     * To obtain this credential, for example, call
+     *
+     * ```
+     * const cred = await navigator.credentials.get({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `get` method
+     *                   based on the public key credential request options from this challenge.
+     */
+    answer(cred: any): Promise<MfaRequestInfo>;
+}