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

package/src/dex/curve-v1-factory/curve-v1-factory-integration.test.ts

@@ -698,4 +698,396 @@ describe('CurveV1Factory', function () {
       }
     });
   });
+
+  describe('Stable NG', () => {
+    describe('Mainnet', () => {
+      const network = Network.MAINNET;
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        // @ts-expect-error for testing there is dummy blocknumber, but it is not
+        // part of the interface
+        dexHelper.blockManager._blockNumber = blockNumber;
+        console.log(
+          `Received blockNumber ${blockNumber} on network ${dexHelper.config.data.network}`,
+        );
+        curveV1Factory = new CurveV1Factory(network, dexKey, dexHelper);
+        if (curveV1Factory.initializePricing) {
+          await curveV1Factory.initializePricing(blockNumber);
+        }
+      });
+
+      describe('GHO -> USDe', () => {
+        const srcTokenSymbol = 'GHO';
+        const destTokenSymbol = 'USDe';
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            curveV1Factory,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getTopPoolsForToken', async function () {
+          // We have to check without calling initializePricing, because
+          // pool-tracker is not calling that function
+          const newCurveV1Factory = new CurveV1Factory(
+            network,
+            dexKey,
+            dexHelper,
+          );
+          if (newCurveV1Factory.updatePoolState) {
+            await newCurveV1Factory.updatePoolState();
+          }
+          const poolLiquidity = await newCurveV1Factory.getTopPoolsForToken(
+            tokens[srcTokenSymbol].address,
+            10,
+          );
+          console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+          if (!newCurveV1Factory.hasConstantPriceLargeAmounts) {
+            checkPoolsLiquidity(
+              poolLiquidity,
+              Tokens[network][srcTokenSymbol].address,
+              dexKey,
+            );
+          }
+        });
+      });
+    });
+
+    describe('Polygon', () => {
+      const network = Network.POLYGON;
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        // @ts-expect-error for testing there is dummy blocknumber, but it is not
+        // part of the interface
+        dexHelper.blockManager._blockNumber = blockNumber;
+        console.log(
+          `Received blockNumber ${blockNumber} on network ${dexHelper.config.data.network}`,
+        );
+        curveV1Factory = new CurveV1Factory(network, dexKey, dexHelper);
+        if (curveV1Factory.initializePricing) {
+          await curveV1Factory.initializePricing(blockNumber);
+        }
+      });
+
+      describe('crvUSD -> USDT', () => {
+        const srcTokenSymbol = 'crvUSD';
+        const destTokenSymbol = 'USDT';
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            curveV1Factory,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getTopPoolsForToken', async function () {
+          // We have to check without calling initializePricing, because
+          // pool-tracker is not calling that function
+          const newCurveV1Factory = new CurveV1Factory(
+            network,
+            dexKey,
+            dexHelper,
+          );
+          if (newCurveV1Factory.updatePoolState) {
+            await newCurveV1Factory.updatePoolState();
+          }
+          const poolLiquidity = await newCurveV1Factory.getTopPoolsForToken(
+            tokens[srcTokenSymbol].address,
+            10,
+          );
+          console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+          if (!newCurveV1Factory.hasConstantPriceLargeAmounts) {
+            checkPoolsLiquidity(
+              poolLiquidity,
+              Tokens[network][srcTokenSymbol].address,
+              dexKey,
+            );
+          }
+        });
+      });
+    });
+
+    describe('Fantom', () => {
+      const network = Network.FANTOM;
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        // @ts-expect-error for testing there is dummy blocknumber, but it is not
+        // part of the interface
+        dexHelper.blockManager._blockNumber = blockNumber;
+        console.log(
+          `Received blockNumber ${blockNumber} on network ${dexHelper.config.data.network}`,
+        );
+        curveV1Factory = new CurveV1Factory(network, dexKey, dexHelper);
+        if (curveV1Factory.initializePricing) {
+          await curveV1Factory.initializePricing(blockNumber);
+        }
+      });
+
+      describe('scrvUSDC_e -> scrvUSDC_p', () => {
+        const srcTokenSymbol = 'scrvUSDC_e';
+        const destTokenSymbol = 'scrvUSDC_p';
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            curveV1Factory,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getTopPoolsForToken', async function () {
+          // We have to check without calling initializePricing, because
+          // pool-tracker is not calling that function
+          const newCurveV1Factory = new CurveV1Factory(
+            network,
+            dexKey,
+            dexHelper,
+          );
+          if (newCurveV1Factory.updatePoolState) {
+            await newCurveV1Factory.updatePoolState();
+          }
+          const poolLiquidity = await newCurveV1Factory.getTopPoolsForToken(
+            tokens[srcTokenSymbol].address,
+            10,
+          );
+          console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+          if (!newCurveV1Factory.hasConstantPriceLargeAmounts) {
+            checkPoolsLiquidity(
+              poolLiquidity,
+              Tokens[network][srcTokenSymbol].address,
+              dexKey,
+            );
+          }
+        });
+      });
+    });
+
+    describe('Arbitrum', () => {
+      const network = Network.ARBITRUM;
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        // @ts-expect-error for testing there is dummy blocknumber, but it is not
+        // part of the interface
+        dexHelper.blockManager._blockNumber = blockNumber;
+        console.log(
+          `Received blockNumber ${blockNumber} on network ${dexHelper.config.data.network}`,
+        );
+        curveV1Factory = new CurveV1Factory(network, dexKey, dexHelper);
+        if (curveV1Factory.initializePricing) {
+          await curveV1Factory.initializePricing(blockNumber);
+        }
+      });
+
+      describe('crvUSD -> USDCe', () => {
+        const srcTokenSymbol = 'crvUSD';
+        const destTokenSymbol = 'USDCe';
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            curveV1Factory,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getTopPoolsForToken', async function () {
+          // We have to check without calling initializePricing, because
+          // pool-tracker is not calling that function
+          const newCurveV1Factory = new CurveV1Factory(
+            network,
+            dexKey,
+            dexHelper,
+          );
+          if (newCurveV1Factory.updatePoolState) {
+            await newCurveV1Factory.updatePoolState();
+          }
+          const poolLiquidity = await newCurveV1Factory.getTopPoolsForToken(
+            tokens[srcTokenSymbol].address,
+            10,
+          );
+          console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+          if (!newCurveV1Factory.hasConstantPriceLargeAmounts) {
+            checkPoolsLiquidity(
+              poolLiquidity,
+              Tokens[network][srcTokenSymbol].address,
+              dexKey,
+            );
+          }
+        });
+      });
+    });
+
+    describe('Optimism', () => {
+      const network = Network.OPTIMISM;
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        // @ts-expect-error for testing there is dummy blocknumber, but it is not
+        // part of the interface
+        dexHelper.blockManager._blockNumber = blockNumber;
+        console.log(
+          `Received blockNumber ${blockNumber} on network ${dexHelper.config.data.network}`,
+        );
+        curveV1Factory = new CurveV1Factory(network, dexKey, dexHelper);
+        if (curveV1Factory.initializePricing) {
+          await curveV1Factory.initializePricing(blockNumber);
+        }
+      });
+
+      describe('crvUSD -> USDT', () => {
+        const srcTokenSymbol = 'crvUSD';
+        const destTokenSymbol = 'USDT';
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            curveV1Factory,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getTopPoolsForToken', async function () {
+          // We have to check without calling initializePricing, because
+          // pool-tracker is not calling that function
+          const newCurveV1Factory = new CurveV1Factory(
+            network,
+            dexKey,
+            dexHelper,
+          );
+          if (newCurveV1Factory.updatePoolState) {
+            await newCurveV1Factory.updatePoolState();
+          }
+          const poolLiquidity = await newCurveV1Factory.getTopPoolsForToken(
+            tokens[srcTokenSymbol].address,
+            10,
+          );
+          console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+          if (!newCurveV1Factory.hasConstantPriceLargeAmounts) {
+            checkPoolsLiquidity(
+              poolLiquidity,
+              Tokens[network][srcTokenSymbol].address,
+              dexKey,
+            );
+          }
+        });
+      });
+    });
+  });
 });

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

@@ -111,6 +111,8 @@ export class CurveV1Factory
   readonly isFeeOnTransferSupported = true;
   readonly isStatePollingDex = true;
 
+  private factoryAddresses: string[];
+
   readonly poolManager: CurveV1FactoryPoolManager;
   readonly ifaces: CurveV1FactoryIfaces;
 
@@ -138,6 +140,8 @@ export class CurveV1Factory
   ) {
     super(dexHelper, dexKey);
     this.logger = dexHelper.getLogger(`${this.dexKey}-${this.network}`);
+    this.factoryAddresses =
+      this.config.factories?.map(e => e.address.toLowerCase()) || [];
     this.ifaces = {
       exchangeRouter: new Interface(CurveABI),
       factory: new Interface(FactoryCurveV1ABI as JsonFragment[]),
@@ -358,10 +362,7 @@ export class CurveV1Factory
       return;
     }
 
-    if (
-      !this.config.factoryAddresses ||
-      this.config.factoryAddresses.length == 0
-    ) {
+    if (!this.factoryAddresses || this.factoryAddresses.length == 0) {
       this.logger.warn(`No factory address specified in configs`);
       return;
     }
@@ -370,13 +371,13 @@ export class CurveV1Factory
     // So I put it here to not forget call, because custom pools must be initialised before factory pools
     // This function may be called multiple times, but will execute only once
     await this.initializeCustomPollingPools(
-      this.config.factoryAddresses,
+      this.factoryAddresses,
       blockNumber,
       initializeInitialState,
     );
 
     await Promise.all(
-      this.config.factoryAddresses.map(async factoryAddress => {
+      this.factoryAddresses.map(async factoryAddress => {
         try {
           const poolCountResult =
             await this.dexHelper.multiWrapper!.tryAggregate(true, [
@@ -436,6 +437,11 @@ export class CurveV1Factory
             }
           });
 
+          const factoryConfig = this.config.factories?.find(
+            ({ address }) =>
+              factoryAddress.toLowerCase() === address.toLowerCase(),
+          );
+
           let callDataFromFactoryPools: MultiCallParams<
             string[] | number[] | string
           >[] = poolAddresses
@@ -458,7 +464,11 @@ export class CurveV1Factory
                 ): string[] =>
                   generalDecoder<string[]>(
                     result,
-                    ['address[4]'],
+                    [
+                      `address[${
+                        factoryConfig?.maxPlainCoins?.toString() || ''
+                      }]`,
+                    ],
                     new Array(4).fill(NULL_ADDRESS),
                     parsed => parsed[0].map((p: string) => p.toLowerCase()),
                   ),
@@ -474,7 +484,11 @@ export class CurveV1Factory
                 ): number[] =>
                   generalDecoder<number[]>(
                     result,
-                    ['uint256[4]'],
+                    [
+                      `uint256[${
+                        factoryConfig?.maxPlainCoins?.toString() || ''
+                      }]`,
+                    ],
                     [0, 0, 0, 0],
                     parsed =>
                       parsed[0].map((p: BigNumber) => Number(p.toString())),
@@ -486,43 +500,51 @@ export class CurveV1Factory
           // This is divider between pools related results and implementations
           const factoryResultsDivider = callDataFromFactoryPools.length;
 
+          const metaPoolImplementations = factoryConfig?.isStableNg
+            ? []
+            : basePoolAddresses.map(basePoolAddress => ({
+                target: factoryAddress,
+                callData: this.ifaces.factory.encodeFunctionData(
+                  'metapool_implementations',
+                  [basePoolAddress],
+                ),
+                decodeFunction: (
+                  result: MultiResult<BytesLike> | BytesLike,
+                ): string[] =>
+                  generalDecoder<string[]>(
+                    result,
+                    ['address[10]'],
+                    new Array(10).fill(NULL_ADDRESS),
+                    parsed => parsed[0].map((p: string) => p.toLowerCase()),
+                  ),
+              }));
+
+          const plainImplementations = factoryConfig?.isStableNg
+            ? []
+            : _.flattenDeep(
+                _.range(2, FACTORY_MAX_PLAIN_COINS + 1).map(coinNumber =>
+                  _.range(FACTORY_MAX_PLAIN_IMPLEMENTATIONS_FOR_COIN).map(
+                    implInd => ({
+                      target: factoryAddress,
+                      callData: this.ifaces.factory.encodeFunctionData(
+                        'plain_implementations',
+                        [coinNumber, implInd],
+                      ),
+                      decodeFunction: addressDecode,
+                    }),
+                  ),
+                ),
+              );
+
           // Implementations must be requested from factory, but it accepts as arg basePool address
           // for metaPools
           callDataFromFactoryPools = callDataFromFactoryPools.concat(
-            ...basePoolAddresses.map(basePoolAddress => ({
-              target: factoryAddress,
-              callData: this.ifaces.factory.encodeFunctionData(
-                'metapool_implementations',
-                [basePoolAddress],
-              ),
-              decodeFunction: (
-                result: MultiResult<BytesLike> | BytesLike,
-              ): string[] =>
-                generalDecoder<string[]>(
-                  result,
-                  ['address[10]'],
-                  new Array(10).fill(NULL_ADDRESS),
-                  parsed => parsed[0].map((p: string) => p.toLowerCase()),
-                ),
-            })),
+            ...metaPoolImplementations,
             // To receive plain pool implementation address, you have to call plain_implementations
             // with two variables: N_COINS and implementations_index
             // N_COINS is between 2-4. Currently more than 4 coins is not supported
             // as for implementation index, there are only 0-9 indexes
-            ..._.flattenDeep(
-              _.range(2, FACTORY_MAX_PLAIN_COINS + 1).map(coinNumber =>
-                _.range(FACTORY_MAX_PLAIN_IMPLEMENTATIONS_FOR_COIN).map(
-                  implInd => ({
-                    target: factoryAddress,
-                    callData: this.ifaces.factory.encodeFunctionData(
-                      'plain_implementations',
-                      [coinNumber, implInd],
-                    ),
-                    decodeFunction: addressDecode,
-                  }),
-                ),
-              ),
-            ),
+            ...plainImplementations,
           );
 
           const allResultsFromFactory = (
@@ -629,7 +651,7 @@ export class CurveV1Factory
               factoryImplementationFromConfig.name,
               implementationAddress.toLowerCase(),
               poolAddresses[i],
-              this.config.stateUpdatePeriodMs,
+              this.config,
               factoryAddress,
               poolIdentifier,
               poolConstants,
@@ -1154,6 +1176,7 @@ export class CurveV1Factory
       sendEthButSupportsInsertFromAmount: true,
       dexFuncHasRecipient: false,
       targetExchange: exchange,
+      returnAmountPos: undefined,
     };
   }
 

package/src/dex/curve-v1-factory/curve-v1-pool-manager.ts

@@ -45,6 +45,7 @@ export class CurveV1FactoryPoolManager {
   private allCurveLiquidityApiSlugs: Set<string> = new Set([
     '/factory',
     '/factory-crvusd',
+    '/factory-stable-ng',
   ]);
 
   private statePollingManager = StatePollingManager;

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

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

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

@@ -1,9 +1,8 @@
-import _ from 'lodash';
 import { ImplementationNames } from '../../types';
 import { IPoolContext, _dynamic_fee } from '../types';
 import { throwNotExist } from './utils';
 
-const customAvalanche3CoinLending: _dynamic_fee = (
+const dynamicFee: _dynamic_fee = (
   self: IPoolContext,
   xpi: bigint,
   xpj: bigint,
@@ -23,6 +22,9 @@ const customAvalanche3CoinLending: _dynamic_fee = (
   }
 };
 
+const stableNg = dynamicFee;
+const customAvalanche3CoinLending = dynamicFee;
+
 const notExist: _dynamic_fee = (
   self: IPoolContext,
   xpi: bigint,
@@ -94,6 +96,8 @@ const implementations: Record<ImplementationNames, _dynamic_fee> = {
   [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]: stableNg,
 };
 
 export default implementations;

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

@@ -109,6 +109,8 @@ const implementations: Record<ImplementationNames, _rates> = {
   [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/_xp.ts

@@ -107,6 +107,8 @@ const implementations: Record<ImplementationNames, _xp> = {
   [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/_xp_mem.ts

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

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

@@ -223,6 +223,8 @@ const implementations: Record<ImplementationNames, calc_token_amount> = {
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA]: customPlain3CoinThree,
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA2]: customPlain3CoinThree,
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]: customPlain2CoinCrv,
+
+  [ImplementationNames.FACTORY_STABLE_NG]: notImplemented,
 };
 
 export default implementations;

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

@@ -83,6 +83,8 @@ export const implementations: Record<
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA]: customPlain3CoinThree,
   [ImplementationNames.FACTORY_PLAIN_2_ETH_EMA2]: customPlain3CoinThree,
   [ImplementationNames.FACTORY_PLAIN_2_CRV_EMA]: customPlain3CoinThree,
+
+  [ImplementationNames.FACTORY_STABLE_NG]: notImplemented,
 };
 
 export default implementations;

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

@@ -584,6 +584,17 @@ const implementationConstants: Record<
     isFeeOnTransferSupported: false,
     isLending: false,
 
+    N_COINS: 2,
+    BI_N_COINS: 2n,
+    PRECISION: BI_POWS[18],
+    FEE_DENOMINATOR: BI_POWS[10],
+    A_PRECISION: 100n,
+  },
+  [ImplementationNames.FACTORY_STABLE_NG]: {
+    isWrapNative: false,
+    isFeeOnTransferSupported: false,
+    isLending: false,
+
     N_COINS: 2,
     BI_N_COINS: 2n,
     PRECISION: BI_POWS[18],