@eth-optimism/actions-sdk 0.0.2

package/src/test/MockLendProvider.ts

@@ -0,0 +1,397 @@
+import type { Address } from 'viem'
+import { type MockedFunction, vi } from 'vitest'
+
+import { LendProvider } from '@/lend/core/LendProvider.js'
+import type { Asset } from '@/types/asset.js'
+import type {
+  ClosePositionParams,
+  GetLendMarketParams,
+  GetLendMarketsParams,
+  GetMarketBalanceParams,
+  LendClosePositionParams,
+  LendConfig,
+  LendMarket,
+  LendMarketId,
+  LendMarketPosition,
+  LendOpenPositionInternalParams,
+  LendOpenPositionParams,
+  LendOptions,
+  LendTransaction,
+} from '@/types/lend/index.js'
+
+export interface MockLendProviderConfig {
+  supportedChains: number[]
+  defaultApy: number
+  mockBalance: bigint
+}
+
+/**
+ * Mock Lend Provider for testing
+ * @description Provides a mock implementation of LendProvider following MockChainManager pattern
+ */
+export class MockLendProvider extends LendProvider<LendConfig> {
+  public openPosition: MockedFunction<
+    (params: LendOpenPositionParams) => Promise<LendTransaction>
+  >
+  public getMarket: MockedFunction<
+    (params: GetLendMarketParams) => Promise<LendMarket>
+  >
+  public getMarkets: MockedFunction<
+    (params?: GetLendMarketsParams) => Promise<LendMarket[]>
+  >
+  public getPosition: MockedFunction<
+    (
+      walletAddress: Address,
+      marketId?: LendMarketId,
+      asset?: Asset,
+    ) => Promise<LendMarketPosition>
+  >
+  public closePosition: MockedFunction<
+    (closePositionParams: ClosePositionParams) => Promise<LendTransaction>
+  >
+  public withdraw: MockedFunction<
+    (
+      asset: Address,
+      amount: bigint,
+      chainId: number,
+      marketId?: string,
+      options?: LendOptions,
+    ) => Promise<LendTransaction>
+  >
+
+  protected readonly SUPPORTED_CHAIN_IDS = [1, 130, 8453, 84532] as const
+
+  protected readonly SUPPORTED_CHAINS = {
+    TESTNET: {
+      chainId: 84532,
+      name: 'Test Chain',
+    },
+  }
+
+  private mockConfig: MockLendProviderConfig
+
+  constructor(
+    config?: LendConfig,
+    mockConfig?: Partial<MockLendProviderConfig>,
+  ) {
+    super(config || { provider: 'morpho' })
+
+    this.mockConfig = {
+      supportedChains: mockConfig?.supportedChains ?? [84532],
+      defaultApy: mockConfig?.defaultApy ?? 0.05,
+      mockBalance: mockConfig?.mockBalance ?? 1000000n,
+    }
+
+    // Create mocked functions with default implementations
+    this.openPosition = vi
+      .fn()
+      .mockImplementation(this.createMockOpenPosition.bind(this))
+    this.getMarket = vi
+      .fn()
+      .mockImplementation(({ address, chainId }: GetLendMarketParams) => {
+        return this.createMockMarket({ address, chainId })
+      })
+    this.getMarkets = vi
+      .fn()
+      .mockImplementation(this.createMockMarkets.bind(this))
+    this.getPosition = vi
+      .fn()
+      .mockImplementation(this.createMockPosition.bind(this))
+    this.closePosition = vi
+      .fn()
+      .mockImplementation(this.createMockClosePosition.bind(this))
+    this.withdraw = vi
+      .fn()
+      .mockImplementation(this.createMockWithdraw.bind(this))
+  }
+
+  /**
+   * Helper method to configure mock responses
+   */
+  configureMock(config: {
+    openPositionResponse?: LendTransaction
+    marketResponse?: LendMarket
+    marketsResponse?: LendMarket[]
+    balanceResponse?: LendMarketPosition
+  }) {
+    if (config.openPositionResponse) {
+      this.openPosition.mockResolvedValue(config.openPositionResponse)
+    }
+    if (config.marketResponse) {
+      this.getMarket.mockResolvedValue(config.marketResponse)
+    }
+    if (config.marketsResponse) {
+      this.getMarkets.mockResolvedValue(config.marketsResponse)
+    }
+    if (config.balanceResponse) {
+      this.getPosition.mockResolvedValue(config.balanceResponse)
+    }
+  }
+
+  /**
+   * Helper method to simulate errors
+   */
+  simulateError(method: keyof MockLendProvider, error: Error) {
+    const mockMethod = this[method] as MockedFunction<any>
+    if (mockMethod && typeof mockMethod.mockRejectedValue === 'function') {
+      mockMethod.mockRejectedValue(error)
+    }
+  }
+
+  /**
+   * Reset all mocks to their default implementations
+   */
+  resetMocks() {
+    this.openPosition.mockImplementation(this.createMockOpenPosition.bind(this))
+    this.getMarket.mockImplementation(
+      ({ address, chainId }: GetLendMarketParams) => {
+        return this.createMockMarket({ address, chainId })
+      },
+    )
+    this.getMarkets.mockImplementation(this.createMockMarkets.bind(this))
+    this.getPosition.mockImplementation(this.createMockPosition.bind(this))
+    this.closePosition.mockImplementation(
+      this.createMockClosePosition.bind(this),
+    )
+    this.withdraw.mockImplementation(this.createMockWithdraw.bind(this))
+  }
+
+  reset(): void {
+    vi.clearAllMocks()
+    this.resetMocks()
+  }
+
+  protected async _openPosition(
+    params: LendOpenPositionInternalParams,
+  ): Promise<LendTransaction> {
+    return this.createMockOpenPositionInternal(params)
+  }
+
+  protected async _getMarket(marketId: LendMarketId): Promise<LendMarket> {
+    return this.createMockMarket(marketId)
+  }
+
+  protected async _getMarkets(
+    _params: GetLendMarketsParams,
+  ): Promise<LendMarket[]> {
+    return this.createMockMarkets()
+  }
+
+  protected async _getPosition(
+    params: GetMarketBalanceParams,
+  ): Promise<LendMarketPosition> {
+    return this.createMockPosition(params.walletAddress, params.marketId)
+  }
+
+  protected async _closePosition(
+    params: LendClosePositionParams,
+  ): Promise<LendTransaction> {
+    const assetAddress = params.asset?.address[params.marketId.chainId]
+    if (!assetAddress) {
+      throw new Error(`Asset not supported on chain ${params.marketId.chainId}`)
+    }
+
+    return this.createMockWithdraw(
+      assetAddress,
+      params.amount,
+      params.marketId.chainId,
+      params.marketId.address,
+      params.options,
+    )
+  }
+
+  private async createMockOpenPosition({
+    amount,
+    asset,
+    marketId,
+    options,
+  }: LendOpenPositionParams): Promise<LendTransaction> {
+    // Get asset address for the chain
+    const assetAddress = asset.address[marketId.chainId]
+    if (!assetAddress) {
+      throw new Error(`Asset not supported on chain ${marketId.chainId}`)
+    }
+
+    // Convert human-readable amount to wei (mock conversion)
+    const amountWei = BigInt(Math.floor(amount * 10 ** asset.metadata.decimals))
+
+    return {
+      amount: amountWei,
+      asset: assetAddress,
+      marketId: marketId.address,
+      apy: this.mockConfig.defaultApy,
+      slippage: options?.slippage || this._config.defaultSlippage || 50,
+      transactionData: {
+        approval: {
+          to: assetAddress,
+          data: '0x095ea7b3' as Address,
+          value: 0n,
+        },
+        openPosition: {
+          to: marketId.address,
+          data: '0x6e553f65' as Address,
+          value: 0n,
+        },
+      },
+    }
+  }
+
+  private async createMockOpenPositionInternal({
+    amountWei,
+    asset,
+    marketId,
+    options,
+  }: LendOpenPositionInternalParams): Promise<LendTransaction> {
+    // Get asset address for the chain
+    const assetAddress = asset.address[marketId.chainId]
+    if (!assetAddress) {
+      throw new Error(`Asset not supported on chain ${marketId.chainId}`)
+    }
+
+    return {
+      amount: amountWei,
+      asset: assetAddress,
+      marketId: marketId.address,
+      apy: this.mockConfig.defaultApy,
+      slippage: options?.slippage || this._config.defaultSlippage || 50,
+      transactionData: {
+        approval: {
+          to: assetAddress,
+          data: '0x095ea7b3' as Address,
+          value: 0n,
+        },
+        openPosition: {
+          to: marketId.address,
+          data: '0x6e553f65' as Address,
+          value: 0n,
+        },
+      },
+    }
+  }
+
+  private async createMockMarket(marketId: LendMarketId): Promise<LendMarket> {
+    return {
+      marketId,
+      name: 'Mock Market',
+      asset: {
+        address: {
+          [marketId.chainId]:
+            '0x0000000000000000000000000000000000000001' as Address,
+        },
+        metadata: {
+          symbol: 'MOCK',
+          name: 'Mock Token',
+          decimals: 18,
+        },
+        type: 'erc20',
+      },
+      supply: {
+        totalAssets: this.mockConfig.mockBalance,
+        totalShares: this.mockConfig.mockBalance,
+      },
+      apy: {
+        total: this.mockConfig.defaultApy,
+        native: this.mockConfig.defaultApy * 0.8,
+        totalRewards: this.mockConfig.defaultApy * 0.2,
+        performanceFee: 0.1,
+      },
+      metadata: {
+        owner: '0x0000000000000000000000000000000000000002' as Address,
+        curator: '0x0000000000000000000000000000000000000003' as Address,
+        fee: 10,
+        lastUpdate: Math.floor(Date.now() / 1000),
+      },
+    }
+  }
+
+  private async createMockMarkets(): Promise<LendMarket[]> {
+    return [
+      await this.createMockMarket({
+        address: '0x1234567890123456789012345678901234567890' as Address,
+        chainId: 84532,
+      }),
+    ]
+  }
+
+  private async createMockPosition(
+    _walletAddress: Address,
+    marketId?: LendMarketId,
+    _asset?: Asset,
+  ): Promise<LendMarketPosition> {
+    if (!marketId) {
+      throw new Error('marketId is required for mock position')
+    }
+
+    return {
+      balance: this.mockConfig.mockBalance / 2n,
+      balanceFormatted: (this.mockConfig.mockBalance / 2n).toString(),
+      shares: this.mockConfig.mockBalance / 2n,
+      sharesFormatted: (this.mockConfig.mockBalance / 2n).toString(),
+      marketId,
+    }
+  }
+
+  private async createMockClosePosition({
+    amount,
+    asset,
+    marketId,
+    options,
+  }: ClosePositionParams): Promise<LendTransaction> {
+    // If asset provided, use its address for the chain; otherwise use a mock asset
+    const assetAddress =
+      asset?.address[marketId.chainId] ||
+      ('0x1234567890123456789012345678901234567890' as Address)
+
+    return {
+      amount: BigInt(amount),
+      asset: assetAddress,
+      marketId: marketId.address,
+      apy: 0,
+      slippage: options?.slippage || this._config.defaultSlippage || 50,
+      transactionData: {
+        closePosition: {
+          to: marketId.address,
+          data: '0xb460af94' as Address,
+          value: 0n,
+        },
+      },
+    }
+  }
+
+  private async createMockWithdraw(
+    asset: Address,
+    amount: bigint,
+    chainId: number,
+    marketId?: string,
+    options?: LendOptions,
+  ): Promise<LendTransaction> {
+    return {
+      amount,
+      asset,
+      marketId: marketId || 'mock-market',
+      apy: 0,
+      slippage: options?.slippage || this._config.defaultSlippage || 50,
+      transactionData: {
+        closePosition: {
+          to:
+            (marketId as Address) ||
+            ('0x1234567890123456789012345678901234567890' as Address),
+          data: '0xb460af94' as Address,
+          value: 0n,
+        },
+      },
+    }
+  }
+}
+
+/**
+ * Create a mock lend provider
+ * @param config - Optional configuration for the mock
+ * @returns MockLendProvider instance
+ */
+export function createMockLendProvider(
+  config?: LendConfig,
+  mockConfig?: Partial<MockLendProviderConfig>,
+): MockLendProvider {
+  return new MockLendProvider(config, mockConfig)
+}

package/src/test/MockMarkets.ts

@@ -0,0 +1,32 @@
+import type { Address } from 'viem'
+
+import { MockUSDCAsset, MockWETHAsset } from '@/test/MockAssets.js'
+import type { LendMarketConfig } from '@/types/lend/index.js'
+
+/**
+ * Mock Gauntlet USDC market configuration for testing
+ */
+export const MockGauntletUSDCMarket: LendMarketConfig = {
+  address: '0x38f4f3B6533de0023b9DCd04b02F93d36ad1F9f9' as Address,
+  chainId: 130,
+  name: 'Gauntlet USDC',
+  asset: MockUSDCAsset,
+  lendProvider: 'morpho',
+}
+
+/**
+ * Mock WETH market configuration for testing
+ */
+export const MockWETHMarket: LendMarketConfig = {
+  address: '0x1234567890123456789012345678901234567890' as Address,
+  chainId: 130,
+  name: 'Test WETH Market',
+  asset: MockWETHAsset,
+  lendProvider: 'morpho',
+}
+
+/**
+ * Mock receiver address for testing
+ */
+export const MockReceiverAddress =
+  '0x1234567890123456789012345678901234567890' as Address

package/src/test/MockPrivyClient.ts

@@ -0,0 +1,118 @@
+import type { PrivyClient } from '@privy-io/server-auth'
+import type { Address } from 'viem'
+
+import { getRandomAddress } from '@/test/utils.js'
+
+/**
+ * Mock Privy Client for testing
+ * @description Provides a mock implementation of PrivyClient for testing purposes
+ */
+export class MockPrivyClient {
+  public walletApi = {
+    createWallet: async (params: { chainType: string }) => {
+      const walletId = `mock-wallet-${++this.walletCounter}`
+      const address = getRandomAddress()
+
+      const wallet = new MockWallet(walletId, address)
+      this.mockWallets.set(walletId, wallet)
+
+      return {
+        id: walletId,
+        address: address,
+        chainType: params.chainType,
+      }
+    },
+
+    getWallet: async (params: { id: string }) => {
+      const wallet = this.mockWallets.get(params.id)
+      if (!wallet) {
+        throw new Error(`Wallet ${params.id} not found`)
+      }
+
+      return {
+        id: wallet.id,
+        address: wallet.address,
+        chainType: 'ethereum',
+      }
+    },
+
+    getWallets: async (params?: { limit?: number; cursor?: string }) => {
+      const wallets = Array.from(this.mockWallets.values())
+      const limit = params?.limit || wallets.length
+
+      return {
+        data: wallets.slice(0, limit).map((wallet) => ({
+          id: wallet.id,
+          address: wallet.address,
+          chainType: 'ethereum',
+        })),
+      }
+    },
+
+    ethereum: {
+      signMessage: async (params: { walletId: string; message: string }) => {
+        const wallet = this.mockWallets.get(params.walletId)
+        if (!wallet) {
+          throw new Error(`Wallet ${params.walletId} not found`)
+        }
+
+        // Mock signature - deterministic based on message
+        const mockSig = `0x${'a'.repeat(128)}${params.message.length.toString(16).padStart(2, '0')}`
+        return { signature: mockSig }
+      },
+
+      secp256k1Sign: async (params: { walletId: string; hash: string }) => {
+        const wallet = this.mockWallets.get(params.walletId)
+        if (!wallet) {
+          throw new Error(`Wallet ${params.walletId} not found`)
+        }
+
+        // Mock signature - deterministic based on hash
+        const mockSig = `0x${'b'.repeat(128)}${params.hash.slice(-2)}`
+        return { signature: mockSig }
+      },
+
+      signTransaction: async (params: {
+        walletId: string
+        transaction: unknown
+      }) => {
+        const wallet = this.mockWallets.get(params.walletId)
+        if (!wallet) {
+          throw new Error(`Wallet ${params.walletId} not found`)
+        }
+
+        // Mock signed transaction
+        const mockSignedTx = `0x${'c'.repeat(200)}`
+        return { signedTransaction: mockSignedTx }
+      },
+    },
+  }
+
+  private mockWallets = new Map<string, MockWallet>()
+  private walletCounter = 0
+
+  constructor(
+    public appId: string,
+    public appSecret: string,
+  ) {}
+}
+
+class MockWallet {
+  constructor(
+    public id: string,
+    public address: Address,
+  ) {}
+}
+
+/**
+ * Create a mock Privy client cast as PrivyClient type
+ * @param appId - Mock app ID
+ * @param appSecret - Mock app secret
+ * @returns MockPrivyClient cast as PrivyClient
+ */
+export function createMockPrivyClient(
+  appId: string,
+  appSecret: string,
+): PrivyClient {
+  return new MockPrivyClient(appId, appSecret) as unknown as PrivyClient
+}

package/src/test/utils.ts

@@ -0,0 +1,5 @@
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+
+export const getRandomAddress = () => {
+  return privateKeyToAccount(generatePrivateKey()).address
+}

package/src/types/actions.ts

@@ -0,0 +1,80 @@
+import type { ChainConfig } from '@/types/chain.js'
+import type { LendConfig } from '@/types/lend/index.js'
+import type { ProviderSpec } from '@/wallet/core/providers/hosted/types/index.js'
+
+/**
+ * Network configuration for lending providers
+ * @description Basic network information that lending providers need
+ */
+export interface LendNetworkConfig {
+  chainId: number
+  name: string
+}
+
+/**
+ * Actions SDK configuration
+ * @description Configuration object for initializing the Actions SDK
+ */
+export interface ActionsConfig<
+  THostedWalletProviderType extends string,
+  TConfigMap extends { [K in THostedWalletProviderType]: unknown },
+> {
+  /** Wallet configuration */
+  wallet: WalletConfig<THostedWalletProviderType, TConfigMap>
+  /** Lending provider configuration (optional) */
+  lend?: LendConfig
+  /** Chains to use for the SDK */
+  chains: ChainConfig[]
+}
+
+/**
+ * Wallet configuration
+ * @description Configuration for wallet providers
+ */
+export type WalletConfig<
+  THostedProviderType extends string,
+  TConfigMap extends { [K in THostedProviderType]: unknown },
+> = {
+  /** Hosted wallet configuration */
+  hostedWalletConfig: HostedWalletConfig<THostedProviderType, TConfigMap>
+  /** Smart wallet configuration for ERC-4337 infrastructure */
+  smartWalletConfig: SmartWalletConfig
+}
+
+/**
+ * Hosted wallet configuration
+ * @description Configuration for hosted wallets / signers
+ */
+export interface HostedWalletConfig<
+  THostedProviderType extends string,
+  TConfigMap extends { [K in THostedProviderType]: unknown },
+> {
+  /** Wallet provider for account creation, management, and signing */
+  provider: ProviderSpec<THostedProviderType, TConfigMap>
+}
+
+/**
+ * Smart Wallet configuration
+ * @description Configuration for ERC-4337 smart wallets.
+ */
+export interface SmartWalletConfig {
+  /** Wallet provider for smart wallet management */
+  provider: SmartWalletProvider
+}
+
+/**
+ * Smart wallet provider configurations
+ * @description Union type supporting multiple wallet provider implementations
+ */
+export type SmartWalletProvider = DefaultSmartWalletProvider
+
+/**
+ * Default smart wallet provider configuration
+ * @description Built-in provider smart wallet provider.
+ */
+export interface DefaultSmartWalletProvider {
+  type: 'default'
+  // This string will be converted to a 16-byte hex suffix appended to callData and initCode
+  // on all ERC-4337 UserOperations
+  attributionSuffix?: string
+}

package/src/types/asset.ts

@@ -0,0 +1,34 @@
+import type { Address } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+
+/**
+ * Asset type inspired by EIP 7811 but adapted for multi-chain asset definitions
+ */
+export interface Asset {
+  /** Multi-chain address mapping */
+  address: Partial<Record<SupportedChainId, Address>>
+  /** Asset metadata */
+  metadata: {
+    decimals: number
+    name: string
+    symbol: string
+  }
+  /** Asset type for proper handling */
+  type: 'native' | 'erc20'
+}
+
+/**
+ * Detailed token balance information
+ */
+export interface TokenBalance {
+  symbol: string
+  totalBalance: bigint
+  totalFormattedBalance: string
+  chainBalances: Array<{
+    chainId: SupportedChainId
+    balance: bigint
+    tokenAddress: Address
+    formattedBalance: string
+  }>
+}

package/src/types/chain.ts

@@ -0,0 +1,30 @@
+import type { SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
+
+/**
+ * Chain configuration
+ * @description Configuration for each supported chain
+ */
+export interface ChainConfig {
+  /** Chain ID */
+  chainId: (typeof SUPPORTED_CHAIN_IDS)[number]
+  /** RPC URL for the chain */
+  rpcUrls?: string[]
+  /** Bundler configuration */
+  bundler?: BundlerConfig
+}
+
+export interface BaseBundlerConfig {
+  /** The URL of the bundler service */
+  url: string
+}
+
+export type BundlerConfig = SimpleBundlerConfig | PimlicoBundlerConfig
+
+export interface SimpleBundlerConfig extends BaseBundlerConfig {
+  type: 'simple'
+}
+
+export interface PimlicoBundlerConfig extends BaseBundlerConfig {
+  type: 'pimlico'
+  sponsorshipPolicyId?: string
+}

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export * from '@/types/actions.js'
+export * from '@/types/asset.js'
+export * from '@/types/chain.js'
+export * from '@/types/lend/index.js'
+export * from '@/types/wallet.js'