feat(amm): handle empty pools

src/parachain/amm.ts

@@ -326,11 +326,7 @@ export class DefaultAMMAPI implements AMMAPI {
             this._getPoolRewardAmountsYearly(lpTokenCurrencyId, blockTimeMs),
         ]);
 
-        // Do not include pools with zero liquidity.
-        if (this._poolHasZeroLiquidity(pooledCurrencies)) {
-            return null;
-        }
-
+        const isEmpty = this._poolHasZeroLiquidity(pooledCurrencies);
         const totalSupply = new MonetaryAmount(lpToken, totalSupplyAmount);
 
         return new StandardLiquidityPool(
@@ -339,7 +335,8 @@ export class DefaultAMMAPI implements AMMAPI {
             yearlyRewards,
             tradingFee,
             isTradingActive,
-            totalSupply
+            totalSupply,
+            isEmpty
         );
     }
 
@@ -487,11 +484,7 @@ export class DefaultAMMAPI implements AMMAPI {
         }
         const { lpToken, actuallyPooledCurrencies, yearlyRewards, tradingFee, amplificationCoefficient, totalSupply } =
             processedPoolData;
-
-        // Do not include pools with zero liquidity.
-        if (this._poolHasZeroLiquidity(actuallyPooledCurrencies)) {
-            return null;
-        }
+        const isEmpty = this._poolHasZeroLiquidity(actuallyPooledCurrencies);
 
         if (poolData.isBase) {
             return new StableLiquidityPool(
@@ -503,7 +496,8 @@ export class DefaultAMMAPI implements AMMAPI {
                 tradingFee,
                 poolId,
                 amplificationCoefficient,
-                totalSupply
+                totalSupply,
+                isEmpty
             );
         }
 
@@ -526,6 +520,7 @@ export class DefaultAMMAPI implements AMMAPI {
             poolId,
             amplificationCoefficient,
             totalSupply,
+            isEmpty,
             basePool
         );
     }

src/parachain/amm/liquidity-pool/calculator.ts

@@ -24,6 +24,7 @@ class LiquidityPoolCalculator<TLpToken extends LpCurrency> {
      *
      * @param amount Amount of one of the pooled currencies.
      * @returns Monetary amounts of all pooled currencies in balanced proportion.
+     * @throws If pool is empty. Note: handle by checking `isEmpty` property of pool.
      */
     public getLiquidityDepositInputAmounts(amount: MonetaryAmount<CurrencyExt>): Array<MonetaryAmount<CurrencyExt>> {
         const inputCurrencyReserve = this._getCurrencyReserve(amount.currency);
@@ -41,6 +42,7 @@ class LiquidityPoolCalculator<TLpToken extends LpCurrency> {
      * @note This method assumes all pooled currencies will be added in balance.
      * @param amount Amount of one of the pooled currencies.
      * @returns Expected amount of lp token that will be received after `amount` is added to pool.
+     * @throws If pool is empty. Note: handle by checking `isEmpty` property of pool.
      */
     public getLiquidityDepositLpTokenAmount(amount: MonetaryAmount<CurrencyExt>): MonetaryAmount<TLpToken> {
         const currencyReserveAmount = this._getCurrencyReserve(amount.currency);
@@ -57,6 +59,7 @@ class LiquidityPoolCalculator<TLpToken extends LpCurrency> {
      * @note This method assumes all pooled currencies will be withdrawn in balance.
      * @param amount Amount of liquidity in LP token to be withdrawn.
      * @returns Amounts of pooled currencies to be returned to account.
+     * @throws If pool is empty. Note: handle by checking `isEmpty` property of pool.
      */
     public getLiquidityWithdrawalPooledCurrencyAmounts(
         amount: MonetaryAmount<TLpToken>

src/parachain/amm/liquidity-pool/stable-meta.ts

@@ -14,6 +14,7 @@ class StableLiquidityMetaPool extends StableLiquidityPool {
         poolId: number,
         amplificationCoefficient: Big,
         totalSupply: MonetaryAmount<StableLpToken>,
+        isEmpty: boolean,
         public basePool: StableLiquidityPool // Contains base pool object.
     ) {
         super(
@@ -25,7 +26,8 @@ class StableLiquidityMetaPool extends StableLiquidityPool {
             tradingFee,
             poolId,
             amplificationCoefficient,
-            totalSupply
+            totalSupply,
+            isEmpty
         );
     }
 }

src/parachain/amm/liquidity-pool/stable.ts

@@ -18,7 +18,8 @@ class StableLiquidityPool extends LiquidityPoolCalculator<StableLpToken> impleme
         public tradingFee: Big, // Decimal point
         public poolId: number,
         public amplificationCoefficient: Big,
-        public totalSupply: MonetaryAmount<StableLpToken>
+        public totalSupply: MonetaryAmount<StableLpToken>,
+        public isEmpty: boolean
     ) {
         super(pooledCurrencies, totalSupply);
     }

src/parachain/amm/liquidity-pool/standard.ts

@@ -18,7 +18,8 @@ class StandardLiquidityPool extends LiquidityPoolCalculator<StandardLpToken> imp
         public rewardAmountsYearly: Array<MonetaryAmount<CurrencyExt>>,
         public tradingFee: Big,
         public isTradingActive: boolean, // True if in `Trading` state, false if in `Bootstrap` state
-        public totalSupply: MonetaryAmount<StandardLpToken>
+        public totalSupply: MonetaryAmount<StandardLpToken>,
+        public isEmpty: boolean
     ) {
         super(pooledCurrencies, totalSupply);
 

src/parachain/amm/liquidity-pool/utils.ts

@@ -13,17 +13,21 @@ import { StableLiquidityPool } from "./stable";
 import { isStablePool, isStandardPool, LiquidityPool } from "./types";
 import { StableLiquidityMetaPool } from "./stable-meta";
 
+const filterNonEmptyPools = (pools: Array<LiquidityPool>): Array<LiquidityPool> =>
+    pools.filter(({ isEmpty }) => !isEmpty);
+
 /**
  * Get all trading pairs based on provided pools.
  *
- * @param pools All standard and stable pools.
+ * @param nonEmptyPools All standard and stable pools.
  * @returns {Array<TradingPair>} All trading pairs.
  */
 const getAllTradingPairs = (pools: Array<LiquidityPool>): Array<TradingPair> => {
-    const stablePools = pools.filter(isStablePool);
+    const nonEmptyPools = filterNonEmptyPools(pools);
+    const stablePools = nonEmptyPools.filter(isStablePool);
     const pairs: Array<TradingPair> = [];
 
-    pools.forEach((pool) => {
+    nonEmptyPools.forEach((pool) => {
         if (isStandardPool(pool)) {
             // Exclude pool in Bootstrap status
             if (pool.isTradingActive) {
@@ -205,4 +209,4 @@ const getStableSwapOutputAmount = (
     return outputAmount;
 };
 
-export { getAllTradingPairs, getStableSwapOutputAmount };
+export { getAllTradingPairs, getStableSwapOutputAmount, filterNonEmptyPools };

src/parachain/amm/types.ts

@@ -12,6 +12,7 @@ interface LiquidityPoolBase {
     tradingFee: Big; // Decimal.
     totalSupply: MonetaryAmount<LpCurrency>;
     rewardAmountsYearly: Array<MonetaryAmount<CurrencyExt>>; // Array of monetary amounts containing reward per pool yearly.
+    isEmpty: boolean;
 }
 
 enum PoolType {