@paraswap/dex-lib 4.1.12 → 4.1.13

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

@@ -11,6 +11,7 @@ import { SparkSDaiPoolState } from './types';
 import PotAbi from '../../abi/maker-psm/pot.json';
 import { Interface } from '@ethersproject/abi';
 import _ from 'lodash';
+import { sUSDSPsmConfig } from './spark-psm';
 
 jest.setTimeout(50 * 1000);
 const network = Network.MAINNET;
@@ -115,3 +116,99 @@ describe('sUSDS', function () {
     });
   });
 });
+
+describe('SparkPsm', () => {
+  const dexKey = 'SparkPsm';
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+
+    const blockNumbers: { [eventName: string]: number[] } = {
+      drip: [304722012, 307345024, 309450889, 312209827, 314627816],
+    };
+
+    const addresses: { [contract: string]: string } = {
+      potAddress: sUSDSPsmConfig[dexKey][network].potAddress,
+    };
+
+    const potIface = sUSDSPsmConfig[dexKey][network].poolInterface;
+
+    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 sUSDSPool = new SparkSDaiEventPool(
+            dexKey,
+            network,
+            `usds-susds-pool`,
+            dexHelper,
+            addresses.potAddress,
+            potIface,
+            logger,
+            '0xc234856e2a0c5b406365714ced016892e7d98f7b1d49982cdd8db416a586d811',
+            'ssrOracle',
+          );
+
+          await sUSDSPool.initialize(blockNumber);
+
+          await testEventSubscriber(
+            sUSDSPool,
+            sUSDSPool.addressesSubscribed,
+            (_blockNumber: number) => fetchPoolState(sUSDSPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${sUSDSPool}`,
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+
+  describe('Base', () => {
+    const network = Network.BASE;
+
+    const blockNumbers: { [eventName: string]: number[] } = {
+      drip: [26505853, 26808109, 26808254, 27110658],
+    };
+
+    const addresses: { [contract: string]: string } = {
+      potAddress: sUSDSPsmConfig[dexKey][network].potAddress,
+    };
+
+    const potIface = sUSDSPsmConfig[dexKey][network].poolInterface;
+
+    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 sUSDSPool = new SparkSDaiEventPool(
+            dexKey,
+            network,
+            `usds-susds-pool`,
+            dexHelper,
+            addresses.potAddress,
+            potIface,
+            logger,
+            '0xc234856e2a0c5b406365714ced016892e7d98f7b1d49982cdd8db416a586d811',
+            'ssrOracle',
+          );
+
+          await sUSDSPool.initialize(blockNumber);
+
+          await testEventSubscriber(
+            sUSDSPool,
+            sUSDSPool.addressesSubscribed,
+            (_blockNumber: number) => fetchPoolState(sUSDSPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${sUSDSPool}`,
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+});

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

@@ -9,6 +9,9 @@ import { BI_POWS } from '../../bigint-constants';
 import { Spark } from './spark';
 import { MultiCallParams } from '../../lib/multi-wrapper';
 import { uint256ToBigInt } from '../../lib/decoders';
+import { SparkPsm } from './spark-psm';
+import SparkPSM3Abi from '../../abi/sdai/PSM3.abi.json';
+import { Interface } from 'ethers/lib/utils';
 
 const network = Network.MAINNET;
 
@@ -432,3 +435,256 @@ describe('sUSDS', function () {
     checkPoolsLiquidity(poolLiquidity, SDaiToken.address, dexKey);
   });
 });
+
+describe('SparkPsm', () => {
+  const network = Network.ARBITRUM;
+  const dexHelper = new DummyDexHelper(network);
+
+  const dexKey = 'SparkPsm';
+  const SDaiSymbol = 'sUSDS';
+  const SDaiToken = Tokens[network][SDaiSymbol];
+  const USDCSymbol = 'USDC';
+  const USDC = Tokens[network][USDCSymbol];
+
+  let sparkPsm: SparkPsm;
+
+  const DaiSymbol = 'USDS';
+  const DaiToken = Tokens[network][DaiSymbol];
+
+  const psmIface = new Interface(SparkPSM3Abi);
+
+  beforeAll(async () => {
+    blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    sparkPsm = new SparkPsm(network, dexKey, dexHelper);
+    if (sparkPsm.initializePricing) {
+      await sparkPsm.initializePricing(blocknumber);
+    }
+  });
+
+  it('getPoolIdentifiers and getPricesVolume USDS -> sUSDS SELL', async () => {
+    const pools = await sparkPsm.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sparkPsm.getPricesVolume(
+      DaiToken,
+      SDaiToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Prices: `, poolPrices);
+
+    const onChainPrices = await Promise.all(
+      amounts.map(async amount => {
+        const callData: MultiCallParams<bigint>[] = [
+          {
+            target: '0x2B05F8e1cACC6974fD79A673a341Fe1f58d27266',
+            callData: psmIface.encodeFunctionData('previewSwapExactIn', [
+              DaiToken.address,
+              SDaiToken.address,
+              amount,
+            ]),
+            decodeFunction: uint256ToBigInt,
+          },
+        ];
+
+        const results = await sparkPsm.dexHelper.multiWrapper.aggregate<bigint>(
+          callData,
+          blocknumber,
+        );
+        return results[0];
+      }),
+    );
+
+    console.log('On-chain price:', onChainPrices);
+
+    expect(poolPrices).not.toBeNull();
+    expect(poolPrices?.[0].prices).toEqual(onChainPrices);
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume sUSDS -> USDS SELL', async () => {
+    const pools = await sparkPsm.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sparkPsm.getPricesVolume(
+      SDaiToken,
+      DaiToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Prices: `, poolPrices);
+
+    const onChainPrices = await Promise.all(
+      amounts.map(async amount => {
+        const callData: MultiCallParams<bigint>[] = [
+          {
+            target: '0x2B05F8e1cACC6974fD79A673a341Fe1f58d27266',
+            callData: psmIface.encodeFunctionData('previewSwapExactIn', [
+              SDaiToken.address,
+              DaiToken.address,
+              amount,
+            ]),
+            decodeFunction: uint256ToBigInt,
+          },
+        ];
+
+        const results = await sparkPsm.dexHelper.multiWrapper.aggregate<bigint>(
+          callData,
+          blocknumber,
+        );
+        return results[0];
+      }),
+    );
+
+    console.log('On-chain price:', onChainPrices);
+
+    expect(poolPrices).not.toBeNull();
+    expect(poolPrices?.[0].prices).toEqual(onChainPrices);
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume USDS -> sUSDS BUY', async () => {
+    const pools = await sparkPsm.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sparkPsm.getPricesVolume(
+      DaiToken,
+      SDaiToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Prices: `, poolPrices);
+
+    const onChainPrices = await Promise.all(
+      amounts.map(async amount => {
+        const callData: MultiCallParams<bigint>[] = [
+          {
+            target: '0x2B05F8e1cACC6974fD79A673a341Fe1f58d27266',
+            callData: psmIface.encodeFunctionData('previewSwapExactOut', [
+              DaiToken.address,
+              SDaiToken.address,
+              amount,
+            ]),
+            decodeFunction: uint256ToBigInt,
+          },
+        ];
+
+        const results = await sparkPsm.dexHelper.multiWrapper.aggregate<bigint>(
+          callData,
+          blocknumber,
+        );
+        return results[0];
+      }),
+    );
+
+    console.log('On-chain price:', onChainPrices);
+
+    expect(poolPrices).not.toBeNull();
+    expect(poolPrices?.[0].prices).toEqual(onChainPrices);
+    checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume sUSDS -> USDS BUY', async () => {
+    const pools = await sparkPsm.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await sparkPsm.getPricesVolume(
+      SDaiToken,
+      DaiToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Prices: `, poolPrices);
+
+    const onChainPrices = await Promise.all(
+      amounts.map(async amount => {
+        const callData: MultiCallParams<bigint>[] = [
+          {
+            target: '0x2B05F8e1cACC6974fD79A673a341Fe1f58d27266',
+            callData: psmIface.encodeFunctionData('previewSwapExactOut', [
+              SDaiToken.address,
+              DaiToken.address,
+              amount,
+            ]),
+            decodeFunction: uint256ToBigInt,
+          },
+        ];
+
+        const results = await sparkPsm.dexHelper.multiWrapper.aggregate<bigint>(
+          callData,
+          blocknumber,
+        );
+        return results[0];
+      }),
+    );
+
+    console.log('On-chain price:', onChainPrices);
+
+    expect(poolPrices).not.toBeNull();
+    expect(poolPrices?.[0].prices).toEqual(onChainPrices);
+    checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+  });
+
+  it('USDS getTopPoolsForToken', async () => {
+    const poolLiquidity = await sparkPsm.getTopPoolsForToken(
+      DaiToken.address,
+      10,
+    );
+    console.log(`${DaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, DaiToken.address, dexKey);
+  });
+
+  it('sUSDS getTopPoolsForToken', async () => {
+    const poolLiquidity = await sparkPsm.getTopPoolsForToken(
+      SDaiToken.address,
+      10,
+    );
+    console.log(`${SDaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, SDaiToken.address, dexKey);
+  });
+
+  it('USDC getTopPoolsForToken', async () => {
+    const poolLiquidity = await sparkPsm.getTopPoolsForToken(USDC.address, 10);
+    console.log(`${USDCSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, USDC.address, dexKey);
+  });
+});