@agoric/inter-protocol 0.13.3 → 0.13.4-dev-d32a66a.0

package/src/vpool-xyk-amm/constantProduct/README.md

@@ -1,204 +0,0 @@
-# Constant Product AMM
-
-A constant product automatic market maker based on our Ratio library. It charges
-two kinds of fees: a pool fee remains in the pool to reward the liquidity
-providers and a protocol fee is extracted to fund the economy. The external
-entry point is a call to `pricesForStatedInput()` or `pricesForStatedOutput()`.
-
-This algorithm uses the x*y=k formula directly, without fees. Briefly, there are
-two kinds of assets, whose values are kept roughly in balance through the
-actions of arbitrageurs. At any time a trader can trade with the pool by
-offering to deposit one of the two assets. They will receive an amount
-of the complementary asset that will maintain the invariant that the product of
-the balances doesn't decrease. (Rounding is done in favor of the
-pool.)
-
-The user can specify a maximum amount they want to pay or a minimum amount they
-want to receive. Unlike Uniswap, this approach will charge less than the user
-offered or pay more than they asked for when appropriate. By analogy, if a user
-is willing to pay up to $20 when the price of soda is $3 per bottle, it would
-give 6 bottles and only charge $18. (We refer to these as "improved" prices.)
-Uniswap doesn't adjust the provided price, so it would charge $20 in that trade.
-This matters whenever the values of the smallest unit of the currencies are
-significantly different, which is common in DeFi.
-
-The rules that drive the design include
-
-* When the user specifies an input (or output) price, they shouldn't pay more
-  (or receive less) than they said.
-* The pool fee is charged against the side not specified by the user (the
-  "computed side"). This increases the pool balance without impacting the amount
-  that the user specified.
-* The protocol fee is always charged in IST.
-* The fees are calculated based on the pool balances before the transaction.
-* Computations are rounded in favor of the pool.
-
-We start by estimating the exchange rate, and calculate fees based on that. Once
-we know the fees, we add or subtract them directly to the amounts added to and
-extracted from the pools to adhere to those rules.
-
-## Calculating fees
-
-In these tables BLD represents any collateral. The user can specify how much
-they want or how much they're willing to pay. We'll call the value they
-specified **sGive** or **sGet** and bold it. We'll always refer to the currency
-being added as X and the currency the user gets as Y. X and Y are the amounts
-used to maintain the constant product invariant. On every transaction the pool
-balance will also increase on one side or the other by the pool fee, and the
-protocol fee will be extracted outside the pool. So the amount produced is less
-(or the amount paid is more) because the invariant is maintained on the amounts
-remaining after fees have been charged. 
-
-In the final table, we'll see what the user pays or gets (sGet, sGive), how much
-the pool balances change (xIncr, yDecr) and the changes that impact the constant
-product calculation(ΔX, ΔY). The amount paid and received by the
-trader and changes to the pool are calculated relative to ΔX and ΔY
-so that the pool grows by the poolFee and the protocolFee can be paid from the
-proceeds.
-
-This table shows which brands the amounts each have, as well as what is computed
-vs. given. The PoolFee is computed based on the calculated amount (BLD in rows 1
-and 2; IST in rows 3 and 4). The Protocol fee is always in IST.
-
-|          | In (X) | Out (Y) | PoolFee | Protocol Fee | Specified | Computed |
-|---------|-----|-----|--------|-----|------|-----|
-| **IST in** | IST | BLD | BLD | IST | **sGive** | sGet |
-| **IST out** | BLD | IST | BLD | IST | **sGet** | sGive |
-| **BLD in** | BLD | IST | IST | IST | **sGive** | sGet |
-| **BLD out** | IST | BLD | IST | IST | **sGet** | sGive |
-
-We'll calculate how much the pool balances would change in the no-fee, improved
-price case using the constant product formulas. We call these results δX,
-and δY. This table uses lower case δ to distinguish estimates from
-final values, which use capital Δ.
-
-The fees are based on δX, and δY. ρ is the poolFee (e.g., 30
-basis points). φ is the protocol fee (e.g., 6 basis points). The pool fee
-will be ρ times whichever of δX and δY was calculated. The
-protocol fee will be φ * δX when IST is paid in, and φ * δY
-when BLD is paid in. (α and β in this table are the no-fee versions.)
-
-|          | δX | δY | PoolFee | Protocol Fee |
-|---------|-----|-----|--------|-----|
-| **IST in**  | **sGive** | y * α / (1 + α) | ρ × δY | φ × **sGive** (= φ × δX) |
-| **IST out** | x * β / (1 - β) | **sGet** | ρ × δX | φ × **sGet** (= φ × δY) |
-| **BLD in**  | **sGive**  | y * α / (1 + α) | ρ × δY | φ × δY |
-| **BLD out** | x * β / (1 - β) | **sGet** | ρ × δX | φ × δX |
-
-In rows 1 and 3, **sGive** was specified and sGet will be calculated. In rows 2
-and 4, **sGet** was specified and sGive will be calculated. Once we know the
-fees, we can add or subtract the fees and calculate the pool changes.
-
-The next table shows how the amount added to and subtracted from the pool (xIncr
-and yIncr) differs from what the trader gives or gets and the change in the pool
-values. While X' and Y' are the values resulting from the constant product
-formula, xHat and yHat are the new values in the pool, reflecting the
-contribution of the pool fee. From the diagram, xIncr is the difference between
-X and xHat, while yIncr is the difference between Y and yHat.
-
-The protocol fee (φ) is always charged on the IST side, and doesn't go in
-the pool. The pool fee (ρ) is charged on the amount that is calculated
-(ΔX or ΔY) and is included in yHat. 
-
-We use the estimate of the amount in or out to calculate improved values of
-ΔX and ΔY. These values tell us how much the trader will pay, the
-changes in pool balances, and what the trader will receive. As before, ΔX
-reflects a balance that will be growing, and ΔY one that will be
-shrinking.
-
-![AMM Diagram](./AMM-Trade.jpeg)
-
-When IST is specified (in or out), we adjust by the protocol Fee to get the
-change to the IST balance (which gives X' or Y'); use that to calculate the
-BLD component of the constant product, and then adjust δ by the pool fee.
-When BLD is specified, the entire amount will affect the pool balance (so the
-value in the constant product formula is the final BLD balance.) Both the pool
-and protocol fees are charged in IST so they respectively reduce sGet or
-increase sGive. 
-
-This table shows how the pool's growth and trader's values differ from the
-amounts that match the constant product formula. X is in IST on lines 1 and 4,
-and BLD on lines 2 and 3. 
-
-|          | xIncr | yDecr | pay In (sGive) | pay Out (sGet) |
-|---------|-----|-----|-----|-----|
-| **IST in**  | ΔX | ΔY - PoolFee | ΔX + protocolFee | ΔY - PoolFee |
-| **IST out**  | ΔX + PoolFee | ΔY | ΔX + protocolFee + PoolFee | ΔY |
-| **BLD in**  | ΔX | ΔY - PoolFee | ΔX + ProtocolFee | ΔY - PoolFee |
-| **BLD out**  | ΔX + PoolFee | ΔY | ΔX + PoolFee + ProtocolFee | ΔY |
-
-In the two right columns the protocolFee is either added to the amount the
-trader pays, or subtracted from the proceeds. The poolFee does the same on the
-left side, and it is either added to the amount deposited in the pool (xIncr)
-or deducted from the amount removed from the pool (yDecr).
-
-
-* line 1: the trader provides **sGive** IST; the pool will gain that minus
-  the protocol fee in IST. The value in the IST pool after (X') will be used to
-  calculate Y'.  The pool fee is calculated from δY and the trader gets
-  &deltaY; - poolFee
-* line 2: the trader asked for **sGet** IST; the pool will be reduced by that
-  amount plus the protocol fee. Y' will be used to calculate X'. The trader
-  must provide &deltaX; plus poolFee
-* Line 3: the trader pays **sGive** BLD; the pool will increase by that minus
-  both fees
-* line 4: the trader specified **sGet** BLD; the pool will be reduced by that
-  plus the protocol fee.
-
-
-## Example
-
-For example, let's say the pool has 40,000,000 IST and 3,000,000 BLD. Alice
-requests a swapIn with inputAmount of 30,000 IST, and outputAmount of 2000 BLD.
-(SwapIn means the inputValue is the basis of the computation, while outputAmount
-is treated as a minimum). To make the numbers concrete, we'll say the pool fee
-is 25 Basis Points, and the protocol fee is 5 Basis Points.
-
-The first step is to compute the trade that would take place with no fees. 30K
-will be added to 40M IST. To keep the product just above 120MM, the BLD will be
-reduced to 2,997,752.
-
-```
-40,030,000 * 2,997,752 > 40,000,000 * 3,000,000 > 40,030,000 * 2,997,751
-   120000012560000     >    120000000000000     >   119999972530000
-```
-
-But we get an even tighter bound by reducing the amount Alice has to spend
-
-```
-40,029,996 * 2,997,752 > 40,000,000 * 3,000,000 > 40,029,995 * 2,997,752
-    120000000568992    >    120000000000000     >   119999997571240
-```
-
-The initial price estimate is that 29,996 IST would get 2248 BLD in a no-fee
-pool. We base fees on this estimate, so the **protocol Fee will be 15 IST**
-(always in IST, ⌈29,996 * 0.0005⌉) and the **pool fee will be 6 BLD**
-(in the computed side, ⌈2248 * 0.0025⌉).  The "computed side" for
-`swapIn` is output and for `swapOut` is input.
-
-Now we calculate the actual ΔX and ΔY, since the fees affect the
-size of the changes to the pool. From the first row of the third table we see
-that the calculation starts from ΔX of
-`sGive - ProtocolFee (i.e. 30,000 - 15 = 29,985)`
-
-```
-40,029,985 * 2,997,753 > 40,000,000 * 3,000,000 > 40,029,985 * 2,997,752
-```
-
-and knowing that 2,997,753 BLD must remain in the pool, we refine the required
-amount of IST:
-
-```
-40,029,983 * 2,997,753 > 40,000,000 * 3,000,000 > 40,029,982 * 2,997,753
-```
-
-**ΔX is 29,983, and ΔY is 2247**.
-
- * Alice pays ΔX + protocolFee, which is 29,983 + 15  (29998 IST)
- * Alice will receive ΔY - PoolFee which is 2247 - 6  (2241 BLD)
- * The IST in the pool will increase by ΔX   (29983 IST)
- * The BLD in the pool will decrease by ΔY   (2247 BLD)
-
-The Pool grew by 6 BLD more than was required to maintain the constant product
-invariant. 15 IST were extracted for the protocol fee.
-

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

@@ -1,99 +0,0 @@
-// @ts-check
-
-import { AmountMath } from '@agoric/ertp';
-import {
-  ceilMultiplyBy,
-  makeRatio,
-} from '@agoric/zoe/src/contractSupport/ratio.js';
-
-import './types.js';
-import './internal-types.js';
-
-import { BASIS_POINTS } from './defaults.js';
-
-const { details: X } = assert;
-
-/**
- * Make a ratio given a nat representing basis points and a brand.
- *
- * @type {MakeFeeRatio}
- */
-const makeFeeRatio = (feeBP, brandOfFee) =>
-  makeRatio(feeBP, brandOfFee, BASIS_POINTS);
-
-/** @type {Maximum} */
-const maximum = (left, right) => {
-  // If left is greater or equal, return left. Otherwise return right.
-  return AmountMath.isGTE(left, right) ? left : right;
-};
-
-/** @type {AmountGT} */
-const amountGT = (left, right) =>
-  AmountMath.isGTE(left, right) && !AmountMath.isEqual(left, right);
-
-/**
- * Apply the feeRatio to the amount that has a matching brand. This used to
- * calculate fees in the single pool case.
- *
- * @param {{ amountIn: Amount, amountOut: Amount}} amounts - a record with two
- *   amounts in different brands.
- * @param {Ratio} feeRatio
- * @returns {Amount}
- */
-const calcFee = ({ amountIn, amountOut }, feeRatio) => {
-  feeRatio.numerator.brand === feeRatio.denominator.brand ||
-    assert.fail(
-      X`feeRatio numerator and denominator must use the same brand ${feeRatio}`,
-    );
-
-  let sameBrandAmount;
-  if (amountIn.brand === feeRatio.numerator.brand) {
-    sameBrandAmount = amountIn;
-  } else if (amountOut.brand === feeRatio.numerator.brand) {
-    sameBrandAmount = amountOut;
-  } else {
-    assert.fail(
-      X`feeRatio's brand (${feeRatio.numerator.brand}) must match one of the amounts [${amountIn}, ${amountOut}].`,
-    );
-  }
-
-  // Always round fees up
-  const fee = ceilMultiplyBy(sameBrandAmount, feeRatio);
-
-  // Fee cannot exceed the amount on which it is levied
-  AmountMath.isGTE(sameBrandAmount, fee) ||
-    assert.fail(X`The feeRatio can't be greater than 1 ${feeRatio}`);
-
-  return fee;
-};
-
-/**
- * Estimate the swap values, then calculate fees. The swapFn provided by the
- * caller will be swapInNoFees or swapOutNoFees.
- * SwapOut.
- *
- * @type {CalculateFees}
- */
-const calculateFees = (
-  amountGiven,
-  poolAllocation,
-  amountWanted,
-  protocolFeeRatio,
-  poolFeeRatio,
-  swapFn,
-) => {
-  // Get a rough estimation in both brands of the amount to be swapped
-  const estimation = swapFn({ amountGiven, poolAllocation, amountWanted });
-
-  const protocolFee = calcFee(estimation, protocolFeeRatio);
-  const poolFee = calcFee(estimation, poolFeeRatio);
-
-  return harden({ protocolFee, poolFee, ...estimation });
-};
-
-harden(amountGT);
-harden(maximum);
-harden(makeFeeRatio);
-harden(calculateFees);
-
-export { amountGT, maximum, makeFeeRatio, calculateFees };

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

@@ -1,85 +0,0 @@
-// @ts-check
-
-import { Far } from '@endo/marshal';
-
-import { swap } from './swap.js';
-import { assertKInvariantSellingX } from './invariants.js';
-import { getXY } from './getXY.js';
-import { swapInNoFees, swapOutNoFees } from './core.js';
-
-// pricesForStatedOutput() and pricesForStatedInput are the external entrypoints
-// to the constantProduct module. The amountWanted is optional for
-// pricesForStatedInput and amountgiven is optional for pricesForStatedOutput.
-
-// The two methods call swap, passing in different functions for noFeeSwap.
-// pricesForStatedInput uses swapInNoFees, while pricesForStatedOutput uses
-// swapOutNoFees. the noFeesSwap functions
-const makeCalcSwapPrices = noFeesSwap => {
-  return Far(
-    'calcSwapPrices',
-    (
-      amountGiven,
-      poolAllocation,
-      amountWanted,
-      protocolFeeRatio,
-      poolFeeRatio,
-    ) => {
-      const result = swap(
-        amountGiven,
-        poolAllocation,
-        amountWanted,
-        protocolFeeRatio,
-        poolFeeRatio,
-        noFeesSwap,
-      );
-      const { x, y } = getXY({
-        amountGiven,
-        poolAllocation,
-        amountWanted,
-      });
-      assertKInvariantSellingX(x, y, result.xIncrement, result.yDecrement);
-      return result;
-    },
-  );
-};
-
-/** @type {CalcSwapInPrices} */
-const pricesForStatedInput = (
-  amountGiven,
-  poolAllocation,
-  amountWanted,
-  protocolFeeRatio,
-  poolFeeRatio,
-) => {
-  const calcSwapPrices = makeCalcSwapPrices(swapInNoFees);
-  return calcSwapPrices(
-    amountGiven,
-    poolAllocation,
-    amountWanted,
-    protocolFeeRatio,
-    poolFeeRatio,
-  );
-};
-
-/** @type {CalcSwapOutPrices} */
-const pricesForStatedOutput = (
-  amountGiven,
-  poolAllocation,
-  amountWanted,
-  protocolFeeRatio,
-  poolFeeRatio,
-) => {
-  const calcSwapPrices = makeCalcSwapPrices(swapOutNoFees);
-  return calcSwapPrices(
-    amountGiven,
-    poolAllocation,
-    amountWanted,
-    protocolFeeRatio,
-    poolFeeRatio,
-  );
-};
-
-harden(pricesForStatedInput);
-harden(pricesForStatedOutput);
-
-export { pricesForStatedOutput, pricesForStatedInput };

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

@@ -1,153 +0,0 @@
-// @ts-check
-
-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 { details: X } = assert;
-
-const assertSingleBrand = ratio => {
-  ratio.numerator.brand === ratio.denominator.brand ||
-    assert.fail(
-      X`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} amount
- * @param {Ratio} ratio
- * @returns {Amount}
- */
-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} amount
- * @param {Ratio} ratio
- * @returns {Amount}
- */
-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} x - the amount of Brand X in pool
- * @param {Amount} y - the amount of Brand Y the pool
- * @param {Amount} deltaX - the amount of Brand X to be added
- * @returns {Amount} 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} x - the amount of Brand X in the pool
- * @param {Amount} y - the amount of Brand Y in the pool
- * @param {Amount} deltaY - the amount of Brand Y to be taken out
- * @returns {Amount} 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) ||
-    assert.fail(
-      X`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) ||
-    assert.fail(
-      X`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,5 +0,0 @@
-// @ts-check
-
-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,52 +0,0 @@
-// @ts-check
-
-// This does not support secondary to secondary. That has to happen at
-// a higher abstraction
-
-const { details: X } = 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 ||
-    assert.fail(
-      X`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`);
-};