@eth-optimism/actions-sdk 0.3.0 → 0.4.0

package/src/services/tokenBalance.ts

@@ -1,6 +1,7 @@
 import type { Address } from 'viem'
 import { erc20Abi, formatEther, formatUnits } from 'viem'
 
+import { ETH } from '@/constants/assets.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import type { Asset, TokenBalance } from '@/types/asset.js'
@@ -9,7 +10,7 @@ import type { Asset, TokenBalance } from '@/types/asset.js'
  * Fetch ETH balance across all supported chains
  * @param chainManager - The chain manager
  * @param walletAddress - The wallet address
- * @returns Promise resolving to array of ETH balances
+ * @returns Promise resolving to ETH balance
  */
 export async function fetchETHBalance(
   chainManager: ChainManager,
@@ -18,26 +19,31 @@ export async function fetchETHBalance(
   const supportedChains = chainManager.getSupportedChains()
   const chainBalancePromises = supportedChains.map(async (chainId) => {
     const publicClient = chainManager.getPublicClient(chainId)
-    const balance = await publicClient.getBalance({
+    const balanceRaw = await publicClient.getBalance({
       address: walletAddress,
     })
     return {
       chainId,
-      balance,
-      tokenAddress: 'native' as const,
-      formattedBalance: formatEther(balance),
+      balanceRaw,
+      balance: parseFloat(formatEther(balanceRaw)),
     }
   })
-  const chainBalances = await Promise.all(chainBalancePromises)
-  const totalBalance = chainBalances.reduce(
-    (total, { balance }) => total + balance,
+  const chainResults = await Promise.all(chainBalancePromises)
+  const totalBalanceRaw = chainResults.reduce(
+    (total, { balanceRaw }) => total + balanceRaw,
     0n,
   )
+
+  const chains: TokenBalance['chains'] = {}
+  for (const { chainId, balance, balanceRaw } of chainResults) {
+    chains[chainId] = { balance, balanceRaw }
+  }
+
   return {
-    symbol: 'ETH',
-    totalBalance,
-    totalFormattedBalance: formatEther(totalBalance),
-    chainBalances,
+    asset: ETH,
+    totalBalance: parseFloat(formatEther(totalBalanceRaw)),
+    totalBalanceRaw,
+    chains,
   }
 }
 
@@ -55,7 +61,7 @@ export async function fetchERC20Balance(
   )
 
   const chainBalancePromises = chainsWithToken.map(async (chainId) => {
-    const { balance, tokenAddress } = await fetchERC20BalanceForChain(
+    const balanceRaw = await fetchBalanceForChain(
       asset,
       chainId,
       walletAddress,
@@ -63,35 +69,41 @@ export async function fetchERC20Balance(
     )
     return {
       chainId,
-      balance,
-      tokenAddress,
-      formattedBalance: formatUnits(balance, asset.metadata.decimals),
+      balanceRaw,
+      balance: parseFloat(formatUnits(balanceRaw, asset.metadata.decimals)),
     }
   })
 
-  const chainBalances = await Promise.all(chainBalancePromises)
-  const totalBalance = chainBalances.reduce(
-    (total, { balance }) => total + balance,
+  const chainResults = await Promise.all(chainBalancePromises)
+  const totalBalanceRaw = chainResults.reduce(
+    (total, { balanceRaw }) => total + balanceRaw,
     0n,
   )
 
+  const chains: TokenBalance['chains'] = {}
+  for (const { chainId, balance, balanceRaw } of chainResults) {
+    chains[chainId] = { balance, balanceRaw }
+  }
+
   return {
-    symbol: asset.metadata.symbol,
-    totalBalance,
-    totalFormattedBalance: formatUnits(totalBalance, asset.metadata.decimals),
-    chainBalances,
+    asset,
+    totalBalance: parseFloat(
+      formatUnits(totalBalanceRaw, asset.metadata.decimals),
+    ),
+    totalBalanceRaw,
+    chains,
   }
 }
 
 /**
  * Fetch balance for this asset on a specific chain
  */
-async function fetchERC20BalanceForChain(
+async function fetchBalanceForChain(
   asset: Asset,
   chainId: SupportedChainId,
   walletAddress: Address,
   chainManager: ChainManager,
-): Promise<{ balance: bigint; tokenAddress: Address | 'native' }> {
+): Promise<bigint> {
   const tokenAddress = asset.address[chainId]
   if (!tokenAddress) {
     throw new Error(
@@ -103,19 +115,13 @@ async function fetchERC20BalanceForChain(
 
   // Handle native ETH balance
   if (asset.type === 'native' || tokenAddress === 'native') {
-    return {
-      balance: await publicClient.getBalance({
-        address: walletAddress,
-      }),
-      tokenAddress: 'native',
-    }
+    return publicClient.getBalance({ address: walletAddress })
   }
 
-  const balance = await publicClient.readContract({
+  return publicClient.readContract({
     address: tokenAddress,
     abi: erc20Abi,
     functionName: 'balanceOf',
     args: [walletAddress],
   })
-  return { balance, tokenAddress }
 }

package/src/swap/__mocks__/MockSwapProvider.ts

@@ -5,21 +5,25 @@ import type { SupportedChainId } from '@/constants/supportedChains.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { SwapSettings } from '@/types/actions.js'
+import type { Asset } from '@/types/asset.js'
 import type {
   GetSwapMarketParams,
   GetSwapMarketsParams,
   ResolvedSwapParams,
   SwapMarket,
-  SwapPrice,
-  SwapPriceParams,
   SwapProviderConfig,
+  SwapQuote,
+  SwapQuoteParams,
   SwapTransaction,
 } from '@/types/swap/index.js'
+import type { TransactionData } from '@/types/transaction.js'
 
 export interface MockSwapProviderConfig {
   supportedChains: SupportedChainId[]
-  defaultPrice: string
+  defaultPrice: number
   defaultPriceImpact: number
+  provider: 'uniswap' | 'velodrome'
 }
 
 /**
@@ -29,8 +33,14 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
   public mockExecute: MockedFunction<
     (params: ResolvedSwapParams) => Promise<SwapTransaction>
   >
-  public mockGetPrice: MockedFunction<
-    (params: SwapPriceParams) => Promise<SwapPrice>
+  public mockGetQuote: MockedFunction<
+    (params: SwapQuoteParams) => Promise<SwapQuote>
+  >
+  public mockBuildApprovals: MockedFunction<
+    (quote: SwapQuote) => Promise<{
+      tokenApproval?: TransactionData
+      permit2Approval?: TransactionData
+    }>
   >
   public mockGetMarket: MockedFunction<
     (params: GetSwapMarketParams) => Promise<SwapMarket>
@@ -46,10 +56,15 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
     config?: SwapProviderConfig,
     mockConfig?: Partial<MockSwapProviderConfig>,
     chainManager?: ChainManager,
+    settings?: SwapSettings,
   ) {
     super(
       config || {},
-      chainManager || (new MockChainManager() as unknown as ChainManager),
+      chainManager ||
+        (new MockChainManager({
+          supportedChains: [84532 as SupportedChainId],
+        }) as unknown as ChainManager),
+      settings,
     )
 
     this._supportedChains = mockConfig?.supportedChains ?? [
@@ -57,17 +72,19 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
     ]
     this.mockProviderConfig = {
       supportedChains: this._supportedChains,
-      defaultPrice: mockConfig?.defaultPrice ?? '1.5',
+      defaultPrice: mockConfig?.defaultPrice ?? 1.5,
       defaultPriceImpact: mockConfig?.defaultPriceImpact ?? 0.001,
+      provider: mockConfig?.provider ?? 'uniswap',
     }
 
     // Create mocked functions
     this.mockExecute = vi
       .fn()
       .mockImplementation(this.createMockSwapTransaction.bind(this))
-    this.mockGetPrice = vi
+    this.mockGetQuote = vi
       .fn()
-      .mockImplementation(this.createMockPrice.bind(this))
+      .mockImplementation(this.createMockQuote.bind(this))
+    this.mockBuildApprovals = vi.fn().mockResolvedValue({})
     this.mockGetMarket = vi
       .fn()
       .mockImplementation(this.createMockMarket.bind(this))
@@ -76,7 +93,7 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
       .mockImplementation(this.createMockMarkets.bind(this))
   }
 
-  supportedChainIds(): SupportedChainId[] {
+  protocolSupportedChainIds(): SupportedChainId[] {
     return this._supportedChains
   }
 
@@ -86,8 +103,8 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
 
   // Expose protected methods for testing
   public testValidateMarketAllowed(
-    assetIn: any,
-    assetOut: any,
+    assetIn: Asset,
+    assetOut: Asset,
     chainId: SupportedChainId,
   ): void {
     return this.validateMarketAllowed(assetIn, assetOut, chainId)
@@ -99,8 +116,12 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
     return this.mockExecute(params)
   }
 
-  protected async _getPrice(params: SwapPriceParams): Promise<SwapPrice> {
-    return this.mockGetPrice(params)
+  protected async _getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+    return this.mockGetQuote(params)
+  }
+
+  protected async _buildApprovals(quote: SwapQuote) {
+    return this.mockBuildApprovals(quote)
   }
 
   protected async _getMarket(params: GetSwapMarketParams): Promise<SwapMarket> {
@@ -116,14 +137,14 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
   private createMockSwapTransaction(
     params: ResolvedSwapParams,
   ): SwapTransaction {
-    const amountIn = params.amountInWei ?? 1000000n
+    const amountIn = params.amountInRaw ?? 1000000n
     const amountOut = 1500000000000000000n
 
     return {
       amountIn: 1.0,
       amountOut: 1.5,
-      amountInWei: amountIn,
-      amountOutWei: amountOut,
+      amountInRaw: amountIn,
+      amountOutRaw: amountOut,
       assetIn: params.assetIn,
       assetOut: params.assetOut,
       price: this.mockProviderConfig.defaultPrice,
@@ -138,37 +159,51 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
     }
   }
 
-  private createMockPrice(params: SwapPriceParams): SwapPrice {
-    const amountIn =
-      params.amountIn !== undefined
-        ? BigInt(
-            Math.floor(
-              params.amountIn * 10 ** params.assetIn.metadata.decimals,
-            ),
-          )
-        : BigInt(10 ** params.assetIn.metadata.decimals)
-
-    const amountOut = (amountIn * 15n) / 10n
+  private createMockQuote(params: SwapQuoteParams): SwapQuote {
+    const now = Math.floor(Date.now() / 1000)
+    const deadline = params.deadline ?? now + 60
+    const slippage = params.slippage ?? 0.005
+    const amountIn = params.amountIn ?? 1.0
+    const amountOut = amountIn * this.mockProviderConfig.defaultPrice
+    const amountInRaw = BigInt(
+      Math.floor(amountIn * 10 ** params.assetIn.metadata.decimals),
+    )
+    const amountOutRaw = BigInt(
+      Math.floor(amountOut * 10 ** params.assetOut.metadata.decimals),
+    )
+    const amountOutMinRaw =
+      (amountOutRaw * BigInt(Math.round((1 - slippage) * 10000))) / 10000n
 
     return {
+      assetIn: params.assetIn,
+      assetOut: params.assetOut,
+      chainId: params.chainId,
+      amountIn,
+      amountInRaw,
+      amountOut,
+      amountOutRaw,
+      amountOutMin: amountOut * (1 - slippage),
+      amountOutMinRaw,
       price: this.mockProviderConfig.defaultPrice,
-      priceInverse: '0.666666',
-      amountIn: 1.0,
-      amountOut: 1.5,
-      amountInWei: amountIn,
-      amountOutWei: amountOut,
+      priceInverse: 1 / this.mockProviderConfig.defaultPrice,
       priceImpact: this.mockProviderConfig.defaultPriceImpact,
       route: {
-        path: [params.assetIn, params.assetOut!],
-        pools: [
-          {
-            address: '0x1234' as Address,
-            fee: 500,
-            version: 'v4',
-          },
-        ],
+        path: [params.assetIn, params.assetOut],
+        pools: [{ address: '0x1234' as Address, fee: 500, version: 'v4' }],
+      },
+      execution: {
+        swapCalldata: '0x1234' as `0x${string}`,
+        routerAddress: '0x492e6456d9528771018deb9e87ef7750ef184104' as Address,
+        value: 0n,
       },
+      provider: this.mockProviderConfig.provider,
+      slippage,
+      deadline,
+      quotedAt: now,
+      expiresAt: deadline,
       gasEstimate: 150000n,
+      quotedRecipient: (params.recipient ??
+        '0x0000000000000000000000000000000000000001') as Address,
     }
   }
 
@@ -191,7 +226,7 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
         },
       ],
       fee: 500,
-      provider: 'uniswap',
+      provider: this.mockProviderConfig.provider,
     }
   }