@agoric/swingset-liveslots 0.10.3-u19.1 → 0.10.3-u20.0

package/test/handled-promises.test.js

@@ -45,34 +45,50 @@ const buildPromiseWatcherRootObject = (vatPowers, vatParameters, baggage) => {
 
   const root = Far('root', {
     getPromise: name => {
-      const promise = knownPromises.get(name);
-      promise || Fail`promise doesn't exists: ${name}`;
+      knownPromises.has(name) || Fail`promise not found: ${name}`;
+      const { promise } = knownPromises.get(name);
       return { promise };
     },
     importPromise: (name, promise) => {
       !knownPromises.has(name) || Fail`promise already exists: ${name}`;
-      knownPromises.set(name, promise);
+      knownPromises.set(name, { promise });
       return `imported promise: ${name}`;
     },
     createLocalPromise: (name, fulfillment, rejection) => {
       !knownPromises.has(name) || Fail`promise already exists: ${name}`;
       const { promise, resolve, reject } = makePromiseKit();
+      let resolvers = {};
       if (fulfillment !== undefined) {
         resolve(fulfillment);
       } else if (rejection !== undefined) {
         reject(rejection);
+      } else {
+        resolvers = { resolve, reject };
       }
-      knownPromises.set(name, promise);
+      knownPromises.set(name, { promise, ...resolvers });
       return `created local promise: ${name}`;
     },
+    resolveLocalPromise: (name, rejection, value) => {
+      knownPromises.has(name) || Fail`promise not found: ${name}`;
+      const { resolve, reject, promise } = knownPromises.get(name);
+      (resolve && reject) || Fail`promise not resolvable: ${name}`;
+      (rejection ? reject : resolve)(value);
+      knownPromises.set(name, { promise });
+      return `resolved promise: ${name}`;
+    },
     watchPromise: name => {
       knownPromises.has(name) || Fail`promise not found: ${name}`;
-      watchPromise(knownPromises.get(name), watcher, name);
+      watchPromise(knownPromises.get(name).promise, watcher, name);
       return `watched promise: ${name}`;
     },
     getWatchResolution: name => {
       return watchResolutions.get(name);
     },
+    sendToPromise: (name, method, ...args) => {
+      knownPromises.has(name) || Fail`promise not found: ${name}`;
+      const { promise } = knownPromises.get(name);
+      return HandledPromise.applyMethod(promise, method, args);
+    },
   });
 
   const startOperations = vatParameters?.startOperations || [];
@@ -132,6 +148,29 @@ const kvStoreDataV1KeysToDelete = ['vc.4.sp+6', 'vc.4.sp-9'];
 const kvStoreDataV1VpidsToKeep = ['p-8'];
 const kvStoreDataV1KeysToKeep = ['vc.4.sp-8'];
 
+// Ignore vatstore syscalls.
+const extractDispatchLogs = vatLogs =>
+  vatLogs.splice(0).filter(m => !m.type.startsWith('vatstore'));
+
+const settlementMessage = (vpid, rejected, value) => ({
+  type: 'resolve',
+  resolutions: [[vpid, rejected, kser(value)]],
+});
+const fulfillmentMessage = (vpid, value) =>
+  settlementMessage(vpid, false, value);
+const rejectionMessage = (vpid, value) => settlementMessage(vpid, true, value);
+const subscribeMessage = vpid => ({
+  type: 'subscribe',
+  target: vpid,
+});
+
+/** @param {`p-${number}` | `p+${number}`} p */
+const extractPNum = p => {
+  const r = /^p[-+](\d+)$/.exec(p);
+  if (!r) throw Fail`Invalid promise ${p}`;
+  return parseInt(r[1], 10);
+};
+
 test('past-incarnation watched promises', async t => {
   const S = 'settlement';
   // Anchor promise counters upon which the other assertions depend.
@@ -139,14 +178,14 @@ test('past-incarnation watched promises', async t => {
   // cf. src/liveslots.js:initialIDCounters
   const firstPExport = 5;
 
-  const startImportedP = firstPImport - 2;
+  const startImportedP = `p-${firstPImport - 2}`;
 
   const v1StartOperations = [
     ['createLocalPromise', 'start orphaned'],
     ['watchPromise', 'start orphaned'],
     ['createLocalPromise', 'start fulfilled', S],
     ['watchPromise', 'start fulfilled'],
-    ['importPromise', 'start imported', kslot(`p-${startImportedP}`)],
+    ['importPromise', 'start imported', kslot(startImportedP)],
     ['watchPromise', 'start imported'],
   ];
   const kvStore = new Map();
@@ -166,172 +205,133 @@ test('past-incarnation watched promises', async t => {
   );
   let vatLogs = v.log;
 
-  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 {`p-${number}`} */
+  let rp = `p-0`;
   /** @type {typeof rawDispatch} */
-  const dispatchMessage = (...args) => {
-    dispatches += 1;
-    return rawDispatch(...args);
+  const dispatchMessage = async (...args) => {
+    rp = /** @type {`p-${number}`} */ (await rawDispatch(...args));
+    return rp;
   };
-  const recordExportedPromise = name => {
-    exportedPromises.add(name);
-    return name;
+  let lastPExport = firstPExport - 1;
+  const exportedPromises = new Map();
+  const recordNextExportedPromise = name => {
+    const p = `p+${(lastPExport += 1)}`;
+    exportedPromises.set(p, name);
+    return p;
+  };
+  const recordExportedPromiseNotification = p => {
+    t.true(exportedPromises.delete(p));
+    return p;
   };
-  // Ignore vatstore syscalls.
-  const getDispatchLogs = () =>
-    vatLogs.splice(0).filter(m => !m.type.startsWith('vatstore'));
-  const settlementMessage = (vpid, rejected, value) => ({
-    type: 'resolve',
-    resolutions: [[vpid, rejected, kser(value)]],
-  });
-  const fulfillmentMessage = (vpid, value) =>
-    settlementMessage(vpid, false, value);
-  const rejectionMessage = (vpid, value) =>
-    settlementMessage(vpid, true, value);
-  const subscribeMessage = vpid => ({
-    type: 'subscribe',
-    target: vpid,
-  });
 
   // startVat logs
-  v1OrphanedPExports.push(nextPExport());
-  recordExportedPromise('start orphaned');
-  v1OrphanedPExports.push(nextPExport());
-  recordExportedPromise('start fulfilled');
-  t.deepEqual(getDispatchLogs(), [
-    subscribeMessage(`p-${startImportedP}`),
-    subscribeMessage(`p+${lastPExport - 1}`),
-    subscribeMessage(`p+${lastPExport}`),
-    fulfillmentMessage(`p+${lastPExport}`, S),
+  const startOrphanedP = recordNextExportedPromise('start orphaned');
+  const startFulfilledP = recordNextExportedPromise('start fulfilled');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(startImportedP),
+    subscribeMessage(startOrphanedP),
+    subscribeMessage(startFulfilledP),
+    fulfillmentMessage(startFulfilledP, S),
   ]);
   await dispatchMessage('createLocalPromise', 'exported', S);
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: exported'),
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: exported'),
   ]);
-  await dispatchMessage('getPromise', recordExportedPromise('exported'));
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
-      promise: kslot(`p+${nextPExport()}`),
+  await dispatchMessage('getPromise', 'exported');
+  const exportedP = recordNextExportedPromise('exported');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
+      promise: kslot(exportedP),
     }),
-    fulfillmentMessage(`p+${lastPExport}`, S),
+    fulfillmentMessage(recordExportedPromiseNotification(exportedP), 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 importedP = `p-${firstPImport - 1}`;
+  await dispatchMessage('importPromise', 'imported', kslot(importedP));
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(importedP),
+    fulfillmentMessage(rp, 'imported promise: imported'),
   ]);
   await dispatchMessage('createLocalPromise', 'orphaned');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: orphaned'),
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, '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}`),
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: orphaned exported'),
+  ]);
+  await dispatchMessage('getPromise', 'orphaned exported');
+  const orphanedExportedP = recordNextExportedPromise('orphaned exported');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
+      promise: kslot(orphanedExportedP),
     }),
   ]);
   await dispatchMessage('createLocalPromise', 'fulfilled', S);
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(
-      `p-${nextPImport()}`,
-      'created local promise: fulfilled',
-    ),
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: fulfilled'),
   ]);
   await dispatchMessage('createLocalPromise', 'rejected', undefined, S);
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: rejected'),
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: rejected'),
   ]);
-  t.is(
-    lastPImport - firstPImport + 1,
-    dispatches,
-    `imported ${dispatches} promises (1 per dispatch)`,
-  );
-  t.is(
-    lastPExport - firstPExport + 1,
-    exportedPromises.size,
-    `exported ${exportedPromises.size} promises: ${[...exportedPromises].join(', ')}`,
-  );
 
-  await dispatchMessage('watchPromise', recordExportedPromise('orphaned'));
-  v1OrphanedPExports.push(nextPExport());
-  t.deepEqual(getDispatchLogs(), [
-    subscribeMessage(`p+${lastPExport}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: orphaned'),
+  await dispatchMessage('watchPromise', 'orphaned');
+  const orphanedP = recordNextExportedPromise('orphaned');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(orphanedP),
+    fulfillmentMessage(rp, 'watched promise: orphaned'),
   ]);
-  await dispatchMessage('watchPromise', recordExportedPromise('fulfilled'));
-  t.deepEqual(getDispatchLogs(), [
-    subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: fulfilled'),
-    fulfillmentMessage(`p+${lastPExport}`, S),
+  await dispatchMessage('watchPromise', 'fulfilled');
+  const fulfilledP = recordNextExportedPromise('fulfilled');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(fulfilledP),
+    fulfillmentMessage(rp, 'watched promise: fulfilled'),
+    fulfillmentMessage(recordExportedPromiseNotification(fulfilledP), S),
   ]);
-  await dispatchMessage('watchPromise', recordExportedPromise('rejected'));
-  t.deepEqual(getDispatchLogs(), [
-    subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: rejected'),
-    rejectionMessage(`p+${lastPExport}`, S),
+  await dispatchMessage('watchPromise', 'rejected');
+  const rejectedP = recordNextExportedPromise('rejected');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(rejectedP),
+    fulfillmentMessage(rp, 'watched promise: rejected'),
+    rejectionMessage(recordExportedPromiseNotification(rejectedP), S),
   ]);
   await dispatchMessage('watchPromise', 'imported');
-  t.deepEqual(getDispatchLogs(), [
+  t.deepEqual(extractDispatchLogs(vatLogs), [
     // no subscribe, we already did at import
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: imported'),
+    fulfillmentMessage(rp, 'watched promise: imported'),
   ]);
   await dispatchMessage('getWatchResolution', 'fulfilled');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'fulfilled',
       value: S,
     }),
   ]);
   await dispatchMessage('getWatchResolution', 'rejected');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'rejected',
       reason: S,
     }),
   ]);
   await dispatchMessage('getWatchResolution', 'start fulfilled');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'fulfilled',
       value: S,
     }),
   ]);
 
-  t.is(
-    lastPImport - firstPImport + 1,
-    dispatches,
-    `imported ${dispatches} promises (1 per dispatch)`,
-  );
-  t.is(
-    lastPExport - firstPExport + 1,
-    exportedPromises.size,
-    `exported ${exportedPromises.size} promises: ${[...exportedPromises].join(', ')}`,
-  );
+  const v2FirstPromise = extractPNum(rp) + 1;
 
   // Simulate upgrade by starting from the non-empty kvStore.
   // t.log(Object.fromEntries([...kvStore.entries()].sort(compareEntriesByKey)));
   const clonedStore = new Map(kvStore);
-  const startImported2P = firstPImport - 3;
+  const startImported2P = `p-${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
+    ['importPromise', 'start imported 2', kslot(startImported2P)], // import of new promise
+    ['importPromise', 'imported', kslot(importedP)], // import previously imported and watched promise
+    ['importPromise', 'orphaned exported', kslot(orphanedExportedP)], // import previously exported but unwatched promise
     ['watchPromise', 'orphaned exported'],
   ];
   ({
@@ -344,45 +344,44 @@ test('past-incarnation watched promises', async t => {
     'durable-promise-watcher-v2',
     {
       kvStore: clonedStore,
-      nextPromiseImportNumber: lastPImport + 1,
+      nextPromiseImportNumber: v2FirstPromise,
       vatParameters: { startOperations: v2StartOperations },
     },
   ));
   vatLogs = v.log;
 
   // startVat logs
-  t.deepEqual(getDispatchLogs(), [
-    subscribeMessage(`p-${startImported2P}`),
-    subscribeMessage(`p-${importedP}`),
-    subscribeMessage(`p+${orphanedExportedP}`),
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(startImported2P),
+    subscribeMessage(importedP),
+    subscribeMessage(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);
-  for (const orphanedPExport of v1OrphanedPExports) {
-    await dispatch(
-      makeReject(`p+${orphanedPExport}`, kser('tomorrow never came')),
-    );
+  for (const [orphanedPExport] of exportedPromises) {
+    await dispatch(makeReject(orphanedPExport, kser('tomorrow never came')));
   }
+  exportedPromises.clear();
   await dispatchMessage('getWatchResolution', 'orphaned');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'rejected',
       reason: 'tomorrow never came',
     }),
   ]);
   await dispatchMessage('getWatchResolution', 'start orphaned');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'rejected',
       reason: 'tomorrow never came',
     }),
   ]);
   await dispatchMessage('getWatchResolution', 'orphaned exported');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'rejected',
       reason: 'tomorrow never came',
     }),
@@ -391,46 +390,50 @@ test('past-incarnation watched promises', async t => {
     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 dispatch(makeResolve(importedP, kser(undefined)));
   await dispatchMessage('getWatchResolution', 'imported');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'fulfilled',
       value: undefined,
     }),
   ]);
-  await dispatch(makeResolve(`p-${startImportedP}`, kser(undefined)));
+  await dispatch(makeResolve(startImportedP, kser(undefined)));
   await dispatchMessage('getWatchResolution', 'start imported');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'fulfilled',
       value: undefined,
     }),
   ]);
-  await dispatch(makeResolve(`p-${startImported2P}`, kser(undefined)));
+  await dispatch(makeResolve(startImported2P, kser(undefined)));
   await dispatchMessage('getWatchResolution', 'start imported 2');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, undefined),
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, undefined),
   ]);
   // simulate resolution of imported promise watched after resolution
   await dispatchMessage('watchPromise', 'start imported 2');
-  t.deepEqual(getDispatchLogs(), [
+  const startImported2ReexportedP =
+    recordNextExportedPromise('start imported 2');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
     // Promise was previously resolved, so it is re-exported
-    subscribeMessage(`p+${nextPExport()}`),
+    subscribeMessage(startImported2ReexportedP),
+    fulfillmentMessage(rp, 'watched promise: start imported 2'),
     fulfillmentMessage(
-      `p-${nextPImport()}`,
-      'watched promise: start imported 2',
+      recordExportedPromiseNotification(startImported2ReexportedP),
+      undefined,
     ),
-    fulfillmentMessage(`p+${lastPExport}`, undefined),
   ]);
   await dispatchMessage('getWatchResolution', 'start imported 2');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'fulfilled',
       value: undefined,
     }),
   ]);
 
+  const finalFirstPromise = extractPNum(rp) + 1;
+
   // Verify that the data is still in loadable condition.
   const finalClonedStore = new Map(clonedStore);
   ({
@@ -441,19 +444,25 @@ test('past-incarnation watched promises', async t => {
     t,
     buildPromiseWatcherRootObject,
     'durable-promise-watcher-final',
-    { kvStore: finalClonedStore, nextPromiseImportNumber: lastPImport + 1 },
+    { kvStore: finalClonedStore, nextPromiseImportNumber: finalFirstPromise },
   ));
   vatLogs = v.log;
   vatLogs.length = 0;
+  t.deepEqual([...exportedPromises], [], 'exportedPromises is empty');
   await dispatchMessage('createLocalPromise', 'final', S);
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: final'),
+  ]);
   await dispatchMessage('watchPromise', 'final');
+  const finalP = recordNextExportedPromise('final');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(finalP),
+    fulfillmentMessage(rp, 'watched promise: final'),
+    fulfillmentMessage(recordExportedPromiseNotification(finalP), S),
+  ]);
   await dispatchMessage('getWatchResolution', 'final');
-  t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: final'),
-    subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: final'),
-    fulfillmentMessage(`p+${lastPExport}`, S),
-    fulfillmentMessage(`p-${nextPImport()}`, {
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
       status: 'fulfilled',
       value: S,
     }),
@@ -504,3 +513,360 @@ test('past-incarnation watched promises from original-format kvStore', async t =
     t.false(finalClonedStore.has(key), `key should be removed: ${key}`);
   }
 });
+
+test('watched local promises should not leak slotToVal entries', async t => {
+  const S = 'settlement';
+  // cf. src/liveslots.js:initialIDCounters
+  const firstPExport = 5;
+
+  const {
+    v: { log: vatLogs },
+    dispatchMessage,
+    testHooks,
+  } = await setupTestLiveslots(t, buildPromiseWatcherRootObject, 'vatA');
+  const { slotToVal } = testHooks;
+  const initial = slotToVal.size;
+
+  let lastPExport = firstPExport - 1;
+  const nextPExport = () => `p+${(lastPExport += 1)}`;
+
+  let rp;
+
+  // Watch already resolved promise
+  rp = await dispatchMessage('createLocalPromise', 'p1', S);
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: p1'),
+  ]);
+  rp = await dispatchMessage('watchPromise', 'p1');
+  const p1 = nextPExport();
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(p1),
+    fulfillmentMessage(rp, 'watched promise: p1'),
+    fulfillmentMessage(p1, S),
+  ]);
+  t.is(slotToVal.size, initial); // exported promise did not leak
+  rp = await dispatchMessage('getWatchResolution', 'p1');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
+      status: 'fulfilled',
+      value: S,
+    }),
+  ]);
+
+  // Watch subsequently resolved promise
+  rp = await dispatchMessage('createLocalPromise', 'p2');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: p2'),
+  ]);
+  t.is(slotToVal.size, initial);
+
+  rp = await dispatchMessage('watchPromise', 'p2');
+  const p2 = nextPExport();
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(p2),
+    fulfillmentMessage(rp, 'watched promise: p2'),
+  ]);
+  t.is(slotToVal.size, initial + 1); // exported promise
+
+  rp = await dispatchMessage('resolveLocalPromise', 'p2', false, S);
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(p2, S),
+    fulfillmentMessage(rp, 'resolved promise: p2'),
+  ]);
+  t.is(slotToVal.size, initial); // exported promise did not leak
+
+  rp = await dispatchMessage('getWatchResolution', 'p2');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, {
+      status: 'fulfilled',
+      value: S,
+    }),
+  ]);
+});
+
+// Remaining case for https://github.com/Agoric/agoric-sdk/issues/10756
+// The workaround doesn't handle this case because it learns about the
+// settlement before the virtual object system
+// See https://github.com/Agoric/agoric-sdk/issues/10757
+test('watched imported promises should not leak slotToVal entries', async t => {
+  const S = 'settlement';
+  // cf. src/liveslots.js:initialIDCounters
+  const firstPExport = 5;
+
+  const {
+    v: { log: vatLogs },
+    dispatch,
+    dispatchMessage,
+    nextPImport,
+    testHooks,
+  } = await setupTestLiveslots(t, buildPromiseWatcherRootObject, 'vatA');
+  const { slotToVal } = testHooks;
+  const initial = slotToVal.size;
+
+  let lastPExport = firstPExport - 1;
+  const nextPExport = () => `p+${(lastPExport += 1)}`;
+
+  let rp;
+
+  // Watch already imported promise
+  const importedP = nextPImport();
+  rp = await dispatchMessage('importPromise', 'importedP', kslot(importedP));
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(importedP),
+    fulfillmentMessage(rp, 'imported promise: importedP'),
+  ]);
+  t.is(slotToVal.size, initial + 1); // imported promise
+
+  rp = await dispatchMessage('watchPromise', 'importedP');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'watched promise: importedP'),
+  ]);
+  t.is(slotToVal.size, initial + 1); // imported promise
+
+  await dispatch(makeResolve(importedP, kser(S)));
+  t.deepEqual(extractDispatchLogs(vatLogs), []);
+  t.is(slotToVal.size, initial); // should not leak
+
+  rp = await dispatchMessage('getPromise', 'importedP');
+  const reexportedP = nextPExport(); // Should allocate a new exported promise
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, { promise: kslot(reexportedP) }),
+    fulfillmentMessage(reexportedP, S),
+  ]);
+  t.is(slotToVal.size, initial); // reexported promise did not leak
+});
+
+test('known imported promises in resolutions should not leak slotToVal entries', async t => {
+  const S = 'settlement';
+  // cf. src/liveslots.js:initialIDCounters
+  const firstPExport = 5;
+
+  const {
+    v: { log: vatLogs },
+    dispatch,
+    dispatchMessage,
+    nextPImport,
+    testHooks,
+  } = await setupTestLiveslots(t, buildPromiseWatcherRootObject, 'vatA');
+  const { slotToVal } = testHooks;
+  const initial = slotToVal.size;
+
+  let lastPExport = firstPExport - 1;
+  const nextPExport = () => `p+${(lastPExport += 1)}`;
+
+  let rp;
+
+  const importedP = nextPImport();
+  rp = await dispatchMessage('importPromise', 'importedP', kslot(importedP));
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    subscribeMessage(importedP),
+    fulfillmentMessage(rp, 'imported promise: importedP'),
+  ]);
+  t.is(slotToVal.size, initial + 1); // imported promise
+
+  rp = await dispatchMessage('getPromise', 'importedP');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, { promise: kslot(importedP) }),
+  ]);
+  t.is(slotToVal.size, initial + 1); // imported promise
+
+  await dispatch(makeResolve(importedP, kser(S)));
+  t.deepEqual(extractDispatchLogs(vatLogs), []);
+  t.is(slotToVal.size, initial); // promise no longer imported
+
+  // The first getPromise causes liveslots to learn about the resolution value
+  // of importedP since liveslots currently only tracks known promise
+  // resolutions on export.
+  rp = await dispatchMessage('getPromise', 'importedP');
+  const reexportedP = nextPExport();
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, { promise: kslot(reexportedP) }),
+    fulfillmentMessage(reexportedP, S), // liveslots learns about the resolution
+  ]);
+  t.is(slotToVal.size, initial);
+
+  // The second getPromise verifies that liveslots does not leak when notifying
+  // a known resolved promise. It allocates a new exported promise because the
+  // resolution was previously notified
+  rp = await dispatchMessage('getPromise', 'importedP');
+  const reexportedP2 = nextPExport(); // allocates a new export promise
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    {
+      type: 'resolve',
+      resolutions: [
+        [rp, false, kser({ promise: kslot(reexportedP2) })],
+        [reexportedP2, false, kser(S)], // one shot resolution notification
+      ],
+    },
+  ]);
+  t.is(slotToVal.size, initial); // did not leak reexportedP2
+
+  // The 3rd getPromise ensures that the 2nd fully cleaned up, and that liveslots
+  // doesn't attempt to re-use a the previously exported promise
+  rp = await dispatchMessage('getPromise', 'importedP');
+  const reexportedP3 = nextPExport(); // allocates a new export promise
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    {
+      type: 'resolve',
+      resolutions: [
+        [rp, false, kser({ promise: kslot(reexportedP3) })],
+        [reexportedP3, false, kser(S)], // still one shot resolution
+      ],
+    },
+  ]);
+  t.is(slotToVal.size, initial); // did not leak reexportedP3
+});
+
+test('known exported promises in resolutions should not leak slotToVal entries', async t => {
+  const S = 'settlement';
+  // cf. src/liveslots.js:initialIDCounters
+  const firstPExport = 5;
+
+  const {
+    v: { log: vatLogs },
+    dispatchMessage,
+    testHooks,
+  } = await setupTestLiveslots(t, buildPromiseWatcherRootObject, 'vatA');
+  const { slotToVal } = testHooks;
+  const initial = slotToVal.size;
+
+  let lastPExport = firstPExport - 1;
+  const nextPExport = () => `p+${(lastPExport += 1)}`;
+
+  let rp;
+
+  rp = await dispatchMessage('createLocalPromise', 'localP');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: localP'),
+  ]);
+  t.is(slotToVal.size, initial);
+
+  rp = await dispatchMessage('getPromise', 'localP');
+  const localP = nextPExport();
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, { promise: kslot(localP) }),
+  ]);
+  t.is(slotToVal.size, initial + 1); // exported promise
+
+  rp = await dispatchMessage('resolveLocalPromise', 'localP', false, S);
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(localP, S),
+    fulfillmentMessage(rp, 'resolved promise: localP'),
+  ]);
+  t.is(slotToVal.size, initial); // promise no longer exported
+
+  // The first getPromise verifies that liveslots does not leak when notifying
+  // a known resolved promise. It allocates a new exported promise because the
+  // resolution was previously notified
+  rp = await dispatchMessage('getPromise', 'localP');
+  const reexportedP = nextPExport();
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    {
+      type: 'resolve',
+      resolutions: [
+        [rp, false, kser({ promise: kslot(reexportedP) })],
+        [reexportedP, false, kser(S)], // one shot resolution notification
+      ],
+    },
+  ]);
+  t.is(slotToVal.size, initial);
+
+  // The second getPromise ensures that previous fully cleaned up, and that
+  // liveslots doesn't attempt to re-use a the previously exported promise
+  rp = await dispatchMessage('getPromise', 'localP');
+  const reexportedP2 = nextPExport(); // allocates a new export promise
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    {
+      type: 'resolve',
+      resolutions: [
+        [rp, false, kser({ promise: kslot(reexportedP2) })],
+        [reexportedP2, false, kser(S)], // still one shot resolution
+      ],
+    },
+  ]);
+  t.is(slotToVal.size, initial); // did not leak reexportedP2
+});
+
+test('known promises in message sends should not leak slotToVal entries', async t => {
+  const S = 'settlement';
+  // cf. src/liveslots.js:initialIDCounters
+  const firstPExport = 5;
+
+  const targetO = `o-1`;
+
+  const {
+    v: { log: vatLogs },
+    dispatch,
+    dispatchMessage,
+    testHooks,
+  } = await setupTestLiveslots(t, buildPromiseWatcherRootObject, 'vatA', {
+    vatParameters: {
+      startOperations: [['createLocalPromise', 'target', kslot(targetO)]],
+    },
+  });
+  const { slotToVal } = testHooks;
+  const initial = slotToVal.size;
+
+  let lastPExport = firstPExport - 1;
+  const nextPExport = () => `p+${(lastPExport += 1)}`;
+
+  let rp;
+
+  rp = await dispatchMessage('createLocalPromise', 'targetP');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: targetP'),
+  ]);
+  t.is(slotToVal.size, initial);
+
+  rp = await dispatchMessage('createLocalPromise', 'localP');
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'created local promise: localP'),
+  ]);
+  t.is(slotToVal.size, initial);
+
+  rp = await dispatchMessage('getPromise', 'localP');
+  const localP = nextPExport();
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, { promise: kslot(localP) }),
+  ]);
+  t.is(slotToVal.size, initial + 1); // localP promise
+
+  rp = await dispatchMessage('sendToPromise', 'targetP', 'foo', kslot(localP));
+  const sendToPromiseResultP = rp;
+  t.deepEqual(extractDispatchLogs(vatLogs), []);
+  t.is(slotToVal.size, initial + 2); // localP and sendToPromiseResultP promises
+
+  rp = await dispatchMessage('resolveLocalPromise', 'localP', false, S);
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(localP, S),
+    fulfillmentMessage(rp, 'resolved promise: localP'),
+  ]);
+  t.is(slotToVal.size, initial + 1); // sendToPromiseResultP promise
+
+  rp = await dispatchMessage(
+    'resolveLocalPromise',
+    'targetP',
+    false,
+    kslot(targetO),
+  );
+  const reexportedP = nextPExport(); // Allocate a new promise for importedP
+  const sendResultP = nextPExport();
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(rp, 'resolved promise: targetP'), // no await so first syscall
+    {
+      type: 'send',
+      targetSlot: targetO,
+      methargs: kser(['foo', [kslot(reexportedP)]]),
+      resultSlot: sendResultP,
+    },
+    fulfillmentMessage(reexportedP, S), // known resolutions comes before subscribe of send result
+    subscribeMessage(sendResultP),
+  ]);
+  t.is(slotToVal.size, initial + 2); // sendToPromiseResultP and sendResultP promises
+
+  await dispatch(makeResolve(sendResultP, kser(S)));
+  t.deepEqual(extractDispatchLogs(vatLogs), [
+    fulfillmentMessage(sendToPromiseResultP, S),
+  ]);
+  t.is(slotToVal.size, initial);
+});