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

package/src/client/actions/signMessage.ts

@@ -1,32 +1,37 @@
-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";
+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";
-import { assertNever } from "../../utils";
+import { type Hex, hexToNumber, serializeSignature } from "viem";
+import { assertNever } from "../../utils.js";
+import {
+  type TypePersonalSignSignatureRequest,
+  type TypeTypedDataSignatureRequest,
+  type TypeAuthorizationSignatureRequest,
+  type TypeEip7702UnsignedAuth,
+} 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<
+  | TypePersonalSignSignatureRequest
+  | TypeTypedDataSignatureRequest
+  | (TypeAuthorizationSignatureRequest & {
+      data: TypeEip7702UnsignedAuth;
+    })
+>;
 
 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 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";
+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);
 }