@alchemy/wallet-apis 0.0.0-alpha.17 → 0.0.0-alpha.19

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

@@ -1,17 +1,15 @@
-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";
-    };
+import type { Prettify } from "viem";
+import type { DistributiveOmit, InnerWalletApiClient } from "../types.ts";
+import { wallet_formatSign as MethodSchema } from "@alchemy/wallet-api-types/rpc";
+import { type AccountParam } from "../utils/resolve.js";
+import { type MethodParams, type MethodResponse } from "../utils/schema.js";
+type BaseFormatSignParams = MethodParams<typeof MethodSchema>;
+type FormatSignResponse = MethodResponse<typeof MethodSchema>;
+export type FormatSignParams = Prettify<DistributiveOmit<BaseFormatSignParams, "from" | "chainId"> & {
+    account?: AccountParam;
+    chainId?: number;
 }>;
-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"]>;
+export type FormatSignResult = FormatSignResponse;
 /**
  * Formats a signature request for signing messages or transactions.
  *
@@ -23,7 +21,7 @@ export type FormatSignResult = Prettify<RpcSchema["ReturnType"]>;
  * ```ts
  * // Formats a signature
  * const result = await client.formatSign({
- *    from: "0x1234...",
+ *    account: "0x1234...",
  *    signature: {
  *      type: "ecdsa",
  *      data: "0xabcd..."
@@ -31,5 +29,5 @@ export type FormatSignResult = Prettify<RpcSchema["ReturnType"]>;
  * });
  * ```
  */
-export declare function formatSign<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: FormatSignParams<TAccount>): Promise<FormatSignResult>;
+export declare function formatSign(client: InnerWalletApiClient, params: FormatSignParams): Promise<FormatSignResult>;
 export {};

package/dist/esm/actions/formatSign.js

@@ -1,6 +1,9 @@
-import { toHex } from "viem";
-import { AccountNotFoundError } from "@alchemy/common";
+import { wallet_formatSign as MethodSchema } from "@alchemy/wallet-api-types/rpc";
 import { LOGGER } from "../logger.js";
+import { resolveAddress } from "../utils/resolve.js";
+import { Value } from "typebox/value";
+import { methodSchema, } from "../utils/schema.js";
+const schema = methodSchema(MethodSchema);
 /**
  * Formats a signature request for signing messages or transactions.
  *
@@ -12,7 +15,7 @@ import { LOGGER } from "../logger.js";
  * ```ts
  * // Formats a signature
  * const result = await client.formatSign({
- *    from: "0x1234...",
+ *    account: "0x1234...",
  *    signature: {
  *      type: "ecdsa",
  *      data: "0xabcd..."
@@ -21,18 +24,21 @@ import { LOGGER } from "../logger.js";
  * ```
  */
 export async function formatSign(client, params) {
-    const from = params.from ?? client.account?.address;
-    if (!from) {
-        throw new AccountNotFoundError();
-    }
+    const from = params.account
+        ? resolveAddress(params.account)
+        : client.account.address;
     LOGGER.debug("formatSign:start");
-    const res = await client.request({
+    const { account: _, chainId: __, ...rest } = params;
+    const rpcParams = Value.Encode(schema.request, {
+        ...rest,
+        from,
+        chainId: params.chainId ?? client.chain.id,
+    });
+    const rpcResp = await client.request({
         method: "wallet_formatSign",
-        params: [
-            { ...params, from, chainId: params.chainId ?? toHex(client.chain.id) },
-        ],
+        params: [rpcParams],
     });
     LOGGER.debug("formatSign:done");
-    return res;
+    return Value.Decode(schema.response, rpcResp);
 }
 //# sourceMappingURL=formatSign.js.map

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

@@ -1 +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"]}
+{"version":3,"file":"formatSign.js","sourceRoot":"","sources":["../../../src/actions/formatSign.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClF,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,cAAc,EAAqB,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EACL,YAAY,GAGb,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAa1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,MAA4B,EAC5B,MAAwB;IAExB,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO;QACzB,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC;QAChC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;IAE3B,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;IAEjC,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC;IACpD,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE;QAC7C,GAAG,IAAI;QACP,IAAI;QACJ,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE;KACZ,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QACnC,MAAM,EAAE,mBAAmB;QAC3B,MAAM,EAAE,CAAC,SAAS,CAAC;KACpB,CAAC,CAAC;IAEH,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAChC,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AAChD,CAAC","sourcesContent":["import type { Prettify } from \"viem\";\nimport type { DistributiveOmit, InnerWalletApiClient } from \"../types.ts\";\nimport { wallet_formatSign as MethodSchema } from \"@alchemy/wallet-api-types/rpc\";\nimport { LOGGER } from \"../logger.js\";\nimport { resolveAddress, type AccountParam } from \"../utils/resolve.js\";\nimport { Value } from \"typebox/value\";\nimport {\n  methodSchema,\n  type MethodParams,\n  type MethodResponse,\n} from \"../utils/schema.js\";\n\nconst schema = methodSchema(MethodSchema);\ntype BaseFormatSignParams = MethodParams<typeof MethodSchema>;\ntype FormatSignResponse = MethodResponse<typeof MethodSchema>;\n\nexport type FormatSignParams = Prettify<\n  DistributiveOmit<BaseFormatSignParams, \"from\" | \"chainId\"> & {\n    account?: AccountParam;\n    chainId?: number;\n  }\n>;\n\nexport type FormatSignResult = FormatSignResponse;\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 *    account: \"0x1234...\",\n *    signature: {\n *      type: \"ecdsa\",\n *      data: \"0xabcd...\"\n *    },\n * });\n * ```\n */\nexport async function formatSign(\n  client: InnerWalletApiClient,\n  params: FormatSignParams,\n): Promise<FormatSignResult> {\n  const from = params.account\n    ? resolveAddress(params.account)\n    : client.account.address;\n\n  LOGGER.debug(\"formatSign:start\");\n\n  const { account: _, chainId: __, ...rest } = params;\n  const rpcParams = Value.Encode(schema.request, {\n    ...rest,\n    from,\n    chainId: params.chainId ?? client.chain.id,\n  } satisfies BaseFormatSignParams);\n\n  const rpcResp = await client.request({\n    method: \"wallet_formatSign\",\n    params: [rpcParams],\n  });\n\n  LOGGER.debug(\"formatSign:done\");\n  return Value.Decode(schema.response, rpcResp);\n}\n"]}

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

@@ -0,0 +1,27 @@
+import type { InnerWalletApiClient } from "../types.js";
+import { type AccountParam } from "../utils/resolve.js";
+export type GetCapabilitiesParams = {
+    account?: AccountParam;
+    chainId?: number;
+};
+export type GetCapabilitiesResult = Record<string, unknown>;
+/**
+ * Gets the capabilities supported by the wallet for the given account.
+ * Delegates to viem's `getCapabilities` and renames `paymasterService`
+ * to `paymaster` for consistency with the SDK's public API.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {GetCapabilitiesParams} [params] - Optional parameters
+ * @param {AccountParam} [params.account] - The account to query capabilities for. Can be an address string or an object with an `address` property. Defaults to the client's account.
+ * @param {number} [params.chainId] - Optional chain ID to filter capabilities for. Defaults to the client's chain ID.
+ * @returns {Promise<GetCapabilitiesResult>} The capabilities for the given chain
+ *
+ * @example
+ * ```ts
+ * const capabilities = await client.getCapabilities({
+ *   account: "0x1234...",
+ * });
+ * // { paymaster: { supported: true }, atomic: { status: "supported" } }
+ * ```
+ */
+export declare function getCapabilities(client: InnerWalletApiClient, params?: GetCapabilitiesParams): Promise<GetCapabilitiesResult>;

package/dist/esm/actions/getCapabilities.js

@@ -0,0 +1,49 @@
+import { getCapabilities as viemGetCapabilities } from "viem/actions";
+import { resolveAddress } from "../utils/resolve.js";
+/**
+ * Gets the capabilities supported by the wallet for the given account.
+ * Delegates to viem's `getCapabilities` and renames `paymasterService`
+ * to `paymaster` for consistency with the SDK's public API.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {GetCapabilitiesParams} [params] - Optional parameters
+ * @param {AccountParam} [params.account] - The account to query capabilities for. Can be an address string or an object with an `address` property. Defaults to the client's account.
+ * @param {number} [params.chainId] - Optional chain ID to filter capabilities for. Defaults to the client's chain ID.
+ * @returns {Promise<GetCapabilitiesResult>} The capabilities for the given chain
+ *
+ * @example
+ * ```ts
+ * const capabilities = await client.getCapabilities({
+ *   account: "0x1234...",
+ * });
+ * // { paymaster: { supported: true }, atomic: { status: "supported" } }
+ * ```
+ */
+export async function getCapabilities(client, params) {
+    const account = params?.account
+        ? resolveAddress(params.account)
+        : client.account.address;
+    const chainId = params?.chainId ?? client.chain.id;
+    // Don't pass chainId to viem — the Alchemy API keys capabilities by a
+    // generic identifier (0) rather than the actual chain ID, so viem's
+    // chainId-based lookup would return undefined.
+    const viemResult = await viemGetCapabilities(client, { account });
+    // Look for capabilities matching the requested chainId, falling back to
+    // the generic "0" key that the Alchemy API uses.
+    const chainCaps = viemResult[chainId] ?? viemResult[0];
+    if (!chainCaps)
+        return {};
+    const result = {};
+    for (const [key, value] of Object.entries(chainCaps)) {
+        // Our paymaster capability interface is non-standard, so we rename it
+        // from `paymasterService` to `paymaster` when used in our SDK client.
+        if (key === "paymasterService") {
+            result["paymaster"] = value;
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=getCapabilities.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getCapabilities.js","sourceRoot":"","sources":["../../../src/actions/getCapabilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,IAAI,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEtE,OAAO,EAAE,cAAc,EAAqB,MAAM,qBAAqB,CAAC;AASxE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,MAA4B,EAC5B,MAA8B;IAE9B,MAAM,OAAO,GAAG,MAAM,EAAE,OAAO;QAC7B,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC;QAChC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;IAE3B,MAAM,OAAO,GAAG,MAAM,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IAEnD,sEAAsE;IACtE,oEAAoE;IACpE,+CAA+C;IAC/C,MAAM,UAAU,GAAG,MAAM,mBAAmB,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAElE,wEAAwE;IACxE,iDAAiD;IACjD,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAEvD,IAAI,CAAC,SAAS;QAAE,OAAO,EAAE,CAAC;IAE1B,MAAM,MAAM,GAA4B,EAAE,CAAC;IAC3C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QACrD,sEAAsE;QACtE,sEAAsE;QACtE,IAAI,GAAG,KAAK,kBAAkB,EAAE,CAAC;YAC/B,MAAM,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACtB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import { getCapabilities as viemGetCapabilities } from \"viem/actions\";\nimport type { InnerWalletApiClient } from \"../types.js\";\nimport { resolveAddress, type AccountParam } from \"../utils/resolve.js\";\n\nexport type GetCapabilitiesParams = {\n  account?: AccountParam;\n  chainId?: number;\n};\n\nexport type GetCapabilitiesResult = Record<string, unknown>;\n\n/**\n * Gets the capabilities supported by the wallet for the given account.\n * Delegates to viem's `getCapabilities` and renames `paymasterService`\n * to `paymaster` for consistency with the SDK's public API.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {GetCapabilitiesParams} [params] - Optional parameters\n * @param {AccountParam} [params.account] - The account to query capabilities for. Can be an address string or an object with an `address` property. Defaults to the client's account.\n * @param {number} [params.chainId] - Optional chain ID to filter capabilities for. Defaults to the client's chain ID.\n * @returns {Promise<GetCapabilitiesResult>} The capabilities for the given chain\n *\n * @example\n * ```ts\n * const capabilities = await client.getCapabilities({\n *   account: \"0x1234...\",\n * });\n * // { paymaster: { supported: true }, atomic: { status: \"supported\" } }\n * ```\n */\nexport async function getCapabilities(\n  client: InnerWalletApiClient,\n  params?: GetCapabilitiesParams,\n): Promise<GetCapabilitiesResult> {\n  const account = params?.account\n    ? resolveAddress(params.account)\n    : client.account.address;\n\n  const chainId = params?.chainId ?? client.chain.id;\n\n  // Don't pass chainId to viem — the Alchemy API keys capabilities by a\n  // generic identifier (0) rather than the actual chain ID, so viem's\n  // chainId-based lookup would return undefined.\n  const viemResult = await viemGetCapabilities(client, { account });\n\n  // Look for capabilities matching the requested chainId, falling back to\n  // the generic \"0\" key that the Alchemy API uses.\n  const chainCaps = viemResult[chainId] ?? viemResult[0];\n\n  if (!chainCaps) return {};\n\n  const result: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(chainCaps)) {\n    // Our paymaster capability interface is non-standard, so we rename it\n    // from `paymasterService` to `paymaster` when used in our SDK client.\n    if (key === \"paymasterService\") {\n      result[\"paymaster\"] = value;\n    } else {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n"]}

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

@@ -1,17 +1,13 @@
-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";
-    };
+import { type Hex, type Prettify } from "viem";
+import type { DistributiveOmit, InnerWalletApiClient } from "../types.ts";
+import { wallet_createSession as MethodSchema } from "@alchemy/wallet-api-types/rpc";
+import { type AccountParam } from "../utils/resolve.js";
+import { type MethodParams } from "../utils/schema.js";
+type BaseCreateSessionParams = MethodParams<typeof MethodSchema>;
+export type GrantPermissionsParams = Prettify<DistributiveOmit<BaseCreateSessionParams, "account" | "chainId"> & {
+    account?: AccountParam;
+    chainId?: number;
 }>;
-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;
 }>;
@@ -21,7 +17,7 @@ export type GrantPermissionsResult = Prettify<{
  *
  * @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 {AccountParam} [params.account] - The account (required if client was not initialized with an account). Can be an address string or an object with an `address` property.
  * @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
@@ -47,10 +43,10 @@ export type GrantPermissionsResult = Prettify<{
  *
  * // Use the permissions to prepare a call
  * const preparedCalls = await client.prepareCalls({
- *   calls: [{ to: zeroAddress, value: "0x0" }],
+ *   calls: [{ to: zeroAddress, value: 0n }],
  *   from: account.address,
  *   capabilities: {
- *     paymasterService: {
+ *     paymaster: {
  *       policyId: "your-paymaster-policy-id",
  *     },
  *     permissions,
@@ -69,5 +65,5 @@ export type GrantPermissionsResult = Prettify<{
  * });
  * ```
  */
-export declare function grantPermissions<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: GrantPermissionsParams<TAccount>): Promise<GrantPermissionsResult>;
+export declare function grantPermissions(client: InnerWalletApiClient, params: GrantPermissionsParams): Promise<GrantPermissionsResult>;
 export {};

package/dist/esm/actions/grantPermissions.js

@@ -1,15 +1,18 @@
-import { toHex, concatHex, } from "viem";
+import { concatHex } from "viem";
+import { wallet_createSession as MethodSchema } from "@alchemy/wallet-api-types/rpc";
 import { signSignatureRequest } from "./signSignatureRequest.js";
-import { AccountNotFoundError, BaseError } from "@alchemy/common";
 import { LOGGER } from "../logger.js";
-import { isWebAuthnAccount } from "../utils/assertions.js";
+import { Value } from "typebox/value";
+import { resolveAddress } from "../utils/resolve.js";
+import { methodSchema } from "../utils/schema.js";
+const schema = methodSchema(MethodSchema);
 /**
  * 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 {AccountParam} [params.account] - The account (required if client was not initialized with an account). Can be an address string or an object with an `address` property.
  * @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
@@ -35,10 +38,10 @@ import { isWebAuthnAccount } from "../utils/assertions.js";
  *
  * // Use the permissions to prepare a call
  * const preparedCalls = await client.prepareCalls({
- *   calls: [{ to: zeroAddress, value: "0x0" }],
+ *   calls: [{ to: zeroAddress, value: 0n }],
  *   from: account.address,
  *   capabilities: {
- *     paymasterService: {
+ *     paymaster: {
  *       policyId: "your-paymaster-policy-id",
  *     },
  *     permissions,
@@ -58,34 +61,28 @@ import { isWebAuthnAccount } from "../utils/assertions.js";
  * ```
  */
 export async function grantPermissions(client, params) {
-    const account = params.account ?? client.account?.address;
-    if (!account) {
-        LOGGER.warn("grantPermissions:no-account");
-        throw new AccountNotFoundError();
-    }
-    if (isWebAuthnAccount(client.owner)) {
-        LOGGER.warn("grantPermissions:unsupported-account");
-        throw new BaseError("WebAuthn signer is not currently supported for grantPermissions");
-    }
+    const account = params.account
+        ? resolveAddress(params.account)
+        : client.account.address;
     LOGGER.debug("grantPermissions:start", { expirySec: params.expirySec });
-    const { sessionId, signatureRequest } = await client.request({
+    const chainId = params.chainId ?? client.chain.id;
+    const { account: _, chainId: __, ...rest } = params;
+    const rpcParams = Value.Encode(schema.request, {
+        ...rest,
+        account,
+        chainId,
+    });
+    const rpcResp = await client.request({
         method: "wallet_createSession",
-        params: [
-            {
-                ...params,
-                account,
-                chainId: params.chainId ?? toHex(client.chain.id),
-            },
-        ],
+        params: [rpcParams],
     });
+    const { sessionId, signatureRequest } = Value.Decode(schema.response, rpcResp);
     const signature = await signSignatureRequest(client, signatureRequest);
     const res = {
         context: concatHex([
             "0x00", // Remote mode.
             sessionId,
-            signature.type === "webauthn-p256"
-                ? signature.data.signature
-                : signature.data,
+            signature.data,
         ]),
     };
     LOGGER.debug("grantPermissions:done");

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

@@ -1 +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,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAwB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,IAAI,iBAAiB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACpC,MAAM,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;QACpD,MAAM,IAAI,SAAS,CACjB,iEAAiE,CAClE,CAAC;IACJ,CAAC;IAED,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;IAEvE,MAAM,GAAG,GAAG;QACV,OAAO,EAAE,SAAS,CAAC;YACjB,MAAM,EAAE,eAAe;YACvB,SAAS;YACT,SAAS,CAAC,IAAI,KAAK,eAAe;gBAChC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS;gBAC1B,CAAC,CAAC,SAAS,CAAC,IAAI;SACnB,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, BaseError } from \"@alchemy/common\";\nimport { LOGGER } from \"../logger.js\";\nimport type { OptionalChainId } from \"../types.ts\";\nimport { isWebAuthnAccount } from \"../utils/assertions.js\";\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  if (isWebAuthnAccount(client.owner)) {\n    LOGGER.warn(\"grantPermissions:unsupported-account\");\n    throw new BaseError(\n      \"WebAuthn signer is not currently supported for grantPermissions\",\n    );\n  }\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\n  const res = {\n    context: concatHex([\n      \"0x00\", // Remote mode.\n      sessionId,\n      signature.type === \"webauthn-p256\"\n        ? signature.data.signature\n        : signature.data,\n    ]),\n  } as const;\n  LOGGER.debug(\"grantPermissions:done\");\n  return res;\n}\n"]}
+{"version":3,"file":"grantPermissions.js","sourceRoot":"","sources":["../../../src/actions/grantPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,SAAS,EAAE,MAAM,MAAM,CAAC;AAE1D,OAAO,EAAE,oBAAoB,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,cAAc,EAAqB,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAqB,MAAM,oBAAoB,CAAC;AAErE,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAc1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,MAA4B,EAC5B,MAA8B;IAE9B,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO;QAC5B,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC;QAChC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;IAE3B,MAAM,CAAC,KAAK,CAAC,wBAAwB,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;IAExE,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IAElD,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC;IACpD,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE;QAC7C,GAAG,IAAI;QACP,OAAO;QACP,OAAO;KAC0B,CAAC,CAAC;IAErC,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QACnC,MAAM,EAAE,sBAAsB;QAC9B,MAAM,EAAE,CAAC,SAAS,CAAC;KACpB,CAAC,CAAC;IAEH,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,KAAK,CAAC,MAAM,CAClD,MAAM,CAAC,QAAQ,EACf,OAAO,CAIR,CAAC;IAEF,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAEvE,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 { type Hex, type Prettify, concatHex } from \"viem\";\nimport type { DistributiveOmit, InnerWalletApiClient } from \"../types.ts\";\nimport { wallet_createSession as MethodSchema } from \"@alchemy/wallet-api-types/rpc\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport { LOGGER } from \"../logger.js\";\nimport { Value } from \"typebox/value\";\nimport { resolveAddress, type AccountParam } from \"../utils/resolve.js\";\nimport { methodSchema, type MethodParams } from \"../utils/schema.js\";\n\nconst schema = methodSchema(MethodSchema);\ntype BaseCreateSessionParams = MethodParams<typeof MethodSchema>;\n\nexport type GrantPermissionsParams = Prettify<\n  DistributiveOmit<BaseCreateSessionParams, \"account\" | \"chainId\"> & {\n    account?: AccountParam;\n    chainId?: number;\n  }\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 {AccountParam} [params.account] - The account (required if client was not initialized with an account). Can be an address string or an object with an `address` property.\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: 0n }],\n *   from: account.address,\n *   capabilities: {\n *     paymaster: {\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  client: InnerWalletApiClient,\n  params: GrantPermissionsParams,\n): Promise<GrantPermissionsResult> {\n  const account = params.account\n    ? resolveAddress(params.account)\n    : client.account.address;\n\n  LOGGER.debug(\"grantPermissions:start\", { expirySec: params.expirySec });\n\n  const chainId = params.chainId ?? client.chain.id;\n\n  const { account: _, chainId: __, ...rest } = params;\n  const rpcParams = Value.Encode(schema.request, {\n    ...rest,\n    account,\n    chainId,\n  } satisfies BaseCreateSessionParams);\n\n  const rpcResp = await client.request({\n    method: \"wallet_createSession\",\n    params: [rpcParams],\n  });\n\n  const { sessionId, signatureRequest } = Value.Decode(\n    schema.response,\n    rpcResp,\n  ) satisfies {\n    sessionId: Hex;\n    signatureRequest: Parameters<typeof signSignatureRequest>[1];\n  };\n\n  const signature = await signSignatureRequest(client, signatureRequest);\n\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

@@ -1,23 +1,14 @@
-import type { InnerWalletApiClient } from "../types.ts";
+import type { DistributiveOmit, InnerWalletApiClient } from "../types.ts";
 import type { Address, Prettify } from "viem";
-import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
-import type { WebAuthnPublicKey } from "@alchemy/wallet-api-types";
-type RpcSchema = Extract<WalletServerRpcSchemaType, {
-    Request: {
-        method: "wallet_listAccounts";
-    };
-}>;
-export type ListAccountsParams = Prettify<Omit<RpcSchema["Request"]["params"][0], "signerAddress"> & ({
+import { wallet_listAccounts as MethodSchema } from "@alchemy/wallet-api-types/rpc";
+import { type MethodParams, type MethodResponse } from "../utils/schema.js";
+type BaseListAccountsParams = MethodParams<typeof MethodSchema>;
+type ListAccountsResponse = MethodResponse<typeof MethodSchema>;
+export type ListAccountsParams = Prettify<DistributiveOmit<BaseListAccountsParams, "signerAddress" | "signerPublicKey"> & {
     signerAddress?: Address;
     signerPublicKey?: never;
-} | {
-    signerPublicKey: WebAuthnPublicKey;
-    signerAddress?: never;
-} | {
-    signerAddress?: never;
-    signerPublicKey?: never;
-})>;
-export type ListAccountsResult = Prettify<RpcSchema["ReturnType"]>;
+}>;
+export type ListAccountsResult = ListAccountsResponse;
 /**
  * Lists all smart accounts for a given signer using the wallet API client.
  *

package/dist/esm/actions/listAccounts.js

@@ -1,5 +1,9 @@
 import { LOGGER } from "../logger.js";
-import { getSignerAddressOrPublicKey } from "../utils/signer.js";
+import { wallet_listAccounts as MethodSchema } from "@alchemy/wallet-api-types/rpc";
+import { isLocalAccount } from "../utils/assertions.js";
+import { Value } from "typebox/value";
+import { methodSchema, } from "../utils/schema.js";
+const schema = methodSchema(MethodSchema);
 /**
  * Lists all smart accounts for a given signer using the wallet API client.
  *
@@ -27,37 +31,20 @@ import { getSignerAddressOrPublicKey } from "../utils/signer.js";
  * ```
  */
 export async function listAccounts(client, params) {
-    const owner = getSignerAddressOrPublicKey(client.owner);
-    // Coalesce:
-    // signerAddress or signerPublicKey in params takes priority.
-    // if not present, then fallback to client's attached signer.
-    const signerParam = params.signerAddress
-        ? { signerAddress: params.signerAddress }
-        : params.signerPublicKey
-            ? {
-                signerPublicKey: {
-                    type: "webauthn-p256",
-                    ...params.signerPublicKey,
-                },
-            }
-            : owner.type === "webauthn-p256"
-                ? {
-                    signerPublicKey: {
-                        type: "webauthn-p256",
-                        ...owner.publicKey,
-                    },
-                }
-                : { signerAddress: owner.address };
+    const signerAddress = params.signerAddress ??
+        (isLocalAccount(client.owner)
+            ? client.owner.address
+            : client.owner.account.address);
     LOGGER.debug("listAccounts:start", { hasAfter: !!params.after });
-    const res = await client.request({
+    const rpcParams = Value.Encode(schema.request, {
+        ...params,
+        signerAddress,
+    });
+    const rpcResp = await client.request({
         method: "wallet_listAccounts",
-        params: [
-            {
-                ...params,
-                ...signerParam,
-            },
-        ],
+        params: [rpcParams],
     });
+    const res = Value.Decode(schema.response, rpcResp);
     LOGGER.debug("listAccounts:done", { count: res.accounts.length });
     return res;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"listAccounts.js","sourceRoot":"","sources":["../../../src/actions/listAccounts.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AA6BjE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAA4B,EAC5B,MAA0B;IAE1B,MAAM,KAAK,GAAG,2BAA2B,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAExD,YAAY;IACZ,6DAA6D;IAC7D,6DAA6D;IAC7D,MAAM,WAAW,GAAsC,MAAM,CAAC,aAAa;QACzE,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,aAAa,EAAE;QACzC,CAAC,CAAC,MAAM,CAAC,eAAe;YACtB,CAAC,CAAC;gBACE,eAAe,EAAE;oBACf,IAAI,EAAE,eAAe;oBACrB,GAAG,MAAM,CAAC,eAAe;iBAC1B;aACF;YACH,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,eAAe;gBAC9B,CAAC,CAAC;oBACE,eAAe,EAAE;wBACf,IAAI,EAAE,eAAe;wBACrB,GAAG,KAAK,CAAC,SAAS;qBACnB;iBACF;gBACH,CAAC,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IAEzC,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,GAAG,WAAW;aACf;SACF;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAElE,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\";\nimport { getSignerAddressOrPublicKey } from \"../utils/signer.js\";\nimport type { WebAuthnPublicKey } from \"@alchemy/wallet-api-types\";\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    (\n      | {\n          signerAddress?: Address;\n          signerPublicKey?: never;\n        }\n      | { signerPublicKey: WebAuthnPublicKey; signerAddress?: never }\n      | {\n          signerAddress?: never;\n          signerPublicKey?: never;\n        }\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 owner = getSignerAddressOrPublicKey(client.owner);\n\n  // Coalesce:\n  // signerAddress or signerPublicKey in params takes priority.\n  // if not present, then fallback to client's attached signer.\n  const signerParam: RpcSchema[\"Request\"][\"params\"][0] = params.signerAddress\n    ? { signerAddress: params.signerAddress }\n    : params.signerPublicKey\n      ? {\n          signerPublicKey: {\n            type: \"webauthn-p256\",\n            ...params.signerPublicKey,\n          },\n        }\n      : owner.type === \"webauthn-p256\"\n        ? {\n            signerPublicKey: {\n              type: \"webauthn-p256\",\n              ...owner.publicKey,\n            },\n          }\n        : { signerAddress: owner.address };\n\n  LOGGER.debug(\"listAccounts:start\", { hasAfter: !!params.after });\n  const res = await client.request({\n    method: \"wallet_listAccounts\",\n    params: [\n      {\n        ...params,\n        ...signerParam,\n      },\n    ],\n  });\n  LOGGER.debug(\"listAccounts:done\", { count: res.accounts.length });\n\n  return res;\n}\n"]}
+{"version":3,"file":"listAccounts.js","sourceRoot":"","sources":["../../../src/actions/listAccounts.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,mBAAmB,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EACL,YAAY,GAGb,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAgB1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAA4B,EAC5B,MAA0B;IAE1B,MAAM,aAAa,GACjB,MAAM,CAAC,aAAa;QACpB,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC;YAC3B,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO;YACtB,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEpC,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IAEjE,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE;QAC7C,GAAG,MAAM;QACT,aAAa;KACmB,CAAC,CAAC;IAEpC,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QACnC,MAAM,EAAE,qBAAqB;QAC7B,MAAM,EAAE,CAAC,SAAS,CAAC;KACpB,CAAC,CAAC;IAEH,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CACtB,MAAM,CAAC,QAAQ,EACf,OAAO,CACqB,CAAC;IAC/B,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAElE,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { DistributiveOmit, InnerWalletApiClient } from \"../types.ts\";\nimport { LOGGER } from \"../logger.js\";\nimport type { Address, Prettify } from \"viem\";\nimport { wallet_listAccounts as MethodSchema } from \"@alchemy/wallet-api-types/rpc\";\nimport { isLocalAccount } from \"../utils/assertions.js\";\nimport { Value } from \"typebox/value\";\nimport {\n  methodSchema,\n  type MethodParams,\n  type MethodResponse,\n} from \"../utils/schema.js\";\n\nconst schema = methodSchema(MethodSchema);\ntype BaseListAccountsParams = MethodParams<typeof MethodSchema>;\ntype ListAccountsResponse = MethodResponse<typeof MethodSchema>;\n\nexport type ListAccountsParams = Prettify<\n  DistributiveOmit<\n    BaseListAccountsParams,\n    \"signerAddress\" | \"signerPublicKey\"\n  > & {\n    signerAddress?: Address;\n    signerPublicKey?: never;\n  }\n>;\n\nexport type ListAccountsResult = ListAccountsResponse;\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 =\n    params.signerAddress ??\n    (isLocalAccount(client.owner)\n      ? client.owner.address\n      : client.owner.account.address);\n\n  LOGGER.debug(\"listAccounts:start\", { hasAfter: !!params.after });\n\n  const rpcParams = Value.Encode(schema.request, {\n    ...params,\n    signerAddress,\n  } satisfies BaseListAccountsParams);\n\n  const rpcResp = await client.request({\n    method: \"wallet_listAccounts\",\n    params: [rpcParams],\n  });\n\n  const res = Value.Decode(\n    schema.response,\n    rpcResp,\n  ) satisfies ListAccountsResult;\n  LOGGER.debug(\"listAccounts:done\", { count: res.accounts.length });\n\n  return res;\n}\n"]}

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

@@ -1,44 +1,46 @@
-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"]>;
+import type { Prettify } from "viem";
+import type { DistributiveOmit, InnerWalletApiClient } from "../types.ts";
+import { type WithCapabilities } from "../utils/capabilities.js";
+import { type AccountParam } from "../utils/resolve.js";
+import { wallet_prepareCalls as MethodSchema } from "@alchemy/wallet-api-types/rpc";
+import { type MethodParams, type MethodResponse } from "../utils/schema.js";
+type BasePrepareCallsParams = MethodParams<typeof MethodSchema>;
+type PrepareCallsResponse = MethodResponse<typeof MethodSchema>;
+export type PrepareCallsParams = Prettify<WithCapabilities<DistributiveOmit<BasePrepareCallsParams, "from" | "chainId"> & {
+    account?: AccountParam;
+    chainId?: number;
+}>>;
+export type PrepareCallsResult = PrepareCallsResponse;
 /**
  * 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)
+ * The client defaults to using EIP-7702 with the signer's address, so you can call
+ * this directly without first calling `requestAccount`.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {PrepareCallsParams} params - Parameters for preparing calls
+ * @param {Array<{to: Address, data?: Hex, value?: bigint}>} params.calls - Array of contract calls to execute
+ * @param {AccountParam} [params.account] - The account to execute the calls from. Can be an address string or an object with an `address` property. Defaults to the client's account (signer address via EIP-7702).
  * @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
+ * // Prepare a sponsored user operation call (uses signer address via EIP-7702 by default)
  * const result = await client.prepareCalls({
  *   calls: [{
  *     to: "0x1234...",
  *     data: "0xabcdef...",
- *     value: "0x0"
+ *     value: 0n
  *   }],
  *   capabilities: {
- *     paymasterService: { policyId: "your-policy-id" }
+ *     paymaster: { policyId: "your-policy-id" }
  *   }
  * });
  * ```
  */
-export declare function prepareCalls<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: PrepareCallsParams<TAccount>): Promise<PrepareCallsResult>;
+export declare function prepareCalls(client: InnerWalletApiClient, params: PrepareCallsParams): Promise<PrepareCallsResult>;
 export {};