@agoric/cosmic-swingset 0.40.0 → 0.40.1-dev-800c2bb.0

package/src/params.js

@@ -1,16 +1,14 @@
 // @ts-check
-import { assert, details as X } from '@agoric/assert';
-import { Nat, isNat } from '@agoric/nat';
+// @jessie-check
+
+import { Fail } from '@agoric/assert';
+import { Nat, isNat } from '@endo/nat';
 
 export const stringToNat = s => {
-  assert.typeof(s, 'string', X`${s} must be a string`);
+  typeof s === 'string' || Fail`${s} must be a string`;
   const bint = BigInt(s);
   const nat = Nat(bint);
-  assert.equal(
-    `${nat}`,
-    s,
-    X`${s} must be the canonical representation of ${nat}`,
-  );
+  `${nat}` === s || Fail`${s} must be the canonical representation of ${nat}`;
   return nat;
 };
 
@@ -18,15 +16,18 @@ export const stringToNat = s => {
 export const parseQueueSizes = queueSizeEntries =>
   Object.fromEntries(
     queueSizeEntries.map(({ key, size }) => {
-      assert.typeof(key, 'string', X`Key ${key} must be a string`);
-      assert(isNat(size), X`Size ${size} is not a positive integer`);
+      typeof key === 'string' || Fail`Key ${key} must be a string`;
+      isNat(size) || Fail`Size ${size} is not a positive integer`;
       return [key, size];
     }),
   );
 
 /** @param {Record<string, number>} queueSizes */
-export const serializeQueueSizes = queueSizes =>
-  Object.entries(queueSizes).map(([key, size]) => ({ key, size }));
+export const encodeQueueSizes = queueSizes =>
+  Object.entries(queueSizes).map(([key, size]) => {
+    isNat(size) || Fail`Size ${size} is not a positive integer`;
+    return { key, size };
+  });
 
 // Map the SwingSet parameters to a deterministic data structure.
 export const parseParams = params => {
@@ -36,24 +37,22 @@ export const parseParams = params => {
     queue_max: rawQueueMax,
   } = params;
   Array.isArray(rawBeansPerUnit) ||
-    assert.fail(X`beansPerUnit must be an array, not ${rawBeansPerUnit}`);
+    Fail`beansPerUnit must be an array, not ${rawBeansPerUnit}`;
   const beansPerUnit = Object.fromEntries(
     rawBeansPerUnit.map(({ key, beans }) => {
-      assert.typeof(key, 'string', X`Key ${key} must be a string`);
+      typeof key === 'string' || Fail`Key ${key} must be a string`;
       return [key, stringToNat(beans)];
     }),
   );
   Array.isArray(rawFeeUnitPrice) ||
-    assert.fail(X`feeUnitPrice ${rawFeeUnitPrice} must be an array`);
+    Fail`feeUnitPrice ${rawFeeUnitPrice} must be an array`;
   const feeUnitPrice = rawFeeUnitPrice.map(({ denom, amount }) => {
-    assert.typeof(denom, 'string', X`denom ${denom} must be a string`);
-    assert(denom, X`denom ${denom} must be non-empty`);
+    typeof denom === 'string' || Fail`denom ${denom} must be a string`;
+    denom || Fail`denom ${denom} must be non-empty`;
     return { denom, amount: stringToNat(amount) };
   });
-  assert(
-    Array.isArray(rawQueueMax),
-    X`queueMax must be an array, not ${rawQueueMax}`,
-  );
+  Array.isArray(rawQueueMax) ||
+    Fail`queueMax must be an array, not ${rawQueueMax}`;
   const queueMax = parseQueueSizes(rawQueueMax);
 
   return { beansPerUnit, feeUnitPrice, queueMax };

package/src/sim-chain.js

@@ -12,14 +12,15 @@ import anylogger from 'anylogger';
 import { makeSlogSender } from '@agoric/telemetry';
 
 import { resolve as importMetaResolve } from 'import-meta-resolve';
-import { assert, details as X } from '@agoric/assert';
-import { makeWithQueue } from '@agoric/vats/src/queue.js';
-import { makeBatchedDeliver } from '@agoric/vats/src/batched-deliver.js';
-import stringify from './json-stable-stringify.js';
+import { Fail } from '@agoric/assert';
+import { makeWithQueue } from '@agoric/internal/src/queue.js';
+import { makeBatchedDeliver } from '@agoric/internal/src/batched-deliver.js';
+import stringify from './helpers/json-stable-stringify.js';
 import { launch } from './launch-chain.js';
 import { getTelemetryProviders } from './kernel-stats.js';
 import { DEFAULT_SIM_SWINGSET_PARAMS, QueueInbound } from './sim-params.js';
 import { parseQueueSizes } from './params.js';
+import { makeQueue, makeQueueStorageMock } from './helpers/make-queue.js';
 
 const console = anylogger('fake-chain');
 
@@ -38,14 +39,14 @@ async function makeMapStorage(file) {
     await fs.promises.writeFile(file, json);
   };
 
-  let obj = {};
-  try {
+  await (async () => {
     content = await fs.promises.readFile(file);
-    obj = JSON.parse(content);
-  } catch (e) {
-    return map;
-  }
-  Object.entries(obj).forEach(([k, v]) => map.set(k, importMailbox(v)));
+    return JSON.parse(content);
+  })().then(
+    obj =>
+      Object.entries(obj).forEach(([k, v]) => map.set(k, importMailbox(v))),
+    () => {},
+  );
 
   return map;
 }
@@ -58,7 +59,6 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
   const mailboxStorage = await makeMapStorage(mailboxFile);
 
   const argv = {
-    ROLE: 'sim-chain',
     giveMeAllTheAgoricPowers: true,
     hardcodedClientAddresses: [bootAddress],
     bootMsg: {
@@ -70,18 +70,17 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
     },
   };
 
-  const vatconfig = new URL(
-    await importMetaResolve(
-      process.env.CHAIN_BOOTSTRAP_VAT_CONFIG ||
-        argv.bootMsg.params.bootstrap_vat_config,
-      import.meta.url,
-    ),
-  ).pathname;
+  const url = await importMetaResolve(
+    process.env.CHAIN_BOOTSTRAP_VAT_CONFIG ||
+      argv.bootMsg.params.bootstrap_vat_config,
+    import.meta.url,
+  );
+  const vatconfig = new URL(url).pathname;
   const stateDBdir = path.join(basedir, `fake-chain-${GCI}-state`);
   function replayChainSends() {
-    assert.fail(X`Replay not implemented`);
+    Fail`Replay not implemented`;
   }
-  function clearChainSends() {
+  async function clearChainSends() {
     return [];
   }
 
@@ -92,26 +91,19 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
     serviceName: TELEMETRY_SERVICE_NAME,
   });
 
-  const { LMDB_MAP_SIZE } = env;
-  const mapSize = (LMDB_MAP_SIZE && parseInt(LMDB_MAP_SIZE, 10)) || undefined;
   const slogSender = await makeSlogSender({
     stateDir: stateDBdir,
     serviceName: TELEMETRY_SERVICE_NAME,
     env,
   });
 
-  let aqContents = [];
-  const actionQueue = {
-    /** @returns {Iterable<unknown>} */
-    consumeAll: () => {
-      const iterable = aqContents;
-      aqContents = [];
-      return iterable;
-    },
-  };
+  const actionQueueStorage = makeQueueStorageMock().storage;
+  const highPriorityQueueStorage = makeQueueStorageMock().storage;
+  const actionQueue = makeQueue(actionQueueStorage);
 
   const s = await launch({
-    actionQueue,
+    actionQueueStorage,
+    highPriorityQueueStorage,
     kernelStateDBDir: stateDBdir,
     mailboxStorage,
     clearChainSends,
@@ -121,13 +113,11 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
     debugName: GCI,
     metricsProvider,
     slogSender,
-    mapSize,
   });
 
-  const { blockingSend, savedHeight, savedBlockTime } = s;
+  const { blockingSend, savedHeight } = s;
 
   let blockHeight = savedHeight;
-  let blockTime = savedBlockTime || scaleBlockTime(Date.now());
   const intoChain = [];
   let nextBlockTimeout = 0;
 
@@ -136,7 +126,7 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
   const withBlockQueue = makeWithQueue();
   const unhandledSimulateBlock = withBlockQueue(
     async function unqueuedSimulateBlock() {
-      blockTime = scaleBlockTime(Date.now());
+      const blockTime = scaleBlockTime(Date.now());
       blockHeight += 1;
 
       const params = DEFAULT_SIM_SWINGSET_PARAMS;
@@ -146,22 +136,27 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
         blockTime,
         params,
       };
-      const beginBlockResult = await blockingSend(beginAction);
-      assert(beginBlockResult);
-      const queueAllowed = parseQueueSizes(beginBlockResult.queue_allowed);
-      assert(QueueInbound in queueAllowed);
+      await blockingSend(beginAction);
+      const inboundQueueMax = parseQueueSizes(params.queue_max)[QueueInbound];
+      const inboundQueueAllowed = Math.max(
+        0,
+        inboundQueueMax - actionQueue.size(),
+      );
 
       // Gather up the new messages into the latest block.
-      const thisBlock = intoChain.splice(0, queueAllowed[QueueInbound]);
-
-      for (const [newMessages, acknum] of thisBlock) {
-        aqContents.push({
-          type: 'DELIVER_INBOUND',
-          peer: bootAddress,
-          messages: newMessages,
-          ack: acknum,
-          blockHeight,
-          blockTime,
+      const thisBlock = intoChain.splice(0, inboundQueueAllowed);
+
+      for (const [i, [newMessages, acknum]] of thisBlock.entries()) {
+        actionQueue.push({
+          action: {
+            type: 'DELIVER_INBOUND',
+            peer: bootAddress,
+            messages: newMessages,
+            ack: acknum,
+            blockHeight,
+            blockTime,
+          },
+          context: { blockHeight, txHash: 'simTx', msgIdx: i },
         });
       }
       const endAction = { type: 'END_BLOCK', blockHeight, blockTime };
@@ -194,10 +189,12 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
 
     intoChain.push([newMessages, acknum]);
     // Only actually simulate a block if we're not in bootstrap.
+    let p;
     if (blockHeight && !delay) {
       clearTimeout(nextBlockTimeout);
-      await simulateBlock();
+      p = simulateBlock();
     }
+    await p;
   }
 
   const bootSimChain = async () => {
@@ -207,7 +204,10 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
     // The before-first-block is special... do it now.
     // This emulates what x/swingset does to run a BOOTSTRAP_BLOCK
     // before continuing with the real initialHeight.
-    await blockingSend({ type: 'BOOTSTRAP_BLOCK', blockTime });
+    await blockingSend({
+      type: 'BOOTSTRAP_BLOCK',
+      blockTime: scaleBlockTime(Date.now()),
+    });
     blockHeight = initialHeight;
   };
 
@@ -222,5 +222,9 @@ export async function connectToFakeChain(basedir, GCI, delay, inbound) {
   });
 
   const batchDelayMs = delay ? delay * 1000 : undefined;
-  return makeBatchedDeliver(deliver, batchDelayMs);
+  return makeBatchedDeliver(
+    deliver,
+    { clearTimeout, setTimeout },
+    batchDelayMs,
+  );
 }

package/src/sim-params.js

@@ -1,4 +1,6 @@
-import { Nat } from '@agoric/nat';
+// @jessie-check
+
+import { Nat } from '@endo/nat';
 
 const makeStringBeans = (key, beans) => ({ key, beans: `${Nat(beans)}` });
 const makePowerFlagFee = (powerFlag, fee) => ({ powerFlag, fee });
@@ -58,8 +60,7 @@ export const defaultBeansPerUnit = [
   makeStringBeans(BeansPerXsnapComputron, defaultBeansPerXsnapComputron),
 ];
 
-export const defaultBootstrapVatConfig =
-  '@agoric/vats/decentral-demo-config.json';
+const defaultBootstrapVatConfig = '@agoric/vats/decentral-demo-config.json';
 
 export const defaultPowerFlagFees = [
   makePowerFlagFee('SMART_WALLET', [makeCoin('ubld', 10_000_000n)]),

package/transfer.ros

@@ -0,0 +1,161 @@
+request_funds(1){
+  find_account{
+    currency = {"symbol":"ubld", "decimals":0};
+    random_account = find_balance({
+      "minimum_balance":{
+        "value": "0",
+        "currency": {{currency}}
+      },
+      "create_limit":1
+    });
+  },
+  send_funds{
+    account_identifier = {{random_account.account_identifier}};
+    address = {{account_identifier.address}};
+    idk = http_request({
+      "method": "POST",
+      "url": "http:\/\/127.0.0.1:7000",
+      "timeout": 10,
+      "body":  {{random_account.account_identifier.address}}
+    });
+  },
+  // Create a separate scenario to request funds so that
+  // the address we are using to request funds does not
+  // get rolled back if funds do not yet exist.
+  request{
+    loaded_account = find_balance({
+      "account_identifier": {{random_account.account_identifier}},
+      "minimum_balance":{
+        "value": "50",
+        "currency": {{currency}}
+      }
+    });
+  }
+}
+create_account(1){
+  create{
+    network = {"network":"agoriclocal", "blockchain":"app"};
+    key = generate_key({"curve_type": "secp256k1"});
+    account = derive({
+      "network_identifier": {{network}},
+      "public_key": {{key.public_key}}
+    });
+    // If the account is not saved, the key will be lost!
+    save_account({
+      "account_identifier": {{account.account_identifier}},
+      "keypair": {{key}}
+    });
+  }
+}
+transferBLD(3){
+  transfer{
+    transfer.network = {"network":"agoriclocal", "blockchain":"app"};
+    currency = {"symbol":"ubld", "decimals":0};
+    sender = find_balance({
+      "minimum_balance":{
+        "value": "1000000",
+        "currency": {{currency}}
+      }
+    });
+    acc_identifier = {{sender.account_identifier}};
+    sender_address = {{acc_identifier.address}};
+    // Set the recipient_amount as some value <= sender.balance-max_fee
+    max_fee = "0";
+    fee_amount = "1";
+    fee_value = 0 - {{fee_amount}};
+    available_amount = {{sender.balance.value}} - {{max_fee}};
+    recipient_amount = random_number({"minimum": "1", "maximum": {{available_amount}}});
+    print_message({"recipient_amount":{{recipient_amount}}});
+    // Find recipient and construct operations
+    sender_amount = 0 - {{recipient_amount}};
+    recipient = find_balance({
+      "not_account_identifier":[{{sender.account_identifier}}],
+      "minimum_balance":{
+        "value": "0",
+        "currency": {{currency}}
+      },
+      "create_limit": 100,
+      "create_probability": 50
+    });
+    transfer.confirmation_depth = "1";
+    recipient_account_identifier = {{recipient.account_identifier}};
+    recipient_address = {{recipient_account_identifier.address}};
+    transfer.operations = [
+      {
+        "operation_identifier":{"index":0},
+        "type":"/cosmos.bank.v1beta1.MsgSend",
+        "account":{{sender.account_identifier}},
+        "metadata": {
+          "amount": [
+            {
+              "amount": {{recipient_amount}},
+              "denom":  {{currency.symbol}}
+            }
+          ],
+          "from_address": {{sender_address}},
+           "to_address": {{recipient_address}}
+        }
+      }
+    ];
+    transfer.preprocess_metadata = {
+        "gas_price": "0.01ubld",
+        "gas_limit": 250000
+    };
+  }
+}
+transferIST(4){
+  transfer{
+    transfer.network = {"network":"agoriclocal", "blockchain":"app"};
+    currency = {"symbol":"uist", "decimals":0};
+    sender = find_balance({
+      "minimum_balance":{
+        "value": "1000000",
+        "currency": {{currency}}
+      }
+    });
+    acc_identifier = {{sender.account_identifier}};
+    sender_address = {{acc_identifier.address}};
+    // Set the recipient_amount as some value <= sender.balance-max_fee
+    max_fee = "0";
+    fee_amount = "1";
+    fee_value = 0 - {{fee_amount}};
+    available_amount = {{sender.balance.value}} - {{max_fee}};
+    recipient_amount = random_number({"minimum": "1", "maximum": {{available_amount}}});
+    print_message({"recipient_amount":{{recipient_amount}}});
+    // Find recipient and construct operations
+    sender_amount = 0 - {{recipient_amount}};
+    recipient = find_balance({
+      "not_account_identifier":[{{sender.account_identifier}}],
+      "minimum_balance":{
+        "value": "0",
+        "currency": {{currency}}
+      },
+      "create_limit": 100,
+      "create_probability": 50
+    });
+    transfer.confirmation_depth = "1";
+    recipient_account_identifier = {{recipient.account_identifier}};
+    recipient_address = {{recipient_account_identifier.address}};
+    transfer.operations = [
+      {
+        "operation_identifier":{"index":0},
+        "type":"/cosmos.bank.v1beta1.MsgSend",
+        "account":{{sender.account_identifier}},
+        "metadata": {
+          "amount": [
+            {
+              "amount": {{recipient_amount}},
+              "denom":  {{currency.symbol}}
+            }
+          ],
+          "from_address": {{sender_address}},
+           "to_address": {{recipient_address}}
+        }
+      }
+    ];
+    transfer.preprocess_metadata = {
+        "gas_price": "0.01ubld",
+        "gas_limit": 250000
+    };
+  }
+}

package/src/action-types.js

@@ -1,13 +0,0 @@
-export const BOOTSTRAP_BLOCK = 'BOOTSTRAP_BLOCK';
-export const BEGIN_BLOCK = 'BEGIN_BLOCK';
-export const CALCULATE_FEES_IN_BEANS = 'CALCULATE_FEES_IN_BEANS';
-export const CORE_EVAL = 'CORE_EVAL';
-export const DELIVER_INBOUND = 'DELIVER_INBOUND';
-export const END_BLOCK = 'END_BLOCK';
-export const COMMIT_BLOCK = 'COMMIT_BLOCK';
-export const IBC_EVENT = 'IBC_EVENT';
-export const PLEASE_PROVISION = 'PLEASE_PROVISION';
-export const VBANK_BALANCE_UPDATE = 'VBANK_BALANCE_UPDATE';
-export const WALLET_ACTION = 'WALLET_ACTION';
-export const WALLET_SPEND_ACTION = 'WALLET_SPEND_ACTION';
-export const INSTALL_BUNDLE = 'INSTALL_BUNDLE';

package/src/make-queue.js

@@ -1,86 +0,0 @@
-/**
- * @typedef {object} QueueStorage
- * @property {() => void} commit
- * @property {() => void} abort
- * @property {(key: string) => unknown} get
- * @property {(key: string, value: unknown) => void} set
- * @property {(key: string) => void} delete
- */
-
-/**
- * Create a queue backed by some sort of scoped storage.
- *
- * The queue writes the following bare keys, and expect any prefixing/scoping
- * to be handled by the storage:
- * - `head`: the index of the first entry of the queue.
- * - `tail`: the index *past* the last entry in the queue.
- * - `<index>`: the contents of the queue at the given index.
- *
- * For the `actionQueue`, the Cosmos side of the queue will push into the queue,
- * updating `<prefix>tail` and `<prefix><index>`.  The JS side will shift the
- * queue, updating `<prefix>head` and reading and deleting `<prefix><index>`.
- *
- * Parallel access is not supported, only a single outstanding operation at a
- * time.
- *
- * @param {QueueStorage} storage a scoped queue storage
- */
-export const makeQueue = storage => {
-  const queue = {
-    size: () => {
-      const tail = storage.get('tail') || 0;
-      const head = storage.get('head') || 0;
-      return tail - head;
-    },
-    push: obj => {
-      const tail = storage.get('tail') || 0;
-      storage.set('tail', tail + 1);
-      storage.set(`${tail}`, obj);
-      storage.commit();
-    },
-    /** @type {Iterable<unknown>} */
-    consumeAll: () => ({
-      [Symbol.iterator]: () => {
-        let done = false;
-        let head = storage.get('head') || 0;
-        const tail = storage.get('tail') || 0;
-        return {
-          next: () => {
-            if (done) return { done };
-            if (head < tail) {
-              // Still within the queue.
-              const headKey = `${head}`;
-              const value = storage.get(headKey);
-              storage.delete(headKey);
-              head += 1;
-              return { value, done };
-            }
-            // Reached the end, so clean up our indices.
-            storage.delete('head');
-            storage.delete('tail');
-            storage.commit();
-            done = true;
-            return { done };
-          },
-          return: () => {
-            if (done) return { done };
-            // We're done consuming, so save our state.
-            storage.set('head', head);
-            storage.commit();
-            done = true;
-            return { done };
-          },
-          throw: err => {
-            if (done) return { done };
-            // Don't change our state.
-            storage.abort();
-            done = true;
-            throw err;
-          },
-        };
-      },
-    }),
-  };
-  return queue;
-};
-harden(makeQueue);

package/src/validate-inbound.js

@@ -1,109 +0,0 @@
-import { assert, details as X } from '@agoric/assert';
-
-import * as ActionType from './action-types.js';
-
-const MAX_BODY_DEPTH = 50n;
-
-const SMART_WALLET_BODY_KEYS = new Set([
-  '',
-  'brand',
-  'digits',
-  'give',
-  'id',
-  'iface',
-  'In',
-  'index',
-  'instance',
-  'invitationSpec',
-  'method',
-  'offer',
-  'Out',
-  'proposal',
-  'publicInvitationMaker',
-  '@qclass',
-  'source',
-  'value',
-  'want',
-]);
-
-// From economicCommitteeAddresses in `decentral-main-psm-config.json`
-const SMART_WALLET_EC_COMMITTEE = new Set(
-  Object.values({
-    'Jason Potts': 'agoric1gx9uu7y6c90rqruhesae2t7c2vlw4uyyxlqxrx',
-    'Chloe White': 'agoric1d4228cvelf8tj65f4h7n2td90sscavln2283h5',
-    'Thibault Schrepel': 'agoric14543m33dr28x7qhwc558hzlj9szwhzwzpcmw6a',
-    'Chris Berg': 'agoric13p9adwk0na5npfq64g22l6xucvqdmu3xqe70wq',
-    'Youssef Amrani': 'agoric1el6zqs8ggctj5vwyukyk4fh50wcpdpwgugd5l5',
-    'Joe Clark': 'agoric1zayxg4e9vd0es9c9jlpt36qtth255txjp6a8yc',
-  }),
-);
-
-export const validateWalletAction = async action => {
-  if (SMART_WALLET_EC_COMMITTEE.has(action.owner)) {
-    // The Economic Committee uses the smart wallet for governance votes
-    // which have a less structured payload.
-    return;
-  }
-
-  const actualAction =
-    action.type === ActionType.WALLET_SPEND_ACTION
-      ? action.spendAction
-      : action.action;
-  assert(
-    actualAction !== undefined,
-    X`Wallet action undefined for ${action.type}`,
-  );
-  const actualPayloadBody = JSON.parse(actualAction).body;
-
-  assert.typeof(actualPayloadBody, 'string');
-  assert(
-    !actualPayloadBody.startsWith('#'),
-    X`Unexpected smallcaps in smart wallet payload`,
-  );
-
-  let bodyMaxDepth = 0n;
-  try {
-    bodyMaxDepth = JSON.parse(
-      actualPayloadBody,
-      function reviverCheck(key, value) {
-        if (!Array.isArray(this)) {
-          assert(
-            SMART_WALLET_BODY_KEYS.has(key),
-            X`Unexpected key in smart wallet payload: ${key}`,
-          );
-        }
-
-        switch (typeof value) {
-          case 'object': {
-            if (!value) return 0n;
-            let maxChildDepth = 0n;
-
-            for (const childDepth of Object.values(value)) {
-              if (childDepth > maxChildDepth) {
-                maxChildDepth = childDepth;
-              }
-            }
-            return 1n + maxChildDepth;
-          }
-          case 'boolean':
-          case 'number':
-          case 'string':
-            return 0n;
-          default:
-            assert.fail(X`Unexpected parsed type`);
-        }
-      },
-    );
-  } catch (err) {
-    if (err.name === 'SyntaxError') {
-      console.warn('Invalid smart wallet body', action, err);
-    } else {
-      throw err;
-    }
-  }
-
-  assert(
-    bodyMaxDepth < MAX_BODY_DEPTH,
-    X`Smart wallet message body too deep: ${bodyMaxDepth}`,
-  );
-};