evernode-js-client 0.5.0 → 0.5.2

package/src/clients/host-client.js

@@ -1,357 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,264 +0,0 @@
-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
-}