evernode-js-client 0.5.3 → 0.5.5

package/index.js

@@ -12145,6 +12145,17 @@ class BaseEvernodeClient {
                 }
             }
         }
+        else if (tx.Memos.length >= 1 &&
+            tx.Memos[0].type === MemoTypes.HOST_REBATE) {
+
+            return {
+                name: EvernodeEvents.HostRebate,
+                data: {
+                    transaction: tx,
+                    host: tx.Account
+                }
+            }
+        }
 
         return null;
     }
@@ -12626,6 +12637,15 @@ class HostClient extends BaseEvernodeClient {
             options.transactionOptions);
     }
 
+    async requestRebate(options = {}) {
+        return this.xrplAcc.makePayment(this.registryAddress,
+            XrplConstants.MIN_XRP_AMOUNT,
+            XrplConstants.XRP,
+            null,
+            [{ type: MemoTypes.HOST_REBATE, format: "", data: "" }],
+            options.transactionOptions);
+    }
+
     getLeaseNFTokenIdPrefix() {
         let buf = Buffer.allocUnsafe(24);
         buf.writeUInt16BE(1);
@@ -12633,6 +12653,67 @@ class HostClient extends BaseEvernodeClient {
         codec.decodeAccountID(this.xrplAcc.address).copy(buf, 4);
         return buf.toString('hex');
     }
+
+    async transfer(transfereeAddress = this.xrplAcc.address, options = {}) {
+        if (!(await this.isRegistered()))
+            throw "Host is not registered.";
+
+        const transfereeAcc = new XrplAccount(transfereeAddress, null, { xrplApi: this.xrplApi });
+
+        if (this.xrplAcc.address !== transfereeAddress) {
+            // Find the new transferee also owns an Evernode Host Registration NFT.
+            const nft = (await transfereeAcc.getNfts()).find(n => n.URI.startsWith(EvernodeConstants.NFT_PREFIX_HEX) && n.Issuer === this.registryAddress);
+            if (nft) {
+                // Check whether the token was actually issued from Evernode registry contract.
+                const issuerHex = nft.NFTokenID.substr(8, 40);
+                const issuerAddr = codec.encodeAccountID(Buffer.from(issuerHex, 'hex'));
+                if (issuerAddr == this.registryAddress) {
+                    throw "The transferee is already registered in Evernode.";
+                }
+            }
+        }
+
+        const regNFT = (await this.xrplAcc.getNfts()).find(n => n.URI.startsWith(EvernodeConstants.NFT_PREFIX_HEX) && n.Issuer === this.registryAddress);
+
+        let memoData = Buffer.allocUnsafe(20);
+        codec.decodeAccountID(transfereeAddress).copy(memoData);
+
+        await this.xrplAcc.makePayment(this.registryAddress,
+            XrplConstants.MIN_XRP_AMOUNT,
+            XrplConstants.XRP,
+            null,
+            [{ type: MemoTypes.HOST_TRANSFER, format: MemoFormats.HEX, data: memoData.toString('hex') }],
+            options.transactionOptions);
+
+        let offer = null;
+        let attempts = 0;
+        let offerLedgerIndex = 0;
+        const regAcc = new XrplAccount(this.registryAddress, null, { xrplApi: this.xrplApi });
+
+        while (attempts < OFFER_WAIT_TIMEOUT) {
+            offer = (await regAcc.getNftOffers()).find(o => (o.NFTokenID == regNFT.NFTokenID) && (o.Flags === 0));
+            offerLedgerIndex = this.xrplApi.ledgerIndex;
+            if (offer)
+                break;
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            attempts++;
+        }
+        if (!offer)
+            throw 'No buy offer found within timeout.';
+
+        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,
+        // 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();
+        });
+
+        await this.xrplAcc.sellNft(offer.index);
+    }
 }
 
 module.exports = {
@@ -12656,7 +12737,9 @@ const RegistryEvents = {
     RegistryInitialized: EvernodeEvents.RegistryInitialized,
     Heartbeat: EvernodeEvents.Heartbeat,
     HostPostDeregistered: EvernodeEvents.HostPostDeregistered,
-    DeadHostPrune: EvernodeEvents.DeadHostPrune
+    DeadHostPrune: EvernodeEvents.DeadHostPrune,
+    HostTransfer: EvernodeEvents.HostTransfer,
+    HostRebate: EvernodeEvents.HostRebate
 }
 
 class RegistryClient extends BaseEvernodeClient {
@@ -13391,6 +13474,7 @@ const MemoTypes = {
     HOST_UPDATE_INFO: 'evnHostUpdateReg',
     HEARTBEAT: 'evnHeartbeat',
     HOST_POST_DEREG: 'evnHostPostDereg',
+    HOST_TRANSFER: 'evnTransfer',
     EXTEND_LEASE: 'evnExtendLease',
     EXTEND_SUCCESS: 'evnExtendSuccess',
     EXTEND_ERROR: 'evnExtendError',
@@ -13398,7 +13482,8 @@ const MemoTypes = {
     REGISTRY_INIT: 'evnInitialize',
     REFUND: 'evnRefund',
     REFUND_REF: 'evnRefundRef',
-    DEAD_HOST_PRUNE: 'evnDeadHostPrune'
+    DEAD_HOST_PRUNE: 'evnDeadHostPrune',
+    HOST_REBATE: 'evnHostRebate'
 }
 
 const MemoFormats = {
@@ -13450,12 +13535,14 @@ const HookStateKeys = {
     // Prefixes
     PREFIX_HOST_TOKENID: "45565202",
     PREFIX_HOST_ADDR: "45565203",
+    PREFIX_TRANSFEREE_ADDR: "45565204",
 }
 
 const EvernodeEvents = {
     HostRegistered: "HostRegistered",
     HostDeregistered: "HostDeregistered",
     HostPostDeregistered: "HostPostDeregistered",
+    HostTransfer: "HostTransfer",
     AcquireLease: "AcquireLease",
     AcquireSuccess: "AcquireSuccess",
     AcquireError: "AcquireError",
@@ -13466,7 +13553,8 @@ const EvernodeEvents = {
     HostRegUpdated: "HostRegUpdated",
     HostReRegistered: "HostReRegistered",
     RegistryInitialized: "RegistryInitialized",
-    DeadHostPrune: "DeadHostPrune"
+    DeadHostPrune: "DeadHostPrune",
+    HostRebate: "HostRebate"
 }
 
 module.exports = {
@@ -13900,6 +13988,7 @@ const HOST_ACT_INS_COUNT_OFFSET = 88;
 const HOST_HEARTBEAT_LEDGER_IDX_OFFSET = 92;
 const HOST_VERSION_OFFSET = 100;
 const HOST_REG_TIMESTAMP_OFFSET = 103;
+const HOST_TRANSFER_FLAG_OFFSET = 111;
 
 const HOST_ADDRESS_OFFSET = 0;
 const HOST_CPU_MODEL_NAME_OFFSET = 20;
@@ -13922,13 +14011,15 @@ const MOMENT_TYPES = {
 const EVERNODE_PREFIX = 'EVR';
 const HOST_ADDR_KEY_ZERO_COUNT = 8;
 const HOOK_STATE_LEDGER_TYPE_PREFIX = 118; // Decimal value of ASCII 'v'
+const PENDING_TRANSFER = 1;
 
 class StateHelpers {
     static StateTypes = {
         TOKEN_ID: 'tokenId',
         HOST_ADDR: 'hostAddr',
         SIGLETON: 'singleton',
-        CONFIGURATION: 'configuration'
+        CONFIGURATION: 'configuration',
+        TRANSFEREE_ADDR: 'transfereeAddr'
     }
 
     static timeLines = {
@@ -13955,6 +14046,7 @@ class StateHelpers {
             activeInstances: stateDataBuf.readUInt32BE(HOST_ACT_INS_COUNT_OFFSET),
             lastHeartbeatIndex: Number(stateDataBuf.readBigUInt64BE(HOST_HEARTBEAT_LEDGER_IDX_OFFSET)),
             version: `${stateDataBuf.readUInt8(HOST_VERSION_OFFSET)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 1)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 2)}`,
+            hasPendingTransfer: (stateDataBuf.readUInt8(HOST_TRANSFER_FLAG_OFFSET) === PENDING_TRANSFER) ? true : false
         }
         if (stateDataBuf.length > HOST_REG_TIMESTAMP_OFFSET)
             data.registrationTimestamp = Number(stateDataBuf.readBigUInt64BE(HOST_REG_TIMESTAMP_OFFSET));
@@ -13994,6 +14086,12 @@ class StateHelpers {
                 ...this.decodeTokenIdState(stateData)
             }
         }
+        else if (Buffer.from(HookStateKeys.PREFIX_TRANSFEREE_ADDR, 'hex').compare(stateKey, 0, 4) === 0) {
+            return {
+                type: this.StateTypes.TRANSFEREE_ADDR,
+                key: hexKey
+            }
+        }
         else if (Buffer.from(HookStateKeys.HOST_COUNT, 'hex').compare(stateKey) === 0) {
             return {
                 type: this.StateTypes.SIGLETON,
@@ -14482,8 +14580,10 @@ class XrplAccount {
         this.address = address;
 
         this.secret = secret;
-        if (this.secret)
+        if (this.secret) {
             this.wallet = xrpl.Wallet.fromSeed(this.secret);
+            this.address= this.wallet.classicAddress;
+        }
 
         this.#txStreamHandler = (eventName, tx, error) => {
             this.#events.emit(eventName, tx, error);
@@ -14579,7 +14679,7 @@ class XrplAccount {
     }
 
     async getAccountTrx(minLedgerIndex = -1, maxLedgerIndex = -1, isForward = true) {
-        return await this.xrplApi.getAccountTrx(this.address, { ledger_index_min: minLedgerIndex, ledger_index_max: maxLedgerIndex, forward: isForward});
+        return await this.xrplApi.getAccountTrx(this.address, { ledger_index_min: minLedgerIndex, ledger_index_max: maxLedgerIndex, forward: isForward });
     }
 
     setAccountFields(fields, options = {}) {

package/package.json

@@ -6,7 +6,7 @@
     ],
     "homepage": "https://github.com/HotPocketDev/evernode-js-client",
     "license": "MIT",
-    "version": "0.5.3",
+    "version": "0.5.5",
     "dependencies": {
         "elliptic": "6.5.4",
         "ripple-address-codec": "4.2.0",