Merge branch 'redirect-deposit'

Author: dglowinski

src/swapService/config/mainnet.ts

@@ -6,6 +6,7 @@ import {
   StrategyERC4626Wrapper,
   StrategyIdleCDOTranche,
   StrategyMidas,
+  StrategyRedirectDepositWrapper,
   StrategyRepayWrapper,
 } from "../strategies"
 
@@ -22,6 +23,8 @@ const IDLEAATRANCHEFASANARA_MAINNET =
   "0x45054c6753b4Bce40C5d54418DabC20b070F85bE"
 const CUSDOUSDC_CURVELP_MAINNET = "0x90455bd11Ce8a67C57d467e634Dc142b8e4105Aa"
 
+const USUAL_USD0_VAULT_MAINNET = "0xd001f0a15D272542687b2677BA627f48A4333b5d"
+
 const mainnetRoutingConfig: ChainRoutingConfig = [
   // WRAPPERS
   {
@@ -125,7 +128,13 @@ const mainnetRoutingConfig: ChainRoutingConfig = [
     },
   },
   // FALLBACKS
-
+  // If exact out for Usual's USD0 repay doesn't work, over swap with deposit to escrow
+  {
+    strategy: StrategyRedirectDepositWrapper.name(),
+    match: {
+      repayVaults: [USUAL_USD0_VAULT_MAINNET],
+    },
+  },
   // Binary search overswap for target  debt
   {
     strategy: StrategyBalmySDK.name(),

src/swapService/interface.ts

@@ -71,6 +71,7 @@ export interface StrategyMatchConfig {
   isPendlePT?: boolean
   tokensInOrOut?: Address[]
   excludeTokensInOrOut?: Address[]
+  repayVaults?: Address[]
 }
 
 export interface RoutingItem {

src/swapService/runner.ts

@@ -58,7 +58,10 @@ export async function runPipeline(
     )
   }
 
-  // console.log('finalResult.response: ', JSON.stringify(finalResult.response, null, 2));
+  console.log(
+    "finalResult.response: ",
+    JSON.stringify(finalResult.response, null, 2),
+  )
   return finalResult.response
 }
 

src/swapService/strategies/index.ts

@@ -4,6 +4,7 @@ import { StrategyCurveLPNG } from "./strategyCurveLPNG"
 import { StrategyERC4626Wrapper } from "./strategyERC4626Wrapper"
 import { StrategyIdleCDOTranche } from "./strategyIdleCDOTranche"
 import { StrategyMidas } from "./strategyMidas"
+import { StrategyRedirectDepositWrapper } from "./strategyRedirectDepositWrapper"
 import { StrategyRepayWrapper } from "./strategyRepayWrapper"
 
 export {
@@ -14,6 +15,7 @@ export {
   StrategyERC4626Wrapper,
   StrategyIdleCDOTranche,
   StrategyCurveLPNG,
+  StrategyRedirectDepositWrapper,
 }
 
 export const strategies = {
@@ -24,4 +26,5 @@ export const strategies = {
   [StrategyERC4626Wrapper.name()]: StrategyERC4626Wrapper,
   [StrategyIdleCDOTranche.name()]: StrategyIdleCDOTranche,
   [StrategyCurveLPNG.name()]: StrategyCurveLPNG,
+  [StrategyRedirectDepositWrapper.name()]: StrategyRedirectDepositWrapper,
 }

src/swapService/strategies/strategyRedirectDepositWrapper.ts

@@ -0,0 +1,158 @@
+import { type Address, isAddressEqual, maxUint256 } from "viem"
+import { getRoutingConfig } from "../config"
+import { SwapperMode } from "../interface"
+import { runPipeline } from "../runner"
+import type { StrategyResult, SwapParams } from "../types"
+import {
+  adjustForInterest,
+  buildApiResponseSwap,
+  buildApiResponseVerifyDebtMax,
+  encodeDepositMulticallItem,
+  encodeRepayAndDepositMulticallItem,
+  encodeRepayMulticallItem,
+  encodeSwapMulticallItem,
+  matchParams,
+} from "../utils"
+
+const defaultConfig: {
+  supportedVaults: Array<{
+    chainId: number
+    vault: Address
+    asset: Address
+    assetDustEVault: Address
+  }>
+} = {
+  supportedVaults: [
+    {
+      chainId: 1,
+      vault: "0xd001f0a15D272542687b2677BA627f48A4333b5d",
+      asset: "0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5",
+      assetDustEVault: "0xB0465546E8D70E667d4a187F66eF959B1522cc77",
+    },
+  ],
+}
+
+// Wrapper which redirects deposit of over-swapped repay to vault other than the debt vault
+export class StrategyRedirectDepositWrapper {
+  static name() {
+    return "redirect_deposit_wrapper"
+  }
+  readonly match
+  readonly config
+
+  constructor(match = {}, config = defaultConfig) {
+    this.match = match
+    this.config = config
+  }
+
+  async supports(swapParams: SwapParams) {
+    return (
+      swapParams.swapperMode === SwapperMode.TARGET_DEBT &&
+      this.config.supportedVaults.some(
+        (v) =>
+          v.chainId === swapParams.chainId &&
+          isAddressEqual(v.vault, swapParams.receiver),
+      )
+    )
+  }
+
+  async findSwap(swapParams: SwapParams): Promise<StrategyResult> {
+    const result: StrategyResult = {
+      strategy: StrategyRedirectDepositWrapper.name(),
+      supports: await this.supports(swapParams),
+      match: matchParams(swapParams, this.match),
+    }
+
+    if (!result.supports || !result.match) return result
+
+    try {
+      const vaultData = this.getSupportedVault(swapParams.receiver)
+      // remove itself from the routing and run the pipeline, directing output to Swapper
+      const routing = getRoutingConfig(swapParams.chainId).filter(
+        (r) => r.strategy !== StrategyRedirectDepositWrapper.name(),
+      )
+
+      const innerSwapParams = {
+        ...swapParams,
+        receiver: swapParams.from,
+        routingOverride: routing,
+      }
+
+      const innerSwap = await runPipeline(innerSwapParams)
+
+      // split target debt repay into swap to Swapper, repay and deposit into escrow vault
+
+      const newMulticallItems = innerSwap.swap.multicallItems.flatMap(
+        (item) => {
+          if (
+            item.functionName === "swap" &&
+            item.args[0].mode === String(SwapperMode.TARGET_DEBT)
+          ) {
+            const exactInSwapItemArgs = {
+              ...item.args[0],
+              mode: SwapperMode.EXACT_IN,
+            }
+
+            console.log("exactInSwapItemArgs: ", exactInSwapItemArgs)
+            const swapItem = encodeSwapMulticallItem(exactInSwapItemArgs)
+            // if target debt is 0, encode repay(max) to repay all debt, otherwise use all of the available Swapper balance
+            const repayAmount =
+              swapParams.targetDebt === 0n ? maxUint256 : maxUint256 - 1n
+            console.log("repayAmount: ", repayAmount === maxUint256)
+            const repayItem = encodeRepayMulticallItem(
+              vaultData.asset,
+              swapParams.receiver,
+              repayAmount,
+              swapParams.accountOut,
+            )
+            const depositItem = encodeDepositMulticallItem(
+              vaultData.asset,
+              vaultData.assetDustEVault,
+              5n,
+              swapParams.accountOut,
+            )
+
+            return [swapItem, repayItem, depositItem]
+          }
+          return item
+        },
+      )
+
+      // reencode everything
+
+      const swap = buildApiResponseSwap(swapParams.from, newMulticallItems)
+
+      let debtMax = swapParams.currentDebt - BigInt(innerSwap.amountOutMin)
+      if (debtMax < 0n) debtMax = 0n
+      debtMax = adjustForInterest(debtMax)
+
+      const verify = buildApiResponseVerifyDebtMax(
+        swapParams.chainId,
+        swapParams.receiver,
+        swapParams.accountOut,
+        debtMax,
+        swapParams.deadline,
+      )
+      console.log("swapParams.deadline: ", swapParams.deadline)
+
+      result.response = {
+        ...innerSwap,
+        swap,
+        verify,
+      }
+    } catch (error) {
+      result.error = error
+    }
+
+    return result
+  }
+
+  getSupportedVault(vault: Address) {
+    const supportedVault = this.config.supportedVaults.find((v) =>
+      isAddressEqual(v.vault, vault),
+    )
+    if (!supportedVault) throw new Error("Vault not supported")
+
+    return supportedVault
+  }
+}

src/swapService/utils.ts

@@ -83,6 +83,15 @@ export function matchParams(
     )
       return false
   }
+  if (match.repayVaults) {
+    if (
+      !swapParams.isRepay ||
+      !match.repayVaults.some((vault: Hex) => {
+        return isAddressEqual(swapParams.receiver, vault)
+      })
+    )
+      return false
+  }
 
   return true
 }
@@ -356,6 +365,23 @@ export const encodeRepayAndDepositMulticallItem = (
   }
 }
 
+export const encodeRepayMulticallItem = (
+  token: Address,
+  vault: Address,
+  repayAmount: bigint,
+  account: Address,
+): SwapApiResponseMulticallItem => {
+  return {
+    functionName: "repay",
+    args: [token, vault, String(repayAmount), account],
+    data: encodeFunctionData({
+      abi: contractBook.swapper.abi,
+      functionName: "repay",
+      args: [token, vault, repayAmount, account],
+    }),
+  }
+}
+
 export const encodeApproveMulticallItem = (
   token: Address,
   spender: Address,