@eth-optimism/actions-sdk 0.0.0-main-20251009211102

package/src/services/tokenBalance.ts

@@ -0,0 +1,122 @@
+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'
+
+/**
+ * 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
+ */
+export async function fetchETHBalance(
+  chainManager: ChainManager,
+  walletAddress: Address,
+): Promise<TokenBalance> {
+  const supportedChains = chainManager.getSupportedChains()
+  const chainBalancePromises = supportedChains.map(async (chainId) => {
+    const publicClient = chainManager.getPublicClient(chainId)
+    const balance = await publicClient.getBalance({
+      address: walletAddress,
+    })
+    return {
+      chainId,
+      balance,
+      tokenAddress: ETH.address[chainId]!,
+      formattedBalance: formatEther(balance),
+    }
+  })
+  const chainBalances = await Promise.all(chainBalancePromises)
+  const totalBalance = chainBalances.reduce(
+    (total, { balance }) => total + balance,
+    0n,
+  )
+  return {
+    symbol: 'ETH',
+    totalBalance,
+    totalFormattedBalance: formatEther(totalBalance),
+    chainBalances,
+  }
+}
+
+/**
+ * Fetch total balance for this asset across all supported chains
+ */
+export async function fetchERC20Balance(
+  chainManager: ChainManager,
+  walletAddress: Address,
+  asset: Asset,
+): Promise<TokenBalance> {
+  const supportedChains = chainManager.getSupportedChains()
+  const chainsWithToken = supportedChains.filter(
+    (chainId) => asset.address[chainId],
+  )
+
+  const chainBalancePromises = chainsWithToken.map(async (chainId) => {
+    const { balance, tokenAddress } = await fetchERC20BalanceForChain(
+      asset,
+      chainId,
+      walletAddress,
+      chainManager,
+    )
+    return {
+      chainId,
+      balance,
+      tokenAddress,
+      formattedBalance: formatUnits(balance, asset.metadata.decimals),
+    }
+  })
+
+  const chainBalances = await Promise.all(chainBalancePromises)
+  const totalBalance = chainBalances.reduce(
+    (total, { balance }) => total + balance,
+    0n,
+  )
+
+  return {
+    symbol: asset.metadata.symbol,
+    totalBalance,
+    totalFormattedBalance: formatUnits(totalBalance, asset.metadata.decimals),
+    chainBalances,
+  }
+}
+
+/**
+ * Fetch balance for this asset on a specific chain
+ */
+async function fetchERC20BalanceForChain(
+  asset: Asset,
+  chainId: SupportedChainId,
+  walletAddress: Address,
+  chainManager: ChainManager,
+): Promise<{ balance: bigint; tokenAddress: Address }> {
+  const tokenAddress = asset.address[chainId]
+  if (!tokenAddress) {
+    throw new Error(
+      `${asset.metadata.symbol} not supported on chain ${chainId}`,
+    )
+  }
+
+  const publicClient = chainManager.getPublicClient(chainId)
+
+  // Handle native ETH balance
+  if (asset.type === 'native') {
+    return {
+      balance: await publicClient.getBalance({
+        address: walletAddress,
+      }),
+      tokenAddress: ETH.address[chainId]!,
+    }
+  }
+
+  const balance = await publicClient.readContract({
+    address: tokenAddress as Address,
+    abi: erc20Abi,
+    functionName: 'balanceOf',
+    args: [walletAddress],
+  })
+  return { balance, tokenAddress: tokenAddress as Address }
+}

package/src/supported/tokens.ts

@@ -0,0 +1,103 @@
+import type { Address } from 'viem'
+import { base, baseSepolia, mainnet, unichain } from 'viem/chains'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { Asset } from '@/types/asset.js'
+
+export const SUPPORTED_TOKENS: Asset[] = [
+  {
+    address: {
+      [mainnet.id]: '0x0000000000000000000000000000000000000000',
+      [unichain.id]: '0x0000000000000000000000000000000000000000',
+      [base.id]: '0x0000000000000000000000000000000000000000',
+      [baseSepolia.id]: '0x0000000000000000000000000000000000000000',
+    },
+    metadata: {
+      symbol: 'ETH',
+      name: 'Ethereum',
+      decimals: 18,
+    },
+    type: 'native',
+  },
+  {
+    address: {
+      [mainnet.id]: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+      [unichain.id]: '0x078d782b760474a361dda0af3839290b0ef57ad6',
+      [baseSepolia.id]: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
+    },
+    metadata: {
+      symbol: 'USDC',
+      name: 'USDC',
+      decimals: 6,
+    },
+    type: 'erc20',
+  },
+  {
+    address: {
+      [baseSepolia.id]: '0x87c25229afbc30418d0144e8dfb2bcf8efd92c6c',
+    },
+    metadata: {
+      symbol: 'USDC_DEMO',
+      name: 'USDC Demo',
+      decimals: 6,
+    },
+    type: 'erc20',
+  },
+  {
+    address: {
+      [mainnet.id]: '0x58D97B57BB95320F9a05dC918Aef65434969c2B2',
+      [base.id]: '0xBAa5CC21fd487B8Fcc2F632f3F4E8D37262a0842',
+    },
+    metadata: {
+      symbol: 'MORPHO',
+      name: 'Morpho Token',
+      decimals: 18,
+    },
+    type: 'erc20',
+  },
+]
+
+/**
+ * Find token by address and chain ID
+ * @param address Token address
+ * @param chainId Chain ID
+ * @returns Token symbol or null if not found
+ */
+export function findTokenByAddress(
+  address: Address,
+  chainId: SupportedChainId,
+): string | null {
+  const normalizedAddress = address.toLowerCase()
+
+  for (const token of SUPPORTED_TOKENS) {
+    const tokenAddress = token.address[chainId]
+    if (tokenAddress && tokenAddress.toLowerCase() === normalizedAddress) {
+      return token.metadata.symbol
+    }
+  }
+
+  return null
+}
+
+/**
+ * Get token address for a specific chain
+ * @param symbol Token symbol
+ * @param chainId Chain ID
+ * @returns Token address or null if not supported on that chain
+ */
+export function getTokenAddress(
+  symbol: string,
+  chainId: SupportedChainId,
+): Address | null {
+  const token = SUPPORTED_TOKENS.find((t) => t.metadata.symbol === symbol)
+  return token?.address[chainId] || null
+}
+
+/**
+ * Get token by symbol
+ * @param symbol Token symbol
+ * @returns Asset or null if not found
+ */
+export function getTokenBySymbol(symbol: string): Asset | null {
+  return SUPPORTED_TOKENS.find((t) => t.metadata.symbol === symbol) || null
+}

package/src/test/MockAssets.ts

@@ -0,0 +1,33 @@
+import type { Address } from 'viem'
+
+import type { Asset } from '@/types/asset.js'
+
+/**
+ * Mock USDC asset for testing
+ */
+export const MockUSDCAsset: Asset = {
+  address: {
+    130: '0xA0b86991c431c924C2407E4C573C686cc8C6c5b7' as Address,
+  },
+  metadata: {
+    decimals: 6,
+    name: 'USD Coin',
+    symbol: 'USDC',
+  },
+  type: 'erc20',
+}
+
+/**
+ * Mock WETH asset for testing
+ */
+export const MockWETHAsset: Asset = {
+  address: {
+    130: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2' as Address,
+  },
+  metadata: {
+    decimals: 18,
+    name: 'Wrapped Ether',
+    symbol: 'WETH',
+  },
+  type: 'erc20',
+}

package/src/test/MockChainManager.ts

@@ -0,0 +1,138 @@
+import { chainById } from '@eth-optimism/viem/chains'
+import type { Chain, PublicClient } from 'viem'
+import type { BundlerClient, SmartAccount } from 'viem/account-abstraction'
+import { unichain } from 'viem/chains'
+import { type MockedFunction, vi } from 'vitest'
+
+import type {
+  SUPPORTED_CHAIN_IDS,
+  SupportedChainId,
+} from '@/constants/supportedChains.js'
+
+export interface MockChainManagerConfig {
+  supportedChains: SupportedChainId[]
+  defaultBalance: bigint
+  defaultETHBalance: bigint
+}
+
+/**
+ * Mock ChainManager for testing
+ * Provides the same interface as the real ChainManager but with configurable behavior
+ */
+export class MockChainManager {
+  public getSupportedChains: MockedFunction<() => number[]>
+  public getPublicClient: MockedFunction<
+    (chainId: SupportedChainId) => PublicClient
+  >
+  public getBundlerClient: MockedFunction<
+    (chainId: SupportedChainId, account: SmartAccount) => BundlerClient
+  >
+
+  private config: MockChainManagerConfig
+  private publicClients: Map<SupportedChainId, PublicClient>
+  private bundlerClients: Map<SupportedChainId, BundlerClient>
+
+  constructor(config?: Partial<MockChainManagerConfig>) {
+    this.config = {
+      supportedChains: config?.supportedChains ?? [unichain.id],
+      defaultBalance: config?.defaultBalance ?? 1000000n,
+      defaultETHBalance: config?.defaultETHBalance ?? 1000000000n,
+    }
+
+    this.publicClients = this.createMockPublicClients()
+    this.bundlerClients = this.createMockBundlerClients()
+
+    // Create mocked functions
+    this.getSupportedChains = vi
+      .fn()
+      .mockReturnValue(this.config.supportedChains)
+    this.getPublicClient = vi
+      .fn()
+      .mockImplementation((chainId: SupportedChainId) => {
+        const client = this.publicClients.get(chainId)
+        if (!client) {
+          throw new Error(
+            `No public client configured for chain ID: ${chainId}`,
+          )
+        }
+        return client
+      })
+    this.getBundlerClient = vi
+      .fn()
+      .mockImplementation((chainId: SupportedChainId) => {
+        const client = this.bundlerClients.get(chainId)
+        if (!client) {
+          throw new Error(
+            `No bundler client configured for chain ID: ${chainId}`,
+          )
+        }
+        return client
+      })
+  }
+
+  reset(): void {
+    vi.clearAllMocks()
+    this.publicClients.forEach((client) => {
+      vi.mocked(client.readContract).mockResolvedValue(
+        this.config.defaultBalance,
+      )
+    })
+  }
+
+  getChain(chainId: (typeof SUPPORTED_CHAIN_IDS)[number]): Chain {
+    return chainById[chainId]
+  }
+
+  getRpcUrls(chainId: (typeof SUPPORTED_CHAIN_IDS)[number]): string[] {
+    return this.getChain(chainId).rpcUrls.default.http as string[]
+  }
+
+  getTransportForChain(_chainId: (typeof SUPPORTED_CHAIN_IDS)[number]) {
+    // Mock implementation returns a simple http transport
+    // In tests, the actual transport behavior is typically mocked at a higher level
+    return {} as unknown
+  }
+
+  private createMockBundlerClients(): Map<SupportedChainId, BundlerClient> {
+    const clients = new Map<SupportedChainId, BundlerClient>()
+
+    for (const chainId of this.config.supportedChains) {
+      const mockClient: BundlerClient = this.createBundlerClient()
+      clients.set(chainId, mockClient)
+    }
+
+    return clients
+  }
+
+  private createMockPublicClients(): Map<SupportedChainId, PublicClient> {
+    const clients = new Map<SupportedChainId, PublicClient>()
+
+    for (const chainId of this.config.supportedChains) {
+      const mockClient: PublicClient = this.createPublicClient(chainId)
+
+      clients.set(chainId, mockClient)
+    }
+
+    return clients
+  }
+
+  private createPublicClient(chainId: SupportedChainId): PublicClient {
+    return {
+      chain: { id: chainId },
+      readContract: vi.fn().mockImplementation(() => {
+        return Promise.resolve(this.config.defaultBalance)
+      }),
+      getBalance: vi.fn().mockImplementation(() => {
+        return Promise.resolve(this.config.defaultBalance)
+      }),
+    } as any
+  }
+
+  private createBundlerClient(): BundlerClient {
+    return {
+      sendUserOperation: vi.fn(),
+      waitForUserOperationReceipt: vi.fn(),
+      prepareUserOperation: vi.fn(),
+    } as any
+  }
+}