feat: contract code to mint tickets

contract/.gitignore

@@ -1,3 +1,3 @@
-start-agoric-basics-permit.json
-start-agoric-basics.js
+start-sell-concert-tickets-permit.json
+start-sell-concert-tickets.js
 bundles/

contract/Makefile

@@ -103,8 +103,8 @@ print-key: /root/.agoric/user1.key
 	@agd keys show user1 -a --keyring-backend="test"
 	@echo
 
-SCRIPT=start-agoric-basics.js
-PERMIT=start-agoric-basics-permit.json
+SCRIPT=start-sell-concert-tickets.js
+PERMIT=start-sell-concert-tickets-permit.json
 start-contract: $(SCRIPT) $(PERMIT) install-bundles
 	scripts/propose-start-contract.sh
 

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/scripts/build-contract-deployer.js

@@ -4,27 +4,30 @@
  * Creates files for starting an instance of the contract:
  * * contract source and instantiation proposal bundles to be published via
  *   `agd tx swingset install-bundle`
- * * start-agoric-basics-permit.json and start-agoric-basics.js to submit the
+ * * start-sell-concert-tickets-permit.json and start-sell-concert-tickets.js to submit the
  *   instantiation proposal via `agd tx gov submit-proposal swingset-core-eval`
  *
  * Usage:
  *   agoric run build-contract-deployer.js
  */
 
 import { makeHelpers } from '@agoric/deploy-script-support';
-import { getManifestForAgoricBasics } from '../src/agoric-basics-proposal.js';
+import { getManifestForSellConcertTickets } from '../src/sell-concert-tickets-proposal.js';
 
 /** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
-export const agoricBasicsProposalBuilder = async ({ publishRef, install }) => {
+export const sellConcertTicketsProposalBuilder = async ({
+  publishRef,
+  install,
+}) => {
   return harden({
-    sourceSpec: '../src/agoric-basics-proposal.js',
+    sourceSpec: '../src/sell-concert-tickets-proposal.js',
     getManifestCall: [
-      getManifestForAgoricBasics.name,
+      getManifestForSellConcertTickets.name,
       {
-        agoricBasicsRef: publishRef(
+        sellConcertTicketsRef: publishRef(
           install(
-            '../src/agoric-basics.contract.js',
-            '../bundles/bundle-agoric-basics.js',
+            '../src/sell-concert-tickets.contract.js',
+            '../bundles/bundle-sell-concert-tickets.js',
             {
               persist: true,
             },
@@ -38,5 +41,5 @@ export const agoricBasicsProposalBuilder = async ({ publishRef, install }) => {
 /** @type {DeployScriptFunction} */
 export default async (homeP, endowments) => {
   const { writeCoreProposal } = await makeHelpers(homeP, endowments);
-  await writeCoreProposal('start-agoric-basics', agoricBasicsProposalBuilder);
+  await writeCoreProposal('start-sell-concert-tickets', sellConcertTicketsProposalBuilder);
 };

contract/scripts/propose-start-contract.sh

@@ -3,16 +3,16 @@ set -xueo pipefail
 
 cd /workspace/contract
 
-SCRIPT=start-agoric-basics.js
-PERMIT=start-agoric-basics-permit.json
+SCRIPT=start-sell-concert-tickets.js
+PERMIT=start-sell-concert-tickets-permit.json
 ls -sh "$SCRIPT" "$PERMIT"
 
 PROPOSAL=$(agd query gov proposals --output json | jq -c '.proposals | length | .+1')
 
 make fund-acct
 
 agd tx gov submit-proposal swingset-core-eval "$PERMIT" "$SCRIPT" \
-  --title="Start Agoric Basics Contract" --description="Evaluate $SCRIPT" \
+  --title="Start Sell Concert Tickets Contract" --description="Evaluate $SCRIPT" \
   --deposit=10000000ubld --gas=auto --gas-adjustment=1.2 \
   --from user1 --chain-id agoriclocal --keyring-backend=test \
   --yes -b block

contract/src/agoric-basics-proposal.js → contract/src/sell-concert-tickets-proposal.js

@@ -13,7 +13,29 @@ const BOARD_AUX = 'boardAux';
 const marshalData = makeMarshal(_val => Fail`data only`);
 
 const IST_UNIT = 1_000_000n;
-const CENT = IST_UNIT / 100n;
+
+export const makeInventory = (brand, baseUnit) => {
+  return {
+    frontRow: {
+      tradePrice: AmountMath.make(brand, baseUnit * 3n),
+      maxTickets: 3n,
+    },
+    middleRow: {
+      tradePrice: AmountMath.make(brand, baseUnit * 2n),
+      maxTickets: 3n,
+    },
+    lastRow: {
+      tradePrice: AmountMath.make(brand, baseUnit * 1n),
+      maxTickets: 3n,
+    },
+  };
+};
+
+export const makeTerms = (brand, baseUnit) => {
+  return {
+    inventory: makeInventory(brand, baseUnit),
+  };
+};
 
 /**
  * Make a storage node for auxilliary data for a value on the board.
@@ -41,86 +63,89 @@ const publishBrandInfo = async (chainStorage, board, brand) => {
  *
  * @param {BootstrapPowers} permittedPowers
  */
-export const startAgoricBasicsContract = async permittedPowers => {
-  console.error('startAgoricBasicsContract()...');
+export const startSellConcertTicketsContract = async permittedPowers => {
+  console.error('startSellConcertTicketsContract()...');
   const {
     consume: { board, chainStorage, startUpgradable, zoe },
     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 },
+      consume: { sellConcertTickets: sellConcertTicketsInstallationP },
     },
     instance: {
       // @ts-expect-error dynamic extension to promise space
-      produce: { agoricBasics: produceInstance },
+      produce: { sellConcertTickets: produceInstance },
     },
   } = permittedPowers;
 
   const istIssuer = await istIssuerP;
   const istBrand = await istBrandP;
 
-  const terms = { tradePrice: AmountMath.make(istBrand, 25n * CENT) };
+  const terms = makeTerms(istBrand, 1n * IST_UNIT);
 
   // agoricNames gets updated each time; the promise space only once XXXXXXX
-  const installation = await agoricBasicsInstallationP;
+  const installation = await sellConcertTicketsInstallationP;
 
   const { instance } = await E(startUpgradable)({
     installation,
     issuerKeywordRecord: { Price: istIssuer },
-    label: 'agoricBasics',
+    label: 'sellConcertTickets',
     terms,
   });
   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');
+  console.log('sellConcertTickets (re)started');
 };
 
 /** @type { import("@agoric/vats/src/core/lib-boot").BootstrapManifest } */
-const agoricBasicsManifest = {
-  [startAgoricBasicsContract.name]: {
+const sellConcertTicketsManifest = {
+  [startSellConcertTicketsContract.name]: {
     consume: {
       agoricNames: true,
       board: true, // to publish boardAux info for NFT brand
       chainStorage: true, // to publish boardAux info for NFT brand
       startUpgradable: true, // to start contract and save adminFacet
       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 } },
-    instance: { produce: { agoricBasics: true } },
+    installation: { consume: { sellConcertTickets: true } },
+    issuer: { consume: { IST: true }, produce: { Ticket: true } },
+    brand: { consume: { IST: true }, produce: { Ticket: true } },
+    instance: { produce: { sellConcertTickets: true } },
   },
 };
-harden(agoricBasicsManifest);
+harden(sellConcertTicketsManifest);
 
-export const getManifestForAgoricBasics = ({ restoreRef }, { agoricBasicsRef }) => {
+export const getManifestForSellConcertTickets = (
+  { restoreRef },
+  { sellConcertTicketsRef },
+) => {
   return harden({
-    manifest: agoricBasicsManifest,
+    manifest: sellConcertTicketsManifest,
     installations: {
-      agoricBasics: restoreRef(agoricBasicsRef),
+      sellConcertTickets: restoreRef(sellConcertTicketsRef),
     },
   });
 };