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

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

@@ -1,398 +0,0 @@
-import '@agoric/zoe/exported.js';
-
-import { AmountMath, isNatValue } from '@agoric/ertp';
-import { makeStoredPublishKit } from '@agoric/notifier';
-import { prepareKindMulti } from '@agoric/vat-data';
-import {
-  calcLiqValueToMint,
-  calcSecondaryRequired,
-  calcValueToRemove,
-  atomicRearrange,
-} from '@agoric/zoe/src/contractSupport/index.js';
-
-import { E } from '@endo/eventual-send';
-import { makeMetricsPublisherKit } from '../contractSupport.js';
-import { makePriceAuthority } from './priceAuthority.js';
-import { makeSinglePool } from './singlePool.js';
-
-// Pools represent a single pool of liquidity. Price calculations and trading
-// happen in a wrapper class that knows whether the proposed trade involves a
-// single pool or multiple hops.
-
-export const publicPrices = prices => {
-  return { amountIn: prices.swapperGives, amountOut: prices.swapperGets };
-};
-
-/** @typedef {{ liquidityIssuerRecord: IssuerRecord<'nat'> }} InitPublication */
-
-/** @typedef {{ central: Amount, secondary: Amount }} NotificationState */
-
-/**
- * @typedef {Readonly<{
- * poolSeat: ZCFSeat,
- * secondaryBrand: Brand<'nat'>,
- * liquidityZcfMint: ZCFMint,
- * }>} ImmutableState
- */
-
-/** @typedef {{liqTokenSupply: bigint}} MutableState */
-
-/**
- * @typedef {{
- *   addLiquidityInternal: AddLiquidityInternal,
- *   addLiquidityActual: AddLiquidityActual,
- *   updateMetrics: () => void,
- * }} HelperFacet
- */
-
-/**
- * @typedef {{
- *   state: ImmutableState & MutableState,
- *   facets: {
- *     helper: HelperFacet,
- *     pool: XYKPool,
- *     singlePool: VirtualPool,
- *   },
- * }} MethodContext
- *
- * @typedef {object} PoolMetricsNotification
- * @property {Amount} centralAmount
- * @property {Amount} secondaryAmount
- * @property {Amount} liquidityTokens - outstanding tokens
- */
-
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
-/** @typedef {import('./multipoolMarketMaker.js').AmmPowers} AmmPowers */
-
-/**
- * @param {Baggage} baggage
- * @param {AmmPowers} ammPowers
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
- */
-export const definePoolKind = (baggage, ammPowers, storageNode, marshaller) => {
-  /** @type {StoredPublishKit<NotificationState>} */
-  const { subscriber, publisher } = makeStoredPublishKit(
-    storageNode,
-    marshaller,
-  );
-  /** @type {import('../contractSupport.js').MetricsPublisherKit<PoolMetricsNotification>} */
-  const { metricsPublication, metricsSubscription } = makeMetricsPublisherKit(
-    storageNode,
-    marshaller,
-  );
-
-  /**
-   * @param {ZCFMint<'nat'>} liquidityZcfMint
-   * @param {ZCFSeat} poolSeat
-   * @param {Brand<'nat'>} secondaryBrand
-   * @returns {ImmutableState & MutableState}
-   */
-  const poolInit = (liquidityZcfMint, poolSeat, secondaryBrand) => {
-    /** @type {StoredPublishKit<InitPublication>} */
-    const { publisher: initPublisher } = makeStoredPublishKit(
-      E(storageNode).makeChildNode('init'),
-      marshaller,
-    );
-    initPublisher.finish({
-      liquidityIssuerRecord: liquidityZcfMint.getIssuerRecord(),
-    });
-
-    return {
-      liqTokenSupply: 0n,
-      poolSeat,
-      secondaryBrand,
-      liquidityZcfMint,
-    };
-  };
-
-  /** @param {MethodContext} context */
-  const makePriceGetters = context => {
-    const getPAInputPrice = (amountIn, brandOut) => {
-      return publicPrices(
-        context.facets.singlePool.getPriceForInput(
-          amountIn,
-          AmountMath.makeEmpty(brandOut),
-        ),
-      );
-    };
-    const getPAOutputPrice = (brandIn, amountout) =>
-      publicPrices(
-        context.facets.singlePool.getPriceForOutput(
-          AmountMath.makeEmpty(brandIn),
-          amountout,
-        ),
-      );
-    return { getPAInputPrice, getPAOutputPrice };
-  };
-
-  let toCentralPriceAuthority;
-  const provideToCentralPriceAuthority = context => {
-    if (!toCentralPriceAuthority) {
-      const { getPAInputPrice, getPAOutputPrice } = makePriceGetters(context);
-      const { secondaryBrand } = context.state;
-      const { quoteIssuerKit } = ammPowers;
-      toCentralPriceAuthority = makePriceAuthority(
-        getPAInputPrice,
-        getPAOutputPrice,
-        secondaryBrand,
-        ammPowers.centralBrand,
-        ammPowers.timer,
-        subscriber,
-        quoteIssuerKit,
-      );
-    }
-    return toCentralPriceAuthority;
-  };
-
-  let fromCentralPriceAuthority;
-  const provideFromCentralPriceAuthority = context => {
-    if (!fromCentralPriceAuthority) {
-      const { getPAInputPrice, getPAOutputPrice } = makePriceGetters(context);
-      const { secondaryBrand } = context.state;
-      const quoteIssuerKit = ammPowers.quoteIssuerKit;
-      fromCentralPriceAuthority = makePriceAuthority(
-        getPAInputPrice,
-        getPAOutputPrice,
-        ammPowers.centralBrand,
-        secondaryBrand,
-        ammPowers.timer,
-        subscriber,
-        quoteIssuerKit,
-      );
-    }
-    return fromCentralPriceAuthority;
-  };
-
-  const poolBehavior = {
-    getLiquiditySupply: ({ state: { liqTokenSupply } }) => liqTokenSupply,
-    getLiquidityIssuer: ({ state: { liquidityZcfMint } }) =>
-      liquidityZcfMint.getIssuerRecord().issuer,
-    getPoolSeat: ({ state: { poolSeat } }) => poolSeat,
-    getCentralAmount: ({ state: { poolSeat } }) =>
-      poolSeat.getAmountAllocated('Central', ammPowers.centralBrand),
-    getSecondaryAmount: ({ state }) =>
-      state.poolSeat.getAmountAllocated('Secondary', state.secondaryBrand),
-
-    /**
-     * @param {MethodContext} context
-     * @param {ZCFSeat} zcfSeat
-     * @returns {string}
-     */
-    addLiquidity: ({ state, facets }, zcfSeat) => {
-      const { helper, pool } = facets;
-      const centralIn = zcfSeat.getStagedAllocation().Central;
-      assert(isNatValue(centralIn.value), 'User Central');
-      const secondaryIn = zcfSeat.getStagedAllocation().Secondary;
-      assert(isNatValue(secondaryIn.value), 'User Secondary');
-
-      if (state.liqTokenSupply === 0n) {
-        return helper.addLiquidityActual(pool, zcfSeat, secondaryIn, centralIn);
-      }
-
-      const centralPoolAmount = pool.getCentralAmount();
-      const secondaryPoolAmount = pool.getSecondaryAmount();
-      assert(isNatValue(centralPoolAmount.value), 'Pool Central');
-      assert(isNatValue(secondaryPoolAmount.value), 'Pool Secondary');
-
-      // To calculate liquidity, we'll need to calculate alpha from the primary
-      // token's value before, and the value that will be added to the pool
-      const secondaryRequired = AmountMath.make(
-        state.secondaryBrand,
-        calcSecondaryRequired(
-          centralIn.value,
-          centralPoolAmount.value,
-          secondaryPoolAmount.value,
-          secondaryIn.value,
-        ),
-      );
-
-      // Central was specified precisely so offer must provide enough secondary.
-      assert(
-        AmountMath.isGTE(secondaryIn, secondaryRequired),
-        'insufficient Secondary deposited',
-      );
-
-      return helper.addLiquidityActual(
-        pool,
-        zcfSeat,
-        secondaryRequired,
-        centralPoolAmount,
-      );
-    },
-    removeLiquidity: ({ state, facets }, userSeat) => {
-      const { liquidityZcfMint, poolSeat, secondaryBrand } = state;
-      const liquidityBrand = liquidityZcfMint.getIssuerRecord().brand;
-      const liquidityIn = userSeat.getAmountAllocated(
-        'Liquidity',
-        liquidityBrand,
-      );
-      if (AmountMath.isEmpty(liquidityIn)) {
-        // prevent divide-by-zero. If the caller has tokens, the pool is not empty
-        userSeat.exit();
-        return 'request to remove zero liquidity';
-      }
-
-      const liquidityValueIn = liquidityIn.value;
-      assert(isNatValue(liquidityValueIn), 'User Liquidity');
-      const centralTokenAmountOut = AmountMath.make(
-        ammPowers.centralBrand,
-        calcValueToRemove(
-          state.liqTokenSupply,
-          facets.pool.getCentralAmount().value,
-          liquidityValueIn,
-        ),
-      );
-
-      const tokenKeywordAmountOut = AmountMath.make(
-        secondaryBrand,
-        calcValueToRemove(
-          state.liqTokenSupply,
-          facets.pool.getSecondaryAmount().value,
-          liquidityValueIn,
-        ),
-      );
-
-      atomicRearrange(
-        ammPowers.zcf,
-        harden([
-          [userSeat, poolSeat, { Liquidity: liquidityIn }],
-          [
-            poolSeat,
-            userSeat,
-            {
-              Central: centralTokenAmountOut,
-              Secondary: tokenKeywordAmountOut,
-            },
-          ],
-        ]),
-      );
-
-      state.liqTokenSupply -= liquidityValueIn;
-
-      userSeat.exit();
-      facets.pool.updateState();
-      return 'Liquidity successfully removed.';
-    },
-    getSubscriber: () => subscriber,
-    /**
-     * Update metrics and primary state
-     *
-     * @param {MethodContext} context
-     */
-    updateState: ({ facets: { pool, helper } }) => {
-      helper.updateMetrics();
-      publisher.publish({
-        central: pool.getCentralAmount(),
-        secondary: pool.getSecondaryAmount(),
-      });
-    },
-
-    /** @deprecated priceAuthorities will not be provided by the AMM */
-    getToCentralPriceAuthority: provideToCentralPriceAuthority,
-    /** @deprecated priceAuthorities will not be provided by the AMM */
-    getFromCentralPriceAuthority: provideFromCentralPriceAuthority,
-
-    /** @param {MethodContext} context */
-    getVPool: ({ facets }) => facets.singlePool,
-    getMetrics: () => metricsSubscription,
-  };
-
-  /** @param {MethodContext} context */
-  const finish = context => {
-    context.facets.helper.updateMetrics();
-  };
-
-  const helperBehavior = {
-    /** @type {import('@agoric/vat-data/src/types').PlusContext<MethodContext, AddLiquidityInternal>} */
-    addLiquidityInternal: (
-      { state },
-      zcfSeat,
-      secondaryAmount,
-      poolCentralAmount,
-      feeSeat,
-    ) => {
-      const { poolSeat, liquidityZcfMint } = state;
-      // addLiquidity can't be called until the pool has been created. We verify
-      // that the asset is NAT before creating a pool.
-
-      const liquidityValueOut = calcLiqValueToMint(
-        state.liqTokenSupply,
-        // @ts-expect-error value could be not Nat
-        zcfSeat.getStagedAllocation().Central.value,
-        poolCentralAmount.value,
-      );
-
-      const liquidityAmountOut = AmountMath.make(
-        liquidityZcfMint.getIssuerRecord().brand,
-        liquidityValueOut,
-      );
-      liquidityZcfMint.mintGains(
-        harden({ Liquidity: liquidityAmountOut }),
-        poolSeat,
-      );
-      state.liqTokenSupply += liquidityValueOut;
-
-      poolSeat.incrementBy(
-        zcfSeat.decrementBy(
-          harden({
-            Central: zcfSeat.getStagedAllocation().Central,
-            Secondary: secondaryAmount,
-          }),
-        ),
-      );
-
-      zcfSeat.incrementBy(
-        poolSeat.decrementBy(harden({ Liquidity: liquidityAmountOut })),
-      );
-      if (feeSeat) {
-        ammPowers.zcf.reallocate(poolSeat, zcfSeat, feeSeat);
-      } else {
-        ammPowers.zcf.reallocate(poolSeat, zcfSeat);
-      }
-    },
-    /** @type {import('@agoric/vat-data/src/types').PlusContext<MethodContext, AddLiquidityActual>} */
-    addLiquidityActual: (
-      { facets },
-      pool,
-      zcfSeat,
-      secondaryAmount,
-      poolCentralAmount,
-      feeSeat,
-    ) => {
-      const { helper } = facets;
-
-      helper.addLiquidityInternal(
-        zcfSeat,
-        secondaryAmount,
-        poolCentralAmount,
-        feeSeat,
-      );
-      zcfSeat.exit();
-      facets.pool.updateState();
-      return 'Added liquidity.';
-    },
-    /** @param {MethodContext} context */
-    updateMetrics: context => {
-      const { state, facets } = context;
-      const payload = harden({
-        centralAmount: facets.pool.getCentralAmount(),
-        secondaryAmount: facets.pool.getSecondaryAmount(),
-        liquidityTokens: AmountMath.make(
-          state.liquidityZcfMint.getIssuerRecord().brand,
-          state.liqTokenSupply,
-        ),
-      });
-
-      metricsPublication.updateState(payload);
-    },
-  };
-
-  const facets = harden({
-    helper: helperBehavior,
-    pool: poolBehavior,
-    singlePool: makeSinglePool(ammPowers),
-  });
-
-  return prepareKindMulti(baggage, 'pool', poolInit, facets, { finish });
-};

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

@@ -1,92 +0,0 @@
-import { AmountMath } from '@agoric/ertp';
-import {
-  makeNotifierFromSubscriber,
-  observeIteration,
-  subscribeLatest,
-} from '@agoric/notifier';
-import { E } from '@endo/eventual-send';
-import { Far } from '@endo/marshal';
-
-import { makeOnewayPriceAuthorityKit } from '@agoric/zoe/src/contractSupport/index.js';
-
-/**
- *
- * @param {*} getOutputForGivenInput
- * @param {*} getInputForWantedOutput
- * @param {Brand<'nat'>} actualBrandIn
- * @param {Brand<'nat'>} actualBrandOut
- * @param {import('@agoric/time/src/types').TimerService} timer
- * @param {Subscriber<import('./pool').NotificationState>} subscriber
- * @param {IssuerKit<'set'>} quoteIssuerKit
- * @returns {PriceAuthority}
- */
-export const makePriceAuthority = (
-  getOutputForGivenInput,
-  getInputForWantedOutput,
-  actualBrandIn,
-  actualBrandOut,
-  timer,
-  subscriber,
-  quoteIssuerKit,
-) => {
-  const { brand, issuer: quoteIssuer } = quoteIssuerKit;
-
-  /** @param {PriceQuoteValue} quote */
-  const authenticateQuote = quote => {
-    const quoteAmount = AmountMath.make(brand, harden(quote));
-    const quotePayment = quoteIssuerKit.mint.mintPayment(quoteAmount);
-    return harden({ quoteAmount, quotePayment });
-  };
-
-  // called by createQuote for each trigger to compare price to trigger level
-  const calcAmountOut = amountIn =>
-    getOutputForGivenInput(amountIn, actualBrandOut).amountOut;
-  const calcAmountIn = amountOut =>
-    getInputForWantedOutput(actualBrandIn, amountOut).amountIn;
-
-  /**
-   * @param {PriceQuery} priceQuery
-   * @returns {ERef<PriceQuote> | undefined}
-   */
-  function createQuote(priceQuery) {
-    const quote = priceQuery(calcAmountOut, calcAmountIn);
-    if (!quote) {
-      return undefined;
-    }
-
-    const { amountIn, amountOut } = quote;
-    return E(timer)
-      .getCurrentTimestamp()
-      .then(now =>
-        authenticateQuote([{ amountIn, amountOut, timer, timestamp: now }]),
-      );
-  }
-
-  const priceAuthorityOptions = harden({
-    timer,
-    createQuote,
-    actualBrandIn,
-    actualBrandOut,
-    quoteIssuer,
-    notifier: makeNotifierFromSubscriber(subscriber),
-  });
-
-  const {
-    priceAuthority,
-    adminFacet: { fireTriggers },
-  } = makeOnewayPriceAuthorityKit(priceAuthorityOptions);
-
-  // An observer on a notifier that gets updated when the pool's balances
-  // change via swap or liquidity operations. It checks the comparison predicate
-  // for each active trigger. Due to `subscribeLatest` below it may drop
-  // intermediate values.
-  const priceObserver = Far('priceObserver', {
-    updateState: () => {
-      void fireTriggers(createQuote);
-    },
-  });
-
-  void observeIteration(subscribeLatest(subscriber), priceObserver);
-
-  return priceAuthority;
-};

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

@@ -1,29 +0,0 @@
-import { assertProposalShape } from '@agoric/zoe/src/contractSupport/index.js';
-
-import '@agoric/zoe/exported.js';
-
-/**
- * @param {ZCF} zcf
- * @param {(brand: Brand) => XYKPool} getPool
- */
-export const makeMakeRemoveLiquidityInvitation = (zcf, getPool) => {
-  const removeLiquidity = seat => {
-    assertProposalShape(seat, {
-      want: {
-        Central: null,
-        Secondary: null,
-      },
-      give: {
-        Liquidity: null,
-      },
-    });
-    // Get the brand of the secondary token so we can identify the liquidity pool.
-    const secondaryBrand = seat.getProposal().want.Secondary.brand;
-    const pool = getPool(secondaryBrand);
-    return pool.removeLiquidity(seat);
-  };
-
-  const makeRemoveLiquidityInvitation = () =>
-    zcf.makeInvitation(removeLiquidity, 'autoswap remove liquidity');
-  return makeRemoveLiquidityInvitation;
-};

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

@@ -1,88 +0,0 @@
-import {
-  atomicRearrange,
-  fromOnly,
-  toOnly,
-} from '@agoric/zoe/src/contractSupport/index.js';
-import { makeFeeRatio } from './constantProduct/calcFees.js';
-import {
-  pricesForStatedInput,
-  pricesForStatedOutput,
-} from './constantProduct/calcSwapPrices.js';
-
-const getSecondaryBrand = pool => pool.getSecondaryAmount().brand;
-const getCentralBrand = pool => pool.getCentralAmount().brand;
-
-const getPools = pool => ({
-  Central: pool.getCentralAmount(),
-  Secondary: pool.getSecondaryAmount(),
-});
-
-export const makeSinglePool = ammPowers => ({
-  allocateGainsAndLosses: (context, seat, prices) => {
-    const { pool } = context.facets;
-    const { poolSeat } = context.state;
-    const { zcf, protocolSeat } = ammPowers;
-    const inBrand = prices.swapperGives.brand;
-
-    /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} */
-    const xfer = harden(
-      inBrand === getSecondaryBrand(pool)
-        ? [
-            fromOnly(poolSeat, { Central: prices.yDecrement }),
-            toOnly(poolSeat, { Secondary: prices.xIncrement }),
-          ]
-        : [
-            fromOnly(poolSeat, { Secondary: prices.yDecrement }),
-            toOnly(poolSeat, { Central: prices.xIncrement }),
-          ],
-    );
-
-    atomicRearrange(
-      zcf,
-      harden([
-        fromOnly(seat, { In: prices.swapperGives }),
-
-        toOnly(seat, { Out: prices.swapperGets }),
-        toOnly(protocolSeat, { Fee: prices.protocolFee }),
-
-        ...xfer,
-      ]),
-    );
-    seat.exit();
-    pool.updateState();
-    return `Swap successfully completed.`;
-  },
-
-  /**
-   * @param {import('./pool').MethodContext} context
-   * @param {Amount} amountIn
-   * @param {Amount} amountOut
-   */
-  getPriceForInput: ({ facets }, amountIn, amountOut) => {
-    const { params } = ammPowers;
-    return pricesForStatedInput(
-      amountIn,
-      getPools(facets.pool),
-      amountOut,
-      makeFeeRatio(params.getProtocolFee(), getCentralBrand(facets.pool)),
-      makeFeeRatio(params.getPoolFee(), amountOut.brand),
-    );
-  },
-
-  /**
-   * @param {import('./pool').MethodContext} context
-   * @param {Amount} amountIn
-   * @param {Amount} amountOut
-   */
-  getPriceForOutput: ({ facets }, amountIn, amountOut) => {
-    const { params } = ammPowers;
-    return pricesForStatedOutput(
-      amountIn,
-      getPools(facets.pool),
-      amountOut,
-      makeFeeRatio(params.getProtocolFee(), getCentralBrand(facets.pool)),
-      makeFeeRatio(params.getPoolFee(), amountIn.brand),
-    );
-  },
-});
-harden(makeSinglePool);

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

@@ -1,68 +0,0 @@
-import { assertProposalShape } from '@agoric/zoe/src/contractSupport/index.js';
-
-import '@agoric/zoe/exported.js';
-import { AmountMath } from '@agoric/ertp';
-
-/**
- * @param {ZCF} zcf
- * @param {(brandIn: Brand, brandOut: Brand) => VirtualPool} provideVPool
- */
-export const makeMakeSwapInvitation = (zcf, provideVPool) => {
-  /**
-   * trade with a stated amountIn.
-   *
-   * @param {ZCFSeat} seat
-   * @param {{ stopAfter: Amount }} args
-   */
-  const swapIn = (seat, args) => {
-    assertProposalShape(seat, {
-      give: { In: null },
-      want: { Out: null },
-    });
-    const {
-      give: { In: amountIn },
-      want: { Out: amountOut },
-    } = seat.getProposal();
-    if (args) {
-      AmountMath.coerce(amountOut.brand, args.stopAfter);
-      // TODO check that there are no other keys
-    }
-
-    const pool = provideVPool(amountIn.brand, amountOut.brand);
-    let prices;
-    const stopAfter = args && args.stopAfter;
-    if (stopAfter) {
-      AmountMath.coerce(amountOut.brand, stopAfter);
-      prices = pool.getPriceForOutput(amountIn, stopAfter);
-    }
-    if (!prices || !AmountMath.isGTE(prices.swapperGets, stopAfter)) {
-      // `amountIn` is not enough to sell for stopAfter so just sell it all
-      prices = pool.getPriceForInput(amountIn, amountOut);
-    }
-    assert(amountIn.brand === prices.swapperGives.brand);
-    return pool.allocateGainsAndLosses(seat, prices);
-  };
-
-  // trade with a stated amount out.
-  const swapOut = seat => {
-    assertProposalShape(seat, {
-      give: { In: null },
-      want: { Out: null },
-    });
-    const {
-      give: { In: amountIn },
-      want: { Out: amountOut },
-    } = seat.getProposal();
-    const pool = provideVPool(amountIn.brand, amountOut.brand);
-    const prices = pool.getPriceForOutput(amountIn, amountOut);
-    return pool.allocateGainsAndLosses(seat, prices);
-  };
-
-  const makeSwapInInvitation = () =>
-    zcf.makeInvitation(swapIn, 'autoswap swapIn');
-
-  const makeSwapOutInvitation = () =>
-    zcf.makeInvitation(swapOut, 'autoswap swapOut');
-
-  return { makeSwapInInvitation, makeSwapOutInvitation };
-};