@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.4

package/src/dex/angle-staked-stable/config.ts

@@ -0,0 +1,139 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const AngleStakedStableConfig: DexConfigMap<DexParams> = {
+  // USDA <-> stUSD
+  AngleStakedStableUSD: {
+    [Network.ARBITRUM]: {
+      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
+      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
+    },
+    [Network.MAINNET]: {
+      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
+      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
+    },
+    [Network.OPTIMISM]: {
+      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
+      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
+    },
+    [Network.POLYGON]: {
+      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
+      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
+    },
+    [Network.BASE]: {
+      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
+      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
+    },
+    [Network.BSC]: {
+      agToken: '0x0000206329b97db379d5e1bf586bbdb969c63274',
+      stakeToken: '0x0022228a2cc5e7ef0274a7baa600d44da5ab5776',
+    },
+  },
+  // EURA <-> stEUR
+  AngleStakedStableEUR: {
+    [Network.ARBITRUM]: {
+      agToken: '0xfa5ed56a203466cbbc2430a43c66b9d8723528e7',
+      stakeToken: '0x004626a008b1acdc4c74ab51644093b155e59a23',
+    },
+    [Network.MAINNET]: {
+      agToken: '0x1a7e4e63778b4f12a199c062f3efdd288afcbce8',
+      stakeToken: '0x004626a008b1acdc4c74ab51644093b155e59a23',
+    },
+    [Network.OPTIMISM]: {
+      agToken: '0x9485aca5bbbe1667ad97c7fe7c4531a624c8b1ed',
+      stakeToken: '0x004626a008b1acdc4c74ab51644093b155e59a23',
+    },
+    [Network.POLYGON]: {
+      agToken: '0xe0b52e49357fd4daf2c15e02058dce6bc0057db4',
+      stakeToken: '0x004626a008b1acdc4c74ab51644093b155e59a23',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'ArbitrumAdapter03',
+        index: 1,
+      },
+    ],
+    [SwapSide.BUY]: [
+      {
+        name: 'ArbitrumBuyAdapter',
+        index: 10,
+      },
+    ],
+  },
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'Adapter06',
+        index: 1,
+      },
+    ],
+    [SwapSide.BUY]: [
+      {
+        name: 'BuyAdapter02',
+        index: 4,
+      },
+    ],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'OptimismAdapter02',
+        index: 1,
+      },
+    ],
+    [SwapSide.BUY]: [
+      {
+        name: 'OptimismBuyAdapter',
+        index: 6,
+      },
+    ],
+  },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'BaseAdapter01',
+        index: 11,
+      },
+    ],
+    [SwapSide.BUY]: [
+      {
+        name: 'BaseBuyAdapter',
+        index: 7,
+      },
+    ],
+  },
+  [Network.POLYGON]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'PolygonAdapter02',
+        index: 10,
+      },
+    ],
+    [SwapSide.BUY]: [
+      {
+        name: 'PolygonBuyAdapter',
+        index: 9,
+      },
+    ],
+  },
+  [Network.BSC]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'BscAdapter02',
+        index: 10,
+      },
+    ],
+    [SwapSide.BUY]: [
+      {
+        name: 'BscBuyAdapter',
+        index: 8,
+      },
+    ],
+  },
+};

package/src/dex/angle-staked-stable/types.ts

@@ -0,0 +1,16 @@
+import { Address } from '../../types';
+
+export type PoolState = {
+  totalAssets: bigint;
+  totalSupply: bigint;
+  lastUpdate: bigint;
+  rate: bigint;
+  paused: boolean;
+};
+
+export type AngleStakedStableData = { exchange: Address };
+
+export type DexParams = {
+  agToken: Address;
+  stakeToken: Address;
+};

package/src/dex/bProtocol/bProtocol.ts

@@ -12,6 +12,7 @@ import { SimpleExchange } from '../simple-exchange';
 import BProtocolABI from '../../abi/BProtocol.json';
 import { IDexHelper } from '../../dex-helper';
 import { BProtocolData, BProtocolFunctions, BProtocolParam } from './types';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class BProtocol
   extends SimpleExchange
@@ -95,6 +96,13 @@ export class BProtocol
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: data.exchange,
+      returnAmountPos:
+        _side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              swapFunction,
+            )
+          : undefined,
     };
   }
 }

package/src/dex/balancer-v1/balancer-v1.ts

@@ -43,6 +43,7 @@ import BalancerCustomMulticallABI from '../../abi/BalancerCustomMulticall.json';
 import { NumberAsString, SwapSide } from '@paraswap/core';
 import { BigNumber, ethers } from 'ethers';
 import { SpecialDex } from '../../executor/types';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 const {
   utils: { hexlify, hexZeroPad, solidityPack },
@@ -416,6 +417,14 @@ export class BalancerV1
       dexFuncHasRecipient: false,
       exchangeData: exchangeData,
       targetExchange: this.config.exchangeProxy,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              BalancerV1.proxyIface,
+              swapFunction,
+              'totalAmountOut',
+            )
+          : undefined,
     };
   }
 

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

@@ -479,6 +479,70 @@ describe('BalancerV2 E2E', () => {
       );
     });
 
+    describe('GyroE pool', () => {
+      const sideToContractMethods = new Map([
+        [
+          SwapSide.SELL,
+          [
+            ContractMethod.simpleSwap,
+            // ContractMethod.multiSwap,
+            // ContractMethod.megaSwap,
+          ],
+        ],
+        // [
+        // SwapSide.BUY,
+        // [
+        //   ContractMethod.simpleBuy,
+        //   ContractMethod.buy
+        // ],
+        // ],
+      ]);
+
+      const pairs: { name: string; amount: string }[][] = [
+        [
+          { name: 'GYD', amount: '10000000000000000000' },
+          { name: 'sDAI', amount: '10000000000000000000' },
+        ],
+      ];
+
+      sideToContractMethods.forEach((contractMethods, side) =>
+        describe(`${side}`, () => {
+          contractMethods.forEach((contractMethod: ContractMethod) => {
+            pairs.forEach(pair => {
+              describe(`${contractMethod}`, () => {
+                it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                  await testE2E(
+                    tokens[pair[0].name],
+                    tokens[pair[1].name],
+                    holders[pair[0].name],
+                    pair[0].amount,
+                    side,
+                    dexKey,
+                    contractMethod,
+                    network,
+                    provider,
+                  );
+                });
+                it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                  await testE2E(
+                    tokens[pair[1].name],
+                    tokens[pair[0].name],
+                    holders[pair[1].name],
+                    pair[1].amount,
+                    side,
+                    dexKey,
+                    contractMethod,
+                    network,
+                    provider,
+                  );
+                });
+              });
+            });
+          });
+        }),
+      );
+    });
+
     //daniel: BPT swaps are currently not supported, we've refactored to focus on mainToken paths
     /*it('MAIN TOKEN -> BPT, LinearPool', async () => {
         // Linear Pools allow swaps between main token (i.e. USDT) and pools BPT
@@ -735,6 +799,36 @@ describe('BalancerV2 E2E', () => {
         });
       }),
     );
+
+    it('USDC -> USDT through Gyro3', async () => {
+      await testE2E(
+        tokens['USDC'],
+        tokens['USDT'],
+        holders['USDC'],
+        '10000000', // 10 * 1e6
+        SwapSide.SELL,
+        dexKey,
+        ContractMethod.multiSwap,
+        network,
+        provider,
+        [`${dexKey}_0x17f1ef81707811ea15d9ee7c741179bbe2a63887`],
+      );
+    });
+
+    it('USDC -> USDT through Gyro3 (BUY)', async () => {
+      await testE2E(
+        tokens['USDC'],
+        tokens['USDT'],
+        holders['USDC'],
+        '10000000', // 10 * 1e6
+        SwapSide.BUY,
+        dexKey,
+        ContractMethod.multiSwap,
+        network,
+        provider,
+        [`${dexKey}_0x17f1ef81707811ea15d9ee7c741179bbe2a63887`],
+      );
+    });
   });
 
   describe('BalancerV2 ARBITRUM', () => {

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

@@ -0,0 +1,268 @@
+// 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
+      });
+    });
+  });
+});