feat: contract code to mint tickets

contract/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "dapp-agoric-basics-contract",
+  "name": "agoric-basics-contract",
   "version": "0.1.0",
   "private": true,
   "description": "Agoric Basics Contract",

contract/src/agoric-basics-proposal.js

@@ -48,12 +48,12 @@ export const startAgoricBasicsContract = async permittedPowers => {
     brand: {
       consume: { IST: istBrandP },
       // @ts-expect-error dynamic extension to promise space
-      produce: { Item: produceItemBrand },
+      produce: { Ticket: produceTicketBrand },
     },
     issuer: {
       consume: { IST: istIssuerP },
       // @ts-expect-error dynamic extension to promise space
-      produce: { Item: produceItemIssuer },
+      produce: { Ticket: produceTicketIssuer },
     },
     installation: {
       consume: { agoricBasics: agoricBasicsInstallationP },
@@ -80,19 +80,19 @@ export const startAgoricBasicsContract = async permittedPowers => {
   });
   console.log('CoreEval script: started contract', instance);
   const {
-    brands: { Item: brand },
-    issuers: { Item: issuer },
+    brands: { Ticket: brand },
+    issuers: { Ticket: issuer },
   } = await E(zoe).getTerms(instance);
 
   console.log('CoreEval script: share via agoricNames:', brand);
 
   produceInstance.reset();
   produceInstance.resolve(instance);
 
-  produceItemBrand.reset();
-  produceItemIssuer.reset();
-  produceItemBrand.resolve(brand);
-  produceItemIssuer.resolve(issuer);
+  produceTicketBrand.reset();
+  produceTicketIssuer.reset();
+  produceTicketBrand.resolve(brand);
+  produceTicketIssuer.resolve(issuer);
 
   await publishBrandInfo(chainStorage, board, brand);
   console.log('agoricBasics (re)started');
@@ -109,8 +109,8 @@ const agoricBasicsManifest = {
       zoe: true, // to get contract terms, including issuer/brand
     },
     installation: { consume: { agoricBasics: true } },
-    issuer: { consume: { IST: true }, produce: { Item: true } },
-    brand: { consume: { IST: true }, produce: { Item: true } },
+    issuer: { consume: { IST: true }, produce: { Ticket: true } },
+    brand: { consume: { IST: true }, produce: { Ticket: true } },
     instance: { produce: { agoricBasics: true } },
   },
 };

contract/src/agoric-basics.contract.js

@@ -1,5 +1,5 @@
 /**
- * @file Contract to mint and sell a few Item NFTs at a time.
+ * @file Contract to mint and sell a few ticket NFTs at a time.
  *
  * We declare variables (including functions) before using them,
  * so you may want to skip ahead and come back to some details.
@@ -22,76 +22,130 @@
 import { Far } from '@endo/far';
 import { M, getCopyBagEntries } from '@endo/patterns';
 import { AssetKind } from '@agoric/ertp/src/amountMath.js';
-import { AmountShape } from '@agoric/ertp/src/typeGuards.js';
 import { atomicRearrange } from '@agoric/zoe/src/contractSupport/atomicTransfer.js';
 import '@agoric/zoe/exported.js';
+import { AmountMath, AmountShape } from '@agoric/ertp';
 
 const { Fail, quote: q } = assert;
 
 // #region bag utilities
 /** @type { (xs: bigint[]) => bigint } */
 const sum = xs => xs.reduce((acc, x) => acc + x, 0n);
 
 /**
  * @param {import('@endo/patterns').CopyBag} bag
  * @returns {bigint[]}
  */
 const bagCounts = bag => {
   const entries = getCopyBagEntries(bag);
   return entries.map(([_k, ct]) => ct);
 };
+
+/**
+ *
+ * @param {import('@endo/patterns').CopyBag} bag
+ * @param {Object.<string, {tradePrice: Amount, maxTickets: bigint}>} inventory
+ * @returns {boolean}
+ */
+export const hasInventory = (bag, inventory) => {
+  const entries = getCopyBagEntries(bag);
+  for (const [k, ct] of entries) {
+    if (k in inventory) {
+      const { maxTickets } = inventory[k];
+      if (ct > maxTickets) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ *
+ * @param {Amount} amount
+ * @param {number} n
+ * @returns {Amount}
+ */
+const multiply = (amount, n) => {
+  const arr = Array.from({ length: n });
+  return arr.reduce(
+    (sum, _) => AmountMath.add(amount, sum),
+    AmountMath.make(amount.brand, 0n),
+  );
+};
+
+/**
+ *
+ * @param {Amount} sum
+ * @param {[string, bigint]} entry
+ * @param {Object.<string, {tradePrice: Amount, maxTickets: bigint}>} inventory
+ * @returns {Amount}
+ */
+const addMultiples = (sum, entry, inventory) => {
+  const multiple = multiply(inventory[entry[0]].tradePrice, Number(entry[1]));
+  return AmountMath.add(multiple, sum);
+};
+
+/**
+ *
+ * @param {import('@endo/patterns').CopyBag} bag
+ * @param {Object.<string, {tradePrice: Amount, maxTickets: bigint}>} inventory
+ * @returns {Amount}
+ */
+export const bagPrice = (bag, inventory) => {
+  const entries = getCopyBagEntries(bag);
+  const brand = Object.values(inventory)[0].tradePrice.brand;
+  return entries.reduce(
+    (sum, entry) => addMultiples(sum, entry, inventory),
+    // TODO: a better way to create empty amount
+    AmountMath.make(brand, 0n),
+  );
+};
 // #endregion
 
 /**
  * In addition to the standard `issuers` and `brands` terms,
  * this contract is parameterized by terms for price and,
- * optionally, a maximum number of items sold for that price (default: 3).
+ * optionally, a maximum number of tickets sold for that price (default: 3).
  *
  * @typedef {{
- *   tradePrice: Amount;
- *   maxItems?: bigint;
+ *   inventory: Object.<string, {tradePrice: Amount, maxTickets: bigint}>;
  * }} AgoricBasicsTerms
  */
 
-export const meta = {
-  customTermsShape: M.splitRecord(
-    { tradePrice: AmountShape },
-    { maxItems: M.bigint() },
-  ),
-};
-// compatibility with an earlier contract metadata API
-export const customTermsShape = meta.customTermsShape;
-
 /**
  * Start a contract that
- *   - creates a new non-fungible asset type for Items, and
- *   - handles offers to buy up to `maxItems` items at a time.
+ *   - creates a new non-fungible asset type for Tickets, and
+ *   - handles offers to buy up to `maxTickets` tickets at a time.
  *
  * @param {ZCF<AgoricBasicsTerms>} zcf
  */
 export const start = async zcf => {
-  const { tradePrice, maxItems = 3n } = zcf.getTerms();
+  const { inventory } = zcf.getTerms();
 
   /**
-   * a new ERTP mint for items, accessed thru the Zoe Contract Facet.
+   * a new ERTP mint for tickets, accessed thru the Zoe Contract Facet.
    * Note: `makeZCFMint` makes the associated brand and issuer available
    * in the contract's terms.
    *
    * AssetKind.COPY_BAG can express non-fungible (or rather: semi-fungible)
    * amounts such as: 3 potions and 1 map.
    */
-  const itemMint = await zcf.makeZCFMint('Item', AssetKind.COPY_BAG);
-  const { brand: itemBrand } = itemMint.getIssuerRecord();
+  const ticketMint = await zcf.makeZCFMint('Ticket', AssetKind.COPY_BAG);
+  const { brand: ticketBrand } = ticketMint.getIssuerRecord();
 
   /**
    * a pattern to constrain proposals given to {@link tradeHandler}
    *
    * The `Price` amount must be >= `tradePrice` term.
-   * The `Items` amount must use the `Item` brand and a bag value.
+   * The `Tickets` amount must use the `Ticket` brand and a bag value.
    */
   const proposalShape = harden({
-    give: { Price: M.gte(tradePrice) },
-    want: { Items: { brand: itemBrand, value: M.bag() } },
+    give: { Price: AmountShape },
+    want: { Tickets: { brand: ticketBrand, value: M.bag() } },
     exit: M.any(),
   });
 
@@ -101,39 +155,45 @@
   /** @type {OfferHandler} */
   const tradeHandler = buyerSeat => {
     // give and want are guaranteed by Zoe to match proposalShape
-    const { want } = buyerSeat.getProposal();
+    const { give, want } = buyerSeat.getProposal();
+
+    hasInventory(want.Tickets.value, inventory) ||
+      Fail`${q(want.Tickets.value)} wanted, which exceeds inventory ${q(
+        inventory,
+      )}`;
 
-    sum(bagCounts(want.Items.value)) <= maxItems ||
-      Fail`max ${q(maxItems)} items allowed: ${q(want.Items)}`;
+    const totalPrice = bagPrice(want.Tickets.value, inventory);
+    AmountMath.isGTE(give.Price, totalPrice) ||
+      Fail`Total price is ${q(totalPrice)}, but ${q(give.Price)} was given`;
 
-    const newItems = itemMint.mintGains(want);
+    const newTickets = ticketMint.mintGains(want);
     atomicRearrange(
       zcf,
       harden([
         // price from buyer to proceeds
-        [buyerSeat, proceeds, { Price: tradePrice }],
-        // new items to buyer
-        [newItems, buyerSeat, want],
+        [buyerSeat, proceeds, { Price: totalPrice }],
+        // new tickets to buyer
+        [newTickets, buyerSeat, want],
       ]),
     );
 
     buyerSeat.exit(true);
-    newItems.exit();
+    newTickets.exit();
     return 'trade complete';
   };
 
   /**
-   * Make an invitation to trade for items.
+   * Make an invitation to trade for tickets.
    *
    * Proposal Keywords used in offers using these invitations:
    *   - give: `Price`
-   *   - want: `Items`
+   *   - want: `Tickets`
    */
   const makeTradeInvitation = () =>
-    zcf.makeInvitation(tradeHandler, 'buy items', undefined, proposalShape);
+    zcf.makeInvitation(tradeHandler, 'buy tickets', undefined, proposalShape);
 
   // Mark the publicFacet Far, i.e. reachable from outside the contract
-  const publicFacet = Far('Items Public Facet', {
+  const publicFacet = Far('Tickets Public Facet', {
     makeTradeInvitation,
   });
   return harden({ publicFacet });