postchain-client 1.1.0 → 1.2.0

package/README.md

@@ -41,7 +41,7 @@ let blockchainRID = "7d565d92fd15bd1cdac2dc276cbcbc5581349d05a9e94ba919e1155ef4d
 // default pool size is 10. Applications that do hundreds of requests
 // per second may consider setting this a bit higher, for example 100.
 // It *may* speed things up a bit. You may also set an opitional
-// poolinginterval in milliseconds, default is set to 500, a fail over 
+// poolinginterval in milliseconds, default is set to 500, a fail over
 // config wich include attemps per endpoint and attempt interval, default is 3 and 500.
 let rest = restClient.createRestClient([`http://localhost:7741`], blockchainRID, 5, 1000);
 
@@ -74,9 +74,9 @@ await req.sign(signatureProviderA);
 //await req.sign(signerPrivKeyA, signerPubKeyA);
 
 // ... or by the addSignature() function
-let bufferToSign = req.getBufferToSign();
+let digestToSign = req.getDigestToSign();
 // Sign the buffer externally.
-let signatureFromB = askUserBToSign(bufferToSign);
+let signatureFromB = askUserBToSign(digestToSign);
 // and add the signature to the request
 req.addSignature(signerPubKeyB, signatureFromB);
 
@@ -119,7 +119,7 @@ function askUserBToSign(buffer) {
 }
 
 // The complex signature process can, however, even be implemented in
-// a signatureProvider. Once you have a callback like the one above, 
+// a signatureProvider. Once you have a callback like the one above,
 // it's a simple matter of making a signature provider:
 let signatureProviderB {
   pubKey: signerPubKeyB,

package/built/cjs/index.js

@@ -2,7 +2,7 @@
 
 var bn_js = require('bn.js');
 var crypto = require('crypto');
-var secp256k1$1 = require('secp256k1');
+var secp256k1 = require('secp256k1');
 
 function _interopNamespaceDefault(e) {
 	var n = Object.create(null);
@@ -22,7 +22,7 @@ function _interopNamespaceDefault(e) {
 }
 
 var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
-var secp256k1__namespace = /*#__PURE__*/_interopNamespaceDefault(secp256k1$1);
+var secp256k1__namespace = /*#__PURE__*/_interopNamespaceDefault(secp256k1);
 
 function getAugmentedNamespace(n) {
   if (n.__esModule) return n;
@@ -120,11 +120,18 @@ function toBuffer(key) {
 function toString(buffer) {
     return buffer.toString("hex");
 }
-function toQueryObjectGTV(object) {
-    const objectCopy = Object.assign({}, object);
-    const name = objectCopy.type;
-    delete objectCopy.type;
-    return [name, objectCopy];
+function toQueryObjectGTV(nameOrObject, queryArguments) {
+    let name;
+    if (typeof nameOrObject === "string") {
+        name = nameOrObject;
+        return [name, Object.assign({}, queryArguments)];
+    }
+    else {
+        const objectCopy = Object.assign({}, nameOrObject);
+        name = objectCopy.type;
+        delete objectCopy.type;
+        return [name, objectCopy];
+    }
 }
 class PgBytesInputException extends Error {
     constructor(buffer) {
@@ -1623,6 +1630,15 @@ var index = /*#__PURE__*/Object.freeze({
 const encode = encodeValueGtx;
 const decode = decodeValueGtx;
 
+var __awaiter$5 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 function emptyGtx(blockchainRID) {
     return { blockchainRID: blockchainRID, operations: [], signers: [] };
 }
@@ -1665,14 +1681,19 @@ function gtvTxBody(gtx) {
         gtx.signers,
     ];
 }
-/**
- * Signs the gtx with the provided privKey. This is a convenience function
- * for situations where you don't have to ask someone else to sign.
- */
-function sign(privKey, pubKey, gtx) {
-    const digestToSign = getDigestToSign(gtx);
-    const signature = signDigest(digestToSign, privKey);
-    addSignature(pubKey, signature, gtx);
+function sign(gtx, privOrSigProv, pubKey) {
+    return __awaiter$5(this, void 0, void 0, function* () {
+        if (privOrSigProv instanceof Buffer) {
+            const digestToSign = getDigestToSign(gtx);
+            const signature = signDigest(digestToSign, privOrSigProv);
+            addSignature(pubKey || makeKeyPair(privOrSigProv).pubKey, signature, gtx);
+        }
+        else {
+            const digestToSign = getDigestToSign(gtx);
+            const signature = yield privOrSigProv.sign(digestToSign);
+            addSignature(privOrSigProv.pubKey, signature, gtx);
+        }
+    });
 }
 function signRawTransaction(_keyPair, _rawTransaction) {
     throw Error("TODO");
@@ -1733,6 +1754,20 @@ function checkGTXSignatures(txHash, gtx) {
     }
     return true;
 }
+function newSignatureProvider(keyPair) {
+    let pub, priv;
+    if (keyPair) {
+        priv = ensureBuffer(keyPair.privKey);
+        pub = keyPair.pubKey ? ensureBuffer(keyPair.pubKey) : createPublicKey(priv);
+    }
+    else {
+        ({ privKey: priv, pubKey: pub } = makeKeyPair());
+    }
+    return {
+        pubKey: pub,
+        sign: (digest) => __awaiter$5(this, void 0, void 0, function* () { return signDigest(digest, priv); })
+    };
+}
 
 var gtx = /*#__PURE__*/Object.freeze({
 	__proto__: null,
@@ -1744,6 +1779,7 @@ var gtx = /*#__PURE__*/Object.freeze({
 	emptyGtx: emptyGtx,
 	getDigestToSign: getDigestToSign,
 	gtvTxBody: gtvTxBody,
+	newSignatureProvider: newSignatureProvider,
 	serialize: serialize,
 	sign: sign,
 	signRawTransaction: signRawTransaction
@@ -1811,21 +1847,32 @@ var logger = /*#__PURE__*/Object.freeze({
 	warning: warning
 });
 
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const secp256k1 = require("secp256k1");
+var __awaiter$4 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 function createClient(restApiClient, blockchainRID, functionNames) {
     functionNames.push("message");
     function transaction(gtx$1) {
         return {
             gtx: gtx$1,
-            sign: function (privKey, pubKey) {
-                let pub = pubKey;
-                if (!pub) {
-                    debug(`pubKey not provided, will instead be generated using secp256k1`);
-                    pub = Buffer.from(secp256k1.publicKeyCreate(privKey));
-                }
-                debug(`signing transaction with privKey: ${privKey}, pubKey: ${pub}`);
-                sign(privKey, pub, this.gtx);
+            sign: function (privOrSigProv, pubKey) {
+                return __awaiter$4(this, void 0, void 0, function* () {
+                    debug(`signing transaction with ${privOrSigProv instanceof Buffer
+                        ? "privkey: " + privOrSigProv.toString("hex")
+                        : "signature provider [pubkey: " + privOrSigProv.pubKey + "]"}`);
+                    if (privOrSigProv instanceof Buffer) {
+                        yield sign(this.gtx, privOrSigProv, pubKey);
+                    }
+                    else {
+                        yield sign(this.gtx, privOrSigProv);
+                    }
+                });
             },
             getTxRID: function () {
                 return this.getDigestToSign();
@@ -1877,8 +1924,13 @@ function createClient(restApiClient, blockchainRID, functionNames) {
             addFunctions(req);
             return req;
         },
-        query: function (queryObject, callback) {
-            return restApiClient.query(queryObject, callback);
+        query: function (nameOrObject, queryArguments) {
+            if (typeof nameOrObject === "string") {
+                return restApiClient.query(nameOrObject, queryArguments);
+            }
+            else {
+                return restApiClient.query(nameOrObject);
+            }
         },
     };
     return client;
@@ -1951,7 +2003,7 @@ class EmptyListOfUrlsException extends Error {
     }
 }
 
-var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -1960,50 +2012,8 @@ var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-function getBrid(urlBase, chainId) {
-    if (chainId >= 0) {
-        const url = `${urlBase}/brid/iid_${chainId}`;
-        return fetch(url).then((response) => {
-            if (response.ok)
-                return response.text();
-            throw new GetBridFromChainException(chainId, response.statusText);
-        });
-    }
-    else {
-        const url = `${urlBase}/_debug`;
-        return fetch(url).then((response) => {
-            if (response.ok)
-                return response
-                    .json()
-                    .then((json) => json.blockchain[json.blockchain.length - 1].brid);
-            throw new GetBridFromChainException(chainId, response.statusText);
-        });
-    }
-}
-function requestWithRetry(method, path, config, postObject) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        let statusCode, rspBody, error;
-        const noRetryStatusCodes = [200, 400, 409, 500];
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        for (const _endpoint of config.endpointPool) {
-            const endpoint = nextEndpoint(config.endpointPool);
-            for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
-                ({ error, statusCode, rspBody } = yield handleRequest(method, path, endpoint, postObject));
-                if (noRetryStatusCodes.includes(statusCode)) {
-                    return { error, statusCode, rspBody };
-                }
-                if (statusCode == 503) {
-                    break;
-                }
-                info(`${method} request failed on ${endpoint}. Attempt: ${attempt + 1} / ${config.attemptsPerEndpoint}`);
-                yield sleep(config.attemptInterval);
-            }
-        }
-        return { error, statusCode, rspBody };
-    });
-}
 function handleRequest(method, path, endpoint, postObject) {
-    return __awaiter$2(this, void 0, void 0, function* () {
+    return __awaiter$3(this, void 0, void 0, function* () {
         if (method == Method.GET) {
             return yield get(path, endpoint);
         }
@@ -2018,7 +2028,7 @@ function handleRequest(method, path, endpoint, postObject) {
  * @param endpoint
  */
 function get(path, endpoint) {
-    return __awaiter$2(this, void 0, void 0, function* () {
+    return __awaiter$3(this, void 0, void 0, function* () {
         debug("GET URL " + new URL(path, endpoint).href);
         try {
             const response = yield fetch(new URL(path, endpoint).href);
@@ -2041,7 +2051,7 @@ function get(path, endpoint) {
  * @param requestBody request body
  */
 function post(path, endpoint, requestBody) {
-    return __awaiter$2(this, void 0, void 0, function* () {
+    return __awaiter$3(this, void 0, void 0, function* () {
         debug("POST URL " + new URL(path, endpoint).href);
         debug("POST body " + JSON.stringify(requestBody));
         if (Buffer.isBuffer(requestBody)) {
@@ -2079,6 +2089,58 @@ function post(path, endpoint, requestBody) {
         }
     });
 }
+
+var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+function getBrid(urlBase, chainId) {
+    if (chainId >= 0) {
+        const url = `${urlBase}/brid/iid_${chainId}`;
+        return fetch(url).then((response) => {
+            if (response.ok)
+                return response.text();
+            throw new GetBridFromChainException(chainId, response.statusText);
+        });
+    }
+    else {
+        const url = `${urlBase}/_debug`;
+        return fetch(url).then((response) => {
+            if (response.ok)
+                return response
+                    .json()
+                    .then((json) => json.blockchain[json.blockchain.length - 1].brid);
+            throw new GetBridFromChainException(chainId, response.statusText);
+        });
+    }
+}
+function requestWithRetry(method, path, config, postObject) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        let statusCode, rspBody, error;
+        const noRetryStatusCodes = [200, 400, 409, 500];
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const _endpoint of config.endpointPool) {
+            const endpoint = nextEndpoint(config.endpointPool);
+            for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
+                ({ error, statusCode, rspBody } = yield handleRequest(method, path, endpoint, postObject));
+                if (noRetryStatusCodes.includes(statusCode)) {
+                    return { error, statusCode, rspBody };
+                }
+                if (statusCode == 503) {
+                    break;
+                }
+                info(`${method} request failed on ${endpoint}. Attempt: ${attempt + 1} / ${config.attemptsPerEndpoint}`);
+                yield sleep(config.attemptInterval);
+            }
+        }
+        return { error, statusCode, rspBody };
+    });
+}
 function nextEndpoint(endpointPool) {
     return endpointPool[Math.floor(Math.random() * endpointPool.length)];
 }
@@ -2087,7 +2149,6 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 var restclientutil = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	getBrid: getBrid,
-	handleRequest: handleRequest,
 	nextEndpoint: nextEndpoint,
 	requestWithRetry: requestWithRetry,
 	sleep: sleep
@@ -2112,15 +2173,6 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
             attemptsPerEndpoint: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptsPerEndpoint) || 3,
             attemptInterval: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptInterval) || 500,
         },
-        /**
-         * Retrieves the client message with the specified double-sha256 hash
-         * @param txRID the id of the transaction
-         * @param callback parameters (error, serializedMessage) if first
-         * parameter is not null, an error occurred.
-         * If first parameter is null, then the second parameter is a buffer
-         * with the serialized client message. If no such client message exists,
-         * the callback will be called with (null, null).
-         */
         getTransaction: function (txRID, callback) {
             return __awaiter$1(this, void 0, void 0, function* () {
                 if (!validTxRID(txRID)) {
@@ -2132,16 +2184,6 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
                 }
             });
         },
-        /**
-         * Sends a transaction to postchain for inclusion in a block.
-         * Use status() to monitor progress once this transaction is
-         * posted.
-         *
-         * @param serializedTransaction The transaction (a buffer) to send
-         * @param callback taking parameter (error, responseObject) if error is null
-         * then resonseObject is also null. If error is not null, then responseObject
-         * is an object with the string property 'error'
-         */
         postTransaction: function (serializedTransaction, callback) {
             return __awaiter$1(this, void 0, void 0, function* () {
                 if (!Buffer.isBuffer(serializedTransaction)) {
@@ -2154,76 +2196,6 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
                 handlePostResponse(error, statusCode, rspBody, callback);
             });
         },
-        /**
-         * Retrieves a confirmation proof for a client message with the specified double-sha256
-         * hash.
-         * @param txRID the id of the transaction
-         * @param callback parameters (error, responseObjectProof) if first
-         * parameter is not null, an error occurred.
-         * If first parameter is null, then the second parameter is an object
-         * like the following:
-         *
-         * {hash: messageHashBuffer,
-         *  blockHeader: blockHeaderBuffer,
-         *  signatures: [{pubKey: pubKeyBuffer, signature: sigBuffer}, ...],
-         *  merklePath: [{side: <0|1>, hash: <hash buffer level n-1>},
-         *               ...
-         *               {side: <0|1>, hash: <hash buffer level 1>}]}
-         *
-         * If no such client message exists, the callback will be called with (null, null).
-         *
-         * The proof object can be validated using
-         * postchain-common.util.validateMerklePath(proof.merklePath, proof.hash,
-         * proof.blockHeader.slice(32, 64))
-         *
-         * The signatures must be validated agains some know trusted source for valid signers
-         * at this specific block height.
-         */
-        getConfirmationProof: function (txRID, callback) {
-            return __awaiter$1(this, void 0, void 0, function* () {
-                if (!validTxRID(txRID)) {
-                    callback(new UnvalidTxRidException(txRID), null);
-                }
-                else {
-                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, "tx/" +
-                        blockchainRID +
-                        "/" +
-                        txRID.toString("hex") +
-                        "/confirmationProof", this.config);
-                    const confirmationProof = {
-                        hash: undefined,
-                        blockHeader: undefined,
-                        signatures: [],
-                        merklePath: [],
-                    };
-                    if (statusCode === 200 || statusCode === 503) {
-                        confirmationProof.hash = toBuffer(rspBody.hash);
-                        confirmationProof.blockHeader = toBuffer(rspBody.blockHeader);
-                        if (rspBody.signatures) {
-                            confirmationProof.signatures = rspBody.signatures.map((item) => ({
-                                pubKey: toBuffer(item.pubKey),
-                                signature: toBuffer(item.signature),
-                            }));
-                        }
-                        if (rspBody.merklePath) {
-                            confirmationProof.merklePath = rspBody.merklePath.map((item) => {
-                                return { side: item.side, hash: toBuffer(item.hash) };
-                            });
-                        }
-                    }
-                    handleGetResponse(error, statusCode, confirmationProof, callback);
-                }
-            });
-        },
-        /**
-         * Queries the status of a certain transaction.
-         * @param txRID the id of the transaction
-         * @param callback taking parameters (error, responseBody). If error is null
-         * then responseBody is an object on the form
-         * { status: '<confirmed|waiting|rejected|unknown>' }
-         * If error is not null, then responseBody
-         * is an object with the string property 'error'
-         */
         status: function (txRID, callback) {
             return __awaiter$1(this, void 0, void 0, function* () {
                 if (!validTxRID(txRID)) {
@@ -2235,11 +2207,7 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
                 }
             });
         },
-        /**
-         * Interfaces the query enpoint of the Rell backend. Returns either a resolved or rejected promise.
-         * @param queryObject an object that must contain a "type" and follows this pattern: { type: "nameOfQuery", arg1: argValue1, arg2: argvalue2 }
-         */
-        query: function (queryObject) {
+        query: function (nameOrQueryObject, queryArguments) {
             return __awaiter$1(this, void 0, void 0, function* () {
                 // eslint-disable-next-line no-async-promise-executor
                 return new Promise((resolve, reject) => __awaiter$1(this, void 0, void 0, function* () {
@@ -2251,15 +2219,11 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
                             resolve(result);
                         }
                     };
-                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.POST, `query_gtv/${blockchainRID}`, this.config, encodeValue(toQueryObjectGTV(queryObject)));
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.POST, `query_gtv/${blockchainRID}`, this.config, encodeValue(toQueryObjectGTV(nameOrQueryObject, queryArguments)));
                     handlePostResponse(error, statusCode, rspBody, callback);
                 }));
             });
         },
-        /**
-         * Polls for status while waiting for response; confirmed, rejected or unknown. Returns either a resolved or rejected promise.
-         * @param txRID the id of the transaction
-         */
         waitConfirmation(txRID) {
             return new Promise((resolve, reject) => {
                 this.status(txRID, (error$1, result) => {
@@ -2289,12 +2253,6 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
                 });
             });
         },
-        /**
-         * Posts a transaction and polls for status while waiting for status response; confirmed, rejected or unknown. Returns either a resolved or rejected promise.
-         * @param serializedTransaction The transaction (a buffer) to send
-         * @param txRID the id of the transaction
-         * @param validate true if the transaction needs to be validated
-         */
         postAndWaitConfirmation(serializedTransaction, txRID, validate) {
             if (validate === true) {
                 return Promise.reject("Automatic validation is not yet implemented");
@@ -2309,10 +2267,6 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
                 });
             });
         },
-        /**
-         * Returns a string array with the endpoints hosting the dApp the client
-         * is connected to
-         */
         getEndpointPool() {
             return this.config.endpointPool;
         },
@@ -2351,11 +2305,11 @@ function handleGetResponse(error$1, statusCode, responseObject, callback) {
         if (error$1) {
             callback(error$1, null);
         }
-        else if (statusCode === 404) {
+        else if (statusCode === 404) { //TODO remove 
             error("404 received");
             callback(null, null);
         }
-        else if (statusCode != 200) {
+        else if (statusCode !== 200) {
             callback(new UnexpectedStatusError(statusCode), responseObject);
         }
         else {