trac-peer 0.4.7 → 0.4.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-peer",
   "main": "src/index.js",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "type": "module",
   "pear": {
     "name": "trac-peer",
@@ -99,7 +99,7 @@
     "timers": "npm:bare-node-timers",
     "tls": "npm:bare-node-tls",
     "trac-crypto-api": "^0.1.5",
-    "trac-msb": "^0.2.19",
+    "trac-msb": "github:Trac-Systems/main_settlement_bus#7220c257d8c493456714791e03f7021dbcfc7c85",
     "trac-wallet": "^1.0.4",
     "url": "npm:bare-node-url",
     "util": "npm:bare-node-util",

package/src/artifacts/contract.js

@@ -20,9 +20,36 @@ class Contract {
         this.value = null;
         this.assert = assert;
         this.check = new Check();
+        this.execute_queue = null;
+    }
+
+    /**
+     * A contract instance keeps the state of the running call (address,
+     * validator_address, is_feature, is_message, tx, op, value, storage) in
+     * instance fields, and handlers re-read those fields after every await. Two
+     * executions in flight on one instance therefore interleave their working
+     * state, which on a busy peer produced a simulation result with fields
+     * missing and a "get(key): storage undefined" throw in the call that resumed
+     * afterwards. Autobase apply is sequential, but Protocol.simulateTransaction
+     * executes on the same live instance from outside the apply loop, so calls
+     * are queued here and the body in executeQueued() runs one call at a time.
+     */
+    async execute(op, storage){
+        const previous = this.execute_queue === null ? Promise.resolve() : this.execute_queue;
+        let finish = null;
+        const finished = new Promise((resolve) => { finish = resolve; });
+        const queued = previous.then(() => finished);
+        this.execute_queue = queued;
+        await previous;
+        try {
+            return await this.executeQueued(op, storage);
+        } finally {
+            finish();
+            if(this.execute_queue === queued) this.execute_queue = null;
+        }
     }
 
-    async execute(op, storage){
+    async executeQueued(op, storage){
         this.address = null;
         this.validator_address = null;
         this.is_message = false;

package/src/config/config.js

@@ -1,6 +1,8 @@
 import b4a from "b4a";
 import path from "path";
 
+const DEFAULT_MAX_MSB_SIGNED_LENGTH_FUTURE_DELTA = 1_000_000;
+
 export class Config {
     #options;
 
@@ -47,6 +49,15 @@ export class Config {
         }
         this.maxMsbSignedLength = maxMsbSignedLength;
 
+        const maxMsbSignedLengthFutureDelta =
+            this.#select("maxMsbSignedLengthFutureDelta", options, defaults) ??
+            DEFAULT_MAX_MSB_SIGNED_LENGTH_FUTURE_DELTA;
+        if (!Number.isSafeInteger(maxMsbSignedLengthFutureDelta) ||
+            maxMsbSignedLengthFutureDelta < 0) {
+            throw new Error("Peer: maxMsbSignedLengthFutureDelta must be a non-negative safe integer.");
+        }
+        this.maxMsbSignedLengthFutureDelta = maxMsbSignedLengthFutureDelta;
+
         const maxMsbApplyOperationBytes = this.#select("maxMsbApplyOperationBytes", options, defaults);
         if (!Number.isSafeInteger(maxMsbApplyOperationBytes)) {
             throw new Error("Peer: maxMsbApplyOperationBytes must be a safe integer.");

package/src/config/env.js

@@ -15,6 +15,7 @@ const configData = {
         txPoolMaxSize: 1_000,
         maxTxDelay: 60,
         maxMsbSignedLength: 1_000_000_000,
+        maxMsbSignedLengthFutureDelta: 1_000_000,
         maxMsbApplyOperationBytes: 1024 * 1024,
         enableInteractiveMode: true,
         enableBackgroundTasks: true,
@@ -39,6 +40,7 @@ const configData = {
         txPoolMaxSize: 1_000,
         maxTxDelay: 60,
         maxMsbSignedLength: 1_000_000_000,
+        maxMsbSignedLengthFutureDelta: 1_000_000,
         maxMsbApplyOperationBytes: 1024 * 1024,
         enableInteractiveMode: true,
         enableBackgroundTasks: true,
@@ -63,6 +65,7 @@ const configData = {
         txPoolMaxSize: 1_000,
         maxTxDelay: 60,
         maxMsbSignedLength: 1_000_000_000,
+        maxMsbSignedLengthFutureDelta: 1_000_000,
         maxMsbApplyOperationBytes: 1024 * 1024,
         enableInteractiveMode: true,
         enableBackgroundTasks: false,

package/src/msbClient.js

@@ -97,11 +97,35 @@ export class MsbClient extends ReadyResource {
         return await this.#msb.network.tryConnect(pubKeyHex, role);
     }
 
-    async waitForSignedLengthAtLeast(targetSignedLength) {
+    async waitForSignedLengthAtLeast(targetSignedLength, { pollMs = 1_000 } = {}) {
         const core = this.#msb.state?.base?.view?.core ?? null;
         if (!core) throw new Error('MSB view core not available.');
+        if (!Number.isSafeInteger(targetSignedLength) || targetSignedLength < 0) {
+            throw new Error('Invalid MSB signed length target.');
+        }
+        if (!Number.isSafeInteger(pollMs) || pollMs < 1) {
+            throw new Error('Invalid MSB signed length wait poll interval.');
+        }
         while (core.signedLength < targetSignedLength) {
-            await new Promise((resolve) => core.once('append', resolve));
+            await new Promise((resolve) => {
+                const onAppend = () => {
+                    cleanup();
+                    resolve();
+                };
+                const cleanup = () => {
+                    clearTimeout(timer);
+                    if (typeof core.off === 'function') {
+                        core.off('append', onAppend);
+                    } else if (typeof core.removeListener === 'function') {
+                        core.removeListener('append', onAppend);
+                    }
+                };
+                const timer = setTimeout(() => {
+                    cleanup();
+                    resolve();
+                }, pollMs);
+                core.once('append', onAppend);
+            });
         }
     }
 

package/src/operations/tx/index.js

@@ -36,6 +36,11 @@ export class TxOperation {
         if(false === this.#validator.validate(op)) return;
         // Stall guard: don't allow a writer to pin apply waiting on an absurd MSB height
         if (op.value.msbsl > this.#config.maxMsbSignedLength) return;
+        const localMsbSignedLength = this.#msbClient.getSignedLength();
+        if (localMsbSignedLength > 0 &&
+            op.value.msbsl > localMsbSignedLength + this.#config.maxMsbSignedLengthFutureDelta) {
+            return;
+        }
         // Wait for local MSB view to reach the referenced signed length
         await this.#msbClient.waitForSignedLengthAtLeast(op.value.msbsl);
         // Fetch MSB apply-op at msbsl by tx key (op.key = tx hash)

package/tests/unit/applyGuards.test.js

@@ -164,6 +164,65 @@ test('apply: tx msbsl stall guard skips waiting', async (t) => {
     });
 });
 
+test('apply: tx msbsl relative future guard skips waiting', async (t) => {
+    await withTempDir(async ({ storesDirectory }) => {
+        const msbBootstrapBuf = b4a.alloc(32).fill(7);
+        const msb = makeMsbStub({
+            msbBootstrapBuf,
+            signedLength: 100,
+            async getEntry() {
+                return null;
+            },
+        });
+
+        msb.state.base.view.core.once = () => {
+            throw new Error('apply should not wait for a far-future msbsl');
+        };
+
+        const storeName = 'peer-relative-stall-guard';
+        const wallet = await prepareWallet(storesDirectory, storeName);
+        const config = createConfig(ENV.DEVELOPMENT, {
+            storesDirectory,
+            storeName,
+            maxMsbSignedLength: 1_000_000_000,
+            maxMsbSignedLengthFutureDelta: 10,
+        });
+        const peer = new Peer({
+            config,
+            msb,
+            protocol: TestProtocol,
+            contract: TestContract,
+            wallet,
+        });
+
+        try {
+            await peer.ready();
+
+            const txHashHex = makeHex32(1);
+            const op = {
+                type: 'tx',
+                key: txHashHex,
+                value: {
+                    dispatch: { type: 'ping', value: { msg: 'hi' } },
+                    msbsl: 111,
+                    ipk: makeHex32(2),
+                    wp: makeHex32(3),
+                },
+            };
+
+            const timeout = new Promise((_, reject) =>
+                setTimeout(() => reject(new Error('append timed out (possible apply stall)')), 2000)
+            );
+            await Promise.race([peer.base.append(op), timeout]);
+
+            const txl = await peer.bee.get('txl');
+            t.is(txl, null, 'tx should not be indexed when msbsl exceeds the local future window');
+        } finally {
+            await closePeer(peer);
+        }
+    });
+});
+
 test('apply: tx MSB payload size guard blocks otherwise-valid tx', async (t) => {
     await withTempDir(async ({ storesDirectory }) => {
         const msbBootstrapBuf = b4a.alloc(32).fill(7);

package/tests/unit/contractExecuteQueue.test.js

@@ -0,0 +1,266 @@
+import test from "brittle";
+
+import Contract from "../../src/artifacts/contract.js";
+
+const makeProtocolStubForContract = () => {
+  const compile = (_schema) => () => true;
+  return { peer: { check: { validator: { compile } } } };
+};
+
+class MemoryStorage {
+  constructor(initial = {}) {
+    this.values = new Map(Object.entries(initial));
+  }
+
+  async get(key) {
+    return this.values.has(key) ? { value: this.values.get(key) } : null;
+  }
+
+  async put(key, value) {
+    this.values.set(key, value);
+  }
+
+  async del(key) {
+    this.values.delete(key);
+  }
+
+  keys() {
+    return [...this.values.keys()].sort();
+  }
+
+  snapshotBytes() {
+    return JSON.stringify(
+      [...this.values.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    );
+  }
+}
+
+const txKey = (n) => n.toString(16).padStart(64, "0");
+const address = (n) => n.toString(16).repeat(64).slice(0, 64);
+
+const operation = (type, value, sender, txNo, writer = "0".repeat(64)) => ({
+  type: "tx",
+  key: txKey(txNo),
+  value: {
+    dispatch: { type, value },
+    ipk: sender,
+    wp: writer,
+  },
+});
+
+const deferred = () => {
+  let resolve = null;
+  const promise = new Promise((settle) => { resolve = settle; });
+  return { promise, resolve };
+};
+
+// Give a pending execution enough turns of the event loop to reach its await.
+const settle = async () => {
+  for (let index = 0; index < 8; index += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+};
+
+const probeContract = (release, ContractClass = Contract) => {
+  const contract = new ContractClass(makeProtocolStubForContract(), {});
+  contract.addFunction("probe");
+  contract.probe = async function probe() {
+    const entered = {
+      tag: this.value.tag,
+      tx: this.tx,
+      address: this.address,
+      validator_address: this.validator_address,
+      type: this.op.type,
+      is_feature: this.is_feature,
+      is_message: this.is_message,
+    };
+    if (entered.tag === "held") await release.promise;
+    const resumed = {
+      tag: this.value.tag,
+      tx: this.tx,
+      address: this.address,
+      validator_address: this.validator_address,
+      type: this.op.type,
+      is_feature: this.is_feature,
+      is_message: this.is_message,
+    };
+    await this.put(`probe/${resumed.tag}`, resumed);
+    const stored = await this.get(`probe/${resumed.tag}`);
+    return { ok: true, entered, resumed, stored };
+  };
+  return contract;
+};
+
+test("contract execute: overlapping executions each keep their own operation, sender and storage", async (t) => {
+  const release = deferred();
+  const contract = probeContract(release);
+  const heldStorage = new MemoryStorage();
+  const otherStorage = new MemoryStorage();
+
+  const heldRun = contract.execute(
+    operation("probe", { tag: "held" }, address(1), 701, address(9)),
+    heldStorage
+  );
+  await settle();
+  const otherRun = contract.execute(
+    operation("probe", { tag: "other" }, address(2), 702, address(8)),
+    otherStorage
+  );
+  await settle();
+  release.resolve();
+  const [heldResult, otherResult] = await Promise.all([heldRun, otherRun]);
+
+  const heldExpected = {
+    tag: "held",
+    tx: txKey(701),
+    address: address(1),
+    validator_address: address(9),
+    type: "probe",
+    is_feature: false,
+    is_message: false,
+  };
+  const otherExpected = {
+    tag: "other",
+    tx: txKey(702),
+    address: address(2),
+    validator_address: address(8),
+    type: "probe",
+    is_feature: false,
+    is_message: false,
+  };
+
+  t.alike(heldResult.entered, heldExpected);
+  t.alike(heldResult.resumed, heldExpected);
+  t.alike(heldResult.stored, heldExpected);
+  t.alike(otherResult.entered, otherExpected);
+  t.alike(otherResult.resumed, otherExpected);
+  t.alike(otherResult.stored, otherExpected);
+  t.alike(heldStorage.keys(), ["probe/held"]);
+  t.alike(otherStorage.keys(), ["probe/other"]);
+
+  // The same two calls, run one after the other, produce the same results and
+  // the same storage bytes.
+  const sequentialRelease = deferred();
+  sequentialRelease.resolve();
+  const sequentialContract = probeContract(sequentialRelease);
+  const sequentialHeldStorage = new MemoryStorage();
+  const sequentialOtherStorage = new MemoryStorage();
+  const sequentialHeld = await sequentialContract.execute(
+    operation("probe", { tag: "held" }, address(1), 701, address(9)),
+    sequentialHeldStorage
+  );
+  const sequentialOther = await sequentialContract.execute(
+    operation("probe", { tag: "other" }, address(2), 702, address(8)),
+    sequentialOtherStorage
+  );
+
+  t.alike(heldResult, sequentialHeld);
+  t.alike(otherResult, sequentialOther);
+  t.is(heldStorage.snapshotBytes(), sequentialHeldStorage.snapshotBytes());
+  t.is(otherStorage.snapshotBytes(), sequentialOtherStorage.snapshotBytes());
+  t.is(contract.storage, null);
+  t.is(contract.address, null);
+  t.is(contract.execute_queue, null);
+});
+
+test("contract execute: a throwing handler leaves the queue usable", async (t) => {
+  const contract = new Contract(makeProtocolStubForContract(), {});
+  contract.addFunction("boom");
+  contract.boom = async function boom() {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    throw new Error("handler failed");
+  };
+  contract.addFunction("after");
+  contract.after = async function after() {
+    await this.put("after/ran", { tx: this.tx, address: this.address });
+    return { ok: true, tx: this.tx, address: this.address };
+  };
+
+  const storage = new MemoryStorage();
+  await t.exception(
+    () => contract.execute(operation("boom", { tag: "boom" }, address(3), 801), storage),
+    /Error in contract/
+  );
+  t.is(contract.execute_queue, null);
+
+  const result = await contract.execute(
+    operation("after", { tag: "after" }, address(4), 802),
+    storage
+  );
+  t.alike(result, { ok: true, tx: txKey(802), address: address(4) });
+  t.alike(storage.keys(), ["after/ran"]);
+
+  // Two more overlapping calls still take turns after the failure.
+  const release = deferred();
+  const slowStorage = new MemoryStorage();
+  contract.addFunction("slow");
+  contract.slow = async function slow() {
+    const seen = { tx: this.tx, address: this.address };
+    if (this.value.tag === "first") await release.promise;
+    return { ok: true, seen, still: { tx: this.tx, address: this.address } };
+  };
+  const first = contract.execute(
+    operation("slow", { tag: "first" }, address(5), 803),
+    slowStorage
+  );
+  await settle();
+  const second = contract.execute(
+    operation("slow", { tag: "second" }, address(6), 804),
+    slowStorage
+  );
+  await settle();
+  release.resolve();
+  const [firstResult, secondResult] = await Promise.all([first, second]);
+  t.alike(firstResult.seen, firstResult.still);
+  t.alike(secondResult.seen, secondResult.still);
+  t.is(firstResult.seen.address, address(5));
+  t.is(secondResult.seen.address, address(6));
+});
+
+test("contract execute: a sub-class override calling super.execute() still runs", async (t) => {
+  const calls = [];
+
+  class SubContract extends Contract {
+    async execute(op, storage) {
+      calls.push(op.value.dispatch.value.tag);
+      this.last_type = op.type;
+      try {
+        return await super.execute(op, storage);
+      } finally {
+        this.last_type = null;
+      }
+    }
+  }
+
+  const release = deferred();
+  const contract = probeContract(release, SubContract);
+  const heldStorage = new MemoryStorage();
+  const otherStorage = new MemoryStorage();
+
+  const heldRun = contract.execute(
+    operation("probe", { tag: "held" }, address(1), 901, address(9)),
+    heldStorage
+  );
+  await settle();
+  const otherRun = contract.execute(
+    operation("probe", { tag: "other" }, address(2), 902, address(8)),
+    otherStorage
+  );
+  await settle();
+  release.resolve();
+  const [heldResult, otherResult] = await Promise.all([heldRun, otherRun]);
+
+  t.alike(calls, ["held", "other"]);
+  t.is(heldResult.ok, true);
+  t.is(otherResult.ok, true);
+  t.alike(heldResult.entered, heldResult.resumed);
+  t.alike(otherResult.entered, otherResult.resumed);
+  t.is(heldResult.resumed.address, address(1));
+  t.is(otherResult.resumed.address, address(2));
+  t.is(heldResult.resumed.tx, txKey(901));
+  t.is(otherResult.resumed.tx, txKey(902));
+  t.alike(heldStorage.keys(), ["probe/held"]);
+  t.alike(otherStorage.keys(), ["probe/other"]);
+  t.is(contract.last_type, null);
+  t.is(contract.execute_queue, null);
+});

package/tests/unit/unit.test.js

@@ -4,6 +4,7 @@ import test from 'brittle';
 test.pause();
 await import('./applyGuards.test.js');
 await import('./baseContractProtocol.test.js');
+await import('./contractExecuteQueue.test.js');
 await import('./cliTx.test.js');
 await import('./operations.test.js');
 await import('./simFunds.test.js');