@paraswap/dex-lib 2.16.3 → 2.16.4-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/balancer-v2/types.ts

@@ -33,6 +33,7 @@ export type PoolState = {
   };
   swapFee: bigint;
   orderedTokens: string[];
+  rate?: bigint;
   amp?: bigint;
   // Linear Pools
   mainIndex?: number;

package/src/dex/index.ts

@@ -65,6 +65,7 @@ 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';
+import { TraderJoeV21 } from './trader-joe-v2.1';
 
 const LegacyDexes = [
   CurveV2,
@@ -84,6 +85,7 @@ const LegacyDexes = [
   ZyberSwapV3,
   SpiritSwapV3,
   TraderJoeV2,
+  TraderJoeV21,
   Jarvis,
   Lido,
   AugustusRFQOrder,

package/src/dex/trader-joe-v2.1.ts

@@ -0,0 +1,155 @@
+import { Network, SwapSide } from '../constants';
+import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
+import { IDexTxBuilder } from './idex';
+import { IDexHelper } from '../dex-helper';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from './simple-exchange';
+import { NumberAsString } from '@paraswap/core';
+import { AsyncOrSync } from 'ts-essentials';
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import TraderJoeV21RouterABI from '../abi/TraderJoeV21Router.json';
+
+const TRADERJOE_V2_1_ROUTER_ADDRESS: { [network: number]: Address } = {
+  [Network.AVALANCHE]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
+  [Network.ARBITRUM]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
+  [Network.BSC]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
+};
+
+type RouterPath = [
+  pairBinSteps: NumberAsString[],
+  versions: NumberAsString[],
+  tokenPath: Address[],
+];
+type TraderJoeV2RouterSellParams = [
+  _amountIn: NumberAsString,
+  _amountOutMin: NumberAsString,
+  _routerPath: RouterPath,
+  to: Address,
+  _deadline: string,
+];
+
+type TraderJoeV2RouterBuyParams = [
+  _amountOut: NumberAsString,
+  _amountInMax: NumberAsString,
+  _routerPath: RouterPath,
+  to: Address,
+  _deadline: string,
+];
+
+type TraderJoeV2RouterParam =
+  | TraderJoeV2RouterSellParams
+  | TraderJoeV2RouterBuyParams;
+
+export type TraderJoeV2Data = {
+  tokenIn: string; // redundant
+  tokenOut: string; // redundant
+  binStep: string;
+};
+
+enum TraderJoeV2RouterFunctions {
+  swapExactTokensForTokens = 'swapExactTokensForTokens',
+  swapTokensForExactTokens = 'swapTokensForExactTokens',
+}
+export class TraderJoeV21
+  extends SimpleExchange
+  implements IDexTxBuilder<TraderJoeV2Data, TraderJoeV2RouterParam>
+{
+  static dexKeys = ['traderjoev2.1'];
+  protected routerAddress: string;
+  exchangeRouterInterface: Interface;
+  needWrapNative = true;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'traderjoev2.1');
+
+    this.routerAddress =
+      TRADERJOE_V2_1_ROUTER_ADDRESS[dexHelper.config.data.network];
+
+    this.exchangeRouterInterface = new Interface(
+      TraderJoeV21RouterABI as JsonFragment[],
+    );
+  }
+
+  getAdapterParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    let payload = this.abiCoder.encodeParameters(
+      ['tuple(tuple(uint256[],uint8[],address[]),uint256)'],
+      [
+        [
+          [
+            [
+              data.binStep, // _pairBinSteps: uint256[]
+            ],
+            [
+              2, // _versions: uint8[]
+            ],
+            [
+              data.tokenIn,
+              data.tokenOut, // _tokenPath: address[]
+            ],
+          ],
+          getLocalDeadlineAsFriendlyPlaceholder(), // _deadline: uint256
+        ],
+      ],
+    );
+
+    return {
+      targetExchange: this.routerAddress,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  getSimpleParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): AsyncOrSync<SimpleExchangeParam> {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? TraderJoeV2RouterFunctions.swapExactTokensForTokens
+        : TraderJoeV2RouterFunctions.swapTokensForExactTokens;
+
+    const swapFunctionParams: TraderJoeV2RouterParam =
+      side === SwapSide.SELL
+        ? [
+            srcAmount,
+            destAmount,
+            [[data.binStep], ['2'], [srcToken, destToken]],
+            this.augustusAddress,
+            getLocalDeadlineAsFriendlyPlaceholder(),
+          ]
+        : [
+            destAmount,
+            srcAmount,
+            [[data.binStep], ['2'], [srcToken, destToken]],
+            this.augustusAddress,
+            getLocalDeadlineAsFriendlyPlaceholder(),
+          ];
+
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      this.routerAddress,
+    );
+  }
+}

package/tests/constants-e2e.ts

@@ -67,6 +67,10 @@ export const Tokens: {
       addBalance: balanceOfFn,
       addAllowance: allowanceFn,
     },
+    PSP: {
+      address: '0xcafe001067cdef266afb7eb5a286dcfd277f3de5',
+      decimals: 18,
+    },
     SETH: {
       address: '0x5e74C9036fb86BD7eCdcb084a0673EFc32eA31cb',
       decimals: 18,
@@ -812,12 +816,12 @@ export const Holders: {
 } = {
   [Network.MAINNET]: {
     ETH: '0x176F3DAb24a159341c0509bB36B833E7fdd0a132',
-    USDC: '0xDcEF968d416a41Cdac0ED8702fAC8128A64241A2',
-    WBTC: '0x6daB3bCbFb336b29d06B9C793AEF7eaA57888922',
+    USDC: '0x915dA56c5995EAaf66fd06BA3AeD62a4D3BD011A',
+    WBTC: '0x1Cb17a66DC606a52785f69F08F4256526aBd4943',
     BADGER: '0x34e2741a3f8483dbe5231f61c005110ff4b9f50a',
     STETH: '0x9bdb521a97e95177bf252c253e256a60c3e14447',
     wstETH: '0x6cE0F913F035ec6195bC3cE885aec4C66E485BC4',
-    WETH: '0x56178a0d5f301baf6cf3e1cd53d9863437345bf9',
+    WETH: '0x2fEb1512183545f48f6b9C5b4EbfCaF49CfCa6F3',
     USDT: '0x5754284f345afc66a98fbb0a0afe71e0f007b949',
     XAUT: '0xc4e161e8d8a4bc4ac762ab33a28bbac5474203d7',
     CVX: '0x0aCA67Fa70B142A3b9bF2eD89A81B40ff85dACdC',
@@ -864,7 +868,8 @@ export const Holders: {
     SHIBA: '0x73af3bcf944a6559933396c1577b257e2054d935',
     aEthUSDC: '0x3178490d60B5cceaA5a79FD4D9050C7405Bab80c',
     aEthWETH: '0x645C4c0c95C1Aa6EF25d12f4a25038cA9b0C6Cc7',
-    dUSDC: '0x3C6A135F7A3A7Ce203EF629B43D9dc66f0f98BFa',
+    dUSDC: '0x2FC2F705110A7F46Ce85F701d7217EF1018f01A3',
+    PSP: '0xE5E5440a1CE69C5cf67BFFA74d185e57c31b43E5',
   },
   [Network.ROPSTEN]: {
     ETH: '0x43262A12d8610AA70C15DbaeAC321d51613c9071',