@openocean.finance/widget 1.0.28 → 1.0.29

package/src/cross/constants/index.ts

@@ -0,0 +1,223 @@
+import { ChainId } from '@openocean.finance/widget-sdk'
+
+export const CROSS_CHAIN_FEE_RECEIVER =
+  '0x922164BBBd36Acf9E854AcBbF32faCC949fCAEef'
+export const CROSS_CHAIN_FEE_RECEIVER_SOLANA =
+  'yEVG5DpokLuVRAqoWeKJANBY2wynzgTSXUbGz7aDKBq'
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
+export const BTC_DEFAULT_RECEIVER = ''
+export const SOLANA_NATIVE = '11111111111111111111111111111111'
+export const ETHER_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
+export const TOKEN_API_URL = 'https://token-api.kyberengineering.io/api'
+export const NativeCurrencies = {
+  [ChainId.ETH]: {
+    name: 'Ether',
+    symbol: 'ETH',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped Ether',
+      symbol: 'WETH',
+      decimals: 18,
+      address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    },
+  },
+  [ChainId.BSC]: {
+    name: 'Binance Coin',
+    symbol: 'BNB',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped BNB',
+      symbol: 'WBNB',
+      decimals: 18,
+      address: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
+    },
+  },
+  [ChainId.AVA]: {
+    name: 'Avalanche',
+    symbol: 'AVAX',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped AVAX',
+      symbol: 'WAVAX',
+      decimals: 18,
+      address: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7',
+    },
+  },
+  [ChainId.POL]: {
+    name: 'Polygon',
+    symbol: 'MATIC',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped MATIC',
+      symbol: 'WMATIC',
+      decimals: 18,
+      address: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
+    },
+  },
+  [ChainId.ARB]: {
+    name: 'ETH',
+    symbol: 'ETH',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped ETH',
+      symbol: 'WEHT',
+      decimals: 18,
+      address: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+    },
+  },
+  [ChainId.OPT]: {
+    name: 'Optimism',
+    symbol: 'ETH',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped ETH',
+      symbol: 'WETH',
+      decimals: 18,
+      address: '0x4200000000000000000000000000000000000006',
+    },
+  },
+  [ChainId.FTM]: {
+    name: 'Fantom',
+    symbol: 'FTM',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped FTM',
+      symbol: 'WFTM',
+      decimals: 18,
+      address: '0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83',
+    },
+  },
+  [ChainId.BAS]: {
+    name: 'Base',
+    symbol: 'ETH',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped ETH',
+      symbol: 'WEHT',
+      decimals: 18,
+      address: '0x4200000000000000000000000000000000000006',
+    },
+  },
+  [ChainId.SCL]: {
+    name: 'Scroll',
+    symbol: 'ETH',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped ETH',
+      symbol: 'WEHT',
+      decimals: 18,
+      address: '0x5300000000000000000000000000000000000004',
+    },
+  },
+  [ChainId.BLS]: {
+    name: 'Blast',
+    symbol: 'ETH',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped ETH',
+      symbol: 'WEHT',
+      decimals: 18,
+      address: '0x4300000000000000000000000000000000000004',
+    },
+  },
+  [ChainId.MNT]: {
+    name: 'Mantle',
+    symbol: 'ETH',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped MNT',
+      symbol: 'WMNT',
+      decimals: 18,
+      address: '0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8',
+    },
+  },
+  [ChainId.SON]: {
+    name: 'Son',
+    symbol: 'S',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped S',
+      symbol: 'WS',
+      decimals: 18,
+      address: '0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38',
+    },
+  },
+  [ChainId.UNI]: {
+    name: 'UniChain',
+    symbol: 'ETH',
+    decimals: 18,
+    address: '0x0000000000000000000000000000000000000000',
+    wrapped: {
+      name: 'Wrapped ETH',
+      symbol: 'WEHT',
+      decimals: 18,
+      address: '0x4200000000000000000000000000000000000006',
+    },
+  },
+}
+export const MAINNET_NETWORKS = [
+  ChainId.ETH,
+  ChainId.BSC,
+  ChainId.AVA,
+  ChainId.BAS,
+  ChainId.POL,
+  ChainId.ARB,
+  ChainId.OPT,
+  // ChainId.FTM,
+  // ChainId.MAM,
+  ChainId.MNT,
+  ChainId.SON,
+  ChainId.UNI,
+  ChainId.BLS,
+  ChainId.SCL,
+] as const
+
+export interface Currency {
+  id: string
+  name: string
+  symbol: string
+  address: string
+  icon: string
+  logo: string
+  decimals: number
+  isNative: boolean
+  wrapped: {
+    name: string
+    symbol: string
+    decimals: number
+    address: string
+  }
+}
+
+export interface NearToken {
+  assetId: string
+  decimals: number
+  blockchain: string
+  symbol: string
+  price: number
+  priceUpdatedAt: number
+  contractAddress: string
+  logo: string
+}
+
+export interface SolanaToken {
+  id: string
+  name: string
+  symbol: string
+  icon: string
+  logo: string
+  decimals: number
+  tokenProgram: string
+}

package/src/cross/crossChainQuote.ts

@@ -0,0 +1,181 @@
+import type { WalletClient } from 'viem'
+import type { QuoteParams } from './adapters/index.js'
+import { CrossChainSwapFactory } from './factory.js'
+import { CrossChainSwapAdapterRegistry, type Quote } from './registry.js'
+
+/**
+ * Get cross-chain aggregated quotes (supports multiple adapter comparison)
+ * @param params - Cross-chain quote parameters
+ * @returns Best quote result, compatible with useRoutes.ts requirements
+ */
+export async function getCrossChainQuote({
+  fromMsg,
+  toMsg,
+  inAmount,
+  slippage_tolerance,
+  account,
+  receiver,
+  tokenInUsd = 0,
+  tokenOutUsd = 0,
+  feeBps = 10,
+  walletClient,
+  publicKey,
+  nearTokens = [],
+}: {
+  fromMsg: any
+  toMsg: any
+  inAmount: string
+  slippage_tolerance: string | number
+  account: string
+  receiver?: string
+  tokenInUsd?: number
+  tokenOutUsd?: number
+  feeBps?: number
+  walletClient?: any
+  publicKey?: string
+  nearTokens?: any[]
+}): Promise<any | null> {
+  try {
+    // 1. Register all Adapters
+    const registry = new CrossChainSwapAdapterRegistry()
+    CrossChainSwapFactory.getAllAdapters().forEach((adapter) => {
+      registry.registerAdapter(adapter)
+    })
+    // 2. Construct QuoteParams
+    const params: QuoteParams = {
+      feeBps,
+      fromChain: fromMsg.chainId,
+      toChain: toMsg.chainId,
+      fromToken: fromMsg,
+      toToken: toMsg,
+      amount: inAmount,
+      slippage:
+        typeof slippage_tolerance === 'string'
+          ? Number.parseFloat(slippage_tolerance)
+          : slippage_tolerance,
+      walletClient,
+      tokenInUsd,
+      tokenOutUsd,
+      sender: account,
+      recipient: receiver || account,
+      publicKey,
+    }
+
+    if (fromMsg.chainId === 'near' || toMsg.chainId === 'near') {
+      ;(params as any).nearTokens = nearTokens
+    }
+
+    // 3. Get all quotes
+    const adapters = registry
+      .getAllAdapters()
+      .filter(
+        (adapter) =>
+          adapter.getSupportedChains().includes(params.fromChain) &&
+          adapter.getSupportedChains().includes(params.toChain)
+      )
+
+    if (adapters.length === 0) {
+      console.warn('No supported adapters found for the specified chains')
+      return null
+    }
+
+    const quoteResults: Quote[] = []
+
+    // Get quotes from all adapters in parallel
+    const quotePromises = adapters.map(async (adapter) => {
+      try {
+        const quote = await adapter.getQuote(params)
+        if (quote) {
+          quoteResults.push({ adapter, quote })
+        }
+      } catch (error) {
+        // Ignore individual adapter errors, continue getting quotes from other adapters
+        console.warn(`Failed to get quote from ${adapter.getName()}:`, error)
+      }
+    })
+
+    await Promise.all(quotePromises)
+
+    if (quoteResults.length === 0) {
+      console.warn('No valid quotes found from any adapter')
+      return null
+    }
+
+    // 4. Select best quote (highest outputAmount)
+    quoteResults.sort((a, b) =>
+      a.quote.outputAmount < b.quote.outputAmount ? 1 : -1
+    )
+
+    const best = quoteResults[0]
+
+    // 5. Construct return structure compatible with useRoutes.ts
+    return {
+      data: {
+        minOutAmount: best.quote.outputAmount || '0',
+        outAmount: best.quote.outputAmount || '0',
+        fromTokenUSD: best.quote.inputUsd?.toString() || '0',
+        toTokenUSD: best.quote.outputUsd?.toString() || '0',
+        quoteAdapterName: best.adapter.getName(),
+        quoteAdapterKey: best.adapter.getName().toLowerCase(),
+        chainId: fromMsg.chainId,
+        from: account,
+
+        to: best.quote.contractAddress || '0x0',
+        value: best.quote.rawQuote.tx?.value || '0x0',
+        data: best.quote.rawQuote.tx?.data || '0x',
+        // gasLimit: best.quote.rawQuote.tx?.gasLimit || '0',
+        // gas: best.quote.rawQuote.tx?.gas || '0',
+        // nonce: best.quote.rawQuote.tx?.nonce || '0',
+        approveContract: best.quote.contractAddress || '0x0',
+        executionDuration: best.quote.timeEstimate || 300,
+        // Fee information
+        feeCosts: [
+          {
+            name: `${best.adapter.getName()} Fee`,
+            description: 'Protocol fee',
+            token: fromMsg,
+            amount: '0',
+            amountUSD: best.quote.protocolFee,
+            percentage: '0',
+            included: false,
+          },
+        ],
+        // Original quote data
+        quoteRawData: best.quote,
+      },
+    }
+  } catch (error) {
+    console.error('Error getting cross-chain quote:', error)
+    return null
+  }
+}
+
+export const bridgeExecuteSwap = async ({
+  quoteData,
+  walletClient,
+}: {
+  quoteData: any
+  walletClient: WalletClient
+}) => {
+  const adapterName = quoteData.quoteAdapterKey
+  const adapter = CrossChainSwapFactory.getAdapterByName(adapterName)
+  const result = await adapter.executeSwap(
+    {
+      quote: quoteData.quoteRawData,
+    },
+    walletClient
+  )
+
+  return result
+}
+
+// Login URL mapping for each adapter
+export const ADAPTER_LOGIN_URLS: Record<string, string> = {
+  debridge: 'https://app.debridge.finance/',
+  across: 'https://across.to/',
+  lifi: 'https://jumper.exchange/',
+  mayan: 'https://swap.mayan.finance/',
+  relay: 'https://app.relay.link/',
+  xyfinance: 'https://xy.finance/',
+  kyberswap: 'https://kyberswap.com/',
+}

package/src/cross/factory.ts

@@ -0,0 +1,145 @@
+// import { NearIntentsAdapter } from './adapters/NearIntentsAdapter.js'
+// import { OptimexAdapter } from './adapters/OptimexAdapter.js'
+// import { OrbiterAdapter } from './adapters/OrbiterAdapter.js'
+import {
+  // AcrossAdapter,
+  // DeBridgeAdapter,
+  // LifiAdapter,
+  MayanAdapter,
+  RelayAdapter,
+  // SwapProvider,
+  // SymbiosisAdapter,
+  // XYFinanceAdapter,
+} from './adapters/index.js'
+
+// Factory for creating swap provider instances
+export class CrossChainSwapFactory {
+  // Singleton instances (lazy loaded)
+  // private static acrossInstance: AcrossAdapter
+  private static relayInstance: RelayAdapter
+  // private static xyFinanceInstance: XYFinanceAdapter
+  // private static nearIntentsInstance: NearIntentsAdapter
+  private static mayanInstance: MayanAdapter
+  // private static symbiosisInstance: SymbiosisAdapter
+  // private static debridgeInstance: DeBridgeAdapter
+  // private static lifiInstance: LifiAdapter
+  // private static optimexInstance: OptimexAdapter
+  // private static orbiterInstance: OrbiterAdapter
+
+  // // Get or create Across adapter
+  // static getAcrossAdapter(): AcrossAdapter {
+  //   if (!CrossChainSwapFactory.acrossInstance) {
+  //     CrossChainSwapFactory.acrossInstance = new AcrossAdapter()
+  //   }
+  //   return CrossChainSwapFactory.acrossInstance
+  // }
+
+  // // Get or create Relay adapter
+  static getRelayAdapter(): RelayAdapter {
+    if (!CrossChainSwapFactory.relayInstance) {
+      CrossChainSwapFactory.relayInstance = new RelayAdapter()
+    }
+    return CrossChainSwapFactory.relayInstance
+  }
+
+  // static getXyFinanceAdapter(): XYFinanceAdapter {
+  //   if (!CrossChainSwapFactory.xyFinanceInstance) {
+  //     CrossChainSwapFactory.xyFinanceInstance = new XYFinanceAdapter()
+  //   }
+  //   return CrossChainSwapFactory.xyFinanceInstance
+  // }
+
+  // static getNearIntentsAdapter(): NearIntentsAdapter {
+  //   if (!CrossChainSwapFactory.nearIntentsInstance) {
+  //     CrossChainSwapFactory.nearIntentsInstance = new NearIntentsAdapter()
+  //   }
+  //   return CrossChainSwapFactory.nearIntentsInstance
+  // }
+
+  static getMayanAdapter(): MayanAdapter {
+    if (!CrossChainSwapFactory.mayanInstance) {
+      CrossChainSwapFactory.mayanInstance = new MayanAdapter()
+    }
+    return CrossChainSwapFactory.mayanInstance
+  }
+
+  // static getSymbiosisAdapter(): SymbiosisAdapter {
+  //   if (!CrossChainSwapFactory.symbiosisInstance) {
+  //     CrossChainSwapFactory.symbiosisInstance = new SymbiosisAdapter()
+  //   }
+  //   return CrossChainSwapFactory.symbiosisInstance
+  // }
+
+  // static getDebridgeInstance(): DeBridgeAdapter {
+  //   if (!CrossChainSwapFactory.debridgeInstance) {
+  //     CrossChainSwapFactory.debridgeInstance = new DeBridgeAdapter()
+  //   }
+  //   return CrossChainSwapFactory.debridgeInstance
+  // }
+
+  // static getLifiInstance(): LifiAdapter {
+  //   if (!CrossChainSwapFactory.lifiInstance) {
+  //     CrossChainSwapFactory.lifiInstance = new LifiAdapter()
+  //   }
+  //   return CrossChainSwapFactory.lifiInstance
+  // }
+
+  // static getOptimexAdapter(): OptimexAdapter {
+  //   if (!CrossChainSwapFactory.optimexInstance) {
+  //     CrossChainSwapFactory.optimexInstance = new OptimexAdapter()
+  //   }
+  //   return CrossChainSwapFactory.optimexInstance
+  // }
+
+  // static getOrbiterAdapter(): OrbiterAdapter {
+  //   if (!CrossChainSwapFactory.orbiterInstance) {
+  //     CrossChainSwapFactory.orbiterInstance = new OrbiterAdapter()
+  //   }
+  //   return CrossChainSwapFactory.orbiterInstance
+  // }
+
+  // Get all registered adapters
+  static getAllAdapters(): SwapProvider[] {
+    return [
+      // CrossChainSwapFactory.getMayanAdapter(),
+      CrossChainSwapFactory.getRelayAdapter(),
+
+      // CrossChainSwapFactory.getAcrossAdapter(),
+      // CrossChainSwapFactory.getXyFinanceAdapter(),
+      // CrossChainSwapFactory.getNearIntentsAdapter(),
+      // CrossChainSwapFactory.getSymbiosisAdapter(),
+      // CrossChainSwapFactory.getDebridgeInstance(),
+      // CrossChainSwapFactory.getLifiInstance(),
+      // CrossChainSwapFactory.getOptimexAdapter(),
+      // CrossChainSwapFactory.getOrbiterAdapter(),
+    ]
+  }
+
+  // Get adapter by name
+  static getAdapterByName(name: string): SwapProvider | undefined {
+    switch (name.toLowerCase()) {
+      // case 'across':
+      //   return CrossChainSwapFactory.getAcrossAdapter()
+      case 'relay':
+        return CrossChainSwapFactory.getRelayAdapter()
+      // case 'xyfinance':
+      //   return CrossChainSwapFactory.getXyFinanceAdapter()
+      // case 'near intents':
+      //   return CrossChainSwapFactory.getNearIntentsAdapter()
+      case 'mayan':
+        return CrossChainSwapFactory.getMayanAdapter()
+      // case 'symbiosis':
+      //   return CrossChainSwapFactory.getSymbiosisAdapter()
+      // case 'debridge':
+      //   return CrossChainSwapFactory.getDebridgeInstance()
+      // case 'lifi':
+      //   return CrossChainSwapFactory.getLifiInstance()
+      // case 'optimex':
+      //   return CrossChainSwapFactory.getOptimexAdapter()
+      // case 'orbiter':
+      //   return CrossChainSwapFactory.getOrbiterAdapter()
+      default:
+        return undefined
+    }
+  }
+}

package/src/cross/registry.ts

@@ -0,0 +1,65 @@
+// import { isEvmChain } from 'utils'
+import type {
+  // NearQuoteParams,
+  NormalizedQuote, // QuoteParams,
+  SwapProvider,
+} from './adapters/BaseSwapAdapter.js'
+
+export interface Quote {
+  adapter: SwapProvider
+  quote: NormalizedQuote
+}
+
+export class CrossChainSwapAdapterRegistry {
+  private adapters: Map<string, SwapProvider> = new Map()
+
+  registerAdapter(adapter: SwapProvider): void {
+    this.adapters.set(adapter.getName().toLowerCase(), adapter)
+  }
+
+  getAdapter(name: string): SwapProvider | undefined {
+    return this.adapters.get(name.toLowerCase())
+  }
+
+  getAllAdapters(): SwapProvider[] {
+    return Array.from(this.adapters.values())
+  }
+
+  // get quotes from all adapters and sort them by output amount
+  // async getQuotes(params: QuoteParams | NearQuoteParams): Promise<Quote[]> {
+  //   const quotes: { adapter: SwapProvider; quote: NormalizedQuote }[] = []
+  //
+  //   const adapters =
+  //     params.fromChain === params.toChain && isEvmChain(params.fromChain)
+  //       ? ([this.getAdapter('KyberSwap')] as SwapProvider[])
+  //       : this.getAllAdapters().filter(
+  //           adapter =>
+  //             adapter.getSupportedChains().includes(params.fromChain) &&
+  //             adapter.getSupportedChains().includes(params.toChain),
+  //         )
+  //
+  //   console.log(
+  //     'Available adapters',
+  //     params,
+  //     adapters.map(ad => ad.getName()),
+  //   )
+  //   // Get quotes from all compatible adapters
+  //   const quotePromises = adapters.map(async adapter => {
+  //     try {
+  //       const quote = await adapter.getQuote(params)
+  //       quotes.push({ adapter, quote })
+  //     } catch (err) {
+  //       console.error(`Failed to get quote from ${adapter.getName()}:`, err)
+  //     }
+  //   })
+  //
+  //   await Promise.all(quotePromises)
+  //
+  //   if (quotes.length === 0) {
+  //     throw new Error('No valid quotes found for the requested swap')
+  //   }
+  //
+  //   quotes.sort((a, b) => (a.quote.outputAmount < b.quote.outputAmount ? 1 : -1))
+  //   return quotes
+  // }
+}

package/src/hooks/useGasSufficiencyBridge.ts

@@ -67,9 +67,7 @@ export const useGasSufficiencyBridge = (route?: RouteExtended) => {
         } else {
           currentTokenBalance = 0n
         }
-        const insufficientFunds =
-          BigInt(parsedFromAmount) > currentTokenBalance &&
-          BigInt(parsedFromAmount) < token.amount
+        const insufficientFunds = BigInt(parsedFromAmount) > currentTokenBalance
         return insufficientFunds
       }
       return false

package/src/hooks/useRouteExecution.ts

@@ -67,7 +67,8 @@ export const useRouteExecution = ({
     if (!routeExecution) {
       return
     }
-    const clonedUpdatedRoute = structuredClone(updatedRoute)
+    const safeObj = JSON.parse(JSON.stringify(updatedRoute))
+    const clonedUpdatedRoute = structuredClone(safeObj)
     updateRoute(clonedUpdatedRoute)
     const process = getUpdatedProcess(routeExecution.route, clonedUpdatedRoute)
     if (process) {