evernode-js-client 0.5.12 → 0.5.13

package/src/state-helpers.js

@@ -0,0 +1,396 @@
+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 TRANSIT_IDX_OFFSET = 0;
+const TRANSIT_MOMENT_SIZE_OFFSET = 8;
+const TRANSIT_MOMENT_TYPE_OFFSET = 10;
+
+const MOMENT_BASE_POINT_OFFSET = 0;
+const MOMENT_AT_TRANSITION_OFFSET = 8;
+const MOMENT_TYPE_OFFSET = 12;
+
+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_REG_TIMESTAMP_OFFSET = 103;
+const HOST_TRANSFER_FLAG_OFFSET = 111;
+
+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 HOST_EMAIL_ADDRESS_OFFSET = 76;
+
+const PREV_HOST_ADDRESS_OFFSET = 0;
+const TRANSFER_LEDGER_IDX_OFFSET = 20;
+const TRANSFERRED_NFT_ID_OFFSET = 28;
+
+const STATE_KEY_TYPES = {
+    TOKEN_ID: 2,
+    HOST_ADDR: 3,
+    TRANSFEREE_ADDR: 4
+}
+
+const MOMENT_TYPES = {
+    LEDGER: 0,
+    TIMESTAMP: 1
+}
+
+const TRANSFER_STATES = {
+    NO_TRANSFER: 0,
+    HAS_A_TRANSFER: 1
+}
+
+const EVERNODE_PREFIX = 'EVR';
+const HOST_ADDR_KEY_ZERO_COUNT = 8;
+const TRANSFEREE_ADDR_KEY_ZERO_COUNT = 8;
+const HOOK_STATE_LEDGER_TYPE_PREFIX = 118; // Decimal value of ASCII 'v'
+const PENDING_TRANSFER = 1;
+const HOST_EMAIL_ADDRESS_LEN = 40;
+
+class StateHelpers {
+    static StateTypes = {
+        TOKEN_ID: 'tokenId',
+        HOST_ADDR: 'hostAddr',
+        SIGLETON: 'singleton',
+        CONFIGURATION: 'configuration',
+        TRANSFEREE_ADDR: 'transfereeAddr'
+    }
+
+    static timeLines = {
+        SEC: "SEC"
+    }
+
+    static getStateData(states, key) {
+        const state = states.find(s => key === s.key);
+        if (!state)
+            return null;
+
+        return state.data;
+    }
+
+    static decodeHostAddressState(stateKeyBuf, stateDataBuf) {
+        let data = {
+            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),
+            lastHeartbeatIndex: 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)}`,
+            isATransferer: (stateDataBuf.length > HOST_TRANSFER_FLAG_OFFSET && (stateDataBuf.readUInt8(HOST_TRANSFER_FLAG_OFFSET) === PENDING_TRANSFER)) ? TRANSFER_STATES.HAS_A_TRANSFER : TRANSFER_STATES.NO_TRANSFER
+        }
+        if (stateDataBuf.length > HOST_REG_TIMESTAMP_OFFSET)
+            data.registrationTimestamp = Number(stateDataBuf.readBigUInt64BE(HOST_REG_TIMESTAMP_OFFSET));
+        return data;
+    }
+
+    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),
+            email: (stateDataBuf.length > HOST_EMAIL_ADDRESS_OFFSET ?
+                stateDataBuf.slice(HOST_EMAIL_ADDRESS_OFFSET, HOST_EMAIL_ADDRESS_OFFSET + HOST_EMAIL_ADDRESS_LEN).toString().toString().replace(/\0/g, '') :
+                "")
+        }
+    }
+
+
+    static decodeTransfereeAddrState(stateKeyBuf, stateDataBuf) {
+        const prevHostClassicAddress = codec.encodeAccountID(stateDataBuf.slice(PREV_HOST_ADDRESS_OFFSET, TRANSFER_LEDGER_IDX_OFFSET));
+        return {
+            futureOwnerAddress: codec.encodeAccountID(stateKeyBuf.slice(12)),
+            prevHostAddressKey: this.generateHostAddrStateKey(prevHostClassicAddress),
+            prevHostAddress: prevHostClassicAddress,
+            transferLedgerIdx: Number(stateDataBuf.readBigUInt64BE(TRANSFER_LEDGER_IDX_OFFSET)),
+            transferredNfTokenId: stateDataBuf.slice(TRANSFERRED_NFT_ID_OFFSET, 60).toString('hex').toUpperCase()
+        }
+    }
+
+    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.PREFIX_TRANSFEREE_ADDR, 'hex').compare(stateKey, 0, 4) === 0) {
+            return {
+                type: this.StateTypes.TRANSFEREE_ADDR,
+                key: hexKey,
+                ...this.decodeTransfereeAddrState(stateKey, 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_INFO, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.SIGLETON,
+                key: hexKey,
+                value: {
+                    baseIdx: Number(stateData.readBigUInt64BE(MOMENT_BASE_POINT_OFFSET)),
+                    baseTransitionMoment: stateData.length > MOMENT_AT_TRANSITION_OFFSET ? stateData.readUInt32BE(MOMENT_AT_TRANSITION_OFFSET) : 0,
+                    momentType: (stateData.length <= MOMENT_TYPE_OFFSET || stateData.readUInt8(MOMENT_TYPE_OFFSET) === MOMENT_TYPES.LEDGER) ? 'ledger' : 'timestamp'
+                }
+            }
+        }
+        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 if (Buffer.from(HookStateKeys.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0) {
+            Buffer.alloc(1).readUInt8()
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: {
+                    transitionIndex: Number(stateData.readBigInt64BE(TRANSIT_IDX_OFFSET)),
+                    momentSize: stateData.readUInt16BE(TRANSIT_MOMENT_SIZE_OFFSET),
+                    momentType: stateData.readUInt8(TRANSIT_MOMENT_TYPE_OFFSET) === MOMENT_TYPES.LEDGER ? 'ledger' : 'timestamp'
+                }
+            }
+        }
+        else if (Buffer.from(HookStateKeys.MAX_TRX_EMISSION_FEE, 'hex').compare(stateKey) === 0) {
+            return {
+                type: this.StateTypes.CONFIGURATION,
+                key: hexKey,
+                value: Number(stateData.readBigUInt64BE())
+            }
+        }
+        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.PREFIX_TRANSFEREE_ADDR, 'hex').compare(stateKey, 0, 4) === 0) {
+            return {
+                key: hexKey,
+                type: this.StateTypes.TRANSFEREE_ADDR
+            };
+        }
+        else if (Buffer.from(HookStateKeys.HOST_COUNT, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MOMENT_BASE_INFO, '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 ||
+            Buffer.from(HookStateKeys.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0 ||
+            Buffer.from(HookStateKeys.MAX_TRX_EMISSION_FEE, '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 generateTransfereeAddrStateKey(address) {
+        // 1 byte - Key Type.
+        // 8 bytes - Zeros.
+        let buf = Buffer.allocUnsafe(9);
+        buf.writeUInt8(STATE_KEY_TYPES.TRANSFEREE_ADDR);
+        for (let i = 0; i < TRANSFEREE_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
+}

package/src/util-helpers.js

@@ -0,0 +1,50 @@
+const { Buffer } = require('buffer');
+const { XflHelpers } = require('./xfl-helpers');
+const { EvernodeConstants, ErrorReasons } = require('./evernode-common');
+
+// Utility helper functions.
+class UtilHelpers {
+
+    static readUInt(buf, base = 32, isBE = true) {
+        buf = Buffer.from(buf);
+        switch (base) {
+            case (8):
+                return buf.readUInt8();
+            case (16):
+                return isBE ? buf.readUInt16BE() : buf.readUInt16LE();
+            case (32):
+                return isBE ? buf.readUInt32BE() : buf.readUInt32LE();
+            case (64):
+                return isBE ? Number(buf.readBigUInt64BE()) : Number(buf.readBigUInt64LE());
+            default:
+                throw 'Invalid base value';
+        }
+    }
+
+    static decodeLeaseNftUri(hexUri) {
+        // Get the lease index from the nft URI.
+        // <prefix><lease index (uint16)><half of tos hash (16 bytes)><lease amount (uint32)>
+        const prefixLen = EvernodeConstants.LEASE_NFT_PREFIX_HEX.length / 2;
+        const halfToSLen = 16;
+        const uriBuf = Buffer.from(hexUri, 'hex');
+        return {
+            leaseIndex: uriBuf.readUint16BE(prefixLen),
+            halfTos: uriBuf.slice(prefixLen + 2, halfToSLen),
+            leaseAmount: parseFloat(XflHelpers.toString(uriBuf.readBigInt64BE(prefixLen + 2 + halfToSLen)))
+        }
+    }
+
+    static getCurrentUnixTime(format = "sec") {
+        const time = Date.now();
+        switch (format) {
+            case "sec":
+                return Math.floor(time / 1000);
+            default:
+                return time;
+        }
+    }
+}
+
+module.exports = {
+    UtilHelpers
+}

package/src/xfl-helpers.js

@@ -0,0 +1,130 @@
+const minMantissa = 1000000000000000n
+const maxMantissa = 9999999999999999n
+const minExponent = -96
+const maxExponent = 80
+
+// Helper class to handle XFL float numbers.
+class XflHelpers {
+
+    static getExponent(xfl) {
+        if (xfl < 0n)
+            throw "Invalid XFL";
+        if (xfl == 0n)
+            return 0n;
+        return ((xfl >> 54n) & 0xFFn) - 97n;
+    }
+
+    static getMantissa(xfl) {
+        if (xfl < 0n)
+            throw "Invalid XFL";
+        if (xfl == 0n)
+            return 0n;
+        return xfl - ((xfl >> 54n) << 54n);
+    }
+
+    static isNegative(xfl) {
+        if (xfl < 0n)
+            throw "Invalid XFL";
+        if (xfl == 0n)
+            return false;
+        return ((xfl >> 62n) & 1n) == 0n;
+    }
+
+    static toString(xfl) {
+        if (xfl < 0n)
+            throw "Invalid XFL";
+        if (xfl == 0n)
+            return '0';
+
+        const mantissa = this.getMantissa(xfl);
+        const exponent = this.getExponent(xfl);
+        const mantissaStr = mantissa.toString();
+        let finalResult = '';
+        if (exponent > 0n) {
+            finalResult = mantissaStr.padEnd(mantissaStr.length + Number(exponent), '0');
+        } else {
+            const newExponent = Number(exponent) + mantissaStr.length;
+            const cleanedMantissa = mantissaStr.replace(/0+$/, '');
+            if (newExponent == 0) {
+                finalResult = '0.' + cleanedMantissa;
+            } else if (newExponent < 0) {
+                finalResult = '0.' + cleanedMantissa.padStart(newExponent * (-1) + cleanedMantissa.length, '0');
+            } else {
+                finalResult = mantissaStr.substr(0, newExponent) + '.' + mantissaStr.substr(newExponent).replace(/0+$/, '');
+            }
+        }
+        return (this.isNegative(xfl) ? '-' : '') + finalResult.replace(/\.+$/, '');
+    }
+
+    static getXfl(floatStr) {
+        let exponent;
+        let mantissa;
+        floatStr = parseFloat(floatStr).toString();
+
+        if (floatStr === '0') {
+            exponent = BigInt(0);
+            mantissa = BigInt(0);
+        }
+        else if (floatStr.includes('.')) {
+            const parts = floatStr.split('.');
+            exponent = BigInt(-parts[1].length);
+            mantissa = BigInt(parseInt(parts.join('')));
+        }
+        else if (floatStr.endsWith('0')) {
+            const mantissaStr = floatStr.replace(/0+$/g, "");
+            exponent = BigInt(floatStr.length - mantissaStr.length);
+            mantissa = BigInt(parseInt(mantissaStr));
+        }
+        else {
+            exponent = BigInt(0);
+            mantissa = BigInt(parseInt(floatStr));
+        }
+
+        // Convert types as needed.
+        if (typeof (exponent) != 'bigint')
+            exponent = BigInt(exponent);
+
+        if (typeof (mantissa) != 'bigint')
+            mantissa = BigInt(mantissa);
+
+        // Canonical zero.
+        if (mantissa == 0n)
+            return 0n;
+
+        // Normalize.
+        let is_negative = mantissa < 0;
+        if (is_negative)
+            mantissa *= -1n;
+
+        while (mantissa > maxMantissa) {
+            mantissa /= 10n;
+            exponent++;
+        }
+        while (mantissa < minMantissa) {
+            mantissa *= 10n;
+            exponent--;
+        }
+
+        // Canonical zero on mantissa underflow.
+        if (mantissa == 0)
+            return 0n;
+
+        // Under and overflows.
+        if (exponent > maxExponent || exponent < minExponent)
+            return -1; // Note this is an "invalid" XFL used to propagate errors.
+
+        exponent += 97n;
+
+        let xfl = (is_negative ? 0n : 1n);
+        xfl <<= 8n;
+        xfl |= BigInt(exponent);
+        xfl <<= 54n;
+        xfl |= BigInt(mantissa);
+
+        return xfl;
+    }
+}
+
+module.exports = {
+    XflHelpers
+}