evernode-js-client 0.5.8 → 0.5.10

package/index.js

@@ -11732,6 +11732,7 @@ const { EventEmitter } = __nccwpck_require__(6170);
 const { UtilHelpers } = __nccwpck_require__(6687);
 const { FirestoreHandler } = __nccwpck_require__(9718);
 const { StateHelpers } = __nccwpck_require__(3860);
+const { EvernodeHelpers } = __nccwpck_require__(2523);
 
 class BaseEvernodeClient {
 
@@ -11905,7 +11906,8 @@ class BaseEvernodeClient {
             rewardInfo: HookStateKeys.REWARD_INFO,
             rewardConfiguration: HookStateKeys.REWARD_CONFIGURATION,
             hostCount: HookStateKeys.HOST_COUNT,
-            momentTransitInfo: HookStateKeys.MOMENT_TRANSIT_INFO
+            momentTransitInfo: HookStateKeys.MOMENT_TRANSIT_INFO,
+            registryMaxTrxEmitFee: HookStateKeys.MAX_TRX_EMISSION_FEE
         }
         let config = {};
         for (const [key, value] of Object.entries(configStateKeys)) {
@@ -12036,17 +12038,13 @@ class BaseEvernodeClient {
             }
         }
         else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.HOST_REG && tx.Memos[0].format === MemoFormats.TEXT && tx.Memos[0].data) {
+            tx.Memos[0].type === MemoTypes.HOST_REG && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
 
-            const parts = tx.Memos[0].data.split(';');
             return {
                 name: EvernodeEvents.HostRegistered,
                 data: {
                     transaction: tx,
-                    host: tx.Account,
-                    token: parts[0],
-                    instanceSize: parts[1],
-                    location: parts[2]
+                    host: tx.Account
                 }
             }
         }
@@ -12134,17 +12132,13 @@ class BaseEvernodeClient {
             }
         }
         else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.HOST_UPDATE_INFO && tx.Memos[0].format === MemoFormats.TEXT && tx.Memos[0].data) {
-
-            const specs = tx.Memos[0].data.split(';');
+            tx.Memos[0].type === MemoTypes.HOST_UPDATE_INFO && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
 
             return {
                 name: EvernodeEvents.HostRegUpdated,
                 data: {
                     transaction: tx,
-                    host: tx.Account,
-                    version: specs[specs.length - 1],
-                    specs: specs,
+                    host: tx.Account
                 }
             }
         }
@@ -12237,13 +12231,16 @@ class BaseEvernodeClient {
     async getHosts(filters = null, pageSize = null, nextPageToken = null) {
         const hosts = await this.#firestoreHandler.getHosts(filters, pageSize, nextPageToken);
         const curMomentStartIdx = await this.getMomentStartIndex();
-        // Populate the host active status.
-        (hosts.nextPageToken ? hosts.data : hosts).forEach(h => {
-            h.active = (h.lastHeartbeatIndex > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
-                (h.lastHeartbeatIndex >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
-                (h.lastHeartbeatIndex > 0))
-        });
-        return hosts;
+        
+        return await Promise.all((hosts.nextPageToken ? hosts.data : hosts).map(async host => {
+            const hostAcc = new XrplAccount(host.address);
+            host.domain = await hostAcc.getDomain();
+
+            host.active = (host.lastHeartbeatIndex > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
+            (host.lastHeartbeatIndex >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
+            (host.lastHeartbeatIndex > 0));
+            return host;
+        }));
     }
 
     /**
@@ -12303,11 +12300,28 @@ class BaseEvernodeClient {
         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') }]);
+        // To obtain registration NFT Page Keylet and index.
+        const hostAcc = new XrplAccount(hostAddress, null, { xrplApi: this.xrplApi });
+        const regNFT = (await hostAcc.getNfts()).find(n => n.URI.startsWith(EvernodeConstants.NFT_PREFIX_HEX) && n.Issuer === this.registryAddress);
+        if (regNFT) {
+            // Check whether the token was actually issued from Evernode registry contract.
+            const issuerHex = regNFT.NFTokenID.substr(8, 40);
+            const issuerAddr = codec.encodeAccountID(Buffer.from(issuerHex, 'hex'));
+            if (issuerAddr == this.registryAddress) {
+                const nftPageDataBuf = await EvernodeHelpers.getNFTPageAndLocation(regNFT.NFTokenID, hostAcc, this.xrplApi);
+
+                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') },
+                        { type: MemoTypes.HOST_REGISTRY_REF, format: MemoFormats.HEX, data: nftPageDataBuf.toString('hex') }
+                    ]);
+            } else
+                throw "Invalid Registration NFT."
+        } else
+            throw "No Registration NFT was found for the Host account."
 
     }
 }
@@ -12340,6 +12354,29 @@ const HostEvents = {
     ExtendLease: EvernodeEvents.ExtendLease
 }
 
+const HOST_COUNTRY_CODE_MEMO_OFFSET = 0;
+const HOST_CPU_MICROSEC_MEMO_OFFSET = 2;
+const HOST_RAM_MB_MEMO_OFFSET = 6;
+const HOST_DISK_MB_MEMO_OFFSET = 10;
+const HOST_TOT_INS_COUNT_MEMO_OFFSET = 14;
+const HOST_CPU_MODEL_NAME_MEMO_OFFSET = 18;
+const HOST_CPU_COUNT_MEMO_OFFSET = 58;
+const HOST_CPU_SPEED_MEMO_OFFSET = 60;
+const HOST_DESCRIPTION_MEMO_OFFSET = 62;
+const HOST_EMAIL_ADDRESS_MEMO_OFFSET = 88;
+const HOST_REG_MEMO_SIZE = 128;
+
+const HOST_UPDATE_TOKEN_ID_MEMO_OFFSET = 0;
+const HOST_UPDATE_COUNTRY_CODE_MEMO_OFFSET = 32;
+const HOST_UPDATE_CPU_MICROSEC_MEMO_OFFSET = 34;
+const HOST_UPDATE_RAM_MB_MEMO_OFFSET = 38;
+const HOST_UPDATE_DISK_MB_MEMO_OFFSET = 42;
+const HOST_UPDATE_TOT_INS_COUNT_MEMO_OFFSET = 46;
+const HOST_UPDATE_ACT_INS_COUNT_MEMO_OFFSET = 50;
+const HOST_UPDATE_DESCRIPTION_MEMO_OFFSET = 54;
+const HOST_UPDATE_VERSION_MEMO_OFFSET = 80;
+const HOST_UPDATE_MEMO_SIZE = 83;
+
 class HostClient extends BaseEvernodeClient {
 
     constructor(xrpAddress, xrpSecret, options = {}) {
@@ -12459,8 +12496,8 @@ class HostClient extends BaseEvernodeClient {
             throw "description should consist of 0-26 ascii characters except ';'";
 
         else if (!emailAddress || !(/[a-z0-9]+@[a-z]+.[a-z]{2,3}/.test(emailAddress)) || (emailAddress.length > 40))
-            throw "Email address should be valid and can not have more than 40 characters.";    
-        
+            throw "Email address should be valid and can not have more than 40 characters.";
+
         if (await this.isRegistered())
             throw "Host already registered.";
 
@@ -12500,12 +12537,24 @@ class HostClient extends BaseEvernodeClient {
             console.log("No initiated transfers were found.");
         }
 
-        const memoData = `${countryCode};${cpuMicroSec};${ramMb};${diskMb};${totalInstanceCount};${cpuModel};${cpuCount};${cpuSpeed};${description};${emailAddress}`
+        // <country_code(2)><cpu_microsec(4)><ram_mb(4)><disk_mb(4)><no_of_total_instances(4)><cpu_model(40)><cpu_count(2)><cpu_speed(2)><description(26)><email_address(40)>
+        const memoBuf = Buffer.alloc(HOST_REG_MEMO_SIZE, 0);
+        Buffer.from(countryCode.substr(0, 2), "utf-8").copy(memoBuf, HOST_COUNTRY_CODE_MEMO_OFFSET);
+        memoBuf.writeUInt32BE(cpuMicroSec, HOST_CPU_MICROSEC_MEMO_OFFSET);
+        memoBuf.writeUInt32BE(ramMb, HOST_RAM_MB_MEMO_OFFSET);
+        memoBuf.writeUInt32BE(diskMb, HOST_DISK_MB_MEMO_OFFSET);
+        memoBuf.writeUInt32BE(totalInstanceCount, HOST_TOT_INS_COUNT_MEMO_OFFSET);
+        Buffer.from(cpuModel.substr(0, 40), "utf-8").copy(memoBuf, HOST_CPU_MODEL_NAME_MEMO_OFFSET);
+        memoBuf.writeUInt16BE(cpuCount, HOST_CPU_COUNT_MEMO_OFFSET);
+        memoBuf.writeUInt16BE(cpuSpeed, HOST_CPU_SPEED_MEMO_OFFSET);
+        Buffer.from(description.substr(0, 26), "utf-8").copy(memoBuf, HOST_DESCRIPTION_MEMO_OFFSET);
+        Buffer.from(emailAddress.substr(0, 40), "utf-8").copy(memoBuf, HOST_EMAIL_ADDRESS_MEMO_OFFSET);
+
         const tx = await this.xrplAcc.makePayment(this.registryAddress,
             (transferredNFTokenId) ? EvernodeConstants.NOW_IN_EVRS : this.config.hostRegFee.toString(),
             EvernodeConstants.EVR,
             this.config.evrIssuerAddress,
-            [{ type: MemoTypes.HOST_REG, format: MemoFormats.TEXT, data: memoData }],
+            [{ type: MemoTypes.HOST_REG, format: MemoFormats.HEX, data: memoBuf.toString('hex') }],
             options.transactionOptions);
 
         console.log('Waiting for the sell offer')
@@ -12550,11 +12599,18 @@ class HostClient extends BaseEvernodeClient {
             throw "Host not registered."
 
         const regNFT = await this.getRegistrationNft();
+
+        // To obtain registration NFT Page Keylet and index.
+        const nftPageDataBuf = await EvernodeHelpers.getNFTPageAndLocation(regNFT.NFTokenID, this.xrplAcc, this.xrplApi);
+
         await this.xrplAcc.makePayment(this.registryAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [{ type: MemoTypes.HOST_DEREG, format: MemoFormats.HEX, data: regNFT.NFTokenID }],
+            [
+                { type: MemoTypes.HOST_DEREG, format: MemoFormats.HEX, data: regNFT.NFTokenID },
+                { type: MemoTypes.HOST_REGISTRY_REF, format: MemoFormats.HEX, data: nftPageDataBuf.toString('hex') }
+            ],
             options.transactionOptions);
 
         console.log('Waiting for the buy offer')
@@ -12593,21 +12649,62 @@ class HostClient extends BaseEvernodeClient {
     }
 
     async updateRegInfo(activeInstanceCount = null, version = null, totalInstanceCount = null, tokenID = null, countryCode = null, cpuMicroSec = null, ramMb = null, diskMb = null, description = null, options = {}) {
-        const dataStr = `${tokenID ? tokenID : ''};${countryCode ? countryCode : ''};${cpuMicroSec ? cpuMicroSec : ''};${ramMb ? ramMb : ''};${diskMb ? diskMb : ''};${totalInstanceCount ? totalInstanceCount : ''};${activeInstanceCount !== undefined ? activeInstanceCount : ''};${description ? description : ''};${version ? version : ''}`;
+        // <token_id(32)><country_code(2)><cpu_microsec(4)><ram_mb(4)><disk_mb(4)><total_instance_count(4)><active_instances(4)><description(26)><version(3)>
+        const memoBuf = Buffer.alloc(HOST_UPDATE_MEMO_SIZE, 0);
+        if (tokenID)
+            Buffer.from(tokenID.substr(0, 32), "hex").copy(memoBuf, HOST_UPDATE_TOKEN_ID_MEMO_OFFSET);
+        if (countryCode)
+            Buffer.from(countryCode.substr(0, 2), "utf-8").copy(memoBuf, HOST_UPDATE_COUNTRY_CODE_MEMO_OFFSET);
+        if (cpuMicroSec)
+            memoBuf.writeUInt32BE(cpuMicroSec, HOST_UPDATE_CPU_MICROSEC_MEMO_OFFSET);
+        if (ramMb)
+            memoBuf.writeUInt32BE(ramMb, HOST_UPDATE_RAM_MB_MEMO_OFFSET);
+        if (diskMb)
+            memoBuf.writeUInt32BE(diskMb, HOST_UPDATE_DISK_MB_MEMO_OFFSET);
+        if (totalInstanceCount)
+            memoBuf.writeUInt32BE(totalInstanceCount, HOST_UPDATE_TOT_INS_COUNT_MEMO_OFFSET);
+        if (activeInstanceCount)
+            memoBuf.writeUInt32BE(activeInstanceCount, HOST_UPDATE_ACT_INS_COUNT_MEMO_OFFSET);
+        if (description)
+            Buffer.from(description.substr(0, 26), "utf-8").copy(memoBuf, HOST_UPDATE_DESCRIPTION_MEMO_OFFSET);
+        if (version) {
+            const components = version.split('.').map(v => parseInt(v));
+            if (components.length != 3)
+                throw 'Invalid version format.';
+            memoBuf.writeUInt8(components[0], HOST_UPDATE_VERSION_MEMO_OFFSET);
+            memoBuf.writeUInt8(components[1], HOST_UPDATE_VERSION_MEMO_OFFSET + 1);
+            memoBuf.writeUInt8(components[2], HOST_UPDATE_VERSION_MEMO_OFFSET + 2);
+        }
+
+        // To obtain registration NFT Page Keylet and index.
+        if (!tokenID)
+            tokenID = (await this.getRegistrationNft()).NFTokenID;
+        const nftPageDataBuf = await EvernodeHelpers.getNFTPageAndLocation(tokenID, this.xrplAcc, this.xrplApi);
+
         return await this.xrplAcc.makePayment(this.registryAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [{ type: MemoTypes.HOST_UPDATE_INFO, format: MemoFormats.TEXT, data: dataStr }],
+            [
+                { type: MemoTypes.HOST_UPDATE_INFO, format: MemoFormats.HEX, data: memoBuf.toString('hex') },
+                { type: MemoTypes.HOST_REGISTRY_REF, format: MemoFormats.HEX, data: nftPageDataBuf.toString('hex') }
+            ],
             options.transactionOptions);
     }
 
     async heartbeat(options = {}) {
+        // To obtain registration NFT Page Keylet and index.
+        const regNFT = await this.getRegistrationNft();
+        const nftPageDataBuf = await EvernodeHelpers.getNFTPageAndLocation(regNFT.NFTokenID, this.xrplAcc, this.xrplApi);
+
         return this.xrplAcc.makePayment(this.registryAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [{ type: MemoTypes.HEARTBEAT, format: "", data: "" }],
+            [
+                { type: MemoTypes.HEARTBEAT, format: "", data: "" },
+                { type: MemoTypes.HOST_REGISTRY_REF, format: MemoFormats.HEX, data: nftPageDataBuf.toString('hex') }
+            ],
             options.transactionOptions);
     }
 
@@ -12691,11 +12788,19 @@ class HostClient extends BaseEvernodeClient {
     }
 
     async requestRebate(options = {}) {
+
+        // To obtain registration NFT Page Keylet and index.
+        const regNFT = await this.getRegistrationNft();
+        const nftPageDataBuf = await EvernodeHelpers.getNFTPageAndLocation(regNFT.NFTokenID, this.xrplAcc, this.xrplApi);
+
         return this.xrplAcc.makePayment(this.registryAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [{ type: MemoTypes.HOST_REBATE, format: "", data: "" }],
+            [
+                { type: MemoTypes.HOST_REBATE, format: "", data: "" },
+                { type: MemoTypes.HOST_REGISTRY_REF, format: MemoFormats.HEX, data: nftPageDataBuf.toString('hex') }
+            ],
             options.transactionOptions);
     }
 
@@ -12726,16 +12831,21 @@ class HostClient extends BaseEvernodeClient {
             }
         }
 
-        const regNFT = (await this.xrplAcc.getNfts()).find(n => n.URI.startsWith(EvernodeConstants.NFT_PREFIX_HEX) && n.Issuer === this.registryAddress);
-
         let memoData = Buffer.allocUnsafe(20);
         codec.decodeAccountID(transfereeAddress).copy(memoData);
 
+        // To obtain registration NFT Page Keylet and index.
+        const regNFT = await this.getRegistrationNft();
+        const nftPageDataBuf = await EvernodeHelpers.getNFTPageAndLocation(regNFT.NFTokenID, this.xrplAcc, this.xrplApi);
+
         await this.xrplAcc.makePayment(this.registryAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [{ type: MemoTypes.HOST_TRANSFER, format: MemoFormats.HEX, data: memoData.toString('hex') }],
+            [
+                { type: MemoTypes.HOST_TRANSFER, format: MemoFormats.HEX, data: memoData.toString('hex') },
+                { type: MemoTypes.HOST_REGISTRY_REF, format: MemoFormats.HEX, data: nftPageDataBuf.toString('hex') }
+            ],
             options.transactionOptions);
 
         let offer = null;
@@ -12767,6 +12877,19 @@ class HostClient extends BaseEvernodeClient {
 
         await this.xrplAcc.sellNft(offer.index);
     }
+
+    async hasPendingTransfer() {
+
+        // Check the availability of TRANSFEREE state for this host address.
+        const stateTransfereeAddrKey = StateHelpers.generateTransfereeAddrStateKey(this.xrplAcc.address);
+        const stateTransfereeAddrIndex = StateHelpers.getHookStateIndex(this.registryAddress, stateTransfereeAddrKey);
+        const res = await this.xrplApi.getLedgerEntry(stateTransfereeAddrIndex);
+
+        if (res && res?.HookStateData)
+            return true;
+
+        return false;
+    }
 }
 
 module.exports = {
@@ -13593,7 +13716,8 @@ const MemoTypes = {
     REFUND: 'evnRefund',
     REFUND_REF: 'evnRefundRef',
     DEAD_HOST_PRUNE: 'evnDeadHostPrune',
-    HOST_REBATE: 'evnHostRebate'
+    HOST_REBATE: 'evnHostRebate',
+    HOST_REGISTRY_REF: 'evnHostRegistryRef'
 }
 
 const MemoFormats = {
@@ -13634,6 +13758,8 @@ const HookStateKeys = {
     REWARD_CONFIGURATION: "4556520100000000000000000000000000000000000000000000000000000009",
     MAX_TOLERABLE_DOWNTIME: "455652010000000000000000000000000000000000000000000000000000000A",
     MOMENT_TRANSIT_INFO: "455652010000000000000000000000000000000000000000000000000000000B",
+    MAX_TRX_EMISSION_FEE: "455652010000000000000000000000000000000000000000000000000000000C",
+
 
     // Singleton
     HOST_COUNT: "4556523200000000000000000000000000000000000000000000000000000000",
@@ -13683,6 +13809,7 @@ module.exports = {
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const { EvernodeConstants } = __nccwpck_require__(9849);
+const NFT_PAGE_LEDGER_ENTRY_TYPE_HEX = '0050';
 
 class EvernodeHelpers {
     static async getLeaseOffers(xrplAcc) {
@@ -13691,6 +13818,36 @@ class EvernodeHelpers {
         const nftOffers = (await xrplAcc.getNftOffers())?.filter(offer => (offer.Flags == 1 && hostTokenIDs.includes(offer.NFTokenID))); // Filter only sell offers
         return nftOffers;
     }
+
+    static async getNFTPageAndLocation(nfTokenId, xrplAcc, xrplApi, buffer = true) {
+
+        const nftPageApprxKeylet = xrplAcc.generateKeylet('nftPage', { nfTokenId: nfTokenId });
+        const nftPageMaxKeylet = xrplAcc.generateKeylet('nftPageMax');
+        // Index is the last 32 bytes of the Keylet (Last 64 HEX characters).
+        let page = await xrplApi.getLedgerEntry(nftPageMaxKeylet.substring(4, 68));
+        while (page?.PreviousPageMin) {
+            // Compare the low 96 bits. (Last 24 HEX characters).
+            if (Number('0x' + page.index.substring(40, 64)) >= Number('0x' + nftPageApprxKeylet.substring(40, 64))) {
+                // Check the existence of the NFToken
+                let token = page.NFTokens.find(n => n.NFToken.NFTokenID == nfTokenId);
+                if (!token) {
+                    page = await xrplApi.getLedgerEntry(page.PreviousPageMin);
+                }
+                else
+                    break;
+            }
+        }
+
+        const nftPageInfo = page.NFTokens.map((n, loc) => { return { NFTPage: NFT_PAGE_LEDGER_ENTRY_TYPE_HEX + page.index, NFTokenID: n.NFToken.NFTokenID, location: loc } }).find(n => n.NFTokenID == nfTokenId);
+        if (buffer) {
+            let locBuf = Buffer.allocUnsafe(2);
+            locBuf.writeUInt16BE(nftPageInfo.location);
+            // <NFT_PAGE_KEYLET(34 bytes)><LOCATION(2 bytes)>
+            return Buffer.concat([Buffer.from(nftPageInfo.NFTPage, "hex"), locBuf]);
+        }
+
+        return nftPageInfo;
+    }
 }
 
 module.exports = {
@@ -14107,7 +14264,7 @@ const HOST_CPU_SPEED_OFFSET = 62;
 const HOST_CPU_MICROSEC_OFFSET = 64;
 const HOST_RAM_MB_OFFSET = 68;
 const HOST_DISK_MB_OFFSET = 72;
-const EMAIL_ADDRESS_OFFSET = 112;
+const HOST_EMAIL_ADDRESS_OFFSET = 76;
 
 const PREV_HOST_ADDRESS_OFFSET = 0;
 const TRANSFER_LEDGER_IDX_OFFSET = 20;
@@ -14134,6 +14291,7 @@ const HOST_ADDR_KEY_ZERO_COUNT = 8;
 const TRANSFEREE_ADDR_KEY_ZERO_COUNT = 8;
 const HOOK_STATE_LEDGER_TYPE_PREFIX = 118; // Decimal value of ASCII 'v'
 const PENDING_TRANSFER = 1;
+const HOST_EMAIL_ADDRESS_LEN = 40;
 
 class StateHelpers {
     static StateTypes = {
@@ -14184,7 +14342,9 @@ class StateHelpers {
             cpuMicrosec: stateDataBuf.readUInt32BE(HOST_CPU_MICROSEC_OFFSET),
             ramMb: stateDataBuf.readUInt32BE(HOST_RAM_MB_OFFSET),
             diskMb: stateDataBuf.readUInt32BE(HOST_DISK_MB_OFFSET),
-            email: (stateDataBuf.length > HOST_DISK_MB_OFFSET ? stateDataBuf.slice(HOST_DISK_MB_OFFSET, EMAIL_ADDRESS_OFFSET).toString() : "")
+            email: (stateDataBuf.length > HOST_EMAIL_ADDRESS_OFFSET ?
+                stateDataBuf.slice(HOST_EMAIL_ADDRESS_OFFSET, HOST_EMAIL_ADDRESS_OFFSET + HOST_EMAIL_ADDRESS_LEN).toString().toString().replace(/\0/g, '') :
+                "")
         }
     }
 
@@ -14329,6 +14489,13 @@ class StateHelpers {
                 }
             }
         }
+        else if (Buffer.from(HookStateKeys.MAX_TRX_EMISSION_FEE, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: Number(stateData.readBigUInt64BE())
+            }
+        }
         else
             throw { type: 'Validation Error', message: 'Invalid state key.' };
     }
@@ -14347,6 +14514,12 @@ class StateHelpers {
                 type: this.StateTypes.TOKEN_ID
             };
         }
+        else if (Buffer.from(HookStateKeys.PREFIX_TRANSFEREE_ADDR, 'hex').compare(stateKey, 0, 4) === 0) {
+            return {
+                key: hexKey,
+                type: this.StateTypes.TRANSFEREE_ADDR
+            };
+        }
         else if (Buffer.from(HookStateKeys.HOST_COUNT, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.MOMENT_BASE_INFO, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.HOST_REG_FEE, 'hex').compare(stateKey) === 0 ||
@@ -14367,7 +14540,8 @@ class StateHelpers {
             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.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0) {
+            Buffer.from(HookStateKeys.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MAX_TRX_EMISSION_FEE, 'hex').compare(stateKey) === 0) {
             return {
                 key: hexKey,
                 type: this.STATE_TYPES.CONFIGURATION
@@ -14721,18 +14895,27 @@ class XrplAccount {
     #subscribed = false;
     #txStreamHandler;
 
-    constructor(address, secret = null, options = {}) {
+    constructor(address = null, secret = null, options = {}) {
+        if (!address && !secret)
+            throw "Both address and secret cannot be empty";
+
+        this.address = address;
+        this.secret = secret;
         this.xrplApi = options.xrplApi || DefaultValues.xrplApi;
 
         if (!this.xrplApi)
             throw "XrplAccount: xrplApi not specified.";
 
-        this.address = address;
-
-        this.secret = secret;
-        if (this.secret) {
+        if (!this.address && this.secret) {
             this.wallet = xrpl.Wallet.fromSeed(this.secret);
-            this.address= this.wallet.classicAddress;
+            this.address = this.wallet.classicAddress;
+        } else if (this.secret) {
+            const keypair = kp.deriveKeypair(this.secret);
+            const derivedPubKeyAddress = kp.deriveAddress(keypair.publicKey);
+            if (this.address == derivedPubKeyAddress)
+                this.wallet = xrpl.Wallet.fromSeed(this.secret);
+            else
+                this.wallet = xrpl.Wallet.fromSeed(this.secret, { masterAddress: this.address });
         }
 
         this.#txStreamHandler = (eventName, tx, error) => {
@@ -14759,6 +14942,10 @@ class XrplAccount {
         return kp.deriveKeypair(this.secret);
     }
 
+    async exists() {
+        return await this.xrplApi.isAccountExists(this.address);
+    }
+
     async getInfo() {
         return await this.xrplApi.getAccountInfo(this.address);
     }
@@ -14832,6 +15019,10 @@ class XrplAccount {
         return await this.xrplApi.getAccountTrx(this.address, { ledger_index_min: minLedgerIndex, ledger_index_max: maxLedgerIndex, forward: isForward });
     }
 
+    async hasValidKeyPair() {
+        return await this.xrplApi.isValidKeyForAddress(this.wallet.publicKey, this.address);
+    }
+
     setAccountFields(fields, options = {}) {
         /**
          * Example for fields
@@ -15055,6 +15246,29 @@ class XrplAccount {
         return this.#submitAndVerifyTransaction(owner ? { ...tx, Owner: owner } : tx, options);
     }
 
+    generateKeylet(type, data = {}) {
+        switch (type) {
+            case 'nftPage': {
+                const accIdHex = (codec.decodeAccountID(this.address)).toString('hex').toUpperCase();
+                const tokenPortion = data?.nfTokenId.substr(40, 64);
+                return '0050' + accIdHex + tokenPortion;
+            }
+
+            case 'nftPageMax': {
+                const accIdHex = (codec.decodeAccountID(this.address)).toString('hex').toUpperCase();
+                return '0050' + accIdHex + 'F'.repeat(24);
+            }
+
+            case 'nftPageMin': {
+                const accIdHex = (codec.decodeAccountID(this.address)).toString('hex').toUpperCase();
+                return '0050' + accIdHex + '0'.repeat(24);
+            }
+
+            default:
+                return null;
+        }
+    }
+
     async subscribe() {
         // Subscribe only once. Otherwise event handlers will be duplicated.
         if (this.#subscribed)
@@ -15390,6 +15604,17 @@ class XrplApi {
             return derivedPubKeyAddress === address || (regularKey && derivedPubKeyAddress === regularKey);
     }
 
+    async isAccountExists(address) {
+        try {
+            await this.#client.request({ command: 'account_info', account: address });
+            return true;
+        }
+        catch (e) {
+            if (e.data.error === 'actNotFound') return false;
+            else throw e;
+        }
+    }
+
     async getAccountInfo(address) {
         const resp = (await this.#client.request({ command: 'account_info', account: address }));
         return resp?.result?.account_data;
@@ -15434,8 +15659,15 @@ 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;
+        try {
+            const resp = (await this.#client.request({ command: 'ledger_entry', index: index, ledger_index: "validated", ...options }));
+            return resp?.result?.node;
+
+        } catch (e) {
+            if (e?.data?.error === 'entryNotFound')
+                return null;
+            throw e;
+        }
     }
 
     async submitAndVerify(tx, options) {

package/package.json

@@ -6,7 +6,7 @@
     ],
     "homepage": "https://github.com/HotPocketDev/evernode-js-client",
     "license": "MIT",
-    "version": "0.5.8",
+    "version": "0.5.10",
     "dependencies": {
         "elliptic": "6.5.4",
         "libsodium-wrappers": "0.7.10",