evernode-js-client 0.6.20 → 0.6.21-definition-1.0

package/index.js

@@ -9149,7 +9149,7 @@ module.exports = { mask, unmask };
 
 
 try {
-  module.exports = require(__nccwpck_require__.ab + "prebuilds/linux-x64/node.napi.node");
+  module.exports = require(__nccwpck_require__.ab + "prebuilds/linux-x64/node.napi1.node");
 } catch (e) {
   module.exports = __nccwpck_require__(2567);
 }
@@ -33340,7 +33340,7 @@ module.exports = isValidUTF8;
 
 
 try {
-  module.exports = require(__nccwpck_require__.ab + "prebuilds/linux-x64/node.napi1.node");
+  module.exports = require(__nccwpck_require__.ab + "prebuilds/linux-x64/node.napi.node");
 } catch (e) {
   module.exports = __nccwpck_require__(9372);
 }
@@ -51832,7 +51832,7 @@ const { XrplApi } = __nccwpck_require__(1850);
 const { XrplAccount } = __nccwpck_require__(9329);
 const { XrplApiEvents, XrplConstants } = __nccwpck_require__(3307);
 const { EvernodeEvents, EventTypes, MemoFormats, EvernodeConstants, HookStateKeys, HookParamKeys, RegExp } = __nccwpck_require__(9849);
-const { DefaultValues } = __nccwpck_require__(8262);
+const { Defaults } = __nccwpck_require__(8262);
 const { EncryptionHelper } = __nccwpck_require__(4832);
 const { EventEmitter } = __nccwpck_require__(6170);
 const { UtilHelpers } = __nccwpck_require__(6687);
@@ -51861,10 +51861,10 @@ class BaseEvernodeClient {
     constructor(xrpAddress, xrpSecret, watchEvents, autoSubscribe = false, options = {}) {
 
         this.connected = false;
-        this.governorAddress = options.governorAddress || DefaultValues.governorAddress;
+        this.governorAddress = options.governorAddress || Defaults.values.governorAddress;
 
-        this.xrplApi = options.xrplApi || DefaultValues.xrplApi || new XrplApi(options.rippledServer);
-        if (!options.xrplApi && !DefaultValues.xrplApi)
+        this.xrplApi = options.xrplApi || Defaults.values.xrplApi || new XrplApi(options.rippledServer);
+        if (!options.xrplApi && !Defaults.values.xrplApi)
             this.#ownsXrplApi = true;
 
         this.xrplAcc = new XrplAccount(xrpAddress, xrpSecret, { xrplApi: this.xrplApi });
@@ -53036,7 +53036,7 @@ module.exports = {
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const { BaseEvernodeClient } = __nccwpck_require__(6263);
-const { DefaultValues } = __nccwpck_require__(8262);
+const { Defaults } = __nccwpck_require__(8262);
 const { EvernodeEvents } = __nccwpck_require__(9849);
 
 const GovernorEvents = {
@@ -53055,7 +53055,7 @@ const GovernorEvents = {
 
 class GovernorClient extends BaseEvernodeClient {
     constructor(options = {}) {
-        super((options.governorAddress || DefaultValues.governorAddress), null, Object.values(GovernorEvents), false, options);
+        super((options.governorAddress || Defaults.values.governorAddress), null, Object.values(GovernorEvents), false, options);
     }
 }
 
@@ -54355,16 +54355,22 @@ module.exports = {
 /***/ }),
 
 /***/ 8262:
-/***/ ((module) => {
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+const DefinitionsPath = './resources/definitions.json';
+
+const Definitions = __nccwpck_require__(4626);
 
 const DefaultValues = {
-    governorAddress: 'rGVHr1PrfL93UAjyw3DWZoi9adz2sLp2yL',
-    rippledServer: 'wss://hooks-testnet-v3.xrpl-labs.com',
     xrplApi: null,
-    stateIndexId: 'evernodeindex',
-    networkID: 21338
 }
 
+const RequiredInfoKeys = [
+    "governorAddress",
+    "stateIndexId",
+    "networkID"
+]
+
 const HookTypes = {
     governor: 'GOVERNOR',
     registry: 'REGISTRY',
@@ -54372,6 +54378,17 @@ const HookTypes = {
 }
 
 class Defaults {
+    /**
+     * Load defaults from the public definitions json.
+     * @param {string} network Network to choose the info.
+     */
+    static useNetwork(network) {
+        if (!Definitions[network])
+            throw 'Invalid network';
+
+        this.set(Definitions[network]);
+    }
+
     /**
      * Override Evernode default configs.
      * @param {object} newDefaults Configurations to override `{ governorAddress: '{string} governor xrpl address', rippledServer: '{string} rippled server url', xrplApi: '{XrplApi} xrpl instance', stateIndexId: '{string} firestore index', networkID: '{number} rippled network id' }`
@@ -54384,13 +54401,18 @@ class Defaults {
      * Read Evernode default configs.
      * @returns The Object of Evernode configs
      */
-    static get() {
+    static get values() {
+        var notFound = RequiredInfoKeys.find(k => !DefaultValues[k]);
+        if (notFound)
+            throw `Value for ${notFound} is not set.`;
+        else if (!DefaultValues.rippledServer && (!DefaultValues.fallbackRippledServers || !DefaultValues.fallbackRippledServers.length))
+            throw 'Either rippledServer or fallbackRippledServers required.';
+
         return { ...DefaultValues };
     }
 }
 
 module.exports = {
-    DefaultValues,
     Defaults,
     HookTypes
 }
@@ -55075,7 +55097,7 @@ module.exports = {
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const https = __nccwpck_require__(5687);
-const { DefaultValues } = __nccwpck_require__(8262);
+const { Defaults } = __nccwpck_require__(8262);
 
 const FirestoreOperations = {
     EQUAL: 'EQUAL',
@@ -55087,8 +55109,8 @@ class FirestoreHandler {
     #collectionPrefix = null;
 
     constructor(options = {}) {
-        this.#projectId = options.stateIndexId || DefaultValues.stateIndexId;
-        this.#collectionPrefix = options.collectionPrefix || DefaultValues.governorAddress;
+        this.#projectId = options.stateIndexId || Defaults.values.stateIndexId;
+        this.#collectionPrefix = options.collectionPrefix || Defaults.values.governorAddress;
     }
 
     /**
@@ -56450,7 +56472,7 @@ const crypto = __nccwpck_require__(6113);
 const { XrplConstants, XrplTransactionTypes } = __nccwpck_require__(3307);
 const { TransactionHelper } = __nccwpck_require__(7071);
 const { EventEmitter } = __nccwpck_require__(6170);
-const { DefaultValues } = __nccwpck_require__(8262);
+const { Defaults } = __nccwpck_require__(8262);
 
 class XrplAccount {
 
@@ -56464,7 +56486,7 @@ class XrplAccount {
 
         this.address = address;
         this.secret = secret;
-        this.xrplApi = options.xrplApi || DefaultValues.xrplApi;
+        this.xrplApi = options.xrplApi || Defaults.values.xrplApi;
 
         if (!this.xrplApi)
             throw "XrplAccount: xrplApi not specified.";
@@ -57186,7 +57208,7 @@ class XrplAccount {
             Sequence: options.sequence || await this.getSequence(),
             SigningPubKey: '', // This field is required for fee calculation.
             Fee: '0', // This field is required for fee calculation.
-            NetworkID: DefaultValues.networkID
+            NetworkID: Defaults.values.networkID
         }
 
         Object.assign(tx, txOptions);
@@ -57244,11 +57266,11 @@ module.exports = {
 const xrpl = __nccwpck_require__(4666);
 const kp = __nccwpck_require__(8150);
 const { EventEmitter } = __nccwpck_require__(6170);
-const { DefaultValues } = __nccwpck_require__(8262);
+const { Defaults } = __nccwpck_require__(8262);
 const { TransactionHelper } = __nccwpck_require__(7071);
 const { XrplApiEvents } = __nccwpck_require__(3307);
 const { XrplAccount } = __nccwpck_require__(9329);
-const {XrplHelpers} = __nccwpck_require__(3189)
+const { XrplHelpers } = __nccwpck_require__(3189)
 
 const MAX_PAGE_LIMIT = 400;
 const API_REQ_TYPE = {
@@ -57264,29 +57286,58 @@ const LEDGER_CLOSE_TIME = 1000
 
 class XrplApi {
 
-    #rippledServer;
+    #primaryServer;
+    #fallbackServers;
     #client;
     #events = new EventEmitter();
     #addressSubscriptions = [];
     #initialConnectCalled = false;
     #isPermanentlyDisconnected = false;
+    #isClientLocked = false;
+    #isPrimaryServerConnected = false;
+    #isFallbackServerConnected = false;
+    #isAttemptingConnection = false;
+    #xrplClientOptions;
     #autoReconnect;
 
-    constructor(rippledServer = null, options = {}) {
-        this.#rippledServer = rippledServer || DefaultValues.rippledServer;
-        this.#initXrplClient(options.xrplClientOptions);
+    constructor(rippledServer = '-', options = {}) {
+        if (rippledServer == '-') {
+            this.#primaryServer = null;
+        } else {
+            this.#primaryServer = rippledServer || Defaults.values.rippledServer;
+        }
+        this.#fallbackServers = options.fallbackRippledServers || Defaults.values.fallbackRippledServers || [];
+
+        if (!this.#primaryServer && (!this.#fallbackServers || !this.#fallbackServers.length))
+            throw 'Either primaryServer or fallbackServers required.';
+
+        this.#xrplClientOptions = options.xrplClientOptions;
+        const initServer = this.#primaryServer || this.#fallbackServers[0];
+        const client = new xrpl.Client(initServer, this.#xrplClientOptions);
+        this.#initXrplClient(client);
         this.#autoReconnect = options.autoReconnect ?? true;
     }
 
-    async #initXrplClient(xrplClientOptions = {}) {
-        if (this.#client) { // If the client already exists, clean it up.
+    async #setClient(client, removeCurrentClient = false) {
+        while (this.#isClientLocked) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        if (removeCurrentClient) {
+            this.#isClientLocked = true;
             this.#client.removeAllListeners(); // Remove existing event listeners to avoid them getting called from the old client object.
             await this.#client.disconnect();
-            this.#client = null;
+            this.#isClientLocked = false;
+        }
+        this.#client = client;
+    }
+
+    async #initXrplClient(client) {
+        if (this.#client) { // If the client already exists, clean it up.
+            await this.#setClient(null, true);
         }
 
         try {
-            this.#client = new xrpl.Client(this.#rippledServer, xrplClientOptions);
+            await this.#setClient(client);
         }
         catch (e) {
             console.log("Error occurred in Client initiation:", e)
@@ -57298,10 +57349,10 @@ class XrplApi {
 
         this.#client.on('disconnected', (code) => {
             if (this.#autoReconnect && !this.#isPermanentlyDisconnected) {
-                console.log(`Connection failure for ${this.#rippledServer} (code:${code})`);
+                console.log(`Connection failure for ${this.#client.url} (code:${code})`);
                 console.log("Re-initializing xrpl client.");
                 try {
-                    this.#initXrplClient().then(() => this.#connectXrplClient(true));
+                    this.#initXrplClient(this.#client).then(() => this.#connectXrplClient(true));
                 }
                 catch (e) {
                     console.log("Error occurred while re-initializing", e)
@@ -57359,40 +57410,113 @@ class XrplApi {
         });
     }
 
-    async #connectXrplClient(reconnect = false) {
+    async #attemptFallbackServerReconnect(maxRounds, attemptsPerServer = 3) {
+        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.
+            ++round;
+            serverIterator:
+            for (let serverIndex in fallbackServers) {
+                const server = fallbackServers[serverIndex];
+                for (let attempt = 0; attempt < attemptsPerServer;) {
+                    if (this.#isPrimaryServerConnected || this.#isPermanentlyDisconnected) {
+                        break serverIterator;
+                    }
+                    console.log(`Fallback server ${server} reconnection attempt ${++attempt}`);
+                    try {
+                        while (this.#isAttemptingConnection) {
+                            await new Promise((resolve) => setTimeout(resolve, 100));
+                        }
+                        this.#isAttemptingConnection = true;
+                        const client = new xrpl.Client(server, this.#xrplClientOptions);
+                        if (!this.#isPrimaryServerConnected) {
+                            await this.#handleClientConnect(client);
+                            await this.#initXrplClient(client);
+                            this.#isFallbackServerConnected = true;
+                            console.log(`Successfully connected to the fallback server ${server}`)
+                        }
+                        this.#isAttemptingConnection = false;
+                        break serverIterator;
+                    }
+                    catch (e) {
+                        console.log(`Error occurred while connecting to fallback server ${server}`, e)
+                        this.#isAttemptingConnection = false;
+                        if (!this.#isPermanentlyDisconnected) {
+                            if (!maxRounds || round < maxRounds)
+                                console.log(`Fallback server ${server} connection attempt ${attempt} failed. Retrying in ${2 * round}s...`);
+                            else
+                                console.log(`Fallback server ${server} connection attempt failed.`);
+                            await new Promise(resolve => setTimeout(resolve, 2 * round * 1000));
+                        }
+                    }
+                }
+            }
 
-        if (reconnect) {
-            let attempts = 0;
-            while (!this.#isPermanentlyDisconnected) { // Keep attempting until consumer calls disconnect() manually.
-                console.log(`Reconnection attempt ${++attempts}`);
-                try {
-                    await this.#client.connect();
-                    break;
+        }
+    }
+
+    async #attemptPrimaryServerReconnect() {
+        let attempt = 0;
+        while (!this.#isPermanentlyDisconnected && !this.#isPrimaryServerConnected) { // Keep attempting until consumer calls disconnect() manually.
+            console.log(`Primary server reconnection attempt ${++attempt}`);
+            try {
+                const client = new xrpl.Client(this.#primaryServer, this.#xrplClientOptions);
+                while (this.#isAttemptingConnection) {
+                    await new Promise((resolve) => setTimeout(resolve, 100));
                 }
-                catch (e) {
-                    console.log("Error occurred while re-connecting", e)
-                    if (!this.#isPermanentlyDisconnected) {
-                        const delaySec = 2 * attempts; // Retry with backoff delay.
-                        console.log(`Attempt ${attempts} failed. Retrying in ${delaySec}s...`);
-                        await new Promise(resolve => setTimeout(resolve, delaySec * 1000));
-                    }
+                this.#isAttemptingConnection = true;
+                await this.#handleClientConnect(client);
+                await this.#initXrplClient(client);
+                this.#isFallbackServerConnected = false;
+                this.#isPrimaryServerConnected = true;
+                console.log("Successfully connected to the primary server");
+                this.#isAttemptingConnection = false;
+                break;
+            }
+            catch (e) {
+                console.log("Error occurred while re-connecting to the primary server", e)
+                this.#isAttemptingConnection = false;
+                if (!this.#isPermanentlyDisconnected) {
+                    const delaySec = 2 * attempt; // Retry with backoff delay.
+                    console.log(`Attempt ${attempt} failed. Retrying in ${delaySec}s...`);
+                    await new Promise(resolve => setTimeout(resolve, delaySec * 1000));
                 }
             }
         }
+    }
+
+    async #connectXrplClient(reconnect = false) {
+        if (reconnect) {
+            if (this.#primaryServer) {
+                Promise.all([this.#attemptFallbackServerReconnect(), this.#attemptPrimaryServerReconnect()]);
+            } else {
+                this.#attemptFallbackServerReconnect();
+            }
+            await this.#waitForReconnection();
+        }
         else {
             // Single attempt and throw error. Used for initial connect() call.
-            await this.#client.connect();
+            try {
+                await this.#handleClientConnect();
+                this.#isPrimaryServerConnected = true;
+            } catch {
+                await this.#attemptFallbackServerReconnect(1, 1);
+                if (this.#isFallbackServerConnected)
+                    await this.#attemptPrimaryServerReconnect();
+            }
         }
 
         // 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) {
+            this.#isClientLocked = true;
             this.ledgerIndex = await this.#client.getLedgerIndex();
+            this.#isClientLocked = false;
             this.#subscribeToStream('ledger');
 
             // Re-subscribe to existing account address subscriptions (in case this is a reconnect)
             if (this.#addressSubscriptions.length > 0)
-                await this.#client.request({ command: 'subscribe', accounts: this.#addressSubscriptions.map(s => s.address) });
+                await this.#handleClientRequest({ command: 'subscribe', accounts: this.#addressSubscriptions.map(s => s.address) });
         }
         else {
             await this.disconnect();
@@ -57412,7 +57536,7 @@ class XrplApi {
                 requestObj.marker = resp?.result?.marker;
             else
                 delete requestObj.marker;
-            resp = (await this.#client.request(requestObj));
+            resp = (await this.#handleClientRequest(requestObj));
             if (resp?.result && resp?.result[requestType])
                 res.push(...resp.result[requestType]);
             if (count)
@@ -57422,6 +57546,23 @@ class XrplApi {
         return res;
     }
 
+    async #handleClientRequest(request = {}) {
+        while (this.#isAttemptingConnection) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        this.#isClientLocked = true;
+        const response = await this.#client.request(request);
+
+        this.#isClientLocked = false;
+        return response;
+    }
+
+    async #handleClientConnect(client = this.#client) {
+        this.#isClientLocked = true;
+        await client.connect();
+        this.#isClientLocked = false;
+    }
+
     on(event, handler) {
         this.#events.on(event, handler);
     }
@@ -57434,23 +57575,34 @@ class XrplApi {
         this.#events.off(event, handler);
     }
 
+    async #waitForReconnection() {
+        while (!(this.#isPrimaryServerConnected || this.#isFallbackServerConnected)) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        return true;
+    }
+
     async connect() {
         if (this.#initialConnectCalled) {
             return
         }
-        this.#initialConnectCalled = true
-        this.#isPermanentlyDisconnected = false
+        this.#initialConnectCalled = true;
+        this.#isPermanentlyDisconnected = false;
         await this.#connectXrplClient();
-        const definitions = await this.#client.request({ command: 'server_definitions' })
+        const definitions = await this.#handleClientRequest({ command: 'server_definitions' })
         this.xrplHelper = new XrplHelpers(definitions.result);
     }
 
     async disconnect() {
         this.#initialConnectCalled = false;
-        this.#isPermanentlyDisconnected = true
+        this.#isPermanentlyDisconnected = true;
 
         if (this.#client.isConnected()) {
+            this.#isClientLocked = true;
             await this.#client.disconnect().catch(console.error);
+            this.#isClientLocked = false;
+            this.#isPrimaryServerConnected = false;
+            this.#isFallbackServerConnected = false;
         }
     }
 
@@ -57470,7 +57622,7 @@ class XrplApi {
 
     async isAccountExists(address) {
         try {
-            await this.#client.request({ command: 'account_info', account: address });
+            await this.#handleClientRequest({ command: 'account_info', account: address });
             return true;
         }
         catch (e) {
@@ -57480,12 +57632,12 @@ class XrplApi {
     }
 
     async getAccountInfo(address) {
-        const resp = (await this.#client.request({ command: 'account_info', account: address }));
+        const resp = (await this.#handleClientRequest({ command: 'account_info', account: address }));
         return resp?.result?.account_data;
     }
 
     async getServerDefinition() {
-        const resp = (await this.#client.request({ command: 'server_definitions' }));
+        const resp = (await this.#handleClientRequest({ command: 'server_definitions' }));
         return resp?.result;
     }
 
@@ -57529,7 +57681,7 @@ class XrplApi {
 
     async getLedgerEntry(index, options) {
         try {
-            const resp = (await this.#client.request({ command: 'ledger_entry', index: index, ledger_index: "validated", ...options }));
+            const resp = (await this.#handleClientRequest({ command: 'ledger_entry', index: index, ledger_index: "validated", ...options }));
             return resp?.result?.node;
 
         } catch (e) {
@@ -57540,13 +57692,13 @@ class XrplApi {
     }
 
     async getTxnInfo(txnHash, options) {
-        const resp = (await this.#client.request({ command: 'tx', transaction: txnHash, binary: false, ...options }));
+        const resp = (await this.#handleClientRequest({ command: 'tx', transaction: txnHash, binary: false, ...options }));
         return resp?.result;
     }
 
     async subscribeToAddress(address, handler) {
         this.#addressSubscriptions.push({ address: address, handler: handler });
-        await this.#client.request({ command: 'subscribe', accounts: [address] });
+        await this.#handleClientRequest({ command: 'subscribe', accounts: [address] });
     }
 
     async unsubscribeFromAddress(address, handler) {
@@ -57555,16 +57707,16 @@ class XrplApi {
             if (sub.address === address && sub.handler === handler)
                 this.#addressSubscriptions.splice(i, 1);
         }
-        await this.#client.request({ command: 'unsubscribe', accounts: [address] });
+        await this.#handleClientRequest({ command: 'unsubscribe', accounts: [address] });
     }
 
     async getTransactionFee(txBlob) {
-        const fees = await this.#client.request({ command: 'fee', tx_blob: txBlob });
+        const fees = await this.#handleClientRequest({ command: 'fee', tx_blob: txBlob });
         return fees?.result?.drops?.base_fee;
     }
 
     async #subscribeToStream(streamName) {
-        await this.#client.request({ command: 'subscribe', streams: [streamName] });
+        await this.#handleClientRequest({ command: 'subscribe', streams: [streamName] });
     }
 
     /**
@@ -57580,7 +57732,9 @@ class XrplApi {
 
         await new Promise(r => setTimeout(r, LEDGER_CLOSE_TIME));
 
+        this.#isClientLocked = true;
         const latestLedger = await this.#client.getLedgerIndex();
+        this.#isClientLocked = false;
 
         if (lastLedger < latestLedger) {
             throw `The latest ledger sequence ${latestLedger} is greater than the transaction's LastLedgerSequence (${lastLedger}).\n` +
@@ -57647,7 +57801,7 @@ class XrplApi {
      */
     async submitMultisignedAndWait(tx) {
         tx.SigningPubKey = "";
-        const submissionResult = await this.#client.request({ command: 'submit_multisigned', tx_json: tx });
+        const submissionResult = await this.#handleClientRequest({ command: 'submit_multisigned', tx_json: tx });
         return await this.#prepareResponse(tx, submissionResult);
     }
 
@@ -57658,7 +57812,7 @@ class XrplApi {
      */
     async submitMultisigned(tx) {
         tx.SigningPubKey = "";
-        return await this.#client.request({ command: 'submit_multisigned', tx_json: tx });
+        return await this.#handleClientRequest({ command: 'submit_multisigned', tx_json: tx });
     }
 
     /**
@@ -57667,7 +57821,7 @@ class XrplApi {
      * @returns response object of the validated transaction.
      */
     async submitAndWait(tx, tx_blob) {
-        const submissionResult = await this.#client.request({ command: 'submit', tx_blob: tx_blob });
+        const submissionResult = await this.#handleClientRequest({ command: 'submit', tx_blob: tx_blob });
         return await this.#prepareResponse(tx, submissionResult);
     }
 
@@ -57677,7 +57831,7 @@ class XrplApi {
      * @returns response object of the submitted transaction.
      */
     async submit(tx_blob) {
-        return await this.#client.request({ command: 'submit', tx_blob: tx_blob });
+        return await this.#handleClientRequest({ command: 'submit', tx_blob: tx_blob });
     }
 
     /**
@@ -57777,6 +57931,14 @@ module.exports = {
     XrplHelpers
 }
 
+/***/ }),
+
+/***/ 4626:
+/***/ ((module) => {
+
+module.exports = eval("require")("./resources/definitions.json");
+
+
 /***/ }),
 
 /***/ 9491:

package/package.json

@@ -6,7 +6,7 @@
     ],
     "homepage": "https://github.com/HotPocketDev/evernode-js-client",
     "license": "MIT",
-    "version": "0.6.20",
+    "version": "0.6.21-definition-1.0",
     "dependencies": {
         "elliptic": "6.5.4",
         "libsodium-wrappers": "0.7.10",