@paraswap/dex-lib 2.17.0 → 2.17.1-pancakeswapv3.0

package/src/dex/balancer-v2/balancer-v2-e2e.test.ts

@@ -31,10 +31,7 @@ describe('BalancerV2 E2E', () => {
             ContractMethod.megaSwap,
           ],
         ],
-        [SwapSide.BUY, [
-          ContractMethod.simpleBuy,
-          ContractMethod.buy
-        ]],
+        [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
       ]);
 
       const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
@@ -98,7 +95,7 @@ describe('BalancerV2 E2E', () => {
               sellAmount: '200000000000000',
               buyAmount: '10000000000',
             },
-          ]
+          ],
         ];
 
       sideToContractMethods.forEach((contractMethods, side) =>
@@ -153,11 +150,14 @@ describe('BalancerV2 E2E', () => {
             ContractMethod.megaSwap,
           ],
         ],
-        [SwapSide.BUY, [
-          // Buy support is enabled only for Weighted Pools
-          // ContractMethod.simpleBuy,
-          // ContractMethod.buy
-        ]],
+        [
+          SwapSide.BUY,
+          [
+            // Buy support is enabled only for Weighted Pools
+            // ContractMethod.simpleBuy,
+            // ContractMethod.buy
+          ],
+        ],
       ]);
 
       const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
@@ -555,10 +555,7 @@ describe('BalancerV2 E2E', () => {
             ContractMethod.megaSwap,
           ],
         ],
-        [SwapSide.BUY, [
-          ContractMethod.simpleBuy,
-          ContractMethod.buy
-        ]],
+        [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
       ]);
 
       const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
@@ -857,10 +854,7 @@ describe('BalancerV2 E2E', () => {
             ContractMethod.megaSwap,
           ],
         ],
-        [SwapSide.BUY, [
-          ContractMethod.simpleBuy,
-          ContractMethod.buy
-        ]],
+        [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
       ]);
 
       const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
@@ -932,7 +926,7 @@ describe('BalancerV2 E2E', () => {
         }),
       );
     });
-  })
+  });
 
   describe('BeetsFi OPTIMISM', () => {
     const dexKey = 'BeetsFi';

package/src/dex/balancer-v2/balancer-v2-integration.test.ts

@@ -11,7 +11,7 @@ import { Tokens } from '../../../tests/constants-e2e';
 import { BalancerV2Data } from './types';
 import { PoolPrices } from '../../types';
 
-const amounts = [ 0n, BI_POWS[18], 2000000000000000000n ];
+const amounts = [0n, BI_POWS[18], 2000000000000000000n];
 
 const dexKey = 'BalancerV2';
 
@@ -23,42 +23,53 @@ async function getOnChainPricingForWeightedPool(
   srcTokenAddress: string,
   destTokenAddress: string,
   side: SwapSide,
-): Promise<BigInt[]>{
-  return Promise.all(poolPrice.prices.map(async (price, index) => {
-    if(amounts[index] === 0n) {
-      return 0n;
-    }
-
-    const params = balancerV2.getBalancerParam(
-      srcTokenAddress,
-      destTokenAddress,
-      '0',
-      '0',
-      {
-        swaps: [
-          { poolId: poolPrice.data.poolId, amount: amounts[index].toString() },
-        ]
-      },
-      side,
-    );
+): Promise<BigInt[]> {
+  return Promise.all(
+    poolPrice.prices.map(async (price, index) => {
+      if (amounts[index] === 0n) {
+        return 0n;
+      }
+
+      const params = balancerV2.getBalancerParam(
+        srcTokenAddress,
+        destTokenAddress,
+        '0',
+        '0',
+        {
+          swaps: [
+            {
+              poolId: poolPrice.data.poolId,
+              amount: amounts[index].toString(),
+            },
+          ],
+        },
+        side,
+      );
 
-    const calldata = [
-      {
-        target: balancerV2.vaultAddress,
-        callData: balancerV2.eventPools.vaultInterface.encodeFunctionData('queryBatchSwap', params.slice(0, 4)),
-      },
-    ];
-
-    const results = (
-      await balancerV2.dexHelper.multiContract.methods
-        .aggregate(calldata)
-        .call({}, blockNumber)
-    ).returnData;
-
-    const parsed = balancerV2.eventPools.vaultInterface.decodeFunctionResult('queryBatchSwap', results[0]);
-    const resultIndex = side === SwapSide.SELL ? parsed[0].length - 1 : 0;
-    return BigInt(parsed[0][resultIndex]._hex.replace('-', ''));
-  }));
+      const calldata = [
+        {
+          target: balancerV2.vaultAddress,
+          callData: balancerV2.eventPools.vaultInterface.encodeFunctionData(
+            'queryBatchSwap',
+            params.slice(0, 4),
+          ),
+        },
+      ];
+
+      const results = (
+        await balancerV2.dexHelper.multiContract.methods
+          .aggregate(calldata)
+          .call({}, blockNumber)
+      ).returnData;
+
+      const parsed = balancerV2.eventPools.vaultInterface.decodeFunctionResult(
+        'queryBatchSwap',
+        results[0],
+      );
+      const resultIndex = side === SwapSide.SELL ? parsed[0].length - 1 : 0;
+      return BigInt(parsed[0][resultIndex]._hex.replace('-', ''));
+    }),
+  );
 }
 
 describe('BalancerV2', function () {

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

@@ -12,7 +12,15 @@ import {
   SimpleExchangeParam,
   Token,
 } from '../../types';
-import { ETHER_ADDRESS, MAX_INT, MAX_UINT, Network, NULL_ADDRESS, SUBGRAPH_TIMEOUT, SwapSide, } from '../../constants';
+import {
+  ETHER_ADDRESS,
+  MAX_INT,
+  MAX_UINT,
+  Network,
+  NULL_ADDRESS,
+  SUBGRAPH_TIMEOUT,
+  SwapSide,
+} from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
 import { StablePool } from './pools/stable/StablePool';
 import { WeightedPool } from './pools/weighted/WeightedPool';
@@ -38,8 +46,17 @@ import {
 } from './types';
 import { SimpleExchange } from '../simple-exchange';
 import { Adapters, BalancerConfig } from './config';
-import { getAllPoolsUsedInPaths, isSameAddress, poolGetMainTokens, poolGetPathForTokenInOut, } from './utils';
-import { MIN_USD_LIQUIDITY_TO_FETCH, STABLE_GAS_COST, VARIABLE_GAS_COST_PER_CYCLE } from './constants';
+import {
+  getAllPoolsUsedInPaths,
+  isSameAddress,
+  poolGetMainTokens,
+  poolGetPathForTokenInOut,
+} from './utils';
+import {
+  MIN_USD_LIQUIDITY_TO_FETCH,
+  STABLE_GAS_COST,
+  VARIABLE_GAS_COST_PER_CYCLE,
+} from './constants';
 
 const fetchAllPools = `query ($count: Int) {
   pools: pools(
@@ -348,7 +365,10 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
       return null;
     }
 
-    if(subgraphPool.poolType !== BalancerPoolTypes.Weighted && side === SwapSide.BUY) {
+    if (
+      subgraphPool.poolType !== BalancerPoolTypes.Weighted &&
+      side === SwapSide.BUY
+    ) {
       return null;
     }
 
@@ -495,8 +515,7 @@ export class BalancerV2
     protected network: Network,
     dexKey: string,
     public dexHelper: IDexHelper,
-    public vaultAddress: Address = BalancerConfig[dexKey][network]
-      .vaultAddress,
+    public vaultAddress: Address = BalancerConfig[dexKey][network].vaultAddress,
     protected subgraphURL: string = BalancerConfig[dexKey][network].subgraphURL,
     protected adapters = Adapters[network],
   ) {
@@ -596,23 +615,22 @@ export class BalancerV2
   }
 
   getPoolsWithTokenPair(from: Token, to: Token): SubgraphPoolBase[] {
-    const pools = this.eventPools.allPools
-      .filter(p => {
-        const fromMain = p.mainTokens.find(
-          token => token.address.toLowerCase() === from.address.toLowerCase(),
-        );
-        const toMain = p.mainTokens.find(
-          token => token.address.toLowerCase() === to.address.toLowerCase(),
-        );
+    const pools = this.eventPools.allPools.filter(p => {
+      const fromMain = p.mainTokens.find(
+        token => token.address.toLowerCase() === from.address.toLowerCase(),
+      );
+      const toMain = p.mainTokens.find(
+        token => token.address.toLowerCase() === to.address.toLowerCase(),
+      );
 
-        return (
-          fromMain &&
-          toMain &&
-          // filter instances similar to the following:
-          // USDC -> DAI in a pool where bbaUSD is nested (ie: MAI / bbaUSD)
-          !(fromMain.isDeeplyNested && toMain.isDeeplyNested)
-        );
-      });
+      return (
+        fromMain &&
+        toMain &&
+        // filter instances similar to the following:
+        // USDC -> DAI in a pool where bbaUSD is nested (ie: MAI / bbaUSD)
+        !(fromMain.isDeeplyNested && toMain.isDeeplyNested)
+      );
+    });
 
     return pools.slice(0, 10);
   }
@@ -952,7 +970,7 @@ export class BalancerV2
         side,
       );
 
-      if(side === SwapSide.BUY) {
+      if (side === SwapSide.BUY) {
         path = path.reverse();
       }
 
@@ -960,7 +978,11 @@ export class BalancerV2
         poolId: hop.pool.id,
         assetInIndex: swapOffset + index,
         assetOutIndex: swapOffset + index + 1,
-        amount: (side === SwapSide.SELL && index === 0 || side === SwapSide.BUY && index === path.length - 1) ? swapData.amount  : '0',
+        amount:
+          (side === SwapSide.SELL && index === 0) ||
+          (side === SwapSide.BUY && index === path.length - 1)
+            ? swapData.amount
+            : '0',
         userData: '0x',
       }));
 

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

@@ -51,7 +51,7 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'PolygonAdapter01', index: 9 }],
     [SwapSide.BUY]: [{ name: 'PolygonBuyAdapter', index: 6 }],
   },
-  [Network.FANTOM]:{
+  [Network.FANTOM]: {
     [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 5 }],
     [SwapSide.BUY]: [{ name: 'FantomBuyAdapter', index: 4 }],
   },

package/src/dex/balancer-v2/pools/linear/LinearMath.ts

@@ -271,8 +271,8 @@ export function _calcTokensOutGivenExactBptIn(
    // bpt = bptTotalSupply                                                                      //
    **********************************************************************************************/
 
-    // Since we're computing an amount out, we round down overall. This means rounding down on both the
-    // multiplication and division.
+  // Since we're computing an amount out, we round down overall. This means rounding down on both the
+  // multiplication and division.
 
   const bptRatio = MathSol.divDownFixed(bptAmountIn, bptTotalSupply);
   const amountsOut: bigint[] = new Array(balances.length);

package/src/dex/balancer-v2/pools/linear/LinearPool.ts

@@ -631,7 +631,7 @@ export class LinearPool extends BasePool {
       (this._upscale(
         poolPairData.balances[poolPairData.indexOut],
         poolPairData.scalingFactors[poolPairData.indexOut],
-        ) *
+      ) *
         99n) /
       100n
     );

package/src/dex/balancer-v2/pools/phantom-stable/PhantomStableMath.ts

@@ -17,7 +17,7 @@ export function _calculateInvariant(
    // n = number of tokens                                                                      //
    *********x************************************************************************************/
 
-    // We support rounding up or down.
+  // We support rounding up or down.
 
   let sum = 0n;
   const numTokens = balances.length;
@@ -44,18 +44,18 @@ export function _calculateInvariant(
     prevInvariant = invariant;
     invariant = MathSol.div(
       MathSol.mul(MathSol.mul(BigInt(numTokens), invariant), invariant) +
-      MathSol.div(
-        MathSol.mul(MathSol.mul(ampTimesTotal, sum), P_D),
-        AMP_PRECISION,
-        roundUp,
-      ),
+        MathSol.div(
+          MathSol.mul(MathSol.mul(ampTimesTotal, sum), P_D),
+          AMP_PRECISION,
+          roundUp,
+        ),
       MathSol.mul(BigInt(numTokens + 1), invariant) +
-      // No need to use checked arithmetic for the amp precision, the amp is guaranteed to be at least 1
-      MathSol.div(
-        MathSol.mul(ampTimesTotal - AMP_PRECISION, P_D),
-        AMP_PRECISION,
-        !roundUp,
-      ),
+        // No need to use checked arithmetic for the amp precision, the amp is guaranteed to be at least 1
+        MathSol.div(
+          MathSol.mul(ampTimesTotal - AMP_PRECISION, P_D),
+          AMP_PRECISION,
+          !roundUp,
+        ),
       roundUp,
     );
 
@@ -234,9 +234,9 @@ export function _calcTokenInGivenExactBptOut(
   const newInvariant = MathSol.mulUpFixed(
     MathSol.divUpFixed(
       MathSol.add(bptTotalSupply, bptAmountOut),
-      bptTotalSupply
+      bptTotalSupply,
     ),
-    invariant
+    invariant,
   );
 
   const newBalanceTokenIndex =
@@ -244,11 +244,11 @@ export function _calcTokenInGivenExactBptOut(
       amp,
       balances,
       newInvariant,
-      tokenIndexIn
+      tokenIndexIn,
     );
   const amountInWithoutFee = MathSol.sub(
     newBalanceTokenIndex,
-    balances[tokenIndexIn]
+    balances[tokenIndexIn],
   );
 
   let sumBalances = BigInt(0);
@@ -260,18 +260,18 @@ export function _calcTokenInGivenExactBptOut(
   // and used in virtual swaps, and charge swap fees accordingly.
   const currentWeight = MathSol.divDownFixed(
     balances[tokenIndexIn],
-    sumBalances
+    sumBalances,
   );
   const taxablePercentage = MathSol.complementFixed(currentWeight);
   const taxableAmount = MathSol.mulUpFixed(
     amountInWithoutFee,
-    taxablePercentage
+    taxablePercentage,
   );
   const nonTaxableAmount = MathSol.sub(amountInWithoutFee, taxableAmount);
 
   return MathSol.add(
     nonTaxableAmount,
-    MathSol.divUpFixed(taxableAmount, MathSol.sub(MathSol.ONE, fee))
+    MathSol.divUpFixed(taxableAmount, MathSol.sub(MathSol.ONE, fee)),
   );
 }
 

package/src/dex/balancer-v2/pools/phantom-stable/PhantomStablePool.ts

@@ -282,7 +282,6 @@ export class PhantomStablePool extends BasePool {
         amountsIn.push(amt);
       });
     } else if (pairType === PairTypes.BptToToken) {
-
       tokenAmountsOut.forEach(amountOut => {
         let amt: bigint;
         try {

package/src/dex/balancer-v2/pools/stable/StableMath.ts

@@ -44,18 +44,18 @@ export class StableMath {
       prevInvariant = invariant;
       invariant = MathSol.div(
         MathSol.mul(MathSol.mul(BigInt(numTokens), invariant), invariant) +
-        MathSol.div(
-          MathSol.mul(MathSol.mul(ampTimesTotal, sum), P_D),
-          this._AMP_PRECISION,
-          roundUp,
-        ),
+          MathSol.div(
+            MathSol.mul(MathSol.mul(ampTimesTotal, sum), P_D),
+            this._AMP_PRECISION,
+            roundUp,
+          ),
         MathSol.mul(BigInt(numTokens + 1), invariant) +
-        // No need to use checked arithmetic for the amp precision, the amp is guaranteed to be at least 1
-        MathSol.div(
-          MathSol.mul(ampTimesTotal - this._AMP_PRECISION, P_D),
-          this._AMP_PRECISION,
-          !roundUp,
-        ),
+          // No need to use checked arithmetic for the amp precision, the amp is guaranteed to be at least 1
+          MathSol.div(
+            MathSol.mul(ampTimesTotal - this._AMP_PRECISION, P_D),
+            this._AMP_PRECISION,
+            !roundUp,
+          ),
         roundUp,
       );
 
@@ -71,7 +71,6 @@ export class StableMath {
     throw new Error('Errors.STABLE_INVARIANT_DIDNT_CONVERGE');
   }
 
-
   static _calcInGivenOut(
     amplificationParameter: bigint,
     balances: bigint[],
@@ -101,7 +100,7 @@ export class StableMath {
         1n,
       );
     });
-  };
+  }
 
   static _calcOutGivenIn(
     amplificationParameter: bigint,
@@ -117,7 +116,7 @@ export class StableMath {
       amplificationParameter,
       balances,
       true,
-      );
+    );
 
     const initBalance = balances[tokenIndexIn];
     // Modification: The original code was implemented for a single tokenAmountsIn

package/src/dex/balancer-v2/pools/stable/StablePool.ts

@@ -77,7 +77,9 @@ export class StablePool extends BaseGeneralPool {
 
     const scalingFactors: bigint[] = [];
     const balances = poolState.orderedTokens.map((tokenAddress, i) => {
-      const t = pool.tokensMap[tokenAddress.toLowerCase()] || poolState.tokens[tokenAddress.toLowerCase()];
+      const t =
+        pool.tokensMap[tokenAddress.toLowerCase()] ||
+        poolState.tokens[tokenAddress.toLowerCase()];
 
       if (t.address.toLowerCase() === tokenIn.toLowerCase()) {
         indexIn = i;
@@ -213,7 +215,7 @@ export class StablePool extends BaseGeneralPool {
       (this._upscale(
         poolPairData.balances[poolPairData.indexOut],
         poolPairData.scalingFactors[poolPairData.indexOut],
-        ) *
+      ) *
         99n) /
       100n
     );

package/src/dex/balancer-v2/pools/weighted/WeightedPool.ts

@@ -16,7 +16,6 @@ export type WeightedPoolPairData = {
   swapFee: bigint;
 };
 
-
 export class WeightedPool extends BaseMinimalSwapInfoPool {
   vaultAddress: string;
   vaultInterface: Interface;

package/src/dex/index.ts

@@ -64,8 +64,8 @@ import { QuickSwapV3 } from './quickswap/quickswap-v3';
 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';
+import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 
 const LegacyDexes = [
   CurveV2,

package/src/dex/pancakeswap-v3/config.ts

@@ -0,0 +1,68 @@
+import { DexParams } from '../uniswap-v3/types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+import { Address } from '../../types';
+
+const PANCAKE_SUPPORTED_FEES = [10000n, 2500n, 500n, 100n];
+
+// Pools that will be initialized on app startup
+// They are added for testing
+export const PancakeswapV3Config: DexConfigMap<DexParams> = {
+  PancakeswapV3: {
+    [Network.MAINNET]: {
+      factory: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+      deployer: '0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9',
+      quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+      router: '0x1b81D678ffb9C0263b24A97847620C99d213eB14',
+      supportedFees: PANCAKE_SUPPORTED_FEES,
+      stateMulticall: '0x80898f80cFA3Fa3AbF410d90e69aDc432AE5D4c2',
+      uniswapMulticall: '0xac1cE734566f390A94b00eb9bf561c2625BF44ea',
+      chunksCount: 10,
+      initHash:
+        '0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/pancakeswap/exchange-v3-eth',
+    },
+    [Network.BSC]: {
+      factory: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+      deployer: '0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9',
+      quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+      router: '0x1b81D678ffb9C0263b24A97847620C99d213eB14',
+      supportedFees: PANCAKE_SUPPORTED_FEES,
+      stateMulticall: '0x9DAd2ED7ADc6eaacf81589Cd043579c9684E5C81',
+      uniswapMulticall: '0xac1cE734566f390A94b00eb9bf561c2625BF44ea',
+      chunksCount: 10,
+      initHash:
+        '0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/pancakeswap/exchange-v3-bsc',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [{ name: 'Adapter01', index: 6 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter', index: 2 }],
+  },
+  [Network.BSC]: {
+    [SwapSide.SELL]: [{ name: 'BscAdapter02', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'BscBuyAdapter', index: 5 }],
+  },
+  [Network.POLYGON]: {
+    [SwapSide.SELL]: [{ name: 'PolygonAdapter01', index: 13 }],
+    [SwapSide.BUY]: [{ name: 'PolygonBuyAdapter', index: 2 }],
+  },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter01', index: 3 }],
+    [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 2 }],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 3 }],
+    [SwapSide.BUY]: [{ name: 'OptimismBuyAdapter', index: 2 }],
+  },
+  [Network.FANTOM]: {
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 11 }],
+    [SwapSide.BUY]: [{ name: 'FantomBuyAdapter', index: 3 }],
+  },
+};

package/src/dex/pancakeswap-v3/constants.ts

@@ -0,0 +1,35 @@
+export const PANCAKESWAP3_FUNCTION_CALL_GAS_COST = 21_000; // Ceiled
+export const PANCAKESWAPV3_TICK_GAS_COST = 24_000; // Ceiled
+
+// This is used for price calculation. If out of scope, return 0n
+export const TICK_BITMAP_TO_USE = 4n;
+
+// This is used to check if the state is still valid.
+export const TICK_BITMAP_BUFFER = 8n;
+
+export const MAX_PRICING_COMPUTATION_STEPS_ALLOWED = 128;
+
+export const PANCAKESWAPV3_SUBGRAPH_URL =
+  'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3';
+
+export const PANCAKESWAPV3_EFFICIENCY_FACTOR = 3;
+
+export const ZERO_TICK_INFO = {
+  liquidityGross: 0n,
+  liquidityNet: 0n,
+  tickCumulativeOutside: 0n,
+  secondsPerLiquidityOutsideX128: 0n,
+  secondsOutside: 0n,
+  initialized: false,
+};
+
+export const ZERO_ORACLE_OBSERVATION = {
+  blockTimestamp: 0n,
+  tickCumulative: 0n,
+  secondsPerLiquidityCumulativeX128: 0n,
+  initialized: false,
+};
+
+export const OUT_OF_RANGE_ERROR_POSTFIX = `INVALID_TICK_BIT_MAP_RANGES`;
+
+export const DEFAULT_POOL_INIT_CODE_HASH = `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`;