@openocean.finance/widget 1.0.28 → 1.0.29

package/src/cross/adapters/OptimexAdapter.ts

@@ -0,0 +1,273 @@
+import { ChainId } from '@openocean.finance/widget-sdk'
+import { Currency } from '../constants/index.js'
+
+import { WalletClient, formatUnits } from 'viem'
+
+import { CROSS_CHAIN_FEE_RECEIVER, ZERO_ADDRESS } from '../constants/index.js'
+
+import { Quote } from '../registry.js'
+import {
+  BaseSwapAdapter,
+  Chain,
+  NonEvmChain,
+  NormalizedQuote,
+  NormalizedTxResponse,
+  QuoteParams,
+  SwapStatus,
+} from './BaseSwapAdapter.js'
+
+const OPTIMEX_API = 'https://ks-provider.optimex.xyz/v1'
+
+interface OptimexToken {
+  id: number
+  network_id: 'ethereum' | 'bitcoin'
+  token_id: string
+  network_name: string
+  network_symbol: string
+  network_type: 'EVM' | 'BTC'
+  token_name: string
+  token_symbol: string
+  token_address: string
+  token_decimals: number
+  token_logo_uri: string
+  network_logo_uri: string
+  active: boolean
+}
+
+export class OptimexAdapter extends BaseSwapAdapter {
+  private tokens: OptimexToken[]
+
+  constructor() {
+    super()
+    this.tokens = []
+  }
+
+  private async getTokens() {
+    try {
+      const res = await fetch(`${OPTIMEX_API}/tokens`)
+      const { data } = await res.json()
+      this.tokens = data.tokens
+    } catch (error) {
+      console.error('Failed to initialize Optimex tokens:', error)
+      // Handle error appropriately
+    }
+  }
+  getName(): string {
+    return 'Optimex'
+  }
+  getIcon(): string {
+    return 'https://storage.googleapis.com/ks-setting-1d682dca/464ce79e-a906-4590-bf78-9054e606aa041749023419612.png'
+  }
+  getSupportedChains(): Chain[] {
+    return [NonEvmChain.Bitcoin, ChainId.MAINNET]
+  }
+
+  getSupportedTokens(_sourceChain: Chain, _destChain: Chain): Currency[] {
+    return []
+  }
+
+  async getQuote(params: QuoteParams): Promise<NormalizedQuote> {
+    if (!this.tokens?.length) {
+      await this.getTokens()
+    }
+
+    const isFromBtc = params.fromChain === NonEvmChain.Bitcoin
+    const isToBtc = params.toChain === NonEvmChain.Bitcoin
+    const fromToken = isFromBtc
+      ? { token_id: 'BTC', token_symbol: 'BTC' }
+      : this.tokens.find(item => {
+          const address = (params.fromToken as any).isNative ? 'native' : (params.fromToken as any).wrapped.address
+          return item.network_id === 'ethereum' && address.toLowerCase() === item.token_address.toLowerCase()
+        })
+    const fromTokenId = fromToken?.token_id
+
+    const toToken = isToBtc
+      ? { token_id: 'BTC', token_symbol: 'BTC' }
+      : this.tokens.find(item => {
+          const address = (params.toToken as any).isNative ? 'native' : (params.toToken as any).wrapped.address
+          return item.network_id === 'ethereum' && address.toLowerCase() === item.token_address.toLowerCase()
+        })
+    const toTokenId = toToken?.token_id
+
+    if (!fromTokenId || !toTokenId) {
+      console.log('optimex tokens', this.tokens)
+      throw new Error(`Optimex does not support ${!fromTokenId ? params.fromToken.symbol : params.toToken.symbol}`)
+    }
+
+    const [quoteRes, estimateRes, token0Usd, token1Usd] = await Promise.all([
+      fetch(`${OPTIMEX_API}/solver/indicative-quote`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          debug: false,
+          from_token_amount: params.amount,
+          from_token_id: fromTokenId,
+          to_token_id: toTokenId,
+          affiliate_fee_bps: params.feeBps.toString(),
+        }),
+      }).then(res => res.json()),
+      fetch(`${OPTIMEX_API}/trades/estimate?from_token=${fromTokenId}&to_token=${toTokenId}`).then(res => res.json()),
+      fetch(`https://api.optimex.xyz/v1/tokens/${fromToken.token_symbol}`)
+        .then(res => res.json())
+        .then(res => res?.data?.current_price || 0),
+      fetch(`https://api.optimex.xyz/v1/tokens/${toToken.token_symbol}`)
+        .then(res => res.json())
+        .then(res => res?.data?.current_price || 0),
+    ])
+
+    let txData: { deposit_address: string; payload?: string; trade_id: string } | null = null
+
+    if (params.sender && params.recipient && (isFromBtc ? params.publicKey : true)) {
+      const tradeTimeout = new Date()
+      tradeTimeout.setHours(tradeTimeout.getHours() + 2)
+
+      const scriptTimeout = new Date()
+      scriptTimeout.setHours(scriptTimeout.getHours() + 24)
+
+      const res = await fetch(`${OPTIMEX_API}/trades/initiate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          session_id: quoteRes.data.session_id,
+          from_user_address: params.sender,
+          amount_in: params.amount,
+          min_amount_out: (
+            (BigInt(quoteRes.data.best_quote_after_fees) * (10_000n - BigInt(params.slippage))) /
+            10_000n
+          ).toString(),
+          to_user_address: params.recipient,
+          user_refund_pubkey: params.fromChain === NonEvmChain.Bitcoin ? params.publicKey : params.sender,
+          user_refund_address: params.sender,
+          creator_public_key: params.fromChain === NonEvmChain.Bitcoin ? params.publicKey : params.sender,
+          from_wallet_address: params.sender,
+          trade_timeout: Math.floor(tradeTimeout.getTime() / 1000),
+          script_timeout: Math.floor(scriptTimeout.getTime() / 1000),
+          affiliate_info: [
+            {
+              provider: 'KyberSwap',
+              rate: params.feeBps.toString(),
+              receiver: CROSS_CHAIN_FEE_RECEIVER,
+              network: 'ethereum',
+            },
+          ],
+        }),
+      }).then(res => res.json())
+
+      if (res.data.deposit_address) {
+        txData = res.data
+      }
+    }
+
+    const formattedOutputAmount = formatUnits(BigInt(quoteRes.data.best_quote_after_fees), params.toToken.decimals)
+    const formattedInputAmount = formatUnits(BigInt(params.amount), params.fromToken.decimals)
+    const inputUsd = token0Usd * +formattedInputAmount
+    const outputUsd = token1Usd * +formattedOutputAmount
+
+    return {
+      quoteParams: params,
+      outputAmount: BigInt(quoteRes.data.best_quote_after_fees),
+      formattedOutputAmount,
+      inputUsd,
+      outputUsd,
+      priceImpact: !inputUsd || !outputUsd ? NaN : ((inputUsd - outputUsd) * 100) / inputUsd,
+      rate: +formattedOutputAmount / +formattedInputAmount,
+      gasFeeUsd: 0,
+      timeEstimate: estimateRes.data.estimated_time,
+      contractAddress: txData?.deposit_address || ZERO_ADDRESS,
+      rawQuote: { ...quoteRes.data, txData },
+
+      protocolFee: 0,
+      platformFeePercent: (params.feeBps * 100) / 10000,
+    }
+  }
+
+  async executeSwap(
+    { quote }: Quote,
+    walletClient: WalletClient,
+    _nearWallet: any,
+    sendBtcFn?: (params: { recipient: string; amount: string | number }) => Promise<string>,
+  ): Promise<NormalizedTxResponse> {
+    const params = {
+      sender: quote.quoteParams.sender,
+      id: quote.rawQuote.txData.trade_id,
+      adapter: this.getName(),
+      sourceChain: quote.quoteParams.fromChain,
+      targetChain: quote.quoteParams.toChain,
+      inputAmount: quote.quoteParams.amount,
+      outputAmount: quote.outputAmount.toString(),
+      sourceToken: quote.quoteParams.fromToken,
+      targetToken: quote.quoteParams.toToken,
+      timestamp: new Date().getTime(),
+    }
+    if (quote.quoteParams.fromChain === NonEvmChain.Bitcoin) {
+      if (!sendBtcFn) throw new Error('sendBtcFn is not defined')
+      const res = await sendBtcFn({
+        recipient: quote.rawQuote.txData.deposit_address,
+        amount: quote.quoteParams.amount,
+      }).catch(e => {
+        throw e
+      })
+      await fetch(`${OPTIMEX_API}/trades/${quote.rawQuote.txData.trade_id}/submit-tx`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          tx_id: res,
+        }),
+      }).catch(e => {
+        console.log('submit tx error for optimex', e)
+      })
+      return {
+        ...params,
+        sourceTxHash: res,
+      }
+    }
+
+    if (!walletClient || !walletClient.account) throw new Error('Not connected')
+
+    const account = walletClient.account?.address as `0x${string}`
+    const hash = await walletClient.sendTransaction({
+      to: quote.rawQuote.txData.deposit_address,
+      value: (quote.quoteParams.fromToken as any).isNative ? BigInt(quote.quoteParams.amount) : undefined,
+      data: quote.rawQuote.txData.payload,
+      chain: undefined,
+      account,
+    })
+
+    await fetch(`${OPTIMEX_API}/trades/${quote.rawQuote.txData.trade_id}/submit-tx`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        tx_id: hash,
+      }),
+    }).catch(e => {
+      console.log('submit tx error for optimex', e)
+    })
+    return {
+      ...params,
+      sourceTxHash: hash,
+    }
+  }
+
+  async getTransactionStatus(p: NormalizedTxResponse): Promise<SwapStatus> {
+    const res = await fetch(`${OPTIMEX_API}/trades/${p.id}`).then(res => res.json())
+
+    return {
+      txHash: res.data?.payment_bundle?.settlement_tx || '',
+      status: ['Done', 'PaymentConfirmed'].includes(res?.data?.state)
+        ? 'Success'
+        : ['Aborted', 'ToBeAborted', 'Failed', 'Failure', 'UserCancelled'].includes(res?.data?.state)
+        ? 'Failed'
+        : res?.data?.state === 'Refunded'
+        ? 'Refunded'
+        : 'Processing',
+    }
+  }
+}

package/src/cross/adapters/OrbiterAdapter.ts

@@ -0,0 +1,270 @@
+
+import { Currency } from '../constants/index.js'
+import { useWalletSelector } from '@near-wallet-selector/react-hook'
+import { WalletAdapterProps } from '@solana/wallet-adapter-base'
+import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
+import { getPublicClient } from '@wagmi/core'
+import { WalletClient, formatUnits } from 'viem'
+import { useConfig } from 'wagmi'
+import { CROSS_CHAIN_FEE_RECEIVER, CROSS_CHAIN_FEE_RECEIVER_SOLANA, ZERO_ADDRESS } from '../constants/index.js'
+import { MAINNET_NETWORKS } from '../constants/index.js'
+import { SolanaToken } from '../constants/index.js'
+
+import { Quote } from '../registry.js'
+import {
+  BaseSwapAdapter,
+  Chain,
+  NOT_SUPPORTED_CHAINS_PRICE_SERVICE,
+  NormalizedQuote,
+  NormalizedTxResponse,
+  QuoteParams,
+  SwapStatus,
+} from './BaseSwapAdapter.js'
+
+interface Step {
+  action: string
+  tx: {
+    data: string
+    to: string
+    value: string
+  }
+}
+
+export class OrbiterAdapter extends BaseSwapAdapter {
+  constructor() {
+    super()
+  }
+
+  getName(): string {
+    return 'Orbiter'
+  }
+  getIcon(): string {
+    return 'https://www.orbiter.finance/favicon.ico'
+  }
+  getSupportedChains(): Chain[] {
+    return [...MAINNET_NETWORKS]
+  }
+
+  getSupportedTokens(_sourceChain: Chain, _destChain: Chain): Currency[] {
+    return []
+  }
+
+  async getQuote(params: QuoteParams): Promise<NormalizedQuote> {
+    const fromToken = params.fromToken as any
+    const toToken = params.toToken as any
+    const body = {
+      sourceChainId: params.fromChain === 'solana' ? 'SOLANA_MAIN' : params.fromChain.toString(),
+      destChainId: params.toChain === 'solana' ? 'SOLANA_MAIN' : params.toChain.toString(),
+      sourceToken:
+        params.fromChain === 'solana'
+          ? (params.fromToken as SolanaToken).id
+          : fromToken.isNative
+          ? ZERO_ADDRESS
+          : fromToken.address,
+
+      destToken:
+        params.toChain === 'solana'
+          ? (params.toToken as SolanaToken).id
+          : toToken.isNative
+          ? ZERO_ADDRESS
+          : toToken.address,
+      amount: params.amount.toString(),
+      userAddress: params.sender,
+      targetRecipient: params.recipient,
+      slippage: params.slippage / 10_000,
+      feeConfig: {
+        feeRecipient: params.fromChain === 'solana' ? CROSS_CHAIN_FEE_RECEIVER_SOLANA : CROSS_CHAIN_FEE_RECEIVER,
+        feePercent: (params.feeBps / 10000).toString(),
+      },
+      channel: 'kyberswap',
+    }
+    const res = await fetch(`https://api.orbiter.finance/quote`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+      .then(res => res.json())
+      .then(res => res.result)
+
+    const formattedOutputAmount = formatUnits(BigInt(res.details?.destTokenAmount || '0'), params.toToken.decimals)
+    const formattedInputAmount = formatUnits(BigInt(params.amount), params.fromToken.decimals)
+
+    const inputUsd = NOT_SUPPORTED_CHAINS_PRICE_SERVICE.includes(params.fromChain)
+      ? Number(res.details?.sourceAmountUSD || 0)
+      : params.tokenInUsd * +formattedInputAmount
+    const outputUsd = NOT_SUPPORTED_CHAINS_PRICE_SERVICE.includes(params.toChain)
+      ? Number(res.details?.destAmountUSD || 0)
+      : params.tokenOutUsd * +formattedOutputAmount
+
+    const haveApproval = res.steps.some((step: Step) => step.action === 'approve')
+    const approvalContract = res.steps.find((step: Step) => step.action === 'swap' || step.action === 'bridge')
+
+    return {
+      quoteParams: params,
+      outputAmount: BigInt(res.details?.destTokenAmount || '0'),
+      formattedOutputAmount,
+      inputUsd,
+      outputUsd,
+      priceImpact: !inputUsd || !outputUsd ? NaN : ((inputUsd - outputUsd) * 100) / inputUsd,
+      //rate: Number(resp.details?.rate || 0),
+      rate: +formattedOutputAmount / +formattedInputAmount,
+      gasFeeUsd: 0,
+      timeEstimate: 10,
+      contractAddress: haveApproval ? approvalContract?.tx.to || ZERO_ADDRESS : ZERO_ADDRESS,
+      rawQuote: res,
+      protocolFee: 0,
+      platformFeePercent: (params.feeBps * 100) / 10000,
+    }
+  }
+
+  async executeSwap(
+    { quote }: Quote,
+    walletClient: WalletClient,
+    _nearWallet?: ReturnType<typeof useWalletSelector>,
+    _sendBtcFn?: (params: { recipient: string; amount: string | number }) => Promise<string>,
+    sendSolanaFn?: WalletAdapterProps['sendTransaction'],
+    solanaConnection?: Connection,
+  ): Promise<NormalizedTxResponse> {
+    if (quote.quoteParams.fromChain === 'solana') {
+      if (!solanaConnection || !sendSolanaFn) throw new Error('Connection is not defined for Solana swap')
+      const encodedData = quote.rawQuote.steps?.[0]?.tx?.data
+      const txBuffer = Buffer.from(encodedData, 'base64')
+
+      // Try to deserialize as VersionedTransaction first
+      let transaction
+      try {
+        transaction = VersionedTransaction.deserialize(txBuffer)
+        console.log('Parsed as VersionedTransaction')
+      } catch (versionedError) {
+        console.log('Failed to parse as VersionedTransaction, trying legacy Transaction')
+        try {
+          transaction = Transaction.from(txBuffer)
+          console.log('Parsed as legacy Transaction')
+        } catch (legacyError) {
+          throw new Error('Could not parse transaction as either VersionedTransaction or legacy Transaction')
+        }
+      }
+
+      console.log('Transaction parsed successfully:', transaction)
+
+      const waitForConfirmation = async (txId: string) => {
+        try {
+          const latestBlockhash = await solanaConnection.getLatestBlockhash()
+
+          // Wait for confirmation with timeout
+          const confirmation = await Promise.race([
+            solanaConnection.confirmTransaction(
+              {
+                signature: txId,
+                blockhash: latestBlockhash.blockhash,
+                lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+              },
+              'confirmed',
+            ),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Transaction confirmation timeout')), 60000)),
+          ])
+
+          const confirmationResult = confirmation as { value: { err: any } }
+          if (confirmationResult.value.err) {
+            throw new Error(`Transaction failed: ${JSON.stringify(confirmationResult.value.err)}`)
+          }
+
+          console.log('Transaction confirmed successfully!')
+        } catch (confirmError) {
+          console.error('Transaction confirmation failed:', confirmError)
+
+          // Check if transaction actually succeeded despite timeout
+          const txStatus = await solanaConnection.getSignatureStatus(txId)
+          if (txStatus?.value?.confirmationStatus !== 'confirmed') {
+            throw new Error(`Transaction was not confirmed: ${confirmError.message}`)
+          }
+        }
+      }
+
+      // Send through wallet adapter
+      const signature = await sendSolanaFn(transaction, solanaConnection)
+      await waitForConfirmation(signature)
+
+      return {
+        sender: quote.quoteParams.sender,
+        id: signature,
+        sourceTxHash: signature,
+        adapter: this.getName(),
+        sourceChain: quote.quoteParams.fromChain,
+        targetChain: quote.quoteParams.toChain,
+        inputAmount: quote.quoteParams.amount,
+        outputAmount: quote.outputAmount.toString(),
+        sourceToken: quote.quoteParams.fromToken,
+        targetToken: quote.quoteParams.toToken,
+        timestamp: new Date().getTime(),
+      }
+    }
+
+    const steps = quote.rawQuote.steps.filter((st: Step) => st.action !== 'approve') // already approve before
+
+    const account = walletClient.account?.address
+    if (!account) throw new Error('WalletClient account is not defined')
+    const txs = await Promise.all(
+      steps.map(async (step: Step) => {
+        const tx = await walletClient.sendTransaction({
+          chain: undefined,
+          account,
+          to: step.tx.to as `0x${string}`,
+          value: BigInt(step.tx.value),
+          data: step.tx.data as `0x${string}`,
+        })
+        return tx
+      }),
+    )
+
+    if (!txs || txs.length === 0) throw new Error('No transactions found after executing swap steps')
+
+    return {
+      sender: quote.quoteParams.sender,
+      sourceTxHash: txs[txs.length - 1],
+      adapter: this.getName(),
+      id: txs[txs.length - 1],
+      sourceChain: quote.quoteParams.fromChain,
+      targetChain: quote.quoteParams.toChain,
+      inputAmount: quote.quoteParams.amount,
+      outputAmount: quote.outputAmount.toString(),
+      sourceToken: quote.quoteParams.fromToken,
+      targetToken: quote.quoteParams.toToken,
+      timestamp: new Date().getTime(),
+    }
+  }
+
+  async getTransactionStatus(p: NormalizedTxResponse): Promise<SwapStatus> {
+    if (p.sourceChain !== 'solana') {
+      const publicClient = getPublicClient(useConfig(), {
+        chainId: p.sourceChain as any,
+      })
+      const receipt = await publicClient?.getTransactionReceipt({
+        hash: p.id as `0x${string}`,
+      })
+      if (receipt.status === 'reverted') {
+        return {
+          txHash: '',
+          status: 'Failed',
+        }
+      }
+    }
+
+    const res = await fetch(`https://api.orbiter.finance/transaction/${p.id}`).then(r => r.json())
+    return {
+      txHash: res.result.targetId || '',
+      // this is from orbiter source code, their docs dont have info for this
+      // https://github.com/Orbiter-Finance/OrbiterFE-V2/blob/2b35399aad581e666c45a829e0151485f4007c93/src/views/statistics/LatestTransactions.vue#L115
+      status:
+        res.result.opStatus === -1
+          ? 'Failed'
+          : res.result.opStatus === 80
+          ? 'Refunded'
+          : res.result.opStatus !== 98 && res.result.opStatus !== 99
+          ? 'Processing'
+          : 'Success',
+    }
+  }
+}