evernode-js-client 0.5.11 → 0.5.12

package/src/clients/tenant-client.js

@@ -1,276 +0,0 @@
-const { BaseEvernodeClient } = require('./base-evernode-client');
-const { EvernodeEvents, MemoFormats, MemoTypes, ErrorCodes, ErrorReasons, EvernodeConstants } = require('../evernode-common');
-const { EncryptionHelper } = require('../encryption-helper');
-const { XrplAccount } = require('../xrpl-account');
-const { UtilHelpers } = require('../util-helpers');
-const { Buffer } = require('buffer');
-const codec = require('ripple-address-codec');
-const { EvernodeHelpers } = require('../evernode-helpers');
-const { TransactionHelper } = require('../transaction-helper');
-
-const DEFAULT_WAIT_TIMEOUT = 60000;
-
-const TenantEvents = {
-    AcquireSuccess: EvernodeEvents.AcquireSuccess,
-    AcquireError: EvernodeEvents.AcquireError,
-    ExtendSuccess: EvernodeEvents.ExtendSuccess,
-    ExtendError: EvernodeEvents.ExtendError,
-}
-
-class TenantClient extends BaseEvernodeClient {
-
-    /**
-     * Constructs a tenant client instance.
-     * @param {string} xrpAddress XRPL address of the tenant.
-     * @param {string} XRPL secret of the tenant.
-     * @param {object} options [Optional] An object with 'rippledServer' URL and 'registryAddress'.
-     */
-    constructor(xrpAddress, xrpSecret, options = {}) {
-        super(xrpAddress, xrpSecret, Object.values(TenantEvents), false, options);
-    }
-
-    async prepareAccount() {
-        try {
-            if (!await this.xrplAcc.getMessageKey())
-                await this.xrplAcc.setAccountFields({ MessageKey: this.accKeyPair.publicKey });
-        }
-        catch (err) {
-            console.log("Error in preparing user xrpl account for Evernode.", err);
-        }
-    }
-
-    async getLeaseHost(hostAddress) {
-        const host = new XrplAccount(hostAddress, null, { xrplApi: this.xrplApi });
-        // Find an owned NFT with matching Evernode host NFT prefix.
-        const nft = (await host.getNfts()).find(n => n.URI.startsWith(EvernodeConstants.NFT_PREFIX_HEX));
-        if (!nft)
-            throw { reason: ErrorReasons.HOST_INVALID, error: "Host is not registered." };
-
-        // Check whether the token was actually issued from Evernode registry contract.
-        const issuerHex = nft.NFTokenID.substr(8, 40);
-        const issuerAddr = codec.encodeAccountID(Buffer.from(issuerHex, 'hex'));
-        if (issuerAddr != this.registryAddress)
-            throw { reason: ErrorReasons.HOST_INVALID, error: "Host is not registered." };
-
-        // Check whether active.
-        const hostInfo = await this.getHostInfo(host.address);
-        if (!hostInfo)
-            throw { reason: ErrorReasons.HOST_INVALID, error: "Host is not registered." };
-        else if (!hostInfo.active)
-            throw { reason: ErrorReasons.HOST_INACTIVE, error: "Host is not active." };
-
-        return host;
-    }
-
-    /**
-     * 
-     * @param {string} hostAddress XRPL address of the host to acquire the lease.
-     * @param {object} requirement The instance requirements and configuration.
-     * @param {object} options [Optional] Options for the XRPL transaction.
-     * @returns The transaction result.
-     */
-    async acquireLeaseSubmit(hostAddress, requirement, options = {}) {
-
-        const hostAcc = await this.getLeaseHost(hostAddress);
-        let selectedOfferIndex = options.leaseOfferIndex;
-
-        // Attempt to get first available offer, if offer is not specified in options.
-        if (!selectedOfferIndex) {
-            const nftOffers = await EvernodeHelpers.getLeaseOffers(hostAcc);
-            selectedOfferIndex = nftOffers && nftOffers[0] && nftOffers[0].index;
-
-            if (!selectedOfferIndex)
-                throw { reason: ErrorReasons.NO_OFFER, error: "No offers available." };
-        }
-
-        // Encrypt the requirements with the host's encryption key (Specified in MessageKey field of the host account).
-        const encKey = await hostAcc.getMessageKey();
-        if (!encKey)
-            throw { reason: ErrorReasons.INTERNAL_ERR, error: "Host encryption key not set." };
-
-        const ecrypted = await EncryptionHelper.encrypt(encKey, requirement, {
-            iv: options.iv, // Must be null or 16 bytes.
-            ephemPrivateKey: options.ephemPrivateKey // Must be null or 32 bytes.
-        });
-
-        return this.xrplAcc.buyNft(selectedOfferIndex, [{ type: MemoTypes.ACQUIRE_LEASE, format: MemoFormats.BASE64, data: ecrypted }], options.transactionOptions);
-    }
-
-    /**
-     * Watch for the acquire-success response after the acquire request is made.
-     * @param {object} tx The transaction returned by the acquireLeaseSubmit function.
-     * @param {object} options [Optional] Options for the XRPL transaction.
-     * @returns An object including transaction details,instance info, and acquireReference Id.
-     */
-    async watchAcquireResponse(tx, options = {}) {
-        console.log(`Waiting for acquire response... (txHash: ${tx.id})`);
-
-        return new Promise(async (resolve, reject) => {
-            let rejected = false;
-            const failTimeout = setTimeout(() => {
-                rejected = true;
-                reject({ error: ErrorCodes.ACQUIRE_ERR, reason: ErrorReasons.TIMEOUT });
-            }, options.timeout || DEFAULT_WAIT_TIMEOUT);
-
-            let relevantTx = null;
-            while (!rejected && !relevantTx) {
-                const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
-                for (let t of txList) {
-                    t.tx.Memos = TransactionHelper.deserializeMemos(t.tx?.Memos);
-                    const res = await this.extractEvernodeEvent(t.tx);
-                    if ((res?.name === EvernodeEvents.AcquireSuccess || res?.name === EvernodeEvents.AcquireError) && res?.data?.acquireRefId === tx.id) {
-                        clearTimeout(failTimeout);
-                        relevantTx = res;
-                        break;
-                    }
-                }
-                await new Promise(resolveSleep => setTimeout(resolveSleep, 2000));
-            }
-
-            if (!rejected) {
-                if (relevantTx?.name === TenantEvents.AcquireSuccess) {
-                    resolve({
-                        transaction: relevantTx?.data.transaction,
-                        instance: relevantTx?.data.payload.content,
-                        acquireRefId: relevantTx?.data.acquireRefId
-                    });
-                } else if (relevantTx?.name === TenantEvents.AcquireError) {
-                    reject({
-                        error: ErrorCodes.ACQUIRE_ERR,
-                        transaction: relevantTx?.data.transaction,
-                        reason: relevantTx?.data.reason,
-                        acquireRefId: relevantTx?.data.acquireRefId
-                    });
-                }
-            }
-        });
-    }
-
-    /**
-     * Acquire an instance from a host
-     * @param {string} hostAddress XRPL address of the host to acquire the lease.
-     * @param {object} requirement The instance requirements and configuration.
-     * @param {object} options [Optional] Options for the XRPL transaction.
-     * @returns An object including transaction details,instance info, and acquireReference Id.
-     */
-    acquireLease(hostAddress, requirement, options = {}) {
-        return new Promise(async (resolve, reject) => {
-            const tx = await this.acquireLeaseSubmit(hostAddress, requirement, options).catch(error => {
-                reject({ error: ErrorCodes.ACQUIRE_ERR, reason: error.reason || ErrorReasons.TRANSACTION_FAILURE, content: error.error || error });
-            });
-            if (tx) {
-                try {
-                    const response = await this.watchAcquireResponse(tx, options);
-                    resolve(response);
-                } catch (error) {
-                    reject(error);
-                }
-            }
-        });
-    }
-
-    /**
-     * This function is called by a tenant client to submit the extend lease transaction in certain host. This function will be called inside extendLease function. This function can take four parameters as follows.
-     * @param {string} hostAddress XRPL account address of the host.
-     * @param {number} amount Cost for the extended moments , in EVRs.
-     * @param {string} tokenID Tenant received instance name. this name can be retrieve by performing acquire Lease.
-     * @param {object} options This is an optional field and contains necessary details for the transactions.
-     * @returns The transaction result.
-     */
-    async extendLeaseSubmit(hostAddress, amount, tokenID, options = {}) {
-        const host = await this.getLeaseHost(hostAddress);
-        return this.xrplAcc.makePayment(host.address, amount.toString(), EvernodeConstants.EVR, this.config.evrIssuerAddress,
-            [{ type: MemoTypes.EXTEND_LEASE, format: MemoFormats.HEX, data: tokenID }], options.transactionOptions);
-    }
-
-    /**
-     * This function watches for an extendlease-success response(transaction) and returns the response or throws the error response on extendlease-error response from the host XRPL account. This function is called within the extendLease function.
-     * @param {object} tx Response of extendLeaseSubmit.
-     * @param {object} options This is an optional field and contains necessary details for the transactions.
-     * @returns An object including transaction details.
-     */
-    async watchExtendResponse(tx, options = {}) {
-        console.log(`Waiting for extend lease response... (txHash: ${tx.id})`);
-
-        return new Promise(async (resolve, reject) => {
-            let rejected = false;
-            const failTimeout = setTimeout(() => {
-                rejected = true;
-                reject({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.TIMEOUT });
-            }, options.timeout || DEFAULT_WAIT_TIMEOUT);
-
-            let relevantTx = null;
-            while (!rejected && !relevantTx) {
-                const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
-                for (let t of txList) {
-                    t.tx.Memos = TransactionHelper.deserializeMemos(t.tx.Memos);
-                    const res = await this.extractEvernodeEvent(t.tx);
-                    if ((res?.name === TenantEvents.ExtendSuccess || res?.name === TenantEvents.ExtendError) && res?.data?.extendRefId === tx.id) {
-                        clearTimeout(failTimeout);
-                        relevantTx = res;
-                        break;
-                    }
-                }
-                await new Promise(resolveSleep => setTimeout(resolveSleep, 1000));
-            }
-
-            if (!rejected) {
-                if (relevantTx?.name === TenantEvents.ExtendSuccess) {
-                    resolve({
-                        transaction: relevantTx?.data.transaction,
-                        expiryMoment: relevantTx?.data.expiryMoment,
-                        extendeRefId: relevantTx?.data.extendRefId
-                    });
-                } else if (relevantTx?.name === TenantEvents.ExtendError) {
-                    reject({
-                        error: ErrorCodes.EXTEND_ERR,
-                        transaction: relevantTx?.data.transaction,
-                        reason: relevantTx?.data.reason
-                    });
-                }
-            }
-        });
-    }
-
-    /**
-     * This function is called by a tenant client to extend an available instance in certain host. This function can take four parameters as follows.
-     * @param {string} hostAddress XRPL account address of the host.
-     * @param {number} moments 1190 ledgers (est. 1 hour).
-     * @param {string} instanceName Tenant received instance name. this name can be retrieve by performing acquire Lease.
-     * @param {object} options This is an optional field and contains necessary details for the transactions.
-     * @returns An object including transaction details.
-     */
-    extendLease(hostAddress, moments, instanceName, options = {}) {
-        return new Promise(async (resolve, reject) => {
-            const tokenID = instanceName;
-            const nft = (await this.xrplAcc.getNfts())?.find(n => n.NFTokenID == tokenID);
-
-            if (!nft) {
-                reject({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.NO_NFT, content: 'Could not find the nft for lease extend request.' });
-                return;
-            }
-
-            let minLedgerIndex = this.xrplApi.ledgerIndex;
-
-            // Get the agreement lease amount from the nft and calculate EVR amount to be sent.
-            const uriInfo = UtilHelpers.decodeLeaseNftUri(nft.URI);
-            const tx = await this.extendLeaseSubmit(hostAddress, moments * uriInfo.leaseAmount, tokenID, options).catch(error => {
-                reject({ error: ErrorCodes.EXTEND_ERR, reason: error.reason || ErrorReasons.TRANSACTION_FAILURE, content: error.error || error });
-            });
-
-            if (tx) {
-                try {
-                    const response = await this.watchExtendResponse(tx, minLedgerIndex, options)
-                    resolve(response);
-                } catch (error) {
-                    reject(error);
-                }
-            }
-        });
-    }
-}
-
-module.exports = {
-    TenantEvents,
-    TenantClient
-}

package/src/defaults.js

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

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

@@ -1,96 +0,0 @@
-class ed25519 {
-    static async #getLibrary() {
-        const _sodium = require('libsodium-wrappers');
-        await _sodium.ready;
-        return _sodium;
-    }
-
-    static async encrypt(publicKeyBuf, messageBuf) {
-        const sodium = await this.#getLibrary();
-        const curve25519PublicKey = sodium.crypto_sign_ed25519_pk_to_curve25519(publicKeyBuf.slice(1));
-        return Buffer.from(sodium.crypto_box_seal(messageBuf, curve25519PublicKey));
-    }
-
-    static async decrypt(privateKeyBuf, encryptedBuf) {
-        const sodium = await this.#getLibrary();
-        const keyPair = sodium.crypto_sign_seed_keypair(privateKeyBuf.slice(1));
-        const curve25519PublicKey_ = sodium.crypto_sign_ed25519_pk_to_curve25519(keyPair.publicKey);
-        const curve25519PrivateKey = sodium.crypto_sign_ed25519_sk_to_curve25519(keyPair.privateKey);
-        return Buffer.from(sodium.crypto_box_seal_open(encryptedBuf, curve25519PublicKey_, curve25519PrivateKey));
-    }
-}
-
-class secp256k1 {
-    // Offsets of the properties in the encrypted buffer.
-    static ivOffset = 65;
-    static macOffset = this.ivOffset + 16;
-    static ciphertextOffset = this.macOffset + 32;
-    
-    static #getLibrary() {
-        const eccrypto = require('./eccrypto') // Using local copy of the eccrypto code file.
-        return eccrypto;
-    }
-
-    static async encrypt(publicKeyBuf, messageBuf, options = {}) {
-        const eccrypto = this.#getLibrary();
-        // For the encryption library, both keys and data should be buffers.
-        const encrypted = await eccrypto.encrypt(publicKeyBuf, messageBuf, options);
-        // Concat all the properties of the encrypted object to a single buffer.
-        return Buffer.concat([encrypted.ephemPublicKey, encrypted.iv, encrypted.mac, encrypted.ciphertext]);
-    }
-
-    static async decrypt(privateKeyBuf, encryptedBuf) {
-        const eccrypto = this.#getLibrary();
-        // Extract the buffer from the string and prepare encrypt object from buffer offsets for decryption.
-        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(privateKeyBuf.slice(1), encryptedObj)
-            .catch(err => console.log(err));
-
-        return decrypted;
-    }
-}
-
-class EncryptionHelper {
-    static contentFormat = 'base64';
-    static keyFormat = 'hex';
-    static ed25519KeyType = 'ed25519';
-    static secp256k1KeyType = 'ecdsa-secp256k1';
-
-    static #getAlgorithmFromKey(key) {
-        const bytes = Buffer.from(key, this.keyFormat);
-        return bytes.length === 33 && bytes.at(0) === 0xed
-            ? this.ed25519KeyType
-            : this.secp256k1KeyType;
-    }
-
-    static #getEncryptor(key) {
-        const format = this.#getAlgorithmFromKey(key);
-        return format === this.secp256k1KeyType ? secp256k1 : ed25519;
-    }
-
-    static async encrypt(publicKey, message, options = {}) {
-        const publicKeyBuf = Buffer.from(publicKey, this.keyFormat);
-        const messageBuf = Buffer.from(JSON.stringify(message));
-        const encryptor = this.#getEncryptor(publicKey);
-        const result = await encryptor.encrypt(publicKeyBuf, messageBuf, options);
-        return result ? result.toString(this.contentFormat) : null;
-    }
-
-    static async decrypt(privateKey, encrypted) {
-        const privateKeyBuf = Buffer.from(privateKey, this.keyFormat);
-        const encryptedBuf = Buffer.from(encrypted, this.contentFormat);
-        const encryptor = this.#getEncryptor(privateKey);
-        const decrypted = await encryptor.decrypt(privateKeyBuf, encryptedBuf);
-        return decrypted ? JSON.parse(decrypted.toString()) : null;
-    }
-}
-
-module.exports = {
-    EncryptionHelper
-}