@account-kit/wallet-client 0.1.0-alpha.8 → 4.50.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alchemy Insights, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,30 @@
+import type { Static } from "@sinclair/typebox";
+import type { wallet_formatSign } from "@alchemy/wallet-api-types/rpc";
+import type { InnerWalletApiClient, WithoutChainId } from "../../types.ts";
+import { type Address, type IsUndefined } from "viem";
+export type FormatSignParams<TAccount extends Address | undefined = Address | undefined> = Omit<WithoutChainId<Static<(typeof wallet_formatSign)["properties"]["Request"]["properties"]["params"]>[0]>, "from"> & (IsUndefined<TAccount> extends true ? {
+    from: Address;
+} : {
+    from?: never;
+});
+export type FormatSignResult = Static<typeof wallet_formatSign>["ReturnType"];
+/**
+ * Formats a signature request for signing messages or transactions.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {FormatSignParams} params - Parameters for formatting the signature
+ * @returns {Promise<FormatSignResult>} A Promise that resolves to the formatSign result containing the formatted signature.
+ *
+ * @example
+ * ```ts
+ * // Formats a signature
+ * const result = await client.formatSign({
+ *    from: "0x1234...",
+ *    signature: {
+ *      type: "ecdsa",
+ *      data: "0xabcd..."
+ *    },
+ * });
+ * ```
+ */
+export declare function formatSign<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: FormatSignParams<TAccount>): Promise<FormatSignResult>;

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

@@ -0,0 +1,32 @@
+import { toHex } from "viem";
+import { AccountNotFoundError } from "@aa-sdk/core";
+/**
+ * Formats a signature request for signing messages or transactions.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {FormatSignParams} params - Parameters for formatting the signature
+ * @returns {Promise<FormatSignResult>} A Promise that resolves to the formatSign result containing the formatted signature.
+ *
+ * @example
+ * ```ts
+ * // Formats a signature
+ * const result = await client.formatSign({
+ *    from: "0x1234...",
+ *    signature: {
+ *      type: "ecdsa",
+ *      data: "0xabcd..."
+ *    },
+ * });
+ * ```
+ */
+export async function formatSign(client, params) {
+    const from = params.from ?? client.account?.address;
+    if (!from) {
+        throw new AccountNotFoundError();
+    }
+    return client.request({
+        method: "wallet_formatSign",
+        params: [{ ...params, from, chainId: toHex(client.chain.id) }],
+    });
+}
+//# sourceMappingURL=formatSign.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatSign.js","sourceRoot":"","sources":["../../../../src/client/actions/formatSign.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAkC,MAAM,MAAM,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAgBpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAG9B,MAA4B,EAC5B,MAAkC;IAElC,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,mBAAmB;QAC3B,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 { Static } from \"@sinclair/typebox\";\nimport type { wallet_formatSign } from \"@alchemy/wallet-api-types/rpc\";\nimport type { InnerWalletApiClient, WithoutChainId } from \"../../types.ts\";\nimport { toHex, type Address, type IsUndefined } from \"viem\";\nimport { AccountNotFoundError } from \"@aa-sdk/core\";\n\nexport type FormatSignParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Omit<\n  WithoutChainId<\n    Static<\n      (typeof wallet_formatSign)[\"properties\"][\"Request\"][\"properties\"][\"params\"]\n    >[0]\n  >,\n  \"from\"\n> &\n  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });\n\nexport type FormatSignResult = Static<typeof wallet_formatSign>[\"ReturnType\"];\n\n/**\n * Formats a signature request for signing messages or transactions.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {FormatSignParams} params - Parameters for formatting the signature\n * @returns {Promise<FormatSignResult>} A Promise that resolves to the formatSign result containing the formatted signature.\n *\n * @example\n * ```ts\n * // Formats a signature\n * const result = await client.formatSign({\n *    from: \"0x1234...\",\n *    signature: {\n *      type: \"ecdsa\",\n *      data: \"0xabcd...\"\n *    },\n * });\n * ```\n */\nexport async function formatSign<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  params: FormatSignParams<TAccount>,\n): Promise<FormatSignResult> {\n  const from = params.from ?? client.account?.address;\n  if (!from) {\n    throw new AccountNotFoundError();\n  }\n\n  return client.request({\n    method: \"wallet_formatSign\",\n    params: [{ ...params, from, chainId: toHex(client.chain.id) }],\n  });\n}\n"]}

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

@@ -1,7 +1,8 @@
-import type { GetCallsStatusParams as IsomorphicGetCallsStatusParams, GetCallsStatusResponse as IsomorphicGetCallsStatusResult } from "../../isomorphic/actions/getCallsStatus.ts";
 import type { InnerWalletApiClient } from "../../types.ts";
-export type GetCallsStatusParams = IsomorphicGetCallsStatusParams;
-export type GetCallsStatusResult = IsomorphicGetCallsStatusResult;
+import type { Static } from "@sinclair/typebox";
+import { wallet_getCallsStatus } from "@alchemy/wallet-api-types/rpc";
+export type GetCallsStatusParams = Static<typeof wallet_getCallsStatus>["Request"]["params"][0];
+export type GetCallsStatusResult = Static<typeof wallet_getCallsStatus>["ReturnType"];
 /**
  * Gets the status of a prepared call by its ID.
  * This method is used to check the execution status of calls sent via sendPreparedCalls.
@@ -15,10 +16,12 @@ export type GetCallsStatusResult = IsomorphicGetCallsStatusResult;
  *   - receipts: Optional array of transaction receipts if the batch has been executed
  *
  * @example
+ * ```ts
  * // After sending prepared calls
  * const sendResult = await client.sendPreparedCalls({...});
  *
  * // Check the status of the first call ID
  * const status = await client.getCallsStatus(sendResult.preparedCallIds[0]);
+ * ```
  */
 export declare function getCallsStatus(client: InnerWalletApiClient, params: GetCallsStatusParams): Promise<GetCallsStatusResult>;

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

@@ -1,3 +1,4 @@
+import { wallet_getCallsStatus } from "@alchemy/wallet-api-types/rpc";
 /**
  * Gets the status of a prepared call by its ID.
  * This method is used to check the execution status of calls sent via sendPreparedCalls.
@@ -11,11 +12,13 @@
  *   - receipts: Optional array of transaction receipts if the batch has been executed
  *
  * @example
+ * ```ts
  * // After sending prepared calls
  * const sendResult = await client.sendPreparedCalls({...});
  *
  * // Check the status of the first call ID
  * const status = await client.getCallsStatus(sendResult.preparedCallIds[0]);
+ * ```
  */
 export async function getCallsStatus(client, params) {
     return await client.request({

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

@@ -1 +1 @@
-{"version":3,"file":"getCallsStatus.js","sourceRoot":"","sources":["../../../../src/client/actions/getCallsStatus.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAA4B,EAC5B,MAA4B;IAE5B,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC;QAC1B,MAAM,EAAE,uBAAuB;QAC/B,MAAM,EAAE,CAAC,MAAM,CAAC;KACjB,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type {\n  GetCallsStatusParams as IsomorphicGetCallsStatusParams,\n  GetCallsStatusResponse as IsomorphicGetCallsStatusResult,\n} from \"../../isomorphic/actions/getCallsStatus.ts\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\n\nexport type GetCallsStatusParams = IsomorphicGetCallsStatusParams;\n\nexport type GetCallsStatusResult = IsomorphicGetCallsStatusResult;\n\n/**\n * Gets the status of a prepared call by its ID.\n * This method is used to check the execution status of calls sent via sendPreparedCalls.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {GetCallsStatusParams} params - The ID of the prepared call to check\n * @returns {Promise<GetCallsStatusResult>} A Promise that resolves to the status information including:\n *   - id: The hex ID of the call\n *   - chainId: The chain ID in hex format\n *   - status: The current status of the batch execution\n *   - receipts: Optional array of transaction receipts if the batch has been executed\n *\n * @example\n * // After sending prepared calls\n * const sendResult = await client.sendPreparedCalls({...});\n *\n * // Check the status of the first call ID\n * const status = await client.getCallsStatus(sendResult.preparedCallIds[0]);\n */\nexport async function getCallsStatus(\n  client: InnerWalletApiClient,\n  params: GetCallsStatusParams,\n): Promise<GetCallsStatusResult> {\n  return await client.request({\n    method: \"wallet_getCallsStatus\",\n    params: [params],\n  });\n}\n"]}
+{"version":3,"file":"getCallsStatus.js","sourceRoot":"","sources":["../../../../src/client/actions/getCallsStatus.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAUtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAA4B,EAC5B,MAA4B;IAE5B,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC;QAC1B,MAAM,EAAE,uBAAuB;QAC/B,MAAM,EAAE,CAAC,MAAM,CAAC;KACjB,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { InnerWalletApiClient } from \"../../types.ts\";\nimport type { Static } from \"@sinclair/typebox\";\nimport { wallet_getCallsStatus } from \"@alchemy/wallet-api-types/rpc\";\n\nexport type GetCallsStatusParams = Static<\n  typeof wallet_getCallsStatus\n>[\"Request\"][\"params\"][0];\n\nexport type GetCallsStatusResult = Static<\n  typeof wallet_getCallsStatus\n>[\"ReturnType\"];\n\n/**\n * Gets the status of a prepared call by its ID.\n * This method is used to check the execution status of calls sent via sendPreparedCalls.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {GetCallsStatusParams} params - The ID of the prepared call to check\n * @returns {Promise<GetCallsStatusResult>} A Promise that resolves to the status information including:\n *   - id: The hex ID of the call\n *   - chainId: The chain ID in hex format\n *   - status: The current status of the batch execution\n *   - receipts: Optional array of transaction receipts if the batch has been executed\n *\n * @example\n * ```ts\n * // After sending prepared calls\n * const sendResult = await client.sendPreparedCalls({...});\n *\n * // Check the status of the first call ID\n * const status = await client.getCallsStatus(sendResult.preparedCallIds[0]);\n * ```\n */\nexport async function getCallsStatus(\n  client: InnerWalletApiClient,\n  params: GetCallsStatusParams,\n): Promise<GetCallsStatusResult> {\n  return await client.request({\n    method: \"wallet_getCallsStatus\",\n    params: [params],\n  });\n}\n"]}

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

@@ -1,12 +1,13 @@
 import { type SmartAccountSigner } from "@aa-sdk/core";
-import { type Address, type Hex, type IsUndefined } from "viem";
-import type { CreateSessionParams } from "../../isomorphic/actions/createSession.ts";
+import { type Address, type Hex, type IsUndefined, type Prettify } from "viem";
 import type { InnerWalletApiClient } from "../../types.ts";
-export type GrantPermissionsParams<TAccount extends Address | undefined = Address | undefined> = Omit<CreateSessionParams, "account" | "chainId"> & (IsUndefined<TAccount> extends true ? {
+import type { Static } from "@sinclair/typebox";
+import { wallet_createSession } from "@alchemy/wallet-api-types/rpc";
+export type GrantPermissionsParams<TAccount extends Address | undefined = Address | undefined> = Prettify<Omit<Static<(typeof wallet_createSession)["properties"]["Request"]["properties"]["params"]>[0], "account" | "chainId"> & (IsUndefined<TAccount> extends true ? {
     account: Address;
 } : {
     account?: never;
-});
+})>;
 export type GrantPermissionsResult = {
     context: Hex;
 };
@@ -19,21 +20,21 @@ export type GrantPermissionsResult = {
  * @param {GrantPermissionsParams} params - The parameters for granting permissions
  * @param {Address} [params.account] - The account address (required if client was not initialized with an account)
  * @param {number} params.expirySec - Unix timestamp when the permissions expire
- * @param {object} params.key - The session key information
+ * @param {sessionKeyData} params.key - The session key information
  * @param {string} params.key.publicKey - The public key of the session key
  * @param {string} params.key.type - The type of the key (e.g., "secp256k1")
  * @param {Array} params.permissions - Array of permission objects defining what the session key can do
  * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier
- * @returns {Hex} result.context - A hex identifier for the granted permissions context
  *
  * @example
+ * ```ts
  * // Create a session key and grant root permissions
  * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
  * const account = await client.requestAccount();
  *
  * const permissions = await client.grantPermissions({
  *   account: account.address,
- *   expiry: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
  *   key: {
  *     publicKey: await sessionKey.getAddress(),
  *     type: "secp256k1",
@@ -54,10 +55,7 @@ export type GrantPermissionsResult = {
  * });
  *
  * // Sign with the session key
- * const signedCalls = await client.signPreparedCalls(
- *   sessionKey,
- *   preparedCalls,
- * );
+ * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);
  *
  * // Send the prepared call using the session key
  * const result = await client.sendPreparedCalls({
@@ -66,5 +64,6 @@ export type GrantPermissionsResult = {
  *     permissions,
  *   },
  * });
+ * ```
  */
 export declare function grantPermissions<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, signer: SmartAccountSigner, params: GrantPermissionsParams<TAccount>): Promise<GrantPermissionsResult>;

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

@@ -1,5 +1,8 @@
 import { AccountNotFoundError } from "@aa-sdk/core";
-import { toHex } from "viem";
+import { toHex, } from "viem";
+import { wallet_createSession } from "@alchemy/wallet-api-types/rpc";
+import { encodePermissionsContext } from "@alchemy/wallet-api-types/capabilities";
+import { signSignatureRequest } from "./signSignatureRequest.js";
 /**
  * Grants permissions to a smart account by creating a session.
  * This allows another key to perform operations on behalf of the account.
@@ -9,21 +12,21 @@ import { toHex } from "viem";
  * @param {GrantPermissionsParams} params - The parameters for granting permissions
  * @param {Address} [params.account] - The account address (required if client was not initialized with an account)
  * @param {number} params.expirySec - Unix timestamp when the permissions expire
- * @param {object} params.key - The session key information
+ * @param {sessionKeyData} params.key - The session key information
  * @param {string} params.key.publicKey - The public key of the session key
  * @param {string} params.key.type - The type of the key (e.g., "secp256k1")
  * @param {Array} params.permissions - Array of permission objects defining what the session key can do
  * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier
- * @returns {Hex} result.context - A hex identifier for the granted permissions context
  *
  * @example
+ * ```ts
  * // Create a session key and grant root permissions
  * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
  * const account = await client.requestAccount();
  *
  * const permissions = await client.grantPermissions({
  *   account: account.address,
- *   expiry: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
  *   key: {
  *     publicKey: await sessionKey.getAddress(),
  *     type: "secp256k1",
@@ -44,10 +47,7 @@ import { toHex } from "viem";
  * });
  *
  * // Sign with the session key
- * const signedCalls = await client.signPreparedCalls(
- *   sessionKey,
- *   preparedCalls,
- * );
+ * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);
  *
  * // Send the prepared call using the session key
  * const result = await client.sendPreparedCalls({
@@ -56,16 +56,30 @@ import { toHex } from "viem";
  *     permissions,
  *   },
  * });
+ * ```
  */
 export async function grantPermissions(client, signer, params) {
     const account = params.account ?? client.account?.address;
     if (!account) {
         throw new AccountNotFoundError();
     }
-    return client.grantPermissions(signer, {
-        ...params,
-        account,
-        chainId: toHex(client.chain.id),
+    const { sessionId, signatureRequest } = await client.request({
+        method: "wallet_createSession",
+        params: [
+            {
+                ...params,
+                account,
+                chainId: toHex(client.chain.id),
+            },
+        ],
     });
+    const signature = await signSignatureRequest(signer, signatureRequest);
+    return {
+        context: encodePermissionsContext({
+            contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
+            sessionId,
+            signature: signature.data,
+        }),
+    };
 }
 //# sourceMappingURL=grantPermissions.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"grantPermissions.js","sourceRoot":"","sources":["../../../../src/client/actions/grantPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAA2B,MAAM,cAAc,CAAC;AAC7E,OAAO,EAA4C,KAAK,EAAE,MAAM,MAAM,CAAC;AAevE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAGpC,MAA4B,EAC5B,MAA0B,EAC1B,MAAwC;IAExC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1D,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IAED,OAAO,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE;QACrC,GAAG,MAAM;QACT,OAAO;QACP,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;KAChC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { AccountNotFoundError, type SmartAccountSigner } from \"@aa-sdk/core\";\nimport { type Address, type Hex, type IsUndefined, toHex } from \"viem\";\nimport type { CreateSessionParams } from \"../../isomorphic/actions/createSession.ts\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\n\nexport type GrantPermissionsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Omit<CreateSessionParams, \"account\" | \"chainId\"> &\n  (IsUndefined<TAccount> extends true\n    ? { account: Address }\n    : { account?: never });\n\nexport type GrantPermissionsResult = {\n  context: Hex;\n};\n\n/**\n * Grants permissions to a smart account by creating a session.\n * This allows another key to perform operations on behalf of the account.\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 {GrantPermissionsParams} params - The parameters for granting permissions\n * @param {Address} [params.account] - The account address (required if client was not initialized with an account)\n * @param {number} params.expirySec - Unix timestamp when the permissions expire\n * @param {object} params.key - The session key information\n * @param {string} params.key.publicKey - The public key of the session key\n * @param {string} params.key.type - The type of the key (e.g., \"secp256k1\")\n * @param {Array} params.permissions - Array of permission objects defining what the session key can do\n * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier\n * @returns {Hex} result.context - A hex identifier for the granted permissions context\n *\n * @example\n * // Create a session key and grant root permissions\n * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();\n * const account = await client.requestAccount();\n *\n * const permissions = await client.grantPermissions({\n *   account: account.address,\n *   expiry: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now\n *   key: {\n *     publicKey: await sessionKey.getAddress(),\n *     type: \"secp256k1\",\n *   },\n *   permissions: [{ type: \"root\" }],\n * });\n *\n * // Use the permissions to prepare a call\n * const preparedCalls = await client.prepareCalls({\n *   calls: [{ to: zeroAddress, value: \"0x0\" }],\n *   from: account.address,\n *   capabilities: {\n *     paymasterService: {\n *       policyId: \"your-paymaster-policy-id\",\n *     },\n *     permissions,\n *   },\n * });\n *\n * // Sign with the session key\n * const signedCalls = await client.signPreparedCalls(\n *   sessionKey,\n *   preparedCalls,\n * );\n *\n * // Send the prepared call using the session key\n * const result = await client.sendPreparedCalls({\n *   ...signedCalls,\n *   capabilities: {\n *     permissions,\n *   },\n * });\n */\nexport async function grantPermissions<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params: GrantPermissionsParams<TAccount>,\n): Promise<GrantPermissionsResult> {\n  const account = params.account ?? client.account?.address;\n\n  if (!account) {\n    throw new AccountNotFoundError();\n  }\n\n  return client.grantPermissions(signer, {\n    ...params,\n    account,\n    chainId: toHex(client.chain.id),\n  });\n}\n"]}
+{"version":3,"file":"grantPermissions.js","sourceRoot":"","sources":["../../../../src/client/actions/grantPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAA2B,MAAM,cAAc,CAAC;AAC7E,OAAO,EACL,KAAK,GAKN,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAoBjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAGpC,MAA4B,EAC5B,MAA0B,EAC1B,MAAwC;IAExC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1D,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC3D,MAAM,EAAE,sBAAsB;QAC9B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,OAAO;gBACP,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aAChC;SACF;KACF,CAAC,CAAC;IAEH,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAEvE,OAAO;QACL,OAAO,EAAE,wBAAwB,CAAC;YAChC,cAAc,EAAE,6BAA6B;YAC7C,SAAS;YACT,SAAS,EAAE,SAAS,CAAC,IAAI;SAC1B,CAAC;KACH,CAAC;AACJ,CAAC","sourcesContent":["import { AccountNotFoundError, type SmartAccountSigner } from \"@aa-sdk/core\";\nimport {\n  toHex,\n  type Address,\n  type Hex,\n  type IsUndefined,\n  type Prettify,\n} from \"viem\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\nimport type { Static } from \"@sinclair/typebox\";\nimport { wallet_createSession } from \"@alchemy/wallet-api-types/rpc\";\nimport { encodePermissionsContext } from \"@alchemy/wallet-api-types/capabilities\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\n\nexport type GrantPermissionsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<\n  Omit<\n    Static<\n      (typeof wallet_createSession)[\"properties\"][\"Request\"][\"properties\"][\"params\"]\n    >[0],\n    \"account\" | \"chainId\"\n  > &\n    (IsUndefined<TAccount> extends true\n      ? { account: Address }\n      : { account?: never })\n>;\n\nexport type GrantPermissionsResult = {\n  context: Hex;\n};\n\n/**\n * Grants permissions to a smart account by creating a session.\n * This allows another key to perform operations on behalf of the account.\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 {GrantPermissionsParams} params - The parameters for granting permissions\n * @param {Address} [params.account] - The account address (required if client was not initialized with an account)\n * @param {number} params.expirySec - Unix timestamp when the permissions expire\n * @param {sessionKeyData} params.key - The session key information\n * @param {string} params.key.publicKey - The public key of the session key\n * @param {string} params.key.type - The type of the key (e.g., \"secp256k1\")\n * @param {Array} params.permissions - Array of permission objects defining what the session key can do\n * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier\n *\n * @example\n * ```ts\n * // Create a session key and grant root permissions\n * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();\n * const account = await client.requestAccount();\n *\n * const permissions = await client.grantPermissions({\n *   account: account.address,\n *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now\n *   key: {\n *     publicKey: await sessionKey.getAddress(),\n *     type: \"secp256k1\",\n *   },\n *   permissions: [{ type: \"root\" }],\n * });\n *\n * // Use the permissions to prepare a call\n * const preparedCalls = await client.prepareCalls({\n *   calls: [{ to: zeroAddress, value: \"0x0\" }],\n *   from: account.address,\n *   capabilities: {\n *     paymasterService: {\n *       policyId: \"your-paymaster-policy-id\",\n *     },\n *     permissions,\n *   },\n * });\n *\n * // Sign with the session key\n * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);\n *\n * // Send the prepared call using the session key\n * const result = await client.sendPreparedCalls({\n *   ...signedCalls,\n *   capabilities: {\n *     permissions,\n *   },\n * });\n * ```\n */\nexport async function grantPermissions<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params: GrantPermissionsParams<TAccount>,\n): Promise<GrantPermissionsResult> {\n  const account = params.account ?? client.account?.address;\n  if (!account) {\n    throw new AccountNotFoundError();\n  }\n\n  const { sessionId, signatureRequest } = await client.request({\n    method: \"wallet_createSession\",\n    params: [\n      {\n        ...params,\n        account,\n        chainId: toHex(client.chain.id),\n      },\n    ],\n  });\n\n  const signature = await signSignatureRequest(signer, signatureRequest);\n\n  return {\n    context: encodePermissionsContext({\n      contextVersion: \"REMOTE_MODE_DEFERRED_ACTION\",\n      sessionId,\n      signature: signature.data,\n    }),\n  };\n}\n"]}

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

@@ -1,12 +1,17 @@
 import type { Static } from "@sinclair/typebox";
-import type { wallet_listAccounts } from "../../rpc/request.ts";
+import type { wallet_listAccounts } from "@alchemy/wallet-api-types/rpc";
 import type { InnerWalletApiClient } from "../../types.ts";
-export type ListAccountsParams = Static<typeof wallet_listAccounts>["Request"]["params"][0];
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { Address } from "viem";
+export type ListAccountsParams = Omit<Static<typeof wallet_listAccounts>["Request"]["params"][0], "signerAddress"> & {
+    signerAddress?: Address;
+};
 export type ListAccountsResult = Static<typeof wallet_listAccounts>["ReturnType"];
 /**
  * Lists all smart accounts for a given signer using the wallet API client.
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer for which to list accounts
  * @param {ListAccountsParams} params - Parameters for listing accounts
  * @param {string} params.signerAddress - The address of the signer to list accounts for
  * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)
@@ -14,6 +19,7 @@ export type ListAccountsResult = Static<typeof wallet_listAccounts>["ReturnType"
  * @returns {Promise<ListAccountsResult>} A Promise that resolves to the list of accounts and pagination metadata
  *
  * @example
+ * ```ts
  * // Fetch the first page of accounts
  * const firstPage = await client.listAccounts({
  *   signerAddress: "0x123...",
@@ -26,5 +32,6 @@ export type ListAccountsResult = Static<typeof wallet_listAccounts>["ReturnType"
  *   limit: 10,
  *   after: firstPage.meta.after
  * });
+ * ```
  */
-export declare function listAccounts(client: InnerWalletApiClient, params: ListAccountsParams): Promise<ListAccountsResult>;
+export declare function listAccounts(client: InnerWalletApiClient, signer: SmartAccountSigner, params: ListAccountsParams): Promise<ListAccountsResult>;

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

@@ -2,6 +2,7 @@
  * Lists all smart accounts for a given signer using the wallet API client.
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer for which to list accounts
  * @param {ListAccountsParams} params - Parameters for listing accounts
  * @param {string} params.signerAddress - The address of the signer to list accounts for
  * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)
@@ -9,6 +10,7 @@
  * @returns {Promise<ListAccountsResult>} A Promise that resolves to the list of accounts and pagination metadata
  *
  * @example
+ * ```ts
  * // Fetch the first page of accounts
  * const firstPage = await client.listAccounts({
  *   signerAddress: "0x123...",
@@ -21,8 +23,18 @@
  *   limit: 10,
  *   after: firstPage.meta.after
  * });
+ * ```
  */
-export async function listAccounts(client, params) {
-    return client.request({ method: "wallet_listAccounts", params: [params] });
+export async function listAccounts(client, signer, params) {
+    const signerAddress = params.signerAddress ?? (await signer.getAddress());
+    return client.request({
+        method: "wallet_listAccounts",
+        params: [
+            {
+                ...params,
+                signerAddress,
+            },
+        ],
+    });
 }
 //# sourceMappingURL=listAccounts.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"listAccounts.js","sourceRoot":"","sources":["../../../../src/client/actions/listAccounts.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAA4B,EAC5B,MAA0B;IAE1B,OAAO,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAC7E,CAAC","sourcesContent":["import type { Static } from \"@sinclair/typebox\";\nimport type { wallet_listAccounts } from \"../../rpc/request.ts\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\n\nexport type ListAccountsParams = Static<\n  typeof wallet_listAccounts\n>[\"Request\"][\"params\"][0];\n\nexport type ListAccountsResult = Static<\n  typeof wallet_listAccounts\n>[\"ReturnType\"];\n\n/**\n * Lists all smart accounts for a given signer using the wallet API client.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {ListAccountsParams} params - Parameters for listing accounts\n * @param {string} params.signerAddress - The address of the signer to list accounts for\n * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)\n * @param {string} [params.after] - Optional pagination cursor for fetching subsequent pages\n * @returns {Promise<ListAccountsResult>} A Promise that resolves to the list of accounts and pagination metadata\n *\n * @example\n * // Fetch the first page of accounts\n * const firstPage = await client.listAccounts({\n *   signerAddress: \"0x123...\",\n *   limit: 10\n * });\n *\n * // If an 'after' cursor exists, use it to fetch the next page\n * const nextPage = await client.listAccounts({\n *   signerAddress: \"0x123...\",\n *   limit: 10,\n *   after: firstPage.meta.after\n * });\n */\nexport async function listAccounts(\n  client: InnerWalletApiClient,\n  params: ListAccountsParams,\n): Promise<ListAccountsResult> {\n  return client.request({ method: \"wallet_listAccounts\", params: [params] });\n}\n"]}
+{"version":3,"file":"listAccounts.js","sourceRoot":"","sources":["../../../../src/client/actions/listAccounts.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAA4B,EAC5B,MAA0B,EAC1B,MAA0B;IAE1B,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,IAAI,CAAC,MAAM,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;IAE1E,OAAO,MAAM,CAAC,OAAO,CAAC;QACpB,MAAM,EAAE,qBAAqB;QAC7B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,aAAa;aACd;SACF;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { Static } from \"@sinclair/typebox\";\nimport type { wallet_listAccounts } from \"@alchemy/wallet-api-types/rpc\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\nimport type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport type { Address } from \"viem\";\n\nexport type ListAccountsParams = Omit<\n  Static<typeof wallet_listAccounts>[\"Request\"][\"params\"][0],\n  \"signerAddress\"\n> & { signerAddress?: Address };\n\nexport type ListAccountsResult = Static<\n  typeof wallet_listAccounts\n>[\"ReturnType\"];\n\n/**\n * Lists all smart accounts for a given signer using the wallet API client.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {SmartAccountSigner} signer - The signer for which to list accounts\n * @param {ListAccountsParams} params - Parameters for listing accounts\n * @param {string} params.signerAddress - The address of the signer to list accounts for\n * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)\n * @param {string} [params.after] - Optional pagination cursor for fetching subsequent pages\n * @returns {Promise<ListAccountsResult>} A Promise that resolves to the list of accounts and pagination metadata\n *\n * @example\n * ```ts\n * // Fetch the first page of accounts\n * const firstPage = await client.listAccounts({\n *   signerAddress: \"0x123...\",\n *   limit: 10\n * });\n *\n * // If an 'after' cursor exists, use it to fetch the next page\n * const nextPage = await client.listAccounts({\n *   signerAddress: \"0x123...\",\n *   limit: 10,\n *   after: firstPage.meta.after\n * });\n * ```\n */\nexport async function listAccounts(\n  client: InnerWalletApiClient,\n  signer: SmartAccountSigner,\n  params: ListAccountsParams,\n): Promise<ListAccountsResult> {\n  const signerAddress = params.signerAddress ?? (await signer.getAddress());\n\n  return client.request({\n    method: \"wallet_listAccounts\",\n    params: [\n      {\n        ...params,\n        signerAddress,\n      },\n    ],\n  });\n}\n"]}

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

@@ -1,17 +1,18 @@
 import { type Address, type IsUndefined } from "viem";
-import type { PrepareCallsParams as IsomorphicPrepareCallsParams, PrepareCallsResult as IsomorphicPrepareCallsResult } from "../../isomorphic/actions/prepareCalls.ts";
 import type { InnerWalletApiClient } from "../../types.ts";
+import type { Static } from "@sinclair/typebox";
+import { wallet_prepareCalls } from "@alchemy/wallet-api-types/rpc";
 export type GetAccountParam<TAccount> = IsUndefined<TAccount> extends true ? {
     account: Address;
 } : {
     account?: Address;
 };
-export type PrepareCallsParams<TAccount extends Address | undefined = Address | undefined> = Omit<IsomorphicPrepareCallsParams, "from" | "chainId"> & (IsUndefined<TAccount> extends true ? {
+export type PrepareCallsParams<TAccount extends Address | undefined = Address | undefined> = Omit<Static<(typeof wallet_prepareCalls)["properties"]["Request"]["properties"]["params"]>[0], "from" | "chainId"> & (IsUndefined<TAccount> extends true ? {
     from: Address;
 } : {
     from?: never;
 });
-export type PrepareCallsResult = IsomorphicPrepareCallsResult;
+export type PrepareCallsResult = Static<typeof wallet_prepareCalls>["ReturnType"];
 /**
  * Prepares a set of contract calls for execution by building a user operation.
  * Returns the built user operation and a signature request that needs to be signed
@@ -26,6 +27,7 @@ export type PrepareCallsResult = IsomorphicPrepareCallsResult;
  * the user operation data and signature request
  *
  * @example
+ * ```ts
  * // Prepare a sponsored user operation call
  * const result = await client.prepareCalls({
  *   calls: [{
@@ -37,5 +39,6 @@ export type PrepareCallsResult = IsomorphicPrepareCallsResult;
  *     paymasterService: { policyId: "your-policy-id" }
  *   }
  * });
+ * ```
  */
 export declare function prepareCalls<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: PrepareCallsParams<TAccount>): Promise<PrepareCallsResult>;

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

@@ -1,5 +1,6 @@
 import { AccountNotFoundError } from "@aa-sdk/core";
 import { toHex } from "viem";
+import { wallet_prepareCalls } from "@alchemy/wallet-api-types/rpc";
 /**
  * Prepares a set of contract calls for execution by building a user operation.
  * Returns the built user operation and a signature request that needs to be signed
@@ -14,6 +15,7 @@ import { toHex } from "viem";
  * the user operation data and signature request
  *
  * @example
+ * ```ts
  * // Prepare a sponsored user operation call
  * const result = await client.prepareCalls({
  *   calls: [{
@@ -25,26 +27,28 @@ import { toHex } from "viem";
  *     paymasterService: { policyId: "your-policy-id" }
  *   }
  * });
+ * ```
  */
 export async function prepareCalls(client, params) {
     const from = params.from ?? client.account?.address;
     if (!from) {
         throw new AccountNotFoundError();
     }
-    if (client.policyId && !params.capabilities?.paymasterService) {
+    if (client.policyIds && !params.capabilities?.paymasterService) {
         params.capabilities = {
             ...params.capabilities,
-            paymasterService: { policyId: client.policyId },
+            paymasterService: { policyIds: client.policyIds },
         };
     }
-    const params_ = {
-        ...params,
-        chainId: toHex(client.chain.id),
-        from,
-    };
     return await client.request({
         method: "wallet_prepareCalls",
-        params: [params_],
+        params: [
+            {
+                ...params,
+                chainId: toHex(client.chain.id),
+                from,
+            },
+        ],
     });
 }
 //# sourceMappingURL=prepareCalls.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"prepareCalls.js","sourceRoot":"","sources":["../../../../src/client/actions/prepareCalls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,KAAK,EAAkC,MAAM,MAAM,CAAC;AAmB7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAGhC,MAA4B,EAC5B,MAAoC;IAEpC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IAEpD,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IAED,IAAI,MAAM,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,gBAAgB,EAAE,CAAC;QAC9D,MAAM,CAAC,YAAY,GAAG;YACpB,GAAG,MAAM,CAAC,YAAY;YACtB,gBAAgB,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE;SAChD,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAG;QACd,GAAG,MAAM;QACT,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,IAAI;KACL,CAAC;IAEF,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC;QAC1B,MAAM,EAAE,qBAAqB;QAC7B,MAAM,EAAE,CAAC,OAAO,CAAC;KAClB,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { AccountNotFoundError } from \"@aa-sdk/core\";\nimport { toHex, type Address, type IsUndefined } from \"viem\";\nimport type {\n  PrepareCallsParams as IsomorphicPrepareCallsParams,\n  PrepareCallsResult as IsomorphicPrepareCallsResult,\n} from \"../../isomorphic/actions/prepareCalls.ts\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\n\nexport type GetAccountParam<TAccount> =\n  IsUndefined<TAccount> extends true\n    ? { account: Address }\n    : { account?: Address };\n\nexport type PrepareCallsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Omit<IsomorphicPrepareCallsParams, \"from\" | \"chainId\"> &\n  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });\n\nexport type PrepareCallsResult = IsomorphicPrepareCallsResult;\n\n/**\n * Prepares a set of contract calls for execution by building a user operation.\n * Returns the built user operation and a signature request that needs to be signed\n * before submitting to sendPreparedCalls.\n *\n * @param {InnerWalletApiClient<TAccount>} client - The wallet API client to use for the request\n * @param {PrepareCallsParams<TAccount>} params - Parameters for preparing calls\n * @param {Array<{to: Address, data?: Hex, value?: Hex}>} params.calls - Array of contract calls to execute\n * @param {Address} [params.from] - The address to execute the calls from (required if the client wasn't initialized with an account)\n * @param {object} [params.capabilities] - Optional capabilities to include with the request\n * @returns {Promise<PrepareCallsResult>} A Promise that resolves to the prepared calls result containing\n * the user operation data and signature request\n *\n * @example\n * // Prepare a sponsored user operation call\n * const result = 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 */\nexport async function prepareCalls<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  params: PrepareCallsParams<TAccount>,\n): Promise<PrepareCallsResult> {\n  const from = params.from ?? client.account?.address;\n\n  if (!from) {\n    throw new AccountNotFoundError();\n  }\n\n  if (client.policyId && !params.capabilities?.paymasterService) {\n    params.capabilities = {\n      ...params.capabilities,\n      paymasterService: { policyId: client.policyId },\n    };\n  }\n\n  const params_ = {\n    ...params,\n    chainId: toHex(client.chain.id),\n    from,\n  };\n\n  return await client.request({\n    method: \"wallet_prepareCalls\",\n    params: [params_],\n  });\n}\n"]}
+{"version":3,"file":"prepareCalls.js","sourceRoot":"","sources":["../../../../src/client/actions/prepareCalls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,KAAK,EAAkC,MAAM,MAAM,CAAC;AAG7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAqBpE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAGhC,MAA4B,EAC5B,MAAoC;IAEpC,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,IAAI,MAAM,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,gBAAgB,EAAE,CAAC;QAC/D,MAAM,CAAC,YAAY,GAAG;YACpB,GAAG,MAAM,CAAC,YAAY;YACtB,gBAAgB,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE;SAClD,CAAC;IACJ,CAAC;IAED,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC;QAC1B,MAAM,EAAE,qBAAqB;QAC7B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC/B,IAAI;aACL;SACF;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { AccountNotFoundError } from \"@aa-sdk/core\";\nimport { toHex, type Address, type IsUndefined } from \"viem\";\nimport type { InnerWalletApiClient } from \"../../types.ts\";\nimport type { Static } from \"@sinclair/typebox\";\nimport { wallet_prepareCalls } from \"@alchemy/wallet-api-types/rpc\";\n\nexport type GetAccountParam<TAccount> =\n  IsUndefined<TAccount> extends true\n    ? { account: Address }\n    : { account?: Address };\n\nexport type PrepareCallsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Omit<\n  Static<\n    (typeof wallet_prepareCalls)[\"properties\"][\"Request\"][\"properties\"][\"params\"]\n  >[0],\n  \"from\" | \"chainId\"\n> &\n  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });\n\nexport type PrepareCallsResult = Static<\n  typeof wallet_prepareCalls\n>[\"ReturnType\"];\n\n/**\n * Prepares a set of contract calls for execution by building a user operation.\n * Returns the built user operation and a signature request that needs to be signed\n * before submitting to sendPreparedCalls.\n *\n * @param {InnerWalletApiClient<TAccount>} client - The wallet API client to use for the request\n * @param {PrepareCallsParams<TAccount>} params - Parameters for preparing calls\n * @param {Array<{to: Address, data?: Hex, value?: Hex}>} params.calls - Array of contract calls to execute\n * @param {Address} [params.from] - The address to execute the calls from (required if the client wasn't initialized with an account)\n * @param {object} [params.capabilities] - Optional capabilities to include with the request\n * @returns {Promise<PrepareCallsResult>} A Promise that resolves to the prepared calls result containing\n * the user operation data and signature request\n *\n * @example\n * ```ts\n * // Prepare a sponsored user operation call\n * const result = 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 */\nexport async function prepareCalls<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  params: PrepareCallsParams<TAccount>,\n): Promise<PrepareCallsResult> {\n  const from = params.from ?? client.account?.address;\n  if (!from) {\n    throw new AccountNotFoundError();\n  }\n\n  if (client.policyIds && !params.capabilities?.paymasterService) {\n    params.capabilities = {\n      ...params.capabilities,\n      paymasterService: { policyIds: client.policyIds },\n    };\n  }\n\n  return await client.request({\n    method: \"wallet_prepareCalls\",\n    params: [\n      {\n        ...params,\n        chainId: toHex(client.chain.id),\n        from,\n      },\n    ],\n  });\n}\n"]}

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

@@ -0,0 +1,28 @@
+import type { InnerWalletApiClient } from "../../types.ts";
+import { type Address, type IsUndefined } from "viem";
+import type { Static } from "@sinclair/typebox";
+import { wallet_prepareSign } from "@alchemy/wallet-api-types/rpc";
+export type PrepareSignParams<TAccount extends Address | undefined = Address | undefined> = Omit<Static<(typeof wallet_prepareSign)["properties"]["Request"]["properties"]["params"]>[0], "from" | "chainId"> & (IsUndefined<TAccount> extends true ? {
+    from: Address;
+} : {
+    from?: never;
+});
+export type PrepareSignResult = Static<typeof wallet_prepareSign>["ReturnType"];
+/**
+ * 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
+ * ```ts
+ * // Prepare a message to be signed
+ * const result = await client.prepareSign({
+ *    from: "0x1234...",
+ *    type: "personal_sign",
+ *    data: "Hello, world!",
+ * });
+ * ```
+ */
+export declare function prepareSign<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: PrepareSignParams<TAccount>): Promise<PrepareSignResult>;

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

@@ -0,0 +1,31 @@
+import { toHex } from "viem";
+import { AccountNotFoundError } from "@aa-sdk/core";
+import { wallet_prepareSign } from "@alchemy/wallet-api-types/rpc";
+/**
+ * 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
+ * ```ts
+ * // 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;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAcnE;;;;;;;;;;;;;;;;GAgBG;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 { AccountNotFoundError } from \"@aa-sdk/core\";\nimport type { Static } from \"@sinclair/typebox\";\nimport { wallet_prepareSign } from \"@alchemy/wallet-api-types/rpc\";\n\nexport type PrepareSignParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Omit<\n  Static<\n    (typeof wallet_prepareSign)[\"properties\"][\"Request\"][\"properties\"][\"params\"]\n  >[0],\n  \"from\" | \"chainId\"\n> &\n  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });\n\nexport type PrepareSignResult = Static<typeof wallet_prepareSign>[\"ReturnType\"];\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 * ```ts\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 * ```\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,7 +1,7 @@
 import { type SmartAccountSigner, type SmartContractAccount } from "@aa-sdk/core";
 import type { Static } from "@sinclair/typebox";
 import type { Address } from "abitype";
-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 = Omit<Extract<Static<typeof wallet_requestAccount>["Request"]["params"][0], {
     signerAddress: Address;
@@ -22,8 +22,10 @@ export type RequestAccountResult = SmartContractAccount;
  * @returns {Promise<RequestAccountResult>} A Promise that resolves to a SmartContractAccount instance
  *
  * @example
+ * ```ts
  * // 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>;