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

package/src/dex/balancer-v2/pools/gyro/Gyro3Pool.ts

@@ -0,0 +1,255 @@
+import { Interface } from '@ethersproject/abi';
+import { BigNumber } from '@ethersproject/bignumber';
+
+import { BasePool } from '../balancer-v2-pool';
+import { SwapSide } from '../../../../constants';
+import {
+  decodeThrowError,
+  getTokenScalingFactor,
+  safeParseFixed,
+} from '../../utils';
+import { callData, SubgraphPoolBase, PoolState, TokenState } from '../../types';
+import { MathSol } from '../../balancer-v2-math';
+import { Gyro3Maths } from '@balancer-labs/sor';
+import { _addFee, _reduceFee } from './gyro-helpers';
+
+// Swap Limit factor
+const SWAP_LIMIT_FACTOR = BigInt('999999000000000000');
+
+// All values should be normalised to 18 decimals. e.g. 1USDC = 1e18 not 1e6
+export type Gyro3PoolPairData = {
+  balances: BigNumber[];
+  indexIn: number;
+  indexOut: number;
+  swapFee: bigint;
+  balanceTertiary: BigNumber; // Balance of the unchanged asset
+  decimalsTertiary: number; // Decimals of the unchanged asset
+  scalingFactors: bigint[];
+  root3Alpha: BigNumber;
+};
+
+export class Gyro3Pool extends BasePool {
+  vaultAddress: string;
+  vaultInterface: Interface;
+  poolInterface = new Interface([
+    'function getSwapFeePercentage() view returns (uint256)',
+  ]);
+
+  constructor(vaultAddress: string, vaultInterface: Interface) {
+    super();
+    this.vaultAddress = vaultAddress;
+    this.vaultInterface = vaultInterface;
+  }
+
+  parsePoolPairData(
+    pool: SubgraphPoolBase,
+    poolState: PoolState,
+    tokenIn: string,
+    tokenOut: string,
+  ): Gyro3PoolPairData {
+    // All values should be normalised to 18 decimals. e.g. 1USDC = 1e18 not 1e6
+    let indexIn = 0,
+      indexOut = 0,
+      indexTertiary = 0;
+    const scalingFactors: bigint[] = [];
+    const balances = pool.tokens.map((t, i) => {
+      if (t.address.toLowerCase() === tokenIn.toLowerCase()) {
+        indexIn = i;
+      } else if (t.address.toLowerCase() === tokenOut.toLowerCase()) {
+        indexOut = i;
+      } else {
+        indexTertiary = i;
+      }
+
+      const scalingFactor = getTokenScalingFactor(t.decimals);
+      scalingFactors.push(scalingFactor);
+
+      return BigNumber.from(
+        this._upscale(
+          BigInt(poolState.tokens[t.address.toLowerCase()].balance),
+          scalingFactor,
+        ),
+      );
+    });
+
+    const balanceTertiary = balances[indexTertiary];
+    const decimalsTertiary = pool.tokens[indexTertiary].decimals;
+
+    const poolPairData: Gyro3PoolPairData = {
+      balances,
+      indexIn,
+      indexOut,
+      scalingFactors,
+      swapFee: poolState.swapFee,
+      balanceTertiary,
+      decimalsTertiary,
+      root3Alpha: safeParseFixed(pool.root3Alpha, 18),
+    };
+
+    return poolPairData;
+  }
+
+  getSwapMaxAmount(poolPairData: Gyro3PoolPairData, side: SwapSide): bigint {
+    if (side === SwapSide.SELL) {
+      // Approximation - similar to traditional stable pools
+      return this._downscaleDown(
+        MathSol.mulDownFixed(
+          poolPairData.balances[poolPairData.indexOut].toBigInt(),
+          SWAP_LIMIT_FACTOR,
+        ),
+        poolPairData.scalingFactors[poolPairData.indexIn],
+      );
+    } else {
+      return this._downscaleDown(
+        MathSol.mulDownFixed(
+          poolPairData.balances[poolPairData.indexIn].toBigInt(),
+          SWAP_LIMIT_FACTOR,
+        ),
+        poolPairData.scalingFactors[poolPairData.indexOut],
+      );
+    }
+  }
+
+  /*
+  Helper function to construct onchain multicall data for Pool.
+  */
+  getOnChainCalls(pool: SubgraphPoolBase): callData[] {
+    const poolCallData: callData[] = [
+      {
+        target: this.vaultAddress,
+        callData: this.vaultInterface.encodeFunctionData('getPoolTokens', [
+          pool.id,
+        ]),
+      },
+      {
+        target: pool.address,
+        callData: this.poolInterface.encodeFunctionData('getSwapFeePercentage'),
+      },
+    ];
+    return poolCallData;
+  }
+
+  /*
+  Helper function to decode multicall data for 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 poolState: PoolState = {
+      swapFee: BigInt(swapFee.toString()),
+      orderedTokens: poolTokens.tokens,
+      tokens: poolTokens.tokens.reduce(
+        (ptAcc: { [address: string]: TokenState }, pt: string, j: number) => {
+          const tokenState: TokenState = {
+            balance: BigInt(poolTokens.balances[j].toString()),
+          };
+          ptAcc[pt.toLowerCase()] = tokenState;
+          return ptAcc;
+        },
+        {},
+      ),
+    };
+    pools[pool.address] = poolState;
+    return [pools, startIndex];
+  }
+
+  onSell(amounts: bigint[], poolPairData: Gyro3PoolPairData): bigint[] {
+    try {
+      const invariant = Gyro3Maths._calculateInvariant(
+        poolPairData.balances,
+        poolPairData.root3Alpha,
+      );
+
+      const virtualOffsetInOut = MathSol.mulDownFixed(
+        invariant.toBigInt(),
+        poolPairData.root3Alpha.toBigInt(),
+      );
+
+      const tokenAmountsInWithFee = amounts.map(a => {
+        const withFee = _reduceFee(a, poolPairData.swapFee);
+        return this._upscale(
+          withFee,
+          poolPairData.scalingFactors[poolPairData.indexIn],
+        );
+      });
+
+      return tokenAmountsInWithFee.map(amount => {
+        try {
+          const amountOut = Gyro3Maths._calcOutGivenIn(
+            poolPairData.balances[poolPairData.indexIn],
+            poolPairData.balances[poolPairData.indexOut],
+            BigNumber.from(amount),
+            BigNumber.from(virtualOffsetInOut),
+          ).toBigInt();
+
+          return this._downscaleDown(
+            amountOut,
+            poolPairData.scalingFactors[poolPairData.indexOut],
+          );
+        } catch (error) {
+          return BigInt(0);
+        }
+      });
+    } catch (error) {
+      return [];
+    }
+  }
+
+  onBuy(amounts: bigint[], poolPairData: Gyro3PoolPairData): bigint[] {
+    try {
+      const invariant = Gyro3Maths._calculateInvariant(
+        poolPairData.balances,
+        poolPairData.root3Alpha,
+      );
+
+      const virtualOffsetInOut = MathSol.mulDownFixed(
+        invariant.toBigInt(),
+        poolPairData.root3Alpha.toBigInt(),
+      );
+
+      const tokenAmountsUpscaled = amounts.map(a =>
+        this._upscale(a, poolPairData.scalingFactors[poolPairData.indexOut]),
+      );
+
+      return tokenAmountsUpscaled.map(amount => {
+        try {
+          const amountIn = Gyro3Maths._calcInGivenOut(
+            poolPairData.balances[poolPairData.indexIn],
+            poolPairData.balances[poolPairData.indexOut],
+            BigNumber.from(amount),
+            BigNumber.from(virtualOffsetInOut),
+          ).toBigInt();
+
+          const downScaledAmount = this._downscaleUp(
+            amountIn,
+            poolPairData.scalingFactors[poolPairData.indexIn],
+          );
+          return _addFee(downScaledAmount, poolPairData.swapFee);
+        } catch (error) {
+          return BigInt(0);
+        }
+      });
+    } catch (error) {
+      return [];
+    }
+  }
+}

package/src/dex/balancer-v2/pools/gyro/GyroEPool.ts

@@ -0,0 +1,403 @@
+import { Interface } from '@ethersproject/abi';
+import { BigNumber } from '@ethersproject/bignumber';
+
+import { BasePool } from '../balancer-v2-pool';
+import { NULL_ADDRESS, SwapSide } from '../../../../constants';
+import {
+  decodeThrowError,
+  getTokenScalingFactor,
+  safeParseFixed,
+} from '../../utils';
+import { callData, SubgraphPoolBase, PoolState, TokenState } from '../../types';
+import { MathSol } from '../../balancer-v2-math';
+import {
+  GyroEMaths,
+  DerivedGyroEParams,
+  GyroEParams,
+  balancesFromTokenInOut,
+  Vector2,
+} from '@balancer-labs/sor';
+import GyroEAbi from '../../../../abi/balancer-v2/gyro-e.abi.json';
+import * as util from 'util';
+
+// Swap Limit factor
+const SWAP_LIMIT_FACTOR = BigInt('999999000000000000');
+
+// All values should be normalised to 18 decimals. e.g. 1USDC = 1e18 not 1e6
+export type GyroEPoolPairData = {
+  balances: BigNumber[];
+  tokenRates: bigint[];
+  gyroParams: GyroEParams;
+  gyroDerivedParams: DerivedGyroEParams;
+  rateProviders: string[];
+  indexIn: number;
+  indexOut: number;
+  swapFee: bigint;
+  scalingFactors: bigint[];
+  tokenInIsToken0: boolean;
+};
+
+export class GyroEPool extends BasePool {
+  vaultAddress: string;
+  vaultInterface: Interface;
+  poolInterface = new Interface(GyroEAbi);
+
+  constructor(vaultAddress: string, vaultInterface: Interface) {
+    super();
+    this.vaultAddress = vaultAddress;
+    this.vaultInterface = vaultInterface;
+  }
+
+  parsePoolPairData(
+    pool: SubgraphPoolBase,
+    poolState: PoolState,
+    tokenIn: string,
+    tokenOut: string,
+  ): GyroEPoolPairData {
+    // All values should be normalised to 18 decimals. e.g. 1USDC = 1e18 not 1e6
+    let indexIn = 0,
+      indexOut = 0;
+    const scalingFactors: bigint[] = [];
+    const balances = pool.tokens.map((t, i) => {
+      if (t.address.toLowerCase() === tokenIn.toLowerCase()) indexIn = i;
+      else if (t.address.toLowerCase() === tokenOut.toLowerCase()) indexOut = i;
+      const scalingFactor = getTokenScalingFactor(t.decimals);
+      scalingFactors.push(scalingFactor);
+      return BigNumber.from(
+        this._upscale(
+          BigInt(poolState.tokens[t.address.toLowerCase()].balance),
+          scalingFactor,
+        ),
+      );
+    });
+
+    const tokenInIsToken0 = indexIn === 0;
+
+    const tokenRates = poolState.tokenRates
+      ? [poolState.tokenRates![0], poolState.tokenRates![1]]
+      : [];
+
+    const rateProviders = poolState.rateProviders ?? [];
+
+    const poolPairData: GyroEPoolPairData = {
+      gyroParams: poolState.gyroParams!,
+      gyroDerivedParams: poolState.gyroDerivedParams!,
+      tokenRates,
+      rateProviders,
+      balances,
+      indexIn,
+      indexOut,
+      scalingFactors,
+      swapFee: poolState.swapFee,
+      tokenInIsToken0,
+    };
+    return poolPairData;
+  }
+
+  getSwapMaxAmount(poolPairData: GyroEPoolPairData, side: SwapSide): bigint {
+    if (side === SwapSide.SELL) {
+      // Approximation - similar to traditional stable pools
+      return this._downscaleDown(
+        MathSol.mulDownFixed(
+          poolPairData.balances[poolPairData.indexOut].toBigInt(),
+          SWAP_LIMIT_FACTOR,
+        ),
+        poolPairData.scalingFactors[poolPairData.indexIn],
+      );
+    } else {
+      return this._downscaleDown(
+        MathSol.mulDownFixed(
+          poolPairData.balances[poolPairData.indexIn].toBigInt(),
+          SWAP_LIMIT_FACTOR,
+        ),
+        poolPairData.scalingFactors[poolPairData.indexOut],
+      );
+    }
+  }
+
+  /*
+  Helper function to construct onchain multicall data for Pool.
+  */
+  getOnChainCalls(pool: SubgraphPoolBase): callData[] {
+    const poolCallData: callData[] = [
+      {
+        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('getECLPParams'),
+      },
+    ];
+
+    // Only version 2 of GyroE uses token rates
+    const v2Calls =
+      pool.poolTypeVersion === 2
+        ? [
+            {
+              target: pool.address,
+              callData: this.poolInterface.encodeFunctionData('getTokenRates'),
+            },
+            {
+              target: pool.address,
+              callData: this.poolInterface.encodeFunctionData('rateProvider0'),
+            },
+            {
+              target: pool.address,
+              callData: this.poolInterface.encodeFunctionData('rateProvider1'),
+            },
+          ]
+        : [];
+
+    return [...poolCallData, ...v2Calls];
+  }
+
+  /*
+  Helper function to decode multicall data for 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 eclParams = decodeThrowError(
+      this.poolInterface,
+      'getECLPParams',
+      data[startIndex++],
+      pool.address,
+    );
+
+    let tokenRates;
+    let rateProviders: string[] = [];
+    if (pool.poolTypeVersion === 2) {
+      tokenRates = decodeThrowError(
+        this.poolInterface,
+        'getTokenRates',
+        data[startIndex++],
+        pool.address,
+      );
+      tokenRates = tokenRates.map(t => BigInt(t.toString()));
+
+      const rateProvider0 = decodeThrowError(
+        this.poolInterface,
+        'rateProvider0',
+        data[startIndex++],
+        pool.address,
+      )[0];
+
+      const rateProvider1 = decodeThrowError(
+        this.poolInterface,
+        'rateProvider1',
+        data[startIndex++],
+        pool.address,
+      )[0];
+      rateProviders = [rateProvider0, rateProvider1];
+    }
+
+    const poolState: PoolState = {
+      gyroParams: eclParams.params,
+      gyroDerivedParams: eclParams.d,
+      swapFee: BigInt(swapFee.toString()),
+      tokenRates,
+      rateProviders,
+      orderedTokens: poolTokens.tokens,
+      tokens: poolTokens.tokens.reduce(
+        (ptAcc: { [address: string]: TokenState }, pt: string, j: number) => {
+          const tokenState: TokenState = {
+            balance: BigInt(poolTokens.balances[j].toString()),
+          };
+          ptAcc[pt.toLowerCase()] = tokenState;
+          return ptAcc;
+        },
+        {},
+      ),
+    };
+    pools[pool.address] = poolState;
+    return [pools, startIndex];
+  }
+
+  onSell(amounts: bigint[], poolPairData: GyroEPoolPairData): bigint[] {
+    try {
+      const scalingFactorTokenIn = this._scalingFactor(
+        poolPairData.tokenInIsToken0,
+        poolPairData,
+      );
+      const scalingFactorTokenOut = this._scalingFactor(
+        !poolPairData.tokenInIsToken0,
+        poolPairData,
+      );
+      const normalizedBalances = this._normalizeBalances(
+        poolPairData.balances,
+        poolPairData.tokenRates,
+      );
+
+      const orderedNormalizedBalances = balancesFromTokenInOut(
+        normalizedBalances[poolPairData.indexIn],
+        normalizedBalances[poolPairData.indexOut],
+        poolPairData.tokenInIsToken0,
+      );
+
+      const [currentInvariant, invErr] = GyroEMaths.calculateInvariantWithError(
+        orderedNormalizedBalances,
+        poolPairData.gyroParams,
+        poolPairData.gyroDerivedParams,
+      );
+
+      const invariant: Vector2 = {
+        x: currentInvariant.add(invErr.mul(2)),
+        y: currentInvariant,
+      };
+
+      const tokenAmountsInScaled = amounts.map(a =>
+        this._upscale(a, scalingFactorTokenIn),
+      );
+
+      const tokenAmountsInWithFee = tokenAmountsInScaled.map(a =>
+        this._subtractSwapFeeAmount(a, poolPairData.swapFee),
+      );
+
+      const amountsOut: bigint[] = tokenAmountsInWithFee.map(amount => {
+        try {
+          const amountOut = GyroEMaths.calcOutGivenIn(
+            orderedNormalizedBalances,
+            BigNumber.from(amount),
+            poolPairData.tokenInIsToken0,
+            poolPairData.gyroParams,
+            poolPairData.gyroDerivedParams,
+            invariant,
+          ).toBigInt();
+
+          return this._downscaleDown(amountOut, scalingFactorTokenOut);
+        } catch (error) {
+          return BigInt(0);
+        }
+      });
+
+      return amountsOut;
+    } catch (error) {
+      return [];
+    }
+  }
+
+  onBuy(amounts: bigint[], poolPairData: GyroEPoolPairData): bigint[] {
+    try {
+      const scalingFactorTokenIn = this._scalingFactor(
+        poolPairData.tokenInIsToken0,
+        poolPairData,
+      );
+      const scalingFactorTokenOut = this._scalingFactor(
+        !poolPairData.tokenInIsToken0,
+        poolPairData,
+      );
+
+      const normalizedBalances = this._normalizeBalances(
+        poolPairData.balances,
+        poolPairData.tokenRates,
+      );
+
+      const orderedNormalizedBalances = balancesFromTokenInOut(
+        normalizedBalances[poolPairData.indexIn],
+        normalizedBalances[poolPairData.indexOut],
+        poolPairData.tokenInIsToken0,
+      );
+
+      const [currentInvariant, invErr] = GyroEMaths.calculateInvariantWithError(
+        orderedNormalizedBalances,
+        poolPairData.gyroParams,
+        poolPairData.gyroDerivedParams,
+      );
+
+      const invariant: Vector2 = {
+        x: currentInvariant.add(invErr.mul(2)),
+        y: currentInvariant,
+      };
+
+      const tokenAmountsOutScaled = amounts.map(a =>
+        this._upscale(a, scalingFactorTokenOut),
+      );
+
+      const amountsIn: bigint[] = tokenAmountsOutScaled.map(amount => {
+        try {
+          const amountIn = GyroEMaths.calcInGivenOut(
+            orderedNormalizedBalances,
+            BigNumber.from(amount),
+            poolPairData.tokenInIsToken0,
+            poolPairData.gyroParams,
+            poolPairData.gyroDerivedParams,
+            invariant,
+          ).toBigInt();
+          return amountIn;
+        } catch (error) {
+          return BigInt(0);
+        }
+      });
+
+      const downScaled = amountsIn.map(amount =>
+        this._downscaleUp(amount, scalingFactorTokenIn),
+      );
+
+      return downScaled.map(a => this._addFeeAmount(a, poolPairData.swapFee));
+    } catch (error) {
+      return [];
+    }
+  }
+
+  private _scalingFactor(
+    token0: boolean,
+    poolPairData: GyroEPoolPairData,
+  ): bigint {
+    const tokenIndex = token0 ? 0 : 1;
+    const scalingFactor = poolPairData.scalingFactors[tokenIndex];
+    if (
+      poolPairData.rateProviders.length === 0 ||
+      poolPairData.rateProviders[tokenIndex].toLowerCase() === NULL_ADDRESS
+    ) {
+      return scalingFactor;
+    } else {
+      return MathSol.mulDownFixed(
+        scalingFactor,
+        poolPairData.tokenRates[tokenIndex],
+      );
+    }
+  }
+
+  private _normalizeBalances(
+    balances: BigNumber[],
+    tokenRates: bigint[],
+  ): BigNumber[] {
+    // If pool is V1, e.g. has no tokenRates return balances
+    if (tokenRates.length === 0) return balances;
+    /*
+    Apply tokenRates
+    SOR upscales here first using scalingFactors but this is already being done in parse pair data so no need to repeat.
+    */
+    return balances.map((bal, i) => {
+      return BigNumber.from(
+        MathSol.mulDownFixed(bal.toBigInt(), tokenRates[i]),
+      );
+    });
+  }
+}

package/src/dex/balancer-v2/pools/gyro/gyro-helpers.ts

@@ -0,0 +1,15 @@
+export function _reduceFee(amountIn: bigint, swapFee: bigint): bigint {
+  const product = amountIn * swapFee;
+  const feeAmount = (product - 1n) / 1000000000000000000n + 1n;
+  return amountIn - feeAmount;
+}
+
+export function _addFee(amountIn: bigint, swapFee: bigint): bigint {
+  const fee = 1000000000000000000n - swapFee;
+  return divUp(amountIn, fee);
+}
+
+function divUp(a: bigint, b: bigint): bigint {
+  const aInflated = a * 1000000000000000000n;
+  return (aInflated - 1n) / b + 1n;
+}