@account-kit/wallet-client 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/esm/client/actions/signSignatureRequest.js

@@ -1,15 +1,73 @@
-import {} from "viem";
-import { TypeSignatureRequest } from "../../schemas";
-import { assertNever } from "../../utils";
+import { hexToNumber, serializeSignature } from "viem";
+import { assertNever } from "../../utils.js";
+import {} from "@alchemy/wallet-api-types";
+import { vToYParity } from "ox/Signature";
+/**
+ * Signs a signature request using the provided signer.
+ * This method handles different types of signature requests including personal_sign, eth_signTypedData_v4, and authorization.
+ *
+ * @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', '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 'secp256k1' 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
+ * const result = await client.signSignatureRequest({
+ *   type: 'personal_sign',
+ *   data: 'Hello, world!'
+ * });
+ *
+ * @example
+ * // Sign typed data (EIP-712)
+ * const result = await client.signSignatureRequest({
+ *   type: 'eth_signTypedData_v4',
+ *   data: {
+ *     domain: { ... },
+ *     types: { ... },
+ *     primaryType: '...',
+ *     message: { ... }
+ *   }
+ * });
+ */
 export async function signSignatureRequest(signer, params) {
-    const signature = params.type === "personal_sign"
-        ? await signer.signMessage(params.data)
-        : params.type === "eth_signTypedData_v4"
-            ? await signer.signTypedData(params.data)
-            : assertNever(params, "Unexpected signature request type");
-    return {
-        type: "ecdsa",
-        signature,
-    };
+    switch (params.type) {
+        case "personal_sign": {
+            return {
+                type: "secp256k1",
+                data: await signer.signMessage(params.data),
+            };
+        }
+        case "eth_signTypedData_v4": {
+            return {
+                type: "secp256k1",
+                data: await signer.signTypedData(params.data),
+            };
+        }
+        case "eip7702Auth": {
+            if (!signer.signAuthorization) {
+                throw new Error("Signer does not implement signAuthorization");
+            }
+            const { r, s, v, yParity } = await signer.signAuthorization({
+                ...params.data,
+                chainId: hexToNumber(params.data.chainId),
+                nonce: hexToNumber(params.data.nonce),
+            });
+            return {
+                type: "secp256k1",
+                data: serializeSignature({
+                    r,
+                    s,
+                    yParity: yParity ?? vToYParity(Number(v)),
+                }),
+            };
+        }
+        default:
+            return assertNever(params, `Unexpected signature request type.`);
+    }
 }
 //# sourceMappingURL=signSignatureRequest.js.map

package/dist/esm/client/actions/signSignatureRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"signSignatureRequest.js","sourceRoot":"","sources":["../../../../src/client/actions/signSignatureRequest.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,MAAM,MAAM,CAAC;AAChC,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAc1C,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,MAA0B,EAC1B,MAAkC;IAElC,MAAM,SAAS,GACb,MAAM,CAAC,IAAI,KAAK,eAAe;QAC7B,CAAC,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC;QACvC,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAsB;YACtC,CAAC,CAAC,MAAM,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC;YACzC,CAAC,CAAC,WAAW,CAAC,MAAM,EAAE,mCAAmC,CAAC,CAAC;IAEjE,OAAO;QACL,IAAI,EAAE,OAAO;QACb,SAAS;KACV,CAAC;AACJ,CAAC","sourcesContent":["import type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport type { Static } from \"@sinclair/typebox\";\nimport { type Hex } from \"viem\";\nimport { TypeSignatureRequest } from \"../../schemas\";\nimport { assertNever } from \"../../utils\";\n\nexport type SignSignatureRequestParams = Static<typeof TypeSignatureRequest>;\n\nexport type SignSignatureRequestResult = {\n  type: \"ecdsa\";\n  signature: Hex;\n};\n\nexport function signSignatureRequest(\n  signer: SmartAccountSigner,\n  params: SignSignatureRequestParams,\n): Promise<SignSignatureRequestResult>;\n\nexport async function signSignatureRequest(\n  signer: SmartAccountSigner,\n  params: SignSignatureRequestParams,\n): Promise<SignSignatureRequestResult> {\n  const signature =\n    params.type === \"personal_sign\"\n      ? await signer.signMessage(params.data)\n      : params.type === \"eth_signTypedData_v4\"\n        ? await signer.signTypedData(params.data)\n        : assertNever(params, \"Unexpected signature request type\");\n\n  return {\n    type: \"ecdsa\",\n    signature,\n  };\n}\n"]}
+{"version":3,"file":"signSignatureRequest.js","sourceRoot":"","sources":["../../../../src/client/actions/signSignatureRequest.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,WAAW,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAKN,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAgB1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,MAA0B,EAC1B,MAAkC;IAElC,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACpB,KAAK,eAAe,CAAC,CAAC,CAAC;YACrB,OAAO;gBACL,IAAI,EAAE,WAAW;gBACjB,IAAI,EAAE,MAAM,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC;aAC5C,CAAC;QACJ,CAAC;QACD,KAAK,sBAAsB,CAAC,CAAC,CAAC;YAC5B,OAAO;gBACL,IAAI,EAAE,WAAW;gBACjB,IAAI,EAAE,MAAM,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC;aAC9C,CAAC;QACJ,CAAC;QACD,KAAK,aAAa,CAAC,CAAC,CAAC;YACnB,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;gBAC9B,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;YACjE,CAAC;YACD,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC;gBAC1D,GAAG,MAAM,CAAC,IAAI;gBACd,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;gBACzC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;aACtC,CAAC,CAAC;YAEH,OAAO;gBACL,IAAI,EAAE,WAAW;gBACjB,IAAI,EAAE,kBAAkB,CAAC;oBACvB,CAAC;oBACD,CAAC;oBACD,OAAO,EAAE,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;iBAC1C,CAAC;aACH,CAAC;QACJ,CAAC;QACD;YACE,OAAO,WAAW,CAAC,MAAM,EAAE,oCAAoC,CAAC,CAAC;IACrE,CAAC;AACH,CAAC","sourcesContent":["import type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport { type Hex, hexToNumber, serializeSignature } from \"viem\";\nimport { assertNever } from \"../../utils.js\";\nimport {\n  type TypePersonalSignSignatureRequest,\n  type TypeTypedDataSignatureRequest,\n  type TypeAuthorizationSignatureRequest,\n  type TypeEip7702UnsignedAuth,\n} from \"@alchemy/wallet-api-types\";\nimport { vToYParity } from \"ox/Signature\";\nimport type { WithoutRawPayload } from \"../../types.ts\";\n\nexport type SignSignatureRequestParams = WithoutRawPayload<\n  | TypePersonalSignSignatureRequest\n  | TypeTypedDataSignatureRequest\n  | (TypeAuthorizationSignatureRequest & {\n      data: TypeEip7702UnsignedAuth;\n    })\n>;\n\nexport type SignSignatureRequestResult = {\n  type: \"secp256k1\";\n  data: Hex;\n};\n\n/**\n * Signs a signature request using the provided signer.\n * This method handles different types of signature requests including personal_sign, eth_signTypedData_v4, and authorization.\n *\n * @param {SmartAccountSigner} signer - The signer to use for signing the request\n * @param {SignSignatureRequestParams} params - The signature request parameters\n * @param {string} params.type - The type of signature request ('personal_sign', 'eth_signTypedData_v4', or 'signature_with_authorization')\n * @param {any} params.data - The data to sign, format depends on the signature type\n * @returns {Promise<SignSignatureRequestResult>} A Promise that resolves to the signature result\n * @returns {string} result.type - The signature type (currently only 'secp256k1' is supported)\n * @returns {Hex} result.signature - The hex-encoded signature\n * @returns {Eip7702ExtendedFields[\"eip7702Auth\"]} result.signedAuthorization - The signed EIP-7702 authorization, if applicable\n *\n * @example\n * // Sign a personal message\n * const result = await client.signSignatureRequest({\n *   type: 'personal_sign',\n *   data: 'Hello, world!'\n * });\n *\n * @example\n * // Sign typed data (EIP-712)\n * const result = await client.signSignatureRequest({\n *   type: 'eth_signTypedData_v4',\n *   data: {\n *     domain: { ... },\n *     types: { ... },\n *     primaryType: '...',\n *     message: { ... }\n *   }\n * });\n */\n\nexport async function signSignatureRequest(\n  signer: SmartAccountSigner,\n  params: SignSignatureRequestParams,\n): Promise<SignSignatureRequestResult> {\n  switch (params.type) {\n    case \"personal_sign\": {\n      return {\n        type: \"secp256k1\",\n        data: await signer.signMessage(params.data),\n      };\n    }\n    case \"eth_signTypedData_v4\": {\n      return {\n        type: \"secp256k1\",\n        data: await signer.signTypedData(params.data),\n      };\n    }\n    case \"eip7702Auth\": {\n      if (!signer.signAuthorization) {\n        throw new Error(\"Signer does not implement signAuthorization\");\n      }\n      const { r, s, v, yParity } = await signer.signAuthorization({\n        ...params.data,\n        chainId: hexToNumber(params.data.chainId),\n        nonce: hexToNumber(params.data.nonce),\n      });\n\n      return {\n        type: \"secp256k1\",\n        data: serializeSignature({\n          r,\n          s,\n          yParity: yParity ?? vToYParity(Number(v)),\n        }),\n      };\n    }\n    default:\n      return assertNever(params, `Unexpected signature request type.`);\n  }\n}\n"]}

package/dist/esm/client/actions/signTypedData.d.ts

@@ -1,6 +1,39 @@
-import { type Address, type Hex, type JsonRpcAccount, type TypedDataDefinition } from "viem";
-import type { InnerWalletApiClient } from "../../types";
 import type { SmartAccountSigner } from "@aa-sdk/core";
-export type SignTypedDataParams = TypedDataDefinition;
+import { type Address, type Hex, type TypedDataDefinition } from "viem";
+import type { InnerWalletApiClient } from "../../types.ts";
+export type SignTypedDataParams = TypedDataDefinition & {
+    account?: Address;
+};
 export type SignTypedDataResult = Hex;
-export declare function signTypedData<TAccount extends JsonRpcAccount<Address> | undefined = JsonRpcAccount<Address> | undefined>(client: InnerWalletApiClient<TAccount>, signer: SmartAccountSigner, params: SignTypedDataParams): Promise<SignTypedDataResult>;
+/**
+ * Signs typed data (EIP-712) using the smart account.
+ * This method requests the account associated with the signer and uses it to sign the typed data.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer of the smart account
+ * @param {TypedDataDefinition} params - The typed data to sign, following EIP-712 format
+ * @returns {Promise<SignTypedDataResult>} A Promise that resolves to the signature as a hex string
+ *
+ * @example
+ * // Sign typed data
+ * const signature = await client.signTypedData({
+ *   domain: {
+ *     name: 'Example DApp',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' }
+ *     ]
+ *   },
+ *   primaryType: 'Person',
+ *   message: {
+ *     name: 'John Doe',
+ *     wallet: '0xAaAaAaAaAaAaAaAaAaAAAAAAAAaaaAaAaAaaAaAa'
+ *   }
+ * });
+ */
+export declare function signTypedData(client: InnerWalletApiClient, signer: SmartAccountSigner, params: SignTypedDataParams): Promise<SignTypedDataResult>;

package/dist/esm/client/actions/signTypedData.js

@@ -1,7 +1,40 @@
 import {} from "viem";
-import { requestAccount } from "./requestAccount";
+import { requestAccount } from "./requestAccount.js";
+/**
+ * Signs typed data (EIP-712) using the smart account.
+ * This method requests the account associated with the signer and uses it to sign the typed data.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer of the smart account
+ * @param {TypedDataDefinition} params - The typed data to sign, following EIP-712 format
+ * @returns {Promise<SignTypedDataResult>} A Promise that resolves to the signature as a hex string
+ *
+ * @example
+ * // Sign typed data
+ * const signature = await client.signTypedData({
+ *   domain: {
+ *     name: 'Example DApp',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' }
+ *     ]
+ *   },
+ *   primaryType: 'Person',
+ *   message: {
+ *     name: 'John Doe',
+ *     wallet: '0xAaAaAaAaAaAaAaAaAaAAAAAAAAaaaAaAaAaaAaAa'
+ *   }
+ * });
+ */
 export async function signTypedData(client, signer, params) {
-    const account = await requestAccount(client, signer);
+    const account = await requestAccount(client, signer, {
+        accountAddress: params.account ?? client.account?.address,
+    });
     return account.signTypedDataWith6492(params);
 }
 //# sourceMappingURL=signTypedData.js.map

package/dist/esm/client/actions/signTypedData.js.map

@@ -1 +1 @@
-{"version":3,"file":"signTypedData.js","sourceRoot":"","sources":["../../../../src/client/actions/signTypedData.ts"],"names":[],"mappings":"AAAA,OAAO,EAKN,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAgBlD,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,MAA4B,EAC5B,MAA0B,EAC1B,MAA2B;IAE3B,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,OAAO,OAAO,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAC/C,CAAC","sourcesContent":["import {\n  type Address,\n  type Hex,\n  type JsonRpcAccount,\n  type TypedDataDefinition,\n} from \"viem\";\nimport type { InnerWalletApiClient } from \"../../types\";\nimport type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport { requestAccount } from \"./requestAccount\";\n\nexport type SignTypedDataParams = TypedDataDefinition;\n\nexport type SignTypedDataResult = Hex;\n\nexport async function signTypedData<\n  TAccount extends JsonRpcAccount<Address> | undefined =\n    | JsonRpcAccount<Address>\n    | undefined,\n>(\n  client: InnerWalletApiClient<TAccount>,\n  signer: SmartAccountSigner,\n  params: SignTypedDataParams,\n): Promise<SignTypedDataResult>;\n\nexport async function signTypedData(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params: SignTypedDataParams,\n): Promise<SignTypedDataResult> {\n  const account = await requestAccount(client, signer);\n  return account.signTypedDataWith6492(params);\n}\n"]}
+{"version":3,"file":"signTypedData.js","sourceRoot":"","sources":["../../../../src/client/actions/signTypedData.ts"],"names":[],"mappings":"AACA,OAAO,EAAoD,MAAM,MAAM,CAAC;AAExE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAQrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,MAA4B,EAC5B,MAA0B,EAC1B,MAA2B;IAE3B,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE;QACnD,cAAc,EAAE,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO;KAC1D,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAC/C,CAAC","sourcesContent":["import type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport { type Address, type Hex, type TypedDataDefinition } from \"viem\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\nimport { requestAccount } from \"./requestAccount.js\";\n\nexport type SignTypedDataParams = TypedDataDefinition & {\n  account?: Address;\n};\n\nexport type SignTypedDataResult = Hex;\n\n/**\n * Signs typed data (EIP-712) using the smart account.\n * This method requests the account associated with the signer and uses it to sign the typed data.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {SmartAccountSigner} signer - The signer of the smart account\n * @param {TypedDataDefinition} params - The typed data to sign, following EIP-712 format\n * @returns {Promise<SignTypedDataResult>} A Promise that resolves to the signature as a hex string\n *\n * @example\n * // Sign typed data\n * const signature = await client.signTypedData({\n *   domain: {\n *     name: 'Example DApp',\n *     version: '1',\n *     chainId: 1,\n *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'\n *   },\n *   types: {\n *     Person: [\n *       { name: 'name', type: 'string' },\n *       { name: 'wallet', type: 'address' }\n *     ]\n *   },\n *   primaryType: 'Person',\n *   message: {\n *     name: 'John Doe',\n *     wallet: '0xAaAaAaAaAaAaAaAaAaAAAAAAAAaaaAaAaAaaAaAa'\n *   }\n * });\n */\nexport async function signTypedData(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params: SignTypedDataParams,\n): Promise<SignTypedDataResult> {\n  const account = await requestAccount(client, signer, {\n    accountAddress: params.account ?? client.account?.address,\n  });\n\n  return account.signTypedDataWith6492(params);\n}\n"]}

package/dist/esm/client/client.e2e-test.js

@@ -2,8 +2,7 @@ import { LocalAccountSigner } from "@aa-sdk/core";
 import { alchemy, arbitrumSepolia } from "@account-kit/infra";
 import { describe, expect, it } from "bun:test";
 import { createPublicClient, zeroAddress } from "viem";
-import { createSmartWalletClient } from ".";
-import { signSignatureRequest } from "./actions/signSignatureRequest";
+import { createSmartWalletClient } from "./index.js";
 describe("Client E2E Tests", () => {
     const transport = alchemy(process.env.ALCHEMY_PROXY_RPC_URL
         ? {
@@ -13,7 +12,7 @@ describe("Client E2E Tests", () => {
             apiKey: process.env.TEST_ALCHEMY_API_KEY,
         });
     describe("Local Mode Tests", () => {
-        const signer = LocalAccountSigner.privateKeyToAccountSigner("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff81");
+        const signer = LocalAccountSigner.privateKeyToAccountSigner("0xbaca22d9b6846ec09a4da378ffa07e2f14ce7d65675d135911b6fd281416bb03");
         const client = createSmartWalletClient({
             transport,
             chain: arbitrumSepolia,
@@ -26,19 +25,30 @@ describe("Client E2E Tests", () => {
         });
         it("should successfully get a counterfactual address", async () => {
             const account = await client.requestAccount();
-            expect(account.address).toMatchInlineSnapshot(`"0x26809de7733F9CcB5c0c61210a4f78d6F1daFc58"`);
+            expect(account.address).toMatchInlineSnapshot(`"0xa46944b7a39c35d931D514ACAc3ac77c226a81ff"`);
+        });
+        it("should successfully request account with different salt", async () => {
+            const account = await client.requestAccount({
+                id: "f4c1d956-24ef-4002-a141-2c9d6d92af1a",
+                creationHint: { salt: "0x1" },
+            });
+            expect(account.address).toMatchInlineSnapshot(`"0xA692f0E5AfAD20F771443D89C635146C6A592f06"`);
+        });
+        it("should not cache account if different inputs provided", async () => {
+            const account = await client.requestAccount();
+            const account2 = await client.requestAccount({
+                id: "52ab44be-b03e-47ed-ad65-43014ea5fbfc",
+                creationHint: { salt: "0x2" },
+            });
+            expect(account.address).not.toEqual(account2.address);
         });
         it("can correctly sign a message", async () => {
             const account = await client.requestAccount();
             const message = "hello world";
-            const signature = await client.signMessage(message);
-            const publicClient = createPublicClient({
-                chain: arbitrumSepolia,
-                transport,
-            });
+            const signature = await client.signMessage({ message });
             const isValid = await publicClient.verifyMessage({
                 address: account.address,
-                message: "hello world",
+                message,
                 signature,
             });
             expect(isValid).toBeTrue();
@@ -53,9 +63,53 @@ describe("Client E2E Tests", () => {
             });
             expect(isValid).toBeTrue();
         });
-        it("should successfully send a UO with paymaster", async () => {
-            const account = await client.requestAccount();
-            const preparedUO = await client.prepareCalls({
+        it("can correctly sign a message with a different account", async () => {
+            const account = await client.requestAccount({
+                id: "f4c1d956-24ef-4002-a141-2c9d6d92af1a",
+                creationHint: { salt: "0x1" },
+            });
+            const message = "hello world";
+            const signature = await client.signMessage({
+                message,
+                account: account.address,
+            });
+            const isValid = await publicClient.verifyMessage({
+                address: account.address,
+                message,
+                signature,
+            });
+            expect(isValid).toBeTrue();
+        });
+        it("can correctly sign typed data with a different account", async () => {
+            const account = await client.requestAccount({
+                id: "f4c1d956-24ef-4002-a141-2c9d6d92af1a",
+                creationHint: { salt: "0x1" },
+            });
+            const signature = await client.signTypedData({
+                ...givenTypedData,
+                account: account.address,
+            });
+            const isValid = await publicClient.verifyTypedData({
+                ...givenTypedData,
+                signature,
+                address: account.address,
+            });
+            expect(isValid).toBeTrue();
+        });
+        it("should successfully send a UO with paymaster using 7702", async () => {
+            const _signer = LocalAccountSigner.privateKeyToAccountSigner("0x49daf21e92c997093e9ffdf7e7ddbf8970e9eadc5d4847d0f690db25d5128e1f");
+            const _client = createSmartWalletClient({
+                transport,
+                chain: arbitrumSepolia,
+                mode: "local",
+                signer: _signer,
+            });
+            const account = await _client.requestAccount({
+                creationHint: {
+                    accountType: "7702",
+                },
+            });
+            const preparedCalls = await _client.prepareCalls({
                 calls: [{ to: zeroAddress, value: "0x0" }],
                 from: account.address,
                 capabilities: {
@@ -64,17 +118,23 @@ describe("Client E2E Tests", () => {
                     },
                 },
             });
-            if (preparedUO.signatureRequest.type !== "personal_sign") {
-                throw new Error("Invalid signature request type");
-            }
-            const signature = await signer.signMessage(preparedUO.signatureRequest.data);
-            const result = await client.sendPreparedCalls({
-                ...preparedUO,
-                signature: {
-                    type: "ecdsa",
-                    signature,
+            const signedCalls = await _client.signPreparedCalls(preparedCalls);
+            const result = await _client.sendPreparedCalls(signedCalls);
+            expect(result.preparedCallIds).toBeArrayOfSize(1);
+        });
+        it("should successfully send a UO with paymaster", async () => {
+            const account = await client.requestAccount();
+            const preparedCalls = await client.prepareCalls({
+                calls: [{ to: zeroAddress, value: "0x0" }],
+                from: account.address,
+                capabilities: {
+                    paymasterService: {
+                        policyId: process.env.TEST_PAYMASTER_POLICY_ID,
+                    },
                 },
             });
+            const signedCalls = await client.signPreparedCalls(preparedCalls);
+            const result = await client.sendPreparedCalls(signedCalls);
             expect(result.preparedCallIds).toBeArrayOfSize(1);
         });
         it("should successfully create a session with grantPermissions and send a UO", async () => {
@@ -82,14 +142,20 @@ describe("Client E2E Tests", () => {
             const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
             const permissions = await client.grantPermissions({
                 account: account.address,
-                expiry: Math.floor(Date.now() / 1000) + 60 * 60,
+                expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
                 key: {
                     publicKey: await sessionKey.getAddress(),
                     type: "secp256k1",
                 },
                 permissions: [{ type: "root" }],
             });
-            const preparedUO = await client.prepareCalls({
+            const sessionKeyClient = createSmartWalletClient({
+                transport,
+                chain: arbitrumSepolia,
+                mode: "local",
+                signer: sessionKey,
+            });
+            const preparedCalls = await sessionKeyClient.prepareCalls({
                 calls: [{ to: zeroAddress, value: "0x0" }],
                 from: account.address,
                 capabilities: {
@@ -99,10 +165,9 @@ describe("Client E2E Tests", () => {
                     permissions,
                 },
             });
-            const signature = await signSignatureRequest(sessionKey, preparedUO.signatureRequest);
-            const result = await client.sendPreparedCalls({
-                ...preparedUO,
-                signature,
+            const signedCalls = await sessionKeyClient.signPreparedCalls(preparedCalls);
+            const result = await sessionKeyClient.sendPreparedCalls({
+                ...signedCalls,
                 capabilities: {
                     permissions,
                 },
@@ -111,7 +176,7 @@ describe("Client E2E Tests", () => {
         });
     });
     describe("Remote Mode Tests", () => {
-        const signer = LocalAccountSigner.privateKeyToAccountSigner("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+        const signer = LocalAccountSigner.privateKeyToAccountSigner("0xd7b061ef04d29cf68b3c89356678eccec9988de8d5ed892c19461c4a9d65925d");
         const client = createSmartWalletClient({
             transport,
             chain: arbitrumSepolia,
@@ -124,16 +189,27 @@ describe("Client E2E Tests", () => {
         });
         it("should successfully get a counterfactual address", async () => {
             const account = await client.requestAccount();
-            expect(account.address).toMatchInlineSnapshot(`"0x65b5DE0251f553B2208762a4724303E750294D96"`);
+            expect(account.address).toMatchInlineSnapshot(`"0x76E765e80FFAC96ac10Aa8908a8267A3B80d606D"`);
+        });
+        it("should successfully request account with different salt", async () => {
+            const account = await client.requestAccount({
+                id: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+                creationHint: { salt: "0x1" },
+            });
+            expect(account.address).toMatchInlineSnapshot(`"0xdfdd407b9569D40BEFa503208753E59cAc9713fA"`);
+        });
+        it("should not cache account if different inputs provided", async () => {
+            const account = await client.requestAccount();
+            const account2 = await client.requestAccount({
+                id: "2a3320b4-6ed2-4833-a488-5188e9bdd9d2",
+                creationHint: { salt: "0x2" },
+            });
+            expect(account.address).not.toEqual(account2.address);
         });
         it("can correctly sign a message", async () => {
             const account = await client.requestAccount();
             const message = "hello world";
-            const signature = await client.signMessage(message);
-            const publicClient = createPublicClient({
-                chain: arbitrumSepolia,
-                transport,
-            });
+            const signature = await client.signMessage({ message });
             const isValid = await publicClient.verifyMessage({
                 address: account.address,
                 message: "hello world",
@@ -151,9 +227,42 @@ describe("Client E2E Tests", () => {
             });
             expect(isValid).toBeTrue();
         });
+        it("can correctly sign a message with a different account", async () => {
+            const account = await client.requestAccount({
+                id: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+                creationHint: { salt: "0x1" },
+            });
+            const message = "hello world";
+            const signature = await client.signMessage({
+                message,
+                account: account.address,
+            });
+            const isValid = await publicClient.verifyMessage({
+                address: account.address,
+                message: "hello world",
+                signature,
+            });
+            expect(isValid).toBeTrue();
+        });
+        it("can correctly sign typed data with a different account", async () => {
+            const account = await client.requestAccount({
+                id: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+                creationHint: { salt: "0x1" },
+            });
+            const signature = await client.signTypedData({
+                ...givenTypedData,
+                account: account.address,
+            });
+            const isValid = await publicClient.verifyTypedData({
+                ...givenTypedData,
+                signature,
+                address: account.address,
+            });
+            expect(isValid).toBeTrue();
+        });
         it("should successfully send a UO with paymaster", async () => {
             const account = await client.requestAccount();
-            const preparedUO = await client.prepareCalls({
+            const preparedCalls = await client.prepareCalls({
                 calls: [{ to: zeroAddress, value: "0x0" }],
                 from: account.address,
                 capabilities: {
@@ -162,11 +271,62 @@ describe("Client E2E Tests", () => {
                     },
                 },
             });
-            const signature = await client.signSignatureRequest(preparedUO.signatureRequest);
-            const result = await client.sendPreparedCalls({
-                ...preparedUO,
-                signature,
+            const signedCalls = await client.signPreparedCalls(preparedCalls);
+            const result = await client.sendPreparedCalls(signedCalls);
+            expect(result.preparedCallIds).toBeArrayOfSize(1);
+        });
+        it("should successfully drop and replace a UO with repeat calls", async () => {
+            const account = await client.requestAccount();
+            const preparedCalls = await client.prepareCalls({
+                calls: [{ to: zeroAddress, value: "0x0" }],
+                from: account.address,
+                capabilities: {
+                    paymasterService: {
+                        policyId: process.env.TEST_PAYMASTER_POLICY_ID,
+                    },
+                },
             });
+            const signedCalls = await client.signPreparedCalls(preparedCalls);
+            const result = await client.sendPreparedCalls(signedCalls);
+            expect(result.preparedCallIds).toBeArrayOfSize(1);
+            const prepareCalls2 = await client.prepareCalls({
+                calls: [{ to: zeroAddress, value: "0x0" }],
+                from: account.address,
+                capabilities: {
+                    paymasterService: {
+                        policyId: process.env.TEST_PAYMASTER_POLICY_ID,
+                    },
+                },
+            });
+            const signedCalls2 = await client.signPreparedCalls(prepareCalls2);
+            const result2 = await client.sendPreparedCalls(signedCalls2);
+            expect(result2.preparedCallIds).toBeArrayOfSize(1);
+        });
+        it("should successfully send a UO with paymaster using 7702", async () => {
+            const _signer = LocalAccountSigner.privateKeyToAccountSigner("0x00d35c6d307b5cddeb70aeed96ee27a551fee58bf1a43858477e6c11f9172ba8");
+            const _client = createSmartWalletClient({
+                transport,
+                chain: arbitrumSepolia,
+                mode: "remote",
+                signer: _signer,
+            });
+            const account = await _client.requestAccount({
+                creationHint: {
+                    accountType: "7702",
+                },
+            });
+            expect(account.address).toBe(await _signer.getAddress());
+            const preparedCalls = await _client.prepareCalls({
+                calls: [{ to: zeroAddress, value: "0x0" }],
+                from: account.address,
+                capabilities: {
+                    paymasterService: {
+                        policyId: process.env.TEST_PAYMASTER_POLICY_ID,
+                    },
+                },
+            });
+            const signedCalls = await _client.signPreparedCalls(preparedCalls);
+            const result = await _client.sendPreparedCalls(signedCalls);
             expect(result.preparedCallIds).toBeArrayOfSize(1);
         });
         it("should successfully create a session with grantPermissions and send a UO", async () => {
@@ -174,14 +334,20 @@ describe("Client E2E Tests", () => {
             const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
             const permissions = await client.grantPermissions({
                 account: account.address,
-                expiry: Math.floor(Date.now() / 1000) + 60 * 60,
+                expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
                 key: {
                     publicKey: await sessionKey.getAddress(),
                     type: "secp256k1",
                 },
                 permissions: [{ type: "root" }],
             });
-            const preparedUO = await client.prepareCalls({
+            const sessionKeyClient = createSmartWalletClient({
+                transport,
+                chain: arbitrumSepolia,
+                mode: "remote",
+                signer: sessionKey,
+            });
+            const preparedCalls = await sessionKeyClient.prepareCalls({
                 calls: [{ to: zeroAddress, value: "0x0" }],
                 from: account.address,
                 capabilities: {
@@ -191,10 +357,9 @@ describe("Client E2E Tests", () => {
                     permissions,
                 },
             });
-            const signature = await signSignatureRequest(sessionKey, preparedUO.signatureRequest);
-            const result = await client.sendPreparedCalls({
-                ...preparedUO,
-                signature,
+            const signedCalls = await sessionKeyClient.signPreparedCalls(preparedCalls);
+            const result = await sessionKeyClient.sendPreparedCalls({
+                ...signedCalls,
                 capabilities: {
                     permissions,
                 },