@bithomp/xrpl-api 2.3.6

package/lib/models/transaction/locked_balance_changes.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFinalLockedBalances = exports.parseLockedBalanceChanges = void 0;
+const _ = __importStar(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("../../v1/common/utils");
+function groupByAddress(lockedBalanceChanges) {
+    const grouped = _.groupBy(lockedBalanceChanges, function (node) {
+        return node.address;
+    });
+    return _.mapValues(grouped, function (group) {
+        return _.map(group, function (node) {
+            return node.lockedBalance;
+        });
+    });
+}
+function parseValue(value) {
+    return new bignumber_js_1.default(value.value || value);
+}
+function computeBalanceChange(node) {
+    var value = null;
+    if (node.newFields.LockedBalance) {
+        value = parseValue(node.newFields.LockedBalance);
+    }
+    else if (node.previousFields.LockedBalance && node.finalFields.LockedBalance) {
+        value = parseValue(node.finalFields.LockedBalance).minus(parseValue(node.previousFields.LockedBalance));
+    }
+    return value === null ? null : value.isZero() ? null : value;
+}
+function parseFinalBalance(node) {
+    if (node.newFields.LockedBalance) {
+        return parseValue(node.newFields.LockedBalance);
+    }
+    else if (node.finalFields.LockedBalance) {
+        return parseValue(node.finalFields.LockedBalance);
+    }
+    return null;
+}
+function parseXRPQuantity(node, valueParser) {
+    var value = valueParser(node);
+    if (value === null) {
+        return null;
+    }
+    return {
+        address: node.finalFields.Account || node.newFields.Account,
+        lockedBalance: {
+            counterparty: '',
+            currency: 'XRP',
+            value: (0, utils_1.dropsToXrp)(value).toString()
+        }
+    };
+}
+function parseTrustlineQuantity(node, valueParser) {
+    var value = valueParser(node);
+    if (value === null) {
+        return null;
+    }
+    var fields = _.isEmpty(node.newFields) ? node.finalFields : node.newFields;
+    var result = {
+        address: fields.LowLimit.issuer,
+        lockedBalance: {
+            counterparty: fields.HighLimit.issuer,
+            currency: fields.LockedBalance.currency,
+            value: value.toString()
+        }
+    };
+    return [result];
+}
+function parseQuantities(metadata, valueParser) {
+    var values = (0, utils_1.normalizeNodes)(metadata).map(function (node) {
+        if (node.entryType === 'AccountRoot') {
+            return [parseXRPQuantity(node, valueParser)];
+        }
+        else if (node.entryType === 'RippleState') {
+            return parseTrustlineQuantity(node, valueParser);
+        }
+        return [];
+    });
+    return groupByAddress(_.compact(_.flatten(values)));
+}
+function parseLockedBalanceChanges(metadata) {
+    return parseQuantities(metadata, computeBalanceChange);
+}
+exports.parseLockedBalanceChanges = parseLockedBalanceChanges;
+function parseFinalLockedBalances(metadata) {
+    return parseQuantities(metadata, parseFinalBalance);
+}
+exports.parseFinalLockedBalances = parseFinalLockedBalances;

package/lib/models/transaction/nftoken_changes.d.ts

@@ -0,0 +1 @@
+export declare function parseNFTokenChanges(tx: object): object;

package/lib/models/transaction/nftoken_changes.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNFTokenChanges = void 0;
+const _ = __importStar(require("lodash"));
+const AddressCodec = require("ripple-address-codec");
+const common_1 = require("../../v1/common");
+function parseNFTokenChanges(tx) {
+    return new NFTokenChanges(tx).call();
+}
+exports.parseNFTokenChanges = parseNFTokenChanges;
+class NFTokenChanges {
+    constructor(tx) {
+        this.tx = tx;
+        this.changes = {};
+        this.affectedAccounts = [];
+        this.finalNFTokens = {};
+        this.previousNFTokens = {};
+    }
+    call() {
+        if (this.hasAffectedNodes() === false) {
+            return this.changes;
+        }
+        this.parseAffectedNodes();
+        this.parseNFTokensChanges();
+        return this.changes;
+    }
+    hasAffectedNodes() {
+        if (this.tx.meta?.AffectedNodes === undefined) {
+            return false;
+        }
+        if (this.tx.meta?.AffectedNodes?.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    addChange(account, change) {
+        if (!this.changes[account]) {
+            this.changes[account] = [];
+        }
+        this.changes[account].push((0, common_1.removeUndefined)(change));
+    }
+    parseAffectedNodes() {
+        for (const affectedNode of this.tx.meta.AffectedNodes) {
+            const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+            if (node?.LedgerEntryType === "NFTokenPage" && node?.LedgerIndex) {
+                const account = AddressCodec.encodeAccountID(Buffer.from(node?.LedgerIndex.slice(0, 40), "hex"));
+                if (this.affectedAccounts.includes(account) === false) {
+                    this.affectedAccounts.push(account);
+                }
+                if (affectedNode.CreatedNode) {
+                    this.parseFinalNFTokens(account, node.NewFields?.NFTokens);
+                }
+                if ((affectedNode.ModifiedNode || affectedNode.DeletedNode) && Array.isArray(node.PreviousFields?.NFTokens)) {
+                    this.parseFinalNFTokens(account, node.FinalFields?.NFTokens);
+                    this.parsePreviousNFTokens(account, node.PreviousFields?.NFTokens);
+                }
+                if (affectedNode.DeletedNode && node.PreviousFields === undefined) {
+                    this.parsePreviousNFTokens(account, node.FinalFields?.NFTokens);
+                }
+            }
+        }
+    }
+    parseFinalNFTokens(account, NFTokens) {
+        if (this.finalNFTokens[account] === undefined) {
+            this.finalNFTokens[account] = [];
+        }
+        if (Array.isArray(NFTokens)) {
+            this.finalNFTokens[account] = _.concat(this.finalNFTokens[account], NFTokens);
+        }
+    }
+    parsePreviousNFTokens(account, NFTokens) {
+        if (this.previousNFTokens[account] === undefined) {
+            this.previousNFTokens[account] = [];
+        }
+        if (Array.isArray(NFTokens)) {
+            this.previousNFTokens[account] = _.concat(this.previousNFTokens[account], NFTokens);
+        }
+    }
+    parseNFTokensChanges() {
+        for (const account of this.affectedAccounts) {
+            let finalTokens = [];
+            if (Array.isArray(this.finalNFTokens[account])) {
+                finalTokens = this.finalNFTokens[account].map((NFToken) => NFToken.NFToken.NFTokenID);
+                finalTokens = [...new Set(finalTokens)];
+            }
+            let previousTokens = [];
+            if (Array.isArray(this.previousNFTokens[account])) {
+                previousTokens = this.previousNFTokens[account].map((NFToken) => NFToken.NFToken.NFTokenID);
+                previousTokens = [...new Set(previousTokens)];
+            }
+            const added = _.difference(finalTokens, previousTokens);
+            const removed = _.difference(previousTokens, finalTokens);
+            for (const nftokenID of added) {
+                const uri = this.findNFTokenUri(nftokenID);
+                this.addChange(account, {
+                    status: "added",
+                    nftokenID,
+                    uri,
+                });
+            }
+            for (const nftokenID of removed) {
+                const uri = this.findNFTokenUri(nftokenID);
+                this.addChange(account, {
+                    status: "removed",
+                    nftokenID,
+                    uri,
+                });
+            }
+        }
+    }
+    findNFTokenUri(nftokenID) {
+        for (const affectedNode of this.tx.meta.AffectedNodes) {
+            const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+            if (node?.LedgerEntryType === "NFTokenPage") {
+                if (Array.isArray(node.NewFields?.NFTokens)) {
+                    for (const tokenNode of node.NewFields?.NFTokens) {
+                        if (tokenNode.NFToken.NFTokenID === nftokenID) {
+                            return tokenNode.NFToken.URI;
+                        }
+                    }
+                }
+                if (Array.isArray(node.FinalFields?.NFTokens)) {
+                    for (const tokenNode of node.FinalFields?.NFTokens) {
+                        if (tokenNode.NFToken.NFTokenID === nftokenID) {
+                            return tokenNode.NFToken.URI;
+                        }
+                    }
+                }
+                if (Array.isArray(node.PreviousFields?.NFTokens)) {
+                    for (const tokenNode of node.PreviousFields?.NFTokens) {
+                        if (tokenNode.NFToken.NFTokenID === nftokenID) {
+                            return tokenNode.NFToken.URI;
+                        }
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+}

package/lib/models/transaction/nftoken_offer_changes.d.ts

@@ -0,0 +1 @@
+export declare function parseNFTokenOfferChanges(tx: object): object;

package/lib/models/transaction/nftoken_offer_changes.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNFTokenOfferChanges = void 0;
+const ledger_1 = require("../../models/ledger");
+const common_1 = require("../../v1/common");
+function parseNFTokenOfferChanges(tx) {
+    return new NFTokenOfferChanges(tx).call();
+}
+exports.parseNFTokenOfferChanges = parseNFTokenOfferChanges;
+class NFTokenOfferChanges {
+    constructor(tx) {
+        this.tx = tx;
+        this.changes = {};
+    }
+    call() {
+        if (this.hasAffectedNodes() === false) {
+            return this.changes;
+        }
+        for (const affectedNode of this.tx.meta.AffectedNodes) {
+            this.parseAffectedNode(affectedNode);
+        }
+        return this.changes;
+    }
+    addChange(account, change) {
+        if (!this.changes[account]) {
+            this.changes[account] = [];
+        }
+        this.changes[account].push((0, common_1.removeUndefined)(change));
+    }
+    hasAffectedNodes() {
+        if (this.tx.meta?.AffectedNodes === undefined) {
+            return false;
+        }
+        if (this.tx.meta?.AffectedNodes?.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    parseAffectedNode(affectedNode) {
+        if (this.isNFTokensCreateOfferNode(affectedNode)) {
+            this.parseNFTokensCreateOfferNode(affectedNode);
+        }
+        else if (this.isNFTokensDeleteOfferNode(affectedNode)) {
+            this.parseNFTokensDeleteOfferNode(affectedNode);
+        }
+    }
+    isNFTokensCreateOfferNode(affectedNode) {
+        return affectedNode.CreatedNode?.LedgerEntryType === "NFTokenOffer" && affectedNode.CreatedNode?.NewFields;
+    }
+    parseNFTokensCreateOfferNode(affectedNode) {
+        const status = "created";
+        const amount = affectedNode.CreatedNode.NewFields.Amount;
+        const flags = affectedNode.CreatedNode.NewFields.Flags;
+        const nftokenID = affectedNode.CreatedNode.NewFields.NFTokenID;
+        const owner = affectedNode.CreatedNode.NewFields.Owner;
+        const index = affectedNode.CreatedNode.LedgerIndex;
+        const destination = affectedNode.CreatedNode.NewFields.Destination;
+        const prevTxHash = affectedNode.CreatedNode.NewFields.PreviousTxnID;
+        const prevLedgerIndex = affectedNode.CreatedNode.NewFields.PreviousTxnLgrSeq;
+        let expiration = affectedNode.CreatedNode.NewFields.Expiration;
+        if (typeof expiration === "number") {
+            expiration = (0, ledger_1.ledgerTimeToUnixTime)(expiration);
+        }
+        this.addChange(this.tx.Account, {
+            status,
+            amount,
+            flags,
+            nftokenID,
+            owner,
+            destination,
+            expiration,
+            index,
+            prevTxHash,
+            prevLedgerIndex,
+        });
+    }
+    isNFTokensDeleteOfferNode(affectedNode) {
+        return affectedNode.DeletedNode?.LedgerEntryType === "NFTokenOffer" && affectedNode.DeletedNode?.FinalFields;
+    }
+    parseNFTokensDeleteOfferNode(affectedNode) {
+        const status = "deleted";
+        const amount = affectedNode.DeletedNode.FinalFields.Amount;
+        const flags = affectedNode.DeletedNode.FinalFields.Flags;
+        const nftokenID = affectedNode.DeletedNode.FinalFields.NFTokenID;
+        const owner = affectedNode.DeletedNode.FinalFields.Owner;
+        const index = affectedNode.DeletedNode.LedgerIndex;
+        const destination = affectedNode.DeletedNode.FinalFields.Destination;
+        const prevTxHash = affectedNode.DeletedNode.FinalFields.PreviousTxnID;
+        const prevLedgerIndex = affectedNode.DeletedNode.FinalFields.PreviousTxnLgrSeq;
+        let expiration = affectedNode.DeletedNode.FinalFields.Expiration;
+        if (typeof expiration === "number") {
+            expiration = (0, ledger_1.ledgerTimeToUnixTime)(expiration);
+        }
+        this.addChange(owner, {
+            status,
+            amount,
+            flags,
+            nftokenID,
+            owner,
+            destination,
+            expiration,
+            index,
+            prevTxHash,
+            prevLedgerIndex,
+        });
+    }
+}

package/lib/models/transaction/orderbook_changes.d.ts

@@ -0,0 +1,3 @@
+import * as _ from 'lodash';
+declare function parseOrderbookChanges(metadata: any): _.Dictionary<any[]>;
+export { parseOrderbookChanges };

package/lib/models/transaction/orderbook_changes.js

@@ -0,0 +1,136 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOrderbookChanges = void 0;
+const _ = __importStar(require("lodash"));
+const bignumber_js_1 = require("bignumber.js");
+const BigNumber = bignumber_js_1.BigNumber.clone({ DECIMAL_PLACES: 40 });
+const utils_1 = require("../../v1/common/utils");
+const quality_1 = require("./quality");
+const currency_amount_1 = __importDefault(require("../../v1/ledger/parse/currency-amount"));
+const lsfSell = 0x00020000;
+function removeUndefined(obj) {
+    return _.omitBy(obj, _.isUndefined);
+}
+function convertOrderChange(order) {
+    var takerGets = order.taker_gets;
+    var takerPays = order.taker_pays;
+    var direction = order.sell ? 'sell' : 'buy';
+    var quantity = (direction === 'buy') ? takerPays : takerGets;
+    var totalPrice = (direction === 'buy') ? takerGets : takerPays;
+    return removeUndefined({
+        direction: direction,
+        quantity: quantity,
+        totalPrice: totalPrice,
+        sequence: order.sequence,
+        status: order.status,
+        makerExchangeRate: order.quality,
+        expirationTime: order.expiration
+    });
+}
+function getExpirationTime(node) {
+    var expirationTime = node.finalFields.Expiration || node.newFields.Expiration;
+    if (expirationTime === undefined) {
+        return undefined;
+    }
+    return (new Date((0, utils_1.rippleToUnixTimestamp)(expirationTime))).toISOString();
+}
+function getQuality(node) {
+    var takerGets = node.finalFields.TakerGets || node.newFields.TakerGets;
+    var takerPays = node.finalFields.TakerPays || node.newFields.TakerPays;
+    var takerGetsCurrency = takerGets.currency || 'XRP';
+    var takerPaysCurrency = takerPays.currency || 'XRP';
+    var bookDirectory = node.finalFields.BookDirectory
+        || node.newFields.BookDirectory;
+    var qualityHex = bookDirectory.substring(bookDirectory.length - 16);
+    return (0, quality_1.parseQuality)(qualityHex, takerGetsCurrency, takerPaysCurrency);
+}
+function parseOrderStatus(node) {
+    if (node.diffType === 'CreatedNode') {
+        return 'created';
+    }
+    if (node.diffType === 'ModifiedNode') {
+        return 'partially-filled';
+    }
+    if (node.diffType === 'DeletedNode') {
+        if (node.previousFields.hasOwnProperty('TakerPays')) {
+            return 'filled';
+        }
+        return 'cancelled';
+    }
+    return undefined;
+}
+function calculateDelta(finalAmount, previousAmount) {
+    if (previousAmount) {
+        var finalValue = new BigNumber(finalAmount.value);
+        var previousValue = new BigNumber(previousAmount.value);
+        return finalValue.minus(previousValue).abs().toString();
+    }
+    return '0';
+}
+function parseChangeAmount(node, type) {
+    var status = parseOrderStatus(node);
+    if (status === 'cancelled') {
+        return (0, currency_amount_1.default)(node.finalFields[type]);
+    }
+    else if (status === 'created') {
+        return (0, currency_amount_1.default)(node.newFields[type]);
+    }
+    var finalAmount = (0, currency_amount_1.default)(node.finalFields[type]);
+    var previousAmount = (0, currency_amount_1.default)(node.previousFields[type]);
+    var value = calculateDelta(finalAmount, previousAmount);
+    return _.assign({}, finalAmount, { value: value });
+}
+function parseOrderChange(node) {
+    var orderChange = convertOrderChange({
+        taker_pays: parseChangeAmount(node, 'TakerPays'),
+        taker_gets: parseChangeAmount(node, 'TakerGets'),
+        sell: (node.finalFields.Flags & lsfSell) !== 0,
+        sequence: node.finalFields.Sequence || node.newFields.Sequence,
+        status: parseOrderStatus(node),
+        quality: getQuality(node),
+        expiration: getExpirationTime(node)
+    });
+    Object.defineProperty(orderChange, 'account', {
+        value: node.finalFields.Account || node.newFields.Account
+    });
+    return orderChange;
+}
+function groupByAddress(orderChanges) {
+    return _.groupBy(orderChanges, function (change) {
+        return change.account;
+    });
+}
+function parseOrderbookChanges(metadata) {
+    var nodes = (0, utils_1.normalizeNodes)(metadata);
+    var orderChanges = _.map(_.filter(nodes, function (node) {
+        return node.entryType === 'Offer';
+    }), parseOrderChange);
+    return groupByAddress(orderChanges);
+}
+exports.parseOrderbookChanges = parseOrderbookChanges;

package/lib/models/transaction/quality.d.ts

@@ -0,0 +1,2 @@
+declare function parseQuality(qualityHex: any, takerGetsCurrency: any, takerPaysCurrency: any): string;
+export { parseQuality };

package/lib/models/transaction/quality.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuality = void 0;
+const assert = __importStar(require("assert"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+function adjustQualityForXRP(quality, takerGetsCurrency, takerPaysCurrency) {
+    var numeratorShift = (takerPaysCurrency === 'XRP' ? -6 : 0);
+    var denominatorShift = (takerGetsCurrency === 'XRP' ? -6 : 0);
+    var shift = numeratorShift - denominatorShift;
+    return shift === 0 ? (new bignumber_js_1.default(quality)).toString() :
+        (new bignumber_js_1.default(quality)).shiftedBy(shift).toString();
+}
+function parseQuality(qualityHex, takerGetsCurrency, takerPaysCurrency) {
+    assert.ok(qualityHex.length === 16);
+    var mantissa = new bignumber_js_1.default(qualityHex.substring(2), 16);
+    var offset = parseInt(qualityHex.substring(0, 2), 16) - 100;
+    var quality = mantissa.toString() + 'e' + offset.toString();
+    return adjustQualityForXRP(quality, takerGetsCurrency, takerPaysCurrency);
+}
+exports.parseQuality = parseQuality;

package/lib/models/transaction.d.ts

@@ -0,0 +1,39 @@
+import { Transaction, TransactionMetadata } from "xrpl";
+import { FormattedSpecification, FormattedTransaction } from "../parse/transaction";
+export { FormattedTransaction } from "../parse/transaction";
+import { Outcome } from "../v1/transaction/types";
+export interface TransactionBaseResponse {
+    hash: string;
+    ledger_index?: number;
+    meta?: TransactionMetadata | string;
+    validated?: boolean;
+    date?: number;
+    specification?: FormattedSpecification;
+    outcome?: Outcome;
+    rawTransaction?: string;
+}
+export type TransactionResponse = TransactionBaseResponse & Transaction;
+export type AccountTransaction = {
+    tx: TransactionResponse;
+    meta: TransactionMetadata;
+    validated: boolean;
+};
+export type LedgerTransaction = TransactionBaseResponse & {
+    metaData?: TransactionMetadata;
+};
+export type StreamTransaction = TransactionBaseResponse & {
+    transaction: TransactionResponse;
+    meta: TransactionMetadata;
+};
+export interface AccountPaymentParamsInterface {
+    fee?: string;
+    sequence?: number;
+    lastLedgerSequence?: number;
+}
+export declare function getTxDetails(tx: TransactionResponse, includeRawTransaction: boolean): FormattedTransaction;
+export declare function getAccountTxDetails(tx: AccountTransaction, includeRawTransaction: boolean): FormattedTransaction;
+export declare function getLedgerTxDetails(tx: LedgerTransaction, ledgerIndex: number, closeTime: number, includeRawTransaction: boolean): FormattedTransaction;
+export declare function getStreamTxDetails(tx: StreamTransaction, includeRawTransaction: boolean): FormattedTransaction;
+export declare function AccountTxToTx(accountTx: AccountTransaction): TransactionResponse;
+export declare function LedgerTxToTx(ledgerTx: LedgerTransaction, ledgerIndex: number, closeTime: number): TransactionResponse;
+export declare function StreamTxToTx(streamTx: StreamTransaction): TransactionResponse;

package/lib/models/transaction.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamTxToTx = exports.LedgerTxToTx = exports.AccountTxToTx = exports.getStreamTxDetails = exports.getLedgerTxDetails = exports.getAccountTxDetails = exports.getTxDetails = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const transaction_1 = require("../parse/transaction");
+function getTxDetails(tx, includeRawTransaction) {
+    return (0, transaction_1.parseTransaction)(tx, includeRawTransaction);
+}
+exports.getTxDetails = getTxDetails;
+function getAccountTxDetails(tx, includeRawTransaction) {
+    return getTxDetails(AccountTxToTx(tx), includeRawTransaction);
+}
+exports.getAccountTxDetails = getAccountTxDetails;
+function getLedgerTxDetails(tx, ledgerIndex, closeTime, includeRawTransaction) {
+    return getTxDetails(LedgerTxToTx(tx, ledgerIndex, closeTime), includeRawTransaction);
+}
+exports.getLedgerTxDetails = getLedgerTxDetails;
+function getStreamTxDetails(tx, includeRawTransaction) {
+    return getTxDetails(StreamTxToTx(tx), includeRawTransaction);
+}
+exports.getStreamTxDetails = getStreamTxDetails;
+function AccountTxToTx(accountTx) {
+    return Object.assign({}, accountTx.tx, { meta: accountTx.meta, validated: accountTx.validated });
+}
+exports.AccountTxToTx = AccountTxToTx;
+function LedgerTxToTx(ledgerTx, ledgerIndex, closeTime) {
+    const tx = lodash_1.default.omit(ledgerTx, "metaData");
+    return Object.assign({}, tx, {
+        meta: ledgerTx.metaData,
+        date: closeTime,
+        ledger_index: ledgerIndex,
+    });
+}
+exports.LedgerTxToTx = LedgerTxToTx;
+function StreamTxToTx(streamTx) {
+    return Object.assign({}, streamTx.transaction, {
+        meta: streamTx.meta,
+        ledger_index: streamTx.ledger_index,
+        validated: streamTx.validated,
+    });
+}
+exports.StreamTxToTx = StreamTxToTx;

package/lib/models/trustline.d.ts

@@ -0,0 +1,15 @@
+export interface Trustline {
+    account: string;
+    balance: string;
+    currency: string;
+    limit: string;
+    limit_peer: string;
+    quality_in: number;
+    quality_out: number;
+    no_ripple?: boolean;
+    no_ripple_peer?: boolean;
+    authorized?: boolean;
+    peer_authorized?: boolean;
+    freeze?: boolean;
+    freeze_peer?: boolean;
+}