evernode-js-client 0.5.1 → 0.5.3

package/index.js

@@ -11846,29 +11846,29 @@ class BaseEvernodeClient {
     }
 
     /**
-     * Get the moment from the given XRP ledger index. (1 Moment - 1190 XRP ledgers).
-     * @param {number} ledgerIndex [Optional] Ledger index to get the moment value.
-     * @returns The moment of the given XPR ledger index as 'number'. Returns current moment if XRP ledger index is not given.
-     */
-    async getMoment(ledgerIndex = null) {
-        const lv = ledgerIndex || this.xrplApi.ledgerIndex;
-        const m = Math.floor((lv - this.config.momentBaseIdx) / this.config.momentSize);
-
-        await Promise.resolve(); // Awaiter placeholder for future async requirements.
+     * Get the moment from the given index (timestamp).
+     * @param {number} index [Optional] Index (timestamp) to get the moment value.
+     * @returns The moment of the given index (timestamp) as 'number'. Returns current moment if index (timestamp) is not given.
+     */
+    async getMoment(index = null) {
+        const i = index || UtilHelpers.getCurrentUnixTime();
+        const m = this.config.momentBaseInfo.baseTransitionMoment + Math.floor((i - this.config.momentBaseInfo.baseIdx) / this.config.momentSize);
+        await Promise.resolve();
         return m;
     }
 
     /**
-     * Get start XRP ledger index of the moment (of the given XRPL index).
-     * @param {number} ledgerIndex [Optional] Ledger index to get the moment value.
-     * @returns The XRP ledger index of the moment (of the given XRPL index) as a 'number'. Returns the current moment's start XRP ledger index if ledger index parameter is not given.
+     * Get start index (timestamp) of the moment.
+     * @param {number} index [Optional] Index (timestamp) to get the moment value.
+     * @returns The index (timestamp) of the moment as a 'number'. Returns the current moment's start index (timestamp) if ledger index parameter is not given.
      */
-    async getMomentStartIndex(ledgerIndex = null) {
-        const lv = ledgerIndex || this.xrplApi.ledgerIndex;
-        const m = Math.floor((lv - this.config.momentBaseIdx) / this.config.momentSize);
+    async getMomentStartIndex(index = null) {
+        const i = index || UtilHelpers.getCurrentUnixTime();
+
+        const m = Math.floor((i - this.config.momentBaseInfo.baseIdx) / this.config.momentSize);
 
         await Promise.resolve(); // Awaiter placeholder for future async requirements.
-        return this.config.momentBaseIdx + (m * this.config.momentSize);
+        return this.config.momentBaseInfo.baseIdx + (m * this.config.momentSize);
     }
 
     /**
@@ -11883,19 +11883,23 @@ class BaseEvernodeClient {
             hostRegFee: HookStateKeys.HOST_REG_FEE,
             momentSize: HookStateKeys.MOMENT_SIZE,
             hostHeartbeatFreq: HookStateKeys.HOST_HEARTBEAT_FREQ,
-            momentBaseIdx: HookStateKeys.MOMENT_BASE_IDX,
+            momentBaseInfo: HookStateKeys.MOMENT_BASE_INFO,
             purchaserTargetPrice: HookStateKeys.PURCHASER_TARGET_PRICE,
             leaseAcquireWindow: HookStateKeys.LEASE_ACQUIRE_WINDOW,
             rewardInfo: HookStateKeys.REWARD_INFO,
-            rewardConfiguaration: HookStateKeys.REWARD_CONFIGURATION,
-            hostCount: HookStateKeys.HOST_COUNT
+            rewardConfiguration: HookStateKeys.REWARD_CONFIGURATION,
+            hostCount: HookStateKeys.HOST_COUNT,
+            momentTransitInfo: HookStateKeys.MOMENT_TRANSIT_INFO
         }
         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;
+            const stateDataBin = StateHelpers.getStateData(states, value);
+            if (stateDataBin) {
+                const stateData = Buffer.from(StateHelpers.getStateData(states, value), 'hex');
+                const decoded = StateHelpers.decodeStateData(stateKey, stateData);
+                config[key] = decoded.value;
+            }
         }
         return config;
     }
@@ -12159,9 +12163,9 @@ class BaseEvernodeClient {
             if (addrStateData) {
                 const addrStateDecoded = StateHelpers.decodeHostAddressState(Buffer.from(addrStateKey, 'hex'), Buffer.from(addrStateData, 'hex'));
                 const curMomentStartIdx = await this.getMomentStartIndex();
-                addrStateDecoded.active = (addrStateDecoded.lastHeartbeatLedger > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
-                    (addrStateDecoded.lastHeartbeatLedger >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
-                    (addrStateDecoded.lastHeartbeatLedger > 0))
+                addrStateDecoded.active = (addrStateDecoded.lastHeartbeatIndex > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
+                    (addrStateDecoded.lastHeartbeatIndex >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
+                    (addrStateDecoded.lastHeartbeatIndex > 0))
 
                 const nftIdStatekey = StateHelpers.generateTokenIdStateKey(addrStateDecoded.nfTokenId);
                 const nftIdStateIndex = StateHelpers.getHookStateIndex(this.registryAddress, nftIdStatekey);
@@ -12195,9 +12199,9 @@ class BaseEvernodeClient {
         const curMomentStartIdx = await this.getMomentStartIndex();
         // Populate the host active status.
         (hosts.nextPageToken ? hosts.data : hosts).forEach(h => {
-            h.active = (h.lastHeartbeatLedger > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
-                (h.lastHeartbeatLedger >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
-                (h.lastHeartbeatLedger > 0))
+            h.active = (h.lastHeartbeatIndex > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
+                (h.lastHeartbeatIndex >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
+                (h.lastHeartbeatIndex > 0))
         });
         return hosts;
     }
@@ -12804,41 +12808,47 @@ class TenantClient extends BaseEvernodeClient {
      * @returns An object including transaction details,instance info, and acquireReference Id.
      */
     async watchAcquireResponse(tx, options = {}) {
-            console.log(`Waiting for acquire response... (txHash: ${tx.id})`);
+        console.log(`Waiting for acquire response... (txHash: ${tx.id})`);
 
+        return new Promise(async (resolve, reject) => {
+            let rejected = false;
             const failTimeout = setTimeout(() => {
-                throw({ error: ErrorCodes.ACQUIRE_ERR, reason: ErrorReasons.TIMEOUT });
+                rejected = true;
+                reject({ error: ErrorCodes.ACQUIRE_ERR, reason: ErrorReasons.TIMEOUT });
             }, options.timeout || DEFAULT_WAIT_TIMEOUT);
-    
+
             let relevantTx = null;
-            while (!relevantTx) {
+            while (!rejected && !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;
-                        }
+                    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));
+                await new Promise(resolveSleep => setTimeout(resolveSleep, 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
-                })
+
+            if (!rejected) {
+                if (relevantTx?.name === TenantEvents.AcquireSuccess) {
+                    resolve({
+                        transaction: relevantTx?.data.transaction,
+                        instance: relevantTx?.data.payload.content,
+                        acquireRefId: relevantTx?.data.acquireRefId
+                    });
+                } else if (relevantTx?.name === TenantEvents.AcquireError) {
+                    reject({
+                        error: ErrorCodes.ACQUIRE_ERR,
+                        transaction: relevantTx?.data.transaction,
+                        reason: relevantTx?.data.reason,
+                        acquireRefId: relevantTx?.data.acquireRefId
+                    });
+                }
             }
+        });
     }
 
     /**
@@ -12887,38 +12897,44 @@ class TenantClient extends BaseEvernodeClient {
     async watchExtendResponse(tx, options = {}) {
         console.log(`Waiting for extend lease response... (txHash: ${tx.id})`);
 
-        const failTimeout = setTimeout(() => {
-            throw({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.TIMEOUT });
-        }, options.timeout || DEFAULT_WAIT_TIMEOUT);
-
-        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 === TenantEvents.ExtendSuccess || res?.name === TenantEvents.ExtendError) && res?.data?.extendRefId === tx.id) {
-                    clearTimeout(failTimeout);
-                    relevantTx = res;
-                    break;
+        return new Promise(async (resolve, reject) => {
+            let rejected = false;
+            const failTimeout = setTimeout(() => {
+                rejected = true;
+                reject({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.TIMEOUT });
+            }, options.timeout || DEFAULT_WAIT_TIMEOUT);
+
+            let relevantTx = null;
+            while (!rejected && !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 === TenantEvents.ExtendSuccess || res?.name === TenantEvents.ExtendError) && res?.data?.extendRefId === tx.id) {
+                        clearTimeout(failTimeout);
+                        relevantTx = res;
+                        break;
+                    }
                 }
+                await new Promise(resolveSleep => setTimeout(resolveSleep, 1000));
             }
-            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
-            })
-        }
+            if (!rejected) {
+                if (relevantTx?.name === TenantEvents.ExtendSuccess) {
+                    resolve({
+                        transaction: relevantTx?.data.transaction,
+                        expiryMoment: relevantTx?.data.expiryMoment,
+                        extendeRefId: relevantTx?.data.extendRefId
+                    });
+                } else if (relevantTx?.name === TenantEvents.ExtendError) {
+                    reject({
+                        error: ErrorCodes.EXTEND_ERR,
+                        transaction: relevantTx?.data.transaction,
+                        reason: relevantTx?.data.reason
+                    });
+                }
+            }
+        });
     }
 
     /**
@@ -13422,10 +13438,11 @@ const HookStateKeys = {
     LEASE_ACQUIRE_WINDOW: "4556520100000000000000000000000000000000000000000000000000000008",
     REWARD_CONFIGURATION: "4556520100000000000000000000000000000000000000000000000000000009",
     MAX_TOLERABLE_DOWNTIME: "455652010000000000000000000000000000000000000000000000000000000A",
+    MOMENT_TRANSIT_INFO: "455652010000000000000000000000000000000000000000000000000000000B",
 
     // Singleton
     HOST_COUNT: "4556523200000000000000000000000000000000000000000000000000000000",
-    MOMENT_BASE_IDX: "4556523300000000000000000000000000000000000000000000000000000000",
+    MOMENT_BASE_INFO: "4556523300000000000000000000000000000000000000000000000000000000",
     HOST_REG_FEE: "4556523400000000000000000000000000000000000000000000000000000000",
     MAX_REG: "4556523500000000000000000000000000000000000000000000000000000000",
     REWARD_INFO: "4556523600000000000000000000000000000000000000000000000000000000",
@@ -13864,6 +13881,14 @@ const FIRST_EPOCH_REWARD_QUOTA_OFFSET = 1;
 const EPOCH_REWARD_AMOUNT_OFFSET = 5;
 const REWARD_START_MOMENT_OFFSET = 9;
 
+const TRANSIT_IDX_OFFSET = 0;
+const TRANSIT_MOMENT_SIZE_OFFSET = 8;
+const TRANSIT_MOMENT_TYPE_OFFSET = 10;
+
+const MOMENT_BASE_POINT_OFFSET = 0;
+const MOMENT_AT_TRANSITION_OFFSET = 8;
+const MOMENT_TYPE_OFFSET = 12;
+
 const HOST_TOKEN_ID_OFFSET = 0;
 const HOST_COUNTRY_CODE_OFFSET = 32;
 const HOST_RESERVED_OFFSET = 34;
@@ -13874,6 +13899,7 @@ const HOST_TOT_INS_COUNT_OFFSET = 84;
 const HOST_ACT_INS_COUNT_OFFSET = 88;
 const HOST_HEARTBEAT_LEDGER_IDX_OFFSET = 92;
 const HOST_VERSION_OFFSET = 100;
+const HOST_REG_TIMESTAMP_OFFSET = 103;
 
 const HOST_ADDRESS_OFFSET = 0;
 const HOST_CPU_MODEL_NAME_OFFSET = 20;
@@ -13888,6 +13914,11 @@ const STATE_KEY_TYPES = {
     HOST_ADDR: 3
 }
 
+const MOMENT_TYPES = {
+    LEDGER: 0,
+    TIMESTAMP: 1
+}
+
 const EVERNODE_PREFIX = 'EVR';
 const HOST_ADDR_KEY_ZERO_COUNT = 8;
 const HOOK_STATE_LEDGER_TYPE_PREFIX = 118; // Decimal value of ASCII 'v'
@@ -13900,8 +13931,20 @@ class StateHelpers {
         CONFIGURATION: 'configuration'
     }
 
+    static timeLines = {
+        SEC: "SEC"
+    }
+
+    static getStateData(states, key) {
+        const state = states.find(s => key === s.key);
+        if (!state)
+            return null;
+
+        return state.data;
+    }
+
     static decodeHostAddressState(stateKeyBuf, stateDataBuf) {
-        return {
+        let data = {
             address: codec.encodeAccountID(stateKeyBuf.slice(12)),
             nfTokenId: stateDataBuf.slice(HOST_TOKEN_ID_OFFSET, HOST_COUNTRY_CODE_OFFSET).toString('hex').toUpperCase(),
             countryCode: stateDataBuf.slice(HOST_COUNTRY_CODE_OFFSET, HOST_RESERVED_OFFSET).toString(),
@@ -13910,9 +13953,12 @@ class StateHelpers {
             registrationFee: Number(stateDataBuf.readBigUInt64BE(HOST_REG_FEE_OFFSET)),
             maxInstances: stateDataBuf.readUInt32BE(HOST_TOT_INS_COUNT_OFFSET),
             activeInstances: stateDataBuf.readUInt32BE(HOST_ACT_INS_COUNT_OFFSET),
-            lastHeartbeatLedger: Number(stateDataBuf.readBigUInt64BE(HOST_HEARTBEAT_LEDGER_IDX_OFFSET)),
-            version: `${stateDataBuf.readUInt8(HOST_VERSION_OFFSET)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 1)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 2)}`
+            lastHeartbeatIndex: Number(stateDataBuf.readBigUInt64BE(HOST_HEARTBEAT_LEDGER_IDX_OFFSET)),
+            version: `${stateDataBuf.readUInt8(HOST_VERSION_OFFSET)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 1)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 2)}`,
         }
+        if (stateDataBuf.length > HOST_REG_TIMESTAMP_OFFSET)
+            data.registrationTimestamp = Number(stateDataBuf.readBigUInt64BE(HOST_REG_TIMESTAMP_OFFSET));
+        return data;
     }
 
     static decodeTokenIdState(stateDataBuf) {
@@ -13955,11 +14001,15 @@ class StateHelpers {
                 value: stateData.readUInt32BE()
             }
         }
-        else if (Buffer.from(HookStateKeys.MOMENT_BASE_IDX, 'hex').compare(stateKey) === 0) {
+        else if (Buffer.from(HookStateKeys.MOMENT_BASE_INFO, 'hex').compare(stateKey) === 0) {
             return {
                 type: this.StateTypes.SIGLETON,
                 key: hexKey,
-                value: Number(stateData.readBigInt64BE())
+                value: {
+                    baseIdx: Number(stateData.readBigUInt64BE(MOMENT_BASE_POINT_OFFSET)),
+                    baseTransitionMoment: stateData.length > MOMENT_AT_TRANSITION_OFFSET ? stateData.readUInt32BE(MOMENT_AT_TRANSITION_OFFSET) : 0,
+                    momentType: (stateData.length <= MOMENT_TYPE_OFFSET || stateData.readUInt8(MOMENT_TYPE_OFFSET) === MOMENT_TYPES.LEDGER) ? 'ledger' : 'timestamp'
+                }
             }
         }
         else if (Buffer.from(HookStateKeys.HOST_REG_FEE, 'hex').compare(stateKey) === 0 || Buffer.from(HookStateKeys.MAX_REG, 'hex').compare(stateKey) === 0) {
@@ -14033,6 +14083,18 @@ class StateHelpers {
                 value: stateData.readUInt16BE()
             }
         }
+        else if (Buffer.from(HookStateKeys.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0) {
+            Buffer.alloc(1).readUInt8()
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: {
+                    transitionIndex: Number(stateData.readBigInt64BE(TRANSIT_IDX_OFFSET)),
+                    momentSize: stateData.readUInt16BE(TRANSIT_MOMENT_SIZE_OFFSET),
+                    momentType: stateData.readUInt8(TRANSIT_MOMENT_TYPE_OFFSET) === MOMENT_TYPES.LEDGER ? 'ledger' : 'timestamp'
+                }
+            }
+        }
         else
             throw { type: 'Validation Error', message: 'Invalid state key.' };
     }
@@ -14052,7 +14114,7 @@ class StateHelpers {
             };
         }
         else if (Buffer.from(HookStateKeys.HOST_COUNT, 'hex').compare(stateKey) === 0 ||
-            Buffer.from(HookStateKeys.MOMENT_BASE_IDX, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MOMENT_BASE_INFO, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.HOST_REG_FEE, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.MAX_REG, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.REWARD_INFO, 'hex').compare(stateKey) === 0) {
@@ -14070,7 +14132,8 @@ class StateHelpers {
             Buffer.from(HookStateKeys.FIXED_REG_FEE, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.LEASE_ACQUIRE_WINDOW, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.REWARD_CONFIGURATION, 'hex').compare(stateKey) === 0 ||
-            Buffer.from(HookStateKeys.MAX_TOLERABLE_DOWNTIME, 'hex').compare(stateKey) === 0) {
+            Buffer.from(HookStateKeys.MAX_TOLERABLE_DOWNTIME, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0) {
             return {
                 key: hexKey,
                 type: this.STATE_TYPES.CONFIGURATION
@@ -14209,14 +14272,6 @@ const { EvernodeConstants, ErrorReasons } = __nccwpck_require__(9849);
 // Utility helper functions.
 class UtilHelpers {
 
-    static getStateData(states, key) {
-        const state = states.find(s => key === s.key);
-        if (!state)
-            throw { code: ErrorReasons.NO_STATE_KEY, error: `State key '${key}' not found.` };
-
-        return state.data;
-    }
-
     static readUInt(buf, base = 32, isBE = true) {
         buf = Buffer.from(buf);
         switch (base) {
@@ -14245,6 +14300,16 @@ class UtilHelpers {
             leaseAmount: parseFloat(XflHelpers.toString(uriBuf.readBigInt64BE(prefixLen + 2 + halfToSLen)))
         }
     }
+
+    static getCurrentUnixTime(format = "sec") {
+        const time = Date.now();
+        switch (format) {
+            case "sec":
+                return Math.floor(time / 1000);
+            default:
+                return time;
+        }
+    }
 }
 
 module.exports = {
@@ -15110,6 +15175,14 @@ class XrplApi {
         return this.#requestWithPaging({ command: 'account_offers', account: address, ledger_index: "validated", ...options }, API_REQ_TYPE.OFFERS);
     }
 
+    async getSellOffers(nfTokenId, options = {}) {
+        return this.#requestWithPaging({ command: 'nft_sell_offers', nft_id: nfTokenId, ledger_index: "validated", ...options }, API_REQ_TYPE.OFFERS);
+    }
+
+    async getBuyOffers(nfTokenId, options = {}) {
+        return this.#requestWithPaging({ command: 'nft_buy_offers', nft_id: nfTokenId, ledger_index: "validated", ...options }, API_REQ_TYPE.OFFERS);
+    }
+
     async getLedgerEntry(index, options) {
         const resp = (await this.#client.request({ command: 'ledger_entry', index: index, ledger_index: "validated", ...options }));
         return resp?.result?.node;

package/package.json

@@ -6,7 +6,7 @@
     ],
     "homepage": "https://github.com/HotPocketDev/evernode-js-client",
     "license": "MIT",
-    "version": "0.5.1",
+    "version": "0.5.3",
     "dependencies": {
         "elliptic": "6.5.4",
         "ripple-address-codec": "4.2.0",