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

package/src/vpool-xyk-amm/doublePool.js

@@ -1,200 +0,0 @@
-import { AmountMath } from '@agoric/ertp';
-import {
-  atomicRearrange,
-  fromOnly,
-  toOnly,
-} from '@agoric/zoe/src/contractSupport/index.js';
-import { Far } from '@endo/marshal';
-import { makeFeeRatio } from './constantProduct/calcFees.js';
-import {
-  pricesForStatedInput,
-  pricesForStatedOutput,
-} from './constantProduct/calcSwapPrices.js';
-
-const { Fail } = assert;
-
-// Price calculations and swap using a pair of pools. Both pools map between RUN
-// and some collateral. We arrange the trades so collateralInPool will have
-// collateral added and collateralOutPool subtracted. When traders specify an
-// input price, that brand will be the inPool; when they specify the output
-// price that brand is the outPool.
-
-/**
- * doublePool is the virtualPool implementation for calculating prices when
- * transiting through two pools. virtual pools wrap something that can do a swap
- * and calculate prices. Current wrapped pools are single pools and pairs of
- * pools, but we've also contemplated using a similar virtual wrapper for other
- * curves.
- *
- * @param {ZCF} zcf
- * @param {XYKPool} collateralInPool
- * @param {XYKPool} collateralOutPool
- * @param {() => bigint} getProtocolFeeBP - retrieve governed protocol fee value
- * @param {() => bigint} getPoolFeeBP - retrieve governed pool fee value
- * @param {ZCFSeat} feeSeat
- * @returns {VirtualPool<'double'>}
- */
-export const makeDoublePool = (
-  zcf,
-  collateralInPool,
-  collateralOutPool,
-  getProtocolFeeBP,
-  getPoolFeeBP,
-  feeSeat,
-) => {
-  const inCentral = collateralInPool.getCentralAmount();
-  const inSecondary = collateralInPool.getSecondaryAmount();
-
-  const outCentral = collateralOutPool.getCentralAmount();
-  const outSecondary = collateralOutPool.getSecondaryAmount();
-
-  const inAllocation = { Central: inCentral, Secondary: inSecondary };
-  const outAllocation = { Central: outCentral, Secondary: outSecondary };
-
-  const centralBrand = inCentral.brand;
-  const emptyCentralAmount = AmountMath.makeEmpty(centralBrand);
-  centralBrand === outCentral.brand ||
-    Fail`The central brands on the two pools must match: ${centralBrand}, ${outCentral.brand}`;
-
-  const allocateGainsAndLosses = (seat, prices) => {
-    const inPoolSeat = collateralInPool.getPoolSeat();
-    const outPoolSeat = collateralOutPool.getPoolSeat();
-
-    atomicRearrange(
-      zcf,
-      harden([
-        fromOnly(seat, { In: prices.swapperGives }),
-        fromOnly(inPoolSeat, { Central: prices.inPoolDecrement }),
-        fromOnly(outPoolSeat, { Secondary: prices.outPoolDecrement }),
-
-        toOnly(seat, { Out: prices.swapperGets }),
-        toOnly(inPoolSeat, { Secondary: prices.inPoolIncrement }),
-        toOnly(outPoolSeat, { Central: prices.outPoolIncrement }),
-        toOnly(feeSeat, { Fee: prices.protocolFee }),
-      ]),
-    );
-
-    seat.exit();
-    collateralInPool.updateState();
-    collateralOutPool.updateState();
-    return `Swap successfully completed.`;
-  };
-
-  const getPriceForInput = (amountIn, amountOut) => {
-    const protocolFeeRatio = makeFeeRatio(getProtocolFeeBP(), centralBrand);
-    const poolFeeRatioCentral = makeFeeRatio(getPoolFeeBP(), centralBrand);
-    const poolFeeRatioAmountOut = makeFeeRatio(getPoolFeeBP(), amountOut.brand);
-
-    // We must do two consecutive swapInPrice() calls,
-    // followed by a call to swapOutPrice().
-    // 1) from amountIn to the central token, which tells us how much central
-    //  would be provided for amountIn,
-    // 2) from that amount of central to brandOut, which tells us how much of
-    //  brandOut will be provided as well as the minimum price in central
-    //  tokens, then finally
-    // 3) call swapOutPrice() to see if the same proceeds can be purchased for
-    //  less.
-    // Notice that in the second call, the original amountOut is used, and in
-    // the third call, the original amountIn is used.
-    const interimInpoolPrices = pricesForStatedInput(
-      amountIn,
-      inAllocation,
-      emptyCentralAmount,
-      protocolFeeRatio,
-      poolFeeRatioCentral,
-    );
-    const outPoolPrices = pricesForStatedInput(
-      interimInpoolPrices.swapperGets,
-      outAllocation,
-      amountOut,
-      protocolFeeRatio,
-      poolFeeRatioAmountOut,
-    );
-    const finalInPoolPrices = pricesForStatedOutput(
-      amountIn,
-      inAllocation,
-      outPoolPrices.swapperGives,
-      protocolFeeRatio,
-      poolFeeRatioCentral,
-    );
-
-    // When finalInPoolPrices has a price improvement that makes the difference
-    // between finalInPoolPrices.yDecrement and outPoolPrices.xIncrement more
-    // than the calculated protocol fees add the excess to the protocol fee.
-    const protocolFee = AmountMath.max(
-      AmountMath.add(finalInPoolPrices.protocolFee, outPoolPrices.protocolFee),
-      AmountMath.subtract(
-        finalInPoolPrices.yDecrement,
-        outPoolPrices.xIncrement,
-      ),
-    );
-
-    return harden({
-      swapperGives: finalInPoolPrices.swapperGives,
-      swapperGets: outPoolPrices.swapperGets,
-      inPoolIncrement: finalInPoolPrices.xIncrement,
-      inPoolDecrement: finalInPoolPrices.yDecrement,
-      outPoolIncrement: outPoolPrices.xIncrement,
-      outPoolDecrement: outPoolPrices.yDecrement,
-      protocolFee,
-    });
-  };
-
-  const getPriceForOutput = (amountIn, amountOut) => {
-    const protocolFeeRatio = makeFeeRatio(getProtocolFeeBP(), centralBrand);
-    const poolFeeRatioCentral = makeFeeRatio(getPoolFeeBP(), centralBrand);
-    const poolFeeRatioAmountIn = makeFeeRatio(getPoolFeeBP(), amountIn.brand);
-
-    // We must do two consecutive swapOutPrice() calls, followed by a call to
-    // swapInPrice().
-    // 1) from amountOut to the central token, which tells us how much central
-    //  is required to obtain amountOut,
-    // 2) from that amount of central to brandIn, which tells us how much of
-    //  brandIn is required as well as the max proceeds in central tokens, then
-    //  finally
-    // 3) call swapInPrice() to see if those central proceeds could purchase
-    //  larger amount
-    // Notice that the amountIn parameter to the first call to swapOutPrice
-    // specifies an empty amount. This is interpreted as "no limit", which is
-    // necessary since we can't guess a reasonable maximum of the central token.
-    const interimOutpoolPrices = pricesForStatedOutput(
-      emptyCentralAmount,
-      outAllocation,
-      amountOut,
-      protocolFeeRatio,
-      poolFeeRatioCentral,
-    );
-    const inpoolPrices = pricesForStatedOutput(
-      amountIn,
-      inAllocation,
-      interimOutpoolPrices.swapperGives,
-      protocolFeeRatio,
-      poolFeeRatioAmountIn,
-    );
-    const finalOutpoolPrices = pricesForStatedInput(
-      inpoolPrices.swapperGets,
-      outAllocation,
-      amountOut,
-      protocolFeeRatio,
-      poolFeeRatioCentral,
-    );
-    return harden({
-      swapperGives: inpoolPrices.swapperGives,
-      swapperGets: finalOutpoolPrices.swapperGets,
-      inPoolIncrement: inpoolPrices.xIncrement,
-      inPoolDecrement: inpoolPrices.yDecrement,
-      outPoolIncrement: finalOutpoolPrices.xIncrement,
-      outPoolDecrement: finalOutpoolPrices.yDecrement,
-      protocolFee: AmountMath.add(
-        finalOutpoolPrices.protocolFee,
-        inpoolPrices.protocolFee,
-      ),
-    });
-  };
-
-  return Far('double pool', {
-    getPriceForInput,
-    getPriceForOutput,
-    allocateGainsAndLosses,
-  });
-};

package/src/vpool-xyk-amm/estimate.js

@@ -1,175 +0,0 @@
-import { natSafeMath } from '@agoric/zoe/src/contractSupport/index.js';
-import { AmountMath } from '@agoric/ertp';
-import { BASIS_POINTS } from './constantProduct/defaults.js';
-
-/**
- * @file support the UI in calculating how much to offer, taking slippage
- * into account, and not requiring a round trip to the chain.
- */
-
-/** @typedef {{ centralAmount: Amount<'nat'>, secondaryAmount: Amount<'nat'> }} Pool */
-
-const { ceilDivide, floorDivide } = natSafeMath;
-
-/**
- * @param {bigint} chargeBP
- * @param {Amount<'nat'>} amount
- */
-export const charge = (chargeBP, amount) => {
-  return AmountMath.make(
-    amount.brand,
-    ceilDivide(amount.value * chargeBP, BASIS_POINTS),
-  );
-};
-
-/**
- * @param {bigint} chargeBP
- * @param {Amount<'nat'>} amount
- */
-export const chargeFloor = (chargeBP, amount) => {
-  return AmountMath.make(
-    amount.brand,
-    floorDivide(amount.value * chargeBP, BASIS_POINTS),
-  );
-};
-
-const makeEstimator = (centralBrand, rates) => {
-  const { poolFeeBP, protocolFeeBP, slippageBP } = rates;
-
-  /**
-   * Proceeds less slippage when specifying the amount to add to a single pool
-   *
-   * @param {Amount<'nat'>} amountIn
-   * @param {Brand<'nat'>} brandOut
-   * @param {MapStore<Brand, Pool>} pools
-   */
-  function estimateSinglePoolProceeds(amountIn, brandOut, pools) {
-    const isCentralIn = amountIn.brand === centralBrand;
-    const pool = isCentralIn ? pools.get(brandOut) : pools.get(amountIn.brand);
-    const kPre = pool.secondaryAmount.value * pool.centralAmount.value;
-
-    function calcYFromX(X) {
-      const denom = isCentralIn
-        ? AmountMath.add(pool.centralAmount, X)
-        : AmountMath.add(pool.secondaryAmount, X);
-      const finalOutBalance = AmountMath.make(
-        brandOut,
-        ceilDivide(kPre, denom.value),
-      );
-
-      return isCentralIn
-        ? AmountMath.subtract(pool.secondaryAmount, finalOutBalance)
-        : AmountMath.subtract(pool.centralAmount, finalOutBalance);
-    }
-
-    const amountAdded = isCentralIn
-      ? AmountMath.subtract(amountIn, charge(protocolFeeBP, amountIn))
-      : amountIn;
-    const amountOutForFees = calcYFromX(amountIn);
-    const amountOut = calcYFromX(amountAdded);
-    const amountRemoved = AmountMath.subtract(
-      amountOut,
-      charge(poolFeeBP, amountOutForFees),
-    );
-    const amountReturned = isCentralIn
-      ? amountRemoved
-      : AmountMath.subtract(
-          amountRemoved,
-          charge(protocolFeeBP, amountOutForFees),
-        );
-
-    return amountReturned;
-  }
-
-  /**
-   * Payment w/slippage when specifying the amount to receive from a single pool
-   *
-   * @param {Brand<'nat'>} brandIn
-   * @param {Amount<'nat'>} amountOut
-   * @param {MapStore<Brand, Pool>} pools
-   */
-  function estimateSinglePoolRequired(brandIn, amountOut, pools) {
-    const isCentralIn = brandIn === centralBrand;
-    const pool = isCentralIn ? pools.get(amountOut.brand) : pools.get(brandIn);
-    const kPre = pool.secondaryAmount.value * pool.centralAmount.value;
-    const amountWithdrawn = isCentralIn
-      ? AmountMath.add(amountOut, charge(protocolFeeBP, amountOut))
-      : amountOut;
-
-    const calcXFromY = y => {
-      const denom = isCentralIn
-        ? AmountMath.subtract(pool.secondaryAmount, y)
-        : AmountMath.subtract(pool.centralAmount, y);
-      const finalInBalance = AmountMath.make(
-        brandIn,
-        ceilDivide(kPre, denom.value),
-      );
-      return isCentralIn
-        ? AmountMath.subtract(finalInBalance, pool.centralAmount)
-        : AmountMath.subtract(finalInBalance, pool.secondaryAmount);
-    };
-
-    const amountInForFees = calcXFromY(amountOut);
-    const amountIn = calcXFromY(amountWithdrawn);
-    const amountAddToPool = AmountMath.add(
-      amountIn,
-      charge(poolFeeBP, amountInForFees),
-    );
-    const amountToBePaid = isCentralIn
-      ? amountAddToPool
-      : AmountMath.add(
-          amountAddToPool,
-          chargeFloor(protocolFeeBP, amountInForFees),
-        );
-
-    return amountToBePaid;
-  }
-
-  // ignores price improvement
-  function estimateDoublePoolProceeds(amountIn, brandOut, pools) {
-    const inProceeds = estimateSinglePoolProceeds(
-      amountIn,
-      centralBrand,
-      pools,
-    );
-    const outProceeds = estimateSinglePoolProceeds(inProceeds, brandOut, pools);
-    return outProceeds;
-  }
-
-  // ignores price improvement
-  function estimateDoublePoolRequired(brandIn, amountOut, pools) {
-    const outRequired = estimateSinglePoolRequired(
-      centralBrand,
-      amountOut,
-      pools,
-    );
-    const inRequired = estimateSinglePoolRequired(brandIn, outRequired, pools);
-    return inRequired;
-  }
-
-  const estimateProceeds = (amountIn, brandOut, pools) => {
-    let proceeds;
-    if (amountIn.brand === centralBrand || brandOut === centralBrand) {
-      proceeds = estimateSinglePoolProceeds(amountIn, brandOut, pools);
-    } else {
-      proceeds = estimateDoublePoolProceeds(amountIn, brandOut, pools);
-    }
-    return AmountMath.subtract(proceeds, charge(slippageBP, proceeds));
-  };
-
-  const estimateRequired = (brandIn, amountOut, pools) => {
-    let required;
-    if (brandIn === centralBrand || amountOut.brand === centralBrand) {
-      required = estimateSinglePoolRequired(brandIn, amountOut, pools);
-    } else {
-      required = estimateDoublePoolRequired(brandIn, amountOut, pools);
-    }
-
-    return AmountMath.add(required, charge(slippageBP, required));
-  };
-
-  return { estimateProceeds, estimateRequired };
-};
-harden(makeEstimator);
-
-export { makeEstimator };