@eth-optimism/actions-sdk 0.1.0 → 0.3.0

package/src/utils/permit2.test.ts

@@ -0,0 +1,142 @@
+import type { Address, PublicClient } from 'viem'
+import { decodeFunctionData } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+  buildPermit2ApprovalTx,
+  buildTokenApprovalTx,
+  checkPermit2Allowance,
+  checkTokenAllowance,
+  DEFAULT_PERMIT2_EXPIRY_SECONDS,
+} from '@/utils/permit2.js'
+
+const PERMIT2_ABI = [
+  {
+    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
+
+const TOKEN = '0x1111111111111111111111111111111111111111' as Address
+const OWNER = '0x2222222222222222222222222222222222222222' as Address
+const SPENDER = '0x3333333333333333333333333333333333333333' as Address
+const PERMIT2 = '0x000000000022D473030F116dDEE9F6B43aC78BA3' as Address
+
+describe('checkPermit2Allowance', () => {
+  it('returns parsed allowance data', async () => {
+    const publicClient = {
+      readContract: vi.fn().mockResolvedValue([
+        1000000n, // amount (uint160)
+        1700000000, // expiration (uint48)
+        5, // nonce (uint48)
+      ]),
+    } as unknown as PublicClient
+
+    const result = await checkPermit2Allowance({
+      publicClient,
+      permit2Address: PERMIT2,
+      owner: OWNER,
+      token: TOKEN,
+      spender: SPENDER,
+    })
+
+    expect(result.amount).toBe(1000000n)
+    expect(result.expiration).toBe(1700000000)
+    expect(result.nonce).toBe(5)
+    expect(publicClient.readContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        address: PERMIT2,
+        functionName: 'allowance',
+        args: [OWNER, TOKEN, SPENDER],
+      }),
+    )
+  })
+})
+
+describe('checkTokenAllowance', () => {
+  it('returns token allowance as bigint', async () => {
+    const publicClient = {
+      readContract: vi.fn().mockResolvedValue(500000n),
+    } as unknown as PublicClient
+
+    const result = await checkTokenAllowance({
+      publicClient,
+      token: TOKEN,
+      owner: OWNER,
+      spender: SPENDER,
+    })
+
+    expect(result).toBe(500000n)
+    expect(publicClient.readContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        address: TOKEN,
+        functionName: 'allowance',
+        args: [OWNER, SPENDER],
+      }),
+    )
+  })
+})
+
+describe('buildTokenApprovalTx', () => {
+  it('builds max approval to Permit2', () => {
+    const tx = buildTokenApprovalTx(TOKEN, PERMIT2)
+
+    expect(tx.to).toBe(TOKEN)
+    expect(tx.value).toBe(0n)
+    expect(tx.data).toMatch(/^0x/)
+    // Should encode approve(permit2, maxUint256)
+    expect(tx.data.length).toBeGreaterThan(10)
+  })
+})
+
+describe('buildPermit2ApprovalTx', () => {
+  it('approves exact amount with default expiry', () => {
+    const before = Math.floor(Date.now() / 1000)
+    const amount = 100000000n
+
+    const tx = buildPermit2ApprovalTx({
+      permit2Address: PERMIT2,
+      token: TOKEN,
+      spender: SPENDER,
+      amount,
+    })
+
+    expect(tx.to).toBe(PERMIT2)
+    expect(tx.value).toBe(0n)
+
+    const decoded = decodeFunctionData({ abi: PERMIT2_ABI, data: tx.data })
+    const [, , decodedAmount, expiration] = decoded.args
+    expect(decodedAmount).toBe(amount)
+    expect(Number(expiration)).toBeGreaterThanOrEqual(
+      before + DEFAULT_PERMIT2_EXPIRY_SECONDS,
+    )
+  })
+
+  it('uses custom expiry when provided', () => {
+    const before = Math.floor(Date.now() / 1000)
+    const customExpiry = 7 * 24 * 60 * 60 // 7 days
+
+    const tx = buildPermit2ApprovalTx({
+      permit2Address: PERMIT2,
+      token: TOKEN,
+      spender: SPENDER,
+      amount: 100000000n,
+      expirySeconds: customExpiry,
+    })
+
+    const decoded = decodeFunctionData({ abi: PERMIT2_ABI, data: tx.data })
+    const [, , , expiration] = decoded.args
+    expect(Number(expiration)).toBeGreaterThanOrEqual(before + customExpiry)
+    expect(Number(expiration)).toBeLessThan(
+      before + DEFAULT_PERMIT2_EXPIRY_SECONDS,
+    )
+  })
+})

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/namespace/WalletNamespace.ts

@@ -18,10 +18,8 @@ import type { SmartWallet } from '@/wallet/core/wallets/smart/abstract/SmartWall
 export class WalletNamespace<
   THostedProviderType extends string,
   TToActionsMap extends Record<THostedProviderType, unknown>,
-  H extends HostedWalletProvider<
-    THostedProviderType,
-    TToActionsMap
-  > = HostedWalletProvider<THostedProviderType, TToActionsMap>,
+  H extends HostedWalletProvider<THostedProviderType, TToActionsMap> =
+    HostedWalletProvider<THostedProviderType, TToActionsMap>,
   S extends SmartWalletProvider = SmartWalletProvider,
 > {
   private provider: WalletProvider<THostedProviderType, TToActionsMap, H, S>

package/src/wallet/core/namespace/__tests__/WalletNamespace.spec.ts

@@ -3,16 +3,16 @@ import { getAddress } from 'viem'
 import { unichain } from 'viem/chains'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import type { SupportedChainId } from '@/constants/supportedChains.js'
-import type { ChainManager } from '@/services/ChainManager.js'
-import { MockChainManager } from '@/test/MockChainManager.js'
-import { createMockLendProvider } from '@/test/MockLendProvider.js'
 import {
   createMockPrivyClient,
   createMockPrivyWallet,
   getMockAuthorizationContext,
-} from '@/test/MockPrivyClient.js'
-import { getRandomAddress } from '@/test/utils.js'
+} from '@/__mocks__/MockPrivyClient.js'
+import { getRandomAddress } from '@/__mocks__/utils.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.js'
 import { WalletNamespace } from '@/wallet/core/namespace/WalletNamespace.js'
 import { DefaultSmartWalletProvider } from '@/wallet/core/providers/smart/default/DefaultSmartWalletProvider.js'
 import { WalletProvider } from '@/wallet/core/providers/WalletProvider.js'

package/src/wallet/core/providers/__tests__/WalletProvider.spec.ts

@@ -2,16 +2,16 @@ import type { WaitForUserOperationReceiptReturnType } from 'viem/account-abstrac
 import { unichain } from 'viem/chains'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-import type { SupportedChainId } from '@/constants/supportedChains.js'
-import type { ChainManager } from '@/services/ChainManager.js'
-import { MockChainManager } from '@/test/MockChainManager.js'
-import { createMockLendProvider } from '@/test/MockLendProvider.js'
 import {
   createMockPrivyClient,
   createMockPrivyWallet,
   getMockAuthorizationContext,
-} from '@/test/MockPrivyClient.js'
-import { getRandomAddress } from '@/test/utils.js'
+} from '@/__mocks__/MockPrivyClient.js'
+import { getRandomAddress } from '@/__mocks__/utils.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.js'
 import { DefaultSmartWalletProvider } from '@/wallet/core/providers/smart/default/DefaultSmartWalletProvider.js'
 import { WalletProvider } from '@/wallet/core/providers/WalletProvider.js'
 import { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'

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/registry/__tests__/HostedWalletProviderRegistry.spec.ts

@@ -2,12 +2,12 @@ import type { PrivyClient } from '@privy-io/node'
 import { unichain } from 'viem/chains'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import type { ChainManager } from '@/services/ChainManager.js'
-import { MockChainManager } from '@/test/MockChainManager.js'
 import {
   createMockPrivyClient,
   getMockAuthorizationContext,
-} from '@/test/MockPrivyClient.js'
+} from '@/__mocks__/MockPrivyClient.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.js'
 import { HostedWalletProviderRegistry } from '@/wallet/core/providers/hosted/registry/HostedWalletProviderRegistry.js'
 import { PrivyHostedWalletProvider } from '@/wallet/node/providers/hosted/privy/PrivyHostedWalletProvider.js'
 import type { NodeOptionsMap } from '@/wallet/node/providers/hosted/types/index.js'

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

@@ -14,11 +14,11 @@ import type {
 } from 'viem/account-abstraction'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { getRandomAddress } from '@/__mocks__/utils.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import { MockChainManager } from '@/test/MockChainManager.js'
-import { createMockLendProvider } from '@/test/MockLendProvider.js'
-import { getRandomAddress } from '@/test/utils.js'
 import { DefaultSmartWalletProvider } from '@/wallet/core/providers/smart/default/DefaultSmartWalletProvider.js'
 import { createMock as createDefaultSmartWalletMock } from '@/wallet/core/wallets/smart/default/__mocks__/DefaultSmartWallet.js'
 import {
@@ -165,9 +165,8 @@ describe('DefaultSmartWalletProvider', () => {
     const nonce = BigInt(123)
 
     // Mock deploy to fail for all chains
-    const { SmartWalletDeploymentError } = await import(
-      '@/wallet/core/wallets/smart/error/errors.js'
-    )
+    const { SmartWalletDeploymentError } =
+      await import('@/wallet/core/wallets/smart/error/errors.js')
     vi.mocked(mockWallet.deploy)
       .mockRejectedValueOnce(
         new SmartWalletDeploymentError('Deployment failed', 1),
@@ -209,9 +208,8 @@ describe('DefaultSmartWalletProvider', () => {
     const signers = [mockSigner.address, getRandomAddress()]
     const nonce = BigInt(123)
 
-    const { SmartWalletDeploymentError } = await import(
-      '@/wallet/core/wallets/smart/error/errors.js'
-    )
+    const { SmartWalletDeploymentError } =
+      await import('@/wallet/core/wallets/smart/error/errors.js')
 
     // Mock deploy to succeed for chain 1, fail for chain 130
     vi.mocked(mockWallet.deploy)
@@ -415,6 +413,7 @@ describe('DefaultSmartWalletProvider', () => {
     const provider = new DefaultSmartWalletProvider(
       mockChainManager,
       { morpho: mockLendProvider },
+      undefined,
       supportedAssets,
       attributionSeed,
     )
@@ -442,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/abstract/__tests__/Wallet.spec.ts

@@ -2,12 +2,12 @@ import type { LocalAccount } from 'viem'
 import { unichain } from 'viem/chains'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { getRandomAddress } from '@/__mocks__/utils.js'
 import type { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { fetchERC20Balance, fetchETHBalance } from '@/services/tokenBalance.js'
 import { SUPPORTED_TOKENS } from '@/supported/tokens.js'
-import { MockChainManager } from '@/test/MockChainManager.js'
-import { getRandomAddress } from '@/test/utils.js'
 import { TestWallet } from '@/wallet/core/wallets/abstract/__mocks__/TestWallet.js'
 
 vi.mock('@/services/tokenBalance.js', async () => {