@account-kit/wallet-client 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/types/rpc/schema.d.ts

@@ -4,6 +4,9 @@ export declare const WalletServerRpcSchema: {
             capabilities?: {
                 permissions?: {
                     context: `0x${string}`;
+                } | {
+                    signature: `0x${string}`;
+                    sessionId: `0x${string}`;
                 } | undefined;
                 paymasterService?: {
                     policyId: string;
@@ -43,7 +46,7 @@ export declare const WalletServerRpcSchema: {
         method: "wallet_prepareCalls";
     };
     ReturnType: {
-        type: "user-operation-v060" | "user-operation-v070";
+        type: "user-operation-v070" | "user-operation-v060";
         chainId: `0x${string}`;
         data: {
             sender: `0x${string}`;
@@ -72,7 +75,7 @@ export declare const WalletServerRpcSchema: {
             maxFeePerGas: `0x${string}`;
             maxPriorityFeePerGas: `0x${string}`;
         };
-        signatureRequest: {
+        signatureRequest: ({
             type: "personal_sign";
             data: string | {
                 raw: `0x${string}`;
@@ -81,8 +84,8 @@ export declare const WalletServerRpcSchema: {
             type: "eth_signTypedData_v4";
             data: {
                 domain?: {
-                    salt?: `0x${string}` | undefined;
                     chainId?: number | undefined;
+                    salt?: `0x${string}` | undefined;
                     name?: string | undefined;
                     verifyingContract?: `0x${string}` | undefined;
                     version?: string | undefined;
@@ -98,17 +101,34 @@ export declare const WalletServerRpcSchema: {
                     [x: string]: unknown;
                 };
             };
+        }) & {
+            authorizationRequest?: {
+                nonce: number;
+                chainId: number;
+                address: `0x${string}`;
+            } | undefined;
         };
     };
 } | {
     Request: {
         params: [{
+            signedAuthorization?: {
+                nonce: `0x${string}`;
+                chainId: `0x${string}`;
+                address: `0x${string}`;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                yParity: `0x${string}`;
+            } | undefined;
             capabilities?: {
-                permissions: {
+                permissions?: {
                     context: `0x${string}`;
-                };
+                } | {
+                    signature: `0x${string}`;
+                    sessionId: `0x${string}`;
+                } | undefined;
             } | undefined;
-            type: "user-operation-v060" | "user-operation-v070";
+            type: "user-operation-v070" | "user-operation-v060";
             signature: {
                 type: "ecdsa";
                 signature: `0x${string}`;
@@ -154,6 +174,8 @@ export declare const WalletServerRpcSchema: {
             creationOptions?: {
                 salt?: `0x${string}` | undefined;
                 accountType?: "sma-b" | undefined;
+            } | {
+                accountType: "7702";
             } | undefined;
             signerAddress: `0x${string}`;
         }];
@@ -170,6 +192,8 @@ export declare const WalletServerRpcSchema: {
             creationHint?: {
                 salt?: `0x${string}` | undefined;
                 accountType?: "sma-b" | undefined;
+            } | {
+                accountType: "7702";
             } | undefined;
             includeCounterfactualInfo?: boolean | undefined;
             signerAddress: `0x${string}`;
@@ -185,6 +209,7 @@ export declare const WalletServerRpcSchema: {
             factoryAddress: `0x${string}`;
             factoryType: "unknown" | "LightAccountV2.0.0" | "LightAccountV1.1.0" | "LightAccountV1.0.2" | "LightAccountV1.0.1" | "MAv1.0.0-MultiOwner" | "LightAccountV2.0.0-MultiOwner" | "MAv1.0.0-MultiSig" | "MAv2.0.0-sma-b" | "MAv2.0.0-ma-ssv" | "MAv2.0.0-ma-webauthn";
         } | undefined;
+        delegation?: `0x${string}` | undefined;
         accountAddress: `0x${string}`;
         id: string;
     };
@@ -224,8 +249,8 @@ export declare const WalletServerRpcSchema: {
             } | {
                 type: "erc20-token-transfer";
                 data: {
-                    allowance: `0x${string}`;
                     address: `0x${string}`;
+                    allowance: `0x${string}`;
                 };
             } | {
                 type: "gas-limit";
@@ -264,7 +289,7 @@ export declare const WalletServerRpcSchema: {
     };
     ReturnType: {
         sessionId: `0x${string}`;
-        signatureRequest: {
+        signatureRequest: ({
             type: "personal_sign";
             data: string | {
                 raw: `0x${string}`;
@@ -273,8 +298,8 @@ export declare const WalletServerRpcSchema: {
             type: "eth_signTypedData_v4";
             data: {
                 domain?: {
-                    salt?: `0x${string}` | undefined;
                     chainId?: number | undefined;
+                    salt?: `0x${string}` | undefined;
                     name?: string | undefined;
                     verifyingContract?: `0x${string}` | undefined;
                     version?: string | undefined;
@@ -290,6 +315,12 @@ export declare const WalletServerRpcSchema: {
                     [x: string]: unknown;
                 };
             };
+        }) & {
+            authorizationRequest?: {
+                nonce: number;
+                chainId: number;
+                address: `0x${string}`;
+            } | undefined;
         };
     };
 } | {
@@ -301,8 +332,8 @@ export declare const WalletServerRpcSchema: {
         receipts?: {
             status: `0x${string}`;
             logs: {
-                data: `0x${string}`;
                 address: `0x${string}`;
+                data: `0x${string}`;
                 topics: `0x${string}`[];
             }[];
             blockHash: `0x${string}`;
@@ -313,7 +344,7 @@ export declare const WalletServerRpcSchema: {
         chainId: `0x${string}`;
         id: `0x${string}`;
         atomic: boolean;
-        status: 100 | 200 | 400 | 500 | 600;
+        status: 200 | 100 | 400 | 500 | 600;
     };
 };
 export type WalletServerRpcSchemaType = typeof WalletServerRpcSchema;

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/rpc/schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ/B,CAAC;AAEJ,MAAM,MAAM,yBAAyB,GAAG,OAAO,qBAAqB,CAAC;AAErE,KAAK,qBAAqB,GAAG;KAC1B,CAAC,IAAI,yBAAyB,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG;QACrD,MAAM,EAAE,CAAC,CAAC;QACV,UAAU,EAAE,OAAO,CACjB,yBAAyB,CAAC,SAAS,CAAC,EACpC;YAAE,MAAM,EAAE,CAAC,CAAA;SAAE,CACd,CAAC,QAAQ,CAAC,CAAC;QACZ,UAAU,EAAE,OAAO,CACjB,yBAAyB,EACzB;YAAE,OAAO,EAAE;gBAAE,MAAM,EAAE,CAAC,CAAA;aAAE,CAAA;SAAE,CAC3B,CAAC,YAAY,CAAC,CAAC;KACjB;CACF,CAAC;AAGF,MAAM,MAAM,yBAAyB,GAAG;IACtC,qBAAqB,CAAC,sBAAsB,CAAC;IAC7C,qBAAqB,CAAC,uBAAuB,CAAC;IAC9C,qBAAqB,CAAC,qBAAqB,CAAC;IAC5C,qBAAqB,CAAC,qBAAqB,CAAC;IAC5C,qBAAqB,CAAC,0BAA0B,CAAC;IACjD,qBAAqB,CAAC,uBAAuB,CAAC;IAC9C,qBAAqB,CAAC,sBAAsB,CAAC;CAC9C,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/rpc/schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ/B,CAAC;AAEJ,MAAM,MAAM,yBAAyB,GAAG,OAAO,qBAAqB,CAAC;AAErE,KAAK,qBAAqB,GAAG;KAC1B,CAAC,IAAI,yBAAyB,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG;QACrD,MAAM,EAAE,CAAC,CAAC;QACV,UAAU,EAAE,OAAO,CACjB,yBAAyB,CAAC,SAAS,CAAC,EACpC;YAAE,MAAM,EAAE,CAAC,CAAA;SAAE,CACd,CAAC,QAAQ,CAAC,CAAC;QACZ,UAAU,EAAE,OAAO,CACjB,yBAAyB,EACzB;YAAE,OAAO,EAAE;gBAAE,MAAM,EAAE,CAAC,CAAA;aAAE,CAAA;SAAE,CAC3B,CAAC,YAAY,CAAC,CAAC;KACjB;CACF,CAAC;AAGF,MAAM,MAAM,yBAAyB,GAAG;IACtC,qBAAqB,CAAC,sBAAsB,CAAC;IAC7C,qBAAqB,CAAC,uBAAuB,CAAC;IAC9C,qBAAqB,CAAC,qBAAqB,CAAC;IAC5C,qBAAqB,CAAC,qBAAqB,CAAC;IAC5C,qBAAqB,CAAC,0BAA0B,CAAC;IACjD,qBAAqB,CAAC,uBAAuB,CAAC;IAC9C,qBAAqB,CAAC,sBAAsB,CAAC;CAC9C,CAAC"}

package/dist/types/schemas.d.ts

@@ -35,6 +35,19 @@ export declare const TypeUserOperationRequest_v7: import("@sinclair/typebox").TO
     paymasterPostOpGasLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">>;
     signature: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 }>;
+export declare const TypeEip7702AuthRequest: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TInteger;
+    address: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
+    nonce: import("@sinclair/typebox").TInteger;
+}>;
+export declare const TypeEip7702AuthExtendedFields: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
+    nonce: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
+    address: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
+    r: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
+    s: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
+    yParity: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
+}>;
 export declare const TypeWebAuthnPublicKey: import("@sinclair/typebox").TObject<{
     x: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, bigint>;
     y: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, bigint>;
@@ -123,12 +136,15 @@ export declare const TypeCounterfactualInfo: import("@sinclair/typebox").TInters
     }>]>]>]>;
 }>]>, import("@sinclair/typebox").TObject<{
     type: import("@sinclair/typebox").TLiteral<"7702">;
+    implementationAddress: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
 }>]>]>;
 export type TypeCounterfactualInfo = Static<typeof TypeCounterfactualInfo>;
-export declare const TypeCreationOptions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+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">>;
     salt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">>;
-}>>;
+}>, import("@sinclair/typebox").TObject<{
+    accountType: import("@sinclair/typebox").TLiteral<"7702">;
+}>]>>;
 export type TypeCreationOptions = Static<typeof TypeCreationOptions>;
 export type TypeAccountType = Exclude<Static<typeof TypeCreationOptions>, undefined>["accountType"];
 export declare const KeySigner: import("@sinclair/typebox").TObject<{
@@ -138,7 +154,7 @@ export declare const KeySigner: import("@sinclair/typebox").TObject<{
 export type KeySigner = Static<typeof KeySigner>;
 export declare const TTypedDataDefinition: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TObject<{
     domain: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
         name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         salt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">>;
         verifyingContract: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">>;
@@ -152,8 +168,8 @@ export declare const TTypedDataDefinition: import("@sinclair/typebox").TTransfor
     message: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>;
 }>, {
     domain?: {
-        salt?: `0x${string}` | undefined;
         chainId?: number | undefined;
+        salt?: `0x${string}` | undefined;
         name?: string | undefined;
         verifyingContract?: `0x${string}` | undefined;
         version?: string | undefined;
@@ -169,7 +185,7 @@ export declare const TTypedDataDefinition: import("@sinclair/typebox").TTransfor
         [x: string]: unknown;
     };
 }>;
-export declare const TypeSignatureRequest: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+export declare const TypeSignatureRequest: import("@sinclair/typebox").TIntersect<[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}">;
@@ -178,7 +194,7 @@ export declare const TypeSignatureRequest: import("@sinclair/typebox").TUnion<[i
     type: import("@sinclair/typebox").TLiteral<"eth_signTypedData_v4">;
     data: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TObject<{
         domain: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
             name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
             salt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">>;
             verifyingContract: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">>;
@@ -192,8 +208,8 @@ export declare const TypeSignatureRequest: import("@sinclair/typebox").TUnion<[i
         message: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>;
     }>, {
         domain?: {
-            salt?: `0x${string}` | undefined;
             chainId?: number | undefined;
+            salt?: `0x${string}` | undefined;
             name?: string | undefined;
             verifyingContract?: `0x${string}` | undefined;
             version?: string | undefined;
@@ -209,6 +225,12 @@ export declare const TypeSignatureRequest: import("@sinclair/typebox").TUnion<[i
             [x: string]: unknown;
         };
     }>;
+}>]>, import("@sinclair/typebox").TObject<{
+    authorizationRequest: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        chainId: import("@sinclair/typebox").TInteger;
+        address: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
+        nonce: import("@sinclair/typebox").TInteger;
+    }>>;
 }>]>;
 export declare const TypeCallId: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, {
     chainId: `0x${string}`;

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

@@ -1 +1 @@
-{"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;AAU3B,eAAO,MAAM,OAAO,GAAI,UAAU,aAAa,sEACD,CAAC;AAC/C,eAAO,MAAM,WAAW,mEAAsC,CAAC;AAC/D,eAAO,MAAM,QAAQ,qCAAkC,CAAC;AACxD,eAAO,MAAM,0BAA0B,qCAErC,CAAC;AAGH,eAAO,MAAM,QAAQ,qFAEa,CAAC;AAEnC,eAAO,MAAM,OAAO,qFAEc,CAAC;AAEnC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAYtC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAgBtC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;EAGhC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsDhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;EAgBjC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAejC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE3E,eAAO,MAAM,mBAAmB;;;GAS/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,SAAS;;;EAGpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,SAAS,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4C7B,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAc/B,CAAC;AAEH,eAAO,MAAM,UAAU;;;EAUnB,CAAC"}
+{"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;AAU3B,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,sBAAsB;;;;EAIjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;EAOxC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;EAGhC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyFhC,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;;;;;KA0B/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,SAAS;;;EAMpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,SAAS,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4C7B,CAAC;AA4BL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK/B,CAAC;AAEH,eAAO,MAAM,UAAU;;;EAUnB,CAAC"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@account-kit/wallet-client",
   "private": false,
   "type": "module",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.3",
   "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": "435c18e58616f1f0706d6e4df6f23c7676062191"
+  "gitHead": "017c20b3777d96b1b4ab6f01385725aa2689416a"
 }

package/src/capabilities/index.ts

@@ -3,11 +3,8 @@ import { GasParamsOverrideCapability } from "./overrides.js";
 import { PaymasterCapability } from "./paymaster.js";
 import { PermissionsCapability } from "./permissions/index.js";
 
-export const Capabilities = Type.Object(
-  {
-    permissions: Type.Optional(PermissionsCapability),
-    paymasterService: Type.Optional(PaymasterCapability),
-    gasParamsOverride: Type.Optional(GasParamsOverrideCapability),
-  },
-  { minProperties: 1 },
-);
+export const Capabilities = Type.Object({
+  permissions: Type.Optional(PermissionsCapability),
+  paymasterService: Type.Optional(PaymasterCapability),
+  gasParamsOverride: Type.Optional(GasParamsOverrideCapability),
+});

package/src/capabilities/overrides.ts

@@ -1,20 +1,35 @@
 import { Type } from "@sinclair/typebox";
 import { TypeHex } from "../schemas.js";
 
-export const Mutliplier = Type.Object({ multiplier: Type.Number() });
+export const Mutliplier = Type.Object(
+  { multiplier: Type.Number() },
+  { title: "Multiplier" },
+);
 
 // This is still being defined in https://github.com/ethereum/ERCs/pull/947/files#diff-dab085f963ca621595044bcbc0922705aa38b69f5bf8770dcb3d0496a633efcfR158
 export const GasParamsOverrideCapability = Type.Object(
   {
-    preVerificationGas: Type.Optional(Type.Union([TypeHex(), Mutliplier])),
-    verificationGasLimit: Type.Optional(Type.Union([TypeHex(), Mutliplier])),
-    callGasLimit: Type.Optional(Type.Union([TypeHex(), Mutliplier])),
+    preVerificationGas: Type.Optional(
+      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+    ),
+    verificationGasLimit: Type.Optional(
+      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+    ),
+    callGasLimit: Type.Optional(
+      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+    ),
     paymasterVerificationGasLimit: Type.Optional(
-      Type.Union([TypeHex(), Mutliplier]),
+      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+    ),
+    paymasterPostOpGasLimit: Type.Optional(
+      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+    ),
+    maxFeePerGas: Type.Optional(
+      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+    ),
+    maxPriorityFeePerGas: Type.Optional(
+      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
     ),
-    paymasterPostOpGasLimit: Type.Optional(Type.Union([TypeHex(), Mutliplier])),
-    maxFeePerGas: Type.Optional(Type.Union([TypeHex(), Mutliplier])),
-    maxPriorityFeePerGas: Type.Optional(Type.Union([TypeHex(), Mutliplier])),
   },
   { minProperties: 1 },
 );

package/src/capabilities/permissions/index.ts

@@ -24,7 +24,7 @@ const Permission = <
         type: Type.Literal(typeEnum),
         data,
       },
-      { description },
+      { description, title: `${typeString}` },
     ),
   )
     .Decode((value) => ({
@@ -124,19 +124,35 @@ export const TypePermission = Type.Union([
 
 export const PermissionsArray = Type.Array(TypePermission, { minItems: 1 });
 
-export const PermissionsContext = Type.Object({
-  context: TypeHex(),
-});
+export const PermissionsContext = Type.Object(
+  {
+    context: TypeHex(),
+  },
+  {
+    title: "Permissions context",
+  },
+);
+
+export const RemotePermission = Type.Object(
+  {
+    sessionId: TypeHex(),
+    signature: TypeHex(),
+  },
+  {
+    title: "Remote permission",
+  },
+);
 
 export const PermissionsData = Type.Object({
   chainId: TypeHex(),
-  expiry: Type.Optional(Type.Number()),
+  expiry: Type.Optional(Type.Integer()),
   key: KeySigner,
   permissions: PermissionsArray,
 });
 
 export const PermissionsCapability = Type.Union([
   PermissionsContext,
+  RemotePermission,
   // TODO: support permissions object here instead of only context-encoded permissions
   // PermissionsData,
 ]);

package/src/capabilities/permissions/mav2.ts

@@ -1,9 +1,9 @@
 import { PermissionType } from "@account-kit/smart-contracts/experimental";
 import type { Static } from "@sinclair/typebox";
 import { concatHex, sliceHex, type Hex } from "viem";
-import type { PermissionsData } from "./index.ts";
 import type { KeySigner } from "../../schemas.ts";
 import { assertNever } from "../../utils.js";
+import type { PermissionsCapability, PermissionsData } from "./index.ts";
 
 export const SESSION_ID_LENGTH_BYTES = 16;
 export const ENTITY_ID_LENGTH_BYTES = 4;
@@ -69,8 +69,18 @@ export const encodePermissionsContext = (
 };
 
 export const decodePermissionsContext = (
-  input: Hex,
+  capability: Static<typeof PermissionsCapability>,
 ): DecodedPermissionsContext => {
+  if (!("context" in capability)) {
+    return {
+      contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
+      sessionId: capability.sessionId,
+      signature: capability.signature,
+    };
+  }
+
+  const input = capability.context;
+
   const contextVersion = sliceHex(input, 0, 1) as ContextVersionHex;
   switch (contextVersion) {
     case "0x00": {

package/src/client/actions/grantPermissions.ts

@@ -8,6 +8,8 @@ import {
 import type { InnerWalletApiClient } from "../../types.ts";
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { CreateSessionParams } from "../../isomorphic/actions/createSession.ts";
+import { TypeEip7702AuthExtendedFields } from "../../schemas.js";
+import type { Static } from "@sinclair/typebox";
 
 export type GrantPermissionsParams<
   TAccount extends JsonRpcAccount<Address> | undefined =
@@ -20,6 +22,7 @@ export type GrantPermissionsParams<
 
 export type GrantPermissionsResult = {
   context: Hex;
+  signedAuthorization?: Static<typeof TypeEip7702AuthExtendedFields>;
 };
 
 /**
@@ -37,6 +40,7 @@ export type GrantPermissionsResult = {
  * @param {Array} params.permissions - Array of permission objects defining what the session key can do
  * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier
  * @returns {Hex} result.context - A hex identifier for the granted permissions context
+ * @returns {Static<typeof TypeEip7702AuthExtendedFields>} result.signedAuthorization - The EIP-7702 authorization fields, if applicable
  *
  * @example
  * // Create a session key and grant root permissions
@@ -54,7 +58,7 @@ export type GrantPermissionsResult = {
  * });
  *
  * // Use the permissions to prepare a call
- * const preparedUO = await client.prepareCalls({
+ * const preparedCall = await client.prepareCalls({
  *   calls: [{ to: zeroAddress, value: "0x0" }],
  *   from: account.address,
  *   capabilities: {
@@ -68,17 +72,67 @@ export type GrantPermissionsResult = {
  * // Sign with the session key
  * const signature = await signSignatureRequest(
  *   sessionKey,
- *   preparedUO.signatureRequest,
+ *   preparedCall.signatureRequest,
  * );
  *
  * // Send the prepared call using the session key
  * const result = await client.sendPreparedCalls({
- *   ...preparedUO,
+ *   ...preparedCall,
  *   signature,
  *   capabilities: {
  *     permissions,
  *   },
  * });
+ *
+ * @example
+ * // Create a session key and grant root permissions using a 7702 account
+ * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+ * const account = await client.requestAccount({
+ *   creationHint: {
+ *     accountType: "7702",
+ *   }
+ * });
+ *
+ * const permissions = await client.grantPermissions({
+ *   account: account.address,
+ *   expiry: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   key: {
+ *     publicKey: await sessionKey.getAddress(),
+ *     type: "secp256k1",
+ *   },
+ *   permissions: [{ type: "root" }],
+ * });
+ *
+ * // Use the permissions to prepare a call
+ * const preparedCall = await client.prepareCalls({
+ *   calls: [{ to: zeroAddress, value: "0x0" }],
+ *   from: account.address,
+ *   capabilities: {
+ *     paymasterService: {
+ *       policyId: "your-paymaster-policy-id",
+ *     },
+ *     permissions,
+ *   },
+ * });
+ *
+ * // Sign with the session key
+ * // If the 7702 account delegation is not yet installed, the result
+ * // here will include a `signedAuthorization` field that that
+ * // must be included when sending the account's first call.
+ * const { signedAuthorization, ...signature} = await signSignatureRequest(
+ *   sessionKey,
+ *   preparedCall.signatureRequest,
+ * );
+ *
+ * // Send the prepared call using the session key
+ * const result = await client.sendPreparedCalls({
+ *   ...preparedCall,
+ *   signature,
+ *   signedAuthorization,
+ *   capabilities: {
+ *     permissions,
+ *   },
+ * });
  */
 export async function grantPermissions<
   TAccount extends JsonRpcAccount<Address> | undefined =

package/src/client/actions/requestAccount.ts

@@ -5,12 +5,12 @@ import {
 import type { Static } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import type { Address } from "abitype";
-import deepEqual from "deep-equal";
 import { custom, type IsUndefined, type JsonRpcAccount } from "viem";
 import { createAccount } from "../../isomorphic/utils/createAccount.js";
 import type { wallet_requestAccount } from "../../rpc/request.js";
 import { TypeSerializedInitcode } from "../../schemas.js";
 import type { InnerWalletApiClient } from "../../types.js";
+import deepEqual from "deep-equal";
 
 export type RequestAccountParams<
   TAccount extends JsonRpcAccount<Address> | undefined =
@@ -27,7 +27,6 @@ export type RequestAccountParams<
       > & { accountAddress?: Address }
     : never;
 
-// TODO: this could be more specific potentially :shrug:
 export type RequestAccountResult = SmartContractAccount;
 
 /**
@@ -90,7 +89,7 @@ export async function requestAccount(
   });
 
   const account = await createAccount({
-    accountAddress: accountAddress,
+    accountAddress,
     counterfactualInfo: Value.Parse(
       TypeSerializedInitcode,
       counterfactualInfo!,

package/src/client/actions/signSignatureRequest.ts

@@ -1,14 +1,16 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { Static } from "@sinclair/typebox";
-import { type Hex } from "viem";
+import { type Hex, toHex } from "viem";
 import { TypeSignatureRequest } from "../../schemas.js";
 import { assertNever } from "../../utils.js";
+import type { Eip7702ExtendedFields } from "@aa-sdk/core";
 
 export type SignSignatureRequestParams = Static<typeof TypeSignatureRequest>;
 
 export type SignSignatureRequestResult = {
   type: "ecdsa";
   signature: Hex;
+  signedAuthorization?: Eip7702ExtendedFields["eip7702Auth"];
 };
 
 /**
@@ -17,11 +19,12 @@ export type SignSignatureRequestResult = {
  *
  * @param {SmartAccountSigner} signer - The signer to use for signing the request
  * @param {SignSignatureRequestParams} params - The signature request parameters
- * @param {string} params.type - The type of signature request ('personal_sign' or 'eth_signTypedData_v4')
+ * @param {string} params.type - The type of signature request ('personal_sign', 'eth_signTypedData_v4', or 'signature_with_authorization')
  * @param {any} params.data - The data to sign, format depends on the signature type
  * @returns {Promise<SignSignatureRequestResult>} A Promise that resolves to the signature result
  * @returns {string} result.type - The signature type (currently only 'ecdsa' is supported)
  * @returns {Hex} result.signature - The hex-encoded signature
+ * @returns {Eip7702ExtendedFields["eip7702Auth"]} result.signedAuthorization - The signed EIP-7702 authorization, if applicable
  *
  * @example
  * // Sign a personal message
@@ -58,8 +61,33 @@ export async function signSignatureRequest(
         ? await signer.signTypedData(params.data)
         : assertNever(params, "Unexpected signature request type");
 
+  if (!params.authorizationRequest) {
+    return {
+      type: "ecdsa" as const,
+      signature,
+    };
+  }
+
+  if (!signer.signAuthorization) {
+    throw new Error("Signer does not implement signAuthorization");
+  }
+
+  const authSig = await signer.signAuthorization(params.authorizationRequest);
+  const { r, s } = authSig;
+  const yParity = toHex(authSig.yParity ?? authSig.v - 27n);
+
+  const signedAuthorization = {
+    chainId: toHex(params.authorizationRequest.chainId),
+    nonce: toHex(params.authorizationRequest.nonce),
+    address: params.authorizationRequest.address,
+    r,
+    s,
+    yParity,
+  };
+
   return {
-    type: "ecdsa",
+    type: "ecdsa" as const,
     signature,
+    signedAuthorization,
   };
 }