@agoric/inter-protocol 0.13.2-dev-70ba9b0.0 → 0.13.2-dev-ed5ee58.0

package/src/vpool-xyk-amm/constantProduct/core.js

@@ -1,145 +0,0 @@
-import { AmountMath } from '@agoric/ertp';
-
-import { natSafeMath } from '@agoric/zoe/src/contractSupport/index.js';
-import { makeRatioFromAmounts } from '@agoric/zoe/src/contractSupport/ratio.js';
-import { getXY } from './getXY.js';
-
-const { Fail } = assert;
-
-const assertSingleBrand = ratio => {
-  ratio.numerator.brand === ratio.denominator.brand ||
-    Fail`Ratio was expected to have same brand in numerator ${ratio.numerator.brand} and denominator ${ratio.denominator.brand}`;
-};
-
-/**
- * Multiply an amount by a ratio using floorDivide, ignoring the ratio's brands
- * in favor of the amount brand. This is necessary because the ratio is produced
- * by dividing assets of the opposite brand.
- *
- * @param {Amount<'nat'>} amount
- * @param {Ratio} ratio
- * @returns {Amount<'nat'>}
- */
-const floorMultiplyKeepBrand = (amount, ratio) => {
-  assertSingleBrand(ratio);
-  const value = natSafeMath.floorDivide(
-    natSafeMath.multiply(amount.value, ratio.numerator.value),
-    ratio.denominator.value,
-  );
-  return AmountMath.make(amount.brand, value);
-};
-
-/**
- * Multiply an amount and a ratio using ceilDivide, ignoring the ratio's brands
- * in favor of the amount brand. This is necessary because the ratio is produced
- * by dividing assets of the opposite brand.
- *
- * @param {Amount<'nat'>} amount
- * @param {Ratio} ratio
- * @returns {Amount<'nat'>}
- */
-const ceilMultiplyKeepBrand = (amount, ratio) => {
-  assertSingleBrand(ratio);
-  const value = natSafeMath.ceilDivide(
-    natSafeMath.multiply(amount.value, ratio.numerator.value),
-    ratio.denominator.value,
-  );
-  return AmountMath.make(amount.brand, value);
-};
-
-/**
- * Calculate deltaY when the user is selling brand X. That is, whichever asset
- * the user is selling, this function is used to calculate the change in the
- * other asset, i.e. how much of brand Y to give the user in return.
- * swapOutImproved calls this function with the calculated amountIn to find out
- * if more than the wantedAmountOut can be gained for the necessary amountIn.
- *
- * deltaY = (deltaXOverX/(1 + deltaXOverX))*y
- * Equivalently: (deltaX / (deltaX + x)) * y
- *
- * @param {Amount<'nat'>} x - the amount of Brand X in pool
- * @param {Amount<'nat'>} y - the amount of Brand Y the pool
- * @param {Amount<'nat'>} deltaX - the amount of Brand X to be added
- * @returns {Amount<'nat'>} deltaY - the amount of Brand Y to be taken out
- */
-export const calcDeltaYSellingX = (x, y, deltaX) => {
-  const deltaXPlusX = AmountMath.add(deltaX, x);
-  const xRatio = makeRatioFromAmounts(deltaX, deltaXPlusX);
-  // We want to err on the side of the pool, so this will use floorDivide to
-  // round down the amount paid out.
-  return floorMultiplyKeepBrand(y, xRatio);
-};
-
-/**
- * Calculate deltaX when the user is selling brand X. That is, whichever asset
- * the user is selling, this function is used to calculate the change to the
- * pool for that asset. swapInReduced calls this with the calculated amountOut
- * to find out if less than the offeredAmountIn would be sufficient.
- *
- * deltaX = (deltaYOverY/(1 - deltaYOverY))*x
- * Equivalently: (deltaY / (Y - deltaY )) * x
- *
- * @param {Amount<'nat'>} x - the amount of Brand X in the pool
- * @param {Amount<'nat'>} y - the amount of Brand Y in the pool
- * @param {Amount<'nat'>} deltaY - the amount of Brand Y to be taken out
- * @returns {Amount<'nat'>} deltaX - the amount of Brand X to be added
- */
-export const calcDeltaXSellingX = (x, y, deltaY) => {
-  const yMinusDeltaY = AmountMath.subtract(y, deltaY);
-  const yRatio = makeRatioFromAmounts(deltaY, yMinusDeltaY);
-  // We want to err on the side of the pool, so this will use ceilMultiply to
-  // round up the amount required.
-  return ceilMultiplyKeepBrand(x, yRatio);
-};
-
-/**
- * The input contains the amounts in the pool and a maximum amount offered.
- * Calculate the most beneficial trade that satisfies the constant product
- * invariant.
- *
- * @param {GetXYResultDeltaX} obj
- * @returns {ImprovedNoFeeSwapResult}
- */
-const swapInReduced = ({ x, y, deltaX: offeredAmountIn }) => {
-  const amountOut = calcDeltaYSellingX(x, y, offeredAmountIn);
-  const reducedAmountIn = calcDeltaXSellingX(x, y, amountOut);
-  AmountMath.isGTE(offeredAmountIn, reducedAmountIn) ||
-    Fail`The trade would have required ${reducedAmountIn} more than was offered ${offeredAmountIn}`;
-
-  return harden({
-    amountIn: reducedAmountIn,
-    amountOut,
-  });
-};
-
-/**
- * The input contains the amounts in the pool and the minimum amount requested.
- * Calculate the most beneficial trade that satisfies the constant product
- * invariant.
- *
- * @param {GetXYResultDeltaY} obj
- * @returns {ImprovedNoFeeSwapResult}
- */
-const swapOutImproved = ({ x, y, deltaY: wantedAmountOut }) => {
-  const amountIn = calcDeltaXSellingX(x, y, wantedAmountOut);
-  const improvedAmountOut = calcDeltaYSellingX(x, y, amountIn);
-  AmountMath.isGTE(improvedAmountOut, wantedAmountOut) ||
-    Fail`The trade would have returned ${improvedAmountOut} less than was wanted ${wantedAmountOut}`;
-
-  return harden({
-    amountIn,
-    amountOut: improvedAmountOut,
-  });
-};
-
-/** @type {NoFeeSwapFn} */
-export const swapInNoFees = ({ amountGiven, poolAllocation }) => {
-  const XY = getXY({ amountGiven, poolAllocation });
-  return swapInReduced(XY);
-};
-
-/** @type {NoFeeSwapFn} */
-export const swapOutNoFees = ({ poolAllocation, amountWanted }) => {
-  const XY = getXY({ poolAllocation, amountWanted });
-  return swapOutImproved(XY);
-};

package/src/vpool-xyk-amm/constantProduct/defaults.js

@@ -1,3 +0,0 @@
-export const BASIS_POINTS = 10000n;
-export const DEFAULT_POOL_FEE = 24n; // 0.0024 or .24%
-export const DEFAULT_PROTOCOL_FEE = 6n; // .0006 or .06%

package/src/vpool-xyk-amm/constantProduct/getXY.js

@@ -1,48 +0,0 @@
-// This does not support secondary to secondary. That has to happen at
-// a higher abstraction
-
-const { Fail } = assert;
-/**
- * The caller provides poolAllocation, which has balances for both Central and
- * Secondary, and at least one of amountGiven and amountWanted. getXY treats
- * the amountGiven as the X pool, and amountWanted as Y. It figures out which
- * way to pair up X and Y with Central and Secondary, and returns the pool
- * balances as X and Y and given and wanted as deltaX and deltaY
- * { X, Y, deltaX, deltaY }.
- *
- * @type {GetXY}
- */
-export const getXY = ({ amountGiven, poolAllocation, amountWanted }) => {
-  // Regardless of whether we are specifying the amountIn or the
-  // amountOut, the xBrand is the brand of the amountIn.
-  const xBrand = amountGiven && amountGiven.brand;
-  const yBrand = amountWanted && amountWanted.brand;
-  const secondaryBrand = poolAllocation.Secondary.brand;
-  const centralBrand = poolAllocation.Central.brand;
-  amountGiven ||
-    amountWanted ||
-    Fail`At least one of ${amountGiven} and ${amountWanted} must be specified`;
-
-  const deltas = {
-    deltaX: amountGiven,
-    deltaY: amountWanted,
-  };
-
-  if (secondaryBrand === xBrand || centralBrand === yBrand) {
-    // @ts-expect-error at least one of amountGiven and amountWanted is non-null
-    return harden({
-      x: poolAllocation.Secondary,
-      y: poolAllocation.Central,
-      ...deltas,
-    });
-  }
-  if (centralBrand === xBrand || secondaryBrand === yBrand) {
-    // @ts-expect-error at least one of amountGiven and amountWanted is non-null
-    return harden({
-      x: poolAllocation.Central,
-      y: poolAllocation.Secondary,
-      ...deltas,
-    });
-  }
-  assert.fail(`brand ${xBrand} was not recognized as Central or Secondary`);
-};

package/src/vpool-xyk-amm/constantProduct/internal-types.js

@@ -1,114 +0,0 @@
-/**
- * @typedef {object} ImprovedNoFeeSwapResult
- * @property {Amount<'nat'>} amountIn
- * @property {Amount<'nat'>} amountOut
- */
-
-/**
- * @typedef {object} FeePair
- *
- * @property {Amount<'nat'>} poolFee
- * @property {Amount<'nat'>} protocolFee
- */
-
-/**
- * @typedef {object} PoolAllocation
- *
- * @property {Amount<'nat'>} Central
- * @property {Amount<'nat'>} Secondary
- */
-
-/**
- * @typedef {object} NoFeeSwapFnInput
- * @property {Amount} amountGiven
- * @property {Amount} amountWanted
- * @property {Brand} [brand]
- * @property {PoolAllocation} poolAllocation
- */
-
-/**
- * This is the type for swapInNoFees and swapOutNoFees. pricesForStatedInput()
- * uses swapInNoFees, while pricesForStatedOutput() uses swapOutNoFees.
- *
- * @callback NoFeeSwapFn
- * @param {NoFeeSwapFnInput} input
- * @returns {ImprovedNoFeeSwapResult}
- */
-
-/**
- * @typedef {FeePair & ImprovedNoFeeSwapResult} FeeEstimate
- */
-
-/**
- * @callback CalculateFees
- * @param {Amount<'nat'>} amountGiven
- * @param {PoolAllocation} poolAllocation
- * @param {Amount<'nat'>} amountWanted
- * @param {Ratio} protocolFeeRatio
- * @param {Ratio} poolFeeRatio
- * @param {NoFeeSwapFn} swapFn
- * @returns {FeeEstimate}
- */
-
-/**
- * @callback InternalSwap
- * @param {Amount<'nat'>} amountGiven
- * @param {PoolAllocation} poolAllocation
- * @param {Amount<'nat'>} amountWanted
- * @param {Ratio} protocolFeeRatio
- * @param {Ratio} poolFeeRatio
- * @param {NoFeeSwapFn} swapFn
- * @returns {SinglePoolSwapResult}
- */
-
-/**
- * @callback CalcSwapInPrices
- * @param {Amount} amountGiven
- * @param {PoolAllocation} poolAllocation
- * @param {Amount} [amountWanted]
- * @param {Ratio} protocolFeeRatio
- * @param {Ratio} poolFeeRatio
- * @returns {SinglePoolSwapResult}
- */
-/**
- * @callback CalcSwapOutPrices
- * @param {Amount} [amountGiven]
- * @param {PoolAllocation} poolAllocation
- * @param {Amount} amountWanted
- * @param {Ratio} protocolFeeRatio
- * @param {Ratio} poolFeeRatio
- * @returns {SinglePoolSwapResult}
- */
-
-/**
- * @typedef {object} GetXYParam
- * @property {Amount} [amountGiven]
- * @property {PoolAllocation} poolAllocation
- * @property {Amount} [amountWanted]
- */
-
-/**
- * @typedef {object} GetXYResultDeltaX
- * @property {Amount<'nat'>} x
- * @property {Amount<'nat'>} y
- * @property {Amount<'nat'>} deltaX
- * @property {Amount<'nat'>|undefined} deltaY
- */
-
-/**
- * @typedef {object} GetXYResultDeltaY
- * @property {Amount<'nat'>} x
- * @property {Amount<'nat'>} y
- * @property {Amount<'nat'>} deltaY
- * @property {Amount<'nat'>|undefined} deltaX
- */
-
-/**
- * @typedef {GetXYResultDeltaX & GetXYResultDeltaY} GetXYResult
- */
-
-/**
- * @callback GetXY
- * @param {GetXYParam} obj
- * @returns {GetXYResult}
- */

package/src/vpool-xyk-amm/constantProduct/invariants.js

@@ -1,39 +0,0 @@
-import { Fail } from '@agoric/assert';
-import { AmountMath } from '@agoric/ertp';
-
-import { natSafeMath } from '@agoric/zoe/src/contractSupport/index.js';
-
-/**
- * xy <= (x + deltaX)(y - deltaY)
- *
- * @param {Amount<'nat'>} x - the amount of Brand X in pool, xPoolAllocation
- * @param {Amount<'nat'>} y - the amount of Brand Y in pool, yPoolAllocation
- * @param {Amount<'nat'>} deltaX - the amount of Brand X to be added
- * @param {Amount<'nat'>} deltaY - the amount of Brand Y to be taken out
- */
-export const checkKInvariantSellingX = (x, y, deltaX, deltaY) => {
-  const oldK = natSafeMath.multiply(x.value, y.value);
-  const newX = AmountMath.add(x, deltaX);
-  const newY = AmountMath.subtract(y, deltaY);
-  const newK = natSafeMath.multiply(newX.value, newY.value);
-  return oldK <= newK;
-};
-
-/**
- * xy <= (x + deltaX)(y - deltaY)
- *
- * @param {Amount<'nat'>} x - the amount of Brand X in pool, xPoolAllocation
- * @param {Amount<'nat'>} y - the amount of Brand Y in pool, yPoolAllocation
- * @param {Amount<'nat'>} deltaX - the amount of Brand X to be added
- * @param {Amount<'nat'>} deltaY - the amount of Brand Y to be taken out
- */
-export const assertKInvariantSellingX = (x, y, deltaX, deltaY) => {
-  checkKInvariantSellingX(x, y, deltaX, deltaY) ||
-    Fail`the constant product invariant was violated, with x=${x}, y=${y}, deltaX=${deltaX}, deltaY=${deltaY}, oldK=${natSafeMath.multiply(
-      x.value,
-      y.value,
-    )}, newK=${natSafeMath.multiply(
-      AmountMath.add(x, deltaX).value,
-      AmountMath.subtract(y, deltaY).value,
-    )}`;
-};

package/src/vpool-xyk-amm/constantProduct/swap.js

@@ -1,270 +0,0 @@
-import { AmountMath } from '@agoric/ertp';
-import { calculateFees, amountGT } from './calcFees.js';
-
-const { Fail } = assert;
-
-/**
- * The fee might not be in the same brand as the amount. If they are the same,
- * subtract the fee from the amount. Otherwise return the unadjusted amount.
- *
- * We return empty if the fee is larger because an empty amount indicates that
- * the trader didn't place a limit on the inputAmount.
- *
- * @param {Amount<'nat'>} amount
- * @param {Amount<'nat'>} fee
- * @returns {Amount<'nat'>}
- */
-const subtractRelevantFees = (amount, fee) => {
-  if (amount.brand === fee.brand) {
-    if (AmountMath.isGTE(fee, amount)) {
-      return AmountMath.makeEmptyFromAmount(amount);
-    }
-
-    return AmountMath.subtract(amount, fee);
-  }
-  return amount;
-};
-
-/**
- * PoolFee and ProtocolFee each identify their brand. If either (or both) match
- * the brand of the Amount, subtract it/them from the amount.
- *
- * @param {Amount<'nat'>} amount
- * @param {FeePair} fee
- * @returns {Amount<'nat'>}
- */
-const subtractFees = (amount, { poolFee, protocolFee }) => {
-  return subtractRelevantFees(
-    subtractRelevantFees(amount, protocolFee),
-    poolFee,
-  );
-};
-
-/**
- * The fee might not be in the same brand as the amount. If they are the same,
- * add the fee to the amount. Otherwise return the unadjusted amount.
- *
- * @param {Amount<'nat'>} amount
- * @param {Amount<'nat'>} fee
- * @returns {Amount<'nat'>}
- */
-const addRelevantFees = (amount, fee) => {
-  if (amount.brand === fee.brand) {
-    return AmountMath.add(amount, fee);
-  }
-  return amount;
-};
-
-/**
- * PoolFee and ProtocolFee each identify their brand. If either (or both) match
- * the brand of the Amount, add it/them to the amount.
- *
- * @param {Amount<'nat'>} amount
- * @param {FeePair} fee
- * @returns {Amount<'nat'>}
- */
-const addFees = (amount, { poolFee, protocolFee }) => {
-  return addRelevantFees(addRelevantFees(amount, protocolFee), poolFee);
-};
-
-/**
- * Increment or decrement a pool balance by an amount. The amount's brand might
- * match the Central or Secondary balance of the pool. Return the adjusted
- * balance. The caller knows which amount they provided, so they're expecting a
- * single Amount whose brand matches the amount parameter.
- *
- * The first parameter specifies whether we're incrementing or decrementing from the pool
- *
- * @param {(amountLeft: Amount<any>, amountRight: Amount<any>, brand?: Brand) => Amount<any>} addOrSub
- * @param {PoolAllocation} poolAllocation
- * @param {Amount<'nat'>} amount
- * @returns {Amount<'nat'>}
- */
-const addOrSubtractFromPool = (addOrSub, poolAllocation, amount) => {
-  if (poolAllocation.Central.brand === amount.brand) {
-    return addOrSub(poolAllocation.Central, amount);
-  } else {
-    return addOrSub(poolAllocation.Secondary, amount);
-  }
-};
-
-const isGreaterThanZero = amount => {
-  return amount && amountGT(amount, AmountMath.makeEmptyFromAmount(amount));
-};
-
-const assertGreaterThanZero = (amount, name) => {
-  (amount && isGreaterThanZero(amount)) ||
-    Fail`${name} must be greater than 0: ${amount}`;
-};
-
-const isWantedAvailable = (poolAllocation, amountWanted) => {
-  // The question is about a poolAllocation. If it has exactly amountWanted,
-  // that's not sufficient, since it would leave the pool empty.
-  return amountWanted.brand === poolAllocation.Central.brand
-    ? !AmountMath.isGTE(amountWanted, poolAllocation.Central)
-    : !AmountMath.isGTE(amountWanted, poolAllocation.Secondary);
-};
-
-/**
- * We've identified a violation of constraints that means we won't be able to
- * satisfy the user's request. (Not enough funds in the pool, too much was
- * requested, the proceeds would be empty, etc.) Return a result that says no
- * trade will take place and the pool balances won't change.
- *
- * @param {Amount<'nat'>} amountGiven
- * @param {Amount<'nat'>} amountWanted
- * @param {PoolAllocation} poolAllocation
- * @param {Ratio} poolFee
- */
-const makeNoTransaction = (
-  amountGiven,
-  amountWanted,
-  poolAllocation,
-  poolFee,
-) => {
-  const emptyGive = AmountMath.makeEmptyFromAmount(amountGiven);
-  const emptyWant = AmountMath.makeEmptyFromAmount(amountWanted);
-
-  let newX;
-  let newY;
-  if (poolAllocation.Central.brand === amountGiven.brand) {
-    newX = poolAllocation.Central;
-    newY = poolAllocation.Secondary;
-  } else {
-    newX = poolAllocation.Secondary;
-    newY = poolAllocation.Central;
-  }
-
-  const result = harden({
-    protocolFee: AmountMath.makeEmpty(poolAllocation.Central.brand),
-    poolFee: AmountMath.makeEmpty(poolFee.numerator.brand),
-    swapperGives: emptyGive,
-    swapperGets: emptyWant,
-    xIncrement: emptyGive,
-    yDecrement: emptyWant,
-    newX,
-    newY,
-  });
-  return result;
-};
-
-/**
- * This is the heart of the calculation. See README.md for the long explanation.
- * calculate how much should be added to and removed from the pool, the fees,
- * and what the user will pay and receive.
- *
- * As soon as we detect that we won't be able to satisfy the request, we return
- * noTransaction, indicating that no trade should take place. This can be due to
- * a request for more assets than the pool holds, a specified price the current
- * assets won't support, or the trade would require more than the trader allowed,
- * or provide less, or fees would eat up all the trader's proceeds.
- *
- * We start by calculating the amounts that would be traded if no fees were
- * charged. The actual fees are based on these amounts. Once we know the actual
- * fees, we calculate the deltaX and deltaY that will best maintain the
- * constant product invariant.
- *
- * The amounts by which the pool will be adjusted, that the trader will pay and
- * receive, and the fees are then computed based on deltaX and deltaY.
- *
- * @type {InternalSwap}
- */
-export const swap = (
-  amountGiven,
-  poolAllocation,
-  amountWanted,
-  protocolFeeRatio,
-  poolFeeRatio,
-  swapFn,
-) => {
-  const noTransaction = makeNoTransaction(
-    amountGiven,
-    amountWanted,
-    poolAllocation,
-    poolFeeRatio,
-  );
-  assertGreaterThanZero(poolAllocation.Central, 'poolAllocation.Central');
-  assertGreaterThanZero(poolAllocation.Secondary, 'poolAllocation.Secondary');
-
-  if (!isGreaterThanZero(amountGiven) && !isGreaterThanZero(amountWanted)) {
-    return noTransaction;
-  }
-
-  if (!isWantedAvailable(poolAllocation, amountWanted)) {
-    return noTransaction;
-  }
-
-  // The protocol fee must always be collected in `Fee`, but the pool
-  // fee is collected in the amount opposite of what is specified.
-  // This call gives us improved amountIn or amountOut
-  const fees = calculateFees(
-    amountGiven,
-    poolAllocation,
-    amountWanted,
-    protocolFeeRatio,
-    poolFeeRatio,
-    swapFn,
-  );
-
-  if (!isWantedAvailable(poolAllocation, addFees(amountWanted, fees))) {
-    return noTransaction;
-  }
-
-  // Calculate no-fee amounts. swapFn will only pay attention to the `specified`
-  // value. The pool fee is always charged on the unspecified side, so it is an
-  // output of the calculation. When the specified value is in `Fee`, the protocol fee will
-  // be deducted from amountGiven before adding to the pool or added to
-  // amountWanted to calculate amountOut. Otherwise we add the protocol fee
-  // to amountWanted.
-  const { amountIn, amountOut } = swapFn({
-    amountGiven: subtractFees(amountGiven, fees),
-    poolAllocation,
-    amountWanted: addFees(amountWanted, fees),
-  });
-
-  if (AmountMath.isEmpty(amountOut)) {
-    return noTransaction;
-  }
-
-  // The swapper pays extra or receives less to cover the fees.
-  const swapperGives = addFees(amountIn, fees);
-  const swapperGets = subtractFees(amountOut, fees);
-
-  // return noTransaction if fees would eat up all the trader's proceeds,
-  // the trader specified an amountGiven, and the trade would require more, or
-  // the trade would require them to give more than they specified.
-  if (
-    AmountMath.isEmpty(swapperGets) ||
-    (!AmountMath.isEmpty(amountGiven) && amountGT(swapperGives, amountGiven)) ||
-    amountGT(amountWanted, swapperGets)
-  ) {
-    return noTransaction;
-  }
-
-  const xIncrement = addRelevantFees(amountIn, fees.poolFee);
-  const yDecrement = subtractRelevantFees(amountOut, fees.poolFee);
-
-  // poolFee is the amount the pool will grow over the no-fee calculation.
-  // protocolFee is to be separated and sent to an external purse.
-  // The swapper amounts are what will be paid and received.
-  // xIncrement and yDecrement are what will be added and removed from the pools.
-  //   Either xIncrement will be increased by the pool fee or yDecrement will be
-  //   reduced by it in order to compensate the pool.
-  // newX and newY are the new pool balances, for comparison with start values.
-  const result = harden({
-    protocolFee: fees.protocolFee,
-    poolFee: fees.poolFee,
-    swapperGives,
-    swapperGets,
-    xIncrement,
-    yDecrement,
-    newX: addOrSubtractFromPool(AmountMath.add, poolAllocation, xIncrement),
-    newY: addOrSubtractFromPool(
-      AmountMath.subtract,
-      poolAllocation,
-      yDecrement,
-    ),
-  });
-
-  return result;
-};

package/src/vpool-xyk-amm/constantProduct/types.js

@@ -1,30 +0,0 @@
-/**
- * @callback Maximum
- * @param {Amount} left
- * @param {Amount} right
- * @returns {Amount}
- */
-
-/**
- * A bigint representing a number that will be divided by 10,0000. Financial
- * ratios are often represented in basis points.
- *
- * @typedef {bigint} BASIS_POINTS
- */
-
-/**
- * Make a Ratio representing a fee expressed in Basis Points.  (hundredths of a
- *    percent)
- *
- * @callback MakeFeeRatio
- * @param {BASIS_POINTS} feeBP
- * @param {Brand} brandOfFee
- * @returns {Ratio}
- */
-
-/**
- * @callback AmountGT
- * @param {Amount} left
- * @param {Amount} right
- * @returns {boolean}
- */