postchain-client 1.8.1 → 1.9.0

package/README.md

@@ -40,7 +40,7 @@ Next, create a Chromia client instance and configure it with a specific set of b
 
 ```typescript
 const chromiaClient = await createClient({
-  nodeURLPool: "http://localhost:7740",
+  nodeUrlPool: "http://localhost:7740",
   blockchainRid,
 });
 ```
@@ -229,11 +229,11 @@ const tx = {
   operations: [
     {
       name: "my_operation_1",
-      arguments: ["arg1", "arg2"],
+      args: ["arg1", "arg2"],
     },
     {
       name: "my_operation_2",
-      arguments: ["arg1", "arg2"],
+      args: ["arg1", "arg2"],
     },
   ],
   signers: ["signer1", "signer2"],
@@ -245,7 +245,7 @@ You can modify the object to add operations or signers.
 ```typescript
 tx.operations.push({
   name: "my_operation_3",
-  arguments: ["arg1", "arg2"],
+  args: ["arg1", "arg2"],
 });
 
 tx.signers.push("signer3");
@@ -289,9 +289,7 @@ This example demonstrates that you can use external signing mechanisms. It could
 
 ```typescript
 function askUserBToSign(buffer) {
-  // The signed digest is a sha-256
-  var digest = sha256(buffer);
-  return secp256k1.sign(digest, signerPrivKeyB).signature;
+  return Buffer.from(secp256k1.ecdsaSign(buffer, signerPrivKeyB).signature);
 }
 ```
 

package/built/cjs/index.js

@@ -1733,12 +1733,12 @@ function getDigest(gtx) {
  * @param gtx the gtx to serialize
  */
 function getDigestToSign(gtx) {
-    return gtvHash(gtvTxBody(gtx));
+    return gtvHash(gtxToRawGtxBody(gtx));
 }
-function getDigestToSignFromBody(gtxBody) {
+function getDigestToSignFromRawGtxBody(gtxBody) {
     return gtvHash(gtxBody);
 }
-function gtvTxBody(gtx) {
+function gtxToRawGtxBody(gtx) {
     return [
         gtx.blockchainRid,
         gtx.operations.map((op) => [op.opName, op.args]),
@@ -1797,7 +1797,7 @@ function serialize(gtx) {
         // the signatures attribute, so let's add that.
         gtx.signatures = [];
     }
-    return encode([gtvTxBody(gtx), gtx.signatures]);
+    return encode([gtxToRawGtxBody(gtx), gtx.signatures]);
 }
 function deserialize(gtxBytes) {
     const deserializedTx = decode(gtxBytes);
@@ -1919,9 +1919,9 @@ var gtx = /*#__PURE__*/Object.freeze({
 	emptyGtx: emptyGtx,
 	getDigest: getDigest,
 	getDigestToSign: getDigestToSign,
-	getDigestToSignFromBody: getDigestToSignFromBody,
-	gtvTxBody: gtvTxBody,
+	getDigestToSignFromRawGtxBody: getDigestToSignFromRawGtxBody,
 	gtxToRawGtx: gtxToRawGtx,
+	gtxToRawGtxBody: gtxToRawGtxBody,
 	newSignatureProvider: newSignatureProvider,
 	rawGtvToGtx: rawGtvToGtx,
 	serialize: serialize,
@@ -2705,6 +2705,22 @@ function createClient(settings) {
                     });
                 });
             },
+            getBlocksInfo(limit = 25, beforeTime, beforeHeight, txs, callback) {
+                return __awaiter$6(this, void 0, void 0, function* () {
+                    let filteringQueryParam = "";
+                    if (beforeTime) {
+                        filteringQueryParam = `&before-time=${beforeTime.getTime()}`;
+                    }
+                    else if (beforeHeight) {
+                        filteringQueryParam = `&before-height=${beforeHeight}`;
+                    }
+                    const shouldIncludeFullTransaction = txs ? `&txs=${txs}` : "";
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, `blocks/${this.config.blockchainRid}?limit=${limit}${filteringQueryParam}${shouldIncludeFullTransaction}`, this.config);
+                    return new Promise((resolve, reject) => {
+                        handleGetResponse(error, statusCode, statusCode === 200 ? rspBody.map(formatBlockInfoResponse) : rspBody, callbackPromiseBuilder(reject, resolve, callback));
+                    });
+                });
+            },
             encodeTransaction(transaction) {
                 const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRid);
                 return serialize(gtx$1);
@@ -2941,6 +2957,30 @@ const formatTransactionInfoResponse = (transactionInfoResponse) => {
         txData: toBuffer(transactionInfoResponse.txData),
     };
 };
+const formatBlockInfoResponse = (blockInfoResponse) => {
+    return {
+        rid: toBuffer(blockInfoResponse.rid),
+        prevBlockRid: toBuffer(blockInfoResponse.prevBlockRID),
+        header: toBuffer(blockInfoResponse.header),
+        transactions: blockInfoResponse.transactions.map(formatTransaction),
+        height: blockInfoResponse.height,
+        witness: toBuffer(blockInfoResponse.witness),
+        witnesses: blockInfoResponse.witnesses.map((witness) => {
+            return toBuffer(witness);
+        }),
+        timestamp: blockInfoResponse.timestamp,
+    };
+};
+const formatTransaction = (transaction) => {
+    const formattedTransaction = {
+        rid: toBuffer(transaction.rid),
+        hash: toBuffer(transaction.hash),
+    };
+    if (transaction.data !== undefined) {
+        formattedTransaction.data = toBuffer(transaction.data);
+    }
+    return formattedTransaction;
+};
 const isKeyPair = (keypair) => {
     return (typeof keypair === "object" &&
         keypair !== null &&