@paraswap/dex-lib 2.16.1 → 2.16.2-balancer-v2-buy.2

package/src/dex/balancer-v2/pools/weighted/WeightedMath.ts

@@ -0,0 +1,84 @@
+import { MathSol } from '../../balancer-v2-math';
+
+const _require = (b: boolean, message: string) => {
+  if (!b) throw new Error(message);
+};
+
+export class WeightedMath {
+  static _MAX_IN_RATIO = 300000000000000000n;
+  static _MAX_OUT_RATIO = 300000000000000000n;
+
+  static _calcInGivenOut(
+    balanceIn: bigint,
+    weightIn: bigint,
+    balanceOut: bigint,
+    weightOut: bigint,
+    amountsOut: bigint[],
+  ): bigint[] {
+    /* https://docs.balancer.fi/reference/math/weighted-math.html#ingivenout */
+    /**********************************************************************************************
+     // outGivenOut                                                                              //
+     // aI = amountIn                                                                            //
+     // bI = balanceIn                                                                           //
+     // bO = balanceOut              /  /            bO             \    (wO / wI)     \         //
+     // aO = amountOut    aI = bI * |  | -------------------------- | ^            - 1  |        //
+     // wI = weightIn               \  \       ( bO - aO )         /                   /         //
+     // wO = weightOut                                                                           //
+     *********************************************************************************************/
+    const exponent = MathSol.divUpFixed(weightOut, weightIn);
+    return amountsOut.map((amountOut) => {
+      _require(
+        amountOut <= MathSol.mulDownFixed(balanceOut, this._MAX_OUT_RATIO),
+        'Errors.MAX_OUT_RATIO',
+      );
+
+      const denominator = balanceOut - amountOut;
+      const base = MathSol.divUpFixed(balanceOut, denominator);
+      const power = MathSol.powUpFixed(base, exponent);
+      const ratio = MathSol.sub(power, MathSol.ONE);
+
+      return MathSol.mulUpFixed(balanceIn, ratio);
+    });
+  }
+
+  // Computes how many tokens can be taken out of a pool if `amountIn` are sent, given the
+  // current balances and weights.
+  static _calcOutGivenIn(
+    balanceIn: bigint,
+    weightIn: bigint,
+    balanceOut: bigint,
+    weightOut: bigint,
+    amountsIn: bigint[],
+  ): bigint[] {
+    /* https://docs.balancer.fi/reference/math/weighted-math.html#outgivenin */
+    /**********************************************************************************************
+     // outGivenIn                                                                                //
+     // aO = amountOut                                                                            //
+     // bO = balanceOut                                                                           //
+     // bI = balanceIn              /      /            bI             \    (wI / wO) \           //
+     // aI = amountIn    aO = bO * |  1 - | --------------------------  | ^            |          //
+     // wI = weightIn               \      \       ( bI + aI )         /              /           //
+     // wO = weightOut                                                                            //
+     **********************************************************************************************/
+
+      // Amount out, so we round down overall.
+
+      // The multiplication rounds down, and the subtrahend (power) rounds up (so the base rounds up too).
+      // Because bI / (bI + aI) <= 1, the exponent rounds down.
+
+      // Cannot exceed maximum in ratio
+
+    const exponent = MathSol.divDownFixed(weightIn, weightOut);
+    return amountsIn.map(amountIn => {
+      _require(
+        amountIn <= MathSol.mulDownFixed(balanceIn, this._MAX_IN_RATIO),
+        'Errors.MAX_IN_RATIO',
+      );
+      const denominator = balanceIn + amountIn;
+      const base = MathSol.divUpFixed(balanceIn, denominator);
+      const power = MathSol.powUpFixed(base, exponent);
+
+      return MathSol.mulDownFixed(balanceOut, MathSol.complementFixed(power));
+    });
+  }
+}

package/src/dex/balancer-v2/pools/weighted/WeightedPool.ts

@@ -0,0 +1,189 @@
+import { Interface } from '@ethersproject/abi';
+import WeightedPoolABI from '../../../../abi/balancer-v2/weighted-pool.json';
+import { callData, PoolState, SubgraphPoolBase, TokenState } from '../../types';
+import { decodeThrowError, getTokenScalingFactor } from '../../utils';
+import { SwapSide } from '../../../../constants';
+import { BaseMinimalSwapInfoPool } from '../balancer-v2-pool';
+import { WeightedMath } from './WeightedMath';
+
+export type WeightedPoolPairData = {
+  tokenInBalance: bigint;
+  tokenOutBalance: bigint;
+  tokenInScalingFactor: bigint;
+  tokenOutScalingFactor: bigint;
+  tokenInWeight: bigint;
+  tokenOutWeight: bigint;
+  swapFee: bigint;
+};
+
+
+export class WeightedPool extends BaseMinimalSwapInfoPool {
+  vaultAddress: string;
+  vaultInterface: Interface;
+  poolInterface: Interface;
+
+  constructor(vaultAddress: string, vaultInterface: Interface) {
+    super();
+    this.vaultAddress = vaultAddress;
+    this.vaultInterface = vaultInterface;
+    this.poolInterface = new Interface(WeightedPoolABI);
+  }
+
+  _onSwapGivenOut(
+    tokenAmountsOut: bigint[],
+    currentBalanceTokenIn: bigint,
+    currentBalanceTokenOut: bigint,
+    _weightIn: bigint,
+    _weightOut: bigint,
+  ): bigint[] {
+    return WeightedMath._calcInGivenOut(
+      currentBalanceTokenIn,
+      _weightIn,
+      currentBalanceTokenOut,
+      _weightOut,
+      tokenAmountsOut,
+    );
+  }
+
+  _onSwapGivenIn(
+    tokenAmountsIn: bigint[],
+    currentBalanceTokenIn: bigint,
+    currentBalanceTokenOut: bigint,
+    _weightIn: bigint,
+    _weightOut: bigint,
+  ): bigint[] {
+    return WeightedMath._calcOutGivenIn(
+      currentBalanceTokenIn,
+      _weightIn,
+      currentBalanceTokenOut,
+      _weightOut,
+      tokenAmountsIn,
+    );
+  }
+
+  /*
+  Helper function to parse pool data into params for onSell function.
+  */
+  parsePoolPairData(
+    pool: SubgraphPoolBase,
+    poolState: PoolState,
+    tokenIn: string,
+    tokenOut: string,
+  ): WeightedPoolPairData {
+    const inAddress = tokenIn.toLowerCase();
+    const outAddress = tokenOut.toLowerCase();
+
+    const tIn = pool.tokens.find(t => t.address.toLowerCase() === inAddress);
+    const tOut = pool.tokens.find(t => t.address.toLowerCase() === outAddress);
+
+    if (!tIn || !tOut) return {} as WeightedPoolPairData;
+
+    const tokenInBalance = poolState.tokens[inAddress].balance;
+    const tokenOutBalance = poolState.tokens[outAddress].balance;
+    const tokenInWeight = poolState.tokens[inAddress].weight || 0n;
+    const tokenOutWeight = poolState.tokens[outAddress].weight || 0n;
+    const tokenInScalingFactor = getTokenScalingFactor(tIn.decimals);
+    const tokenOutScalingFactor = getTokenScalingFactor(tOut.decimals);
+
+    const poolPairData: WeightedPoolPairData = {
+      tokenInBalance,
+      tokenOutBalance,
+      tokenInScalingFactor,
+      tokenOutScalingFactor,
+      tokenInWeight,
+      tokenOutWeight,
+      swapFee: poolState.swapFee,
+    };
+    return poolPairData;
+  }
+
+  /*
+  Helper function to construct onchain multicall data for WeightedPool (also 'LiquidityBootstrapping' and 'Investment' pool types).
+  */
+  getOnChainCalls(pool: SubgraphPoolBase): callData[] {
+    return [
+      {
+        target: this.vaultAddress,
+        callData: this.vaultInterface.encodeFunctionData('getPoolTokens', [
+          pool.id,
+        ]),
+      },
+      {
+        target: pool.address,
+        callData: this.poolInterface.encodeFunctionData('getSwapFeePercentage'),
+      },
+      {
+        target: pool.address,
+        callData: this.poolInterface.encodeFunctionData('getNormalizedWeights'),
+      },
+    ];
+  }
+
+  /*
+  Helper function to decodes multicall data for a Weighted Pool.
+  data must contain returnData
+  startIndex is where to start in returnData. Allows this decode function to be called along with other pool types.
+  */
+  decodeOnChainCalls(
+    pool: SubgraphPoolBase,
+    data: { success: boolean; returnData: any }[],
+    startIndex: number,
+  ): [{ [address: string]: PoolState }, number] {
+    const pools = {} as { [address: string]: PoolState };
+
+    const poolTokens = decodeThrowError(
+      this.vaultInterface,
+      'getPoolTokens',
+      data[startIndex++],
+      pool.address,
+    );
+    const swapFee = decodeThrowError(
+      this.poolInterface,
+      'getSwapFeePercentage',
+      data[startIndex++],
+      pool.address,
+    )[0];
+    const normalisedWeights = decodeThrowError(
+      this.poolInterface,
+      'getNormalizedWeights',
+      data[startIndex++],
+      pool.address,
+    )[0];
+
+    const poolState: PoolState = {
+      swapFee: BigInt(swapFee.toString()),
+      tokens: poolTokens.tokens.reduce(
+        (ptAcc: { [address: string]: TokenState }, pt: string, j: number) => {
+          const tokenState: TokenState = {
+            balance: BigInt(poolTokens.balances[j].toString()),
+          };
+
+          if (normalisedWeights)
+            tokenState.weight = BigInt(normalisedWeights[j].toString());
+
+          ptAcc[pt.toLowerCase()] = tokenState;
+          return ptAcc;
+        },
+        {},
+      ),
+      orderedTokens: poolTokens.tokens,
+    };
+
+    pools[pool.address] = poolState;
+
+    return [pools, startIndex];
+  }
+
+  /*
+  For weighted pools there is a Swap limit of 30%: amounts swapped may not be larger than this percentage of total balance.
+  */
+  getSwapMaxAmount(poolPairData: WeightedPoolPairData, side: SwapSide): bigint {
+    return (
+      ((side === SwapSide.SELL
+        ? poolPairData.tokenInBalance
+        : poolPairData.tokenOutBalance) *
+        3n) /
+      10n
+    );
+  }
+}

package/src/dex/index.ts

@@ -63,6 +63,8 @@ import { MaverickV1 } from './maverick-v1/maverick-v1';
 import { QuickSwapV3 } from './quickswap/quickswap-v3';
 import { ZyberSwapV3 } from './quickswap/zyberswap-v3';
 import { TraderJoeV2 } from './trader-joe-v2';
+import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
+import { PancakeswapV3 } from './uniswap-v3/forks/pancakeswap-v3/pancakeswap-v3';
 
 const LegacyDexes = [
   CurveV2,
@@ -80,6 +82,7 @@ const LegacyDexes = [
   DodoV2,
   QuickSwapV3,
   ZyberSwapV3,
+  SpiritSwapV3,
   TraderJoeV2,
   Jarvis,
   Lido,
@@ -94,6 +97,7 @@ const Dexes = [
   BalancerV2,
   UniswapV2,
   UniswapV3,
+  PancakeswapV3,
   BiSwap,
   MDEX,
   Dfyn,

package/src/dex/maverick-v1/config.ts

@@ -10,7 +10,7 @@ export const MaverickV1Config: DexConfigMap<DexParams> = {
   MaverickV1: {
     [Network.MAINNET]: {
       subgraphURL:
-        'https://gateway.thegraph.com/api/4b42aaaee3e81a3f29390e9df7010cbc/subgraphs/id/9n4uEbt1XV6DnYH7AGHJ84Gh2fpu68iwxwBKnWqVMX9G',
+        'https://api.thegraph.com/subgraphs/name/maverickprotocol/maverick-mainnet',
       routerAddress: '0x4a585e0f7c18e2c414221d6402652d5e0990e5f8',
       poolInspectorAddress: '0xaA5BF61a664109e959D69C38734d4EA7dF74e456',
     },

package/src/dex/quickswap/config.ts

@@ -21,4 +21,13 @@ export const QuickSwapConfig: DexConfigMap<DexParams> = {
         '0xfa2ad44b9e39d38a7d396bb44a41ea957ac7b622c5c6afdc285728c300b3382a',
     },
   },
+  SpiritSwapV3: {
+    [Network.FANTOM]: {
+      factoryAddress: '0xC58A98644fCeee73bc2B6d349B3102627e2Ec58e',
+      router: '0x03108EDEd4902e89781839c885496c6de9D21956',
+      quoteAddress: '0xc4D1310D60A36c7d849A332Be8Dcff29603fe907',
+      initCode:
+        '0xa360004fb86ddf4cd7fe9aa67d0c6a7f7812d9069142659003dc503e1d7d241f',
+    },
+  },
 };

package/src/dex/quickswap/quickswap-e2e.test.ts

@@ -354,4 +354,98 @@ describe('QuickSwap', () => {
       });
     });
   });
+
+  describe('Fantom', () => {
+    const network = Network.FANTOM;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    describe('SpiritSwapV3', () => {
+      const dexKey = 'SpiritSwapV3';
+
+      const sideToContractMethods = new Map([
+        [
+          SwapSide.SELL,
+          [
+            ContractMethod.simpleSwap,
+            ContractMethod.multiSwap,
+            ContractMethod.megaSwap,
+          ],
+        ],
+        [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+      ]);
+
+      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
+        [
+          [
+            {
+              name: 'USDC',
+              sellAmount: '100',
+              buyAmount: '10000000000000000',
+            },
+            {
+              name: 'WFTM',
+              sellAmount: '10000000000000000',
+              buyAmount: '100',
+            },
+          ],
+          [
+            {
+              name: 'FTM',
+              sellAmount: '1000000000000000',
+              buyAmount: '100',
+            },
+            {
+              name: 'USDC',
+              sellAmount: '100',
+              buyAmount: '10000000000000000',
+            },
+          ],
+        ];
+
+      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],
+                    side === SwapSide.SELL
+                      ? pair[0].sellAmount
+                      : pair[0].buyAmount,
+                    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],
+                    side === SwapSide.SELL
+                      ? pair[1].sellAmount
+                      : pair[1].buyAmount,
+                    side,
+                    dexKey,
+                    contractMethod,
+                    network,
+                    provider,
+                  );
+                });
+              });
+            });
+          });
+        }),
+      );
+    });
+  });
 });

package/src/dex/quickswap/spiritswap-v3.ts

@@ -0,0 +1,19 @@
+import { IDexHelper } from '../../dex-helper';
+import _ from 'lodash';
+import { QuickSwapConfig } from './config';
+import { QuickSwapV3 } from './quickswap-v3';
+
+const config = _.pick(QuickSwapConfig, ['SpiritSwapV3']).SpiritSwapV3;
+
+export class SpiritSwapV3 extends QuickSwapV3 {
+  static dexKeys = ['spiritswapv3'];
+
+  // public static dexKeysWithNetwork
+  constructor(dexHelper: IDexHelper) {
+    super(
+      dexHelper,
+      'spiritswapv3',
+      config[dexHelper.config.data.network].router,
+    );
+  }
+}

package/src/dex/uniswap-v3/config.ts

@@ -4,6 +4,7 @@ import { Network, SwapSide } from '../../constants';
 import { Address } from '../../types';
 
 const SUPPORTED_FEES = [10000n, 3000n, 500n, 100n];
+const PANCAKE_SUPPORTED_FEES = [10000n, 2500n, 500n, 100n];
 
 // Pools that will be initialized on app startup
 // They are added for testing
@@ -22,6 +23,7 @@ export const PoolsToPreload: DexConfigMap<
       },
     ],
   },
+  PancakeswapV3: {},
 };
 
 export const UniswapV3Config: DexConfigMap<DexParams> = {
@@ -34,6 +36,8 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       stateMulticall: '0x9c764D2e92dA68E4CDfD784B902283A095ff8b63',
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       chunksCount: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL: 'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3',
     },
     [Network.BSC]: {
       factory: '0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7',
@@ -43,6 +47,9 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       stateMulticall: '0x593F39A4Ba26A9c8ed2128ac95D109E8e403C485',
       uniswapMulticall: '0x963Df249eD09c358A4819E39d9Cd5736c3087184',
       chunksCount: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-bsc',
     },
     [Network.POLYGON]: {
       factory: '0x1F98431c8aD98523631AE4a59f267346ea31F984',
@@ -52,6 +59,9 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       stateMulticall: '0x6Dc993Fe1e945A640576B4Dca81281d8e998DF71',
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       chunksCount: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-polygon',
     },
     [Network.ARBITRUM]: {
       factory: '0x1F98431c8aD98523631AE4a59f267346ea31F984',
@@ -61,6 +71,9 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       stateMulticall: '0xaBB58098A7B5172A9b0B38a1925A522dbf0b4FC3',
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       chunksCount: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/ianlapham/arbitrum-minimal',
     },
     [Network.OPTIMISM]: {
       factory: '0x1F98431c8aD98523631AE4a59f267346ea31F984',
@@ -70,6 +83,39 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       stateMulticall: '0x4FF0dEC5f9a763Aa1E5C2a962aa6f4eDFeE4f9eA',
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       chunksCount: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/ianlapham/optimism-post-regenesis',
+    },
+  },
+  PancakeswapV3: {
+    [Network.MAINNET]: {
+      factory: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+      deployer: '0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9',
+      quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+      router: '0x1b81D678ffb9C0263b24A97847620C99d213eB14',
+      supportedFees: PANCAKE_SUPPORTED_FEES,
+      stateMulticall: '0x80898f80cFA3Fa3AbF410d90e69aDc432AE5D4c2',
+      uniswapMulticall: '0xac1cE734566f390A94b00eb9bf561c2625BF44ea',
+      chunksCount: 10,
+      initHash:
+        '0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/pancakeswap/exchange-v3-eth',
+    },
+    [Network.BSC]: {
+      factory: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+      deployer: '0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9',
+      quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+      router: '0x1b81D678ffb9C0263b24A97847620C99d213eB14',
+      supportedFees: PANCAKE_SUPPORTED_FEES,
+      stateMulticall: '0x9DAd2ED7ADc6eaacf81589Cd043579c9684E5C81',
+      uniswapMulticall: '0xac1cE734566f390A94b00eb9bf561c2625BF44ea',
+      chunksCount: 10,
+      initHash:
+        '0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/pancakeswap/exchange-v3-bsc',
     },
   },
 };
@@ -95,4 +141,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 3 }],
     [SwapSide.BUY]: [{ name: 'OptimismBuyAdapter', index: 2 }],
   },
+  [Network.FANTOM]: {
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 11 }],
+    [SwapSide.BUY]: [{ name: 'FantomBuyAdapter', index: 3 }],
+  },
 };

package/src/dex/uniswap-v3/forks/pancakeswap-v3/pancakeswap-v3.ts

@@ -0,0 +1,28 @@
+import { UniswapV3 } from '../../uniswap-v3';
+import { Network } from '../../../../constants';
+import { IDexHelper } from '../../../../dex-helper';
+import { Interface } from '@ethersproject/abi';
+import PancakeswapV3RouterABI from '../../../../abi/uniswap-v3/pancakeswap-v3/PancakeswapV3Router.abi.json';
+import PancakeswapV3QuoterV2ABI from '../../../../abi/uniswap-v3/pancakeswap-v3/PancakeswapV3QuoterV2.abi.json';
+import { getDexKeysWithNetwork } from '../../../../utils';
+import _ from 'lodash';
+import { UniswapV3Config } from '../../config';
+
+export class PancakeswapV3 extends UniswapV3 {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(UniswapV3Config, ['PancakeswapV3']));
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+      undefined,
+      new Interface(PancakeswapV3RouterABI),
+      new Interface(PancakeswapV3QuoterV2ABI),
+    );
+  }
+}

package/src/dex/uniswap-v3/types.ts

@@ -67,6 +67,9 @@ export type DexParams = {
   uniswapMulticall: Address;
   supportedFees: bigint[];
   chunksCount: number;
+  deployer?: Address;
+  subgraphURL: string;
+  initHash: string;
 };
 
 export type UniswapV3SellParam = {