evernode-js-client 0.5.9 → 0.5.11

package/src/event-emitter.js

@@ -0,0 +1,45 @@
+class EventEmitter {
+    constructor() {
+        this.handlers = {};
+    }
+
+    on(event, handler) {
+        if (!this.handlers[event])
+            this.handlers[event] = [];
+        this.handlers[event].push({
+            once: false,
+            func: handler
+        });
+    }
+
+    once(event, handler) {
+        if (!this.handlers[event])
+            this.handlers[event] = [];
+        this.handlers[event].push({
+            once: true,
+            func: handler
+        });
+    }
+
+    off(event, handler = null) {
+        if (this.handlers[event]) {
+            if (handler)
+                this.handlers[event] = this.handlers[event].filter(h => h !== handler);
+            else
+                delete this.handlers[event];
+        }
+    }
+
+    emit(event, value, error = null) {
+        if (this.handlers[event]) {
+            this.handlers[event].forEach(handler => handler.func(value, error));
+
+            // Rmove all handlers marked as 'once'.
+            this.handlers[event] = this.handlers[event].filter(h => !h.once);
+        }
+    }
+}
+
+module.exports = {
+    EventEmitter
+}

package/src/evernode-common.js

@@ -0,0 +1,113 @@
+const EvernodeConstants = {
+    EVR: 'EVR',
+    NFT_PREFIX_HEX: '657672686F7374', // evrhost
+    LEASE_NFT_PREFIX_HEX: '6576726C65617365', // evrlease
+    HOOK_NAMESPACE: '01EAF09326B4911554384121FF56FA8FECC215FDDE2EC35D9E59F2C53EC665A0',
+    NOW_IN_EVRS: "0.00000001"
+}
+
+const MemoTypes = {
+    ACQUIRE_LEASE: 'evnAcquireLease',
+    ACQUIRE_SUCCESS: 'evnAcquireSuccess',
+    ACQUIRE_ERROR: 'evnAcquireError',
+    ACQUIRE_REF: 'evnAcquireRef',
+    HOST_REG: 'evnHostReg',
+    HOST_DEREG: 'evnHostDereg',
+    HOST_UPDATE_INFO: 'evnHostUpdateReg',
+    HEARTBEAT: 'evnHeartbeat',
+    HOST_POST_DEREG: 'evnHostPostDereg',
+    HOST_TRANSFER: 'evnTransfer',
+    EXTEND_LEASE: 'evnExtendLease',
+    EXTEND_SUCCESS: 'evnExtendSuccess',
+    EXTEND_ERROR: 'evnExtendError',
+    EXTEND_REF: 'evnExtendRef',
+    REGISTRY_INIT: 'evnInitialize',
+    REFUND: 'evnRefund',
+    REFUND_REF: 'evnRefundRef',
+    DEAD_HOST_PRUNE: 'evnDeadHostPrune',
+    HOST_REBATE: 'evnHostRebate',
+    HOST_REGISTRY_REF: 'evnHostRegistryRef'
+}
+
+const MemoFormats = {
+    TEXT: 'text/plain',
+    JSON: 'text/json',
+    BASE64: 'base64',
+    HEX: 'hex'
+}
+
+const ErrorCodes = {
+    ACQUIRE_ERR: 'ACQUIRE_ERR',
+    EXTEND_ERR: 'EXTEND_ERR'
+}
+
+const ErrorReasons = {
+    TRANSACTION_FAILURE: 'TRANSACTION_FAILURE',
+    NO_OFFER: 'NO_OFFER',
+    NO_NFT: 'NO_NFT',
+    INTERNAL_ERR: 'INTERNAL_ERR',
+    TIMEOUT: 'TIMEOUT',
+    HOST_INVALID: 'HOST_INVALID',
+    HOST_INACTIVE: 'HOST_INACTIVE',
+    NO_STATE_KEY: 'NO_STATE_KEY'
+}
+
+// All keys are prefixed with 'EVR' (0x455652)
+// Config keys sub-prefix: 0x01
+const HookStateKeys = {
+    // Configuration.
+    EVR_ISSUER_ADDR: "4556520100000000000000000000000000000000000000000000000000000001",
+    FOUNDATION_ADDR: "4556520100000000000000000000000000000000000000000000000000000002",
+    MOMENT_SIZE: "4556520100000000000000000000000000000000000000000000000000000003",
+    MINT_LIMIT: "4556520100000000000000000000000000000000000000000000000000000004",
+    FIXED_REG_FEE: "4556520100000000000000000000000000000000000000000000000000000005",
+    HOST_HEARTBEAT_FREQ: "4556520100000000000000000000000000000000000000000000000000000006",
+    PURCHASER_TARGET_PRICE: "4556520100000000000000000000000000000000000000000000000000000007",
+    LEASE_ACQUIRE_WINDOW: "4556520100000000000000000000000000000000000000000000000000000008",
+    REWARD_CONFIGURATION: "4556520100000000000000000000000000000000000000000000000000000009",
+    MAX_TOLERABLE_DOWNTIME: "455652010000000000000000000000000000000000000000000000000000000A",
+    MOMENT_TRANSIT_INFO: "455652010000000000000000000000000000000000000000000000000000000B",
+    MAX_TRX_EMISSION_FEE: "455652010000000000000000000000000000000000000000000000000000000C",
+
+
+    // Singleton
+    HOST_COUNT: "4556523200000000000000000000000000000000000000000000000000000000",
+    MOMENT_BASE_INFO: "4556523300000000000000000000000000000000000000000000000000000000",
+    HOST_REG_FEE: "4556523400000000000000000000000000000000000000000000000000000000",
+    MAX_REG: "4556523500000000000000000000000000000000000000000000000000000000",
+    REWARD_INFO: "4556523600000000000000000000000000000000000000000000000000000000",
+
+    // 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",
+    Heartbeat: "Heartbeat",
+    ExtendLease: "ExtendLease",
+    ExtendSuccess: "ExtendSuccess",
+    ExtendError: "ExtendError",
+    HostRegUpdated: "HostRegUpdated",
+    HostReRegistered: "HostReRegistered",
+    RegistryInitialized: "RegistryInitialized",
+    DeadHostPrune: "DeadHostPrune",
+    HostRebate: "HostRebate"
+}
+
+module.exports = {
+    EvernodeConstants,
+    MemoTypes,
+    MemoFormats,
+    ErrorCodes,
+    ErrorReasons,
+    HookStateKeys,
+    EvernodeEvents
+}

package/src/evernode-helpers.js

@@ -0,0 +1,45 @@
+const { EvernodeConstants } = require('./evernode-common');
+const NFT_PAGE_LEDGER_ENTRY_TYPE_HEX = '0050';
+
+class EvernodeHelpers {
+    static async getLeaseOffers(xrplAcc) {
+        const hostNfts = (await xrplAcc.getNfts()).filter(nft => nft.URI.startsWith(EvernodeConstants.LEASE_NFT_PREFIX_HEX));
+        const hostTokenIDs = hostNfts.map(nft => nft.NFTokenID);
+        const nftOffers = (await xrplAcc.getNftOffers())?.filter(offer => (offer.Flags == 1 && hostTokenIDs.includes(offer.NFTokenID))); // Filter only sell offers
+        return nftOffers;
+    }
+
+    static async getNFTPageAndLocation(nfTokenId, xrplAcc, xrplApi, buffer = true) {
+
+        const nftPageApprxKeylet = xrplAcc.generateKeylet('nftPage', { nfTokenId: nfTokenId });
+        const nftPageMaxKeylet = xrplAcc.generateKeylet('nftPageMax');
+        // Index is the last 32 bytes of the Keylet (Last 64 HEX characters).
+        let page = await xrplApi.getLedgerEntry(nftPageMaxKeylet.substring(4, 68));
+        while (page?.PreviousPageMin) {
+            // Compare the low 96 bits. (Last 24 HEX characters).
+            if (Number('0x' + page.index.substring(40, 64)) >= Number('0x' + nftPageApprxKeylet.substring(40, 64))) {
+                // Check the existence of the NFToken
+                let token = page.NFTokens.find(n => n.NFToken.NFTokenID == nfTokenId);
+                if (!token) {
+                    page = await xrplApi.getLedgerEntry(page.PreviousPageMin);
+                }
+                else
+                    break;
+            }
+        }
+
+        const nftPageInfo = page.NFTokens.map((n, loc) => { return { NFTPage: NFT_PAGE_LEDGER_ENTRY_TYPE_HEX + page.index, NFTokenID: n.NFToken.NFTokenID, location: loc } }).find(n => n.NFTokenID == nfTokenId);
+        if (buffer) {
+            let locBuf = Buffer.allocUnsafe(2);
+            locBuf.writeUInt16BE(nftPageInfo.location);
+            // <NFT_PAGE_KEYLET(34 bytes)><LOCATION(2 bytes)>
+            return Buffer.concat([Buffer.from(nftPageInfo.NFTPage, "hex"), locBuf]);
+        }
+
+        return nftPageInfo;
+    }
+}
+
+module.exports = {
+    EvernodeHelpers
+}

package/src/firestore/firestore-handler.js

@@ -0,0 +1,309 @@
+const https = require('https');
+const { DefaultValues } = require('../defaults');
+
+const FirestoreOperations = {
+    EQUAL: 'EQUAL',
+    AND: 'AND'
+}
+
+class FirestoreHandler {
+    #projectId = null;
+    #collectionPrefix = null;
+
+    constructor(options = {}) {
+        this.#projectId = options.stateIndexId || DefaultValues.stateIndexId;
+        this.#collectionPrefix = options.collectionPrefix || DefaultValues.registryAddress;
+    }
+
+    /**
+     * Convert given document value object to real format and snake_case key to camelCase.
+     * @param key Name of the property.
+     * @param value Value to be parsed.
+     * @returns Parsed key and value.
+     */
+    #parseValue(key, value) {
+        // Convert snake_case to camelCase.
+        const ccKey = key.replace(/_([a-z])/g, function (g) { return g[1].toUpperCase(); });
+        const type = Object.keys(value)[0];
+        let parsed;
+        switch (type) {
+            case 'integerValue':
+                parsed = parseInt(value[type]);
+                break;
+            case 'floatValue':
+                parsed = parseFloat(value[type]);
+                break;
+            case 'mapValue':
+                parsed = {};
+                for (const [subKey, subValue] of Object.entries(value[type].fields)) {
+                    const field = this.#parseValue(subKey, subValue);
+                    parsed[field.key] = field.value;
+                }
+                break;
+            default:
+                parsed = value[type];
+                break;
+        }
+        return { key: ccKey, value: parsed };
+    }
+
+    /**
+     * Get values filtered according to the given body.
+     * @param body Body to parsed in to the query reqest.
+     * @returns Result set.
+     */
+    async #runQuery(body) {
+        const url = this.buildApiPath(null, null, true);
+        return await this.sendRequest('POST', url, null, body);
+    }
+
+    /**
+     * Get documents from a collection.
+     * @param collectionId Name of the collection.
+     * @param pageSize Optianal page size if result set needed to be paginated
+     * @param nextPageToken Next page token of a paginated result set.
+     * @returns Result set.
+     */
+    async #read(collectionId, pageSize = null, nextPageToken = null) {
+        if (!collectionId)
+            throw { type: 'Validation Error', message: 'collectionId is required' };
+
+        const url = this.buildApiPath(collectionId);
+        let params = (pageSize || nextPageToken) ? {} : null;
+        if (pageSize)
+            params = { pageSize: pageSize };
+        if (nextPageToken)
+            params = { pageToken: nextPageToken, ...params };
+
+        return await this.sendRequest('GET', url, params);
+    }
+
+    /**
+     * Get documents from a collection with filtering support.
+     * @param collectionId Name of the collection.
+     * @param filter Optional filters to filter documents.
+     * @param pageSize Optianal page size if result set needed to be paginated
+     * @param nextPageToken Next page token of a paginated result set.
+     * @returns Parsed readable result set.
+     */
+    async #getDocuments(collectionId, filters = null, pageSize = null, nextPageToken = null) {
+        if (filters && (pageSize || nextPageToken))
+            throw { type: 'Validation Error', message: 'Pagination isn\'t supported with filter.' };
+
+        let data;
+        // If there are filters send requst in query mode.
+        if (filters) {
+            // Prepare the query body from given filters.
+            let where = {
+                compositeFilter: {
+                    filters: Object.entries(filters).map(([key, value]) => {
+                        const field = this.convertValue(key, value);
+                        return {
+                            fieldFilter: {
+                                field: { fieldPath: field.key },
+                                op: FirestoreOperations.EQUAL,
+                                value: field.value
+                            }
+                        }
+                    }),
+                    op: filters.operator ? filters.operator : FirestoreOperations.AND
+                }
+            };
+            for (const [key, value] of Object.entries(filters)) {
+                const field = this.convertValue(key, value);
+                let fieldFilter = {
+                    field: { fieldPath: field.key },
+                    op: FirestoreOperations.EQUAL,
+                    value: field.value
+                }
+                where.compositeFilter.filters.push({ fieldFilter: fieldFilter });
+            }
+
+            let body = {
+                structuredQuery: {
+                    where: where,
+                    from: [{ collectionId: collectionId }]
+                }
+            };
+            data = await this.#runQuery(body);
+            data = data ? JSON.parse(data) : [];
+            if (data && data.length && data[0].document) {
+                return data.map(d => {
+                    return this.parseDocument(d.document);
+                });
+            }
+        }
+        else {
+            data = await this.#read(collectionId, pageSize, nextPageToken);
+            data = data ? JSON.parse(data) : {};
+            if (data.documents && data.documents.length) {
+                const list = data.documents.map(d => {
+                    return this.parseDocument(d);
+                });
+                return data.nextPageToken ? {
+                    data: list,
+                    nextPageToken: data.nextPageToken
+                } : list;
+            }
+        }
+
+        return [];
+    }
+
+    getCollectionId(collection) {
+        // Document if is generated with given prefix.
+        return `${this.#collectionPrefix}_${collection}`;
+    }
+
+    /**
+     * Send http requst.
+     * @param httpMethod GET/POST/PATCH/DELETE
+     * @param url Url for the request.
+     * @param params Optional query params.
+     * @param data Optional request body.
+     * @param options Optional options.
+     * @returns Result set.
+     */
+    async sendRequest(httpMethod, url, params = null, data = null, options = null) {
+        const urlObj = new URL(url);
+        // Populate uri params to the URL object.
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value) {
+                    // If value is a array, populate it with same name.
+                    if (typeof value === 'object') {
+                        for (const val of value) {
+                            if (val)
+                                urlObj.searchParams.append(key, val);
+                        }
+                    }
+                    else
+                        urlObj.searchParams.set(key, value);
+                }
+            }
+        }
+
+        let reqOptions = {
+            method: httpMethod,
+            protocol: urlObj.protocol,
+            hostname: urlObj.hostname,
+            port: urlObj.port,
+            path: `${urlObj.pathname}?${urlObj.searchParams.toString()}`,
+            ...(options ? options : {})
+        };
+
+        return new Promise(async (resolve, reject) => {
+            // Send request and collect data chuncks to a buffer. Then return the result set on end event.
+            // Resolve only if the status is 200.
+            const req = https.request(reqOptions, (res) => {
+                let resData = '';
+                res.on('data', (d) => {
+                    resData += d;
+                });
+                res.on('end', async () => {
+                    if (res.statusCode === 200) {
+                        resolve(resData);
+                        return;
+                    }
+                    reject({ status: res.statusCode, data: resData });
+                    return;
+                });
+            }).on('error', async (e) => {
+                reject(e);
+                return;
+            });
+
+            if (data)
+                req.write(typeof data === 'object' ? JSON.stringify(data) : data);
+
+            req.end();
+        });
+    }
+
+    /**
+     * Generate url for firestore.
+     * @param collectionId Optional collection name.
+     * @param documentId Optional document name.
+     * @param isQuery Whether a query request or not.
+     * @returns The generated url.
+     */
+    buildApiPath(collectionId = null, documentId = null, isQuery = false) {
+        let path = `https://firestore.googleapis.com/v1/projects/${this.#projectId}/databases/(default)/documents`;
+        if (collectionId)
+            path += `/${collectionId.toString()}`;
+        if (documentId)
+            path += `/${documentId.toString()}`;
+        if (isQuery)
+            path += ':runQuery';
+        return path;
+    }
+
+    /**
+     * Generate firestore document value object from given key and value, Convert camelCase key to snake_case.
+     * @param key Name of the value.
+     * @param value Value to be parsed.
+     * @returns Generated firestore document object.
+     */
+    convertValue(key, value) {
+        // Convert camelCase to snake_case.
+        const uKey = key.replace(/([A-Z])/g, function (g) { return `_${g[0].toLocaleLowerCase()}`; });
+        let val = {};
+        let type
+        switch (typeof value) {
+            case 'number':
+                type = (value % 1 > 0 ? 'float' : 'integer');
+                val = value;
+                break;
+            case 'object':
+                type = 'map';
+                val = {
+                    fields: {}
+                }
+                // Prepare the firestore write body with the given data object.
+                for (const [subKey, subValue] of Object.entries(value)) {
+                    const field = this.convertValue(subKey, subValue);
+                    val.fields[field.key] = field.value;
+                }
+                break;
+            default:
+                type = 'string';
+                val = value;
+                break;
+        }
+        type = `${type}Value`;
+        let obj = {};
+        obj[type] = val;
+        return { key: uKey, value: obj };
+    }
+
+    /**
+     * Convert the firestore document to human readable simplified json object.
+     * @param document Firestore document.
+     * @returns Simplified json object for the document.
+     */
+    parseDocument(document) {
+        let item = {
+            id: document.name.split('/').pop(),
+            createTime: new Date(document.createTime),
+            updateTime: new Date(document.updateTime)
+        };
+        for (const [key, value] of Object.entries(document.fields)) {
+            const field = this.#parseValue(key, value);
+            item[field.key] = field.value;
+        }
+        return item;
+    }
+
+    async getHosts(filters = null, pageSize = null, nextPageToken = null) {
+        return await this.#getDocuments(this.getCollectionId('hosts'), filters, pageSize, nextPageToken);
+    }
+
+    async getConfigs(filters = null, pageSize = null, nextPageToken = null) {
+        return await this.#getDocuments(this.getCollectionId('configs'), filters, pageSize, nextPageToken);
+    }
+}
+
+module.exports = {
+    FirestoreHandler,
+    FirestoreOperations
+}

package/src/index.js

@@ -0,0 +1,37 @@
+const { Defaults } = require('./defaults');
+const { RegistryClient, RegistryEvents } = require("./clients/registry-client");
+const { TenantClient, TenantEvents } = require("./clients/tenant-client");
+const { HostClient, HostEvents } = require("./clients/host-client");
+const { XrplApi } = require('./xrpl-api');
+const { XrplApiEvents, XrplConstants } = require('./xrpl-common');
+const { XrplAccount } = require('./xrpl-account');
+const { EvernodeConstants, HookStateKeys, MemoTypes } = require('./evernode-common');
+const { XflHelpers } = require('./xfl-helpers');
+const { FirestoreHandler } = require('./firestore/firestore-handler');
+const { StateHelpers } = require('./state-helpers');
+const { UtilHelpers } = require('./util-helpers');
+const { TransactionHelper } = require('./transaction-helper');
+const { EncryptionHelper } = require('./encryption-helper');
+
+module.exports = {
+    RegistryClient,
+    RegistryEvents,
+    TenantClient,
+    TenantEvents,
+    HostClient,
+    HostEvents,
+    XrplApi,
+    XrplApiEvents,
+    XrplConstants,
+    XrplAccount,
+    EvernodeConstants,
+    Defaults,
+    XflHelpers,
+    StateHelpers,
+    FirestoreHandler,
+    UtilHelpers,
+    TransactionHelper,
+    EncryptionHelper,
+    HookStateKeys,
+    MemoTypes
+}