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

package/src/isomorphic/utils/7702.ts

@@ -1,18 +1,19 @@
 import type { SmartAccountClient, SmartContractAccount } from "@aa-sdk/core";
 import {
   concatHex,
-  type Authorization,
+  numberToHex,
   type Address,
   type Chain,
   type Transport,
   isAddress,
 } 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";
 
-export const createAuthorization = async (
+export const createAuthorizationRequest = async (
   client: SmartAccountClient<
     Transport,
     Chain,
@@ -21,18 +22,27 @@ export const createAuthorization = async (
     WalletServerViemRpcSchema
   >,
   params: { address: Address; delegation: Address },
-): Promise<Authorization<number, false> | undefined> => {
+): Promise<Static<typeof PreparedCall_Authorization> | undefined> => {
   const expectedCode = concatHex(["0xef0100", params.delegation]);
   const code = (await client.getCode({ address: params.address })) ?? "0x";
   if (code.toLowerCase() === expectedCode.toLowerCase()) {
     return undefined; // Already authorized.
   }
-  return {
-    chainId: client.chain.id,
+  const data = {
     address: params.delegation,
-    nonce: await client.getTransactionCount({
-      address: params.address,
-    }),
+    nonce: numberToHex(
+      await client.getTransactionCount({
+        address: params.address,
+      }),
+    ),
+  };
+  return {
+    type: "authorization" as const,
+    data,
+    chainId: numberToHex(client.chain.id),
+    signatureRequest: {
+      type: "eip7702Auth" as const,
+    },
   };
 };
 

package/src/isomorphic/utils/decodeSignature.ts

@@ -0,0 +1,18 @@
+import { Value } from "@sinclair/typebox/value";
+import type { Static, StaticDecode } from "@sinclair/typebox";
+import { TypeEcdsaSig } from "../../schemas.js";
+import { assertNever } from "../../utils.js";
+
+export const decodeSignature = (
+  signature: Static<typeof TypeEcdsaSig>["signature"],
+): StaticDecode<typeof TypeEcdsaSig>["signature"] => {
+  switch (signature.type) {
+    case "ecdsa":
+    case "secp256k1":
+      return Value.Decode(TypeEcdsaSig, { signature } satisfies Static<
+        typeof TypeEcdsaSig
+      >).signature;
+    default:
+      return assertNever(signature, "Unexpected signature type");
+  }
+};

package/src/local/client.ts

@@ -121,19 +121,15 @@ const innerClientActions = (
     grantPermissions: async (signer, params) => {
       const { signatureRequest, fullPreSignatureDeferredActionDigest } =
         await isomorphicClient.createSession(params);
-      const { signedAuthorization, signature } = await signSignatureRequest(
-        signer,
-        signatureRequest,
-      );
+      const signature = await signSignatureRequest(signer, signatureRequest);
       return {
         context: encodePermissionsContext({
           contextVersion: "LOCAL_MODE_DEFERRED_ACTION",
           deferredAction: buildDeferredActionDigest({
             fullPreSignatureDeferredActionDigest,
-            sig: prefixSignatureKeyType(signature, "secp256k1"),
+            sig: prefixSignatureKeyType(signature.data, signature.type),
           }),
         }),
-        signedAuthorization,
       };
     },
   };

package/src/remote/client.ts

@@ -1,5 +1,5 @@
 import { Provider } from "ox";
-import { BaseError, createClient, custom, type Address } from "viem";
+import { createClient, custom, type Address } from "viem";
 import { encodePermissionsContext } from "../capabilities/permissions/mav2.js";
 import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
 import { internalStateDecorator } from "../internal/decorator.js";
@@ -54,20 +54,13 @@ const innerClientActions = (
         method: "wallet_createSession",
         params: [params],
       });
-      if (signatureRequest.type !== "eth_signTypedData_v4") {
-        throw new BaseError("Unexpected signature request type");
-      }
-      const { signedAuthorization, signature } = await signSignatureRequest(
-        signer,
-        signatureRequest,
-      );
+      const signature = await signSignatureRequest(signer, signatureRequest);
       return {
         context: encodePermissionsContext({
           contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
           sessionId,
-          signature,
+          signature: signature.data,
         }),
-        signedAuthorization,
       };
     },
   };

package/src/rpc/examples.ts

@@ -82,9 +82,8 @@ const SendPreparedCalls = [
             },
             chainId: "0x66eee",
             signature: {
-              type: "ecdsa",
-              signature:
-                "0xb1a055089b1ba8387ed435f2bd0afe7ff69f22b928cdfdea1b5323c64d6af387164de3fa6febf031b544de46a84d6fb7f084b9798ddfaba820950c257139a7321b",
+              type: "secp256k1",
+              data: "0xb1a055089b1ba8387ed435f2bd0afe7ff69f22b928cdfdea1b5323c64d6af387164de3fa6febf031b544de46a84d6fb7f084b9798ddfaba820950c257139a7321b",
             },
           },
         ],
@@ -200,7 +199,7 @@ const CreateSession = [
                 type: "root",
               },
             ],
-            expiry: 1747969653,
+            expirySec: 1747969653,
           },
         ],
       },

package/src/rpc/request.ts

@@ -6,57 +6,43 @@ import {
   RemotePermission,
 } from "../capabilities/permissions/index.js";
 import {
+  TypeCallArray,
+  TypePrepareCall_UserOpV060_Signed,
+  TypePrepareCall_UserOpV070_Signed,
+  PreparedCall_Authorization,
+  PreparedCall_UserOpV060,
+  PreparedCall_UserOpV070,
   TypeAddress,
   TypeBase64UrlEncodedString,
   TypeCreationOptions,
-  TypeEip7702AuthExtendedFields,
   TypeHex,
   TypeSerializedInitcode,
-  TypeSignatureRequest,
-  TypeUserOperationRequest_v6,
-  TypeUserOperationRequest_v7,
+  TypeTypedDataSignatureRequest,
   TypeUuid,
-  TypeSignatureType,
 } from "../schemas.js";
 import { Examples } from "./examples.js";
-import { Eip7702AuthCapability } from "../capabilities/eip7702Auth.js";
 
 export const wallet_sendPreparedCalls = Type.Object(
   {
     Request: Type.Object({
       method: Type.Literal("wallet_sendPreparedCalls"),
       params: Type.Tuple([
-        Type.Object({
-          type: Type.Union([
-            Type.Literal("user-operation-v060", {
-              title: "User Operation (Entrypoint v0.6.0)",
-            }),
-            Type.Literal("user-operation-v070", {
-              title: "User Operation (Entrypoint v0.7.0)",
-            }),
-          ]),
-          data: Type.Union([
-            Type.Omit(TypeUserOperationRequest_v6, ["signature"], {
-              title: "Unsigned User Operation (Entrypoint v0.6.0)",
-            }),
-            Type.Omit(TypeUserOperationRequest_v7, ["signature"], {
-              title: "Unsigned User Operation (Entrypoint v0.7.0)",
-            }),
+        Type.Intersect([
+          Type.Union([
+            TypeCallArray,
+            TypePrepareCall_UserOpV060_Signed,
+            TypePrepareCall_UserOpV070_Signed,
           ]),
-          chainId: TypeHex(),
-          signature: Type.Object({
-            type: Type.Exclude(TypeSignatureType, Type.Literal("contract")),
-            signature: TypeHex(),
+          Type.Object({
+            capabilities: Type.Optional(
+              Type.Object({
+                permissions: Type.Optional(
+                  Type.Union([PermissionsContext, RemotePermission]),
+                ),
+              }),
+            ),
           }),
-          signedAuthorization: Type.Optional(TypeEip7702AuthExtendedFields),
-          capabilities: Type.Optional(
-            Type.Object({
-              permissions: Type.Optional(
-                Type.Union([PermissionsContext, RemotePermission]),
-              ),
-            }),
-          ),
-        }),
+        ]),
       ]),
     }),
     ReturnType: Type.Object({
@@ -89,26 +75,23 @@ export const wallet_prepareCalls = Type.Object(
         }),
       ]),
     }),
-    ReturnType: Type.Object({
-      type: Type.Union([
-        Type.Literal("user-operation-v060", {
-          title: "User Operation (Entrypoint v0.6.0)",
-        }),
-        Type.Literal("user-operation-v070", {
-          title: "User Operation (Entrypoint v0.7.0)",
-        }),
-      ]),
-      data: Type.Union([
-        Type.Omit(TypeUserOperationRequest_v6, ["signature"], {
-          title: "Unsigned User Operation (Entrypoint v0.6.0)",
-        }),
-        Type.Omit(TypeUserOperationRequest_v7, ["signature"], {
-          title: "Unsigned User Operation (Entrypoint v0.7.0)",
-        }),
-      ]),
-      chainId: TypeHex(),
-      signatureRequest: TypeSignatureRequest,
-    }),
+    ReturnType: Type.Union([
+      Type.Object(
+        {
+          type: Type.Literal("array"),
+          data: Type.Array(
+            Type.Union([
+              PreparedCall_UserOpV060,
+              PreparedCall_UserOpV070,
+              PreparedCall_Authorization,
+            ]),
+          ),
+        },
+        { description: "Array of prepared calls" },
+      ),
+      PreparedCall_UserOpV060,
+      PreparedCall_UserOpV070,
+    ]),
   },
   {
     description:
@@ -133,7 +116,7 @@ export const wallet_requestAccount = Type.Object(
               ),
             },
             {
-              title: "Using signer address",
+              description: "Using signer address",
             },
           ),
           Type.Object(
@@ -144,7 +127,7 @@ export const wallet_requestAccount = Type.Object(
               ),
             },
             {
-              title: "Using smart contract account address",
+              description: "Using smart contract account address",
             },
           ),
         ]),
@@ -229,18 +212,13 @@ export const wallet_createSession = Type.Object(
           PermissionsData,
           Type.Object({
             account: TypeAddress,
-            capabilities: Type.Optional(
-              Type.Object({
-                eip7702Auth: Type.Optional(Eip7702AuthCapability),
-              }),
-            ),
           }),
         ]),
       ]),
     }),
     ReturnType: Type.Object({
       sessionId: TypeHex(),
-      signatureRequest: TypeSignatureRequest,
+      signatureRequest: TypeTypedDataSignatureRequest,
     }),
   },
   {

package/src/rpc/schema.ts

@@ -1,10 +1,10 @@
-import { type Static, type StaticDecode } from "@sinclair/typebox";
+import { type Static } from "@sinclair/typebox";
 import { RpcSchema } from "ox";
 import * as Requests from "./request.js";
 
 export const WalletServerRpcSchema = RpcSchema.from<
   | Static<typeof Requests.wallet_prepareCalls>
-  | StaticDecode<typeof Requests.wallet_sendPreparedCalls>
+  | Static<typeof Requests.wallet_sendPreparedCalls>
   | Static<typeof Requests.wallet_createAccount>
   | Static<typeof Requests.wallet_requestAccount>
   | Static<typeof Requests.wallet_listAccounts>