@eth-optimism/actions-sdk 0.4.0 → 0.6.0

package/src/actions.ts

@@ -1,8 +1,13 @@
-import { AaveLendProvider, MorphoLendProvider } from '@/lend/index.js'
-import { ActionsLendNamespace } from '@/lend/namespaces/ActionsLendNamespace.js'
+import { AaveLendProvider, MorphoLendProvider } from '@/actions/lend/index.js'
+import { ActionsLendNamespace } from '@/actions/lend/namespaces/ActionsLendNamespace.js'
+import {
+  UniswapSwapProvider,
+  VelodromeSwapProvider,
+} from '@/actions/swap/index.js'
+import { ActionsSwapNamespace } from '@/actions/swap/namespaces/ActionsSwapNamespace.js'
+import { ProviderNotConfiguredError } from '@/core/error/errors.js'
 import { ChainManager } from '@/services/ChainManager.js'
-import { UniswapSwapProvider, VelodromeSwapProvider } from '@/swap/index.js'
-import { ActionsSwapNamespace } from '@/swap/namespaces/ActionsSwapNamespace.js'
+import { EnsNamespace } from '@/services/nameservices/ens/index.js'
 import type {
   ActionsConfig,
   AssetsConfig,
@@ -47,6 +52,7 @@ export class Actions<
     SmartWalletProvider
   >
   private chainManager: ChainManager
+  private _ens: EnsNamespace
   private _lend?: ActionsLendNamespace
   private _lendProviders: LendProviders = {}
   private _swap?: ActionsSwapNamespace
@@ -76,16 +82,21 @@ export class Actions<
     this._assetsConfig = config.assets
     validateConfigAddresses(config)
 
+    this._ens = new EnsNamespace(this.chainManager)
+
+    const lendSettings = config.lend?.settings
     if (config.lend?.morpho) {
       this._lendProviders.morpho = new MorphoLendProvider(
         config.lend.morpho,
         this.chainManager,
+        lendSettings,
       )
     }
     if (config.lend?.aave) {
       this._lendProviders.aave = new AaveLendProvider(
         config.lend.aave,
         this.chainManager,
+        lendSettings,
       )
     }
     if (this._lendProviders.morpho || this._lendProviders.aave) {
@@ -111,6 +122,7 @@ export class Actions<
     if (Object.values(this._swapProviders).some(Boolean)) {
       this._swap = new ActionsSwapNamespace(
         this._swapProviders,
+        (r) => (r ? this._ens.getAddress(r) : Promise.resolve(undefined)),
         this._swapSettings,
       )
     }
@@ -127,9 +139,10 @@ export class Actions<
    */
   get lend(): ActionsLendNamespace {
     if (!this._lend) {
-      throw new Error(
-        'Lend provider not configured. Please add lend configuration to ActionsConfig.',
-      )
+      throw new ProviderNotConfiguredError({
+        provider: 'lend',
+        details: 'Please add lend configuration to ActionsConfig.',
+      })
     }
     return this._lend
   }
@@ -142,6 +155,16 @@ export class Actions<
     return this._lendProviders
   }
 
+  /**
+   * Get ENS operations interface
+   * @description Access to Ethereum Name Service operations: resolve, reverseResolve, lookupText.
+   * Requires Ethereum mainnet (chain ID 1) to be included in your chain configuration.
+   * @returns EnsNamespace for ENS operations
+   */
+  get ens(): EnsNamespace {
+    return this._ens
+  }
+
   /**
    * Get swap operations interface
    * @description Access to swap operations like price quotes and markets.
@@ -151,9 +174,10 @@ export class Actions<
    */
   get swap(): ActionsSwapNamespace {
     if (!this._swap) {
-      throw new Error(
-        'Swap provider not configured. Please add swap configuration to ActionsConfig.',
-      )
+      throw new ProviderNotConfiguredError({
+        provider: 'swap',
+        details: 'Please add swap configuration to ActionsConfig.',
+      })
     }
     return this._swap
   }
@@ -211,7 +235,42 @@ export class Actions<
       SmartWalletProvider
     >
   > {
-    const hostedWalletProviderConfig = config.hostedWalletConfig.provider
+    const hostedWalletProvider = config.hostedWalletConfig
+      ? await this.createHostedWalletProvider(config.hostedWalletConfig)
+      : undefined
+
+    const smartWalletProvider: SmartWalletProvider = (() => {
+      if (
+        !config.smartWalletConfig ||
+        config.smartWalletConfig.provider.type === 'default'
+      ) {
+        return new DefaultSmartWalletProvider(
+          this.chainManager,
+          this._lendProviders,
+          this._swapProviders,
+          this.getSupportedAssets(),
+          config.smartWalletConfig.provider.attributionSuffix,
+        )
+      }
+      throw new ProviderNotConfiguredError({
+        provider: config.smartWalletConfig.provider.type,
+      })
+    })()
+
+    return new WalletProvider(hostedWalletProvider, smartWalletProvider)
+  }
+
+  private async createHostedWalletProvider(
+    hostedWalletConfig: NonNullable<
+      ActionsConfig<
+        THostedWalletProviderType,
+        THostedWalletProvidersSchema['providerConfigs']
+      >['wallet']['hostedWalletConfig']
+    >,
+  ): Promise<
+    THostedWalletProvidersSchema['providerInstances'][THostedWalletProviderType]
+  > {
+    const hostedWalletProviderConfig = hostedWalletConfig.provider
     const factory = this.hostedWalletProviderRegistry.getFactory(
       hostedWalletProviderConfig.type,
     )
@@ -221,11 +280,12 @@ export class Actions<
         : undefined
     ) as unknown
     if (!factory.validateOptions(options)) {
-      throw new Error(
-        `Invalid options for hosted wallet provider: ${hostedWalletProviderConfig.type}`,
-      )
+      throw new ProviderNotConfiguredError({
+        provider: hostedWalletProviderConfig.type,
+        details: 'Invalid options',
+      })
     }
-    const hostedWalletProvider = await factory.create(
+    return factory.create(
       {
         chainManager: this.chainManager,
         lendProviders: this._lendProviders,
@@ -235,26 +295,6 @@ export class Actions<
       },
       options,
     )
-
-    let smartWalletProvider: SmartWalletProvider
-    if (
-      !config.smartWalletConfig ||
-      config.smartWalletConfig.provider.type === 'default'
-    ) {
-      smartWalletProvider = new DefaultSmartWalletProvider(
-        this.chainManager,
-        this._lendProviders,
-        this._swapProviders,
-        this.getSupportedAssets(),
-        config.smartWalletConfig.provider.attributionSuffix,
-      )
-    } else {
-      throw new Error(
-        `Unsupported smart wallet provider: ${config.smartWalletConfig.provider.type}`,
-      )
-    }
-
-    return new WalletProvider(hostedWalletProvider, smartWalletProvider)
   }
 
   /**
@@ -276,6 +316,12 @@ export class Actions<
       THostedWalletProvidersSchema['providerToActionsOptions'],
       THostedWalletProvidersSchema['providerInstances'][THostedWalletProviderType],
       SmartWalletProvider
-    >(providerFactory)
+    >(providerFactory, {
+      chainManager: this.chainManager,
+      lendProviders: this._lendProviders,
+      swapProviders: this._swapProviders,
+      supportedAssets: this.getSupportedAssets(),
+      swapSettings: this._swapSettings,
+    })
   }
 }

package/src/core/error/__tests__/errors.test.ts

@@ -0,0 +1,236 @@
+import { BaseError } from 'viem'
+import { describe, expect, it } from 'vitest'
+
+import {
+  ActionsError,
+  AddressRequiredError,
+  AmountRequiredError,
+  AssetMetadataRequiredError,
+  AssetNotSupportedOnChainError,
+  ChainNotSupportedError,
+  ConflictingAmountsError,
+  ExactOutputNotSupportedError,
+  InvalidAmountError,
+  InvalidParamsError,
+  MarketIdRequiredError,
+  MarketNotAllowedError,
+  MarketNotFoundError,
+  NativeAssetAddressError,
+  ProviderNotConfiguredError,
+  QuoteExpiredError,
+  SameAssetError,
+  SlippageOutOfRangeError,
+  ZeroAddressError,
+} from '@/core/error/errors.js'
+
+describe('ActionsError hierarchy', () => {
+  it('ChainNotSupportedError', () => {
+    const err = new ChainNotSupportedError({
+      chainId: 999,
+      supportedChainIds: [10, 8453],
+    })
+    expect(err.name).toBe('ChainNotSupportedError')
+    expect(err.chainId).toBe(999)
+    expect(err.supportedChainIds).toEqual([10, 8453])
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err).toBeInstanceOf(BaseError)
+    expect(err.shortMessage).toContain('999')
+  })
+
+  it('MarketNotAllowedError with pair', () => {
+    const err = new MarketNotAllowedError({
+      assetInSymbol: 'ETH',
+      assetOutSymbol: 'USDC',
+      chainId: 10,
+      reason: 'Pair is blocked',
+    })
+    expect(err.name).toBe('MarketNotAllowedError')
+    expect(err.assetInSymbol).toBe('ETH')
+    expect(err.assetOutSymbol).toBe('USDC')
+    expect(err.chainId).toBe(10)
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err).toBeInstanceOf(BaseError)
+    expect(err.shortMessage).toContain('ETH/USDC')
+  })
+
+  it('MarketNotAllowedError with address', () => {
+    const err = new MarketNotAllowedError({
+      address: '0xabc',
+      chainId: 8453,
+    })
+    expect(err.address).toBe('0xabc')
+    expect(err.shortMessage).toContain('0xabc')
+  })
+
+  it('ProviderNotConfiguredError', () => {
+    const err = new ProviderNotConfiguredError({
+      provider: 'lend',
+      details: 'Please configure lend',
+    })
+    expect(err.name).toBe('ProviderNotConfiguredError')
+    expect(err.provider).toBe('lend')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toContain('lend')
+  })
+
+  it('MarketIdRequiredError', () => {
+    const err = new MarketIdRequiredError()
+    expect(err.name).toBe('MarketIdRequiredError')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toBe('marketId is required')
+  })
+
+  it('AmountRequiredError', () => {
+    const err = new AmountRequiredError()
+    expect(err.name).toBe('AmountRequiredError')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toContain('amountIn or amountOut')
+  })
+
+  it('InvalidAmountError', () => {
+    const err = new InvalidAmountError(-5)
+    expect(err.name).toBe('InvalidAmountError')
+    expect(err.amount).toBe(-5)
+    expect(err).toBeInstanceOf(ActionsError)
+  })
+
+  it('ConflictingAmountsError', () => {
+    const err = new ConflictingAmountsError()
+    expect(err.name).toBe('ConflictingAmountsError')
+    expect(err).toBeInstanceOf(ActionsError)
+  })
+
+  it('SameAssetError', () => {
+    const err = new SameAssetError('USDC')
+    expect(err.name).toBe('SameAssetError')
+    expect(err.symbol).toBe('USDC')
+    expect(err).toBeInstanceOf(ActionsError)
+  })
+
+  it('QuoteExpiredError', () => {
+    const err = new QuoteExpiredError({ expiresAt: 1000, currentTime: 2000 })
+    expect(err.name).toBe('QuoteExpiredError')
+    expect(err.expiresAt).toBe(1000)
+    expect(err.currentTime).toBe(2000)
+    expect(err).toBeInstanceOf(ActionsError)
+  })
+
+  it('ExactOutputNotSupportedError', () => {
+    const err = new ExactOutputNotSupportedError('Velodrome')
+    expect(err.name).toBe('ExactOutputNotSupportedError')
+    expect(err.provider).toBe('Velodrome')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toContain('Velodrome')
+  })
+
+  it('AddressRequiredError', () => {
+    const err = new AddressRequiredError('walletAddress')
+    expect(err.name).toBe('AddressRequiredError')
+    expect(err.label).toBe('walletAddress')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toBe('walletAddress is required')
+  })
+
+  it('ZeroAddressError', () => {
+    const err = new ZeroAddressError('walletAddress', '0x0')
+    expect(err.name).toBe('ZeroAddressError')
+    expect(err.label).toBe('walletAddress')
+    expect(err.address).toBe('0x0')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toContain('walletAddress')
+  })
+
+  it('SlippageOutOfRangeError', () => {
+    const err = new SlippageOutOfRangeError(0.6, 0.5)
+    expect(err.name).toBe('SlippageOutOfRangeError')
+    expect(err.slippage).toBe(0.6)
+    expect(err.maxSlippage).toBe(0.5)
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toContain('0.6')
+  })
+
+  it('AssetNotSupportedOnChainError', () => {
+    const err = new AssetNotSupportedOnChainError('USDC', 999)
+    expect(err.name).toBe('AssetNotSupportedOnChainError')
+    expect(err.symbol).toBe('USDC')
+    expect(err.chainId).toBe(999)
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toContain('USDC')
+    expect(err.shortMessage).toContain('999')
+  })
+
+  it('NativeAssetAddressError', () => {
+    const err = new NativeAssetAddressError('ETH')
+    expect(err.name).toBe('NativeAssetAddressError')
+    expect(err.symbol).toBe('ETH')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toContain('ETH')
+  })
+
+  it('MarketNotFoundError with poolId', () => {
+    const err = new MarketNotFoundError({ chainId: 10, poolId: '0xabc' })
+    expect(err.name).toBe('MarketNotFoundError')
+    expect(err.chainId).toBe(10)
+    expect(err.poolId).toBe('0xabc')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err).toBeInstanceOf(BaseError)
+    expect(err.shortMessage).toContain('0xabc')
+    expect(err.shortMessage).toContain('10')
+  })
+
+  it('MarketNotFoundError without poolId', () => {
+    const err = new MarketNotFoundError({ chainId: 8453 })
+    expect(err.chainId).toBe(8453)
+    expect(err.poolId).toBeUndefined()
+    expect(err.shortMessage).toContain('8453')
+  })
+
+  it('AssetMetadataRequiredError', () => {
+    const err = new AssetMetadataRequiredError('decimals field is missing')
+    expect(err.name).toBe('AssetMetadataRequiredError')
+    expect(err.context).toBe('decimals field is missing')
+    expect(err).toBeInstanceOf(ActionsError)
+    expect(err.shortMessage).toBe('Asset metadata is required')
+  })
+
+  it('all errors are instanceof BaseError', () => {
+    const errors = [
+      new AddressRequiredError('x'),
+      new ChainNotSupportedError({ chainId: 1 }),
+      new MarketNotAllowedError({ chainId: 1 }),
+      new MarketNotFoundError({ chainId: 1 }),
+      new ProviderNotConfiguredError({ provider: 'x' }),
+      new MarketIdRequiredError(),
+      new AmountRequiredError(),
+      new InvalidAmountError(0),
+      new ConflictingAmountsError(),
+      new SameAssetError('ETH'),
+      new QuoteExpiredError({ expiresAt: 0, currentTime: 1 }),
+      new ExactOutputNotSupportedError('X'),
+      new ZeroAddressError('label'),
+      new SlippageOutOfRangeError(1, 0.5),
+      new AssetNotSupportedOnChainError('X', 1),
+      new NativeAssetAddressError('ETH'),
+      new AssetMetadataRequiredError(),
+      new InvalidParamsError({ param: 'x', expected: 'y' }),
+    ]
+    for (const err of errors) {
+      expect(err).toBeInstanceOf(ActionsError)
+      expect(err).toBeInstanceOf(BaseError)
+    }
+  })
+
+  it('InvalidParamsError carries param + expected (and optional received)', () => {
+    const err = new InvalidParamsError({
+      param: 'chainIds',
+      expected: 'SupportedChainId[] (non-empty)',
+      received: '[]',
+    })
+    expect(err.name).toBe('InvalidParamsError')
+    expect(err.param).toBe('chainIds')
+    expect(err.expected).toBe('SupportedChainId[] (non-empty)')
+    expect(err.received).toBe('[]')
+    expect(err.shortMessage).toContain('chainIds')
+    expect(err).toBeInstanceOf(ActionsError)
+  })
+})