evernode-js-client 0.4.15 → 0.4.18

package/index.js

@@ -11,8 +11,6 @@ const { EvernodeEvents, MemoTypes, MemoFormats, EvernodeConstants, HookStateKeys
 const { DefaultValues } = __nccwpck_require__(262);
 const { EncryptionHelper } = __nccwpck_require__(832);
 const { EventEmitter } = __nccwpck_require__(170);
-const codec = __nccwpck_require__(597);
-const { Buffer } = __nccwpck_require__(300);
 const { UtilHelpers } = __nccwpck_require__(687);
 const { FirestoreHandler } = __nccwpck_require__(718);
 
@@ -133,10 +131,15 @@ class BaseEvernodeClient {
             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)
+            momentBaseIdx: UtilHelpers.getStateData(states, HookStateKeys.MOMENT_BASE_IDX),
+            purchaserTargetPrice: UtilHelpers.getStateData(states, HookStateKeys.PURCHASER_TARGET_PRICE)
         };
     }
 
+    async refreshConfig() {
+        this.config = await this.#getEvernodeConfig();
+    }
+
     async #handleEvernodeEvent(tx, error) {
         if (error)
             console.error(error);
@@ -179,37 +182,16 @@ class BaseEvernodeClient {
                     console.log('Failed to decrypt redeem data.');
             }
 
-            if (tx.Memos.length >= 2 &&
-                tx.Memos[1].type === MemoTypes.REDEEM_ORIGIN && tx.Memos[1].format === MemoFormats.HEX && tx.Memos[1].data) {
-
-                // If the origin memo exists, get the token and user information from it.
-                const buf = Buffer.from(tx.Memos[1].data, 'hex');
-
-                return {
-                    name: EvernodeEvents.Redeem,
-                    data: {
-                        transaction: tx,
-                        redeemRefId: buf.slice(31, 63).toString('hex'),
-                        user: codec.encodeAccountID(buf.slice(0, 20)),
-                        host: tx.Destination,
-                        token: buf.slice(28, 31).toString(),
-                        moments: parseInt(buf.slice(20, 28).readBigInt64BE(0)),
-                        payload: payload
-                    }
-                }
-            }
-            else {
-                return {
-                    name: EvernodeEvents.Redeem,
-                    data: {
-                        transaction: tx,
-                        redeemRefId: tx.Hash,
-                        user: tx.Account,
-                        host: tx.Amount.issuer,
-                        token: tx.Amount.currency,
-                        moments: parseInt(tx.Amount.value),
-                        payload: payload
-                    }
+            return {
+                name: EvernodeEvents.Redeem,
+                data: {
+                    transaction: tx,
+                    redeemRefId: tx.hash,
+                    user: tx.Account,
+                    host: tx.Amount.issuer,
+                    token: tx.Amount.currency,
+                    moments: parseInt(tx.Amount.value),
+                    payload: payload
                 }
             }
         }
@@ -418,6 +400,22 @@ class HostClient extends BaseEvernodeClient {
         if (await this.isRegistered())
             throw "Host already registered.";
 
+        // Check whether is there any missed NFT sell offer that needs to be accepted
+        // from the client-side in order to complete the registration.
+        const regNft = await this.getRegistrationNft();
+        if (!regNft) {
+            const regInfo = await this.getHosts({ address: this.xrplAcc.address });
+            if (regInfo.length !== 0) {
+                const registryAcc = new XrplAccount(this.registryAddress, null, { xrplApi: this.xrplApi });
+                const sellOffer = (await registryAcc.getNftOffers()).find(o => o.TokenID == regInfo[0].nfTokenId);
+                if (sellOffer) {
+                    await this.xrplAcc.buyNft(sellOffer.index);
+                    console.log("Registration was successfully completed after acquiring the NFT.");
+                    return await this.isRegistered();
+                }
+            }
+        }
+
         const memoData = `${hostingToken};${countryCode};${cpuMicroSec};${ramMb};${diskMb};${totalInstanceCount};${description}`
         const tx = await this.xrplAcc.makePayment(this.registryAddress,
             this.config.hostRegFee.toString(),
@@ -453,8 +451,10 @@ class HostClient extends BaseEvernodeClient {
             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.TokenID === nft.TokenID && o.Flags === 1);
-                await this.xrplAcc.buyNft(sellOffer.index);
-                tx.isSellOfferAccepted = true;
+                if (sellOffer) {
+                    await this.xrplAcc.buyNft(sellOffer.index);
+                    tx.isSellOfferAccepted = true;
+                }
             }
         }
     }
@@ -473,7 +473,7 @@ class HostClient extends BaseEvernodeClient {
             options.transactionOptions);
 
         console.log('Waiting for the buy offer')
-        const regAcc = new XrplAccount(this.registryAddress);
+        const regAcc = new XrplAccount(this.registryAddress, null, { xrplApi: this.xrplApi });
         let offer = null;
         let attempts = 0;
         while (attempts < OFFER_WAIT_TIMEOUT) {
@@ -492,6 +492,15 @@ class HostClient extends BaseEvernodeClient {
         return await this.isRegistered();
     }
 
+    async heartbeat(options = {}) {
+        return this.xrplAcc.makePayment(this.registryAddress,
+            XrplConstants.MIN_XRP_AMOUNT,
+            XrplConstants.XRP,
+            null,
+            [{ type: MemoTypes.HEARTBEAT, format: "", data: "" }],
+            options.transactionOptions);
+    }
+
     async redeemSuccess(txHash, userAddress, instanceInfo, options = {}) {
 
         // Encrypt the instance info with the user's encryption key (Specified in MessageKey field of the user account).
@@ -505,7 +514,7 @@ class HostClient extends BaseEvernodeClient {
             { type: MemoTypes.REDEEM_SUCCESS, format: MemoFormats.BASE64, data: encrypted },
             { type: MemoTypes.REDEEM_REF, format: MemoFormats.HEX, data: txHash }];
 
-        return this.xrplAcc.makePayment(this.registryAddress,
+        return this.xrplAcc.makePayment(userAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
@@ -513,29 +522,19 @@ class HostClient extends BaseEvernodeClient {
             options.transactionOptions);
     }
 
-    async redeemError(txHash, reason, options = {}) {
+    async redeemError(txHash, userAddress, reason, options = {}) {
 
         const memos = [
             { type: MemoTypes.REDEEM_ERROR, format: MemoFormats.JSON, data: { type: ErrorCodes.REDEEM_ERR, reason: reason } },
             { type: MemoTypes.REDEEM_REF, format: MemoFormats.HEX, data: txHash }];
 
-        return this.xrplAcc.makePayment(this.registryAddress,
+        return this.xrplAcc.makePayment(userAddress,
             XrplConstants.MIN_XRP_AMOUNT,
             XrplConstants.XRP,
             null,
             memos,
             options.transactionOptions);
     }
-
-    async heartbeat(options = {}) {
-        return this.xrplAcc.makePayment(this.registryAddress,
-            XrplConstants.MIN_XRP_AMOUNT,
-            XrplConstants.XRP,
-            null,
-            this.xrplAcc.address,
-            [{ type: MemoTypes.HEARTBEAT, format: "", data: "" }],
-            options.transactionOptions);
-    }
 }
 
 module.exports = {
@@ -1089,7 +1088,6 @@ const EvernodeConstants = {
 
 const MemoTypes = {
     REDEEM: 'evnRedeem',
-    REDEEM_ORIGIN: 'evnRedeemOrigin',
     REDEEM_SUCCESS: 'evnRedeemSuccess',
     REDEEM_ERROR: 'evnRedeemError',
     REDEEM_REF: 'evnRedeemRef',
@@ -1123,6 +1121,7 @@ const HookStateKeys = {
     MINT_LIMIT: "4556520100000000000000000000000000000000000000000000000000000004",
     FIXED_REG_FEE: "4556520100000000000000000000000000000000000000000000000000000005",
     HOST_HEARTBEAT_FREQ: "4556520100000000000000000000000000000000000000000000000000000006",
+    PURCHASER_TARGET_PRICE: "4556520100000000000000000000000000000000000000000000000000000007",
     // Singleton
     HOST_COUNT: "4556523200000000000000000000000000000000000000000000000000000000",
     MOMENT_BASE_IDX: "4556523300000000000000000000000000000000000000000000000000000000",
@@ -1482,6 +1481,7 @@ module.exports = {
 const codec = __nccwpck_require__(597);
 const { Buffer } = __nccwpck_require__(300);
 const { HookStateKeys } = __nccwpck_require__(849);
+const { XflHelpers } = __nccwpck_require__(243);
 
 const NFTOKEN_PREFIX = '00080000';
 
@@ -1520,7 +1520,7 @@ class StateHelpers {
             registrationFee: Number(stateDataBuf.readBigUInt64BE(HOST_REG_FEE_OFFSET)),
             noOfTotalInstances: stateDataBuf.readUInt32BE(HOST_TOT_INS_COUNT_OFFSET),
             noOfActiveInstances: stateDataBuf.readUInt32BE(HOST_ACT_INS_COUNT_OFFSET),
-            lastHeartbeatLedger: stateDataBuf.readUInt32BE(HOST_HEARTBEAT_LEDGER_IDX_OFFSET)
+            lastHeartbeatLedger: Number(stateDataBuf.readBigUInt64BE(HOST_HEARTBEAT_LEDGER_IDX_OFFSET))
         }
     }
 
@@ -1583,6 +1583,15 @@ class StateHelpers {
                 value: Number(stateData.readBigUInt64BE())
             }
         }
+        else if (Buffer.from(HookStateKeys.PURCHASER_TARGET_PRICE, 'hex').compare(stateKey) === 0) {
+            const xfl = stateData.readBigInt64BE(0);
+            const val = XflHelpers.toString(xfl);
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: val
+            }
+        }
         else
             throw { type: 'Validation Error', message: 'Invalid state key.' };
     }
@@ -1613,6 +1622,7 @@ class StateHelpers {
         else if (Buffer.from(HookStateKeys.EVR_ISSUER_ADDR, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.FOUNDATION_ADDR, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.MOMENT_SIZE, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.PURCHASER_TARGET_PRICE, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.HOST_HEARTBEAT_FREQ, 'hex').compare(stateKey) ||
             Buffer.from(HookStateKeys.MINT_LIMIT, 'hex').compare(stateKey) === 0 ||
             Buffer.from(HookStateKeys.FIXED_REG_FEE, 'hex').compare(stateKey) === 0) {

package/package.json

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