@paraswap/dex-lib 2.50.6-sdai → 2.50.7-sdai

package/src/dex/curve-v1-factory/price-handlers/functions/get_D.ts

@@ -2,7 +2,12 @@ import _ from 'lodash';
 import { CONVERGENCE_ERROR_PREFIX } from '../../constants';
 import { ImplementationNames } from '../../types';
 import { get_D, IPoolContext } from '../types';
-import { getCachedValueOrCallFunc, requireConstant } from './utils';
+import {
+  getCachedValueOrCallFunc,
+  pow_mod256,
+  requireConstant,
+  requireValue,
+} from './utils';
 
 /*
  * This function get_D may be optimized further. We are doing many redundant
@@ -52,6 +57,57 @@ const customPlain3CoinThree: get_D = (
   return D;
 };
 
+const stableNg: get_D = (
+  self: IPoolContext,
+  xp: bigint[],
+  amp: bigint,
+  N_COINS?: number,
+): bigint => {
+  const A_PRECISION = requireConstant(self, 'A_PRECISION', 'stableNg');
+  const BI_N_COINS = BigInt(N_COINS!);
+
+  let S = 0n;
+  let Dprev = 0n;
+
+  for (const _x of xp) {
+    S += _x;
+  }
+  if (S === 0n) {
+    return 0n;
+  }
+
+  let D = S;
+  const Ann = amp * BI_N_COINS;
+  for (const _i of _.range(255)) {
+    let D_P = D;
+    for (const _x of xp) {
+      D_P = (D_P * D) / _x;
+    }
+
+    D_P /= pow_mod256(BI_N_COINS, BI_N_COINS);
+    Dprev = D;
+    D =
+      (((Ann * S) / A_PRECISION + D_P * BI_N_COINS) * D) /
+      (((Ann - A_PRECISION) * D) / A_PRECISION + (BI_N_COINS + 1n) * D_P);
+    // Equality with the precision of 1
+    if (D > Dprev) {
+      if (D - Dprev <= 1n) {
+        return D;
+      }
+    } else {
+      if (Dprev - D <= 1n) {
+        return D;
+      }
+    }
+  }
+
+  // convergence typically occurs in 4 rounds or less, this should be unreachable!
+  // if it does happen the pool is borked and LPs can withdraw via `remove_liquidity`
+  throw new Error(
+    `${CONVERGENCE_ERROR_PREFIX}_${self.IMPLEMENTATION_NAME}: function stableNg didn't converge`,
+  );
+};
+
 const customPlain2CoinFrax: get_D = (
   self: IPoolContext,
   xp: bigint[],
@@ -323,6 +379,8 @@ const implementations: Record<ImplementationNames, get_D> = {
     makeFuncCacheable(factoryPlain2Basic),
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]:
     makeFuncCacheable(factoryPlain2Basic),
+
+  [ImplementationNames.FACTORY_STABLE_NG]: stableNg,
 };
 
 export default implementations;

package/src/dex/curve-v1-factory/price-handlers/functions/get_D_mem.ts

@@ -141,6 +141,8 @@ export const implementations: Record<ImplementationNames, get_D_mem> = {
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA]: factoryPlain2Basic,
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA2]: factoryPlain2EthEma2,
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]: factoryPlain2Basic,
+
+  [ImplementationNames.FACTORY_STABLE_NG]: notImplemented,
 };
 
 export default implementations;

package/src/dex/curve-v1-factory/price-handlers/functions/get_D_precisions.ts

@@ -113,6 +113,8 @@ const implementations: Record<ImplementationNames, get_D_precisions> = {
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA]: notExist,
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA2]: notExist,
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]: notExist,
+
+  [ImplementationNames.FACTORY_STABLE_NG]: notExist,
 };
 
 export default implementations;

package/src/dex/curve-v1-factory/price-handlers/functions/get_dy.ts

@@ -2,6 +2,7 @@ import _ from 'lodash';
 import { ImplementationNames, PoolState } from '../../types';
 import { get_dy, IPoolContext } from '../types';
 import { requireConstant, requireValue } from './utils';
+import get_y from './get_y';
 
 const _genericFactoryPlain2Basic = (
   self: IPoolContext,
@@ -162,6 +163,54 @@ const customPlain3CoinBtc: get_dy = (
   return dy - _fee;
 };
 
+const stableNg: get_dy = (
+  self: IPoolContext,
+  state: PoolState,
+  i: number,
+  j: number,
+  dx: bigint,
+) => {
+  const rates = requireValue(self, state, 'storedRates', 'stableNg');
+  const N_COINS = requireValue(self, state, 'n_coins', 'stableNg');
+  const A = requireValue(self, state, 'A', 'stableNg');
+  const stateFee = requireValue(self, state, 'fee', 'stableNg');
+  const offpeg_fee_multiplier = requireValue(
+    self,
+    state,
+    'offpeg_fee_multiplier',
+    'stableNg',
+  );
+
+  const { FEE_DENOMINATOR, PRECISION } = self.constants;
+  const xp: bigint[] = [];
+  const { balances } = state;
+
+  for (const idx of _.range(N_COINS)) {
+    xp.push((rates[idx] * balances[idx]) / PRECISION);
+  }
+
+  const amp = A;
+  const D = self.get_D(self, xp, amp, N_COINS);
+
+  const x = xp[i] + (dx * rates[i]) / PRECISION;
+  const y = self.get_y(self, state, i, j, x, xp, amp, D);
+  const dy = xp[j] - y - 1n;
+
+  const base_fee = stateFee;
+  const fee_multiplier = offpeg_fee_multiplier;
+  const dynamic_fee = self._dynamic_fee(
+    self,
+    (xp[i] + x) / 2n,
+    (xp[j] + y) / 2n,
+    base_fee,
+    fee_multiplier,
+  );
+
+  const fee = (dynamic_fee * dy) / FEE_DENOMINATOR;
+
+  return ((dy - fee) * PRECISION) / rates[j];
+};
+
 const customAvalanche3CoinLending: get_dy = (
   self: IPoolContext,
   state: PoolState,
@@ -267,6 +316,8 @@ const implementations: Record<ImplementationNames, get_dy> = {
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA]: factoryPlain2Basic,
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA2]: factoryPlain2EthEma2,
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]: factoryPlain2Basic,
+
+  [ImplementationNames.FACTORY_STABLE_NG]: stableNg,
 };
 
 export default implementations;

package/src/dex/curve-v1-factory/price-handlers/functions/get_dy_underlying.ts

@@ -286,6 +286,8 @@ const implementations: Record<ImplementationNames, get_dy_underlying> = {
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA]: notExist,
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA2]: notExist,
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]: notExist,
+
+  [ImplementationNames.FACTORY_STABLE_NG]: notExist,
 };
 
 export default implementations;

package/src/dex/curve-v1-factory/price-handlers/functions/get_y.ts

@@ -2,9 +2,74 @@ import _ from 'lodash';
 import { ImplementationNames, PoolState } from '../../types';
 import { _require } from '../../../../utils';
 import { get_y, IPoolContext } from '../types';
-import { requireConstant } from './utils';
+import { requireConstant, requireValue } from './utils';
 import { CONVERGENCE_ERROR_PREFIX } from '../../constants';
 
+const stableNg = (
+  self: IPoolContext,
+  state: PoolState,
+  i: number,
+  j: number,
+  x: bigint,
+  xp: bigint[],
+  _amp?: bigint,
+  _D?: bigint,
+): bigint => {
+  const A_PRECISION = requireConstant(self, 'A_PRECISION', 'stableNg');
+  const N_COINS = requireValue(self, state, 'n_coins', 'stableNg');
+  // x in the input is converted to the same price/precision
+
+  _require(i !== j, 'same coin', { i, j }, 'i !== j');
+  _require(j >= 0, 'j below zero', { i, j }, 'j >= 0');
+  _require(j < N_COINS, 'j above N_COINS', { i, j, N_COINS }, 'j < N_COINS');
+
+  // should be unreachable, but good for safety
+  _require(i >= 0, 'i below zero', { i, j }, 'i >= 0');
+  _require(i < N_COINS, 'i above N_COINS', { i, j, N_COINS }, 'i < N_COINS');
+
+  const BI_N_COINS = BigInt(N_COINS);
+
+  const amp = _amp!;
+  const D = _D!;
+  let c = D;
+  let S_ = 0n;
+  const Ann = amp * BI_N_COINS;
+
+  let _x = 0n;
+  for (const _i of _.range(N_COINS)) {
+    if (_i === i) {
+      _x = x;
+    } else if (_i !== j) {
+      _x = xp[_i];
+    } else {
+      continue;
+    }
+    S_ += _x;
+    c = (c * D) / (_x * BI_N_COINS);
+  }
+  c = (c * D * A_PRECISION) / (Ann * BI_N_COINS);
+  const b = S_ + (D * A_PRECISION) / Ann; // - D
+  let y_prev = 0n;
+  let y = D;
+
+  for (const _i of _.range(255)) {
+    y_prev = y;
+    y = (y * y + c) / (2n * y + b - D);
+    //
+    // Equality with the precision of 1
+    if (y > y_prev) {
+      if (y - y_prev <= 1) {
+        break;
+      }
+    } else {
+      if (y_prev - y <= 1) {
+        break;
+      }
+    }
+  }
+  return y;
+};
+
 const customPlain3CoinThree = (
   self: IPoolContext,
   state: PoolState,
@@ -190,6 +255,8 @@ const implementations: Record<ImplementationNames, get_y> = {
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA]: customPlain2CoinFrax,
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA2]: customPlain2CoinFrax,
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]: customPlain2CoinFrax,
+
+  [ImplementationNames.FACTORY_STABLE_NG]: stableNg,
 };
 
 export default implementations;

package/src/dex/curve-v1-factory/price-handlers/functions/get_y_D.ts

@@ -176,6 +176,8 @@ const implementations: Record<ImplementationNames, get_y_D> = {
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA]: customPlain2CoinFrax,
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA2]: customPlain2CoinFrax,
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]: customPlain2CoinFrax,
+
+  [ImplementationNames.FACTORY_STABLE_NG]: customPlain2CoinFrax,
 };
 
 export default implementations;

package/src/dex/curve-v1-factory/price-handlers/functions/utils.ts

@@ -70,3 +70,7 @@ export const getCachedValueOrCallFunc = <T>(
   curveV1FactoryNodeCache.set(key, calculated);
   return calculated;
 };
+
+export function pow_mod256(a: bigint, b: bigint): bigint {
+  return a ** b % 2n ** 256n;
+}

package/src/dex/curve-v1-factory/price-handlers/types.ts

@@ -52,7 +52,12 @@ export type get_D_precisions = (
   amp: bigint,
 ) => bigint;
 
-export type get_D = (self: IPoolContext, xp: bigint[], amp: bigint) => bigint;
+export type get_D = (
+  self: IPoolContext,
+  xp: bigint[],
+  amp: bigint,
+  N_COINS?: number,
+) => bigint;
 
 export type get_dy_underlying = (
   self: IPoolContext,
@@ -85,6 +90,8 @@ export type get_y = (
   j: number,
   x: bigint,
   xp_: bigint[],
+  _amp?: bigint,
+  _D?: bigint,
 ) => bigint;
 
 /*

package/src/dex/curve-v1-factory/state-polling-pools/factory-pool-polling.ts

@@ -2,6 +2,7 @@ import { Interface, JsonFragment } from '@ethersproject/abi';
 import { Logger } from 'log4js';
 import { MultiCallParams, MultiResult } from '../../../lib/multi-wrapper';
 import {
+  DexParams,
   FactoryImplementationNames,
   PoolConstants,
   PoolContextConstants,
@@ -9,19 +10,20 @@ import {
 } from '../types';
 import { PoolPollingBase, MulticallReturnedTypes } from './pool-polling-base';
 import FactoryCurveV1ABI from '../../../abi/curve-v1-factory/FactoryCurveV1.json';
-import { generalDecoder, uint256ToBigInt } from '../../../lib/decoders';
+import {
+  generalDecoder,
+  uint256DecodeToNumber,
+  uint256ToBigInt,
+} from '../../../lib/decoders';
 import { BytesLike } from 'ethers/lib/utils';
 import { Address } from '@paraswap/core';
 import { BigNumber } from 'ethers';
-import { _require } from '../../../utils';
-import { AbiItem } from 'web3-utils';
+import { DexConfigMap } from '../../../types';
 
 const DEFAULT_2_ZERO_ARRAY = [0n, 0n];
 const DEFAULT_4_ZERO_ARRAY = [0n, 0n, 0n, 0n];
 
-type AdditionalContractFunctions = 'stored_rates';
-
-const getStoredRatesABI = (n: number) => ({
+const getStoredRatesABI = (n: string) => ({
   name: 'stored_rates',
   stateMutability: 'view',
   type: 'function',
@@ -38,7 +40,7 @@ export class FactoryStateHandler extends PoolPollingBase {
     readonly implementationName: FactoryImplementationNames,
     implementationAddress: Address,
     readonly address: Address,
-    stateUpdatePeriodMs: number,
+    readonly config: DexParams,
     readonly factoryAddress: Address,
     readonly poolIdentifier: string,
     readonly poolConstants: PoolConstants,
@@ -52,7 +54,7 @@ export class FactoryStateHandler extends PoolPollingBase {
       FactoryCurveV1ABI as JsonFragment[],
     ),
     private additionalFuncsIface: Interface = new Interface([
-      getStoredRatesABI(poolContextConstants.N_COINS),
+      getStoredRatesABI(poolContextConstants?.N_COINS?.toString() || ''),
     ]),
   ) {
     super(
@@ -62,7 +64,7 @@ export class FactoryStateHandler extends PoolPollingBase {
       cacheStateKey,
       implementationName,
       implementationAddress,
-      stateUpdatePeriodMs,
+      config.stateUpdatePeriodMs,
       poolIdentifier,
       poolConstants,
       address,
@@ -81,6 +83,11 @@ export class FactoryStateHandler extends PoolPollingBase {
   }
 
   getStateMultiCalldata(): MultiCallParams<MulticallReturnedTypes>[] {
+    const factoryConfig = this.config.factories?.find(
+      ({ address }) =>
+        address.toLowerCase() === this.factoryAddress.toLowerCase(),
+    );
+
     const calls = [
       {
         target: this.factoryAddress,
@@ -106,8 +113,11 @@ export class FactoryStateHandler extends PoolPollingBase {
           this.address,
         ]),
         decodeFunction: (result: MultiResult<BytesLike> | BytesLike) =>
-          generalDecoder(result, ['uint256[4]'], DEFAULT_4_ZERO_ARRAY, parsed =>
-            parsed[0].map((p: BigNumber) => p.toBigInt()),
+          generalDecoder(
+            result,
+            [`uint256[${factoryConfig?.isStableNg ? '' : '4'}]`],
+            DEFAULT_4_ZERO_ARRAY,
+            parsed => parsed[0].map((p: BigNumber) => p.toBigInt()),
           ),
       },
     ];
@@ -122,13 +132,51 @@ export class FactoryStateHandler extends PoolPollingBase {
         decodeFunction: (result: MultiResult<BytesLike> | BytesLike) =>
           generalDecoder(
             result,
-            [`uint256[${this.poolContextConstants.N_COINS}]`],
+            [
+              `uint256[${
+                factoryConfig?.isStableNg
+                  ? ''
+                  : this.poolContextConstants.N_COINS
+              }]`,
+            ],
             new Array(this.poolContextConstants.N_COINS).fill(0n),
             parsed => parsed[0].map((p: BigNumber) => p.toBigInt()),
           ),
       });
     }
 
+    if (factoryConfig?.isStableNg) {
+      calls.push({
+        target: this.address,
+        callData: this.abiCoder.encodeFunctionCall(
+          {
+            stateMutability: 'view',
+            type: 'function',
+            name: 'offpeg_fee_multiplier',
+            inputs: [],
+            outputs: [{ name: '', type: 'uint256' }],
+          },
+          [],
+        ),
+        decodeFunction: uint256ToBigInt,
+      });
+
+      calls.push({
+        target: this.address,
+        callData: this.abiCoder.encodeFunctionCall(
+          {
+            stateMutability: 'view',
+            type: 'function',
+            name: 'N_COINS',
+            inputs: [],
+            outputs: [{ name: '', type: 'uint256' }],
+          },
+          [],
+        ),
+        decodeFunction: uint256DecodeToNumber,
+      });
+    }
+
     return calls;
   }
 
@@ -137,12 +185,15 @@ export class FactoryStateHandler extends PoolPollingBase {
     blockNumber: number,
     updatedAtMs: number,
   ): PoolState {
-    const [A, fees, balances, storedRates] = multiOutputs as [
-      bigint,
-      bigint[],
-      bigint[],
-      bigint[] | undefined,
-    ];
+    const [A, fees, balances, storedRates, offpeg_fee_multiplier, n_coins] =
+      multiOutputs as [
+        bigint,
+        bigint[],
+        bigint[],
+        bigint[] | undefined,
+        bigint | undefined,
+        number | undefined,
+      ];
 
     let basePoolState: PoolState | undefined;
     if (this.isMetaPool) {
@@ -164,9 +215,11 @@ export class FactoryStateHandler extends PoolPollingBase {
       fee: fees[0], // Array has [fee, adminFee], but we want only fee
       balances: balances,
       constants: this.poolConstants,
+      n_coins,
       basePoolState,
       updatedAtMs,
       blockNumber,
+      offpeg_fee_multiplier,
       storedRates,
     };
   }

package/src/dex/curve-v1-factory/state-polling-pools/pool-polling-base.ts

@@ -53,6 +53,7 @@ export abstract class PoolPollingBase {
     this.fullName = `${dexKey}-${network}-${this.CLASS_NAME}-${this.implementationName}-${this.address}`;
     this.isMetaPool = baseStatePoolPolling !== undefined;
     this.coinsToIndices = this._reduceToIndexMapping(poolConstants.COINS);
+
     this.underlyingCoinsToIndices = baseStatePoolPolling
       ? this._reduceToIndexMapping([
           poolConstants.COINS[0],

package/src/dex/curve-v1-factory/types.ts

@@ -58,6 +58,7 @@ export type PoolState = {
   offpeg_fee_multiplier?: bigint; // from pool
   basePoolState?: PoolState;
   storedRates?: bigint[]; // from pool, but only for oracle ones
+  n_coins?: number;
 };
 
 export type PoolStateWithUpdateInfo<T> = {
@@ -115,6 +116,10 @@ export enum FactoryImplementationNames {
   FACTORY_PLAIN_4_BASIC = 'factory_plain_4_basic',
   FACTORY_PLAIN_4_ETH = 'factory_plain_4_eth',
   FACTORY_PLAIN_4_OPTIMIZED = 'factory_plain_4_optimized',
+
+  FACTORY_STABLE_NG = 'factory_stable_ng',
+  // FACTORY_STABLE_6_NG = 'factory_stable_6_ng',
+  // FACTORY_STABLE_8_NG = 'factory_stable_8_ng',
 }
 
 export enum CustomImplementationNames {
@@ -175,8 +180,14 @@ export type CustomPoolConfig = {
   useForPricing: boolean;
 };
 
+type DexParamFactory = {
+  address: string;
+  maxPlainCoins?: number;
+  isStableNg?: boolean;
+};
+
 export type DexParams = {
-  factoryAddresses: string[] | null;
+  factories: DexParamFactory[] | null;
   stateUpdatePeriodMs: number;
   factoryPoolImplementations: Record<Address, FactoryPoolImplementations>;
   customPools: Record<string, CustomPoolConfig>;

package/src/dex/dexalot/config.ts

@@ -7,6 +7,9 @@ export const DexalotConfig: DexConfigMap<DexParams> = {
     [Network.AVALANCHE]: {
       mainnetRFQAddress: '0xEed3c159F3A96aB8d41c8B9cA49EE1e5071A7cdD',
     },
+    [Network.ARBITRUM]: {
+      mainnetRFQAddress: '0x010224949cCa211Fb5dDfEDD28Dc8Bf9D2990368',
+    },
   },
 };
 
@@ -15,4 +18,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter02', index: 6 }],
     [SwapSide.BUY]: [{ name: 'AvalancheBuyAdapter', index: 8 }],
   },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter03', index: 2 }],
+    [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 11 }],
+  },
 };

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

@@ -196,7 +196,7 @@ describe('Dexalot E2E', () => {
     const tokenASymbol: string = 'BTCb';
     const tokenBSymbol: string = 'USDC';
 
-    const tokenAAmount: string = '100';
+    const tokenAAmount: string = '10000';
     const tokenBAmount: string = '9000000000';
     const nativeTokenAmount = '1000000000000000000';
 
@@ -211,4 +211,26 @@ describe('Dexalot E2E', () => {
       true,
     );
   });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+
+    const tokenASymbol: string = 'USDT';
+    const tokenBSymbol: string = 'USDC';
+
+    const tokenAAmount: string = '1000000';
+    const tokenBAmount: string = '1000000';
+    const nativeTokenAmount = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+      true,
+    );
+  });
 });