feat(bridging): add bridge-then-swap provider abstraction and Bungee implementation

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

@@ -1,7 +1,7 @@
 import { getEthFlowContract, TradingSdk } from '@cowprotocol/sdk-trading'
 import { MockHookBridgeProvider } from '../providers/mock/HookMockBridgeProvider'
 import { MockReceiverAccountBridgeProvider } from '../providers/mock/ReceiverAccountMockBridgeProvider'
-import { QuoteBridgeRequest } from '../types'
+import { BridgeQuoteAndPost, QuoteBridgeRequest } from '../types'
 import { getQuoteWithBridge } from './getQuoteWithBridge'
 import {
   bridgeCallDetails,
@@ -85,7 +85,7 @@ adapterNames.forEach((adapterName) => {
       return getQuoteWithBridge(mockProvider, {
         swapAndBridgeRequest: request,
         tradingSdk,
-      })
+      }) as Promise<BridgeQuoteAndPost>
     }
 
     async function postOrderWithCustomReceiver(customReceiver: string) {

packages/bridging/src/BridgingSdk/getQuoteWithBridge.ts

@@ -16,6 +16,8 @@
   BridgeQuoteAndPost,
   BridgeQuoteResult,
   BridgeQuoteResults,
+  BridgeThenSwapProvider,
+  BridgeThenSwapQuoteAndPost,
   QuoteBridgeRequest,
   QuoteBridgeRequestWithoutAmount,
   BridgeProvider,
@@ -28,20 +30,31 @@
 import { getBridgeSignedHook } from './getBridgeSignedHook'
 import { HOOK_DAPP_BRIDGE_PROVIDER_PREFIX } from '../const'
 import { getHookMockForCostEstimation } from '../hooks/utils'
-import { isHookBridgeProvider, isReceiverAccountBridgeProvider } from '../utils'
+import { isHookBridgeProvider, isReceiverAccountBridgeProvider, isBridgeThenSwapProvider } from '../utils'
 import { getIntermediateSwapResult } from './getIntermediateSwapResult'
+import { getQuoteWithBridgeThenSwap } from './getQuoteWithBridgeThenSwap'
 
 export async function getQuoteWithBridge<T extends BridgeQuoteResult>(
   provider: BridgeProvider<T>,
   params: GetQuoteWithBridgeParams,
-): Promise<BridgeQuoteAndPost> {
+): Promise<BridgeQuoteAndPost | BridgeThenSwapQuoteAndPost> {
   const { kind } = params.swapAndBridgeRequest
 
   // Ensure the quote request is for a sell order (only type supported for now)
   if (kind !== OrderKind.SELL) {
     throw new Error('Bridging only support SELL orders')
   }
 
+  // If the provider uses bridge-then-swap (reverse flow)
+  if (isBridgeThenSwapProvider(provider)) {
+    return getQuoteWithBridgeThenSwap(provider, {
+      swapAndBridgeRequest: params.swapAndBridgeRequest,
+      advancedSettings: params.advancedSettings,
+      tradingSdk: params.tradingSdk,
+      intermediateTokensCache: params.intermediateTokensCache,
+    })
+  }
+
   // If the provider relies on hooks
   if (isHookBridgeProvider(provider)) {
     return getQuoteWithHookBridge(provider, params)

packages/bridging/src/BridgingSdk/getQuoteWithBridgeThenSwap.ts

@@ -0,0 +1,274 @@
+import {
+  QuoteResults,
+  SwapAdvancedSettings,
+  TradingSdk,
+  WithPartialTraderParams,
+  TradeParameters,
+} from '@cowprotocol/sdk-trading'
+import { getGlobalAdapter, log, SignerLike } from '@cowprotocol/sdk-common'
+import { OrderKind } from '@cowprotocol/sdk-order-book'
+import { TokenInfo } from '@cowprotocol/sdk-config'
+import {
+  BridgeQuoteResult,
+  BridgeQuoteResults,
+  BridgeThenSwapProvider,
+  BridgeThenSwapQuoteAndPost,
+  QuoteBridgeRequest,
+} from '../types'
+import { GetQuoteWithBridgeThenSwapParams } from './types'
+import { BridgeProviderQuoteError, BridgeQuoteErrors } from '../errors'
+import { determineIntermediateToken } from './determineIntermediateToken'
+
+const DESTINATION_GAS_BUFFER = 30_000
+
+/**
+ * Get a quote for a bridge-then-swap operation.
+ *
+ * Flow:
+ * 1. Determine the intermediate token on the destination chain (what can be bridged)
+ * 2. Get a bridge quote from source chain to destination chain (for the intermediate token)
+ * 3. Get a swap quote on the destination chain (intermediate token → final buy token)
+ * 4. Compute the OrderFlow address (CREATE2)
+ * 5. Encode the destination order data
+ * 6. Build the bridge transaction (includes destination payload)
+ * 7. Return the combined quote
+ */
+export async function getQuoteWithBridgeThenSwap<T extends BridgeQuoteResult>(
+  provider: BridgeThenSwapProvider<T>,
+  params: GetQuoteWithBridgeThenSwapParams,
+): Promise<BridgeThenSwapQuoteAndPost> {
+  const { swapAndBridgeRequest, tradingSdk, advancedSettings } = params
+  const {
+    kind,
+    sellTokenChainId,
+    sellTokenAddress,
+    sellTokenDecimals,
+    buyTokenChainId,
+    buyTokenAddress,
+    buyTokenDecimals,
+    amount,
+    signer: signerLike,
+  } = swapAndBridgeRequest
+
+  if (kind !== OrderKind.SELL) {
+    throw new Error('Bridge-then-swap only supports SELL orders')
+  }
+
+  const adapter = getGlobalAdapter()
+  const signer = signerLike ? adapter.createSigner(signerLike) : adapter.signer
+  const owner = swapAndBridgeRequest.owner ?? swapAndBridgeRequest.account
+  if (!owner) {
+    throw new BridgeProviderQuoteError(BridgeQuoteErrors.QUOTE_ERROR, {
+      error: 'Owner address is required for bridge-then-swap',
+    })
+  }
+
+  log(
+    `Bridge-then-swap: ${amount} ${sellTokenAddress} (chain ${sellTokenChainId}) → bridge → swap for ${buyTokenAddress} (chain ${buyTokenChainId})`,
+  )
+
+  // Step 1: Get intermediate tokens (tokens that can be bridged to the destination chain)
+  const intermediateTokens = await provider.getIntermediateTokens(swapAndBridgeRequest)
+
+  if (intermediateTokens.length === 0) {
+    throw new BridgeProviderQuoteError(BridgeQuoteErrors.NO_INTERMEDIATE_TOKENS)
+  }
+
+  // Determine the best intermediate token for bridging
+  const intermediateToken = await determineIntermediateToken(
+    sellTokenChainId,
+    sellTokenAddress,
+    intermediateTokens,
+    advancedSettings?.getCorrelatedTokens,
+  )
+
+  log(`Using ${intermediateToken?.name ?? intermediateToken?.address} as bridge intermediate token`)
+
+  // Step 2: Get bridge quote (source chain sell token → destination chain intermediate token)
+  const bridgeRequest: QuoteBridgeRequest = {
+    ...swapAndBridgeRequest,
+    // The sell token is the user's source token
+    sellTokenAddress,
+    sellTokenChainId,
+    sellTokenDecimals,
+    // The buy token for the bridge is the intermediate token on the destination chain
+    buyTokenAddress: intermediateToken.address,
+    buyTokenChainId,
+    buyTokenDecimals: intermediateToken.decimals,
+  }
+
+  const bridgeQuote = await provider.getQuote(bridgeRequest)
+
+  // The amount that arrives on the destination chain after bridge fees
+  const bridgedAmount = bridgeQuote.amountsAndCosts.afterSlippage.buyAmount
+
+  log(`Bridge quote: ${amount} → ${bridgedAmount} of ${intermediateToken.symbol} on chain ${buyTokenChainId}`)
+
+  // Step 3: Get swap quote on the destination chain (intermediate token → final buy token)
+  // This is an indicative quote — the actual order is created on-chain by OrderFlowFactory
+  const destinationSwapResult = await getDestinationSwapQuote({
+    tradingSdk,
+    bridgedAmount,
+    intermediateToken,
+    buyTokenAddress,
+    buyTokenDecimals,
+    buyTokenChainId,
+    swapAndBridgeRequest,
+    signer,
+    advancedSettings,
+  })
+
+  const destinationBuyAmount = destinationSwapResult.swapResult.amountsAndCosts.afterSlippage.buyAmount
+  const estimatedBuyAmount = destinationSwapResult.swapResult.amountsAndCosts.afterPartnerFees.buyAmount
+
+  // Step 4: Compute the OrderFlow address
+  const orderFlowAddress = provider.getOrderFlowAddress(owner, buyTokenChainId)
+
+  log(`OrderFlow address for ${owner} on chain ${buyTokenChainId}: ${orderFlowAddress}`)
+
+  // Determine validTo for the destination order
+  // Use a generous validity window since we need time for bridge + order settlement
+  const validTo = Math.floor(Date.now() / 1000) + 3600 // 1 hour from now
+
+  // Step 5: Encode destination order data
+  const receiver = swapAndBridgeRequest.receiver ?? owner
+  const destinationOrderParams = {
+    sellToken: intermediateToken.address,
+    buyToken: buyTokenAddress,
+    receiver,
+    owner,
+    sellAmount: bridgedAmount,
+    buyAmount: destinationBuyAmount,
+    validTo,
+    appData: destinationSwapResult.swapResult.appDataInfo.appDataKeccak256,
+    feeAmount: 0n,
+    partiallyFillable: false,
+    quoteId: undefined as number | undefined,
+  }
+
+  const destinationPayload = provider.encodeDestinationOrderData(destinationOrderParams)
+
+  // Step 6: Estimate destination gas
+  const baseGasLimit = await provider.getDestinationGasLimit(destinationOrderParams)
+  const destinationGasLimit = baseGasLimit + DESTINATION_GAS_BUFFER
+
+  log(`Destination gas limit: ${destinationGasLimit} (${baseGasLimit} + ${DESTINATION_GAS_BUFFER} buffer)`)
+
+  // Step 7: Build bridge transaction
+  const bridgeTransaction = await provider.getBridgeTransaction({
+    bridgeQuote,
+    destinationPayload,
+    destinationGasLimit,
+  })
+
+  // Prepare bridge result
+  const bridgeResult: BridgeQuoteResults = {
+    providerInfo: provider.info,
+    id: bridgeQuote.id,
+    signature: bridgeQuote.signature,
+    quoteBody: bridgeQuote.quoteBody,
+    tradeParameters: bridgeRequest,
+    isSell: bridgeQuote.isSell,
+    expectedFillTimeSeconds: bridgeQuote.expectedFillTimeSeconds,
+    fees: bridgeQuote.fees,
+    limits: bridgeQuote.limits,
+    quoteTimestamp: bridgeQuote.quoteTimestamp,
+    amountsAndCosts: bridgeQuote.amountsAndCosts,
+  }
+
+  // Build buy token info
+  const buyTokenInfo: TokenInfo = {
+    address: buyTokenAddress,
+    decimals: buyTokenDecimals,
+    chainId: buyTokenChainId,
+    name: destinationSwapResult.swapResult.tradeParameters.buyToken,
+    symbol: destinationSwapResult.swapResult.tradeParameters.buyToken,
+  }
+
+  // Build sell token info for destination (the intermediate token)
+  const destSellTokenInfo: TokenInfo = {
+    ...intermediateToken,
+    chainId: buyTokenChainId,
+  }
+
+  return {
+    bridge: bridgeResult,
+    destinationSwap: {
+      sellToken: destSellTokenInfo,
+      buyToken: buyTokenInfo,
+      estimatedBuyAmount,
+      minBuyAmount: destinationBuyAmount,
+      validTo,
+      quoteId: undefined,
+    },
+    orderFlowAddress,
+    bridgeTransaction,
+    approvalData: undefined, // TODO: Extract from Bungee build-tx approvalData if needed
+    submitBridgeTransaction: async (txSigner: SignerLike) => {
+      const resolvedSigner = adapter.createSigner(txSigner)
+      const txResponse = await resolvedSigner.sendTransaction({
+        to: bridgeTransaction.to,
+        data: bridgeTransaction.data,
+        value: BigInt(bridgeTransaction.value),
+      })
+      return { txHash: txResponse.hash }
+    },
+  }
+}
+
+interface GetDestinationSwapQuoteParams {
+  tradingSdk: TradingSdk
+  bridgedAmount: bigint
+  intermediateToken: TokenInfo
+  buyTokenAddress: string
+  buyTokenDecimals: number
+  buyTokenChainId: number
+  swapAndBridgeRequest: QuoteBridgeRequest
+  signer: SignerLike
+  advancedSettings?: SwapAdvancedSettings
+}
+
+async function getDestinationSwapQuote(
+  params: GetDestinationSwapQuoteParams,
+): Promise<{ swapResult: QuoteResults }> {
+  const {
+    tradingSdk,
+    bridgedAmount,
+    intermediateToken,
+    buyTokenAddress,
+    buyTokenDecimals,
+    buyTokenChainId,
+    swapAndBridgeRequest,
+    signer,
+    advancedSettings,
+  } = params
+
+  const {
+    kind,
+    swapSlippageBps,
+    owner,
+    account,
+    receiver,
+  } = swapAndBridgeRequest
+
+  const swapParams: WithPartialTraderParams<TradeParameters> = {
+    kind,
+    chainId: buyTokenChainId,
+    sellToken: intermediateToken.address,
+    sellTokenDecimals: intermediateToken.decimals,
+    buyToken: buyTokenAddress,
+    buyTokenDecimals,
+    amount: bridgedAmount.toString(),
+    slippageBps: swapSlippageBps,
+    signer,
+    receiver: receiver ?? owner ?? account,
+  }
+
+  log(
+    `Getting destination swap quote on chain ${buyTokenChainId}: ${intermediateToken.symbol} → ${buyTokenAddress}. Amount: ${bridgedAmount}`,
+  )
+
+  const { result: swapResult } = await tradingSdk.getQuoteResults(swapParams, advancedSettings)
+
+  return { swapResult }
+}

packages/bridging/src/BridgingSdk/types.ts

@@ -38,6 +38,28 @@ export type GetQuoteWithBridgeParams = {
   allowIntermediateEqSellToken?: boolean
 }
 
+export type GetQuoteWithBridgeThenSwapParams = {
+  /**
+   * Overall request for the bridge-then-swap operation.
+   */
+  swapAndBridgeRequest: QuoteBridgeRequest
+
+  /**
+   * Advanced settings for the destination swap.
+   */
+  advancedSettings?: SwapAdvancedSettings
+
+  /**
+   * Trading SDK.
+   */
+  tradingSdk: TradingSdk
+
+  /**
+   * Cache for intermediate tokens.
+   */
+  intermediateTokensCache?: TTLCache<TokenInfo[]>
+}
+
 export type BridgingSdkConfig = Required<Omit<BridgingSdkOptions, 'enableLogging' | 'cacheConfig'>>
 
 /**

packages/bridging/src/index.ts

@@ -14,6 +14,12 @@ export type { AcrossQuoteResult, AcrossBridgeProviderOptions } from './providers
 export { BungeeBridgeProvider } from './providers/bungee/BungeeBridgeProvider'
 export type { BungeeQuoteResult, BungeeBridgeProviderOptions } from './providers/bungee/BungeeBridgeProvider'
 
+export { BungeeBridgeThenSwapProvider } from './providers/bungee/BungeeBridgeThenSwapProvider'
+export type {
+  BungeeBridgeThenSwapQuoteResult,
+  BungeeBridgeThenSwapProviderOptions,
+} from './providers/bungee/BungeeBridgeThenSwapProvider'
+
 export { NearIntentsBridgeProvider } from './providers/near-intents/NearIntentsBridgeProvider'
 
 export type {