From 1a954ad96e34d47833094a2d6b1384be1a35087c Mon Sep 17 00:00:00 2001
From: Ravin Perera <33562092+ravinsp@users.noreply.github.com>
Date: Tue, 22 Dec 2020 16:55:44 +0530
Subject: [PATCH] Implemented output signature checks. (#200)

---
 CMakeLists.txt                          |   1 +
 examples/js_client/browser-example.html |  61 ++++--
 examples/js_client/hp-client-lib.js     | 263 +++++++++++++++++++-----
 examples/js_client/package-lock.json    |   5 +
 examples/js_client/package.json         |   1 +
 examples/js_client/text-client.js       |  74 +++++--
 src/consensus.cpp                       | 163 +++++++++------
 src/consensus.hpp                       |  24 ++-
 src/msg/bson/usrmsg_bson.cpp            |  47 ++++-
 src/msg/bson/usrmsg_bson.hpp            |   7 +-
 src/msg/fbuf/ledger_helpers.cpp         |   4 +-
 src/msg/fbuf/ledger_schema.fbs          |   2 +-
 src/msg/fbuf/ledger_schema_generated.h  |  31 +--
 src/msg/fbuf/p2pmsg_content.fbs         |   5 +-
 src/msg/fbuf/p2pmsg_content_generated.h | 108 +++++++---
 src/msg/fbuf/p2pmsg_helpers.cpp         |  19 +-
 src/msg/json/usrmsg_json.cpp            | 114 +++++++---
 src/msg/json/usrmsg_json.hpp            |   7 +-
 src/msg/usrmsg_common.hpp               |   4 +
 src/msg/usrmsg_parser.cpp               |   8 +-
 src/msg/usrmsg_parser.hpp               |   5 +-
 src/p2p/p2p.hpp                         |   5 +-
 src/util/merkle_hash_tree.cpp           | 157 ++++++++++++++
 src/util/merkle_hash_tree.hpp           |  34 +++
 src/util/util.cpp                       |  17 +-
 src/util/util.hpp                       |   2 +
 26 files changed, 903 insertions(+), 265 deletions(-)
 create mode 100644 src/util/merkle_hash_tree.cpp
 create mode 100644 src/util/merkle_hash_tree.hpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ec9c2884..13910348 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -28,6 +28,7 @@ add_executable(hpcore
     src/util/rollover_hashset.cpp
     src/util/ttl_set.cpp
     src/util/buffer_store.cpp
+    src/util/merkle_hash_tree.cpp
     src/unl.cpp
     src/crypto.cpp
     src/conf.cpp
diff --git a/examples/js_client/browser-example.html b/examples/js_client/browser-example.html
index 4af813c0..67921773 100644
--- a/examples/js_client/browser-example.html
+++ b/examples/js_client/browser-example.html
@@ -1,7 +1,8 @@
 <html>
 
 <head>
-    <title>HotPocket test page</title>
+    <title>HotPocket browser example</title>
+
     <script src="hp-client-lib.js"></script>
 
     <!--Hot Pocket client library requires libsodium js for cryptographic operations.-->
@@ -9,49 +10,58 @@
         integrity="sha512-oRfU7aik4u7f0dPAKgOyA4+bb/YRGfAaD5RA4Z3Mb2ycPcGDs+k8qAnDNd7ouruoqlIHSuGVaTTlEs91Gvd37A=="
         crossorigin="anonymous"></script>
 
+    <!--Hot Pocket client library requires blake3 for hashing operations.-->
+    <script type="module">
+        import init from 'https://cdn.jsdelivr.net/npm/blake3@2.1.4/browser-async.js';
+        init().then(blake3 => HotPocket.setBlake3(blake3)).catch(console.error);
+    </script>
+
     <script>
         async function testFunc() {
+
             const keys = await HotPocket.generateKeys(); // Can provide existing hex private key as parameter as well.
 
             // Simple connection to single server without any validations.
             const hpc = await HotPocket.createClient(["wss://localhost:8081"], keys);
 
-            // Maintain multiple connections with contract id/version and server key validation.
-            // const options = {
-            //     contractId: "3c349abe-4d70-4f50-9fa6-018f1f2530ab",
-            //     contractVersion: "1.0",
-            //     validServerKeys: [
-            //         "ed5597c207bbd251997b7133d5d83a2c6ab9600810edf0bdb43f4004852b8c9e17",
-            //         "ed0b2ffd75b67c3979d3c362d8350ec190f053fa27d3dfcb2eced426efd1d3affc",
-            //         "edd2e1a817387d68adf8adb1d0b339e3f04868c3c81bf6a7472647f10657e31aa1"
-            //     ],
-            //     protocol: HotPocket.protocols.json,
-            //     requiredConnectionCount: 2,
-            //     connectionTimeoutMs: 5000
-            // };
+            // Maintain multiple connections with contract id/version and trusted server key validation.
             // const hpc = await HotPocket.createClient(
             //     [
             //         "wss://localhost:8081",
             //         "wss://localhost:8082",
             //         "wss://localhost:8083"
-            //     ], keys, options);
+            //     ],
+            //     keys,
+            //     {
+            //         contractId: "3c349abe-4d70-4f50-9fa6-018f1f2530ab",
+            //         contractVersion: "1.0",
+            //         trustedServerKeys: [
+            //             "ed5597c207bbd251997b7133d5d83a2c6ab9600810edf0bdb43f4004852b8c9e17",
+            //             "ed0b2ffd75b67c3979d3c362d8350ec190f053fa27d3dfcb2eced426efd1d3affc",
+            //             "edd2e1a817387d68adf8adb1d0b339e3f04868c3c81bf6a7472647f10657e31aa1"
+            //         ],
+            //         protocol: HotPocket.protocols.json,
+            //         requiredConnectionCount: 2,
+            //         connectionTimeoutMs: 5000
+            //     });
 
-            if (!await hpc.connect()) {
-                console.log('Connection failed.');
-                return;
-            }
-            console.log('HotPocket Connected.');
+            // We'll register for HotPocket events before connecting.
 
             // This will get fired if HP server disconnects unexpectedly.
             hpc.on(HotPocket.events.disconnect, () => {
                 console.log('Disconnected');
             })
 
-            // This will get fired as servers connects/disconnects after the initial connection establishment.
+            // This will get fired as servers connects/disconnects.
             hpc.on(HotPocket.events.connectionChange, (server, action) => {
                 console.log(server + " " + action);
             })
 
+            // This will get when the unl public key list changes.
+            hpc.on(HotPocket.events.unlChange, (unl) => {
+                console.log("New unl received: " + JSON.stringify(unl)); // unl is an array of hex public keys.
+            })
+
             // This will get fired when contract sends an output.
             hpc.on(HotPocket.events.contractOutput, (output) => {
                 console.log("Contract output>> " + output);
@@ -62,6 +72,13 @@
                 console.log("Contract read response>> " + response);
             })
 
+            // Establish HotPocket connection.
+            if (!await hpc.connect()) {
+                console.log('Connection failed.');
+                return;
+            }
+            console.log('HotPocket Connected.');
+
             hpc.sendContractReadRequest("Hello");
             hpc.sendContractInput("World!")
 
@@ -73,7 +90,7 @@
 </head>
 
 <body>
-    HotPocket browser client test page.
+    HotPocket browser client example page. Use developer tools to see activity.
 </body>
 
 </html>
\ No newline at end of file
diff --git a/examples/js_client/hp-client-lib.js b/examples/js_client/hp-client-lib.js
index 51ef0089..20ed88d0 100644
--- a/examples/js_client/hp-client-lib.js
+++ b/examples/js_client/hp-client-lib.js
@@ -9,6 +9,7 @@
 
     const supportedHpVersion = "0.0";
     const serverChallengeSize = 16;
+    const outputValidationPassThreshold = 0.8;
     const connectionCheckIntervalMs = 1000;
     const recentActivityThresholdMs = 3000;
 
@@ -16,6 +17,7 @@
     let WebSocket = null;
     let sodium = null;
     let bson = null;
+    let blake3 = null;
 
     /*--- Included in public interface. ---*/
     const protocols = {
@@ -29,7 +31,8 @@
         disconnect: "disconnect",
         contractOutput: "contractOutput",
         contractReadResponse: "contractReadResponse",
-        connectionChange: "connectionChange"
+        connectionChange: "connectionChange",
+        unlChange: "unlChange"
     }
     Object.freeze(events);
 
@@ -60,7 +63,7 @@
         const defaultOptions = {
             contractId: null,
             contractVersion: null,
-            validServerKeys: null,
+            trustedServerKeys: null,
             protocol: protocols.json,
             requiredConnectionCount: 1,
             connectionTimeoutMs: 5000
@@ -81,6 +84,7 @@
             throw "Connection timeout must be greater than 0.";
 
         await initSodium();
+        await initBlake3();
         initWebSocket();
         if (opt.protocol == protocols.bson)
             initBson();
@@ -98,26 +102,32 @@
         if (opt.requiredConnectionCount > Object.keys(serversLookup).length)
             throw "requiredConnectionCount is higher than no. of servers.";
 
-        let serverKeysLookup = null;
-        if (opt.validServerKeys) {
-            serverKeysLookup = {};
-            opt.validServerKeys.forEach(k => {
-                const key = k.trim();
-                if (key.length > 0)
-                    serverKeysLookup[key] = true
-            });
-        }
+        let trustedKeysLookup = {};
+        opt.trustedServerKeys && opt.trustedServerKeys.sort().forEach(k => {
+            const key = k.trim();
+            if (key.length > 0)
+                trustedKeysLookup[key] = true
+        });
+        if (Object.keys(trustedKeysLookup).length == 0)
+            trustedKeysLookup = null;
 
-        if (serverKeysLookup && Object.keys(serverKeysLookup).length == 0)
-            throw "serverKeys must contain at least one key. Specify null to bypass key validation.";
-
-        return new HotPocketClient(opt.contractId, opt.contractVersion, clientKeys, serversLookup, serverKeysLookup, opt.protocol, opt.requiredConnectionCount, opt.connectionTimeoutMs);
+        return new HotPocketClient(opt.contractId, opt.contractVersion, clientKeys, serversLookup, trustedKeysLookup, opt.protocol, opt.requiredConnectionCount, opt.connectionTimeoutMs);
     }
 
-    function HotPocketClient(contractId, contractVersion, clientKeys, serversLookup, serverKeysLookup, protocol, requiredConnectionCount, connectionTimeoutMs) {
+    function HotPocketClient(contractId, contractVersion, clientKeys, serversLookup, trustedKeysLookup, protocol, requiredConnectionCount, connectionTimeoutMs) {
 
         let emitter = new EventEmitter();
 
+        // The accessor function passed into connections to query latest trusted key list.
+        // We update the returning key list whenever we get a unl update.
+        const getTrustedKeys = () => trustedKeysLookup;
+
+        // Whenever unl change is reported, update the trusted key list.
+        emitter.on(events.unlChange, (unl) => {
+            trustedKeysLookup = {};
+            unl.sort().forEach(pubkey => trustedKeysLookup[pubkey] = true);
+        })
+
         const nodes = Object.keys(serversLookup).map(s => {
             return {
                 server: s, // Server address.
@@ -194,7 +204,7 @@
 
                 // Get the next available node.
                 const n = freeNodes.shift();
-                n.connection = new HotPocketConnection(contractId, contractVersion, clientKeys, n.server, serverKeysLookup, protocol, connectionTimeoutMs, emitter);
+                n.connection = new HotPocketConnection(contractId, contractVersion, clientKeys, n.server, getTrustedKeys, protocol, connectionTimeoutMs, emitter);
                 n.lastActivity = new Date().getTime();
 
                 n.connection.connect().then(success => {
@@ -247,7 +257,7 @@
             if (status == 2)
                 return;
 
-            await Promise.all(
+            return await Promise.all(
                 nodes.filter(n => n.connection && n.connection.isConnected())
                     .map(n => n.connection.sendContractInput(input, nonce, maxLclOffset)));
         }
@@ -262,7 +272,7 @@
         }
     }
 
-    function HotPocketConnection(contractId, contractVersion, clientKeys, server, serverKeysLookup, protocol, connectionTimeoutMs, emitter) {
+    function HotPocketConnection(contractId, contractVersion, clientKeys, server, getTrustedKeys, protocol, connectionTimeoutMs, emitter) {
 
         // Create message helper with JSON protocol initially.
         // After challenge handshake, we will change this to use the protocol specified by user.
@@ -272,6 +282,7 @@
         let serverChallenge = null; // The hex challenge we have issued to the server.
         let reportedContractId = null;
         let reportedContractVersion = null;
+        let pubkey = false; // Pubkey hex (with prefix) of this connection.
 
         let ws = null;
         let handshakeTimer = null; // Timer to track connection handshake timeout.
@@ -280,6 +291,93 @@
         let statResponseResolvers = [];
         let contractInputResolvers = {};
 
+        // Calcualtes the blake3 hash of all array items.
+        const getHash = (arr) => {
+            const hash = blake3.createHash();
+            arr.forEach(item => hash.update(item));
+            return new Uint8Array(hash.digest());
+        }
+
+        // Get root hash of the given merkle hash tree. (called recursively)
+        // checkHashString specifies the hash that must be checked for existance.
+        const getMerkleHash = (tree, checkHashString) => {
+
+            const listToHash = []; // Collects elements to hash.
+            let checkHashFound = false;
+
+            for (let elem of tree) {
+
+                if (Array.isArray(elem)) {
+                    // If the 'elem' is an array we should find the root hash of the array.
+                    // Call this func recursively. If checkHash already found, pass null.
+                    const result = getMerkleHash(elem, checkHashFound ? null : checkHashString);
+                    if (result[0] == true)
+                        checkHashFound = true;
+
+                    listToHash.push(result[1]);
+                }
+                else {
+                    // 'elem' is a single hash value. We get the hash bytes depending on the data type.
+                    // (json encoding will use hex string and bson will use buffer)
+                    const hashBytes = isString(elem) ? hexToUint8Array(elem) : elem.buffer;
+                    listToHash.push(hashBytes);
+
+                    // If checkHash is specified, compare the hashes.
+                    if (checkHashString && msgHelper.stringifyValue(hashBytes) == checkHashString)
+                        checkHashFound = true;
+                }
+            }
+
+            // Return a tuple of whether check hash was found and the root hash of the provided merkle tree.
+            return [checkHashFound, getHash(listToHash)];
+        }
+
+        // Verifies whether the provided root hash has enough signatures from unl.
+        const validateHashSignatures = (rootHash, signatures, unlKeysLookup) => {
+
+            const totalUnl = Object.keys(unlKeysLookup).length;
+            if (totalUnl == 0) {
+                console.log("Cannot validate outputs with empty unl.");
+                return false;
+            }
+
+            const passedKeys = {};
+
+            // 'signatures' is an array of pairs of [pubkey, signature]
+            for (pair of signatures) {
+                const pubkeyHex = msgHelper.stringifyValue(pair[0]); // Gets the pubkey hex to use for unl lookup key.
+
+                // Get the signature and issuer pubkey bytes based on the data type.
+                // (json encoding will use hex string and bson will use buffer)
+                const pubkey = isString(pair[0]) ? hexToUint8Array(pair[0].substring(2)) : pair[0].buffer.slice(1); // Skip prefix byte.
+                const sig = isString(pair[1]) ? hexToUint8Array(pair[1]) : pair[1].buffer;
+
+                // Check whether the pubkey is in unl and whether signature is valid.
+                if (!passedKeys[pubkeyHex] && unlKeysLookup[pubkeyHex] && sodium.crypto_sign_verify_detached(sig, rootHash, pubkey))
+                    passedKeys[pubkeyHex] = true;
+            }
+
+            // Check the percentage of unl keys that passed the signature check.
+            const passed = Object.keys(passedKeys).length;
+            return ((passed / totalUnl) >= outputValidationPassThreshold);
+        }
+
+        const validateOutput = (msg, trustedKeys) => {
+
+            // Calculate combined output hash with user's pubkey.
+            const outputHash = getHash([[0xED], clientKeys.publicKey, ...msgHelper.spreadArrayField(msg.outputs)]);
+
+            const result = getMerkleHash(msg.hashes, msgHelper.stringifyValue(outputHash));
+            if (result[0] == true) {
+                const rootHash = result[1];
+
+                // Verify the issued signatures against the root hash.
+                return validateHashSignatures(rootHash, msg.unl_sig, trustedKeys);
+            }
+
+            return false;
+        }
+
         const handshakeMessageHandler = (m) => {
 
             if (connectionStatus == 0 && m.type == "user_challenge" && m.hp_version && m.contract_id) {
@@ -320,12 +418,6 @@
             }
             else if (connectionStatus == 1 && serverChallenge && m.type == "server_challenge_response" && m.sig && m.pubkey) {
 
-                // If server keys has been specified, validate whether this server's pubkey is among the valid list.
-                if (serverKeysLookup && !serverKeysLookup[m.pubkey]) {
-                    console.log(`${server} key '${m.pubkey}' not among the valid keys.`);
-                    return false;
-                }
-
                 // Verify server challenge response.
                 const stringToVerify = serverChallenge + reportedContractId + reportedContractVersion;
                 const serverPubkeyHex = m.pubkey.substring(2); // Skip 'ed' prefix;
@@ -338,12 +430,26 @@
                 handshakeTimer = null;
                 serverChallenge = null; // Clear the sent challenge as we no longer need it.
                 msgHelper.useProtocol(protocol); // Here onwards, use the message protocol specified by user.
+                pubkey = m.pubkey; // Set this connection's public key.
                 connectionStatus = 2; // Handshake complete.
 
                 // If we are still connected, report handshaking as successful.
                 // (If websocket disconnects, handshakeResolver will be already null)
                 handshakeResolver && handshakeResolver(true);
                 console.log(`Connected to ${server}`);
+
+                // If this is currently a trusted connection, notify unl update.
+                const trustedKeys = getTrustedKeys();
+                if (trustedKeys && trustedKeys[pubkey]) {
+                    // Prepare sorted new unl lookup object for equality comparison.
+                    const newUnl = {};
+                    m.unl.sort().forEach(k => newUnl[k] = true);
+
+                    // Only emit unl change event if the unl has really changed.
+                    if (JSON.stringify(trustedKeys) != JSON.stringify(newUnl))
+                        emitter && emitter.emit(events.unlChange, m.unl);
+                }
+
                 return true;
             }
 
@@ -358,7 +464,7 @@
                 emitter && emitter.emit(events.contractReadResponse, msgHelper.deserializeOutput(m.content));
             }
             else if (m.type == "contract_input_status") {
-                const sigKey = msgHelper.stringifySignature(m.input_sig);
+                const sigKey = msgHelper.stringifyValue(m.input_sig);
                 const resolver = contractInputResolvers[sigKey];
                 if (resolver) {
                     if (m.status == "accepted")
@@ -369,7 +475,14 @@
                 }
             }
             else if (m.type == "contract_output") {
-                emitter && emitter.emit(events.contractOutput, msgHelper.deserializeOutput(m.content));
+                if (emitter) {
+                    // Validate outputs if trusted keys is not null. (null means bypass validation)
+                    const trustedKeys = getTrustedKeys();
+                    if (!trustedKeys || validateOutput(m, trustedKeys))
+                        m.outputs.forEach(output => emitter.emit(events.contractOutput, msgHelper.deserializeOutput(output)));
+                    else
+                        console.log("Output validation failed.");
+                }
             }
             else if (m.type == "stat_response") {
                 statResponseResolvers.forEach(resolver => {
@@ -529,7 +642,7 @@
             const maxLclSeqNo = stat.lclSeqNo + maxLclOffset;
 
             const msg = msgHelper.createContractInput(input, nonce, maxLclSeqNo);
-            const sigKey = msgHelper.stringifySignature(msg.sig);
+            const sigKey = msgHelper.stringifyValue(msg.sig);
             const p = new Promise(resolve => {
                 contractInputResolvers[sigKey] = resolve;
             });
@@ -570,7 +683,7 @@
 
         this.serializeInput = (input) => {
             return protocol == protocols.json ?
-                ((typeof input === "string" || input instanceof String) ? input : input.toString()) :
+                (isString(input) ? input : input.toString()) :
                 (Buffer.isBuffer(input) ? input : Buffer.from(input));
         }
 
@@ -578,18 +691,23 @@
             return protocol == protocols.json ? content : content.buffer;
         }
 
-        // Used for generating strings to hold signature as js object keys.
-        this.stringifySignature = (sig) => {
-            if (typeof sig === 'string' || sig instanceof String)
-                return sig;
-            else if (sig instanceof Uint8Array)
-                return uint8ArrayToHex(sig);
-            else if (sig.buffer) // BSON binary.
-                return uint8ArrayToHex(new Uint8Array(sig.buffer));
+        // Used for generating strings to hold values as js object keys.
+        this.stringifyValue = (val) => {
+            if (isString(val))
+                return val;
+            else if (val instanceof Uint8Array)
+                return uint8ArrayToHex(val);
+            else if (val.buffer) // BSON binary.
+                return uint8ArrayToHex(new Uint8Array(val.buffer));
             else
                 throw "Cannot stringify signature.";
         }
 
+        // Spreads hex/binary item array.
+        this.spreadArrayField = (outputs) => {
+            return protocol == protocols.json ? outputs : outputs.map(o => o.buffer);
+        }
+
         this.createUserChallengeResponse = (userChallenge, serverChallenge, msgProtocol) => {
             // For challenge response encoding Hot Pocket always uses json.
             // Challenge response will specify the protocol to use for contract messages.
@@ -650,6 +768,10 @@
         return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
     }
 
+    function isString(obj) {
+        return (typeof obj === "string" || obj instanceof String);
+    }
+
     function EventEmitter() {
         const registrations = {};
 
@@ -681,12 +803,9 @@
             sodium = window.sodium;
         }
         else if (isBrowser && !window.sodium) { // If sodium not yet loaded in browser, wait for sodium ready.
-            await new Promise(resolve => {
+            sodium = await new Promise(resolve => {
                 window.sodium = {
-                    onload: async function (sodiumRef) {
-                        sodium = sodiumRef;
-                        resolve();
-                    }
+                    onload: async (sodiumRef) => resolve(sodiumRef)
                 }
             })
         }
@@ -694,9 +813,9 @@
             sodium = require('libsodium-wrappers');
             await sodium.ready;
         }
-        else {
+
+        if (!sodium)
             throw "Sodium reference not found. Please include sodium js lib in browser scripts.";
-        }
     }
 
     // Set bson reference.
@@ -707,7 +826,8 @@
             bson = window.BSON;
         else if (!isBrowser) // nodejs
             bson = require('bson');
-        else
+
+        if (!bson)
             throw "BSON reference not found.";
     }
 
@@ -719,19 +839,52 @@
             WebSocket = window.WebSocket;
         else if (!isBrowser) // nodejs
             WebSocket = require('ws');
-        else
+
+        if (!WebSocket)
             throw "WebSocket reference not found.";
     }
 
-    const hotPocketLib = {
-        generateKeys,
-        createClient,
-        events,
-        protocols
+    let blake3Resolver = null;
+    // Set blake3 reference.
+    async function initBlake3() {
+        if (blake3) // If already set, do nothing.
+            return;
+        else if (isBrowser && window.blake3) // browser (if blake3 already loaded)
+            blake3 = window.blake3;
+        else if (isBrowser && !window.blake3) // If blake3 not yet loaded in browser, wait for it.
+            blake3 = await new Promise(resolve => blake3Resolver = resolve);
+        else if (!isBrowser) // nodejs
+            blake3 = require('blake3');
+
+        if (!blake3)
+            throw "Blake3 reference not found.";
     }
 
-    if (isBrowser)
-        window.HotPocket = hotPocketLib;
-    else
-        module.exports = hotPocketLib;
+    function setBlake3(blake3ref) {
+        if (blake3Resolver) {
+            blake3Resolver(blake3ref)
+            blake3Resolver = null;
+        }
+        else {
+            blake3 = blake3ref;
+        }
+    }
+
+    if (isBrowser) {
+        window.HotPocket = {
+            generateKeys,
+            createClient,
+            events,
+            protocols,
+            setBlake3
+        };
+    }
+    else {
+        module.exports = {
+            generateKeys,
+            createClient,
+            events,
+            protocols
+        };
+    }
 })();
\ No newline at end of file
diff --git a/examples/js_client/package-lock.json b/examples/js_client/package-lock.json
index 41c7b036..15539cf9 100644
--- a/examples/js_client/package-lock.json
+++ b/examples/js_client/package-lock.json
@@ -164,6 +164,11 @@
             "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
             "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="
         },
+        "blake3": {
+            "version": "2.1.4",
+            "resolved": "https://registry.npmjs.org/blake3/-/blake3-2.1.4.tgz",
+            "integrity": "sha512-70hmx0lPd6zmtNwxPT4/1P0pqaEUlTJ0noUBvCXPLfMpN0o8PPaK3q7ZlpRIyhrqcXxeMAJSowNm/L9oi/x1XA=="
+        },
         "bn.js": {
             "version": "5.1.3",
             "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.1.3.tgz",
diff --git a/examples/js_client/package.json b/examples/js_client/package.json
index 50d51b0e..88635a36 100644
--- a/examples/js_client/package.json
+++ b/examples/js_client/package.json
@@ -5,6 +5,7 @@
     },
     "dependencies": {
         "libsodium-wrappers": "0.7.6",
+        "blake3": "2.1.4",
         "ws": "7.1.2",
         "bson": "4.0.4"
     },
diff --git a/examples/js_client/text-client.js b/examples/js_client/text-client.js
index 04af9ad1..6ed4071d 100644
--- a/examples/js_client/text-client.js
+++ b/examples/js_client/text-client.js
@@ -11,8 +11,59 @@ async function main() {
     let server = 'wss://localhost:8080'
     if (process.argv.length == 3) server = 'wss://localhost:' + process.argv[2]
     if (process.argv.length == 4) server = 'wss://' + process.argv[2] + ':' + process.argv[3]
+
+    // Simple connection to single server without any validations.
     const hpc = await HotPocket.createClient([server], keys);
 
+    // Maintain multiple connections with contract id/version and trusted server key validation.
+    // const hpc = await HotPocket.createClient(
+    //     [
+    //         "wss://localhost:8081",
+    //         "wss://localhost:8082",
+    //         "wss://localhost:8083"
+    //     ],
+    //     keys,
+    //     {
+    //         contractId: "3c349abe-4d70-4f50-9fa6-018f1f2530ab",
+    //         contractVersion: "1.0",
+    //         trustedServerKeys: [
+    //             "ed5597c207bbd251997b7133d5d83a2c6ab9600810edf0bdb43f4004852b8c9e17",
+    //             "ed0b2ffd75b67c3979d3c362d8350ec190f053fa27d3dfcb2eced426efd1d3affc",
+    //             "edd2e1a817387d68adf8adb1d0b339e3f04868c3c81bf6a7472647f10657e31aa1"
+    //         ],
+    //         protocol: HotPocket.protocols.json,
+    //         requiredConnectionCount: 2,
+    //         connectionTimeoutMs: 5000
+    //     });
+
+    // We'll register for HotPocket events before connecting.
+
+    // This will get fired if HP server disconnects unexpectedly.
+    hpc.on(HotPocket.events.disconnect, () => {
+        console.log('Disconnected');
+        rl.close();
+    })
+
+    // This will get fired as servers connects/disconnects.
+    hpc.on(HotPocket.events.connectionChange, (server, action) => {
+        console.log(server + " " + action);
+    })
+
+    // This will get when the unl public key list changes.
+    hpc.on(HotPocket.events.unlChange, (unl) => {
+        console.log("New unl received: " + JSON.stringify(unl)); // unl is an array of hex public keys.
+    })
+
+    // This will get fired when contract sends an output.
+    hpc.on(HotPocket.events.contractOutput, (output) => {
+        console.log("Contract output>> " + output);
+    })
+
+    // This will get fired when contract sends a read response.
+    hpc.on(HotPocket.events.contractReadResponse, (response) => {
+        console.log("Contract read response>> " + response);
+    })
+
     // Establish HotPocket connection.
     if (!await hpc.connect()) {
         console.log('Connection failed.');
@@ -33,22 +84,6 @@ async function main() {
         hpc.close();
     });
 
-    // This will get fired if HP server disconnects unexpectedly.
-    hpc.on(HotPocket.events.disconnect, () => {
-        console.log('Disconnected');
-        rl.close();
-    })
-
-    // This will get fired when contract sends an output.
-    hpc.on(HotPocket.events.contractOutput, (output) => {
-        console.log("Contract output>> " + output);
-    })
-
-    // This will get fired when contract sends a read response.
-    hpc.on(HotPocket.events.contractReadResponse, (response) => {
-        console.log("Contract read response>> " + response);
-    })
-
     console.log("Ready to accept inputs.");
 
     const input_pump = () => {
@@ -56,12 +91,9 @@ async function main() {
 
             if (inp.length > 0) {
                 if (inp.startsWith("read "))
-                    hpc.sendContractReadRequest(inp.substr(5))
+                    hpc.sendContractReadRequest(inp.substr(5));
                 else {
-                    hpc.sendContractInput(inp).then(submissionStatus => {
-                        if (submissionStatus && submissionStatus != "ok")
-                            console.log("Input submission failed. reason: " + submissionStatus);
-                    });
+                    hpc.sendContractInput(inp);
                 }
             }
 
diff --git a/src/consensus.cpp b/src/consensus.cpp
index 32ec55e1..3615b957 100644
--- a/src/consensus.cpp
+++ b/src/consensus.cpp
@@ -268,9 +268,8 @@ namespace consensus
             const bool keep_candidate = (time_diff < (conf::cfg.roundtime * 4)) && (stage_diff == -3 || stage_diff <= 1);
             LOG_DEBUG << (keep_candidate ? "Prop--->" : "Erased")
                       << " [s" << std::to_string(cp.stage)
-                      << "] u/i/o:" << cp.users.size()
-                      << "/" << cp.hash_inputs.size()
-                      << "/" << cp.hash_outputs.size()
+                      << "] u/i:" << cp.users.size()
+                      << "/" << cp.input_hashes.size()
                       << " ts:" << std::to_string(cp.time)
                       << " lcl:" << cp.lcl.substr(0, 15)
                       << " state:" << cp.state
@@ -385,9 +384,8 @@ namespace consensus
         p2pmsg::create_msg_from_proposal(fbuf, p);
         p2p::broadcast_message(fbuf, true, false, !conf::cfg.is_consensus_public);
 
-        LOG_DEBUG << "Proposed <s" << std::to_string(p.stage) << "> u/i/o:" << p.users.size()
-                  << "/" << p.hash_inputs.size()
-                  << "/" << p.hash_outputs.size()
+        LOG_DEBUG << "Proposed <s" << std::to_string(p.stage) << "> u/i:" << p.users.size()
+                  << "/" << p.input_hashes.size()
                   << " ts:" << std::to_string(p.time)
                   << " lcl:" << p.lcl.substr(0, 15)
                   << " state:" << p.state;
@@ -549,11 +547,11 @@ namespace consensus
 
         // Populate the proposal with hashes of user inputs.
         for (const auto &[hash, cand_input] : ctx.candidate_user_inputs)
-            p.hash_inputs.emplace(hash);
+            p.input_hashes.emplace(hash);
 
-        // Populate the proposal with hashes of user outputs.
-        for (const auto &[hash, cand_output] : ctx.candidate_user_outputs)
-            p.hash_outputs.emplace(hash);
+        // Populate the output hash and our signature. This is the merkle tree root hash of user outputs and state hash.
+        p.output_hash = ctx.user_outputs_hashtree.root_hash();
+        p.output_sig = ctx.user_outputs_our_sig;
 
         // Populate the proposal with unl changeset.
         p.unl_changeset = ctx.candidate_unl_changeset;
@@ -573,7 +571,7 @@ namespace consensus
         // our peers or we will halt depending on level of consensus on the sides of the fork.
         p.lcl = lcl;
 
-        // We always votr for our current unl hash.
+        // We always vote for our current unl hash.
         p.unl_hash = unl_hash;
 
         const uint64_t time_now = util::get_epoch_milliseconds();
@@ -594,14 +592,12 @@ namespace consensus
                 increment(votes.users, pubkey);
 
             // Vote for user inputs (hashes). Only vote for the inputs that are in our candidate_inputs set.
-            for (const std::string &hash : cp.hash_inputs)
+            for (const std::string &hash : cp.input_hashes)
                 if (ctx.candidate_user_inputs.count(hash) > 0)
                     increment(votes.inputs, hash);
 
-            // Vote for contract outputs (hashes). Only vote for the outputs that are in our candidate_outputs set.
-            for (const std::string &hash : cp.hash_outputs)
-                if (ctx.candidate_user_outputs.count(hash) > 0)
-                    increment(votes.outputs, hash);
+            // Vote for contract output hash.
+            increment(votes.output_hash, cp.output_hash);
 
             // Vote for unl additions. Only vote for the unl additions that are in our candidate_unl_changeset.
             for (const std::string &pubkey : cp.unl_changeset.additions)
@@ -629,12 +625,7 @@ namespace consensus
         // Add inputs which have votes over stage threshold to proposal.
         for (const auto &[hash, numvotes] : votes.inputs)
             if (numvotes >= required_votes || (ctx.stage == 1 && numvotes > 0))
-                p.hash_inputs.emplace(hash);
-
-        // Add outputs which have votes over stage threshold to proposal.
-        for (const auto &[hash, numvotes] : votes.outputs)
-            if (numvotes >= required_votes)
-                p.hash_outputs.emplace(hash);
+                p.input_hashes.emplace(hash);
 
         // For the unl changeset, reset required votes for majority votes.
         required_votes = ceil(MAJORITY_THRESHOLD * unl_count);
@@ -649,13 +640,41 @@ namespace consensus
             if (numvotes >= required_votes)
                 p.unl_changeset.removals.emplace(pubkey);
 
+        // Add the output hash which has most votes over stage threshold to proposal.
+        uint32_t highest_output_vote = 0;
+        for (const auto &[hash, numvotes] : votes.output_hash)
+        {
+            if (numvotes >= required_votes && numvotes > highest_output_vote)
+            {
+                highest_output_vote = numvotes;
+                p.output_hash = hash;
+            }
+        }
+
+        if (!p.output_hash.empty())
+        {
+            if (ctx.stage < 3)
+            {
+                // If the elected hash is our output hash, then place our output signature in the proposal.
+                // We only do this if we are at stage 1 or 2.
+                if (p.output_hash == ctx.user_outputs_hashtree.root_hash())
+                    p.output_sig = ctx.user_outputs_our_sig;
+            }
+            else
+            {
+                // If this is the stage 3 proposal, collect the UNL output signatures matching the elected output hash.
+                for (const auto &[pubkey, cp] : ctx.candidate_proposals)
+                {
+                    if (cp.output_hash == p.output_hash)
+                        ctx.user_outputs_unl_sig.emplace_back(cp.pubkey, cp.output_sig);
+                }
+            }
+        }
+
         // time is voted on a simple sorted (highest to lowest) and majority basis.
         uint32_t highest_time_vote = 0;
-        for (auto itr = votes.time.rbegin(); itr != votes.time.rend(); ++itr)
+        for (const auto &[time, numvotes] : votes.time)
         {
-            const uint64_t time = itr->first;
-            const uint32_t numvotes = itr->second;
-
             if (numvotes > highest_time_vote)
             {
                 highest_time_vote = numvotes;
@@ -668,11 +687,8 @@ namespace consensus
 
         // Round nonce is voted on a simple sorted (highest to lowest) and majority basis, since there will always be disagreement.
         uint32_t highest_nonce_vote = 0;
-        for (auto itr = votes.nonce.rbegin(); itr != votes.nonce.rend(); ++itr)
+        for (const auto [nonce, numvotes] : votes.nonce)
         {
-            const std::string &nonce = itr->first;
-            const uint32_t numvotes = itr->second;
-
             if (numvotes > highest_nonce_vote)
             {
                 highest_nonce_vote = numvotes;
@@ -808,7 +824,7 @@ namespace consensus
         // Add raw_inputs to the proposal if full history mode is on.
         if (conf::cfg.fullhistory)
         {
-            for (const auto &hash : cons_prop.hash_inputs)
+            for (const auto &hash : cons_prop.input_hashes)
             {
                 const auto itr = ctx.candidate_user_inputs.find(hash);
                 if (itr != ctx.candidate_user_inputs.end())
@@ -851,7 +867,8 @@ namespace consensus
         ctx.candidate_unl_changeset.clear();
 
         // Send any output from the previous consensus round to locally connected users.
-        dispatch_user_outputs(cons_prop, new_lcl_seq_no, new_lcl);
+        if (dispatch_user_outputs(cons_prop, new_lcl_seq_no, new_lcl) == -1)
+            return -1;
 
         // Execute the contract
         if (!ctx.is_shutting_down)
@@ -882,6 +899,17 @@ namespace consensus
 
             extract_user_outputs_from_contract_bufmap(args.userbufs);
 
+            // Generate user output hash merkle tree and signature with state hash included.
+            if (!ctx.generated_user_outputs.empty())
+            {
+                std::vector<std::string_view> hashes;
+                for (const auto &[hash, output] : ctx.generated_user_outputs)
+                    hashes.push_back(hash);
+                hashes.push_back(new_state.to_string_view());
+                ctx.user_outputs_hashtree.populate(hashes);
+                ctx.user_outputs_our_sig = crypto::sign(ctx.user_outputs_hashtree.root_hash(), conf::cfg.seckey);
+            }
+
             // Prepare the consensus candidate unl changeset that we have accumulated so far. (We receive them as control inputs)
             // The candidate unl changeset will be included in the stage 0 proposal.
             std::swap(ctx.candidate_unl_changeset, ctx.contract_ctx->args.unl_changeset);
@@ -899,45 +927,53 @@ namespace consensus
      * Dispatch any consensus-reached outputs to matching users if they are connected to us locally.
      * @param cons_prop The proposal that achieved consensus.
      */
-    void dispatch_user_outputs(const p2p::proposal &cons_prop, const uint64_t lcl_seq_no, std::string_view lcl)
+    int dispatch_user_outputs(const p2p::proposal &cons_prop, const uint64_t lcl_seq_no, std::string_view lcl)
     {
-        std::scoped_lock<std::mutex> lock(usr::ctx.users_mutex);
-
-        for (const std::string &hash : cons_prop.hash_outputs)
+        if (cons_prop.output_hash == ctx.user_outputs_hashtree.root_hash())
         {
-            const auto cu_itr = ctx.candidate_user_outputs.find(hash);
-            const bool hashfound = (cu_itr != ctx.candidate_user_outputs.end());
-            if (!hashfound)
-            {
-                LOG_ERROR << "Output required but wasn't in our candidate outputs map, this will potentially cause desync.";
-                // todo: consider fatal
-            }
-            else
-            {
-                // Send matching outputs to locally connected users.
-                candidate_user_output &cand_output = cu_itr->second;
+            std::scoped_lock<std::mutex> lock(usr::ctx.users_mutex);
 
+            // If final elected output hash matches our output hash, distribute the outputs
+            // to locally connected users.
+            for (auto &[hash, user_output] : ctx.generated_user_outputs)
+            {
                 // Find user to send by pubkey.
-                const auto user_itr = usr::ctx.users.find(cand_output.userpubkey);
+                const auto user_itr = usr::ctx.users.find(user_output.userpubkey);
                 if (user_itr != usr::ctx.users.end()) // match found
                 {
                     const usr::connected_user &user = user_itr->second;
                     msg::usrmsg::usrmsg_parser parser(user.protocol);
 
-                    // Sending all the outputs to the user.
-                    for (sc::contract_output &output : cand_output.outputs)
-                    {
-                        std::vector<uint8_t> msg;
-                        parser.create_contract_output_container(msg, output.message, lcl_seq_no, lcl);
-                        user.session.send(msg);
-                        output.message.clear();
-                    }
+                    // Send the outputs and signatures to the user.
+                    std::vector<uint8_t> msg;
+
+                    // Get the collapsed hash tree with this user's output hash remaining independently.
+                    util::merkle_hash_node collapsed_hash_root = ctx.user_outputs_hashtree.collapse(hash);
+
+                    std::vector<std::string_view> outputs;
+                    for (const sc::contract_output &output : user_output.outputs)
+                        outputs.emplace_back(output.message);
+
+                    parser.create_contract_output_container(msg, outputs, collapsed_hash_root, ctx.user_outputs_unl_sig, lcl_seq_no, lcl);
+
+                    user.session.send(msg);
                 }
 
-                // now we can safely delete this candidate output.
-                ctx.candidate_user_outputs.erase(cu_itr);
+                user_output.outputs.clear(); // We no longer need this user's outputs.
             }
         }
+        else
+        {
+            LOG_INFO << "Output required but didn't match our output hash.";
+        }
+
+        // Clear the output hash tree and signature because we no longer need it.
+        ctx.user_outputs_hashtree.clear();
+        ctx.user_outputs_our_sig.clear();
+        ctx.user_outputs_unl_sig.clear();
+        ctx.generated_user_outputs.clear();
+
+        return 0;
     }
 
     /**
@@ -954,7 +990,7 @@ namespace consensus
             bufmap.try_emplace(pubkey, sc::contract_iobufs());
         }
 
-        for (const std::string &hash : cons_prop.hash_inputs)
+        for (const std::string &hash : cons_prop.input_hashes)
         {
             // For each consensus input hash, we need to find the actual input content to feed the contract.
             const auto itr = ctx.candidate_user_inputs.find(hash);
@@ -981,7 +1017,7 @@ namespace consensus
     }
 
     /**
-     * Reads any outputs the contract has produced on the provided buf map and transfers them to candidate outputs
+     * Reads any outputs the contract has produced on the provided buf map and transfers them to generated outputs
      * for the next consensus round.
      * @param bufmap The contract bufmap containing the outputs produced by the contract.
      */
@@ -996,14 +1032,17 @@ namespace consensus
                 vect.push_back(pubkey);
                 // Only using message to generate hash for output messages. Length is not needed.
                 for (sc::contract_output &output : bufs.outputs)
+                {
                     vect.push_back(output.message);
+                }
 
                 const std::string hash = crypto::get_hash(vect);
-                ctx.candidate_user_outputs.try_emplace(
+                ctx.generated_user_outputs.try_emplace(
                     std::move(hash),
-                    candidate_user_output(pubkey, std::move(bufs.outputs)));
+                    generated_user_output(pubkey, std::move(bufs.outputs)));
             }
         }
+        bufmap.clear();
     }
 
     /**
diff --git a/src/consensus.hpp b/src/consensus.hpp
index 756e31f2..7ca5df15 100644
--- a/src/consensus.hpp
+++ b/src/consensus.hpp
@@ -4,6 +4,7 @@
 #include "pchheader.hpp"
 #include "util/util.hpp"
 #include "util/buffer_store.hpp"
+#include "util/merkle_hash_tree.hpp"
 #include "sc.hpp"
 #include "p2p/p2p.hpp"
 #include "usr/user_input.hpp"
@@ -28,14 +29,14 @@ namespace consensus
     };
 
     /**
-     * Represents a contract output that takes part in consensus.
+     * Represents a contract-generated user output that takes part in consensus.
      */
-    struct candidate_user_output
+    struct generated_user_output
     {
         const std::string userpubkey;
         std::list<sc::contract_output> outputs;
 
-        candidate_user_output(const std::string userpubkey, const std::list<sc::contract_output> outputs)
+        generated_user_output(const std::string userpubkey, const std::list<sc::contract_output> outputs)
             : userpubkey(std::move(userpubkey)), outputs(std::move(outputs))
         {
         }
@@ -57,12 +58,15 @@ namespace consensus
         // Map of candidate user inputs with input hash as map key. Inputs will stay here until they
         // achieve consensus or expire (due to maxledgerseqno). Input hash is globally unique among inputs
         // from all users. We will use this map to feed inputs into the contract once consensus is achieved.
-        std::unordered_map<std::string, candidate_user_input> candidate_user_inputs;
+        std::map<std::string, candidate_user_input> candidate_user_inputs;
 
-        // Map of outputs generated by the contract with output hash is the map key. Outputs will stay
+        // Map of outputs generated by the contract with output hash as the map key. Outputs will stay
         // here until the end of the current consensus round. Output hash is globally unique among outputs for
         // all users. We will use this map to distribute outputs back to connected users once consensus is achieved.
-        std::unordered_map<std::string, candidate_user_output> candidate_user_outputs;
+        std::map<std::string, generated_user_output> generated_user_outputs;
+        util::merkle_hash_tree user_outputs_hashtree;
+        std::string user_outputs_our_sig;
+        std::vector<std::pair<std::string, std::string>> user_outputs_unl_sig;
 
         // Collected unl changset to be subjected to the consensus. This will stay here until end of the current consensus round.
         p2p::contract_unl_changeset candidate_unl_changeset;
@@ -77,6 +81,10 @@ namespace consensus
         bool is_shutting_down = false;
 
         std::thread consensus_thread;
+
+        consensus_context() : user_outputs_hashtree(16)
+        {
+        }
     };
 
     struct vote_counter
@@ -86,7 +94,7 @@ namespace consensus
         std::map<std::string, uint32_t> lcl;
         std::map<std::string, uint32_t> users;
         std::map<std::string, uint32_t> inputs;
-        std::map<std::string, uint32_t> outputs;
+        std::map<std::string, uint32_t> output_hash;
         std::map<hpfs::h32, uint32_t> state;
         std::map<std::string, uint32_t> unl;
         std::map<std::string, uint32_t> unl_additions;
@@ -137,7 +145,7 @@ namespace consensus
 
     int update_ledger_and_execute_contract(const p2p::proposal &proposal, std::string &new_lcl, hpfs::h32 &new_state);
 
-    void dispatch_user_outputs(const p2p::proposal &cons_prop, const uint64_t lcl_seq_no, std::string_view lcl);
+    int dispatch_user_outputs(const p2p::proposal &cons_prop, const uint64_t lcl_seq_no, std::string_view lcl);
 
     int feed_user_inputs_to_contract_bufmap(sc::contract_bufmap_t &bufmap, const p2p::proposal &cons_prop);
 
diff --git a/src/msg/bson/usrmsg_bson.cpp b/src/msg/bson/usrmsg_bson.cpp
index 0d821e3e..52fdfb69 100644
--- a/src/msg/bson/usrmsg_bson.cpp
+++ b/src/msg/bson/usrmsg_bson.cpp
@@ -90,11 +90,15 @@ namespace msg::usrmsg::bson
      *              "type": "contract_output",
      *              "lcl": "<lcl id>"
      *              "lcl_seqno": <integer>,
-     *              "content": <contract output>
+     *              "outputs": [<binary output 1>, <binary output 2>, ...], // The output order is the hash order.
+     *              "hashes": [<binary merkle hash tree>], // Always includes user's output hash [output hash = hash(pubkey+all outputs for the user)]
+     *              "unl_sig": [["<pubkey>", "<sig>"], ...] // Binary UNL pubkeys and signatures of root hash.
      *            }
      * @param content The contract binary output content to be put in the message.
      */
-    void create_contract_output_container(std::vector<uint8_t> &msg, std::string_view content, const uint64_t lcl_seq_no, std::string_view lcl)
+    void create_contract_output_container(std::vector<uint8_t> &msg, const ::std::vector<std::string_view> &outputs,
+                                          const util::merkle_hash_node &hash_root, const std::vector<std::pair<std::string, std::string>> &unl_sig,
+                                          const uint64_t lcl_seq_no, std::string_view lcl)
     {
         jsoncons::bson::bson_bytes_encoder encoder(msg);
         encoder.begin_object();
@@ -104,8 +108,27 @@ namespace msg::usrmsg::bson
         encoder.string_value(lcl);
         encoder.key(msg::usrmsg::FLD_LCL_SEQ);
         encoder.int64_value(lcl_seq_no);
-        encoder.key(msg::usrmsg::FLD_CONTENT);
-        encoder.byte_string_value(content);
+
+        encoder.key(msg::usrmsg::FLD_OUTPUTS);
+        encoder.begin_array();
+        for (int i = 0; i < outputs.size(); i++)
+            encoder.byte_string_value(outputs[i]);
+        encoder.end_array();
+
+        encoder.key(msg::usrmsg::FLD_HASHES);
+        populate_output_hash_array(encoder, hash_root);
+
+        encoder.key(msg::usrmsg::FLD_UNL_SIG);
+        encoder.begin_array();
+        for (const auto &[pubkey, sig] : unl_sig)
+        {
+            encoder.begin_array();
+            encoder.byte_string_value(pubkey);
+            encoder.byte_string_value(sig);
+            encoder.end_array();
+        }
+        encoder.end_array();
+
         encoder.end_object();
         encoder.flush();
     }
@@ -255,4 +278,20 @@ namespace msg::usrmsg::bson
         return 0;
     }
 
+    void populate_output_hash_array(jsoncons::bson::bson_bytes_encoder &encoder, const util::merkle_hash_node &node)
+    {
+        if (node.children.empty())
+        {
+            encoder.byte_string_value(node.hash);
+            return;
+        }
+        else
+        {
+            encoder.begin_array();
+            for (const auto &child : node.children)
+                populate_output_hash_array(encoder, child);
+            encoder.end_array();
+        }
+    }
+
 } // namespace msg::usrmsg::bson
\ No newline at end of file
diff --git a/src/msg/bson/usrmsg_bson.hpp b/src/msg/bson/usrmsg_bson.hpp
index abdb4cf0..de0971be 100644
--- a/src/msg/bson/usrmsg_bson.hpp
+++ b/src/msg/bson/usrmsg_bson.hpp
@@ -2,6 +2,7 @@
 #define _HP_MSG_BSON_USRMSG_BSON_
 
 #include "../../pchheader.hpp"
+#include "../../util/merkle_hash_tree.hpp"
 
 namespace msg::usrmsg::bson
 {
@@ -13,7 +14,9 @@ namespace msg::usrmsg::bson
 
     void create_contract_read_response_container(std::vector<uint8_t> &msg, std::string_view content);
 
-    void create_contract_output_container(std::vector<uint8_t> &msg, std::string_view content, const uint64_t lcl_seq_no, std::string_view lcl);
+    void create_contract_output_container(std::vector<uint8_t> &msg, const ::std::vector<std::string_view> &outputs,
+                                          const util::merkle_hash_node &hash_root, const std::vector<std::pair<std::string, std::string>> &unl_sig,
+                                          const uint64_t lcl_seq_no, std::string_view lcl);
 
     int verify_user_handshake_response(std::string &extracted_pubkeyhex, std::string &extracted_protocol,
                                        std::string_view response, std::string_view original_challenge);
@@ -30,6 +33,8 @@ namespace msg::usrmsg::bson
     int extract_input_container(std::string &input, std::string &nonce,
                                 uint64_t &max_lcl_seqno, std::string_view contentbson);
 
+    void populate_output_hash_array(jsoncons::bson::bson_bytes_encoder &encoder, const util::merkle_hash_node &node);
+
 } // namespace msg::usrmsg::bson
 
 #endif
\ No newline at end of file
diff --git a/src/msg/fbuf/ledger_helpers.cpp b/src/msg/fbuf/ledger_helpers.cpp
index bf4597c5..a88acd4d 100644
--- a/src/msg/fbuf/ledger_helpers.cpp
+++ b/src/msg/fbuf/ledger_helpers.cpp
@@ -28,8 +28,8 @@ namespace msg::fbuf::ledger
                 hash_to_flatbuff_bytes(builder, p.state),
                 sv_to_flatbuff_bytes(builder, p.unl_hash),
                 stringlist_to_flatbuf_bytearrayvector(builder, p.users),
-                stringlist_to_flatbuf_bytearrayvector(builder, p.hash_inputs),
-                stringlist_to_flatbuf_bytearrayvector(builder, p.hash_outputs),
+                stringlist_to_flatbuf_bytearrayvector(builder, p.input_hashes),
+                sv_to_flatbuff_bytes(builder, p.output_hash),
                 unl_changeset);
 
         builder.Finish(ledger); // Finished building message content to get serialised content.
diff --git a/src/msg/fbuf/ledger_schema.fbs b/src/msg/fbuf/ledger_schema.fbs
index 66977ef6..9cc5ca79 100644
--- a/src/msg/fbuf/ledger_schema.fbs
+++ b/src/msg/fbuf/ledger_schema.fbs
@@ -11,7 +11,7 @@ table LedgerBlock {
     unl:[ubyte];
     users: [ByteArray];
     inputs: [ByteArray]; 
-    outputs: [ByteArray];
+    output: [ubyte];
     unl_changeset: Unl_Changeset;
 }
 
diff --git a/src/msg/fbuf/ledger_schema_generated.h b/src/msg/fbuf/ledger_schema_generated.h
index 0753d716..feb79b68 100644
--- a/src/msg/fbuf/ledger_schema_generated.h
+++ b/src/msg/fbuf/ledger_schema_generated.h
@@ -29,7 +29,7 @@ struct LedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_UNL = 14,
     VT_USERS = 16,
     VT_INPUTS = 18,
-    VT_OUTPUTS = 20,
+    VT_OUTPUT = 20,
     VT_UNL_CHANGESET = 22
   };
   const flatbuffers::String *version() const {
@@ -80,11 +80,11 @@ struct LedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_inputs() {
     return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_INPUTS);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *outputs() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_OUTPUTS);
+  const flatbuffers::Vector<uint8_t> *output() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_OUTPUT);
   }
-  flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_outputs() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_OUTPUTS);
+  flatbuffers::Vector<uint8_t> *mutable_output() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_OUTPUT);
   }
   const msg::fbuf::ledger::Unl_Changeset *unl_changeset() const {
     return GetPointer<const msg::fbuf::ledger::Unl_Changeset *>(VT_UNL_CHANGESET);
@@ -110,9 +110,8 @@ struct LedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyOffset(verifier, VT_INPUTS) &&
            verifier.VerifyVector(inputs()) &&
            verifier.VerifyVectorOfTables(inputs()) &&
-           VerifyOffset(verifier, VT_OUTPUTS) &&
-           verifier.VerifyVector(outputs()) &&
-           verifier.VerifyVectorOfTables(outputs()) &&
+           VerifyOffset(verifier, VT_OUTPUT) &&
+           verifier.VerifyVector(output()) &&
            VerifyOffset(verifier, VT_UNL_CHANGESET) &&
            verifier.VerifyTable(unl_changeset()) &&
            verifier.EndTable();
@@ -147,8 +146,8 @@ struct LedgerBlockBuilder {
   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> inputs) {
     fbb_.AddOffset(LedgerBlock::VT_INPUTS, inputs);
   }
-  void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> outputs) {
-    fbb_.AddOffset(LedgerBlock::VT_OUTPUTS, outputs);
+  void add_output(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output) {
+    fbb_.AddOffset(LedgerBlock::VT_OUTPUT, output);
   }
   void add_unl_changeset(flatbuffers::Offset<msg::fbuf::ledger::Unl_Changeset> unl_changeset) {
     fbb_.AddOffset(LedgerBlock::VT_UNL_CHANGESET, unl_changeset);
@@ -157,6 +156,7 @@ struct LedgerBlockBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  LedgerBlockBuilder &operator=(const LedgerBlockBuilder &);
   flatbuffers::Offset<LedgerBlock> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LedgerBlock>(end);
@@ -174,13 +174,13 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlock(
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> unl = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> inputs = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> outputs = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output = 0,
     flatbuffers::Offset<msg::fbuf::ledger::Unl_Changeset> unl_changeset = 0) {
   LedgerBlockBuilder builder_(_fbb);
   builder_.add_time(time);
   builder_.add_seq_no(seq_no);
   builder_.add_unl_changeset(unl_changeset);
-  builder_.add_outputs(outputs);
+  builder_.add_output(output);
   builder_.add_inputs(inputs);
   builder_.add_users(users);
   builder_.add_unl(unl);
@@ -200,7 +200,7 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlockDirect(
     const std::vector<uint8_t> *unl = nullptr,
     const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *users = nullptr,
     const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *inputs = nullptr,
-    const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *outputs = nullptr,
+    const std::vector<uint8_t> *output = nullptr,
     flatbuffers::Offset<msg::fbuf::ledger::Unl_Changeset> unl_changeset = 0) {
   auto version__ = version ? _fbb.CreateString(version) : 0;
   auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
@@ -208,7 +208,7 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlockDirect(
   auto unl__ = unl ? _fbb.CreateVector<uint8_t>(*unl) : 0;
   auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*users) : 0;
   auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*inputs) : 0;
-  auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*outputs) : 0;
+  auto output__ = output ? _fbb.CreateVector<uint8_t>(*output) : 0;
   return msg::fbuf::ledger::CreateLedgerBlock(
       _fbb,
       version__,
@@ -219,7 +219,7 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlockDirect(
       unl__,
       users__,
       inputs__,
-      outputs__,
+      output__,
       unl_changeset);
 }
 
@@ -267,6 +267,7 @@ struct Unl_ChangesetBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Unl_ChangesetBuilder &operator=(const Unl_ChangesetBuilder &);
   flatbuffers::Offset<Unl_Changeset> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Unl_Changeset>(end);
diff --git a/src/msg/fbuf/p2pmsg_content.fbs b/src/msg/fbuf/p2pmsg_content.fbs
index e6efa0dd..fc615a17 100644
--- a/src/msg/fbuf/p2pmsg_content.fbs
+++ b/src/msg/fbuf/p2pmsg_content.fbs
@@ -61,8 +61,9 @@ table Proposal_Message { //Proposal type message schema
     time:uint64;
     nonce: [ubyte];
     users:[ByteArray];
-    hash_inputs:[ByteArray];
-    hash_outputs:[ByteArray];
+    input_hashes:[ByteArray];
+    output_hash:[ubyte];
+    output_sig:[ubyte];
     state: [ubyte];
     unl_hash: [ubyte]; // Hash of the current unl list.
     unl_changeset: Unl_Changeset;
diff --git a/src/msg/fbuf/p2pmsg_content_generated.h b/src/msg/fbuf/p2pmsg_content_generated.h
index fce65ac9..2f69195e 100644
--- a/src/msg/fbuf/p2pmsg_content_generated.h
+++ b/src/msg/fbuf/p2pmsg_content_generated.h
@@ -359,6 +359,7 @@ struct Peer_Challenge_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Peer_Challenge_MessageBuilder &operator=(const Peer_Challenge_MessageBuilder &);
   flatbuffers::Offset<Peer_Challenge_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Peer_Challenge_Message>(end);
@@ -430,6 +431,7 @@ struct Peer_Challenge_Response_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Peer_Challenge_Response_MessageBuilder &operator=(const Peer_Challenge_Response_MessageBuilder &);
   flatbuffers::Offset<Peer_Challenge_Response_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Peer_Challenge_Response_Message>(end);
@@ -512,6 +514,7 @@ struct UserInputBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  UserInputBuilder &operator=(const UserInputBuilder &);
   flatbuffers::Offset<UserInput> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<UserInput>(end);
@@ -588,6 +591,7 @@ struct UserInputGroupBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  UserInputGroupBuilder &operator=(const UserInputGroupBuilder &);
   flatbuffers::Offset<UserInputGroup> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<UserInputGroup>(end);
@@ -761,6 +765,7 @@ struct ContentBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  ContentBuilder &operator=(const ContentBuilder &);
   flatbuffers::Offset<Content> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Content>(end);
@@ -809,6 +814,7 @@ struct NonUnl_Proposal_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  NonUnl_Proposal_MessageBuilder &operator=(const NonUnl_Proposal_MessageBuilder &);
   flatbuffers::Offset<NonUnl_Proposal_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<NonUnl_Proposal_Message>(end);
@@ -877,6 +883,7 @@ struct Unl_ChangesetBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Unl_ChangesetBuilder &operator=(const Unl_ChangesetBuilder &);
   flatbuffers::Offset<Unl_Changeset> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Unl_Changeset>(end);
@@ -913,11 +920,12 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_TIME = 6,
     VT_NONCE = 8,
     VT_USERS = 10,
-    VT_HASH_INPUTS = 12,
-    VT_HASH_OUTPUTS = 14,
-    VT_STATE = 16,
-    VT_UNL_HASH = 18,
-    VT_UNL_CHANGESET = 20
+    VT_INPUT_HASHES = 12,
+    VT_OUTPUT_HASH = 14,
+    VT_OUTPUT_SIG = 16,
+    VT_STATE = 18,
+    VT_UNL_HASH = 20,
+    VT_UNL_CHANGESET = 22
   };
   uint8_t stage() const {
     return GetField<uint8_t>(VT_STAGE, 0);
@@ -943,17 +951,23 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_users() {
     return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_USERS);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_inputs() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_HASH_INPUTS);
+  const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *input_hashes() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_INPUT_HASHES);
   }
-  flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_hash_inputs() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_HASH_INPUTS);
+  flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_input_hashes() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_INPUT_HASHES);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_outputs() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_HASH_OUTPUTS);
+  const flatbuffers::Vector<uint8_t> *output_hash() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_OUTPUT_HASH);
   }
-  flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_hash_outputs() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_HASH_OUTPUTS);
+  flatbuffers::Vector<uint8_t> *mutable_output_hash() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_OUTPUT_HASH);
+  }
+  const flatbuffers::Vector<uint8_t> *output_sig() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_OUTPUT_SIG);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_output_sig() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_OUTPUT_SIG);
   }
   const flatbuffers::Vector<uint8_t> *state() const {
     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_STATE);
@@ -982,12 +996,13 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyOffset(verifier, VT_USERS) &&
            verifier.VerifyVector(users()) &&
            verifier.VerifyVectorOfTables(users()) &&
-           VerifyOffset(verifier, VT_HASH_INPUTS) &&
-           verifier.VerifyVector(hash_inputs()) &&
-           verifier.VerifyVectorOfTables(hash_inputs()) &&
-           VerifyOffset(verifier, VT_HASH_OUTPUTS) &&
-           verifier.VerifyVector(hash_outputs()) &&
-           verifier.VerifyVectorOfTables(hash_outputs()) &&
+           VerifyOffset(verifier, VT_INPUT_HASHES) &&
+           verifier.VerifyVector(input_hashes()) &&
+           verifier.VerifyVectorOfTables(input_hashes()) &&
+           VerifyOffset(verifier, VT_OUTPUT_HASH) &&
+           verifier.VerifyVector(output_hash()) &&
+           VerifyOffset(verifier, VT_OUTPUT_SIG) &&
+           verifier.VerifyVector(output_sig()) &&
            VerifyOffset(verifier, VT_STATE) &&
            verifier.VerifyVector(state()) &&
            VerifyOffset(verifier, VT_UNL_HASH) &&
@@ -1014,11 +1029,14 @@ struct Proposal_MessageBuilder {
   void add_users(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users) {
     fbb_.AddOffset(Proposal_Message::VT_USERS, users);
   }
-  void add_hash_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_inputs) {
-    fbb_.AddOffset(Proposal_Message::VT_HASH_INPUTS, hash_inputs);
+  void add_input_hashes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> input_hashes) {
+    fbb_.AddOffset(Proposal_Message::VT_INPUT_HASHES, input_hashes);
   }
-  void add_hash_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_outputs) {
-    fbb_.AddOffset(Proposal_Message::VT_HASH_OUTPUTS, hash_outputs);
+  void add_output_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output_hash) {
+    fbb_.AddOffset(Proposal_Message::VT_OUTPUT_HASH, output_hash);
+  }
+  void add_output_sig(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output_sig) {
+    fbb_.AddOffset(Proposal_Message::VT_OUTPUT_SIG, output_sig);
   }
   void add_state(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state) {
     fbb_.AddOffset(Proposal_Message::VT_STATE, state);
@@ -1033,6 +1051,7 @@ struct Proposal_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Proposal_MessageBuilder &operator=(const Proposal_MessageBuilder &);
   flatbuffers::Offset<Proposal_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Proposal_Message>(end);
@@ -1046,8 +1065,9 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_Message(
     uint64_t time = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> nonce = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_inputs = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_outputs = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> input_hashes = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output_hash = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output_sig = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> unl_hash = 0,
     flatbuffers::Offset<msg::fbuf::p2pmsg::Unl_Changeset> unl_changeset = 0) {
@@ -1056,8 +1076,9 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_Message(
   builder_.add_unl_changeset(unl_changeset);
   builder_.add_unl_hash(unl_hash);
   builder_.add_state(state);
-  builder_.add_hash_outputs(hash_outputs);
-  builder_.add_hash_inputs(hash_inputs);
+  builder_.add_output_sig(output_sig);
+  builder_.add_output_hash(output_hash);
+  builder_.add_input_hashes(input_hashes);
   builder_.add_users(users);
   builder_.add_nonce(nonce);
   builder_.add_stage(stage);
@@ -1070,15 +1091,17 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_MessageDirect(
     uint64_t time = 0,
     const std::vector<uint8_t> *nonce = nullptr,
     const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *users = nullptr,
-    const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_inputs = nullptr,
-    const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_outputs = nullptr,
+    const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *input_hashes = nullptr,
+    const std::vector<uint8_t> *output_hash = nullptr,
+    const std::vector<uint8_t> *output_sig = nullptr,
     const std::vector<uint8_t> *state = nullptr,
     const std::vector<uint8_t> *unl_hash = nullptr,
     flatbuffers::Offset<msg::fbuf::p2pmsg::Unl_Changeset> unl_changeset = 0) {
   auto nonce__ = nonce ? _fbb.CreateVector<uint8_t>(*nonce) : 0;
   auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*users) : 0;
-  auto hash_inputs__ = hash_inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*hash_inputs) : 0;
-  auto hash_outputs__ = hash_outputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*hash_outputs) : 0;
+  auto input_hashes__ = input_hashes ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*input_hashes) : 0;
+  auto output_hash__ = output_hash ? _fbb.CreateVector<uint8_t>(*output_hash) : 0;
+  auto output_sig__ = output_sig ? _fbb.CreateVector<uint8_t>(*output_sig) : 0;
   auto state__ = state ? _fbb.CreateVector<uint8_t>(*state) : 0;
   auto unl_hash__ = unl_hash ? _fbb.CreateVector<uint8_t>(*unl_hash) : 0;
   return msg::fbuf::p2pmsg::CreateProposal_Message(
@@ -1087,8 +1110,9 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_MessageDirect(
       time,
       nonce__,
       users__,
-      hash_inputs__,
-      hash_outputs__,
+      input_hashes__,
+      output_hash__,
+      output_sig__,
       state__,
       unl_hash__,
       unl_changeset);
@@ -1124,6 +1148,7 @@ struct Npl_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Npl_MessageBuilder &operator=(const Npl_MessageBuilder &);
   flatbuffers::Offset<Npl_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Npl_Message>(end);
@@ -1178,6 +1203,7 @@ struct History_Request_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  History_Request_MessageBuilder &operator=(const History_Request_MessageBuilder &);
   flatbuffers::Offset<History_Request_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<History_Request_Message>(end);
@@ -1232,6 +1258,7 @@ struct Unl_Request_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Unl_Request_MessageBuilder &operator=(const Unl_Request_MessageBuilder &);
   flatbuffers::Offset<Unl_Request_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Unl_Request_Message>(end);
@@ -1299,6 +1326,7 @@ struct Unl_Response_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Unl_Response_MessageBuilder &operator=(const Unl_Response_MessageBuilder &);
   flatbuffers::Offset<Unl_Response_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Unl_Response_Message>(end);
@@ -1382,6 +1410,7 @@ struct History_Response_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  History_Response_MessageBuilder &operator=(const History_Response_MessageBuilder &);
   flatbuffers::Offset<History_Response_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<History_Response_Message>(end);
@@ -1456,6 +1485,7 @@ struct HistoryLedgerBlockPairBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  HistoryLedgerBlockPairBuilder &operator=(const HistoryLedgerBlockPairBuilder &);
   flatbuffers::Offset<HistoryLedgerBlockPair> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<HistoryLedgerBlockPair>(end);
@@ -1515,6 +1545,7 @@ struct HistoryLedgerBlockBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  HistoryLedgerBlockBuilder &operator=(const HistoryLedgerBlockBuilder &);
   flatbuffers::Offset<HistoryLedgerBlock> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<HistoryLedgerBlock>(end);
@@ -1608,6 +1639,7 @@ struct State_Request_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  State_Request_MessageBuilder &operator=(const State_Request_MessageBuilder &);
   flatbuffers::Offset<State_Request_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<State_Request_Message>(end);
@@ -1729,6 +1761,7 @@ struct State_Response_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  State_Response_MessageBuilder &operator=(const State_Response_MessageBuilder &);
   flatbuffers::Offset<State_Response_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<State_Response_Message>(end);
@@ -1797,6 +1830,7 @@ struct Fs_Entry_ResponseBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Fs_Entry_ResponseBuilder &operator=(const Fs_Entry_ResponseBuilder &);
   flatbuffers::Offset<Fs_Entry_Response> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Fs_Entry_Response>(end);
@@ -1862,6 +1896,7 @@ struct File_HashMap_ResponseBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  File_HashMap_ResponseBuilder &operator=(const File_HashMap_ResponseBuilder &);
   flatbuffers::Offset<File_HashMap_Response> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<File_HashMap_Response>(end);
@@ -1931,6 +1966,7 @@ struct Block_ResponseBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Block_ResponseBuilder &operator=(const Block_ResponseBuilder &);
   flatbuffers::Offset<Block_Response> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Block_Response>(end);
@@ -2012,6 +2048,7 @@ struct State_FS_Hash_EntryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  State_FS_Hash_EntryBuilder &operator=(const State_FS_Hash_EntryBuilder &);
   flatbuffers::Offset<State_FS_Hash_Entry> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<State_FS_Hash_Entry>(end);
@@ -2074,6 +2111,7 @@ struct Peer_Requirement_Announcement_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Peer_Requirement_Announcement_MessageBuilder &operator=(const Peer_Requirement_Announcement_MessageBuilder &);
   flatbuffers::Offset<Peer_Requirement_Announcement_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Peer_Requirement_Announcement_Message>(end);
@@ -2129,6 +2167,7 @@ struct Available_Capacity_Announcement_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Available_Capacity_Announcement_MessageBuilder &operator=(const Available_Capacity_Announcement_MessageBuilder &);
   flatbuffers::Offset<Available_Capacity_Announcement_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Available_Capacity_Announcement_Message>(end);
@@ -2162,6 +2201,7 @@ struct Peer_List_Request_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Peer_List_Request_MessageBuilder &operator=(const Peer_List_Request_MessageBuilder &);
   flatbuffers::Offset<Peer_List_Request_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Peer_List_Request_Message>(end);
@@ -2206,6 +2246,7 @@ struct Peer_List_Response_MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Peer_List_Response_MessageBuilder &operator=(const Peer_List_Response_MessageBuilder &);
   flatbuffers::Offset<Peer_List_Response_Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Peer_List_Response_Message>(end);
@@ -2293,6 +2334,7 @@ struct Peer_PropertiesBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Peer_PropertiesBuilder &operator=(const Peer_PropertiesBuilder &);
   flatbuffers::Offset<Peer_Properties> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Peer_Properties>(end);
diff --git a/src/msg/fbuf/p2pmsg_helpers.cpp b/src/msg/fbuf/p2pmsg_helpers.cpp
index a97f2eef..d34d5c4b 100644
--- a/src/msg/fbuf/p2pmsg_helpers.cpp
+++ b/src/msg/fbuf/p2pmsg_helpers.cpp
@@ -241,11 +241,14 @@ namespace msg::fbuf::p2pmsg
         if (msg.users())
             p.users = flatbuf_bytearrayvector_to_stringlist(msg.users());
 
-        if (msg.hash_inputs())
-            p.hash_inputs = flatbuf_bytearrayvector_to_stringlist(msg.hash_inputs());
+        if (msg.input_hashes())
+            p.input_hashes = flatbuf_bytearrayvector_to_stringlist(msg.input_hashes());
 
-        if (msg.hash_outputs())
-            p.hash_outputs = flatbuf_bytearrayvector_to_stringlist(msg.hash_outputs());
+        if (msg.output_hash())
+            p.output_hash = flatbuff_bytes_to_sv(msg.output_hash());
+
+        if (msg.output_sig())
+            p.output_sig = flatbuff_bytes_to_sv(msg.output_sig());
 
         return p;
     }
@@ -377,8 +380,7 @@ namespace msg::fbuf::p2pmsg
         const flatbuffers::Offset<Unl_Changeset> unl_changeset = CreateUnl_Changeset(
             builder,
             stringlist_to_flatbuf_bytearrayvector(builder, p.unl_changeset.additions),
-            stringlist_to_flatbuf_bytearrayvector(builder, p.unl_changeset.removals)
-        );
+            stringlist_to_flatbuf_bytearrayvector(builder, p.unl_changeset.removals));
 
         const flatbuffers::Offset<Proposal_Message> proposal =
             CreateProposal_Message(
@@ -387,8 +389,9 @@ namespace msg::fbuf::p2pmsg
                 p.time,
                 sv_to_flatbuff_bytes(builder, p.nonce),
                 stringlist_to_flatbuf_bytearrayvector(builder, p.users),
-                stringlist_to_flatbuf_bytearrayvector(builder, p.hash_inputs),
-                stringlist_to_flatbuf_bytearrayvector(builder, p.hash_outputs),
+                stringlist_to_flatbuf_bytearrayvector(builder, p.input_hashes),
+                sv_to_flatbuff_bytes(builder, p.output_hash),
+                sv_to_flatbuff_bytes(builder, p.output_sig),
                 hash_to_flatbuff_bytes(builder, p.state),
                 sv_to_flatbuff_bytes(builder, p.unl_hash),
                 unl_changeset);
diff --git a/src/msg/json/usrmsg_json.cpp b/src/msg/json/usrmsg_json.cpp
index 1e895f48..c2a6bc6d 100644
--- a/src/msg/json/usrmsg_json.cpp
+++ b/src/msg/json/usrmsg_json.cpp
@@ -1,5 +1,7 @@
 #include "../../pchheader.hpp"
 #include "../../util/util.hpp"
+#include "../../util/merkle_hash_tree.hpp"
+#include "../../unl.hpp"
 #include "../../crypto.hpp"
 #include "../../hplog.hpp"
 #include "../../conf.hpp"
@@ -83,7 +85,8 @@ namespace msg::usrmsg::json
      *            {
      *              "type": "server_challenge_response",
      *              "sig": "<hex encoded signature of the [challenge + contract_id]>",
-     *              "pubkey": "<our public key in hex>"
+     *              "pubkey": "<our public key in hex>",
+     *              "unl": [<hex unl pubkey list>]
      *            }
      * @param original_challenge Original challenge issued by the user.
      */
@@ -94,7 +97,7 @@ namespace msg::usrmsg::json
         const std::string sig_hex = crypto::sign_hex(content, conf::cfg.seckeyhex);
 
         // Since we know the rough size of the challenge message we reserve adequate amount for the holder.
-        msg.reserve(256);
+        msg.reserve(1024);
         msg += "{\"";
         msg += msg::usrmsg::FLD_TYPE;
         msg += SEP_COLON;
@@ -107,7 +110,19 @@ namespace msg::usrmsg::json
         msg += msg::usrmsg::FLD_PUBKEY;
         msg += SEP_COLON;
         msg += conf::cfg.pubkeyhex;
-        msg += "\"}";
+        msg += SEP_COMMA;
+        msg += msg::usrmsg::FLD_UNL;
+        msg += "\":[";
+        const std::set<std::string> unl_list = unl::get();
+        for (auto itr = unl_list.begin(); itr != unl_list.end(); itr++)
+        {
+            msg += "\"";
+            msg += util::to_hex(*itr);
+            msg += "\"";
+            if (std::next(itr) != unl_list.end())
+                msg += ",";
+        }
+        msg += "]}";
     }
 
     /**
@@ -226,15 +241,17 @@ namespace msg::usrmsg::json
      *              "type": "contract_output",
      *              "lcl": "<lcl id>"
      *              "lcl_seqno": <integer>,
-     *              "content": "<contract output string>"
+     *              "outputs": ["<output string 1>", "<output string 2>", ...], // The output order is the hash order.
+     *              "hashes": [<hex merkle hash tree>], // Always includes user's output hash [output hash = hash(pubkey+all outputs for the user)]
+     *              "unl_sig": [["<pubkey hex>", "<sig hex>"], ...] // UNL pubkeys and signatures of root hash.
      *            }
      * @param content The contract binary output content to be put in the message.
      */
-    void create_contract_output_container(std::vector<uint8_t> &msg, std::string_view content, const uint64_t lcl_seq_no, std::string_view lcl)
+    void create_contract_output_container(std::vector<uint8_t> &msg, const ::std::vector<std::string_view> &outputs,
+                                          const util::merkle_hash_node &hash_root, const std::vector<std::pair<std::string, std::string>> &unl_sig,
+                                          const uint64_t lcl_seq_no, std::string_view lcl)
     {
-        const bool is_string = is_json_string(content);
-
-        msg.reserve(content.size() + 256);
+        msg.reserve(1024);
         msg += "{\"";
         msg += msg::usrmsg::FLD_TYPE;
         msg += SEP_COLON;
@@ -248,27 +265,56 @@ namespace msg::usrmsg::json
         msg += SEP_COLON_NOQUOTE;
         msg += std::to_string(lcl_seq_no);
         msg += SEP_COMMA_NOQUOTE;
-        msg += msg::usrmsg::FLD_CONTENT;
-        msg += SEP_COLON_NOQUOTE;
+        msg += msg::usrmsg::FLD_OUTPUTS;
+        msg += "\":[";
 
-        if (is_json_string(content))
+        for (int i = 0; i < outputs.size(); i++)
         {
-            // Process the final string using jsoncons.
-            jsoncons::json jstring = content;
-            jsoncons::json_options options;
-            options.escape_all_non_ascii(true);
+            std::string_view output = outputs[i];
 
-            std::string escaped_content;
-            jstring.dump(escaped_content);
+            if (is_json_string(output))
+            {
+                // Process the final string using jsoncons.
+                jsoncons::json jstring = output;
+                jsoncons::json_options options;
+                options.escape_all_non_ascii(true);
 
-            msg += escaped_content;
-        }
-        else
-        {
-            msg += content;
+                std::string escaped_content;
+                jstring.dump(escaped_content);
+
+                msg += escaped_content;
+            }
+            else
+            {
+                msg += output;
+            }
+
+            if (i < outputs.size() - 1)
+                msg += ",";
         }
 
-        msg += "}";
+        msg += "],\"";
+
+        msg += msg::usrmsg::FLD_HASHES;
+        msg += "\":";
+        populate_output_hash_array(msg, hash_root);
+        msg += ",\"";
+
+        msg += msg::usrmsg::FLD_UNL_SIG;
+        msg += "\":[";
+        for (int i = 0; i < unl_sig.size(); i++)
+        {
+            const auto &sig = unl_sig[i]; // Pubkey and Signature pair.
+            msg += "[\"";
+            msg += util::to_hex(sig.first);
+            msg += "\",\"";
+            msg += util::to_hex(sig.second);
+            msg += "\"]";
+
+            if (i < unl_sig.size() - 1)
+                msg += ",";
+        }
+        msg += "]}";
     }
 
     /**
@@ -569,4 +615,26 @@ namespace msg::usrmsg::json
         return false; // Is a number.
     }
 
+    void populate_output_hash_array(std::vector<uint8_t> &msg, const util::merkle_hash_node &node)
+    {
+        if (node.children.empty())
+        {
+            msg += "\"";
+            msg += util::to_hex(node.hash);
+            msg += "\"";
+            return;
+        }
+        else
+        {
+            msg += "[";
+            for (auto itr = node.children.begin(); itr != node.children.end(); itr++)
+            {
+                populate_output_hash_array(msg, *itr);
+                if (std::next(itr) != node.children.end())
+                    msg += ",";
+            }
+            msg += "]";
+        }
+    }
+
 } // namespace msg::usrmsg::json
\ No newline at end of file
diff --git a/src/msg/json/usrmsg_json.hpp b/src/msg/json/usrmsg_json.hpp
index 03357057..fbdcc145 100644
--- a/src/msg/json/usrmsg_json.hpp
+++ b/src/msg/json/usrmsg_json.hpp
@@ -2,6 +2,7 @@
 #define _HP_MSG_JSON_USRMSG_JSON_
 
 #include "../../pchheader.hpp"
+#include "../../util/merkle_hash_tree.hpp"
 
 namespace msg::usrmsg::json
 {
@@ -17,7 +18,9 @@ namespace msg::usrmsg::json
 
     void create_contract_read_response_container(std::vector<uint8_t> &msg, std::string_view content);
 
-    void create_contract_output_container(std::vector<uint8_t> &msg, std::string_view content, const uint64_t lcl_seq_no, std::string_view lcl);
+    void create_contract_output_container(std::vector<uint8_t> &msg, const ::std::vector<std::string_view> &outputs,
+                                          const util::merkle_hash_node &hash_root, const std::vector<std::pair<std::string, std::string>> &unl_sig,
+                                          const uint64_t lcl_seq_no, std::string_view lcl);
 
     int verify_user_challenge(std::string &extracted_pubkeyhex, std::string &extracted_protocol, std::string &extracted_server_challenge,
                               std::string_view response, std::string_view original_challenge);
@@ -36,6 +39,8 @@ namespace msg::usrmsg::json
 
     bool is_json_string(std::string_view content);
 
+    void populate_output_hash_array(std::vector<uint8_t> &msg, const util::merkle_hash_node &node);
+
 } // namespace msg::usrmsg::json
 
 #endif
\ No newline at end of file
diff --git a/src/msg/usrmsg_common.hpp b/src/msg/usrmsg_common.hpp
index 177aa07d..6fb4fe2c 100644
--- a/src/msg/usrmsg_common.hpp
+++ b/src/msg/usrmsg_common.hpp
@@ -19,11 +19,15 @@ namespace msg::usrmsg
     constexpr const char *FLD_SIG = "sig";
     constexpr const char *FLD_PUBKEY = "pubkey";
     constexpr const char *FLD_PROTOCOL = "protocol";
+    constexpr const char *FLD_UNL = "unl";
     constexpr const char *FLD_INPUT = "input";
     constexpr const char *FLD_INPUT_CONTAINER = "input_container";
     constexpr const char *FLD_INPUT_SIG = "input_sig";
     constexpr const char *FLD_MAX_LCL_SEQ = "max_lcl_seqno";
     constexpr const char *FLD_CONTENT = "content";
+    constexpr const char *FLD_OUTPUTS = "outputs";
+    constexpr const char *FLD_HASHES = "hashes";
+    constexpr const char *FLD_UNL_SIG = "unl_sig";
     constexpr const char *FLD_NONCE = "nonce";
     constexpr const char *FLD_LCL = "lcl";
     constexpr const char *FLD_LCL_SEQ = "lcl_seqno";
diff --git a/src/msg/usrmsg_parser.cpp b/src/msg/usrmsg_parser.cpp
index 65b0feff..af569e06 100644
--- a/src/msg/usrmsg_parser.cpp
+++ b/src/msg/usrmsg_parser.cpp
@@ -38,12 +38,14 @@ namespace msg::usrmsg
             busrmsg::create_contract_read_response_container(msg, content);
     }
 
-    void usrmsg_parser::create_contract_output_container(std::vector<uint8_t> &msg, std::string_view content, const uint64_t lcl_seq_no, std::string_view lcl) const
+    void usrmsg_parser::create_contract_output_container(std::vector<uint8_t> &msg, const ::std::vector<std::string_view> &outputs,
+                                                         const util::merkle_hash_node &hash_root, const std::vector<std::pair<std::string, std::string>> &unl_sig,
+                                                         const uint64_t lcl_seq_no, std::string_view lcl) const
     {
         if (protocol == util::PROTOCOL::JSON)
-            jusrmsg::create_contract_output_container(msg, content, lcl_seq_no, lcl);
+            jusrmsg::create_contract_output_container(msg, outputs, hash_root, unl_sig, lcl_seq_no, lcl);
         else
-            busrmsg::create_contract_output_container(msg, content, lcl_seq_no, lcl);
+            busrmsg::create_contract_output_container(msg, outputs, hash_root, unl_sig, lcl_seq_no, lcl);
     }
 
     int usrmsg_parser::parse(std::string_view message)
diff --git a/src/msg/usrmsg_parser.hpp b/src/msg/usrmsg_parser.hpp
index 12174aa1..f3003aeb 100644
--- a/src/msg/usrmsg_parser.hpp
+++ b/src/msg/usrmsg_parser.hpp
@@ -2,6 +2,7 @@
 #define _HP_MSG_USRMSG_PARSER_
 
 #include "../util/util.hpp"
+#include "../util/merkle_hash_tree.hpp"
 #include "../pchheader.hpp"
 
 namespace msg::usrmsg
@@ -25,7 +26,9 @@ namespace msg::usrmsg
 
         void create_contract_read_response_container(std::vector<uint8_t> &msg, std::string_view content) const;
 
-        void create_contract_output_container(std::vector<uint8_t> &msg, std::string_view content, const uint64_t lcl_seq_no, std::string_view lcl) const;
+        void create_contract_output_container(std::vector<uint8_t> &msg, const ::std::vector<std::string_view> &outputs,
+                                              const util::merkle_hash_node &hash_root, const std::vector<std::pair<std::string, std::string>> &unl_sig,
+                                              const uint64_t lcl_seq_no, std::string_view lcl) const;
 
         int parse(std::string_view message);
 
diff --git a/src/p2p/p2p.hpp b/src/p2p/p2p.hpp
index 70023c9d..482bda37 100644
--- a/src/p2p/p2p.hpp
+++ b/src/p2p/p2p.hpp
@@ -55,8 +55,9 @@ namespace p2p
         std::string unl_hash; // Hash of the current unl list.
         hpfs::h32 state;
         std::set<std::string> users;
-        std::set<std::string> hash_inputs;
-        std::set<std::string> hash_outputs;
+        std::set<std::string> input_hashes;
+        std::string output_hash;
+        std::string output_sig;
         contract_unl_changeset unl_changeset; // Additions and removals of the unl.
     };
 
diff --git a/src/util/merkle_hash_tree.cpp b/src/util/merkle_hash_tree.cpp
new file mode 100644
index 00000000..0f757209
--- /dev/null
+++ b/src/util/merkle_hash_tree.cpp
@@ -0,0 +1,157 @@
+#include "../pchheader.hpp"
+#include "../crypto.hpp"
+#include "util.hpp"
+#include "merkle_hash_tree.hpp"
+
+namespace util
+{
+    merkle_hash_tree::merkle_hash_tree(const size_t block_size) : block_size(block_size)
+    {
+    }
+
+    void merkle_hash_tree::create_groups(std::list<merkle_hash_node> &nodes)
+    {
+        if (nodes.size() == 1)
+        {
+            merkle_hash_node &first = nodes.front();
+            root.hash.swap(first.hash);
+            root.children.swap(first.children);
+        }
+        else if (nodes.size() > 1)
+        {
+            // Create parent hash nodes for blocks of nodes.
+            std::list<merkle_hash_node> parents;
+
+            const size_t blocks = (nodes.size() + block_size - 1) / block_size;
+            for (int i = 0; i < blocks; i++)
+            {
+                parents.push_back({});
+                merkle_hash_node &parent = parents.back();
+
+                // Move a portion of nodes under the parent.
+                auto last_child = nodes.begin();
+                std::advance(last_child, MIN(block_size, nodes.size()));
+                parent.children.splice(parent.children.end(), nodes, nodes.begin(), last_child);
+
+                // Calculate parent hash.
+                if (parent.children.size() > 1)
+                {
+                    std::vector<std::string_view> hashes;
+                    for (const util::merkle_hash_node &child : parent.children)
+                        hashes.push_back(child.hash);
+                    parent.hash = crypto::get_hash(hashes);
+                }
+                else
+                {
+                    // If parent has a single child, the child becomes the parent.
+                    parent.hash.swap(parent.children.begin()->hash);
+                    parent.children.swap(parent.children.begin()->children);
+                }
+            }
+
+            create_groups(parents);
+        }
+    }
+
+    void merkle_hash_tree::populate(const std::vector<std::string_view> &hashes)
+    {
+        // Create leaf tree nodes for all hashes.
+        std::list<merkle_hash_node> leafs;
+        for (std::string_view hash : hashes)
+            leafs.push_back(merkle_hash_node{std::string(hash)});
+
+        create_groups(leafs);
+    }
+
+    const std::string merkle_hash_tree::root_hash()
+    {
+        return root.hash;
+    }
+
+    const merkle_hash_node merkle_hash_tree::collapse(std::string_view retain_hash)
+    {
+        // Traverse through the tree and collapse (merge) all leaf nodes except for the retained hash.
+        merkle_hash_node new_root = clone(root);
+        retain_node(new_root, retain_hash);
+        return new_root;
+    }
+
+    bool merkle_hash_tree::empty()
+    {
+        return root.hash.empty();
+    }
+
+    void merkle_hash_tree::clear()
+    {
+        root.hash.clear();
+        root.children.clear();
+    }
+
+    merkle_hash_node merkle_hash_tree::clone(const merkle_hash_node &node)
+    {
+        merkle_hash_node new_node;
+        new_node.hash = node.hash;
+
+        for (const merkle_hash_node &child : node.children)
+            new_node.children.push_back(clone(child));
+
+        return new_node;
+    }
+
+    bool merkle_hash_tree::retain_node(merkle_hash_node &node, std::string_view retain_hash)
+    {
+        // Check whether this node is the retain hash or we have already found the retain hash.
+        if (retain_hash.empty() || node.hash == retain_hash)
+        {
+            node.children.clear(); // No need to dig deeper.
+            return true;
+        }
+        else
+        {
+            // Check whether any child contains the retain hash.
+            bool contains_retain_child = false;
+            for (merkle_hash_node &child : node.children)
+            {
+                // If the retain child already found, there's no need to check hashes further. So we pass empty hash.
+                std::string_view hash_to_check = contains_retain_child ? std::string_view() : retain_hash;
+                if (retain_node(child, hash_to_check))
+                    contains_retain_child = true;
+            }
+
+            // If a child contains the retain hash, then this node must be retained as well.
+            if (contains_retain_child)
+            {
+                return true;
+            }
+            else
+            {
+                node.children.clear();
+                return false;
+            }
+        }
+    }
+
+    /**
+     * Helper method to print the contents for debugging.
+     */
+    void merkle_hash_tree::print(const merkle_hash_node &node)
+    {
+        std::cout << util::to_hex(node.hash).substr(0, 8);
+
+        if (!node.children.empty())
+        {
+            std::cout << "(";
+            for (const merkle_hash_node &child : node.children)
+            {
+                print(child);
+                if (&child != &node.children.back())
+                    std::cout << " ";
+            }
+            std::cout << ")";
+        }
+
+        if (&node == &root)
+            std::cout << "\n";
+    }
+
+} // namespace util
\ No newline at end of file
diff --git a/src/util/merkle_hash_tree.hpp b/src/util/merkle_hash_tree.hpp
new file mode 100644
index 00000000..c85222c3
--- /dev/null
+++ b/src/util/merkle_hash_tree.hpp
@@ -0,0 +1,34 @@
+#ifndef _HP_UTIL_MERKLE_HASH_TREE_
+#define _HP_UTIL_MERKLE_HASH_TREE_
+
+#include "../pchheader.hpp"
+
+namespace util
+{
+    struct merkle_hash_node
+    {
+        std::string hash;
+        std::list<merkle_hash_node> children;
+    };
+
+    class merkle_hash_tree
+    {
+    private:
+        const size_t block_size;
+        merkle_hash_node root;
+        void create_groups(std::list<merkle_hash_node> &nodes);
+        merkle_hash_node clone(const merkle_hash_node &node);
+        bool retain_node(merkle_hash_node &node, std::string_view retain_hash);
+        void print(const merkle_hash_node &node);
+
+    public:
+        merkle_hash_tree(const size_t block_size);
+        void populate(const std::vector<std::string_view> &hashes);
+        const std::string root_hash();
+        const merkle_hash_node collapse(std::string_view retain_hash);
+        bool empty();
+        void clear();
+    };
+} // namespace util
+
+#endif
\ No newline at end of file
diff --git a/src/util/util.cpp b/src/util/util.cpp
index f62d3073..0e3b01f9 100644
--- a/src/util/util.cpp
+++ b/src/util/util.cpp
@@ -4,6 +4,21 @@
 
 namespace util
 {
+    const std::string to_hex(const std::string_view bin)
+    {
+        // Allocate the target string.
+        std::string encoded_string;
+        encoded_string.resize(bin.size() * 2);
+
+        // Get encoded string.
+        sodium_bin2hex(
+            encoded_string.data(),
+            encoded_string.length() + 1, // + 1 because sodium writes ending '\0' character as well.
+            reinterpret_cast<const unsigned char *>(bin.data()),
+            bin.size());
+        return encoded_string;
+    }
+
     /**
      * Encodes provided bytes to hex string.
      * 
@@ -221,7 +236,7 @@ namespace util
             if (!error_thrown && mkdir(path.data(), S_IRWXU | S_IRWXG | S_IROTH) == -1)
                 error_thrown = true;
 
-            if(error_thrown)
+            if (error_thrown)
                 return -1;
         }
 
diff --git a/src/util/util.hpp b/src/util/util.hpp
index 72af3dad..748cf42a 100644
--- a/src/util/util.hpp
+++ b/src/util/util.hpp
@@ -38,6 +38,8 @@ namespace util
         BSON = 1
     };
 
+    const std::string to_hex(const std::string_view bin);
+
     int bin2hex(std::string &encoded_string, const unsigned char *bin, const size_t bin_len);
 
     int hex2bin(unsigned char *decoded, const size_t decoded_len, std::string_view hex_str);
