@account-kit/wallet-client 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/client/actions/requestAccount.ts

@@ -1,50 +1,53 @@
-import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
+import {
+  type SmartAccountSigner,
+  type 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 deepEqual from "deep-equal";
+import { custom } from "viem";
 import { createAccount } from "../../isomorphic/utils/createAccount.js";
-import type { wallet_requestAccount } from "../../rpc/request.js";
-import { TypeSerializedInitcode } from "../../schemas.js";
+import type { wallet_requestAccount } from "@alchemy/wallet-api-types/rpc";
+import { SerializedInitcode } from "@alchemy/wallet-api-types";
 import type { InnerWalletApiClient } from "../../types.js";
 
-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;
+export type RequestAccountParams = Omit<
+  Extract<
+    Static<typeof wallet_requestAccount>["Request"]["params"][0],
+    { signerAddress: Address }
+  >,
+  "signerAddress" | "includeCounterfactualInfo"
+> & { accountAddress?: Address };
 
-// 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>;
-
+/**
+ * Requests an account for the provided signer using the wallet API client.
+ * If an account already exists for the signer, it will always return that account unless a new ID is specified.
+ * If an account already exists, the creationHint will be ignored.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer that will be associated with the account
+ * @param {RequestAccountParams} [params] - Optional parameters for requesting a specific account
+ * @param {string} [params.id] - Optional identifier for the account. If specified, a new account with this ID will be created even if one already exists for the signer
+ * @param {object} [params.creationHint] - Optional hints to guide account creation. These are ignored if an account already exists
+ * @returns {Promise<RequestAccountResult>} A Promise that resolves to a SmartContractAccount instance
+ *
+ * @example
+ * // Request an account with default parameters using a local signer
+ * const signer = LocalAccountSigner.privateKeyToAccountSigner("0x...");
+ * const account = await client.requestAccount(signer);
+ */
 export async function requestAccount(
   client: InnerWalletApiClient,
   signer: SmartAccountSigner,
   params?: RequestAccountParams,
 ): Promise<RequestAccountResult> {
   const args =
-    client.account && !params
+    (client.account && !params) || params?.accountAddress
       ? {
-          accountAddress: client.account.address,
+          accountAddress: params?.accountAddress ?? client.account!.address,
           includeCounterfactualInfo: true,
         }
       : {
@@ -53,19 +56,35 @@ export async function requestAccount(
           includeCounterfactualInfo: true,
         };
 
-  const { counterfactualInfo, accountAddress } = await client.request({
-    method: "wallet_requestAccount",
-    params: [args],
-  });
+  const cachedAccount = client.internal.getAccount();
+
+  if (
+    cachedAccount &&
+    ((args.accountAddress &&
+      cachedAccount.account.address === args.accountAddress) ||
+      deepEqual(cachedAccount.requestParams, args, { strict: true }))
+  ) {
+    return cachedAccount.account;
+  }
 
-  return createAccount({
-    accountAddress: accountAddress,
-    counterfactualInfo: Value.Parse(
-      TypeSerializedInitcode,
-      counterfactualInfo!,
-    ),
+  const { accountAddress, counterfactualInfo, delegation } =
+    await client.request({
+      method: "wallet_requestAccount",
+      params: [args],
+    });
+
+  const account = await createAccount({
+    accountAddress,
+    counterfactualInfo: counterfactualInfo
+      ? Value.Parse(SerializedInitcode, counterfactualInfo)
+      : undefined,
+    delegation,
     chain: client.chain,
     transport: custom(client.transport),
     signer,
   });
+
+  client.internal.setAccount({ account, requestParams: args });
+
+  return account;
 }

package/src/client/actions/sendPreparedCalls.ts

@@ -1,23 +1,60 @@
-import type { Static, StaticDecode } from "@sinclair/typebox";
+import type { Static } from "@sinclair/typebox";
 import { toHex } from "viem";
-import type { wallet_sendPreparedCalls } from "../../rpc/request";
-import type { InnerWalletApiClient } from "../../types";
+import type { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
+import type { InnerWalletApiClient, WithoutChainId } from "../../types.ts";
 
-export type SendPreparedCallsParams = Omit<
-  StaticDecode<typeof wallet_sendPreparedCalls>["Request"]["params"][0],
-  "chainId"
+export type SendPreparedCallsParams = WithoutChainId<
+  Static<
+    (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
+  >[0]
 >;
 
 export type SendPreparedCallsResult = Static<
   typeof wallet_sendPreparedCalls
 >["ReturnType"];
 
+/**
+ * Sends prepared calls by submitting a signed user operation.
+ * This method is used after signing the signature request returned from prepareCalls.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SendPreparedCallsParams} params - Parameters for sending prepared calls
+ * @returns {Promise<SendPreparedCallsResult>} A Promise that resolves to the result containing the prepared call IDs
+ *
+ * @example
+ * // First prepare the calls
+ * const preparedCalls = await client.prepareCalls({
+ *   calls: [{
+ *     to: "0x1234...",
+ *     data: "0xabcdef...",
+ *     value: "0x0"
+ *   }],
+ *   capabilities: {
+ *     paymasterService: { policyId: "your-policy-id" }
+ *   }
+ * });
+ *
+ * // Then sign the calls
+ * const signedCalls = await client.signPreparedCalls(preparedCalls);
+ *
+ * // Then send the prepared calls with the signature
+ * const result = await client.sendPreparedCalls({
+ *   signedCalls,
+ * });
+ */
 export async function sendPreparedCalls(
   client: InnerWalletApiClient,
   params: SendPreparedCallsParams,
 ): Promise<SendPreparedCallsResult> {
   return client.request({
     method: "wallet_sendPreparedCalls",
-    params: [{ ...params, chainId: toHex(client.chain.id) }],
+    params: [
+      params.type === "array"
+        ? params
+        : {
+            ...params,
+            chainId: toHex(client.chain.id),
+          },
+    ],
   });
 }

package/src/client/actions/signMessage.ts

@@ -1,32 +1,37 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
-import {
-  type Address,
-  type Hex,
-  type JsonRpcAccount,
-  type SignableMessage,
-} from "viem";
-import type { InnerWalletApiClient } from "../../types";
+import { type SmartAccountSigner } from "@aa-sdk/core";
+import { type Address, type Hex, type SignableMessage } from "viem";
+import type { InnerWalletApiClient } from "../../types.ts";
 import { requestAccount } from "./requestAccount.js";
 
-export type SignMessageParams = SignableMessage;
+export type SignMessageParams = { message: SignableMessage; account?: Address };
 
 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>;
-
+/**
+ * Signs a message using the smart account.
+ * This method requests the account associated with the signer and uses it to sign the message.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer of the smart account
+ * @param {SignableMessage} message - The message to sign
+ * @returns {Promise<SignMessageResult>} A Promise that resolves to the signed message as a hex string
+ *
+ * @example
+ * // Sign a simple text message
+ * const signature = await client.signMessage("Hello, world!");
+ *
+ * @example
+ * // Sign a raw hex message
+ * const signature = await client.signMessage({ raw: "0x48656c6c6f2c20776f726c6421" });
+ */
 export async function signMessage(
   client: InnerWalletApiClient,
   signer: SmartAccountSigner,
   params: SignMessageParams,
 ): Promise<SignMessageResult> {
-  const account = await requestAccount(client, signer);
-  return account.signMessageWith6492({ message: params });
+  const account = await requestAccount(client, signer, {
+    accountAddress: params.account ?? client.account?.address,
+  });
+
+  return account.signMessageWith6492({ message: params.message });
 }

package/src/client/actions/signPreparedCalls.ts

@@ -0,0 +1,67 @@
+import type { PrepareCallsResult } from "./prepareCalls.ts";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import { signSignatureRequest } from "./signSignatureRequest.js";
+import type { Static } from "@sinclair/typebox";
+import { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
+import {
+  type PreparedCall_Authorization,
+  type PreparedCall_UserOpV060,
+  type PreparedCall_UserOpV070,
+} from "@alchemy/wallet-api-types";
+
+export type SignPreparedCallsParams = PrepareCallsResult;
+
+export type SignPreparedCallsResult = Static<
+  (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
+>[0];
+
+/**
+ * Signs prepared calls using the provided signer.
+ *
+ * @param {SmartAccountSigner} signer - The signer to use
+ * @param {SignPreparedCallsParams} params - The prepared calls with signature requests
+ * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls
+ **/
+export async function signPreparedCalls(
+  signer: SmartAccountSigner,
+  params: SignPreparedCallsParams,
+): Promise<SignPreparedCallsResult> {
+  const signAuthorizationCall = async (call: PreparedCall_Authorization) => {
+    const { signatureRequest: _signatureRequest, ...rest } = call;
+    const signature = await signSignatureRequest(signer, {
+      type: "eip7702Auth",
+      data: {
+        ...rest.data,
+        chainId: call.chainId,
+      },
+    });
+    return {
+      ...rest,
+      signature,
+    };
+  };
+
+  const signUserOperationCall = async (
+    call: PreparedCall_UserOpV060 | PreparedCall_UserOpV070,
+  ) => {
+    const { signatureRequest, ...rest } = call;
+    const signature = await signSignatureRequest(signer, signatureRequest);
+    return {
+      ...rest,
+      signature,
+    };
+  };
+
+  return params.type === "array"
+    ? {
+        type: "array" as const,
+        data: await Promise.all(
+          params.data.map((call) =>
+            call.type === "authorization"
+              ? signAuthorizationCall(call)
+              : signUserOperationCall(call),
+          ),
+        ),
+      }
+    : signUserOperationCall(params);
+}

package/src/client/actions/signSignatureRequest.ts

@@ -1,34 +1,98 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import type { Static } from "@sinclair/typebox";
-import { type Hex } from "viem";
-import { TypeSignatureRequest } from "../../schemas.js";
+import { type Hex, hexToNumber, serializeSignature } from "viem";
 import { assertNever } from "../../utils.js";
+import {
+  type PersonalSignSignatureRequest,
+  type TypedDataSignatureRequest,
+  type AuthorizationSignatureRequest,
+  type Eip7702UnsignedAuth,
+} from "@alchemy/wallet-api-types";
+import { vToYParity } from "ox/Signature";
+import type { WithoutRawPayload } from "../../types.ts";
 
-export type SignSignatureRequestParams = Static<typeof TypeSignatureRequest>;
+export type SignSignatureRequestParams = WithoutRawPayload<
+  | PersonalSignSignatureRequest
+  | TypedDataSignatureRequest
+  | (AuthorizationSignatureRequest & {
+      data: Eip7702UnsignedAuth;
+    })
+>;
 
 export type SignSignatureRequestResult = {
-  type: "ecdsa";
-  signature: Hex;
+  type: "secp256k1";
+  data: Hex;
 };
 
-export function signSignatureRequest(
-  signer: SmartAccountSigner,
-  params: SignSignatureRequestParams,
-): Promise<SignSignatureRequestResult>;
+/**
+ * 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: 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");
+  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: "ecdsa",
-    signature,
-  };
+      return {
+        type: "secp256k1",
+        data: serializeSignature({
+          r,
+          s,
+          yParity: yParity ?? vToYParity(Number(v)),
+        }),
+      };
+    }
+    default:
+      return assertNever(params, `Unexpected signature request type.`);
+  }
 }

package/src/client/actions/signTypedData.ts

@@ -1,32 +1,53 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import {
-  type Address,
-  type Hex,
-  type JsonRpcAccount,
-  type TypedDataDefinition,
-} from "viem";
-import type { InnerWalletApiClient } from "../../types";
+import { type Address, type Hex, type TypedDataDefinition } from "viem";
+import type { InnerWalletApiClient } from "../../types.ts";
 import { requestAccount } from "./requestAccount.js";
 
-export type SignTypedDataParams = TypedDataDefinition;
+export type SignTypedDataParams = TypedDataDefinition & {
+  account?: Address;
+};
 
 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>;
-
+/**
+ * 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: InnerWalletApiClient,
   signer: SmartAccountSigner,
   params: SignTypedDataParams,
 ): Promise<SignTypedDataResult> {
-  const account = await requestAccount(client, signer);
+  const account = await requestAccount(client, signer, {
+    accountAddress: params.account ?? client.account?.address,
+  });
+
   return account.signTypedDataWith6492(params);
 }