evernode-js-client 0.5.2 → 0.5.4

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;
     }
@@ -12141,6 +12145,17 @@ class BaseEvernodeClient {
                 }
             }
         }
+        else if (tx.Memos.length >= 1 &&
+            tx.Memos[0].type === MemoTypes.HOST_REBATE) {
+
+            return {
+                name: EvernodeEvents.HostRebate,
+                data: {
+                    transaction: tx,
+                    host: tx.Account
+                }
+            }
+        }
 
         return null;
     }
@@ -12159,9 +12174,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 +12210,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;
     }
@@ -12622,6 +12637,15 @@ class HostClient extends BaseEvernodeClient {
             options.transactionOptions);
     }
 
+    async requestRebate(options = {}) {
+        return this.xrplAcc.makePayment(this.registryAddress,
+            XrplConstants.MIN_XRP_AMOUNT,
+            XrplConstants.XRP,
+            null,
+            [{ type: MemoTypes.HOST_REBATE, format: "", data: "" }],
+            options.transactionOptions);
+    }
+
     getLeaseNFTokenIdPrefix() {
         let buf = Buffer.allocUnsafe(24);
         buf.writeUInt16BE(1);
@@ -12652,7 +12676,8 @@ const RegistryEvents = {
     RegistryInitialized: EvernodeEvents.RegistryInitialized,
     Heartbeat: EvernodeEvents.Heartbeat,
     HostPostDeregistered: EvernodeEvents.HostPostDeregistered,
-    DeadHostPrune: EvernodeEvents.DeadHostPrune
+    DeadHostPrune: EvernodeEvents.DeadHostPrune,
+    HostRebate: EvernodeEvents.HostRebate
 }
 
 class RegistryClient extends BaseEvernodeClient {
@@ -13394,7 +13419,8 @@ const MemoTypes = {
     REGISTRY_INIT: 'evnInitialize',
     REFUND: 'evnRefund',
     REFUND_REF: 'evnRefundRef',
-    DEAD_HOST_PRUNE: 'evnDeadHostPrune'
+    DEAD_HOST_PRUNE: 'evnDeadHostPrune',
+    HOST_REBATE: 'evnHostRebate'
 }
 
 const MemoFormats = {
@@ -13434,10 +13460,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",
@@ -13461,7 +13488,8 @@ const EvernodeEvents = {
     HostRegUpdated: "HostRegUpdated",
     HostReRegistered: "HostReRegistered",
     RegistryInitialized: "RegistryInitialized",
-    DeadHostPrune: "DeadHostPrune"
+    DeadHostPrune: "DeadHostPrune",
+    HostRebate: "HostRebate"
 }
 
 module.exports = {
@@ -13876,6 +13904,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;
@@ -13886,6 +13922,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;
@@ -13900,6 +13937,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'
@@ -13912,8 +13954,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(),
@@ -13922,9 +13976,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) {
@@ -13967,11 +14024,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) {
@@ -14045,6 +14106,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.' };
     }
@@ -14064,7 +14137,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) {
@@ -14082,7 +14155,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
@@ -14221,14 +14295,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) {
@@ -14257,6 +14323,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 = {

package/package.json

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