@account-kit/signer 4.26.0 → 4.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@account-kit/signer",
-  "version": "4.26.0",
+  "version": "4.28.0",
   "description": "Core interfaces and clients for interfacing with the Alchemy Signer API",
   "author": "Alchemy",
   "license": "MIT",
@@ -42,6 +42,7 @@
   },
   "devDependencies": {
     "@tanstack/react-query": "^5.28.9",
+    "@types/bs58": "^4.0.4",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "tailwindcss": "^3.4.3",
@@ -50,13 +51,14 @@
     "vitest": "^2.0.4"
   },
   "dependencies": {
-    "@aa-sdk/core": "^4.26.0",
-    "@account-kit/logging": "^4.26.0",
+    "@aa-sdk/core": "^4.28.0",
+    "@account-kit/logging": "^4.28.0",
     "@solana/web3.js": "^1.98.0",
     "@turnkey/http": "^2.6.2",
     "@turnkey/iframe-stamper": "^1.0.0",
     "@turnkey/viem": "^0.4.8",
     "@turnkey/webauthn-stamper": "^0.4.3",
+    "bs58": "^6.0.0",
     "jwt-decode": "^4.0.0",
     "zod": "^3.22.4",
     "zustand": "^5.0.0-rc.2"
@@ -76,5 +78,5 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "cce56919f91518b2bc1f94c1a721d99dd0f21646"
+  "gitHead": "fd15569ef554b4ff19c72d864e1031aad8bdf8b3"
 }

package/src/base.ts

@@ -28,8 +28,8 @@ import type {
   OauthParams,
   User,
   VerifyMfaParams,
-  EnableMfaParams,
-  EnableMfaResult,
+  AddMfaParams,
+  AddMfaResult,
   RemoveMfaParams,
 } from "./client/types";
 import { NotAuthenticatedError } from "./errors.js";
@@ -1214,11 +1214,11 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * // Result contains multiFactorTotpUrl to display as QR code
    * ```
    *
-   * @param {EnableMfaParams} params The parameters required to enable a new MFA factor
+   * @param {AddMfaParams} params The parameters required to enable a new MFA factor
    * @throws {NotAuthenticatedError} If no user is authenticated
-   * @returns {Promise<EnableMfaResult>} A promise that resolves to the factor setup information
+   * @returns {Promise<AddMfaResult>} A promise that resolves to the factor setup information
    */
-  addMfa: (params: EnableMfaParams) => Promise<EnableMfaResult> =
+  addMfa: (params: AddMfaParams) => Promise<AddMfaResult> =
     SignerLogger.profiled("BaseAlchemySigner.addMfa", async (params) => {
       return this.inner.addMfa(params);
     });

package/src/client/base.ts

@@ -16,8 +16,8 @@ import type {
   CreateAccountParams,
   RemoveMfaParams,
   EmailAuthParams,
-  EnableMfaParams,
-  EnableMfaResult,
+  AddMfaParams,
+  AddMfaResult,
   experimental_CreateApiKeyParams,
   GetOauthProviderUrlArgs,
   GetWebAuthnAttestationResult,
@@ -50,6 +50,14 @@ export type ExportWalletStamper = TurnkeyClient["stamper"] & {
   publicKey(): string | null;
 };
 
+const MFA_PAYLOAD = {
+  GET: "get_mfa",
+  ADD: "add_mfa",
+  DELETE: "delete_mfas",
+  VERIFY: "verify_mfa",
+  LIST: "list_mfas",
+} as const;
+
 /**
  * Base class for all Alchemy Signer clients
  */
@@ -142,53 +150,6 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     params: Omit<EmailAuthParams, "targetPublicKey">
   ): Promise<{ orgId: string; otpId?: string; multiFactors?: MfaFactor[] }>;
 
-  /**
-   * Retrieves the list of MFA factors configured for the current user.
-   *
-   * @returns {Promise<{ multiFactors: Array<MfaFactor> }>} A promise that resolves to an array of configured MFA factors
-   */
-  public abstract getMfaFactors(): Promise<{
-    multiFactors: MfaFactor[];
-  }>;
-
-  /**
-   * Initiates the setup of a new MFA factor for the current user. Mfa will need to be verified before it is active.
-   *
-   * @param {EnableMfaParams} params The parameters required to enable a new MFA factor
-   * @returns {Promise<EnableMfaResult>} A promise that resolves to the factor setup information
-   */
-  public abstract addMfa(params: EnableMfaParams): Promise<EnableMfaResult>;
-
-  /**
-   * Verifies a newly created MFA factor to complete the setup process.
-   *
-   * @param {VerifyMfaParams} params The parameters required to verify the MFA factor
-   * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to the updated list of MFA factors
-   */
-  public abstract verifyMfa(params: VerifyMfaParams): Promise<{
-    multiFactors: MfaFactor[];
-  }>;
-
-  /**
-   * Removes existing MFA factors by ID or factor type.
-   *
-   * @param {RemoveMfaParams} params The parameters specifying which factors to disable
-   * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to the updated list of MFA factors
-   */
-  public abstract removeMfa(params: RemoveMfaParams): Promise<{
-    multiFactors: MfaFactor[];
-  }>;
-
-  /**
-   * Validates multiple MFA factors using the provided encrypted payload and MFA codes.
-   *
-   * @param {ValidateMultiFactorsParams} params The validation parameters
-   * @returns {Promise<{ bundle: string }>} A promise that resolves to an object containing the credential bundle
-   */
-  public abstract validateMultiFactors(
-    params: ValidateMultiFactorsParams
-  ): Promise<{ bundle: string }>;
-
   public abstract completeAuthWithBundle(params: {
     bundle: string;
     orgId: string;
@@ -536,6 +497,167 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     return json as SignerResponse<R>;
   };
 
+  /**
+   * Retrieves the list of MFA factors configured for the current user.
+   *
+   * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to an array of configured MFA factors
+   * @throws {NotAuthenticatedError} If no user is authenticated
+   */
+  public getMfaFactors = async (): Promise<{
+    multiFactors: MfaFactor[];
+  }> => {
+    if (!this.user) {
+      throw new NotAuthenticatedError();
+    }
+
+    const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
+      organizationId: this.user.orgId,
+      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+      timestampMs: Date.now().toString(),
+      parameters: {
+        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+        hashFunction: "HASH_FUNCTION_NO_OP",
+        payload: MFA_PAYLOAD.LIST,
+        signWith: this.user.address,
+      },
+    });
+
+    return this.request("/v1/auth-list-multi-factors", {
+      stampedRequest,
+    });
+  };
+
+  /**
+   * Initiates the setup of a new MFA factor for the current user. Mfa will need to be verified before it is active.
+   *
+   * @param {AddMfaParams} params The parameters required to enable a new MFA factor
+   * @returns {Promise<AddMfaResult>} A promise that resolves to the factor setup information
+   * @throws {NotAuthenticatedError} If no user is authenticated
+   * @throws {Error} If an unsupported factor type is provided
+   */
+  public addMfa = async (params: AddMfaParams): Promise<AddMfaResult> => {
+    if (!this.user) {
+      throw new NotAuthenticatedError();
+    }
+
+    const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
+      organizationId: this.user.orgId,
+      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+      timestampMs: Date.now().toString(),
+      parameters: {
+        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+        hashFunction: "HASH_FUNCTION_NO_OP",
+        payload: MFA_PAYLOAD.ADD,
+        signWith: this.user.address,
+      },
+    });
+
+    switch (params.multiFactorType) {
+      case "totp":
+        return this.request("/v1/auth-request-multi-factor", {
+          stampedRequest,
+          multiFactorType: params.multiFactorType,
+        });
+      default:
+        throw new Error(
+          `Unsupported MFA factor type: ${params.multiFactorType}`
+        );
+    }
+  };
+
+  /**
+   * Verifies a newly created MFA factor to complete the setup process.
+   *
+   * @param {VerifyMfaParams} params The parameters required to verify the MFA factor
+   * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to the updated list of MFA factors
+   * @throws {NotAuthenticatedError} If no user is authenticated
+   */
+  public verifyMfa = async (
+    params: VerifyMfaParams
+  ): Promise<{ multiFactors: MfaFactor[] }> => {
+    if (!this.user) {
+      throw new NotAuthenticatedError();
+    }
+
+    const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
+      organizationId: this.user.orgId,
+      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+      timestampMs: Date.now().toString(),
+      parameters: {
+        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+        hashFunction: "HASH_FUNCTION_NO_OP",
+        payload: MFA_PAYLOAD.VERIFY,
+        signWith: this.user.address,
+      },
+    });
+
+    return this.request("/v1/auth-verify-multi-factor", {
+      stampedRequest,
+      multiFactorId: params.multiFactorId,
+      multiFactorCode: params.multiFactorCode,
+    });
+  };
+
+  /**
+   * Removes existing MFA factors by ID.
+   *
+   * @param {RemoveMfaParams} params The parameters specifying which factors to disable
+   * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to the updated list of MFA factors
+   * @throws {NotAuthenticatedError} If no user is authenticated
+   */
+  public removeMfa = async (
+    params: RemoveMfaParams
+  ): Promise<{ multiFactors: MfaFactor[] }> => {
+    if (!this.user) {
+      throw new NotAuthenticatedError();
+    }
+
+    const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
+      organizationId: this.user.orgId,
+      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+      timestampMs: Date.now().toString(),
+      parameters: {
+        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+        hashFunction: "HASH_FUNCTION_NO_OP",
+        payload: MFA_PAYLOAD.DELETE,
+        signWith: this.user.address,
+      },
+    });
+
+    return this.request("/v1/auth-delete-multi-factors", {
+      stampedRequest,
+      multiFactorIds: params.multiFactorIds,
+    });
+  };
+
+  /**
+   * Validates multiple MFA factors using the provided encrypted payload and MFA codes.
+   *
+   * @param {ValidateMultiFactorsParams} params The validation parameters
+   * @returns {Promise<{ bundle: string }>} A promise that resolves to an object containing the credential bundle
+   * @throws {Error} If no credential bundle is returned from the server
+   */
+  public validateMultiFactors = async (
+    params: ValidateMultiFactorsParams
+  ): Promise<{ bundle: string }> => {
+    // Send the encryptedPayload plus TOTP codes, etc:
+    const response = await this.request("/v1/auth-validate-multi-factors", {
+      encryptedPayload: params.encryptedPayload,
+      multiFactors: params.multiFactors,
+    });
+
+    // The server is expected to return the *decrypted* payload in `response.payload.credentialBundle`
+    if (!response.payload || !response.payload.credentialBundle) {
+      throw new Error(
+        "Request to validateMultiFactors did not return a credential bundle"
+      );
+    }
+
+    return {
+      bundle: response.payload.credentialBundle,
+    };
+  };
+
   // #endregion
 
   // #region PRIVATE METHODS

package/src/client/index.ts

@@ -17,25 +17,12 @@ import type {
   OauthConfig,
   OtpParams,
   User,
-  MfaFactor,
-  EnableMfaParams,
-  EnableMfaResult,
-  VerifyMfaParams,
-  RemoveMfaParams,
   SubmitOtpCodeResponse,
-  ValidateMultiFactorsParams,
 } from "./types.js";
-import { MfaRequiredError, NotAuthenticatedError } from "../errors.js";
+import { MfaRequiredError } from "../errors.js";
 import { parseMfaError } from "../utils/parseMfaError.js";
 
 const CHECK_CLOSE_INTERVAL = 500;
-const MFA_PAYLOAD = {
-  GET: "get_mfa",
-  ADD: "add_mfa",
-  DELETE: "delete_mfas",
-  VERIFY: "verify_mfa",
-  LIST: "list_mfas",
-};
 
 export const AlchemySignerClientParamsSchema = z.object({
   connection: ConnectionConfigSchema,
@@ -722,169 +709,6 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     const nonce = this.getOauthNonce(publicKey);
     return this.request("/v1/prepare-oauth", { nonce });
   };
-
-  /**
-   * Retrieves the list of MFA factors configured for the current user.
-   *
-   * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to an array of configured MFA factors
-   * @throws {NotAuthenticatedError} If no user is authenticated
-   */
-  public override getMfaFactors = async (): Promise<{
-    multiFactors: MfaFactor[];
-  }> => {
-    if (!this.user) {
-      throw new NotAuthenticatedError();
-    }
-
-    const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
-      organizationId: this.user.orgId,
-      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
-      timestampMs: Date.now().toString(),
-      parameters: {
-        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
-        hashFunction: "HASH_FUNCTION_NO_OP",
-        payload: MFA_PAYLOAD.LIST,
-        signWith: this.user.address,
-      },
-    });
-
-    return this.request("/v1/auth-list-multi-factors", {
-      stampedRequest,
-    });
-  };
-
-  /**
-   * Initiates the setup of a new MFA factor for the current user. Mfa will need to be verified before it is active.
-   *
-   * @param {EnableMfaParams} params The parameters required to enable a new MFA factor
-   * @returns {Promise<EnableMfaResult>} A promise that resolves to the factor setup information
-   * @throws {NotAuthenticatedError} If no user is authenticated
-   * @throws {Error} If an unsupported factor type is provided
-   */
-  public override addMfa = async (
-    params: EnableMfaParams
-  ): Promise<EnableMfaResult> => {
-    if (!this.user) {
-      throw new NotAuthenticatedError();
-    }
-
-    const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
-      organizationId: this.user.orgId,
-      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
-      timestampMs: Date.now().toString(),
-      parameters: {
-        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
-        hashFunction: "HASH_FUNCTION_NO_OP",
-        payload: MFA_PAYLOAD.ADD,
-        signWith: this.user.address,
-      },
-    });
-
-    switch (params.multiFactorType) {
-      case "totp":
-        return this.request("/v1/auth-request-multi-factor", {
-          stampedRequest,
-          multiFactorType: params.multiFactorType,
-        });
-      default:
-        throw new Error(
-          `Unsupported MFA factor type: ${params.multiFactorType}`
-        );
-    }
-  };
-
-  /**
-   * Verifies a newly created MFA factor to complete the setup process.
-   *
-   * @param {VerifyMfaParams} params The parameters required to verify the MFA factor
-   * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to the updated list of MFA factors
-   * @throws {NotAuthenticatedError} If no user is authenticated
-   */
-  public override verifyMfa = async (
-    params: VerifyMfaParams
-  ): Promise<{ multiFactors: MfaFactor[] }> => {
-    if (!this.user) {
-      throw new NotAuthenticatedError();
-    }
-
-    const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
-      organizationId: this.user.orgId,
-      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
-      timestampMs: Date.now().toString(),
-      parameters: {
-        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
-        hashFunction: "HASH_FUNCTION_NO_OP",
-        payload: MFA_PAYLOAD.VERIFY,
-        signWith: this.user.address,
-      },
-    });
-
-    return this.request("/v1/auth-verify-multi-factor", {
-      stampedRequest,
-      multiFactorId: params.multiFactorId,
-      multiFactorCode: params.multiFactorCode,
-    });
-  };
-
-  /**
-   * Removes existing MFA factors by ID.
-   *
-   * @param {RemoveMfaParams} params The parameters specifying which factors to disable
-   * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to the updated list of MFA factors
-   * @throws {NotAuthenticatedError} If no user is authenticated
-   */
-  public override removeMfa = async (
-    params: RemoveMfaParams
-  ): Promise<{ multiFactors: MfaFactor[] }> => {
-    if (!this.user) {
-      throw new NotAuthenticatedError();
-    }
-
-    const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
-      organizationId: this.user.orgId,
-      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
-      timestampMs: Date.now().toString(),
-      parameters: {
-        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
-        hashFunction: "HASH_FUNCTION_NO_OP",
-        payload: MFA_PAYLOAD.DELETE,
-        signWith: this.user.address,
-      },
-    });
-
-    return this.request("/v1/auth-delete-multi-factors", {
-      stampedRequest,
-      multiFactorIds: params.multiFactorIds,
-    });
-  };
-
-  /**
-   * Validates multiple MFA factors using the provided encrypted payload and MFA codes.
-   *
-   * @param {ValidateMultiFactorsParams} params The validation parameters
-   * @returns {Promise<{ bundle: string }>} A promise that resolves to an object containing the credential bundle
-   * @throws {Error} If no credential bundle is returned from the server
-   */
-  public override async validateMultiFactors(
-    params: ValidateMultiFactorsParams
-  ): Promise<{ bundle: string }> {
-    // Send the encryptedPayload plus TOTP codes, etc:
-    const response = await this.request("/v1/auth-validate-multi-factors", {
-      encryptedPayload: params.encryptedPayload,
-      multiFactors: params.multiFactors,
-    });
-
-    // The server is expected to return the *decrypted* payload in `response.payload.credentialBundle`
-    if (!response.payload || !response.payload.credentialBundle) {
-      throw new Error(
-        "Request to validateMultiFactors did not return a credential bundle"
-      );
-    }
-
-    return {
-      bundle: response.payload.credentialBundle,
-    };
-  }
 }
 
 /**

package/src/client/types.ts

@@ -208,7 +208,7 @@ export type SignerEndpoints = [
       stampedRequest: TSignedRequest;
       multiFactorType: MultiFactorType;
     };
-    Response: EnableMfaResult;
+    Response: AddMfaResult;
   },
   {
     Route: "/v1/auth-verify-multi-factor";
@@ -287,11 +287,11 @@ export type MfaFactor = {
 
 type MultiFactorType = "totp";
 
-export type EnableMfaParams = {
+export type AddMfaParams = {
   multiFactorType: MultiFactorType;
 };
 
-export type EnableMfaResult = {
+export type AddMfaResult = {
   multiFactorType: MultiFactorType;
   multiFactorId: string;
   multiFactorTotpUrl: string;
@@ -308,10 +308,7 @@ export type RemoveMfaParams = {
 
 export type ValidateMultiFactorsParams = {
   encryptedPayload: string;
-  multiFactors: Array<{
-    multiFactorId: string;
-    multiFactorCode: string;
-  }>;
+  multiFactors: VerifyMfaParams[];
 };
 
 export type MfaChallenge = {

package/src/index.ts

@@ -20,3 +20,4 @@ export { AlchemyWebSigner } from "./signer.js";
 export type * from "./solanaSigner.js";
 export type * from "./types.js";
 export { AlchemySignerStatus } from "./types.js";
+export { SolanaSigner } from "./solanaSigner.js";