@account-kit/wallet-client 0.0.1-alpha.1

package/src/client/actions/grantPermissions.ts

@@ -0,0 +1,48 @@
+import {
+  type Address,
+  type Hex,
+  type IsUndefined,
+  type JsonRpcAccount,
+  toHex,
+} from "viem";
+import type { InnerWalletApiClient } from "../../types";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { CreateSessionParams } from "../../isomorphic/actions/createSession";
+
+export type GrantPermissionsParams<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+> = Omit<CreateSessionParams, "account" | "chainId"> &
+  (IsUndefined<TAccount> extends true
+    ? { account: Address }
+    : { account?: never });
+
+export type GrantPermissionsResult = {
+  context: Hex;
+};
+
+export async function grantPermissions<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+>(
+  client: InnerWalletApiClient,
+  signer: SmartAccountSigner,
+  params: GrantPermissionsParams<TAccount>,
+): Promise<GrantPermissionsResult>;
+
+export async function grantPermissions(
+  client: InnerWalletApiClient,
+  signer: SmartAccountSigner,
+  params: GrantPermissionsParams,
+): Promise<GrantPermissionsResult> {
+  if (client.account && !params.account) {
+    params.account = client.account.address;
+  }
+
+  return client.grantPermissions(signer, {
+    ...params,
+    chainId: toHex(client.chain.id),
+  });
+}

package/src/client/actions/listAccounts.ts

@@ -0,0 +1,18 @@
+import type { Static } from "@sinclair/typebox";
+import type { wallet_listAccounts } from "../../rpc/request";
+import type { InnerWalletApiClient } from "../../types";
+
+export type ListAccountsParams = Static<
+  typeof wallet_listAccounts
+>["Request"]["params"][0];
+
+export type ListAccountsResult = Static<
+  typeof wallet_listAccounts
+>["ReturnType"];
+
+export async function listAccounts(
+  client: InnerWalletApiClient,
+  params: ListAccountsParams,
+): Promise<ListAccountsResult> {
+  return client.request({ method: "wallet_listAccounts", params: [params] });
+}

package/src/client/actions/prepareCalls.ts

@@ -0,0 +1,55 @@
+import {
+  toHex,
+  type Address,
+  type IsUndefined,
+  type JsonRpcAccount,
+} from "viem";
+import type {
+  PrepareCallsParams as IsomorphicPrepareCallsParams,
+  PrepareCallsResult as IsomorphicPrepareCallsResult,
+} from "../../isomorphic/actions/prepareCalls";
+import type { InnerWalletApiClient } from "../../types";
+
+export type GetAccountParam<TAccount> =
+  IsUndefined<TAccount> extends true
+    ? { account: Address }
+    : { account?: never };
+
+export type PrepareCallsParams<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+> = Omit<IsomorphicPrepareCallsParams, "from" | "chainId"> &
+  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });
+
+export type PrepareCallsResult = IsomorphicPrepareCallsResult;
+
+export async function prepareCalls<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+>(
+  client: InnerWalletApiClient<TAccount>,
+  params: PrepareCallsParams<TAccount>,
+): Promise<PrepareCallsResult>;
+
+export async function prepareCalls(
+  client: InnerWalletApiClient,
+  params: PrepareCallsParams,
+): Promise<PrepareCallsResult> {
+  if (client.policyId && !params.capabilities?.paymasterService) {
+    params.capabilities = {
+      ...params.capabilities,
+      paymasterService: { policyId: client.policyId },
+    };
+  }
+
+  if (client.account && !params.from) {
+    params.from = client.account.address;
+  }
+
+  return await client.request({
+    method: "wallet_prepareCalls",
+    params: [{ ...params, chainId: toHex(client.chain.id) }],
+  });
+}

package/src/client/actions/requestAccount.ts

@@ -0,0 +1,71 @@
+import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
+import type { Static } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import type { Address } from "abitype";
+import { custom, type IsUndefined, type JsonRpcAccount } from "viem";
+import { createAccount } from "../../isomorphic/utils/createAccount";
+import type { wallet_requestAccount } from "../../rpc/request";
+import { TypeSerializedInitcode } from "../../schemas";
+import type { InnerWalletApiClient } from "../../types";
+
+export type RequestAccountParams<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+> =
+  IsUndefined<TAccount> extends true
+    ? Omit<
+        Extract<
+          Static<typeof wallet_requestAccount>["Request"]["params"][0],
+          { signerAddress: Address }
+        >,
+        "signerAddress" | "includeCounterfactualInfo"
+      >
+    : never;
+
+// TODO: this could be more specific potentially :shrug:
+export type RequestAccountResult = SmartContractAccount;
+
+export function requestAccount<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+>(
+  client: InnerWalletApiClient<TAccount>,
+  signer: SmartAccountSigner,
+  params?: RequestAccountParams<TAccount>,
+): Promise<RequestAccountResult>;
+
+export async function requestAccount(
+  client: InnerWalletApiClient,
+  signer: SmartAccountSigner,
+  params?: RequestAccountParams,
+): Promise<RequestAccountResult> {
+  const args =
+    client.account && !params
+      ? {
+          accountAddress: client.account.address,
+          includeCounterfactualInfo: true,
+        }
+      : {
+          ...params,
+          signerAddress: await signer.getAddress(),
+          includeCounterfactualInfo: true,
+        };
+
+  const { counterfactualInfo, accountAddress } = await client.request({
+    method: "wallet_requestAccount",
+    params: [args],
+  });
+
+  return createAccount({
+    accountAddress: accountAddress,
+    counterfactualInfo: Value.Parse(
+      TypeSerializedInitcode,
+      counterfactualInfo!,
+    ),
+    chain: client.chain,
+    transport: custom(client.transport),
+    signer,
+  });
+}

package/src/client/actions/sendPreparedCalls.ts

@@ -0,0 +1,23 @@
+import type { Static } from "@sinclair/typebox";
+import type { wallet_sendPreparedCalls } from "../../rpc/request";
+import type { InnerWalletApiClient } from "../../types";
+import { toHex } from "viem";
+
+export type SendPreparedCallsParams = Omit<
+  Static<typeof wallet_sendPreparedCalls>["Request"]["params"][0],
+  "chainId"
+>;
+
+export type SendPreparedCallsResult = Static<
+  typeof wallet_sendPreparedCalls
+>["ReturnType"];
+
+export async function sendPreparedCalls(
+  client: InnerWalletApiClient,
+  params: SendPreparedCallsParams,
+): Promise<SendPreparedCallsResult> {
+  return client.request({
+    method: "wallet_sendPreparedCalls",
+    params: [{ ...params, chainId: toHex(client.chain.id) }],
+  });
+}

package/src/client/actions/signMessage.ts

@@ -0,0 +1,32 @@
+import {
+  type Address,
+  type Hex,
+  type JsonRpcAccount,
+  type SignableMessage,
+} from "viem";
+import type { InnerWalletApiClient } from "../../types";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import { requestAccount } from "./requestAccount";
+
+export type SignMessageParams = SignableMessage;
+
+export type SignMessageResult = Hex;
+
+export async function signMessage<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+>(
+  client: InnerWalletApiClient<TAccount>,
+  signer: SmartAccountSigner,
+  params: SignMessageParams,
+): Promise<SignMessageResult>;
+
+export async function signMessage(
+  client: InnerWalletApiClient,
+  signer: SmartAccountSigner,
+  params: SignMessageParams,
+): Promise<SignMessageResult> {
+  const account = await requestAccount(client, signer);
+  return account.signMessageWith6492({ message: params });
+}

package/src/client/actions/signSignatureRequest.ts

@@ -0,0 +1,34 @@
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { Static } from "@sinclair/typebox";
+import { type Hex } from "viem";
+import { TypeSignatureRequest } from "../../schemas";
+import { assertNever } from "../../utils";
+
+export type SignSignatureRequestParams = Static<typeof TypeSignatureRequest>;
+
+export type SignSignatureRequestResult = {
+  type: "ecdsa";
+  signature: Hex;
+};
+
+export function signSignatureRequest(
+  signer: SmartAccountSigner,
+  params: SignSignatureRequestParams,
+): Promise<SignSignatureRequestResult>;
+
+export async function signSignatureRequest(
+  signer: SmartAccountSigner,
+  params: SignSignatureRequestParams,
+): Promise<SignSignatureRequestResult> {
+  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,
+  };
+}

package/src/client/actions/signTypedData.ts

@@ -0,0 +1,32 @@
+import {
+  type Address,
+  type Hex,
+  type JsonRpcAccount,
+  type TypedDataDefinition,
+} from "viem";
+import type { InnerWalletApiClient } from "../../types";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import { requestAccount } from "./requestAccount";
+
+export type SignTypedDataParams = TypedDataDefinition;
+
+export type SignTypedDataResult = Hex;
+
+export async function signTypedData<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+>(
+  client: InnerWalletApiClient<TAccount>,
+  signer: SmartAccountSigner,
+  params: SignTypedDataParams,
+): Promise<SignTypedDataResult>;
+
+export async function signTypedData(
+  client: InnerWalletApiClient,
+  signer: SmartAccountSigner,
+  params: SignTypedDataParams,
+): Promise<SignTypedDataResult> {
+  const account = await requestAccount(client, signer);
+  return account.signTypedDataWith6492(params);
+}

package/src/client/client.e2e-test.ts

@@ -0,0 +1,294 @@
+import { LocalAccountSigner } from "@aa-sdk/core";
+import { alchemy, arbitrumSepolia } from "@account-kit/infra";
+import { describe, expect, it } from "bun:test";
+import { createPublicClient, zeroAddress, type Address } from "viem";
+import { createSmartWalletClient } from ".";
+import { PermissionType } from "@account-kit/smart-contracts/experimental";
+import { signSignatureRequest } from "./actions/signSignatureRequest";
+
+describe("Client E2E Tests", () => {
+  const transport = alchemy(
+    process.env.ALCHEMY_PROXY_RPC_URL
+      ? {
+          rpcUrl: process.env.ALCHEMY_PROXY_RPC_URL,
+        }
+      : {
+          apiKey: process.env.TEST_ALCHEMY_API_KEY!,
+        },
+  );
+  describe("Local Mode Tests", () => {
+    const signer = LocalAccountSigner.privateKeyToAccountSigner(
+      "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff81",
+    );
+
+    const client = createSmartWalletClient({
+      transport,
+      chain: arbitrumSepolia,
+      mode: "local",
+      signer,
+    });
+
+    const publicClient = createPublicClient({
+      chain: arbitrumSepolia,
+      transport,
+    });
+
+    it("should successfully get a counterfactual address", async () => {
+      const account = await client.requestAccount();
+      expect(account.address).toMatchInlineSnapshot(
+        `"0x26809de7733F9CcB5c0c61210a4f78d6F1daFc58"`,
+      );
+    });
+
+    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 isValid = await publicClient.verifyMessage({
+        address: account.address,
+        message: "hello world",
+        signature,
+      });
+      expect(isValid).toBeTrue();
+    });
+
+    it("can correctly sign typed data", async () => {
+      const account = await client.requestAccount();
+      const signature = await client.signTypedData(givenTypedData);
+      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({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+        },
+      });
+
+      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,
+        },
+      });
+
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+    });
+
+    it("should successfully create a session with grantPermissions and send a UO", async () => {
+      const account = await client.requestAccount();
+
+      const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+
+      const permissions = await client.grantPermissions({
+        account: account.address,
+        expiry: Math.floor(Date.now() / 1000) + 60 * 60,
+        key: {
+          publicKey: await sessionKey.getAddress(),
+          type: "secp256k1",
+        },
+        permissions: [{ type: PermissionType.ROOT }],
+      });
+
+      const preparedUO = await client.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+          permissions,
+        },
+      });
+
+      const signature = await signSignatureRequest(
+        sessionKey,
+        preparedUO.signatureRequest,
+      );
+
+      const result = await client.sendPreparedCalls({
+        ...preparedUO,
+        signature,
+        capabilities: {
+          permissions,
+        },
+      });
+
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+    });
+  });
+
+  describe("Remote Mode Tests", () => {
+    const signer = LocalAccountSigner.privateKeyToAccountSigner(
+      "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+    );
+
+    const client = createSmartWalletClient({
+      transport,
+      chain: arbitrumSepolia,
+      mode: "remote",
+      signer,
+    });
+
+    const publicClient = createPublicClient({
+      chain: arbitrumSepolia,
+      transport,
+    });
+
+    it("should successfully get a counterfactual address", async () => {
+      const account = await client.requestAccount();
+      expect(account.address).toMatchInlineSnapshot(
+        `"0x65b5DE0251f553B2208762a4724303E750294D96"`,
+      );
+    });
+
+    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 isValid = await publicClient.verifyMessage({
+        address: account.address,
+        message: "hello world",
+        signature,
+      });
+      expect(isValid).toBeTrue();
+    });
+
+    it("can correctly sign typed data", async () => {
+      const account = await client.requestAccount();
+      const signature = await client.signTypedData(givenTypedData);
+      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({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+        },
+      });
+
+      const signature = await client.signSignatureRequest(
+        preparedUO.signatureRequest,
+      );
+
+      const result = await client.sendPreparedCalls({
+        ...preparedUO,
+        signature,
+      });
+
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+    });
+
+    it("should successfully create a session with grantPermissions and send a UO", async () => {
+      const account = await client.requestAccount();
+
+      const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+
+      const permissions = await client.grantPermissions({
+        account: account.address,
+        expiry: Math.floor(Date.now() / 1000) + 60 * 60,
+        key: {
+          publicKey: await sessionKey.getAddress(),
+          type: "secp256k1",
+        },
+        permissions: [{ type: PermissionType.ROOT }],
+      });
+
+      const preparedUO = await client.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+          permissions,
+        },
+      });
+
+      const signature = await signSignatureRequest(
+        sessionKey,
+        preparedUO.signatureRequest,
+      );
+
+      const result = await client.sendPreparedCalls({
+        ...preparedUO,
+        signature,
+        capabilities: {
+          permissions,
+        },
+      });
+
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+    });
+  });
+
+  const givenTypedData = {
+    types: {
+      Person: [
+        { name: "name", type: "string" },
+        { name: "wallet", type: "address" },
+      ],
+      Mail: [
+        { name: "from", type: "Person" },
+        { name: "to", type: "Person" },
+        { name: "contents", type: "string" },
+      ],
+    },
+    primaryType: "Mail" as const,
+    domain: {
+      name: "Ether Mail",
+      version: "1",
+      chainId: 1,
+      verifyingContract:
+        "0xbbc68f94D29d52EE8D4994E54d6ED0fEAeb99C2c" as Address,
+    },
+    message: {
+      from: {
+        name: "Alice",
+        wallet: "0xFC24e57486116026740634F629ffC4E5C95A6893",
+      },
+      to: {
+        name: "Bob",
+        wallet: "0xe7a26f006EAA562308C5df235C02BFB9a5849177",
+      },
+      contents: "Hello, Bob!",
+    },
+  } as const;
+});