@paraswap/dex-lib 2.16.3 → 2.16.4-balancer-v2-buy.2

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

@@ -2,49 +2,50 @@ import { Interface } from '@ethersproject/abi';
 import { assert, DeepReadonly } from 'ts-essentials';
 import _, { keyBy } from 'lodash';
 import {
-  Token,
+  AdapterExchangeParam,
   Address,
   ExchangePrices,
-  PoolPrices,
   Log,
-  AdapterExchangeParam,
-  SimpleExchangeParam,
-  PoolLiquidity,
   Logger,
+  PoolLiquidity,
+  PoolPrices,
+  SimpleExchangeParam,
+  Token,
 } from '../../types';
 import {
-  SwapSide,
   ETHER_ADDRESS,
-  NULL_ADDRESS,
   MAX_INT,
   MAX_UINT,
   Network,
+  NULL_ADDRESS,
   SUBGRAPH_TIMEOUT,
+  SwapSide,
 } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { StablePool, WeightedPool } from './balancer-v2-pool';
-import { PhantomStablePool } from './PhantomStablePool';
-import { LinearPool } from './LinearPool';
+import { StablePool } from './pools/stable/StablePool';
+import { WeightedPool } from './pools/weighted/WeightedPool';
+import { PhantomStablePool } from './pools/phantom-stable/PhantomStablePool';
+import { LinearPool } from './pools/linear/LinearPool';
 import VaultABI from '../../abi/balancer-v2/vault.json';
 import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { getDexKeysWithNetwork, getBigIntPow } from '../../utils';
+import { getBigIntPow, getDexKeysWithNetwork } from '../../utils';
 import { IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper';
 import {
-  PoolState,
-  SubgraphPoolBase,
-  BalancerV2Data,
   BalancerParam,
+  BalancerPoolTypes,
   BalancerSwap,
+  BalancerV2Data,
   OptimizedBalancerV2Data,
-  SwapTypes,
-  PoolStateMap,
+  PoolState,
   PoolStateCache,
-  BalancerPoolTypes,
+  PoolStateMap,
   SubgraphPoolAddressDictionary,
+  SubgraphPoolBase,
+  SwapTypes,
 } from './types';
 import { SimpleExchange } from '../simple-exchange';
-import { BalancerConfig, Adapters } from './config';
+import { Adapters, BalancerConfig } from './config';
 import {
   getAllPoolsUsedInPaths,
   isSameAddress,
@@ -407,13 +408,22 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
     const unitResult =
       checkedUnitVolume === 0n
         ? 0n
-        : pool.onSell([checkedUnitVolume], poolPairData as any)[0];
+        : side === SwapSide.SELL
+        ? pool.onSell([checkedUnitVolume], poolPairData as any)[0]
+        : pool.onBuy([checkedUnitVolume], poolPairData as any)[0];
 
     const prices: bigint[] = new Array(amounts.length).fill(0n);
-    const outputs = pool.onSell(
-      amountWithoutZero.slice(0, nonZeroAmountIndex),
-      poolPairData as any,
-    );
+
+    const outputs =
+      side === SwapSide.SELL
+        ? pool.onSell(
+            amountWithoutZero.slice(0, nonZeroAmountIndex),
+            poolPairData as any,
+          )
+        : pool.onBuy(
+            amountWithoutZero.slice(0, nonZeroAmountIndex),
+            poolPairData as any,
+          );
 
     assert(
       outputs.length <= prices.length,
@@ -618,8 +628,7 @@ export class BalancerV2
   }
 
   getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    if (side === SwapSide.BUY) return null;
-    return this.adapters;
+    return this.adapters[side] ? this.adapters[side] : null;
   }
 
   async getPoolIdentifiers(
@@ -628,7 +637,6 @@ export class BalancerV2
     side: SwapSide,
     blockNumber: number,
   ): Promise<string[]> {
-    if (side === SwapSide.BUY) return [];
     const _from = this.dexHelper.config.wrapETH(from);
     const _to = this.dexHelper.config.wrapETH(to);
 
@@ -676,7 +684,6 @@ export class BalancerV2
     blockNumber: number,
     limitPools?: string[],
   ): Promise<null | ExchangePrices<BalancerV2Data>> {
-    if (side === SwapSide.BUY) return null;
     try {
       const _from = this.dexHelper.config.wrapETH(from);
       const _to = this.dexHelper.config.wrapETH(to);
@@ -956,7 +963,12 @@ export class BalancerV2
         poolId: hop.pool.id,
         assetInIndex: swapOffset + index,
         assetOutIndex: swapOffset + index + 1,
-        amount: index === 0 ? swapData.amount : '0',
+        amount:
+          side === SwapSide.SELL && index === 0
+            ? swapData.amount
+            : side === SwapSide.BUY && index === path.length - 1
+            ? swapData.amount
+            : '0',
         userData: '0x',
       }));
 
@@ -983,7 +995,7 @@ export class BalancerV2
 
     const params: BalancerParam = [
       side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
-      swaps,
+      side === SwapSide.SELL ? swaps : swaps.reverse(),
       assets,
       funds,
       limits,

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

@@ -1,6 +1,6 @@
 import { DexParams } from './types';
-import { DexConfigMap } from '../../types';
-import { Network } from '../../constants';
+import { AdapterMappings, DexConfigMap } from '../../types';
+import { Network, SwapSide } from '../../constants';
 
 export const BalancerConfig: DexConfigMap<DexParams> = {
   BalancerV2: {
@@ -42,37 +42,25 @@ export const BalancerConfig: DexConfigMap<DexParams> = {
   // },
 };
 
-export const Adapters: {
-  [chainId: number]: { name: string; index: number }[];
-} = {
-  [Network.MAINNET]: [
-    {
-      name: 'Adapter02',
-      index: 9,
-    },
-  ],
-  [Network.POLYGON]: [
-    {
-      name: 'PolygonAdapter01',
-      index: 9,
-    },
-  ],
-  [Network.FANTOM]: [
-    {
-      name: 'FantomAdapter01',
-      index: 5,
-    },
-  ],
-  [Network.ARBITRUM]: [
-    {
-      name: 'ArbitrumAdapter01',
-      index: 5,
-    },
-  ],
-  [Network.OPTIMISM]: [
-    {
-      name: 'OptimismAdapter01',
-      index: 4,
-    },
-  ],
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [{ name: 'Adapter02', index: 9 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter', index: 9 }],
+  },
+  [Network.POLYGON]: {
+    [SwapSide.SELL]: [{ name: 'PolygonAdapter01', index: 9 }],
+    [SwapSide.BUY]: [{ name: 'PolygonBuyAdapter', index: 6 }],
+  },
+  [Network.FANTOM]:{
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 5 }],
+    [SwapSide.BUY]: [{ name: 'FantomBuyAdapter', index: 4 }],
+  },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter01', index: 5 }],
+    [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 6 }],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'OptimismBuyAdapter', index: 5 }],
+  },
 };

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

@@ -0,0 +1,274 @@
+import { MathSol } from '../balancer-v2-math';
+import { WeightedPoolPairData } from './weighted/WeightedPool';
+import { StablePoolPairData } from './stable/StablePool';
+
+export class BasePool {
+  _subtractSwapFeeAmount(amount: bigint, _swapFeePercentage: bigint): bigint {
+    // This returns amount - fee amount, so we round up (favoring a higher fee amount).
+    const feeAmount = MathSol.mulUpFixed(amount, _swapFeePercentage);
+    return amount - feeAmount;
+  }
+
+  _addFeeAmount(amount: bigint, _swapFeePercentage: bigint): bigint {
+    return MathSol.divUpFixed(
+      amount,
+      MathSol.complementFixed(_swapFeePercentage),
+    );
+  }
+
+  // These methods use fixed versions to match SC scaling
+  _upscaleArray(amounts: bigint[], scalingFactors: bigint[]): bigint[] {
+    return amounts.map((a, i) => MathSol.mulUpFixed(a, scalingFactors[i]));
+  }
+
+  _upscale(amount: bigint, scalingFactor: bigint): bigint {
+    return MathSol.mulUpFixed(amount, scalingFactor);
+  }
+
+  _downscaleDown(amount: bigint, scalingFactor: bigint): bigint {
+    return MathSol.divDownFixed(amount, scalingFactor);
+  }
+
+  _downscaleUp(amount: bigint, scalingFactor: bigint): bigint {
+    return MathSol.divUpFixed(amount, scalingFactor);
+  }
+
+  _nullifyIfMaxAmountExceeded(amountToTrade: bigint, swapMax: bigint): bigint {
+    return swapMax >= amountToTrade ? amountToTrade : 0n;
+  }
+}
+
+export abstract class BaseGeneralPool extends BasePool {
+  // Swap Hooks
+  onBuy(amounts: bigint[], poolPairData: StablePoolPairData): bigint[] {
+    return this._swapGivenOut(
+      amounts,
+      poolPairData.balances,
+      poolPairData.indexIn,
+      poolPairData.indexOut,
+      poolPairData.scalingFactors,
+      poolPairData.swapFee,
+      poolPairData.amp,
+    );
+  }
+
+  // Modification: this is inspired from the function onSwap which is in the original contract
+  onSell(amounts: bigint[], poolPairData: StablePoolPairData): bigint[] {
+    // _validateIndexes(indexIn, indexOut, _getTotalTokens());
+    // uint256[] memory scalingFactors = _scalingFactors();
+    return this._swapGivenIn(
+      amounts,
+      poolPairData.balances,
+      poolPairData.indexIn,
+      poolPairData.indexOut,
+      poolPairData.scalingFactors,
+      poolPairData.swapFee,
+      poolPairData.amp,
+    );
+  }
+
+  _swapGivenIn(
+    tokenAmountsIn: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    scalingFactors: bigint[],
+    _swapFeePercentage: bigint,
+    _amplificationParameter: bigint,
+  ): bigint[] {
+    // Fees are subtracted before scaling, to reduce the complexity of the rounding direction analysis.
+    const tokenAmountsInWithFee = tokenAmountsIn.map(a =>
+      this._subtractSwapFeeAmount(a, _swapFeePercentage),
+    );
+
+    const balancesUpscaled = this._upscaleArray(balances, scalingFactors);
+    const tokenAmountsInScaled = tokenAmountsInWithFee.map(a =>
+      this._upscale(a, scalingFactors[indexIn]),
+    );
+
+    const amountsOut = this._onSwapGivenIn(
+      tokenAmountsInScaled,
+      balancesUpscaled,
+      indexIn,
+      indexOut,
+      _amplificationParameter,
+    );
+
+    // amountOut tokens are exiting the Pool, so we round down.
+    return amountsOut.map(a =>
+      this._downscaleDown(a, scalingFactors[indexOut]),
+    );
+  }
+
+  _swapGivenOut(
+    tokenAmountsOut: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    scalingFactors: bigint[],
+    _swapFeePercentage: bigint,
+    _amplificationParameter: bigint,
+  ): bigint[] {
+    const balancesUpscaled = this._upscaleArray(balances, scalingFactors);
+    const tokenAmountsOutScaled = tokenAmountsOut.map(a =>
+      this._upscale(a, scalingFactors[indexOut]),
+    );
+
+    let amountsIn: bigint[];
+    try {
+      amountsIn = this._onSwapGivenOut(
+        tokenAmountsOutScaled,
+        balancesUpscaled,
+        indexIn,
+        indexOut,
+        _amplificationParameter,
+      );
+    } catch (e) {
+      amountsIn = new Array(tokenAmountsOut.length).fill(0n);
+    }
+
+    // amountIn tokens are entering the Pool, so we round up.
+    const amountsInDownscaled = amountsIn.map(a =>
+      this._downscaleUp(a, scalingFactors[indexIn]),
+    );
+
+    // Fees are added after scaling happens, to reduce the complexity of the rounding direction analysis.
+    return amountsInDownscaled.map(a =>
+      this._subtractSwapFeeAmount(a, _swapFeePercentage),
+    );
+  }
+
+  /*
+   * @dev Called when a swap with the Pool occurs, where the amount of tokens entering the Pool is known.
+   *
+   * Returns the amount of tokens that will be taken from the Pool in return.
+   *
+   * All amounts inside `swapRequest` and `balances` are upscaled. The swap fee has already been deducted from
+   * `swapRequest.amount`.
+   *
+   * The return value is also considered upscaled, and will be downscaled (rounding down) before returning it to the
+   * Vault.
+   */
+  abstract _onSwapGivenIn(
+    tokenAmountsIn: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    _amplificationParameter: bigint,
+  ): bigint[];
+
+  abstract _onSwapGivenOut(
+    tokenAmountsOut: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    _amplificationParameter: bigint,
+  ): bigint[];
+}
+
+export abstract class BaseMinimalSwapInfoPool extends BasePool {
+  // Swap Hooks
+
+  // This is inspired from the function onSwap which is in the original contract
+  onBuy(
+    tokenAmountsOut: bigint[],
+    poolPairData: WeightedPoolPairData,
+  ): bigint[] {
+    // uint256 scalingFactorTokenIn = _scalingFactor(request.tokenIn);
+    // uint256 scalingFactorTokenOut = _scalingFactor(request.tokenOut);
+
+    // All token amounts are upscaled.
+    const balanceTokenIn = this._upscale(
+      poolPairData.tokenInBalance,
+      poolPairData.tokenInScalingFactor,
+    );
+
+    const balanceTokenOut = this._upscale(
+      poolPairData.tokenOutBalance,
+      poolPairData.tokenOutScalingFactor,
+    );
+
+    const tokenAmountsOutScaled = tokenAmountsOut.map(a =>
+      this._upscale(a, poolPairData.tokenOutScalingFactor),
+    );
+
+    let amountsIn: bigint[];
+    try {
+      amountsIn = this._onSwapGivenOut(
+        tokenAmountsOutScaled,
+        balanceTokenIn,
+        balanceTokenOut,
+        poolPairData.tokenInWeight,
+        poolPairData.tokenOutWeight,
+      );
+    } catch (e) {
+      amountsIn = new Array(tokenAmountsOut.length).fill(0n);
+    }
+
+    // amountIn tokens are entering the Pool, so we round up.
+    const amountsInDownscaled = amountsIn.map(a =>
+      this._downscaleUp(a, poolPairData.tokenInScalingFactor),
+    );
+
+    // Fees are added after scaling happens, to reduce the complexity of the rounding direction analysis.
+    return amountsInDownscaled.map(a =>
+      this._addFeeAmount(a, poolPairData.swapFee),
+    );
+  }
+
+  // Modification: this is inspired from the function onSwap which is in the original contract
+  onSell(
+    tokenAmountsIn: bigint[],
+    poolPairData: WeightedPoolPairData,
+  ): bigint[] {
+    // uint256 _scalingFactorTokenIn = _scalingFactor(request.tokenIn);
+    // uint256 _scalingFactorTokenOut = _scalingFactor(request.tokenOut);
+
+    // Fees are subtracted before scaling, to reduce the complexity of the rounding direction analysis.
+    const tokenAmountsInWithFee = tokenAmountsIn.map(a =>
+      this._subtractSwapFeeAmount(a, poolPairData.swapFee),
+    );
+
+    // All token amounts are upscaled.
+    const balanceTokenIn = this._upscale(
+      poolPairData.tokenInBalance,
+      poolPairData.tokenInScalingFactor,
+    );
+    const balanceTokenOut = this._upscale(
+      poolPairData.tokenOutBalance,
+      poolPairData.tokenOutScalingFactor,
+    );
+    const tokenAmountsInScaled = tokenAmountsInWithFee.map(a =>
+      this._upscale(a, poolPairData.tokenInScalingFactor),
+    );
+
+    const amountsOut = this._onSwapGivenIn(
+      tokenAmountsInScaled,
+      balanceTokenIn,
+      balanceTokenOut,
+      poolPairData.tokenInWeight,
+      poolPairData.tokenOutWeight,
+    );
+
+    // amountOut tokens are exiting the Pool, so we round down.
+    return amountsOut.map(a =>
+      this._downscaleDown(a, poolPairData.tokenOutScalingFactor),
+    );
+  }
+
+  abstract _onSwapGivenIn(
+    tokenAmountsIn: bigint[],
+    currentBalanceTokenIn: bigint,
+    currentBalanceTokenOut: bigint,
+    _weightIn: bigint,
+    _weightOut: bigint,
+  ): bigint[];
+
+  abstract _onSwapGivenOut(
+    tokenAmountsOut: bigint[],
+    currentBalanceTokenIn: bigint,
+    currentBalanceTokenOut: bigint,
+    _weightIn: bigint,
+    _weightOut: bigint,
+  ): bigint[];
+}

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

@@ -1,4 +1,4 @@
-import { MathSol } from './balancer-v2-math';
+import { MathSol } from '../../balancer-v2-math';
 
 /*
 Note when comparing vs smart contract:
@@ -8,6 +8,7 @@ Similar for mul
 */
 
 type Params = {
+  rate: bigint;
   fee: bigint;
   lowerTarget: bigint;
   upperTarget: bigint;
@@ -29,7 +30,11 @@ export function _calcBptOutPerMainIn(
   const previousNominalMain = _toNominal(mainBalance, params);
   const afterNominalMain = _toNominal(mainBalance + mainIn, params);
   const deltaNominalMain = afterNominalMain - previousNominalMain;
-  const invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+  const invariant = _calcInvariantUp(
+    previousNominalMain,
+    wrappedBalance,
+    params,
+  );
   return MathSol.divDown(MathSol.mul(bptSupply, deltaNominalMain), invariant);
 }
 
@@ -44,7 +49,11 @@ export function _calcBptInPerMainOut(
   const previousNominalMain = _toNominal(mainBalance, params);
   const afterNominalMain = _toNominal(mainBalance - mainOut, params);
   const deltaNominalMain = previousNominalMain - afterNominalMain;
-  const invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+  const invariant = _calcInvariantDown(
+    previousNominalMain,
+    wrappedBalance,
+    params,
+  );
   return MathSol.divUp(MathSol.mul(bptSupply, deltaNominalMain), invariant);
 }
 
@@ -57,9 +66,17 @@ export function _calcBptInPerWrappedOut(
 ): bigint {
   // Amount in, so we round up overall.
   const nominalMain = _toNominal(mainBalance, params);
-  const previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+  const previousInvariant = _calcInvariantUp(
+    nominalMain,
+    wrappedBalance,
+    params,
+  );
   const newWrappedBalance = wrappedBalance - wrappedOut;
-  const newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
+  const newInvariant = _calcInvariantDown(
+    nominalMain,
+    newWrappedBalance,
+    params,
+  );
   const newBptBalance = MathSol.divDown(
     MathSol.mul(bptSupply, newInvariant),
     previousInvariant,
@@ -75,7 +92,8 @@ export function _calcWrappedOutPerMainIn(
   // Amount out, so we round down overall.
   const previousNominalMain = _toNominal(mainBalance, params);
   const afterNominalMain = _toNominal(mainBalance + mainIn, params);
-  return afterNominalMain - previousNominalMain;
+  const deltaNominalMain = afterNominalMain - previousNominalMain;
+  return MathSol.divDownFixed(deltaNominalMain, params.rate);
 }
 
 export function _calcWrappedInPerMainOut(
@@ -86,7 +104,8 @@ export function _calcWrappedInPerMainOut(
   // Amount in, so we round up overall.
   const previousNominalMain = _toNominal(mainBalance, params);
   const afterNominalMain = _toNominal(mainBalance - mainOut, params);
-  return previousNominalMain - afterNominalMain;
+  const deltaNominalMain = previousNominalMain - afterNominalMain;
+  return MathSol.divUpFixed(deltaNominalMain, params.rate);
 }
 
 export function _calcMainInPerBptOut(
@@ -101,7 +120,11 @@ export function _calcMainInPerBptOut(
     return _fromNominal(bptOut, params);
   }
   const previousNominalMain = _toNominal(mainBalance, params);
-  const invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+  const invariant = _calcInvariantUp(
+    previousNominalMain,
+    wrappedBalance,
+    params,
+  );
   const deltaNominalMain = MathSol.divUp(
     MathSol.mul(invariant, bptOut),
     bptSupply,
@@ -120,7 +143,11 @@ export function _calcMainOutPerBptIn(
 ): bigint {
   // Amount out, so we round down overall.
   const previousNominalMain = _toNominal(mainBalance, params);
-  const invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+  const invariant = _calcInvariantDown(
+    previousNominalMain,
+    wrappedBalance,
+    params,
+  );
   const deltaNominalMain = MathSol.divDown(
     MathSol.mul(invariant, bptIn),
     bptSupply,
@@ -137,7 +164,8 @@ export function _calcMainOutPerWrappedIn(
 ): bigint {
   // Amount out, so we round down overall.
   const previousNominalMain = _toNominal(mainBalance, params);
-  const afterNominalMain = previousNominalMain - wrappedIn;
+  const deltaNominalMain = MathSol.mulDownFixed(wrappedIn, params.rate);
+  const afterNominalMain = previousNominalMain - deltaNominalMain;
   const newMainBalance = _fromNominal(afterNominalMain, params);
   return mainBalance - newMainBalance;
 }
@@ -149,7 +177,8 @@ export function _calcMainInPerWrappedOut(
 ): bigint {
   // Amount in, so we round up overall.
   const previousNominalMain = _toNominal(mainBalance, params);
-  const afterNominalMain = previousNominalMain + wrappedOut;
+  const deltaNominalMain = MathSol.mulUpFixed(wrappedOut, params.rate);
+  const afterNominalMain = previousNominalMain + deltaNominalMain;
   const newMainBalance = _fromNominal(afterNominalMain, params);
   return newMainBalance - mainBalance;
 }
@@ -164,13 +193,21 @@ export function _calcBptOutPerWrappedIn(
   // Amount out, so we round down overall.
   if (bptSupply == 0n) {
     // Return nominal DAI
-    return wrappedIn;
+    return MathSol.mulDownFixed(wrappedIn, params.rate);
   }
 
   const nominalMain = _toNominal(mainBalance, params);
-  const previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+  const previousInvariant = _calcInvariantUp(
+    nominalMain,
+    wrappedBalance,
+    params,
+  );
   const newWrappedBalance = wrappedBalance + wrappedIn;
-  const newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
+  const newInvariant = _calcInvariantDown(
+    nominalMain,
+    newWrappedBalance,
+    params,
+  );
   const newBptBalance = MathSol.divDown(
     MathSol.mul(bptSupply, newInvariant),
     previousInvariant,
@@ -188,15 +225,21 @@ export function _calcWrappedInPerBptOut(
   // Amount in, so we round up overall.
   if (bptSupply == 0n) {
     // Return nominal DAI
-    return bptOut;
+    return MathSol.divUpFixed(bptOut, params.rate);
   }
 
   const nominalMain = _toNominal(mainBalance, params);
-  const previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+  const previousInvariant = _calcInvariantUp(
+    nominalMain,
+    wrappedBalance,
+    params,
+  );
   const newBptBalance = bptSupply + bptOut;
-  const newWrappedBalance =
+  const newWrappedBalance = MathSol.divUpFixed(
     MathSol.divUp(MathSol.mul(newBptBalance, previousInvariant), bptSupply) -
-    nominalMain;
+      nominalMain,
+    params.rate,
+  );
   return newWrappedBalance - wrappedBalance;
 }
 
@@ -209,19 +252,34 @@ export function _calcWrappedOutPerBptIn(
 ): bigint {
   // Amount out, so we round down overall.
   const nominalMain = _toNominal(mainBalance, params);
-  const previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+  const previousInvariant = _calcInvariantUp(
+    nominalMain,
+    wrappedBalance,
+    params,
+  );
   const newBptBalance = bptSupply - bptIn;
-  const newWrappedBalance =
+  const newWrappedBalance = MathSol.divUpFixed(
     MathSol.divUp(MathSol.mul(newBptBalance, previousInvariant), bptSupply) -
-    nominalMain;
+      nominalMain,
+    params.rate,
+  );
   return wrappedBalance - newWrappedBalance;
 }
 
-function _calcInvariant(
+function _calcInvariantUp(
   nominalMainBalance: bigint,
   wrappedBalance: bigint,
+  params: Params,
+): bigint {
+  return nominalMainBalance + MathSol.mulUpFixed(wrappedBalance, params.rate);
+}
+
+function _calcInvariantDown(
+  nominalMainBalance: bigint,
+  wrappedBalance: bigint,
+  params: Params,
 ): bigint {
-  return nominalMainBalance + wrappedBalance;
+  return nominalMainBalance + MathSol.mulDownFixed(wrappedBalance, params.rate);
 }
 
 function _toNominal(real: bigint, params: Params): bigint {