postchain-client 2.0.2 → 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") {
@@ -385,7 +386,19 @@ function sortDictPairByKey(dict) {
     return sortedDict;
 }
 
+const MERKLE_HASH_VERSIONS = {
+    ONE: 1,
+    TWO: 2,
+    UNSET: NaN,
+};
+
 const gtvHash2 = (obj, merkleHashVersion) => {
+    if (!Object.values(MERKLE_HASH_VERSIONS).includes(merkleHashVersion)) {
+        throw new Error("Merkle hash version is not valid");
+    }
+    if (isNaN(merkleHashVersion)) {
+        throw new Error("Merkle hash version is not set");
+    }
     return merklehashts.gtvHash(obj, merkleHashVersion);
 };
 const encode$1 = encodeValue;
@@ -411,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);
@@ -421,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.
@@ -462,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)
@@ -479,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 };
 }
@@ -497,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);
     }
 }
@@ -602,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);
@@ -610,7 +623,7 @@ function sign(gtx, privOrSigProv, merkleHashVersion, pubKey) {
         else {
             // Removes signatures and extract the rawgtxBody
             const rawGtxBody = gtxToRawGtxBody(gtx);
-            const signature = yield privOrSigProv.sign(rawGtxBody);
+            const signature = yield privOrSigProv.sign(rawGtxBody, merkleHashVersion);
             return addSignature(privOrSigProv.pubKey, signature, gtx);
         }
     });
@@ -680,7 +693,7 @@ function checkExistingGTXSignatures(txHash, gtx) {
     }
     return true;
 }
-function newSignatureProvider(merkleHashVersion, keyPair) {
+function newSignatureProvider(keyPair) {
     let pub, priv;
     if (keyPair) {
         priv = ensureBuffer(keyPair.privKey);
@@ -691,7 +704,7 @@ function newSignatureProvider(merkleHashVersion, keyPair) {
     }
     return {
         pubKey: pub,
-        sign: (gtx) => __awaiter$9(this, void 0, void 0, function* () {
+        sign: (gtx, merkleHashVersion) => __awaiter$9(this, void 0, void 0, function* () {
             const signature = getDigestToSignFromRawGtxBody(gtx, merkleHashVersion);
             return signDigest(signature, priv);
         }),
@@ -709,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");
         }
     });
@@ -721,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])) {
@@ -731,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");
         }
     });
@@ -988,6 +1001,7 @@ exports.TransactionEvent = void 0;
     TransactionEvent["DappConfirmed"] = "dappConfirmed";
     TransactionEvent["DappReceived"] = "dappReceived";
     TransactionEvent["Signed"] = "signed";
+    TransactionEvent["Rejected"] = "rejected";
 })(exports.TransactionEvent || (exports.TransactionEvent = {}));
 exports.AnchoringStatus = void 0;
 (function (AnchoringStatus) {
@@ -1082,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) => {
@@ -1104,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" }),
@@ -1156,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()),
 ]);
@@ -1186,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(),
 });
@@ -1203,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(),
 });
@@ -1296,18 +1310,12 @@ function encodeTransaction(gtx) {
     return serialize(gtx);
 }
 
-const MERKLE_HASH_VERSIONS = {
-    ONE: 1,
-    TWO: 2,
-};
-
 const MerkleHashSchema = zod.z.object({
     merkle_hash_version: zod.z.number().int().positive(),
 });
 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;
@@ -1373,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",
@@ -1415,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();
@@ -1583,7 +1591,8 @@ function retryRequest({ method, path, config, postObject, validateStatusCode, })
         let error = null;
         let transactionTimestamp = undefined;
         const { nodeManager } = config;
-        for (const endpoint of nodeManager.getAvailableNodes()) {
+        const availableNodes = nodeManager.getAvailableNodes();
+        for (const endpoint of availableNodes) {
             for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
                 const response = yield handleRequest(method, path, endpoint.url, postObject);
                 error = (_a = response === null || response === void 0 ? void 0 : response.error) !== null && _a !== void 0 ? _a : null;
@@ -1594,6 +1603,7 @@ function retryRequest({ method, path, config, postObject, validateStatusCode, })
                 const isServerError = statusCode ? hasServerError(statusCode) : false;
                 if (isStatusCodeValid && !error) {
                     // Find a way to have this handled more elegantly in the node manager.
+                    nodeManager.lastUsedNode = endpoint;
                     if (nodeManager.stickedNode !== endpoint) {
                         nodeManager.setStickyNode(endpoint);
                     }
@@ -1744,7 +1754,7 @@ function getClientConfigFromSettings(settings) {
                     nodeManager,
                     endpointPool,
                     chainId: settings.blockchainIid,
-                    merkleHashVersion: (_k = settings.merkleHashVersion) !== null && _k !== void 0 ? _k : 0,
+                    merkleHashVersion: (_k = settings.merkleHashVersion) !== null && _k !== void 0 ? _k : MERKLE_HASH_VERSIONS.UNSET,
                 });
             }
             throw new MissingBlockchainIdentifierError();
@@ -1759,17 +1769,18 @@ function getClientConfigFromSettings(settings) {
                 nodeManager,
                 endpointPool,
                 chainId: directoryChainIid,
-                merkleHashVersion: (_l = settings.merkleHashVersion) !== null && _l !== void 0 ? _l : 0,
+                merkleHashVersion: (_l = settings.merkleHashVersion) !== null && _l !== void 0 ? _l : MERKLE_HASH_VERSIONS.UNSET,
             });
         }))();
         return {
             endpointPool,
             nodeManager: nodeManager,
             blockchainRid: blockchainRidToUse,
-            merkleHashVersion: (_e = settings.merkleHashVersion) !== null && _e !== void 0 ? _e : 0,
+            merkleHashVersion: (_e = settings.merkleHashVersion) !== null && _e !== void 0 ? _e : MERKLE_HASH_VERSIONS.UNSET,
             dappStatusPolling: setStatusPolling(settings.dappStatusPolling),
             clusterAnchoringStatusPolling: setStatusPolling(settings.clusterAnchoringStatusPolling),
             systemAnchoringStatusPolling: setStatusPolling(settings.systemAnchoringStatusPolling),
+            retryTransactionPolling: setRetryTransactionPolling(settings.retryTransactionPolling),
             failoverStrategy: ((_f = settings.failOverConfig) === null || _f === void 0 ? void 0 : _f.strategy) || defaultFailoverConfig.strategy,
             attemptsPerEndpoint: ((_g = settings.failOverConfig) === null || _g === void 0 ? void 0 : _g.attemptsPerEndpoint) || defaultFailoverConfig.attemptsPerEndpoint,
             attemptInterval: ((_h = settings.failOverConfig) === null || _h === void 0 ? void 0 : _h.attemptInterval) || defaultFailoverConfig.attemptInterval,
@@ -1805,7 +1816,6 @@ function nodeDiscovery({ nodeManager, directoryEndpointPool, failOverConfig, blo
             endpointPool: directoryEndpointPool,
             chainId: directoryIid,
             failOverConfig,
-            merkleHashVersion: 0,
         });
         const blockchainRidToUse = yield (() => __awaiter$5(this, void 0, void 0, function* () {
             if (blockchainRid) {
@@ -1817,7 +1827,6 @@ function nodeDiscovery({ nodeManager, directoryEndpointPool, failOverConfig, blo
                     endpointPool: directoryEndpointPool,
                     chainId: blockchainIid,
                     failOverConfig,
-                    merkleHashVersion: 0,
                 });
             }
             throw new MissingBlockchainIdentifierError();
@@ -1825,7 +1834,6 @@ function nodeDiscovery({ nodeManager, directoryEndpointPool, failOverConfig, blo
         const D1Client = yield createClient({
             nodeUrlPool: getUrlsFromEndpoints(directoryEndpointPool),
             blockchainRid: directoryBRID,
-            merkleHashVersion: 0,
         });
         return yield getBlockchainApiUrls(D1Client, ensureBuffer(blockchainRidToUse));
     });
@@ -1850,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) {
@@ -1958,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;
@@ -1998,7 +2006,6 @@ function getSystemClient(directoryNodeUrlPool, directoryChainRid) {
         return yield createClient({
             directoryNodeUrlPool,
             blockchainRid: directoryChainRid,
-            merkleHashVersion: 0,
         });
     });
 }
@@ -2037,7 +2044,7 @@ const getUrlsFromEndpoints = (endpointPool) => {
 function awaitDappConfirmation(txRID, dappStatusPolling, getTransactionStatus) {
     var _a;
     return __awaiter$5(this, void 0, void 0, function* () {
-        let lastKnownResult;
+        let lastKnownResult = null;
         for (let i = 0; i < dappStatusPolling.count; i++) {
             lastKnownResult = yield getTransactionStatus(txRID);
             if (lastKnownResult.status === exports.ResponseStatus.Confirmed) {
@@ -2048,10 +2055,7 @@ function awaitDappConfirmation(txRID, dappStatusPolling, getTransactionStatus) {
             }
             yield sleep(dappStatusPolling.interval);
         }
-        // TS issue. This could be fixed by implementing new retry strategy
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        //@ts-expect-error
-        return lastKnownResult;
+        throw new Error(`Retry count exceeded. Confirmation not received. Last transaction status: ${lastKnownResult === null || lastKnownResult === void 0 ? void 0 : lastKnownResult.status}`);
     });
 }
 function awaitClusterAnchoringChainConfirmation(txRID, clusterAnchoringStatusPolling, getClusterAnchoringTransactionConfirmation) {
@@ -2165,6 +2169,13 @@ function setStatusPolling(statusPolling) {
         count: (_b = statusPolling === null || statusPolling === void 0 ? void 0 : statusPolling.count) !== null && _b !== void 0 ? _b : 20,
     };
 }
+function setRetryTransactionPolling(statusPolling) {
+    var _a, _b;
+    return {
+        interval: (_a = statusPolling === null || statusPolling === void 0 ? void 0 : statusPolling.interval) !== null && _a !== void 0 ? _a : 500,
+        count: (_b = statusPolling === null || statusPolling === void 0 ? void 0 : statusPolling.count) !== null && _b !== void 0 ? _b : 3,
+    };
+}
 function linkPromiEvents(event1, event2) {
     const transactionEvents = Object.values(exports.TransactionEvent).filter((event) => typeof event === "string");
     /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -2236,11 +2247,12 @@ function getBlockchainRidFromIid({ endpointPool, chainId, failOverConfig = {}, n
             dappStatusPolling: setStatusPolling(),
             clusterAnchoringStatusPolling: setStatusPolling(),
             systemAnchoringStatusPolling: setStatusPolling(),
+            retryTransactionPolling: setRetryTransactionPolling(),
             failoverStrategy: mergedFailOverConfig.strategy,
             attemptsPerEndpoint: mergedFailOverConfig.attemptsPerEndpoint,
             attemptInterval: mergedFailOverConfig.attemptInterval,
             unreachableDuration: mergedFailOverConfig.unreachableDuration,
-            merkleHashVersion: 0,
+            merkleHashVersion: MERKLE_HASH_VERSIONS.UNSET,
         };
         const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/brid/iid_${chainId}`, config);
         const blockchainRid = isString(rspBody);
@@ -2364,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);
@@ -2374,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) {
@@ -2548,7 +2560,7 @@ function getAnchoringClient(client, dappBlockchainRid, cluster) {
         if (!sourceClusterInfo || !sourceClusterInfo.anchoring_chain) {
             throw Error("Cluster info could not be found");
         }
-        const networkSettings = Object.assign(Object.assign({}, client.config), { directoryNodeUrlPool: getUrlsFromEndpoints(client.config.endpointPool), blockchainRid: toString(sourceClusterInfo.anchoring_chain), merkleHashVersion: 0 });
+        const networkSettings = Object.assign(Object.assign({}, client.config), { directoryNodeUrlPool: getUrlsFromEndpoints(client.config.endpointPool), blockchainRid: toString(sourceClusterInfo.anchoring_chain) });
         const clientConfiguredToAnchoringchain = yield createClient(networkSettings);
         return clientConfiguredToAnchoringchain;
     });
@@ -2906,6 +2918,48 @@ function createClient(settings) {
                     }
                 });
             },
+            sendTransactionWithRetries(transaction, callback, confirmationLevel = exports.ChainConfirmationLevel.Dapp) {
+                const client = this;
+                function sendOnce() {
+                    return client.sendTransaction(transaction, true, callback, confirmationLevel);
+                }
+                const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter$1(this, void 0, void 0, function* () {
+                    let error = null;
+                    // await sleep(1000);
+                    for (let i = 0; i < config.retryTransactionPolling.count; i++) {
+                        info(`sendTransactionWithRetries attempt ${i + 1} of ${config.retryTransactionPolling.count}`);
+                        const tmpPromiEvent = sendOnce()
+                            .on(exports.TransactionEvent.ClusterAnchoringConfirmation, receipt => {
+                            promiEvent.emit(exports.TransactionEvent.ClusterAnchoringConfirmation, receipt);
+                        })
+                            .on(exports.TransactionEvent.SystemAnchoringConfirmation, receipt => {
+                            promiEvent.emit(exports.TransactionEvent.SystemAnchoringConfirmation, receipt);
+                        })
+                            .on(exports.TransactionEvent.DappReceived, receipt => {
+                            promiEvent.emit(exports.TransactionEvent.DappReceived, receipt);
+                        })
+                            .on(exports.TransactionEvent.Signed, receipt => {
+                            promiEvent.emit(exports.TransactionEvent.Signed, receipt);
+                        })
+                            .on(exports.TransactionEvent.DappConfirmed, receipt => {
+                            promiEvent.emit(exports.TransactionEvent.DappConfirmed, receipt);
+                        })
+                            .catch(tmpError => {
+                            warning(`sendTransactionWithRetries error on attempt ${i + 1} of ${config.retryTransactionPolling.count}: ${tmpError}`);
+                            promiEvent.emit(exports.TransactionEvent.Rejected, tmpError);
+                            error = tmpError;
+                        });
+                        const tmpReceipt = yield tmpPromiEvent;
+                        if (tmpReceipt) {
+                            resolve(tmpReceipt);
+                            return;
+                        }
+                        yield sleep(config.retryTransactionPolling.interval);
+                    }
+                    reject(error);
+                }));
+                return promiEvent;
+            },
             sendTransaction(transaction, doStatusPolling = true, callback, confirmationLevel = exports.ChainConfirmationLevel.Dapp) {
                 const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter$1(this, void 0, void 0, function* () {
                     var _a, _b;
@@ -2940,14 +2994,15 @@ function createClient(settings) {
                             clusterAnchoringStatusPolling: client.config.clusterAnchoringStatusPolling,
                             systemAnchoringStatusPolling: client.config.systemAnchoringStatusPolling,
                         };
-                        let transactionReceipt = yield handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, statusPollingConfig.dappStatusPolling, () => client.getTransactionStatus(transactionRid, callback), client);
+                        const stickyNodeClient = yield createStickyNodeClient(client); //to avoid false rejections by oblivious nodes
+                        let transactionReceipt = yield handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, statusPollingConfig.dappStatusPolling, () => stickyNodeClient.getTransactionStatus(transactionRid, callback), stickyNodeClient);
                         if (confirmationLevel === exports.ChainConfirmationLevel.None ||
                             confirmationLevel === exports.ChainConfirmationLevel.Dapp) {
                             resolve(transactionReceipt);
                             return;
                         }
                         const { anchoringClient, systemAnchoringChainBridString } = yield getAnchoringClientAndSystemChainRid(client);
-                        transactionReceipt = yield handleSystemConfirmations(transactionReceipt, confirmationLevel, promiEvent, statusPollingConfig, anchoringClient, systemAnchoringChainBridString, () => client.getClusterAnchoringTransactionConfirmation(transactionRid, anchoringClient, callback), anchoredTxRid => client.getSystemAnchoringTransactionConfirmation(anchoredTxRid, anchoringClient, systemAnchoringChainBridString, callback));
+                        transactionReceipt = yield handleSystemConfirmations(transactionReceipt, confirmationLevel, promiEvent, statusPollingConfig, anchoringClient, systemAnchoringChainBridString, () => stickyNodeClient.getClusterAnchoringTransactionConfirmation(transactionRid, anchoringClient, callback), anchoredTxRid => stickyNodeClient.getSystemAnchoringTransactionConfirmation(anchoredTxRid, anchoringClient, systemAnchoringChainBridString, callback));
                         resolve(transactionReceipt);
                     }
                     catch (error) {
@@ -3367,6 +3422,21 @@ function createClient(settings) {
                 return merkleHashVersion;
             });
         }
+        function createStickyNodeClient(client) {
+            var _a;
+            return __awaiter$1(this, void 0, void 0, function* () {
+                if (!client.config.nodeManager.lastUsedNode) {
+                    throw new Error("No last used node found; cannot create sticky node client");
+                }
+                const stickyNodeClient = yield createClient({
+                    nodeUrlPool: (_a = client.config.nodeManager.lastUsedNode) === null || _a === void 0 ? void 0 : _a.url,
+                    blockchainRid: client.config.blockchainRid,
+                    merkleHashVersion: client.config.merkleHashVersion,
+                    useStickyNode: true,
+                });
+                return stickyNodeClient;
+            });
+        }
     });
 }
 
@@ -3392,6 +3462,7 @@ function createStubClient() {
                 dappStatusPolling: setStatusPolling({ interval: 5000, count: 5 }),
                 clusterAnchoringStatusPolling: setStatusPolling(),
                 systemAnchoringStatusPolling: setStatusPolling(),
+                retryTransactionPolling: setRetryTransactionPolling(),
                 failoverStrategy: exports.FailoverStrategy.AbortOnError,
                 attemptsPerEndpoint: 3,
                 attemptInterval: 5000,
@@ -3411,6 +3482,9 @@ function createStubClient() {
             sendTransaction() {
                 return new Web3PromiEvent((_resolve, reject) => reject("sendTransaction rejected"));
             },
+            sendTransactionWithRetries() {
+                return new Web3PromiEvent((_resolve, reject) => reject("sendTransactionWithRetries rejected"));
+            },
             signAndSendUniqueTransaction() {
                 return new Web3PromiEvent((_resolve, reject) => reject("signAndSendUniqueTransaction rejected"));
             },
@@ -3536,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" &&