evernode-js-client 0.6.35 → 0.6.37

package/index.js

@@ -52488,7 +52488,7 @@ class BaseEvernodeClient {
      * Get the hosts registered in Evernode.
      * @returns The list of hosts. 
      */
-    async getAllHostsFromLedger() {
+    async getAllHostsFromLedger(skipGetDomain = false) {
         const states = await this.getHookStates();
         let hosts = {};
 
@@ -52508,7 +52508,9 @@ class BaseEvernodeClient {
         const curMomentStartIdx = await this.getMomentStartIndex();
         await Promise.all((hostList).map(async host => {
             const hostAcc = new XrplAccount(host.address, null, { xrplApi: this.xrplApi });
-            host.domain = await hostAcc.getDomain();
+            if (!skipGetDomain) {
+                host.domain = await hostAcc.getDomain();
+            }
             host.active = (host.lastHeartbeatIndex > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
                 (host.lastHeartbeatIndex >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
                 (host.lastHeartbeatIndex > 0));
@@ -53315,10 +53317,11 @@ class HostClient extends BaseEvernodeClient {
         let attempt = 0;
         let feeUplift = 0;
         const maxAttempts = (options?.maxRetryAttempts || 1);
+        let submissionRef = options.submissionRef || {};
         while (attempt <= maxAttempts) {
             attempt++;
             try {
-                return await callback(feeUplift);
+                return await callback(feeUplift, submissionRef);
             }
             catch (e) {
                 if (attempt == maxAttempts || e.code === "tecDUPLICATE" || e.code === "tefPAST_SEQ" || e.code === "tefALREADY")
@@ -53329,6 +53332,16 @@ class HostClient extends BaseEvernodeClient {
                 console.error(e);
                 console.error(`Submission attempt ${attempt} failed. Retrying...`);
                 await new Promise(resolve => setTimeout(resolve, TX_RETRY_INTERVAL));
+
+                // Check again wether the transaction is validated before retry.
+                const txHash = submissionRef?.submissionResult?.result?.tx_json?.hash;
+                if (txHash) {
+                    const txResponse = await this.xrplApi.getTransactionValidatedResults(txHash);
+                    if (txResponse && txResponse.code === "tesSUCCESS") {
+                        console.log('Transaction is validated and success, Retry skipped!')
+                        return txResponse;
+                    }
+                }
             }
         }
     }
@@ -53353,15 +53366,15 @@ class HostClient extends BaseEvernodeClient {
             { ...accountSetFields, Domain: domain } : accountSetFields;
 
         if (Object.keys(accountSetFields).length !== 0) {
-            await this.#submitWithRetry(async (feeUplift) => {
-                await this.xrplAcc.setAccountFields(accountSetFields, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-            }, options.retryOptions);
+            await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                await this.xrplAcc.setAccountFields(accountSetFields, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+            }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
         }
 
         if (trustLines.length === 0) {
-            await this.#submitWithRetry(async (feeUplift) => {
-                await this.xrplAcc.setTrustLine(EvernodeConstants.EVR, this.config.evrIssuerAddress, "99999999999999", null, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-            }, options.retryOptions);
+            await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                await this.xrplAcc.setTrustLine(EvernodeConstants.EVR, this.config.evrIssuerAddress, "99999999999999", null, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+            }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
         }
     }
 
@@ -53424,9 +53437,9 @@ class HostClient extends BaseEvernodeClient {
         const uri = uriBuf.toString('base64');
 
         try {
-            await this.#submitWithRetry(async (feeUplift) => {
-                await this.xrplAcc.mintURIToken(uri, null, { isBurnable: true, isHexUri: false }, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-            }, options.retryOptions);
+            await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                await this.xrplAcc.mintURIToken(uri, null, { isBurnable: true, isHexUri: false }, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+            }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
         } catch (e) {
             // Re-minting the URIToken after burning that sold URIToken.
             if (e.code === "tecDUPLICATE") {
@@ -53442,12 +53455,12 @@ class HostClient extends BaseEvernodeClient {
         if (!uriToken)
             throw "Offer lease NFT creation error.";
 
-        await this.#submitWithRetry(async (feeUplift) => {
+        await this.#submitWithRetry(async (feeUplift, submissionRef) => {
             await this.xrplAcc.sellURIToken(uriToken.index,
                 leaseAmount.toString(),
                 EvernodeConstants.EVR,
-                this.config.evrIssuerAddress, null, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-        }, options.retryOptions);
+                this.config.evrIssuerAddress, null, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+        }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
     }
 
     /**
@@ -53509,9 +53522,9 @@ class HostClient extends BaseEvernodeClient {
         const uri = uriBuf.toString('base64');
 
         try {
-            await this.#submitWithRetry(async (feeUplift) => {
-                await this.xrplAcc.mintURIToken(uri, null, { isBurnable: true, isHexUri: false }, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-            }, options.retryOptions);
+            await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                await this.xrplAcc.mintURIToken(uri, null, { isBurnable: true, isHexUri: false }, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+            }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
         } catch (e) {
             // Re-minting the URIToken after burning that sold URIToken.
             if (e.code === "tecDUPLICATE") {
@@ -53530,11 +53543,11 @@ class HostClient extends BaseEvernodeClient {
      * @param {number} leaseAmount Amount (EVRs) of the lease offer.
      */
     async offerMintedLease(uriTokenId, leaseAmount, options = {}) {
-        await this.#submitWithRetry(async (feeUplift) => {
+        await this.#submitWithRetry(async (feeUplift, submissionRef) => {
             await this.xrplAcc.sellURIToken(uriTokenId, leaseAmount.toString(),
                 EvernodeConstants.EVR,
-                this.config.evrIssuerAddress, null, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-        }, options.retryOptions);
+                this.config.evrIssuerAddress, null, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+        }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
     }
 
     /**
@@ -53542,9 +53555,9 @@ class HostClient extends BaseEvernodeClient {
      * @param {string} uriTokenId Hex URI token id of the lease.
      */
     async expireLease(uriTokenId, options = {}) {
-        await this.#submitWithRetry(async (feeUplift) => {
-            await this.xrplAcc.burnURIToken(uriTokenId, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-        }, options.retryOptions);
+        await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+            await this.xrplAcc.burnURIToken(uriTokenId, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+        }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
     }
 
     /**
@@ -53564,9 +53577,9 @@ class HostClient extends BaseEvernodeClient {
                 const sellOffer = (await registryAcc.getURITokens()).find(o => o.index == regInfo.uriTokenId && o.Amount);
                 console.log('Pending sell offer found.')
                 if (sellOffer) {
-                    await this.#submitWithRetry(async (feeUplift) => {
-                        await this.xrplAcc.buyURIToken(sellOffer, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-                    }, options.retryOptions);
+                    await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                        await this.xrplAcc.buyURIToken(sellOffer, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+                    }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
                     console.log("Registration was successfully completed after acquiring the NFT.");
                     return await this.isRegistered();
                 }
@@ -53627,9 +53640,9 @@ class HostClient extends BaseEvernodeClient {
         if (existingLeaseURITokens) {
             console.log("Burning unsold URITokens related to the previous leases.");
             for (const uriToken of existingLeaseURITokens) {
-                await this.#submitWithRetry(async (feeUplift) => {
-                    await this.xrplAcc.burnURIToken(uriToken.index, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-                }, options.retryOptions);
+                await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                    await this.xrplAcc.burnURIToken(uriToken.index, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+                }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
             }
         }
 
@@ -53669,7 +53682,7 @@ class HostClient extends BaseEvernodeClient {
         Buffer.from(description.substr(0, 26), "utf-8").copy(paramBuf, HOST_DESCRIPTION_PARAM_OFFSET);
         Buffer.from(emailAddress.substr(0, 40), "utf-8").copy(paramBuf, HOST_EMAIL_ADDRESS_PARAM_OFFSET);
 
-        const tx = await this.#submitWithRetry(async (feeUplift) => {
+        const tx = await this.#submitWithRetry(async (feeUplift, submissionRef) => {
             return await this.xrplAcc.makePayment(this.config.registryAddress,
                 (transferredNFTokenId) ? EvernodeConstants.NOW_IN_EVRS : this.config.hostRegFee.toString(),
                 EvernodeConstants.EVR,
@@ -53681,10 +53694,10 @@ class HostClient extends BaseEvernodeClient {
                         { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: paramBuf.toString('hex').toUpperCase() }
                     ],
                     maxLedgerIndex: this.#getMaxLedgerSequence(),
-                    feeUplift: feeUplift,
+                    feeUplift: feeUplift, submissionRef: submissionRef,
                     ...options.transactionOptions
                 });
-        }, options.retryOptions);
+        }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
 
         console.log('Waiting for the sell offer', tx.id)
         const registryAcc = new XrplAccount(this.config.registryAddress, null, { xrplApi: this.xrplApi });
@@ -53722,9 +53735,9 @@ class HostClient extends BaseEvernodeClient {
             resolve();
         });
 
-        await this.#submitWithRetry(async (feeUplift) => {
-            await this.xrplAcc.buyURIToken(sellOffer, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift });
-        }, options.retryOptions);
+        await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+            await this.xrplAcc.buyURIToken(sellOffer, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+        }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
         return await this.isRegistered();
     }
 
@@ -53747,7 +53760,7 @@ class HostClient extends BaseEvernodeClient {
             paramBuf.writeUInt8(1, 32);
         }
 
-        await this.#submitWithRetry(async (feeUplift) => {
+        await this.#submitWithRetry(async (feeUplift, submissionRef) => {
             await this.xrplAcc.makePayment(this.config.registryAddress,
                 XrplConstants.MIN_DROPS,
                 null,
@@ -53759,10 +53772,10 @@ class HostClient extends BaseEvernodeClient {
                         { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: paramBuf.toString('hex').toUpperCase() }
                     ],
                     maxLedgerIndex: this.#getMaxLedgerSequence(),
-                    feeUplift: feeUplift,
+                    feeUplift: feeUplift, submissionRef: submissionRef,
                     ...options.transactionOptions
                 });
-        }, options.retryOptions);
+        }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
 
         return await this.isRegistered();
     }
@@ -53812,7 +53825,7 @@ class HostClient extends BaseEvernodeClient {
             paramBuf.writeUInt8(components[2], HOST_UPDATE_VERSION_PARAM_OFFSET + 2);
         }
 
-        return await this.#submitWithRetry(async (feeUplift) => {
+        return await this.#submitWithRetry(async (feeUplift, submissionRef) => {
             return await this.xrplAcc.makePayment(this.config.registryAddress,
                 XrplConstants.MIN_DROPS,
                 null,
@@ -53824,10 +53837,10 @@ class HostClient extends BaseEvernodeClient {
                         { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: paramBuf.toString('hex') }
                     ],
                     maxLedgerIndex: this.#getMaxLedgerSequence(),
-                    feeUplift: feeUplift,
+                    feeUplift: feeUplift, submissionRef: submissionRef,
                     ...options.transactionOptions
                 });
-        }, options.retryOptions);
+        }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
 
     }
 
@@ -53838,6 +53851,12 @@ class HostClient extends BaseEvernodeClient {
      * @returns Transaction result.
      */
     async heartbeat(voteInfo = {}, options = {}) {
+        let unofferedLeases = await this.getUnofferedLeases();
+        if (unofferedLeases.length > 0) {
+            console.log("Unoffered leases detected. Heartbeat was not sent.");
+            return;
+        }
+
         let data;
         // Prepare voteInfo
         if (Object.keys(voteInfo).length > 1) {
@@ -53859,7 +53878,8 @@ class HostClient extends BaseEvernodeClient {
                         ...(data ? [{ name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: data }] : [])
                     ],
                     maxLedgerIndex: this.#getMaxLedgerSequence(),
-                    ...options.transactionOptions
+                    ...options.transactionOptions,
+                    submissionRef: options.submissionRef
                 });
             return res;
         }
@@ -53926,7 +53946,8 @@ class HostClient extends BaseEvernodeClient {
                     { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
                 ],
                 maxLedgerIndex: this.#getMaxLedgerSequence(),
-                ...options.transactionOptions
+                ...options.transactionOptions,
+                submissionRef: options.submissionRef
             });
     }
 
@@ -53954,7 +53975,8 @@ class HostClient extends BaseEvernodeClient {
                     { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
                 ],
                 maxLedgerIndex: this.#getMaxLedgerSequence(),
-                ...options.transactionOptions
+                ...options.transactionOptions,
+                submissionRef: options.submissionRef
             });
     }
 
@@ -53983,7 +54005,8 @@ class HostClient extends BaseEvernodeClient {
                     { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
                 ],
                 maxLedgerIndex: this.#getMaxLedgerSequence(),
-                ...options.transactionOptions
+                ...options.transactionOptions,
+                submissionRef: options.submissionRef
             });
     }
 
@@ -54012,7 +54035,8 @@ class HostClient extends BaseEvernodeClient {
                     { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
                 ],
                 maxLedgerIndex: this.#getMaxLedgerSequence(),
-                ...options.transactionOptions
+                ...options.transactionOptions,
+                submissionRef: options.submissionRef
             });
     }
 
@@ -54038,7 +54062,8 @@ class HostClient extends BaseEvernodeClient {
                     { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
                 ],
                 maxLedgerIndex: this.#getMaxLedgerSequence(),
-                ...options.transactionOptions
+                ...options.transactionOptions,
+                submissionRef: options.submissionRef
             });
     }
 
@@ -54060,7 +54085,8 @@ class HostClient extends BaseEvernodeClient {
                     { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.HOST_REBATE }
                 ],
                 maxLedgerIndex: this.#getMaxLedgerSequence(),
-                ...options.transactionOptions
+                ...options.transactionOptions,
+                submissionRef: options.submissionRef
             });
     }
 
@@ -54086,7 +54112,7 @@ class HostClient extends BaseEvernodeClient {
 
         const regUriToken = await this.getRegistrationUriToken();
 
-        await this.#submitWithRetry(async (feeUplift) => {
+        await this.#submitWithRetry(async (feeUplift, submissionRef) => {
             await this.xrplAcc.sellURIToken(regUriToken.index,
                 XrplConstants.MIN_DROPS,
                 null,
@@ -54099,10 +54125,10 @@ class HostClient extends BaseEvernodeClient {
                         { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: paramData.toString('hex') }
                     ],
                     maxLedgerIndex: this.#getMaxLedgerSequence(),
-                    feeUplift: feeUplift,
+                    feeUplift: feeUplift, submissionRef: submissionRef,
                     ...options.transactionOptions
                 });
-        }, options.retryOptions);
+        }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
 
         let token = null;
         let attempts = 0;
@@ -56512,7 +56538,7 @@ class XrplAccount {
 
     async setAccountFields(fields, options = {}) {
         const preparedTxn = await this.prepareSetAccountFields(fields, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareSetAccountFields(fields, options = {}) {
@@ -56559,7 +56585,7 @@ class XrplAccount {
     async setSignerList(signerList = [], options = {}) {
 
         const preparedTxn = await this.prepareSetSignerList(signerList, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     /**
@@ -56605,7 +56631,7 @@ class XrplAccount {
 
     async makePayment(toAddr, amount, currency = null, issuer = null, memos = null, options = {}) {
         const preparedTxn = await this.prepareMakePayment(toAddr, amount, currency, issuer, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareMakePayment(toAddr, amount, currency = null, issuer = null, memos = null, options = {}) {
@@ -56624,7 +56650,7 @@ class XrplAccount {
 
     async setTrustLine(currency, issuer, limit, allowRippling = false, memos = null, options = {}) {
         const preparedTxn = await this.prepareSetTrustLine(currency, issuer, limit, allowRippling, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareSetTrustLine(currency, issuer, limit, allowRippling = false, memos = null, options = {}) {
@@ -56652,7 +56678,7 @@ class XrplAccount {
 
     async setRegularKey(regularKey, memos = null, options = {}) {
         const preparedTxn = await this.prepareSetRegularKey(regularKey, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareSetRegularKey(regularKey, memos = null, options = {}) {
@@ -56668,7 +56694,7 @@ class XrplAccount {
 
     async cashCheck(check, options = {}) {
         const preparedTxn = await this.prepareCashCheck(check, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareCashCheck(check, options = {}) {
@@ -56695,7 +56721,7 @@ class XrplAccount {
 
     async offerSell(sellAmount, sellCurrency, sellIssuer, forAmount, forCurrency, forIssuer = null, expiration = 4294967295, memos = null, options = {}) {
         const preparedTxn = await this.prepareOfferSell(sellAmount, sellCurrency, sellIssuer, forAmount, forCurrency, forIssuer, expiration, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareOfferSell(sellAmount, sellCurrency, sellIssuer, forAmount, forCurrency, forIssuer = null, expiration = 4294967295, memos = null, options = {}) {
@@ -56716,7 +56742,7 @@ class XrplAccount {
 
     async offerBuy(buyAmount, buyCurrency, buyIssuer, forAmount, forCurrency, forIssuer = null, expiration = 4294967295, memos = null, options = {}) {
         const preparedTxn = await this.prepareOfferBuy(buyAmount, buyCurrency, buyIssuer, forAmount, forCurrency, forIssuer, expiration, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareOfferBuy(buyAmount, buyCurrency, buyIssuer, forAmount, forCurrency, forIssuer = null, expiration = 4294967295, memos = null, options = {}) {
@@ -56737,7 +56763,7 @@ class XrplAccount {
 
     async cancelOffer(offerSequence, memos = null, options = {}) {
         const preparedTxn = await this.prepareCancelOffer(offerSequence, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareCancelOffer(offerSequence, memos = null, options = {}) {
@@ -56752,7 +56778,7 @@ class XrplAccount {
 
     async mintNft(uri, taxon, transferFee, flags = {}, memos = null, options = {}) {
         const preparedTxn = await this.prepareMintNft(uri, taxon, transferFee, flags, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareMintNft(uri, taxon, transferFee, flags = {}, memos = null, options = {}) {
@@ -56770,7 +56796,7 @@ class XrplAccount {
 
     async offerSellNft(nfTokenId, amount, currency, issuer = null, destination = null, expiration = 4294967295, memos = null, options = {}) {
         const preparedTxn = await this.prepareOfferSellNft(nfTokenId, amount, currency, issuer, destination, expiration, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareOfferSellNft(nfTokenId, amount, currency, issuer = null, destination = null, expiration = 4294967295, memos = null, options = {}) {
@@ -56792,7 +56818,7 @@ class XrplAccount {
 
     async offerBuyNft(nfTokenId, owner, amount, currency, issuer = null, expiration = 4294967295, memos = null, options = {}) {
         const preparedTxn = await this.prepareOfferSellNft(nfTokenId, owner, amount, currency, issuer, expiration, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareOfferBuyNft(nfTokenId, owner, amount, currency, issuer = null, expiration = 4294967295, memos = null, options = {}) {
@@ -56815,7 +56841,7 @@ class XrplAccount {
 
     async sellNft(offerId, memos = null, options = {}) {
         const preparedTxn = await this.prepareSellNft(offerId, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareSellNft(offerId, memos = null, options = {}) {
@@ -56831,7 +56857,7 @@ class XrplAccount {
 
     async buyNft(offerId, memos = null, options = {}) {
         const preparedTxn = await this.prepareBuyNft(offerId, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareBuyNft(offerId, memos = null, options = {}) {
@@ -56847,7 +56873,7 @@ class XrplAccount {
 
     async burnNft(nfTokenId, owner = null, memos = null, options = {}) {
         const preparedTxn = await this.prepareBurnNft(nfTokenId, owner, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareBurnNft(nfTokenId, owner = null, memos = null, options = {}) {
@@ -56963,7 +56989,7 @@ class XrplAccount {
 
     async mintURIToken(uri, digest = null, flags = {}, options = {}) {
         const preparedTxn = await this.prepareMintURIToken(uri, digest, flags, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareMintURIToken(uri, digest = null, flags = {}, options = {}) {
@@ -56983,7 +57009,7 @@ class XrplAccount {
 
     async burnURIToken(uriTokenID, options = {}) {
         const preparedTxn = await this.prepareBurnURIToken(uriTokenID, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareBurnURIToken(uriTokenID, options = {}) {
@@ -56997,7 +57023,7 @@ class XrplAccount {
 
     async sellURIToken(uriTokenID, amount, currency, issuer = null, toAddr = null, memos = null, options = {}) {
         const preparedTxn = await this.prepareSellURIToken(uriTokenID, amount, currency, issuer, toAddr, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareSellURIToken(uriTokenID, amount, currency, issuer = null, toAddr = null, memos = null, options = {}) {
@@ -57023,7 +57049,7 @@ class XrplAccount {
 
     async buyURIToken(uriToken, memos = null, options = {}) {
         const preparedTxn = await this.prepareBuyURIToken(uriToken, memos, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareBuyURIToken(uriToken, memos = null, options = {}) {
@@ -57045,7 +57071,7 @@ class XrplAccount {
 
     async clearURITokenOffer(uriTokenID, options = {}) {
         const preparedTxn = await this.prepareClearURITokenOffer(uriTokenID, options);
-        return await this.signAndSubmit(preparedTxn);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
     }
 
     async prepareClearURITokenOffer(uriTokenID, options = {}) {
@@ -57127,11 +57153,12 @@ class XrplAccount {
     /**
      * Sign and submit prepared transaction.
      * @param {object} preparedTransaction Prepared transaction.
+     * @param {object} submissionRef [Optional] Reference object to take submission references.
      * @returns result of the submitted transaction.
      */
-    async signAndSubmit(preparedTransaction) {
+    async signAndSubmit(preparedTransaction, submissionRef = {}) {
         const signedTxn = this.sign(preparedTransaction, false);
-        return await this.xrplApi.submitAndWait(preparedTransaction, signedTxn.tx_blob);
+        return await this.xrplApi.submitAndWait(preparedTransaction, signedTxn.tx_blob, submissionRef);
     }
 
     /**
@@ -57218,7 +57245,7 @@ class XrplApi {
     }
 
     async #acquireClient() {
-        while (this.#isClientAcquired || this.#isConnectionAcquired) {
+        while (!(this.#isPrimaryServerConnected || this.#isFallbackServerConnected) && this.#isClientAcquired) {
             await new Promise((resolve) => setTimeout(resolve, 100));
         }
         this.#isClientAcquired = true;
@@ -57229,7 +57256,7 @@ class XrplApi {
     }
 
     async #acquireConnection() {
-        while (this.#isClientAcquired) {
+        while (this.#isConnectionAcquired) {
             await new Promise((resolve) => setTimeout(resolve, 100));
         }
         this.#isConnectionAcquired = true;
@@ -57240,16 +57267,15 @@ class XrplApi {
     }
 
     async #setXrplClient(client) {
-        await this.#acquireClient();
         try {
-            if (this.#client) // Clear all listeners if there's an already created client.
+            if (this.#client) { // Clear all listeners if there's an already created client.
                 await this.#client.removeAllListeners();
+                await this.#client.disconnect();
+            }
 
             this.#client = client;
-            this.#releaseClient();
         }
         catch (e) {
-            this.#releaseClient();
             console.log("Error occurred in Client initiation:", e)
         }
     }
@@ -57349,9 +57375,14 @@ class XrplApi {
     }
 
     async #attemptFallbackServerReconnect(maxRounds, attemptsPerServer = 3) {
+        if (!this.#fallbackServers || this.#fallbackServers?.length == 0)
+            return;
+
+        await this.#acquireClient();
+
         const fallbackServers = this.#fallbackServers;
         let round = 0;
-        while (fallbackServers?.length > 0 && !this.#isPermanentlyDisconnected && !this.#isPrimaryServerConnected && !this.#isFallbackServerConnected && (!maxRounds || round < maxRounds)) { // Keep attempting until consumer calls disconnect() manually or if the primary server is disconnected.
+        while (!this.#isPermanentlyDisconnected && !this.#isPrimaryServerConnected && !this.#isFallbackServerConnected && (!maxRounds || round < maxRounds)) { // Keep attempting until consumer calls disconnect() manually or if the primary server is disconnected.
             ++round;
             serverIterator:
             for (let serverIndex in fallbackServers) {
@@ -57361,8 +57392,8 @@ class XrplApi {
                         break serverIterator;
                     }
                     ++attempt;
+                    const client = new xrpl.Client(server, this.#xrplClientOptions);
                     try {
-                        const client = new xrpl.Client(server, this.#xrplClientOptions);
                         if (!this.#isPrimaryServerConnected) {
                             await this.#handleClientConnect(client);
                             this.#isFallbackServerConnected = true;
@@ -57370,67 +57401,90 @@ class XrplApi {
                         break serverIterator;
                     }
                     catch (e) {
-                        console.log(`Error occurred while connecting to fallback server ${server}`, e)
+                        this.#releaseClient();
+                        console.log(`Error occurred while connecting to fallback server ${server}`);
+                        await new Promise(resolve => setTimeout(resolve, 1000));
+                        if (client.isConnected()) {
+                            console.log('Connection closure already handled');
+                            await client.disconnect();
+                        }
+
                         if (!this.#isPermanentlyDisconnected) {
                             if (!maxRounds || round < maxRounds)
                                 console.log(`Fallback server ${server} connection attempt ${attempt} failed. Retrying in ${2 * round}s...`);
                             else
-                                throw `Fallback server ${server} connection max attempts failed.`;
+                                return { error: `Fallback server ${server} connection max attempts failed.`, exception: e };
                             await new Promise(resolve => setTimeout(resolve, 2 * round * 1000));
                         }
                     }
                 }
             }
-
         }
+
+        return {};
     }
 
     async #attemptPrimaryServerReconnect(maxAttempts = null) {
+        await this.#acquireClient();
+
         let attempt = 0;
-        while (!this.#isPermanentlyDisconnected && !this.#isPrimaryServerConnected) { // Keep attempting until consumer calls disconnect() manually.
+        while (!this.#isPermanentlyDisconnected && !this.#isPrimaryServerConnected && !this.#isFallbackServerConnected) { // Keep attempting until consumer calls disconnect() manually.
             ++attempt;
+            const client = new xrpl.Client(this.#primaryServer, this.#xrplClientOptions);
             try {
-                const client = new xrpl.Client(this.#primaryServer, this.#xrplClientOptions);
                 await this.#handleClientConnect(client);
-                this.#isFallbackServerConnected = false;
                 this.#isPrimaryServerConnected = true;
                 break;
             }
             catch (e) {
-                console.log("Error occurred while re-connecting to the primary server", e)
+                this.#releaseClient();
+                console.log("Error occurred while re-connecting to the primary server")
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                if (client.isConnected()) {
+                    console.log('Connection closure already handled');
+                    await client.disconnect();
+                }
+
                 if (!this.#isPermanentlyDisconnected) {
                     const delaySec = 2 * attempt; // Retry with backoff delay.
                     if (!maxAttempts || attempt < maxAttempts)
                         console.log(`Primary server ${this.#primaryServer} attempt ${attempt} failed. Retrying in ${delaySec}s...`);
                     else
-                        throw `Primary server ${this.#primaryServer} connection max attempts failed.`;
+                        return { error: `Primary server ${this.#primaryServer} connection max attempts failed.`, exception: e };
                     await new Promise(resolve => setTimeout(resolve, delaySec * 1000));
                 }
             }
         }
+
+        return {};
     }
 
     async #connectXrplClient(reconnect = false) {
+        let res = [];
         if (reconnect) {
             if (this.#primaryServer) {
-                Promise.all([this.#attemptFallbackServerReconnect(), this.#attemptPrimaryServerReconnect()]);
+                res = await Promise.all([this.#attemptPrimaryServerReconnect(), this.#attemptFallbackServerReconnect()]);
             } else {
-                this.#attemptFallbackServerReconnect();
+                res = [await this.#attemptFallbackServerReconnect()];
             }
         }
         else {
             if (this.#primaryServer) {
-                Promise.all([this.#attemptFallbackServerReconnect(1, 1), this.#attemptPrimaryServerReconnect(1)]);
+                res = await Promise.all([this.#attemptPrimaryServerReconnect(1), this.#attemptFallbackServerReconnect(1, 1)]);
             } else {
-                this.#attemptFallbackServerReconnect(1, 1);
+                res = [await this.#attemptFallbackServerReconnect(1, 1)];
             }
         }
 
-        await this.#waitForConnection();
+        if (res.filter(r => r && !r.error).length == 0)
+            throw res.filter(r => r && r.error).map(r => r.error);
 
         // After connection established, check again whether maintainConnections has become false.
         // This is in case the consumer has called disconnect() while connection is being established.
         if (!this.#isPermanentlyDisconnected) {
+            await this.#waitForConnection();
+            this.#releaseClient();
+
             this.ledgerIndex = await this.#getLedgerIndex();
 
             this.#subscribeToStream('ledger');
@@ -57440,6 +57494,7 @@ class XrplApi {
                 await this.#handleClientRequest({ command: 'subscribe', accounts: this.#addressSubscriptions.map(s => s.address) });
         }
         else {
+            this.#releaseClient();
             await this.disconnect();
         }
     }
@@ -57501,24 +57556,27 @@ class XrplApi {
 
     async connect() {
         this.#isPermanentlyDisconnected = false;
-        await this.#connectXrplClient();
+
+        if (!this.#client || !this.#client.isConnected()) {
+            await this.#connectXrplClient();
+        }
         const definitions = await this.#handleClientRequest({ command: 'server_definitions' })
         this.xrplHelper = new XrplHelpers(definitions.result);
     }
 
     async disconnect() {
-        await this.#acquireClient();
+        await this.#acquireConnection();
 
         try {
             this.#isPermanentlyDisconnected = true;
 
-            if (this.#client.isConnected()) {
+            if (this.#client && this.#client.isConnected()) {
                 await this.#client.disconnect().catch(console.error);
             }
-            this.#releaseClient();
+            this.#releaseConnection();
         }
         catch (e) {
-            this.#releaseClient();
+            this.#releaseConnection();
             throw e;
         }
     }
@@ -57655,6 +57713,28 @@ class XrplApi {
         await this.#handleClientRequest({ command: 'subscribe', streams: [streamName] });
     }
 
+    /**
+     * Get the transaction results if validated.
+     * @param {string} txHash Hash of the transaction to check.
+     * @returns Validated results of the transaction.
+     */
+    async getTransactionValidatedResults(txHash) {
+        const txResponse = await this.getTxnInfo(txHash)
+            .catch((e) => {
+                return null;
+            });
+
+        if (txResponse?.validated) {
+            return {
+                id: txResponse?.hash,
+                code: txResponse?.meta?.TransactionResult,
+                details: txResponse
+            };
+        }
+
+        return null;
+    }
+
     /**
      * Watching to acquire the transaction submission. (Waits until txn. is applied to the ledger.)
      * @param {string} txHash Transaction Hash
@@ -57723,18 +57803,18 @@ class XrplApi {
             return { ...txResult, ...(hookExecRes ? { hookExecutionResult: hookExecRes } : {}) };
         else
             throw { ...txResult, ...(hookExecRes ? { hookExecutionResult: hookExecRes } : {}) };
-
     }
 
     /**
      * Submit a multi-signature transaction and wait for validation.
      * @param {object} tx Multi-signed transaction object.
+     * @param {object} submissionRef [Optional] Reference object to take submission references.
      * @returns response object of the validated transaction.
      */
-    async submitMultisignedAndWait(tx) {
+    async submitMultisignedAndWait(tx, submissionRef = {}) {
         tx.SigningPubKey = "";
-        const submissionResult = await this.#handleClientRequest({ command: 'submit_multisigned', tx_json: tx });
-        return await this.#prepareResponse(tx, submissionResult);
+        submissionRef.submissionResult = await this.#handleClientRequest({ command: 'submit_multisigned', tx_json: tx });
+        return await this.#prepareResponse(tx, submissionRef.submissionResult);
     }
 
     /**
@@ -57750,11 +57830,12 @@ class XrplApi {
     /**
      * Submit a single-signature transaction.
      * @param {string} tx_blob Signed transaction object.
+     * @param {object} submissionRef [Optional] Reference object to take submission references.
      * @returns response object of the validated transaction.
      */
-    async submitAndWait(tx, tx_blob) {
-        const submissionResult = await this.#handleClientRequest({ command: 'submit', tx_blob: tx_blob });
-        return await this.#prepareResponse(tx, submissionResult);
+    async submitAndWait(tx, tx_blob, submissionRef = {}) {
+        submissionRef.submissionResult = await this.#handleClientRequest({ command: 'submit', tx_blob: tx_blob });
+        return await this.#prepareResponse(tx, submissionRef.submissionResult);
     }
 
     /**

package/package.json

@@ -6,7 +6,7 @@
     ],
     "homepage": "https://github.com/HotPocketDev/evernode-js-client",
     "license": "SEE LICENSE IN https://raw.githubusercontent.com/EvernodeXRPL/evernode-resources/main/license/evernode-license.pdf",
-    "version": "0.6.35",
+    "version": "0.6.37",
     "dependencies": {
         "elliptic": "6.5.4",
         "libsodium-wrappers": "0.7.10",