@paraswap/dex-lib 2.47.4 → 2.47.5

package/src/dex/balancer-v2/balancer-v2-gyro3.test.ts

@@ -1,268 +0,0 @@
-// npx jest src/dex/balancer-v2/balancer-v2-gyro3.test.ts
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { Interface } from '@ethersproject/abi';
-import { BigNumber } from '@ethersproject/bignumber';
-
-import { Tokens } from '../../../tests/constants-e2e';
-import { DummyDexHelper } from '../../dex-helper/index';
-import { Network, SwapSide } from '../../constants';
-import { BalancerV2EventPool } from './balancer-v2';
-import { BalancerConfig } from './config';
-import { PoolState, SubgraphPoolBase } from './types';
-import { Gyro3Pool, Gyro3PoolPairData } from './pools/gyro/Gyro3Pool';
-import { queryOnChain } from './queryOnChain';
-
-import VaultABI from '../../abi/balancer-v2/vault.json';
-
-const rpcUrl = process.env.HTTP_PROVIDER_137 as string;
-
-describe('BalancerV2', () => {
-  const dexKey = 'BalancerV2';
-  const network = Network.POLYGON;
-  const config = BalancerConfig[dexKey][network];
-  const vaultInterface = new Interface(VaultABI);
-  const gyro3Pool = new Gyro3Pool(config.vaultAddress, vaultInterface);
-  const tokens = Tokens[network];
-
-  const dexHelper = new DummyDexHelper(network);
-  const logger = dexHelper.getLogger(dexKey);
-  const balancerPools = new BalancerV2EventPool(
-    dexKey,
-    network,
-    config.vaultAddress,
-    config.subgraphURL,
-    dexHelper,
-    logger,
-  );
-
-  describe('Gyro3 Pool', () => {
-    describe('Pool Fetching', () => {
-      let Gyro3PoolSg: SubgraphPoolBase;
-      let Gyro3PoolState: PoolState;
-
-      it('should be supported pool type', async function () {
-        expect(balancerPools.isSupportedPool('Gyro3')).toBe(true);
-      });
-
-      it('should fetch Gyro3 Pool with correct fields from Subgraph', async function () {
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        // USDC/BUSD/USDT
-        const Gyro3PoolId =
-          '0x17f1ef81707811ea15d9ee7c741179bbe2a63887000100000000000000000799';
-        const Gyro3 = pools.filter(p => p.id === Gyro3PoolId);
-        expect(Gyro3.length).toBe(1);
-        Gyro3PoolSg = Gyro3[0];
-        expect(Gyro3PoolSg.tokens.length).toBe(3);
-        const root3Alpha = parseFloat(Gyro3PoolSg.root3Alpha);
-        expect(root3Alpha > 0).toBe(true);
-        Gyro3PoolSg = { ...Gyro3PoolSg };
-        Gyro3PoolSg.root3Alpha = '0.9995';
-      });
-
-      it('getOnChainState', async function () {
-        const blocknumber = 40038397;
-        const state = await balancerPools.getOnChainState(
-          [Gyro3PoolSg],
-          blocknumber,
-        );
-        Gyro3PoolState = state[Gyro3PoolSg.address];
-        expect(Gyro3PoolState.swapFee).toBe(BigInt('300000000000000'));
-        expect(Gyro3PoolState.tokens[tokens.USDC.address].balance).toBe(
-          BigInt('25755475662'),
-        );
-        expect(
-          Gyro3PoolState.tokens[tokens.BUSD.address.toLowerCase()].balance,
-        ).toBe(BigInt('41279070738726640173873'));
-        expect(
-          Gyro3PoolState.tokens[tokens.USDT.address.toLowerCase()].balance,
-        ).toBe(BigInt('25601127342'));
-      });
-
-      it('parsePoolPairData', async function () {
-        const tokenIn = tokens.BUSD.address;
-        const tokenOut = tokens.USDT.address;
-        const pairData = gyro3Pool.parsePoolPairData(
-          Gyro3PoolSg,
-          Gyro3PoolState,
-          tokenIn,
-          tokenOut,
-        );
-        expect(pairData.indexIn).toBe(1);
-        expect(pairData.indexOut).toBe(2);
-        expect(pairData.swapFee).toBe(BigInt('300000000000000'));
-        expect(pairData.balanceTertiary.toString()).toBe(
-          '25755475662000000000000',
-        );
-        expect(pairData.decimalsTertiary.toString()).toBe('6');
-        expect(pairData.balances).toStrictEqual([
-          BigNumber.from('25755475662000000000000'),
-          BigNumber.from('41279070738726640173873'),
-          BigNumber.from('25601127342000000000000'),
-        ]);
-        expect(pairData.root3Alpha.toString()).toBe('999500000000000000');
-      });
-    });
-
-    describe('Swap Functions', () => {
-      describe('Swap Functions  - 6decimals>18decimals', () => {
-        const pairData: Gyro3PoolPairData = {
-          balances: [
-            BigNumber.from('25755475662000000000000'),
-            BigNumber.from('41279070738726640173873'),
-            BigNumber.from('25601127342000000000000'),
-          ],
-          indexIn: 0,
-          indexOut: 1,
-          swapFee: BigInt('300000000000000'),
-          scalingFactors: [
-            BigInt('1000000000000000000000000000000'),
-            BigInt('1000000000000000000'),
-            BigInt('1000000000000000000000000000000'),
-          ],
-          balanceTertiary: BigNumber.from('25601127342000000000000'),
-          decimalsTertiary: 6,
-          root3Alpha: BigNumber.from('999500000000000000'),
-        };
-
-        it('getSwapMaxAmount (SELL)', async () => {
-          const swapMaxAmount = gyro3Pool.getSwapMaxAmount(
-            pairData,
-            SwapSide.SELL,
-          );
-          expect(swapMaxAmount).toBe(BigInt('41279029459'));
-        });
-
-        it('swap', async function () {
-          const amountIn = BigInt('13500000');
-          const amountOut = gyro3Pool.onSell([amountIn], pairData);
-          expect(amountOut.length).toBe(1);
-          expect(amountOut[0].toString()).toBe('13499339792532290017');
-        });
-
-        it('buy', async function () {
-          const amountOut = BigInt('13500000');
-          const amountIn = gyro3Pool.onBuy([amountOut], pairData);
-          expect(amountIn.length).toBe(1);
-        });
-      });
-
-      describe('Swap Functions  - 18decimals>6decimals', () => {
-        const pairData: Gyro3PoolPairData = {
-          balances: [
-            BigNumber.from('25755475662000000000000'),
-            BigNumber.from('41279070738726640173873'),
-            BigNumber.from('25601127342000000000000'),
-          ],
-          indexIn: 1,
-          indexOut: 2,
-          swapFee: BigInt('300000000000000'),
-          scalingFactors: [
-            BigInt('1000000000000000000000000000000'),
-            BigInt('1000000000000000000'),
-            BigInt('1000000000000000000000000000000'),
-          ],
-          balanceTertiary: BigNumber.from('25601127342000000000000'),
-          decimalsTertiary: 6,
-          root3Alpha: BigNumber.from('999500000000000000'),
-        };
-
-        it('getSwapMaxAmount', async () => {
-          const swapMaxAmount = gyro3Pool.getSwapMaxAmount(
-            pairData,
-            SwapSide.SELL,
-          );
-          expect(swapMaxAmount).toBe(BigInt('25601101740872658000000'));
-        });
-
-        it('swap', async function () {
-          const amountIn = BigInt('13500000000000000000');
-          const amountOut = gyro3Pool.onSell([amountIn], pairData);
-          expect(amountOut.length).toBe(1);
-          expect(amountOut[0].toString()).toBe('13492521');
-        });
-      });
-    });
-
-    describe('Onchain Compare', () => {
-      it('_exactTokenInForTokenOut', async function () {
-        const blocknumber = 55433090;
-        // usdc/busd/usdt
-        const poolId =
-          '0x17f1ef81707811ea15d9ee7c741179bbe2a63887000100000000000000000799';
-        const tokenIn = tokens.USDC.address;
-        const tokenOut = tokens.BUSD.address;
-        const amountIn = BigInt('1000400');
-
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        const poolSg = pools.filter(p => p.id === poolId)[0];
-        const state = await balancerPools.getOnChainState(
-          [poolSg],
-          blocknumber,
-        );
-        const poolState = state[poolSg.address];
-
-        const pairData = gyro3Pool.parsePoolPairData(
-          poolSg,
-          poolState,
-          tokenIn,
-          tokenOut,
-        );
-        const amountOut = gyro3Pool.onSell([amountIn], pairData);
-        const deltas = await queryOnChain(
-          rpcUrl,
-          blocknumber,
-          poolId,
-          0,
-          tokenIn,
-          tokenOut,
-          amountIn,
-        );
-        expect(amountIn).toEqual(deltas[0]);
-        expect(amountOut[0] + deltas[1]).toEqual(0n);
-      });
-
-      it('_exactTokenOutForTokenIn', async function () {
-        const blocknumber = 54571344;
-        const poolId =
-          '0x17f1ef81707811ea15d9ee7c741179bbe2a63887000100000000000000000799';
-
-        const tokenIn = tokens.USDT.address;
-        const tokenOut = tokens.USDC.address;
-
-        const amountOut = BigInt('11000000');
-
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        const poolSg = pools.filter(p => p.id === poolId)[0];
-        const state = await balancerPools.getOnChainState(
-          [poolSg],
-          blocknumber,
-        );
-        const poolState = state[poolSg.address];
-
-        const pairData = gyro3Pool.parsePoolPairData(
-          poolSg,
-          poolState,
-          tokenIn,
-          tokenOut,
-        );
-
-        const amountIn = gyro3Pool.onBuy([amountOut], pairData);
-
-        const deltas = await queryOnChain(
-          rpcUrl,
-          blocknumber,
-          poolId,
-          1,
-          tokenIn,
-          tokenOut,
-          amountOut,
-        );
-
-        expect(amountIn[0]).toEqual(deltas[0]); // amountIn should equal deltas[0]
-        expect(deltas[1] + amountOut).toEqual(0n); // deltas[1] (consumed) + amountOut should equal 0
-      });
-    });
-  });
-});

package/src/dex/balancer-v2/balancer-v2-gyroE.test.ts

@@ -1,401 +0,0 @@
-/* eslint-disable no-console */
-// npx jest src/dex/balancer-v2/balancer-v2-gyroE.test.ts
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { Interface } from '@ethersproject/abi';
-import { BigNumber } from '@ethersproject/bignumber';
-
-import { Tokens } from '../../../tests/constants-e2e';
-import { DummyDexHelper } from '../../dex-helper/index';
-import { Network, SwapSide } from '../../constants';
-import { BalancerV2EventPool } from './balancer-v2';
-import { BalancerConfig } from './config';
-import { PoolState, SubgraphPoolBase } from './types';
-import { GyroEPool, GyroEPoolPairData } from './pools/gyro/GyroEPool';
-import { queryOnChain } from './queryOnChain';
-import VaultABI from '../../abi/balancer-v2/vault.json';
-
-const rpcUrl = process.env.HTTP_PROVIDER_137 as string;
-
-describe('BalancerV2', () => {
-  const dexKey = 'BalancerV2';
-  const network = Network.POLYGON;
-  const config = BalancerConfig[dexKey][network];
-  const vaultInterface = new Interface(VaultABI);
-  const gyroEPool = new GyroEPool(config.vaultAddress, vaultInterface);
-  const tokens = Tokens[network];
-  let GyroEPoolSg: SubgraphPoolBase;
-  let GyroEPoolState: PoolState;
-  const dexHelper = new DummyDexHelper(network);
-  const logger = dexHelper.getLogger(dexKey);
-  const balancerPools = new BalancerV2EventPool(
-    dexKey,
-    network,
-    config.vaultAddress,
-    config.subgraphURL,
-    dexHelper,
-    logger,
-  );
-
-  describe('GyroE Pool V1', () => {
-    describe('Pool Fetching', () => {
-      it('should be supported pool type', async function () {
-        expect(balancerPools.isSupportedPool('GyroE')).toBe(true);
-      });
-
-      it('should fetch GyroE Pool with correct fields from Subgraph', async function () {
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        // USDC/TUSD
-        const GyroEPoolId =
-          '0x97469e6236bd467cd147065f77752b00efadce8a0002000000000000000008c0';
-        const GyroE = pools.filter(p => p.id === GyroEPoolId);
-        expect(GyroE.length).toBe(1);
-        GyroEPoolSg = GyroE[0];
-        expect(GyroEPoolSg.tokens.length).toBe(2);
-        expect(GyroEPoolSg.poolTypeVersion).toEqual(1);
-      });
-
-      it('getOnChainState', async function () {
-        const blocknumber = 40068730;
-        const state = await balancerPools.getOnChainState(
-          [GyroEPoolSg],
-          blocknumber,
-        );
-        GyroEPoolState = state[GyroEPoolSg.address];
-        expect(GyroEPoolState.swapFee).toBe(BigInt('200000000000000'));
-        expect(GyroEPoolState.tokens[tokens.USDC.address].balance).toBe(
-          BigInt('18186193501'),
-        );
-        expect(
-          GyroEPoolState.tokens[tokens.TUSD.address.toLowerCase()].balance,
-        ).toBe(BigInt('26629907962671451455387'));
-      });
-
-      it('parsePoolPairData', async function () {
-        const tokenIn = tokens.USDC.address;
-        const tokenOut = tokens.TUSD.address;
-        const pairData = gyroEPool.parsePoolPairData(
-          GyroEPoolSg,
-          GyroEPoolState,
-          tokenIn,
-          tokenOut,
-        );
-        expect(pairData.indexIn).toBe(0);
-        expect(pairData.indexOut).toBe(1);
-        expect(pairData.swapFee).toBe(BigInt('200000000000000'));
-        expect(pairData.balances).toStrictEqual([
-          BigNumber.from('18186193501000000000000'),
-          BigNumber.from('26629907962671451455387'),
-        ]);
-        expect(pairData.tokenInIsToken0).toBe(true);
-      });
-    });
-
-    describe('Swap Functions', () => {
-      describe('Swap Functions  - 6decimals>18decimals', () => {
-        const pairData: GyroEPoolPairData = {
-          tokenInIsToken0: true,
-          balances: [
-            BigNumber.from('18186193501000000000000'),
-            BigNumber.from('26629907962671451455387'),
-          ],
-          indexIn: 0,
-          indexOut: 1,
-          scalingFactors: [
-            1000000000000000000000000000000n,
-            1000000000000000000n,
-          ],
-          swapFee: 200000000000000n,
-          gyroDerivedParams: {
-            tauAlpha: {
-              x: BigNumber.from('-99921684096872623630266893017017590000'),
-              y: BigNumber.from('3956898690236155895758568963473897000'),
-            },
-            tauBeta: {
-              x: BigNumber.from('99921684096872623626859806443439160000'),
-              y: BigNumber.from('3956898690236155981796108700303143000'),
-            },
-            u: BigNumber.from('99921684096872623515276234437562470000'),
-            v: BigNumber.from('3956898690236155934291169066298950000'),
-            w: BigNumber.from('43018769868414623130'),
-            z: BigNumber.from('-1703543286789219094'),
-            dSq: BigNumber.from('99999999999999999886624093342106120000'),
-          },
-          gyroParams: {
-            alpha: BigNumber.from('980000000000000000'),
-            beta: BigNumber.from('1020408163265306122'),
-            c: BigNumber.from('707106781186547524'),
-            s: BigNumber.from('707106781186547524'),
-            lambda: BigNumber.from('2500000000000000000000'),
-          },
-          tokenRates: [],
-          rateProviders: [],
-        };
-
-        it('getSwapMaxAmount', async () => {
-          const swapMaxAmount = gyroEPool.getSwapMaxAmount(
-            pairData,
-            SwapSide.SELL,
-          );
-          expect(swapMaxAmount).toBe(BigInt('26629881332'));
-        });
-
-        it('swap', async function () {
-          const amountIn = BigInt('13500000');
-          const amountOut = gyroEPool.onSell([amountIn], pairData);
-          expect(amountOut.length).toBe(1);
-          expect(amountOut[0].toString()).toBe('13499365736688193741');
-        });
-      });
-
-      describe('Swap Functions  - 18decimals>6decimals', () => {
-        const pairData: GyroEPoolPairData = {
-          tokenInIsToken0: false,
-          balances: [
-            BigNumber.from('18186193501000000000000'),
-            BigNumber.from('26629907962671451455387'),
-          ],
-          indexIn: 1,
-          indexOut: 0,
-          scalingFactors: [
-            1000000000000000000000000000000n,
-            1000000000000000000n,
-          ],
-          swapFee: 200000000000000n,
-          gyroDerivedParams: {
-            tauAlpha: {
-              x: BigNumber.from('-99921684096872623630266893017017590000'),
-              y: BigNumber.from('3956898690236155895758568963473897000'),
-            },
-            tauBeta: {
-              x: BigNumber.from('99921684096872623626859806443439160000'),
-              y: BigNumber.from('3956898690236155981796108700303143000'),
-            },
-            u: BigNumber.from('99921684096872623515276234437562470000'),
-            v: BigNumber.from('3956898690236155934291169066298950000'),
-            w: BigNumber.from('43018769868414623130'),
-            z: BigNumber.from('-1703543286789219094'),
-            dSq: BigNumber.from('99999999999999999886624093342106120000'),
-          },
-          gyroParams: {
-            alpha: BigNumber.from('980000000000000000'),
-            beta: BigNumber.from('1020408163265306122'),
-            c: BigNumber.from('707106781186547524'),
-            s: BigNumber.from('707106781186547524'),
-            lambda: BigNumber.from('2500000000000000000000'),
-          },
-          tokenRates: [],
-          rateProviders: [],
-        };
-
-        it('getSwapMaxAmount', async () => {
-          const swapMaxAmount = gyroEPool.getSwapMaxAmount(
-            pairData,
-            SwapSide.SELL,
-          );
-          expect(swapMaxAmount).toBe(BigInt('18186175314806499000000'));
-        });
-
-        it('swap', async function () {
-          const amountIn = BigInt('13500000000000000000');
-          const amountOut = gyroEPool.onSell([amountIn], pairData);
-          expect(amountOut.length).toBe(1);
-          expect(amountOut[0].toString()).toBe('13495227');
-        });
-      });
-    });
-
-    describe('Onchain Compare', () => {
-      it('exactIn', async function () {
-        const blocknumber = 54571344;
-        // USDC/TUSD
-        const poolId =
-          '0x97469e6236bd467cd147065f77752b00efadce8a0002000000000000000008c0';
-        const tokenIn = tokens.USDC.address;
-        const tokenOut = tokens.TUSD.address;
-        const amountIn = BigInt('1000000');
-
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        const poolSg = pools.filter(p => p.id === poolId)[0];
-        const state = await balancerPools.getOnChainState(
-          [poolSg],
-          blocknumber,
-        );
-        const poolState = state[poolSg.address];
-
-        const pairData = gyroEPool.parsePoolPairData(
-          poolSg,
-          poolState,
-          tokenIn,
-          tokenOut,
-        );
-        const amountOut = gyroEPool.onSell([amountIn], pairData);
-        const deltas = await queryOnChain(
-          rpcUrl,
-          blocknumber,
-          poolId,
-          0,
-          tokenIn,
-          tokenOut,
-          amountIn,
-        );
-        expect(amountIn).toEqual(deltas[0]);
-        expect(amountOut[0] + deltas[1]).toEqual(0n);
-      });
-      it('exactOut', async function () {
-        const blocknumber = 54571344;
-        // USDC/TUSD
-        const poolId =
-          '0x97469e6236bd467cd147065f77752b00efadce8a0002000000000000000008c0';
-        const tokenIn = tokens.USDC.address;
-        const tokenOut = tokens.TUSD.address;
-        const amountOut = BigInt('2000000000000000000');
-
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        const poolSg = pools.filter(p => p.id === poolId)[0];
-        const state = await balancerPools.getOnChainState(
-          [poolSg],
-          blocknumber,
-        );
-        const poolState = state[poolSg.address];
-
-        const pairData = gyroEPool.parsePoolPairData(
-          poolSg,
-          poolState,
-          tokenIn,
-          tokenOut,
-        );
-        const amountIn = gyroEPool.onBuy([amountOut], pairData);
-        const deltas = await queryOnChain(
-          rpcUrl,
-          blocknumber,
-          poolId,
-          1,
-          tokenIn,
-          tokenOut,
-          amountOut,
-        );
-        expect(amountIn[0]).toEqual(deltas[0]);
-        expect(amountOut + deltas[1]).toEqual(0n);
-      });
-    });
-  });
-
-  describe('GyroE Pool V2', () => {
-    describe('Pool Fetching', () => {
-      it('should fetch GyroE Pool with correct fields from Subgraph', async function () {
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        // wmatic/xmatic
-        const GyroEPoolId =
-          '0xee278d943584dd8640eaf4cc6c7a5c80c0073e85000200000000000000000bc7';
-        const GyroE = pools.filter(p => p.id === GyroEPoolId);
-        expect(GyroE.length).toBe(1);
-        GyroEPoolSg = GyroE[0];
-        expect(GyroEPoolSg.tokens.length).toBe(2);
-        expect(GyroEPoolSg.poolTypeVersion).toEqual(2);
-      });
-
-      it('getOnChainState', async function () {
-        const blocknumber = 54571344;
-        const state = await balancerPools.getOnChainState(
-          [GyroEPoolSg],
-          blocknumber,
-        );
-        GyroEPoolState = state[GyroEPoolSg.address];
-        expect(GyroEPoolState.swapFee).toBe(BigInt('100000000000000'));
-        expect(
-          GyroEPoolState.tokens[tokens.WMATIC.address.toLowerCase()].balance,
-        ).toBe(231918780712184629424641n);
-        expect(
-          GyroEPoolState.tokens[tokens.MATICX.address.toLowerCase()].balance,
-        ).toBe(1614748628144003818699851n);
-        expect(GyroEPoolState.rateProviders![0]).toBe(
-          '0x0000000000000000000000000000000000000000',
-        );
-        expect(GyroEPoolState.rateProviders![1].toLowerCase()).toBe(
-          '0xee652bbf72689aa59f0b8f981c9c90e2a8af8d8f',
-        );
-        // Token has no rate provider so rate should be 1
-        expect(GyroEPoolState.tokenRates![0]).toBe(1000000000000000000n);
-        // Token has a rate provider so should use that rate
-        expect(GyroEPoolState.tokenRates![1]).toBe(1103299689517375348n);
-      });
-    });
-
-    describe('Onchain Compare', () => {
-      it('exactIn', async function () {
-        const blocknumber = 54571344;
-        // wmatic/xmatic
-        const poolId =
-          '0xee278d943584dd8640eaf4cc6c7a5c80c0073e85000200000000000000000bc7';
-        const tokenIn = tokens.MATICX.address;
-        const tokenOut = tokens.WMATIC.address;
-        const amountIn = BigInt('110000000000000000');
-
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        const poolSg = pools.filter(p => p.id === poolId)[0];
-        const state = await balancerPools.getOnChainState(
-          [poolSg],
-          blocknumber,
-        );
-        const poolState = state[poolSg.address];
-
-        const pairData = gyroEPool.parsePoolPairData(
-          poolSg,
-          poolState,
-          tokenIn,
-          tokenOut,
-        );
-        const amountOut = gyroEPool.onSell([amountIn], pairData);
-        const deltas = await queryOnChain(
-          rpcUrl,
-          blocknumber,
-          poolId,
-          0,
-          tokenIn,
-          tokenOut,
-          amountIn,
-        );
-        expect(amountIn).toEqual(deltas[0]);
-        expect(amountOut[0] + deltas[1]).toEqual(0n);
-      });
-      it('exactOut', async function () {
-        const blocknumber = 54571344;
-        // wmatic/xmatic
-        const poolId =
-          '0xee278d943584dd8640eaf4cc6c7a5c80c0073e85000200000000000000000bc7';
-        const tokenIn = tokens.MATICX.address;
-        const tokenOut = tokens.WMATIC.address;
-        const amountOut = BigInt('2000000000000000000');
-
-        const pools = await balancerPools.fetchAllSubgraphPools();
-        const poolSg = pools.filter(p => p.id === poolId)[0];
-        const state = await balancerPools.getOnChainState(
-          [poolSg],
-          blocknumber,
-        );
-        const poolState = state[poolSg.address];
-
-        const pairData = gyroEPool.parsePoolPairData(
-          poolSg,
-          poolState,
-          tokenIn,
-          tokenOut,
-        );
-        const amountIn = gyroEPool.onBuy([amountOut], pairData);
-        const deltas = await queryOnChain(
-          rpcUrl,
-          blocknumber,
-          poolId,
-          1,
-          tokenIn,
-          tokenOut,
-          amountOut,
-        );
-        expect(amountIn[0]).toEqual(deltas[0]);
-        expect(amountOut + deltas[1]).toEqual(0n);
-      });
-    });
-  });
-});