@paraswap/dex-lib 2.47.4-hashflow-mm → 2.47.4

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;
+}

package/src/dex/balancer-v2/queryOnChain.ts

@@ -0,0 +1,48 @@
+import dotenv from 'dotenv';
+dotenv.config();
+import { Contract } from '@ethersproject/contracts';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import VaultABI from '../../abi/balancer-v2/vault.json';
+
+// Compare retrieve an onchain query result for a single swap
+export async function queryOnChain(
+  rpcUrl: string,
+  blockNumber: number,
+  poolId: string,
+  kind: 0 | 1,
+  assetIn: string,
+  assetOut: string,
+  amount: BigInt,
+): Promise<bigint[]> {
+  const provider = new JsonRpcProvider(rpcUrl);
+  const vaultAddress = '0xBA12222222228d8Ba445958a75a0704d566BF2C8';
+  const vaultContract = new Contract(vaultAddress, VaultABI, provider);
+
+  const funds = {
+    sender: '0x0000000000000000000000000000000000000000',
+    recipient: '0x0000000000000000000000000000000000000000',
+    fromInternalBalance: false,
+    toInternalBalance: false,
+  };
+  const swaps = [
+    {
+      poolId,
+      assetInIndex: 0,
+      assetOutIndex: 1,
+      amount,
+      userData: '0x',
+    },
+  ];
+  const assets = [assetIn, assetOut];
+  const deltas = await vaultContract.callStatic.queryBatchSwap(
+    kind,
+    swaps,
+    assets,
+    funds,
+    {
+      blockTag: blockNumber,
+    },
+  );
+  // console.log(deltas.toString());
+  return [deltas[0].toBigInt(), deltas[1].toBigInt()];
+}

package/src/dex/balancer-v2/types.ts

@@ -1,5 +1,6 @@
 import { NumberAsString } from '@paraswap/core';
 import { Address } from '../../types';
+import { DerivedGyroEParams, GyroEParams } from '@balancer-labs/sor';
 
 // These should match the Balancer Pool types available on Subgraph
 export enum BalancerPoolTypes {
@@ -20,6 +21,8 @@ export enum BalancerPoolTypes {
   SiloLinear = 'SiloLinear',
   TetuLinear = 'TetuLinear',
   YearnLinear = 'YearnLinear',
+  Gyro3 = 'Gyro3',
+  GyroE = 'GyroE',
 }
 
 export type TokenState = {
@@ -32,6 +35,10 @@ export type PoolState = {
   tokens: {
     [address: string]: TokenState;
   };
+  tokenRates?: bigint[];
+  rateProviders?: string[];
+  gyroParams?: GyroEParams;
+  gyroDerivedParams?: DerivedGyroEParams;
   swapFee: bigint;
   orderedTokens: string[];
   rate?: bigint;
@@ -71,12 +78,31 @@ export interface SubgraphPoolBase {
   id: string;
   address: string;
   poolType: BalancerPoolTypes;
+  poolTypeVersion: number;
   tokens: SubgraphToken[];
   tokensMap: { [tokenAddress: string]: SubgraphToken };
   mainIndex: number;
   wrappedIndex: number;
 
   mainTokens: SubgraphMainToken[];
+
+  // gyro3
+  root3Alpha: string;
+  // gyroE
+  alpha: string;
+  beta: string;
+  c: string;
+  s: string;
+  lambda: string;
+  tauAlphaX: string;
+  tauAlphaY: string;
+  tauBetaX: string;
+  tauBetaY: string;
+  u: string;
+  v: string;
+  w: string;
+  z: string;
+  dSq: string;
 }
 
 export type BalancerSwapV2 = {

package/src/dex/balancer-v2/utils.ts

@@ -1,5 +1,6 @@
 import { getAddress } from '@ethersproject/address';
 import { Interface, Result } from '@ethersproject/abi';
+import { parseFixed, BigNumber } from '@ethersproject/bignumber';
 import { getBigIntPow } from '../../utils';
 import { BI_POWS } from '../../bigint-constants';
 import { SwapSide } from '../../constants';
@@ -19,6 +20,21 @@ interface BalancerPathHop {
   tokenOut: SubgraphToken;
 }
 
+/**
+ * Parses a fixed-point decimal string into a BigNumber. If we do not have enough decimals to express the number, we truncate it.
+ * @param value
+ * @param decimals
+ * @returns BigNumber
+ */
+export function safeParseFixed(value: string, decimals = 0): BigNumber {
+  const [integer, fraction] = value.split('.');
+  if (!fraction) {
+    return parseFixed(value, decimals);
+  }
+  const safeValue = integer + '.' + fraction.slice(0, decimals);
+  return parseFixed(safeValue, decimals);
+}
+
 export const isSameAddress = (address1: string, address2: string): boolean =>
   getAddress(address1) === getAddress(address2);
 

package/src/dex/hashflow/constants.ts

@@ -2,7 +2,7 @@ import BigNumber from 'bignumber.js';
 
 export const HASHFLOW_BLACKLIST_TTL_S = 60 * 60 * 24 * 7; // 7 days
 
-export const HASHFLOW_MM_RESTRICT_TTL_S = 60 * 5; // 5 minutes
+export const HASHFLOW_MM_RESTRICT_TTL_S = 60 * 60;
 
 export const HASHFLOW_PRICES_CACHES_TTL_S = 3;
 

package/src/dex/hashflow/hashflow.ts

@@ -711,7 +711,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         },
         { deadline: minDeadline },
       ];
-    } catch (e: any) {
+    } catch (e) {
       if (
         e instanceof Error &&
         e.message.endsWith('User is restricted from using Hashflow')
@@ -726,9 +726,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
             `${this.dexKey}-${this.network}: Market Maker ${mm} failed to build transaction on side ${side} with too strict slippage. Skipping restriction`,
           );
         } else {
-          this.logger.error(
-            `${this.dexKey}-${this.network} MM unknown preprocess transaction error: ${e}`,
-          );
           await this.restrictMM(mm);
         }
       }

package/src/dex/synthetix/synthetix-state.ts

@@ -407,7 +407,7 @@ export class SynthetixState {
       Address,
       bigint,
       bigint,
-      ...Address[]
+      ...Address[],
     ];
 
     const [
@@ -437,7 +437,7 @@ export class SynthetixState {
       Address,
       Address,
       bigint,
-      ...string[]
+      ...string[],
     ];
 
     _require(

package/tests/constants-e2e.ts

@@ -41,6 +41,14 @@ export const Tokens: {
       addBalance: balancesFn,
       addAllowance: allowedFn,
     },
+    R: {
+      address: '0x183015a9ba6ff60230fdeadc3f43b3d788b13e21',
+      decimals: 18,
+    },
+    sDAI: {
+      address: '0x83f20f44975d03b1b09e64809b757c47f942beea',
+      decimals: 18,
+    },
     CUSDC: {
       address: '0x39AA39c021dfbaE8faC545936693aC917d5E7563',
       decimals: 8,
@@ -335,6 +343,10 @@ export const Tokens: {
       address: '0x455e53CBB86018Ac2B8092FdCd39d8444aFFC3F6',
       decimals: 19,
     },
+    GYD: {
+      address: '0xe07f9d810a48ab5c3c914ba3ca53af14e4491e8a',
+      decimals: 18,
+    },
   },
   [Network.ROPSTEN]: {
     DAI: {
@@ -465,10 +477,22 @@ export const Tokens: {
       address: '0xa3fa99a148fa48d14ed51d610c367c61876997f1',
       decimals: 18,
     },
+    BUSD: {
+      address: '0x9C9e5fD8bbc25984B178FdCE6117Defa39d2db39',
+      decimals: 18,
+    },
+    TUSD: {
+      address: '0x2e1ad108ff1d8c782fcbbb89aad783ac49586756',
+      decimals: 18,
+    },
     SDEX: {
       address: '0x6899fAcE15c14348E1759371049ab64A3a06bFA6',
       decimals: 18,
     },
+    MATICX: {
+      address: '0xfa68fb4628dff1028cfec22b4162fccd0d45efb6',
+      decimals: 18,
+    },
   },
   [Network.FANTOM]: {
     FTM: { address: ETHER_ADDRESS, decimals: 18 },
@@ -1031,6 +1055,8 @@ export const Holders: {
     WETH: '0x2fEb1512183545f48f6b9C5b4EbfCaF49CfCa6F3',
     USDT: '0x8A446971dbB112f3be15bc38C14D44B94D9E94b9',
     XAUT: '0xc4e161e8d8a4bc4ac762ab33a28bbac5474203d7',
+    R: '0xBfe4c9D3235475C138a61f62e9e72FaD94A3303b',
+    sDAI: '0x8846163Fedc6b881526A6B48321601b474D40923',
     CVX: '0x0aCA67Fa70B142A3b9bF2eD89A81B40ff85dACdC',
     MIM: '0xa046a8660e66d178ee07ec97c585eeb6aa18c26c',
     AnkETH: '0xF7260D4ADc48fEefd5a19a9Eb23f9747CeE15C92',