Contract and client library improvements. (#184)

* Added tty check to contract libs.
* Javascript browser-native client.
* Removed hex encoding in user json outputs.
* Updated file contract for new contract library.

examples/nodejs_client/hp-node-client-lib.js

@@ -0,0 +1,306 @@
+const WebSocket = require('isomorphic-ws');
+const sodium = require('libsodium-wrappers');
+const EventEmitter = require('events');
+const bson = require('bson');
+
+// Whether we are in NodeJS or Browser.
+const isNodeJS = (typeof window === 'undefined');
+
+const protocols = {
+    json: "json",
+    bson: "bson"
+}
+Object.freeze(protocols);
+
+const events = {
+    disconnect: "disconnect",
+    contractOutput: "contractOutput",
+    contractReadResponse: "contractReadResponse"
+}
+Object.freeze(events);
+
+const HotPocketKeyGenerator = {
+    generate: async function (privateKeyHex = null) {
+        await sodium.ready;
+
+        if (!privateKeyHex) {
+            const keys = sodium.crypto_sign_keypair();
+            return {
+                privateKey: keys.privateKey,
+                publicKey: keys.publicKey
+            }
+        }
+        else {
+            const binPrivateKey = Buffer.from(privateKeyHex, "hex");
+            return {
+                privateKey: Uint8Array.from(binPrivateKey),
+                publicKey: Uint8Array.from(binPrivateKey.slice(32))
+            }
+        }
+    },
+}
+
+function HotPocketClient(contractId, server, keys, protocol = protocols.json) {
+
+    let ws = null;
+    const msgHelper = new MessageHelper(keys, protocol);
+    const emitter = new EventEmitter();
+
+    let handshakeResolver = null;
+    let statResponseResolvers = [];
+    let contractInputResolvers = {};
+
+    this.connect = function () {
+        return new Promise(resolve => {
+
+            handshakeResolver = resolve;
+
+            if (isNodeJS) {
+                ws = new WebSocket(server, {
+                    rejectUnauthorized: false
+                })
+            }
+            else {
+                ws = new WebSocket(server);
+            }
+
+            ws.onclose = () => {
+
+                // If there are any ongoing resolvers resolve them with error output.
+
+                handshakeResolver && handshakeResolver(false);
+                handshakeResolver = null;
+
+                statResponseResolvers.forEach(resolver => resolver(null));
+                statResponseResolvers = [];
+
+                Object.values(contractInputResolvers).forEach(resolver => resolver(null));
+                contractInputResolvers = {};
+
+                emitter.emit(events.disconnect);
+            };
+
+            ws.onmessage = async (rcvd) => {
+
+                if (isNodeJS) {
+                    msg = rcvd.data;
+                }
+                else {
+                    msg = (handshakeResolver || protocol == protocols.json) ?
+                        await rcvd.data.text() :
+                        Buffer.from(await rcvd.data.arrayBuffer());
+                }
+
+                try {
+                    // Use JSON if we are still in handshake phase.
+                    m = handshakeResolver ? JSON.parse(msg) : msgHelper.deserializeMessage(msg);
+                } catch (e) {
+                    console.log(e);
+                    console.log("Exception deserializing: ");
+                    console.log(msg)
+                    return;
+                }
+
+                if (m.type == 'handshake_challenge') {
+                    // Check whether contract id is matching if specified.
+                    if (contractId && m.contract_id != contractId) {
+                        console.error("Contract id mismatch.")
+                        ws.close();
+                    }
+
+                    // Sign the challenge and send back the response
+                    const response = msgHelper.createHandshakeResponse(m.challenge);
+                    ws.send(JSON.stringify(response));
+
+                    setTimeout(() => {
+                        // If we are still connected, report handshaking as successful.
+                        // (If websocket disconnects, handshakeResolver will be null)
+                        handshakeResolver && handshakeResolver(true);
+                        handshakeResolver = null;
+                    }, 100);
+                }
+                else if (m.type == 'contract_read_response') {
+                    emitter.emit(events.contractReadResponse, msgHelper.deserializeOutput(m.content));
+                }
+                else if (m.type == 'contract_input_status') {
+                    const sigKey = (typeof m.input_sig === "string") ? m.input_sig : m.input_sig.toString("hex");
+                    const resolver = contractInputResolvers[sigKey];
+                    if (resolver) {
+                        if (m.status == "accepted")
+                            resolver("ok");
+                        else
+                            resolver(m.reason);
+                        delete contractInputResolvers[sigKey];
+                    }
+                }
+                else if (m.type == 'contract_output') {
+                    emitter.emit(events.contractOutput, msgHelper.deserializeOutput(m.content));
+                }
+                else if (m.type == "stat_response") {
+                    statResponseResolvers.forEach(resolver => {
+                        resolver({
+                            lcl: m.lcl,
+                            lclSeqNo: m.lcl_seqno
+                        });
+                    })
+                    statResponseResolvers = [];
+                }
+                else {
+                    console.log("Received unrecognized message: type:" + m.type);
+                }
+            }
+        });
+    };
+
+    this.on = function (event, listener) {
+        emitter.on(event, listener);
+    }
+
+    this.close = function () {
+        return new Promise(resolve => {
+            try {
+                ws.onclose = resolve;
+                ws.on("close", resolve);
+                ws.close();
+            } catch (error) {
+                resolve();
+            }
+        })
+    }
+
+    this.getStatus = function () {
+        const p = new Promise(resolve => {
+            statResponseResolvers.push(resolve);
+        });
+
+        // If this is the only awaiting stat request, then send an actual stat request.
+        // Otherwise simply wait for the previously sent request.
+        if (statResponseResolvers.length == 1) {
+            const msg = msgHelper.createStatusRequest();
+            ws.send(msgHelper.serializeObject(msg));
+        }
+        return p;
+    }
+
+    this.sendContractInput = async function (input, nonce = null, maxLclOffset = null) {
+
+        if (!maxLclOffset)
+            maxLclOffset = 10;
+
+        if (!nonce)
+            nonce = (new Date()).getTime().toString();
+        else
+            nonce = nonce.toString();
+
+        // Acquire the current lcl and add the specified offset.
+        const stat = await this.getStatus();
+        if (!stat)
+            return new Promise(resolve => resolve("ledger_status_error"));
+        const maxLclSeqNo = stat.lclSeqNo + maxLclOffset;
+
+        const msg = msgHelper.createContractInput(input, nonce, maxLclSeqNo);
+        const sigKey = (typeof msg.sig === "string") ? msg.sig : msg.sig.toString("hex");
+        const p = new Promise(resolve => {
+            contractInputResolvers[sigKey] = resolve;
+        });
+
+        ws.send(msgHelper.serializeObject(msg));
+        return p;
+    }
+
+    this.sendContractReadRequest = function (request) {
+        const msg = msgHelper.createReadRequest(request);
+        ws.send(msgHelper.serializeObject(msg));
+    }
+}
+
+function MessageHelper(keys, protocol) {
+
+    this.binaryEncode = function (data) {
+        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        return protocol == protocols.json ? buffer.toString("hex") : buffer;
+    }
+
+    this.serializeObject = function (obj) {
+        return protocol == protocols.json ? JSON.stringify(obj) : bson.serialize(obj);
+    }
+
+    this.deserializeMessage = function (m) {
+        return protocol == protocols.json ? JSON.parse(m) : bson.deserialize(m);
+    }
+
+    this.serializeInput = function (input) {
+        return protocol == protocols.json ?
+            input.toString() :
+            Buffer.isBuffer(input) ? input : Buffer.from(input);
+    }
+
+    this.deserializeOutput = function (content) {
+        return (protocol == protocols.json) ? content : content.buffer;
+    }
+
+    this.createHandshakeResponse = function (challenge) {
+        // For handshake response encoding Hot Pocket always uses json.
+        // Handshake response will specify the protocol to use for subsequent messages.
+        const sigBytes = sodium.crypto_sign_detached(challenge, keys.privateKey);
+        return {
+            type: "handshake_response",
+            challenge: challenge,
+            sig: Buffer.from(sigBytes).toString("hex"),
+            pubkey: "ed" + Buffer.from(keys.publicKey).toString("hex"),
+            protocol: protocol
+        }
+    }
+
+    this.createContractInput = function (input, nonce, maxLclSeqNo) {
+
+        if (input.length == 0)
+            return null;
+
+        const inpContainer = {
+            input: this.serializeInput(input),
+            nonce: nonce,
+            max_lcl_seqno: maxLclSeqNo
+        }
+
+        const serlializedInpContainer = this.serializeObject(inpContainer);
+        const sigBytes = sodium.crypto_sign_detached(Buffer.from(serlializedInpContainer), keys.privateKey);
+
+        const signedInpContainer = {
+            type: "contract_input",
+            input_container: serlializedInpContainer,
+            sig: this.binaryEncode(sigBytes)
+        }
+
+        return signedInpContainer;
+    }
+
+    this.createReadRequest = function (request) {
+
+        if (request.length == 0)
+            return null;
+
+        return {
+            type: "contract_read_request",
+            content: this.serializeInput(request)
+        }
+    }
+
+    this.createStatusRequest = function () {
+        return { type: 'stat' };
+    }
+}
+
+const exportObj = {
+    KeyGenerator: HotPocketKeyGenerator,
+    Client: HotPocketClient,
+    events: events,
+    protocols: protocols
+};
+
+if (isNodeJS) {
+    module.exports = exportObj;
+}
+else {
+    window.HotPocket = exportObj;
+}