chore(vat-upgrade): upgrade agoricNames, test old values are preserved

a3p-integration/proposals/p:upgrade-19/.gitignore

@@ -1,4 +1,7 @@
 replaceFeeDistributor/
 testUpgradedBoard/
 addUsdLemons/
+addUsdOlives/
 upgradeProvisionPool/
+upgradeAgoricNames/
+publishTestInfo/

a3p-integration/proposals/p:upgrade-19/agoricNames.test.js

 ); 
 const updated = (updateCallback, hub, _newValue = undefined) => { 
   if (!updateCallback) { 
     return; 
   } 
   // wait for values to settle before writing 
   return E.when(deeplyFulfilledObject(hub.entries()), settledEntries => 
     E(updateCallback).write(settledEntries), 
   ); 
 }; 
 await E(nameAdmin).onUpdate( 
   // XXX will live on the heap in the bootstrap vat. When we upgrade or kill 
   // that this handler will sever and vat-agoricNames will need to be upgraded 
   // to allow changing the handler, or to use pubsub mechanics instead. 
   Far('chain info writer', { 
     write(entries) { 
       // chainInfo has no cap data but we need to marshal bigints 
       const marshalData = makeMarshal(_val => Fail`data only`); 
       for (const [chainName, info] of entries) { 
         const value = JSON.stringify(marshalData.toCapData(info)); 
         if (prev[chainName] === value) { 
           continue; 
         } 
         const chainNode = E(chainNamesNode).makeChildNode(chainName); 
         prev[chainName] = value; 
         void E(chainNode) 
           .setValue(value) 
           .catch(() => delete prev[chainName]); 
       } 
     }, 
   }), 
 ); 
@@ -0,0 +1,236 @@
+/* eslint-env node */
+
+/**
+ * @file The goal of this file is to test different aspects of agoricNames to make sure
+ * everything works after an upgrade. Here's the test plan;
+ * 1. publish a new node called 'testInfo' under agoricNames
+ *    CONTEXT: onUpdate callback of testInfo nameAdmin is registered in a core-eval. Which means it is
+ *    both ephemeral and lives in bootstrap vat. We create a scenario like this to make sure any ephemeral
+ *    onUpdate keeps working after an agoricNames upgrade.
+ * 2. upgrade agoricNames
+ * 3. send a core-eval that writes into children of agoricNames (brand, issuer, instance...)
+ *   3b. expect a child nameHub of agoricNames will publish ALL its entries when a new item is written to it
+ *   3c. check the values in the vstorage match before and after the upgrade
+ *   3d. also check that new items are in the vstorage as well
+ * 4. append new chain
+ *    CONTEXT: there are two new children introduced to agoricNames by orchestration and their
+ *    onUpdate callback isn't durable. So we must check that if we write a new chain info to those child
+ *    nameHubs, we should observe the new value in vstorage.
+ *   4b. send a core-eval that writes new chain info to published.agoricNames.chain and published.agoricNames.chainConnection
+ *   4c. wait until the expected data observed in vstorage
+ *
+ *
+ * TESTING CODE THAT HOLDS ONTO 'agoricNames': smartWallet is one of the vats that depend on agoricNames to work properly the most.
+ * smartWallet uses agoricNames to;
+ * - create purses for known brands
+ *   - looks for the brand in agoricNames.brand
+ *   - creates a purse for the brand using the issuer in agoricNames.issuer
+ * - create invitations for a from the publicFacet of a given instance (agoricNames.instance)
+ *
+ * So the fact that a user can complete an offer successfully means;
+ * - smartWallet can find the instance on agoricNames.instance (for invitationSource = 'agoricContract')
+ * - smartWallet can find, if not present create, a purse for known brand, agoricNames.brand
+ * and agoricNames.issuer returned correct values
+ *
+ *
+ * 5. add a new PSM and swap against it
+ *   5b. adding the new PSM requires introducing a new asset to the chain and writing
+ *       the PSM instance to agoricNames.instance
+ *   5c. being able to deposit the new asset to a user means that smartWallet created a purse
+ *       for the new brand
+ *   5d. being able to send the offer to the PSM instance means smartWallet can find the instance
+ *       in agoricNames.instance
+ *
+ * 6. we want to make sure objects that were already in agoricNames works as well, so open a vault
+ *    in an existing collateralManager
+ *   6a. fund GOV1 with ATOM
+ *   6b. open a vault
+ *   6c. check the vault is opened successfully
+ *
+ */
+
+import '@endo/init';
+import test from 'ava';
+import {
+  agoric,
+  ATOM_DENOM,
+  evalBundles,
+  getIncarnation,
+  GOV1ADDR,
+  openVault,
+} from '@agoric/synthetic-chain';
+import { makeVstorageKit, retryUntilCondition } from '@agoric/client-utils';
+import {
+  bankSend,
+  extractBalance,
+  psmSwap,
+  tryISTBalances,
+} from './test-lib/psm-lib.js';
+import { getBalances, listVaults } from './test-lib/utils.js';
+import { walletUtils } from './test-lib/index.js';
+
+const AGORIC_NAMES_UPGRADE_DIR = 'agoricNamesCoreEvals/upgradeAgoricNames';
+const WRITE_AGORIC_NAMES_DIR = 'agoricNamesCoreEvals/writeToAgoricNames';
+const ADD_USD_OLIVES_DIR = 'agoricNamesCoreEvals/addUsdOlives';
+const DEPOSIT_USD_OLIVES_DIR = 'agoricNamesCoreEvals/depositUsdOlives';
+const PUBLISH_TEST_INFO_DIR = 'agoricNamesCoreEvals/publishTestInfo';
+const WRITE_TEST_INFO_DIR = 'agoricNamesCoreEvals/writeToTestInfo';
+
+const makeWaitUntilKeyFound = (keyFinder, vstorage) => (path, targetKey) =>
+  retryUntilCondition(
+    () => vstorage.keys(path),
+    keys => keyFinder(keys, targetKey),
+    'Key not found.',
+    { maxRetries: 5, retryIntervalMs: 2000, log: console.log, setTimeout },
+  );
+
+test.before(async t => {
+  const vstorageKit = await makeVstorageKit(
+    { fetch },
+    { rpcAddrs: ['http://localhost:26657'], chainName: 'agoriclocal' },
+  );
+
+  t.context = {
+    vstorageKit,
+  };
+});
+
+test.serial('publish test info', async t => {
+  // @ts-expect-error casting
+  const { vstorageKit } = t.context;
+
+  const waitUntilKeyFound = makeWaitUntilKeyFound(
+    (keys, targetKey) => keys.includes(targetKey),
+    vstorageKit.vstorage,
+  );
+
+  await evalBundles(PUBLISH_TEST_INFO_DIR);
+  await waitUntilKeyFound('published.agoricNames', 'testInfo');
+
+  const testInfo = await vstorageKit.readLatestHead(
+    'published.agoricNames.testInfo',
+  );
+  t.deepEqual(Object.fromEntries(testInfo), {
+    agoric: {
+      isAwesome: 'yes',
+      tech: ['HardenedJs', 'Orchestration', 'Async_Execution'],
+    },
+  });
+});
+
+test.serial('upgrade agoricNames', async t => {
+  await evalBundles(AGORIC_NAMES_UPGRADE_DIR);
+
+  const incarnation = await getIncarnation('agoricNames');
+  t.is(incarnation, 1, 'incorrect incarnation');
+});
+
+test.serial('check all existing values are preserved', async t => {
+  // @ts-expect-error casting
+  const { vstorageKit } = t.context;
+  const agoricNamesChildren = [
+    'brand',
+    'installation',
+    'instance',
+    'issuer',
+    'oracleBrand',
+    'vbankAsset',
+  ];
+
+  const getAgoricNames = () =>
+    Promise.all(
+      agoricNamesChildren.map(async child => {
+        const content = await vstorageKit.readLatestHead(
+          `published.agoricNames.${child}`,
+        );
+        return [child, Object.fromEntries(content)];
+      }),
+    ).then(rawAgoricNames => Object.fromEntries(rawAgoricNames));
+
+  const agoricNamesBefore = await getAgoricNames();
+  console.log('AGORIC_NAMES_BEFORE', agoricNamesBefore);
+
+  await evalBundles(WRITE_AGORIC_NAMES_DIR);
+
+  const agoricNamesAfter = await getAgoricNames();
+  t.like(agoricNamesAfter, agoricNamesBefore);
+
+  agoricNamesChildren.forEach(child =>
+    assert(
+      agoricNamesAfter[child][`test${child}`],
+      'we should be able to add new value',
+    ),
+  );
+});
+
+test.serial('check testInfo still works', async t => {
+  // @ts-expect-error casting
+  const { vstorageKit } = t.context;
+  await evalBundles(WRITE_TEST_INFO_DIR);
+
+  const testInfo = await vstorageKit.readLatestHead(
+    'published.agoricNames.testInfo',
+  );
+  t.deepEqual(Object.fromEntries(testInfo), {
+    agoric: {
+      isAwesome: 'yes',
+      tech: ['HardenedJs', 'Orchestration', 'Async_Execution'],
+    },
+    ethereum: {
+      isAwesome: 'yes',
+      tech: ['Solidity', 'EVM'],
+    },
+  });
+});
+
+test.serial('check contracts depend on agoricNames are not broken', async t => {
+  await evalBundles(ADD_USD_OLIVES_DIR);
+  await evalBundles(DEPOSIT_USD_OLIVES_DIR);
+
+  const psmSwapIo = {
+    now: Date.now,
+    follow: agoric.follow,
+    setTimeout,
+    log: console.log,
+  };
+
+  const balancesBefore = await getBalances([GOV1ADDR]);
+
+  await psmSwap(
+    GOV1ADDR,
+    ['swap', '--pair', 'IST.USD_OLIVES', '--wantMinted', 1],
+    psmSwapIo,
+  );
+
+  const balancesAfter = await getBalances([GOV1ADDR]);
+  await tryISTBalances(
+    t,
+    extractBalance(balancesAfter, 'uist'),
+    extractBalance(balancesBefore, 'uist') + 1000000, // in uist
+  );
+});
+
+test.serial('open a vault', async t => {
+  await bankSend(GOV1ADDR, `200000000000000000${ATOM_DENOM}`);
+  const istBalanceBefore = await getBalances([GOV1ADDR]);
+  const activeVaultsBefore = await listVaults(GOV1ADDR, walletUtils);
+
+  const mint = '5.0';
+  const collateral = '10.0';
+  await openVault(GOV1ADDR, mint, collateral);
+
+  const istBalanceAfter = await getBalances([GOV1ADDR]);
+  const activeVaultsAfter = await listVaults(GOV1ADDR, walletUtils);
+
+  await tryISTBalances(
+    t,
+    extractBalance(istBalanceAfter, 'uist'),
+    extractBalance(istBalanceBefore, 'uist') + 5000000,
+  );
+
+  t.is(
+    activeVaultsAfter.length,
+    activeVaultsBefore.length + 1,
+    `The number of active vaults should increase after opening a new vault.`,
+  );
+});

a3p-integration/proposals/p:upgrade-19/agoricNamesCoreEvals/depositUsdOlives/deposit-usd-olives-permit.json

@@ -0,0 +1,7 @@
+{
+    "consume": {
+      "contractKits": true,
+      "namesByAddressAdmin": true,
+      "agoricNames": true
+    }
+}

a3p-integration/proposals/p:upgrade-19/agoricNamesCoreEvals/depositUsdOlives/deposit-usd-olives.js

@@ -0,0 +1,52 @@
+// @ts-nocheck
+/* eslint-disable no-undef */
+const GOV_ONE_ADDR = 'agoric1ee9hr0jyrxhy999y755mp862ljgycmwyp4pl7q';
+
+const depositUsdOlives = async powers => {
+  const {
+    consume: {
+      contractKits: contractKitsP,
+      namesByAddressAdmin: namesByAddressAdminP,
+      agoricNames,
+    },
+  } = powers;
+
+  const namesByAddressAdmin = await namesByAddressAdminP;
+
+  const getDepositFacet = async address => {
+    const hub = E(E(namesByAddressAdmin).lookupAdmin(address)).readonly();
+    return E(hub).lookup('depositFacet');
+  };
+
+  const [contractKits, usdOlivesIssuer, usdOlivesBrand, ppDepositFacet] =
+    await Promise.all([
+      contractKitsP,
+      E(agoricNames).lookup('issuer', 'USD_OLIVES'),
+      E(agoricNames).lookup('brand', 'USD_OLIVES'),
+      getDepositFacet(GOV_ONE_ADDR),
+    ]);
+
+  console.log('[CONTRACT_KITS]', contractKits);
+  console.log('[ISSUER]', usdOlivesIssuer);
+
+  let usdOlivesMint;
+  for (const { publicFacet, creatorFacet: mint } of contractKits.values()) {
+    if (publicFacet === usdOlivesIssuer) {
+      usdOlivesMint = mint;
+      console.log('BINGO', mint);
+      break;
+    }
+  }
+
+  console.log('Minting USD_OLIVES');
+  const helloPayment = await E(usdOlivesMint).mintPayment(
+    harden({ brand: usdOlivesBrand, value: 1_000_000n }),
+  );
+
+  console.log('Funding provision pool...');
+  await E(ppDepositFacet).receive(helloPayment);
+
+  console.log('Done.');
+};
+
+depositUsdOlives;

a3p-integration/proposals/p:upgrade-19/agoricNamesCoreEvals/writeToAgoricNames/write-to-agoricNames-permit.json

@@ -0,0 +1,5 @@
+{
+    "consume": {
+        "agoricNamesAdmin": true
+    }
+}

a3p-integration/proposals/p:upgrade-19/agoricNamesCoreEvals/writeToAgoricNames/write-to-agoricNames.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+/* eslint-disable no-undef */
+const writeToAgoricNames = async powers => {
+  const {
+    consume: { agoricNamesAdmin },
+  } = powers;
+
+  console.log('writing to agoricNames...');
+  const agoricNamesChildren = [
+    'brand',
+    'installation',
+    'instance',
+    'issuer',
+    'oracleBrand',
+    'vbankAsset',
+  ];
+
+  await Promise.all(
+    agoricNamesChildren.map(async (child, index) =>
+      E(E(agoricNamesAdmin).lookupAdmin(child)).update(
+        `test${child}`,
+        Far(`test${child}`, { getBoardId: () => `board${index}` }),
+      ),
+    ),
+  );
+
+  console.log('DONE');
+};
+
+writeToAgoricNames;

a3p-integration/proposals/p:upgrade-19/agoricNamesCoreEvals/writeToTestInfo/write-to-testInfo-permit.json

@@ -0,0 +1,5 @@
+{
+    "consume": {
+        "agoricNamesAdmin": true
+    }
+}

a3p-integration/proposals/p:upgrade-19/agoricNamesCoreEvals/writeToTestInfo/write-to-testInfo.js

@@ -0,0 +1,18 @@
+// @ts-nocheck
+/* eslint-disable no-undef */
+const writeToTestInfo = async powers => {
+  const {
+    consume: { agoricNamesAdmin },
+  } = powers;
+
+  console.log('writing to testInfo...');
+
+  E(E(agoricNamesAdmin).lookupAdmin('testInfo')).update('ethereum', {
+    isAwesome: 'yes',
+    tech: ['Solidity', 'EVM'],
+  });
+
+  console.log('DONE');
+};
+
+writeToTestInfo;

a3p-integration/proposals/p:upgrade-19/package.json

@@ -7,7 +7,10 @@
       "vats/upgrade-provisionPool.js upgradeProvisionPool",
       "vats/upgrade-paRegistry.js",
       "vats/upgrade-board.js",
-      "testing/test-upgraded-board.js testUpgradedBoard"
+      "testing/test-upgraded-board.js testUpgradedBoard",
+      "vats/upgrade-agoricNames.js agoricNamesCoreEvals/upgradeAgoricNames",
+      "testing/add-USD-OLIVES.js agoricNamesCoreEvals/addUsdOlives",
+      "testing/publish-test-info.js agoricNamesCoreEvals/publishTestInfo"
     ]
   },
   "type": "module",
@@ -21,6 +24,7 @@
     "@endo/errors": "1.2.7",
     "@endo/init": "^1.1.5",
     "@endo/marshal": "^1.5.4",
+    "agoric": "dev",
     "ava": "^5.3.1",
     "better-sqlite3": "^9.6.0",
     "execa": "9.1.0"