Freshen the simple exchange dApp

packages/dapp-simple-exchange/.gitignore

@@ -0,0 +1 @@
+dappConstants.js

packages/dapp-simple-exchange/api/deploy.js

@@ -1,8 +1,18 @@
 // Agoric Dapp api deployment script
 
 export default async function deployApi(homeP, { bundleSource, pathResolve }) {
-  const { source, moduleFormat } = await bundleSource('./handler.js');
+  let overrideInstanceId;
+  const dc = `${process.cwd()}/dappConstants.js`;
+  try {
+    require(dc);
+    overrideInstanceId = __DAPP_CONSTANTS__.CONTRACT_ID;
+  } catch (e) {
+    console.log(`Proceeeding with defaults; cannot load ${dc}:`, e.message);
+  }
+
+  const { source, moduleFormat } = await bundleSource(pathResolve('./handler.js'));
   const handlerInstall = homeP~.spawner~.install(source, moduleFormat);
-  const handler = handlerInstall~.spawn();
+  const [zoe, registrar] = await Promise.all([homeP~.zoe, homeP~.registrar]);
+  const handler = handlerInstall~.spawn({zoe, registrar, overrideInstanceId});
   await homeP~.http~.registerCommandHandler(handler);
 }

packages/dapp-simple-exchange/api/handler.js

@@ -1,13 +1,62 @@
 import harden from '@agoric/harden';
 
-export default harden((_terms, _inviteMaker) => {
+export default harden(({zoe, registrar, overrideInstanceId = undefined}, _inviteMaker) => {
+  // If we have an overrideInstanceId, use it to assert the correct value in the RPC.
+  function coerceInstanceId(instanceId = undefined) {
+    if (instanceId === undefined) {
+      return overrideInstanceId;
+    }
+    if (overrideInstanceId === undefined || instanceId === overrideInstanceId) {
+      return instanceId;
+    }
+    throw TypeError(`instanceId ${JSON.stringify(instanceId)} must match ${JSON.stringify(overrideInstanceId)}`);
+  }
+
+  const registrarPCache = new Map();
+  function getRegistrarP(id) {
+    let regP = registrarPCache.get(id);
+    if (!regP) {
+      // Cache miss, so try the registrar.
+      regP = E(registrar).get(id);
+      registrarPCache.set(id, regP);
+    }
+    return regP;
+  }
+
+  const instancePCache = new Map();
+  function getInstanceP(id) {
+    let instanceP = instancePCache.get(id);
+    if (!instanceP) {
+      const instanceHandleP = getRegistrarP(id);
+      instanceP = instanceHandleP.then(instanceHandle =>
+        E(zoe).getInstance(instanceHandle));
+      instancePCache.set(id, instanceP);
+    }
+    return instanceP;
+  }
+
+  async function getOrderStatus(instanceRegKey, inviteHandles) {
+    const { publicAPI } = await getInstanceP(instanceRegKey);
+    return E(publicAPI).getOrderStatus(inviteHandles);
+  }
+
   return harden({
     getCommandHandler() {
       return harden({
-        processInbound(obj, _home) {
+        async processInbound(obj, _home) {
           switch (obj.type) {
-            case '@DIR@Message': {
-              return harden({ type: '@DIR@Response', orig: obj });
+            case 'simpleExchange/getOrderStatus': {
+              const { instanceRegKey } = obj;
+              const instanceId = coerceInstanceId(instanceRegKey);
+
+              // FIXME: Use a protocol to negotiate a sharingService.
+              const inviteHandles = [];
+
+              const data = await getOrderStatus(instanceId, inviteHandles);
+              return harden({
+                type: 'simpleExchange/orderStatus',
+                data,
+              });
             }
             default:
               return undefined;