evernode-js-client 0.4.50 → 0.4.53

package/index.js

@@ -11715,7 +11715,6 @@ const { EncryptionHelper } = __nccwpck_require__(4832);
 const { EventEmitter } = __nccwpck_require__(6170);
 const { UtilHelpers } = __nccwpck_require__(6687);
 const { FirestoreHandler } = __nccwpck_require__(9718);
-const { XflHelpers } = __nccwpck_require__(3243);
 const { StateHelpers } = __nccwpck_require__(3860);
 
 class BaseEvernodeClient {
@@ -11828,16 +11827,27 @@ class BaseEvernodeClient {
 
     async #getEvernodeConfig() {
         let states = await this.getHookStates();
-        return {
-            evrIssuerAddress: codec.encodeAccountID(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.EVR_ISSUER_ADDR), 'hex')),
-            foundationAddress: codec.encodeAccountID(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.FOUNDATION_ADDR), 'hex')),
-            hostRegFee: Number(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.HOST_REG_FEE), 'hex').readBigUInt64BE()),
-            momentSize: Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.MOMENT_SIZE), 'hex').readUInt16BE(),
-            hostHeartbeatFreq: Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.HOST_HEARTBEAT_FREQ), 'hex').readUInt16BE(),
-            momentBaseIdx: Number(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.MOMENT_BASE_IDX), 'hex').readBigInt64BE()),
-            purchaserTargetPrice: XflHelpers.toString(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.PURCHASER_TARGET_PRICE), 'hex').readBigInt64BE()),
-            leaseAcquireWindow: Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.LEASE_ACQUIRE_WINDOW), 'hex').readUInt16BE()
-        };
+        const configStateKeys = {
+            evrIssuerAddress: HookStateKeys.EVR_ISSUER_ADDR,
+            foundationAddress: HookStateKeys.FOUNDATION_ADDR,
+            hostRegFee: HookStateKeys.HOST_REG_FEE,
+            momentSize: HookStateKeys.MOMENT_SIZE,
+            hostHeartbeatFreq: HookStateKeys.HOST_HEARTBEAT_FREQ,
+            momentBaseIdx: HookStateKeys.MOMENT_BASE_IDX,
+            purchaserTargetPrice: HookStateKeys.PURCHASER_TARGET_PRICE,
+            leaseAcquireWindow: HookStateKeys.LEASE_ACQUIRE_WINDOW,
+            rewardInfo: HookStateKeys.REWARD_INFO,
+            rewardConfiguaration: HookStateKeys.REWARD_CONFIGURATION,
+            hostCount: HookStateKeys.HOST_COUNT
+        }
+        let config = {};
+        for (const [key, value] of Object.entries(configStateKeys)) {
+            const stateKey = Buffer.from(value, 'hex');
+            const stateData = Buffer.from(UtilHelpers.getStateData(states, value), 'hex');
+            const decoded = StateHelpers.decodeStateData(stateKey, stateData);
+            config[key] = decoded.value;
+        }
+        return config;
     }
 
     async refreshConfig() {
@@ -11850,13 +11860,13 @@ class BaseEvernodeClient {
         else if (!tx)
             console.log('handleEvernodeEvent: Invalid transaction.');
         else {
-            const ev = await this.#extractEvernodeEvent(tx);
+            const ev = await this.extractEvernodeEvent(tx);
             if (ev && this.#watchEvents.find(e => e === ev.name))
                 this.events.emit(ev.name, ev.data);
         }
     }
 
-    async #extractEvernodeEvent(tx) {
+    async extractEvernodeEvent(tx) {
         if (tx.TransactionType === 'NFTokenAcceptOffer' && tx.NFTokenSellOffer && tx.Memos.length >= 1 &&
             tx.Memos[0].type === MemoTypes.ACQUIRE_LEASE && tx.Memos[0].format === MemoFormats.BASE64 && tx.Memos[0].data) {
 
@@ -11875,8 +11885,8 @@ class BaseEvernodeClient {
                 data: {
                     transaction: tx,
                     host: tx.Destination,
-                    nfTokenId: tx.NFTokenSellOffer.NFTokenID,
-                    leaseAmount: tx.NFTokenSellOffer.Amount.value,
+                    nfTokenId: tx.NFTokenSellOffer?.NFTokenID,
+                    leaseAmount: tx.NFTokenSellOffer?.Amount?.value,
                     acquireRefId: tx.hash,
                     tenant: tx.Account,
                     payload: payload
@@ -12600,16 +12610,13 @@ module.exports = {
 
 const { BaseEvernodeClient } = __nccwpck_require__(6263);
 const { EvernodeEvents, MemoFormats, MemoTypes, ErrorCodes, ErrorReasons, EvernodeConstants } = __nccwpck_require__(9849);
-const { EventEmitter } = __nccwpck_require__(6170);
 const { EncryptionHelper } = __nccwpck_require__(4832);
 const { XrplAccount } = __nccwpck_require__(9329);
 const { UtilHelpers } = __nccwpck_require__(6687);
 const { Buffer } = __nccwpck_require__(4300);
 const codec = __nccwpck_require__(597);
 const { EvernodeHelpers } = __nccwpck_require__(2523);
-
-const ACQUIRE_WATCH_PREFIX = 'acquire_';
-const EXTEND_WATCH_PREFIX = 'extend_';
+const { TransactionHelper } = __nccwpck_require__(7071);
 
 const DEFAULT_WAIT_TIMEOUT = 60000;
 
@@ -12622,24 +12629,8 @@ const TenantEvents = {
 
 class TenantClient extends BaseEvernodeClient {
 
-    #respWatcher = new EventEmitter();
-
     constructor(xrpAddress, xrpSecret, options = {}) {
-        super(xrpAddress, xrpSecret, Object.values(TenantEvents), true, options);
-
-        this.on(TenantEvents.AcquireSuccess, (ev) => {
-            this.#respWatcher.emit(ACQUIRE_WATCH_PREFIX + ev.acquireRefId, { success: true, data: ev.payload, transaction: ev.transaction });
-        });
-        this.on(TenantEvents.AcquireError, (ev) => {
-            this.#respWatcher.emit(ACQUIRE_WATCH_PREFIX + ev.acquireRefId, { success: false, data: ev.reason, transaction: ev.transaction });
-        });
-
-        this.on(TenantEvents.ExtendSuccess, (ev) => {
-            this.#respWatcher.emit(EXTEND_WATCH_PREFIX + ev.extendRefId, { success: true, transaction: ev.transaction, expiryMoment: ev.expiryMoment });
-        });
-        this.on(TenantEvents.ExtendError, (ev) => {
-            this.#respWatcher.emit(EXTEND_WATCH_PREFIX + ev.extendRefId, { success: false, data: ev.reason, transaction: ev.transaction });
-        });
+        super(xrpAddress, xrpSecret, Object.values(TenantEvents), false, options);
     }
 
     async prepareAccount() {
@@ -12702,28 +12693,42 @@ class TenantClient extends BaseEvernodeClient {
         return this.xrplAcc.buyNft(selectedOfferIndex, [{ type: MemoTypes.ACQUIRE_LEASE, format: MemoFormats.BASE64, data: ecrypted }], options.transactionOptions);
     }
 
-    watchAcquireResponse(tx, options = {}) {
-        return new Promise(async (resolve, reject) => {
+    async watchAcquireResponse(tx, options = {}) {
             console.log(`Waiting for acquire response... (txHash: ${tx.id})`);
 
-            const watchEvent = ACQUIRE_WATCH_PREFIX + tx.id;
-
             const failTimeout = setTimeout(() => {
-                this.#respWatcher.off(watchEvent);
-                reject({ error: ErrorCodes.ACQUIRE_ERR, reason: ErrorReasons.TIMEOUT });
+                throw({ error: ErrorCodes.ACQUIRE_ERR, reason: ErrorReasons.TIMEOUT });
             }, options.timeout || DEFAULT_WAIT_TIMEOUT);
-
-            this.#respWatcher.once(watchEvent, async (ev) => {
-                clearTimeout(failTimeout);
-                if (ev.success) {
-                    const instanceInfo = ev.data;
-                    resolve({ instance: instanceInfo.content, transaction: ev.transaction });
-                }
-                else {
-                    reject({ error: ErrorCodes.ACQUIRE_ERR, reason: ev.data, transaction: ev.transaction });
+    
+            let relevantTx = null;
+            while (!relevantTx) {
+                const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
+                for (let t of txList) {
+                    t.tx.Memos = TransactionHelper.deserializeMemos(t.tx?.Memos);
+                        const res = await this.extractEvernodeEvent(t.tx);
+                        if ((res?.name === EvernodeEvents.AcquireSuccess || res?.name === EvernodeEvents.AcquireError) && res?.data?.acquireRefId === tx.id) {
+                            clearTimeout(failTimeout);
+                            relevantTx = res;
+                            break;
+                        }
                 }
-            })
-        });
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+    
+            if (relevantTx?.name === TenantEvents.AcquireSuccess) {
+                return({
+                    transaction: relevantTx?.data.transaction,
+                    instance: relevantTx?.data.payload.content,
+                    acquireRefId: relevantTx?.data.acquireRefId
+                });
+            } else if (relevantTx?.name === TenantEvents.AcquireError) {
+                throw({
+                    error: ErrorCodes.ACQUIRE_ERR,
+                    transaction: relevantTx?.data.transaction,
+                    reason: relevantTx?.data.reason,
+                    acquireRefId: relevantTx?.data.acquireRefId
+                })
+            }
     }
 
     acquireLease(hostAddress, requirement, options = {}) {
@@ -12732,13 +12737,11 @@ class TenantClient extends BaseEvernodeClient {
                 reject({ error: ErrorCodes.ACQUIRE_ERR, reason: error.reason || ErrorReasons.TRANSACTION_FAILURE, content: error.error || error });
             });
             if (tx) {
-                const response = await this.watchAcquireResponse(tx, options).catch(error => {
-                    error.acquireRefId = tx.id;
-                    reject(error);
-                });
-                if (response) {
-                    response.acquireRefId = tx.id;
+                try {
+                    const response = await this.watchAcquireResponse(tx, options);
                     resolve(response);
+                } catch (error) {
+                    reject(error);
                 }
             }
         });
@@ -12750,27 +12753,41 @@ class TenantClient extends BaseEvernodeClient {
             [{ type: MemoTypes.EXTEND_LEASE, format: MemoFormats.HEX, data: tokenID }], options.transactionOptions);
     }
 
-    watchExtendResponse(tx, options = {}) {
-        return new Promise(async (resolve, reject) => {
-            console.log(`Waiting for extend lease response... (txHash: ${tx.id})`);
-
-            const watchEvent = EXTEND_WATCH_PREFIX + tx.id;
+    async watchExtendResponse(tx, minLedgerIndex, options = {}) {
+        console.log(`Waiting for extend lease response... (txHash: ${tx.id})`);
 
-            const failTimeout = setTimeout(() => {
-                this.#respWatcher.off(watchEvent);
-                reject({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.TIMEOUT });
-            }, options.timeout || DEFAULT_WAIT_TIMEOUT);
+        const failTimeout = setTimeout(() => {
+            throw({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.TIMEOUT });
+        }, options.timeout || DEFAULT_WAIT_TIMEOUT);
 
-            this.#respWatcher.once(watchEvent, async (ev) => {
-                clearTimeout(failTimeout);
-                if (ev.success) {
-                    resolve({ transaction: ev.transaction, expiryMoment: ev.expiryMoment });
-                }
-                else {
-                    reject({ error: ErrorCodes.EXTEND_ERR, reason: ev.data, transaction: ev.transaction });
+        let relevantTx = null;
+        while (!relevantTx) {
+            const txList = await this.xrplAcc.getAccountTrx(minLedgerIndex);
+            for (let t of txList) {
+                t.tx.Memos = TransactionHelper.deserializeMemos(t.tx.Memos);
+                const res = await this.extractEvernodeEvent(t.tx);
+                if ((res?.name === TenantEvents.ExtendSuccess || res?.name === TenantEvents.ExtendError) && res?.data?.extendRefId === tx.id) {
+                    clearTimeout(failTimeout);
+                    relevantTx = res;
+                    break;
                 }
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+        if (relevantTx?.name === TenantEvents.ExtendSuccess) {
+            return({
+                transaction: relevantTx?.data.transaction,
+                expiryMoment: relevantTx?.data.expiryMoment,
+                extendeRefId: relevantTx?.data.extendRefId
+            });
+        } else if (relevantTx?.name === TenantEvents.ExtendError) {
+            throw({
+                error: ErrorCodes.EXTEND_ERR,
+                transaction: relevantTx?.data.transaction,
+                reason: relevantTx?.data.reason
             })
-        });
+        }
     }
 
     extendLease(hostAddress, moments, instanceName, options = {}) {
@@ -12783,19 +12800,20 @@ class TenantClient extends BaseEvernodeClient {
                 return;
             }
 
+            let minLedgerIndex = this.xrplApi.ledgerIndex;
+
             // Get the agreement lease amount from the nft and calculate EVR amount to be sent.
             const uriInfo = UtilHelpers.decodeLeaseNftUri(nft.URI);
             const tx = await this.extendLeaseSubmit(hostAddress, moments * uriInfo.leaseAmount, tokenID, options).catch(error => {
                 reject({ error: ErrorCodes.EXTEND_ERR, reason: error.reason || ErrorReasons.TRANSACTION_FAILURE, content: error.error || error });
             });
+
             if (tx) {
-                const response = await this.watchExtendResponse(tx, options).catch(error => {
-                    error.extendeRefId = tx.id;
-                    reject(error);
-                });
-                if (response) {
-                    response.extendeRefId = tx.id;
+                try {
+                    const response = await this.watchExtendResponse(tx, minLedgerIndex, options)
                     resolve(response);
+                } catch (error) {
+                    reject(error);
                 }
             }
         });
@@ -13657,6 +13675,8 @@ const { XflHelpers } = __nccwpck_require__(3243);
 const { FirestoreHandler } = __nccwpck_require__(9718);
 const { StateHelpers } = __nccwpck_require__(3860);
 const { UtilHelpers } = __nccwpck_require__(6687);
+const { TransactionHelper } = __nccwpck_require__(7071);
+const { EncryptionHelper } = __nccwpck_require__(4832);
 
 module.exports = {
     RegistryClient,
@@ -13675,6 +13695,8 @@ module.exports = {
     StateHelpers,
     FirestoreHandler,
     UtilHelpers,
+    TransactionHelper,
+    EncryptionHelper,
     HookStateKeys,
     MemoTypes
 }
@@ -14352,6 +14374,9 @@ class XrplAccount {
         return xrpl.parseAccountRootFlags((await this.getInfo()).Flags);
     }
 
+    async getAccountTrx(minLedgerIndex = -1, maxLedgerIndex = -1, isForward = true) {
+        return await this.xrplApi.getAccountTrx(this.address, { ledger_index_min: minLedgerIndex, ledger_index_max: maxLedgerIndex, forward: isForward});
+    }
 
     setAccountFields(fields, options = {}) {
         /**
@@ -14714,6 +14739,16 @@ const { DefaultValues } = __nccwpck_require__(8262);
 const { TransactionHelper } = __nccwpck_require__(7071);
 const { XrplApiEvents } = __nccwpck_require__(3307);
 
+const MAX_PAGE_LIMIT = 400;
+const API_REQ_TYPE = {
+    NAMESPACE_ENTRIES: 'namespace_entries',
+    ACCOUNT_OBJECTS: 'account_objects',
+    LINES: 'lines',
+    ACCOUNT_NFTS: 'account_nfts',
+    OFFERS: 'offers',
+    TRANSACTIONS: 'transactions'
+}
+
 class XrplApi {
 
     #rippledServer;
@@ -14836,6 +14871,29 @@ class XrplApi {
         }
     }
 
+    async #requestWithPaging(requestObj, requestType) {
+        let res = [];
+        let checked = false;
+        let resp;
+        let count = requestObj?.limit;
+
+        while ((!count || count > 0) && (!checked || resp?.result?.marker)) {
+            checked = true;
+            requestObj.limit = count ? Math.min(count, MAX_PAGE_LIMIT) : MAX_PAGE_LIMIT;
+            if (resp?.result?.marker)
+                requestObj.marker = resp?.result?.marker;
+            else
+                delete requestObj.marker;
+            resp = (await this.#client.request(requestObj));
+            if (resp?.result && resp?.result[requestType])
+                res.push(...resp.result[requestType]);
+            if (count)
+                count -= requestObj.limit;
+        }
+
+        return res;
+    }
+
     on(event, handler) {
         this.#events.on(event, handler);
     }
@@ -14884,17 +14942,11 @@ class XrplApi {
     }
 
     async getAccountObjects(address, options) {
-        const resp = (await this.#client.request({ command: 'account_objects', account: address, ...options }));
-        if (resp?.result?.account_objects)
-            return resp.result.account_objects;
-        return [];
+        return this.#requestWithPaging({ command: 'account_objects', account: address, ...options }, API_REQ_TYPE.ACCOUNT_OBJECTS);
     }
 
     async getNamespaceEntries(address, namespaceId, options) {
-        const resp = (await this.#client.request({ command: 'account_namespace', account: address, namespace_id: namespaceId, ...options }));
-        if (resp?.result?.namespace_entries)
-            return resp.result.namespace_entries;
-        return [];
+        return this.#requestWithPaging({ command: 'account_namespace', account: address, namespace_id: namespaceId, ...options }, API_REQ_TYPE.NAMESPACE_ENTRIES);
     }
 
     async getNftOffers(address, options) {
@@ -14904,24 +14956,19 @@ class XrplApi {
     }
 
     async getTrustlines(address, options) {
-        const resp = (await this.#client.request({ command: 'account_lines', account: address, ledger_index: "validated", ...options }));
-        if (resp?.result?.lines)
-            return resp.result.lines;
-        return [];
+        return this.#requestWithPaging({ command: 'account_lines', account: address, ledger_index: "validated", ...options }, API_REQ_TYPE.LINES);
+    }
+
+    async getAccountTrx(address, options) {
+        return this.#requestWithPaging({ command: 'account_tx', account: address, ...options }, API_REQ_TYPE.TRANSACTIONS);
     }
 
     async getNfts(address, options) {
-        const resp = (await this.#client.request({ command: 'account_nfts', account: address, ledger_index: "validated", ...options }));
-        if (resp?.result?.account_nfts)
-            return resp.result.account_nfts;
-        return [];
+        return this.#requestWithPaging({ command: 'account_nfts', account: address, ledger_index: "validated", ...options }, API_REQ_TYPE.ACCOUNT_NFTS);
     }
 
     async getOffers(address, options) {
-        const resp = (await this.#client.request({ command: 'account_offers', account: address, ledger_index: "validated", ...options }));
-        if (resp?.result?.offers)
-            return resp.result.offers;
-        return [];
+        return this.#requestWithPaging({ command: 'account_offers', account: address, ledger_index: "validated", ...options }, API_REQ_TYPE.OFFERS);
     }
 
     async getLedgerEntry(index, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "evernode-js-client",
-    "version": "0.4.50",
+    "version": "0.4.53",
     "dependencies": {
         "elliptic": "6.5.4",
         "ripple-address-codec": "4.2.0",