@alchemy/wallet-apis 0.0.0-alpha.12

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/actions/formatSign.d.ts

@@ -0,0 +1,35 @@
+import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+import type { InnerWalletApiClient, OptionalChainId } from "../types.ts";
+import { type Address, type IsUndefined, type Prettify } from "viem";
+type RpcSchema = Extract<WalletServerRpcSchemaType, {
+    Request: {
+        method: "wallet_formatSign";
+    };
+}>;
+export type FormatSignParams<TAccount extends Address | undefined = Address | undefined> = Prettify<Omit<OptionalChainId<RpcSchema["Request"]["params"][0]>, "from"> & (IsUndefined<TAccount> extends true ? {
+    from: Address;
+} : {
+    from?: never;
+})>;
+export type FormatSignResult = Prettify<RpcSchema["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>;
+export {};

package/dist/esm/actions/formatSign.js

@@ -0,0 +1,38 @@
+import { toHex } from "viem";
+import { AccountNotFoundError } from "@alchemy/common";
+import { LOGGER } from "../logger.js";
+/**
+ * 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();
+    }
+    LOGGER.debug("formatSign:start");
+    const res = await client.request({
+        method: "wallet_formatSign",
+        params: [
+            { ...params, from, chainId: params.chainId ?? toHex(client.chain.id) },
+        ],
+    });
+    LOGGER.debug("formatSign:done");
+    return res;
+}
+//# sourceMappingURL=formatSign.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatSign.js","sourceRoot":"","sources":["../../../src/actions/formatSign.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAiD,MAAM,MAAM,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAoBtC;;;;;;;;;;;;;;;;;;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,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC/B,MAAM,EAAE,mBAAmB;QAC3B,MAAM,EAAE;YACN,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;SACvE;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAChC,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\nimport type { InnerWalletApiClient, OptionalChainId } from \"../types.ts\";\nimport { toHex, type Address, type IsUndefined, type Prettify } from \"viem\";\nimport { AccountNotFoundError } from \"@alchemy/common\";\nimport { LOGGER } from \"../logger.js\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_formatSign\";\n    };\n  }\n>;\n\nexport type FormatSignParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<\n  Omit<OptionalChainId<RpcSchema[\"Request\"][\"params\"][0]>, \"from\"> &\n    (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never })\n>;\n\nexport type FormatSignResult = Prettify<RpcSchema[\"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  LOGGER.debug(\"formatSign:start\");\n  const res = await client.request({\n    method: \"wallet_formatSign\",\n    params: [\n      { ...params, from, chainId: params.chainId ?? toHex(client.chain.id) },\n    ],\n  });\n  LOGGER.debug(\"formatSign:done\");\n  return res;\n}\n"]}

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

@@ -0,0 +1,73 @@
+import { type Address, type Hex, type IsUndefined, type Prettify } from "viem";
+import type { InnerWalletApiClient } from "../types.ts";
+import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+import type { OptionalChainId } from "../types.ts";
+type RpcSchema = Extract<WalletServerRpcSchemaType, {
+    Request: {
+        method: "wallet_createSession";
+    };
+}>;
+export type GrantPermissionsParams<TAccount extends Address | undefined = Address | undefined> = Prettify<OptionalChainId<Omit<RpcSchema["Request"]["params"][0], "account">> & (IsUndefined<TAccount> extends true ? {
+    account: Address;
+} : {
+    account?: never;
+})>;
+export type GrantPermissionsResult = Prettify<{
+    context: Hex;
+}>;
+/**
+ * Grants permissions to a smart account by creating a session.
+ * This allows another key to perform operations on behalf of the account.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @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 {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
+ *
+ * @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,
+ *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   key: {
+ *     publicKey: await sessionKey.getAddress(),
+ *     type: "secp256k1",
+ *   },
+ *   permissions: [{ type: "root" }],
+ * });
+ *
+ * // Use the permissions to prepare a call
+ * const preparedCalls = await client.prepareCalls({
+ *   calls: [{ to: zeroAddress, value: "0x0" }],
+ *   from: account.address,
+ *   capabilities: {
+ *     paymasterService: {
+ *       policyId: "your-paymaster-policy-id",
+ *     },
+ *     permissions,
+ *   },
+ * });
+ *
+ * // Sign with the session key
+ * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);
+ *
+ * // Send the prepared call using the session key
+ * const result = await client.sendPreparedCalls({
+ *   ...signedCalls,
+ *   capabilities: {
+ *     permissions,
+ *   },
+ * });
+ * ```
+ */
+export declare function grantPermissions<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: GrantPermissionsParams<TAccount>): Promise<GrantPermissionsResult>;
+export {};

package/dist/esm/actions/grantPermissions.js

@@ -0,0 +1,87 @@
+import { toHex, concatHex, } from "viem";
+import { signSignatureRequest } from "./signSignatureRequest.js";
+import { AccountNotFoundError } from "@alchemy/common";
+import { LOGGER } from "../logger.js";
+/**
+ * Grants permissions to a smart account by creating a session.
+ * This allows another key to perform operations on behalf of the account.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @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 {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
+ *
+ * @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,
+ *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   key: {
+ *     publicKey: await sessionKey.getAddress(),
+ *     type: "secp256k1",
+ *   },
+ *   permissions: [{ type: "root" }],
+ * });
+ *
+ * // Use the permissions to prepare a call
+ * const preparedCalls = await client.prepareCalls({
+ *   calls: [{ to: zeroAddress, value: "0x0" }],
+ *   from: account.address,
+ *   capabilities: {
+ *     paymasterService: {
+ *       policyId: "your-paymaster-policy-id",
+ *     },
+ *     permissions,
+ *   },
+ * });
+ *
+ * // Sign with the session key
+ * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);
+ *
+ * // Send the prepared call using the session key
+ * const result = await client.sendPreparedCalls({
+ *   ...signedCalls,
+ *   capabilities: {
+ *     permissions,
+ *   },
+ * });
+ * ```
+ */
+export async function grantPermissions(client, params) {
+    const account = params.account ?? client.account?.address;
+    if (!account) {
+        LOGGER.warn("grantPermissions:no-account");
+        throw new AccountNotFoundError();
+    }
+    LOGGER.debug("grantPermissions:start", { expirySec: params.expirySec });
+    const { sessionId, signatureRequest } = await client.request({
+        method: "wallet_createSession",
+        params: [
+            {
+                ...params,
+                account,
+                chainId: params.chainId ?? toHex(client.chain.id),
+            },
+        ],
+    });
+    const signature = await signSignatureRequest(client, signatureRequest);
+    const res = {
+        context: concatHex([
+            "0x00", // Remote mode.
+            sessionId,
+            signature.data,
+        ]),
+    };
+    LOGGER.debug("grantPermissions:done");
+    return res;
+}
+//# sourceMappingURL=grantPermissions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grantPermissions.js","sourceRoot":"","sources":["../../../src/actions/grantPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAKL,SAAS,GACV,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAyBtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAGpC,MAA4B,EAC5B,MAAwC;IAExC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1D,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;QAC3C,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IACD,MAAM,CAAC,KAAK,CAAC,wBAAwB,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;IACxE,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,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aAClD;SACF;KACF,CAAC,CAAC;IAEH,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACvE,MAAM,GAAG,GAAG;QACV,OAAO,EAAE,SAAS,CAAC;YACjB,MAAM,EAAE,eAAe;YACvB,SAAS;YACT,SAAS,CAAC,IAAI;SACf,CAAC;KACM,CAAC;IACX,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACtC,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import {\n  toHex,\n  type Address,\n  type Hex,\n  type IsUndefined,\n  type Prettify,\n  concatHex,\n} from \"viem\";\nimport type { InnerWalletApiClient } from \"../types.ts\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport { AccountNotFoundError } from \"@alchemy/common\";\nimport { LOGGER } from \"../logger.js\";\nimport type { OptionalChainId } from \"../types.ts\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_createSession\";\n    };\n  }\n>;\n\nexport type GrantPermissionsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<\n  OptionalChainId<Omit<RpcSchema[\"Request\"][\"params\"][0], \"account\">> &\n    (IsUndefined<TAccount> extends true\n      ? { account: Address }\n      : { account?: never })\n>;\n\nexport type GrantPermissionsResult = Prettify<{\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 {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  params: GrantPermissionsParams<TAccount>,\n): Promise<GrantPermissionsResult> {\n  const account = params.account ?? client.account?.address;\n  if (!account) {\n    LOGGER.warn(\"grantPermissions:no-account\");\n    throw new AccountNotFoundError();\n  }\n  LOGGER.debug(\"grantPermissions:start\", { expirySec: params.expirySec });\n  const { sessionId, signatureRequest } = await client.request({\n    method: \"wallet_createSession\",\n    params: [\n      {\n        ...params,\n        account,\n        chainId: params.chainId ?? toHex(client.chain.id),\n      },\n    ],\n  });\n\n  const signature = await signSignatureRequest(client, signatureRequest);\n  const res = {\n    context: concatHex([\n      \"0x00\", // Remote mode.\n      sessionId,\n      signature.data,\n    ]),\n  } as const;\n  LOGGER.debug(\"grantPermissions:done\");\n  return res;\n}\n"]}

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

@@ -0,0 +1,40 @@
+import type { InnerWalletApiClient } from "../types.ts";
+import type { Address, Prettify } from "viem";
+import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+type RpcSchema = Extract<WalletServerRpcSchemaType, {
+    Request: {
+        method: "wallet_listAccounts";
+    };
+}>;
+export type ListAccountsParams = Prettify<Omit<RpcSchema["Request"]["params"][0], "signerAddress"> & {
+    signerAddress?: Address;
+}>;
+export type ListAccountsResult = Prettify<RpcSchema["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 {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)
+ * @param {string} [params.after] - Optional pagination cursor for fetching subsequent pages
+ * @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...",
+ *   limit: 10
+ * });
+ *
+ * // If an 'after' cursor exists, use it to fetch the next page
+ * const nextPage = await client.listAccounts({
+ *   signerAddress: "0x123...",
+ *   limit: 10,
+ *   after: firstPage.meta.after
+ * });
+ * ```
+ */
+export declare function listAccounts(client: InnerWalletApiClient, params: ListAccountsParams): Promise<ListAccountsResult>;
+export {};

package/dist/esm/actions/listAccounts.js

@@ -0,0 +1,43 @@
+import { LOGGER } from "../logger.js";
+/**
+ * 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 {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)
+ * @param {string} [params.after] - Optional pagination cursor for fetching subsequent pages
+ * @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...",
+ *   limit: 10
+ * });
+ *
+ * // If an 'after' cursor exists, use it to fetch the next page
+ * const nextPage = await client.listAccounts({
+ *   signerAddress: "0x123...",
+ *   limit: 10,
+ *   after: firstPage.meta.after
+ * });
+ * ```
+ */
+export async function listAccounts(client, params) {
+    const signerAddress = params.signerAddress ?? client.owner.account.address;
+    LOGGER.debug("listAccounts:start", { hasAfter: !!params.after });
+    const res = await client.request({
+        method: "wallet_listAccounts",
+        params: [
+            {
+                ...params,
+                signerAddress,
+            },
+        ],
+    });
+    LOGGER.debug("listAccounts:done", { count: res.accounts.length });
+    return res;
+}
+//# sourceMappingURL=listAccounts.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listAccounts.js","sourceRoot":"","sources":["../../../src/actions/listAccounts.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAqBtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAA4B,EAC5B,MAA0B;IAE1B,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;IAC3E,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IACjE,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC/B,MAAM,EAAE,qBAAqB;QAC7B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,aAAa;aACd;SACF;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAClE,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { InnerWalletApiClient } from \"../types.ts\";\nimport { LOGGER } from \"../logger.js\";\nimport type { Address, Prettify } from \"viem\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_listAccounts\";\n    };\n  }\n>;\n\nexport type ListAccountsParams = Prettify<\n  Omit<RpcSchema[\"Request\"][\"params\"][0], \"signerAddress\"> & {\n    signerAddress?: Address;\n  }\n>;\n\nexport type ListAccountsResult = Prettify<RpcSchema[\"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 * ```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  params: ListAccountsParams,\n): Promise<ListAccountsResult> {\n  const signerAddress = params.signerAddress ?? client.owner.account.address;\n  LOGGER.debug(\"listAccounts:start\", { hasAfter: !!params.after });\n  const res = await client.request({\n    method: \"wallet_listAccounts\",\n    params: [\n      {\n        ...params,\n        signerAddress,\n      },\n    ],\n  });\n  LOGGER.debug(\"listAccounts:done\", { count: res.accounts.length });\n  return res;\n}\n"]}

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

@@ -0,0 +1,44 @@
+import { type Address, type IsUndefined, type Prettify } from "viem";
+import type { InnerWalletApiClient, OptionalChainId } from "../types.ts";
+import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+type RpcSchema = Extract<WalletServerRpcSchemaType, {
+    Request: {
+        method: "wallet_prepareCalls";
+    };
+}>;
+export type PrepareCallsParams<TAccount extends Address | undefined = Address | undefined> = Prettify<OptionalChainId<Omit<RpcSchema["Request"]["params"][0], "from">> & (IsUndefined<TAccount> extends true ? {
+    from: Address;
+} : {
+    from?: never;
+})>;
+export type PrepareCallsResult = Prettify<RpcSchema["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
+ * before submitting to sendPreparedCalls.
+ *
+ * @param {InnerWalletApiClient<TAccount>} client - The wallet API client to use for the request
+ * @param {PrepareCallsParams<TAccount>} params - Parameters for preparing calls
+ * @param {Array<{to: Address, data?: Hex, value?: Hex}>} params.calls - Array of contract calls to execute
+ * @param {Address} [params.from] - The address to execute the calls from (required if the client wasn't initialized with an account)
+ * @param {object} [params.capabilities] - Optional capabilities to include with the request
+ * @returns {Promise<PrepareCallsResult>} A Promise that resolves to the prepared calls result containing
+ * the user operation data and signature request
+ *
+ * @example
+ * ```ts
+ * // Prepare a sponsored user operation call
+ * const result = await client.prepareCalls({
+ *   calls: [{
+ *     to: "0x1234...",
+ *     data: "0xabcdef...",
+ *     value: "0x0"
+ *   }],
+ *   capabilities: {
+ *     paymasterService: { policyId: "your-policy-id" }
+ *   }
+ * });
+ * ```
+ */
+export declare function prepareCalls<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: PrepareCallsParams<TAccount>): Promise<PrepareCallsResult>;
+export {};

package/dist/esm/actions/prepareCalls.js

@@ -0,0 +1,58 @@
+import { toHex } from "viem";
+import { AccountNotFoundError } from "@alchemy/common";
+import { LOGGER } from "../logger.js";
+import { mergeClientCapabilities } from "../utils/capabilities.js";
+/**
+ * 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
+ * before submitting to sendPreparedCalls.
+ *
+ * @param {InnerWalletApiClient<TAccount>} client - The wallet API client to use for the request
+ * @param {PrepareCallsParams<TAccount>} params - Parameters for preparing calls
+ * @param {Array<{to: Address, data?: Hex, value?: Hex}>} params.calls - Array of contract calls to execute
+ * @param {Address} [params.from] - The address to execute the calls from (required if the client wasn't initialized with an account)
+ * @param {object} [params.capabilities] - Optional capabilities to include with the request
+ * @returns {Promise<PrepareCallsResult>} A Promise that resolves to the prepared calls result containing
+ * the user operation data and signature request
+ *
+ * @example
+ * ```ts
+ * // Prepare a sponsored user operation call
+ * const result = await client.prepareCalls({
+ *   calls: [{
+ *     to: "0x1234...",
+ *     data: "0xabcdef...",
+ *     value: "0x0"
+ *   }],
+ *   capabilities: {
+ *     paymasterService: { policyId: "your-policy-id" }
+ *   }
+ * });
+ * ```
+ */
+export async function prepareCalls(client, params) {
+    const from = params.from ?? client.account?.address;
+    if (!from) {
+        LOGGER.warn("prepareCalls:no-from", { hasClientAccount: !!client.account });
+        throw new AccountNotFoundError();
+    }
+    const capabilities = mergeClientCapabilities(client, params.capabilities);
+    LOGGER.debug("prepareCalls:start", {
+        callsCount: params.calls?.length,
+        hasCapabilities: !!params.capabilities,
+    });
+    const res = await client.request({
+        method: "wallet_prepareCalls",
+        params: [
+            {
+                ...params,
+                chainId: params.chainId ?? toHex(client.chain.id),
+                from,
+                capabilities,
+            },
+        ],
+    });
+    LOGGER.debug("prepareCalls:done");
+    return res;
+}
+//# sourceMappingURL=prepareCalls.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepareCalls.js","sourceRoot":"","sources":["../../../src/actions/prepareCalls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAiD,MAAM,MAAM,CAAC;AAE5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAqBnE;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5E,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IAED,MAAM,YAAY,GAAG,uBAAuB,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC;IAE1E,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE;QACjC,UAAU,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM;QAChC,eAAe,EAAE,CAAC,CAAC,MAAM,CAAC,YAAY;KACvC,CAAC,CAAC;IACH,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC/B,MAAM,EAAE,qBAAqB;QAC7B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;gBACjD,IAAI;gBACJ,YAAY;aACb;SACF;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAClC,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import { toHex, type Address, type IsUndefined, type Prettify } from \"viem\";\nimport type { InnerWalletApiClient, OptionalChainId } from \"../types.ts\";\nimport { AccountNotFoundError } from \"@alchemy/common\";\nimport { LOGGER } from \"../logger.js\";\nimport { mergeClientCapabilities } from \"../utils/capabilities.js\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_prepareCalls\";\n    };\n  }\n>;\n\nexport type PrepareCallsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<\n  OptionalChainId<Omit<RpcSchema[\"Request\"][\"params\"][0], \"from\">> &\n    (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never })\n>;\n\nexport type PrepareCallsResult = Prettify<RpcSchema[\"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    LOGGER.warn(\"prepareCalls:no-from\", { hasClientAccount: !!client.account });\n    throw new AccountNotFoundError();\n  }\n\n  const capabilities = mergeClientCapabilities(client, params.capabilities);\n\n  LOGGER.debug(\"prepareCalls:start\", {\n    callsCount: params.calls?.length,\n    hasCapabilities: !!params.capabilities,\n  });\n  const res = await client.request({\n    method: \"wallet_prepareCalls\",\n    params: [\n      {\n        ...params,\n        chainId: params.chainId ?? toHex(client.chain.id),\n        from,\n        capabilities,\n      },\n    ],\n  });\n  LOGGER.debug(\"prepareCalls:done\");\n  return res;\n}\n"]}

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

@@ -0,0 +1,33 @@
+import type { InnerWalletApiClient, OptionalChainId } from "../types.ts";
+import { type Address, type IsUndefined, type Prettify } from "viem";
+import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+type RpcSchema = Extract<WalletServerRpcSchemaType, {
+    Request: {
+        method: "wallet_prepareSign";
+    };
+}>;
+export type PrepareSignParams<TAccount extends Address | undefined = Address | undefined> = Prettify<OptionalChainId<Omit<RpcSchema["Request"]["params"][0], "from">> & (IsUndefined<TAccount> extends true ? {
+    from: Address;
+} : {
+    from?: never;
+})>;
+export type PrepareSignResult = Prettify<RpcSchema["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>;
+export {};

package/dist/esm/actions/prepareSign.js

@@ -0,0 +1,41 @@
+import { toHex } from "viem";
+import { AccountNotFoundError } from "@alchemy/common";
+import { LOGGER } from "../logger.js";
+/**
+ * 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) {
+        LOGGER.warn("prepareSign:no-from", { hasClientAccount: !!client.account });
+        throw new AccountNotFoundError();
+    }
+    LOGGER.debug("prepareSign:start", { type: params.signatureRequest.type });
+    const res = await client.request({
+        method: "wallet_prepareSign",
+        params: [
+            {
+                ...params,
+                from,
+                chainId: params.chainId ?? toHex(client.chain.id),
+            },
+        ],
+    });
+    LOGGER.debug("prepareSign:done");
+    return res;
+}
+//# sourceMappingURL=prepareSign.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepareSign.js","sourceRoot":"","sources":["../../../src/actions/prepareSign.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAiD,MAAM,MAAM,CAAC;AAE5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAoBtC;;;;;;;;;;;;;;;;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,CAAC,IAAI,CAAC,qBAAqB,EAAE,EAAE,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QAC3E,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC;IAC1E,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC/B,MAAM,EAAE,oBAAoB;QAC5B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,IAAI;gBACJ,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aAClD;SACF;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACjC,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { InnerWalletApiClient, OptionalChainId } from \"../types.ts\";\nimport { toHex, type Address, type IsUndefined, type Prettify } from \"viem\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\nimport { AccountNotFoundError } from \"@alchemy/common\";\nimport { LOGGER } from \"../logger.js\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_prepareSign\";\n    };\n  }\n>;\n\nexport type PrepareSignParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<\n  OptionalChainId<Omit<RpcSchema[\"Request\"][\"params\"][0], \"from\">> &\n    (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never })\n>;\n\nexport type PrepareSignResult = Prettify<RpcSchema[\"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    LOGGER.warn(\"prepareSign:no-from\", { hasClientAccount: !!client.account });\n    throw new AccountNotFoundError();\n  }\n\n  LOGGER.debug(\"prepareSign:start\", { type: params.signatureRequest.type });\n  const res = await client.request({\n    method: \"wallet_prepareSign\",\n    params: [\n      {\n        ...params,\n        from,\n        chainId: params.chainId ?? toHex(client.chain.id),\n      },\n    ],\n  });\n  LOGGER.debug(\"prepareSign:done\");\n  return res;\n}\n"]}

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

@@ -0,0 +1,33 @@
+import type { Address } from "abitype";
+import type { Prettify, UnionOmit } from "viem";
+import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+import type { InnerWalletApiClient, OptionalSignerAddress } from "../types";
+type RpcSchema = Extract<WalletServerRpcSchemaType, {
+    Request: {
+        method: "wallet_requestAccount";
+    };
+}>;
+export type RequestAccountParams = Prettify<OptionalSignerAddress<UnionOmit<RpcSchema["Request"]["params"][0], "includeCounterfactualInfo">>>;
+export type RequestAccountResult = Prettify<{
+    address: Address;
+}>;
+/**
+ * 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 {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 an object containing a smart account address
+ *
+ * @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, params?: RequestAccountParams): Promise<RequestAccountResult>;
+export {};