@paraswap/dex-lib 3.8.15 → 3.8.16-oswap.1

package/src/dex/idex.ts

@@ -24,34 +24,7 @@ export type Context = {
   isGlobalDestToken: boolean;
 };
 
-export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
-  needWrapNative: boolean;
-  needsSequentialPreprocessing?: boolean;
-
-  // Returns the ETH fee required to swap
-  // It is optional for a DEX to implement this
-  // This is a legacy function and will be removed soon
-  getNetworkFee?(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    data: ExchangeData,
-    side: SwapSide,
-  ): NumberAsString;
-
-  // If exists, called before getAdapterParam to use async calls and receive data if needed
-  preProcessTransaction?(
-    optimalSwapExchange: OptimalSwapExchange<ExchangeData>,
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    options: PreprocessTransactionOptions,
-  ): AsyncOrSync<[OptimalSwapExchange<ExchangeData>, ExchangeTxInfo]>;
-
-  // This is helper a function to support testing if preProcessTransaction is implemented
-  getTokenFromAddress?(address: Address): Token;
-
+export interface IDexTxBuilderV5<ExchangeData, DirectParam = null> {
   // Encode params required by the exchange adapter
   // V5: Used for multiSwap, buy & megaSwap
   // V6: NOT used, pass a placeholder
@@ -76,18 +49,6 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     side: SwapSide,
   ): AsyncOrSync<SimpleExchangeParam>;
 
-  getDexParam?(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: ExchangeData,
-    side: SwapSide,
-    context: Context,
-    executorAddress: Address,
-  ): AsyncOrSync<DexExchangeParam>;
-
   // Returns params required by direct swap method.
   // Only Dexes which have a direct method should implement this
   // Used if there is a possibility for direct swap (Eg. UniswapV2,
@@ -108,8 +69,23 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     beneficiary: string,
     contractMethod: string,
   ): TxInfo<DirectParam>;
+}
 
-  // Same as above but for V6
+export interface IDexTxBuilderV6<ExchangeData, DirectParam = null> {
+  // Returns params required by generic method
+  getDexParam?(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: ExchangeData,
+    side: SwapSide,
+    context: Context,
+    executorAddress: Address,
+  ): AsyncOrSync<DexExchangeParam>;
+
+  // Returns params for direct method
   getDirectParamV6?(
     srcToken: Address,
     destToken: Address,
@@ -127,6 +103,37 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
   ): TxInfo<DirectParam>;
 }
 
+export interface IDexTxBuilder<ExchangeData, DirectParam = null>
+  extends IDexTxBuilderV5<ExchangeData, DirectParam>,
+    IDexTxBuilderV6<ExchangeData, DirectParam> {
+  needWrapNative: boolean;
+  needsSequentialPreprocessing?: boolean;
+
+  // Returns the ETH fee required to swap
+  // It is optional for a DEX to implement this
+  // This is a legacy function and will be removed soon
+  getNetworkFee?(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: ExchangeData,
+    side: SwapSide,
+  ): NumberAsString;
+
+  // If exists, called before getAdapterParam to use async calls and receive data if needed
+  preProcessTransaction?(
+    optimalSwapExchange: OptimalSwapExchange<ExchangeData>,
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): AsyncOrSync<[OptimalSwapExchange<ExchangeData>, ExchangeTxInfo]>;
+
+  // This is helper a function to support testing if preProcessTransaction is implemented
+  getTokenFromAddress?(address: Address): Token;
+}
+
 export interface IDexPricing<ExchangeData> {
   readonly dexKey: string;
   // This is true if the the DEX is simply

package/src/dex/index.ts

@@ -67,6 +67,7 @@ import { QuickSwapV3 } from './quickswap/quickswap-v3';
 import { ThenaFusion } from './quickswap/thena-fusion';
 import { SwaapV2 } from './swaap-v2/swaap-v2';
 import { TraderJoeV21 } from './trader-joe-v2.1/trader-joe-v2.1';
+import { TraderJoeV22 } from './trader-joe-v2.1/trader-joe-v2.2';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 import { Algebra } from './algebra/algebra';
 import { AngleTransmuter } from './angle-transmuter/angle-transmuter';
@@ -81,8 +82,10 @@ import { EtherFi } from './etherfi';
 import { Spark } from './spark/spark';
 import { VelodromeSlipstream } from './uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream';
 import { AaveV3Stata } from './aave-v3-stata/aave-v3-stata';
+import { OSwap } from './oswap/oswap';
 import { ConcentratorArusd } from './concentrator-arusd/concentrator-arusd';
 import { FxProtocolRusd } from './fx-protocol-rusd/fx-protocol-rusd';
+import { LitePsm } from './lite-psm/lite-psm';
 
 const LegacyDexes = [
   CurveV2,
@@ -95,6 +98,7 @@ const LegacyDexes = [
   QuickSwapV3,
   ThenaFusion,
   TraderJoeV21,
+  TraderJoeV22,
   Lido,
   AugustusRFQOrder,
   EtherFi,
@@ -159,8 +163,10 @@ const Dexes = [
   PharaohV1,
   Spark,
   AaveV3Stata,
+  OSwap,
   ConcentratorArusd,
   FxProtocolRusd,
+  LitePsm,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

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

@@ -0,0 +1,29 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+// Warning: Addresses should be lowercased
+export const LitePsmConfig: DexConfigMap<DexParams> = {
+  LitePsm: {
+    [Network.MAINNET]: {
+      dai: {
+        address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+        decimals: 18,
+      },
+      vatAddress: '0x35d1b3f3d7966a1dfe207aa4514c12a259a0492b',
+      pools: [
+        {
+          gem: {
+            address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+            decimals: 6,
+          },
+          gemJoinAddress: '0xf6e72db5454dd049d0788e411b06cfaf16853042', // Same as psmAddress. LitePsm does not have an external gem join.
+          pocketAddress: '0x37305b1cd40574e4c5ce33f8e8306be057fd7341',
+          psmAddress: '0xf6e72db5454dd049d0788e411b06cfaf16853042',
+          identifier:
+            '0x4c4954452d50534d2d555344432d410000000000000000000000000000000000', // bytes32("LITE-PSM-USDC-A")
+        },
+      ],
+    },
+  },
+};

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

@@ -0,0 +1,79 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+describe('LitePsm E2E', () => {
+  const dexKey = 'LitePsm';
+
+  describe('LitePsm MAINNET_V6', () => {
+    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 = 'DAI';
+
+    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-event-pool.ts

@@ -0,0 +1,216 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import { Contract } from 'web3-eth-contract';
+import { Address, Log, Logger } from '../../types';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { getBigIntPow } from '../../utils';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { PoolState, PoolConfig } from './types';
+import { LitePsmConfig } from './config';
+import PsmABI from '../../abi/maker-psm/psm.json';
+import VatABI from '../../abi/maker-psm/vat.json';
+import { erc20Iface } from '../../lib/tokens/utils';
+import DaiABI from '../../abi/lite-psm/dai.json';
+import UsdcABI from '../../abi/lite-psm/usdc.json';
+
+const vatInterface = new Interface(VatABI);
+const psmInterface = new Interface(PsmABI);
+const daiInterface = new Interface(DaiABI);
+const usdcInterface = new Interface(UsdcABI);
+
+const bigIntify = (b: any) => BigInt(b.toString());
+
+export async function getOnChainState(
+  multiContract: Contract,
+  poolConfigs: PoolConfig[],
+  vatAddress: Address,
+  blockNumber: number | 'latest',
+  daiAddress: Address,
+): Promise<PoolState[]> {
+  const callData = poolConfigs
+    .map(c => [
+      {
+        target: c.psmAddress,
+        callData: psmInterface.encodeFunctionData('tin', []),
+      },
+      {
+        target: c.psmAddress,
+        callData: psmInterface.encodeFunctionData('tout', []),
+      },
+      {
+        target: vatAddress,
+        callData: vatInterface.encodeFunctionData('ilks', [c.identifier]),
+      },
+      // dai liquidity
+      // ceiling for `sellGem`
+      {
+        target: daiAddress,
+        callData: erc20Iface.encodeFunctionData('balanceOf', [c.psmAddress]),
+      },
+      // gem liquidity
+      // ceiling for `buyGem`
+      {
+        target: c.gem.address,
+        callData: erc20Iface.encodeFunctionData('balanceOf', [c.pocketAddress]),
+      },
+    ])
+    .flat();
+
+  const res = await multiContract.methods
+    .aggregate(callData)
+    .call({}, blockNumber);
+
+  let i = 0;
+  const result = poolConfigs.map(c => {
+    const tin = bigIntify(
+      psmInterface.decodeFunctionResult('tin', res.returnData[i++])[0],
+    );
+    const tout = bigIntify(
+      psmInterface.decodeFunctionResult('tout', res.returnData[i++])[0],
+    );
+    const ilks = vatInterface.decodeFunctionResult('ilks', res.returnData[i++]);
+    const rate = bigIntify(ilks.rate);
+    const daiBalance = bigIntify(
+      erc20Iface.decodeFunctionResult('balanceOf', res.returnData[i++])[0],
+    );
+    const gemBalance = bigIntify(
+      erc20Iface.decodeFunctionResult('balanceOf', res.returnData[i++])[0],
+    );
+    const response = {
+      tin,
+      tout,
+      daiBalance,
+      gemBalance,
+      rate,
+    };
+
+    return response;
+  });
+
+  return result;
+}
+
+export class LitePsmEventPool extends StatefulEventSubscriber<PoolState> {
+  handlers: {
+    [event: string]: (event: any, pool: PoolState, log: Log) => PoolState;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  to18ConversionFactor: bigint;
+  bytes32Tout =
+    '0x746f757400000000000000000000000000000000000000000000000000000000'; // bytes32('tout')
+  bytes32Tin =
+    '0x74696e0000000000000000000000000000000000000000000000000000000000'; // bytes32('tin')
+
+  daiAddress: Address;
+
+  constructor(
+    parentName: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
+    public poolConfig: PoolConfig,
+    protected vatAddress: Address,
+  ) {
+    super(parentName, poolConfig.identifier, dexHelper, logger);
+
+    this.daiAddress =
+      LitePsmConfig[this.parentName][this.network].dai.address.toLowerCase();
+    this.logDecoder = (log: Log) => {
+      const logAddress = log.address.toLowerCase();
+      if (logAddress === this.daiAddress) {
+        return daiInterface.parseLog(log);
+      } else if (logAddress === this.poolConfig.gem.address) {
+        return usdcInterface.parseLog(log);
+      } else {
+        return psmInterface.parseLog(log);
+      }
+    };
+    this.addressesSubscribed = [
+      poolConfig.psmAddress,
+      this.daiAddress,
+      this.poolConfig.gem.address,
+    ];
+    this.to18ConversionFactor = getBigIntPow(18 - poolConfig.gem.decimals);
+
+    // Add handlers
+    this.handlers['File'] = this.handleFile.bind(this);
+    this.handlers['Transfer'] = this.handleTransfer.bind(this);
+  }
+
+  handleFile(event: any, pool: PoolState, log: Log): PoolState {
+    if (event.args.what === this.bytes32Tin) {
+      pool.tin = bigIntify(event.args.data);
+    } else if (event.args.what === this.bytes32Tout) {
+      pool.tout = bigIntify(event.args.data);
+    }
+    return pool;
+  }
+
+  handleTransfer(event: any, pool: PoolState, log: Log): PoolState {
+    if (log.address.toLowerCase() === this.daiAddress) {
+      return this.handleTransferDAI(event, pool, log);
+    } else if (log.address.toLowerCase() === this.poolConfig.gem.address) {
+      return this.handleTransferGEM(event, pool, log);
+    }
+    return pool;
+  }
+
+  handleTransferDAI(event: any, pool: PoolState, log: Log): PoolState {
+    if (event.args?.src?.toLowerCase() === this.poolConfig.psmAddress) {
+      pool.daiBalance -= bigIntify(event.args.wad);
+    } else if (event.args?.dst?.toLowerCase() === this.poolConfig.psmAddress) {
+      pool.daiBalance += bigIntify(event.args.wad);
+    }
+    return pool;
+  }
+
+  handleTransferGEM(event: any, pool: PoolState, log: Log): PoolState {
+    if (event.args?.from?.toLowerCase() === this.poolConfig.pocketAddress) {
+      pool.gemBalance -= bigIntify(event.args.value);
+    } else if (
+      event.args?.to?.toLowerCase() === this.poolConfig.pocketAddress
+    ) {
+      pool.gemBalance += bigIntify(event.args.value);
+    }
+    return pool;
+  }
+
+  getIdentifier(): string {
+    return `${this.parentName}_${this.poolConfig.psmAddress}`.toLowerCase();
+  }
+
+  protected processLog(
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+  ): DeepReadonly<PoolState> | null {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        return this.handlers[event.name](event, state, log);
+      }
+      return state;
+    } catch (e) {
+      this.logger.error(
+        `Error_${this.parentName}_processLog could not parse the log with topic ${log.topics}:`,
+        e,
+      );
+      return null;
+    }
+  }
+
+  async generateState(
+    blockNumber: number | 'latest',
+  ): Promise<Readonly<PoolState>> {
+    return (
+      await getOnChainState(
+        this.dexHelper.multiContract,
+        [this.poolConfig],
+        this.vatAddress,
+        blockNumber,
+        this.daiAddress,
+      )
+    )[0];
+  }
+}

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

@@ -0,0 +1,61 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { LitePsmEventPool } from './lite-psm-event-pool';
+import { LitePsmConfig } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { PoolState } from './types';
+
+jest.setTimeout(50 * 1000);
+const dexKey = 'LitePsm';
+const network = Network.MAINNET;
+const config = LitePsmConfig[dexKey][network];
+
+function fetchPoolState(
+  makerPsmPool: LitePsmEventPool,
+  blockNumber: number,
+): Promise<PoolState> {
+  return makerPsmPool.generateState(blockNumber);
+}
+
+describe('LitePsm Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    // File: [], // never happened
+    SellGem: [20559136, 20559876, 20561086, 20563099, 20563672, 20563887],
+    BuyGem: [
+      20554181, 20555354, 20555452, 20555880, 20556086, 20556431, 20558791,
+    ],
+  };
+
+  describe('LitePsmEventPool', 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 makerPsmPool = new LitePsmEventPool(
+            dexKey,
+            network,
+            dexHelper,
+            logger,
+            config.pools[0],
+            config.vatAddress,
+          );
+
+          await testEventSubscriber(
+            makerPsmPool,
+            makerPsmPool.addressesSubscribed,
+            (_blockNumber: number) =>
+              fetchPoolState(makerPsmPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${config.pools[0].psmAddress}`,
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,99 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { LitePsm } from './lite-psm';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { BI_POWS } from '../../bigint-constants';
+
+const network = Network.MAINNET;
+const TokenASymbol = 'USDC';
+const TokenA = Tokens[network][TokenASymbol];
+
+const TokenBSymbol = 'DAI';
+const TokenB = Tokens[network][TokenBSymbol];
+
+const tokenAAmounts = [0n, BI_POWS[8], 200000000n];
+
+const tokenBAmounts = [0n, BI_POWS[18], 2000000000000000000n];
+
+const dexKey = 'LitePsm';
+
+describe('LitePsm', function () {
+  it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    const litePsm = new LitePsm(network, dexKey, dexHelper);
+
+    await litePsm.initializePricing(blocknumber);
+
+    const pools = await litePsm.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await litePsm.getPricesVolume(
+      TokenA,
+      TokenB,
+      tokenAAmounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, tokenAAmounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    const litePsm = new LitePsm(network, dexKey, dexHelper);
+
+    await litePsm.initializePricing(blocknumber);
+
+    const pools = await litePsm.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await litePsm.getPricesVolume(
+      TokenA,
+      TokenB,
+      tokenBAmounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, tokenBAmounts, SwapSide.BUY, dexKey);
+  });
+
+  it('getTopPoolsForToken', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const litePsm = new LitePsm(network, dexKey, dexHelper);
+
+    const poolLiquidity = await litePsm.getTopPoolsForToken(TokenA.address, 10);
+    console.log(
+      `${TokenASymbol} Top Pools:`,
+      JSON.stringify(poolLiquidity, null, 2),
+    );
+
+    checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
+  });
+});