evernode-js-client 0.4.37 → 0.4.40

package/index.js

@@ -11704,6 +11704,7 @@ exports.Vector256 = Vector256;
 /***/ 9595:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
+const codec = __nccwpck_require__(597);
 const { Buffer } = __nccwpck_require__(4300);
 const { XrplApi } = __nccwpck_require__(4346);
 const { XrplAccount } = __nccwpck_require__(8196);
@@ -11714,6 +11715,7 @@ const { EncryptionHelper } = __nccwpck_require__(7769);
 const { EventEmitter } = __nccwpck_require__(8208);
 const { UtilHelpers } = __nccwpck_require__(1255);
 const { FirestoreHandler } = __nccwpck_require__(4972);
+const { XflHelpers } = __nccwpck_require__(5201);
 
 class BaseEvernodeClient {
 
@@ -11807,12 +11809,18 @@ class BaseEvernodeClient {
                 (h.lastHeartbeatLedger >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
                 (h.lastHeartbeatLedger > 0))
         });
-        return hosts
+        return hosts;
     }
 
-    async getConfigs() {
-        const configs = await this.#firestoreHandler.getConfigs();
-        return configs.map(c => { return { key: c.key, data: c.value } });
+    async getHookStates() {
+        const regAcc = new XrplAccount(this.registryAddress, null, { xrplApi: this.xrplApi });
+        const hookNamespaces = (await regAcc.getInfo())?.HookNamespaces;
+        if (hookNamespaces) {
+            const configs = await regAcc.getNamespaceEntries(hookNamespaces[0]);
+            return configs.filter(c => c.LedgerEntryType === 'HookState').map(c => { return { key: c.HookStateKey, data: c.HookStateData } });
+        }
+        return [];
+
     }
 
     async getMoment(ledgerIndex = null) {
@@ -11832,16 +11840,16 @@ class BaseEvernodeClient {
     }
 
     async #getEvernodeConfig() {
-        let states = await this.getConfigs();
+        let states = await this.getHookStates();
         return {
-            evrIssuerAddress: UtilHelpers.getStateData(states, HookStateKeys.EVR_ISSUER_ADDR),
-            foundationAddress: UtilHelpers.getStateData(states, HookStateKeys.FOUNDATION_ADDR),
-            hostRegFee: UtilHelpers.getStateData(states, HookStateKeys.HOST_REG_FEE),
-            momentSize: UtilHelpers.getStateData(states, HookStateKeys.MOMENT_SIZE),
-            hostHeartbeatFreq: UtilHelpers.getStateData(states, HookStateKeys.HOST_HEARTBEAT_FREQ),
-            momentBaseIdx: UtilHelpers.getStateData(states, HookStateKeys.MOMENT_BASE_IDX),
-            purchaserTargetPrice: UtilHelpers.getStateData(states, HookStateKeys.PURCHASER_TARGET_PRICE),
-            leaseAcquireWindow: UtilHelpers.getStateData(states, HookStateKeys.LEASE_ACQUIRE_WINDOW)
+            evrIssuerAddress: codec.encodeAccountID(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.EVR_ISSUER_ADDR), 'hex')),
+            foundationAddress: codec.encodeAccountID(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.FOUNDATION_ADDR), 'hex')),
+            hostRegFee: Number(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.HOST_REG_FEE), 'hex').readBigUInt64BE()),
+            momentSize: Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.MOMENT_SIZE), 'hex').readUInt16BE(),
+            hostHeartbeatFreq: Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.HOST_HEARTBEAT_FREQ), 'hex').readUInt16BE(),
+            momentBaseIdx: Number(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.MOMENT_BASE_IDX), 'hex').readBigInt64BE()),
+            purchaserTargetPrice: XflHelpers.toString(Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.PURCHASER_TARGET_PRICE), 'hex').readBigInt64BE()),
+            leaseAcquireWindow: Buffer.from(UtilHelpers.getStateData(states, HookStateKeys.LEASE_ACQUIRE_WINDOW), 'hex').readUInt16BE()
         };
     }
 
@@ -11862,18 +11870,7 @@ class BaseEvernodeClient {
     }
 
     async #extractEvernodeEvent(tx) {
-        if (tx.TransactionType === 'NFTokenCreateOffer' && (!tx.Memos || tx.Memos.length === 0)) {
-            return {
-                name: EvernodeEvents.NftOfferCreate,
-                data: {
-                    transaction: tx,
-                    nfTokenId: tx.NFTokenID,
-                    flags: tx.Flags,
-                    hash: tx.hash
-                }
-            }
-        }
-        else if (tx.TransactionType === 'NFTokenAcceptOffer' && tx.NFTokenSellOffer && tx.Memos.length >= 1 &&
+        if (tx.TransactionType === 'NFTokenAcceptOffer' && tx.NFTokenSellOffer && tx.Memos.length >= 1 &&
             tx.Memos[0].type === MemoTypes.ACQUIRE_LEASE && tx.Memos[0].format === MemoFormats.BASE64 && tx.Memos[0].data) {
 
             // If our account is the destination host account, then decrypt the payload.
@@ -11899,6 +11896,20 @@ class BaseEvernodeClient {
                 }
             }
         }
+
+        else if (tx.TransactionType === 'NFTokenAcceptOffer' && tx.NFTokenBuyOffer && tx.Memos.length >= 1 &&
+            tx.Memos[0].type === MemoTypes.HOST_POST_DEREG && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+            return {
+                name: EvernodeEvents.HostPostDeregistered,
+                data: {
+                    transaction: tx,
+                    nfTokenId: tx.NFTokenBuyOffer.NFTokenID,
+                    flags: tx.Flags,
+                    hash: tx.hash
+                }
+            }
+        }
+
         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) {
@@ -12032,6 +12043,31 @@ class BaseEvernodeClient {
                 }
             }
         }
+        else if (tx.Memos.length >= 1 &&
+            tx.Memos[0].type === MemoTypes.REGISTRY_INIT && tx.Memos[0].format === MemoFormats.HEX && tx.Memos[0].data) {
+
+            return {
+                name: EvernodeEvents.RegistryInitialized,
+                data: {
+                    transaction: tx
+                }
+            }
+        }
+        else if (tx.Memos.length >= 1 &&
+            tx.Memos[0].type === MemoTypes.HOST_UPDATE_INFO && tx.Memos[0].format === MemoFormats.TEXT && tx.Memos[0].data) {
+
+            const specs = tx.Memos[0].data.split(';');
+
+            return {
+                name: EvernodeEvents.HostRegUpdated,
+                data: {
+                    transaction: tx,
+                    host: tx.Account,
+                    version: specs[specs.length - 1],
+                    specs: specs,
+                }
+            }
+        }
 
         return null;
     }
@@ -12059,7 +12095,6 @@ const OFFER_WAIT_TIMEOUT = 60;
 
 const HostEvents = {
     AcquireLease: EvernodeEvents.AcquireLease,
-    NftOfferCreate: EvernodeEvents.NftOfferCreate,
     ExtendLease: EvernodeEvents.ExtendLease
 }
 
@@ -12205,41 +12240,42 @@ class HostClient extends BaseEvernodeClient {
             [{ type: MemoTypes.HOST_REG, format: MemoFormats.TEXT, data: memoData }],
             options.transactionOptions);
 
-        // Added this attribute as an indication for the sell offer acceptance
-        tx.isSellOfferAccepted = false;
+        console.log('Waiting for the sell offer')
+        const regAcc = new XrplAccount(this.registryAddress, null, { xrplApi: this.xrplApi });
+        let offer = null;
+        let attempts = 0;
+        let offerLedgerIndex = 0;
+        while (attempts < OFFER_WAIT_TIMEOUT) {
+            const nft = (await regAcc.getNfts()).find(n => n.URI === `${EvernodeConstants.NFT_PREFIX_HEX}${tx.id}`);
+            if (nft) {
+                offer = (await regAcc.getNftOffers()).find(o => o.Destination === this.xrplAcc.address && o.NFTokenID === nft.NFTokenID && o.Flags === 1);
+                offerLedgerIndex = this.xrplApi.ledgerIndex;
+                if (offer)
+                    break;
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                attempts++;
+            }
 
-        this.on(HostEvents.NftOfferCreate, r => this.handleNftOffer(r, tx));
+        }
+        if (!offer)
+            throw 'No sell offer found within timeout.';
 
-        let attemps = 0;
+        console.log('Accepting the sell offer..');
 
-        while (attemps < OFFER_WAIT_TIMEOUT) {
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            if (tx.isSellOfferAccepted) {
-                break;
-            }
-            attemps++;
-        }
+        // Wait until the next ledger after the offer is created.
+        // Otherwise if the offer accepted in the same legder which it's been created,
+        // We cannot fetch the offer from registry contract event handler since it's getting deleted immediately.
+        await new Promise(async resolve => {
+            while (this.xrplApi.ledgerIndex <= offerLedgerIndex)
+                await new Promise(resolve2 => setTimeout(resolve2, 1000));
+            resolve();
+        });
 
-        if (!tx.isSellOfferAccepted)
-            throw "No sell offer was found within timeout.";
+        await this.xrplAcc.buyNft(offer.index);
 
         return await this.isRegistered();
     }
 
-    async handleNftOffer(r, tx) {
-        if (this.xrplAcc.address === r.transaction.Destination) {
-            const registryAcc = new XrplAccount(this.registryAddress, null, { xrplApi: this.xrplApi });
-            const nft = (await registryAcc.getNfts()).find(n => n.URI === `${EvernodeConstants.NFT_PREFIX_HEX}${tx.id}`);
-            if (nft) {
-                const sellOffer = (await registryAcc.getNftOffers()).find(o => o.NFTokenID === nft.NFTokenID && o.Flags === 1);
-                if (sellOffer) {
-                    await this.xrplAcc.buyNft(sellOffer.index);
-                    tx.isSellOfferAccepted = true;
-                }
-            }
-        }
-    }
-
     async deregister(options = {}) {
 
         if (!(await this.isRegistered()))
@@ -12267,9 +12303,9 @@ class HostClient extends BaseEvernodeClient {
             attempts++;
         }
         if (!offer)
-            throw 'No offer found within timeout.';
+            throw 'No buy offer found within timeout.';
 
-        console.log('Accepting buy offer..');
+        console.log('Accepting the buy offer..');
 
         // Wait until the next ledger after the offer is created.
         // Otherwise if the offer accepted in the same legder which it's been created,
@@ -12390,7 +12426,11 @@ const { DefaultValues } = __nccwpck_require__(542);
 
 const RegistryEvents = {
     HostRegistered: EvernodeEvents.HostRegistered,
-    HostDeregistered: EvernodeEvents.HostDeregistered
+    HostDeregistered: EvernodeEvents.HostDeregistered,
+    HostRegUpdated: EvernodeEvents.HostRegUpdated,
+    RegistryInitialized: EvernodeEvents.RegistryInitialized,
+    Heartbeat: EvernodeEvents.Heartbeat,
+    HostPostDeregistered: EvernodeEvents.HostPostDeregistered
 }
 
 class RegistryClient extends BaseEvernodeClient {
@@ -12400,9 +12440,22 @@ class RegistryClient extends BaseEvernodeClient {
     }
 
     async getActiveHosts() {
+        let fullHostList = [];
         const hosts = await this.getHosts();
+        if (hosts.nextPageToken) {
+            let currentPageToken = hosts.nextPageToken;
+            let nextHosts = null;
+            fullHostList = fullHostList.concat(hosts.data);
+            while (currentPageToken) {
+                nextHosts = await this.getHosts(null, null, currentPageToken);
+                fullHostList = fullHostList.concat(nextHosts.nextPageToken ? nextHosts.data : nextHosts);
+                currentPageToken = nextHosts.nextPageToken;   
+            }
+        } else {
+            fullHostList = fullHostList.concat(hosts);
+        }
         // Filter only active hosts.
-        return hosts.filter(h => h.active);
+        return fullHostList.filter(h => h.active);
     }
 }
 
@@ -12626,9 +12679,9 @@ module.exports = {
 
 const DefaultValues = {
     registryAddress: 'rDPqJv7zu6DfeXexAYseABNM2hT2j2rpHv',
-    rippledServer: 'wss://xls20-sandbox.rippletest.net:51233',
+    rippledServer: 'wss://hooks-testnet-v2.xrpl-labs.com',
     xrplApi: null,
-    stateIndexId: 'evernodeindex' 
+    stateIndexId: 'evernodeindex'
 }
 
 class Defaults {
@@ -13032,7 +13085,8 @@ const MemoTypes = {
     EXTEND_LEASE: 'evnExtendLease',
     EXTEND_SUCCESS: 'evnExtendSuccess',
     EXTEND_ERROR: 'evnExtendError',
-    EXTEND_REF: 'evnExtendRef'
+    EXTEND_REF: 'evnExtendRef',
+    REGISTRY_INIT: 'evnInitialize'
 }
 
 const MemoFormats = {
@@ -13054,7 +13108,8 @@ const ErrorReasons = {
     INTERNAL_ERR: 'INTERNAL_ERR',
     TIMEOUT: 'TIMEOUT',
     HOST_INVALID: 'HOST_INVALID',
-    HOST_INACTIVE: 'HOST_INACTIVE'
+    HOST_INACTIVE: 'HOST_INACTIVE',
+    NO_STATE_KEY: 'NO_STATE_KEY'
 }
 
 // All keys are prefixed with 'EVR' (0x455652)
@@ -13083,14 +13138,17 @@ const HookStateKeys = {
 const EvernodeEvents = {
     HostRegistered: "HostRegistered",
     HostDeregistered: "HostDeregistered",
+    HostPostDeregistered: "HostPostDeregistered",
     AcquireLease: "AcquireLease",
     AcquireSuccess: "AcquireSuccess",
     AcquireError: "AcquireError",
     Heartbeat: "Heartbeat",
-    NftOfferCreate: "NftOfferCreate",
     ExtendLease: "ExtendLease",
     ExtendSuccess: "ExtendSuccess",
-    ExtendError: "ExtendError"
+    ExtendError: "ExtendError",
+    HostRegUpdated: "HostRegUpdated",
+    HostReRegistered: "HostReRegistered",
+    RegistryInitialized: "RegistryInitialized"
 }
 
 module.exports = {
@@ -13400,7 +13458,7 @@ const { HostClient, HostEvents } = __nccwpck_require__(2878);
 const { XrplApi } = __nccwpck_require__(4346);
 const { XrplApiEvents, XrplConstants } = __nccwpck_require__(2296);
 const { XrplAccount } = __nccwpck_require__(8196);
-const { EvernodeConstants } = __nccwpck_require__(5359);
+const { EvernodeConstants, HookStateKeys, MemoTypes } = __nccwpck_require__(5359);
 const { XflHelpers } = __nccwpck_require__(5201);
 const { FirestoreHandler } = __nccwpck_require__(4972);
 const { StateHelpers } = __nccwpck_require__(1466);
@@ -13422,7 +13480,9 @@ module.exports = {
     XflHelpers,
     StateHelpers,
     FirestoreHandler,
-    UtilHelpers
+    UtilHelpers,
+    HookStateKeys,
+    MemoTypes
 }
 
 /***/ }),
@@ -13456,6 +13516,14 @@ const HOST_CPU_MICROSEC_OFFSET = 64;
 const HOST_RAM_MB_OFFSET = 68;
 const HOST_DISK_MB_OFFSET = 72;
 
+const STATE_KEY_TYPES = {
+    TOKEN_ID: 2,
+    HOST_ADDR: 3
+}
+
+const EVERNODE_PREFIX = 'EVR';
+const HOST_ADDR_KEY_ZERO_COUNT = 8;
+
 class StateHelpers {
     static StateTypes = {
         TOKEN_ID: 'tokenId',
@@ -13488,7 +13556,7 @@ class StateHelpers {
             cpuMicrosec: stateDataBuf.readUInt32BE(HOST_CPU_MICROSEC_OFFSET),
             ramMb: stateDataBuf.readUInt32BE(HOST_RAM_MB_OFFSET),
             diskMb: stateDataBuf.readUInt32BE(HOST_DISK_MB_OFFSET)
-          }
+        }
     }
 
     static decodeStateData(stateKey, stateData) {
@@ -13608,6 +13676,30 @@ class StateHelpers {
         else
             throw { type: 'Validation Error', message: 'Invalid state key.' };
     }
+
+    static generateTokenIdStateKey(nfTokenId) {
+        // 1 byte - Key Type.
+        let buf = Buffer.allocUnsafe(1);
+        buf.writeUInt8(STATE_KEY_TYPES.TOKEN_ID);
+
+        const nfTokenIdBuf = Buffer.from(nfTokenId, "hex");
+        const stateKeyBuf = (Buffer.concat([Buffer.from(EVERNODE_PREFIX, "utf-8"), buf, nfTokenIdBuf.slice(4, 32)]));
+        return stateKeyBuf.toString('hex').toUpperCase();
+    }
+
+    static generateHostAddrStateKey(address) {
+        // 1 byte - Key Type.
+        // 8 bytes - Zeros.
+        let buf = Buffer.allocUnsafe(9);
+        buf.writeUInt8(STATE_KEY_TYPES.HOST_ADDR);
+        for (let i = 0; i < HOST_ADDR_KEY_ZERO_COUNT; i++) {
+            buf.writeUInt8(0, i+1);
+        }
+
+        const addrBuf = Buffer.from(codec.decodeAccountID(address), "hex");
+        const stateKeyBuf = Buffer.concat([Buffer.from(EVERNODE_PREFIX, "utf-8"), buf, addrBuf]);
+        return stateKeyBuf.toString('hex').toUpperCase();
+    }
 }
 
 module.exports = {
@@ -13689,7 +13781,7 @@ module.exports = {
 
 const { Buffer } = __nccwpck_require__(4300);
 const { XflHelpers } = __nccwpck_require__(5201);
-const { EvernodeConstants } = __nccwpck_require__(5359);
+const { EvernodeConstants, ErrorReasons } = __nccwpck_require__(5359);
 
 // Utility helper functions.
 class UtilHelpers {
@@ -13697,7 +13789,7 @@ class UtilHelpers {
     static getStateData(states, key) {
         const state = states.find(s => key === s.key);
         if (!state)
-            throw `State key '${key}' not found.`;
+            throw { code: ErrorReasons.NO_STATE_KEY, error: `State key '${key}' not found.` };
 
         return state.data;
     }
@@ -13990,6 +14082,10 @@ class XrplAccount {
         return await this.xrplApi.getAccountObjects(this.address, options);
     }
 
+    async getNamespaceEntries(namespaceId, options = {}) {
+        return await this.xrplApi.getNamespaceEntries(this.address, namespaceId, options);
+    }
+
     async getFlags() {
         return xrpl.parseAccountRootFlags((await this.getInfo()).Flags);
     }
@@ -14054,7 +14150,7 @@ class XrplAccount {
         if (typeof limit !== 'string')
             throw "Limit must be a string.";
 
-        return this.#submitAndVerifyTransaction({
+        let tx = {
             TransactionType: 'TrustSet',
             Account: this.address,
             LimitAmount: {
@@ -14062,11 +14158,13 @@ class XrplAccount {
                 issuer: issuer,
                 value: limit
             },
-            Flags: {
-                tfSetNoRipple: !allowRippling
-            },
             Memos: TransactionHelper.formatMemos(memos)
-        }, options);
+        };
+
+        if (!allowRippling)
+            tx.Flags = 131072; // tfSetNoRipple;
+
+        return this.#submitAndVerifyTransaction(tx, options);
     }
 
     setRegularKey(regularKey, memos = null, options = {}) {
@@ -14530,6 +14628,13 @@ class XrplApi {
         return [];
     }
 
+    async getNamespaceEntries(address, namespaceId, options) {
+        const resp = (await this.#client.request({ command: 'account_namespace', account: address, namespace_id: namespaceId, ...options }));
+        if (resp?.result?.namespace_entries)
+            return resp.result.namespace_entries;
+        return [];
+    }
+
     async getNftOffers(address, options) {
         const offers = await this.getAccountObjects(address, options);
         // TODO: Pass rippled filter parameter when xrpl.js supports it.

package/package.json

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