postchain-client 1.0.2 → 1.1.0

package/README.md

@@ -5,6 +5,7 @@
 ```javascript
 let crypto = require("crypto");
 let secp256k1 = require("secp256k1");
+let { encryption } = require("postchain-client")
 
 // Create some dummy keys
 let signerPrivKeyA = Buffer.alloc(32, "a");
@@ -12,6 +13,12 @@ let signerPubKeyA = secp256k1.publicKeyCreate(signerPrivKeyA);
 let signerPrivKeyB = Buffer.alloc(32, "b");
 let signerPubKeyB = secp256k1.publicKeyCreate(signerPrivKeyB);
 
+// Create a simple signature provider.
+// This is the standard way of signing a message using the gtxClient,
+// and it can be used with the restClient too. Look further below for
+// more details on how to use it.
+let signatureProviderA = newSignatureProvider({privKey: signerPrivKeyA})
+
 // The lower-level client that can be used for any
 // postchain client messages. It only handles binary data.
 let restClient = require("postchain-client").restClient;
@@ -47,7 +54,7 @@ let gtx = gtxClient.createClient(rest, blockchainRID, ["fun1", "fun2"]);
 // Start a new request. A request instance is created.
 // The public keys are the keys that must sign the request
 // before sending it to postchain. Can be empty.
-let req = gtx.newTransaction([signerPubKeyA, signerPubKeyB]);
+let req = gtx.newTransaction([signatureProviderA.pubKey, signerPubKeyB]);
 
 // call fun1 with three arguments: a string, an array and a Buffer
 req.fun1("arg1", ["arg2", [1, 2]], Buffer.from("hello"));
@@ -57,14 +64,18 @@ req.fun1("arg1");
 req.fun2(1, 2);
 
 // Signing can be done either through the sign() function ...
-// The public key is optional. If omitted it will be calculated
-// from the private key. It is recommended to include the public
-// key for performance reasons.
-req.sign(signerPrivKeyA, signerPubKeyA);
+// The signatureProvider method sign() will be called, and
+// it's expected to return the signature of the digest it's given
+// as input (of type Buffer). It needs to return the output of
+// secp256k1.ecdsaSign(...params).signature
+await req.sign(signatureProviderA);
+// You can also use this, if you don't need a signature provider
+// The second parameter is optional, it will be generated if not given
+//await req.sign(signerPrivKeyA, signerPubKeyA);
 
 // ... or by the addSignature() function
 let bufferToSign = req.getBufferToSign();
-// Sign the buffer externally
+// Sign the buffer externally.
 let signatureFromB = askUserBToSign(bufferToSign);
 // and add the signature to the request
 req.addSignature(signerPubKeyB, signatureFromB);
@@ -81,25 +92,13 @@ req.send((error) => {
 // understand the query object and typically perform a search using
 // the database connection readOnlyConn. The backend query function
 // can return any serializable result object you chose
-let queryObject = { type: "findStuff", text: "arg1" };
-let resultHandler = (error, result) => {
-  if (error) {
-    console.error(error);
-    return;
-  }
-  if (result.hits == 0) {
-    // Poll every 2 seconds
-    setTimeout(gtx.query(queryObject, resultHandler), 2000);
-  }
-  console.log(JSON.stringify(result));
-};
-gtx.query(queryObject, resultHandler);
+gtx.query("findStuff", { text: "arg1" });
 
 // This will make a request with a single operation
 // and a single signature.
-req = gtx.newTransaction(blockchainRID, [signerPubKeyA]);
+req = gtx.newTransaction(blockchainRID, [signatureProviderA.pubkey]);
 req.fun1("arg1");
-req.sign(signerPrivKeyA);
+await req.sign(signatureProviderA);
 req.send((error) => {
   if (!error) {
     done();
@@ -111,12 +110,21 @@ function sha256(buffer) {
 }
 
 // This is to demonstrate that you can use external signing
-// mechanisms.
+// mechanisms. It could be a complex function, requiring you
+// to sign from your phone, another device, or something else again
 function askUserBToSign(buffer) {
   // The signed digest is a double sha-256
   var digest = sha256(sha256(buffer));
   return secp256k1.sign(digest, signerPrivKeyB).signature;
 }
+
+// The complex signature process can, however, even be implemented in
+// 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,
+  sign: askUserBToSign
+}
 ```
 
 A very simple backend for the above client might look like this:
@@ -199,30 +207,3 @@ The first four arguments to backend.fun1 are
 - `call_index`, 0 in this example. It's the index within the GTX of the current call
 - `signers`, all signers of this GTX. The signatures from these signers are already verified by
   the GTX framework when the backend function is called.
-
-## Release notes
-See more release notes [here](./docs/release-notes/).
-### 1.0.0
-- New logger accessible in index.ts.
-- Enable the client to connect to a blockchain through multiple nodes running the blockchain.
-- Load balancing by randomly distributing transactions and queries between nodes.
-- Retry policy added for HTTP request to the blockchain.
-- Enables you to discover the nodes running your blockchain by querying D1 with your dapp´s blockchain RID. Read more in the Chromia client providers [Readme](./src/chromia/README.md).
-
-
-Breaking changes:
-
-- Previously a rest client was initialized with one string containing the address of the node running your blockchain. Now an instance of the rest client is initiated with a list of strings representing the addresses of the nodes where your dapp is running. 
-- Previously a rest client query was called with two parameters; queryName and queryObject. Now this call only takes one parameter called queryObject, which is defined as: 
-```javascript
-{  
-  type: string; 
-  [arg: string]: RawGtv;
-}
-```
-where type is what previously was called query name.
-
-
-
-### 0.\*.*
-Early version of the postchain-client written in javascript.