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

package/src/clientSupport.js

@@ -0,0 +1,324 @@
+// @ts-check
+
+import { Fail } from '@agoric/assert';
+import { AmountMath } from '@agoric/ertp';
+import { assertAllDefined } from '@agoric/internal';
+import { parseRatio } from '@agoric/zoe/src/contractSupport/ratio.js';
+
+// XXX support other decimal places
+const COSMOS_UNIT = 1_000_000n;
+const scaleDecimals = num => BigInt(num * Number(COSMOS_UNIT));
+
+// NB: not really a Proposal because the brands are not remotes
+// Instead they're copyRecord like  "{"boardId":"board0257","iface":"Alleged: IST brand"}" to pass through the boardId
+// mustMatch(harden(proposal), ProposalShape);
+/**
+ * Give/want
+ *
+ * @param {Record<string, Brand>} brands
+ * @param {{ giveMinted?: number, wantMinted?: number } | { collateralBrandKey: string, giveCollateral?: number, wantCollateral?: number }} opts
+ * @returns {Proposal}
+ */
+const makeVaultProposal = (brands, opts) => {
+  const proposal = { give: {}, want: {} };
+
+  if ('giveCollateral' in opts && opts.giveCollateral) {
+    const { collateralBrandKey } = opts;
+    proposal.give.Collateral = {
+      brand: brands[collateralBrandKey],
+      value: scaleDecimals(opts.giveCollateral),
+    };
+  }
+  if ('giveMinted' in opts && opts.giveMinted) {
+    proposal.give.Minted = {
+      brand: brands.IST,
+      value: scaleDecimals(opts.giveMinted),
+    };
+  }
+
+  if ('wantCollateral' in opts && opts.wantCollateral) {
+    const { collateralBrandKey } = opts;
+    proposal.want.Collateral = {
+      brand: brands[collateralBrandKey],
+      value: scaleDecimals(opts.wantCollateral),
+    };
+  }
+  if ('wantMinted' in opts && opts.wantMinted) {
+    proposal.want.Minted = {
+      brand: brands.IST,
+      value: scaleDecimals(opts.wantMinted),
+    };
+  }
+
+  return harden(proposal);
+};
+
+/**
+ * @param {Record<string, Brand>} brands
+ * @param {{ offerId: string, wantMinted: number, giveCollateral: number, collateralBrandKey: string }} opts
+ * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec}
+ */
+const makeOpenOffer = (brands, opts) => {
+  const proposal = makeVaultProposal(brands, opts);
+
+  // NB: not really a Proposal because the brands are not remotes
+  // Instead they're copyRecord like  "{"boardId":"board0257","iface":"Alleged: IST brand"}" to pass through the boardId
+  // mustMatch(harden(proposal), ProposalShape);
+
+  const collateralBrand = brands[opts.collateralBrandKey];
+
+  return {
+    id: opts.offerId,
+    invitationSpec: {
+      source: 'agoricContract',
+      instancePath: ['VaultFactory'],
+      callPipe: [
+        ['getCollateralManager', [collateralBrand]],
+        ['makeVaultInvitation'],
+      ],
+    },
+    proposal,
+  };
+};
+
+/**
+ * @param {Record<string, Brand>} brands
+ * @param {{ offerId: string, collateralBrandKey?: string, giveCollateral?: number, wantCollateral?: number, giveMinted?: number, wantMinted?: number }} opts
+ * @param {string} previousOffer
+ * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec}
+ */
+const makeAdjustOffer = (brands, opts, previousOffer) => {
+  // NB: not really a Proposal because the brands are not remotes
+  // Instead they're copyRecord like  "{"boardId":"board0257","iface":"Alleged: IST brand"}" to pass through the boardId
+  // mustMatch(harden(proposal), ProposalShape);
+  const proposal = makeVaultProposal(brands, opts);
+
+  return {
+    id: opts.offerId,
+    invitationSpec: {
+      source: 'continuing',
+      previousOffer,
+      invitationMakerName: 'AdjustBalances',
+    },
+    proposal,
+  };
+};
+
+/**
+ * @param {Record<string, Brand>} brands
+ * @param {{ offerId: string, collateralBrandKey?: string, giveMinted: number }} opts
+ * @param {string} previousOffer
+ * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec}
+ */
+const makeCloseOffer = (brands, opts, previousOffer) => {
+  const proposal = makeVaultProposal(brands, opts);
+
+  return {
+    id: opts.offerId,
+    invitationSpec: {
+      source: 'continuing',
+      previousOffer,
+      invitationMakerName: 'CloseVault',
+    },
+    proposal,
+  };
+};
+
+/**
+ * @param {string} vaultId
+ * @param {Promise<import('@agoric/smart-wallet/src/smartWallet').CurrentWalletRecord>} currentP
+ * @returns {Promise<string>} offer id in which the vault was made
+ */
+export const lookupOfferIdForVault = async (vaultId, currentP) => {
+  const { offerToPublicSubscriberPaths } = await currentP;
+
+  for (const [offerId, publicSubscribers] of offerToPublicSubscriberPaths) {
+    if (publicSubscribers.vault?.endsWith(vaultId)) {
+      return offerId;
+    }
+  }
+  throw Fail`vault ${vaultId} not found`;
+};
+
+/**
+ * @param {Record<string, Brand>} brands
+ * @param {({ wantMinted: number | undefined, giveMinted: number | undefined })} opts
+ * @param {number} [fee=0]
+ * @param {string} [anchor]
+ * @returns {Proposal} XXX not a real proposal, uses BoardRemote
+ */
+const makePsmProposal = (brands, opts, fee = 0, anchor = 'AUSD') => {
+  const giving = opts.giveMinted ? 'minted' : 'anchor';
+  const brand =
+    giving === 'anchor'
+      ? { in: brands[anchor], out: brands.IST }
+      : { in: brands.IST, out: brands[anchor] };
+  const value =
+    Number(giving === 'anchor' ? opts.wantMinted : opts.giveMinted) *
+    Number(COSMOS_UNIT);
+  const adjusted = {
+    in: BigInt(Math.ceil(giving === 'anchor' ? value / (1 - fee) : value)),
+    out: BigInt(Math.ceil(giving === 'minted' ? value * (1 - fee) : value)),
+  };
+  return {
+    give: {
+      In: { brand: brand.in, value: adjusted.in },
+    },
+    want: {
+      Out: { brand: brand.out, value: adjusted.out },
+    },
+  };
+};
+
+/**
+ * @param {Instance} instance
+ * @param {Record<string, Brand>} brands
+ * @param {{ offerId: number, feePct?: number } &
+ *         ({ wantMinted: number | undefined, giveMinted: number | undefined, pair: [string, string] })} opts
+ * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec}
+ */
+const makePsmSwapOffer = (instance, brands, opts) => {
+  const method = opts.wantMinted
+    ? 'makeWantMintedInvitation'
+    : 'makeGiveMintedInvitation'; // ref psm.js
+  const proposal = makePsmProposal(
+    brands,
+    opts,
+    opts.feePct ? opts.feePct / 100 : undefined,
+    opts.pair[1],
+  );
+
+  // NB: not really a Proposal because the brands are not remotes
+  // Instead they're copyRecord like  "{"boardId":"board0257","iface":"Alleged: IST brand"}" to pass through the boardId
+  // mustMatch(harden(proposal), ProposalShape);
+
+  return {
+    id: opts.offerId,
+    invitationSpec: {
+      source: 'contract',
+      instance,
+      publicInvitationMaker: method,
+    },
+    proposal,
+  };
+};
+
+/**
+ * @param {Record<string, Brand>} _brands
+ * @param {{
+ *   offerId: string,
+ *   give: string,
+ *   maxBuy: string,
+ *   wantMinimum?: string,
+ *   parseAmount: (x: string) => Amount<'nat'>,
+ * } & ({
+ *   price: number,
+ * } | {
+ *   discount: number,  // -1 to 1. e.g. 0.10 for 10% discount, -0.05 for 5% markup
+ * })} opts
+ * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec}
+ */
+const makeBidOffer = (_brands, opts) => {
+  assert.typeof(opts.parseAmount, 'function');
+  assertAllDefined({
+    offerId: opts.offerId,
+    give: opts.give,
+    maxBuy: opts.maxBuy,
+  });
+  const { parseAmount } = opts;
+  const proposal = {
+    give: { Bid: parseAmount(opts.give) },
+    ...(opts.wantMinimum
+      ? { want: { Collateral: parseAmount(opts.wantMinimum) } }
+      : {}),
+  };
+  const istBrand = proposal.give.Bid.brand;
+  const maxBuy = parseAmount(opts.maxBuy);
+
+  const bounds = (x, lo, hi) => {
+    assert(x >= lo && x <= hi);
+    return x;
+  };
+
+  assert(
+    'price' in opts || 'discount' in opts,
+    'must specify price or discount',
+  );
+  /** @type {import('./auction/auctionBook.js').OfferSpec} */
+  const offerArgs =
+    'price' in opts
+      ? {
+          maxBuy: parseAmount(opts.maxBuy),
+          offerPrice: parseRatio(opts.price, istBrand, maxBuy.brand),
+        }
+      : {
+          maxBuy,
+          offerBidScaling: parseRatio(
+            (1 - bounds(opts.discount, -1, 1)).toFixed(2),
+            istBrand,
+            istBrand,
+          ),
+        };
+
+  /** @type {import('@agoric/smart-wallet/src/offers.js').OfferSpec} */
+  const offerSpec = {
+    id: opts.offerId,
+    invitationSpec: {
+      source: 'agoricContract',
+      instancePath: ['auctioneer'],
+      callPipe: [['makeBidInvitation', [maxBuy.brand]]],
+    },
+    proposal,
+    offerArgs,
+  };
+  return offerSpec;
+};
+
+/**
+ * @param {Record<string, Brand>} brands
+ * @param {{
+ *   offerId: string,
+ *   give: number,
+ *   collateralBrandKey: string,
+ * }} opts
+ * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec}
+ */
+const makeAddCollateralOffer = (brands, opts) => {
+  /** @type {AmountKeywordRecord} */
+  const give = {
+    Collateral: AmountMath.make(
+      brands[opts.collateralBrandKey],
+      scaleDecimals(opts.give),
+    ),
+  };
+
+  /** @type {import('@agoric/smart-wallet/src/offers.js').OfferSpec} */
+  const offerSpec = {
+    id: opts.offerId,
+    invitationSpec: {
+      source: 'agoricContract',
+      instancePath: ['reserve'],
+      callPipe: [['makeAddCollateralInvitation', []]],
+    },
+    proposal: { give },
+  };
+  return offerSpec;
+};
+
+export const Offers = {
+  auction: {
+    Bid: makeBidOffer,
+  },
+  psm: {
+    // lowercase because it's not an invitation name. Instead it's an abstraction over two invitation makers.
+    swap: makePsmSwapOffer,
+  },
+  vaults: {
+    OpenVault: makeOpenOffer,
+    AdjustBalances: makeAdjustOffer,
+    CloseVault: makeCloseOffer,
+  },
+  reserve: {
+    AddCollateral: makeAddCollateralOffer,
+  },
+};

package/src/collectFees.js

@@ -1,4 +1,7 @@
-// @ts-check
+// @jessie-check
+
+import { atomicTransfer } from '@agoric/zoe/src/contractSupport/index.js';
+
 /**
  * Provide shared support for providing access to fees from a service contract.
  *
@@ -6,25 +9,16 @@
  * @param {ZCFSeat} feeSeat
  * @param {Brand} feeBrand
  * @param {string} keyword
+ * @returns {Promise<Invitation<string>>}
  */
-export const makeMakeCollectFeesInvitation = (
-  zcf,
-  feeSeat,
-  feeBrand,
-  keyword,
-) => {
+export const makeCollectFeesInvitation = (zcf, feeSeat, feeBrand, keyword) => {
   const collectFees = seat => {
     const amount = feeSeat.getAmountAllocated(keyword, feeBrand);
-    feeSeat.decrementBy(harden({ [keyword]: amount }));
-    seat.incrementBy(harden({ Fee: amount }));
-    zcf.reallocate(seat, feeSeat);
+    atomicTransfer(zcf, feeSeat, seat, { [keyword]: amount }, { Fee: amount });
 
     seat.exit();
     return `paid out ${amount.value}`;
   };
 
-  const makeCollectFeesInvitation = () =>
-    zcf.makeInvitation(collectFees, 'collect fees');
-
-  return { makeCollectFeesInvitation };
+  return zcf.makeInvitation(collectFees, 'collect fees');
 };

package/src/contractSupport.js

@@ -1,10 +1,11 @@
-// @ts-check
+// @jessie-check
+
 import { AmountMath } from '@agoric/ertp';
 import { makeStoredPublisherKit, makeStoredPublishKit } from '@agoric/notifier';
 import { M } from '@agoric/store';
 import { E } from '@endo/eventual-send';
 
-const { details: X, quote: q } = assert;
+const { Fail, quote: q } = assert;
 
 export const amountPattern = harden({ brand: M.remotable(), value: M.any() });
 export const ratioPattern = harden({
@@ -19,10 +20,11 @@ export const ratioPattern = harden({
  * on a proposal. We use two Amounts because an Amount cannot represent
  * a negative number (so we use a "loss" that will be subtracted).
  *
- * @param {Amount} base
- * @param {Amount} gain
- * @param {Amount} loss
- * @returns {Amount}
+ * @template {AssetKind} K
+ * @param {Amount<K>} base
+ * @param {Amount<K>} gain
+ * @param {Amount<K>} loss
+ * @returns {Amount<K>}
  */
 export const addSubtract = (base, gain, loss) =>
   AmountMath.subtract(AmountMath.add(base, gain), loss);
@@ -37,31 +39,16 @@ export const assertOnlyKeys = (proposal, keys) => {
   /** @param {AmountKeywordRecord} clause */
   const onlyKeys = clause =>
     Object.getOwnPropertyNames(clause).every(c => keys.includes(c));
-  onlyKeys(proposal.give) ||
-    assert.fail(X`extraneous terms in give: ${proposal.give}`);
-  onlyKeys(proposal.want) ||
-    assert.fail(X`extraneous terms in want: ${proposal.want}`);
+  onlyKeys(proposal.give) || Fail`extraneous terms in give: ${proposal.give}`;
+  onlyKeys(proposal.want) || Fail`extraneous terms in want: ${proposal.want}`;
 };
 
 /**
- * Stage a transfer between `fromSeat` and `toSeat`, specified as the delta between
- * the gain and a loss on the `fromSeat`. The gain/loss are typically from the
- * give/want respectively of a proposal. The `key` is the allocation keyword.
- *
- * @param {ZCFSeat} fromSeat
- * @param {ZCFSeat} toSeat
- * @param {Amount} fromLoses
- * @param {Amount} fromGains
- * @param {Keyword} key
+ * @param {Amount[]} amounts
+ * @returns {boolean}
  */
-export const stageDelta = (fromSeat, toSeat, fromLoses, fromGains, key) => {
-  // Must check `isEmpty`; can't subtract `empty` from a missing allocation.
-  if (!AmountMath.isEmpty(fromLoses)) {
-    toSeat.incrementBy(fromSeat.decrementBy(harden({ [key]: fromLoses })));
-  }
-  if (!AmountMath.isEmpty(fromGains)) {
-    fromSeat.incrementBy(toSeat.decrementBy(harden({ [key]: fromGains })));
-  }
+export const allEmpty = amounts => {
+  return amounts.every(a => AmountMath.isEmpty(a));
 };
 
 /**
@@ -72,16 +59,14 @@ export const stageDelta = (fromSeat, toSeat, fromLoses, fromGains, key) => {
  */
 export const checkDebtLimit = (debtLimit, totalDebt, toMint) => {
   const debtPost = AmountMath.add(totalDebt, toMint);
-  assert(
-    !AmountMath.isGTE(debtPost, debtLimit),
-    X`Minting ${q(toMint)} past ${q(totalDebt)} would hit total debt limit ${q(
-      debtLimit,
-    )}`,
-  );
+  AmountMath.isGTE(debtLimit, debtPost) ||
+    Fail`Minting ${q(toMint)} past ${q(
+      totalDebt,
+    )} would hit total debt limit ${q(debtLimit)}`;
 };
 
 /**
- * @deprecated use makeMetricsPublishKit
+ * @deprecated incompatible with durability; instead handle vstorage ephemerally on a durable PublishKit
  * @template T
  * @param {ERef<StorageNode>} storageNode
  * @param {ERef<Marshaller>} marshaller
@@ -116,6 +101,7 @@ harden(makeMetricsPublisherKit);
  */
 
 /**
+ * @deprecated incompatible with durability; instead handle vstorage ephemerally on a durable PublishKit
  * @template T
  * @param {ERef<StorageNode>} storageNode
  * @param {ERef<Marshaller>} marshaller
@@ -137,38 +123,8 @@ export const makeMetricsPublishKit = (storageNode, marshaller) => {
 harden(makeMetricsPublishKit);
 
 /**
- * @template K Key
- * @template {{}} E Ephemeral state
- * @param {() => E} init
+ * @param {Brand} brand must be a 'nat' brand, not checked
+ * @param {NatValue} [min]
  */
-export const makeEphemeraProvider = init => {
-  /** @type {Map<K, E>} */
-  const ephemeras = new Map();
-
-  /**
-   * Provide an object to hold state that need not (or cannot) be durable.
-   *
-   * @type {(key: K) => E}
-   */
-  return key => {
-    if (ephemeras.has(key)) {
-      // @ts-expect-error cast
-      return ephemeras.get(key);
-    }
-    const newEph = init();
-    ephemeras.set(key, newEph);
-    return newEph;
-  };
-};
-harden(makeEphemeraProvider);
-
-/**
- * @template {Record<string, unknown>} T
- * @param {T} specimen
- * @param {Array<keyof T>} keyList
- */
-export const assertKeysDefined = (specimen, keyList) => {
-  for (const key of keyList) {
-    assert(specimen[key], X`Missing ${q(key)}`);
-  }
-};
+export const makeNatAmountShape = (brand, min) =>
+  harden({ brand, value: min ? M.gte(min) : M.nat() });