@account-kit/wallet-client 0.1.0-alpha.7 → 0.1.0-alpha.8

package/dist/types/schemas.d.ts

@@ -1,4 +1,8 @@
 import { type SchemaOptions, type Static } from "@sinclair/typebox";
+export declare const baseAccountTypes: readonly ["sma-b", "la-v2", "la-v1.0.1", "la-v1.0.2", "la-v1.1.0"];
+export type BaseAccountType = (typeof baseAccountTypes)[number];
+export declare const accountTypes: readonly ["sma-b", "la-v2", "la-v1.0.1", "la-v1.0.2", "la-v1.1.0", "7702"];
+export type AccountType = (typeof accountTypes)[number];
 export declare const TypeHex: (options?: SchemaOptions) => import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 export declare const TypeAddress: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 export declare const TypeUuid: import("@sinclair/typebox").TString;
@@ -141,7 +145,7 @@ export declare const TypeCounterfactualInfo: import("@sinclair/typebox").TInters
 }>]>]>;
 export type TypeCounterfactualInfo = Static<typeof TypeCounterfactualInfo>;
 export declare const TypeCreationOptions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
-    accountType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TLiteral<"sma-b">>;
+    accountType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"sma-b" | "la-v2" | "la-v1.0.1" | "la-v1.0.2" | "la-v1.1.0">[]>>;
     salt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">>;
 }>, import("@sinclair/typebox").TObject<{
     accountType: import("@sinclair/typebox").TLiteral<"7702">;
@@ -193,6 +197,7 @@ export declare const TypePersonalSignSignatureRequest: import("@sinclair/typebox
     data: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
         raw: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
     }>]>;
+    rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 }>;
 export declare const TypeTypedDataSignatureRequest: import("@sinclair/typebox").TObject<{
     type: import("@sinclair/typebox").TLiteral<"eth_signTypedData_v4">;
@@ -229,15 +234,18 @@ export declare const TypeTypedDataSignatureRequest: import("@sinclair/typebox").
             [x: string]: unknown;
         };
     }>;
+    rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 }>;
 export declare const TypeAuthorizationSignatureRequest: import("@sinclair/typebox").TObject<{
     type: import("@sinclair/typebox").TLiteral<"eip7702Auth">;
+    rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 }>;
 export declare const TypeSignatureRequest: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
     type: import("@sinclair/typebox").TLiteral<"personal_sign">;
     data: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
         raw: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
     }>]>;
+    rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 }>, import("@sinclair/typebox").TObject<{
     type: import("@sinclair/typebox").TLiteral<"eth_signTypedData_v4">;
     data: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TObject<{
@@ -273,8 +281,10 @@ export declare const TypeSignatureRequest: import("@sinclair/typebox").TUnion<[i
             [x: string]: unknown;
         };
     }>;
+    rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 }>, import("@sinclair/typebox").TObject<{
     type: import("@sinclair/typebox").TLiteral<"eip7702Auth">;
+    rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 }>]>;
 export declare const TypeCallId: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, {
     chainId: `0x${string}`;
@@ -300,6 +310,7 @@ export declare const PreparedCall_UserOpV060: import("@sinclair/typebox").TObjec
         data: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
             raw: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
         }>]>;
+        rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
     }>, import("@sinclair/typebox").TObject<{
         type: import("@sinclair/typebox").TLiteral<"eth_signTypedData_v4">;
         data: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TObject<{
@@ -335,6 +346,7 @@ export declare const PreparedCall_UserOpV060: import("@sinclair/typebox").TObjec
                 [x: string]: unknown;
             };
         }>;
+        rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
     }>]>;
 }>;
 export declare const PreparedCall_UserOpV070: import("@sinclair/typebox").TObject<{
@@ -361,6 +373,7 @@ export declare const PreparedCall_UserOpV070: import("@sinclair/typebox").TObjec
         data: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
             raw: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
         }>]>;
+        rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
     }>, import("@sinclair/typebox").TObject<{
         type: import("@sinclair/typebox").TLiteral<"eth_signTypedData_v4">;
         data: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TObject<{
@@ -396,6 +409,7 @@ export declare const PreparedCall_UserOpV070: import("@sinclair/typebox").TObjec
                 [x: string]: unknown;
             };
         }>;
+        rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
     }>]>;
 }>;
 export declare const PreparedCall_Authorization: import("@sinclair/typebox").TObject<{
@@ -407,6 +421,7 @@ export declare const PreparedCall_Authorization: import("@sinclair/typebox").TOb
     chainId: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
     signatureRequest: import("@sinclair/typebox").TObject<{
         type: import("@sinclair/typebox").TLiteral<"eip7702Auth">;
+        rawPayload: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
     }>;
 }>;
 export declare const TypeEdcsaSigData: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TObject<{

package/dist/types/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,MAAM,EACZ,MAAM,mBAAmB,CAAC;AAqB3B,eAAO,MAAM,gBAAgB,oEAMnB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,eAAO,MAAM,YAAY,4EAAyC,CAAC;AAEnE,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,eAAO,MAAM,OAAO,GAAI,UAAU,aAAa,sEAG3C,CAAC;AAEL,eAAO,MAAM,WAAW,mEAA0C,CAAC;AAEnE,eAAO,MAAM,QAAQ,qCAEnB,CAAC;AAEH,eAAO,MAAM,0BAA0B,qCAErC,CAAC;AAGH,eAAO,MAAM,QAAQ,qFAEa,CAAC;AAEnC,eAAO,MAAM,OAAO,qFAEc,CAAC;AAEnC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EA0BtC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAgBtC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;EAIlC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;IAOhC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;EAGhC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;EA4BjC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE3E,eAAO,MAAM,mBAAmB;;;;;KA4B/B,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAErE,MAAM,MAAM,eAAe,GAAG,OAAO,CACnC,MAAM,CAAC,OAAO,mBAAmB,CAAC,EAClC,SAAS,CACV,CAAC,aAAa,CAAC,CAAC;AAEjB,eAAO,MAAM,iBAAiB,0LAI5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,eAAO,MAAM,SAAS;;;EAGpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,SAAS,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4C7B,CAAC;AAEL,eAAO,MAAM,gCAAgC;;;;;;EAe5C,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASzC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;EAG5C,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI/B,CAAC;AAEH,eAAO,MAAM,UAAU;;;EAUnB,CAAC;AAEL,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBnC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBnC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;EAYtC,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;oBA4C3B,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;EAqBvB,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK7C,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK7C,CAAC;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKhD,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAczB,CAAC"}

package/dist/types/types.d.ts

@@ -36,4 +36,7 @@ export type InnerWalletApiClient = InnerWalletApiClientBase<InnerClientActions &
 export type WithoutChainId<T> = T extends {
     chainId: Hex;
 } ? Omit<T, "chainId"> : T;
+export type WithoutRawPayload<T> = T extends {
+    rawPayload: Hex;
+} ? Omit<T, "rawPayload"> : T;
 //# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EACV,OAAO,EACP,KAAK,EACL,MAAM,EACN,GAAG,EACH,cAAc,EACd,SAAS,EACV,MAAM,MAAM,CAAC;AACd,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAEjE,MAAM,MAAM,uBAAuB,CACjC,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,IACxD;IACF,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAClC,OAAO,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAAG,SAAS,GAClD;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAC1B,SAAS,IACX,MAAM,CACR,SAAS,EACT,KAAK,EACL,cAAc,CAAC,OAAO,CAAC,GAAG,SAAS,EACnC,yBAAyB,EACzB;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAChC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gBAAgB,EAAE,CAChB,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,sBAAsB,GAAG;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,KAC9C,OAAO,CAAC,sBAAsB,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,oBAAoB,CAAC;IAC9B,aAAa,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAC;IAC7C,UAAU,EAAE,MAAM,aAAa,GAAG,SAAS,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,wBAAwB,CACzD,kBAAkB,GAAG;IAAE,QAAQ,EAAE,aAAa,CAAA;CAAE,CACjD,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,OAAO,EAAE,GAAG,CAAA;CAAE,GACtD,IAAI,CAAC,CAAC,EAAE,SAAS,CAAC,GAClB,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EACV,OAAO,EACP,KAAK,EACL,MAAM,EACN,GAAG,EACH,cAAc,EACd,SAAS,EACV,MAAM,MAAM,CAAC;AACd,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAEjE,MAAM,MAAM,uBAAuB,CACjC,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,IACxD;IACF,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAClC,OAAO,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAAG,SAAS,GAClD;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAC1B,SAAS,IACX,MAAM,CACR,SAAS,EACT,KAAK,EACL,cAAc,CAAC,OAAO,CAAC,GAAG,SAAS,EACnC,yBAAyB,EACzB;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAChC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gBAAgB,EAAE,CAChB,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,sBAAsB,GAAG;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,KAC9C,OAAO,CAAC,sBAAsB,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,oBAAoB,CAAC;IAC9B,aAAa,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAC;IAC7C,UAAU,EAAE,MAAM,aAAa,GAAG,SAAS,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,wBAAwB,CACzD,kBAAkB,GAAG;IAAE,QAAQ,EAAE,aAAa,CAAA;CAAE,CACjD,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,OAAO,EAAE,GAAG,CAAA;CAAE,GACtD,IAAI,CAAC,CAAC,EAAE,SAAS,CAAC,GAClB,CAAC,CAAC;AAEN,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,UAAU,EAAE,GAAG,CAAA;CAAE,GAC5D,IAAI,CAAC,CAAC,EAAE,YAAY,CAAC,GACrB,CAAC,CAAC"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@account-kit/wallet-client",
   "private": false,
   "type": "module",
-  "version": "0.1.0-alpha.7",
+  "version": "0.1.0-alpha.8",
   "main": "./dist/esm/exports/index.js",
   "module": "./dist/esm/exports/index.js",
   "types": "./dist/types/exports/index.d.ts",
@@ -70,5 +70,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "gitHead": "2bb34aba96eb2234c7dc3986a44ee0ec07c84c84"
+  "gitHead": "529d34cd22178db91f8d67e6601b3e03b8759d19"
 }

package/src/client/actions/prepareCalls.ts

@@ -32,7 +32,7 @@ export type PrepareCallsResult = IsomorphicPrepareCallsResult;
  * the user operation data and signature request
  *
  * @example
- * // Prepare a sponosored user operation call
+ * // Prepare a sponsored user operation call
  * const result = await client.prepareCalls({
  *   calls: [{
  *     to: "0x1234...",

package/src/client/actions/signSignatureRequest.ts

@@ -9,13 +9,15 @@ import {
 } from "../../schemas.js";
 import { TypeEip7702UnsignedAuth } from "../../schemas.js";
 import { vToYParity } from "ox/Signature";
+import type { WithoutRawPayload } from "../../types.ts";
 
-export type SignSignatureRequestParams =
+export type SignSignatureRequestParams = WithoutRawPayload<
   | Static<typeof TypePersonalSignSignatureRequest>
   | Static<typeof TypeTypedDataSignatureRequest>
   | (Static<typeof TypeAuthorizationSignatureRequest> & {
       data: Static<typeof TypeEip7702UnsignedAuth>;
-    });
+    })
+>;
 
 export type SignSignatureRequestResult = {
   type: "secp256k1";

package/src/isomorphic/actions/createSession.ts

@@ -12,19 +12,21 @@ import { Value } from "@sinclair/typebox/value";
 import {
   ChainNotFoundError,
   custom,
+  hashTypedData,
   hexToNumber,
   toHex,
   type Chain,
   type Hex,
   type Transport,
 } from "viem";
+import { InvalidRequestError } from "ox/RpcResponse";
 import { TypePermission } from "../../capabilities/permissions/index.js";
 import { isGlobalValidation } from "../../capabilities/permissions/mav2.js";
 import type { wallet_createSession } from "../../rpc/request.js";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { createAccount, isModularAccountV2 } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
-import { InvalidRequestError } from "ox/RpcResponse";
+import { supportsFeature } from "../utils/supportsFeature.js";
 
 export type CreateSessionParams = Omit<
   Static<
@@ -81,6 +83,16 @@ export async function createSession(
     });
   }
 
+  if (
+    counterfactualInfo &&
+    !supportsFeature(counterfactualInfo, "permissions")
+  ) {
+    throw new InvalidRequestError({
+      message: "Account type does not support createSession",
+    });
+  }
+
+  // At this point we know the account supports the permission feature
   const account = await createAccount({
     chain: client.chain,
     transport: custom(client.transport),
@@ -132,6 +144,7 @@ export async function createSession(
     signatureRequest: {
       type: "eth_signTypedData_v4" as const,
       data: typedData,
+      rawPayload: hashTypedData(typedData),
     },
     fullPreSignatureDeferredActionDigest,
   };

package/src/isomorphic/actions/prepareCalls.ts

@@ -9,6 +9,7 @@ import {
   ChainNotFoundError,
   custom,
   fromHex,
+  hashMessage,
   toHex,
   type Chain,
   type Transport,
@@ -17,7 +18,7 @@ import type { wallet_prepareCalls } from "../../rpc/request.js";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { createAccount } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
-import { createAuthorizationRequest, parseDelegation } from "../utils/7702.js";
+import { createAuthorizationRequest } from "../utils/7702.js";
 import { InvalidRequestError } from "ox/RpcResponse";
 import { assertNever } from "../../utils.js";
 import { assertValid7702AccountAddress } from "../utils/7702.js";
@@ -50,20 +51,23 @@ export async function prepareCalls(
   assertValid7702AccountAddress(params.from, params.capabilities?.eip7702Auth);
 
   // in local mode, we probably want some kind of caching for this
-  const { counterfactualInfo, delegation } = params.capabilities?.eip7702Auth
-    ? {
-        counterfactualInfo: undefined,
-        delegation: parseDelegation(params.capabilities.eip7702Auth),
-      }
-    : await client.request({
-        method: "wallet_requestAccount",
-        params: [
-          {
+  const { counterfactualInfo, delegation } = await client.request({
+    method: "wallet_requestAccount",
+    params: [
+      params.capabilities?.eip7702Auth
+        ? {
+            signerAddress: params.from,
+            creationHint: {
+              accountType: "7702",
+            },
+            includeCounterfactualInfo: true,
+          }
+        : {
             accountAddress: params.from,
             includeCounterfactualInfo: true,
           },
-        ],
-      });
+    ],
+  });
 
   if (!counterfactualInfo && !delegation) {
     throw new InvalidRequestError({
@@ -117,6 +121,8 @@ export async function prepareCalls(
 
   const ep = account.getEntryPoint();
 
+  const uoHash = ep.getUserOperationHash(hexlifiedUo);
+
   const uoRequest = {
     type:
       ep.version === "0.7.0"
@@ -129,8 +135,11 @@ export async function prepareCalls(
     signatureRequest: {
       type: "personal_sign" as const,
       data: {
-        raw: ep.getUserOperationHash(hexlifiedUo),
+        raw: uoHash,
       },
+      rawPayload: hashMessage({
+        raw: uoHash,
+      }),
     },
   };
 

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -120,19 +120,69 @@ export async function sendPreparedCalls(
         ? parseSignature(decodeSignature(authorization.signature).data)
         : undefined;
       const uoSigHex = decodeSignature(userOp.signature).data;
+
+      const { counterfactualInfo, delegation } = await client.request({
+        method: "wallet_requestAccount",
+        params: [
+          {
+            accountAddress: userOp.data.sender,
+            includeCounterfactualInfo: true,
+          },
+        ],
+      });
+
+      if (!counterfactualInfo && !delegation) {
+        throw new InvalidRequestError({
+          message:
+            "No counterfactual info or delegated implementation address found.",
+        });
+      }
+
+      const factoryType = counterfactualInfo?.factoryType;
+
+      // build signature based on account type
+      const signature = (() => {
+        switch (factoryType) {
+          // light accounts
+          case "LightAccountV1.0.1":
+          case "LightAccountV1.0.2":
+          case "LightAccountV1.1.0":
+            // For LAv1, we always just pass the signature.
+            return uoSigHex;
+          case "LightAccountV2.0.0":
+            // for LAv2, we need to prepend the "SignatureType.EOA" byte
+            return concat(["0x00", uoSigHex]);
+          case undefined: // undefined defaults to sma-b
+          case "MAv2.0.0-sma-b":
+            // For sma-b, we need to handle deferred actions if needed and prepend the "Reserved
+            // Signature Segment" and "SignatureType.EOA" bytes
+            return deferredAction != null
+              ? concatHex([
+                  `0x${deferredAction.slice(68)}`, // Cuts off stuff prepended to the digest (nonce, etc.).
+                  "0xFF",
+                  "0x00",
+                  uoSigHex,
+                ])
+              : concat(["0xFF", "0x00", uoSigHex]);
+          case "MAv2.0.0-ma-ssv":
+          case "MAv2.0.0-ma-webauthn":
+          case "LightAccountV2.0.0-MultiOwner":
+          case "MAv1.0.0-MultiOwner":
+          case "MAv1.0.0-MultiSig":
+          case "unknown":
+            throw new InvalidRequestError({
+              message: `Unsupported factory type: ${factoryType}`,
+            });
+          default:
+            return assertNever(factoryType, "Unsupported factory type");
+        }
+      })();
+
       return client
         .sendRawUserOperation(
           {
             ...userOp.data,
-            signature:
-              deferredAction != null
-                ? concatHex([
-                    `0x${deferredAction.slice(68)}`, // Cuts off stuff prepended to the digest (nonce, etc. that we had previously).
-                    "0xff",
-                    "0x00",
-                    uoSigHex,
-                  ])
-                : concat(["0xFF", "0x00", uoSigHex]),
+            signature,
             eip7702Auth:
               idx === 0 && authorization && authSig
                 ? {

package/src/isomorphic/utils/7702.ts

@@ -6,12 +6,14 @@ import {
   type Chain,
   type Transport,
   isAddress,
+  hexToNumber,
 } from "viem";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { PreparedCall_Authorization } from "../../schemas.js";
 import type { Eip7702AuthCapability } from "../../capabilities/eip7702Auth.ts";
 import type { Static } from "@sinclair/typebox";
 import { InvalidRequestError } from "ox/RpcResponse";
+import { hashAuthorization } from "viem/utils";
 
 export const createAuthorizationRequest = async (
   client: SmartAccountClient<
@@ -42,6 +44,11 @@ export const createAuthorizationRequest = async (
     chainId: numberToHex(client.chain.id),
     signatureRequest: {
       type: "eip7702Auth" as const,
+      rawPayload: hashAuthorization({
+        chainId: client.chain.id,
+        nonce: hexToNumber(data.nonce),
+        address: params.delegation,
+      }),
     },
   };
 };
@@ -103,14 +110,23 @@ export const assertValid7702AccountAddress = (
   fromAddress: Address,
   eip7702AuthCapability: Static<typeof Eip7702AuthCapability> | undefined,
 ) => {
-  if (
-    eip7702AuthCapability &&
-    typeof eip7702AuthCapability === "object" &&
-    "account" in eip7702AuthCapability &&
-    eip7702AuthCapability?.account !== fromAddress
-  ) {
-    throw new InvalidRequestError({
-      message: `EIP-7702 delegation account ${eip7702AuthCapability.account} must match 'from' address ${fromAddress}.`,
-    });
+  if (eip7702AuthCapability) {
+    if (
+      typeof eip7702AuthCapability === "object" &&
+      "account" in eip7702AuthCapability &&
+      eip7702AuthCapability?.account !== fromAddress
+    ) {
+      throw new InvalidRequestError({
+        message: `EIP-7702 delegation account ${eip7702AuthCapability.account} must match 'from' address ${fromAddress}.`,
+      });
+    }
+
+    const delegation = parseDelegation(eip7702AuthCapability);
+
+    if (!isSupportedDelegationAddress7702(delegation)) {
+      throw new InvalidRequestError({
+        message: `Unsupported 7702 delegation address: ${delegation}`,
+      });
+    }
   }
 };

package/src/isomorphic/utils/createAccount.ts

@@ -1,5 +1,6 @@
 import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
 import {
+  createLightAccount,
   createModularAccountV2,
   type ModularAccountV2,
 } from "@account-kit/smart-contracts";
@@ -10,8 +11,8 @@ import type { TypeSerializedInitcode } from "../../schemas.js";
 import { parsePermissionsContext } from "./parsePermissionsContext.js";
 import { assertNever } from "../../utils.js";
 import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
-import { InternalError } from "ox/RpcResponse";
 import { PermissionsCapability } from "../../capabilities/permissions/index.js";
+import { InternalError, InvalidRequestError } from "ox/RpcResponse";
 
 type CreateAccountParams = {
   chain: Chain;
@@ -33,32 +34,8 @@ export async function createAccount(
 ): Promise<SmartContractAccount> {
   const { counterfactualInfo: ci, ...accountParams } = params;
 
-  const mode = params.delegation ? "7702" : "default";
-
-  if (mode === "default") {
-    if (!ci) {
-      throw new InternalError({
-        message: "Counterfactual info not found",
-      });
-    }
-    if (ci.factoryType !== "MAv2.0.0-sma-b") {
-      throw new InternalError({
-        message: `Factory type ${ci.factoryType} is not currently supported.`,
-      });
-    }
-  } else if (mode === "7702") {
-    const accountType = getAccountTypeForDelegationAddress7702(
-      params.delegation!,
-    );
-    if (accountType !== "ModularAccountV2") {
-      throw new InternalError({
-        message: "7702 mode currently only supports ModularAccountV2",
-      });
-    }
-  } else {
-    assertNever(mode, "Unexpected mode in createAccount");
-  }
-
+  // This throws if we pass a permission context and the account is not MA-v2
+  // TODO: test that this edge case is handled correctly
   const parsedContext = parsePermissionsContext(
     params.permissions,
     ci,
@@ -73,14 +50,84 @@ export async function createAccount(
         }
       : undefined;
 
-  // TODO: clean this up to support different account types.
-  return createModularAccountV2({
+  const mode = params.delegation ? "7702" : "default";
+
+  if (mode === "7702") {
+    const accountType = getAccountTypeForDelegationAddress7702(
+      params.delegation!,
+    );
+    if (accountType !== "ModularAccountV2") {
+      throw new Error("7702 mode currently only supports ModularAccountV2");
+    }
+    return createModularAccountV2({
+      ...accountParams,
+      signerEntity,
+      deferredAction: parsedContext?.deferredAction,
+      mode,
+    });
+  }
+
+  if (mode !== "default") {
+    return assertNever(mode, "Unexpected mode in createAccount");
+  }
+
+  // At this point, we are guaranteed to be in default mode, where ci
+  // (counterfactualInfo) must be defined
+
+  if (!ci) {
+    throw new InternalError({
+      message: "Counterfactual info not found",
+    });
+  }
+
+  const factoryType = ci.factoryType;
+  const commonParams = {
     ...accountParams,
-    signerEntity,
-    deferredAction: parsedContext?.deferredAction,
-    initCode: ci ? concatHex([ci.factoryAddress, ci.factoryData]) : undefined,
-    mode,
-  });
+    initCode: concatHex([ci.factoryAddress, ci.factoryData]),
+  };
+
+  // Return the account created based on the factory type
+  switch (factoryType) {
+    case "MAv2.0.0-sma-b":
+      return createModularAccountV2({
+        ...commonParams,
+        signerEntity,
+        deferredAction: parsedContext?.deferredAction,
+        mode,
+      });
+    case "LightAccountV2.0.0":
+      return createLightAccount({
+        ...commonParams,
+        version: "v2.0.0",
+      });
+    case "LightAccountV1.0.1":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.0.1",
+      });
+    case "LightAccountV1.0.2":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.0.2",
+      });
+    case "LightAccountV1.1.0":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.1.0",
+      });
+    case "LightAccountV2.0.0-MultiOwner":
+    case "MAv1.0.0-MultiOwner":
+    case "MAv1.0.0-MultiSig":
+    case "MAv2.0.0-ma-ssv":
+    case "MAv2.0.0-ma-webauthn":
+    case "unknown":
+    case undefined:
+      throw new InvalidRequestError({
+        message: `Account type currently unsupported: ${factoryType}`,
+      });
+    default:
+      return assertNever(factoryType, "Unsupported factory type");
+  }
 }
 
 export function isModularAccountV2(

package/src/isomorphic/utils/supportsFeature.ts

@@ -0,0 +1,34 @@
+import type { StaticDecode } from "@sinclair/typebox";
+import type { TypeSerializedInitcode } from "../../schemas.ts";
+
+export type Feature = "permissions";
+
+type FactoryType = StaticDecode<typeof TypeSerializedInitcode>["factoryType"];
+
+const supportedFeatures: Record<FactoryType, Feature[]> = {
+  "LightAccountV1.0.1": [],
+  "LightAccountV1.0.2": [],
+  "LightAccountV1.1.0": [],
+  "LightAccountV2.0.0": [],
+  "LightAccountV2.0.0-MultiOwner": [],
+  "MAv1.0.0-MultiOwner": [],
+  "MAv1.0.0-MultiSig": [],
+  "MAv2.0.0-sma-b": ["permissions"],
+  "MAv2.0.0-ma-ssv": ["permissions"],
+  "MAv2.0.0-ma-webauthn": [],
+  unknown: [],
+};
+
+export function supportsFeature(
+  counterfactualInfo: StaticDecode<typeof TypeSerializedInitcode>,
+  feature: Feature,
+): boolean {
+  const factorySupportedFeatures =
+    supportedFeatures[counterfactualInfo.factoryType];
+  if (factorySupportedFeatures === undefined) {
+    throw new Error(
+      "Unsupported FactoryType: " + counterfactualInfo.factoryType,
+    );
+  }
+  return factorySupportedFeatures.includes(feature);
+}

package/src/schemas.ts

@@ -24,6 +24,20 @@ FormatRegistry.Set("uuid", (value) => UUID_V4_REGEX.test(value));
 const BASE_64_URL_REGEX = /^[A-Za-z0-9_-]+$/; // Matches base64url encoded strings (without padding)
 FormatRegistry.Set("base64url", (value) => BASE_64_URL_REGEX.test(value));
 
+export const baseAccountTypes = [
+  "sma-b",
+  "la-v2",
+  "la-v1.0.1",
+  "la-v1.0.2",
+  "la-v1.1.0",
+] as const;
+
+export type BaseAccountType = (typeof baseAccountTypes)[number];
+
+export const accountTypes = [...baseAccountTypes, "7702"] as const;
+
+export type AccountType = (typeof accountTypes)[number];
+
 export const TypeHex = (options?: SchemaOptions) =>
   Type.TemplateLiteral("0x${string}", {
     ...options,
@@ -271,7 +285,9 @@ export const TypeCreationOptions = Type.Optional(
     Type.Object(
       {
         // Optional b/c `sma-b` is the default if no accountType is specified.
-        accountType: Type.Optional(Type.Literal("sma-b")),
+        accountType: Type.Optional(
+          Type.Union(baseAccountTypes.map((lit) => Type.Literal(lit))),
+        ),
         salt: Type.Optional(TypeHex()),
       },
       {
@@ -371,6 +387,7 @@ export const TypePersonalSignSignatureRequest = Type.Object(
         { description: "Raw message" },
       ),
     ]),
+    rawPayload: TypeHex(),
   },
   { description: "Personal sign" },
 );
@@ -379,6 +396,7 @@ export const TypeTypedDataSignatureRequest = Type.Object(
   {
     type: Type.Literal("eth_signTypedData_v4"),
     data: TTypedDataDefinition,
+    rawPayload: TypeHex(),
   },
   {
     description: "Typed data",
@@ -387,6 +405,7 @@ export const TypeTypedDataSignatureRequest = Type.Object(
 
 export const TypeAuthorizationSignatureRequest = Type.Object({
   type: Type.Literal("eip7702Auth"),
+  rawPayload: TypeHex(),
 });
 
 export const TypeSignatureRequest = Type.Union([