evernode-js-client 0.6.44 → 0.6.46

package/index.js

@@ -59582,7 +59582,7 @@ const { Buffer } = __nccwpck_require__(4300);
 const { XrplApi } = __nccwpck_require__(1850);
 const { XrplAccount } = __nccwpck_require__(9329);
 const { XrplApiEvents, XrplConstants } = __nccwpck_require__(3307);
-const { EvernodeEvents, EventTypes, MemoFormats, EvernodeConstants, HookStateKeys, HookParamKeys, RegExp } = __nccwpck_require__(9849);
+const { EvernodeEvents, EventTypes, MemoFormats, EvernodeConstants, HookStateKeys, HookParamKeys, RegExp, ReputationConstants } = __nccwpck_require__(9849);
 const { Defaults } = __nccwpck_require__(8262);
 const { EncryptionHelper } = __nccwpck_require__(4832);
 const { EventEmitter } = __nccwpck_require__(6170);
@@ -59593,10 +59593,12 @@ const { HookHelpers } = __nccwpck_require__(4675);
 const xrpl = __nccwpck_require__(4666);
 
 const CANDIDATE_PROPOSE_HASHES_PARAM_OFFSET = 0;
-const CANDIDATE_PROPOSE_KEYLETS_PARAM_OFFSET = 96;
-const CANDIDATE_PROPOSE_UNIQUE_ID_PARAM_OFFSET = 198;
-const CANDIDATE_PROPOSE_SHORT_NAME_PARAM_OFFSET = 230;
-const CANDIDATE_PROPOSE_PARAM_SIZE = 250;
+const CANDIDATE_PROPOSE_KEYLETS_PARAM_OFFSET = 128;
+const CANDIDATE_PROPOSE_UNIQUE_ID_PARAM_OFFSET = 264;
+const CANDIDATE_PROPOSE_SHORT_NAME_PARAM_OFFSET = 296;
+const CANDIDATE_PROPOSE_PARAM_SIZE = 316;
+
+const MAX_HOOK_PARAM_SIZE = 256;
 
 const DUD_HOST_CANDID_ADDRESS_OFFSET = 12;
 
@@ -59766,6 +59768,7 @@ class BaseEvernodeClient {
         const configStateKeys = {
             registryAddress: HookStateKeys.REGISTRY_ADDR,
             heartbeatAddress: HookStateKeys.HEARTBEAT_ADDR,
+            reputationAddress: HookStateKeys.REPUTATION_ADDR,
             evrIssuerAddress: HookStateKeys.EVR_ISSUER_ADDR,
             foundationAddress: HookStateKeys.FOUNDATION_ADDR,
             hostRegFee: HookStateKeys.HOST_REG_FEE,
@@ -60482,6 +60485,74 @@ class BaseEvernodeClient {
         return null;
     }
 
+    /**
+     * Get reputation info of given host.
+     * @param {string} hostReputationAddress Host's reputation address.
+     * @param {number} moment (optional) Moment to get reputation info for.
+     * @returns Reputation info object.
+     */
+    async _getReputationInfoByAddress(hostReputationAddress, moment = null) {
+        try {
+            const addrStateKey = StateHelpers.generateHostReputationAddrStateKey(hostReputationAddress);
+            const addrStateIndex = StateHelpers.getHookStateIndex(this.config.reputationAddress, addrStateKey);
+            const addrLedgerEntry = await this.xrplApi.getLedgerEntry(addrStateIndex);
+            const addrStateData = addrLedgerEntry?.HookStateData;
+            let data = {};
+
+            if (addrStateData) {
+                const addrStateDecoded = StateHelpers.decodeHostReputationAddressState(Buffer.from(addrStateKey, 'hex'), Buffer.from(addrStateData, 'hex'));
+                data = addrStateDecoded;
+            }
+
+            const repMoment = moment ?? await this.getMoment();
+            const orderedAddrStateKey = StateHelpers.generateHostReputationOrderAddressStateKey(hostReputationAddress, repMoment);
+            const orderedAddrStateIndex = StateHelpers.getHookStateIndex(this.config.reputationAddress, orderedAddrStateKey);
+            const orderedAddrLedgerEntry = await this.xrplApi.getLedgerEntry(orderedAddrStateIndex);
+            const orderedAddrStateData = orderedAddrLedgerEntry?.HookStateData;
+
+            if (orderedAddrStateData) {
+                const orderedAddrStateDecoded = StateHelpers.decodeHostReputationOrderAddressState(Buffer.from(orderedAddrStateKey, 'hex'), Buffer.from(orderedAddrStateData, 'hex'));
+                data = { ...data, ...orderedAddrStateDecoded };
+            }
+
+            const hostRepAcc = new XrplAccount(hostReputationAddress, null, { xrplApi: this.xrplApi });
+            const [msgKey, rep] = await Promise.all([
+                hostRepAcc.getMessageKey(),
+                hostRepAcc.getDomain()]);
+
+            if (msgKey && rep && rep.length > 0) {
+                const hostAddress = UtilHelpers.deriveAddress(msgKey);
+                const hostAcc = new XrplAccount(hostAddress, null, { xrplApi: this.xrplApi });
+
+                const repBuf = Buffer.from(rep, 'hex');
+                const publicKey = repBuf.slice(0, ReputationConstants.REP_INFO_PEER_PORT_OFFSET).toString('hex').toLocaleLowerCase();
+                const peerPort = repBuf.readUInt16LE(ReputationConstants.REP_INFO_PEER_PORT_OFFSET);
+                const instanceMoment = (repBuf.length > ReputationConstants.REP_INFO_MOMENT_OFFSET) ? Number(repBuf.readBigUInt64LE(ReputationConstants.REP_INFO_MOMENT_OFFSET)) : null;
+                const domain = await hostAcc.getDomain();
+
+                if (instanceMoment === repMoment) {
+                    data = {
+                        ...data,
+                        contract: {
+                            domain: domain,
+                            pubkey: publicKey,
+                            peerPort: peerPort
+                        }
+                    }
+                }
+            }
+
+            return Object.keys(data).length > 0 ? data : null;
+        }
+        catch (e) {
+            // If the exception is entryNotFound from Rippled there's no entry for the host, So return null.
+            if (e?.data?.error !== 'entryNotFound')
+                throw e;
+        }
+
+        return null;
+    }
+
     /**
      * Propose a new hook candidate.
      * @param {string} hashes Hook candidate hashes in hex format, <GOVERNOR_HASH(32)><REGISTRY_HASH(32)><HEARTBEAT_HASH(32)>.
@@ -60491,8 +60562,8 @@ class BaseEvernodeClient {
      */
     async _propose(hashes, shortName, options = {}) {
         const hashesBuf = Buffer.from(hashes, 'hex');
-        if (!hashesBuf || hashesBuf.length != 96)
-            throw 'Invalid hashes: Hashes should contain all three Governor, Registry, Heartbeat hook hashes.';
+        if (!hashesBuf || hashesBuf.length != 128)
+            throw 'Invalid hashes: Hashes should contain all three Governor, Registry, Heartbeat, Reputation hook hashes.';
 
         // Check whether hook hashes exist in the definition.
         let keylets = [];
@@ -60502,7 +60573,7 @@ class BaseEvernodeClient {
             if (!ledgerEntry)
                 throw `No hook exists with the specified ${hook} hook hash.`;
             else
-                keylets.push(HookHelpers.getHookDefinitionKeylet(index));
+                keylets.push(HookHelpers.getKeylet('HOOK_DEFINITION',index));
         }
 
         const uniqueId = StateHelpers.getNewHookCandidateId(hashesBuf);
@@ -60523,7 +60594,9 @@ class BaseEvernodeClient {
             {
                 hookParams: [
                     { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.CANDIDATE_PROPOSE },
-                    { name: HookParamKeys.PARAM_EVENT_DATA_KEY, value: paramBuf.toString('hex').toUpperCase() }
+                    { name: HookParamKeys.PARAM_EVENT_DATA_KEY, value: paramBuf.slice(0, MAX_HOOK_PARAM_SIZE).toString('hex').toUpperCase() },
+                    { name: HookParamKeys.PARAM_EVENT_DATA2_KEY, value: paramBuf.slice(MAX_HOOK_PARAM_SIZE).toString('hex').toUpperCase() }
+
                 ],
                 ...options.transactionOptions
             });
@@ -60840,6 +60913,7 @@ const { HookTypes } = __nccwpck_require__(8262);
 const { RegistryClient } = __nccwpck_require__(8074);
 const { GovernorClient } = __nccwpck_require__(335);
 const { HeartbeatClient } = __nccwpck_require__(6510);
+const { ReputationClient } = __nccwpck_require__(7541);
 
 class HookClientFactory {
     /**
@@ -60864,6 +60938,11 @@ class HookClientFactory {
                 hookClient = new HeartbeatClient({ heartbeatAddress: heartbeatAddress });
                 break;
             }
+            case HookTypes.reputation: {
+                const reputationAddress = await HookClientFactory.#getAccountAddress(hookType);
+                hookClient = new ReputationClient({ reputationAddress: reputationAddress });
+                break;
+            }
             default: {
                 hookClient = null;
                 break;
@@ -60890,7 +60969,8 @@ class HookClientFactory {
             return configs.registryAddress;
         else if (hookType == HookTypes.heartbeat)
             return configs.heartbeatAddress;
-
+        else if (hookType == HookTypes.reputation)
+            return configs.reputationAddress;
     }
 }
 
@@ -60940,12 +61020,91 @@ module.exports = {
 
 /***/ }),
 
+/***/ 7541:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+const { StateHelpers } = __nccwpck_require__(3860);
+const { BaseEvernodeClient } = __nccwpck_require__(6263);
+
+const ReputationEvents = {}
+
+class ReputationClient extends BaseEvernodeClient {
+
+    constructor(options = {}) {
+        super(options.reputationAddress, null, Object.values(ReputationEvents), false, options);
+    }
+
+    /**
+     * Get reputation info of given host reputation orderId.
+     * @param {number} hostReputationOrderedId Reputation order id of the host.
+     * @param {number} moment (optional) Moment to get reputation info for.
+     * @returns Reputation info object.
+     */
+    async getReputationInfoByOrderedId(hostReputationOrderedId, moment = null) {
+        try {
+            const repMoment = moment ?? await this.getMoment();
+            const orderedIdStateKey = StateHelpers.generateHostReputationOrderedIdStateKey(hostReputationOrderedId, repMoment);
+            const orderedIdStateIndex = StateHelpers.getHookStateIndex(this.xrplAcc.address, orderedIdStateKey);
+            const orderedIdLedgerEntry = await this.xrplApi.getLedgerEntry(orderedIdStateIndex);
+            const orderedIdStateData = orderedIdLedgerEntry?.HookStateData;
+
+            if (orderedIdStateData) {
+                const orderedIdStateDecoded = StateHelpers.decodeHostReputationOrderedIdState(Buffer.from(orderedIdStateKey, 'hex'), Buffer.from(orderedIdStateData, 'hex'));
+                return await this._getReputationInfoByAddress(orderedIdStateDecoded.address, moment);
+            }
+        }
+        catch (e) {
+            // If the exception is entryNotFound from Rippled there's no entry for the host, So return null.
+            if (e?.data?.error !== 'entryNotFound')
+                throw e;
+        }
+
+        return null;
+    }
+
+    /**
+     * Get reputation info of the moment.
+     * @param {number} moment (optional) Moment to get reputation info for.
+     * @returns Reputation info object.
+     */
+    async getReputationInfo(moment = null) {
+        try {
+            const repMoment = moment ?? await this.getMoment();
+            const hostCountStateKey = StateHelpers.generateReputationHostCountStateKey(repMoment);
+            const hostCountStateIndex = StateHelpers.getHookStateIndex(this.xrplAcc.address, hostCountStateKey);
+            const hostCountLedgerEntry = await this.xrplApi.getLedgerEntry(hostCountStateIndex);
+            const hostCountStateData = hostCountLedgerEntry?.HookStateData;
+
+            if (hostCountStateData) {
+                const hostCountStateDecoded = StateHelpers.decodeReputationHostCountState(Buffer.from(hostCountStateKey, 'hex'), Buffer.from(hostCountStateData, 'hex'));
+                return hostCountStateDecoded;
+            }
+        }
+        catch (e) {
+            // If the exception is entryNotFound from Rippled there's no entry for the host, So return null.
+            if (e?.data?.error !== 'entryNotFound')
+                throw e;
+        }
+
+        return null;
+    }
+}
+
+module.exports = {
+    ReputationClient,
+    ReputationEvents
+}
+
+/***/ }),
+
 /***/ 1437:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const { XrplConstants } = __nccwpck_require__(3307);
 const { BaseEvernodeClient } = __nccwpck_require__(6263);
-const { EvernodeEvents, EvernodeConstants, MemoFormats, EventTypes, ErrorCodes, HookParamKeys, RegExp } = __nccwpck_require__(9849);
+const { HookClientFactory } = __nccwpck_require__(2344);
+const { HookTypes } = __nccwpck_require__(8262);
+const { EvernodeEvents, EvernodeConstants, MemoFormats, EventTypes, ErrorCodes, HookParamKeys, RegExp, ReputationConstants } = __nccwpck_require__(9849);
 const { XrplAccount } = __nccwpck_require__(9329);
 const { EncryptionHelper } = __nccwpck_require__(4832);
 const { Buffer } = __nccwpck_require__(4300);
@@ -61001,6 +61160,27 @@ class HostClient extends BaseEvernodeClient {
         super(xrpAddress, xrpSecret, Object.values(HostEvents), true, options);
     }
 
+    async connect(options = {}) {
+        const res = await super.connect();
+        await this.setReputationAcc(options.reputationAddress, options.reputationSecret);
+        return res;
+    }
+
+    async setReputationAcc(reputationAddress = null, reputationSecret = null) {
+        let hostReputationAccId;
+        if (!reputationAddress && !reputationSecret) {
+            hostReputationAccId = (await this.xrplAcc.getWalletLocator())?.slice(0, 20);
+            if (hostReputationAccId)
+                reputationAddress = codec.encodeAccountID(Buffer.from(hostReputationAccId, 'hex'));
+        }
+
+        if (reputationAddress || reputationSecret)
+            this.reputationAcc = new XrplAccount(reputationAddress, reputationSecret, { xrplApi: this.xrplApi });
+
+        if (!this.reputationAcc || this.reputationAcc.address === this.xrplAcc.address || this.reputationAcc.address !== reputationAddress)
+            this.reputationAcc = null;
+    }
+
     /**
      * Get max ledger sequence for host client.
      * @returns Max ledger sequence number.
@@ -61034,6 +61214,18 @@ class HostClient extends BaseEvernodeClient {
         return null;
     }
 
+    /**
+     * Get lease token by index.
+     * @param index Index of the token.
+     * @returns Lease token.
+     */
+    async getLeaseByIndex(index) {
+        const token = await EvernodeHelpers.getLeaseByIndex(this.xrplApi, index);
+        if (token.Issuer !== this.xrplAcc.address)
+            return null;
+        return token;
+    }
+
     /**
      * Get offered and unoffered leases created by the host.
      * @returns Array of lease offer objects.
@@ -61131,6 +61323,147 @@ class HostClient extends BaseEvernodeClient {
         }
     }
 
+    /**
+     * Prepare the reputation account with account fields and trust lines.
+     * @param {string} reputationAddress Address of the reputation account.
+     * @param {string} reputationSecret Secret of the reputation account.
+     */
+    async prepareReputationAccount(reputationAddress, reputationSecret, options = {}) {
+        const repAcc = new XrplAccount(reputationAddress, reputationSecret, { xrplApi: this.xrplApi });
+        const [trustLines, walletLocator, hostWalletLocator] = await Promise.all([
+            repAcc.getTrustLines(EvernodeConstants.EVR, this.config.evrIssuerAddress),
+            repAcc.getWalletLocator(),
+            this.xrplAcc.getWalletLocator()]);
+
+        const hostRegAccId = (codec.decodeAccountID(this.xrplAcc.address).toString('hex').toUpperCase()).padEnd(64, '0');
+        const hostReputationAccId = (codec.decodeAccountID(repAcc.address).toString('hex').toUpperCase()).padEnd(64, '0');
+
+        let accountSetFields = {};
+        accountSetFields = (!walletLocator || walletLocator != hostRegAccId) ? { ...accountSetFields, WalletLocator: hostRegAccId } : accountSetFields;
+
+        if (Object.keys(accountSetFields).length !== 0) {
+            await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                await repAcc.setAccountFields(accountSetFields, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+            }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
+        }
+
+        if (trustLines.length === 0) {
+            await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                await repAcc.setTrustLine(EvernodeConstants.EVR, this.config.evrIssuerAddress, "99999999999999", null, null, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+            }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
+        }
+
+        let hostAccountSetFields = {};
+        hostAccountSetFields = (!hostWalletLocator || hostWalletLocator != hostReputationAccId) ? { ...hostAccountSetFields, WalletLocator: hostReputationAccId } : hostAccountSetFields;
+        if (Object.keys(hostAccountSetFields).length !== 0) {
+            await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                await this.xrplAcc.setAccountFields(hostAccountSetFields, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+            }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
+        }
+
+        await this.setReputationAcc(reputationAddress, reputationSecret);
+    }
+
+    /**
+     * Set the reputation contract info.
+     * @param {number} peerPort Peer port of the reputation contract instance.
+     * @param {string} publicKey Public key of the reputation contract instance.
+     */
+    async setReputationContractInfo(peerPort, publicKey, moment = null, options = {}) {
+        const repMoment = moment ?? await this.getMoment();
+
+        var buffer = Buffer.alloc(ReputationConstants.REP_INFO_BUFFER_SIZE, 0);
+        Buffer.from(publicKey.toUpperCase(), "hex").copy(buffer, ReputationConstants.REP_INFO_PUBKEY_OFFSET);
+        buffer.writeUInt16LE(peerPort, ReputationConstants.REP_INFO_PEER_PORT_OFFSET);
+        buffer.writeBigUInt64LE(BigInt(repMoment), ReputationConstants.REP_INFO_MOMENT_OFFSET);
+        const domain = buffer.toString('hex');
+
+        let accountSetFields = {};
+        accountSetFields = { ...accountSetFields, Domain: domain };
+
+        if (Object.keys(accountSetFields).length !== 0) {
+            await this.#submitWithRetry(async (feeUplift, submissionRef) => {
+                await this.reputationAcc.setAccountFields(accountSetFields, { maxLedgerIndex: this.#getMaxLedgerSequence(), feeUplift: feeUplift, submissionRef: submissionRef });
+            }, { ...(options.retryOptions ? options.retryOptions : {}), submissionRef: options.submissionRef });
+        }
+    }
+
+    /**
+     * Get reputation info of this host.
+     * @param {number} moment (optional) Moment to get reputation info for.
+     * @returns Reputation info object.
+     */
+    async getReputationInfo(moment = null) {
+        if (!this.reputationAcc)
+            return null;
+
+        return await this._getReputationInfoByAddress(this.reputationAcc.address, moment);
+    }
+
+    /**
+     * Prepare host reputation score to a common format for submission.
+     * @param {object} collectedScores 
+     * @returns Unified reputation score array.
+     */
+    async prepareHostReputationScores(collectedScores = {}) {
+        const myReputationInfo = await this.getReputationInfo();
+        const myOrderId = myReputationInfo.orderedId;
+
+        // Deciding universe.
+        const universeStartIndex = Math.floor(myOrderId / 64) * 64;
+
+        const reputationClient = await HookClientFactory.create(HookTypes.reputation);
+        await reputationClient.connect();
+        let data = {};
+        await Promise.all(Array.from({ length: 64 }, (_, i) => i + universeStartIndex).map(async (i) => {
+            try {
+                const hostReputationInfo = await reputationClient.getReputationInfoByOrderedId(i);
+                if (!hostReputationInfo)
+                    throw 'No reputation info for this order id';
+                data[i.toString()] = {
+                    publicKey: hostReputationInfo.contract.pubkey,
+                    reputationAddress: hostReputationInfo.address,
+                    orderId: i
+                };
+            } catch (error) {
+                data[i.toString()] = { publicKey: "-1", orderId: i };
+            }
+        }));
+        await reputationClient.disconnect();
+
+        return Object.entries(data).map(e => ({
+            ...e[1],
+            scoreValue: collectedScores[e[1]?.publicKey] || 0
+        }));
+    }
+
+    /**
+     * Send reputation scores to the reputation hook.
+     * @param {object} scores [Optional] Score object in { host: score } format.
+     */
+    async sendReputations(scores = null, options = {}) {
+        let buffer = Buffer.alloc(64, 0);
+        if (scores) {
+            const preparedScores = await this.prepareHostReputationScores(scores);
+            let i = 0;
+            for (const reputationScore of preparedScores) {
+                buffer.writeUIntLE(Number(reputationScore.scoreValue), i, 1);
+                i++;
+            }
+        }
+
+        await this.reputationAcc.invoke(this.config.reputationAddress,
+            scores ? { isHex: true, data: buffer.toString('hex') } : null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.HOST_SEND_REPUTATION }
+                ],
+                maxLedgerIndex: this.#getMaxLedgerSequence(),
+                ...options.transactionOptions,
+                submissionRef: options.submissionRef
+            });
+    }
+
     /**
      * Create a lease offer.
      * @param {number} leaseIndex Index number for the lease.
@@ -62341,7 +62674,8 @@ const DefaultValues = {
 const HookTypes = {
     governor: 'GOVERNOR',
     registry: 'REGISTRY',
-    heartbeat: 'HEARTBEAT'
+    heartbeat: 'HEARTBEAT',
+    reputation: 'REPUTATION'
 }
 
 const getDefinitions = async () => {
@@ -62831,7 +63165,8 @@ const EvernodeConstants = {
     HOOKS: [
         "Governor",
         "Registry",
-        "Heartbeat"
+        "Heartbeat",
+        "Reputation"
     ],
     CandidateVote: {
         Reject: 0,
@@ -62884,7 +63219,8 @@ const EventTypes = {
     HOOK_UPDATE_RES: 'evnHookUpdateRes',
     GOVERNANCE_MODE_CHANGE: 'evnGovernanceModeChange',
     LINKED_CANDIDATE_REMOVE: 'evnRemoveLinkedCandidate',
-    HOST_UPDATE_REPUTATION: 'evnHostUpdateReputation'
+    HOST_UPDATE_REPUTATION: 'evnHostUpdateReputation',
+    HOST_SEND_REPUTATION: 'evnHostSendReputation'
 }
 
 const MemoFormats = {
@@ -62911,6 +63247,13 @@ const ErrorReasons = {
     NO_STATE_KEY: 'NO_STATE_KEY'
 }
 
+const ReputationConstants = {
+    REP_INFO_BUFFER_SIZE: 43,
+    REP_INFO_PUBKEY_OFFSET: 0,
+    REP_INFO_PEER_PORT_OFFSET: 33,
+    REP_INFO_MOMENT_OFFSET: 35
+}
+
 // All keys are prefixed with 'EVR' (0x455652)
 // Config keys sub-prefix: 0x01
 const HookStateKeys = {
@@ -62930,6 +63273,7 @@ const HookStateKeys = {
     REGISTRY_ADDR: "455652010000000000000000000000000000000000000000000000000000000D",
     GOVERNANCE_CONFIGURATION: "455652010000000000000000000000000000000000000000000000000000000E",
     NETWORK_CONFIGURATION: "455652010000000000000000000000000000000000000000000000000000000F",
+    REPUTATION_ADDR: "4556520100000000000000000000000000000000000000000000000000000010",
 
     // Singleton
     HOST_COUNT: "4556523200000000000000000000000000000000000000000000000000000000",
@@ -62953,6 +63297,7 @@ const HookParamKeys = {
     PARAM_STATE_HOOK_KEY: "4556520100000000000000000000000000000000000000000000000000000001",
     PARAM_EVENT_TYPE_KEY: "4556520100000000000000000000000000000000000000000000000000000002",
     PARAM_EVENT_DATA_KEY: "4556520100000000000000000000000000000000000000000000000000000003",
+    PARAM_EVENT_DATA2_KEY: "4556520100000000000000000000000000000000000000000000000000000004",
 }
 
 const EvernodeEvents = {
@@ -63004,7 +63349,8 @@ module.exports = {
     EvernodeEvents,
     URITokenTypes,
     HookParamKeys,
-    RegExp
+    RegExp,
+    ReputationConstants
 }
 
 /***/ }),
@@ -63023,6 +63369,13 @@ class EvernodeHelpers {
         return hostUriOffers;
     }
 
+    static async getLeaseByIndex(xrplApi, index) {
+        const entry = await xrplApi.getLedgerEntry(index);
+        if (!entry || entry.LedgerEntryType !== 'URIToken' || !(this.isValidURI(entry.URI, EvernodeConstants.LEASE_TOKEN_PREFIX_HEX) && entry.Flags == 1))
+            return null;
+        return entry;
+    }
+
     static async getLeaseOffers(xrplAcc) {
         const hostUriOffers = (await this.getLeases(xrplAcc)).filter(uriToken => uriToken.Amount);
         return hostUriOffers;
@@ -63054,7 +63407,7 @@ class EvernodeHelpers {
 
         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.alloc(2,0);
+            let locBuf = Buffer.alloc(2, 0);
             locBuf.writeUInt16BE(nftPageInfo.location);
             // <NFT_PAGE_KEYLET(34 bytes)><LOCATION(2 bytes)>
             return Buffer.concat([Buffer.from(nftPageInfo.NFTPage, "hex"), locBuf]);
@@ -63088,13 +63441,26 @@ module.exports = {
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const crypto = __nccwpck_require__(6113);
+const codec = __nccwpck_require__(597);
 
-const HOOK_DEFINITION_LEDGER_TYPE_PREFIX = 68; // Decimal value of ASCII 'D'
+const LEDGER_ENTRY_TYPES = {
+    HOOK_DEFINITION: 68, // Decimal value of ASCII 'D'
+    ACCOUNT: 97 // Decimal value of ASCII 'a'
+}
 
 class HookHelpers {
+
+    static getKeylet(type, index) {
+        const keyletBuf = Buffer.alloc(34, 0);
+        keyletBuf.writeInt16BE(LEDGER_ENTRY_TYPES[type.toUpperCase()]);
+        Buffer.from(index, 'hex').copy(keyletBuf, 2);
+
+        return keyletBuf.toString('hex');
+    }
+    
     static getHookDefinitionIndex(hookHash) {
         const typeBuf = Buffer.alloc(2, 0);
-        typeBuf.writeInt16BE(HOOK_DEFINITION_LEDGER_TYPE_PREFIX);
+        typeBuf.writeInt16BE(LEDGER_ENTRY_TYPES.HOOK_DEFINITION);
 
         const hookHashBuf = Buffer.from(hookHash, 'hex');
 
@@ -63108,12 +63474,20 @@ class HookHelpers {
         return digest.substring(0, 64).toUpperCase();
     }
 
-    static getHookDefinitionKeylet(index) {
-        const keyletBuf = Buffer.alloc(34, 0);
-        keyletBuf.writeInt16BE(HOOK_DEFINITION_LEDGER_TYPE_PREFIX);
-        Buffer.from(index, 'hex').copy(keyletBuf, 2);
+    static getAccountIndex(address) {
+        const typeBuf = Buffer.alloc(2, 0);
+        typeBuf.writeInt16BE(LEDGER_ENTRY_TYPES.ACCOUNT);
 
-        return keyletBuf.toString('hex');
+        const accountBuf = Buffer.from(codec.decodeAccountID(address), "hex");
+
+        let hash = crypto.createHash('sha512');
+
+        let data = hash.update(typeBuf);
+        data = hash.update(accountBuf);
+
+        const digest = data.digest('hex');
+        // Get the first 32 bytes of hash.
+        return digest.substring(0, 64).toUpperCase();
     }
 }
 
@@ -63263,6 +63637,10 @@ const HOST_DISK_MB_OFFSET = 72;
 const HOST_EMAIL_ADDRESS_OFFSET = 76;
 const HOST_ACCUMULATED_REWARD_OFFSET = 116;
 
+const HOST_REP_LAST_REG_MOMENT_OFFSET = 0;
+const HOST_REP_SCORE_NUMERATOR_OFFSET = 8;
+const HOST_REP_SCORE_DENOMINATOR_OFFSET = 16;
+
 const PREV_HOST_ADDRESS_OFFSET = 0;
 const TRANSFER_LEDGER_IDX_OFFSET = 20;
 const TRANSFERRED_NFT_ID_OFFSET = 28;
@@ -63270,6 +63648,7 @@ const TRANSFERRED_NFT_ID_OFFSET = 28;
 const CANDIDATE_GOVERNOR_HOOK_HASH_OFFSET = 0;
 const CANDIDATE_REGISTRY_HOOK_HASH_OFFSET = 32;
 const CANDIDATE_HEARTBEAT_HOOK_HASH_OFFSET = 64;
+const CANDIDATE_REPUTATION_HOOK_HASH_OFFSET = 96;
 
 const CANDIDATE_OWNER_ADDRESS_OFFSET = 0;
 const CANDIDATE_IDX_OFFSET = 20;
@@ -63314,6 +63693,8 @@ const CANDIDATE_OWNER_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;
+const STATE_KEY_SIZE = 32;
+const ACCOUNT_ID_SIZE = 20;
 
 class StateHelpers {
     static StateTypes = {
@@ -63338,6 +63719,46 @@ class StateHelpers {
         return state.data;
     }
 
+    static decodeHostReputationAddressState(stateKeyBuf, stateDataBuf) {
+        const keyOffset = STATE_KEY_SIZE - ACCOUNT_ID_SIZE;
+        const data = {
+            address: codec.encodeAccountID(stateKeyBuf.slice(keyOffset)),
+            lastRegisteredMoment: Number(stateDataBuf.readBigUInt64LE(HOST_REP_LAST_REG_MOMENT_OFFSET)),
+            scoreNumerator: Number(stateDataBuf.readBigUInt64LE(HOST_REP_SCORE_NUMERATOR_OFFSET)),
+            scoreDenominator: Number(stateDataBuf.readBigUInt64LE(HOST_REP_SCORE_DENOMINATOR_OFFSET))
+        }
+        return data;
+    }
+
+    static decodeHostReputationOrderAddressState(stateKeyBuf, stateDataBuf) {
+        const keyOffset = STATE_KEY_SIZE - ACCOUNT_ID_SIZE - 8;
+        const data = {
+            moment: Number(stateKeyBuf.readBigUInt64LE(keyOffset)),
+            address: codec.encodeAccountID(stateKeyBuf.slice(keyOffset + 8)),
+            orderedId: Number(stateDataBuf.readBigUInt64LE(0))
+        }
+        return data;
+    }
+
+    static decodeHostReputationOrderedIdState(stateKeyBuf, stateDataBuf) {
+        const keyOffset = STATE_KEY_SIZE - 16;
+        const data = {
+            moment: Number(stateKeyBuf.readBigUInt64LE(keyOffset)),
+            orderedId: Number(stateKeyBuf.readBigUInt64LE(keyOffset + 8)),
+            address: codec.encodeAccountID(stateDataBuf.slice(0))
+        }
+        return data;
+    }
+
+    static decodeReputationHostCountState(stateKeyBuf, stateDataBuf) {
+        const keyOffset = STATE_KEY_SIZE - 8;
+        const data = {
+            moment: Number(stateKeyBuf.readBigUInt64LE(keyOffset)),
+            count: Number(stateDataBuf.readBigUInt64LE())
+        }
+        return data;
+    }
+
     static decodeHostAddressState(stateKeyBuf, stateDataBuf) {
         let data = {
             address: codec.encodeAccountID(stateKeyBuf.slice(12)),
@@ -63405,6 +63826,8 @@ class StateHelpers {
             governorHookHash: stateDataBuf.slice(CANDIDATE_GOVERNOR_HOOK_HASH_OFFSET, CANDIDATE_REGISTRY_HOOK_HASH_OFFSET).toString('hex').toUpperCase(),
             registryHookHash: stateDataBuf.slice(CANDIDATE_REGISTRY_HOOK_HASH_OFFSET, CANDIDATE_HEARTBEAT_HOOK_HASH_OFFSET).toString('hex').toUpperCase(),
             heartbeatHookHash: stateDataBuf.slice(CANDIDATE_HEARTBEAT_HOOK_HASH_OFFSET, CANDIDATE_HEARTBEAT_HOOK_HASH_OFFSET + 32).toString('hex').toUpperCase(),
+            reputationHookHash: stateDataBuf.slice(CANDIDATE_REPUTATION_HOOK_HASH_OFFSET, CANDIDATE_REPUTATION_HOOK_HASH_OFFSET + 32).toString('hex').toUpperCase(),
+
         }
         return data;
     }
@@ -63534,7 +63957,8 @@ class StateHelpers {
         else if (Buffer.from(HookStateKeys.REGISTRY_ADDR, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.HEARTBEAT_ADDR, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.EVR_ISSUER_ADDR, 'hex').compare(stateKey) === 0 ||
-            Buffer.from(HookStateKeys.FOUNDATION_ADDR, 'hex').compare(stateKey) === 0) {
+            Buffer.from(HookStateKeys.FOUNDATION_ADDR, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.REPUTATION_ADDR, 'hex').compare(stateKey) === 0) {
             return {
                 type: this.StateTypes.CONFIGURATION,
                 key: hexKey,
@@ -63745,7 +64169,8 @@ class StateHelpers {
             Buffer.from(HookStateKeys.REGISTRY_ADDR, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.HEARTBEAT_ADDR, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.GOVERNANCE_CONFIGURATION, 'hex').compare(stateKey) === 0 ||
-            Buffer.from(HookStateKeys.NETWORK_CONFIGURATION, 'hex').compare(stateKey) === 0) {
+            Buffer.from(HookStateKeys.NETWORK_CONFIGURATION, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.REPUTATION_ADDR, 'hex').compare(stateKey) === 0) {
             return {
                 key: hexKey,
                 type: this.StateTypes.CONFIGURATION
@@ -63779,6 +64204,39 @@ class StateHelpers {
         return stateKeyBuf.toString('hex').toUpperCase();
     }
 
+    static generateHostReputationAddrStateKey(address) {
+        const buf = Buffer.alloc(STATE_KEY_SIZE, 0);
+        Buffer.from(codec.decodeAccountID(address), "hex").copy(buf, buf.length - ACCOUNT_ID_SIZE);
+
+        return buf.toString('hex').toUpperCase();
+    }
+
+    static generateHostReputationOrderAddressStateKey(address, moment) {
+        const buf = Buffer.alloc(STATE_KEY_SIZE, 0);
+        const offset = buf.length - ACCOUNT_ID_SIZE - 8;
+        buf.writeBigUInt64LE(BigInt(moment), offset);
+        Buffer.from(codec.decodeAccountID(address), "hex").copy(buf, offset + 8);
+
+        return buf.toString('hex').toUpperCase();
+    }
+
+    static generateHostReputationOrderedIdStateKey(orderedId, moment) {
+        let buf = Buffer.alloc(STATE_KEY_SIZE, 0);
+        const offset = buf.length - 16;
+        buf.writeBigUInt64LE(BigInt(moment), offset);
+        buf.writeBigUInt64LE(BigInt(orderedId), offset + 8);
+
+        return buf.toString('hex').toUpperCase();
+    }
+
+    static generateReputationHostCountStateKey(moment) {
+        let buf = Buffer.alloc(STATE_KEY_SIZE, 0);
+        const offset = buf.length - 8;
+        buf.writeBigUInt64LE(BigInt(moment), offset);
+
+        return buf.toString('hex').toUpperCase();
+    }
+
     static generateTransfereeAddrStateKey(address) {
         // 1 byte - Key Type.
         // 8 bytes - Zeros.
@@ -63961,6 +64419,7 @@ module.exports = {
 /***/ 6687:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
+const kp = __nccwpck_require__(8150);
 const { Buffer } = __nccwpck_require__(4300);
 const { XflHelpers } = __nccwpck_require__(3243);
 const { EvernodeConstants } = __nccwpck_require__(9849);
@@ -64017,6 +64476,13 @@ class UtilHelpers {
         }
     }
 
+    static deriveKeypair(secret) {
+        return kp.deriveKeypair(secret);
+    }
+
+    static deriveAddress(publicKey) {
+        return kp.deriveAddress(publicKey);
+    }
 }
 
 module.exports = {
@@ -64165,13 +64631,13 @@ module.exports = {
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const xrpl = __nccwpck_require__(4666);
-const kp = __nccwpck_require__(8150);
 const codec = __nccwpck_require__(597);
 const crypto = __nccwpck_require__(6113);
 const { XrplConstants, XrplTransactionTypes } = __nccwpck_require__(3307);
 const { TransactionHelper } = __nccwpck_require__(7071);
 const { EventEmitter } = __nccwpck_require__(6170);
 const { Defaults } = __nccwpck_require__(8262);
+const { UtilHelpers } = __nccwpck_require__(6687);
 
 class XrplAccount {
 
@@ -64194,8 +64660,8 @@ class XrplAccount {
             this.wallet = xrpl.Wallet.fromSeed(this.secret);
             this.address = this.wallet.classicAddress;
         } else if (this.secret) {
-            const keypair = kp.deriveKeypair(this.secret);
-            const derivedPubKeyAddress = kp.deriveAddress(keypair.publicKey);
+            const keypair = UtilHelpers.deriveKeypair(this.secret);
+            const derivedPubKeyAddress = UtilHelpers.deriveAddress(keypair.publicKey);
             if (this.address == derivedPubKeyAddress)
                 this.wallet = xrpl.Wallet.fromSeed(this.secret);
             else
@@ -64223,7 +64689,7 @@ class XrplAccount {
         if (!this.secret)
             throw 'Cannot derive key pair: Account secret is empty.';
 
-        return kp.deriveKeypair(this.secret);
+        return UtilHelpers.deriveKeypair(this.secret);
     }
 
     async exists() {
@@ -64250,6 +64716,10 @@ class XrplAccount {
         return (await this.getInfo())?.MessageKey;
     }
 
+    async getWalletLocator() {
+        return (await this.getInfo())?.WalletLocator;
+    }
+
     async getDomain() {
         const domain = (await this.getInfo())?.Domain;
         return domain ? TransactionHelper.hexToASCII(domain) : null;
@@ -64400,6 +64870,30 @@ class XrplAccount {
         return await this.#prepareSubmissionTransaction(signerListTx, options);
     }
 
+    async invoke(toAddr, blobObj = null, options = {}) {
+        const preparedTxn = await this.prepareInvoke(toAddr, blobObj, options);
+        return await this.signAndSubmit(preparedTxn, options.submissionRef);
+    }
+
+    async prepareInvoke(toAddr, blobObj = null, options = {}) {
+
+        var txObj = {
+            TransactionType: XrplTransactionTypes.INVOKE,
+            Account: this.address,
+            Destination: toAddr,
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
+        };
+
+        if (blobObj) {
+            txObj = {
+                ...txObj,
+                Blob: blobObj.isHex ? blobObj.data : TransactionHelper.asciiToHex(blobObj.data)
+            }
+        }
+
+        return await this.#prepareSubmissionTransaction(txObj, options);
+    }
+
     async makePayment(toAddr, amount, currency = null, issuer = null, memos = null, options = {}) {
         const preparedTxn = await this.prepareMakePayment(toAddr, amount, currency, issuer, memos, options);
         return await this.signAndSubmit(preparedTxn, options.submissionRef);
@@ -64971,7 +65465,8 @@ const { Defaults } = __nccwpck_require__(8262);
 const { TransactionHelper } = __nccwpck_require__(7071);
 const { XrplApiEvents } = __nccwpck_require__(3307);
 const { XrplAccount } = __nccwpck_require__(9329);
-const { XrplHelpers } = __nccwpck_require__(3189)
+const { XrplHelpers } = __nccwpck_require__(3189);
+const { UtilHelpers } = __nccwpck_require__(6687);
 
 const MAX_PAGE_LIMIT = 400;
 const API_REQ_TYPE = {
@@ -65407,7 +65902,7 @@ class XrplApi {
         const info = await this.getAccountInfo(address);
         const accountFlags = xrpl.parseAccountRootFlags(info.Flags);
         const regularKey = info.RegularKey;
-        const derivedPubKeyAddress = kp.deriveAddress(publicKey);
+        const derivedPubKeyAddress = UtilHelpers.deriveAddress(publicKey);
 
         // If the master key is disabled the derived pubkey address should be the regular key.
         // Otherwise it could be account address or the regular key
@@ -65704,6 +66199,7 @@ const XrplConstants = {
 }
 
 const XrplTransactionTypes = {
+    INVOKE: 'Invoke',
     PAYMENT: 'Payment',
     SIGNER_LIST_SET: 'SignerListSet',
     TRUST_SET: 'TrustSet',

package/package.json

@@ -6,7 +6,7 @@
     ],
     "homepage": "https://github.com/HotPocketDev/evernode-js-client",
     "license": "SEE LICENSE IN https://raw.githubusercontent.com/EvernodeXRPL/evernode-resources/main/license/evernode-license.pdf",
-    "version": "0.6.44",
+    "version": "0.6.46",
     "dependencies": {
         "elliptic": "6.5.4",
         "libsodium-wrappers": "0.7.10",