@account-kit/smart-contracts 4.39.0 → 4.41.0

package/src/light-account/accounts/base.ts

@@ -19,8 +19,9 @@ import {
   type Address,
   type Chain,
   type Hex,
-  type SignTypedDataParameters,
   type Transport,
+  type TypedData,
+  type TypedDataDefinition,
 } from "viem";
 import type {
   LightAccountEntryPointVersion,
@@ -28,6 +29,7 @@ import type {
   LightAccountVersion,
 } from "../types.js";
 import { AccountVersionRegistry } from "../utils.js";
+import type { SignatureRequest } from "@aa-sdk/core";
 
 enum SignatureType {
   EOA = "0x00",
@@ -142,11 +144,11 @@ export async function createLightAccountBase<
     });
   };
 
-  const signWith1271Wrapper = async (
+  const get1271Wrapper = (
     hashedMessage: Hex,
     version: string,
-  ): Promise<Hex> => {
-    return signer.signTypedData({
+  ): TypedDataDefinition => {
+    return {
       // EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)
       // https://github.com/alchemyplatform/light-account/blob/main/src/LightAccount.sol#L236
       domain: {
@@ -162,7 +164,45 @@ export async function createLightAccountBase<
         message: hashedMessage,
       },
       primaryType: "LightAccountMessage",
-    });
+    };
+  };
+
+  const prepareSign = async (
+    params: SignatureRequest,
+  ): Promise<SignatureRequest> => {
+    const messageHash =
+      params.type === "personal_sign"
+        ? hashMessage(params.data)
+        : hashTypedData(params.data);
+
+    switch (version as string) {
+      case "v1.0.1":
+        return params;
+      case "v1.0.2":
+        throw new Error(
+          `Version ${String(version)} of LightAccount doesn't support 1271`,
+        );
+      case "v1.1.0":
+        return {
+          type: "eth_signTypedData_v4",
+          data: get1271Wrapper(messageHash, "1"),
+        };
+      case "v2.0.0":
+        return {
+          type: "eth_signTypedData_v4",
+          data: get1271Wrapper(messageHash, "2"),
+        };
+      default:
+        throw new Error(`Unknown version ${String(version)} of LightAccount`);
+    }
+  };
+
+  const formatSign = async (
+    signature: `0x${string}`,
+  ): Promise<`0x${string}`> => {
+    return version === "v2.0.0"
+      ? concat([SignatureType.EOA, signature])
+      : signature;
   };
 
   const account = await toSmartContractAccount({
@@ -172,6 +212,8 @@ export async function createLightAccountBase<
     accountAddress,
     source: type,
     getAccountInitCode,
+    prepareSign,
+    formatSign,
     encodeExecute: async ({ target, data, value }) => {
       return encodeFunctionData({
         abi,
@@ -207,46 +249,33 @@ export async function createLightAccountBase<
       }
     },
     async signMessage({ message }) {
-      switch (version as string) {
-        case "v1.0.1":
-          return signer.signMessage(message);
-        case "v1.0.2":
-          throw new Error(`${type} ${String(version)} doesn't support 1271`);
-        case "v1.1.0":
-          return signWith1271Wrapper(hashMessage(message), "1");
-        case "v2.0.0":
-          const signature = await signWith1271Wrapper(
-            hashMessage(message),
-            "2",
-          );
-          // TODO: handle case where signer is an SCA.
-          return concat([SignatureType.EOA, signature]);
-        default:
-          throw new Error(`Unknown version ${type} of ${String(version)}`);
-      }
+      const { type, data } = await prepareSign({
+        type: "personal_sign",
+        data: message,
+      });
+
+      const sig =
+        type === "personal_sign"
+          ? await signer.signMessage(data)
+          : await signer.signTypedData(data);
+
+      return formatSign(sig);
     },
-    async signTypedData(params) {
-      switch (version as string) {
-        case "v1.0.1":
-          return signer.signTypedData(
-            params as unknown as SignTypedDataParameters,
-          );
-        case "v1.0.2":
-          throw new Error(
-            `Version ${String(version)} of LightAccount doesn't support 1271`,
-          );
-        case "v1.1.0":
-          return signWith1271Wrapper(hashTypedData(params), "1");
-        case "v2.0.0":
-          const signature = await signWith1271Wrapper(
-            hashTypedData(params),
-            "2",
-          );
-          // TODO: handle case where signer is an SCA.
-          return concat([SignatureType.EOA, signature]);
-        default:
-          throw new Error(`Unknown version ${String(version)} of LightAccount`);
-      }
+    async signTypedData<
+      const typedData extends TypedData | Record<string, unknown>,
+      primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+    >(params: TypedDataDefinition<typedData, primaryType>) {
+      const { type, data } = await prepareSign({
+        type: "eth_signTypedData_v4",
+        data: params as TypedDataDefinition,
+      });
+
+      const sig =
+        type === "personal_sign"
+          ? await signer.signMessage(data)
+          : await signer.signTypedData(data);
+
+      return formatSign(sig);
     },
     getDummySignature: (): Hex => {
       const signature =

package/src/ma-v2/account/common/modularAccountV2Base.ts

@@ -82,6 +82,8 @@ export type CreateMAV2BaseParams<
   | "signMessage"
   | "signTypedData"
   | "getDummySignature"
+  | "prepareSign"
+  | "formatSign"
 > & {
   signer: TSigner;
   signerEntity?: SignerEntity;

package/src/ma-v2/account/nativeSMASigner.ts

@@ -1,4 +1,8 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
+import type {
+  SmartAccountSigner,
+  SigningMethods,
+  SignatureRequest,
+} from "@aa-sdk/core";
 import {
   type Address,
   type Chain,
@@ -11,13 +15,14 @@ import {
   type TypedData,
   type TypedDataDefinition,
 } from "viem";
-
-import { SignatureType } from "../modules/utils.js";
 import {
-  DEFAULT_OWNER_ENTITY_ID,
-  pack1271Signature,
   packUOSignature,
+  pack1271Signature,
+  DEFAULT_OWNER_ENTITY_ID,
+  assertNeverSignatureRequestType,
 } from "../utils.js";
+import { SignatureType } from "../modules/utils.js";
+
 /**
  * Creates an object with methods for generating a dummy signature, signing user operation hashes, signing messages, and signing typed data.
  *
@@ -47,7 +52,60 @@ export const nativeSMASigner = (
   accountAddress: Address,
   deferredActionData?: Hex,
 ) => {
+  const signingMethods: SigningMethods = {
+    prepareSign: async (
+      request: SignatureRequest,
+    ): Promise<SignatureRequest> => {
+      let hash;
+
+      switch (request.type) {
+        case "personal_sign":
+          hash = hashMessage(request.data);
+          break;
+
+        case "eth_signTypedData_v4":
+          const isDeferredAction =
+            request.data?.primaryType === "DeferredAction" &&
+            request.data?.domain?.verifyingContract === accountAddress;
+
+          if (isDeferredAction) {
+            return request;
+          } else {
+            hash = await hashTypedData(request.data);
+            break;
+          }
+
+        default:
+          assertNeverSignatureRequestType();
+      }
+
+      return {
+        type: "eth_signTypedData_v4",
+        data: {
+          domain: {
+            chainId: Number(chain.id),
+            verifyingContract: accountAddress,
+          },
+          types: {
+            ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
+          },
+          message: {
+            hash,
+          },
+          primaryType: "ReplaySafeHash",
+        },
+      };
+    },
+    formatSign: async (signature: Hex) => {
+      return pack1271Signature({
+        validationSignature: signature,
+        entityId: DEFAULT_OWNER_ENTITY_ID,
+      });
+    },
+  };
+
   return {
+    ...signingMethods,
     getDummySignature: (): Hex => {
       const sig = packUOSignature({
         // orderedHookData: [],
@@ -78,24 +136,18 @@ export const nativeSMASigner = (
 
     // we apply the expected 1271 packing here since the account contract will expect it
     async signMessage({ message }: { message: SignableMessage }): Promise<Hex> {
-      const hash = hashMessage(message);
-
-      return pack1271Signature({
-        validationSignature: await signer.signTypedData({
-          domain: {
-            chainId: Number(chain.id),
-            verifyingContract: accountAddress,
-          },
-          types: {
-            ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
-          },
-          message: {
-            hash,
-          },
-          primaryType: "ReplaySafeHash",
-        }),
-        entityId: DEFAULT_OWNER_ENTITY_ID,
+      const { type, data } = await signingMethods.prepareSign({
+        type: "personal_sign",
+        data: message,
       });
+
+      if (type !== "eth_signTypedData_v4") {
+        throw new Error("Invalid signature request type");
+      }
+
+      const sig = await signer.signTypedData(data);
+
+      return signingMethods.formatSign(sig);
     },
 
     // TODO: maybe move "sign deferred actions" to a separate function?
@@ -106,7 +158,17 @@ export const nativeSMASigner = (
     >(
       typedDataDefinition: TypedDataDefinition<typedData, primaryType>,
     ): Promise<Hex> => {
-      // the accounts domain already gives replay protection across accounts for deferred actions, so we don't need to apply another wrapping
+      const { type, data } = await signingMethods.prepareSign({
+        type: "eth_signTypedData_v4",
+        data: typedDataDefinition as TypedDataDefinition,
+      });
+
+      if (type !== "eth_signTypedData_v4") {
+        throw new Error("Invalid signature request type");
+      }
+
+      const sig = await signer.signTypedData(data);
+
       const isDeferredAction =
         typedDataDefinition.primaryType === "DeferredAction" &&
         typedDataDefinition.domain != null &&
@@ -115,26 +177,8 @@ export const nativeSMASigner = (
         typedDataDefinition.domain.verifyingContract === accountAddress;
 
       return isDeferredAction
-        ? concat([
-            SignatureType.EOA,
-            await signer.signTypedData(typedDataDefinition),
-          ])
-        : pack1271Signature({
-            validationSignature: await signer.signTypedData({
-              domain: {
-                chainId: Number(chain.id),
-                verifyingContract: accountAddress,
-              },
-              types: {
-                ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
-              },
-              message: {
-                hash: await hashTypedData(typedDataDefinition),
-              },
-              primaryType: "ReplaySafeHash",
-            }),
-            entityId: DEFAULT_OWNER_ENTITY_ID,
-          });
+        ? concat([SignatureType.EOA, sig])
+        : signingMethods.formatSign(sig);
     },
   };
 };

package/src/ma-v2/modules/single-signer-validation/signer.ts

@@ -1,4 +1,8 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
+import type {
+  SmartAccountSigner,
+  SigningMethods,
+  SignatureRequest,
+} from "@aa-sdk/core";
 import {
   type Address,
   type Chain,
@@ -15,8 +19,12 @@ import {
   getDefaultSingleSignerValidationModuleAddress,
   SignatureType,
 } from "../utils.js";
+import {
+  packUOSignature,
+  pack1271Signature,
+  assertNeverSignatureRequestType,
+} from "../../utils.js";
 
-import { pack1271Signature, packUOSignature } from "../../utils.js";
 /**
  * Creates an object with methods for generating a dummy signature, signing user operation hashes, signing messages, and signing typed data.
  *
@@ -49,7 +57,54 @@ export const singleSignerMessageSigner = (
   entityId: number,
   deferredActionData?: Hex,
 ) => {
+  const signingMethods: SigningMethods = {
+    prepareSign: async (
+      request: SignatureRequest,
+    ): Promise<SignatureRequest> => {
+      let hash;
+
+      switch (request.type) {
+        case "personal_sign":
+          hash = hashMessage(request.data);
+          break;
+
+        case "eth_signTypedData_v4":
+          hash = await hashTypedData(request.data);
+          break;
+
+        default:
+          assertNeverSignatureRequestType();
+      }
+
+      return {
+        type: "eth_signTypedData_v4",
+        data: {
+          domain: {
+            chainId: Number(chain.id),
+            verifyingContract:
+              getDefaultSingleSignerValidationModuleAddress(chain),
+            salt: concatHex([`0x${"00".repeat(12)}`, accountAddress]),
+          },
+          types: {
+            ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
+          },
+          message: {
+            hash,
+          },
+          primaryType: "ReplaySafeHash",
+        },
+      };
+    },
+    formatSign: async (signature: Hex) => {
+      return pack1271Signature({
+        validationSignature: signature,
+        entityId,
+      });
+    },
+  };
+
   return {
+    ...signingMethods,
     getDummySignature: (): Hex => {
       const sig = packUOSignature({
         // orderedHookData: [],
@@ -80,26 +135,18 @@ export const singleSignerMessageSigner = (
 
     // we apply the expected 1271 packing here since the account contract will expect it
     async signMessage({ message }: { message: SignableMessage }): Promise<Hex> {
-      const hash = await hashMessage(message);
-
-      return pack1271Signature({
-        validationSignature: await signer.signTypedData({
-          domain: {
-            chainId: Number(chain.id),
-            verifyingContract:
-              getDefaultSingleSignerValidationModuleAddress(chain),
-            salt: concatHex([`0x${"00".repeat(12)}`, accountAddress]),
-          },
-          types: {
-            ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
-          },
-          message: {
-            hash,
-          },
-          primaryType: "ReplaySafeHash",
-        }),
-        entityId,
+      const { type, data } = await signingMethods.prepareSign({
+        type: "personal_sign",
+        data: message,
       });
+
+      if (type !== "eth_signTypedData_v4") {
+        throw new Error("Invalid signature request type");
+      }
+
+      const sig = await signer.signTypedData(data);
+
+      return signingMethods.formatSign(sig);
     },
 
     // TODO: maybe move "sign deferred actions" to a separate function?
@@ -110,7 +157,17 @@ export const singleSignerMessageSigner = (
     >(
       typedDataDefinition: TypedDataDefinition<typedData, primaryType>,
     ): Promise<Hex> => {
-      // the accounts domain already gives replay protection across accounts for deferred actions, so we don't need to apply another wrapping
+      const { type, data } = await signingMethods.prepareSign({
+        type: "eth_signTypedData_v4",
+        data: typedDataDefinition as TypedDataDefinition,
+      });
+
+      if (type !== "eth_signTypedData_v4") {
+        throw new Error("Invalid signature request type");
+      }
+
+      const sig = await signer.signTypedData(data);
+
       const isDeferredAction =
         typedDataDefinition.primaryType === "DeferredAction" &&
         typedDataDefinition.domain != null &&
@@ -118,29 +175,9 @@ export const singleSignerMessageSigner = (
         "verifyingContract" in typedDataDefinition.domain &&
         typedDataDefinition.domain.verifyingContract === accountAddress;
 
-      const validationSignature = await signer.signTypedData({
-        domain: {
-          chainId: Number(chain.id),
-          verifyingContract:
-            getDefaultSingleSignerValidationModuleAddress(chain),
-          salt: concatHex([`0x${"00".repeat(12)}`, accountAddress]),
-        },
-        types: {
-          ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
-        },
-        message: {
-          hash: hashTypedData(typedDataDefinition),
-        },
-        primaryType: "ReplaySafeHash",
-      });
-
-      // TODO: Handle non-EOA signer case
       return isDeferredAction
-        ? concat([SignatureType.EOA, validationSignature])
-        : pack1271Signature({
-            validationSignature,
-            entityId,
-          });
+        ? concat([SignatureType.EOA, sig])
+        : signingMethods.formatSign(sig);
     },
   };
 };

package/src/ma-v2/utils.ts

@@ -315,3 +315,7 @@ export const buildDeferredActionDigest = ({
   ]);
   return encodedData;
 };
+
+export const assertNeverSignatureRequestType = (): never => {
+  throw new Error("Invalid signature request type ");
+};

package/src/msca/plugins/multi-owner/signer.ts

@@ -1,4 +1,9 @@
-import type { Address, BundlerClient, SmartAccountSigner } from "@aa-sdk/core";
+import type {
+  Address,
+  BundlerClient,
+  SmartAccountSigner,
+  SignatureRequest,
+} from "@aa-sdk/core";
 import {
   hashMessage,
   hashTypedData,
@@ -20,7 +25,7 @@ export const multiOwnerMessageSigner = <
   signer: () => TSigner,
   pluginAddress: Address = MultiOwnerPlugin.meta.addresses[client.chain.id],
 ) => {
-  const signWith712Wrapper = async (msg: Hash): Promise<`0x${string}`> => {
+  const get712Wrapper = async (msg: Hash): Promise<TypedDataDefinition> => {
     const [, name, version, chainId, verifyingContract, salt] =
       await client.readContract({
         abi: MultiOwnerPluginAbi,
@@ -29,7 +34,7 @@ export const multiOwnerMessageSigner = <
         account: accountAddress,
       });
 
-    return signer().signTypedData({
+    return {
       domain: {
         chainId: Number(chainId),
         name,
@@ -44,10 +49,32 @@ export const multiOwnerMessageSigner = <
         message: msg,
       },
       primaryType: "AlchemyModularAccountMessage",
-    });
+    };
+  };
+
+  const prepareSign = async (
+    params: SignatureRequest,
+  ): Promise<SignatureRequest> => {
+    const data = await get712Wrapper(
+      params.type === "personal_sign"
+        ? hashMessage(params.data)
+        : hashTypedData(params.data),
+    );
+    return {
+      type: "eth_signTypedData_v4",
+      data,
+    };
+  };
+
+  const formatSign = async (
+    signature: `0x${string}`,
+  ): Promise<`0x${string}`> => {
+    return signature;
   };
 
   return {
+    prepareSign,
+    formatSign,
     getDummySignature: (): Hex => {
       return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
     },
@@ -56,21 +83,33 @@ export const multiOwnerMessageSigner = <
       return signer().signMessage({ raw: uoHash });
     },
 
-    signMessage({
+    async signMessage({
       message,
     }: {
       message: SignableMessage;
     }): Promise<`0x${string}`> {
-      return signWith712Wrapper(hashMessage(message));
+      const { type, data } = await prepareSign({
+        type: "personal_sign",
+        data: message,
+      });
+      return type === "personal_sign"
+        ? signer().signMessage(data)
+        : signer().signTypedData(data);
     },
 
-    signTypedData: <
+    signTypedData: async <
       const typedData extends TypedData | Record<string, unknown>,
       primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
     >(
       typedDataDefinition: TypedDataDefinition<typedData, primaryType>,
     ): Promise<Hex> => {
-      return signWith712Wrapper(hashTypedData(typedDataDefinition));
+      const { type, data } = await prepareSign({
+        type: "eth_signTypedData_v4",
+        data: typedDataDefinition as TypedDataDefinition,
+      });
+      return type === "personal_sign"
+        ? signer().signMessage(data)
+        : signer().signTypedData(data);
     },
   };
 };