@agoric/zoe 0.27.0-upgrade-20-dev-ef71cfd.0 → 0.27.0-upgrade-19-devnet-dev-5428c4d.0

package/src/contractSupport/index.js

@@ -8,7 +8,7 @@ export {
   calcSecondaryRequired,
 } from './bondingCurves.js';
 
-export { natSafeMath } from '@agoric/ertp/src/safeMath.js';
+export { natSafeMath } from './safeMath.js';
 
 export { makeStateMachine } from './stateMachine.js';
 
@@ -34,7 +34,24 @@ export {
   offerTo,
 } from './zoeHelpers.js';
 
-export * from '@agoric/ertp/src/ratio.js';
+export {
+  makeRatio,
+  makeRatioFromAmounts,
+  floorMultiplyBy,
+  floorDivideBy,
+  ceilMultiplyBy,
+  ceilDivideBy,
+  assertIsRatio,
+  invertRatio,
+  oneMinus,
+  addRatios,
+  multiplyRatios,
+  ratiosSame,
+  quantize,
+  ratioGTE,
+  subtractRatios,
+  ratioToNumber,
+} from './ratio.js';
 
 export * from './durability.js';
 export * from './prepare-ownable.js';

package/src/contractSupport/priceAuthorityInitial.d.ts

@@ -1,6 +1,4 @@
 export function makeInitialTransform(priceOutPerIn: Ratio, priceAuthority: PriceAuthority, quoteMint: ERef<Mint<"set", PriceDescription>>, brandIn: Brand<"nat">, brandOut: Brand<"nat">): PriceAuthority;
 import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
 import type { PriceDescription } from '@agoric/zoe/tools/types.js';
-import type { Mint } from '@agoric/ertp';
-import type { Brand } from '@agoric/ertp';
 //# sourceMappingURL=priceAuthorityInitial.d.ts.map

package/src/contractSupport/priceAuthorityInitial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"priceAuthorityInitial.d.ts","sourceRoot":"","sources":["priceAuthorityInitial.js"],"names":[],"mappings":"AA+BO,oDAPI,KAAK,kBACL,cAAc,aACd,IAAI,CAAC,KAAK,KAAK,EAAE,gBAAgB,CAAC,CAAC,WACnC,MAAM,KAAK,CAAC,YACZ,MAAM,KAAK,CAAC,GACV,cAAc,CAyF1B;oCAvG4F,4BAA4B;sCAA5B,4BAA4B;0BAFnF,cAAc;2BAAd,cAAc"}
+{"version":3,"file":"priceAuthorityInitial.d.ts","sourceRoot":"","sources":["priceAuthorityInitial.js"],"names":[],"mappings":"AA6BO,oDAPI,KAAK,kBACL,cAAc,aACd,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,WACnC,KAAK,CAAC,KAAK,CAAC,YACZ,KAAK,CAAC,KAAK,CAAC,GACV,cAAc,CAyF1B;oCAvG4F,4BAA4B;sCAA5B,4BAA4B"}

package/src/contractSupport/priceAuthorityInitial.js

@@ -7,12 +7,10 @@ import { Far } from '@endo/marshal';
 import { makeNotifier } from '@agoric/notifier';
 import { AmountMath } from '@agoric/ertp';
 
-import { multiplyBy } from '@agoric/ertp/src/ratio.js';
+import { multiplyBy } from './ratio.js';
 import { mintQuote } from './priceAuthorityTransform.js';
 
 /**
- * @import {Amount, Brand, Mint} from '@agoric/ertp';
- * @import {Notifier} from '@agoric/notifier';
  * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
  */
 

package/src/contractSupport/ratio.d.ts

@@ -0,0 +1,37 @@
+export function assertIsRatio(ratio: any): void;
+export function makeRatio(numerator: bigint, numeratorBrand: Brand, denominator?: bigint, denominatorBrand?: Brand): Ratio;
+export function makeRatioFromAmounts(numeratorAmount: Amount, denominatorAmount: Amount): Ratio;
+/** @type {ScaleAmount} */
+export const floorMultiplyBy: ScaleAmount;
+/** @type {ScaleAmount} */
+export const ceilMultiplyBy: ScaleAmount;
+/** @type {ScaleAmount} */
+export const multiplyBy: ScaleAmount;
+/**
+ * Divide the amount by the ratio, truncating the remainder.
+ * @type {ScaleAmount}
+ */
+export const floorDivideBy: ScaleAmount;
+/**
+ * Divide the amount by the ratio, rounding up the remainder.
+ * @type {ScaleAmount}
+ */
+export const ceilDivideBy: ScaleAmount;
+/**
+ * Divide the amount by the ratio, rounding to nearest with ties to even (aka Banker's Rounding) as in IEEE 754 default rounding.
+ * @type {ScaleAmount}
+ */
+export const divideBy: ScaleAmount;
+export function invertRatio(ratio: Ratio): Ratio;
+export function addRatios(left: Ratio, right: Ratio): Ratio;
+export function subtractRatios(left: Ratio, right: Ratio): Ratio;
+export function multiplyRatios(left: Ratio, right: Ratio): Ratio;
+export function oneMinus(ratio: Ratio): Ratio;
+export function ratioGTE(left: Ratio, right: Ratio): boolean;
+export function ratiosSame(left: Ratio, right: Ratio): boolean;
+export function quantize(ratio: Ratio, newDen: bigint): Ratio;
+export function parseRatio(numeric: ParsableNumber, numeratorBrand: Brand, denominatorBrand?: Brand): Ratio;
+export function assertParsableNumber(specimen: unknown): asserts specimen is ParsableNumber;
+export function ratioToNumber(ratio: Ratio): number;
+export type ParsableNumber = bigint | number | string;
+//# sourceMappingURL=ratio.d.ts.map

package/src/contractSupport/ratio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ratio.d.ts","sourceRoot":"","sources":["ratio.js"],"names":[],"mappings":"AAwCO,gDAcN;AASM,qCANI,MAAM,kBACN,KAAK,gBACL,MAAM,qBACN,KAAK,GACH,KAAK,CAejB;AAOM,sDAJI,MAAM,qBACN,MAAM,GACJ,KAAK,CAYjB;AA2BD,0BAA0B;AAC1B,8BADW,WAAW,CAGpB;AAEF,0BAA0B;AAC1B,6BADW,WAAW,CAGpB;AAEF,0BAA0B;AAC1B,yBADW,WAAW,CAGpB;AA2BF;;;GAGG;AACH,4BAFU,WAAW,CAInB;AAEF;;;GAGG;AACH,2BAFU,WAAW,CAInB;AAEF;;;GAGG;AACH,uBAFU,WAAW,CAInB;AAMK,mCAHI,KAAK,GACH,KAAK,CAWjB;AAOM,gCAJI,KAAK,SACL,KAAK,GACH,KAAK,CAwBjB;AAOM,qCAJI,KAAK,SACL,KAAK,GACH,KAAK,CAmBjB;AAOM,qCAJI,KAAK,SACL,KAAK,GACH,KAAK,CA8BjB;AAQM,gCAHI,KAAK,GACH,KAAK,CAcjB;AAOM,+BAJI,KAAK,SACL,KAAK,GACH,OAAO,CAkBnB;AASM,iCAJI,KAAK,SACL,KAAK,GACH,OAAO,CAOnB;AAUM,gCAJI,KAAK,UACL,MAAM,GACJ,KAAK,CAiBjB;AAaM,oCALI,cAAc,kBACd,KAAK,qBACL,KAAK,GACH,KAAK,CAmBjB;AAMM,+CAHI,OAAO,GACL,QAAQ,QAAQ,IAAI,cAAc,CAK9C;AAQM,qCAHI,KAAK,GACH,MAAM,CAMlB;6BAhDa,MAAM,GAAG,MAAM,GAAG,MAAM"}

package/src/contractSupport/ratio.js

@@ -0,0 +1,419 @@
+/// <reference path="./types-ambient.js" />
+import { q, Fail } from '@endo/errors';
+import { AmountMath } from '@agoric/ertp';
+import { assertRecord } from '@endo/marshal';
+import { isNat } from '@endo/nat';
+
+import { natSafeMath } from './safeMath.js';
+
+const { multiply, floorDivide, ceilDivide, bankersDivide, add, subtract } =
+  natSafeMath;
+
+// make a Ratio, which represents a fraction. It is a pass-by-copy record.
+//
+// The natural syntax for the most common operations we want to support
+// are Amount * Ratio and Amount / Ratio. Since the operations want to adhere to
+// the ratio rather than the amount, we settled on a calling convention of
+// [ceil|floor]MultiplyBy(Amount, Ratio) and [ceil|floor]DivideBy(Amount, Ratio)
+//
+// The most common kind of Ratio can be applied to Amounts of a particular
+// brand, and produces results of the same brand. This represents a multiplier
+// that is only applicable to that brand. The less common kind of Ratio can be
+// applied to one particular brand of amounts, and produces results of another
+// particular brand. This represents some kind of exchange rate. The
+// brand-checking helps us ensure that normal Ratios aren't applied to amounts
+// of the wrong brand, and that exchange rates are only used in the appropriate
+// direction.
+//
+// Since the ratios are represented by a numerator and a denominator, every
+// multiplication or division operation that produces an amount ends with a
+// division of the underlying bigints, and integer division requires a mode
+// of [rounding to integer](https://en.wikipedia.org/wiki/Rounding#Rounding_to_integer).
+// Because `Ratio` only work with Natural numbers, just three modes suffice:
+//   - floor rounds down
+//   - ceil rounds up
+//   - default (without prefix) minimizes bias by rounding half to even
+
+const PERCENT = 100n;
+
+const ratioPropertyNames = ['numerator', 'denominator'];
+
+export const assertIsRatio = ratio => {
+  assertRecord(ratio, 'ratio');
+  const keys = Object.keys(ratio);
+  keys.length === 2 || Fail`Ratio ${ratio} must be a record with 2 fields.`;
+  for (const name of keys) {
+    ratioPropertyNames.includes(name) ||
+      Fail`Parameter must be a Ratio record, but ${ratio} has ${q(name)}`;
+  }
+  const numeratorValue = ratio.numerator.value;
+  const denominatorValue = ratio.denominator.value;
+  isNat(numeratorValue) ||
+    Fail`The numerator value must be a NatValue, not ${numeratorValue}`;
+  isNat(denominatorValue) ||
+    Fail`The denominator value must be a NatValue, not ${denominatorValue}`;
+};
+
+/**
+ * @param {bigint} numerator
+ * @param {Brand} numeratorBrand
+ * @param {bigint} [denominator] The default denominator is 100
+ * @param {Brand} [denominatorBrand] The default is to reuse the numeratorBrand
+ * @returns {Ratio}
+ */
+export const makeRatio = (
+  numerator,
+  numeratorBrand,
+  denominator = PERCENT,
+  denominatorBrand = numeratorBrand,
+) => {
+  denominator > 0n ||
+    Fail`No infinite ratios! Denominator was 0 ${q(denominatorBrand)}`;
+
+  return harden({
+    numerator: AmountMath.make(numeratorBrand, numerator),
+    denominator: AmountMath.make(denominatorBrand, denominator),
+  });
+};
+
+/**
+ * @param {Amount} numeratorAmount
+ * @param {Amount} denominatorAmount
+ * @returns {Ratio}
+ */
+export const makeRatioFromAmounts = (numeratorAmount, denominatorAmount) => {
+  AmountMath.coerce(numeratorAmount.brand, numeratorAmount);
+  AmountMath.coerce(denominatorAmount.brand, denominatorAmount);
+  return makeRatio(
+    // @ts-expect-error value can be any AmountValue but makeRatio() supports only bigint
+    numeratorAmount.value,
+    numeratorAmount.brand,
+    denominatorAmount.value,
+    denominatorAmount.brand,
+  );
+};
+
+/**
+ * @param {Amount<'nat'>} amount
+ * @param {Ratio} ratio
+ * @param {*} divideOp
+ * @returns {Amount<'nat'>}
+ */
+const multiplyHelper = (amount, ratio, divideOp) => {
+  AmountMath.coerce(amount.brand, amount);
+  assertIsRatio(ratio);
+  amount.brand === ratio.denominator.brand ||
+    Fail`amount's brand ${q(amount.brand)} must match ratio's denominator ${q(
+      ratio.denominator.brand,
+    )}`;
+
+  return /** @type {Amount<'nat'>} */ (
+    AmountMath.make(
+      ratio.numerator.brand,
+      divideOp(
+        multiply(amount.value, ratio.numerator.value),
+        ratio.denominator.value,
+      ),
+    )
+  );
+};
+
+/** @type {ScaleAmount} */
+export const floorMultiplyBy = (amount, ratio) => {
+  return multiplyHelper(amount, ratio, floorDivide);
+};
+
+/** @type {ScaleAmount} */
+export const ceilMultiplyBy = (amount, ratio) => {
+  return multiplyHelper(amount, ratio, ceilDivide);
+};
+
+/** @type {ScaleAmount} */
+export const multiplyBy = (amount, ratio) => {
+  return multiplyHelper(amount, ratio, bankersDivide);
+};
+
+/**
+ * @param {Amount<'nat'>} amount
+ * @param {Ratio} ratio
+ * @param {*} divideOp
+ * @returns {Amount<'nat'>}
+ */
+const divideHelper = (amount, ratio, divideOp) => {
+  AmountMath.coerce(amount.brand, amount);
+  assertIsRatio(ratio);
+  amount.brand === ratio.numerator.brand ||
+    Fail`amount's brand ${q(amount.brand)} must match ratio's numerator ${q(
+      ratio.numerator.brand,
+    )}`;
+
+  return /** @type {Amount<'nat'>} */ (
+    AmountMath.make(
+      ratio.denominator.brand,
+      divideOp(
+        multiply(amount.value, ratio.denominator.value),
+        ratio.numerator.value,
+      ),
+    )
+  );
+};
+
+/**
+ * Divide the amount by the ratio, truncating the remainder.
+ * @type {ScaleAmount}
+ */
+export const floorDivideBy = (amount, ratio) => {
+  return divideHelper(amount, ratio, floorDivide);
+};
+
+/**
+ * Divide the amount by the ratio, rounding up the remainder.
+ * @type {ScaleAmount}
+ */
+export const ceilDivideBy = (amount, ratio) => {
+  return divideHelper(amount, ratio, ceilDivide);
+};
+
+/**
+ * Divide the amount by the ratio, rounding to nearest with ties to even (aka Banker's Rounding) as in IEEE 754 default rounding.
+ * @type {ScaleAmount}
+ */
+export const divideBy = (amount, ratio) => {
+  return divideHelper(amount, ratio, bankersDivide);
+};
+
+/**
+ * @param {Ratio} ratio
+ * @returns {Ratio}
+ */
+export const invertRatio = ratio => {
+  assertIsRatio(ratio);
+
+  return makeRatio(
+    /** @type {NatValue} */ (ratio.denominator.value),
+    ratio.denominator.brand,
+    /** @type {NatValue} */ (ratio.numerator.value),
+    ratio.numerator.brand,
+  );
+};
+
+/**
+ * @param {Ratio} left
+ * @param {Ratio} right
+ * @returns {Ratio}
+ */
+export const addRatios = (left, right) => {
+  assertIsRatio(right);
+  assertIsRatio(left);
+  left.numerator.brand === right.numerator.brand ||
+    Fail`numerator brands must match: ${q(left)} ${q(right)}`;
+  left.denominator.brand === right.denominator.brand ||
+    Fail`denominator brands must match: ${q(left)} ${q(right)}`;
+
+  // Simplifying the expression:
+  //  (and + bnd) / y d**2
+  //  (a + b) nd / y d**2
+  //  ((a + b) n / y d) * (d / d)
+  //  (a + b) n / yd
+  return makeRatio(
+    add(
+      multiply(left.numerator.value, right.denominator.value), // a nd
+      multiply(left.denominator.value, right.numerator.value), // b nd
+    ), // (a + b) nd
+    left.numerator.brand,
+    multiply(left.denominator.value, right.denominator.value), // y d**2
+    left.denominator.brand,
+  );
+};
+
+/**
+ * @param {Ratio} left
+ * @param {Ratio} right
+ * @returns {Ratio}
+ */
+export const subtractRatios = (left, right) => {
+  assertIsRatio(right);
+  assertIsRatio(left);
+  left.numerator.brand === right.numerator.brand ||
+    Fail`numerator brands must match: ${q(left)} ${q(right)}`;
+  left.denominator.brand === right.denominator.brand ||
+    Fail`denominator brands must match: ${q(left)} ${q(right)}`;
+
+  return makeRatio(
+    subtract(
+      multiply(left.numerator.value, right.denominator.value), // a nd
+      multiply(left.denominator.value, right.numerator.value), // b nd
+    ), // (a - b) nd
+    left.numerator.brand,
+    multiply(left.denominator.value, right.denominator.value), // y d**2
+    left.denominator.brand,
+  );
+};
+
+/**
+ * @param {Ratio} left
+ * @param {Ratio} right
+ * @returns {Ratio}
+ */
+export const multiplyRatios = (left, right) => {
+  assertIsRatio(right);
+  assertIsRatio(left);
+
+  const getRemainingBrands = () => {
+    // Prefer results that have the same brand as the left operand.
+    if (right.numerator.brand === right.denominator.brand) {
+      return [left.numerator.brand, left.denominator.brand];
+    }
+    if (right.numerator.brand === left.denominator.brand) {
+      return [left.numerator.brand, right.denominator.brand];
+    }
+    if (left.numerator.brand === right.denominator.brand) {
+      return [right.numerator.brand, left.denominator.brand];
+    }
+    if (left.numerator.brand === left.denominator.brand) {
+      return [right.numerator.brand, right.denominator.brand];
+    }
+    throw Fail`at least one brand must cancel out: ${q(left)} ${q(right)}`;
+  };
+
+  const [numeratorBrand, denominatorBrand] = getRemainingBrands();
+  return makeRatio(
+    multiply(left.numerator.value, right.numerator.value),
+    numeratorBrand,
+    multiply(left.denominator.value, right.denominator.value),
+    denominatorBrand,
+  );
+};
+
+/**
+ * If ratio is between 0 and 1, subtract from 1.
+ *
+ * @param {Ratio} ratio
+ * @returns {Ratio}
+ */
+export const oneMinus = ratio => {
+  assertIsRatio(ratio);
+  ratio.numerator.brand === ratio.denominator.brand ||
+    Fail`oneMinus only supports ratios with a single brand, but ${ratio.numerator.brand} doesn't match ${ratio.denominator.brand}`;
+  ratio.numerator.value <= ratio.denominator.value ||
+    Fail`Parameter must be less than or equal to 1: ${ratio.numerator.value}/${ratio.denominator.value}`;
+  return makeRatio(
+    subtract(ratio.denominator.value, ratio.numerator.value),
+    ratio.numerator.brand,
+    ratio.denominator.value,
+    ratio.numerator.brand,
+  );
+};
+
+/**
+ * @param {Ratio} left
+ * @param {Ratio} right
+ * @returns {boolean}
+ */
+export const ratioGTE = (left, right) => {
+  if (left.numerator.brand === right.numerator.brand) {
+    left.denominator.brand === right.denominator.brand ||
+      Fail`numerator brands match, but denominator brands don't: ${q(left)} ${q(
+        right,
+      )}`;
+  } else if (left.numerator.brand === left.denominator.brand) {
+    right.numerator.brand === right.denominator.brand ||
+      Fail`lefthand brands match, but righthand brands don't: ${q(left)} ${q(
+        right,
+      )}`;
+  }
+  return natSafeMath.isGTE(
+    multiply(left.numerator.value, right.denominator.value),
+    multiply(right.numerator.value, left.denominator.value),
+  );
+};
+
+/**
+ * True iff the ratios are the same values (equal or equivalant may return false)
+ *
+ * @param {Ratio} left
+ * @param {Ratio} right
+ * @returns {boolean}
+ */
+export const ratiosSame = (left, right) => {
+  return (
+    AmountMath.isEqual(left.numerator, right.numerator) &&
+    AmountMath.isEqual(left.denominator, right.denominator)
+  );
+};
+
+/**
+ * Make a new ratio with a smaller denominator that approximates the ratio. If
+ * the proposed denominator is larger than the current one, return the original.
+ *
+ * @param {Ratio} ratio
+ * @param {bigint} newDen
+ * @returns {Ratio}
+ */
+export const quantize = (ratio, newDen) => {
+  const oldDen = ratio.denominator.value;
+  const oldNum = ratio.numerator.value;
+  if (newDen > oldDen) {
+    return ratio;
+  }
+
+  const newNum =
+    newDen === oldDen ? oldNum : bankersDivide(oldNum * newDen, oldDen);
+  return makeRatio(
+    newNum,
+    ratio.numerator.brand,
+    newDen,
+    ratio.denominator.brand,
+  );
+};
+
+const NUMERIC_RE = /^(\d\d*)(?:\.(\d*))?$/;
+/** @typedef {bigint | number | string} ParsableNumber */
+
+/**
+ * Create a ratio from a given numeric value.
+ *
+ * @param {ParsableNumber} numeric
+ * @param {Brand} numeratorBrand
+ * @param {Brand} [denominatorBrand]
+ * @returns {Ratio}
+ */
+export const parseRatio = (
+  numeric,
+  numeratorBrand,
+  denominatorBrand = numeratorBrand,
+) => {
+  const match = `${numeric}`.match(NUMERIC_RE);
+  if (!match) {
+    throw Fail`Invalid numeric data: ${numeric}`;
+  }
+
+  const [_, whole, part = ''] = match;
+  return makeRatio(
+    BigInt(`${whole}${part}`),
+    numeratorBrand,
+    10n ** BigInt(part.length),
+    denominatorBrand,
+  );
+};
+
+/**
+ * @param {unknown} specimen
+ * @returns {asserts specimen is ParsableNumber}
+ */
+export const assertParsableNumber = specimen => {
+  const match = `${specimen}`.match(NUMERIC_RE);
+  match || Fail`Invalid numeric data: ${specimen}`;
+};
+
+/**
+ * Ratios might be greater or less than one.
+ *
+ * @param {Ratio} ratio
+ * @returns {number}
+ */
+export const ratioToNumber = ratio => {
+  const n = Number(ratio.numerator.value);
+  const d = Number(ratio.denominator.value);
+  return n / d;
+};

package/src/contractSupport/safeMath.d.ts

@@ -0,0 +1,11 @@
+export namespace natSafeMath {
+    let add: NatOp;
+    let subtract: NatOp;
+    let multiply: NatOp;
+    let floorDivide: NatOp;
+    let ceilDivide: NatOp;
+    let bankersDivide: NatOp;
+    let isGTE: (x: number | bigint, y: number | bigint) => boolean;
+}
+export type NatOp = (x: number | bigint, y: number | bigint) => NatValue;
+//# sourceMappingURL=safeMath.d.ts.map

package/src/contractSupport/safeMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeMath.d.ts","sourceRoot":"","sources":["safeMath.js"],"names":[],"mappings":";aAYa,KAAK;kBAGL,KAAK;kBAEL,KAAK;qBAEL,KAAK;oBAEL,KAAK;uBAQN,KAAK;eAiBJ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,KAAK,OAAO;;oBA5ClD,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,KAAK,QAAQ"}

package/src/contractSupport/safeMath.js

@@ -0,0 +1,49 @@
+import { Nat } from '@endo/nat';
+
+/** @typedef {(x: number | bigint, y: number | bigint) => NatValue} NatOp */
+
+/**
+ * These operations should be used for calculations with the values of
+ * basic fungible tokens.
+ *
+ * natSafeMath is designed to be used directly, and so it needs to
+ * validate the inputs, as well as the outputs when necessary.
+ */
+export const natSafeMath = harden({
+  /** @type {NatOp} */
+  // BigInts don't observably overflow
+  add: (x, y) => Nat(x) + Nat(y),
+  /** @type {NatOp} */
+  subtract: (x, y) => Nat(Nat(x) - Nat(y)),
+  /** @type {NatOp} */
+  multiply: (x, y) => Nat(x) * Nat(y),
+  /** @type {NatOp} */
+  floorDivide: (x, y) => Nat(x) / Nat(y),
+  /** @type {NatOp} */
+  ceilDivide: (x, y) => {
+    y = Nat(y);
+    return Nat(Nat(x) + y - 1n) / y;
+  },
+  /**
+   * Divide using half-to-even (aka Banker's Rounding) as in IEEE 774 default rounding
+   *
+   * @type {NatOp}
+   */
+  bankersDivide: (a, b) => {
+    a = Nat(a);
+    b = Nat(b);
+
+    const div = a / b;
+    const rem = a % b;
+    // if remainder > half divisor, should have rounded up instead of down, so add 1
+    if (rem * 2n > b) {
+      return div + 1n;
+    } else if (rem * 2n === b) {
+      // Add 1 if result is odd to get an even return value
+      if (div % 2n === 1n) return div + 1n;
+    }
+    return div;
+  },
+  /** @type {(x: number | bigint, y: number | bigint) => boolean} */
+  isGTE: (x, y) => Nat(x) >= Nat(y),
+});

package/src/contractSupport/types-ambient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":";UAOc,OAAO;;;;;WACP,mBAAmB;;;;;;;;YAEnB,mBAAmB;;;;;;;;;;;;;;;kBAqBtB,GAAG,YACH,OAAO,aACP,OAAO,KACL,MAAM;;;;;;;;;;uBAcR,GAAG,YACH,OAAO,aACP,OAAO,KACL,MAAM;;;;4BAIN,MAAM,CAAC,OAAO,EAAC,OAAO,CAAC;;;;;;qEAYvB,oBAAoB;;;;;;;mCAWtB,mBAAmB,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,SAAS,kBAC7E,oBAAoB;;eAKjB,MAAM,CAAC,KAAK,CAAC;iBACb,MAAM,CAAC,KAAK,CAAC;;4BAKhB,MAAM,CAAC,KAAK,CAAC,SACb,KAAK,KACH,MAAM,CAAC,KAAK,CAAC"}
+{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":";UAMc,OAAO;;;;;WACP,mBAAmB;;;;;;;;YAEnB,mBAAmB;;;;;;;;;;;;;;;kBAqBtB,GAAG,YACH,OAAO,aACP,OAAO,KACL,MAAM;;;;;;;;;;uBAcR,GAAG,YACH,OAAO,aACP,OAAO,KACL,MAAM;;;;4BAIN,MAAM,CAAC,OAAO,EAAC,OAAO,CAAC;;;;;;qEAYvB,oBAAoB;;;;;;;mCAWtB,mBAAmB,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,SAAS,kBAC7E,oBAAoB;;eAKjB,MAAM,CAAC,KAAK,CAAC;iBACb,MAAM,CAAC,KAAK,CAAC;;4BAKhB,MAAM,CAAC,KAAK,CAAC,SACb,KAAK,KACH,MAAM,CAAC,KAAK,CAAC"}

package/src/contractSupport/types-ambient.js

@@ -1,7 +1,6 @@
 // @jessie-check
 
 /// <reference types="ses" />
-/// <reference types="@agoric/zoe/exported" />
 
 /**
  * @typedef {object} SeatGainsLossesRecord

package/src/contractSupport/zoeHelpers.d.ts

@@ -1,6 +1,5 @@
 /**
  * @import {Pattern} from '@endo/patterns';
- * @import {ContractMeta, Invitation, Proposal, ZCF, ZCFSeat} from '@agoric/zoe';
  */
 export const defaultAcceptanceMsg: "The offer has been accepted. Once the contract has been completed, please check your payout";
 export function assertIssuerKeywords(zcf: any, expected: any): void;
@@ -15,7 +14,7 @@ export function assertNatAssetKind(zcf: any, brand: any): void;
 export const depositToSeatSuccessMsg: "Deposit and reallocation successful.";
 export function depositToSeat(zcf: ZCF, recipientSeat: ZCFSeat, amounts: AmountKeywordRecord, payments: PaymentPKeywordRecord): Promise<string>;
 export function withdrawFromSeat(zcf: ZCF, seat: ZCFSeat, amounts: AmountKeywordRecord): Promise<PaymentPKeywordRecord>;
-export function saveAllIssuers(zcf: ZCF, issuerKeywordRecord?: IssuerKeywordRecord): Promise<(ZoeIssuerRecord<any, import("@endo/patterns").Key> | undefined)[]>;
+export function saveAllIssuers(zcf: ZCF, issuerKeywordRecord?: IssuerKeywordRecord): Promise<(IssuerRecord<any, import("@endo/patterns").Key> | undefined)[]>;
 /** @type {MapKeywords} */
 export const mapKeywords: MapKeywords;
 export function offerTo<Args extends unknown, Result extends unknown>(zcf: ZCF, invitation: ERef<Invitation<Result, Args>>, keywordMapping: KeywordKeywordRecord | undefined, proposal: Proposal, fromSeat: ZCFSeat, toSeat?: ZCFSeat, offerArgs?: Args): Promise<{
@@ -31,9 +30,5 @@ export type ExpectedRecord = {
     give?: Record<string, null> | undefined;
     exit?: Partial<Record<never, null>> | undefined;
 };
-import type { ZCFSeat } from '@agoric/zoe';
 import type { Pattern } from '@endo/patterns';
-import type { ZCF } from '@agoric/zoe';
-import type { Invitation } from '@agoric/zoe';
-import type { Proposal } from '@agoric/zoe';
 //# sourceMappingURL=zoeHelpers.d.ts.map

package/src/contractSupport/zoeHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zoeHelpers.d.ts","sourceRoot":"","sources":["zoeHelpers.js"],"names":[],"mappings":"AASA;;;GAGG;AAEH,iIAAkI;AAI3H,oEAON;AAuBM,oCALI,GAAG,QACH,cAAc,UACd,mBAAmB,GACjB,CAAC,GAAC,CAAC,CAOf;AAED,mBAAmB;AACnB,mBADW,IAAI,CAkBb;AAEF,wBAAwB;AACxB,wBADW,SAAS,CAqBlB;AAiBK,uCAHI,OAAO,iBACP,OAAO,QAIgD;AAsB3D,0CAHI,OAAO,YACP,cAAc,QA8BxB;AAGM,+DAGN;AAED,6EAA8E;AAavE,mCANI,GAAG,iBACH,OAAO,WACP,mBAAmB,YACnB,qBAAqB,GACnB,OAAO,CAAC,MAAM,CAAC,CA8B3B;AAYM,sCALI,GAAG,QACH,OAAO,WACP,mBAAmB,GACjB,OAAO,CAAC,qBAAqB,CAAC,CAQ1C;AAWM,oCAJI,GAAG,wBACH,mBAAmB,+EAgB7B;AAED,0BAA0B;AAC1B,0BADW,WAAW,CAYpB;AAiDK,wBAHe,IAAI,kBACJ,MAAM,uBA/BjB,GAAG,cAGH,IAAI,CAAC,WAAW,MAAM,EAAE,IAAI,CAAC,CAAC,kBAG9B,oBAAoB,GAAG,SAAS,YAKhC,QAAQ,YAGR,OAAO,WAGP,OAAO,cAIP,IAAI,GAGF,OAAO,CAAC;IAAC,eAAe,EAAE,OAAO,CAAC,SAAS,MAAM,CAAC,CAAC,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAA;CAAC,CAAC,CA+D1G;;iBAxVa,MAAM,cAAc;0BACpB,MAAM,UAAU;;;;;;;6BAnBqC,aAAa;6BADtD,gBAAgB;yBACyB,aAAa;gCAAb,aAAa;8BAAb,aAAa"}
+{"version":3,"file":"zoeHelpers.d.ts","sourceRoot":"","sources":["zoeHelpers.js"],"names":[],"mappings":"AASA;;GAEG;AAEH,iIAAkI;AAI3H,oEAON;AAuBM,oCALI,GAAG,QACH,cAAc,UACd,mBAAmB,GACjB,CAAC,GAAC,CAAC,CAOf;AAED,mBAAmB;AACnB,mBADW,IAAI,CAkBb;AAEF,wBAAwB;AACxB,wBADW,SAAS,CAqBlB;AAiBK,uCAHI,OAAO,iBACP,OAAO,QAIgD;AAsB3D,0CAHI,OAAO,YACP,cAAc,QA8BxB;AAGM,+DAGN;AAED,6EAA8E;AAavE,mCANI,GAAG,iBACH,OAAO,WACP,mBAAmB,YACnB,qBAAqB,GACnB,OAAO,CAAC,MAAM,CAAC,CA8B3B;AAYM,sCALI,GAAG,QACH,OAAO,WACP,mBAAmB,GACjB,OAAO,CAAC,qBAAqB,CAAC,CAQ1C;AAWM,oCAJI,GAAG,wBACH,mBAAmB,4EAgB7B;AAED,0BAA0B;AAC1B,0BADW,WAAW,CAYpB;AAiDK,wBAHe,IAAI,kBACJ,MAAM,uBA/BjB,GAAG,cAGH,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,kBAG9B,oBAAoB,GAAG,SAAS,YAKhC,QAAQ,YAGR,OAAO,WAGP,OAAO,cAIP,IAAI,GAGF,OAAO,CAAC;IAAC,eAAe,EAAE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAA;CAAC,CAAC,CA+D1G;;iBAxVa,MAAM,cAAc;0BACpB,MAAM,UAAU;;;;;;;6BAnBJ,gBAAgB"}

package/src/contractSupport/zoeHelpers.js

@@ -9,7 +9,6 @@ import { atomicTransfer, fromOnly, toOnly } from './atomicTransfer.js';
 
 /**
  * @import {Pattern} from '@endo/patterns';
- * @import {ContractMeta, Invitation, Proposal, ZCF, ZCFSeat} from '@agoric/zoe';
  */
 
 export const defaultAcceptanceMsg = `The offer has been accepted. Once the contract has been completed, please check your payout`;

package/src/contracts/atomicSwap.d.ts

@@ -11,6 +11,6 @@
  * @param {ZCF} zcf
  */
 export function start(zcf: ZCF): {
-    creatorInvitation: Promise<globalThis.Invitation<unknown, never>>;
+    creatorInvitation: Promise<Invitation<unknown, never>>;
 };
 //# sourceMappingURL=atomicSwap.d.ts.map

package/src/contracts/auction/index.d.ts

@@ -26,8 +26,8 @@ export function start(zcf: ZCF<{
     winnerPriceOption?: "first-price" | "second-price";
     bidDuration: bigint;
 }>): {
-    creatorInvitation: Promise<globalThis.Invitation<{
-        makeBidInvitation: () => Promise<globalThis.Invitation<unknown, never>>;
+    creatorInvitation: Promise<Invitation<{
+        makeBidInvitation: () => Promise<Invitation<unknown, never>>;
         getSessionDetails: () => {
             auctionedAssets: any;
             minimumBid: any;
@@ -38,7 +38,7 @@ export function start(zcf: ZCF<{
             bids: string | any[];
         };
     } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
-        makeBidInvitation: () => Promise<globalThis.Invitation<unknown, never>>;
+        makeBidInvitation: () => Promise<Invitation<unknown, never>>;
         getSessionDetails: () => {
             auctionedAssets: any;
             minimumBid: any;