evernode-js-client 0.4.53 → 0.5.0

package/src/defaults.js

@@ -0,0 +1,21 @@
+const DefaultValues = {
+    registryAddress: 'raaFre81618XegCrzTzVotAmarBcqNSAvK',
+    rippledServer: 'wss://hooks-testnet-v2.xrpl-labs.com',
+    xrplApi: null,
+    stateIndexId: 'evernodeindex'
+}
+
+class Defaults {
+    static set(newDefaults) {
+        Object.assign(DefaultValues, newDefaults)
+    }
+
+    static get() {
+        return { ...DefaultValues };
+    }
+}
+
+module.exports = {
+    DefaultValues,
+    Defaults
+}

package/src/eccrypto.js

@@ -0,0 +1,258 @@
+// Code taken from https://github.com/bitchan/eccrypto/blob/master/browser.js
+// We are using this code file directly because the full eccrypto library causes a conflict with
+// tiny-secp256k1 used by xrpl libs during ncc/webpack build.
+
+var EC = require("elliptic").ec;
+var ec = new EC("secp256k1");
+var browserCrypto = global.crypto || global.msCrypto || {};
+var subtle = browserCrypto.subtle || browserCrypto.webkitSubtle;
+
+var nodeCrypto = require('crypto');
+
+const EC_GROUP_ORDER = Buffer.from('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141', 'hex');
+const ZERO32 = Buffer.alloc(32, 0);
+
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}
+
+function isScalar(x) {
+    return Buffer.isBuffer(x) && x.length === 32;
+}
+
+function isValidPrivateKey(privateKey) {
+    if (!isScalar(privateKey)) {
+        return false;
+    }
+    return privateKey.compare(ZERO32) > 0 && // > 0
+        privateKey.compare(EC_GROUP_ORDER) < 0; // < G
+}
+
+// Compare two buffers in constant time to prevent timing attacks.
+function equalConstTime(b1, b2) {
+    if (b1.length !== b2.length) {
+        return false;
+    }
+    var res = 0;
+    for (var i = 0; i < b1.length; i++) {
+        res |= b1[i] ^ b2[i];  // jshint ignore:line
+    }
+    return res === 0;
+}
+
+/* This must check if we're in the browser or
+not, since the functions are different and does
+not convert using browserify */
+function randomBytes(size) {
+    var arr = new Uint8Array(size);
+    if (typeof browserCrypto.getRandomValues === 'undefined') {
+        return Buffer.from(nodeCrypto.randomBytes(size));
+    } else {
+        browserCrypto.getRandomValues(arr);
+    }
+    return Buffer.from(arr);
+}
+
+function sha512(msg) {
+    return new Promise(function (resolve) {
+        var hash = nodeCrypto.createHash('sha512');
+        var result = hash.update(msg).digest();
+        resolve(new Uint8Array(result));
+    });
+}
+
+function getAes(op) {
+    return function (iv, key, data) {
+        return new Promise(function (resolve) {
+            if (subtle) {
+                var importAlgorithm = { name: "AES-CBC" };
+                var keyp = subtle.importKey("raw", key, importAlgorithm, false, [op]);
+                return keyp.then(function (cryptoKey) {
+                    var encAlgorithm = { name: "AES-CBC", iv: iv };
+                    return subtle[op](encAlgorithm, cryptoKey, data);
+                }).then(function (result) {
+                    resolve(Buffer.from(new Uint8Array(result)));
+                });
+            } else {
+                if (op === 'encrypt') {
+                    var cipher = nodeCrypto.createCipheriv('aes-256-cbc', key, iv);
+                    let firstChunk = cipher.update(data);
+                    let secondChunk = cipher.final();
+                    resolve(Buffer.concat([firstChunk, secondChunk]));
+                }
+                else if (op === 'decrypt') {
+                    var decipher = nodeCrypto.createDecipheriv('aes-256-cbc', key, iv);
+                    let firstChunk = decipher.update(data);
+                    let secondChunk = decipher.final();
+                    resolve(Buffer.concat([firstChunk, secondChunk]));
+                }
+            }
+        });
+    };
+}
+
+var aesCbcEncrypt = getAes("encrypt");
+var aesCbcDecrypt = getAes("decrypt");
+
+function hmacSha256Sign(key, msg) {
+    return new Promise(function (resolve) {
+        var hmac = nodeCrypto.createHmac('sha256', Buffer.from(key));
+        hmac.update(msg);
+        var result = hmac.digest();
+        resolve(result);
+    });
+}
+
+function hmacSha256Verify(key, msg, sig) {
+    return new Promise(function (resolve) {
+        var hmac = nodeCrypto.createHmac('sha256', Buffer.from(key));
+        hmac.update(msg);
+        var expectedSig = hmac.digest();
+        resolve(equalConstTime(expectedSig, sig));
+    });
+}
+
+/**
+  * Generate a new valid private key. Will use the window.crypto or window.msCrypto as source
+  * depending on your browser.
+  * @return {Buffer} A 32-byte private key.
+  * @function
+  */
+exports.generatePrivate = function () {
+    var privateKey = randomBytes(32);
+    while (!isValidPrivateKey(privateKey)) {
+        privateKey = randomBytes(32);
+    }
+    return privateKey;
+};
+
+var getPublic = exports.getPublic = function (privateKey) {
+    // This function has sync API so we throw an error immediately.
+    assert(privateKey.length === 32, "Bad private key");
+    assert(isValidPrivateKey(privateKey), "Bad private key");
+    // XXX(Kagami): `elliptic.utils.encode` returns array for every
+    // encoding except `hex`.
+    return Buffer.from(ec.keyFromPrivate(privateKey).getPublic("arr"));
+};
+
+/**
+ * Get compressed version of public key.
+ */
+var getPublicCompressed = exports.getPublicCompressed = function (privateKey) { // jshint ignore:line
+    assert(privateKey.length === 32, "Bad private key");
+    assert(isValidPrivateKey(privateKey), "Bad private key");
+    // See https://github.com/wanderer/secp256k1-node/issues/46
+    let compressed = true;
+    return Buffer.from(ec.keyFromPrivate(privateKey).getPublic(compressed, "arr"));
+};
+
+// NOTE(Kagami): We don't use promise shim in Browser implementation
+// because it's supported natively in new browsers (see
+// <http://caniuse.com/#feat=promises>) and we can use only new browsers
+// because of the WebCryptoAPI (see
+// <http://caniuse.com/#feat=cryptography>).
+exports.sign = function (privateKey, msg) {
+    return new Promise(function (resolve) {
+        assert(privateKey.length === 32, "Bad private key");
+        assert(isValidPrivateKey(privateKey), "Bad private key");
+        assert(msg.length > 0, "Message should not be empty");
+        assert(msg.length <= 32, "Message is too long");
+        resolve(Buffer.from(ec.sign(msg, privateKey, { canonical: true }).toDER()));
+    });
+};
+
+exports.verify = function (publicKey, msg, sig) {
+    return new Promise(function (resolve, reject) {
+        assert(publicKey.length === 65 || publicKey.length === 33, "Bad public key");
+        if (publicKey.length === 65) {
+            assert(publicKey[0] === 4, "Bad public key");
+        }
+        if (publicKey.length === 33) {
+            assert(publicKey[0] === 2 || publicKey[0] === 3, "Bad public key");
+        }
+        assert(msg.length > 0, "Message should not be empty");
+        assert(msg.length <= 32, "Message is too long");
+        if (ec.verify(msg, sig, publicKey)) {
+            resolve(null);
+        } else {
+            reject(new Error("Bad signature"));
+        }
+    });
+};
+
+var derive = exports.derive = function (privateKeyA, publicKeyB) {
+    return new Promise(function (resolve) {
+        assert(Buffer.isBuffer(privateKeyA), "Bad private key");
+        assert(Buffer.isBuffer(publicKeyB), "Bad public key");
+        assert(privateKeyA.length === 32, "Bad private key");
+        assert(isValidPrivateKey(privateKeyA), "Bad private key");
+        assert(publicKeyB.length === 65 || publicKeyB.length === 33, "Bad public key");
+        if (publicKeyB.length === 65) {
+            assert(publicKeyB[0] === 4, "Bad public key");
+        }
+        if (publicKeyB.length === 33) {
+            assert(publicKeyB[0] === 2 || publicKeyB[0] === 3, "Bad public key");
+        }
+        var keyA = ec.keyFromPrivate(privateKeyA);
+        var keyB = ec.keyFromPublic(publicKeyB);
+        var Px = keyA.derive(keyB.getPublic());  // BN instance
+        resolve(Buffer.from(Px.toArray()));
+    });
+};
+
+exports.encrypt = function (publicKeyTo, msg, opts) {
+    opts = opts || {};
+    // Tmp variables to save context from flat promises;
+    var iv, ephemPublicKey, ciphertext, macKey;
+    return new Promise(function (resolve) {
+        var ephemPrivateKey = opts.ephemPrivateKey || randomBytes(32);
+        // There is a very unlikely possibility that it is not a valid key
+        while (!isValidPrivateKey(ephemPrivateKey)) {
+            ephemPrivateKey = opts.ephemPrivateKey || randomBytes(32);
+        }
+        ephemPublicKey = getPublic(ephemPrivateKey);
+        resolve(derive(ephemPrivateKey, publicKeyTo));
+    }).then(function (Px) {
+        return sha512(Px);
+    }).then(function (hash) {
+        iv = opts.iv || randomBytes(16);
+        var encryptionKey = hash.slice(0, 32);
+        macKey = hash.slice(32);
+        return aesCbcEncrypt(iv, encryptionKey, msg);
+    }).then(function (data) {
+        ciphertext = data;
+        var dataToMac = Buffer.concat([iv, ephemPublicKey, ciphertext]);
+        return hmacSha256Sign(macKey, dataToMac);
+    }).then(function (mac) {
+        return {
+            iv: iv,
+            ephemPublicKey: ephemPublicKey,
+            ciphertext: ciphertext,
+            mac: mac,
+        };
+    });
+};
+
+exports.decrypt = function (privateKey, opts) {
+    // Tmp variable to save context from flat promises;
+    var encryptionKey;
+    return derive(privateKey, opts.ephemPublicKey).then(function (Px) {
+        return sha512(Px);
+    }).then(function (hash) {
+        encryptionKey = hash.slice(0, 32);
+        var macKey = hash.slice(32);
+        var dataToMac = Buffer.concat([
+            opts.iv,
+            opts.ephemPublicKey,
+            opts.ciphertext
+        ]);
+        return hmacSha256Verify(macKey, dataToMac, opts.mac);
+    }).then(function (macGood) {
+        assert(macGood, "Bad MAC");
+        return aesCbcDecrypt(opts.iv, encryptionKey, opts.ciphertext);
+    }).then(function (msg) {
+        return Buffer.from(new Uint8Array(msg));
+    });
+};

package/src/encryption-helper.js

@@ -0,0 +1,41 @@
+const eccrypto = require('./eccrypto') // Using local copy of the eccrypto code file.
+
+class EncryptionHelper {
+    // Offsets of the properties in the encrypted buffer.
+    static ivOffset = 65;
+    static macOffset = this.ivOffset + 16;
+    static ciphertextOffset = this.macOffset + 32;
+    static contentFormat = 'base64';
+    static keyFormat = 'hex';
+
+    static async encrypt(publicKey, json, options = {}) {
+        // For the encryption library, both keys and data should be buffers.
+        const encrypted = await eccrypto.encrypt(Buffer.from(publicKey, this.keyFormat), Buffer.from(JSON.stringify(json)), options);
+        // Concat all the properties of the encrypted object to a single buffer.
+        const result = Buffer.concat([encrypted.ephemPublicKey, encrypted.iv, encrypted.mac, encrypted.ciphertext]).toString(this.contentFormat);
+        return result;
+    }
+
+    static async decrypt(privateKey, encrypted) {
+        // Extract the buffer from the string and prepare encrypt object from buffer offsets for decryption.
+        const encryptedBuf = Buffer.from(encrypted, this.contentFormat);
+        const encryptedObj = {
+            ephemPublicKey: encryptedBuf.slice(0, this.ivOffset),
+            iv: encryptedBuf.slice(this.ivOffset, this.macOffset),
+            mac: encryptedBuf.slice(this.macOffset, this.ciphertextOffset),
+            ciphertext: encryptedBuf.slice(this.ciphertextOffset)
+        }
+
+        const decrypted = await eccrypto.decrypt(Buffer.from(privateKey, this.keyFormat).slice(1), encryptedObj)
+            .catch(err => console.log(err));
+
+        if (!decrypted)
+            return null;
+
+        return JSON.parse(decrypted.toString());
+    }
+}
+
+module.exports = {
+    EncryptionHelper
+}

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,103 @@
+const EvernodeConstants = {
+    EVR: 'EVR',
+    NFT_PREFIX_HEX: '657672686F7374', // evrhost
+    LEASE_NFT_PREFIX_HEX: '6576726C65617365', // evrlease
+    HOOK_NAMESPACE: '01EAF09326B4911554384121FF56FA8FECC215FDDE2EC35D9E59F2C53EC665A0'
+}
+
+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',
+    EXTEND_LEASE: 'evnExtendLease',
+    EXTEND_SUCCESS: 'evnExtendSuccess',
+    EXTEND_ERROR: 'evnExtendError',
+    EXTEND_REF: 'evnExtendRef',
+    REGISTRY_INIT: 'evnInitialize',
+    REFUND: 'evnRefund',
+    REFUND_REF: 'evnRefundRef',
+    DEAD_HOST_PRUNE: 'evnDeadHostPrune'
+}
+
+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",
+
+    // Singleton
+    HOST_COUNT: "4556523200000000000000000000000000000000000000000000000000000000",
+    MOMENT_BASE_IDX: "4556523300000000000000000000000000000000000000000000000000000000",
+    HOST_REG_FEE: "4556523400000000000000000000000000000000000000000000000000000000",
+    MAX_REG: "4556523500000000000000000000000000000000000000000000000000000000",
+    REWARD_INFO: "4556523600000000000000000000000000000000000000000000000000000000",
+
+    // Prefixes
+    PREFIX_HOST_TOKENID: "45565202",
+    PREFIX_HOST_ADDR: "45565203",
+}
+
+const EvernodeEvents = {
+    HostRegistered: "HostRegistered",
+    HostDeregistered: "HostDeregistered",
+    HostPostDeregistered: "HostPostDeregistered",
+    AcquireLease: "AcquireLease",
+    AcquireSuccess: "AcquireSuccess",
+    AcquireError: "AcquireError",
+    Heartbeat: "Heartbeat",
+    ExtendLease: "ExtendLease",
+    ExtendSuccess: "ExtendSuccess",
+    ExtendError: "ExtendError",
+    HostRegUpdated: "HostRegUpdated",
+    HostReRegistered: "HostReRegistered",
+    RegistryInitialized: "RegistryInitialized",
+    DeadHostPrune: "DeadHostPrune"
+}
+
+module.exports = {
+    EvernodeConstants,
+    MemoTypes,
+    MemoFormats,
+    ErrorCodes,
+    ErrorReasons,
+    HookStateKeys,
+    EvernodeEvents
+}

package/src/evernode-helpers.js

@@ -0,0 +1,14 @@
+const { EvernodeConstants } = require('./evernode-common');
+
+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;
+    }
+}
+
+module.exports = {
+    EvernodeHelpers
+}