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

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

@@ -0,0 +1,28 @@
+import { toHex } from "viem";
+import { AccountNotFoundError } from "@aa-sdk/core";
+/**
+ * Prepares a signature request for signing messages or transactions.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {PrepareSignParams} params - Parameters for preparing the signature request
+ * @returns {Promise<PrepareSignResult>} A Promise that resolves to the prepare sign result containing a signature request
+ *
+ * @example
+ * // Prepare a message to be signed
+ * const result = await client.prepareSign({
+ *    from: "0x1234...",
+ *    type: "personal_sign",
+ *    data: "Hello, world!",
+ * });
+ */
+export async function prepareSign(client, params) {
+    const from = params.from ?? client.account?.address;
+    if (!from) {
+        throw new AccountNotFoundError();
+    }
+    return client.request({
+        method: "wallet_prepareSign",
+        params: [{ ...params, from, chainId: toHex(client.chain.id) }],
+    });
+}
+//# sourceMappingURL=prepareSign.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepareSign.js","sourceRoot":"","sources":["../../../../src/client/actions/prepareSign.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAkC,MAAM,MAAM,CAAC;AAK7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AASpD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAG/B,MAA4B,EAC5B,MAAmC;IAEnC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IACpD,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IAED,OAAO,MAAM,CAAC,OAAO,CAAC;QACpB,MAAM,EAAE,oBAAoB;QAC5B,MAAM,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;KAC/D,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { InnerWalletApiClient } from \"../../types.ts\";\nimport { toHex, type Address, type IsUndefined } from \"viem\";\nimport type {\n  PrepareSignParams as IsomorphicPrepareSignParams,\n  PrepareSignResult as IsomorphicPrepareSignResult,\n} from \"../../isomorphic/actions/prepareSign.ts\";\nimport { AccountNotFoundError } from \"@aa-sdk/core\";\n\nexport type PrepareSignParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Omit<IsomorphicPrepareSignParams, \"from\" | \"chainId\"> &\n  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });\n\nexport type PrepareSignResult = IsomorphicPrepareSignResult;\n\n/**\n * Prepares a signature request for signing messages or transactions.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {PrepareSignParams} params - Parameters for preparing the signature request\n * @returns {Promise<PrepareSignResult>} A Promise that resolves to the prepare sign result containing a signature request\n *\n * @example\n * // Prepare a message to be signed\n * const result = await client.prepareSign({\n *    from: \"0x1234...\",\n *    type: \"personal_sign\",\n *    data: \"Hello, world!\",\n * });\n */\nexport async function prepareSign<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  params: PrepareSignParams<TAccount>,\n): Promise<PrepareSignResult> {\n  const from = params.from ?? client.account?.address;\n  if (!from) {\n    throw new AccountNotFoundError();\n  }\n\n  return client.request({\n    method: \"wallet_prepareSign\",\n    params: [{ ...params, from, chainId: toHex(client.chain.id) }],\n  });\n}\n"]}

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

@@ -1,11 +1,29 @@
-import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
+import { type SmartAccountSigner, type SmartContractAccount } from "@aa-sdk/core";
 import type { Static } from "@sinclair/typebox";
 import type { Address } from "abitype";
-import { type IsUndefined, type JsonRpcAccount } from "viem";
-import type { wallet_requestAccount } from "../../rpc/request.js";
+import type { wallet_requestAccount } from "@alchemy/wallet-api-types/rpc";
 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], {
+export type RequestAccountParams = Omit<Extract<Static<typeof wallet_requestAccount>["Request"]["params"][0], {
     signerAddress: Address;
-}>, "signerAddress" | "includeCounterfactualInfo"> : never;
+}>, "signerAddress" | "includeCounterfactualInfo"> & {
+    accountAddress?: Address;
+};
 export type RequestAccountResult = SmartContractAccount;
-export declare 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 declare function requestAccount(client: InnerWalletApiClient, signer: SmartAccountSigner, params?: RequestAccountParams): Promise<RequestAccountResult>;

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

@@ -1,11 +1,30 @@
+import {} from "@aa-sdk/core";
 import { Value } from "@sinclair/typebox/value";
+import deepEqual from "deep-equal";
 import { custom } from "viem";
 import { createAccount } from "../../isomorphic/utils/createAccount.js";
-import { TypeSerializedInitcode } from "../../schemas.js";
+import { TypeSerializedInitcode } from "@alchemy/wallet-api-types";
+/**
+ * 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, signer, params) {
-    const args = client.account && !params
+    const args = (client.account && !params) || params?.accountAddress
         ? {
-            accountAddress: client.account.address,
+            accountAddress: params?.accountAddress ?? client.account.address,
             includeCounterfactualInfo: true,
         }
         : {
@@ -13,16 +32,28 @@ export async function requestAccount(client, signer, params) {
             signerAddress: await signer.getAddress(),
             includeCounterfactualInfo: true,
         };
-    const { counterfactualInfo, accountAddress } = await client.request({
+    const cachedAccount = client.internal.getAccount();
+    if (cachedAccount &&
+        ((args.accountAddress &&
+            cachedAccount.account.address === args.accountAddress) ||
+            deepEqual(cachedAccount.requestParams, args, { strict: true }))) {
+        return cachedAccount.account;
+    }
+    const { accountAddress, counterfactualInfo, delegation } = await client.request({
         method: "wallet_requestAccount",
         params: [args],
     });
-    return createAccount({
-        accountAddress: accountAddress,
-        counterfactualInfo: Value.Parse(TypeSerializedInitcode, counterfactualInfo),
+    const account = await createAccount({
+        accountAddress,
+        counterfactualInfo: counterfactualInfo
+            ? Value.Parse(TypeSerializedInitcode, counterfactualInfo)
+            : undefined,
+        delegation,
         chain: client.chain,
         transport: custom(client.transport),
         signer,
     });
+    client.internal.setAccount({ account, requestParams: args });
+    return account;
 }
 //# sourceMappingURL=requestAccount.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"requestAccount.js","sourceRoot":"","sources":["../../../../src/client/actions/requestAccount.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAyC,MAAM,MAAM,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAExE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AA+B1D,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAA4B,EAC5B,MAA0B,EAC1B,MAA6B;IAE7B,MAAM,IAAI,GACR,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM;QACvB,CAAC,CAAC;YACE,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO;YACtC,yBAAyB,EAAE,IAAI;SAChC;QACH,CAAC,CAAC;YACE,GAAG,MAAM;YACT,aAAa,EAAE,MAAM,MAAM,CAAC,UAAU,EAAE;YACxC,yBAAyB,EAAE,IAAI;SAChC,CAAC;IAER,MAAM,EAAE,kBAAkB,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAClE,MAAM,EAAE,uBAAuB;QAC/B,MAAM,EAAE,CAAC,IAAI,CAAC;KACf,CAAC,CAAC;IAEH,OAAO,aAAa,CAAC;QACnB,cAAc,EAAE,cAAc;QAC9B,kBAAkB,EAAE,KAAK,CAAC,KAAK,CAC7B,sBAAsB,EACtB,kBAAmB,CACpB;QACD,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC;QACnC,MAAM;KACP,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { SmartAccountSigner, SmartContractAccount } from \"@aa-sdk/core\";\nimport type { Static } from \"@sinclair/typebox\";\nimport { Value } from \"@sinclair/typebox/value\";\nimport type { Address } from \"abitype\";\nimport { custom, type IsUndefined, type JsonRpcAccount } from \"viem\";\nimport { createAccount } from \"../../isomorphic/utils/createAccount.js\";\nimport type { wallet_requestAccount } from \"../../rpc/request.js\";\nimport { TypeSerializedInitcode } from \"../../schemas.js\";\nimport type { InnerWalletApiClient } from \"../../types.js\";\n\nexport type RequestAccountParams<\n  TAccount extends JsonRpcAccount<Address> | undefined =\n    | JsonRpcAccount<Address>\n    | undefined,\n> =\n  IsUndefined<TAccount> extends true\n    ? Omit<\n        Extract<\n          Static<typeof wallet_requestAccount>[\"Request\"][\"params\"][0],\n          { signerAddress: Address }\n        >,\n        \"signerAddress\" | \"includeCounterfactualInfo\"\n      >\n    : never;\n\n// TODO: this could be more specific potentially :shrug:\nexport type RequestAccountResult = SmartContractAccount;\n\nexport function requestAccount<\n  TAccount extends JsonRpcAccount<Address> | undefined =\n    | JsonRpcAccount<Address>\n    | undefined,\n>(\n  client: InnerWalletApiClient<TAccount>,\n  signer: SmartAccountSigner,\n  params?: RequestAccountParams<TAccount>,\n): Promise<RequestAccountResult>;\n\nexport async function requestAccount(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params?: RequestAccountParams,\n): Promise<RequestAccountResult> {\n  const args =\n    client.account && !params\n      ? {\n          accountAddress: client.account.address,\n          includeCounterfactualInfo: true,\n        }\n      : {\n          ...params,\n          signerAddress: await signer.getAddress(),\n          includeCounterfactualInfo: true,\n        };\n\n  const { counterfactualInfo, accountAddress } = await client.request({\n    method: \"wallet_requestAccount\",\n    params: [args],\n  });\n\n  return createAccount({\n    accountAddress: accountAddress,\n    counterfactualInfo: Value.Parse(\n      TypeSerializedInitcode,\n      counterfactualInfo!,\n    ),\n    chain: client.chain,\n    transport: custom(client.transport),\n    signer,\n  });\n}\n"]}
+{"version":3,"file":"requestAccount.js","sourceRoot":"","sources":["../../../../src/client/actions/requestAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,OAAO,SAAS,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAExE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAanE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAA4B,EAC5B,MAA0B,EAC1B,MAA6B;IAE7B,MAAM,IAAI,GACR,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,EAAE,cAAc;QACnD,CAAC,CAAC;YACE,cAAc,EAAE,MAAM,EAAE,cAAc,IAAI,MAAM,CAAC,OAAQ,CAAC,OAAO;YACjE,yBAAyB,EAAE,IAAI;SAChC;QACH,CAAC,CAAC;YACE,GAAG,MAAM;YACT,aAAa,EAAE,MAAM,MAAM,CAAC,UAAU,EAAE;YACxC,yBAAyB,EAAE,IAAI;SAChC,CAAC;IAER,MAAM,aAAa,GAAG,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;IAEnD,IACE,aAAa;QACb,CAAC,CAAC,IAAI,CAAC,cAAc;YACnB,aAAa,CAAC,OAAO,CAAC,OAAO,KAAK,IAAI,CAAC,cAAc,CAAC;YACtD,SAAS,CAAC,aAAa,CAAC,aAAa,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EACjE,CAAC;QACD,OAAO,aAAa,CAAC,OAAO,CAAC;IAC/B,CAAC;IAED,MAAM,EAAE,cAAc,EAAE,kBAAkB,EAAE,UAAU,EAAE,GACtD,MAAM,MAAM,CAAC,OAAO,CAAC;QACnB,MAAM,EAAE,uBAAuB;QAC/B,MAAM,EAAE,CAAC,IAAI,CAAC;KACf,CAAC,CAAC;IAEL,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC;QAClC,cAAc;QACd,kBAAkB,EAAE,kBAAkB;YACpC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,sBAAsB,EAAE,kBAAkB,CAAC;YACzD,CAAC,CAAC,SAAS;QACb,UAAU;QACV,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC;QACnC,MAAM;KACP,CAAC,CAAC;IAEH,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;IAE7D,OAAO,OAAO,CAAC;AACjB,CAAC","sourcesContent":["import {\n  type SmartAccountSigner,\n  type SmartContractAccount,\n} from \"@aa-sdk/core\";\nimport type { Static } from \"@sinclair/typebox\";\nimport { Value } from \"@sinclair/typebox/value\";\nimport type { Address } from \"abitype\";\nimport deepEqual from \"deep-equal\";\nimport { custom } from \"viem\";\nimport { createAccount } from \"../../isomorphic/utils/createAccount.js\";\nimport type { wallet_requestAccount } from \"@alchemy/wallet-api-types/rpc\";\nimport { TypeSerializedInitcode } from \"@alchemy/wallet-api-types\";\nimport type { InnerWalletApiClient } from \"../../types.js\";\n\nexport type RequestAccountParams = Omit<\n  Extract<\n    Static<typeof wallet_requestAccount>[\"Request\"][\"params\"][0],\n    { signerAddress: Address }\n  >,\n  \"signerAddress\" | \"includeCounterfactualInfo\"\n> & { accountAddress?: Address };\n\nexport type RequestAccountResult = SmartContractAccount;\n\n/**\n * Requests an account for the provided signer using the wallet API client.\n * If an account already exists for the signer, it will always return that account unless a new ID is specified.\n * If an account already exists, the creationHint will be ignored.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {SmartAccountSigner} signer - The signer that will be associated with the account\n * @param {RequestAccountParams} [params] - Optional parameters for requesting a specific account\n * @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\n * @param {object} [params.creationHint] - Optional hints to guide account creation. These are ignored if an account already exists\n * @returns {Promise<RequestAccountResult>} A Promise that resolves to a SmartContractAccount instance\n *\n * @example\n * // Request an account with default parameters using a local signer\n * const signer = LocalAccountSigner.privateKeyToAccountSigner(\"0x...\");\n * const account = await client.requestAccount(signer);\n */\nexport async function requestAccount(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params?: RequestAccountParams,\n): Promise<RequestAccountResult> {\n  const args =\n    (client.account && !params) || params?.accountAddress\n      ? {\n          accountAddress: params?.accountAddress ?? client.account!.address,\n          includeCounterfactualInfo: true,\n        }\n      : {\n          ...params,\n          signerAddress: await signer.getAddress(),\n          includeCounterfactualInfo: true,\n        };\n\n  const cachedAccount = client.internal.getAccount();\n\n  if (\n    cachedAccount &&\n    ((args.accountAddress &&\n      cachedAccount.account.address === args.accountAddress) ||\n      deepEqual(cachedAccount.requestParams, args, { strict: true }))\n  ) {\n    return cachedAccount.account;\n  }\n\n  const { accountAddress, counterfactualInfo, delegation } =\n    await client.request({\n      method: \"wallet_requestAccount\",\n      params: [args],\n    });\n\n  const account = await createAccount({\n    accountAddress,\n    counterfactualInfo: counterfactualInfo\n      ? Value.Parse(TypeSerializedInitcode, counterfactualInfo)\n      : undefined,\n    delegation,\n    chain: client.chain,\n    transport: custom(client.transport),\n    signer,\n  });\n\n  client.internal.setAccount({ account, requestParams: args });\n\n  return account;\n}\n"]}

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

@@ -1,6 +1,35 @@
-import type { Static, StaticDecode } from "@sinclair/typebox";
-import type { wallet_sendPreparedCalls } from "../../rpc/request";
-import type { InnerWalletApiClient } from "../../types";
-export type SendPreparedCallsParams = Omit<StaticDecode<typeof wallet_sendPreparedCalls>["Request"]["params"][0], "chainId">;
+import type { Static } from "@sinclair/typebox";
+import type { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
+import type { InnerWalletApiClient, WithoutChainId } from "../../types.ts";
+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 declare function sendPreparedCalls(client: InnerWalletApiClient, params: SendPreparedCallsParams): Promise<SendPreparedCallsResult>;

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

@@ -1,8 +1,44 @@
 import { toHex } from "viem";
+/**
+ * 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, params) {
     return client.request({
         method: "wallet_sendPreparedCalls",
-        params: [{ ...params, chainId: toHex(client.chain.id) }],
+        params: [
+            params.type === "array"
+                ? params
+                : {
+                    ...params,
+                    chainId: toHex(client.chain.id),
+                },
+        ],
     });
 }
 //# sourceMappingURL=sendPreparedCalls.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"sendPreparedCalls.js","sourceRoot":"","sources":["../../../../src/client/actions/sendPreparedCalls.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAa7B,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,MAA4B,EAC5B,MAA+B;IAE/B,OAAO,MAAM,CAAC,OAAO,CAAC;QACpB,MAAM,EAAE,0BAA0B;QAClC,MAAM,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;KACzD,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { Static, StaticDecode } from \"@sinclair/typebox\";\nimport { toHex } from \"viem\";\nimport type { wallet_sendPreparedCalls } from \"../../rpc/request\";\nimport type { InnerWalletApiClient } from \"../../types\";\n\nexport type SendPreparedCallsParams = Omit<\n  StaticDecode<typeof wallet_sendPreparedCalls>[\"Request\"][\"params\"][0],\n  \"chainId\"\n>;\n\nexport type SendPreparedCallsResult = Static<\n  typeof wallet_sendPreparedCalls\n>[\"ReturnType\"];\n\nexport async function sendPreparedCalls(\n  client: InnerWalletApiClient,\n  params: SendPreparedCallsParams,\n): Promise<SendPreparedCallsResult> {\n  return client.request({\n    method: \"wallet_sendPreparedCalls\",\n    params: [{ ...params, chainId: toHex(client.chain.id) }],\n  });\n}\n"]}
+{"version":3,"file":"sendPreparedCalls.js","sourceRoot":"","sources":["../../../../src/client/actions/sendPreparedCalls.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAc7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,MAA4B,EAC5B,MAA+B;IAE/B,OAAO,MAAM,CAAC,OAAO,CAAC;QACpB,MAAM,EAAE,0BAA0B;QAClC,MAAM,EAAE;YACN,MAAM,CAAC,IAAI,KAAK,OAAO;gBACrB,CAAC,CAAC,MAAM;gBACR,CAAC,CAAC;oBACE,GAAG,MAAM;oBACT,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;iBAChC;SACN;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { Static } from \"@sinclair/typebox\";\nimport { toHex } from \"viem\";\nimport type { wallet_sendPreparedCalls } from \"@alchemy/wallet-api-types/rpc\";\nimport type { InnerWalletApiClient, WithoutChainId } from \"../../types.ts\";\n\nexport type SendPreparedCallsParams = WithoutChainId<\n  Static<\n    (typeof wallet_sendPreparedCalls)[\"properties\"][\"Request\"][\"properties\"][\"params\"]\n  >[0]\n>;\n\nexport type SendPreparedCallsResult = Static<\n  typeof wallet_sendPreparedCalls\n>[\"ReturnType\"];\n\n/**\n * Sends prepared calls by submitting a signed user operation.\n * This method is used after signing the signature request returned from prepareCalls.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {SendPreparedCallsParams} params - Parameters for sending prepared calls\n * @returns {Promise<SendPreparedCallsResult>} A Promise that resolves to the result containing the prepared call IDs\n *\n * @example\n * // First prepare the calls\n * const preparedCalls = await client.prepareCalls({\n *   calls: [{\n *     to: \"0x1234...\",\n *     data: \"0xabcdef...\",\n *     value: \"0x0\"\n *   }],\n *   capabilities: {\n *     paymasterService: { policyId: \"your-policy-id\" }\n *   }\n * });\n *\n * // Then sign the calls\n * const signedCalls = await client.signPreparedCalls(preparedCalls);\n *\n * // Then send the prepared calls with the signature\n * const result = await client.sendPreparedCalls({\n *   signedCalls,\n * });\n */\nexport async function sendPreparedCalls(\n  client: InnerWalletApiClient,\n  params: SendPreparedCallsParams,\n): Promise<SendPreparedCallsResult> {\n  return client.request({\n    method: \"wallet_sendPreparedCalls\",\n    params: [\n      params.type === \"array\"\n        ? params\n        : {\n            ...params,\n            chainId: toHex(client.chain.id),\n          },\n    ],\n  });\n}\n"]}

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

@@ -1,6 +1,26 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
-import { type Address, type Hex, type JsonRpcAccount, type SignableMessage } from "viem";
-import type { InnerWalletApiClient } from "../../types";
-export type SignMessageParams = SignableMessage;
+import { type SmartAccountSigner } from "@aa-sdk/core";
+import { type Address, type Hex, type SignableMessage } from "viem";
+import type { InnerWalletApiClient } from "../../types.ts";
+export type SignMessageParams = {
+    message: SignableMessage;
+    account?: Address;
+};
 export type SignMessageResult = Hex;
-export declare 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 declare function signMessage(client: InnerWalletApiClient, signer: SmartAccountSigner, params: SignMessageParams): Promise<SignMessageResult>;

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

@@ -1,7 +1,27 @@
+import {} from "@aa-sdk/core";
 import {} from "viem";
 import { requestAccount } from "./requestAccount.js";
+/**
+ * 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, signer, params) {
-    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 });
 }
 //# sourceMappingURL=signMessage.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"signMessage.js","sourceRoot":"","sources":["../../../../src/client/actions/signMessage.ts"],"names":[],"mappings":"AACA,OAAO,EAKN,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAgBrD,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,MAA4B,EAC5B,MAA0B,EAC1B,MAAyB;IAEzB,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,OAAO,OAAO,CAAC,mBAAmB,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;AAC1D,CAAC","sourcesContent":["import type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport {\n  type Address,\n  type Hex,\n  type JsonRpcAccount,\n  type SignableMessage,\n} from \"viem\";\nimport type { InnerWalletApiClient } from \"../../types\";\nimport { requestAccount } from \"./requestAccount.js\";\n\nexport type SignMessageParams = SignableMessage;\n\nexport type SignMessageResult = Hex;\n\nexport async function signMessage<\n  TAccount extends JsonRpcAccount<Address> | undefined =\n    | JsonRpcAccount<Address>\n    | undefined,\n>(\n  client: InnerWalletApiClient<TAccount>,\n  signer: SmartAccountSigner,\n  params: SignMessageParams,\n): Promise<SignMessageResult>;\n\nexport async function signMessage(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params: SignMessageParams,\n): Promise<SignMessageResult> {\n  const account = await requestAccount(client, signer);\n  return account.signMessageWith6492({ message: params });\n}\n"]}
+{"version":3,"file":"signMessage.js","sourceRoot":"","sources":["../../../../src/client/actions/signMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,MAAM,cAAc,CAAC;AACvD,OAAO,EAAgD,MAAM,MAAM,CAAC;AAEpE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAMrD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,MAA4B,EAC5B,MAA0B,EAC1B,MAAyB;IAEzB,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,mBAAmB,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;AAClE,CAAC","sourcesContent":["import { type SmartAccountSigner } from \"@aa-sdk/core\";\nimport { type Address, type Hex, type SignableMessage } from \"viem\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\nimport { requestAccount } from \"./requestAccount.js\";\n\nexport type SignMessageParams = { message: SignableMessage; account?: Address };\n\nexport type SignMessageResult = Hex;\n\n/**\n * Signs a message using the smart account.\n * This method requests the account associated with the signer and uses it to sign the message.\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 {SignableMessage} message - The message to sign\n * @returns {Promise<SignMessageResult>} A Promise that resolves to the signed message as a hex string\n *\n * @example\n * // Sign a simple text message\n * const signature = await client.signMessage(\"Hello, world!\");\n *\n * @example\n * // Sign a raw hex message\n * const signature = await client.signMessage({ raw: \"0x48656c6c6f2c20776f726c6421\" });\n */\nexport async function signMessage(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params: SignMessageParams,\n): Promise<SignMessageResult> {\n  const account = await requestAccount(client, signer, {\n    accountAddress: params.account ?? client.account?.address,\n  });\n\n  return account.signMessageWith6492({ message: params.message });\n}\n"]}

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

@@ -0,0 +1,14 @@
+import type { PrepareCallsResult } from "./prepareCalls.ts";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { Static } from "@sinclair/typebox";
+import { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
+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 declare function signPreparedCalls(signer: SmartAccountSigner, params: SignPreparedCallsParams): Promise<SignPreparedCallsResult>;

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

@@ -0,0 +1,43 @@
+import { signSignatureRequest } from "./signSignatureRequest.js";
+import { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
+import {} from "@alchemy/wallet-api-types";
+/**
+ * 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, params) {
+    const signAuthorizationCall = async (call) => {
+        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) => {
+        const { signatureRequest, ...rest } = call;
+        const signature = await signSignatureRequest(signer, signatureRequest);
+        return {
+            ...rest,
+            signature,
+        };
+    };
+    return params.type === "array"
+        ? {
+            type: "array",
+            data: await Promise.all(params.data.map((call) => call.type === "authorization"
+                ? signAuthorizationCall(call)
+                : signUserOperationCall(call))),
+        }
+        : signUserOperationCall(params);
+}
+//# sourceMappingURL=signPreparedCalls.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signPreparedCalls.js","sourceRoot":"","sources":["../../../../src/client/actions/signPreparedCalls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAIN,MAAM,2BAA2B,CAAC;AAQnC;;;;;;IAMI;AACJ,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,MAA0B,EAC1B,MAA+B;IAE/B,MAAM,qBAAqB,GAAG,KAAK,EAAE,IAAgC,EAAE,EAAE;QACvE,MAAM,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;QAC9D,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE;YACnD,IAAI,EAAE,aAAa;YACnB,IAAI,EAAE;gBACJ,GAAG,IAAI,CAAC,IAAI;gBACZ,OAAO,EAAE,IAAI,CAAC,OAAO;aACtB;SACF,CAAC,CAAC;QACH,OAAO;YACL,GAAG,IAAI;YACP,SAAS;SACV,CAAC;IACJ,CAAC,CAAC;IAEF,MAAM,qBAAqB,GAAG,KAAK,EACjC,IAAuD,EACvD,EAAE;QACF,MAAM,EAAE,gBAAgB,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;QAC3C,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACvE,OAAO;YACL,GAAG,IAAI;YACP,SAAS;SACV,CAAC;IACJ,CAAC,CAAC;IAEF,OAAO,MAAM,CAAC,IAAI,KAAK,OAAO;QAC5B,CAAC,CAAC;YACE,IAAI,EAAE,OAAgB;YACtB,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CACrB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACvB,IAAI,CAAC,IAAI,KAAK,eAAe;gBAC3B,CAAC,CAAC,qBAAqB,CAAC,IAAI,CAAC;gBAC7B,CAAC,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAChC,CACF;SACF;QACH,CAAC,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;AACpC,CAAC","sourcesContent":["import type { PrepareCallsResult } from \"./prepareCalls.ts\";\nimport type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport type { Static } from \"@sinclair/typebox\";\nimport { wallet_sendPreparedCalls } from \"@alchemy/wallet-api-types/rpc\";\nimport {\n  type PreparedCall_Authorization,\n  type PreparedCall_UserOpV060,\n  type PreparedCall_UserOpV070,\n} from \"@alchemy/wallet-api-types\";\n\nexport type SignPreparedCallsParams = PrepareCallsResult;\n\nexport type SignPreparedCallsResult = Static<\n  (typeof wallet_sendPreparedCalls)[\"properties\"][\"Request\"][\"properties\"][\"params\"]\n>[0];\n\n/**\n * Signs prepared calls using the provided signer.\n *\n * @param {SmartAccountSigner} signer - The signer to use\n * @param {SignPreparedCallsParams} params - The prepared calls with signature requests\n * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls\n **/\nexport async function signPreparedCalls(\n  signer: SmartAccountSigner,\n  params: SignPreparedCallsParams,\n): Promise<SignPreparedCallsResult> {\n  const signAuthorizationCall = async (call: PreparedCall_Authorization) => {\n    const { signatureRequest: _signatureRequest, ...rest } = call;\n    const signature = await signSignatureRequest(signer, {\n      type: \"eip7702Auth\",\n      data: {\n        ...rest.data,\n        chainId: call.chainId,\n      },\n    });\n    return {\n      ...rest,\n      signature,\n    };\n  };\n\n  const signUserOperationCall = async (\n    call: PreparedCall_UserOpV060 | PreparedCall_UserOpV070,\n  ) => {\n    const { signatureRequest, ...rest } = call;\n    const signature = await signSignatureRequest(signer, signatureRequest);\n    return {\n      ...rest,\n      signature,\n    };\n  };\n\n  return params.type === \"array\"\n    ? {\n        type: \"array\" as const,\n        data: await Promise.all(\n          params.data.map((call) =>\n            call.type === \"authorization\"\n              ? signAuthorizationCall(call)\n              : signUserOperationCall(call),\n          ),\n        ),\n      }\n    : signUserOperationCall(params);\n}\n"]}

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

@@ -1,10 +1,44 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import type { Static } from "@sinclair/typebox";
 import { type Hex } from "viem";
-import { TypeSignatureRequest } from "../../schemas.js";
-export type SignSignatureRequestParams = Static<typeof TypeSignatureRequest>;
+import { type TypePersonalSignSignatureRequest, type TypeTypedDataSignatureRequest, type TypeAuthorizationSignatureRequest, type TypeEip7702UnsignedAuth } from "@alchemy/wallet-api-types";
+import type { WithoutRawPayload } from "../../types.ts";
+export type SignSignatureRequestParams = WithoutRawPayload<TypePersonalSignSignatureRequest | TypeTypedDataSignatureRequest | (TypeAuthorizationSignatureRequest & {
+    data: TypeEip7702UnsignedAuth;
+})>;
 export type SignSignatureRequestResult = {
-    type: "ecdsa";
-    signature: Hex;
+    type: "secp256k1";
+    data: Hex;
 };
+/**
+ * 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 declare function signSignatureRequest(signer: SmartAccountSigner, params: SignSignatureRequestParams): Promise<SignSignatureRequestResult>;

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

@@ -1,15 +1,73 @@
-import {} from "viem";
-import { TypeSignatureRequest } from "../../schemas.js";
+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,kBAAkB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAc7C,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.js\";\nimport { assertNever } from \"../../utils.js\";\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 { SmartAccountSigner } from "@aa-sdk/core";
-import { type Address, type Hex, type JsonRpcAccount, type TypedDataDefinition } from "viem";
-import type { InnerWalletApiClient } from "../../types";
-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>;