feat: allow other bridge provider families in CoW Swap: Recipient based (#552)

* Make bridge provider simpler, and create interfaces for the two families of providers

* chore: add assertion functions for provider types

* chore: adapt providers

* chore: adapt bridging logic

* chore: fix test

* chore: basic implementation of account bridge provider

* chore: refactor

* feat: refactor and cleanup

* chore: refactor

* tests: add mixed provider types tests

* chore: improve types

* tests: add tests

* fix: fix types of get status

* fix: error with type

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* chore: attempt to release a release candidate

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

Author: anxolin

.release-please-config.json

@@ -10,7 +10,9 @@
     },
     "packages/bridging": {
       "package-name": "@cowprotocol/sdk-bridging",
-      "release-type": "node"
+      "release-type": "node",
+      "versioning": "prerelease",
+      "prerelease": true
     },
     "packages/common": {
       "package-name": "@cowprotocol/sdk-common",

packages/bridging/src/BridgingSdk/BridgingSdk.test.ts

@@ -1,6 +1,7 @@
 import { BridgingSdk } from './BridgingSdk'
-import { MockBridgeProvider } from '../providers/mock/MockBridgeProvider'
-import { assertIsBridgeQuoteAndPost } from '../utils'
+import { MockHookBridgeProvider } from '../providers/mock/HookMockBridgeProvider'
+import { MockReceiverAccountBridgeProvider } from '../providers/mock/ReceiverAccountMockBridgeProvider'
+import { assertIsBridgeQuoteAndPost, isHookBridgeProvider, isReceiverAccountBridgeProvider } from '../utils'
 import {
   amountsAndCosts,
   appDataInfo,
@@ -36,7 +37,7 @@ adapterNames.forEach((adapterName) => {
     let orderBookApi: OrderBookApi
     let quoteResult: QuoteResultsWithSigner
 
-    const mockProvider = new MockBridgeProvider()
+    const mockProvider = new MockHookBridgeProvider()
     mockProvider.getQuote = jest.fn().mockResolvedValue(bridgeQuoteResult)
     mockProvider.getUnsignedBridgeCall = jest.fn().mockResolvedValue(bridgeCallDetails.unsignedBridgeCall)
     mockProvider.getSignedHook = jest.fn().mockResolvedValue(bridgeCallDetails.preAuthorizedBridgingHook)
@@ -367,18 +368,18 @@ adapterNames.forEach((adapterName) => {
     })
 
     describe('getMultiQuotes', () => {
-      let mockProvider2: MockBridgeProvider
-      let mockProvider3: MockBridgeProvider
+      let mockProvider2: MockHookBridgeProvider
+      let mockProvider3: MockHookBridgeProvider
 
       beforeEach(() => {
-        mockProvider2 = new MockBridgeProvider()
+        mockProvider2 = new MockHookBridgeProvider()
         mockProvider2.info.dappId = 'cow-sdk://bridging/providers/mock2'
         mockProvider2.info.name = 'Mock Bridge Provider 2'
         mockProvider2.getQuote = jest.fn().mockResolvedValue(bridgeQuoteResult)
         mockProvider2.getUnsignedBridgeCall = jest.fn().mockResolvedValue(bridgeCallDetails.unsignedBridgeCall)
         mockProvider2.getSignedHook = jest.fn().mockResolvedValue(bridgeCallDetails.preAuthorizedBridgingHook)
 
-        mockProvider3 = new MockBridgeProvider()
+        mockProvider3 = new MockHookBridgeProvider()
         mockProvider3.info.dappId = 'cow-sdk://bridging/providers/mock3'
         mockProvider3.info.name = 'Mock Bridge Provider 3'
         mockProvider3.getQuote = jest.fn().mockResolvedValue(bridgeQuoteResult)
@@ -399,7 +400,7 @@ adapterNames.forEach((adapterName) => {
 
         // Verify that the strategy pattern is working
         expect(results).toHaveLength(3)
-        expect(results[0]?.providerDappId).toBe('mockProvider')
+        expect(results[0]?.providerDappId).toBe('dapp-id-MockHookBridgeProvider')
         expect(results[1]?.providerDappId).toBe('cow-sdk://bridging/providers/mock2')
         expect(results[2]?.providerDappId).toBe('cow-sdk://bridging/providers/mock3')
 
@@ -430,22 +431,22 @@ adapterNames.forEach((adapterName) => {
       it('should pass provider filter to strategy', async () => {
         const results = await bridgingSdk.getMultiQuotes({
           quoteBridgeRequest,
-          providerDappIds: ['mockProvider', 'cow-sdk://bridging/providers/mock3'],
+          providerDappIds: ['dapp-id-MockHookBridgeProvider', 'cow-sdk://bridging/providers/mock3'],
         })
 
         // Verify only specified providers were used
         expect(results).toHaveLength(2)
-        expect(results[0]?.providerDappId).toBe('mockProvider')
+        expect(results[0]?.providerDappId).toBe('dapp-id-MockHookBridgeProvider')
         expect(results[1]?.providerDappId).toBe('cow-sdk://bridging/providers/mock3')
       })
     })
 
     describe('getBestQuote', () => {
-      let mockProvider2: MockBridgeProvider
-      let mockProvider3: MockBridgeProvider
+      let mockProvider2: MockHookBridgeProvider
+      let mockProvider3: MockHookBridgeProvider
 
       beforeEach(async () => {
-        mockProvider2 = new MockBridgeProvider()
+        mockProvider2 = new MockHookBridgeProvider()
         mockProvider2.info.dappId = 'cow-sdk://bridging/providers/mock2'
         mockProvider2.info.name = 'Mock Bridge Provider 2'
         // Override mockProvider to have a medium quote (50 ETH)
@@ -473,7 +474,7 @@ adapterNames.forEach((adapterName) => {
         mockProvider2.getUnsignedBridgeCall = jest.fn().mockResolvedValue(bridgeCallDetails.unsignedBridgeCall)
         mockProvider2.getSignedHook = jest.fn().mockResolvedValue(bridgeCallDetails.preAuthorizedBridgingHook)
 
-        mockProvider3 = new MockBridgeProvider()
+        mockProvider3 = new MockHookBridgeProvider()
         mockProvider3.info.dappId = 'cow-sdk://bridging/providers/mock3'
         mockProvider3.info.name = 'Mock Bridge Provider 3'
         mockProvider3.getQuote = jest.fn().mockResolvedValue({
@@ -530,14 +531,124 @@ adapterNames.forEach((adapterName) => {
       it('should pass provider filter to strategy', async () => {
         const result = await bridgingSdk.getBestQuote({
           quoteBridgeRequest,
-          providerDappIds: ['mockProvider'],
+          providerDappIds: ['dapp-id-MockHookBridgeProvider'],
         })
 
         // Verify only specified provider was used
         expect(result).toBeTruthy()
-        expect(result?.providerDappId).toBe('mockProvider')
+        expect(result?.providerDappId).toBe('dapp-id-MockHookBridgeProvider')
         expect(result?.quote).toBeTruthy()
       })
     })
+
+    describe('Mixed Provider Types', () => {
+      let hookProvider: MockHookBridgeProvider
+      let receiverAccountProvider: MockReceiverAccountBridgeProvider
+
+      beforeEach(() => {
+        hookProvider = new MockHookBridgeProvider()
+        hookProvider.getQuote = jest.fn().mockResolvedValue(bridgeQuoteResult)
+        hookProvider.getUnsignedBridgeCall = jest.fn().mockResolvedValue(bridgeCallDetails.unsignedBridgeCall)
+        hookProvider.getSignedHook = jest.fn().mockResolvedValue(bridgeCallDetails.preAuthorizedBridgingHook)
+
+        receiverAccountProvider = new MockReceiverAccountBridgeProvider()
+        receiverAccountProvider.getQuote = jest.fn().mockResolvedValue({
+          ...bridgeQuoteResult,
+          amountsAndCosts: {
+            ...bridgeQuoteResult.amountsAndCosts,
+            costs: {
+              bridgingFee: {
+                feeBps: 5,
+                amountInSellCurrency: 50000n,
+                amountInBuyCurrency: 50000n,
+              },
+            },
+          },
+        })
+
+        bridgingSdk = new BridgingSdk({
+          providers: [hookProvider, receiverAccountProvider],
+          tradingSdk,
+        })
+      })
+
+      it('should return the muxed types for the providers', () => {
+        const providers = bridgingSdk.getProviders()
+
+        expect(providers).toHaveLength(2)
+        expect(providers[0]).toEqual(hookProvider)
+        expect(isHookBridgeProvider(hookProvider)).toBe(true)
+
+        expect(providers[1]).toEqual(receiverAccountProvider)
+        expect(isReceiverAccountBridgeProvider(receiverAccountProvider)).toBe(true)
+      })
+
+      it('should get quotes from both provider types', async () => {
+        const results = await bridgingSdk.getMultiQuotes({
+          quoteBridgeRequest,
+        })
+
+        expect(results).toHaveLength(2)
+        expect(results[0]?.providerDappId).toBe('dapp-id-MockHookBridgeProvider')
+        expect(results[1]?.providerDappId).toBe('dapp-id-ReceiverAccountBridgeProvider')
+
+        // Both should return quotes
+        expect(results[0]?.quote).toBeTruthy()
+        expect(results[1]?.quote).toBeTruthy()
+      })
+
+      it('should compare quotes from different provider types in getBestQuote', async () => {
+        // Make hook provider have a lower quote
+        hookProvider.getQuote = jest.fn().mockResolvedValue({
+          ...bridgeQuoteResult,
+          amountsAndCosts: {
+            ...bridgeQuoteResult.amountsAndCosts,
+            afterSlippage: {
+              ...bridgeQuoteResult.amountsAndCosts.afterSlippage,
+              buyAmount: BigInt('50000000000000000000'), // 50 ETH
+            },
+          },
+        })
+
+        // Make receiver account provider have better quote
+        receiverAccountProvider.getQuote = jest.fn().mockResolvedValue({
+          ...bridgeQuoteResult,
+          amountsAndCosts: {
+            ...bridgeQuoteResult.amountsAndCosts,
+            afterSlippage: {
+              ...bridgeQuoteResult.amountsAndCosts.afterSlippage,
+              buyAmount: BigInt('70000000000000000000'), // 70 ETH - better than hook provider
+            },
+          },
+        })
+
+        const result = await bridgingSdk.getBestQuote({
+          quoteBridgeRequest,
+        })
+
+        // Should select the receiver account provider as it has better quote
+        expect(result).toBeTruthy()
+        expect(result?.providerDappId).toBe('dapp-id-ReceiverAccountBridgeProvider')
+        expect(result?.quote?.bridge.amountsAndCosts.afterSlippage.buyAmount).toBe(BigInt('70000000000000000000'))
+      })
+
+      it('should correctly identify provider types', () => {
+        const providers = bridgingSdk.getProviders()
+
+        const hook = providers.find((p) => p.info.dappId === 'dapp-id-MockHookBridgeProvider')
+        const receiver = providers.find((p) => p.info.dappId === 'dapp-id-ReceiverAccountBridgeProvider')
+
+        expect(hook).toBeDefined()
+        expect(receiver).toBeDefined()
+
+        if (!hook || !receiver) throw new Error('Hook or receiver not found') // Just to satisfy the linter (asserted above)
+
+        expect(isHookBridgeProvider(hook)).toBe(true)
+        expect(isReceiverAccountBridgeProvider(hook)).toBe(false)
+
+        expect(isHookBridgeProvider(receiver)).toBe(false)
+        expect(isReceiverAccountBridgeProvider(receiver)).toBe(true)
+      })
+    })
   })
 })

packages/bridging/src/BridgingSdk/BridgingSdk.ts

@@ -1,5 +1,4 @@
 import {
-  BridgeProvider,
   BridgeQuoteResult,
   BridgeStatusResult,
   BuyTokensParams,
@@ -9,6 +8,7 @@ import {
   MultiQuoteResult,
   MultiQuoteRequest,
   QuoteBridgeRequest,
+  BridgeProvider,
 } from '../types'
 import { getCrossChainOrder } from './getCrossChainOrder'
 import { findBridgeProviderFromHook } from './findBridgeProviderFromHook'

packages/bridging/src/BridgingSdk/getBridgeSignedHook.test.ts

@@ -1,8 +1,8 @@
 import { getBridgeSignedHook } from './getBridgeSignedHook'
-import { QuoteBridgeRequest } from '../types'
-import { BridgeResultContext } from './types'
+import { BridgeQuoteResult, HookBridgeProvider, QuoteBridgeRequest } from '../types'
 import { createAdapters } from '../../tests/setup'
 import { setGlobalAdapter } from '@cowprotocol/sdk-common'
+import { HookBridgeResultContext } from './getQuoteWithBridge'
 
 jest.mock('@cowprotocol/sdk-order-book', () => ({
   ...jest.requireActual('@cowprotocol/sdk-order-book'),
@@ -25,6 +25,11 @@ const unsignedBridgeCallMock = {
 const signedHookMock = {}
 
 const owner = '0x000a1'
+const providerMock = {
+  getQuote: jest.fn().mockResolvedValue(bridgingQuoteMock),
+  getUnsignedBridgeCall: jest.fn().mockResolvedValue(unsignedBridgeCallMock),
+  getSignedHook: jest.fn().mockResolvedValue(signedHookMock),
+} as unknown as HookBridgeProvider<BridgeQuoteResult>
 
 const contextMock = {
   swapResult: {
@@ -35,14 +40,9 @@ const contextMock = {
       owner,
     },
   },
-  provider: {
-    getQuote: jest.fn().mockResolvedValue(bridgingQuoteMock),
-    getUnsignedBridgeCall: jest.fn().mockResolvedValue(unsignedBridgeCallMock),
-    getSignedHook: jest.fn().mockResolvedValue(signedHookMock),
-  },
   signer: {},
   hookGasLimit: 100000n,
-} as unknown as BridgeResultContext
+} as unknown as HookBridgeResultContext
 
 const adapters = createAdapters()
 const adapterNames = Object.keys(adapters) as Array<keyof typeof adapters>
@@ -60,10 +60,10 @@ adapterNames.forEach((adapterName) => {
     })
 
     it('Should create a bridge hook nonce based on orderId and specified owner', async () => {
-      await getBridgeSignedHook(bridgeRequestMock, contextMock)
+      await getBridgeSignedHook(providerMock, bridgeRequestMock, contextMock)
 
-      expect(contextMock.provider.getSignedHook).toHaveBeenCalledTimes(1)
-      expect(contextMock.provider.getSignedHook).toHaveBeenCalledWith(
+      expect(providerMock.getSignedHook).toHaveBeenCalledTimes(1)
+      expect(providerMock.getSignedHook).toHaveBeenCalledWith(
         bridgeRequestMock.sellTokenChainId,
         unsignedBridgeCallMock,
         // nonce
@@ -78,17 +78,17 @@ adapterNames.forEach((adapterName) => {
     it('Should calculate deadline based on orderToSign.validTo first of all', async () => {
       const expectedValidTo = 1750000000
 
-      await getBridgeSignedHook(bridgeRequestMock, {
+      await getBridgeSignedHook(providerMock, bridgeRequestMock, {
         ...contextMock,
         swapResult: {
           orderToSign: {
             validTo: expectedValidTo,
           },
         },
-      } as unknown as BridgeResultContext)
+      } as unknown as HookBridgeResultContext)
 
-      expect(contextMock.provider.getSignedHook).toHaveBeenCalledTimes(1)
-      expect(contextMock.provider.getSignedHook).toHaveBeenCalledWith(
+      expect(providerMock.getSignedHook).toHaveBeenCalledTimes(1)
+      expect(providerMock.getSignedHook).toHaveBeenCalledWith(
         expect.anything(),
         expect.anything(),
         expect.anything(),
@@ -102,18 +102,18 @@ adapterNames.forEach((adapterName) => {
     it('Should use validTo override for deadline if set', async () => {
       const expectedValidTo = 2900000000
 
-      await getBridgeSignedHook(bridgeRequestMock, {
+      await getBridgeSignedHook(providerMock, bridgeRequestMock, {
         ...contextMock,
         swapResult: {
           orderToSign: {
             validTo: 1750000000,
           },
         },
         validToOverride: expectedValidTo,
-      } as unknown as BridgeResultContext)
+      } as unknown as HookBridgeResultContext)
 
-      expect(contextMock.provider.getSignedHook).toHaveBeenCalledTimes(1)
-      expect(contextMock.provider.getSignedHook).toHaveBeenCalledWith(
+      expect(providerMock.getSignedHook).toHaveBeenCalledTimes(1)
+      expect(providerMock.getSignedHook).toHaveBeenCalledWith(
         expect.anything(),
         expect.anything(),
         expect.anything(),

packages/bridging/src/BridgingSdk/getBridgeSignedHook.ts

@@ -1,12 +1,13 @@
 import { EvmCall } from '@cowprotocol/sdk-config'
 import { getGlobalAdapter } from '@cowprotocol/sdk-common'
 
-import { BridgeHook, BridgeQuoteResult, QuoteBridgeRequest } from '../types'
-import { BridgeResultContext } from './types'
+import { BridgeHook, BridgeQuoteResult, HookBridgeProvider, QuoteBridgeRequest } from '../types'
+import { HookBridgeResultContext } from './getQuoteWithBridge'
 
 export async function getBridgeSignedHook(
+  provider: HookBridgeProvider<BridgeQuoteResult>,
   bridgeRequest: QuoteBridgeRequest,
-  { provider, signer, hookGasLimit, swapResult, validToOverride }: BridgeResultContext,
+  { signer, hookGasLimit, swapResult, validToOverride }: HookBridgeResultContext,
 ): Promise<{ hook: BridgeHook; unsignedBridgeCall: EvmCall; bridgingQuote: BridgeQuoteResult }> {
   const adapter = getGlobalAdapter()
 

packages/bridging/src/BridgingSdk/getCrossChainOrder.ts

@@ -1,4 +1,4 @@
-import { BridgeProvider, BridgeQuoteResult, BridgeStatus, CrossChainOrder } from '../types'
+import { BridgeQuoteResult, BridgeStatus, CrossChainOrder, BridgeProvider } from '../types'
 
 import { BridgeOrderParsingError } from '../errors'
 import { findBridgeProviderFromHook } from './findBridgeProviderFromHook'