evernode-js-client 0.5.11 → 0.5.12

package/src/event-emitter.js

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

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

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

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

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