evernode-js-client 0.4.48 → 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,6 +12055,19 @@ 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;
     }
@@ -12076,11 +12089,11 @@ class BaseEvernodeClient {
                 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};
+                    return { ...addrStateDecoded, ...nftIdStateDecoded };
                 }
             }
         }
@@ -12145,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 = {
@@ -12529,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 {
@@ -13194,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 = {
@@ -13232,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",
@@ -13256,7 +13291,8 @@ const EvernodeEvents = {
     ExtendError: "ExtendError",
     HostRegUpdated: "HostRegUpdated",
     HostReRegistered: "HostReRegistered",
-    RegistryInitialized: "RegistryInitialized"
+    RegistryInitialized: "RegistryInitialized",
+    DeadHostPrune: "DeadHostPrune"
 }
 
 module.exports = {
@@ -13329,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;
@@ -13536,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 };
     }
 
@@ -13626,6 +13692,17 @@ const crypto = __nccwpck_require__(6113);
 
 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;
 const HOST_RESERVED_OFFSET = 34;
@@ -13763,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.' };
     }
@@ -13784,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
@@ -13797,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
@@ -13823,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");
@@ -13831,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);
 

package/package.json

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