evernode-js-client 0.4.53 → 0.5.0

package/src/clients/host-client.js

@@ -0,0 +1,357 @@
+const { XrplConstants } = require('../xrpl-common');
+const { BaseEvernodeClient } = require('./base-evernode-client');
+const { EvernodeEvents, EvernodeConstants, MemoFormats, MemoTypes, ErrorCodes } = require('../evernode-common');
+const { XrplAccount } = require('../xrpl-account');
+const { EncryptionHelper } = require('../encryption-helper');
+const { Buffer } = require('buffer');
+const codec = require('ripple-address-codec');
+const { XflHelpers } = require('../xfl-helpers');
+const { EvernodeHelpers } = require('../evernode-helpers');
+
+const OFFER_WAIT_TIMEOUT = 60;
+
+const HostEvents = {
+    AcquireLease: EvernodeEvents.AcquireLease,
+    ExtendLease: EvernodeEvents.ExtendLease
+}
+
+class HostClient extends BaseEvernodeClient {
+
+    constructor(xrpAddress, xrpSecret, options = {}) {
+        super(xrpAddress, xrpSecret, Object.values(HostEvents), true, options);
+    }
+
+    async getRegistrationNft() {
+        // Find an owned NFT with matching Evernode host NFT prefix.
+        const nft = (await this.xrplAcc.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) {
+                return nft;
+            }
+        }
+
+        return null;
+    }
+
+    async getRegistration() {
+        // Check whether we own an evernode host token.
+        const nft = await this.getRegistrationNft();
+        if (nft) {
+            const host = await this.getHostInfo();
+            return (host?.nfTokenId == nft.NFTokenID) ? host : null;
+        }
+
+        return null;
+    }
+
+    async getLeaseOffers() {
+        return await EvernodeHelpers.getLeaseOffers(this.xrplAcc);
+    }
+
+    async cancelOffer(offerIndex) {
+        return this.xrplAcc.cancelOffer(offerIndex);
+    }
+
+    async isRegistered() {
+        return (await this.getRegistration()) !== null;
+    }
+
+    async prepareAccount(domain) {
+        const [flags, trustLines, msgKey, curDomain] = await Promise.all([
+            this.xrplAcc.getFlags(),
+            this.xrplAcc.getTrustLines(EvernodeConstants.EVR, this.config.evrIssuerAddress),
+            this.xrplAcc.getMessageKey(),
+            this.xrplAcc.getDomain()]);
+
+        let accountSetFields = {};
+        accountSetFields = (!flags.lsfDefaultRipple) ? { ...accountSetFields, Flags: { asfDefaultRipple: true } } : accountSetFields;
+        accountSetFields = (!msgKey) ? { ...accountSetFields, MessageKey: this.accKeyPair.publicKey } : accountSetFields;
+
+        domain = domain.toLowerCase();
+        accountSetFields = (!curDomain || curDomain !== domain) ?
+            { ...accountSetFields, Domain: domain } : accountSetFields;
+
+        if (Object.keys(accountSetFields).length !== 0)
+            await this.xrplAcc.setAccountFields(accountSetFields);
+
+        if (trustLines.length === 0)
+            await this.xrplAcc.setTrustLine(EvernodeConstants.EVR, this.config.evrIssuerAddress, "99999999999999");
+    }
+
+    async offerLease(leaseIndex, leaseAmount, tosHash) {
+        // <prefix><lease index 16)><half of tos hash><lease amount (uint32)>
+        const prefixLen = EvernodeConstants.LEASE_NFT_PREFIX_HEX.length / 2;
+        const halfToSLen = tosHash.length / 4;
+        const uriBuf = Buffer.allocUnsafe(prefixLen + halfToSLen + 10);
+        Buffer.from(EvernodeConstants.LEASE_NFT_PREFIX_HEX, 'hex').copy(uriBuf);
+        uriBuf.writeUInt16BE(leaseIndex, prefixLen);
+        Buffer.from(tosHash, 'hex').copy(uriBuf, prefixLen + 2, 0, halfToSLen);
+        uriBuf.writeBigInt64BE(XflHelpers.getXfl(leaseAmount.toString()), prefixLen + 2 + halfToSLen);
+        const uri = uriBuf.toString('hex').toUpperCase();
+
+        await this.xrplAcc.mintNft(uri, 0, 0, { isBurnable: true, isHexUri: true });
+
+        const nft = await this.xrplAcc.getNftByUri(uri, true);
+        if (!nft)
+            throw "Offer lease NFT creation error.";
+
+        await this.xrplAcc.offerSellNft(nft.NFTokenID,
+            leaseAmount.toString(),
+            EvernodeConstants.EVR,
+            this.config.evrIssuerAddress);
+    }
+
+    async expireLease(nfTokenId, tenantAddress = null) {
+        await this.xrplAcc.burnNft(nfTokenId, tenantAddress);
+    }
+
+    async register(countryCode, cpuMicroSec, ramMb, diskMb, totalInstanceCount, cpuModel, cpuCount, cpuSpeed, description, options = {}) {
+        if (!/^([A-Z]{2})$/.test(countryCode))
+            throw "countryCode should consist of 2 uppercase alphabetical characters";
+        else if (!cpuMicroSec || isNaN(cpuMicroSec) || cpuMicroSec % 1 != 0 || cpuMicroSec < 0)
+            throw "cpuMicroSec should be a positive integer";
+        else if (!ramMb || isNaN(ramMb) || ramMb % 1 != 0 || ramMb < 0)
+            throw "ramMb should be a positive integer";
+        else if (!diskMb || isNaN(diskMb) || diskMb % 1 != 0 || diskMb < 0)
+            throw "diskMb should be a positive integer";
+        else if (!totalInstanceCount || isNaN(totalInstanceCount) || totalInstanceCount % 1 != 0 || totalInstanceCount < 0)
+            throw "totalInstanceCount should be a positive intiger";
+        else if (!cpuCount || isNaN(cpuCount) || cpuCount % 1 != 0 || cpuCount < 0)
+            throw "CPU count should be a positive integer";
+        else if (!cpuSpeed || isNaN(cpuSpeed) || cpuSpeed % 1 != 0 || cpuSpeed < 0)
+            throw "CPU speed should be a positive integer";
+        else if (!cpuModel)
+            throw "cpu model cannot be empty";
+
+        // Need to use control characters inside this regex to match ascii characters.
+        // Here we allow all the characters in ascii range except ";" for the description.
+        // no-control-regex is enabled default by eslint:recommended, So we disable it only for next line.
+        // eslint-disable-next-line no-control-regex
+        else if (!/^((?![;])[\x00-\x7F]){0,26}$/.test(description))
+            throw "description should consist of 0-26 ascii characters except ';'";
+
+        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.getHostInfo(this.xrplAcc.address);
+            if (regInfo) {
+                const registryAcc = new XrplAccount(this.registryAddress, null, { xrplApi: this.xrplApi });
+                const sellOffer = (await registryAcc.getNftOffers()).find(o => o.NFTokenID == regInfo.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 = `${countryCode};${cpuMicroSec};${ramMb};${diskMb};${totalInstanceCount};${cpuModel};${cpuCount};${cpuSpeed};${description}`
+        const tx = await this.xrplAcc.makePayment(this.registryAddress,
+            this.config.hostRegFee.toString(),
+            EvernodeConstants.EVR,
+            this.config.evrIssuerAddress,
+            [{ type: MemoTypes.HOST_REG, format: MemoFormats.TEXT, data: memoData }],
+            options.transactionOptions);
+
+        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++;
+            }
+
+        }
+        if (!offer)
+            throw 'No sell offer found within timeout.';
+
+        console.log('Accepting the sell 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.buyNft(offer.index);
+
+        return await this.isRegistered();
+    }
+
+    async deregister(options = {}) {
+
+        if (!(await this.isRegistered()))
+            throw "Host not registered."
+
+        const regNFT = await this.getRegistrationNft();
+        await this.xrplAcc.makePayment(this.registryAddress,
+            XrplConstants.MIN_XRP_AMOUNT,
+            XrplConstants.XRP,
+            null,
+            [{ type: MemoTypes.HOST_DEREG, format: MemoFormats.HEX, data: regNFT.NFTokenID }],
+            options.transactionOptions);
+
+        console.log('Waiting for the buy 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) {
+            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,
+            [{ type: MemoTypes.HOST_POST_DEREG, format: MemoFormats.HEX, data: regNFT.NFTokenID }]
+        );
+
+        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 = {}) {
+        const dataStr = `${tokenID ? tokenID : ''};${countryCode ? countryCode : ''};${cpuMicroSec ? cpuMicroSec : ''};${ramMb ? ramMb : ''};${diskMb ? diskMb : ''};${totalInstanceCount ? totalInstanceCount : ''};${activeInstanceCount !== undefined ? activeInstanceCount : ''};${description ? description : ''};${version ? version : ''}`;
+        return await this.xrplAcc.makePayment(this.registryAddress,
+            XrplConstants.MIN_XRP_AMOUNT,
+            XrplConstants.XRP,
+            null,
+            [{ type: MemoTypes.HOST_UPDATE_INFO, format: MemoFormats.TEXT, data: dataStr }],
+            options.transactionOptions);
+    }
+
+    async heartbeat(options = {}) {
+        return this.xrplAcc.makePayment(this.registryAddress,
+            XrplConstants.MIN_XRP_AMOUNT,
+            XrplConstants.XRP,
+            null,
+            [{ type: MemoTypes.HEARTBEAT, format: "", data: "" }],
+            options.transactionOptions);
+    }
+
+    async acquireSuccess(txHash, tenantAddress, instanceInfo, options = {}) {
+
+        // Encrypt the instance info with the tenant's encryption key (Specified in MessageKey field of the tenant account).
+        const tenantAcc = new XrplAccount(tenantAddress, null, { xrplApi: this.xrplApi });
+        const encKey = await tenantAcc.getMessageKey();
+        if (!encKey)
+            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);
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+    getLeaseNFTokenIdPrefix() {
+        let buf = Buffer.allocUnsafe(24);
+        buf.writeUInt16BE(1);
+        buf.writeUInt16BE(0, 2);
+        codec.decodeAccountID(this.xrplAcc.address).copy(buf, 4);
+        return buf.toString('hex');
+    }
+}
+
+module.exports = {
+    HostEvents,
+    HostClient
+}

package/src/clients/registry-client.js

@@ -0,0 +1,52 @@
+const { EvernodeEvents } = require('../evernode-common');
+const { BaseEvernodeClient } = require('./base-evernode-client');
+const { DefaultValues } = require('../defaults');
+
+const RegistryEvents = {
+    HostRegistered: EvernodeEvents.HostRegistered,
+    HostDeregistered: EvernodeEvents.HostDeregistered,
+    HostRegUpdated: EvernodeEvents.HostRegUpdated,
+    RegistryInitialized: EvernodeEvents.RegistryInitialized,
+    Heartbeat: EvernodeEvents.Heartbeat,
+    HostPostDeregistered: EvernodeEvents.HostPostDeregistered,
+    DeadHostPrune: EvernodeEvents.DeadHostPrune
+}
+
+class RegistryClient extends BaseEvernodeClient {
+
+    /**
+     * Constructs a registry client instance.
+     * @param {object} options [Optional] An object with 'rippledServer' URL and 'registryAddress'.
+     */
+    constructor(options = {}) {
+        super((options.registryAddress || DefaultValues.registryAddress), null, Object.values(RegistryEvents), false, options);
+    }
+
+    /**
+     * Gets all the active hosts registered in Evernode without paginating.
+     * @returns The list of active hosts.
+     */
+    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 fullHostList.filter(h => h.active);
+    }
+}
+
+module.exports = {
+    RegistryEvents,
+    RegistryClient
+}

package/src/clients/tenant-client.js

@@ -0,0 +1,264 @@
+const { BaseEvernodeClient } = require('./base-evernode-client');
+const { EvernodeEvents, MemoFormats, MemoTypes, ErrorCodes, ErrorReasons, EvernodeConstants } = require('../evernode-common');
+const { EncryptionHelper } = require('../encryption-helper');
+const { XrplAccount } = require('../xrpl-account');
+const { UtilHelpers } = require('../util-helpers');
+const { Buffer } = require('buffer');
+const codec = require('ripple-address-codec');
+const { EvernodeHelpers } = require('../evernode-helpers');
+const { TransactionHelper } = require('../transaction-helper');
+
+const DEFAULT_WAIT_TIMEOUT = 60000;
+
+const TenantEvents = {
+    AcquireSuccess: EvernodeEvents.AcquireSuccess,
+    AcquireError: EvernodeEvents.AcquireError,
+    ExtendSuccess: EvernodeEvents.ExtendSuccess,
+    ExtendError: EvernodeEvents.ExtendError,
+}
+
+class TenantClient extends BaseEvernodeClient {
+
+    /**
+     * Constructs a tenant client instance.
+     * @param {string} xrpAddress XRPL address of the tenant.
+     * @param {string} XRPL secret of the tenant.
+     * @param {object} options [Optional] An object with 'rippledServer' URL and 'registryAddress'.
+     */
+    constructor(xrpAddress, xrpSecret, options = {}) {
+        super(xrpAddress, xrpSecret, Object.values(TenantEvents), false, options);
+    }
+
+    async prepareAccount() {
+        try {
+            if (!await this.xrplAcc.getMessageKey())
+                await this.xrplAcc.setAccountFields({ MessageKey: this.accKeyPair.publicKey });
+        }
+        catch (err) {
+            console.log("Error in preparing user xrpl account for Evernode.", err);
+        }
+    }
+
+    async getLeaseHost(hostAddress) {
+        const host = new XrplAccount(hostAddress, null, { xrplApi: this.xrplApi });
+        // Find an owned NFT with matching Evernode host NFT prefix.
+        const nft = (await host.getNfts()).find(n => n.URI.startsWith(EvernodeConstants.NFT_PREFIX_HEX));
+        if (!nft)
+            throw { reason: ErrorReasons.HOST_INVALID, error: "Host is not registered." };
+
+        // 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 { reason: ErrorReasons.HOST_INVALID, error: "Host is not registered." };
+
+        // Check whether active.
+        const hostInfo = await this.getHostInfo(host.address);
+        if (!hostInfo)
+            throw { reason: ErrorReasons.HOST_INVALID, error: "Host is not registered." };
+        else if (!hostInfo.active)
+            throw { reason: ErrorReasons.HOST_INACTIVE, error: "Host is not active." };
+
+        return host;
+    }
+
+    /**
+     * 
+     * @param {string} hostAddress XRPL address of the host to acquire the lease.
+     * @param {object} requirement The instance requirements and configuration.
+     * @param {object} options [Optional] Options for the XRPL transaction.
+     * @returns The transaction result.
+     */
+    async acquireLeaseSubmit(hostAddress, requirement, options = {}) {
+
+        const hostAcc = await this.getLeaseHost(hostAddress);
+        let selectedOfferIndex = options.leaseOfferIndex;
+
+        // Attempt to get first available offer, if offer is not specified in options.
+        if (!selectedOfferIndex) {
+            const nftOffers = await EvernodeHelpers.getLeaseOffers(hostAcc);
+            selectedOfferIndex = nftOffers && nftOffers[0] && nftOffers[0].index;
+
+            if (!selectedOfferIndex)
+                throw { reason: ErrorReasons.NO_OFFER, error: "No offers available." };
+        }
+
+        // Encrypt the requirements with the host's encryption key (Specified in MessageKey field of the host account).
+        const encKey = await hostAcc.getMessageKey();
+        if (!encKey)
+            throw { reason: ErrorReasons.INTERNAL_ERR, error: "Host encryption key not set." };
+
+        const ecrypted = await EncryptionHelper.encrypt(encKey, requirement, {
+            iv: options.iv, // Must be null or 16 bytes.
+            ephemPrivateKey: options.ephemPrivateKey // Must be null or 32 bytes.
+        });
+
+        return this.xrplAcc.buyNft(selectedOfferIndex, [{ type: MemoTypes.ACQUIRE_LEASE, format: MemoFormats.BASE64, data: ecrypted }], options.transactionOptions);
+    }
+
+    /**
+     * Watch for the acquire-success response after the acquire request is made.
+     * @param {object} tx The transaction returned by the acquireLeaseSubmit function.
+     * @param {object} options [Optional] Options for the XRPL transaction.
+     * @returns An object including transaction details,instance info, and acquireReference Id.
+     */
+    async watchAcquireResponse(tx, options = {}) {
+            console.log(`Waiting for acquire response... (txHash: ${tx.id})`);
+
+            const failTimeout = setTimeout(() => {
+                throw({ error: ErrorCodes.ACQUIRE_ERR, reason: ErrorReasons.TIMEOUT });
+            }, options.timeout || DEFAULT_WAIT_TIMEOUT);
+    
+            let relevantTx = null;
+            while (!relevantTx) {
+                const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
+                for (let t of txList) {
+                    t.tx.Memos = TransactionHelper.deserializeMemos(t.tx?.Memos);
+                        const res = await this.extractEvernodeEvent(t.tx);
+                        if ((res?.name === EvernodeEvents.AcquireSuccess || res?.name === EvernodeEvents.AcquireError) && res?.data?.acquireRefId === tx.id) {
+                            clearTimeout(failTimeout);
+                            relevantTx = res;
+                            break;
+                        }
+                }
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+    
+            if (relevantTx?.name === TenantEvents.AcquireSuccess) {
+                return({
+                    transaction: relevantTx?.data.transaction,
+                    instance: relevantTx?.data.payload.content,
+                    acquireRefId: relevantTx?.data.acquireRefId
+                });
+            } else if (relevantTx?.name === TenantEvents.AcquireError) {
+                throw({
+                    error: ErrorCodes.ACQUIRE_ERR,
+                    transaction: relevantTx?.data.transaction,
+                    reason: relevantTx?.data.reason,
+                    acquireRefId: relevantTx?.data.acquireRefId
+                })
+            }
+    }
+
+    /**
+     * Acquire an instance from a host
+     * @param {string} hostAddress XRPL address of the host to acquire the lease.
+     * @param {object} requirement The instance requirements and configuration.
+     * @param {object} options [Optional] Options for the XRPL transaction.
+     * @returns An object including transaction details,instance info, and acquireReference Id.
+     */
+    acquireLease(hostAddress, requirement, options = {}) {
+        return new Promise(async (resolve, reject) => {
+            const tx = await this.acquireLeaseSubmit(hostAddress, requirement, options).catch(error => {
+                reject({ error: ErrorCodes.ACQUIRE_ERR, reason: error.reason || ErrorReasons.TRANSACTION_FAILURE, content: error.error || error });
+            });
+            if (tx) {
+                try {
+                    const response = await this.watchAcquireResponse(tx, options);
+                    resolve(response);
+                } catch (error) {
+                    reject(error);
+                }
+            }
+        });
+    }
+
+    /**
+     * This function is called by a tenant client to submit the extend lease transaction in certain host. This function will be called inside extendLease function. This function can take four parameters as follows.
+     * @param {string} hostAddress XRPL account address of the host.
+     * @param {number} amount Cost for the extended moments , in EVRs.
+     * @param {string} tokenID Tenant received instance name. this name can be retrieve by performing acquire Lease.
+     * @param {object} options This is an optional field and contains necessary details for the transactions.
+     * @returns The transaction result.
+     */
+    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);
+    }
+
+    /**
+     * This function watches for an extendlease-success response(transaction) and returns the response or throws the error response on extendlease-error response from the host XRPL account. This function is called within the extendLease function.
+     * @param {object} tx Response of extendLeaseSubmit.
+     * @param {object} options This is an optional field and contains necessary details for the transactions.
+     * @returns An object including transaction details.
+     */
+    async watchExtendResponse(tx, options = {}) {
+        console.log(`Waiting for extend lease response... (txHash: ${tx.id})`);
+
+        const failTimeout = setTimeout(() => {
+            throw({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.TIMEOUT });
+        }, options.timeout || DEFAULT_WAIT_TIMEOUT);
+
+        let relevantTx = null;
+        while (!relevantTx) {
+            const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
+            for (let t of txList) {
+                t.tx.Memos = TransactionHelper.deserializeMemos(t.tx.Memos);
+                const res = await this.extractEvernodeEvent(t.tx);
+                if ((res?.name === TenantEvents.ExtendSuccess || res?.name === TenantEvents.ExtendError) && res?.data?.extendRefId === tx.id) {
+                    clearTimeout(failTimeout);
+                    relevantTx = res;
+                    break;
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+        if (relevantTx?.name === TenantEvents.ExtendSuccess) {
+            return({
+                transaction: relevantTx?.data.transaction,
+                expiryMoment: relevantTx?.data.expiryMoment,
+                extendeRefId: relevantTx?.data.extendRefId
+            });
+        } else if (relevantTx?.name === TenantEvents.ExtendError) {
+            throw({
+                error: ErrorCodes.EXTEND_ERR,
+                transaction: relevantTx?.data.transaction,
+                reason: relevantTx?.data.reason
+            })
+        }
+    }
+
+    /**
+     * This function is called by a tenant client to extend an available instance in certain host. This function can take four parameters as follows.
+     * @param {string} hostAddress XRPL account address of the host.
+     * @param {number} moments 1190 ledgers (est. 1 hour).
+     * @param {string} instanceName Tenant received instance name. this name can be retrieve by performing acquire Lease.
+     * @param {object} options This is an optional field and contains necessary details for the transactions.
+     * @returns An object including transaction details.
+     */
+    extendLease(hostAddress, moments, instanceName, options = {}) {
+        return new Promise(async (resolve, reject) => {
+            const tokenID = instanceName;
+            const nft = (await this.xrplAcc.getNfts())?.find(n => n.NFTokenID == tokenID);
+
+            if (!nft) {
+                reject({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.NO_NFT, content: 'Could not find the nft for lease extend request.' });
+                return;
+            }
+
+            let minLedgerIndex = this.xrplApi.ledgerIndex;
+
+            // Get the agreement lease amount from the nft and calculate EVR amount to be sent.
+            const uriInfo = UtilHelpers.decodeLeaseNftUri(nft.URI);
+            const tx = await this.extendLeaseSubmit(hostAddress, moments * uriInfo.leaseAmount, tokenID, options).catch(error => {
+                reject({ error: ErrorCodes.EXTEND_ERR, reason: error.reason || ErrorReasons.TRANSACTION_FAILURE, content: error.error || error });
+            });
+
+            if (tx) {
+                try {
+                    const response = await this.watchExtendResponse(tx, minLedgerIndex, options)
+                    resolve(response);
+                } catch (error) {
+                    reject(error);
+                }
+            }
+        });
+    }
+}
+
+module.exports = {
+    TenantEvents,
+    TenantClient
+}