evernode-js-client 0.4.51 → 0.5.0

package/src/util-helpers.js

@@ -0,0 +1,48 @@
+const { Buffer } = require('buffer');
+const { XflHelpers } = require('./xfl-helpers');
+const { EvernodeConstants, ErrorReasons } = require('./evernode-common');
+
+// Utility helper functions.
+class UtilHelpers {
+
+    static getStateData(states, key) {
+        const state = states.find(s => key === s.key);
+        if (!state)
+            throw { code: ErrorReasons.NO_STATE_KEY, error: `State key '${key}' not found.` };
+
+        return state.data;
+    }
+
+    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)))
+        }
+    }
+}
+
+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
+}

package/src/xrpl-account.js

@@ -0,0 +1,473 @@
+const xrpl = require('xrpl');
+const kp = require('ripple-keypairs');
+const codec = require('ripple-address-codec');
+const crypto = require("crypto");
+const { XrplConstants } = require('./xrpl-common');
+const { TransactionHelper } = require('./transaction-helper');
+const { EventEmitter } = require('./event-emitter');
+const { DefaultValues } = require('./defaults');
+const xrplCodec = require('xrpl-binary-codec');
+
+class XrplAccount {
+
+    #events = new EventEmitter();
+    #subscribed = false;
+    #txStreamHandler;
+
+    constructor(address, secret = null, options = {}) {
+        this.xrplApi = options.xrplApi || DefaultValues.xrplApi;
+
+        if (!this.xrplApi)
+            throw "XrplAccount: xrplApi not specified.";
+
+        this.address = address;
+
+        this.secret = secret;
+        if (this.secret)
+            this.wallet = xrpl.Wallet.fromSeed(this.secret);
+
+        this.#txStreamHandler = (eventName, tx, error) => {
+            this.#events.emit(eventName, tx, error);
+        };
+    }
+
+    on(event, handler) {
+        this.#events.on(event, handler);
+    }
+
+    once(event, handler) {
+        this.#events.once(event, handler);
+    }
+
+    off(event, handler = null) {
+        this.#events.off(event, handler);
+    }
+
+    deriveKeypair() {
+        if (!this.secret)
+            throw 'Cannot derive key pair: Account secret is empty.';
+
+        return kp.deriveKeypair(this.secret);
+    }
+
+    async getInfo() {
+        return await this.xrplApi.getAccountInfo(this.address);
+    }
+
+    async getSequence() {
+        return (await this.getInfo())?.Sequence;
+    }
+
+    async getMintedNFTokens() {
+        return ((await this.getInfo())?.MintedNFTokens || 0);
+    }
+
+    async getBurnedNFTokens() {
+        return ((await this.getInfo())?.BurnedNFTokens || 0);
+    }
+
+    async getMessageKey() {
+        return (await this.getInfo())?.MessageKey;
+    }
+
+    async getDomain() {
+        const domain = (await this.getInfo())?.Domain;
+        return domain ? TransactionHelper.hexToASCII(domain) : null;
+    }
+
+    async getTrustLines(currency, issuer) {
+        const lines = await this.xrplApi.getTrustlines(this.address, {
+            limit: 399,
+            peer: issuer
+        });
+        return currency ? lines.filter(l => l.currency === currency) : lines;
+    }
+
+    async getChecks(fromAccount) {
+        return await this.xrplApi.getAccountObjects(fromAccount, { type: "check" });
+    }
+
+    async getNfts() {
+        return await this.xrplApi.getNfts(this.address, {
+            limit: 399
+        });
+    }
+
+    async getOffers() {
+        return await this.xrplApi.getOffers(this.address);
+    }
+
+    async getNftOffers() {
+        return await this.xrplApi.getNftOffers(this.address);
+    }
+
+    async getNftByUri(uri, isHexUri = false) {
+        const nfts = await this.getNfts();
+        const hexUri = isHexUri ? uri : TransactionHelper.asciiToHex(uri).toUpperCase();
+        return nfts.find(n => n.URI == hexUri);
+    }
+
+    async getAccountObjects(options) {
+        return await this.xrplApi.getAccountObjects(this.address, options);
+    }
+
+    async getNamespaceEntries(namespaceId, options = {}) {
+        return await this.xrplApi.getNamespaceEntries(this.address, namespaceId, options);
+    }
+
+    async getFlags() {
+        return xrpl.parseAccountRootFlags((await this.getInfo()).Flags);
+    }
+
+    async getAccountTrx(minLedgerIndex = -1, maxLedgerIndex = -1, isForward = true) {
+        return await this.xrplApi.getAccountTrx(this.address, { ledger_index_min: minLedgerIndex, ledger_index_max: maxLedgerIndex, forward: isForward});
+    }
+
+    setAccountFields(fields, options = {}) {
+        /**
+         * Example for fields
+         * 
+         * fields = {
+         *  Domain : "www.mydomain.com",
+         *  Flags : { asfDefaultRipple: false, asfDisableMaster: true } 
+         * }
+         * 
+         */
+
+        if (Object.keys(fields).length === 0)
+            throw "AccountSet fields cannot be empty.";
+
+        const tx = {
+            TransactionType: 'AccountSet',
+            Account: this.address
+        };
+
+        for (const [key, value] of Object.entries(fields)) {
+
+            switch (key) {
+                case 'Domain':
+                    tx.Domain = TransactionHelper.asciiToHex(value).toUpperCase();
+                    break;
+
+                case 'Flags':
+                    for (const [flagKey, flagValue] of Object.entries(value)) {
+                        tx[(flagValue) ? 'SetFlag' : 'ClearFlag'] |= xrpl.AccountSetAsfFlags[flagKey];
+                    }
+                    break;
+
+                default:
+                    tx[key] = value;
+                    break;
+            }
+        }
+
+        return this.#submitAndVerifyTransaction(tx, options);
+    }
+
+    makePayment(toAddr, amount, currency, issuer = null, memos = null, options = {}) {
+
+        const amountObj = makeAmountObject(amount, currency, issuer);
+
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'Payment',
+            Account: this.address,
+            Amount: amountObj,
+            Destination: toAddr,
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    setTrustLine(currency, issuer, limit, allowRippling = false, memos = null, options = {}) {
+
+        if (typeof limit !== 'string')
+            throw "Limit must be a string.";
+
+        let tx = {
+            TransactionType: 'TrustSet',
+            Account: this.address,
+            LimitAmount: {
+                currency: currency,
+                issuer: issuer,
+                value: limit
+            },
+            Memos: TransactionHelper.formatMemos(memos)
+        };
+
+        if (!allowRippling)
+            tx.Flags = 131072; // tfSetNoRipple;
+
+        return this.#submitAndVerifyTransaction(tx, options);
+    }
+
+    setRegularKey(regularKey, memos = null, options = {}) {
+
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'SetRegularKey',
+            Account: this.address,
+            RegularKey: regularKey,
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    cashCheck(check, options = {}) {
+        const checkIDhasher = crypto.createHash('sha512')
+        checkIDhasher.update(Buffer.from('0043', 'hex'))
+        checkIDhasher.update(Buffer.from(codec.decodeAccountID(check.Account)))
+        const seqBuf = Buffer.alloc(4)
+        seqBuf.writeUInt32BE(check.Sequence, 0)
+        checkIDhasher.update(seqBuf)
+        const checkID = checkIDhasher.digest('hex').slice(0, 64).toUpperCase()
+        console.log("Calculated checkID:", checkID);
+
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'CheckCash',
+            Account: this.address,
+            CheckID: checkID,
+            Amount: {
+                currency: check.SendMax.currency,
+                issuer: check.SendMax.issuer,
+                value: check.SendMax.value
+            },
+        }, options);
+    }
+
+    offerSell(sellAmount, sellCurrency, sellIssuer, forAmount, forCurrency, forIssuer = null, expiration = 4294967295, memos = null, options = {}) {
+
+        const sellAmountObj = makeAmountObject(sellAmount, sellCurrency, sellIssuer);
+        const forAmountObj = makeAmountObject(forAmount, forCurrency, forIssuer);
+
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'OfferCreate',
+            Account: this.address,
+            TakerGets: sellAmountObj,
+            TakerPays: forAmountObj,
+            Expiration: expiration,
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    offerBuy(buyAmount, buyCurrency, buyIssuer, forAmount, forCurrency, forIssuer = null, expiration = 4294967295, memos = null, options = {}) {
+
+        const buyAmountObj = makeAmountObject(buyAmount, buyCurrency, buyIssuer);
+        const forAmountObj = makeAmountObject(forAmount, forCurrency, forIssuer);
+
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'OfferCreate',
+            Account: this.address,
+            TakerGets: forAmountObj,
+            TakerPays: buyAmountObj,
+            Expiration: expiration,
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    cancelOffer(offerSequence, memos = null, options = {}) {
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'OfferCancel',
+            Account: this.address,
+            OfferSequence: offerSequence,
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    mintNft(uri, taxon, transferFee, flags = {}, memos = null, options = {}) {
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'NFTokenMint',
+            Account: this.address,
+            URI: flags.isHexUri ? uri : TransactionHelper.asciiToHex(uri).toUpperCase(),
+            NFTokenTaxon: taxon,
+            TransferFee: transferFee,
+            Flags: (flags.isBurnable ? 1 : 0) | (flags.isOnlyXRP ? 2 : 0) | (flags.isTrustLine ? 4 : 0) | (flags.isTransferable ? 8 : 0),
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    offerSellNft(nfTokenId, amount, currency, issuer = null, destination = null, expiration = 4294967295, memos = null, options = {}) {
+
+        const amountObj = makeAmountObject(amount, currency, issuer);
+        const tx = {
+            TransactionType: 'NFTokenCreateOffer',
+            Account: this.address,
+            NFTokenID: nfTokenId,
+            Amount: amountObj,
+            Expiration: expiration,
+            Flags: 1, // tfSellToken
+            Memos: TransactionHelper.formatMemos(memos)
+        };
+
+        return this.#submitAndVerifyTransaction(destination ? { ...tx, Destination: destination } : tx, options);
+    }
+
+    offerBuyNft(nfTokenId, owner, amount, currency, issuer = null, expiration = 4294967295, memos = null, options = {}) {
+
+        const amountObj = makeAmountObject(amount, currency, issuer);
+
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'NFTokenCreateOffer',
+            Account: this.address,
+            NFTokenID: nfTokenId,
+            Owner: owner,
+            Amount: amountObj,
+            Expiration: expiration,
+            Flags: 0, // Buy offer
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    sellNft(offerId, memos = null, options = {}) {
+
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'NFTokenAcceptOffer',
+            Account: this.address,
+            NFTokenBuyOffer: offerId,
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    buyNft(offerId, memos = null, options = {}) {
+
+        return this.#submitAndVerifyTransaction({
+            TransactionType: 'NFTokenAcceptOffer',
+            Account: this.address,
+            NFTokenSellOffer: offerId,
+            Memos: TransactionHelper.formatMemos(memos)
+        }, options);
+    }
+
+    burnNft(nfTokenId, owner = null, memos = null, options = {}) {
+
+        const tx = {
+            TransactionType: 'NFTokenBurn',
+            Account: this.address,
+            NFTokenID: nfTokenId,
+            Memos: TransactionHelper.formatMemos(memos)
+        };
+
+        return this.#submitAndVerifyTransaction(owner ? { ...tx, Owner: owner } : tx, options);
+    }
+
+    async subscribe() {
+        // Subscribe only once. Otherwise event handlers will be duplicated.
+        if (this.#subscribed)
+            return;
+
+        await this.xrplApi.subscribeToAddress(this.address, this.#txStreamHandler);
+
+        this.#subscribed = true;
+    }
+
+    async unsubscribe() {
+        if (!this.#subscribed)
+            return;
+
+        await this.xrplApi.unsubscribeFromAddress(this.address, this.#txStreamHandler);
+        this.#subscribed = false;
+    }
+
+    #submitAndVerifyTransaction(tx, options) {
+
+        if (!this.wallet)
+            throw "no_secret";
+
+        // Returned format.
+        // {
+        //     id: txHash, (if signing success)
+        //     code: final transaction result code.
+        //     details: submission and transaction details, (if signing success)
+        //     error: Any error that prevents submission.
+        // }
+
+        return new Promise(async (resolve, reject) => {
+
+            // Attach tx options to the transaction.
+            const txOptions = {
+                LastLedgerSequence: options.maxLedgerIndex || (this.xrplApi.ledgerIndex + XrplConstants.MAX_LEDGER_OFFSET),
+                Sequence: options.sequence || await this.getSequence(),
+                SigningPubKey: '', // This field is required for fee calculation.
+                Fee: '0' // This field is required for fee calculation.
+            }
+            Object.assign(tx, txOptions);
+            const txnBlob = xrplCodec.encode(tx);
+            const fees = await this.xrplApi.getTransactionFee(txnBlob);
+            delete tx['SigningPubKey'];
+            tx.Fee = fees + '';
+
+            try {
+                const submission = await this.xrplApi.submitAndVerify(tx, { wallet: this.wallet });
+                const r = submission?.result;
+                const txResult = {
+                    id: r?.hash,
+                    code: r?.meta?.TransactionResult,
+                    details: r
+                };
+
+                console.log("Transaction result: " + txResult.code);
+                if (txResult.code === "tesSUCCESS")
+                    resolve(txResult);
+                else
+                    reject(txResult);
+            }
+            catch (err) {
+                console.log("Error submitting transaction:", err);
+                reject({ error: err });
+            }
+
+        });
+    }
+
+    /**
+     * Submit the signed raw transaction.
+     * @param txBlob Signed and encoded transacion as a hex string.
+     */
+    submitTransactionBlob(txBlob) {
+
+        // Returned format.
+        // {
+        //     id: txHash, (if signing success)
+        //     code: final transaction result code.
+        //     details: submission and transaction details, (if signing success)
+        //     error: Any error that prevents submission.
+        // }
+
+        return new Promise(async (resolve, reject) => {
+            try {
+                const submission = await this.xrplApi.submitAndVerify(txBlob);
+                const r = submission?.result;
+                const txResult = {
+                    id: r?.hash,
+                    code: r?.meta?.TransactionResult,
+                    details: r
+                };
+
+                console.log("Transaction result: " + txResult.code);
+                if (txResult.code === "tesSUCCESS")
+                    resolve(txResult);
+                else
+                    reject(txResult);
+            }
+            catch (err) {
+                console.log("Error submitting transaction:", err);
+                reject({ error: err });
+            }
+
+        });
+    }
+}
+
+function makeAmountObject(amount, currency, issuer) {
+    if (typeof amount !== 'string')
+        throw "Amount must be a string.";
+    if (currency !== XrplConstants.XRP && !issuer)
+        throw "Non-XRP currency must have an issuer.";
+
+    const amountObj = (currency == XrplConstants.XRP) ? amount : {
+        currency: currency,
+        issuer: issuer,
+        value: amount
+    }
+    return amountObj;
+}
+
+module.exports = {
+    XrplAccount
+}