@eth-optimism/actions-sdk 0.2.0 → 0.3.0

package/src/utils/permit2.ts

@@ -0,0 +1,144 @@
+import type { Address, PublicClient } from 'viem'
+import { encodeFunctionData, erc20Abi, maxUint256 } from 'viem'
+
+import type { TransactionData } from '@/types/transaction.js'
+
+/** Default Permit2 approval expiry: 30 days in seconds */
+export const DEFAULT_PERMIT2_EXPIRY_SECONDS = 30 * 24 * 60 * 60
+
+/**
+ * Permit2 ABI (subset for approvals)
+ */
+const PERMIT2_ABI = [
+  {
+    name: 'allowance',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'owner', type: 'address' },
+      { name: 'token', type: 'address' },
+      { name: 'spender', type: 'address' },
+    ],
+    outputs: [
+      { name: 'amount', type: 'uint160' },
+      { name: 'expiration', type: 'uint48' },
+      { name: 'nonce', type: 'uint48' },
+    ],
+  },
+  {
+    name: 'approve',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint160' },
+      { name: 'expiration', type: 'uint48' },
+    ],
+    outputs: [],
+  },
+] as const
+
+/**
+ * Permit2 allowance info
+ */
+export interface Permit2Allowance {
+  amount: bigint
+  expiration: number
+  nonce: number
+}
+
+/**
+ * Check Permit2 allowance for a token/spender pair
+ */
+export async function checkPermit2Allowance(params: {
+  publicClient: PublicClient
+  permit2Address: Address
+  owner: Address
+  token: Address
+  spender: Address
+}): Promise<Permit2Allowance> {
+  const { publicClient, permit2Address, owner, token, spender } = params
+
+  const result = await publicClient.readContract({
+    address: permit2Address,
+    abi: PERMIT2_ABI,
+    functionName: 'allowance',
+    args: [owner, token, spender],
+  })
+
+  return {
+    amount: BigInt(result[0]),
+    expiration: Number(result[1]),
+    nonce: Number(result[2]),
+  }
+}
+
+/**
+ * Build ERC20 token approval transaction to Permit2
+ */
+export function buildTokenApprovalTx(
+  token: Address,
+  permit2Address: Address,
+): TransactionData {
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: 'approve',
+    // ERC20 -> Permit2: maxUint256 is the Uniswap-canonical pattern.
+    // Permit2 is immutable with no owner — spending is scoped by its own allowance system.
+    args: [permit2Address, maxUint256],
+  })
+
+  return {
+    to: token,
+    data,
+    value: 0n,
+  }
+}
+
+/**
+ * Build Permit2 approval transaction for a spender
+ */
+export function buildPermit2ApprovalTx(params: {
+  permit2Address: Address
+  token: Address
+  spender: Address
+  amount: bigint
+  expirySeconds?: number
+}): TransactionData {
+  const { permit2Address, token, spender, amount } = params
+  const expiration =
+    Math.floor(Date.now() / 1000) +
+    (params.expirySeconds ?? DEFAULT_PERMIT2_EXPIRY_SECONDS)
+
+  const data = encodeFunctionData({
+    abi: PERMIT2_ABI,
+    functionName: 'approve',
+    args: [token, spender, amount, expiration],
+  })
+
+  return {
+    to: permit2Address,
+    data,
+    value: 0n,
+  }
+}
+
+/**
+ * Check ERC20 token allowance
+ */
+export async function checkTokenAllowance(params: {
+  publicClient: PublicClient
+  token: Address
+  owner: Address
+  spender: Address
+}): Promise<bigint> {
+  const { publicClient, token, owner, spender } = params
+
+  return publicClient.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: 'allowance',
+    args: [owner, spender],
+  })
+}

package/src/utils/validation.ts

@@ -0,0 +1,76 @@
+import type { Address } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { Asset } from '@/types/asset.js'
+import { isAssetSupportedOnChain } from '@/utils/assets.js'
+
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
+
+export function validateAmountProvided(
+  amountIn?: number,
+  amountOut?: number,
+): void {
+  if (amountIn === undefined && amountOut === undefined) {
+    throw new Error('Either amountIn or amountOut must be provided')
+  }
+}
+
+export function validateAmountPositiveIfExists(amount?: number): void {
+  if (amount !== undefined && amount <= 0) {
+    throw new Error('Amount must be positive')
+  }
+}
+
+export function validateNotBothAmounts(
+  amountIn?: number,
+  amountOut?: number,
+): void {
+  if (amountIn !== undefined && amountOut !== undefined) {
+    throw new Error('Provide either amountIn or amountOut, not both')
+  }
+}
+
+export function validateNotSameAsset(assetIn: Asset, assetOut: Asset): void {
+  if (
+    assetIn.metadata.symbol.toLowerCase() ===
+    assetOut.metadata.symbol.toLowerCase()
+  ) {
+    throw new Error('Cannot swap an asset for itself')
+  }
+}
+
+export function validateNotZeroAddress(address: Address, label: string): void {
+  if (address === ZERO_ADDRESS) {
+    throw new Error(`${label} cannot be the zero address`)
+  }
+}
+
+export function validateSlippage(slippage: number, maxSlippage: number): void {
+  if (slippage < 0 || slippage > maxSlippage) {
+    throw new Error(
+      `Slippage ${slippage} exceeds allowed range [0, ${maxSlippage * 100}%]`,
+    )
+  }
+}
+
+export function validateChainSupported(
+  chainId: number,
+  supportedChainIds: readonly number[],
+): void {
+  if (!supportedChainIds.includes(chainId)) {
+    throw new Error(
+      `Chain ${chainId} is not supported. Supported chains: ${supportedChainIds.join(', ')}`,
+    )
+  }
+}
+
+export function validateAssetOnChain(
+  asset: Asset,
+  chainId: SupportedChainId,
+): void {
+  if (!isAssetSupportedOnChain(asset, chainId)) {
+    throw new Error(
+      `Asset ${asset.metadata.symbol} not supported on chain ${chainId}`,
+    )
+  }
+}

package/src/wallet/core/providers/hosted/abstract/HostedWalletProvider.ts

@@ -2,7 +2,8 @@ import type { LocalAccount } from 'viem'
 
 import type { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
 
@@ -21,6 +22,9 @@ export abstract class HostedWalletProvider<
     morpho?: LendProvider<LendProviderConfig>
     aave?: LendProvider<LendProviderConfig>
   }
+  protected swapProviders: {
+    uniswap?: SwapProvider<SwapProviderConfig>
+  }
   protected supportedAssets?: Asset[]
 
   protected constructor(
@@ -29,10 +33,14 @@ export abstract class HostedWalletProvider<
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     },
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    },
     supportedAssets?: Asset[],
   ) {
     this.chainManager = chainManager
     this.lendProviders = lendProviders || {}
+    this.swapProviders = swapProviders || {}
     this.supportedAssets = supportedAssets
   }
   /**

package/src/wallet/core/providers/hosted/types/index.ts

@@ -1,6 +1,7 @@
 import type { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstract/HostedWalletProvider.js'
 
@@ -16,6 +17,9 @@ export interface HostedProviderDeps {
     morpho?: LendProvider<LendProviderConfig>
     aave?: LendProvider<LendProviderConfig>
   }
+  swapProviders?: {
+    uniswap?: SwapProvider<SwapProviderConfig>
+  }
   supportedAssets?: Asset[]
 }
 

package/src/wallet/core/providers/smart/default/DefaultSmartWalletProvider.ts

@@ -4,7 +4,8 @@ import { keccak256, slice, toHex } from 'viem'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import { SmartWalletProvider } from '@/wallet/core/providers/smart/abstract/SmartWalletProvider.js'
 import type { SmartWalletCreationResult } from '@/wallet/core/providers/smart/abstract/types/index.js'
@@ -31,6 +32,10 @@ export class DefaultSmartWalletProvider extends SmartWalletProvider {
     morpho?: LendProvider<LendProviderConfig>
     aave?: LendProvider<LendProviderConfig>
   }
+  /** Providers for swap operations */
+  private swapProviders: {
+    uniswap?: SwapProvider<SwapProviderConfig>
+  }
   /** Supported assets for this wallet provider */
   private supportedAssets?: Asset[]
   /** Optional 16-byte attribution suffix appended to callData */
@@ -40,6 +45,7 @@ export class DefaultSmartWalletProvider extends SmartWalletProvider {
    * Initialize the Smart Wallet Provider
    * @param chainManager - Manages supported blockchain networks
    * @param lendProviders - Providers for lending market operations
+   * @param swapProviders - Providers for swap operations
    * @param supportedAssets - Optional list of supported assets
    * @param attributionSuffix - Optional attribution suffix
    */
@@ -49,12 +55,16 @@ export class DefaultSmartWalletProvider extends SmartWalletProvider {
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     },
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    },
     supportedAssets?: Asset[],
     attributionSuffix?: string,
   ) {
     super()
     this.chainManager = chainManager
     this.lendProviders = lendProviders || {}
+    this.swapProviders = swapProviders || {}
     this.supportedAssets = supportedAssets
     if (attributionSuffix) {
       this.attributionSuffix =
@@ -93,6 +103,7 @@ export class DefaultSmartWalletProvider extends SmartWalletProvider {
       signer,
       chainManager: this.chainManager,
       lendProviders: this.lendProviders,
+      swapProviders: this.swapProviders,
       supportedAssets: this.supportedAssets,
       nonce,
       attributionSuffix: this.attributionSuffix,
@@ -182,6 +193,7 @@ export class DefaultSmartWalletProvider extends SmartWalletProvider {
       signer,
       chainManager: this.chainManager,
       lendProviders: this.lendProviders,
+      swapProviders: this.swapProviders,
       supportedAssets: this.supportedAssets,
       deploymentAddress: walletAddress,
       attributionSuffix: this.attributionSuffix,

package/src/wallet/core/providers/smart/default/__tests__/DefaultSmartWalletProvider.spec.ts

@@ -413,6 +413,7 @@ describe('DefaultSmartWalletProvider', () => {
     const provider = new DefaultSmartWalletProvider(
       mockChainManager,
       { morpho: mockLendProvider },
+      undefined,
       supportedAssets,
       attributionSeed,
     )
@@ -440,6 +441,7 @@ describe('DefaultSmartWalletProvider', () => {
     const provider = new DefaultSmartWalletProvider(
       mockChainManager,
       { morpho: mockLendProvider },
+      undefined,
       supportedAssets,
       attributionSeed,
     )

package/src/wallet/core/wallets/abstract/Wallet.ts

@@ -6,9 +6,11 @@ import { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { fetchERC20Balance, fetchETHBalance } from '@/services/tokenBalance.js'
 import { SUPPORTED_TOKENS } from '@/supported/tokens.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import { WalletSwapNamespace } from '@/swap/namespaces/WalletSwapNamespace.js'
+import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset, TokenBalance } from '@/types/asset.js'
-import type { TransactionData } from '@/types/lend/index.js'
+import type { TransactionData } from '@/types/transaction.js'
 import type {
   BatchTransactionReturnType,
   TransactionReturnType,
@@ -27,6 +29,12 @@ export abstract class Wallet {
     morpho?: LendProvider<LendProviderConfig>
     aave?: LendProvider<LendProviderConfig>
   }
+  /** Swap namespace with all swap operations */
+  swap?: WalletSwapNamespace
+  /** Providers for swap operations */
+  protected swapProviders: {
+    uniswap?: SwapProvider<SwapProviderConfig>
+  }
   /** Manages supported blockchain networks and RPC clients */
   protected chainManager: ChainManager
   /** List of supported assets for this wallet */
@@ -53,6 +61,7 @@ export abstract class Wallet {
    * Create a new wallet
    * @param chainManager - Chain manager for the wallet
    * @param lendProviders - Lend providers for the wallet
+   * @param swapProviders - Swap providers for the wallet
    * @param supportedAssets - List of supported assets (defaults to all SUPPORTED_TOKENS)
    */
   protected constructor(
@@ -61,14 +70,21 @@ export abstract class Wallet {
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     },
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    },
     supportedAssets?: Asset[],
   ) {
     this.chainManager = chainManager
     this.lendProviders = lendProviders || {}
+    this.swapProviders = swapProviders || {}
     this.supportedAssets = supportedAssets || SUPPORTED_TOKENS
     if (this.lendProviders.morpho || this.lendProviders.aave) {
       this.lend = new WalletLendNamespace(this.lendProviders, this)
     }
+    if (this.swapProviders.uniswap) {
+      this.swap = new WalletSwapNamespace(this.swapProviders, this)
+    }
   }
 
   /**

package/src/wallet/core/wallets/smart/default/DefaultSmartWallet.ts

@@ -15,9 +15,10 @@ import { TransactionConfirmedButRevertedError } from '@/core/error/errors.js'
 import { retryOnStaleRead } from '@/core/utils/retryOnStaleRead.js'
 import type { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
-import type { TransactionData } from '@/types/lend/index.js'
+import type { TransactionData } from '@/types/transaction.js'
 import { parseAssetAmount } from '@/utils/assets.js'
 import { SmartWallet } from '@/wallet/core/wallets/smart/abstract/SmartWallet.js'
 import type { Signer } from '@/wallet/core/wallets/smart/abstract/types/index.js'
@@ -59,6 +60,7 @@ export class DefaultSmartWallet extends SmartWallet {
    * @param signer - Local account for signing transactions
    * @param chainManager - Network management service
    * @param lendProviders - Lending operations providers
+   * @param swapProviders - Swap operations providers
    * @param deploymentAddress - Known wallet address (if already deployed)
    * @param ownerIndex - Index of signer in owners array
    * @param nonce - Nonce for address generation
@@ -71,12 +73,15 @@ export class DefaultSmartWallet extends SmartWallet {
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     },
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    },
     supportedAssets?: Asset[],
     deploymentAddress?: Address,
     nonce?: bigint,
     attributionSuffix?: Hex,
   ) {
-    super(chainManager, lendProviders, supportedAssets)
+    super(chainManager, lendProviders, swapProviders, supportedAssets)
 
     const { signersWithLocalAccount, signerIndex } =
       DefaultSmartWallet.ensureLocalAccountSigner(signers, signer)
@@ -121,6 +126,9 @@ export class DefaultSmartWallet extends SmartWallet {
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     }
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    }
     supportedAssets?: Asset[]
     deploymentAddress?: Address
     nonce?: bigint
@@ -132,6 +140,7 @@ export class DefaultSmartWallet extends SmartWallet {
       params.signer,
       params.chainManager,
       params.lendProviders,
+      params.swapProviders,
       params.supportedAssets,
       params.deploymentAddress,
       params.nonce,
@@ -540,7 +549,7 @@ export class DefaultSmartWallet extends SmartWallet {
 
     // Handle ETH transfers
     if (asset.type === 'native') {
-      const parsedAmount = parseAssetAmount(amount, asset.metadata.decimals)
+      const parsedAmount = parseAssetAmount(asset, amount)
 
       return {
         to: recipientAddress,
@@ -550,7 +559,7 @@ export class DefaultSmartWallet extends SmartWallet {
     }
 
     // Handle ERC20 token transfers
-    const parsedAmount = parseAssetAmount(amount, asset.metadata.decimals)
+    const parsedAmount = parseAssetAmount(asset, amount)
 
     // Encode ERC20 transfer function call
     const transferData = encodeFunctionData({

package/src/wallet/node/providers/hosted/privy/PrivyHostedWalletProvider.ts

@@ -4,7 +4,8 @@ import { getAddress } from 'viem'
 
 import type { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstract/HostedWalletProvider.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
@@ -32,6 +33,7 @@ export class PrivyHostedWalletProvider extends HostedWalletProvider<
    * @param params.privyClient - Privy client instance
    * @param params.chainManager - Chain manager for multi-chain operations
    * @param params.lendProviders - Optional lend providers for DeFi operations
+   * @param params.swapProviders - Optional swap providers for trading operations
    * @param params.supportedAssets - Optional list of supported assets
    * @param params.authorizationContext - Optional authorization context for the Privy client.
    * Used when Privy needs to sign requests.
@@ -45,10 +47,18 @@ export class PrivyHostedWalletProvider extends HostedWalletProvider<
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     }
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    }
     supportedAssets?: Asset[]
     authorizationContext?: AuthorizationContext
   }) {
-    super(params.chainManager, params.lendProviders, params.supportedAssets)
+    super(
+      params.chainManager,
+      params.lendProviders,
+      params.swapProviders,
+      params.supportedAssets,
+    )
     this.privyClient = params.privyClient
     this.authorizationContext = params.authorizationContext
   }
@@ -63,6 +73,7 @@ export class PrivyHostedWalletProvider extends HostedWalletProvider<
       address: getAddress(params.address),
       chainManager: this.chainManager,
       lendProviders: this.lendProviders,
+      swapProviders: this.swapProviders,
       supportedAssets: this.supportedAssets,
     })
   }

package/src/wallet/node/providers/hosted/registry/NodeHostedWalletProviderRegistry.ts

@@ -28,11 +28,15 @@ export class NodeHostedWalletProviderRegistry extends HostedWalletProviderRegist
       validateOptions(options): options is NodeOptionsMap['privy'] {
         return Boolean((options as NodeOptionsMap['privy'])?.privyClient)
       },
-      create({ chainManager, lendProviders, supportedAssets }, options) {
+      create(
+        { chainManager, lendProviders, swapProviders, supportedAssets },
+        options,
+      ) {
         return new PrivyHostedWalletProvider({
           privyClient: options.privyClient,
           chainManager,
           lendProviders,
+          swapProviders,
           supportedAssets,
           authorizationContext: options.authorizationContext,
         })
@@ -45,11 +49,15 @@ export class NodeHostedWalletProviderRegistry extends HostedWalletProviderRegist
         const o = options as NodeOptionsMap['turnkey']
         return Boolean(o?.client)
       },
-      create({ chainManager, lendProviders, supportedAssets }, options) {
+      create(
+        { chainManager, lendProviders, swapProviders, supportedAssets },
+        options,
+      ) {
         return new TurnkeyHostedWalletProvider(
           options.client,
           chainManager,
           lendProviders,
+          swapProviders,
           supportedAssets,
         )
       },

package/src/wallet/node/providers/hosted/turnkey/TurnkeyHostedWalletProvider.ts

@@ -5,7 +5,8 @@ import type { LocalAccount } from 'viem'
 
 import type { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstract/HostedWalletProvider.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
@@ -29,6 +30,7 @@ export class TurnkeyHostedWalletProvider extends HostedWalletProvider<
    * @param client - Turnkey client instance (HTTP, server, or core SDK base)
    * @param chainManager - Chain manager used to resolve chains and RPC transports
    * @param lendProviders - Optional lend providers for DeFi operations
+   * @param swapProviders - Optional swap providers for trading operations
    * @param supportedAssets - Optional list of supported assets
    */
   constructor(
@@ -41,9 +43,12 @@ export class TurnkeyHostedWalletProvider extends HostedWalletProvider<
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     },
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    },
     supportedAssets?: Asset[],
   ) {
-    super(chainManager, lendProviders, supportedAssets)
+    super(chainManager, lendProviders, swapProviders, supportedAssets)
   }
 
   /**
@@ -65,6 +70,7 @@ export class TurnkeyHostedWalletProvider extends HostedWalletProvider<
       ethereumAddress: params.ethereumAddress,
       chainManager: this.chainManager,
       lendProviders: this.lendProviders,
+      swapProviders: this.swapProviders,
       supportedAssets: this.supportedAssets,
     })
   }

package/src/wallet/node/wallets/hosted/privy/PrivyWallet.ts

@@ -3,7 +3,8 @@ import { type Address, type LocalAccount } from 'viem'
 
 import type { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import { EOAWallet } from '@/wallet/core/wallets/eoa/EOAWallet.js'
 import { createSigner } from '@/wallet/node/wallets/hosted/privy/utils/createSigner.js'
@@ -26,6 +27,7 @@ export class PrivyWallet extends EOAWallet {
    * @param address - Ethereum address of the wallet
    * @param chainManager - Chain manager for multi-chain operations
    * @param lendProviders - Optional lend providers for DeFi operations
+   * @param swapProviders - Optional swap providers for trading operations
    * @param supportedAssets - Optional list of supported assets
    */
   private constructor(
@@ -37,10 +39,13 @@ export class PrivyWallet extends EOAWallet {
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     },
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    },
     supportedAssets?: Asset[],
     authorizationContext?: AuthorizationContext,
   ) {
-    super(chainManager, lendProviders, supportedAssets)
+    super(chainManager, lendProviders, swapProviders, supportedAssets)
     this.privyClient = privyClient
     this.authorizationContext = authorizationContext
     this.walletId = walletId
@@ -57,6 +62,9 @@ export class PrivyWallet extends EOAWallet {
       morpho?: LendProvider<LendProviderConfig>
       aave?: LendProvider<LendProviderConfig>
     }
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    }
     supportedAssets?: Asset[]
   }): Promise<PrivyWallet> {
     const wallet = new PrivyWallet(
@@ -65,6 +73,7 @@ export class PrivyWallet extends EOAWallet {
       params.address,
       params.chainManager,
       params.lendProviders,
+      params.swapProviders,
       params.supportedAssets,
       params.authorizationContext,
     )