@paraswap/dex-lib 2.50.5 → 2.50.6-sdai

package/src/dex/sdai/sdai-events.test.ts

@@ -0,0 +1,105 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { SDaiEventPool } from './sdai-pool';
+import { SDaiConfig } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { SDaiPoolState } from './types';
+
+import PotAbi from '../../abi/maker-psm/pot.json';
+import { Interface } from '@ethersproject/abi';
+import _ from 'lodash';
+
+/*
+  README
+  ======
+
+  This test script adds unit tests for SDai event based
+  system. This is done by fetching the state on-chain before the
+  event block, manually pushing the block logs to the event-subscriber,
+  comparing the local state with on-chain state.
+
+  Most of the logic for testing is abstracted by `testEventSubscriber`.
+  You need to do two things to make the tests work:
+
+  1. Fetch the block numbers where certain events were released. You
+  can modify the `./scripts/fetch-event-blocknumber.ts` to get the
+  block numbers for different events. Make sure to get sufficient
+  number of blockNumbers to cover all possible cases for the event
+  mutations.
+
+  2. Complete the implementation for fetchPoolState function. The
+  function should fetch the on-chain state of the event subscriber
+  using just the blocknumber.
+
+  The template tests only include the test for a single event
+  subscriber. There can be cases where multiple event subscribers
+  exist for a single DEX. In such cases additional tests should be
+  added.
+
+  You can run this individual test script by running:
+  `npx jest src/dex/<dex-name>/<dex-name>-events.test.ts`
+
+  (This comment should be removed from the final implementation)
+*/
+
+jest.setTimeout(50 * 1000);
+const dexKey = 'SDai';
+const network = Network.MAINNET;
+
+async function fetchPoolState(
+  sdaiPool: SDaiEventPool,
+  blockNumber: number,
+): Promise<SDaiPoolState> {
+  return sdaiPool.generateState(blockNumber);
+}
+
+describe('SDai Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    drip: [19827559, 19827524, 19827163, 19827124, 19827000, 19826892],
+    // TODO: no matching logs, you have to manually call "file"
+    // from "0xbe8e3e3618f7474f8cb1d074a26affef007e98fb" address
+    // https://etherscan.io/advanced-filter?fadd=0x197e90f9fad81970ba7976f33cbd77088e5d7cf7&tadd=0x197e90f9fad81970ba7976f33cbd77088e5d7cf7&mtd=0x29ae8114%7eFile
+    // file: [19831086]
+  };
+
+  const addresses: { [contract: string]: string } = {
+    potAddress: SDaiConfig[dexKey][network].potAddress,
+  };
+
+  describe('SDaiPool', function () {
+    Object.keys(blockNumbers).forEach((event: string) => {
+      blockNumbers[event].forEach((blockNumber: number) => {
+        it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+          const dexHelper = new DummyDexHelper(network);
+          const logger = dexHelper.getLogger(dexKey);
+
+          const sdaiPool = new SDaiEventPool(
+            dexKey,
+            dexHelper,
+            addresses.potAddress,
+            new Interface(PotAbi),
+            logger,
+          );
+
+          await sdaiPool.initialize(blockNumber);
+
+          await testEventSubscriber(
+            sdaiPool,
+            sdaiPool.addressesSubscribed,
+            (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${sdaiPool}`,
+            dexHelper.provider,
+            (state, expected) => {
+              // TODO:
+              expect(_.omit(state, ['chi'])).toEqual(_.omit(expected, ['chi']));
+            },
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/sdai/sdai-integration.test.ts

@@ -0,0 +1,148 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { BI_POWS } from '../../bigint-constants';
+import { SDai } from './sdai';
+
+const network = Network.MAINNET;
+
+const SDaiSymbol = 'sDAI';
+const SDaiToken = Tokens[network][SDaiSymbol];
+
+const DaiSymbol = 'DAI';
+const DaiToken = Tokens[network][DaiSymbol];
+
+const amounts = [0n, BI_POWS[18], 2000000000000000000n];
+
+const dexKey = 'SDai';
+const dexHelper = new DummyDexHelper(network);
+let blocknumber: number;
+let sdai: SDai;
+
+describe('SDai', function () {
+  beforeAll(async () => {
+    blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    sdai = new SDai(network, dexKey, dexHelper);
+    if (sdai.initializePricing) {
+      await sdai.initializePricing(blocknumber);
+    }
+  });
+
+  it('getPoolIdentifiers and getPricesVolume DAI -> sDAI SELL', async function () {
+    const pools = await sdai.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sdai.getPricesVolume(
+      DaiToken,
+      SDaiToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume sDAI -> DAI SELL', async function () {
+    const pools = await sdai.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sdai.getPricesVolume(
+      SDaiToken,
+      DaiToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume DAI -> sDAI BUY', async function () {
+    const pools = await sdai.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sdai.getPricesVolume(
+      DaiToken,
+      SDaiToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume sDAI -> DAI BUY', async function () {
+    const pools = await sdai.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sdai.getPricesVolume(
+      SDaiToken,
+      DaiToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+  });
+
+  it('Dai getTopPoolsForToken', async function () {
+    const poolLiquidity = await sdai.getTopPoolsForToken(DaiToken.address, 10);
+    console.log(`${DaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, DaiToken.address, dexKey);
+  });
+
+  it('SDai getTopPoolsForToken', async function () {
+    const poolLiquidity = await sdai.getTopPoolsForToken(SDaiToken.address, 10);
+    console.log(`${SDaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, SDaiToken.address, dexKey);
+  });
+});

package/src/dex/sdai/sdai-pool.ts

@@ -0,0 +1,113 @@
+import { BI_POWS } from '../../bigint-constants';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Interface } from '@ethersproject/abi';
+
+import type { IDexHelper } from '../../dex-helper';
+import type { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import type { Address, BlockHeader, Log, Logger } from '../../types';
+import type { SDaiPoolState } from './types';
+import { getOnChainState } from './utils';
+
+const RAY = BI_POWS[27];
+const ZERO = BigInt(0);
+const TWO = BigInt(2);
+const HALF = RAY / TWO;
+
+// function file(bytes32,uint256)
+const FILE_TOPICHASH = `0x29ae811400000000000000000000000000000000000000000000000000000000`;
+// function drip()
+const DRIP_TOPICHASH = `0x9f678cca00000000000000000000000000000000000000000000000000000000`;
+// function cage()
+const CAGE_TOPICHASH = `0x6924500900000000000000000000000000000000000000000000000000000000`;
+// bytes32 repr of "dsr" string
+const DSR_TOPIC = `0x6473720000000000000000000000000000000000000000000000000000000000`;
+
+const rpow = (x: bigint, n: bigint): bigint => {
+  if (!x && !n) return RAY;
+  if (!x) return ZERO;
+
+  let z = n % TWO > ZERO ? x : RAY;
+
+  for (n = n / TWO; n; n /= TWO) {
+    x = (x * x + HALF) / RAY;
+    if (n % TWO > ZERO) {
+      z = (z * x + HALF) / RAY;
+    }
+  }
+
+  return z;
+};
+
+const calcChi = (state: SDaiPoolState, currentTimestamp?: number) => {
+  currentTimestamp ||= Math.floor(Date.now() / 1000);
+  if (!state.live) return RAY;
+
+  const { dsr: dsr_, chi: chi_, rho: rho_ } = state;
+  const now = BigInt(currentTimestamp);
+  const rho = BigInt(rho_);
+  const dsr = BigInt(dsr_);
+  const chi = BigInt(chi_);
+
+  return now > rho ? (rpow(dsr, now - rho) * chi) / RAY : chi;
+};
+
+export class SDaiEventPool extends StatefulEventSubscriber<SDaiPoolState> {
+  constructor(
+    parentName: string,
+    protected dexHelper: IDexHelper,
+    private potAddress: Address,
+    private potInterface: Interface,
+    logger: Logger,
+  ) {
+    super(parentName, 'sdai', dexHelper, logger);
+    this.addressesSubscribed = [potAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<SDaiPoolState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): AsyncOrSync<DeepReadonly<SDaiPoolState> | null> {
+    if (log.topics[0] === FILE_TOPICHASH && log.topics[2] === DSR_TOPIC) {
+      return {
+        ...state,
+        dsr: BigInt(log.topics[3]).toString(),
+      };
+    }
+
+    if (log.topics[0] === DRIP_TOPICHASH) {
+      return {
+        ...state,
+        rho: blockHeader.timestamp.toString(),
+        chi: calcChi(state, +blockHeader.timestamp).toString(),
+      };
+    }
+
+    return null;
+  }
+
+  async generateState(
+    blockNumber: number | 'latest' = 'latest',
+  ): Promise<DeepReadonly<SDaiPoolState>> {
+    return getOnChainState(
+      this.dexHelper.multiContract,
+      this.potAddress,
+      this.potInterface,
+      blockNumber,
+    );
+  }
+
+  convertToSDai(daiAmount: bigint, blockNumber: number): bigint {
+    const state = this.getState(blockNumber);
+    if (!state) throw new Error(`SDai state at ${blockNumber} does not exists`);
+
+    return (daiAmount * RAY) / calcChi(state);
+  }
+
+  convertToDai(sdaiAmount: bigint, blockNumber: number): bigint {
+    const state = this.getState(blockNumber);
+    if (!state) throw new Error(`SDai state at ${blockNumber} does not exists`);
+
+    return (sdaiAmount * calcChi(state)) / RAY;
+  }
+}

package/src/dex/sdai/sdai.ts

@@ -0,0 +1,233 @@
+import { SimpleExchange } from '../simple-exchange';
+import { IDex } from '../idex';
+import { SDaiParams, SDaiData, SDaiFunctions } from './types';
+import { Network, SwapSide } from '../../constants';
+import { getDexKeysWithNetwork } from '../../utils';
+import { Adapters, SDaiConfig } from './config';
+import {
+  AdapterExchangeParam,
+  Address,
+  ExchangePrices,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  SimpleExchangeParam,
+  Token,
+} from '../../types';
+import { IDexHelper } from '../../dex-helper';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import PotAbi from '../../abi/maker-psm/pot.json';
+import SavingsDaiAbi from '../../abi/sdai/SavingsDai.abi.json';
+import { Interface } from 'ethers/lib/utils';
+import { SDaiEventPool } from './sdai-pool';
+import { BI_POWS } from '../../bigint-constants';
+import { SDAI_DEPOSIT_GAS_COST, SDAI_REDEEM_GAS_COST } from './constants';
+
+export class SDai extends SimpleExchange implements IDex<SDaiData, SDaiParams> {
+  readonly hasConstantPriceLargeAmounts = true;
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(SDaiConfig);
+
+  public readonly eventPool: SDaiEventPool;
+  logger: Logger;
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+
+    readonly daiAddress: string = SDaiConfig[dexKey][network].daiAddress,
+    readonly sdaiAddress: string = SDaiConfig[dexKey][network].sdaiAddress,
+    readonly potAddress: string = SDaiConfig[dexKey][network].potAddress,
+
+    protected adapters = Adapters[network] || {},
+    protected sdaiInterface = new Interface(SavingsDaiAbi),
+    protected potInterface = new Interface(PotAbi),
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+    this.eventPool = new SDaiEventPool(
+      this.dexKey,
+      dexHelper,
+      this.potAddress,
+      this.potInterface,
+      this.logger,
+    );
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters[side] || null;
+  }
+
+  isSDai(tokenAddress: Address) {
+    return this.sdaiAddress.toLowerCase() === tokenAddress.toLowerCase();
+  }
+
+  isDai(tokenAddress: Address) {
+    return this.daiAddress.toLowerCase() === tokenAddress.toLowerCase();
+  }
+
+  isAppropriatePair(srcToken: Token, destToken: Token) {
+    return (
+      (this.isDai(srcToken.address) && this.isSDai(destToken.address)) ||
+      (this.isDai(destToken.address) && this.isSDai(srcToken.address))
+    );
+  }
+
+  async initializePricing(blockNumber: number) {
+    await this.eventPool.initialize(blockNumber);
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    return this.isAppropriatePair(srcToken, destToken)
+      ? [`${this.dexKey}_${this.sdaiAddress}`]
+      : [];
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<SDaiData>> {
+    if (!this.isAppropriatePair(srcToken, destToken)) return null;
+    if (!this.eventPool.getState(blockNumber)) return null;
+
+    if (side === SwapSide.SELL) {
+      const calcSellFn = (blockNumber: number, amountIn: bigint) =>
+        this.isDai(srcToken.address)
+          ? this.eventPool.convertToSDai(amountIn, blockNumber)
+          : this.eventPool.convertToDai(amountIn, blockNumber);
+
+      return [
+        {
+          prices: amounts.map(amount => calcSellFn(blockNumber, amount)),
+          unit: calcSellFn(blockNumber, BI_POWS[18]),
+          gasCost: SDAI_DEPOSIT_GAS_COST,
+          exchange: this.dexKey,
+          data: { exchange: `${this.sdaiAddress}` },
+          poolAddresses: [`${this.sdaiAddress}`],
+        },
+      ];
+    } else {
+      const calcBuyFn = (blockNumber: number, amountIn: bigint) =>
+        this.isDai(srcToken.address)
+          ? this.eventPool.convertToDai(amountIn, blockNumber)
+          : this.eventPool.convertToSDai(amountIn, blockNumber);
+
+      return [
+        {
+          prices: amounts.map(amount => calcBuyFn(blockNumber, amount)),
+          unit: calcBuyFn(blockNumber, BI_POWS[18]),
+          gasCost: SDAI_REDEEM_GAS_COST,
+          exchange: this.dexKey,
+          data: { exchange: `${this.sdaiAddress}` },
+          poolAddresses: [`${this.sdaiAddress}`],
+        },
+      ];
+    }
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(poolPrices: PoolPrices<SDaiData>): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    if (!this.isDai(tokenAddress) && !this.isSDai(tokenAddress)) return [];
+
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.sdaiAddress,
+        connectorTokens: [
+          {
+            decimals: 18,
+            address: this.isDai(tokenAddress)
+              ? this.sdaiAddress
+              : this.daiAddress,
+          },
+        ],
+        liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+      },
+    ];
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: SDaiData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const isSell = side === SwapSide.SELL;
+    const { exchange } = data;
+
+    let swapData: string;
+    if (this.isDai(srcToken)) {
+      swapData = this.sdaiInterface.encodeFunctionData(
+        isSell ? SDaiFunctions.deposit : SDaiFunctions.mint,
+        [isSell ? srcAmount : destAmount, this.augustusAddress],
+      );
+    } else {
+      swapData = this.sdaiInterface.encodeFunctionData(
+        isSell ? SDaiFunctions.redeem : SDaiFunctions.withdraw,
+        [
+          isSell ? srcAmount : destAmount,
+          this.augustusAddress,
+          this.augustusAddress,
+        ],
+      );
+    }
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      exchange,
+    );
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: SDaiData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { exchange } = data;
+
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          toStaked: 'bool',
+        },
+      },
+      {
+        toStaked: this.isDai(srcToken),
+      },
+    );
+
+    return {
+      targetExchange: exchange,
+      payload,
+      networkFee: '0',
+    };
+  }
+}

package/src/dex/sdai/types.ts

@@ -0,0 +1,23 @@
+import { Address } from '../../types';
+
+export type SDaiData = { exchange: Address };
+
+export type SDaiParams = {
+  sdaiAddress: Address;
+  daiAddress: Address;
+  potAddress: Address;
+};
+
+export enum SDaiFunctions {
+  deposit = 'deposit',
+  redeem = 'redeem',
+  withdraw = 'withdraw',
+  mint = 'mint',
+}
+
+export type SDaiPoolState = {
+  rho: string;
+  chi: string;
+  dsr: string;
+  live: boolean;
+};

package/src/dex/sdai/utils.ts

@@ -0,0 +1,48 @@
+import { Contract } from 'web3-eth-contract';
+import { SDaiPoolState } from './types';
+import { Interface, AbiCoder } from '@ethersproject/abi';
+import { currentBigIntTimestampInS } from '../../utils';
+
+const coder = new AbiCoder();
+
+// - `dsr`: the Dai Savings Rate
+// - `chi`: the Rate Accumulator
+// - `rho`: time of last drip
+export async function getOnChainState(
+  multiContract: Contract,
+  potAddress: string,
+  potInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<SDaiPoolState> {
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate([
+      {
+        target: potAddress,
+        callData: potInterface.encodeFunctionData('dsr', []),
+      },
+      {
+        target: potAddress,
+        callData: potInterface.encodeFunctionData('chi', []),
+      },
+      {
+        target: potAddress,
+        callData: potInterface.encodeFunctionData('rho', []),
+      },
+      {
+        target: potAddress,
+        callData: potInterface.encodeFunctionData('live', []),
+      },
+    ])
+    .call({}, blockNumber);
+
+  const [dsr, chi, rho, live] = data.returnData.map(item =>
+    coder.decode(['uint256'], item)[0].toString(),
+  );
+
+  return {
+    live: !!live,
+    dsr,
+    chi,
+    rho,
+  };
+}

package/src/dex/woo-fi-v2/config.ts

@@ -15,8 +15,8 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
       },
     },
     [Network.BSC]: {
-      wooPPV2Address: '0xEd9e3f98bBed560e66B89AaC922E29D4596A9642',
-      wooOracleV2Address: '0x2A375567f5E13F6bd74fDa7627Df3b1Af6BfA5a6',
+      wooPPV2Address: '0x59dE3B49314Bf5067719364A2Cb43e8525ab93FA',
+      wooOracleV2Address: '0x72dc7fa5eeb901a34173C874A7333c8d1b34bca9',
       integrationHelperAddress: '0xAA9c15cd603428cA8ddD45e933F8EfE3Afbcc173',
       // USDT
       quoteToken: {
@@ -55,8 +55,8 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
       },
     },
     [Network.AVALANCHE]: {
-      wooPPV2Address: '0xEd9e3f98bBed560e66B89AaC922E29D4596A9642',
-      wooOracleV2Address: '0x2A375567f5E13F6bd74fDa7627Df3b1Af6BfA5a6',
+      wooPPV2Address: '0x3b3E4b4741e91aF52d0e9ad8660573E951c88524',
+      wooOracleV2Address: '0xc13843aE0D2C5ca9E0EfB93a78828446D8173d19',
       integrationHelperAddress: '0x020630613E296c3E9b06186f630D1bF97A2B6Ad1',
       // USDC
       quoteToken: {