postchain-client 2.0.3 → 2.0.4

package/README.md

@@ -451,6 +451,11 @@ Backend
 
 ## Contributing to the Project
 
+### Code conventions
+
+* Remember to `import { Buffer } from "buffer";` in all `.ts` and `.js` files in `src/` which refers to `Buffer` to
+ensure seamless functionality in web browsers.
+
 ### Run tests
 
 Unit tests:

package/built/cjs/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var merklehashts = require('merklehashts');
+var buffer = require('buffer');
 var bn_js = require('bn.js');
 var zod = require('zod');
 var crypto = require('crypto');
@@ -84,7 +85,7 @@ class MissingSignerException extends CustomError {
     }
 }
 
-const bufferSchema = zod.z.custom(val => Buffer.isBuffer(val), {
+const bufferSchema = zod.z.custom(val => buffer.Buffer.isBuffer(val), {
     message: "Expected Buffer",
 });
 const rawGtvSchema = zod.z.lazy(() => zod.z.union([
@@ -105,11 +106,11 @@ function isRawGtx(value) {
     return result.success;
 }
 
-function pgBytes(buffer) {
-    if (!Buffer.isBuffer(buffer)) {
-        throw new PgBytesInputException(buffer);
+function pgBytes(buffer$1) {
+    if (!buffer.Buffer.isBuffer(buffer$1)) {
+        throw new PgBytesInputException(buffer$1);
     }
-    return `\\x${buffer.toString("hex")}`;
+    return `\\x${buffer$1.toString("hex")}`;
 }
 /**
  * Converts hex string to Buffer
@@ -117,7 +118,7 @@ function pgBytes(buffer) {
  * @returns {Buffer}
  */
 function toBuffer(key) {
-    return Buffer.from(key, "hex");
+    return buffer.Buffer.from(key, "hex");
 }
 /**
  * Converts Buffer to hex string
@@ -142,7 +143,7 @@ class PgBytesInputException extends Error {
     }
 }
 function ensureBuffer(value) {
-    if (value instanceof Buffer) {
+    if (value instanceof buffer.Buffer) {
         return value;
     }
     else {
@@ -162,7 +163,7 @@ function checkGtvType(value) {
         if (value == null) {
             return true;
         }
-        if (Buffer.isBuffer(value)) {
+        if (buffer.Buffer.isBuffer(value)) {
             return true;
         }
         if (typeof value === "string" || typeof value === "bigint") {
@@ -228,7 +229,7 @@ function removeDuplicateSigners(signers) {
     });
     const result = [];
     signersAsString.forEach(item => {
-        result.push(Buffer.from(item, "hex"));
+        result.push(buffer.Buffer.from(item, "hex"));
     });
     return result;
 }
@@ -317,7 +318,7 @@ function createTypedArg(value) {
         if (value == null) {
             return { type: "null", value: null };
         }
-        if (Buffer.isBuffer(value)) {
+        if (buffer.Buffer.isBuffer(value)) {
             return { type: "byteArray", value: value };
         }
         if (typeof value === "boolean") {
@@ -423,7 +424,7 @@ class MissingPrivKeyArgumentException extends Error {
 
 function createPublicKey(privKey) {
     validatePrivKeyFormat(privKey);
-    return Buffer.from(secp256k1__namespace.publicKeyCreate(privKey, true).buffer);
+    return buffer.Buffer.from(secp256k1__namespace.publicKeyCreate(privKey, true).buffer);
 }
 function randomBytes(size) {
     return crypto__namespace.randomBytes(size);
@@ -433,7 +434,7 @@ function sha256(buffer) {
 }
 const hash256 = sha256;
 function hashConcat(items) {
-    return hash256(Buffer.concat(items));
+    return hash256(buffer.Buffer.concat(items));
 }
 /**
  * @param content the content that the signature signs. It will be digested before validating.
@@ -474,7 +475,7 @@ function sign$1(content, privKey) {
  * @return the signature
  */
 function signDigest(digestBuffer, privKey) {
-    return Buffer.from(secp256k1__namespace.ecdsaSign(digestBuffer, privKey).signature);
+    return buffer.Buffer.from(secp256k1__namespace.ecdsaSign(digestBuffer, privKey).signature);
 }
 /**
  * Creates a key pair (which usually represents one user)
@@ -491,7 +492,7 @@ function makeKeyPair(privKey) {
         do {
             privKey = randomBytes(32);
         } while (!secp256k1__namespace.privateKeyVerify(privKey));
-        pubKey = Buffer.from(secp256k1__namespace.publicKeyCreate(privKey).buffer);
+        pubKey = buffer.Buffer.from(secp256k1__namespace.publicKeyCreate(privKey).buffer);
     }
     return { pubKey, privKey };
 }
@@ -509,14 +510,14 @@ function makeTuid() {
  */
 function verifyKeyPair(privKey) {
     validatePrivKeyFormat(privKey);
-    const pubKey = Buffer.from(secp256k1__namespace.publicKeyCreate(privKey).buffer);
+    const pubKey = buffer.Buffer.from(secp256k1__namespace.publicKeyCreate(privKey).buffer);
     return { pubKey, privKey };
 }
 function validatePrivKeyFormat(privKey) {
     if (!privKey) {
         throw new MissingPrivKeyArgumentException();
     }
-    if (!Buffer.isBuffer(privKey) || privKey.length !== 32) {
+    if (!buffer.Buffer.isBuffer(privKey) || privKey.length !== 32) {
         throw new PrivKeyFormatException(privKey);
     }
 }
@@ -614,7 +615,7 @@ function gtxToRawGtx(gtx) {
 }
 function sign(gtx, privOrSigProv, merkleHashVersion, pubKey) {
     return __awaiter$9(this, void 0, void 0, function* () {
-        if (privOrSigProv instanceof Buffer) {
+        if (privOrSigProv instanceof buffer.Buffer) {
             const digestToSign = getDigestToSign(gtx, merkleHashVersion);
             const signature = signDigest(digestToSign, privOrSigProv);
             return addSignature(pubKey || makeKeyPair(privOrSigProv).pubKey, signature, gtx);
@@ -721,7 +722,7 @@ function rawGtvToGtx(gtv) {
         throw new Error("Second element must be an array");
     }
     gtvArray[1].forEach(element => {
-        if (!Buffer.isBuffer(element)) {
+        if (!buffer.Buffer.isBuffer(element)) {
             throw new Error("Element must be a buffer");
         }
     });
@@ -733,7 +734,7 @@ function rawGtvToGtxBody(gtv) {
         throw new Error("Gtv must be an array of size 3");
     }
     const array = gtv;
-    if (!Buffer.isBuffer(array[0])) {
+    if (!buffer.Buffer.isBuffer(array[0])) {
         throw new Error("First element must be a byte array");
     }
     if (!Array.isArray(array[1])) {
@@ -743,7 +744,7 @@ function rawGtvToGtxBody(gtv) {
         throw new Error("Third element must be an array");
     }
     array[2].forEach(element => {
-        if (!Buffer.isBuffer(element)) {
+        if (!buffer.Buffer.isBuffer(element)) {
             throw new Error("Element must be a buffer");
         }
     });
@@ -1095,7 +1096,7 @@ const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuratio
     };
 };
 
-const BufferSchema = zod.z.union([zod.z.instanceof(Uint8Array), zod.z.instanceof(Buffer)]);
+const BufferSchema = zod.z.union([zod.z.instanceof(Uint8Array), zod.z.instanceof(buffer.Buffer)]);
 
 const TxRidSchema = BufferSchema.refine(x => x.length === 32, "Rid must be 32 bytes long");
 const isTxRidValid = (rid, options) => {
@@ -1117,12 +1118,12 @@ const isTxRidValid = (rid, options) => {
 };
 
 const AnchoringTransactionSchema = zod.z.object({
-    txRid: zod.z.instanceof(Buffer).superRefine((rid, refCtx) => {
+    txRid: zod.z.instanceof(buffer.Buffer).superRefine((rid, refCtx) => {
         const txRidValidation = TxRidSchema.safeParse(rid);
         if (!txRidValidation.success)
             txRidValidation.error.issues.forEach(issue => refCtx.addIssue(issue));
     }),
-    txData: zod.z.instanceof(Buffer).refine(data => data.length > 0, {
+    txData: zod.z.instanceof(buffer.Buffer).refine(data => data.length > 0, {
         message: "txData must be a non-empty Buffer",
     }),
     txOpIndex: zod.z.number().int().nonnegative({ message: "txOpIndex must be a non-negative integer" }),
@@ -1169,7 +1170,7 @@ const RawGtvSchema = zod.z.union([
     zod.z.string(),
     zod.z.number(),
     zod.z.bigint(),
-    zod.z.instanceof(Buffer),
+    zod.z.instanceof(buffer.Buffer),
     zod.z.array(zod.z.unknown()),
     zod.z.record(zod.z.unknown()),
 ]);
@@ -1199,9 +1200,9 @@ const TransactionConfirmationProofSchema = zod.z.object({
     proof: zod.z.string(),
 });
 const ConfirmationProofSchema = zod.z.object({
-    hash: zod.z.instanceof(Buffer),
-    blockHeader: zod.z.instanceof(Buffer),
-    witness: zod.z.instanceof(Buffer),
+    hash: zod.z.instanceof(buffer.Buffer),
+    blockHeader: zod.z.instanceof(buffer.Buffer),
+    witness: zod.z.instanceof(buffer.Buffer),
     merkleProofTree: RawGtvSchema,
     txIndex: zod.z.number(),
 });
@@ -1216,17 +1217,17 @@ const TransactionInfoResponseSchema = zod.z.object({
     txData: zod.z.string(),
 });
 const TransactionInfoSchema = zod.z.object({
-    blockRid: zod.z.instanceof(Buffer),
+    blockRid: zod.z.instanceof(buffer.Buffer),
     blockHeight: zod.z.number(),
-    blockHeader: zod.z.instanceof(Buffer),
-    witness: zod.z.instanceof(Buffer),
+    blockHeader: zod.z.instanceof(buffer.Buffer),
+    witness: zod.z.instanceof(buffer.Buffer),
     timestamp: zod.z.number(),
-    txRid: zod.z.instanceof(Buffer),
-    txHash: zod.z.instanceof(Buffer),
-    txData: zod.z.instanceof(Buffer),
+    txRid: zod.z.instanceof(buffer.Buffer),
+    txHash: zod.z.instanceof(buffer.Buffer),
+    txData: zod.z.instanceof(buffer.Buffer),
 });
 zod.z.object({
-    txRid: zod.z.instanceof(Buffer),
+    txRid: zod.z.instanceof(buffer.Buffer),
     rejectReason: zod.z.string(),
     rejectTimestamp: zod.z.number(),
 });
@@ -1315,7 +1316,6 @@ const MerkleHashSchema = zod.z.object({
 const validateMerkleHash = (data) => {
     const result = MerkleHashSchema.safeParse(data);
     if (!result.success) {
-        console.warn("MERKLE_HASH_WARNING: version not found or endpoint unreachable");
         return { merkle_hash_version: MERKLE_HASH_VERSIONS.ONE };
     }
     return result.data;
@@ -1381,7 +1381,7 @@ function post(path, endpoint, requestBody) {
     return __awaiter$8(this, void 0, void 0, function* () {
         debug(`POST URL ${new URL(path, endpoint).href}`);
         debug(`POST body ${JSON.stringify(requestBody)}`);
-        if (Buffer.isBuffer(requestBody)) {
+        if (buffer.Buffer.isBuffer(requestBody)) {
             try {
                 const requestOptions = {
                     method: "post",
@@ -1423,8 +1423,8 @@ function constructBufferResponseBody(response) {
         const contentType = response.headers.get("content-type");
         if (contentType === "application/octet-stream") {
             const responseBuffer = yield response.arrayBuffer();
-            const buffer = Buffer.from(responseBuffer);
-            return decodeValue(buffer);
+            const buffer$1 = buffer.Buffer.from(responseBuffer);
+            return decodeValue(buffer$1);
         }
         if (contentType === "application/json") {
             return yield response.json();
@@ -1858,13 +1858,13 @@ function convertToRellOperation(operations) {
 }
 function getSerializedGTX(gtx) {
     const gtxBytes = encodeTransaction(gtx);
-    if (!Buffer.isBuffer(gtxBytes)) {
+    if (!buffer.Buffer.isBuffer(gtxBytes)) {
         throw new SerializedTransactionFormatException();
     }
     return gtxBytes;
 }
 function getGTXFromBufferOrTransactionOrOperation(transaction, blockchainRid) {
-    if (Buffer.isBuffer(transaction)) {
+    if (buffer.Buffer.isBuffer(transaction)) {
         return deserialize(transaction);
     }
     else if ("operations" in transaction) {
@@ -1966,8 +1966,8 @@ const isKeyPair = (keypair) => {
         keypair !== null &&
         "privKey" in keypair &&
         "pubKey" in keypair &&
-        keypair.privKey instanceof Buffer &&
-        keypair.pubKey instanceof Buffer);
+        keypair.privKey instanceof buffer.Buffer &&
+        keypair.pubKey instanceof buffer.Buffer);
 };
 function getNodeUrlsFromSettings(settings) {
     var _a;
@@ -2376,7 +2376,7 @@ function fetchAndVerifyTransaction(sourceClient, txToProveRID, proofHash, txToPr
         const rawTx = yield sourceClient.getTransaction(txToProveRID);
         const txGtv = decodeValue(rawTx);
         const fetchedTxHash = gtvHash2(txGtv, sourceClient.config.merkleHashVersion);
-        if (Buffer.compare(fetchedTxHash, proofHash)) {
+        if (buffer.Buffer.compare(fetchedTxHash, proofHash)) {
             // We received another hash for tx RID than what was included in proof
             // Possibly rouge or faulty node(s). Anyway, we need to give up.
             throw new MissingTransactionProof(proofHash, fetchedTxHash);
@@ -2386,7 +2386,7 @@ function fetchAndVerifyTransaction(sourceClient, txToProveRID, proofHash, txToPr
             throw new DifferentNumberOfSignersException((_c = (_b = fetchedTx.signatures) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0, txToProveSigners.length);
         }
         const txRID = getDigestToSign(fetchedTx, sourceClient.config.merkleHashVersion);
-        if (Buffer.compare(txRID, ensureBuffer(txToProveRID))) {
+        if (buffer.Buffer.compare(txRID, ensureBuffer(txToProveRID))) {
             throw new ProofRidException();
         }
         for (const signer of txToProveSigners) {
@@ -3610,7 +3610,7 @@ function dumpGtv(rawGtv) {
         if (typeof value === "bigint") {
             return `${value.toString()}L`;
         }
-        if (Buffer.isBuffer(value)) {
+        if (buffer.Buffer.isBuffer(value)) {
             return toString(value);
         }
         if (typeof value === "object" &&