@agoric/inter-protocol 0.16.2-other-dev-8f8782b.0 → 0.16.2-other-dev-fbe72e7.0.fbe72e7

package/src/auction/auctionBook.js

@@ -1,25 +1,25 @@
-import '@agoric/governance/exported.js';
-import '@agoric/zoe/exported.js';
-import '@agoric/zoe/src/contracts/exported.js';
+/// <reference types="@agoric/internal/exported" />
+/// <reference types="@agoric/governance/exported" />
+/// <reference types="@agoric/zoe/exported" />
 
-import { AmountMath } from '@agoric/ertp';
+import { Fail } from '@endo/errors';
+import { E } from '@endo/captp';
+import { AmountMath, RatioShape } from '@agoric/ertp';
 import { mustMatch } from '@agoric/store';
 import { M, prepareExoClassKit } from '@agoric/vat-data';
 
 import { assertAllDefined, makeTracer } from '@agoric/internal';
 import {
-  atomicRearrange,
   ceilMultiplyBy,
-  floorDivideBy,
   makeRatioFromAmounts,
   makeRecorderTopic,
   multiplyRatios,
   ratioGTE,
 } from '@agoric/zoe/src/contractSupport/index.js';
-import { E } from '@endo/captp';
 import { observeNotifier } from '@agoric/notifier';
 
 import { makeNatAmountShape } from '../contractSupport.js';
+import { amountsToSettle } from './auctionMath.js';
 import { preparePriceBook, prepareScaledBidBook } from './offerBook.js';
 import {
   isScaledBidPriceHigher,
@@ -27,41 +27,51 @@ import {
   priceFrom,
 } from './util.js';
 
-const { Fail } = assert;
+/**
+ * @import {EReturn} from '@endo/far';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {PriceAuthority} from '@agoric/zoe/tools/types.js';
+ * @import {TypedPattern} from '@agoric/internal';
+ */
+
 const { makeEmpty } = AmountMath;
 
-const DEFAULT_DECIMALS = 9;
+const QUOTE_SCALE = 10n ** 9n;
 
 /**
  * @file The book represents the collateral-specific state of an ongoing
- * auction. It holds the book, the capturedPrice, and the collateralSeat that has
- * the allocation of assets for sale.
+ *   auction. It holds the book, the capturedPrice, and the collateralSeat that
+ *   has the allocation of assets for sale.
+ *
+ *   The book contains orders for the collateral. It holds two kinds of orders:
  *
- * The book contains orders for the collateral. It holds two kinds of
- * orders:
  *   - Prices express the bidding offer in terms of a Bid amount
- *   - ScaledBids express the offer in terms of a discount (or markup) from the
- *     most recent oracle price.
+ *   - ScaledBids express the offer in terms of a discount (or markup) from the most
+ *       recent oracle price.
  *
- * Offers can be added in three ways. 1) When the auction is not active, prices
- * are automatically added to the appropriate collection. When the auction is
- * active, 2) if a new offer is at or above the current price, it will be
- * settled immediately; 2) If the offer is below the current price, it will be
- * added in the appropriate place and settled when the price reaches that level.
+ *   Offers can be added in three ways. 1) When the auction is not active, prices
+ *   are automatically added to the appropriate collection. When the auction is
+ *   active, 2) if a new offer is at or above the current price, it will be
+ *   settled immediately; 2) If the offer is below the current price, it will be
+ *   added in the appropriate place and settled when the price reaches that
+ *   level.
  */
 
 const trace = makeTracer('AucBook', true);
 
 /**
  * @typedef {{
- *   maxBuy: Amount<'nat'>
+ *   maxBuy: Amount<'nat'>;
  * } & {
- *   exitAfterBuy?: boolean,
- * } & ({
- *   offerPrice: Ratio,
- * } | {
- *    offerBidScaling: Ratio,
- * })} OfferSpec
+ *   exitAfterBuy?: boolean;
+ * } & (
+ *     | {
+ *         offerPrice: Ratio;
+ *       }
+ *     | {
+ *         offerBidScaling: Ratio;
+ *       }
+ *   )} OfferSpec
  */
 /**
  * @param {Brand<'nat'>} bidBrand
@@ -84,21 +94,21 @@ export const makeOfferSpecShape = (bidBrand, collateralBrand) => {
   );
 };
 
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
-
 /**
  * @typedef {object} BookDataNotification
- *
- * @property {Ratio         | null}      startPrice identifies the priceAuthority and price
- * @property {Ratio         | null}      currentPriceLevel the price at the current auction tier
- * @property {Amount<'nat'> | null}      startProceedsGoal The proceeds the sellers were targeting to raise
- * @property {Amount<'nat'> | null}      remainingProceedsGoal The remainder of
- *     the proceeds the sellers were targeting to raise
- * @property {Amount<'nat'> | undefined} proceedsRaised The proceeds raised so far in the auction
- * @property {Amount<'nat'>}             startCollateral How much collateral was
- *    available for sale at the start. (If more is deposited later, it'll be
- *    added in.)
- * @property {Amount<'nat'> | null}      collateralAvailable The amount of collateral remaining
+ * @property {Ratio | null} startPrice identifies the priceAuthority and price
+ * @property {Ratio | null} currentPriceLevel the price at the current auction
+ *   tier
+ * @property {Amount<'nat'> | null} startProceedsGoal The proceeds the sellers
+ *   were targeting to raise
+ * @property {Amount<'nat'> | null} remainingProceedsGoal The remainder of the
+ *   proceeds the sellers were targeting to raise
+ * @property {Amount<'nat'> | undefined} proceedsRaised The proceeds raised so
+ *   far in the auction
+ * @property {Amount<'nat'>} startCollateral How much collateral was available
+ *   for sale at the start. (If more is deposited later, it'll be added in.)
+ * @property {Amount<'nat'> | null} collateralAvailable The amount of collateral
+ *   remaining
  */
 
 /**
@@ -109,6 +119,8 @@ export const makeOfferSpecShape = (bidBrand, collateralBrand) => {
 export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
   const makeScaledBidBook = prepareScaledBidBook(baggage);
   const makePriceBook = preparePriceBook(baggage);
+  // Brands that have or are making active quoteNotifier Observers
+  const observedBrands = new Set();
 
   const AuctionBookStateShape = harden({
     collateralBrand: M.any(),
@@ -118,7 +130,7 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
     bidHoldingSeat: M.any(),
     bidAmountShape: M.any(),
     priceAuthority: M.any(),
-    updatingOracleQuote: M.any(),
+    updatingOracleQuote: M.or(RatioShape, M.null()),
     bookDataKit: M.any(),
     priceBook: M.any(),
     scaledBidBook: M.any(),
@@ -141,11 +153,6 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
      */
     (bidBrand, collateralBrand, pAuthority, node) => {
       assertAllDefined({ bidBrand, collateralBrand, pAuthority });
-      const zeroBid = makeEmpty(bidBrand);
-      const zeroRatio = makeRatioFromAmounts(
-        zeroBid,
-        AmountMath.make(collateralBrand, 1n),
-      );
 
       // these don't have to be durable, since we're currently assuming that upgrade
       // from a quiescent state is sufficient. When the auction is quiescent, there
@@ -168,9 +175,7 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
 
       const bookDataKit = makeRecorderKit(
         node,
-        /** @type {import('@agoric/zoe/src/contractSupport/recorder.js').TypedMatcher<BookDataNotification>} */ (
-          M.any()
-        ),
+        /** @type {TypedPattern<BookDataNotification>} */ (M.any()),
       );
 
       return {
@@ -182,7 +187,7 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
         bidAmountShape,
 
         priceAuthority: pAuthority,
-        updatingOracleQuote: zeroRatio,
+        updatingOracleQuote: /** @type {Ratio | null} */ (null),
 
         bookDataKit,
 
@@ -231,8 +236,8 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
     {
       helper: {
         /**
-         * remove the key from the appropriate book, indicated by whether the price
-         * is defined.
+         * remove the key from the appropriate book, indicated by whether the
+         * price is defined.
          *
          * @param {string} key
          * @param {Ratio | undefined} price
@@ -247,8 +252,8 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
         },
 
         /**
-         * Update the entry in the appropriate book, indicated by whether the price
-         * is defined.
+         * Update the entry in the appropriate book, indicated by whether the
+         * price is defined.
          *
          * @param {string} key
          * @param {Amount} collateralSold
@@ -264,7 +269,8 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
         },
 
         /**
-         * Settle with seat. The caller is responsible for updating the book, if any.
+         * Settle with seat. The caller is responsible for updating the book, if
+         * any.
          *
          * @param {ZCFSeat} seat
          * @param {Amount<'nat'>} collateralWanted
@@ -278,46 +284,36 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
             return makeEmpty(collateralBrand);
           }
 
-          /** @type {Amount<'nat'>} */
-          const initialCollateralTarget = AmountMath.min(
-            collateralWanted,
-            collateralAvailable,
-          );
-
           const { curAuctionPrice, bidHoldingSeat, remainingProceedsGoal } =
             this.state;
           curAuctionPrice !== null ||
             Fail`auctionPrice must be set before each round`;
           assert(curAuctionPrice);
 
-          const proceedsNeeded = ceilMultiplyBy(
-            initialCollateralTarget,
-            curAuctionPrice,
-          );
-          if (AmountMath.isEmpty(proceedsNeeded)) {
+          const { proceedsExpected, proceedsTarget, collateralTarget } =
+            amountsToSettle(
+              {
+                bidAlloc,
+                collateralWanted,
+                collateralAvailable,
+                curAuctionPrice,
+                remainingProceedsGoal,
+              },
+              trace,
+            );
+
+          if (proceedsExpected === null) {
             seat.fail(Error('price fell to zero'));
             return makeEmpty(collateralBrand);
           }
 
-          const minProceedsTarget = AmountMath.min(proceedsNeeded, bidAlloc);
-          const proceedsLimit = remainingProceedsGoal
-            ? AmountMath.min(remainingProceedsGoal, minProceedsTarget)
-            : minProceedsTarget;
-          const isRaiseLimited =
-            remainingProceedsGoal ||
-            !AmountMath.isGTE(proceedsLimit, proceedsNeeded);
-
-          const [proceedsTarget, collateralTarget] = isRaiseLimited
-            ? [proceedsLimit, floorDivideBy(proceedsLimit, curAuctionPrice)]
-            : [minProceedsTarget, initialCollateralTarget];
-
+          // check that the requested amount could be satisfied
           const { Collateral } = seat.getProposal().want;
           if (Collateral && AmountMath.isGTE(Collateral, collateralTarget)) {
             seat.exit('unable to satisfy want');
           }
 
-          atomicRearrange(
-            zcf,
+          zcf.atomicRearrange(
             harden([
               [collateralSeat, seat, { Collateral: collateralTarget }],
               [seat, bidHoldingSeat, { Bid: proceedsTarget }],
@@ -331,7 +327,7 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
             );
           }
 
-          trace('settle', {
+          trace('settled', {
             collateralTarget,
             proceedsTarget,
             remainingProceedsGoal: this.state.remainingProceedsGoal,
@@ -341,15 +337,16 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
         },
 
         /**
-         *  Accept an offer expressed as a price. If the auction is active, attempt to
-         *  buy collateral. If any of the offer remains add it to the book.
+         * Accept an offer expressed as a price. If the auction is active,
+         * attempt to buy collateral. If any of the offer remains add it to the
+         * book.
          *
-         *  @param {ZCFSeat} seat
-         *  @param {Ratio} price
-         *  @param {Amount<'nat'>} maxBuy
-         *  @param {object} opts
-         *  @param {boolean} opts.trySettle
-         *  @param {boolean} [opts.exitAfterBuy]
+         * @param {ZCFSeat} seat
+         * @param {Ratio} price
+         * @param {Amount<'nat'>} maxBuy
+         * @param {object} opts
+         * @param {boolean} opts.trySettle
+         * @param {boolean} [opts.exitAfterBuy]
          */
         acceptPriceOffer(
           seat,
@@ -388,16 +385,16 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
         },
 
         /**
-         *  Accept an offer expressed as a discount (or markup). If the auction is
-         *  active, attempt to buy collateral. If any of the offer remains add it to
-         *  the book.
+         * Accept an offer expressed as a discount (or markup). If the auction
+         * is active, attempt to buy collateral. If any of the offer remains add
+         * it to the book.
          *
-         *  @param {ZCFSeat} seat
-         *  @param {Ratio} bidScaling
-         *  @param {Amount<'nat'>} maxBuy
-         *  @param {object} opts
-         *  @param {boolean} opts.trySettle
-         *  @param {boolean} [opts.exitAfterBuy]
+         * @param {ZCFSeat} seat
+         * @param {Ratio} bidScaling
+         * @param {Amount<'nat'>} maxBuy
+         * @param {object} opts
+         * @param {boolean} opts.trySettle
+         * @param {boolean} [opts.exitAfterBuy]
          */
         acceptScaledBidOffer(
           seat,
@@ -460,16 +457,72 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
           });
           return state.bookDataKit.recorder.write(bookData);
         },
+        // Ensure that there is an observer monitoring the quoteNotifier. We
+        // assume that all failure modes for quoteNotifier eventually lead to
+        // fail or finish.
+        ensureQuoteNotifierObserved() {
+          const { state, facets } = this;
+          const { collateralBrand, bidBrand, priceAuthority } = state;
+
+          if (observedBrands.has(collateralBrand)) {
+            return;
+          }
+          observedBrands.add(collateralBrand);
+          trace('observing');
+
+          const quoteNotifierP = E(priceAuthority).makeQuoteNotifier(
+            AmountMath.make(collateralBrand, QUOTE_SCALE),
+            bidBrand,
+          );
+
+          void E.when(
+            quoteNotifierP,
+            quoteNotifier =>
+              observeNotifier(quoteNotifier, {
+                updateState: quote => {
+                  trace(
+                    `BOOK notifier ${priceFrom(quote).numerator.value}/${
+                      priceFrom(quote).denominator.value
+                    }`,
+                  );
+                  state.updatingOracleQuote = priceFrom(quote);
+                },
+                fail: reason => {
+                  trace(
+                    `Failure from quoteNotifier (${reason}) setting to null`,
+                  );
+                  // lack of quote will trigger restart
+                  state.updatingOracleQuote = null;
+                  observedBrands.delete(collateralBrand);
+                },
+                finish: done => {
+                  trace(
+                    `quoteNotifier invoked finish(${done}). setting quote to null`,
+                  );
+                  // lack of quote will trigger restart
+                  state.updatingOracleQuote = null;
+                  observedBrands.delete(collateralBrand);
+                },
+              }),
+            e => {
+              trace('makeQuoteNotifier failed, resetting', e);
+              state.updatingOracleQuote = null;
+              observedBrands.delete(collateralBrand);
+            },
+          );
+
+          void facets.helper.publishBookData();
+        },
       },
       self: {
         /**
          * @param {Amount<'nat'>} assetAmount
          * @param {ZCFSeat} sourceSeat
          * @param {Amount<'nat'>} [proceedsGoal] an amount that the depositor
-         *    would like to raise. The auction is requested to not sell more
-         *    collateral than required to raise that much. The auctioneer might
-         *    sell more if there is more than one supplier of collateral, and
-         *    they request inconsistent limits.
+         *   would like to raise. The auction is requested to not sell more
+         *   collateral than required to raise that much. The auctioneer might
+         *   sell more if there is more than one supplier of collateral, and
+         *   they request inconsistent limits.
          */
         addAssets(assetAmount, sourceSeat, proceedsGoal) {
           const { state, facets } = this;
@@ -531,8 +584,7 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
             state.startProceedsGoal = nextProceedsGoal;
           }
 
-          atomicRearrange(
-            zcf,
+          zcf.atomicRearrange(
             harden([[sourceSeat, collateralSeat, { Collateral: assetAmount }]]),
           );
 
@@ -547,9 +599,12 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
 
           trace(this.state.collateralBrand, 'settleAtNewRate', reduction);
           const { capturedPriceForRound, priceBook, scaledBidBook } = state;
-          capturedPriceForRound !== null ||
-            Fail`price must be captured before auction starts`;
-          assert(capturedPriceForRound);
+          if (!capturedPriceForRound) {
+            console.error(
+              `⚠️No price for ${this.state.collateralBrand}, skipping auction.`,
+            );
+            return;
+          }
 
           state.curAuctionPrice = multiplyRatios(
             reduction,
@@ -561,20 +616,14 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
           const pricedOffers = priceBook.offersAbove(curAuctionPrice);
           const scaledBidOffers = scaledBidBook.offersAbove(reduction);
 
-          const compareValues = (v1, v2) => {
-            if (v1 < v2) {
-              return -1;
-            } else if (v1 === v2) {
-              return 0;
-            } else {
-              return 1;
-            }
-          };
-          trace(`settling`, pricedOffers.length, scaledBidOffers.length);
           // requested price or BidScaling gives no priority beyond specifying which
           // round the order will be serviced in.
           const prioritizedOffers = [...pricedOffers, ...scaledBidOffers].sort(
-            (a, b) => compareValues(a[1].seqNum, b[1].seqNum),
+            (a, b) => Number(a[1].seqNum - b[1].seqNum),
+          );
+
+          trace(
+            `settling ${prioritizedOffers.length} offers at ${curAuctionPrice} (priced ${pricedOffers.length}, scaled ${scaledBidOffers.length}) `,
           );
 
           const { remainingProceedsGoal } = state;
@@ -619,6 +668,13 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
           const { facets, state } = this;
 
           trace(`capturing oracle price `, state.updatingOracleQuote);
+          if (!state.updatingOracleQuote) {
+            // if the price feed has died (or hasn't been started for this
+            // incarnation), (re)start it.
+            facets.helper.ensureQuoteNotifierObserved();
+            return;
+          }
+
           state.capturedPriceForRound = state.updatingOracleQuote;
           void facets.helper.publishBookData();
         },
@@ -718,46 +774,21 @@ export const prepareAuctionBook = (baggage, zcf, makeRecorderKit) => {
       finish: ({ state, facets }) => {
         const { collateralBrand, bidBrand, priceAuthority } = state;
         assertAllDefined({ collateralBrand, bidBrand, priceAuthority });
-        void E.when(
-          E(collateralBrand).getDisplayInfo(),
-          ({ decimalPlaces = DEFAULT_DECIMALS }) => {
-            // TODO(#6946) use this to keep a current price that can be published in state.
-            const quoteNotifier = E(priceAuthority).makeQuoteNotifier(
-              AmountMath.make(collateralBrand, 10n ** BigInt(decimalPlaces)),
-              bidBrand,
-            );
-            void observeNotifier(quoteNotifier, {
-              updateState: quote => {
-                trace(
-                  `BOOK notifier ${priceFrom(quote).numerator.value}/${
-                    priceFrom(quote).denominator.value
-                  }`,
-                );
-                state.updatingOracleQuote = priceFrom(quote);
-              },
-              fail: reason => {
-                throw Error(
-                  `auction observer of ${collateralBrand} failed: ${reason}`,
-                );
-              },
-              finish: done => {
-                throw Error(
-                  `auction observer for ${collateralBrand} died: ${done}`,
-                );
-              },
-            });
-          },
-        );
-        void facets.helper.publishBookData();
+
+        facets.helper.ensureQuoteNotifierObserved();
       },
       stateShape: AuctionBookStateShape,
     },
   );
 
-  /** @type {(...args: Parameters<typeof makeAuctionBookKit>) => ReturnType<typeof makeAuctionBookKit>['self']} */
+  /**
+   * @type {(
+   *   ...args: Parameters<typeof makeAuctionBookKit>
+   * ) => ReturnType<typeof makeAuctionBookKit>['self']}
+   */
   const makeAuctionBook = (...args) => makeAuctionBookKit(...args).self;
   return makeAuctionBook;
 };
 harden(prepareAuctionBook);
 
-/** @typedef {ReturnType<ReturnType<typeof prepareAuctionBook>>} AuctionBook */
+/** @typedef {EReturn<EReturn<typeof prepareAuctionBook>>} AuctionBook */

package/src/auction/auctionMath.d.ts

@@ -0,0 +1,17 @@
+export function amountsToSettle({ bidAlloc, collateralWanted, collateralAvailable, curAuctionPrice, remainingProceedsGoal, }: {
+    bidAlloc: Amount<"nat">;
+    collateralWanted: Amount<"nat">;
+    collateralAvailable: Amount<"nat">;
+    curAuctionPrice: Ratio;
+    remainingProceedsGoal: Amount<"nat"> | null;
+}, log?: (...msgs: any[]) => void): {
+    proceedsExpected: null;
+    proceedsTarget?: undefined;
+    collateralTarget?: undefined;
+} | {
+    proceedsExpected: import("@agoric/ertp").NatAmount;
+    proceedsTarget: import("@agoric/ertp").NatAmount;
+    collateralTarget: import("@agoric/ertp").NatAmount;
+};
+import type { Amount } from '@agoric/ertp/src/types.js';
+//# sourceMappingURL=auctionMath.d.ts.map

package/src/auction/auctionMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auctionMath.d.ts","sourceRoot":"","sources":["auctionMath.js"],"names":[],"mappings":"AAoBO,8HARJ;IAAyB,QAAQ,EAAzB,OAAO,KAAK,CAAC;IACI,gBAAgB,EAAjC,OAAO,KAAK,CAAC;IACI,mBAAmB,EAApC,OAAO,KAAK,CAAC;IACJ,eAAe,EAAxB,KAAK;IACmB,qBAAqB,EAA7C,OAAO,KAAK,CAAC,GAAG,IAAI;CAE5B,QAAQ,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;;;;;EA6DlC;4BAxEwB,2BAA2B"}

package/src/auction/auctionMath.js

@@ -0,0 +1,81 @@
+import { AmountMath } from '@agoric/ertp';
+import {
+  ceilMultiplyBy,
+  floorDivideBy,
+} from '@agoric/zoe/src/contractSupport/index.js';
+
+/**
+ * @import {Amount} from '@agoric/ertp/src/types.js';
+ */
+
+/**
+ * @param {object} p
+ * @param {Amount<'nat'>} p.bidAlloc current allocation of the bidding seat
+ * @param {Amount<'nat'>} p.collateralWanted want of the offer
+ * @param {Amount<'nat'>} p.collateralAvailable available to auction
+ * @param {Ratio} p.curAuctionPrice current auction price
+ * @param {Amount<'nat'> | null} p.remainingProceedsGoal amount still needing
+ *   liquidating over multiple rounds; null indicates no limit
+ * @param {(...msgs: any[]) => void} [log]
+ */
+export const amountsToSettle = (
+  {
+    bidAlloc,
+    collateralWanted,
+    collateralAvailable,
+    curAuctionPrice,
+    remainingProceedsGoal,
+  },
+  log = () => {},
+) => {
+  log('amountsToSettle', {
+    bidAlloc,
+    collateralWanted,
+    collateralAvailable,
+    curAuctionPrice,
+    remainingProceedsGoal,
+  });
+  const initialCollateralTarget = AmountMath.min(
+    collateralWanted,
+    collateralAvailable,
+  );
+
+  const proceedsExpected = ceilMultiplyBy(
+    initialCollateralTarget,
+    curAuctionPrice,
+  );
+  if (AmountMath.isEmpty(proceedsExpected)) {
+    return { proceedsExpected: null };
+  }
+
+  const targetByProceeds = proceedsLimit =>
+    AmountMath.min(
+      collateralAvailable,
+      floorDivideBy(proceedsLimit, curAuctionPrice),
+    );
+
+  const [proceedsTarget, collateralTarget] = (() => {
+    // proceeds cannot exceed what is needed or being offered
+    const proceedsBidded = AmountMath.min(proceedsExpected, bidAlloc);
+    if (remainingProceedsGoal) {
+      const goalProceeds = AmountMath.min(
+        remainingProceedsGoal,
+        proceedsBidded,
+      );
+      return [goalProceeds, targetByProceeds(goalProceeds)];
+    } else if (AmountMath.isGTE(proceedsBidded, proceedsExpected)) {
+      // initial collateral suffices
+      return [proceedsBidded, initialCollateralTarget];
+    } else {
+      return [proceedsBidded, targetByProceeds(proceedsBidded)];
+    }
+  })();
+
+  assert(
+    AmountMath.isGTE(collateralAvailable, collateralTarget),
+    'target cannot exceed available',
+  );
+
+  return { proceedsExpected, proceedsTarget, collateralTarget };
+};
+harden(amountsToSettle);