@paraswap/dex-lib 3.8.35 → 3.8.36-usual

package/src/dex/index.ts

@@ -88,6 +88,7 @@ import { ConcentratorArusd } from './concentrator-arusd/concentrator-arusd';
 import { FxProtocolRusd } from './fx-protocol-rusd/fx-protocol-rusd';
 import { AaveGsm } from './aave-gsm/aave-gsm';
 import { LitePsm } from './lite-psm/lite-psm';
+import { UsualBond } from './usual-bond/usual-bond';
 import { StkGHO } from './stkgho/stkgho';
 import { SkyConverter } from './sky-converter/sky-converter';
 
@@ -173,6 +174,7 @@ const Dexes = [
   FxProtocolRusd,
   AaveGsm,
   LitePsm,
+  UsualBond,
   StkGHO,
   SkyConverter,
 ];

package/src/dex/lite-psm/config.ts

@@ -10,6 +10,11 @@ export const LitePsmConfig: DexConfigMap<DexParams> = {
         address: '0x6b175474e89094c44da98b954eedeac495271d0f',
         decimals: 18,
       },
+      usds: {
+        address: '0xdc035d45d973e3ec169d2276ddab16f1e407384f',
+        decimals: 18,
+      },
+      usdsPsmAddress: '0xA188EEC8F81263234dA3622A406892F3D630f98c',
       vatAddress: '0x35d1b3f3d7966a1dfe207aa4514c12a259a0492b',
       pools: [
         {
@@ -17,7 +22,6 @@ export const LitePsmConfig: DexConfigMap<DexParams> = {
             address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
             decimals: 6,
           },
-          gemJoinAddress: '0xf6e72db5454dd049d0788e411b06cfaf16853042', // Same as psmAddress. LitePsm does not have an external gem join.
           pocketAddress: '0x37305b1cd40574e4c5ce33f8e8306be057fd7341',
           psmAddress: '0xf6e72db5454dd049d0788e411b06cfaf16853042',
           identifier:

package/src/dex/lite-psm/lite-psm-e2e.test.ts

@@ -10,7 +10,7 @@ import { generateConfig } from '../../config';
 describe('LitePsm E2E', () => {
   const dexKey = 'LitePsm';
 
-  describe('LitePsm MAINNET_V6', () => {
+  describe('LitePsm DAI', () => {
     const network = Network.MAINNET;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -76,4 +76,71 @@ describe('LitePsm E2E', () => {
       }),
     );
   });
+
+  describe('LitePsm USDS', () => {
+    const network = Network.MAINNET;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'USDS';
+
+    const tokenAAmount: string = '10000000';
+    const tokenBAmount: string = '10000000000000000';
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.swapExactAmountIn,
+          ContractMethod.swapExactAmountInOutOnMakerPSM,
+        ],
+      ],
+      [
+        SwapSide.BUY,
+        [
+          ContractMethod.swapExactAmountOut,
+          ContractMethod.swapExactAmountInOutOnMakerPSM,
+        ],
+      ],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        describe(`${contractMethod}`, () => {
+          it(`${side}:${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[tokenBSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+
+          it(`${side}:${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+            await testE2E(
+              tokens[tokenBSymbol],
+              tokens[tokenASymbol],
+              holders[tokenBSymbol],
+              side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+        });
+      }),
+    );
+  });
 });

package/src/dex/lite-psm/lite-psm.ts

@@ -4,9 +4,7 @@ import {
   Address,
   ExchangePrices,
   PoolPrices,
-  Log,
   AdapterExchangeParam,
-  SimpleExchangeParam,
   PoolLiquidity,
   Logger,
   NumberAsString,
@@ -32,7 +30,8 @@ import {
 } from './types';
 import { SimpleExchange } from '../simple-exchange';
 import { LitePsmConfig } from './config';
-import PsmABI from '../../abi/lite-psm/psm.json';
+import DaiPsmABI from '../../abi/lite-psm/psm.json';
+import UsdsPsmABI from '../../abi/lite-psm/usdsPsm.json';
 import { BI_POWS } from '../../bigint-constants';
 import { SpecialDex } from '../../executor/types';
 import { hexConcat, hexZeroPad, hexlify } from '@ethersproject/bytes';
@@ -45,7 +44,8 @@ import { BigNumber } from 'ethers';
 import { LitePsmEventPool, getOnChainState } from './lite-psm-event-pool';
 import { extractReturnAmountPosition } from '../../executor/utils';
 
-const psmInterface = new Interface(PsmABI);
+const daiPsmInterface = new Interface(DaiPsmABI);
+const usdsPsmInterface = new Interface(UsdsPsmABI);
 const WAD = BI_POWS[18];
 
 const ceilDiv = (a: bigint, b: bigint) => (a + b - 1n) / b;
@@ -70,6 +70,8 @@ export class LitePsm
     dexKey: string,
     protected dexHelper: IDexHelper,
     protected dai: Token = LitePsmConfig[dexKey][network].dai,
+    protected usds: Token = LitePsmConfig[dexKey][network].usds,
+    protected usdsPsm: Address = LitePsmConfig[dexKey][network].usdsPsmAddress,
     protected vatAddress: Address = LitePsmConfig[dexKey][network].vatAddress,
     protected poolConfigs: PoolConfig[] = LitePsmConfig[dexKey][network].pools,
   ) {
@@ -123,6 +125,8 @@ export class LitePsm
     return (
       (srcAddress === this.dai.address && this.eventPools[destAddress]) ||
       (destAddress === this.dai.address && this.eventPools[srcAddress]) ||
+      (srcAddress === this.usds.address && this.eventPools[destAddress]) ||
+      (destAddress === this.usds.address && this.eventPools[srcAddress]) ||
       null
     );
   }
@@ -153,7 +157,7 @@ export class LitePsm
   }
 
   computePrices(
-    isSrcDai: boolean,
+    isDestGem: boolean,
     to18ConversionFactor: bigint,
     side: SwapSide,
     amounts: bigint[],
@@ -168,7 +172,7 @@ export class LitePsm
 
     return amounts.map(a => {
       if (side === SwapSide.SELL) {
-        if (isSrcDai) {
+        if (isDestGem) {
           const gemAmt18 = (a * WAD) / (WAD + poolState.tout);
           if (buyGemCheck(gemAmt18)) return gemAmt18 / to18ConversionFactor;
         } else {
@@ -177,7 +181,7 @@ export class LitePsm
             return gemAmt18 - (gemAmt18 * poolState.tin) / WAD;
         }
       } else {
-        if (isSrcDai) {
+        if (isDestGem) {
           const gemAmt18 = to18ConversionFactor * a;
           if (buyGemCheck(gemAmt18))
             return gemAmt18 + (gemAmt18 * poolState.tout) / WAD;
@@ -214,33 +218,39 @@ export class LitePsm
       (side === SwapSide.SELL ? srcToken : destToken).decimals,
     );
 
-    const isSrcDai = srcToken.address.toLowerCase() === this.dai.address;
-    const gem = isSrcDai ? destToken : srcToken;
+    const srcLower = srcToken.address.toLowerCase();
+    const isSrcDai = srcLower === this.dai.address;
+    const isDaiSwap =
+      isSrcDai || destToken.address.toLowerCase() === this.dai.address;
+
+    const isDestGem = isSrcDai || srcLower === this.usds.address;
+
+    const gem = isDestGem ? destToken : srcToken;
     const toll =
-      (side === SwapSide.SELL && isSrcDai) ||
-      (side === SwapSide.BUY && !isSrcDai)
+      (side === SwapSide.SELL && isDestGem) ||
+      (side === SwapSide.BUY && !isDestGem)
         ? poolState.tout
         : poolState.tin;
 
     const [unit, ...prices] = this.computePrices(
-      isSrcDai,
+      isDestGem,
       eventPool.to18ConversionFactor,
       side,
       [unitVolume, ...amounts],
       poolState,
     );
 
+    const psm = isDaiSwap ? eventPool.poolConfig.psmAddress : this.usdsPsm;
     return [
       {
         prices,
         unit,
         data: {
           toll: toll.toString(),
-          psmAddress: eventPool.poolConfig.psmAddress,
-          gemJoinAddress: eventPool.poolConfig.gemJoinAddress,
+          psmAddress: psm,
           gemDecimals: gem.decimals,
         },
-        poolAddresses: [eventPool.poolConfig.psmAddress],
+        poolAddresses: [psm],
         exchange: this.dexKey,
         gasCost: 50000,
         poolIdentifier,
@@ -270,10 +280,12 @@ export class LitePsm
     data: LitePsmData,
     side: SwapSide,
   ): { isGemSell: boolean; gemAmount: string } {
-    const isSrcDai = srcToken.toLowerCase() === this.dai.address;
+    const isDestGem =
+      srcToken.toLowerCase() === this.dai.address ||
+      srcToken.toLowerCase() === this.usds.address;
     const to18ConversionFactor = getBigIntPow(18 - data.gemDecimals);
     if (side === SwapSide.SELL) {
-      if (isSrcDai) {
+      if (isDestGem) {
         const gemAmt18 = (BigInt(srcAmount) * WAD) / (WAD + BigInt(data.toll));
         return {
           isGemSell: false,
@@ -283,7 +295,7 @@ export class LitePsm
         return { isGemSell: true, gemAmount: srcAmount };
       }
     } else {
-      if (isSrcDai) {
+      if (isDestGem) {
         return { isGemSell: false, gemAmount: destAmount };
       } else {
         const gemAmt = ceilDiv(
@@ -338,9 +350,7 @@ export class LitePsm
       isApproved = await this.dexHelper.augustusApprovals.hasApproval(
         options.executionContractAddress,
         srcToken.address,
-        srcToken.address.toLowerCase() === this.dai.address.toLowerCase()
-          ? optimalSwapExchange.data.psmAddress
-          : optimalSwapExchange.data.gemJoinAddress,
+        optimalSwapExchange.data.psmAddress,
       );
     }
 
@@ -370,10 +380,16 @@ export class LitePsm
       side,
     );
 
-    let exchangeData = psmInterface.encodeFunctionData(
-      isGemSell ? 'sellGem' : 'buyGem',
-      [recipient, gemAmount],
-    );
+    const isDaiSwap =
+      destToken.toLowerCase() === this.dai.address ||
+      srcToken.toLowerCase() === this.dai.address;
+
+    let exchangeData = (
+      isDaiSwap ? daiPsmInterface : usdsPsmInterface
+    ).encodeFunctionData(isGemSell ? 'sellGem' : 'buyGem', [
+      recipient,
+      gemAmount,
+    ]);
 
     // append toll and to18ConversionFactor & set specialDexFlag = SWAP_ON_MAKER_PSM to
     // - `buyGem` on Ex1 & Ex2
@@ -397,10 +413,14 @@ export class LitePsm
       exchangeData,
       targetExchange: data.psmAddress,
       specialDexFlag,
-      spender: isGemSell ? data.gemJoinAddress : data.psmAddress,
+      spender: data.psmAddress, // psm is the join for both dai and usds
       returnAmountPos:
         side === SwapSide.SELL && isGemSell
-          ? extractReturnAmountPosition(psmInterface, 'sellGem', 'daiOutWad')
+          ? extractReturnAmountPosition(
+              isDaiSwap ? daiPsmInterface : usdsPsmInterface,
+              'sellGem',
+              isDaiSwap ? 'daiOutWad' : 'usdsOutWad',
+            )
           : undefined,
     };
   }
@@ -453,7 +473,7 @@ export class LitePsm
       data.toll,
       to18ConversionFactor.toString(),
       data.psmAddress,
-      data.gemJoinAddress,
+      data.psmAddress,
       metadata,
       beneficiaryDirectionApproveFlag.toString(),
     ];
@@ -492,9 +512,10 @@ export class LitePsm
       );
     };
 
-    const isDai = _tokenAddress === this.dai.address;
+    const isDaiOrUsds =
+      _tokenAddress === this.dai.address || _tokenAddress === this.usds.address;
 
-    const validPoolConfigs = isDai
+    const validPoolConfigs = isDaiOrUsds
       ? this.poolConfigs
       : this.eventPools[_tokenAddress]
       ? [this.eventPools[_tokenAddress].poolConfig]
@@ -513,7 +534,7 @@ export class LitePsm
       exchange: this.dexKey,
       address: p.psmAddress,
       liquidityUSD: minLiq(poolStates[i], p.gem.decimals),
-      connectorTokens: [isDai ? p.gem : this.dai],
+      connectorTokens: isDaiOrUsds ? [p.gem] : [this.dai, this.usds],
     }));
   }
 }

package/src/dex/lite-psm/types.ts

@@ -10,7 +10,6 @@ export type PoolState = {
 
 export type LitePsmData = {
   psmAddress: Address;
-  gemJoinAddress: Address;
   gemDecimals: number;
   toll: string;
   isApproved?: boolean;
@@ -18,7 +17,6 @@ export type LitePsmData = {
 
 export type PoolConfig = {
   gem: Token;
-  gemJoinAddress: Address; // dai liquidity
   pocketAddress: Address; // gem liquidity
   psmAddress: Address;
   identifier: string; // bytes32 of pool identifier (Eg. bytes32("PSM-USDC-A"))
@@ -26,6 +24,8 @@ export type PoolConfig = {
 
 export type DexParams = {
   dai: Token;
+  usds: Token;
+  usdsPsmAddress: Address;
   vatAddress: Address;
   pools: PoolConfig[];
 };
@@ -38,6 +38,7 @@ export type LitePsmParams = [
   toll: NumberAsString,
   to18ConversionFactor: NumberAsString,
   exchange: Address,
+  // psm (exchange) is the join for both dai and usds
   gemJoinAddress: Address,
   metadata: string,
   beneficiaryDirectionApproveFlag: NumberAsString,

package/src/dex/usual-bond/config.ts

@@ -0,0 +1,12 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+export const UsualBondConfig: DexConfigMap<DexParams> = {
+  UsualBond: {
+    [Network.MAINNET]: {
+      usd0Address: '0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5',
+      usd0ppAddress: '0x35D8949372D46B7a3D5A56006AE77B215fc69bC0',
+    },
+  },
+};

package/src/dex/usual-bond/types.ts

@@ -0,0 +1,10 @@
+import { Address } from '../../types';
+
+export type PoolState = {};
+
+export type UsualBondData = {};
+
+export type DexParams = {
+  usd0Address: Address;
+  usd0ppAddress: Address;
+};

package/src/dex/usual-bond/usual-bond-e2e.test.ts

@@ -0,0 +1,81 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('UsualBond E2E', () => {
+  const dexKey = 'UsualBond';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'USD0';
+    const tokenBSymbol: string = 'USD0++';
+
+    const tokenAAmount: string = '100000';
+    const tokenBAmount: string = '100000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});

package/src/dex/usual-bond/usual-bond-integration.test.ts

@@ -0,0 +1,106 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Interface } from '@ethersproject/abi';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { UsualBond } from './usual-bond';
+import { checkPoolPrices, checkConstantPoolPrices } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+
+async function testPricingOnNetwork(
+  usualBond: UsualBond,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenAddress: string,
+  destTokenAddress: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  console.log(amounts);
+
+  const pools = await usualBond.getPoolIdentifiers(
+    networkTokens['USD0'],
+    networkTokens['USD0++'],
+    side,
+    blockNumber,
+  );
+  console.log(`${'USD0'} <> ${'USD0++'} Pool Identifiers: `, pools);
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await usualBond.getPricesVolume(
+    networkTokens['USD0'],
+    networkTokens['USD0++'],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(`${'USD0'} <> ${'USD0++'} Pool Prices: `, poolPrices);
+
+  expect(poolPrices).not.toBeNull();
+  if (usualBond.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  // Check if onchain pricing equals to calculated ones
+  checkPoolPrices(poolPrices!, amounts, side, dexKey);
+}
+
+describe('UsualBond', function () {
+  const dexKey = 'UsualBond';
+  let blockNumber: number;
+  let usualBond: UsualBond;
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+
+    // Don't forget to update relevant tokens in constant-e2e.ts
+
+    const amountsForSell = [
+      0n,
+      1n * BI_POWS[18],
+      2n * BI_POWS[18],
+      3n * BI_POWS[18],
+      4n * BI_POWS[18],
+      5n * BI_POWS[18],
+      6n * BI_POWS[18],
+      7n * BI_POWS[18],
+      8n * BI_POWS[18],
+      9n * BI_POWS[18],
+      10n * BI_POWS[18],
+    ];
+
+    beforeAll(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      usualBond = new UsualBond(network, dexKey, dexHelper);
+      if (usualBond.initializePricing) {
+        await usualBond.initializePricing(blockNumber);
+      }
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      await testPricingOnNetwork(
+        usualBond,
+        network,
+        dexKey,
+        blockNumber,
+        'USD0',
+        'USD0++',
+        SwapSide.SELL,
+        amountsForSell,
+        '',
+      );
+    });
+  });
+});