evernode-js-client 0.5.17-beta-v3.3 → 0.5.17-beta-v3.5

package/index.js

@@ -11725,7 +11725,7 @@ const { Buffer } = __nccwpck_require__(4300);
 const { XrplApi } = __nccwpck_require__(1850);
 const { XrplAccount } = __nccwpck_require__(9329);
 const { XrplApiEvents, XrplConstants } = __nccwpck_require__(3307);
-const { EvernodeEvents, MemoTypes, MemoFormats, EvernodeConstants, HookStateKeys } = __nccwpck_require__(9849);
+const { EvernodeEvents, EventTypes, MemoFormats, EvernodeConstants, HookStateKeys, HookParamKeys } = __nccwpck_require__(9849);
 const { DefaultValues } = __nccwpck_require__(8262);
 const { EncryptionHelper } = __nccwpck_require__(4832);
 const { EventEmitter } = __nccwpck_require__(6170);
@@ -11735,13 +11735,16 @@ const { StateHelpers } = __nccwpck_require__(3860);
 const { EvernodeHelpers } = __nccwpck_require__(2523);
 const { HookHelpers } = __nccwpck_require__(4675);
 
-const CANDIDATE_PROPOSE_UNIQUE_ID_MEMO_OFFSET = 0;
-const CANDIDATE_PROPOSE_SHORT_NAME_MEMO_OFFSET = 32;
-const CANDIDATE_PROPOSE_KEYLETS_MEMO_OFFSET = 52;
-const CANDIDATE_PROPOSE_MEMO_SIZE = 154;
+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 DUD_HOST_CANDID_ADDRESS_OFFSET = 12;
 
+const MAX_HOOK_PARAM_SIZE = 128;
+
 class BaseEvernodeClient {
 
     #watchEvents;
@@ -11959,11 +11962,18 @@ class BaseEvernodeClient {
     /**
      * Extracts the transaction info from a given transaction.
      * @param {object} tx Transaction to be deserialized and extracted.
-     * @returns The event object in the format {name: '', data: {}}. Returns null if not handled. Note: You need to deserialize memos before passing the transaction to this function.
+     * @returns The event object in the format {name: '', data: {}}. Returns null if not handled. Note: You need to deserialize HookParameters before passing the transaction to this function.
      */
     async extractEvernodeEvent(tx) {
-        if (tx.TransactionType === 'URITokenBuy' && tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.ACQUIRE_LEASE && tx.Memos[0].format === MemoFormats.BASE64 && tx.Memos[0].data) {
+        let eventType;
+        let eventData;
+        if (tx.HookParameters.length) {
+            eventType = tx.HookParameters.find(p => p.name === HookParamKeys.PARAM_EVENT_TYPE_KEY)?.value;
+            eventData = tx.HookParameters.find(p => p.name === HookParamKeys.PARAM_EVENT_DATA1_KEY)?.value;
+            eventData += tx.HookParameters.find(p => p.name === HookParamKeys.PARAM_EVENT_DATA2_KEY)?.value ?? '';
+        }
+        if (tx.TransactionType === 'URITokenBuy' && eventType === EventTypes.ACQUIRE_LEASE && tx.Memos.length &&
+            tx.Memos[0].type === EventTypes.ACQUIRE_LEASE && tx.Memos[0].format === MemoFormats.BASE64 && tx.Memos[0].data) {
 
             // If our account is the destination host account, then decrypt the payload.
             let payload = tx.Memos[0].data;
@@ -11989,12 +11999,11 @@ class BaseEvernodeClient {
             }
         }
 
-        else if (tx.Memos.length >= 2 &&
-            tx.Memos[0].type === MemoTypes.ACQUIRE_SUCCESS && tx.Memos[0].data &&
-            tx.Memos[1].type === MemoTypes.ACQUIRE_REF && tx.Memos[1].data) {
+        else if (eventType === EventTypes.ACQUIRE_SUCCESS && eventData && tx.Memos.length &&
+            tx.Memos[0].type === EventTypes.ACQUIRE_SUCCESS && tx.Memos[0].data) {
 
             let payload = tx.Memos[0].data;
-            const acquireRefId = tx.Memos[1].data;
+            const acquireRefId = eventData;
 
             // If our account is the destination user account, then decrypt the payload.
             if (tx.Memos[0].format === MemoFormats.BASE64 && tx.Destination === this.xrplAcc.address) {
@@ -12015,12 +12024,11 @@ class BaseEvernodeClient {
             }
 
         }
-        else if (tx.Memos.length >= 2 &&
-            tx.Memos[0].type === MemoTypes.ACQUIRE_ERROR && tx.Memos[0].data &&
-            tx.Memos[1].type === MemoTypes.ACQUIRE_REF && tx.Memos[1].data) {
+        else if (eventType === EventTypes.ACQUIRE_ERROR && eventData && tx.Memos.length &&
+            tx.Memos[0].type === EventTypes.ACQUIRE_ERROR && tx.Memos[0].data) {
 
             let error = tx.Memos[0].data;
-            const acquireRefId = tx.Memos[1].data;
+            const acquireRefId = eventData;
 
             if (tx.Memos[0].format === MemoFormats.JSON)
                 error = JSON.parse(error).reason;
@@ -12034,8 +12042,7 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.HOST_REG && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+        else if (eventType === EventTypes.HOST_REG && eventData) {
 
             return {
                 name: EvernodeEvents.HostRegistered,
@@ -12045,7 +12052,7 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 && tx.Memos[0].type === MemoTypes.HOST_DEREG) {
+        else if (eventType === EventTypes.HOST_DEREG && eventData) {
             return {
                 name: EvernodeEvents.HostDeregistered,
                 data: {
@@ -12054,14 +12061,13 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.HEARTBEAT) {
+        else if (eventType === EventTypes.HEARTBEAT) {
 
-            const voteInfo = (tx.Memos[0].data && tx.Memos[0].data.length) ?
+            const voteInfo = (eventData && eventData.length) ?
                 {
                     voteInfo: {
-                        candidateId: tx.Memos[0].data.substr(0, 64),
-                        vote: Buffer.from(tx.Memos[0].data, 'hex').slice(32, 33).readUInt8()
+                        candidateId: eventData.substr(0, 64),
+                        vote: Buffer.from(eventData, 'hex').slice(32, 33).readUInt8()
                     }
                 } : {};
 
@@ -12074,10 +12080,9 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.EXTEND_LEASE && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+        else if (eventType === EventTypes.EXTEND_LEASE && eventData) {
 
-            let uriTokenId = tx.Memos[0].data;
+            let uriTokenId = eventData;
 
             return {
                 name: EvernodeEvents.ExtendLease,
@@ -12091,12 +12096,11 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 2 &&
-            tx.Memos[0].type === MemoTypes.EXTEND_SUCCESS && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data &&
-            tx.Memos[1].type === MemoTypes.EXTEND_REF && tx.Memos[1].format === MemoFormats.HEX && tx.Memos[1].data) {
+        else if (eventType === EventTypes.EXTEND_SUCCESS && eventData && tx.Memos.length &&
+            tx.Memos[0].type === EventTypes.EXTEND_SUCCESS && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
 
             const extendResBuf = Buffer.from(tx.Memos[0].data, 'hex');
-            const extendRefId = tx.Memos[1].data;
+            const extendRefId = eventData;
 
             return {
                 name: EvernodeEvents.ExtendSuccess,
@@ -12108,12 +12112,11 @@ class BaseEvernodeClient {
             }
 
         }
-        else if (tx.Memos.length >= 2 &&
-            tx.Memos[0].type === MemoTypes.EXTEND_ERROR && tx.Memos[0].data &&
-            tx.Memos[1].type === MemoTypes.EXTEND_REF && tx.Memos[1].data) {
+        else if (eventType === EventTypes.EXTEND_ERROR && eventData && tx.Memos.length &&
+            tx.Memos[0].type === EventTypes.EXTEND_ERROR && tx.Memos[0].data) {
 
             let error = tx.Memos[0].data;
-            const extendRefId = tx.Memos[1].data;
+            const extendRefId = eventData;
 
             if (tx.Memos[0].format === MemoFormats.JSON)
                 error = JSON.parse(error).reason;
@@ -12127,8 +12130,7 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.INIT && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+        else if (eventType === EventTypes.INIT && eventData) {
 
             return {
                 name: EvernodeEvents.Initialized,
@@ -12137,8 +12139,7 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.HOST_UPDATE_INFO && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+        else if (eventType === EventTypes.HOST_UPDATE_INFO && eventData) {
 
             return {
                 name: EvernodeEvents.HostRegUpdated,
@@ -12148,10 +12149,9 @@ 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) {
+        else if (eventType === EventTypes.DEAD_HOST_PRUNE && eventData) {
 
-            const addrsBuf = Buffer.from(tx.Memos[0].data, 'hex');
+            const addrsBuf = Buffer.from(eventData, 'hex');
 
             return {
                 name: EvernodeEvents.DeadHostPrune,
@@ -12161,8 +12161,7 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.HOST_REBATE) {
+        else if (eventType === EventTypes.HOST_REBATE) {
 
             return {
                 name: EvernodeEvents.HostRebate,
@@ -12172,10 +12171,9 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.HOST_TRANSFER && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+        else if (eventType === EventTypes.HOST_TRANSFER && eventData) {
 
-            const addrsBuf = Buffer.from(tx.Memos[0].data, 'hex');
+            const addrsBuf = Buffer.from(eventData, 'hex');
 
             return {
                 name: EvernodeEvents.HostTransfer,
@@ -12185,40 +12183,36 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 2 &&
-            tx.Memos[0].type === MemoTypes.CANDIDATE_PROPOSE && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data &&
-            tx.Memos[1].type === MemoTypes.CANDIDATE_PROPOSE_REF && tx.Memos[1].format === MemoFormats.HEX && tx.Memos[1].data) {
+        else if (eventType === EventTypes.CANDIDATE_PROPOSE && eventData) {
 
             return {
                 name: EvernodeEvents.CandidateProposed,
                 data: {
                     transaction: tx,
                     owner: tx.Account,
-                    candidateId: tx.Memos[1].data.substr(0, 64)
+                    candidateId: eventData.substr(CANDIDATE_PROPOSE_UNIQUE_ID_PARAM_OFFSET * 2, 64)
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.CANDIDATE_WITHDRAW && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+        else if (eventType === EventTypes.CANDIDATE_WITHDRAW && eventData) {
             return {
                 name: EvernodeEvents.CandidateWithdrew,
                 data: {
                     transaction: tx,
                     owner: tx.Account,
-                    candidateId: tx.Memos[0].data.substr(0, 64)
+                    candidateId: eventData.substr(0, 64)
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.CANDIDATE_STATUS_CHANGE && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
-            const memoBuf = Buffer.from(tx.Memos[0].data, 'hex');
-            const candidateId = memoBuf.slice(0, 32).toString('hex');
+        else if (eventType === EventTypes.CANDIDATE_STATUS_CHANGE && eventData) {
+            const eventDataBuf = Buffer.from(eventData, 'hex');
+            const candidateId = eventDataBuf.slice(0, 32).toString('hex');
             const candidateType = StateHelpers.getCandidateType(candidateId);
 
             switch (candidateType) {
                 case (EvernodeConstants.CandidateTypes.DudHost):
                     return {
-                        name: memoBuf.readUInt8(32) === EvernodeConstants.CandidateStatuses.CANDIDATE_ELECTED ? EvernodeEvents.DudHostRemoved : EvernodeEvents.DudHostStatusChanged,
+                        name: eventDataBuf.readUInt8(32) === EvernodeConstants.CandidateStatuses.CANDIDATE_ELECTED ? EvernodeEvents.DudHostRemoved : EvernodeEvents.DudHostStatusChanged,
                         data: {
                             transaction: tx,
                             candidateId: candidateId,
@@ -12246,20 +12240,18 @@ class BaseEvernodeClient {
             }
 
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.HOOK_UPDATE_RES && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+        else if (eventType === EventTypes.HOOK_UPDATE_RES && eventData) {
             return {
                 name: EvernodeEvents.ChildHookUpdated,
                 data: {
                     transaction: tx,
                     account: tx.Account,
-                    candidateId: tx.Memos[0].data.substr(0, 64)
+                    candidateId: eventData.substr(0, 64)
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.GOVERNANCE_MODE_CHANGE && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
-            const mode = Buffer.from(tx.Memos[0].data, 'hex').slice(0, 1).readUInt8();
+        else if (eventType === EventTypes.GOVERNANCE_MODE_CHANGE && eventData) {
+            const mode = Buffer.from(eventData, 'hex').slice(0, 1).readUInt8();
 
             return {
                 name: EvernodeEvents.GovernanceModeChanged,
@@ -12269,22 +12261,20 @@ class BaseEvernodeClient {
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.CANDIDATE_VOTE && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
-            const vote = Buffer.from(tx.Memos[0].data, 'hex').slice(32, 33).readUInt8();
+        else if (eventType === EventTypes.CANDIDATE_VOTE && eventData) {
+            const vote = Buffer.from(eventData, 'hex').slice(32, 33).readUInt8();
 
             return {
                 name: EvernodeEvents.FoundationVoted,
                 data: {
                     transaction: tx,
-                    candidateId: tx.Memos[0].data.substr(0, 64),
+                    candidateId: eventData.substr(0, 64),
                     vote: vote
                 }
             }
         }
-        else if (tx.Memos.length >= 1 &&
-            tx.Memos[0].type === MemoTypes.DUD_HOST_REPORT && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
-            const candidateId = tx.Memos[0].data.substr(0, 64);
+        else if (eventType === EventTypes.DUD_HOST_REPORT && eventData) {
+            const candidateId = eventData.substr(0, 64);
 
             return {
                 name: EvernodeEvents.DudHostReported,
@@ -12449,8 +12439,8 @@ class BaseEvernodeClient {
         if (this.xrplAcc.address === this.config.registryAddress)
             throw 'Invalid function call';
 
-        let memoData = Buffer.allocUnsafe(20);
-        codec.decodeAccountID(hostAddress).copy(memoData);
+        let paramData = Buffer.allocUnsafe(20);
+        codec.decodeAccountID(hostAddress).copy(paramData);
 
         // To obtain registration NFT Page Keylet and index.
         const hostAcc = new XrplAccount(hostAddress, null, { xrplApi: this.xrplApi });
@@ -12460,9 +12450,13 @@ class BaseEvernodeClient {
                 XrplConstants.MIN_XRP_AMOUNT,
                 XrplConstants.XRP,
                 null,
-                [
-                    { type: MemoTypes.DEAD_HOST_PRUNE, format: MemoFormats.HEX, data: memoData.toString('hex') }
-                ]);
+                null,
+                {
+                    hookParams: [
+                        { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.DEAD_HOST_PRUNE },
+                        { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: paramData.toString('hex') }
+                    ]
+                });
         } else
             throw "No Registration URI token was found for the Host account."
 
@@ -12615,10 +12609,11 @@ class BaseEvernodeClient {
         }
 
         const uniqueId = StateHelpers.getNewHookCandidateId(hashesBuf);
-        const memoBuf = Buffer.alloc(CANDIDATE_PROPOSE_MEMO_SIZE);
-        Buffer.from(uniqueId, 'hex').copy(memoBuf, CANDIDATE_PROPOSE_UNIQUE_ID_MEMO_OFFSET);
-        Buffer.from(shortName.substr(0, 20), "utf-8").copy(memoBuf, CANDIDATE_PROPOSE_SHORT_NAME_MEMO_OFFSET);
-        Buffer.from(keylets.join(''), 'hex').copy(memoBuf, CANDIDATE_PROPOSE_KEYLETS_MEMO_OFFSET);
+        const paramBuf = Buffer.alloc(CANDIDATE_PROPOSE_PARAM_SIZE);
+        hashesBuf.copy(paramBuf, CANDIDATE_PROPOSE_HASHES_PARAM_OFFSET);
+        Buffer.from(keylets.join(''), 'hex').copy(paramBuf, CANDIDATE_PROPOSE_KEYLETS_PARAM_OFFSET);
+        Buffer.from(uniqueId, 'hex').copy(paramBuf, CANDIDATE_PROPOSE_UNIQUE_ID_PARAM_OFFSET);
+        Buffer.from(shortName.substr(0, 20), "utf-8").copy(paramBuf, CANDIDATE_PROPOSE_SHORT_NAME_PARAM_OFFSET);
 
         // Get the proposal fee. Proposal fee is current epochs moment worth of rewards.
         const proposalFee = EvernodeHelpers.getEpochRewardQuota(this.config.rewardInfo.epoch, this.config.rewardConfiguration.firstEpochRewardQuota);
@@ -12627,11 +12622,15 @@ class BaseEvernodeClient {
             proposalFee.toString(),
             EvernodeConstants.EVR,
             this.config.evrIssuerAddress,
-            [
-                { type: MemoTypes.CANDIDATE_PROPOSE, format: MemoFormats.HEX, data: hashesBuf.toString('hex').toUpperCase() },
-                { type: MemoTypes.CANDIDATE_PROPOSE_REF, format: MemoFormats.HEX, data: memoBuf.toString('hex').toUpperCase() }
-            ],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.CANDIDATE_PROPOSE },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_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
+            });
 
         return uniqueId;
     }
@@ -12648,10 +12647,14 @@ class BaseEvernodeClient {
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [
-                { type: MemoTypes.CANDIDATE_WITHDRAW, format: MemoFormats.HEX, data: candidateIdBuf.toString('hex').toUpperCase() }
-            ],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.CANDIDATE_WITHDRAW },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: candidateIdBuf.toString('hex').toUpperCase() }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     /**
@@ -12670,10 +12673,14 @@ class BaseEvernodeClient {
             proposalFee.toString(),
             EvernodeConstants.EVR,
             this.config.evrIssuerAddress,
-            [
-                { type: MemoTypes.DUD_HOST_REPORT, format: MemoFormats.HEX, data: candidateId }
-            ],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.DUD_HOST_REPORT },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: candidateId }
+                ],
+                ...options.transactionOptions
+            });
     }
 }
 
@@ -12688,14 +12695,14 @@ module.exports = {
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const { Buffer } = __nccwpck_require__(4300);
-const { MemoTypes, MemoFormats } = __nccwpck_require__(9849);
+const { EventTypes, HookParamKeys } = __nccwpck_require__(9849);
 const { StateHelpers } = __nccwpck_require__(3860);
 const { XrplConstants } = __nccwpck_require__(3307);
 const { BaseEvernodeClient } = __nccwpck_require__(6263);
 
-const CANDIDATE_VOTE_UNIQUE_ID_MEMO_OFFSET = 0;
-const CANDIDATE_VOTE_VALUE_MEMO_OFFSET = 32;
-const CANDIDATE_VOTE_MEMO_SIZE = 33;
+const CANDIDATE_VOTE_UNIQUE_ID_PARAM_OFFSET = 0;
+const CANDIDATE_VOTE_VALUE_PARAM_OFFSET = 32;
+const CANDIDATE_VOTE_PARAM_SIZE = 33;
 
 const FoundationEvents = {}
 
@@ -12736,18 +12743,22 @@ class FoundationClient extends BaseEvernodeClient {
         if (this.xrplAcc.address !== this.config.foundationAddress)
             throw `Invalid foundation address ${this.xrplAcc.address}.`;
 
-        const voteBuf = Buffer.alloc(CANDIDATE_VOTE_MEMO_SIZE);
-        Buffer.from(candidateId, 'hex').copy(voteBuf, CANDIDATE_VOTE_UNIQUE_ID_MEMO_OFFSET);
-        voteBuf.writeUInt8(vote, CANDIDATE_VOTE_VALUE_MEMO_OFFSET)
+        const voteBuf = Buffer.alloc(CANDIDATE_VOTE_PARAM_SIZE);
+        Buffer.from(candidateId, 'hex').copy(voteBuf, CANDIDATE_VOTE_UNIQUE_ID_PARAM_OFFSET);
+        voteBuf.writeUInt8(vote, CANDIDATE_VOTE_VALUE_PARAM_OFFSET)
 
         return await this.xrplAcc.makePayment(this.config.heartbeatAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [
-                { type: MemoTypes.CANDIDATE_VOTE, format: MemoFormats.HEX, data: voteBuf.toString('hex').toUpperCase() }
-            ],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.CANDIDATE_VOTE },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: voteBuf.toString('hex').toUpperCase() }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     async reportDudHost(hostAddress, options = {}) {
@@ -12803,10 +12814,14 @@ class FoundationClient extends BaseEvernodeClient {
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [
-                { type: MemoTypes.GOVERNANCE_MODE_CHANGE, format: MemoFormats.HEX, data: modeBuf.toString('hex').toUpperCase() }
-            ],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.GOVERNANCE_MODE_CHANGE },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: modeBuf.toString('hex').toUpperCase() }
+                ],
+                ...options.transactionOptions
+            });
     }
 }
 
@@ -12993,7 +13008,7 @@ module.exports = {
 
 const { XrplConstants } = __nccwpck_require__(3307);
 const { BaseEvernodeClient } = __nccwpck_require__(6263);
-const { EvernodeEvents, EvernodeConstants, MemoFormats, MemoTypes, ErrorCodes } = __nccwpck_require__(9849);
+const { EvernodeEvents, EvernodeConstants, MemoFormats, EventTypes, ErrorCodes, HookParamKeys } = __nccwpck_require__(9849);
 const { XrplAccount } = __nccwpck_require__(9329);
 const { EncryptionHelper } = __nccwpck_require__(4832);
 const { Buffer } = __nccwpck_require__(4300);
@@ -13010,28 +13025,28 @@ 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;
+const HOST_COUNTRY_CODE_PARAM_OFFSET = 0;
+const HOST_CPU_MICROSEC_PARAM_OFFSET = 2;
+const HOST_RAM_MB_PARAM_OFFSET = 6;
+const HOST_DISK_MB_PARAM_OFFSET = 10;
+const HOST_TOT_INS_COUNT_PARAM_OFFSET = 14;
+const HOST_CPU_MODEL_NAME_PARAM_OFFSET = 18;
+const HOST_CPU_COUNT_PARAM_OFFSET = 58;
+const HOST_CPU_SPEED_PARAM_OFFSET = 60;
+const HOST_DESCRIPTION_PARAM_OFFSET = 62;
+const HOST_EMAIL_ADDRESS_PARAM_OFFSET = 88;
+const HOST_REG_PARAM_SIZE = 128;
+
+const HOST_UPDATE_TOKEN_ID_PARAM_OFFSET = 0;
+const HOST_UPDATE_COUNTRY_CODE_PARAM_OFFSET = 32;
+const HOST_UPDATE_CPU_MICROSEC_PARAM_OFFSET = 34;
+const HOST_UPDATE_RAM_MB_PARAM_OFFSET = 38;
+const HOST_UPDATE_DISK_MB_PARAM_OFFSET = 42;
+const HOST_UPDATE_TOT_INS_COUNT_PARAM_OFFSET = 46;
+const HOST_UPDATE_ACT_INS_COUNT_PARAM_OFFSET = 50;
+const HOST_UPDATE_DESCRIPTION_PARAM_OFFSET = 54;
+const HOST_UPDATE_VERSION_PARAM_OFFSET = 80;
+const HOST_UPDATE_PARAM_SIZE = 83;
 
 const VOTE_VALIDATION_ERR = "VOTE_VALIDATION_ERR";
 
@@ -13209,24 +13224,30 @@ class HostClient extends BaseEvernodeClient {
         }
 
         // <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 paramBuf = Buffer.alloc(HOST_REG_PARAM_SIZE, 0);
+        Buffer.from(countryCode.substr(0, 2), "utf-8").copy(paramBuf, HOST_COUNTRY_CODE_PARAM_OFFSET);
+        paramBuf.writeUInt32LE(cpuMicroSec, HOST_CPU_MICROSEC_PARAM_OFFSET);
+        paramBuf.writeUInt32LE(ramMb, HOST_RAM_MB_PARAM_OFFSET);
+        paramBuf.writeUInt32LE(diskMb, HOST_DISK_MB_PARAM_OFFSET);
+        paramBuf.writeUInt32LE(totalInstanceCount, HOST_TOT_INS_COUNT_PARAM_OFFSET);
+        Buffer.from(cpuModel.substr(0, 40), "utf-8").copy(paramBuf, HOST_CPU_MODEL_NAME_PARAM_OFFSET);
+        paramBuf.writeUInt16LE(cpuCount, HOST_CPU_COUNT_PARAM_OFFSET);
+        paramBuf.writeUInt16LE(cpuSpeed, HOST_CPU_SPEED_PARAM_OFFSET);
+        Buffer.from(description.substr(0, 26), "utf-8").copy(paramBuf, HOST_DESCRIPTION_PARAM_OFFSET);
+        Buffer.from(emailAddress.substr(0, 40), "utf-8").copy(paramBuf, HOST_EMAIL_ADDRESS_PARAM_OFFSET);
 
         const tx = await this.xrplAcc.makePayment(this.config.registryAddress,
             (transferredNFTokenId) ? EvernodeConstants.NOW_IN_EVRS : this.config.hostRegFee.toString(),
             EvernodeConstants.EVR,
             this.config.evrIssuerAddress,
-            [{ type: MemoTypes.HOST_REG, format: MemoFormats.HEX, data: memoBuf.toString('hex') }],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.HOST_REG },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: paramBuf.toString('hex').toUpperCase() }
+                ],
+                ...options.transactionOptions
+            });
 
         console.log('Waiting for the sell offer', tx.id)
         let sellOffer = null;
@@ -13278,54 +13299,62 @@ class HostClient extends BaseEvernodeClient {
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [
-                { type: MemoTypes.HOST_DEREG, format: MemoFormats.HEX, data: regUriToken.index }
-            ],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.HOST_DEREG },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: regUriToken.index }
+                ],
+                ...options.transactionOptions
+            });
 
         return await this.isRegistered();
     }
 
     async updateRegInfo(activeInstanceCount = null, version = null, totalInstanceCount = null, tokenID = null, countryCode = null, cpuMicroSec = null, ramMb = null, diskMb = null, description = null, options = {}) {
         // <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);
+        const paramBuf = Buffer.alloc(HOST_UPDATE_PARAM_SIZE, 0);
         if (tokenID)
-            Buffer.from(tokenID.substr(0, 32), "hex").copy(memoBuf, HOST_UPDATE_TOKEN_ID_MEMO_OFFSET);
+            Buffer.from(tokenID.substr(0, 32), "hex").copy(paramBuf, HOST_UPDATE_TOKEN_ID_PARAM_OFFSET);
         if (countryCode)
-            Buffer.from(countryCode.substr(0, 2), "utf-8").copy(memoBuf, HOST_UPDATE_COUNTRY_CODE_MEMO_OFFSET);
+            Buffer.from(countryCode.substr(0, 2), "utf-8").copy(paramBuf, HOST_UPDATE_COUNTRY_CODE_PARAM_OFFSET);
         if (cpuMicroSec)
-            memoBuf.writeUInt32BE(cpuMicroSec, HOST_UPDATE_CPU_MICROSEC_MEMO_OFFSET);
+            paramBuf.writeUInt32LE(cpuMicroSec, HOST_UPDATE_CPU_MICROSEC_PARAM_OFFSET);
         if (ramMb)
-            memoBuf.writeUInt32BE(ramMb, HOST_UPDATE_RAM_MB_MEMO_OFFSET);
+            paramBuf.writeUInt32LE(ramMb, HOST_UPDATE_RAM_MB_PARAM_OFFSET);
         if (diskMb)
-            memoBuf.writeUInt32BE(diskMb, HOST_UPDATE_DISK_MB_MEMO_OFFSET);
+            paramBuf.writeUInt32LE(diskMb, HOST_UPDATE_DISK_MB_PARAM_OFFSET);
         if (totalInstanceCount)
-            memoBuf.writeUInt32BE(totalInstanceCount, HOST_UPDATE_TOT_INS_COUNT_MEMO_OFFSET);
+            paramBuf.writeUInt32LE(totalInstanceCount, HOST_UPDATE_TOT_INS_COUNT_PARAM_OFFSET);
         if (activeInstanceCount)
-            memoBuf.writeUInt32BE(activeInstanceCount, HOST_UPDATE_ACT_INS_COUNT_MEMO_OFFSET);
+            paramBuf.writeUInt32LE(activeInstanceCount, HOST_UPDATE_ACT_INS_COUNT_PARAM_OFFSET);
         if (description)
-            Buffer.from(description.substr(0, 26), "utf-8").copy(memoBuf, HOST_UPDATE_DESCRIPTION_MEMO_OFFSET);
+            Buffer.from(description.substr(0, 26), "utf-8").copy(paramBuf, HOST_UPDATE_DESCRIPTION_PARAM_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);
+            paramBuf.writeUInt8(components[0], HOST_UPDATE_VERSION_PARAM_OFFSET);
+            paramBuf.writeUInt8(components[1], HOST_UPDATE_VERSION_PARAM_OFFSET + 1);
+            paramBuf.writeUInt8(components[2], HOST_UPDATE_VERSION_PARAM_OFFSET + 2);
         }
 
         return await this.xrplAcc.makePayment(this.config.registryAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            [
-                { type: MemoTypes.HOST_UPDATE_INFO, format: MemoFormats.HEX, data: memoBuf.toString('hex') }
-            ],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.HOST_UPDATE_INFO },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: paramBuf.toString('hex') }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     async heartbeat(voteInfo = {}, options = {}) {
-        let data = "";
+        let data;
         // Prepare voteInfo
         if (Object.keys(voteInfo).length > 1) {
             let voteBuf = Buffer.alloc(33);
@@ -13339,10 +13368,14 @@ class HostClient extends BaseEvernodeClient {
                 XrplConstants.MIN_XRP_AMOUNT,
                 XrplConstants.XRP,
                 null,
-                [
-                    { type: MemoTypes.HEARTBEAT, format: MemoFormats.HEX, data: data }
-                ],
-                options.transactionOptions);
+                null,
+                {
+                    hookParams: [
+                        { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.HEARTBEAT },
+                        ...(data ? [{ name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: data }] : [])
+                    ],
+                    ...options.transactionOptions
+                });
             return res;
         }
         catch (e) {
@@ -13367,74 +13400,94 @@ class HostClient extends BaseEvernodeClient {
             throw "Tenant encryption key not set.";
 
         const encrypted = await EncryptionHelper.encrypt(encKey, instanceInfo);
-        const memos = [
-            { type: MemoTypes.ACQUIRE_SUCCESS, format: MemoFormats.BASE64, data: encrypted },
-            { type: MemoTypes.ACQUIRE_REF, format: MemoFormats.HEX, data: txHash }];
-
         return this.xrplAcc.makePayment(tenantAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            memos,
-            options.transactionOptions);
+            [
+                { type: EventTypes.ACQUIRE_SUCCESS, format: MemoFormats.BASE64, data: encrypted }
+            ],
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.ACQUIRE_SUCCESS },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     async acquireError(txHash, tenantAddress, leaseAmount, reason, options = {}) {
 
-        const memos = [
-            { type: MemoTypes.ACQUIRE_ERROR, format: MemoFormats.JSON, data: { type: ErrorCodes.ACQUIRE_ERR, reason: reason } },
-            { type: MemoTypes.ACQUIRE_REF, format: MemoFormats.HEX, data: txHash }];
-
         return this.xrplAcc.makePayment(tenantAddress,
             leaseAmount.toString(),
             EvernodeConstants.EVR,
             this.config.evrIssuerAddress,
-            memos,
-            options.transactionOptions);
+            [
+                { type: EventTypes.ACQUIRE_ERROR, format: MemoFormats.JSON, data: { type: ErrorCodes.ACQUIRE_ERR, reason: reason } }
+            ],
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.ACQUIRE_ERROR },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     async extendSuccess(txHash, tenantAddress, expiryMoment, options = {}) {
         let buf = Buffer.allocUnsafe(4);
         buf.writeUInt32BE(expiryMoment);
 
-        const memos = [
-            { type: MemoTypes.EXTEND_SUCCESS, format: MemoFormats.HEX, data: buf.toString('hex') },
-            { type: MemoTypes.EXTEND_REF, format: MemoFormats.HEX, data: txHash }];
-
         return this.xrplAcc.makePayment(tenantAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
-            memos,
-            options.transactionOptions);
+            [
+                { type: EventTypes.EXTEND_SUCCESS, format: MemoFormats.HEX, data: buf.toString('hex') }
+            ],
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.EXTEND_SUCCESS },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     async extendError(txHash, tenantAddress, reason, refund, options = {}) {
 
-        const memos = [
-            { type: MemoTypes.EXTEND_ERROR, format: MemoFormats.JSON, data: { type: ErrorCodes.EXTEND_ERR, reason: reason } },
-            { type: MemoTypes.EXTEND_REF, format: MemoFormats.HEX, data: txHash }];
-
         // Required to refund the paid EVR amount as the offer extention is not successfull.
         return this.xrplAcc.makePayment(tenantAddress,
             refund.toString(),
             EvernodeConstants.EVR,
             this.config.evrIssuerAddress,
-            memos,
-            options.transactionOptions);
+            [
+                { type: EventTypes.EXTEND_ERROR, format: MemoFormats.JSON, data: { type: ErrorCodes.EXTEND_ERR, reason: reason } }
+            ],
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.EXTEND_ERROR },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     async refundTenant(txHash, tenantAddress, refundAmount, options = {}) {
-        const memos = [
-            { type: MemoTypes.REFUND, format: '', data: '' },
-            { type: MemoTypes.REFUND_REF, format: MemoFormats.HEX, data: txHash }];
-
         return this.xrplAcc.makePayment(tenantAddress,
             refundAmount.toString(),
             EvernodeConstants.EVR,
             this.config.evrIssuerAddress,
-            memos,
-            options.transactionOptions);
+            [
+                { type: EventTypes.REFUND, format: '', data: '' }
+            ],
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.REFUND },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: txHash }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     async requestRebate(options = {}) {
@@ -13443,9 +13496,14 @@ class HostClient extends BaseEvernodeClient {
             XrplConstants.XRP,
             null,
             [
-                { type: MemoTypes.HOST_REBATE, format: "", data: "" }
+                { type: EventTypes.HOST_REBATE, format: "", data: "" }
             ],
-            options.transactionOptions);
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.HOST_REBATE }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     getLeaseNFTokenIdPrefix() {
@@ -13469,8 +13527,7 @@ class HostClient extends BaseEvernodeClient {
                 throw "The transferee is already registered in Evernode.";
         }
 
-        let memoData = Buffer.allocUnsafe(20);
-        codec.decodeAccountID(transfereeAddress).copy(memoData);
+        const paramData = codec.decodeAccountID(transfereeAddress);
 
         const regUriToken = await this.getRegistrationUriToken();
 
@@ -13479,10 +13536,14 @@ class HostClient extends BaseEvernodeClient {
             XrplConstants.XRP,
             null,
             this.config.registryAddress,
-            [
-                { type: MemoTypes.HOST_TRANSFER, format: MemoFormats.HEX, data: memoData.toString('hex') }
-            ],
-            options.transactionOptions);
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.HOST_TRANSFER },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: paramData.toString('hex') }
+                ],
+                ...options.transactionOptions
+            });
 
         let token = null;
         let attempts = 0;
@@ -13546,7 +13607,7 @@ module.exports = {
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const { BaseEvernodeClient } = __nccwpck_require__(6263);
-const { EvernodeEvents, MemoFormats, MemoTypes, ErrorCodes, ErrorReasons, EvernodeConstants } = __nccwpck_require__(9849);
+const { EvernodeEvents, MemoFormats, EventTypes, ErrorCodes, ErrorReasons, EvernodeConstants, HookParamKeys } = __nccwpck_require__(9849);
 const { EncryptionHelper } = __nccwpck_require__(4832);
 const { XrplAccount } = __nccwpck_require__(9329);
 const { UtilHelpers } = __nccwpck_require__(6687);
@@ -13642,7 +13703,17 @@ class TenantClient extends BaseEvernodeClient {
             ephemPrivateKey: options.ephemPrivateKey // Must be null or 32 bytes.
         });
 
-        return this.xrplAcc.buyURIToken(buyUriOffer, [{ type: MemoTypes.ACQUIRE_LEASE, format: MemoFormats.BASE64, data: ecrypted }], options.transactionOptions);
+        return this.xrplAcc.buyURIToken(
+            buyUriOffer,
+            [
+                { type: EventTypes.ACQUIRE_LEASE, format: MemoFormats.BASE64, data: ecrypted }
+            ],
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.ACQUIRE_LEASE }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     /**
@@ -13666,6 +13737,7 @@ class TenantClient extends BaseEvernodeClient {
                 const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
                 for (let t of txList) {
                     t.tx.Memos = TransactionHelper.deserializeMemos(t.tx?.Memos);
+                    t.tx.HookParameters = TransactionHelper.deserializeHookParams(t.tx?.HookParameters);
                     const res = await this.extractEvernodeEvent(t.tx);
                     if ((res?.name === EvernodeEvents.AcquireSuccess || res?.name === EvernodeEvents.AcquireError) && res?.data?.acquireRefId === tx.id) {
                         clearTimeout(failTimeout);
@@ -13728,8 +13800,18 @@ class TenantClient extends BaseEvernodeClient {
      */
     async extendLeaseSubmit(hostAddress, amount, tokenID, options = {}) {
         const host = await this.getLeaseHost(hostAddress);
-        return this.xrplAcc.makePayment(host.address, amount.toString(), EvernodeConstants.EVR, this.config.evrIssuerAddress,
-            [{ type: MemoTypes.EXTEND_LEASE, format: MemoFormats.HEX, data: tokenID }], options.transactionOptions);
+        return this.xrplAcc.makePayment(
+            host.address, amount.toString(),
+            EvernodeConstants.EVR,
+            this.config.evrIssuerAddress,
+            null,
+            {
+                hookParams: [
+                    { name: HookParamKeys.PARAM_EVENT_TYPE_KEY, value: EventTypes.EXTEND_LEASE },
+                    { name: HookParamKeys.PARAM_EVENT_DATA1_KEY, value: tokenID }
+                ],
+                ...options.transactionOptions
+            });
     }
 
     /**
@@ -13753,6 +13835,7 @@ class TenantClient extends BaseEvernodeClient {
                 const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
                 for (let t of txList) {
                     t.tx.Memos = TransactionHelper.deserializeMemos(t.tx.Memos);
+                    t.tx.HookParameters = TransactionHelper.deserializeHookParams(t.tx?.HookParameters);
                     const res = await this.extractEvernodeEvent(t.tx);
                     if ((res?.name === TenantEvents.ExtendSuccess || res?.name === TenantEvents.ExtendError) && res?.data?.extendRefId === tx.id) {
                         clearTimeout(failTimeout);
@@ -13795,7 +13878,7 @@ class TenantClient extends BaseEvernodeClient {
             const uriToken = (await this.xrplAcc.getURITokens())?.find(n => n.index == tokenID);
 
             if (!uriToken) {
-                reject({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.NO_NFT, content: 'Could not find the uri token for lease extend request.' });
+                reject({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.NO_TOKEN, content: 'Could not find the uri token for lease extend request.' });
                 return;
             }
 
@@ -14316,7 +14399,7 @@ const EvernodeConstants = {
     }
 }
 
-const MemoTypes = {
+const EventTypes = {
     ACQUIRE_LEASE: 'evnAcquireLease',
     ACQUIRE_SUCCESS: 'evnAcquireSuccess',
     ACQUIRE_ERROR: 'evnAcquireError',
@@ -14361,7 +14444,7 @@ const ErrorCodes = {
 const ErrorReasons = {
     TRANSACTION_FAILURE: 'TRANSACTION_FAILURE',
     NO_OFFER: 'NO_OFFER',
-    NO_NFT: 'NO_NFT',
+    NO_TOKEN: 'NO_TOKEN',
     INTERNAL_ERR: 'INTERNAL_ERR',
     TIMEOUT: 'TIMEOUT',
     HOST_INVALID: 'HOST_INVALID',
@@ -14404,6 +14487,14 @@ const HookStateKeys = {
     PREFIX_CANDIDATE_ID: "45565206",
 }
 
+// All keys are prefixed with 'EVR' (0x455652)
+const HookParamKeys = {
+    PARAM_STATE_HOOK_KEY: "4556520100000000000000000000000000000000000000000000000000000001",
+    PARAM_EVENT_TYPE_KEY: "4556520100000000000000000000000000000000000000000000000000000002",
+    PARAM_EVENT_DATA1_KEY: "4556520100000000000000000000000000000000000000000000000000000003",
+    PARAM_EVENT_DATA2_KEY: "4556520100000000000000000000000000000000000000000000000000000004",
+}
+
 const EvernodeEvents = {
     HostRegistered: "HostRegistered",
     HostDeregistered: "HostDeregistered",
@@ -14439,13 +14530,14 @@ const URITokenTypes = {
 
 module.exports = {
     EvernodeConstants,
-    MemoTypes,
+    EventTypes,
     MemoFormats,
     ErrorCodes,
     ErrorReasons,
     HookStateKeys,
     EvernodeEvents,
-    URITokenTypes
+    URITokenTypes,
+    HookParamKeys
 }
 
 /***/ }),
@@ -14888,7 +14980,7 @@ const { FoundationClient, FoundationEvents } = __nccwpck_require__(2466);
 const { XrplApi } = __nccwpck_require__(1850);
 const { XrplApiEvents, XrplConstants } = __nccwpck_require__(3307);
 const { XrplAccount } = __nccwpck_require__(9329);
-const { EvernodeConstants, HookStateKeys, MemoTypes } = __nccwpck_require__(9849);
+const { EvernodeConstants, HookStateKeys, HookParamKeys, EventTypes } = __nccwpck_require__(9849);
 const { XflHelpers } = __nccwpck_require__(3243);
 const { FirestoreHandler } = __nccwpck_require__(9718);
 const { StateHelpers } = __nccwpck_require__(3860);
@@ -14924,7 +15016,8 @@ module.exports = {
     TransactionHelper,
     EncryptionHelper,
     HookStateKeys,
-    MemoTypes,
+    HookParamKeys,
+    EventTypes,
     HookTypes,
     HookClientFactory,
     EvernodeHelpers
@@ -15081,19 +15174,19 @@ class StateHelpers {
             uriTokenId: stateDataBuf.slice(HOST_TOKEN_ID_OFFSET, HOST_COUNTRY_CODE_OFFSET).toString('hex').toUpperCase(),
             countryCode: stateDataBuf.slice(HOST_COUNTRY_CODE_OFFSET, HOST_RESERVED_OFFSET).toString(),
             description: stateDataBuf.slice(HOST_DESCRIPTION_OFFSET, HOST_REG_LEDGER_OFFSET).toString().replace(/\0/g, ''),
-            registrationLedger: Number(stateDataBuf.readBigUInt64BE(HOST_REG_LEDGER_OFFSET)),
-            registrationFee: Number(stateDataBuf.readBigUInt64BE(HOST_REG_FEE_OFFSET)),
-            maxInstances: stateDataBuf.readUInt32BE(HOST_TOT_INS_COUNT_OFFSET),
-            activeInstances: stateDataBuf.readUInt32BE(HOST_ACT_INS_COUNT_OFFSET),
-            lastHeartbeatIndex: Number(stateDataBuf.readBigUInt64BE(HOST_HEARTBEAT_TIMESTAMP_OFFSET)),
+            registrationLedger: Number(stateDataBuf.readBigUInt64LE(HOST_REG_LEDGER_OFFSET)),
+            registrationFee: Number(stateDataBuf.readBigUInt64LE(HOST_REG_FEE_OFFSET)),
+            maxInstances: stateDataBuf.readUInt32LE(HOST_TOT_INS_COUNT_OFFSET),
+            activeInstances: stateDataBuf.readUInt32LE(HOST_ACT_INS_COUNT_OFFSET),
+            lastHeartbeatIndex: Number(stateDataBuf.readBigUInt64LE(HOST_HEARTBEAT_TIMESTAMP_OFFSET)),
             version: `${stateDataBuf.readUInt8(HOST_VERSION_OFFSET)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 1)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 2)}`,
             isATransferer: (stateDataBuf.readUInt8(HOST_TRANSFER_FLAG_OFFSET) === PENDING_TRANSFER) ? TRANSFER_STATES.HAS_A_TRANSFER : TRANSFER_STATES.NO_TRANSFER,
-            lastVoteCandidateIdx: stateDataBuf.readUInt32BE(HOST_LAST_VOTE_CANDIDATE_IDX_OFFSET),
-            lastVoteTimestamp: Number(stateDataBuf.readBigUInt64BE(HOST_LAST_VOTE_TIMESTAMP_OFFSET)),
+            lastVoteCandidateIdx: stateDataBuf.readUInt32LE(HOST_LAST_VOTE_CANDIDATE_IDX_OFFSET),
+            lastVoteTimestamp: Number(stateDataBuf.readBigUInt64LE(HOST_LAST_VOTE_TIMESTAMP_OFFSET)),
             supportVoteSent: stateDataBuf.readUInt8(HOST_SUPPORT_VOTE_FLAG_OFFSET)
         }
         if (stateDataBuf.length > HOST_REG_TIMESTAMP_OFFSET)
-            data.registrationTimestamp = Number(stateDataBuf.readBigUInt64BE(HOST_REG_TIMESTAMP_OFFSET));
+            data.registrationTimestamp = Number(stateDataBuf.readBigUInt64LE(HOST_REG_TIMESTAMP_OFFSET));
         return data;
     }
 
@@ -15101,13 +15194,13 @@ class StateHelpers {
         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().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),
-            ramMb: stateDataBuf.readUInt32BE(HOST_RAM_MB_OFFSET),
-            diskMb: stateDataBuf.readUInt32BE(HOST_DISK_MB_OFFSET),
+            cpuCount: stateDataBuf.readUInt16LE(HOST_CPU_COUNT_OFFSET),
+            cpuMHz: stateDataBuf.readUInt16LE(HOST_CPU_SPEED_OFFSET),
+            cpuMicrosec: stateDataBuf.readUInt32LE(HOST_CPU_MICROSEC_OFFSET),
+            ramMb: stateDataBuf.readUInt32LE(HOST_RAM_MB_OFFSET),
+            diskMb: stateDataBuf.readUInt32LE(HOST_DISK_MB_OFFSET),
             email: stateDataBuf.slice(HOST_EMAIL_ADDRESS_OFFSET, HOST_EMAIL_ADDRESS_OFFSET + HOST_EMAIL_ADDRESS_LEN).toString().toString().replace(/\0/g, ''),
-            accumulatedRewardAmount: XflHelpers.toString(stateDataBuf.readBigInt64BE(HOST_ACCUMULATED_REWARD_OFFSET))
+            accumulatedRewardAmount: XflHelpers.toString(stateDataBuf.readBigInt64LE(HOST_ACCUMULATED_REWARD_OFFSET))
         }
     }
 
@@ -15117,7 +15210,7 @@ class StateHelpers {
             futureOwnerAddress: codec.encodeAccountID(stateKeyBuf.slice(12)),
             prevHostAddressKey: this.generateHostAddrStateKey(prevHostClassicAddress),
             prevHostAddress: prevHostClassicAddress,
-            transferLedgerIdx: Number(stateDataBuf.readBigUInt64BE(TRANSFER_LEDGER_IDX_OFFSET)),
+            transferLedgerIdx: Number(stateDataBuf.readBigUInt64LE(TRANSFER_LEDGER_IDX_OFFSET)),
             transferredNfTokenId: stateDataBuf.slice(TRANSFERRED_NFT_ID_OFFSET, 60).toString('hex').toUpperCase()
         }
     }
@@ -15155,14 +15248,14 @@ class StateHelpers {
 
         return {
             ownerAddress: codec.encodeAccountID(stateDataBuf.slice(CANDIDATE_OWNER_ADDRESS_OFFSET, CANDIDATE_IDX_OFFSET)),
-            index: stateDataBuf.readUInt32BE(CANDIDATE_IDX_OFFSET),
+            index: stateDataBuf.readUInt32LE(CANDIDATE_IDX_OFFSET),
             shortName: stateDataBuf.slice(CANDIDATE_SHORT_NAME_OFFSET, CANDIDATE_CREATED_TIMESTAMP_OFFSET).toString().replace(/\x00+$/, ''), // Remove trailing \x00 characters.
-            createdTimestamp: Number(stateDataBuf.readBigUInt64BE(CANDIDATE_CREATED_TIMESTAMP_OFFSET)),
-            proposalFee: XflHelpers.toString(stateDataBuf.readBigInt64BE(CANDIDATE_PROPOSAL_FEE_OFFSET)),
-            positiveVoteCount: stateDataBuf.readUInt32BE(CANDIDATE_POSITIVE_VOTE_COUNT_OFFSET),
-            lastVoteTimestamp: Number(stateDataBuf.readBigUInt64BE(CANDIDATE_LAST_VOTE_TIMESTAMP_OFFSET)),
+            createdTimestamp: Number(stateDataBuf.readBigUInt64LE(CANDIDATE_CREATED_TIMESTAMP_OFFSET)),
+            proposalFee: XflHelpers.toString(stateDataBuf.readBigInt64LE(CANDIDATE_PROPOSAL_FEE_OFFSET)),
+            positiveVoteCount: stateDataBuf.readUInt32LE(CANDIDATE_POSITIVE_VOTE_COUNT_OFFSET),
+            lastVoteTimestamp: Number(stateDataBuf.readBigUInt64LE(CANDIDATE_LAST_VOTE_TIMESTAMP_OFFSET)),
             status: status,
-            statusChangeTimestamp: Number(stateDataBuf.readBigUInt64BE(CANDIDATE_STATUS_CHANGE_TIMESTAMP_OFFSET)),
+            statusChangeTimestamp: Number(stateDataBuf.readBigUInt64LE(CANDIDATE_STATUS_CHANGE_TIMESTAMP_OFFSET)),
             foundationVoteStatus: stateDataBuf.readUInt8(CANDIDATE_FOUNDATION_VOTE_STATUS_OFFSET) === EvernodeConstants.CandidateStatuses.CANDIDATE_SUPPORTED ? 'supported' : 'rejected'
         }
     }
@@ -15222,7 +15315,7 @@ class StateHelpers {
             return {
                 type: this.StateTypes.SIGLETON,
                 key: hexKey,
-                value: stateData.readUInt32BE()
+                value: stateData.readUInt32LE()
             }
         }
         else if (Buffer.from(HookStateKeys.MOMENT_BASE_INFO, 'hex').compare(stateKey) === 0) {
@@ -15230,8 +15323,8 @@ class StateHelpers {
                 type: this.StateTypes.SIGLETON,
                 key: hexKey,
                 value: {
-                    baseIdx: Number(stateData.readBigUInt64BE(MOMENT_BASE_POINT_OFFSET)),
-                    baseTransitionMoment: stateData.length > MOMENT_AT_TRANSITION_OFFSET ? stateData.readUInt32BE(MOMENT_AT_TRANSITION_OFFSET) : 0,
+                    baseIdx: Number(stateData.readBigUInt64LE(MOMENT_BASE_POINT_OFFSET)),
+                    baseTransitionMoment: stateData.length > MOMENT_AT_TRANSITION_OFFSET ? stateData.readUInt32LE(MOMENT_AT_TRANSITION_OFFSET) : 0,
                     momentType: (stateData.length <= MOMENT_TYPE_OFFSET || stateData.readUInt8(MOMENT_TYPE_OFFSET) === MOMENT_TYPES.LEDGER) ? 'ledger' : 'timestamp'
                 }
             }
@@ -15240,7 +15333,7 @@ class StateHelpers {
             return {
                 type: this.StateTypes.SIGLETON,
                 key: hexKey,
-                value: Number(stateData.readBigUInt64BE())
+                value: Number(stateData.readBigUInt64LE())
             }
         }
         else if (Buffer.from(HookStateKeys.REGISTRY_ADDR, 'hex').compare(stateKey) === 0 ||
@@ -15259,14 +15352,14 @@ class StateHelpers {
             return {
                 type: this.StateTypes.CONFIGURATION,
                 key: hexKey,
-                value: stateData.readUInt16BE()
+                value: stateData.readUInt16LE()
             }
         }
         else if (Buffer.from(HookStateKeys.MINT_LIMIT, 'hex').compare(stateKey) === 0 || Buffer.from(HookStateKeys.FIXED_REG_FEE, 'hex').compare(stateKey) === 0) {
             return {
                 type: this.StateTypes.CONFIGURATION,
                 key: hexKey,
-                value: Number(stateData.readBigUInt64BE())
+                value: Number(stateData.readBigUInt64LE())
             }
         }
         else if (Buffer.from(HookStateKeys.REWARD_CONFIGURATION, 'hex').compare(stateKey) === 0) {
@@ -15275,10 +15368,10 @@ class StateHelpers {
                 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),
-                    accumulatedRewardFrequency: stateData.readUInt16BE(ACCUMULATED_REWARD_FREQUENCY_OFFSET)
+                    firstEpochRewardQuota: stateData.readUInt32LE(FIRST_EPOCH_REWARD_QUOTA_OFFSET),
+                    epochRewardAmount: stateData.readUInt32LE(EPOCH_REWARD_AMOUNT_OFFSET),
+                    rewardStartMoment: stateData.readUInt32LE(REWARD_START_MOMENT_OFFSET),
+                    accumulatedRewardFrequency: stateData.readUInt16LE(ACCUMULATED_REWARD_FREQUENCY_OFFSET)
                 }
             }
         }
@@ -15288,10 +15381,10 @@ class StateHelpers {
                 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))
+                    savedMoment: stateData.readUInt32LE(SAVED_MOMENT_OFFSET),
+                    prevMomentActiveHostCount: stateData.readUInt32LE(PREV_MOMENT_ACTIVE_HOST_COUNT_OFFSET),
+                    curMomentActiveHostCount: stateData.readUInt32LE(CUR_MOMENT_ACTIVE_HOST_COUNT_OFFSET),
+                    epochPool: XflHelpers.toString(stateData.readBigInt64LE(EPOCH_POOL_OFFSET))
                 }
             }
         }
@@ -15299,7 +15392,7 @@ class StateHelpers {
             return {
                 type: this.StateTypes.CONFIGURATION,
                 key: hexKey,
-                value: stateData.readUInt16BE()
+                value: stateData.readUInt16LE()
             }
         }
         else if (Buffer.from(HookStateKeys.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0) {
@@ -15308,8 +15401,8 @@ class StateHelpers {
                 type: this.StateTypes.CONFIGURATION,
                 key: hexKey,
                 value: {
-                    transitionIndex: Number(stateData.readBigInt64BE(TRANSIT_IDX_OFFSET)),
-                    momentSize: stateData.readUInt16BE(TRANSIT_MOMENT_SIZE_OFFSET),
+                    transitionIndex: Number(stateData.readBigInt64LE(TRANSIT_IDX_OFFSET)),
+                    momentSize: stateData.readUInt16LE(TRANSIT_MOMENT_SIZE_OFFSET),
                     momentType: stateData.readUInt8(TRANSIT_MOMENT_TYPE_OFFSET) === MOMENT_TYPES.LEDGER ? 'ledger' : 'timestamp'
                 }
             }
@@ -15318,7 +15411,7 @@ class StateHelpers {
             return {
                 type: this.StateTypes.CONFIGURATION,
                 key: hexKey,
-                value: Number(stateData.readBigUInt64BE())
+                value: Number(stateData.readBigUInt64LE())
             }
         }
         else if (Buffer.from(HookStateKeys.GOVERNANCE_CONFIGURATION, 'hex').compare(stateKey) === 0) {
@@ -15326,10 +15419,10 @@ class StateHelpers {
                 type: this.StateTypes.CONFIGURATION,
                 key: hexKey,
                 value: {
-                    eligibilityPeriod: stateData.readUInt32BE(ELIGIBILITY_PERIOD_OFFSET),
-                    candidateLifePeriod: stateData.readUInt32BE(CANDIDATE_LIFE_PERIOD_OFFSET),
-                    candidateElectionPeriod: stateData.readUInt32BE(CANDIDATE_ELECTION_PERIOD_OFFSET),
-                    candidateSupportAverage: stateData.readUInt16BE(CANDIDATE_SUPPORT_AVERAGE_OFFSET)
+                    eligibilityPeriod: stateData.readUInt32LE(ELIGIBILITY_PERIOD_OFFSET),
+                    candidateLifePeriod: stateData.readUInt32LE(CANDIDATE_LIFE_PERIOD_OFFSET),
+                    candidateElectionPeriod: stateData.readUInt32LE(CANDIDATE_ELECTION_PERIOD_OFFSET),
+                    candidateSupportAverage: stateData.readUInt16LE(CANDIDATE_SUPPORT_AVERAGE_OFFSET)
                 }
             }
         }
@@ -15354,13 +15447,13 @@ class StateHelpers {
                 key: hexKey,
                 value: {
                     governanceMode: mode,
-                    lastCandidateIdx: stateData.readUInt32BE(LAST_CANDIDATE_IDX_OFFSET),
-                    voteBaseCount: stateData.readUInt32BE(VOTER_BASE_COUNT_OFFSET),
-                    voteBaseCountChangedTimestamp: Number(stateData.readBigUInt64BE(VOTER_BASE_COUNT_CHANGED_TIMESTAMP_OFFSET)),
-                    foundationLastVotedCandidateIdx: stateData.readUInt32BE(FOUNDATION_LAST_VOTED_CANDIDATE_IDX),
-                    foundationLastVotedTimestamp: Number(stateData.readBigUInt64BE(FOUNDATION_LAST_VOTED_TIMESTAMP_OFFSET)),
+                    lastCandidateIdx: stateData.readUInt32LE(LAST_CANDIDATE_IDX_OFFSET),
+                    voteBaseCount: stateData.readUInt32LE(VOTER_BASE_COUNT_OFFSET),
+                    voteBaseCountChangedTimestamp: Number(stateData.readBigUInt64LE(VOTER_BASE_COUNT_CHANGED_TIMESTAMP_OFFSET)),
+                    foundationLastVotedCandidateIdx: stateData.readUInt32LE(FOUNDATION_LAST_VOTED_CANDIDATE_IDX),
+                    foundationLastVotedTimestamp: Number(stateData.readBigUInt64LE(FOUNDATION_LAST_VOTED_TIMESTAMP_OFFSET)),
                     electedProposalUniqueId: stateData.slice(ELECTED_PROPOSAL_UNIQUE_ID_OFFSET, PROPOSAL_ELECTED_TIMESTAMP_OFFSET).toString('hex').toUpperCase(),
-                    proposalElectedTimestamp: Number(stateData.readBigUInt64BE(PROPOSAL_ELECTED_TIMESTAMP_OFFSET)),
+                    proposalElectedTimestamp: Number(stateData.readBigUInt64LE(PROPOSAL_ELECTED_TIMESTAMP_OFFSET)),
                     updatedHookCount: stateData.readUInt8(UPDATED_HOOK_COUNT_OFFSET),
                     supportVoteSent: stateData.readUInt8(FOUNDATION_SUPPORT_VOTE_FLAG_OFFSET)
                 }
@@ -15553,7 +15646,7 @@ module.exports = {
 /***/ 7071:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-const { MemoFormats } = __nccwpck_require__(9849);
+const { MemoFormats, HookParamKeys } = __nccwpck_require__(9849);
 
 class TransactionHelper {
 
@@ -15589,26 +15682,47 @@ class TransactionHelper {
         })
     }
 
+    // Convert hook params from our object type to xrpl lib object type.
+    static formatHookParams(params) {
+        return params ? params.filter(m => m.name).map(m => {
+            return {
+                HookParameter: {
+                    HookParameterName: m.name,
+                    HookParameterValue: m.value ?
+                        (m.name === HookParamKeys.PARAM_EVENT_TYPE_KEY ? TransactionHelper.asciiToHex(m.value) :
+                            m.value.toUpperCase()) : ''
+                }
+            }
+        }) : [];
+    }
+
+    // Convert hook params from xrpl lib object type to our object type.
+    static deserializeHookParams(params) {
+        if (!params)
+            return [];
+
+        return params.filter(m => m.HookParameter).map(m => {
+            return {
+                name: m.HookParameter.HookParameterName,
+                value: m.HookParameter.HookParameterValue ?
+                    (m.HookParameter.HookParameterName === HookParamKeys.PARAM_EVENT_TYPE_KEY ? TransactionHelper.hexToASCII(m.HookParameter.HookParameterValue) :
+                        m.HookParameter.HookParameterValue.toUpperCase()) : '',
+            }
+        })
+    }
+
     static hexToASCII(hex) {
         if (!hex)
             return "";
 
-        let str = "";
-        for (let n = 0; n < hex.length; n += 2) {
-            str += String.fromCharCode(parseInt(hex.substr(n, 2), 16));
-        }
-        return str;
+        return Buffer.from(hex, 'hex').toString();
     }
 
     static asciiToHex(str) {
         if (!str)
             return "";
 
-        let hex = "";
-        for (let n = 0; n < str.length; n++) {
-            hex += str.charCodeAt(n).toString(16)
-        }
-        return hex;
+        return Buffer.from(str).toString('hex').toUpperCase();
     }
 }
 
@@ -15623,28 +15737,12 @@ module.exports = {
 
 const { Buffer } = __nccwpck_require__(4300);
 const { XflHelpers } = __nccwpck_require__(3243);
-const { EvernodeConstants, ErrorReasons } = __nccwpck_require__(9849);
+const { EvernodeConstants } = __nccwpck_require__(9849);
 const { TransactionHelper } = __nccwpck_require__(7071);
 
 // Utility helper functions.
 class UtilHelpers {
 
-    static readUInt(buf, base = 32, isBE = true) {
-        buf = Buffer.from(buf);
-        switch (base) {
-            case (8):
-                return buf.readUInt8();
-            case (16):
-                return isBE ? buf.readUInt16BE() : buf.readUInt16LE();
-            case (32):
-                return isBE ? buf.readUInt32BE() : buf.readUInt32LE();
-            case (64):
-                return isBE ? Number(buf.readBigUInt64BE()) : Number(buf.readBigUInt64LE());
-            default:
-                throw 'Invalid base value';
-        }
-    }
-
     static decodeLeaseNftUri(hexUri) {
         // Get the lease index from the nft URI.
         // <prefix><lease index (uint16)><half of tos hash (16 bytes)><lease amount (uint32)>
@@ -16062,7 +16160,8 @@ class XrplAccount {
             Account: this.address,
             Amount: amountObj,
             Destination: toAddr,
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16079,7 +16178,8 @@ class XrplAccount {
                 issuer: issuer,
                 value: limit
             },
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         };
 
         if (!allowRippling)
@@ -16094,7 +16194,8 @@ class XrplAccount {
             TransactionType: 'SetRegularKey',
             Account: this.address,
             RegularKey: regularKey,
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16131,7 +16232,8 @@ class XrplAccount {
             TakerGets: sellAmountObj,
             TakerPays: forAmountObj,
             Expiration: expiration,
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16146,7 +16248,8 @@ class XrplAccount {
             TakerGets: forAmountObj,
             TakerPays: buyAmountObj,
             Expiration: expiration,
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16155,7 +16258,8 @@ class XrplAccount {
             TransactionType: 'OfferCancel',
             Account: this.address,
             OfferSequence: offerSequence,
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16167,7 +16271,8 @@ class XrplAccount {
             NFTokenTaxon: taxon,
             TransferFee: transferFee,
             Flags: (flags.isBurnable ? 1 : 0) | (flags.isOnlyXRP ? 2 : 0) | (flags.isTrustLine ? 4 : 0) | (flags.isTransferable ? 8 : 0),
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16181,7 +16286,8 @@ class XrplAccount {
             Amount: amountObj,
             Expiration: expiration,
             Flags: 1, // tfSellToken
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         };
 
         return this.#submitAndVerifyTransaction(destination ? { ...tx, Destination: destination } : tx, options);
@@ -16199,7 +16305,8 @@ class XrplAccount {
             Amount: amountObj,
             Expiration: expiration,
             Flags: 0, // Buy offer
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16209,7 +16316,8 @@ class XrplAccount {
             TransactionType: 'NFTokenAcceptOffer',
             Account: this.address,
             NFTokenBuyOffer: offerId,
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16219,7 +16327,8 @@ class XrplAccount {
             TransactionType: 'NFTokenAcceptOffer',
             Account: this.address,
             NFTokenSellOffer: offerId,
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         }, options);
     }
 
@@ -16229,7 +16338,8 @@ class XrplAccount {
             TransactionType: 'NFTokenBurn',
             Account: this.address,
             NFTokenID: nfTokenId,
-            Memos: TransactionHelper.formatMemos(memos)
+            Memos: TransactionHelper.formatMemos(memos),
+            HookParameters: TransactionHelper.formatHookParams(options.hookParams)
         };
 
         return this.#submitAndVerifyTransaction(owner ? { ...tx, Owner: owner } : tx, options);
@@ -16317,7 +16427,7 @@ class XrplAccount {
                 const hookExecRes = txResult.details?.meta?.HookExecutions?.map(o => {
                     return {
                         result: o.HookExecution?.HookResult,
-                        returnCode: o.HookExecution?.HookReturnCode,
+                        returnCode: parseInt(o.HookExecution?.HookReturnCode, 16),
                         message: TransactionHelper.hexToASCII(o.HookExecution?.HookReturnString).replace(/\x00+$/, '')
                     }
                 });
@@ -16362,7 +16472,7 @@ class XrplAccount {
                 const hookExecRes = txResult.details?.meta?.HookExecutions?.map(o => {
                     return {
                         result: o.HookExecution?.HookResult,
-                        returnCode: o.HookExecution?.HookReturnCode,
+                        returnCode: parseInt(o.HookExecution?.HookReturnCode, 16),
                         message: TransactionHelper.hexToASCII(o.HookExecution?.HookReturnString).replace(/\x00+$/, '')
                     }
                 });
@@ -16430,6 +16540,9 @@ class XrplAccount {
         if (memos)
             tx.Memos = TransactionHelper.formatMemos(memos);
 
+        if (options.hookParams)
+            tx.HookParameters = TransactionHelper.formatHookParams(options.hookParams);
+
         return this.#submitAndVerifyTransaction(tx, options);
     }
 
@@ -16444,6 +16557,9 @@ class XrplAccount {
         if (memos)
             tx.Memos = TransactionHelper.formatMemos(memos);
 
+        if (options.hookParams)
+            tx.HookParameters = TransactionHelper.formatHookParams(options.hookParams);
+
         return this.#submitAndVerifyTransaction(tx, options);
     }
 
@@ -16612,6 +16728,7 @@ class XrplApi {
                     // Emit the event only for successful transactions, Otherwise emit error.
                     if (data.engine_result === "tesSUCCESS") {
                         tx.Memos = TransactionHelper.deserializeMemos(tx.Memos);
+                        tx.HookParameters = TransactionHelper.deserializeHookParams(tx.HookParameters);
                         matches.forEach(s => s.handler(eventName, tx));
                     }
                     else {