evernode-js-client 0.4.46 → 0.4.50

package/index.js

@@ -11708,7 +11708,7 @@ const codec = __nccwpck_require__(597);
 const { Buffer } = __nccwpck_require__(4300);
 const { XrplApi } = __nccwpck_require__(1850);
 const { XrplAccount } = __nccwpck_require__(9329);
-const { XrplApiEvents } = __nccwpck_require__(3307);
+const { XrplApiEvents, XrplConstants } = __nccwpck_require__(3307);
 const { EvernodeEvents, MemoTypes, MemoFormats, EvernodeConstants, HookStateKeys } = __nccwpck_require__(9849);
 const { DefaultValues } = __nccwpck_require__(8262);
 const { EncryptionHelper } = __nccwpck_require__(4832);
@@ -12055,23 +12055,52 @@ class BaseEvernodeClient {
                 }
             }
         }
+        else if (tx.Memos.length >= 1 &&
+            tx.Memos[0].type === MemoTypes.DEAD_HOST_PRUNE && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+
+            const addrsBuf = Buffer.from(tx.Memos[0].data, 'hex');
+
+            return {
+                name: EvernodeEvents.DeadHostPrune,
+                data: {
+                    transaction: tx,
+                    host: codec.encodeAccountID(addrsBuf)
+                }
+            }
+        }
 
         return null;
     }
 
     // To get Host details from Hook States.
     async getHostInfo(hostAddress = this.xrplAcc.address) {
-        const hostAddrStatekey = StateHelpers.generateHostAddrStateKey(hostAddress);
-        const stateLedgerIndex = StateHelpers.getHookStateIndex(this.registryAddress, hostAddrStatekey);
-        const ledgerEntry = await this.xrplApi.getLedgerEntry(stateLedgerIndex);
-        const curMomentStartIdx = await this.getMomentStartIndex();
-        if (ledgerEntry?.HookStateData) {
-            const hostAddrStateData = ledgerEntry.HookStateData;
-            const hostInfo = StateHelpers.decodeHostAddressState(Buffer.from(hostAddrStatekey, 'hex'), Buffer.from(hostAddrStateData, 'hex'));
-            hostInfo.active = (hostInfo.lastHeartbeatLedger > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
-                (hostInfo.lastHeartbeatLedger >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
-                (hostInfo.lastHeartbeatLedger > 0))
-            return hostInfo;
+        try {
+            const addrStateKey = StateHelpers.generateHostAddrStateKey(hostAddress);
+            const addrStateIndex = StateHelpers.getHookStateIndex(this.registryAddress, addrStateKey);
+            const addrLedgerEntry = await this.xrplApi.getLedgerEntry(addrStateIndex);
+            const addrStateData = addrLedgerEntry?.HookStateData;
+            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))
+
+                const nftIdStatekey = StateHelpers.generateTokenIdStateKey(addrStateDecoded.nfTokenId);
+                const nftIdStateIndex = StateHelpers.getHookStateIndex(this.registryAddress, nftIdStatekey);
+                const nftIdLedgerEntry = await this.xrplApi.getLedgerEntry(nftIdStateIndex);
+
+                const nftIdStateData = nftIdLedgerEntry?.HookStateData;
+                if (nftIdStateData) {
+                    const nftIdStateDecoded = StateHelpers.decodeTokenIdState(Buffer.from(nftIdStateData, 'hex'));
+                    return { ...addrStateDecoded, ...nftIdStateDecoded };
+                }
+            }
+        }
+        catch (e) {
+            // If the exeption is entryNotFound from Rippled there's no entry for the host, So return null.
+            if (e?.data?.error !== 'entryNotFound')
+                throw e;
         }
 
         return null;
@@ -12129,6 +12158,22 @@ class BaseEvernodeClient {
 
         return fullHostList;
     }
+
+    // To prune an inactive host/
+    async pruneDeadHost(hostAddress) {
+        if (this.xrplAcc.address === this.registryAddress)
+            throw 'Invalid function call';
+
+        let memoData = Buffer.allocUnsafe(20);
+        codec.decodeAccountID(hostAddress).copy(memoData);
+
+        await this.xrplAcc.makePayment(this.registryAddress,
+            XrplConstants.MIN_XRP_AMOUNT,
+            XrplConstants.XRP,
+            null,
+            [{ type: MemoTypes.DEAD_HOST_PRUNE, format: MemoFormats.HEX, data: memoData.toString('hex') }]);
+
+    }
 }
 
 module.exports = {
@@ -12513,7 +12558,8 @@ const RegistryEvents = {
     HostRegUpdated: EvernodeEvents.HostRegUpdated,
     RegistryInitialized: EvernodeEvents.RegistryInitialized,
     Heartbeat: EvernodeEvents.Heartbeat,
-    HostPostDeregistered: EvernodeEvents.HostPostDeregistered
+    HostPostDeregistered: EvernodeEvents.HostPostDeregistered,
+    DeadHostPrune: EvernodeEvents.DeadHostPrune
 }
 
 class RegistryClient extends BaseEvernodeClient {
@@ -12621,9 +12667,9 @@ class TenantClient extends BaseEvernodeClient {
 
         // Check whether active.
         const hostInfo = await this.getHostInfo(host.address);
-        if (hostInfo)
+        if (!hostInfo)
             throw { reason: ErrorReasons.HOST_INVALID, error: "Host is not registered." };
-        else if (hostInfo.active)
+        else if (!hostInfo.active)
             throw { reason: ErrorReasons.HOST_INACTIVE, error: "Host is not active." };
 
         return host;
@@ -13178,7 +13224,8 @@ const MemoTypes = {
     EXTEND_REF: 'evnExtendRef',
     REGISTRY_INIT: 'evnInitialize',
     REFUND: 'evnRefund',
-    REFUND_REF: 'evnRefundRef'
+    REFUND_REF: 'evnRefundRef',
+    DEAD_HOST_PRUNE: 'evnDeadHostPrune'
 }
 
 const MemoFormats = {
@@ -13216,11 +13263,15 @@ const HookStateKeys = {
     HOST_HEARTBEAT_FREQ: "4556520100000000000000000000000000000000000000000000000000000006",
     PURCHASER_TARGET_PRICE: "4556520100000000000000000000000000000000000000000000000000000007",
     LEASE_ACQUIRE_WINDOW: "4556520100000000000000000000000000000000000000000000000000000008",
+    REWARD_CONFIGURATION: "4556520100000000000000000000000000000000000000000000000000000009",
+    MAX_TOLERABLE_DOWNTIME: "455652010000000000000000000000000000000000000000000000000000000A",
+
     // Singleton
     HOST_COUNT: "4556523200000000000000000000000000000000000000000000000000000000",
     MOMENT_BASE_IDX: "4556523300000000000000000000000000000000000000000000000000000000",
     HOST_REG_FEE: "4556523400000000000000000000000000000000000000000000000000000000",
     MAX_REG: "4556523500000000000000000000000000000000000000000000000000000000",
+    REWARD_INFO: "4556523600000000000000000000000000000000000000000000000000000000",
 
     // Prefixes
     PREFIX_HOST_TOKENID: "45565202",
@@ -13240,7 +13291,8 @@ const EvernodeEvents = {
     ExtendError: "ExtendError",
     HostRegUpdated: "HostRegUpdated",
     HostReRegistered: "HostReRegistered",
-    RegistryInitialized: "RegistryInitialized"
+    RegistryInitialized: "RegistryInitialized",
+    DeadHostPrune: "DeadHostPrune"
 }
 
 module.exports = {
@@ -13313,6 +13365,13 @@ class FirestoreHandler {
             case 'floatValue':
                 parsed = parseFloat(value[type]);
                 break;
+            case 'mapValue':
+                parsed = {};
+                for (const [subKey, subValue] of Object.entries(value[type].fields)) {
+                    const field = this.#parseValue(subKey, subValue);
+                    parsed[field.key] = field.value;
+                }
+                break;
             default:
                 parsed = value[type];
                 break;
@@ -13520,9 +13579,32 @@ class FirestoreHandler {
     convertValue(key, value) {
         // Convert camelCase to snake_case.
         const uKey = key.replace(/([A-Z])/g, function (g) { return `_${g[0].toLocaleLowerCase()}`; });
-        const type = `${typeof value !== 'number' ? 'string' : (value % 1 > 0 ? 'float' : 'integer')}Value`;
+        let val = {};
+        let type
+        switch (typeof value) {
+            case 'number':
+                type = (value % 1 > 0 ? 'float' : 'integer');
+                val = value;
+                break;
+            case 'object':
+                type = 'map';
+                val = {
+                    fields: {}
+                }
+                // Prepare the firestore write body with the given data object.
+                for (const [subKey, subValue] of Object.entries(value)) {
+                    const field = this.convertValue(subKey, subValue);
+                    val.fields[field.key] = field.value;
+                }
+                break;
+            default:
+                type = 'string';
+                val = value;
+                break;
+        }
+        type = `${type}Value`;
         let obj = {};
-        obj[type] = value;
+        obj[type] = val;
         return { key: uKey, value: obj };
     }
 
@@ -13608,7 +13690,18 @@ const { HookStateKeys, EvernodeConstants } = __nccwpck_require__(9849);
 const { XflHelpers } = __nccwpck_require__(3243);
 const crypto = __nccwpck_require__(6113);
 
-const NFTOKEN_PREFIX = '00080000';
+const NFTOKEN_PREFIX = '00000000';
+
+const EPOCH_OFFSET = 0;
+const SAVED_MOMENT_OFFSET = 1;
+const PREV_MOMENT_ACTIVE_HOST_COUNT_OFFSET = 5;
+const CUR_MOMENT_ACTIVE_HOST_COUNT_OFFSET = 9;
+const EPOCH_POOL_OFFSET = 13;
+
+const EPOCH_COUNT_OFFSET = 0;
+const FIRST_EPOCH_REWARD_QUOTA_OFFSET = 1;
+const EPOCH_REWARD_AMOUNT_OFFSET = 5;
+const REWARD_START_MOMENT_OFFSET = 9;
 
 const HOST_TOKEN_ID_OFFSET = 0;
 const HOST_COUNTRY_CODE_OFFSET = 32;
@@ -13664,7 +13757,7 @@ class StateHelpers {
     static decodeTokenIdState(stateDataBuf) {
         return {
             address: codec.encodeAccountID(stateDataBuf.slice(HOST_ADDRESS_OFFSET, HOST_CPU_MODEL_NAME_OFFSET)),
-            cpuModelName: stateDataBuf.slice(HOST_CPU_MODEL_NAME_OFFSET, HOST_CPU_COUNT_OFFSET).toString(),
+            cpuModelName: stateDataBuf.slice(HOST_CPU_MODEL_NAME_OFFSET, HOST_CPU_COUNT_OFFSET).toString().replace(/\x00+$/, ''), // Remove trailing \x00 characters.
             cpuCount: stateDataBuf.readUInt16BE(HOST_CPU_COUNT_OFFSET),
             cpuMHz: stateDataBuf.readUInt16BE(HOST_CPU_SPEED_OFFSET),
             cpuMicrosec: stateDataBuf.readUInt32BE(HOST_CPU_MICROSEC_OFFSET),
@@ -13747,6 +13840,38 @@ class StateHelpers {
                 value: val
             }
         }
+        else if (Buffer.from(HookStateKeys.REWARD_CONFIGURATION, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: {
+                    epochCount: stateData.readUInt8(EPOCH_COUNT_OFFSET),
+                    firstEpochRewardQuota: stateData.readUInt32BE(FIRST_EPOCH_REWARD_QUOTA_OFFSET),
+                    epochRewardAmount: stateData.readUInt32BE(EPOCH_REWARD_AMOUNT_OFFSET),
+                    rewardStartMoment: stateData.readUInt32BE(REWARD_START_MOMENT_OFFSET)
+                }
+            }
+        }
+        else if (Buffer.from(HookStateKeys.REWARD_INFO, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.SIGLETON,
+                key: hexKey,
+                value: {
+                    epoch: stateData.readUInt8(EPOCH_OFFSET),
+                    savedMoment: stateData.readUInt32BE(SAVED_MOMENT_OFFSET),
+                    prevMomentActiveHostCount: stateData.readUInt32BE(PREV_MOMENT_ACTIVE_HOST_COUNT_OFFSET),
+                    curMomentActiveHostCount: stateData.readUInt32BE(CUR_MOMENT_ACTIVE_HOST_COUNT_OFFSET),
+                    epochPool: XflHelpers.toString(stateData.readBigInt64BE(EPOCH_POOL_OFFSET))
+                }
+            }
+        }
+        else if (Buffer.from(HookStateKeys.MAX_TOLERABLE_DOWNTIME, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: stateData.readUInt16BE()
+            }
+        }
         else
             throw { type: 'Validation Error', message: 'Invalid state key.' };
     }
@@ -13768,7 +13893,8 @@ 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.HOST_REG_FEE, 'hex').compare(stateKey) === 0 ||
-            Buffer.from(HookStateKeys.MAX_REG, 'hex').compare(stateKey) === 0) {
+            Buffer.from(HookStateKeys.MAX_REG, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.REWARD_INFO, 'hex').compare(stateKey) === 0) {
             return {
                 key: hexKey,
                 type: this.STATE_TYPES.SIGLETON
@@ -13781,7 +13907,9 @@ class StateHelpers {
             Buffer.from(HookStateKeys.HOST_HEARTBEAT_FREQ, 'hex').compare(stateKey) ||
             Buffer.from(HookStateKeys.MINT_LIMIT, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.FIXED_REG_FEE, 'hex').compare(stateKey) === 0 ||
-            Buffer.from(HookStateKeys.LEASE_ACQUIRE_WINDOW, '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) {
             return {
                 key: hexKey,
                 type: this.STATE_TYPES.CONFIGURATION
@@ -13807,7 +13935,7 @@ class StateHelpers {
         let buf = Buffer.allocUnsafe(9);
         buf.writeUInt8(STATE_KEY_TYPES.HOST_ADDR);
         for (let i = 0; i < HOST_ADDR_KEY_ZERO_COUNT; i++) {
-            buf.writeUInt8(0, i+1);
+            buf.writeUInt8(0, i + 1);
         }
 
         const addrBuf = Buffer.from(codec.decodeAccountID(address), "hex");
@@ -13815,7 +13943,7 @@ class StateHelpers {
         return stateKeyBuf.toString('hex').toUpperCase();
     }
 
-    static  getHookStateIndex(hookAccount, stateKey, hookNamespace = EvernodeConstants.HOOK_NAMESPACE) {
+    static getHookStateIndex(hookAccount, stateKey, hookNamespace = EvernodeConstants.HOOK_NAMESPACE) {
         const typeBuf = Buffer.allocUnsafe(2);
         typeBuf.writeInt16BE(HOOK_STATE_LEDGER_TYPE_PREFIX);
 
@@ -14798,7 +14926,7 @@ class XrplApi {
 
     async getLedgerEntry(index, options) {
         const resp = (await this.#client.request({ command: 'ledger_entry', index: index, ledger_index: "validated", ...options }));
-            return resp?.result?.node;
+        return resp?.result?.node;
     }
 
     async submitAndVerify(tx, options) {

package/package.json

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