@paraswap/dex-lib 3.8.36 → 3.8.37

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/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,80 @@
+/* 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]],
+  ]);
+
+  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,144 @@
+/* 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,
+  checkPoolsLiquidity,
+} 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,
+        '',
+      );
+    });
+
+    it('getTopPoolsForToken: USD0', async function () {
+      const tokenA = Tokens[network]['USD0'];
+      const dexHelper = new DummyDexHelper(network);
+      const usualBond = new UsualBond(network, dexKey, dexHelper);
+
+      const poolLiquidity = await usualBond.getTopPoolsForToken(
+        tokenA.address,
+        10,
+      );
+      console.log(
+        `${tokenA.symbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+    });
+
+    it('getTopPoolsForToken: USD0++', async function () {
+      const tokenA = Tokens[network]['USD0++'];
+      const dexHelper = new DummyDexHelper(network);
+      const usualBond = new UsualBond(network, dexKey, dexHelper);
+
+      const poolLiquidity = await usualBond.getTopPoolsForToken(
+        tokenA.address,
+        10,
+      );
+      console.log(
+        `${tokenA.symbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+    });
+  });
+});

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

@@ -0,0 +1,208 @@
+import {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  Logger,
+  NumberAsString,
+  DexExchangeParam,
+  PoolLiquidity,
+} from '../../types';
+import { SwapSide, Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getDexKeysWithNetwork } from '../../utils';
+import { IDex } from '../idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { UsualBondData, DexParams } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { UsualBondConfig } from './config';
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import USD0PP_ABI from '../../abi/usual-bond/usd0pp.abi.json';
+import { BI_POWS } from '../../bigint-constants';
+
+export class UsualBond extends SimpleExchange implements IDex<UsualBondData> {
+  protected config: DexParams;
+
+  readonly hasConstantPriceLargeAmounts = true;
+  readonly needWrapNative = false;
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(UsualBondConfig);
+
+  usd0ppIface: Interface;
+  logger: Logger;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+  ) {
+    super(dexHelper, dexKey);
+    const config = UsualBondConfig[dexKey][network];
+    this.usd0ppIface = new Interface(USD0PP_ABI as JsonFragment[]);
+    this.config = {
+      usd0Address: config.usd0Address.toLowerCase(),
+      usd0ppAddress: config.usd0ppAddress.toLowerCase(),
+    };
+    this.logger = dexHelper.getLogger(dexKey);
+  }
+
+  async initializePricing(blockNumber: number) {
+    // No initialization needed for constant price
+  }
+
+  getConfig() {
+    return this.config;
+  }
+
+  is_usd0(token: string) {
+    return token.toLowerCase() === this.config.usd0Address.toLowerCase();
+  }
+
+  is_usd0pp(token: string) {
+    return token.toLowerCase() === this.config.usd0ppAddress.toLowerCase();
+  }
+
+  is_usd0_swap_token(srcToken: string, destToken: string) {
+    return this.is_usd0(srcToken) && this.is_usd0pp(destToken);
+  }
+
+  getAdapters() {
+    return null;
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    if (!srcToken || !destToken) {
+      this.logger.error('Source or destination token is undefined');
+      return [];
+    }
+
+    const srcTokenAddress = srcToken.address?.toLowerCase();
+    const destTokenAddress = destToken.address?.toLowerCase();
+
+    if (!srcTokenAddress || !destTokenAddress) {
+      this.logger.error('Source or destination token address is undefined');
+      return [];
+    }
+
+    if (this.is_usd0_swap_token(srcTokenAddress, destTokenAddress)) {
+      return [`${this.dexKey}_${this.config.usd0ppAddress}`];
+    }
+
+    return [];
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<UsualBondData>> {
+    if (side === SwapSide.BUY) {
+      return null;
+    }
+
+    const isUSD0SwapToken = this.is_usd0_swap_token(
+      srcToken.address,
+      destToken.address,
+    );
+
+    if (!isUSD0SwapToken) {
+      return null;
+    }
+
+    const unitOut = BI_POWS[18]; // 1:1 swap
+    const amountsOut = amounts; // 1:1 swap, so output amounts are the same as input
+
+    return [
+      {
+        unit: unitOut,
+        prices: amountsOut,
+        data: {},
+        poolAddresses: [this.config.usd0ppAddress],
+        exchange: this.dexKey,
+        gasCost: 70000,
+        poolIdentifier: this.dexKey,
+      },
+    ];
+  }
+
+  getCalldataGasCost(poolPrices: PoolPrices<UsualBondData>): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: UsualBondData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const payload = '0x';
+
+    return {
+      targetExchange: this.config.usd0ppAddress,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  async getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: UsualBondData,
+    side: SwapSide,
+  ): Promise<DexExchangeParam> {
+    if (this.is_usd0(srcToken) && this.is_usd0pp(destToken)) {
+      const exchangeData = this.usd0ppIface.encodeFunctionData('mint', [
+        srcAmount,
+      ]);
+
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: false,
+        exchangeData,
+        targetExchange: this.config.usd0ppAddress,
+        returnAmountPos: undefined,
+      };
+    }
+    throw new Error('LOGIC ERROR');
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    const isUsd0 = this.is_usd0(tokenAddress);
+    if (!isUsd0 && !this.is_usd0pp(tokenAddress)) return [];
+
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.config.usd0ppAddress,
+        connectorTokens: [
+          {
+            decimals: 18,
+            address: isUsd0
+              ? this.config.usd0ppAddress
+              : this.config.usd0Address,
+          },
+        ],
+        liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+      },
+    ];
+  }
+}

package/tests/constants-e2e.ts

@@ -523,6 +523,16 @@ export const Tokens: {
       address: '0x07D1718fF05a8C53C8F05aDAEd57C0d672945f9a',
       decimals: 18,
     },
+    USD0: {
+      address: '0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5',
+      decimals: 18,
+      symbol: 'USD0',
+    },
+    'USD0++': {
+      address: '0x35D8949372D46B7a3D5A56006AE77B215fc69bC0',
+      decimals: 18,
+      symbol: 'USD0++',
+    },
   },
   [Network.POLYGON]: {
     jGBP: {
@@ -1606,6 +1616,8 @@ export const Holders: {
     weETH: '0x267ed5f71EE47D3E45Bb1569Aa37889a2d10f91e',
     rUSD: '0xEC2eda1C4F981E468ABF62424a10B69B738b498E',
     arUSD: '0xeFc24206053a452e2299BF3b8f964512b041Db4C',
+    USD0: '0x6A5d5Af0E266a24648a9d7E8D388EAEc7AbD8433',
+    'USD0++': '0x2227b6806339906707b43F36a1f07B52FF7Fa776',
   },
   [Network.POLYGON]: {
     jGBP: '0x02aa0B826c7BA6386DdBE04C0a8715A1c0A16B24',