@activeledger/activeprotocol 2.15.6 → 4.3.3

package/es/protocol/process.js

@@ -1,4 +1,4 @@
-import * as fs from "fs";
+import { promises as fs } from "fs";
 import { EventEmitter } from "events";
 import { VirtualMachine } from "./vm";
 import { ActiveOptions } from "@activeledger/activeoptions";
@@ -6,9 +6,41 @@ import { ActiveLogger } from "@activeledger/activelogger";
 import { Shared } from "./shared";
 import { StreamUpdater } from "./streamUpdater";
 import { PermissionsChecker } from "./permissionsChecker";
-import path from "path";
-const BROADCAST_TIMEOUT = 20 * 1000;
+const BROADCAST_TIMEOUT_EARLY = 60 * 1000;
+const BROADCAST_TIMEOUT_VOTE = 60 * 1000;
+const BROADCAST_TIMEOUT_COMMIT = 60 * 1000;
 export class Process extends EventEmitter {
+    entry;
+    selfHost;
+    reference;
+    right;
+    db;
+    dbe;
+    dbev;
+    secured;
+    static networkNodeLength = 0;
+    static generalContractVM;
+    isDefault = false;
+    inputs;
+    outputs;
+    nodeResponse;
+    contractLocation;
+    contractId;
+    commiting = false;
+    voting = true;
+    storeSingleError = false;
+    errorOut = {
+        code: 0,
+        reason: "",
+        priority: 0,
+    };
+    broadcastTimeout;
+    currentTrueVotes;
+    securityCache;
+    shared;
+    permissionChecker;
+    willEmit;
+    willEmitData;
     constructor(entry, selfHost, reference, right, db, dbe, dbev, secured) {
         super();
         this.entry = entry;
@@ -19,18 +51,9 @@ export class Process extends EventEmitter {
         this.dbe = dbe;
         this.dbev = dbev;
         this.secured = secured;
-        this.isDefault = false;
-        this.checkRevs = true;
-        this.commiting = false;
-        this.voting = true;
-        this.storeSingleError = false;
-        this.errorOut = {
-            code: 0,
-            reason: "",
-            priority: 0,
-        };
         this.shared = new Shared(this.storeSingleError, this.entry, this.dbe, this);
         this.nodeResponse = entry.$nodes[reference];
+        Process.networkNodeLength = ActiveOptions.get("neighbourhood", []).length;
         try {
             if (!Process.generalContractVM) {
                 Process.generalContractVM = new VirtualMachine(this.selfHost, this.secured, this.db, this.dbev);
@@ -40,23 +63,21 @@ export class Process extends EventEmitter {
         catch (error) {
             throw new Error(error);
         }
-        if (!this.securityCache) {
-            this.securityCache = ActiveOptions.get("security", null);
-        }
-        this.permissionChecker = new PermissionsChecker(this.entry, this.db, this.checkRevs, this.securityCache, this.shared);
+        this.securityCache = ActiveOptions.get("security", null);
+        this.permissionChecker = new PermissionsChecker(this.entry, this.db, this.securityCache, this.shared);
     }
     destroy(umid) {
-        clearTimeout(this.broadcastTimeout);
-        if (this.isDefault) {
-            if (Process.defaultContractsVM)
-                Process.defaultContractsVM.destroy(umid);
+        if (this.entry.$broadcast) {
+            clearTimeout(this.broadcastTimeout);
+            Process.generalContractVM.destroy(umid);
+            delete this.entry;
         }
         else {
-            this.contractRef
-                ? Process.singleContractVMHolder[this.contractRef].destroy(umid)
-                : Process.generalContractVM.destroy(umid);
+            setTimeout(() => {
+                Process.generalContractVM.destroy(umid);
+                delete this.entry;
+            }, 60000);
         }
-        delete this.entry;
     }
     sortVersions(a, b) {
         const padSorting = (v) => {
@@ -69,80 +90,98 @@ export class Process extends EventEmitter {
         };
         return padSorting(a).localeCompare(padSorting(b));
     }
-    async start(contractVersion) {
-        ActiveLogger.debug("New TX : " + this.entry.$umid);
-        const setupDefaultLocation = () => {
+    static contractPathCache = {};
+    static clearContractPathCache(contractId) {
+        if (contractId) {
+            for (const key of Object.keys(Process.contractPathCache)) {
+                if (key === contractId || Process.contractPathCache[key].includes(contractId)) {
+                    delete Process.contractPathCache[key];
+                }
+            }
+        }
+        else {
+            Process.contractPathCache = {};
+        }
+    }
+    async start(contractVersion, contractData) {
+        ActiveLogger.debug(`New TX : ${this.entry.$umid}`);
+        const setupDefaultLocation = async () => {
             this.isDefault = true;
-            this.contractLocation = fs.realpathSync(`${process.cwd()}/default_contracts/${this.entry.$tx.$contract}.js`);
+            if (await fs.stat(`${process.cwd()}/default_contracts/_LOCK.${this.entry.$tx.$contract}`).catch(() => false)) {
+                throw new Error("Contract Global Lock");
+            }
+            this.contractLocation = await fs.realpath(`${process.cwd()}/default_contracts/${this.entry.$tx.$contract}.js`);
         };
-        const setupLocation = () => {
-            var _a;
+        const setupLocation = async () => {
             let contract = this.entry.$tx.$contract;
+            this.contractId = contract.split("@")[0];
             try {
-                let contractId;
-                let namespacePath;
-                try {
-                    namespacePath = fs.realpathSync(`${process.cwd()}/contracts/${this.entry.$tx.$namespace}/`);
-                    const trueContractPath = fs.realpathSync(`${namespacePath}/${contract}.js`);
-                    contractId = path.basename(trueContractPath, path.extname(trueContractPath));
-                    if (contractId.indexOf("@") > -1) {
-                        contractId = contractId.split("@")[0];
+                if (!Process.contractPathCache[this.entry.$tx.$contract] ||
+                    (contractVersion && !Process.contractPathCache[this.entry.$tx.$contract].endsWith(`${contractVersion}.js`))) {
+                    let namespacePath = "";
+                    try {
+                        namespacePath = await fs.realpath(`${process.cwd()}/contracts/${this.entry.$tx.$namespace}/`);
+                    }
+                    catch {
+                        throw new Error("Namespace not found");
                     }
-                }
-                catch (_b) {
-                    throw new Error("Contract or Namespace not found");
-                }
-                this.contractId = contractId;
-                if (this.entry.$tx.$contract.indexOf("@") === -1) {
                     if (contractVersion) {
                         contract = contractVersion;
                     }
                     else {
-                        try {
-                            contract =
-                                ((_a = fs
-                                    .readdirSync(namespacePath)
-                                    .filter((fn) => fn.includes(`${this.contractId}@`))
-                                    .sort(this.sortVersions)
-                                    .pop()) === null || _a === void 0 ? void 0 : _a.replace(".js", "")) || this.contractId;
-                            this.emit("contractLatestVersion", {
-                                contract: this.entry.$tx.$contract,
-                                file: contract,
-                            });
+                        if (this.entry.$tx.$contract.indexOf("@=") !== -1) {
+                            contract = this.entry.$tx.$contract.replace("@=", "@");
                         }
-                        catch (_c) {
-                            throw new Error(`${this.contractId}@latest not found`);
+                        else {
+                            try {
+                                contract = ((await fs
+                                    .readdir(namespacePath))
+                                    .filter((fn) => fn.includes(this.entry.$tx.$contract))
+                                    .sort(this.sortVersions)
+                                    .pop() || "notfound.404").replace(".js", "");
+                            }
+                            catch {
+                                throw new Error("Contract not found");
+                            }
                         }
                     }
+                    if (!(await fs.stat(`${namespacePath}/${contract}.js`).catch(() => false))) {
+                        throw new Error("Contract not found");
+                    }
+                    if (!contractVersion) {
+                        this.emit("contractLatestVersion", {
+                            contract: this.entry.$tx.$contract,
+                            file: contract,
+                            refresh: false,
+                        });
+                    }
+                    if (await fs.stat(`${namespacePath}/_LOCK.${this.contractId}`).catch(() => false)) {
+                        throw new Error("Contract Global Lock");
+                    }
+                    if (await fs.stat(`${namespacePath}/_LOCK.${contract}`).catch(() => false)) {
+                        throw new Error(`Contract Version Lock ${contract.substring(contract.indexOf("@") + 1)}`);
+                    }
+                    Process.contractPathCache[this.entry.$tx.$contract] = await fs.realpath(`${namespacePath}/${contract}.js`);
                 }
-                if (fs.existsSync(`${namespacePath}/_LOCK.${this.contractId}`)) {
-                    throw new Error("Contract Global Lock");
-                }
-                if (fs.existsSync(`${namespacePath}/_LOCK.${contract}`)) {
-                    throw new Error(`Contract Version Lock ${contract.substring(contract.indexOf("@") + 1)}`);
-                }
-                this.contractLocation = fs.realpathSync(`${namespacePath}/${contract}.js`);
+                this.contractLocation =
+                    Process.contractPathCache[this.entry.$tx.$contract];
             }
             catch (e) {
                 throw e;
             }
         };
         try {
-            this.entry.$tx.$namespace === "default"
+            await (this.entry.$tx.$namespace === "default"
                 ? setupDefaultLocation()
-                : setupLocation();
+                : setupLocation());
         }
         catch (error) {
-            this.entry.$nodes[this.reference].error = `Init Contract Error - ${error.message}`;
+            this.entry.$nodes[this.reference].error = `Init Contract Error - ${error.message || error}`;
             this.emit("commited", { instant: true });
             return;
         }
-        const virtualMachine = this.isDefault
-            ? Process.defaultContractsVM
-            : this.contractRef
-                ? Process.singleContractVMHolder[this.contractRef]
-                : Process.generalContractVM;
-        if (fs.existsSync(this.contractLocation)) {
+        const virtualMachine = Process.generalContractVM;
+        if (await fs.stat(this.contractLocation).catch(() => false)) {
             this.inputs = Object.keys(this.entry.$tx.$i || {});
             if (this.inputs.length) {
                 this.labelOrKey();
@@ -152,7 +191,6 @@ export class Process extends EventEmitter {
                 this.labelOrKey(true);
             }
             if (!this.entry.$revs) {
-                this.checkRevs = false;
                 this.entry.$revs = {
                     $i: {},
                     $o: {},
@@ -162,28 +200,24 @@ export class Process extends EventEmitter {
                 try {
                     const inputStreams = await this.permissionChecker.process(this.inputs);
                     const outputStreams = await this.permissionChecker.process(this.outputs, false);
-                    let contractData = undefined;
-                    if (!this.isDefault) {
-                        try {
-                            const contractDataStreams = await this.permissionChecker.process([`${this.contractId}:data`], false);
-                            if (contractDataStreams.length > 0) {
-                                contractData = contractDataStreams[0]
-                                    .state;
-                            }
-                        }
-                        catch (e) {
-                            if (e.code === 1200) {
-                                throw e;
-                            }
-                        }
-                    }
-                    this.process(inputStreams, outputStreams, contractData);
+                    this.process(inputStreams, outputStreams, await this.getContractDate(contractData));
                 }
                 catch (error) {
-                    this.postVote(virtualMachine, {
-                        code: error.code,
-                        reason: error.reason || error.message,
-                    });
+                    const reason = error.reason || error.message || error;
+                    if (this.entry.$unanimous &&
+                        !this.entry.$broadcast &&
+                        !this.entry.$spiRetry &&
+                        (reason.indexOf("Position Incorrect") !== -1 ||
+                            reason === "Stream(s) not found")) {
+                        this.entry.$nodes[this.reference].error = reason;
+                        this.emitFailed({ status: error.code || 1200, error: reason, entry: this.entry }, true);
+                    }
+                    else {
+                        this.postVote(virtualMachine, {
+                            code: error.code,
+                            reason,
+                        });
+                    }
                 }
             }
             else {
@@ -211,15 +245,29 @@ export class Process extends EventEmitter {
                         }
                     }
                 }
+                else {
+                    return this.shared.raiseLedgerError(1260, new Error("Self signed - Must have inputs"));
+                }
                 try {
                     const outputStreams = await this.permissionChecker.process(this.outputs, false);
-                    this.process([], outputStreams, undefined);
+                    this.process([], outputStreams, await this.getContractDate(contractData));
                 }
                 catch (error) {
-                    this.postVote(virtualMachine, {
-                        code: error.code,
-                        reason: error.reason || error.message,
-                    });
+                    const reason = error.reason || error.message || error;
+                    if (this.entry.$unanimous &&
+                        !this.entry.$broadcast &&
+                        !this.entry.$spiRetry &&
+                        (reason === "Stream(s) not found" ||
+                            reason.indexOf("Position Incorrect") !== -1)) {
+                        this.entry.$nodes[this.reference].error = reason;
+                        this.emitFailed({ status: error.code || 1200, error: reason, entry: this.entry }, true);
+                    }
+                    else {
+                        this.postVote(virtualMachine, {
+                            code: error.code,
+                            reason,
+                        });
+                    }
                 }
             }
         }
@@ -234,10 +282,13 @@ export class Process extends EventEmitter {
         if (this.isCommiting()) {
             return;
         }
+        if (node[this.reference]) {
+            delete node[this.reference];
+        }
         this.entry.$nodes = Object.assign(this.entry.$nodes, node);
         if (this.willEmit) {
             const nodes = Object.keys(this.entry.$nodes);
-            if (!this.hasOutstandingVotes(nodes.length) && !this.canCommit()) {
+            if (!(this.hasOutstandingVotes()) && !this.canCommit()) {
                 this.emitFailed(this.willEmitData);
             }
             else {
@@ -251,42 +302,62 @@ export class Process extends EventEmitter {
         }
         else {
             if (!this.isCommiting() && !this.voting) {
-                this.nodeResponse = this.entry.$nodes[this.reference];
-                this.isDefault
-                    ? this.commit(Process.defaultContractsVM)
-                    : this.contractRef
-                        ? this.commit(Process.singleContractVMHolder[this.contractRef])
-                        : this.commit(Process.generalContractVM);
+                this.commit(Process.generalContractVM);
             }
         }
     }
     isCommiting() {
         return this.commiting;
     }
-    processDefaultContracts(payload, contractName) {
-        if (!Process.defaultContractsVM) {
-            try {
-                Process.defaultContractsVM = new VirtualMachine(this.selfHost, this.secured, this.db, this.dbev);
-                Process.defaultContractsVM.initialiseVirtualMachine(["fs", "path", "os", "crypto"], ["typescript"]);
+    async getContractDate(contractData) {
+        if (!contractData && !this.isDefault) {
+            if (await this.db.exists(`${this.contractId}:data`)) {
+                try {
+                    const contractDataStreams = await this.permissionChecker.process([`${this.contractId}:data`], false, 5);
+                    if (contractDataStreams.length > 0) {
+                        contractData = contractDataStreams[0]
+                            .state;
+                    }
+                }
+                catch (e) {
+                    if (e.code === 1200) {
+                        this.emit("contractData", {
+                            contract: this.contractId,
+                            data: {},
+                        });
+                        throw e;
+                    }
+                }
             }
-            catch (error) {
-                throw new Error(error);
+            else {
+                contractData = { _id: "", data: {} };
             }
+            this.emit("contractData", {
+                contract: this.contractId,
+                data: contractData,
+            });
         }
-        this.handleVM(Process.defaultContractsVM, payload, contractName);
-    }
-    processUnsafeContracts(payload, namespace, contractName, extraBuiltins, extraExternals, extraMocks) {
-        this.contractRef = namespace;
-        if (!Process.singleContractVMHolder[this.contractRef]) {
-            try {
-                Process.singleContractVMHolder[this.contractRef] = new VirtualMachine(this.selfHost, this.secured, this.db, this.dbev);
-                Process.singleContractVMHolder[this.contractRef].initialiseVirtualMachine(extraBuiltins, extraExternals, extraMocks);
-            }
-            catch (error) {
-                throw new Error(error);
+        else {
+            if (contractData && this.contractId) {
+                const rev = `0-context:${contractData._rev}`;
+                if (this.entry.$revs.$o[`${this.contractId}:data`]) {
+                    if (this.entry.$revs.$o[`${this.contractId}:data`] !== rev) {
+                        this.emit("contractData", {
+                            contract: this.contractId,
+                            data: {},
+                        });
+                        throw {
+                            code: 1200,
+                            reason: "Output Stream Position Incorrect",
+                        };
+                    }
+                }
+                else {
+                    this.entry.$revs.$o[`${this.contractId}:data`] = rev;
+                }
             }
         }
-        this.handleVM(Process.singleContractVMHolder[this.contractRef], payload, contractName);
+        return contractData;
     }
     async handleVM(virtualMachine, payload, contractName) {
         const handleVoteError = async (error) => {
@@ -294,7 +365,7 @@ export class Process extends EventEmitter {
             ActiveLogger.debug(this.nodeResponse.error, `Handle Vote Error ${payload.umid}`);
             ActiveLogger.debug(`Calling Contract Return Data - ${payload.umid}`);
             this.nodeResponse.return = virtualMachine.getReturnContractData(this.entry.$umid);
-            this.postVote(virtualMachine);
+            this.postVote(virtualMachine, this.nodeResponse.error);
         };
         let continueProcessing = true;
         try {
@@ -319,7 +390,12 @@ export class Process extends EventEmitter {
             try {
                 if (continueProcessing)
                     ActiveLogger.debug(`Calling Contract Vote - ${payload.umid}`);
-                await virtualMachine.vote(this.entry.$nodes, payload.umid);
+                const vote = await virtualMachine.vote(this.entry.$nodes, payload.umid);
+                if (typeof vote !== "boolean" && vote.leader) {
+                    this.nodeResponse.vote = this.nodeResponse.leader = true;
+                    this.commit(virtualMachine);
+                    return;
+                }
             }
             catch (error) {
                 handleVoteError(error);
@@ -327,6 +403,7 @@ export class Process extends EventEmitter {
             }
             if (continueProcessing) {
                 this.nodeResponse.vote = true;
+                this.nodeResponse.early = false;
                 ActiveLogger.debug(`Calling Contract INC - ${payload.umid}`);
                 this.nodeResponse.incomms = virtualMachine.getInternodeCommsFromVM(payload.umid);
                 ActiveLogger.debug(`Calling Contract Return Data - ${payload.umid}`);
@@ -342,6 +419,7 @@ export class Process extends EventEmitter {
             }
             catch (error) {
                 this.nodeResponse.error = "Read Error - " + JSON.stringify(error);
+                this.nodeResponse.early = false;
             }
             this.nodeResponse.commit = true;
             this.emit("commited");
@@ -349,8 +427,10 @@ export class Process extends EventEmitter {
     }
     async process(inputs, outputs = [], contractData = undefined) {
         try {
-            if (this.entry.$broadcast) {
-                this.emit("broadcast", true);
+            if (this.entry.$broadcast && !this.entry.$wait) {
+                if (this.entry.$origin === this.reference) {
+                    this.emit("broadcast", true);
+                }
             }
             const readonly = await this.getReadOnlyStreams();
             const contractName = this.contractLocation.substring(this.contractLocation.lastIndexOf("/") + 1);
@@ -374,46 +454,10 @@ export class Process extends EventEmitter {
                 inputs,
                 outputs,
                 readonly,
-                key: Math.floor(Math.random() * 100),
-                contractData,
+                key: 0,
+                contractData: contractData ? contractData : { _id: "", data: {} },
             };
-            if (!this.securityCache) {
-                this.securityCache = ActiveOptions.get("security", null);
-            }
-            if (payload.transaction.$namespace === "default") {
-                this.processDefaultContracts(payload, contractName);
-            }
-            else {
-                if (this.securityCache &&
-                    this.securityCache.namespace &&
-                    this.securityCache.namespace[payload.transaction.$namespace]) {
-                    const builtin = [];
-                    const external = [];
-                    const mocks = [];
-                    const namespaceExtras = this.securityCache.namespace[payload.transaction.$namespace];
-                    if (namespaceExtras) {
-                        if (namespaceExtras.std) {
-                            namespaceExtras.std.forEach((item) => {
-                                builtin.push(item);
-                            });
-                        }
-                        if (namespaceExtras.external) {
-                            namespaceExtras.external.forEach((item) => {
-                                external.push(item);
-                            });
-                        }
-                        if (namespaceExtras.mock) {
-                            namespaceExtras.mock.forEach((item) => {
-                                mocks.push(item);
-                            });
-                        }
-                    }
-                    this.processUnsafeContracts(payload, payload.transaction.$namespace, contractName, builtin, external, mocks);
-                }
-                else {
-                    this.handleVM(Process.generalContractVM, payload, contractName);
-                }
-            }
+            this.handleVM(Process.generalContractVM, payload, contractName);
         }
         catch (error) {
             this.shared.raiseLedgerError(1210, new Error("Read Only Stream Error"));
@@ -422,6 +466,8 @@ export class Process extends EventEmitter {
     }
     postVote(virtualMachine, error = false) {
         this.voting = false;
+        this.nodeResponse.early = false;
+        delete this.nodeResponse.early;
         if (!this.entry) {
             ActiveLogger.debug(`postVote entry is missing?`);
             return;
@@ -432,25 +478,32 @@ export class Process extends EventEmitter {
         }
         if (this.entry.$broadcast) {
             if (error) {
-                this.entry.$nodes[this.reference].error = error.reason;
+                this.entry.$nodes[this.reference].error = error.reason
+                    ? error.reason
+                    : error;
+                if (error.code === 950) {
+                    this.shared.raiseLedgerError(error.code, error.reason);
+                }
             }
-            this.emit("broadcast");
-            if (this.canCommit()) {
-                this.commit(virtualMachine);
+            if (!this.nodeResponse.leader) {
+                this.emit("broadcast");
             }
+            this.commit(virtualMachine);
         }
         else {
             if (this.right.reference != this.entry.$origin) {
-                ActiveLogger.debug("Attempting commit with too early commit callback (to send right");
+                ActiveLogger.debug("Attempting commit with too early commit callback (to send right)");
                 this.commit(virtualMachine, async () => {
                     try {
                         const response = await this.initRightKnock();
                         if (!this.nodeResponse.commit) {
-                            this.entry.$territoriality = response.data.$territoriality;
-                            this.entry.$nodes = response.data.$nodes;
+                            const data = response.data;
+                            this.entry.$territoriality =
+                                data.$territoriality ?? this.entry.$territoriality;
+                            this.entry.$nodes = data.$nodes ?? this.entry.$nodes;
                             this.nodeResponse = this.entry.$nodes[this.reference];
                             if (error) {
-                                this.shared.raiseLedgerError(error.code, error.reason, true, 10);
+                                this.shared.raiseLedgerError(error.code || 1000, error.reason || error, true, 10);
                             }
                             ActiveLogger.debug("Sending Commit without callback");
                             this.commit(virtualMachine);
@@ -467,15 +520,16 @@ export class Process extends EventEmitter {
             else {
                 ActiveLogger.debug("Origin is next (Sending Back)");
                 error
-                    ? this.shared.raiseLedgerError(error.code, error.reason)
+                    ? this.shared.raiseLedgerError(error.code || 1000, error.reason || error)
                     : this.commit(virtualMachine);
             }
         }
     }
-    emitFailed(data) {
-        if (this.willEmit) {
+    emitFailed(data, noWait) {
+        this.commiting = false;
+        if (this.willEmit || noWait) {
             clearTimeout(this.willEmit);
-            this.emit("failed", this.willEmitData);
+            this.emit("failed", this.willEmitData || data);
         }
         else {
             if (this.entry &&
@@ -491,14 +545,23 @@ export class Process extends EventEmitter {
             }
         }
     }
-    hasOutstandingVotes(nodes) {
-        const neighbours = ActiveOptions.get("neighbourhood", []).length;
-        return !!(neighbours - (nodes || Object.keys(this.entry.$nodes).length));
+    hasOutstandingVotes() {
+        return !!(Process.networkNodeLength - this.countOutstandingVotes());
+    }
+    countOutstandingVotes() {
+        const nodes = Object.keys(this.entry.$nodes);
+        let votedNodes = 0;
+        for (let i = nodes.length; i--;) {
+            if (!this.entry.$nodes[nodes[i]].early) {
+                votedNodes++;
+            }
+        }
+        return votedNodes;
     }
     async initRightKnock(retries = 0) {
         try {
             ActiveLogger.debug(`Sending -> ${this.right.reference} - ${this.entry.$umid}`);
-            return await this.right.knock("init", this.entry);
+            return await this.right.knock("init-legacy", this.entry);
         }
         catch (e) {
             if (retries <= 2) {
@@ -516,22 +579,27 @@ export class Process extends EventEmitter {
     }
     canCommit() {
         let networkNodes = Object.keys(this.entry.$nodes);
-        this.currentVotes = 0;
-        for (let i = networkNodes.length; i--;) {
-            if (this.entry.$nodes[networkNodes[i]].vote)
-                this.currentVotes++;
-        }
-        const percent = this.entry.$unanimous
-            ? 100
-            : ActiveOptions.get("consensus", {}).reached;
-        return ((this.currentVotes /
-            ActiveOptions.get("neighbourhood", []).length) *
-            100 >=
-            percent || false);
+        this.currentTrueVotes = 0;
+        if (networkNodes) {
+            for (let i = networkNodes.length; i--;) {
+                if (!this.entry.$nodes[networkNodes[i]].early &&
+                    this.entry.$nodes[networkNodes[i]].vote)
+                    this.currentTrueVotes++;
+            }
+            const percent = this.entry.$unanimous
+                ? 100
+                : ActiveOptions.get("consensus", {}).reached;
+            const reached = (this.currentTrueVotes / Process.networkNodeLength) * 100 >= percent;
+            return reached;
+        }
+        else {
+            return false;
+        }
     }
     async commit(virtualMachine, earlyCommit) {
         if (!this.nodeResponse.commit && !this.isCommiting()) {
-            if (this.canCommit() && this.nodeResponse.vote) {
+            if (this.nodeResponse.vote &&
+                (this.nodeResponse.leader || this.canCommit())) {
                 this.commiting = true;
                 clearTimeout(this.broadcastTimeout);
                 try {
@@ -542,15 +610,8 @@ export class Process extends EventEmitter {
                     this.nodeResponse.incomms = virtualMachine.getInternodeCommsFromVM(this.entry.$umid);
                     ActiveLogger.debug(`Calling Contract Return Data X2 - ${this.entry.$umid}`);
                     this.nodeResponse.return = virtualMachine.getReturnContractData(this.entry.$umid);
-                    this.entry = this.shared.clearAllComms(virtualMachine, this.nodeResponse.incomms);
-                    let throws = virtualMachine.getThrowsFromVM(this.entry.$umid);
-                    if (throws && throws.length) {
-                        this.emit("throw", { locations: throws });
-                    }
                     const streamUpdater = new StreamUpdater(this.entry, virtualMachine, this.reference, this.nodeResponse, this.db, this.dbev, this, this.shared, this.contractId);
-                    earlyCommit
-                        ? streamUpdater.updateStreams(earlyCommit)
-                        : streamUpdater.updateStreams();
+                    await streamUpdater.updateStreams(earlyCommit);
                 }
                 catch (error) {
                     if (earlyCommit)
@@ -575,7 +636,7 @@ export class Process extends EventEmitter {
                             if (reconciled) {
                                 ActiveLogger.info("Self Reconcile Successful");
                                 const streamUpdater = new StreamUpdater(this.entry, virtualMachine, this.reference, this.nodeResponse, this.db, this.dbev, this, this.shared, this.contractId);
-                                streamUpdater.updateStreams();
+                                await streamUpdater.updateStreams();
                             }
                             else {
                                 if (this.errorOut.code === 1505) {
@@ -607,9 +668,8 @@ export class Process extends EventEmitter {
                         this.shared.raiseLedgerError(1510, new Error("Failed Network Voting Round - Non Broadcast"));
                     }
                     else {
-                        const neighbours = ActiveOptions.get("neighbourhood", []).length;
                         const consensusNeeded = ActiveOptions.get("consensus", {}).reached;
-                        const outstandingVoters = neighbours - Object.keys(this.entry.$nodes).length;
+                        const outstandingVoters = Process.networkNodeLength - this.countOutstandingVotes();
                         if (!outstandingVoters) {
                             clearTimeout(this.broadcastTimeout);
                             if (this.nodeResponse.error) {
@@ -626,12 +686,17 @@ export class Process extends EventEmitter {
                         }
                         else {
                             clearTimeout(this.broadcastTimeout);
-                            if (((this.currentVotes + outstandingVoters) / neighbours) * 100 >=
+                            if (((this.currentTrueVotes + outstandingVoters) / Process.networkNodeLength) *
+                                100 >=
                                 consensusNeeded) {
                                 this.broadcastTimeout = setTimeout(() => {
-                                    ActiveLogger.debug("VM Commit Failure, NETWORK Timeout");
-                                    return this.shared.raiseLedgerError(1510, new Error("Failed Network Voting Timeout - Voters Timed Out"));
-                                }, BROADCAST_TIMEOUT);
+                                    if (!this.isCommiting()) {
+                                        ActiveLogger.debug("VM Commit Failure, NETWORK Timeout");
+                                        return this.shared.raiseLedgerError(1510, new Error("Failed Network Voting Timeout - Voters Timed Out"));
+                                    }
+                                }, this.isCommiting()
+                                    ? BROADCAST_TIMEOUT_COMMIT
+                                    : this.currentTrueVotes === 0 ? BROADCAST_TIMEOUT_EARLY : BROADCAST_TIMEOUT_VOTE);
                             }
                             else {
                                 if (this.nodeResponse.error) {
@@ -699,9 +764,11 @@ export class Process extends EventEmitter {
                 let streamId = txIO[streams[i]].$stream || streams[i];
                 map[streamId] = streams[i];
                 streams[i] = streamId;
+                if (!outputs && txIO[map[streamId]].$sigOnly) {
+                    this.shared.sigOnly[streams[i]] = true;
+                }
             }
         }
     }
 }
-Process.singleContractVMHolder = {};
 //# sourceMappingURL=process.js.map