@coinbase/cdp-sdk 1.20.0 → 1.21.0

package/accounts/evm/networkCapabilities.ts

@@ -0,0 +1,117 @@
+/**
+ * Centralized configuration for network capabilities.
+ * This defines which methods are available on which networks.
+ */
+
+/**
+ * Network capabilities configuration.
+ * Each network has a set of boolean flags indicating which methods are supported.
+ */
+export const NETWORK_CAPABILITIES = {
+  base: {
+    listTokenBalances: true,
+    requestFaucet: false,
+    quoteFund: true,
+    fund: true,
+    waitForFundOperationReceipt: true,
+    transfer: true,
+    sendTransaction: true,
+    quoteSwap: true,
+    swap: true,
+  },
+  "base-sepolia": {
+    listTokenBalances: true,
+    requestFaucet: true,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: true,
+    sendTransaction: true,
+    quoteSwap: false,
+    swap: false,
+  },
+  ethereum: {
+    listTokenBalances: true,
+    requestFaucet: false,
+    quoteFund: false, // Only base is supported for quoteFund
+    fund: false, // Only base is supported for fund
+    waitForFundOperationReceipt: false,
+    transfer: true,
+    sendTransaction: true,
+    quoteSwap: true,
+    swap: true,
+  },
+  "ethereum-sepolia": {
+    listTokenBalances: false,
+    requestFaucet: true,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: true,
+    sendTransaction: true,
+    quoteSwap: false,
+    swap: false,
+  },
+  "ethereum-hoodi": {
+    listTokenBalances: false,
+    requestFaucet: true,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+  },
+} as const;
+
+/**
+ * Type for a network name from the capabilities configuration
+ */
+export type NetworkName = keyof typeof NETWORK_CAPABILITIES;
+
+/**
+ * Type for method names
+ */
+export type MethodName = keyof (typeof NETWORK_CAPABILITIES)[NetworkName];
+
+/**
+ * Helper to get networks that support a specific method
+ *
+ * @param method - The method name to check support for
+ * @returns An array of network names that support the method
+ */
+export function getNetworksSupportingMethod(method: MethodName): NetworkName[] {
+  return (Object.keys(NETWORK_CAPABILITIES) as NetworkName[]).filter(
+    network => NETWORK_CAPABILITIES[network][method],
+  );
+}
+
+/**
+ * Helper to check if a network supports a method
+ *
+ * @param method - The method name to check
+ * @param network - The network name to check
+ * @returns True if the network supports the method, false otherwise
+ */
+export function isMethodSupportedOnNetwork(method: MethodName, network: string): boolean {
+  const networkConfig = NETWORK_CAPABILITIES[network as NetworkName];
+  return networkConfig ? networkConfig[method] : false;
+}
+
+/**
+ * Type helper to extract networks supporting a specific method
+ */
+export type NetworksSupporting<M extends MethodName> = {
+  [N in NetworkName]: (typeof NETWORK_CAPABILITIES)[N][M] extends true ? N : never;
+}[NetworkName];
+
+// Export specific network types for each method
+export type ListTokenBalancesNetworks = NetworksSupporting<"listTokenBalances">;
+export type RequestFaucetNetworks = NetworksSupporting<"requestFaucet">;
+export type QuoteFundNetworks = NetworksSupporting<"quoteFund">;
+export type FundNetworks = NetworksSupporting<"fund">;
+export type TransferNetworks = NetworksSupporting<"transfer">;
+export type SendTransactionNetworks = NetworksSupporting<"sendTransaction">;
+export type QuoteSwapNetworks = NetworksSupporting<"quoteSwap">;
+export type SwapNetworks = NetworksSupporting<"swap">;

package/accounts/evm/resolveViemClients.ts

@@ -11,8 +11,7 @@ import {
 import { toAccount } from "viem/accounts";
 import * as chains from "viem/chains";
 
-import { generateJwt } from "../../auth/utils/jwt.js";
-import { config } from "../../openapi-client/cdpApiClient.js";
+import { getBaseNodeRpcUrl } from "./getBaseNodeRpcUrl.js";
 
 import type { EvmAccount } from "./types.js";
 
@@ -135,42 +134,6 @@ export type ResolvedViemClients = {
   walletClient: WalletClient<Transport, Chain, Account>;
 };
 
-/**
- * Get the base node RPC URL for a given network
- *
- * @param network - The network identifier
- * @returns The base node RPC URL or undefined if the network is not supported
- */
-async function getBaseNodeRpcUrl(network: "base" | "base-sepolia"): Promise<string | undefined> {
-  if (!config) {
-    return;
-  }
-
-  try {
-    const basePath = config.basePath?.replace("/platform", "");
-
-    const jwt = await generateJwt({
-      apiKeyId: config.apiKeyId,
-      apiKeySecret: config.apiKeySecret,
-      requestMethod: "GET",
-      requestHost: basePath.replace("https://", ""),
-      requestPath: "/apikeys/v1/tokens/active",
-    });
-
-    const response = await fetch(`${basePath}/apikeys/v1/tokens/active`, {
-      headers: {
-        Authorization: `Bearer ${jwt}`,
-        "Content-Type": "application/json",
-      },
-    });
-
-    const json = await response.json();
-    return `${basePath}/rpc/v1/${network}/${json.id}`;
-  } catch {
-    return;
-  }
-}
-
 /**
  * Resolves viem clients based on a network identifier or Node URL.
  *

package/accounts/evm/toEvmServerAccount.ts

@@ -33,7 +33,7 @@ import { sendSwapTransaction } from "../../actions/evm/swap/sendSwapTransaction.
 import { accountTransferStrategy } from "../../actions/evm/transfer/accountTransferStrategy.js";
 import { transfer } from "../../actions/evm/transfer/transfer.js";
 
-import type { EvmServerAccount } from "./types.js";
+import type { EvmServerAccount, NetworkOrRpcUrl } from "./types.js";
 import type {
   SendTransactionOptions,
   TransactionResult,
@@ -169,8 +169,8 @@ export function toEvmServerAccount(
     name: options.account.name,
     type: "evm-server",
     policies: options.account.policies,
-    useNetwork: async (networkOrRpcUrl: string) => {
-      return toNetworkScopedEvmServerAccount(apiClient, {
+    useNetwork: async <Network extends NetworkOrRpcUrl>(networkOrRpcUrl: Network) => {
+      return toNetworkScopedEvmServerAccount({
         account,
         network: networkOrRpcUrl,
       });

package/accounts/evm/toEvmSmartAccount.ts

@@ -35,7 +35,7 @@ import {
 } from "../../actions/evm/waitForUserOperation.js";
 import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
 
-import type { EvmAccount, EvmSmartAccount } from "./types.js";
+import type { EvmAccount, EvmSmartAccount, KnownEvmNetworks } from "./types.js";
 import type {
   SmartAccountQuoteSwapOptions,
   SmartAccountQuoteSwapResult,
@@ -156,11 +156,11 @@ export function toEvmSmartAccount(
 
     name: options.smartAccount.name,
     type: "evm-smart",
-    __experimental_useNetwork: async (networkOrRpcUrl: string) => {
+    useNetwork: async <Network extends KnownEvmNetworks>(network: Network) => {
       return toNetworkScopedEvmSmartAccount(apiClient, {
         smartAccount: account,
         owner: options.owner,
-        network: networkOrRpcUrl,
+        network,
       });
     },
   };

package/accounts/evm/toNetworkScopedEvmServerAccount.ts

@@ -1,14 +1,27 @@
 import { WaitForTransactionReceiptParameters } from "viem";
-import { base, baseSepolia, sepolia } from "viem/chains";
+import { base, baseSepolia, mainnet, sepolia } from "viem/chains";
 
+import { mapChainToNetwork } from "./chainToNetworkMapper.js";
+import { isMethodSupportedOnNetwork } from "./networkCapabilities.js";
 import { resolveViemClients } from "./resolveViemClients.js";
-import { RequestFaucetOptions } from "../../actions/evm/requestFaucet.js";
-import { TransactionResult } from "../../actions/evm/sendTransaction.js";
 import { transferWithViem } from "../../actions/evm/transfer/transferWithViem.js";
 
 import type { EvmServerAccount, NetworkScopedEvmServerAccount } from "./types.js";
-import type { Network } from "../../actions/evm/transfer/types.js";
-import type { CdpOpenApiClientType } from "../../openapi-client/index.js";
+import type { FundOptions } from "../../actions/evm/fund/fund.js";
+import type { QuoteFundOptions } from "../../actions/evm/fund/quoteFund.js";
+import type { WaitForFundOperationOptions } from "../../actions/evm/fund/waitForFundOperationReceipt.js";
+import type { ListTokenBalancesOptions } from "../../actions/evm/listTokenBalances.js";
+import type { RequestFaucetOptions } from "../../actions/evm/requestFaucet.js";
+import type {
+  SendTransactionOptions,
+  TransactionResult,
+} from "../../actions/evm/sendTransaction.js";
+import type { AccountQuoteSwapOptions, AccountSwapOptions } from "../../actions/evm/swap/types.js";
+import type { TransferOptions } from "../../actions/evm/transfer/types.js";
+import type {
+  ListEvmTokenBalancesNetwork,
+  SendEvmTransactionBodyNetwork,
+} from "../../openapi-client/index.js";
 import type { Address, TransactionRequestEIP1559 } from "../../types/misc.js";
 
 /**
@@ -25,24 +38,26 @@ export type ToNetworkScopedEvmServerAccountOptions = {
  * Creates a Network-scoped Server-managed EvmAccount instance from an existing EvmAccount.
  * Use this to interact with previously deployed EvmAccounts on a specific network.
  *
- * @param {CdpOpenApiClientType} apiClient - The API client.
  * @param {ToNetworkScopedEvmServerAccountOptions} options - Configuration options.
  * @param {EvmServerAccount} options.account - The EvmServerAccount that was previously created.
  * @param {string} options.network - The network to scope the account to.
  * @returns {NetworkScopedEvmServerAccount} A configured NetworkScopedEvmServerAccount instance ready for signing.
  */
-export async function toNetworkScopedEvmServerAccount(
-  apiClient: CdpOpenApiClientType,
-  options: ToNetworkScopedEvmServerAccountOptions,
-): Promise<NetworkScopedEvmServerAccount> {
+export async function toNetworkScopedEvmServerAccount<Network extends string>(
+  options: ToNetworkScopedEvmServerAccountOptions & { network: Network },
+): Promise<NetworkScopedEvmServerAccount<Network>> {
   const { publicClient, walletClient, chain } = await resolveViemClients({
     networkOrNodeUrl: options.network,
     account: options.account,
   });
 
-  const shouldUseApi = chain.id === base.id || chain.id === baseSepolia.id;
+  const shouldUseApiForSends =
+    chain.id === base.id ||
+    chain.id === baseSepolia.id ||
+    chain.id === mainnet.id ||
+    chain.id === sepolia.id;
 
-  const account: NetworkScopedEvmServerAccount = {
+  const account = {
     address: options.account.address as Address,
     network: options.network,
     signMessage: options.account.signMessage,
@@ -52,35 +67,11 @@ export async function toNetworkScopedEvmServerAccount(
     name: options.account.name,
     type: "evm-server",
     policies: options.account.policies,
-    requestFaucet: async (faucetOptions: Omit<RequestFaucetOptions, "address" | "network">) => {
-      if (chain.id !== baseSepolia.id && chain.id !== sepolia.id) {
-        throw new Error(
-          "Requesting a faucet is supported only on base-sepolia or ethereum-sepolia",
-        );
-      }
-      return options.account.requestFaucet({
-        ...faucetOptions,
-        network: chain.id === baseSepolia.id ? "base-sepolia" : "ethereum-sepolia",
-      });
-    },
-    transfer: async transferArgs => {
-      if (shouldUseApi) {
-        return options.account.transfer({
-          ...transferArgs,
-          network: (chain.id === base.id ? "base" : "base-sepolia") as Network,
-        });
-      } else {
-        return transferWithViem(walletClient, account, {
-          ...transferArgs,
-          network: options.network as Network,
-        });
-      }
-    },
-    sendTransaction: async txOpts => {
-      if (shouldUseApi) {
+    sendTransaction: async (txOpts: Omit<SendTransactionOptions, "address" | "network">) => {
+      if (shouldUseApiForSends) {
         return options.account.sendTransaction({
           ...txOpts,
-          network: chain.id === base.id ? "base" : "base-sepolia",
+          network: mapChainToNetwork(chain) as SendEvmTransactionBodyNetwork,
         });
       } else {
         const hash = await walletClient.sendTransaction(
@@ -89,17 +80,98 @@ export async function toNetworkScopedEvmServerAccount(
         return { transactionHash: hash };
       }
     },
+    transfer: async (transferArgs: Omit<TransferOptions, "address" | "network">) => {
+      if (shouldUseApiForSends) {
+        return options.account.transfer({
+          ...transferArgs,
+          network: mapChainToNetwork(chain) as SendEvmTransactionBodyNetwork,
+        });
+      } else {
+        return transferWithViem(walletClient, account, transferArgs);
+      }
+    },
     waitForTransactionReceipt: async (
-      options: WaitForTransactionReceiptParameters | TransactionResult,
+      waitOptions: WaitForTransactionReceiptParameters | TransactionResult,
     ) => {
-      if ("transactionHash" in options) {
+      if ("transactionHash" in waitOptions) {
         return publicClient.waitForTransactionReceipt({
-          hash: options.transactionHash,
+          hash: waitOptions.transactionHash,
         });
       }
-      return publicClient.waitForTransactionReceipt(options);
+      return publicClient.waitForTransactionReceipt(waitOptions);
     },
-  };
+  } as NetworkScopedEvmServerAccount<Network>;
+
+  if (isMethodSupportedOnNetwork("listTokenBalances", options.network)) {
+    Object.assign(account, {
+      listTokenBalances: async (
+        listTokenBalancesOptions: Omit<ListTokenBalancesOptions, "address" | "network">,
+      ) => {
+        return options.account.listTokenBalances({
+          ...listTokenBalancesOptions,
+          network: options.network as ListEvmTokenBalancesNetwork,
+        });
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("requestFaucet", options.network)) {
+    Object.assign(account, {
+      requestFaucet: async (faucetOptions: Omit<RequestFaucetOptions, "address" | "network">) => {
+        return options.account.requestFaucet({
+          ...faucetOptions,
+          network: chain.id === baseSepolia.id ? "base-sepolia" : "ethereum-sepolia",
+        });
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("quoteFund", options.network)) {
+    Object.assign(account, {
+      quoteFund: async (quoteFundOptions: Omit<QuoteFundOptions, "address">) => {
+        return options.account.quoteFund({
+          ...quoteFundOptions,
+        });
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("fund", options.network)) {
+    Object.assign(account, {
+      fund: async (fundOptions: Omit<FundOptions, "address">) => {
+        return options.account.fund({
+          ...fundOptions,
+        });
+      },
+      waitForFundOperationReceipt: async (waitOptions: WaitForFundOperationOptions) => {
+        return options.account.waitForFundOperationReceipt(waitOptions);
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("transfer", options.network)) {
+    Object.assign(account, {
+      transfer: async (transferOptions: TransferOptions) => {
+        return options.account.transfer(transferOptions);
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("quoteSwap", options.network)) {
+    Object.assign(account, {
+      quoteSwap: async (quoteSwapOptions: AccountQuoteSwapOptions) => {
+        return options.account.quoteSwap(quoteSwapOptions);
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("swap", options.network)) {
+    Object.assign(account, {
+      swap: async (swapOptions: AccountSwapOptions) => {
+        return options.account.swap(swapOptions);
+      },
+    });
+  }
 
   return account;
 }

package/accounts/evm/toNetworkScopedEvmSmartAccount.ts

@@ -1,14 +1,52 @@
-import type { EvmAccount, EvmSmartAccount, NetworkScopedEvmSmartAccount } from "./types.js";
-import type { CdpOpenApiClientType } from "../../openapi-client/index.js";
+import { getBaseNodeRpcUrl } from "./getBaseNodeRpcUrl.js";
+import { isMethodSupportedOnNetwork } from "./networkCapabilities.js";
+import { fund } from "../../actions/evm/fund/fund.js";
+import { quoteFund } from "../../actions/evm/fund/quoteFund.js";
+import { waitForFundOperationReceipt } from "../../actions/evm/fund/waitForFundOperationReceipt.js";
+import { getUserOperation } from "../../actions/evm/getUserOperation.js";
+import { listTokenBalances } from "../../actions/evm/listTokenBalances.js";
+import { requestFaucet } from "../../actions/evm/requestFaucet.js";
+import { sendUserOperation } from "../../actions/evm/sendUserOperation.js";
+import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
+import { sendSwapOperation } from "../../actions/evm/swap/sendSwapOperation.js";
+import { smartAccountTransferStrategy } from "../../actions/evm/transfer/smartAccountTransferStrategy.js";
+import { transfer } from "../../actions/evm/transfer/transfer.js";
+import { waitForUserOperation } from "../../actions/evm/waitForUserOperation.js";
+
+import type {
+  EvmAccount,
+  EvmSmartAccount,
+  KnownEvmNetworks,
+  NetworkScopedEvmSmartAccount,
+} from "./types.js";
+import type { FundOptions } from "../../actions/evm/fund/fund.js";
+import type { QuoteFundOptions } from "../../actions/evm/fund/quoteFund.js";
+import type { WaitForFundOperationOptions } from "../../actions/evm/fund/waitForFundOperationReceipt.js";
+import type { ListTokenBalancesOptions } from "../../actions/evm/listTokenBalances.js";
+import type { RequestFaucetOptions } from "../../actions/evm/requestFaucet.js";
+import type { SendUserOperationOptions } from "../../actions/evm/sendUserOperation.js";
+import type {
+  SmartAccountQuoteSwapOptions,
+  SmartAccountSwapNetwork,
+  SmartAccountSwapOptions,
+} from "../../actions/evm/swap/types.js";
+import type { SmartAccountTransferOptions } from "../../actions/evm/transfer/types.js";
+import type { WaitForUserOperationOptions } from "../../actions/evm/waitForUserOperation.js";
+import type { GetUserOperationOptions } from "../../client/evm/evm.types.js";
+import type {
+  CdpOpenApiClientType,
+  EvmUserOperationNetwork,
+  ListEvmTokenBalancesNetwork,
+} from "../../openapi-client/index.js";
 
 /**
- * Options for converting a pre-existing EvmSmartAccount and owner to a EvmSmartAccount
+ * Options for converting a pre-existing EvmSmartAccount and owner to a NetworkScopedEvmSmartAccount
  */
-export type ToEvmSmartAccountOptions = {
+export type ToNetworkScopedEvmSmartAccountOptions = {
   /** The pre-existing EvmSmartAccount. */
   smartAccount: EvmSmartAccount;
   /** The network to scope the smart account object to. */
-  network: string;
+  network: KnownEvmNetworks;
   /** The owner of the smart account. */
   owner: EvmAccount;
 };
@@ -20,22 +58,151 @@ export type ToEvmSmartAccountOptions = {
  * The owner must be the original owner of the evm smart account.
  *
  * @param {CdpOpenApiClientType} apiClient - The API client.
- * @param {ToEvmSmartAccountOptions} options - Configuration options.
+ * @param {ToNetworkScopedEvmSmartAccountOptions} options - Configuration options.
  * @param {EvmSmartAccount} options.smartAccount - The deployed evm smart account.
  * @param {EvmAccount} options.owner - The owner which signs for the smart account.
+ * @param {KnownEvmNetworks} options.network - The network to scope the smart account to.
  * @returns {NetworkScopedEvmSmartAccount} A configured NetworkScopedEvmSmartAccount instance ready for user operation submission.
  */
-export function toNetworkScopedEvmSmartAccount(
+export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNetworks>(
   apiClient: CdpOpenApiClientType,
-  options: ToEvmSmartAccountOptions,
-): NetworkScopedEvmSmartAccount {
-  const account: NetworkScopedEvmSmartAccount = {
+  options: ToNetworkScopedEvmSmartAccountOptions & { network: Network },
+): Promise<NetworkScopedEvmSmartAccount<Network>> {
+  const paymasterUrl = await (async () => {
+    if (options.network === "base") {
+      return getBaseNodeRpcUrl(options.network);
+    }
+    return undefined;
+  })();
+
+  const account = {
     address: options.smartAccount.address,
     network: options.network,
     owners: [options.owner],
     name: options.smartAccount.name,
     type: "evm-smart",
-  };
+    sendUserOperation: async (
+      userOpOptions: Omit<SendUserOperationOptions<unknown[]>, "smartAccount" | "network">,
+    ) => {
+      return sendUserOperation(apiClient, {
+        ...userOpOptions,
+        smartAccount: options.smartAccount,
+        network: options.network as EvmUserOperationNetwork,
+        paymasterUrl: userOpOptions.paymasterUrl ?? paymasterUrl,
+      });
+    },
+    waitForUserOperation: async (
+      waitOptions: Omit<WaitForUserOperationOptions, "smartAccountAddress">,
+    ) => {
+      return waitForUserOperation(apiClient, {
+        ...waitOptions,
+        smartAccountAddress: options.smartAccount.address,
+      });
+    },
+    getUserOperation: async (getOptions: Omit<GetUserOperationOptions, "smartAccount">) => {
+      return getUserOperation(apiClient, {
+        ...getOptions,
+        smartAccount: options.smartAccount,
+      });
+    },
+  } as NetworkScopedEvmSmartAccount<Network>;
+
+  if (isMethodSupportedOnNetwork("transfer", options.network)) {
+    Object.assign(account, {
+      transfer: async (transferOptions: Omit<SmartAccountTransferOptions, "network">) => {
+        return transfer(
+          apiClient,
+          options.smartAccount,
+          {
+            ...transferOptions,
+            network: options.network as EvmUserOperationNetwork,
+            paymasterUrl: transferOptions.paymasterUrl ?? paymasterUrl,
+          },
+          smartAccountTransferStrategy,
+        );
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("listTokenBalances", options.network)) {
+    Object.assign(account, {
+      listTokenBalances: async (
+        listOptions: Omit<ListTokenBalancesOptions, "address" | "network">,
+      ) => {
+        return listTokenBalances(apiClient, {
+          ...listOptions,
+          address: options.smartAccount.address,
+          network: options.network as ListEvmTokenBalancesNetwork,
+        });
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("requestFaucet", options.network)) {
+    Object.assign(account, {
+      requestFaucet: async (faucetOptions: Omit<RequestFaucetOptions, "address" | "network">) => {
+        return requestFaucet(apiClient, {
+          ...faucetOptions,
+          address: options.smartAccount.address,
+          network: options.network as "base-sepolia" | "ethereum-sepolia",
+        });
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("quoteFund", options.network)) {
+    Object.assign(account, {
+      quoteFund: async (quoteOptions: Omit<QuoteFundOptions, "address">) => {
+        return quoteFund(apiClient, {
+          ...quoteOptions,
+          address: options.smartAccount.address,
+        });
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("fund", options.network)) {
+    Object.assign(account, {
+      fund: async (fundOptions: Omit<FundOptions, "address">) => {
+        return fund(apiClient, {
+          ...fundOptions,
+          address: options.smartAccount.address,
+        });
+      },
+      waitForFundOperationReceipt: async (waitOptions: WaitForFundOperationOptions) => {
+        return waitForFundOperationReceipt(apiClient, waitOptions);
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("quoteSwap", options.network)) {
+    Object.assign(account, {
+      quoteSwap: async (quoteSwapOptions: SmartAccountQuoteSwapOptions) => {
+        return createSwapQuote(apiClient, {
+          ...quoteSwapOptions,
+          taker: options.smartAccount.address,
+          signerAddress: options.owner.address,
+          smartAccount: options.smartAccount,
+          network: options.network as SmartAccountSwapNetwork,
+        });
+      },
+    });
+  }
+
+  if (isMethodSupportedOnNetwork("swap", options.network)) {
+    Object.assign(account, {
+      swap: async (swapOptions: SmartAccountSwapOptions) => {
+        return sendSwapOperation(apiClient, {
+          ...swapOptions,
+          smartAccount: options.smartAccount,
+          taker: options.smartAccount.address,
+          signerAddress: options.owner.address,
+          network: options.network as SmartAccountSwapNetwork,
+          paymasterUrl: swapOptions.paymasterUrl ?? paymasterUrl,
+        });
+      },
+    });
+  }
 
   return account;
 }