feat(bridge): track order progress (#324)

* feat(bridge): use across API to get bridge supported tokens

* chore: bump v

* chore: fix lowercase

* feat(bridge): get deposit status from Across API

* feat(bridge): add order status tracking methods

* chore: fix tests

* feat(bridge): add depositParams to getOrder() result

* chore: bump v

* chore: fix naming

* chore: unknown status

* chore: add deposit and fill tx

* chore: update test

* chore: bump v

---------

Co-authored-by: daniele <[email protected]>

Author: shoom3301

examples/nodejs/src/index.ts

@@ -1,4 +1,16 @@
-import { SupportedChainId, OrderKind, postSwapOrder, postLimitOrder } from '../../../src'
+import {
+  SupportedChainId,
+  OrderKind,
+  postSwapOrder,
+  postLimitOrder,
+  enableLogging,
+  AcrossBridgeProvider,
+  BridgingSdk,
+  OrderBookApi,
+} from '../../../src'
+import { JsonRpcProvider } from '@ethersproject/providers'
+
+enableLogging(true)
 
 const privateKey = 'xxx'
 
@@ -41,6 +53,8 @@ const privateKey = 'xxx'
 
 // Swap with partner fee
 ;(async function () {
+  return
+
   postSwapOrder(
     {
       appCode: 'cow-sdk-example',
@@ -66,3 +80,29 @@ const privateKey = 'xxx'
     },
   )
 })()
+
+// Get bridging order
+;(async function () {
+  return
+
+  const acrossProvider = new AcrossBridgeProvider()
+  const sdk = new BridgingSdk({
+    providers: [acrossProvider],
+    orderBookApi: new OrderBookApi({
+      backoffOpts: {
+        maxDelay: 0,
+        numOfAttempts: 0,
+      },
+    }),
+  })
+
+  const data = await sdk.getOrder({
+    chainId: SupportedChainId.MAINNET,
+    env: 'staging',
+    rpcProvider: new JsonRpcProvider('https://mainnet.gateway.tenderly.co'),
+    orderId:
+      '0xb8aeae0626654ea134614a42044dcf081544981e19f35082e20c967d5210834dfb3c7eb936caa12b5a884d612393969a557d430768248d30',
+  })
+
+  console.log('Bidging order data', data)
+})()

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cowprotocol/cow-sdk",
-  "version": "6.0.0-RC.51",
+  "version": "6.0.0-RC.52",
   "license": "(MIT OR Apache-2.0)",
   "files": [
     "/dist"

src/bridging/BridgingSdk/BridgingSdk.ts

@@ -2,17 +2,19 @@ import { SwapAdvancedSettings, TradingSdk } from '../../trading'
 import {
   BridgeProvider,
   BridgeQuoteResult,
+  BridgeStatusResult,
   CrossChainOrder,
   CrossChainQuoteAndPost,
   QuoteBridgeRequest,
 } from '../types'
-import { ALL_SUPPORTED_CHAINS, CowEnv, TokenInfo } from '../../common'
+import { ALL_SUPPORTED_CHAINS, CowEnv, TokenInfo, enableLogging } from '../../common'
 import { ChainInfo, SupportedChainId, TargetChainId } from '../../chains'
 import { getQuoteWithoutBridge } from './getQuoteWithoutBridge'
 import { getQuoteWithBridge } from './getQuoteWithBridge'
-import { enableLogging } from '../../common/utils/log'
-import { OrderBookApi } from 'src/order-book'
 import { getCrossChainOrder } from './getCrossChainOrder'
+import { JsonRpcProvider } from '@ethersproject/providers'
+import { OrderBookApi } from '../../order-book'
+import { findBridgeProviderFromHook } from './findBridgeProviderFromHook'
 
 export interface BridgingSdkOptions {
   /**
@@ -40,15 +42,19 @@ export interface BridgingSdkOptions {
  * Parameters for the `getOrder` method.
  */
 export interface GetOrderParams {
+  /**
+   * Id of a network where order was settled
+   */
+  chainId: SupportedChainId
   /**
    * The unique identifier of the order.
    */
   orderId: string
 
   /**
-   * The chain ID of the order.
+   * RPC provider to get order transactions details
    */
-  chainId: SupportedChainId
+  rpcProvider: JsonRpcProvider
 
   /**
    * The environment of the order
@@ -116,9 +122,8 @@ export class BridgingSdk {
 
   /**
    * Get the available buy tokens for buying in a specific target chain
-   *
-   * @param param
-   * @returns
+
+   * @param targetChainId
    */
   async getBuyTokens(targetChainId: TargetChainId): Promise<TokenInfo[]> {
     return this.provider.getBuyTokens(targetChainId)
@@ -165,16 +170,26 @@ export class BridgingSdk {
     }
   }
 
-  async getOrder(params: GetOrderParams): Promise<CrossChainOrder> {
+  async getOrder(params: GetOrderParams): Promise<CrossChainOrder | null> {
     const { orderBookApi } = this.config
 
-    const { orderId, chainId, env } = params
+    const { chainId, orderId, rpcProvider, env = orderBookApi.context.env } = params
+
     return getCrossChainOrder({
-      orderId,
       chainId,
+      orderId,
+      rpcProvider,
       orderBookApi,
+      env,
       providers: this.config.providers,
-      env: env || orderBookApi.context.env,
     })
   }
+
+  async getOrderBridgingStatus(bridgingId: string, originChainId: SupportedChainId): Promise<BridgeStatusResult> {
+    return this.provider.getStatus(bridgingId, originChainId)
+  }
+
+  getProviderFromAppData(fullAppData: string): BridgeProvider<BridgeQuoteResult> | undefined {
+    return findBridgeProviderFromHook(fullAppData, this.getProviders())
+  }
 }

src/bridging/BridgingSdk/findBridgeProviderFromHook.ts

@@ -0,0 +1,24 @@
+import { getPostHooks } from '../utils'
+import { HOOK_DAPP_BRIDGE_PROVIDER_PREFIX } from '../const'
+import { BridgeProvider, BridgeQuoteResult } from '../types'
+
+export function findBridgeProviderFromHook(
+  fullAppData: string,
+  providers: BridgeProvider<BridgeQuoteResult>[],
+): BridgeProvider<BridgeQuoteResult> | undefined {
+  const postHooks = getPostHooks(fullAppData)
+
+  // Assuming we only have one bridging hook
+  const bridgingHook = postHooks.find((hook) => {
+    return hook.dappId?.startsWith(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX)
+  })
+
+  if (!bridgingHook) {
+    return undefined
+  }
+  // Bridge provider would be the last part of the dappId
+  const bridgeProviderDappId = bridgingHook.dappId
+
+  // Find the provider by name (note that I could just have use this.provider, but just wanted to leave it ready in case we implement multiple providers)
+  return providers.find((provider) => provider.info.dappId === bridgeProviderDappId)
+}

src/bridging/BridgingSdk/getCrossChainOrder.ts

@@ -1,43 +1,35 @@
 import { BridgeProvider, BridgeQuoteResult, BridgeStatus, CrossChainOrder } from '../types'
-import { SupportedChainId } from '../../chains'
-import { OrderBookApi } from 'src/order-book'
-import { getPostHooks } from '../utils'
-import { HOOK_DAPP_BRIDGE_PROVIDER_PREFIX } from '../providers/across/const/misc'
+
 import { CowEnv } from '../../common'
+import { JsonRpcProvider } from '@ethersproject/providers'
+import { BridgeOrderParsingError } from '../errors'
+import { SupportedChainId } from '../../chains'
+import { OrderBookApi } from '../../order-book'
+import { findBridgeProviderFromHook } from './findBridgeProviderFromHook'
 
-/**
- * Fetch a cross-chain order and its status.
- */
-export async function getCrossChainOrder(params: {
-  orderId: string
+interface GetCrossChainOrderParams {
   chainId: SupportedChainId
+  orderId: string
+  rpcProvider: JsonRpcProvider
   orderBookApi: OrderBookApi
   providers: BridgeProvider<BridgeQuoteResult>[]
   env: CowEnv
-}): Promise<CrossChainOrder> {
-  const { orderId, chainId, orderBookApi, providers, env } = params
+}
+
+/**
+ * Fetch a cross-chain order and its status.
+ */
+export async function getCrossChainOrder(params: GetCrossChainOrderParams): Promise<CrossChainOrder | null> {
+  const { chainId, orderId, orderBookApi, providers, rpcProvider, env } = params
 
   const chainContext = { chainId, env }
   const order = await orderBookApi.getOrder(orderId, chainContext)
 
-  const postHooks = getPostHooks(order.fullAppData ?? undefined)
-
-  // Assuming we only have one bridging hook
-  const bridgingHook = postHooks.find((hook) => {
-    return hook.dappId?.startsWith(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX)
-  })
-
-  if (!bridgingHook) {
-    throw new Error(`Order ${orderId} is not a cross-chain order`)
-  }
-  // Bridge provider would be the last part of the dappId
-  const bridgeProviderName = bridgingHook.dappId?.split(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX).pop()
-
   // Find the provider by name (note that I could just have use this.provider, but just wanted to leave it ready in case we implement multiple providers)
-  const provider = providers.find((provider) => provider.info.name === bridgeProviderName)
+  const provider = order.fullAppData && findBridgeProviderFromHook(order.fullAppData, providers)
   if (!provider) {
-    throw new Error(
-      `Unknown Bridge provider: ${bridgeProviderName}. Add provider to the SDK config to be able to decode the order`
+    throw new BridgeOrderParsingError(
+      `Unknown Bridge provider in order ${order.uid}. Add provider to the SDK config to be able to decode the order`,
     )
   }
 
@@ -46,33 +38,50 @@ export async function getCrossChainOrder(params: {
 
   // Check if there are any trades for this order
   const trades = await orderBookApi.getTrades({ orderUid: order.uid }, chainContext)
+
   if (trades.length > 0) {
     // Bridging already initiated
     const firstTrade = trades[0]
-    if (!firstTrade.txHash) {
-      // Shouldn't happen, but lets make typescript happy
-      throw new Error(`No tx hash found for order ${orderId} . First trade, with log index ${firstTrade.logIndex}`)
+    const tradeTxHash = firstTrade.txHash
+
+    if (!tradeTxHash) {
+      throw new BridgeOrderParsingError(
+        `No tx hash found for order ${orderId} . First trade, with log index ${firstTrade.logIndex}`,
+      )
     }
 
     // Get bridging id for this order
-    const bridgingId = await provider.getBridgingId(orderId, firstTrade.txHash, firstTrade.logIndex)
-    const { status, fillTimeInSeconds } = await provider.getStatus(bridgingId)
-    const explorerUrl = provider.getExplorerUrl(bridgingId)
+    const bridgingParams = await provider.getBridgingParams(chainId, rpcProvider, orderId, tradeTxHash)
 
-    return {
-      chainId,
-      order,
-      status,
-      bridgingId,
-      explorerUrl,
-      fillTimeInSeconds,
+    if (!bridgingParams) {
+      throw new BridgeOrderParsingError(`Bridging params cannot be derived from transaction: ${tradeTxHash}`)
     }
-  } else {
-    // Bridging not initiated yet
-    return {
+
+    const state: CrossChainOrder = {
       chainId,
       order,
-      status: BridgeStatus.NOT_INITIATED,
+      statusResult: {
+        status: BridgeStatus.UNKNOWN,
+      },
+      bridgingParams,
+      tradeTxHash,
+    }
+
+    try {
+      const statusResult = await provider.getStatus(bridgingParams.bridgingId, chainId)
+      const explorerUrl = provider.getExplorerUrl(bridgingParams.bridgingId)
+
+      return {
+        ...state,
+        statusResult,
+        explorerUrl,
+      }
+    } catch (e) {
+      console.error('Cannot get bridging status', e)
+      return state
     }
   }
+
+  // Bridging not initiated yet
+  return null
 }

src/bridging/const.ts

@@ -2,3 +2,4 @@ import { RAW_FILES_PATH } from '../common/consts/path'
 
 export const RAW_PROVIDERS_FILES_PATH = `${RAW_FILES_PATH}/src/bridging/providers`
 export const DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION = 200_000 // Based on https://dashboard.tenderly.co/shoom/project/simulator/a5e29dac-d0f2-407f-9e3d-d1b916da595b
+export const HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = 'cow-sdk://bridging/providers'

src/bridging/errors.ts

@@ -7,3 +7,13 @@ export class BridgeProviderQuoteError extends Error {
     this.name = 'BridgeProviderQuoteError'
   }
 }
+
+export class BridgeOrderParsingError extends Error {
+  constructor(
+    message: string,
+    public readonly context?: unknown,
+  ) {
+    super(message)
+    this.name = 'BridgeOrderParsingError'
+  }
+}

src/bridging/providers/across/AcrossApi.spec.ts

@@ -1,6 +1,6 @@
-import { SupportedChainId } from '../../../chains'
+import { AdditionalTargetChainId, SupportedChainId } from '../../../chains'
 import { AcrossApi } from './AcrossApi'
-
+import { DepositStatusResponse } from './types'
 describe('AcrossApi: Shape of API response', () => {
   let api: AcrossApi
 
@@ -62,4 +62,21 @@ describe('AcrossApi: Shape of API response', () => {
 
     expect(result).toBeDefined()
   })
+
+  it('getDepositStatus', async () => {
+    // Attempt to make a REAL API call. The API implementation will assert the result shape matches the expected object
+    const result: DepositStatusResponse = await api.getDepositStatus({
+      originChainId: AdditionalTargetChainId.OPTIMISM.toString(),
+      depositId: '1349975',
+    })
+
+    expect(result).toBeDefined()
+    expect(result.status).toBe('filled')
+    expect(result.depositTxHash).toBe('0x2bb3be895fd9be20522562cd62b52ae8d58eb00b31548c2caa7fcb557708f4cf')
+    expect(result.fillTx).toBe('0xee2087bfb253c4d50e2ee8ddbae14a625540534569b9e54ea31a7cb13584a3ef')
+    expect(result.destinationChainId).toBe(8453)
+    expect(result.depositRefundTxHash).toBeNull()
+    expect(result.pagination).toBeDefined()
+    expect(result.pagination?.currentIndex).toBe(0)
+  })
 })