@agoric/swingset-liveslots 0.10.3-dev-ee2126b.0 → 0.10.3-dev-c7eca9b.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-liveslots",
-  "version": "0.10.3-dev-ee2126b.0+ee2126b",
+  "version": "0.10.3-dev-c7eca9b.0+c7eca9b",
   "description": "SwingSet ocap support layer",
   "type": "module",
   "main": "src/index.js",
@@ -17,8 +17,8 @@
     "lint:eslint": "eslint ."
   },
   "dependencies": {
-    "@agoric/internal": "0.3.3-dev-ee2126b.0+ee2126b",
-    "@agoric/store": "0.9.3-dev-ee2126b.0+ee2126b",
+    "@agoric/internal": "0.3.3-dev-c7eca9b.0+c7eca9b",
+    "@agoric/store": "0.9.3-dev-c7eca9b.0+c7eca9b",
     "@endo/env-options": "^1.1.4",
     "@endo/errors": "^1.2.2",
     "@endo/eventual-send": "^1.2.2",
@@ -32,7 +32,7 @@
     "@endo/promise-kit": "^1.1.2"
   },
   "devDependencies": {
-    "@agoric/kmarshal": "0.1.1-dev-ee2126b.0+ee2126b",
+    "@agoric/kmarshal": "0.1.1-dev-c7eca9b.0+c7eca9b",
     "ava": "^5.3.0"
   },
   "files": [
@@ -68,5 +68,5 @@
   "typeCoverage": {
     "atLeast": 75.35
   },
-  "gitHead": "ee2126bcb2267010a840679a9cc52c848ed07b70"
+  "gitHead": "c7eca9bba1bb4ca361c716570ef2ee4bc496beb0"
 }

package/src/liveslots.js

@@ -752,32 +752,43 @@ function build(
       if (facet !== undefined) {
         result = vrm.getFacet(id, val, facet);
       }
-    } else {
+    } else if (type === 'object') {
+      // Note: an abandonned (e.g. by an upgrade) exported ephemeral or virtual
+      // object would appear as an import if re-introduced. In the future we
+      // may need to change that if we want to keep recognizing such references
+      // In that case we'd need to create an imported presence for these
+      // unknown vrefs allocated by the vat.
+      // See https://github.com/Agoric/agoric-sdk/issues/9746
       !allocatedByVat || Fail`I don't remember allocating ${slot}`;
-      if (type === 'object') {
-        // this is a new import value
-        val = makeImportedPresence(slot, iface);
-      } else if (type === 'promise') {
-        const pRec = makePipelinablePromise(slot);
-        importedVPIDs.set(slot, pRec);
-        val = pRec.promise;
-        // ideally we'd wait until .then is called on p before subscribing,
-        // but the current Promise API doesn't give us a way to discover
-        // this, so we must subscribe right away. If we were using Vows or
-        // some other then-able, we could just hook then() to notify us.
-        if (importedPromises) {
-          // leave the subscribe() up to dispatch.notify()
-          importedPromises.add(slot);
-        } else {
-          // probably in dispatch.deliver(), so subscribe now
-          syscall.subscribe(slot);
-        }
-      } else if (type === 'device') {
-        val = makeDeviceNode(slot, iface);
-        importedDevices.add(val);
+      // this is a new import value
+      val = makeImportedPresence(slot, iface);
+    } else if (type === 'promise') {
+      // We unconditionally create a promise record, even if the promise looks
+      // like it was allocated by us. This can happen when re-importing a
+      // promise created by the previous incarnation. We may or may not have
+      // been the decider of the promise. If we were, the kernel will be
+      // rejecting the promise on our behalf. We may have previously been
+      // subscribed to that promise, but subscription is idempotent.
+      const pRec = makePipelinablePromise(slot);
+      importedVPIDs.set(slot, pRec);
+      val = pRec.promise;
+      // ideally we'd wait until .then is called on p before subscribing,
+      // but the current Promise API doesn't give us a way to discover
+      // this, so we must subscribe right away. If we were using Vows or
+      // some other then-able, we could just hook then() to notify us.
+      if (importedPromises) {
+        // leave the subscribe() up to dispatch.notify()
+        importedPromises.add(slot);
       } else {
-        Fail`unrecognized slot type '${type}'`;
+        // probably in dispatch.deliver(), so subscribe now
+        syscall.subscribe(slot);
       }
+    } else if (type === 'device') {
+      !allocatedByVat || Fail`unexpected device ${slot} allocated by vat`;
+      val = makeDeviceNode(slot, iface);
+      importedDevices.add(val);
+    } else {
+      Fail`unrecognized slot type '${type}'`;
     }
     registerValue(baseRef, val, facet !== undefined);
     if (!result) {
@@ -790,7 +801,25 @@ function build(
     meterControl.assertNotMetered();
     const { type } = parseVatSlot(slot);
     type === 'promise' || Fail`revivePromise called on non-promise ${slot}`;
-    !getValForSlot(slot) || Fail`revivePromise called on pre-existing ${slot}`;
+    const val = getValForSlot(slot);
+    if (val) {
+      // revivePromise is only called by loadWatchedPromiseTable, which runs
+      // after buildRootObject(), which is given the deserialized vatParameters.
+      // The only way revivePromise() might encounter a pre-existing vpid is if
+      // these vatParameters include a promise that the previous incarnation
+      // watched, but that `buildRootObject` in the new incarnation didn't
+      // explicitly watch again. This can be either a previously imported
+      // promise, or a promise the previous incarnation exported, regardless of
+      // who the decider now is.
+      //
+      // In that case convertSlotToVal() has already deserialized the vpid, but
+      // since `buildRootObject` didn't explicitely call watchPromise on it, no
+      // registration exists so loadWatchedPromiseTable attempts to revive the
+      // promise.
+      return val;
+    }
+    // NOTE: it is important that this code not do anything *more*
+    // than what convertSlotToVal(vpid) would do
     const pRec = makePipelinablePromise(slot);
     importedVPIDs.set(slot, pRec);
     const p = pRec.promise;
@@ -1593,12 +1622,10 @@ function build(
     } else if (delivery[0] === 'stopVat') {
       return meterControl.runWithoutMeteringAsync(() => stopVat(delivery[1]));
     } else {
-      let complete = false;
       // Start user code running, record any internal liveslots errors. We do
       // *not* directly wait for the userspace function to complete, nor for
       // any promise it returns to fire.
       const p = Promise.resolve(delivery).then(unmeteredDispatch);
-      void p.finally(() => (complete = true));
 
       // Instead, we wait for userspace to become idle by draining the
       // promise queue. We clean up and then examine/return 'p' so any
@@ -1609,10 +1636,11 @@ function build(
       return gcTools.waitUntilQuiescent().then(() => {
         afterDispatchActions();
         // eslint-disable-next-line prefer-promise-reject-errors
-        return complete ? p : Promise.reject('buildRootObject unresolved');
+        return Promise.race([p, Promise.reject('buildRootObject unresolved')]);
         // the only delivery that pays attention to a user-provided
         // Promise is startVat, so the error message is specialized to
-        // the only user problem that could cause complete===false
+        // the only user problem that could cause the promise to not be
+        // settled.
       });
     }
   }

package/src/watchedPromises.js

@@ -139,6 +139,12 @@ export function makeWatchedPromiseManager({
    */
   function loadWatchedPromiseTable(revivePromise) {
     for (const vpid of watchedPromiseTable.keys()) {
+      if (promiseRegistrations.has(vpid)) {
+        // We're only interested in reconnecting the promises from the previous
+        // incarnation. Any promise watched during buildRootObject would have
+        // already created a registration.
+        continue;
+      }
       const p = revivePromise(vpid);
       promiseRegistrations.init(vpid, p);
       pseudoThen(p, vpid);

package/test/handled-promises.test.js

@@ -84,7 +84,7 @@ const makeExoUtils = VatData => {
 };
 
 // cf. packages/SwingSet/test/vat-durable-promise-watcher.js
-const buildPromiseWatcherRootObject = (vatPowers, _vatParameters, baggage) => {
+const buildPromiseWatcherRootObject = (vatPowers, vatParameters, baggage) => {
   const { VatData } = vatPowers;
   const { watchPromise } = VatData;
   const { prepareExo } = makeExoUtils(VatData);
@@ -93,37 +93,62 @@ const buildPromiseWatcherRootObject = (vatPowers, _vatParameters, baggage) => {
     onFulfilled: M.call(M.any(), M.string()).returns(),
     onRejected: M.call(M.any(), M.string()).returns(),
   });
+  const watchResolutions = new Map();
   const watcher = prepareExo(
     baggage,
+    // No longer ignoring, but the name is set in stone in `kvStoreDataV1`
     'DurablePromiseIgnorer',
     PromiseWatcherI,
     {
-      onFulfilled(_value, _name) {},
-      onRejected(_reason, _name) {},
+      onFulfilled(value, name) {
+        watchResolutions.set(name, { status: 'fulfilled', value });
+      },
+      onRejected(reason, name) {
+        watchResolutions.set(name, { status: 'rejected', reason });
+      },
     },
   );
 
-  const localPromises = new Map();
+  const knownPromises = new Map();
 
-  return Far('root', {
-    exportPromise: () => [Promise.resolve()],
+  const root = Far('root', {
+    getPromise: name => {
+      const promise = knownPromises.get(name);
+      promise || Fail`promise doesn't exists: ${name}`;
+      return { promise };
+    },
+    importPromise: (name, promise) => {
+      !knownPromises.has(name) || Fail`promise already exists: ${name}`;
+      knownPromises.set(name, promise);
+      return `imported promise: ${name}`;
+    },
     createLocalPromise: (name, fulfillment, rejection) => {
-      !localPromises.has(name) || Fail`local promise already exists: ${name}`;
+      !knownPromises.has(name) || Fail`promise already exists: ${name}`;
       const { promise, resolve, reject } = makePromiseKit();
       if (fulfillment !== undefined) {
         resolve(fulfillment);
       } else if (rejection !== undefined) {
         reject(rejection);
       }
-      localPromises.set(name, promise);
+      knownPromises.set(name, promise);
       return `created local promise: ${name}`;
     },
-    watchLocalPromise: name => {
-      localPromises.has(name) || Fail`local promise not found: ${name}`;
-      watchPromise(localPromises.get(name), watcher, name);
-      return `watched local promise: ${name}`;
+    watchPromise: name => {
+      knownPromises.has(name) || Fail`promise not found: ${name}`;
+      watchPromise(knownPromises.get(name), watcher, name);
+      return `watched promise: ${name}`;
+    },
+    getWatchResolution: name => {
+      return watchResolutions.get(name);
     },
   });
+
+  const startOperations = vatParameters?.startOperations || [];
+  for (const [method, ...args] of startOperations) {
+    root[method](...args);
+  }
+
+  return root;
 };
 const kvStoreDataV1 = Object.entries({
   baggageID: 'o+d6/1',
@@ -176,23 +201,55 @@ const kvStoreDataV1VpidsToKeep = ['p-8'];
 const kvStoreDataV1KeysToKeep = ['vc.4.sp-8'];
 
 test('past-incarnation watched promises', async t => {
+  const S = 'settlement';
+  // Anchor promise counters upon which the other assertions depend.
+  const firstPImport = 9;
+  // cf. src/liveslots.js:initialIDCounters
+  const firstPExport = 5;
+
+  const startImportedP = firstPImport - 2;
+
+  const v1StartOperations = [
+    ['createLocalPromise', 'start orphaned'],
+    ['watchPromise', 'start orphaned'],
+    ['createLocalPromise', 'start fulfilled', S],
+    ['watchPromise', 'start fulfilled'],
+    ['importPromise', 'start imported', kslot(`p-${startImportedP}`)],
+    ['watchPromise', 'start imported'],
+  ];
   const kvStore = new Map();
-  let { v, dispatch, dispatchMessage } = await setupTestLiveslots(
+  let {
+    v,
+    dispatch,
+    dispatchMessage: rawDispatch,
+  } = await setupTestLiveslots(
     t,
     buildPromiseWatcherRootObject,
     'durable-promise-watcher',
-    { kvStore },
+    {
+      kvStore,
+      nextPromiseImportNumber: firstPImport,
+      vatParameters: { startOperations: v1StartOperations },
+    },
   );
   let vatLogs = v.log;
 
-  // Anchor promise counters upon which the other assertions depend.
-  const firstPImport = 1;
-  // cf. src/liveslots.js:initialIDCounters
-  const firstPExport = 5;
   let lastPImport = firstPImport - 1;
   let lastPExport = firstPExport - 1;
+  let dispatches = 0;
+  const exportedPromises = new Set();
+  const v1OrphanedPExports = [];
   const nextPImport = () => (lastPImport += 1);
   const nextPExport = () => (lastPExport += 1);
+  /** @type {typeof rawDispatch} */
+  const dispatchMessage = (...args) => {
+    dispatches += 1;
+    return rawDispatch(...args);
+  };
+  const recordExportedPromise = name => {
+    exportedPromises.add(name);
+    return name;
+  };
   // Ignore vatstore syscalls.
   const getDispatchLogs = () =>
     vatLogs.splice(0).filter(m => !m.type.startsWith('vatstore'));
@@ -208,18 +265,55 @@ test('past-incarnation watched promises', async t => {
     type: 'subscribe',
     target: vpid,
   });
-  vatLogs.length = 0;
-  await dispatchMessage('exportPromise');
+
+  // startVat logs
+  v1OrphanedPExports.push(nextPExport());
+  recordExportedPromise('start orphaned');
+  v1OrphanedPExports.push(nextPExport());
+  recordExportedPromise('start fulfilled');
   t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, [kslot(`p+${nextPExport()}`)]),
-    fulfillmentMessage(`p+${lastPExport}`, undefined),
+    subscribeMessage(`p-${startImportedP}`),
+    subscribeMessage(`p+${lastPExport - 1}`),
+    subscribeMessage(`p+${lastPExport}`),
+    fulfillmentMessage(`p+${lastPExport}`, S),
+  ]);
+  await dispatchMessage('createLocalPromise', 'exported', S);
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: exported'),
+  ]);
+  await dispatchMessage('getPromise', recordExportedPromise('exported'));
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      promise: kslot(`p+${nextPExport()}`),
+    }),
+    fulfillmentMessage(`p+${lastPExport}`, S),
+  ]);
+  const importedP = firstPImport - 1;
+  await dispatchMessage('importPromise', 'imported', kslot(`p-${importedP}`));
+  t.deepEqual(getDispatchLogs(), [
+    subscribeMessage(`p-${importedP}`),
+    fulfillmentMessage(`p-${nextPImport()}`, 'imported promise: imported'),
   ]);
-
-  const S = 'settlement';
   await dispatchMessage('createLocalPromise', 'orphaned');
   t.deepEqual(getDispatchLogs(), [
     fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: orphaned'),
   ]);
+  await dispatchMessage('createLocalPromise', 'orphaned exported');
+  await dispatchMessage(
+    'getPromise',
+    recordExportedPromise('orphaned exported'),
+  );
+  const orphanedExportedP = nextPExport();
+  v1OrphanedPExports.push(orphanedExportedP);
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(
+      `p-${nextPImport()}`,
+      'created local promise: orphaned exported',
+    ),
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      promise: kslot(`p+${orphanedExportedP}`),
+    }),
+  ]);
   await dispatchMessage('createLocalPromise', 'fulfilled', S);
   t.deepEqual(getDispatchLogs(), [
     fulfillmentMessage(
@@ -233,68 +327,185 @@ test('past-incarnation watched promises', async t => {
   ]);
   t.is(
     lastPImport - firstPImport + 1,
-    4,
-    'imported 4 promises (1 per dispatch)',
+    dispatches,
+    `imported ${dispatches} promises (1 per dispatch)`,
+  );
+  t.is(
+    lastPExport - firstPExport + 1,
+    exportedPromises.size,
+    `exported ${exportedPromises.size} promises: ${[...exportedPromises].join(', ')}`,
   );
-  t.is(lastPExport - firstPExport + 1, 1, 'exported 1 promise: first');
 
-  await dispatchMessage('watchLocalPromise', 'orphaned');
+  await dispatchMessage('watchPromise', recordExportedPromise('orphaned'));
+  v1OrphanedPExports.push(nextPExport());
   t.deepEqual(getDispatchLogs(), [
-    subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched local promise: orphaned'),
+    subscribeMessage(`p+${lastPExport}`),
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: orphaned'),
   ]);
-  await dispatchMessage('watchLocalPromise', 'fulfilled');
+  await dispatchMessage('watchPromise', recordExportedPromise('fulfilled'));
   t.deepEqual(getDispatchLogs(), [
     subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(
-      `p-${nextPImport()}`,
-      'watched local promise: fulfilled',
-    ),
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: fulfilled'),
     fulfillmentMessage(`p+${lastPExport}`, S),
   ]);
-  await dispatchMessage('watchLocalPromise', 'rejected');
+  await dispatchMessage('watchPromise', recordExportedPromise('rejected'));
   t.deepEqual(getDispatchLogs(), [
     subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched local promise: rejected'),
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: rejected'),
     rejectionMessage(`p+${lastPExport}`, S),
   ]);
+  await dispatchMessage('watchPromise', 'imported');
+  t.deepEqual(getDispatchLogs(), [
+    // no subscribe, we already did at import
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: imported'),
+  ]);
+  await dispatchMessage('getWatchResolution', 'fulfilled');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: S,
+    }),
+  ]);
+  await dispatchMessage('getWatchResolution', 'rejected');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'rejected',
+      reason: S,
+    }),
+  ]);
+  await dispatchMessage('getWatchResolution', 'start fulfilled');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: S,
+    }),
+  ]);
+
   t.is(
     lastPImport - firstPImport + 1,
-    7,
-    'imported 7 promises (1 per dispatch)',
+    dispatches,
+    `imported ${dispatches} promises (1 per dispatch)`,
   );
   t.is(
     lastPExport - firstPExport + 1,
-    4,
-    'exported 4 promises: first, orphaned, fulfilled, rejected',
+    exportedPromises.size,
+    `exported ${exportedPromises.size} promises: ${[...exportedPromises].join(', ')}`,
   );
 
   // Simulate upgrade by starting from the non-empty kvStore.
   // t.log(Object.fromEntries([...kvStore.entries()].sort(compareEntriesByKey)));
   const clonedStore = new Map(kvStore);
-  ({ v, dispatch, dispatchMessage } = await setupTestLiveslots(
+  const startImported2P = firstPImport - 3;
+  const v2StartOperations = [
+    ['importPromise', 'start imported 2', kslot(`p-${startImported2P}`)], // import of new promise
+    ['importPromise', 'imported', kslot(`p-${importedP}`)], // import previously imported and watched promise
+    ['importPromise', 'orphaned exported', kslot(`p+${orphanedExportedP}`)], // import previously exported but unwatched promise
+    ['watchPromise', 'orphaned exported'],
+  ];
+  ({
+    v,
+    dispatch,
+    dispatchMessage: rawDispatch,
+  } = await setupTestLiveslots(
     t,
     buildPromiseWatcherRootObject,
     'durable-promise-watcher-v2',
-    { kvStore: clonedStore, nextPromiseImportNumber: lastPImport + 1 },
+    {
+      kvStore: clonedStore,
+      nextPromiseImportNumber: lastPImport + 1,
+      vatParameters: { startOperations: v2StartOperations },
+    },
   ));
   vatLogs = v.log;
 
+  // startVat logs
+  t.deepEqual(getDispatchLogs(), [
+    subscribeMessage(`p-${startImported2P}`),
+    subscribeMessage(`p-${importedP}`),
+    subscribeMessage(`p+${orphanedExportedP}`),
+  ]);
   // Simulate kernel rejection of promises orphaned by termination/upgrade of their decider vat.
   const expectedDeletions = [...clonedStore.entries()].filter(entry =>
     entry[1].includes('orphaned'),
   );
   t.true(expectedDeletions.length >= 1);
-  await dispatch(
-    makeReject(`p+${firstPExport + 1}`, kser('tomorrow never came')),
-  );
+  for (const orphanedPExport of v1OrphanedPExports) {
+    await dispatch(
+      makeReject(`p+${orphanedPExport}`, kser('tomorrow never came')),
+    );
+  }
+  await dispatchMessage('getWatchResolution', 'orphaned');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'rejected',
+      reason: 'tomorrow never came',
+    }),
+  ]);
+  await dispatchMessage('getWatchResolution', 'start orphaned');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'rejected',
+      reason: 'tomorrow never came',
+    }),
+  ]);
+  await dispatchMessage('getWatchResolution', 'orphaned exported');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'rejected',
+      reason: 'tomorrow never came',
+    }),
+  ]);
   for (const [key, value] of expectedDeletions) {
     t.false(clonedStore.has(key), `entry should be removed: ${key}: ${value}`);
   }
+  // Simulate resolution of imported promises watched in previous incarnation
+  await dispatch(makeResolve(`p-${importedP}`, kser(undefined)));
+  await dispatchMessage('getWatchResolution', 'imported');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: undefined,
+    }),
+  ]);
+  await dispatch(makeResolve(`p-${startImportedP}`, kser(undefined)));
+  await dispatchMessage('getWatchResolution', 'start imported');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: undefined,
+    }),
+  ]);
+  await dispatch(makeResolve(`p-${startImported2P}`, kser(undefined)));
+  await dispatchMessage('getWatchResolution', 'start imported 2');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, undefined),
+  ]);
+  // simulate resolution of imported promise watched after resolution
+  await dispatchMessage('watchPromise', 'start imported 2');
+  t.deepEqual(getDispatchLogs(), [
+    // Promise was previously resolved, so it is re-exported
+    subscribeMessage(`p+${nextPExport()}`),
+    fulfillmentMessage(
+      `p-${nextPImport()}`,
+      'watched promise: start imported 2',
+    ),
+    fulfillmentMessage(`p+${lastPExport}`, undefined),
+  ]);
+  await dispatchMessage('getWatchResolution', 'start imported 2');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: undefined,
+    }),
+  ]);
 
   // Verify that the data is still in loadable condition.
   const finalClonedStore = new Map(clonedStore);
-  ({ v, dispatch, dispatchMessage } = await setupTestLiveslots(
+  ({
+    v,
+    dispatch,
+    dispatchMessage: rawDispatch,
+  } = await setupTestLiveslots(
     t,
     buildPromiseWatcherRootObject,
     'durable-promise-watcher-final',
@@ -303,12 +514,17 @@ test('past-incarnation watched promises', async t => {
   vatLogs = v.log;
   vatLogs.length = 0;
   await dispatchMessage('createLocalPromise', 'final', S);
-  await dispatchMessage('watchLocalPromise', 'final');
+  await dispatchMessage('watchPromise', 'final');
+  await dispatchMessage('getWatchResolution', 'final');
   t.deepEqual(getDispatchLogs(), [
     fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: final'),
     subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched local promise: final'),
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: final'),
     fulfillmentMessage(`p+${lastPExport}`, S),
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: S,
+    }),
   ]);
 });
 

package/test/liveslots-helpers.js

@@ -131,6 +131,7 @@ export async function makeDispatch(
   build,
   vatID = 'vatA',
   liveSlotsOptions = {},
+  vatParameters = undefined,
 ) {
   const gcTools = harden({
     WeakRef,
@@ -150,7 +151,7 @@ export async function makeDispatch(
       return { buildRootObject: build };
     },
   );
-  await dispatch(['startVat', kser()]);
+  await dispatch(['startVat', kser(vatParameters)]);
   return { dispatch, testHooks };
 }
 
@@ -171,6 +172,7 @@ function makeRPMaker(nextNumber = 1) {
  * @param {Map<string, string>} [options.kvStore]
  * @param {number} [options.nextPromiseImportNumber]
  * @param {boolean} [options.skipLogging]
+ * @param {any} [options.vatParameters]
  */
 export async function setupTestLiveslots(
   t,
@@ -183,6 +185,7 @@ export async function setupTestLiveslots(
     kvStore = new Map(),
     nextPromiseImportNumber,
     skipLogging = false,
+    vatParameters,
   } = options;
   const { log, syscall, fakestore } = buildSyscall({ skipLogging, kvStore });
   const nextRP = makeRPMaker(nextPromiseImportNumber);
@@ -190,6 +193,8 @@ export async function setupTestLiveslots(
     syscall,
     buildRootObject,
     vatName,
+    {},
+    vatParameters,
   );
 
   async function dispatchMessage(message, ...args) {

package/test/vpid-liveslots.test.js

@@ -898,3 +898,104 @@ test('inter-vat circular promise references', async t => {
   // });
   // t.deepEqual(log, []);
 });
+
+test('accept previously allocated promise', async t => {
+  function build(vatPowers, vatParameters) {
+    const { target } = vatParameters;
+    return Far('root', {
+      call() {
+        const promise = E(target).foo();
+        // wrap to avoid adoption
+        return { promise };
+      },
+      async waitFor(promise2) {
+        // if we're in the same incarnation as the `E(target).foo()`, this
+        // `promise2` will be the same JS Promise as the `promise` above
+        const v = await promise2;
+        return v;
+      },
+    });
+  }
+
+  let log;
+  let syscall;
+  let dispatch;
+
+  const kvStore = new Map();
+  ({ log, syscall } = buildSyscall({ kvStore }));
+
+  const target = 'o-1';
+  ({ dispatch } = await makeDispatch(
+    syscall,
+    build,
+    'reimport-promise',
+    {},
+    { target: kslot(target) },
+  ));
+  log.length = 0; // assume pre-build vatstore operations are correct
+
+  const root = 'o+0';
+  const callResultP = 'p-1';
+  const waitForResultP = 'p-2';
+  const expectedP1 = 'p+5';
+
+  await dispatch(makeMessage(root, 'call', [], callResultP));
+
+  // The vat should send 'foo', subscribe to the result promise, and resolve with that promise
+  t.deepEqual(log.splice(0, 3), [
+    {
+      type: 'send',
+      targetSlot: target,
+      methargs: kser(['foo', []]),
+      resultSlot: expectedP1,
+    },
+    { type: 'subscribe', target: expectedP1 },
+    {
+      type: 'resolve',
+      resolutions: [[callResultP, false, kser({ promise: kslot(expectedP1) })]],
+    },
+  ]);
+  matchIDCounterSet(t, log);
+  t.deepEqual(log, []);
+
+  // snapshot the store at this point
+  const clonedStore = new Map(kvStore);
+
+  const verifyPromiseReImport = async shouldSubscribe => {
+    await dispatch(
+      makeMessage(root, 'waitFor', [kslot(expectedP1)], waitForResultP),
+    );
+
+    // The vat will only subscribe if it was upgraded; if the vat still
+    // remembers it, receiving the vref will merely look it up in slotToVal and
+    // not create a new Promise (and trigger a subscribe)
+    if (shouldSubscribe) {
+      t.deepEqual(log.shift(), { type: 'subscribe', target: expectedP1 });
+    }
+
+    // waitFor will suspend until promise is resolved
+    t.deepEqual(log, []);
+
+    // Resolution propagates the value to the waitFor result
+    await dispatch(makeResolve(expectedP1, kser('success')));
+    t.deepEqual(log.shift(), {
+      type: 'resolve',
+      resolutions: [[waitForResultP, false, kser('success')]],
+    });
+    t.deepEqual(log, []);
+  };
+
+  await verifyPromiseReImport(false);
+  ({ log, syscall } = buildSyscall({ kvStore: clonedStore }));
+  ({ dispatch } = await makeDispatch(
+    syscall,
+    build,
+    'reimport-promise-v2',
+    {},
+    {},
+  ));
+  log.length = 0;
+
+  // verify this works the same in the restarted vat
+  await verifyPromiseReImport(true);
+});