@account-kit/wallet-client 0.1.0-alpha.9 → 4.50.1

package/src/client/actions/grantPermissions.ts

@@ -1,14 +1,30 @@
 import { AccountNotFoundError, type SmartAccountSigner } from "@aa-sdk/core";
-import { type Address, type Hex, type IsUndefined, toHex } from "viem";
-import type { CreateSessionParams } from "../../isomorphic/actions/createSession.ts";
+import {
+  toHex,
+  type Address,
+  type Hex,
+  type IsUndefined,
+  type Prettify,
+} from "viem";
 import type { InnerWalletApiClient } from "../../types.ts";
+import type { Static } from "@sinclair/typebox";
+import { wallet_createSession } from "@alchemy/wallet-api-types/rpc";
+import { encodePermissionsContext } from "@alchemy/wallet-api-types/capabilities";
+import { signSignatureRequest } from "./signSignatureRequest.js";
 
 export type GrantPermissionsParams<
   TAccount extends Address | undefined = Address | undefined,
-> = Omit<CreateSessionParams, "account" | "chainId"> &
-  (IsUndefined<TAccount> extends true
-    ? { account: Address }
-    : { account?: never });
+> = Prettify<
+  Omit<
+    Static<
+      (typeof wallet_createSession)["properties"]["Request"]["properties"]["params"]
+    >[0],
+    "account" | "chainId"
+  > &
+    (IsUndefined<TAccount> extends true
+      ? { account: Address }
+      : { account?: never })
+>;
 
 export type GrantPermissionsResult = {
   context: Hex;
@@ -23,21 +39,21 @@ export type GrantPermissionsResult = {
  * @param {GrantPermissionsParams} params - The parameters for granting permissions
  * @param {Address} [params.account] - The account address (required if client was not initialized with an account)
  * @param {number} params.expirySec - Unix timestamp when the permissions expire
- * @param {object} params.key - The session key information
+ * @param {sessionKeyData} params.key - The session key information
  * @param {string} params.key.publicKey - The public key of the session key
  * @param {string} params.key.type - The type of the key (e.g., "secp256k1")
  * @param {Array} params.permissions - Array of permission objects defining what the session key can do
  * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier
- * @returns {Hex} result.context - A hex identifier for the granted permissions context
  *
  * @example
+ * ```ts
  * // Create a session key and grant root permissions
  * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
  * const account = await client.requestAccount();
  *
  * const permissions = await client.grantPermissions({
  *   account: account.address,
- *   expiry: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
  *   key: {
  *     publicKey: await sessionKey.getAddress(),
  *     type: "secp256k1",
@@ -58,10 +74,7 @@ export type GrantPermissionsResult = {
  * });
  *
  * // Sign with the session key
- * const signedCalls = await client.signPreparedCalls(
- *   sessionKey,
- *   preparedCalls,
- * );
+ * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);
  *
  * // Send the prepared call using the session key
  * const result = await client.sendPreparedCalls({
@@ -70,6 +83,7 @@ export type GrantPermissionsResult = {
  *     permissions,
  *   },
  * });
+ * ```
  */
 export async function grantPermissions<
   TAccount extends Address | undefined = Address | undefined,
@@ -79,14 +93,28 @@ export async function grantPermissions<
   params: GrantPermissionsParams<TAccount>,
 ): Promise<GrantPermissionsResult> {
   const account = params.account ?? client.account?.address;
-
   if (!account) {
     throw new AccountNotFoundError();
   }
 
-  return client.grantPermissions(signer, {
-    ...params,
-    account,
-    chainId: toHex(client.chain.id),
+  const { sessionId, signatureRequest } = await client.request({
+    method: "wallet_createSession",
+    params: [
+      {
+        ...params,
+        account,
+        chainId: toHex(client.chain.id),
+      },
+    ],
   });
+
+  const signature = await signSignatureRequest(signer, signatureRequest);
+
+  return {
+    context: encodePermissionsContext({
+      contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
+      sessionId,
+      signature: signature.data,
+    }),
+  };
 }

package/src/client/actions/listAccounts.ts

@@ -1,10 +1,13 @@
 import type { Static } from "@sinclair/typebox";
-import type { wallet_listAccounts } from "../../rpc/request.ts";
+import type { wallet_listAccounts } from "@alchemy/wallet-api-types/rpc";
 import type { InnerWalletApiClient } from "../../types.ts";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { Address } from "viem";
 
-export type ListAccountsParams = Static<
-  typeof wallet_listAccounts
->["Request"]["params"][0];
+export type ListAccountsParams = Omit<
+  Static<typeof wallet_listAccounts>["Request"]["params"][0],
+  "signerAddress"
+> & { signerAddress?: Address };
 
 export type ListAccountsResult = Static<
   typeof wallet_listAccounts
@@ -14,6 +17,7 @@ export type ListAccountsResult = Static<
  * Lists all smart accounts for a given signer using the wallet API client.
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer for which to list accounts
  * @param {ListAccountsParams} params - Parameters for listing accounts
  * @param {string} params.signerAddress - The address of the signer to list accounts for
  * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)
@@ -21,6 +25,7 @@ export type ListAccountsResult = Static<
  * @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...",
@@ -33,10 +38,22 @@ export type ListAccountsResult = Static<
  *   limit: 10,
  *   after: firstPage.meta.after
  * });
+ * ```
  */
 export async function listAccounts(
   client: InnerWalletApiClient,
+  signer: SmartAccountSigner,
   params: ListAccountsParams,
 ): Promise<ListAccountsResult> {
-  return client.request({ method: "wallet_listAccounts", params: [params] });
+  const signerAddress = params.signerAddress ?? (await signer.getAddress());
+
+  return client.request({
+    method: "wallet_listAccounts",
+    params: [
+      {
+        ...params,
+        signerAddress,
+      },
+    ],
+  });
 }

package/src/client/actions/prepareCalls.ts

@@ -1,10 +1,8 @@
 import { AccountNotFoundError } from "@aa-sdk/core";
 import { toHex, type Address, type IsUndefined } from "viem";
-import type {
-  PrepareCallsParams as IsomorphicPrepareCallsParams,
-  PrepareCallsResult as IsomorphicPrepareCallsResult,
-} from "../../isomorphic/actions/prepareCalls.ts";
 import type { InnerWalletApiClient } from "../../types.ts";
+import type { Static } from "@sinclair/typebox";
+import { wallet_prepareCalls } from "@alchemy/wallet-api-types/rpc";
 
 export type GetAccountParam<TAccount> =
   IsUndefined<TAccount> extends true
@@ -13,10 +11,17 @@ export type GetAccountParam<TAccount> =
 
 export type PrepareCallsParams<
   TAccount extends Address | undefined = Address | undefined,
-> = Omit<IsomorphicPrepareCallsParams, "from" | "chainId"> &
+> = Omit<
+  Static<
+    (typeof wallet_prepareCalls)["properties"]["Request"]["properties"]["params"]
+  >[0],
+  "from" | "chainId"
+> &
   (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });
 
-export type PrepareCallsResult = IsomorphicPrepareCallsResult;
+export type PrepareCallsResult = Static<
+  typeof wallet_prepareCalls
+>["ReturnType"];
 
 /**
  * Prepares a set of contract calls for execution by building a user operation.
@@ -32,6 +37,7 @@ export type PrepareCallsResult = IsomorphicPrepareCallsResult;
  * the user operation data and signature request
  *
  * @example
+ * ```ts
  * // Prepare a sponsored user operation call
  * const result = await client.prepareCalls({
  *   calls: [{
@@ -43,6 +49,7 @@ export type PrepareCallsResult = IsomorphicPrepareCallsResult;
  *     paymasterService: { policyId: "your-policy-id" }
  *   }
  * });
+ * ```
  */
 export async function prepareCalls<
   TAccount extends Address | undefined = Address | undefined,
@@ -51,26 +58,25 @@ export async function prepareCalls<
   params: PrepareCallsParams<TAccount>,
 ): Promise<PrepareCallsResult> {
   const from = params.from ?? client.account?.address;
-
   if (!from) {
     throw new AccountNotFoundError();
   }
 
-  if (client.policyId && !params.capabilities?.paymasterService) {
+  if (client.policyIds && !params.capabilities?.paymasterService) {
     params.capabilities = {
       ...params.capabilities,
-      paymasterService: { policyId: client.policyId },
+      paymasterService: { policyIds: client.policyIds },
     };
   }
 
-  const params_ = {
-    ...params,
-    chainId: toHex(client.chain.id),
-    from,
-  };
-
   return await client.request({
     method: "wallet_prepareCalls",
-    params: [params_],
+    params: [
+      {
+        ...params,
+        chainId: toHex(client.chain.id),
+        from,
+      },
+    ],
   });
 }

package/src/client/actions/prepareSign.ts

@@ -0,0 +1,51 @@
+import type { InnerWalletApiClient } from "../../types.ts";
+import { toHex, type Address, type IsUndefined } from "viem";
+import { AccountNotFoundError } from "@aa-sdk/core";
+import type { Static } from "@sinclair/typebox";
+import { wallet_prepareSign } from "@alchemy/wallet-api-types/rpc";
+
+export type PrepareSignParams<
+  TAccount extends Address | undefined = Address | undefined,
+> = Omit<
+  Static<
+    (typeof wallet_prepareSign)["properties"]["Request"]["properties"]["params"]
+  >[0],
+  "from" | "chainId"
+> &
+  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });
+
+export type PrepareSignResult = Static<typeof wallet_prepareSign>["ReturnType"];
+
+/**
+ * Prepares a signature request for signing messages or transactions.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {PrepareSignParams} params - Parameters for preparing the signature request
+ * @returns {Promise<PrepareSignResult>} A Promise that resolves to the prepare sign result containing a signature request
+ *
+ * @example
+ * ```ts
+ * // Prepare a message to be signed
+ * const result = await client.prepareSign({
+ *    from: "0x1234...",
+ *    type: "personal_sign",
+ *    data: "Hello, world!",
+ * });
+ * ```
+ */
+export async function prepareSign<
+  TAccount extends Address | undefined = Address | undefined,
+>(
+  client: InnerWalletApiClient,
+  params: PrepareSignParams<TAccount>,
+): Promise<PrepareSignResult> {
+  const from = params.from ?? client.account?.address;
+  if (!from) {
+    throw new AccountNotFoundError();
+  }
+
+  return client.request({
+    method: "wallet_prepareSign",
+    params: [{ ...params, from, chainId: toHex(client.chain.id) }],
+  });
+}

package/src/client/actions/requestAccount.ts

@@ -7,10 +7,10 @@ import { Value } from "@sinclair/typebox/value";
 import type { Address } from "abitype";
 import deepEqual from "deep-equal";
 import { custom } from "viem";
-import { createAccount } from "../../isomorphic/utils/createAccount.js";
-import type { wallet_requestAccount } from "../../rpc/request.js";
-import { TypeSerializedInitcode } from "../../schemas.js";
+import type { wallet_requestAccount } from "@alchemy/wallet-api-types/rpc";
+import { SerializedInitcode } from "@alchemy/wallet-api-types";
 import type { InnerWalletApiClient } from "../../types.js";
+import { createAccount } from "../../internal/account.js";
 
 export type RequestAccountParams = Omit<
   Extract<
@@ -35,9 +35,11 @@ export type RequestAccountResult = SmartContractAccount;
  * @returns {Promise<RequestAccountResult>} A Promise that resolves to a SmartContractAccount instance
  *
  * @example
+ * ```ts
  * // Request an account with default parameters using a local signer
  * const signer = LocalAccountSigner.privateKeyToAccountSigner("0x...");
  * const account = await client.requestAccount(signer);
+ * ```
  */
 export async function requestAccount(
   client: InnerWalletApiClient,
@@ -76,7 +78,7 @@ export async function requestAccount(
   const account = await createAccount({
     accountAddress,
     counterfactualInfo: counterfactualInfo
-      ? Value.Parse(TypeSerializedInitcode, counterfactualInfo)
+      ? Value.Parse(SerializedInitcode, counterfactualInfo)
       : undefined,
     delegation,
     chain: client.chain,

package/src/client/actions/sendPreparedCalls.ts

@@ -1,6 +1,6 @@
 import type { Static } from "@sinclair/typebox";
 import { toHex } from "viem";
-import type { wallet_sendPreparedCalls } from "../../rpc/request.ts";
+import type { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
 import type { InnerWalletApiClient, WithoutChainId } from "../../types.ts";
 
 export type SendPreparedCallsParams = WithoutChainId<
@@ -22,6 +22,7 @@ export type SendPreparedCallsResult = Static<
  * @returns {Promise<SendPreparedCallsResult>} A Promise that resolves to the result containing the prepared call IDs
  *
  * @example
+ * ```ts
  * // First prepare the calls
  * const preparedCalls = await client.prepareCalls({
  *   calls: [{
@@ -41,6 +42,7 @@ export type SendPreparedCallsResult = Static<
  * const result = await client.sendPreparedCalls({
  *   signedCalls,
  * });
+ * ```
  */
 export async function sendPreparedCalls(
   client: InnerWalletApiClient,

package/src/client/actions/signMessage.ts

@@ -13,16 +13,19 @@ export type SignMessageResult = Hex;
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
  * @param {SmartAccountSigner} signer - The signer of the smart account
- * @param {SignableMessage} message - The message to sign
+ * @param {SignMessageParams} params - Parameters for signing the message
+ * @param {SignableMessage} params.message - The message to sign using EIP-191. Can be a string, or object with raw bytes.
+ * @param {Address} [params.account] - Optional account address to use for signing. If not provided, uses the client's current account.
  * @returns {Promise<SignMessageResult>} A Promise that resolves to the signed message as a hex string
  *
  * @example
+ * ```ts
  * // Sign a simple text message
  * const signature = await client.signMessage("Hello, world!");
  *
- * @example
  * // Sign a raw hex message
  * const signature = await client.signMessage({ raw: "0x48656c6c6f2c20776f726c6421" });
+ * ```
  */
 export async function signMessage(
   client: InnerWalletApiClient,

package/src/client/actions/signPreparedCalls.ts

@@ -2,12 +2,12 @@ import type { PrepareCallsResult } from "./prepareCalls.ts";
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import { signSignatureRequest } from "./signSignatureRequest.js";
 import type { Static } from "@sinclair/typebox";
-import { wallet_sendPreparedCalls } from "../../rpc/request.js";
+import { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
 import {
-  PreparedCall_Authorization,
-  PreparedCall_UserOpV060,
-  PreparedCall_UserOpV070,
-} from "../../schemas.js";
+  type PreparedCall_Authorization,
+  type PreparedCall_UserOpV060,
+  type PreparedCall_UserOpV070,
+} from "@alchemy/wallet-api-types";
 
 export type SignPreparedCallsParams = PrepareCallsResult;
 
@@ -21,14 +21,12 @@ export type SignPreparedCallsResult = Static<
  * @param {SmartAccountSigner} signer - The signer to use
  * @param {SignPreparedCallsParams} params - The prepared calls with signature requests
  * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls
- **/
+ */
 export async function signPreparedCalls(
   signer: SmartAccountSigner,
   params: SignPreparedCallsParams,
 ): Promise<SignPreparedCallsResult> {
-  const signAuthorizationCall = async (
-    call: Static<typeof PreparedCall_Authorization>,
-  ) => {
+  const signAuthorizationCall = async (call: PreparedCall_Authorization) => {
     const { signatureRequest: _signatureRequest, ...rest } = call;
     const signature = await signSignatureRequest(signer, {
       type: "eip7702Auth",
@@ -44,9 +42,7 @@ export async function signPreparedCalls(
   };
 
   const signUserOperationCall = async (
-    call:
-      | Static<typeof PreparedCall_UserOpV060>
-      | Static<typeof PreparedCall_UserOpV070>,
+    call: PreparedCall_UserOpV060 | PreparedCall_UserOpV070,
   ) => {
     const { signatureRequest, ...rest } = call;
     const signature = await signSignatureRequest(signer, signatureRequest);

package/src/client/actions/signSignatureRequest.ts

@@ -1,21 +1,20 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import type { Static } from "@sinclair/typebox";
 import { type Hex, hexToNumber, serializeSignature } from "viem";
 import { assertNever } from "../../utils.js";
 import {
-  TypeAuthorizationSignatureRequest,
-  TypePersonalSignSignatureRequest,
-  TypeTypedDataSignatureRequest,
-} from "../../schemas.js";
-import { TypeEip7702UnsignedAuth } from "../../schemas.js";
+  type PersonalSignSignatureRequest,
+  type TypedDataSignatureRequest,
+  type AuthorizationSignatureRequest,
+  type Eip7702UnsignedAuth,
+} from "@alchemy/wallet-api-types";
 import { vToYParity } from "ox/Signature";
 import type { WithoutRawPayload } from "../../types.ts";
 
 export type SignSignatureRequestParams = WithoutRawPayload<
-  | Static<typeof TypePersonalSignSignatureRequest>
-  | Static<typeof TypeTypedDataSignatureRequest>
-  | (Static<typeof TypeAuthorizationSignatureRequest> & {
-      data: Static<typeof TypeEip7702UnsignedAuth>;
+  | PersonalSignSignatureRequest
+  | TypedDataSignatureRequest
+  | (AuthorizationSignatureRequest & {
+      data: Eip7702UnsignedAuth;
     })
 >;
 
@@ -31,20 +30,17 @@ export type SignSignatureRequestResult = {
  * @param {SmartAccountSigner} signer - The signer to use for signing the request
  * @param {SignSignatureRequestParams} params - The signature request parameters
  * @param {string} params.type - The type of signature request ('personal_sign', 'eth_signTypedData_v4', or 'signature_with_authorization')
- * @param {any} params.data - The data to sign, format depends on the signature type
+ * @param {SignSignatureRequestParams["data"]} params.data - The data to sign, format depends on the signature type
  * @returns {Promise<SignSignatureRequestResult>} A Promise that resolves to the signature result
- * @returns {string} result.type - The signature type (currently only 'secp256k1' is supported)
- * @returns {Hex} result.signature - The hex-encoded signature
- * @returns {Eip7702ExtendedFields["eip7702Auth"]} result.signedAuthorization - The signed EIP-7702 authorization, if applicable
  *
  * @example
+ * ```ts
  * // Sign a personal message
  * const result = await client.signSignatureRequest({
  *   type: 'personal_sign',
  *   data: 'Hello, world!'
  * });
  *
- * @example
  * // Sign typed data (EIP-712)
  * const result = await client.signSignatureRequest({
  *   type: 'eth_signTypedData_v4',
@@ -55,6 +51,7 @@ export type SignSignatureRequestResult = {
  *     message: { ... }
  *   }
  * });
+ * ```
  */
 
 export async function signSignatureRequest(

package/src/client/actions/signTypedData.ts

@@ -19,6 +19,7 @@ export type SignTypedDataResult = Hex;
  * @returns {Promise<SignTypedDataResult>} A Promise that resolves to the signature as a hex string
  *
  * @example
+ * ```ts
  * // Sign typed data
  * const signature = await client.signTypedData({
  *   domain: {
@@ -39,6 +40,7 @@ export type SignTypedDataResult = Hex;
  *     wallet: '0xAaAaAaAaAaAaAaAaAaAAAAAAAAaaaAaAaAaaAaAa'
  *   }
  * });
+ * ```
  */
 export async function signTypedData(
   client: InnerWalletApiClient,

package/src/client/decorator.ts

@@ -1,11 +1,6 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { Address, Hex } from "viem";
 import type { InnerWalletApiClient } from "../types.ts";
-import {
-  createAccount,
-  type CreateAccountParams,
-  type CreateAccountResult,
-} from "./actions/createAccount.js";
 import {
   getCallsStatus,
   type GetCallsStatusParams,
@@ -64,7 +59,6 @@ export type SmartWalletActions<
   sendPreparedCalls: (
     params: SendPreparedCallsParams,
   ) => Promise<SendPreparedCallsResult>;
-  createAccount: (params: CreateAccountParams) => Promise<CreateAccountResult>;
   listAccounts: (params: ListAccountsParams) => Promise<ListAccountsResult>;
   getCallsStatus: (
     params: GetCallsStatusParams,
@@ -90,9 +84,8 @@ export function smartWalletClientActions<
 ): SmartWalletActions<TAccount> {
   return {
     requestAccount: (params) => requestAccount(client, signer, params),
-    createAccount: (params) => createAccount(client, signer, params),
     prepareCalls: (params) => prepareCalls(client, params),
-    listAccounts: (params) => listAccounts(client, params),
+    listAccounts: (params) => listAccounts(client, signer, params),
     sendPreparedCalls: (params) => sendPreparedCalls(client, params),
     getCallsStatus: (params) => getCallsStatus(client, params),
     signSignatureRequest: (params) => signSignatureRequest(signer, params),

package/src/client/index.ts

@@ -1,24 +1,34 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { AlchemyTransport } from "@account-kit/infra";
-import type { Address, Chain, Prettify } from "viem";
-import { createLocalClient } from "../local/client.js";
-import { createRemoteClient } from "../remote/client.js";
+import {
+  type Address,
+  type Chain,
+  type Prettify,
+  createClient,
+  custom,
+} from "viem";
 import type { InnerWalletApiClient } from "../types.ts";
 import {
   smartWalletClientActions,
   type SmartWalletActions,
 } from "./decorator.js";
+import { Provider } from "ox";
+import { WalletServerRpcSchema } from "@alchemy/wallet-api-types/rpc";
+import { internalStateDecorator } from "../internal/decorator.js";
 
 export type SmartWalletClientParams<
   TAccount extends Address | undefined = Address | undefined,
-> = Prettify<{
-  transport: AlchemyTransport;
-  chain: Chain;
-  signer: SmartAccountSigner;
-  mode: "local" | "remote";
-  policyId?: string;
-  account?: TAccount | Address | undefined;
-}>;
+> = Prettify<
+  {
+    transport: AlchemyTransport;
+    chain: Chain;
+    signer: SmartAccountSigner;
+    account?: TAccount | Address | undefined;
+  } & (
+    | { policyId?: string; policyIds?: never }
+    | { policyIds?: string[]; policyId?: never }
+  )
+>;
 
 export type SmartWalletClient<
   TAccount extends Address | undefined = Address | undefined,
@@ -31,12 +41,12 @@ export type SmartWalletClient<
  * @param {AlchemyTransport} params.transport - The Alchemy transport to use
  * @param {Chain} params.chain - The chain to use
  * @param {SmartAccountSigner} params.signer - The signer to use for the smart account
- * @param {"local" | "remote"} params.mode - The client's mode (local or remote).
  * @param {string} [params.policyId] - The policy ID for gas sponsorship (optional)
  * @param {Address} [params.account] - The smart account address to use (optional)
  * @returns {SmartWalletClient} - A viem-compatible client
  *
  * @example
+ * ```ts
  * import { LocalAccountSigner } from "@aa-sdk/core";
  * import { alchemy, arbitrumSepolia } from "@account-kit/infra";
  * import { generatePrivateKey } from "viem/accounts";
@@ -49,9 +59,9 @@ export type SmartWalletClient<
  * const client = createSmartWalletClient({
  *   transport,
  *   chain: arbitrumSepolia,
- *   mode: "remote",
  *   signer,
  * });
+ * ```
  */
 export function createSmartWalletClient<
   TAccount extends Address | undefined = undefined,
@@ -60,26 +70,26 @@ export function createSmartWalletClient<
 export function createSmartWalletClient(
   params: SmartWalletClientParams,
 ): SmartWalletClient {
-  const { transport, chain, policyId, mode, account, signer } = params;
+  const { transport, chain, account, signer } = params;
+
+  const policyIds = params.policyId
+    ? [params.policyId]
+    : params.policyIds
+      ? params.policyIds
+      : undefined;
 
-  const innerClient =
-    mode === "local"
-      ? createLocalClient({
-          transport,
-          chain,
-          policyId,
-          account,
-        })
-      : createRemoteClient({
-          transport,
-          chain,
-          policyId,
-          account,
-        });
+  const innerClient = createClient({
+    transport: (opts) =>
+      custom(Provider.from(transport(opts), { schema: WalletServerRpcSchema }))(
+        opts,
+      ),
+    chain,
+    account,
+  }).extend(() => ({
+    policyIds,
+    internal: internalStateDecorator(),
+  }));
 
-  // TODO: we need to do a few things here:
-  // 1. decorate the client with the wallet api actions
-  // 2. potentially we might want to make this client async and have it use `requestAccount` so that it can create a SCA client with an account attached to it
   return innerClient.extend((client) =>
     smartWalletClientActions(client, signer),
   );
@@ -90,7 +100,6 @@ export function createSmartWalletClient(
 //   transport: alchemy({ apiKey: "123" }),
 //   chain: baseSepolia,
 //   signer: createDummySigner(zeroAddress),
-//   mode: "local",
 // });
 
 // const account1 = await clientWithoutAccount.requestAccount();
@@ -99,7 +108,6 @@ export function createSmartWalletClient(
 //   transport: alchemy({ apiKey: "123" }),
 //   chain: baseSepolia,
 //   signer: createDummySigner(zeroAddress),
-//   mode: "local",
 //   account: zeroAddress,
 // });