evernode-js-client 0.4.53 → 0.5.0

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
+}

package/src/state-helpers.js

@@ -0,0 +1,283 @@
+const codec = require('ripple-address-codec');
+const { Buffer } = require('buffer');
+const { HookStateKeys, EvernodeConstants } = require('./evernode-common');
+const { XflHelpers } = require('./xfl-helpers');
+const crypto = require("crypto");
+
+const NFTOKEN_PREFIX = '00000000';
+
+const EPOCH_OFFSET = 0;
+const SAVED_MOMENT_OFFSET = 1;
+const PREV_MOMENT_ACTIVE_HOST_COUNT_OFFSET = 5;
+const CUR_MOMENT_ACTIVE_HOST_COUNT_OFFSET = 9;
+const EPOCH_POOL_OFFSET = 13;
+
+const EPOCH_COUNT_OFFSET = 0;
+const FIRST_EPOCH_REWARD_QUOTA_OFFSET = 1;
+const EPOCH_REWARD_AMOUNT_OFFSET = 5;
+const REWARD_START_MOMENT_OFFSET = 9;
+
+const HOST_TOKEN_ID_OFFSET = 0;
+const HOST_COUNTRY_CODE_OFFSET = 32;
+const HOST_RESERVED_OFFSET = 34;
+const HOST_DESCRIPTION_OFFSET = 42;
+const HOST_REG_LEDGER_OFFSET = 68;
+const HOST_REG_FEE_OFFSET = 76;
+const HOST_TOT_INS_COUNT_OFFSET = 84;
+const HOST_ACT_INS_COUNT_OFFSET = 88;
+const HOST_HEARTBEAT_LEDGER_IDX_OFFSET = 92;
+const HOST_VERSION_OFFSET = 100;
+
+const HOST_ADDRESS_OFFSET = 0;
+const HOST_CPU_MODEL_NAME_OFFSET = 20;
+const HOST_CPU_COUNT_OFFSET = 60;
+const HOST_CPU_SPEED_OFFSET = 62;
+const HOST_CPU_MICROSEC_OFFSET = 64;
+const HOST_RAM_MB_OFFSET = 68;
+const HOST_DISK_MB_OFFSET = 72;
+
+const STATE_KEY_TYPES = {
+    TOKEN_ID: 2,
+    HOST_ADDR: 3
+}
+
+const EVERNODE_PREFIX = 'EVR';
+const HOST_ADDR_KEY_ZERO_COUNT = 8;
+const HOOK_STATE_LEDGER_TYPE_PREFIX = 118; // Decimal value of ASCII 'v'
+
+class StateHelpers {
+    static StateTypes = {
+        TOKEN_ID: 'tokenId',
+        HOST_ADDR: 'hostAddr',
+        SIGLETON: 'singleton',
+        CONFIGURATION: 'configuration'
+    }
+
+    static decodeHostAddressState(stateKeyBuf, stateDataBuf) {
+        return {
+            address: codec.encodeAccountID(stateKeyBuf.slice(12)),
+            nfTokenId: stateDataBuf.slice(HOST_TOKEN_ID_OFFSET, HOST_COUNTRY_CODE_OFFSET).toString('hex').toUpperCase(),
+            countryCode: stateDataBuf.slice(HOST_COUNTRY_CODE_OFFSET, HOST_RESERVED_OFFSET).toString(),
+            description: stateDataBuf.slice(HOST_DESCRIPTION_OFFSET, HOST_REG_LEDGER_OFFSET).toString().replace(/\0/g, ''),
+            registrationLedger: Number(stateDataBuf.readBigUInt64BE(HOST_REG_LEDGER_OFFSET)),
+            registrationFee: Number(stateDataBuf.readBigUInt64BE(HOST_REG_FEE_OFFSET)),
+            maxInstances: stateDataBuf.readUInt32BE(HOST_TOT_INS_COUNT_OFFSET),
+            activeInstances: stateDataBuf.readUInt32BE(HOST_ACT_INS_COUNT_OFFSET),
+            lastHeartbeatLedger: Number(stateDataBuf.readBigUInt64BE(HOST_HEARTBEAT_LEDGER_IDX_OFFSET)),
+            version: `${stateDataBuf.readUInt8(HOST_VERSION_OFFSET)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 1)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 2)}`
+        }
+    }
+
+    static decodeTokenIdState(stateDataBuf) {
+        return {
+            address: codec.encodeAccountID(stateDataBuf.slice(HOST_ADDRESS_OFFSET, HOST_CPU_MODEL_NAME_OFFSET)),
+            cpuModelName: stateDataBuf.slice(HOST_CPU_MODEL_NAME_OFFSET, HOST_CPU_COUNT_OFFSET).toString().replace(/\x00+$/, ''), // Remove trailing \x00 characters.
+            cpuCount: stateDataBuf.readUInt16BE(HOST_CPU_COUNT_OFFSET),
+            cpuMHz: stateDataBuf.readUInt16BE(HOST_CPU_SPEED_OFFSET),
+            cpuMicrosec: stateDataBuf.readUInt32BE(HOST_CPU_MICROSEC_OFFSET),
+            ramMb: stateDataBuf.readUInt32BE(HOST_RAM_MB_OFFSET),
+            diskMb: stateDataBuf.readUInt32BE(HOST_DISK_MB_OFFSET)
+        }
+    }
+
+    static decodeStateData(stateKey, stateData) {
+        const hexKey = stateKey.toString('hex').toUpperCase();
+        if (Buffer.from(HookStateKeys.PREFIX_HOST_ADDR, 'hex').compare(stateKey, 0, 4) === 0) {
+            return {
+                type: this.StateTypes.HOST_ADDR,
+                key: hexKey,
+                ...this.decodeHostAddressState(stateKey, stateData)
+            }
+        }
+        else if (Buffer.from(HookStateKeys.PREFIX_HOST_TOKENID, 'hex').compare(stateKey, 0, 4) === 0) {
+            // Generate the address state key.
+            const addressKeyBuf = Buffer.alloc(32, 0);
+            Buffer.from(HookStateKeys.PREFIX_HOST_ADDR, 'hex').copy(addressKeyBuf);
+            stateData.copy(addressKeyBuf, 12, HOST_ADDRESS_OFFSET, HOST_CPU_MODEL_NAME_OFFSET)
+            return {
+                type: this.StateTypes.TOKEN_ID,
+                key: hexKey,
+                addressKey: addressKeyBuf.toString('hex').toUpperCase(),
+                ...this.decodeTokenIdState(stateData)
+            }
+        }
+        else if (Buffer.from(HookStateKeys.HOST_COUNT, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.SIGLETON,
+                key: hexKey,
+                value: stateData.readUInt32BE()
+            }
+        }
+        else if (Buffer.from(HookStateKeys.MOMENT_BASE_IDX, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.SIGLETON,
+                key: hexKey,
+                value: Number(stateData.readBigInt64BE())
+            }
+        }
+        else if (Buffer.from(HookStateKeys.HOST_REG_FEE, 'hex').compare(stateKey) === 0 || Buffer.from(HookStateKeys.MAX_REG, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.SIGLETON,
+                key: hexKey,
+                value: Number(stateData.readBigUInt64BE())
+            }
+        }
+        else if (Buffer.from(HookStateKeys.EVR_ISSUER_ADDR, 'hex').compare(stateKey) === 0 || Buffer.from(HookStateKeys.FOUNDATION_ADDR, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: codec.encodeAccountID(stateData)
+            }
+        }
+        else if (Buffer.from(HookStateKeys.MOMENT_SIZE, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.HOST_HEARTBEAT_FREQ, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.LEASE_ACQUIRE_WINDOW, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: stateData.readUInt16BE()
+            }
+        }
+        else if (Buffer.from(HookStateKeys.MINT_LIMIT, 'hex').compare(stateKey) === 0 || Buffer.from(HookStateKeys.FIXED_REG_FEE, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: Number(stateData.readBigUInt64BE())
+            }
+        }
+        else if (Buffer.from(HookStateKeys.PURCHASER_TARGET_PRICE, 'hex').compare(stateKey) === 0) {
+            const xfl = stateData.readBigInt64BE(0);
+            const val = XflHelpers.toString(xfl);
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: val
+            }
+        }
+        else if (Buffer.from(HookStateKeys.REWARD_CONFIGURATION, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: {
+                    epochCount: stateData.readUInt8(EPOCH_COUNT_OFFSET),
+                    firstEpochRewardQuota: stateData.readUInt32BE(FIRST_EPOCH_REWARD_QUOTA_OFFSET),
+                    epochRewardAmount: stateData.readUInt32BE(EPOCH_REWARD_AMOUNT_OFFSET),
+                    rewardStartMoment: stateData.readUInt32BE(REWARD_START_MOMENT_OFFSET)
+                }
+            }
+        }
+        else if (Buffer.from(HookStateKeys.REWARD_INFO, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.SIGLETON,
+                key: hexKey,
+                value: {
+                    epoch: stateData.readUInt8(EPOCH_OFFSET),
+                    savedMoment: stateData.readUInt32BE(SAVED_MOMENT_OFFSET),
+                    prevMomentActiveHostCount: stateData.readUInt32BE(PREV_MOMENT_ACTIVE_HOST_COUNT_OFFSET),
+                    curMomentActiveHostCount: stateData.readUInt32BE(CUR_MOMENT_ACTIVE_HOST_COUNT_OFFSET),
+                    epochPool: XflHelpers.toString(stateData.readBigInt64BE(EPOCH_POOL_OFFSET))
+                }
+            }
+        }
+        else if (Buffer.from(HookStateKeys.MAX_TOLERABLE_DOWNTIME, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: stateData.readUInt16BE()
+            }
+        }
+        else
+            throw { type: 'Validation Error', message: 'Invalid state key.' };
+    }
+
+    static decodeStateKey(stateKey) {
+        const hexKey = stateKey.toString('hex').toUpperCase();
+        if (Buffer.from(HookStateKeys.PREFIX_HOST_ADDR, 'hex').compare(stateKey, 0, 4) === 0) {
+            return {
+                key: hexKey,
+                type: this.StateTypes.HOST_ADDR
+            };
+        }
+        else if (Buffer.from(HookStateKeys.PREFIX_HOST_TOKENID, 'hex').compare(stateKey, 0, 4) === 0) {
+            return {
+                key: hexKey,
+                type: this.StateTypes.TOKEN_ID
+            };
+        }
+        else if (Buffer.from(HookStateKeys.HOST_COUNT, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MOMENT_BASE_IDX, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.HOST_REG_FEE, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MAX_REG, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.REWARD_INFO, 'hex').compare(stateKey) === 0) {
+            return {
+                key: hexKey,
+                type: this.STATE_TYPES.SIGLETON
+            };
+        }
+        else if (Buffer.from(HookStateKeys.EVR_ISSUER_ADDR, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.FOUNDATION_ADDR, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MOMENT_SIZE, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.PURCHASER_TARGET_PRICE, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.HOST_HEARTBEAT_FREQ, 'hex').compare(stateKey) ||
+            Buffer.from(HookStateKeys.MINT_LIMIT, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.FIXED_REG_FEE, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.LEASE_ACQUIRE_WINDOW, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.REWARD_CONFIGURATION, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MAX_TOLERABLE_DOWNTIME, 'hex').compare(stateKey) === 0) {
+            return {
+                key: hexKey,
+                type: this.STATE_TYPES.CONFIGURATION
+            };
+        }
+        else
+            throw { type: 'Validation Error', message: 'Invalid state key.' };
+    }
+
+    static generateTokenIdStateKey(nfTokenId) {
+        // 1 byte - Key Type.
+        let buf = Buffer.allocUnsafe(1);
+        buf.writeUInt8(STATE_KEY_TYPES.TOKEN_ID);
+
+        const nfTokenIdBuf = Buffer.from(nfTokenId, "hex");
+        const stateKeyBuf = (Buffer.concat([Buffer.from(EVERNODE_PREFIX, "utf-8"), buf, nfTokenIdBuf.slice(4, 32)]));
+        return stateKeyBuf.toString('hex').toUpperCase();
+    }
+
+    static generateHostAddrStateKey(address) {
+        // 1 byte - Key Type.
+        // 8 bytes - Zeros.
+        let buf = Buffer.allocUnsafe(9);
+        buf.writeUInt8(STATE_KEY_TYPES.HOST_ADDR);
+        for (let i = 0; i < HOST_ADDR_KEY_ZERO_COUNT; i++) {
+            buf.writeUInt8(0, i + 1);
+        }
+
+        const addrBuf = Buffer.from(codec.decodeAccountID(address), "hex");
+        const stateKeyBuf = Buffer.concat([Buffer.from(EVERNODE_PREFIX, "utf-8"), buf, addrBuf]);
+        return stateKeyBuf.toString('hex').toUpperCase();
+    }
+
+    static getHookStateIndex(hookAccount, stateKey, hookNamespace = EvernodeConstants.HOOK_NAMESPACE) {
+        const typeBuf = Buffer.allocUnsafe(2);
+        typeBuf.writeInt16BE(HOOK_STATE_LEDGER_TYPE_PREFIX);
+
+        const accIdBuf = codec.decodeAccountID(hookAccount);
+        const stateKeyBuf = Buffer.from(stateKey, 'hex');
+        const namespaceBuf = Buffer.from(hookNamespace, 'hex');
+
+        let hash = crypto.createHash('sha512');
+
+        let data = hash.update(typeBuf);
+        data = hash.update(accIdBuf);
+        data = hash.update(stateKeyBuf);
+        data = hash.update(namespaceBuf);
+
+        const digest = data.digest('hex');
+        // Get the first 32 bytes of hash.
+        return digest.substring(0, 64).toUpperCase();
+    }
+}
+
+module.exports = {
+    StateHelpers
+}

package/src/transaction-helper.js

@@ -0,0 +1,62 @@
+const { MemoFormats } = require('./evernode-common');
+
+class TransactionHelper {
+
+    // Convert memos from our object type to xrpl lib object type.
+    static formatMemos(memos) {
+        return memos ? memos.filter(m => m.type).map(m => {
+            const data = (m.format === MemoFormats.HEX) ? m.data :
+                TransactionHelper.asciiToHex((typeof m.data === "object") ? JSON.stringify(m.data) : m.data)
+            return {
+                Memo: {
+                    MemoType: TransactionHelper.asciiToHex(m.type),
+                    MemoFormat: TransactionHelper.asciiToHex(m.format),
+                    MemoData: data
+                }
+            }
+        }) : [];
+    }
+
+    // Convert memos from xrpl lib object type to our object type.
+    static deserializeMemos(memos) {
+        if (!memos)
+            return [];
+
+        return memos.filter(m => m.Memo).map(m => {
+            const format = m.Memo.MemoFormat ? TransactionHelper.hexToASCII(m.Memo.MemoFormat) : null;
+            const data = m.Memo.MemoData ?
+                ((format === MemoFormats.HEX) ? m.Memo.MemoData : TransactionHelper.hexToASCII(m.Memo.MemoData)) : null;
+            return {
+                type: m.Memo.MemoType ? TransactionHelper.hexToASCII(m.Memo.MemoType) : null,
+                format: format,
+                data: data
+            }
+        })
+    }
+
+    static hexToASCII(hex) {
+        if (!hex)
+            return "";
+
+        let str = "";
+        for (let n = 0; n < hex.length; n += 2) {
+            str += String.fromCharCode(parseInt(hex.substr(n, 2), 16));
+        }
+        return str;
+    }
+
+    static asciiToHex(str) {
+        if (!str)
+            return "";
+
+        let hex = "";
+        for (let n = 0; n < str.length; n++) {
+            hex += str.charCodeAt(n).toString(16)
+        }
+        return hex;
+    }
+}
+
+module.exports = {
+    TransactionHelper
+}