@bithomp/xrpl-api 2.3.6

package/lib/ledger/vl.d.ts

@@ -0,0 +1,10 @@
+import { VLInterface, ValidatorInterface, VLBlobInterface } from "../models/vl";
+export declare function createVL(masterSecret: {
+    privateKey: string;
+    publicKey: string;
+}, ephemeralSecret: {
+    privateKey: string;
+    publicKey: string;
+}, sequence: number, expiration: number, validatorsPublicKeys: string[]): Promise<VLInterface>;
+export declare function createVLBlob(sequence: number, expiration: number, validatorsPublicKeys: string[]): Promise<VLBlobInterface>;
+export declare function getVLBlobValidatorsManifets(validatorsPublicKeys: string[]): Promise<ValidatorInterface[]>;

package/lib/ledger/vl.js

@@ -0,0 +1,92 @@
+"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.getVLBlobValidatorsManifets = exports.createVLBlob = exports.createVL = void 0;
+const Client = __importStar(require("../client"));
+const vl_1 = require("../models/vl");
+const manifest_1 = require("../models/manifest");
+const ledger_1 = require("../models/ledger");
+const Validator = __importStar(require("../validator"));
+async function createVL(masterSecret, ephemeralSecret, sequence, expiration, validatorsPublicKeys) {
+    if (!masterSecret) {
+        throw new Error("Master key is required");
+    }
+    if (!ephemeralSecret) {
+        throw new Error("Ephemeral key is required");
+    }
+    const vlBlob = await createVLBlob(sequence, expiration, validatorsPublicKeys);
+    const blob = (0, vl_1.encodeVLBlob)(vlBlob);
+    const manifest = (0, manifest_1.generateManifest)({
+        Sequence: sequence,
+        PublicKey: masterSecret.publicKey,
+        SigningPubKey: ephemeralSecret.publicKey,
+        SigningPrivateKey: ephemeralSecret.privateKey,
+        MasterPrivateKey: masterSecret.privateKey,
+    });
+    const signature = Validator.sign(Buffer.from(blob, "base64"), ephemeralSecret.privateKey);
+    return {
+        blob,
+        manifest,
+        signature,
+        public_key: masterSecret.publicKey,
+        version: 1,
+    };
+}
+exports.createVL = createVL;
+async function createVLBlob(sequence, expiration, validatorsPublicKeys) {
+    const validators = await getVLBlobValidatorsManifets(validatorsPublicKeys);
+    return {
+        sequence,
+        expiration: (0, ledger_1.unixTimeToLedgerTime)(expiration),
+        validators,
+    };
+}
+exports.createVLBlob = createVLBlob;
+async function getVLBlobValidatorsManifets(validatorsPublicKeys) {
+    const connection = Client.findConnection("manifest");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const validatorsManifests = await Promise.all(validatorsPublicKeys.map(async (publicKey) => {
+        const response = await connection.request({
+            command: "manifest",
+            public_key: publicKey,
+        });
+        if (response.error) {
+            Promise.reject(response.error);
+        }
+        return response.result;
+    }));
+    const validators = validatorsManifests.map((info) => {
+        const validationPublicKey = info.requested;
+        const manifest = info.manifest;
+        return {
+            validation_public_key: validationPublicKey,
+            manifest,
+        };
+    });
+    return validators;
+}
+exports.getVLBlobValidatorsManifets = getVLBlobValidatorsManifets;

package/lib/models/account_info.d.ts

@@ -0,0 +1,122 @@
+import { LedgerEntry, AccountSetAsfFlags } from "xrpl";
+import { QueueData } from "../v1/common/types/objects/queue_data";
+export declare const AccountRootFlagsKeys: {
+    passwordSpent: LedgerEntry.AccountRootFlags;
+    requireDestTag: LedgerEntry.AccountRootFlags;
+    requireAuth: LedgerEntry.AccountRootFlags;
+    depositAuth: LedgerEntry.AccountRootFlags;
+    disallowXRP: LedgerEntry.AccountRootFlags;
+    disableMaster: LedgerEntry.AccountRootFlags;
+    noFreeze: LedgerEntry.AccountRootFlags;
+    globalFreeze: LedgerEntry.AccountRootFlags;
+    defaultRipple: LedgerEntry.AccountRootFlags;
+    disallowIncomingNFTokenOffer: LedgerEntry.AccountRootFlags;
+    disallowIncomingCheck: LedgerEntry.AccountRootFlags;
+    disallowIncomingPayChan: LedgerEntry.AccountRootFlags;
+    disallowIncomingTrustline: LedgerEntry.AccountRootFlags;
+};
+export interface AccountRootFlagsKeysInterface {
+    passwordSpent?: boolean;
+    requireDestTag?: boolean;
+    requireAuth?: boolean;
+    depositAuth?: boolean;
+    disallowXRP?: boolean;
+    disableMaster?: boolean;
+    noFreeze?: boolean;
+    globalFreeze?: boolean;
+    defaultRipple?: boolean;
+    disallowIncomingNFTokenOffer?: boolean;
+    disallowIncomingCheck?: boolean;
+    disallowIncomingPayChan?: boolean;
+    disallowIncomingTrustline?: boolean;
+}
+export declare const AccountSetFlags: {
+    requireDestinationTag: AccountSetAsfFlags;
+    requireAuthorization: AccountSetAsfFlags;
+    depositAuth: AccountSetAsfFlags;
+    disallowIncomingXRP: AccountSetAsfFlags;
+    disableMasterKey: AccountSetAsfFlags;
+    enableTransactionIDTracking: AccountSetAsfFlags;
+    noFreeze: AccountSetAsfFlags;
+    globalFreeze: AccountSetAsfFlags;
+    defaultRipple: AccountSetAsfFlags;
+    authorizedMinter: AccountSetAsfFlags;
+    disallowIncomingNFTokenOffer: AccountSetAsfFlags;
+    disallowIncomingCheck: AccountSetAsfFlags;
+    disallowIncomingPayChan: AccountSetAsfFlags;
+    disallowIncomingTrustline: AccountSetAsfFlags;
+};
+export declare const SignerListFlagsKeys: {
+    oneOwnerCount: LedgerEntry.SignerListFlags;
+};
+export interface SignerListFlagsKeysInterface {
+    oneOwnerCount?: boolean;
+}
+export declare const AccountFields: {
+    EmailHash: {
+        name: string;
+        encoding: string;
+        length: number;
+        defaults: string;
+    };
+    WalletLocator: {
+        name: string;
+    };
+    MessageKey: {
+        name: string;
+    };
+    Domain: {
+        name: string;
+        encoding: string;
+    };
+    TransferRate: {
+        name: string;
+        defaults: number;
+        shift: number;
+    };
+    TickSize: {
+        name: string;
+        defaults: number;
+    };
+    RegularKey: {
+        name: string;
+    };
+    NFTokenMinter: {
+        name: string;
+    };
+};
+export interface AccountInfoResponse {
+    account_data: AccountInfoDataResponse;
+    ledger_current_index?: number;
+    ledger_index?: number;
+    queue_data?: QueueData;
+    validated?: boolean;
+}
+export interface AccountSignerListResponse {
+    signer_lists?: LedgerEntry.SignerList[];
+}
+export interface AccountInfoDataResponse extends LedgerEntry.AccountRoot, AccountSignerListResponse {
+}
+export interface AccountFieldsInterface {
+    blackholed?: boolean;
+    emailHash?: string;
+    walletLocator?: string;
+    messageKey?: string;
+    domain?: string;
+    transferRate?: number;
+    tickSize?: number;
+    regularKey?: string;
+    nftokenMinter?: string;
+}
+export interface AccountSettingsInterface extends AccountFieldsInterface, AccountRootFlagsKeysInterface {
+}
+export declare function getSettings(accountInfo: AccountInfoDataResponse, excludeFalse?: boolean): AccountSettingsInterface;
+export declare function parseAccountFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): AccountRootFlagsKeysInterface;
+export declare function parseAccountFields(accountInfo: AccountInfoDataResponse, options?: {
+    excludeFalse?: boolean;
+}): AccountFieldsInterface;
+export declare function parseSignerListFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): SignerListFlagsKeysInterface;

package/lib/models/account_info.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSignerListFlags = exports.parseAccountFields = exports.parseAccountFlags = exports.getSettings = exports.AccountFields = exports.SignerListFlagsKeys = exports.AccountSetFlags = exports.AccountRootFlagsKeys = void 0;
+const xrpl_1 = require("xrpl");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const common_1 = require("../common");
+const flags_1 = require("../parse/ledger/flags");
+exports.AccountRootFlagsKeys = {
+    passwordSpent: xrpl_1.LedgerEntry.AccountRootFlags.lsfPasswordSpent,
+    requireDestTag: xrpl_1.LedgerEntry.AccountRootFlags.lsfRequireDestTag,
+    requireAuth: xrpl_1.LedgerEntry.AccountRootFlags.lsfRequireAuth,
+    depositAuth: xrpl_1.LedgerEntry.AccountRootFlags.lsfDepositAuth,
+    disallowXRP: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowXRP,
+    disableMaster: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisableMaster,
+    noFreeze: xrpl_1.LedgerEntry.AccountRootFlags.lsfNoFreeze,
+    globalFreeze: xrpl_1.LedgerEntry.AccountRootFlags.lsfGlobalFreeze,
+    defaultRipple: xrpl_1.LedgerEntry.AccountRootFlags.lsfDefaultRipple,
+    disallowIncomingNFTokenOffer: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingNFTokenOffer,
+    disallowIncomingCheck: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingCheck,
+    disallowIncomingPayChan: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingPayChan,
+    disallowIncomingTrustline: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingTrustline,
+};
+exports.AccountSetFlags = {
+    requireDestinationTag: xrpl_1.AccountSetAsfFlags.asfRequireDest,
+    requireAuthorization: xrpl_1.AccountSetAsfFlags.asfRequireAuth,
+    depositAuth: xrpl_1.AccountSetAsfFlags.asfDepositAuth,
+    disallowIncomingXRP: xrpl_1.AccountSetAsfFlags.asfDisallowXRP,
+    disableMasterKey: xrpl_1.AccountSetAsfFlags.asfDisableMaster,
+    enableTransactionIDTracking: xrpl_1.AccountSetAsfFlags.asfAccountTxnID,
+    noFreeze: xrpl_1.AccountSetAsfFlags.asfNoFreeze,
+    globalFreeze: xrpl_1.AccountSetAsfFlags.asfGlobalFreeze,
+    defaultRipple: xrpl_1.AccountSetAsfFlags.asfDefaultRipple,
+    authorizedMinter: xrpl_1.AccountSetAsfFlags.asfAuthorizedNFTokenMinter,
+    disallowIncomingNFTokenOffer: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingNFTokenOffer,
+    disallowIncomingCheck: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingCheck,
+    disallowIncomingPayChan: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingPayChan,
+    disallowIncomingTrustline: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingTrustline,
+};
+exports.SignerListFlagsKeys = {
+    oneOwnerCount: xrpl_1.LedgerEntry.SignerListFlags.lsfOneOwnerCount,
+};
+exports.AccountFields = {
+    EmailHash: { name: "emailHash", encoding: "hex", length: 32, defaults: "00000000000000000000000000000000" },
+    WalletLocator: { name: "walletLocator" },
+    MessageKey: { name: "messageKey" },
+    Domain: { name: "domain", encoding: "hex" },
+    TransferRate: { name: "transferRate", defaults: 0, shift: 9 },
+    TickSize: { name: "tickSize", defaults: 0 },
+    RegularKey: { name: "regularKey" },
+    NFTokenMinter: { name: "nftokenMinter" },
+};
+function getSettings(accountInfo, excludeFalse = true) {
+    const parsedFlags = parseAccountFlags(accountInfo.Flags, { excludeFalse });
+    const parsedFields = parseAccountFields(accountInfo, { excludeFalse });
+    return {
+        ...parsedFlags,
+        ...parsedFields,
+    };
+}
+exports.getSettings = getSettings;
+function parseAccountFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, exports.AccountRootFlagsKeys, options);
+}
+exports.parseAccountFlags = parseAccountFlags;
+function parseAccountFields(accountInfo, options = {}) {
+    const settings = {};
+    if (accountInfo.hasOwnProperty("signer_lists")) {
+        if (accountInfo.Flags & exports.AccountRootFlagsKeys.disableMaster &&
+            common_1.BLACKHOLE_ACCOUNTS.includes(accountInfo.RegularKey) &&
+            accountInfo.signer_lists?.length === 0) {
+            settings.blackholed = true;
+        }
+        else if (!options.excludeFalse) {
+            settings.blackholed = false;
+        }
+    }
+    for (const fieldName in exports.AccountFields) {
+        const fieldValue = accountInfo[fieldName];
+        if (fieldValue != null) {
+            const info = exports.AccountFields[fieldName];
+            settings[info.name] = parseField(info, fieldValue);
+        }
+    }
+    function parseField(info, value) {
+        if (info.encoding === "hex" && !info.length) {
+            return Buffer.from(value, "hex").toString("ascii");
+        }
+        if (info.shift) {
+            return new bignumber_js_1.default(value).shiftedBy(-info.shift).toNumber();
+        }
+        return value;
+    }
+    return settings;
+}
+exports.parseAccountFields = parseAccountFields;
+function parseSignerListFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, exports.SignerListFlagsKeys, options);
+}
+exports.parseSignerListFlags = parseSignerListFlags;

package/lib/models/account_lines.d.ts

@@ -0,0 +1,24 @@
+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;
+}
+export interface AccountLinesResponse {
+    account: string;
+    lines: Trustline[];
+    ledger_current_index?: number;
+    ledger_index?: number;
+    ledger_hash?: string;
+    marker?: unknown;
+    validated?: boolean;
+}

package/lib/models/account_lines.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/account_nfts.d.ts

@@ -0,0 +1,19 @@
+import { SortDirection } from "../common";
+export interface NFTokenInterface {
+    Flags: number;
+    Issuer: string;
+    NFTokenID: string;
+    NFTokenTaxon: number;
+    TransferFee: number;
+    Sequence: number;
+}
+export interface AccountNFTokenInterface {
+    Flags: number;
+    Issuer: string;
+    NFTokenID: string;
+    TokenTaxons: number;
+    nft_serial: number;
+}
+export declare function sortHelperAccountNFToken(a: AccountNFTokenInterface, b: AccountNFTokenInterface): SortDirection;
+export declare function cipheredTaxon(tokenSeq: number, taxon: number): number;
+export declare function parseNFTokenID(nftokenID: string): NFTokenInterface | null;

package/lib/models/account_nfts.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.parseNFTokenID = exports.cipheredTaxon = exports.sortHelperAccountNFToken = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const AddressCodec = require("ripple-address-codec");
+function sortHelperAccountNFToken(a, b) {
+    const cmpIssuer = a.Issuer.localeCompare(b.Issuer);
+    if (cmpIssuer !== 0) {
+        return cmpIssuer;
+    }
+    if (a.nft_serial < b.nft_serial) {
+        return -1;
+    }
+    if (a.nft_serial > b.nft_serial) {
+        return 1;
+    }
+    return 0;
+}
+exports.sortHelperAccountNFToken = sortHelperAccountNFToken;
+function cipheredTaxon(tokenSeq, taxon) {
+    return (taxon ^ ((384160001 * tokenSeq + 2459) >>> 0)) >>> 0;
+}
+exports.cipheredTaxon = cipheredTaxon;
+function parseNFTokenID(nftokenID) {
+    if (typeof nftokenID !== "string" || nftokenID.length !== 64) {
+        return null;
+    }
+    const flags = new bignumber_js_1.default(nftokenID.slice(0, 4), 16).toNumber();
+    const transferFee = new bignumber_js_1.default(nftokenID.slice(4, 8), 16).toNumber();
+    const issuer = AddressCodec.encodeAccountID(Buffer.from(nftokenID.slice(8, 48), "hex"));
+    const scrambledTaxon = new bignumber_js_1.default(nftokenID.slice(48, 56), 16).toNumber();
+    const sequence = new bignumber_js_1.default(nftokenID.slice(56, 64), 16).toNumber();
+    return {
+        NFTokenID: nftokenID,
+        Flags: flags,
+        TransferFee: transferFee,
+        Issuer: issuer,
+        NFTokenTaxon: cipheredTaxon(sequence, scrambledTaxon),
+        Sequence: sequence,
+    };
+}
+exports.parseNFTokenID = parseNFTokenID;

package/lib/models/account_object.d.ts

@@ -0,0 +1,38 @@
+import { LedgerEntry } from "xrpl";
+import { Trustline } from "./account_lines";
+import { Amount } from "../v1/common/types/objects";
+export type AccountObject = LedgerEntry.Check | LedgerEntry.DepositPreauth | LedgerEntry.Escrow | LedgerEntry.Offer | LedgerEntry.PayChannel | LedgerEntry.SignerList | LedgerEntry.Ticket | LedgerEntry.RippleState;
+export type AccountObjectType = "check" | "escrow" | "offer" | "payment_channel" | "signer_list" | "state" | "ticket" | "nft_offer";
+export interface AccountObjectsResponse {
+    account: string;
+    account_objects: AccountObject[];
+    ledger_hash?: string;
+    ledger_index?: number;
+    ledger_current_index?: number;
+    limit?: number;
+    marker?: string;
+    validated?: boolean;
+}
+export interface AccountNFTObjectsResponse {
+    account: string;
+    nft_offers: AccountNFTOffersInterface[];
+    ledger_hash?: string;
+    ledger_index?: number;
+    ledger_current_index?: number;
+    limit?: number;
+    marker?: string;
+    validated?: boolean;
+}
+export interface AccountNFTOffersInterface {
+    nft_id: string;
+    amount: Amount;
+    flags: number;
+    index: string;
+    owner: string;
+    destination?: string;
+    expiration?: number;
+    ledger_index: number;
+    transaction_hash: string;
+}
+export declare function accountObjectsToAccountLines(account: string, accountObjects: AccountObject[]): Trustline[];
+export declare function accountObjectsToNFTOffers(accountObjects: AccountObject[]): AccountNFTOffersInterface[];

package/lib/models/account_object.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountObjectsToNFTOffers = exports.accountObjectsToAccountLines = void 0;
+const xrpl_1 = require("xrpl");
+const { RippleStateFlags } = xrpl_1.LedgerEntry;
+const common_1 = require("../common");
+const ledger_1 = require("../models/ledger");
+function accountObjectsToAccountLines(account, accountObjects) {
+    const notInDefaultState = accountObjects.filter((node) => {
+        return (node.LedgerEntryType === "RippleState" &&
+            node.Flags & RippleStateFlags[node.HighLimit.issuer === account ? "lsfHighReserve" : "lsfLowReserve"]);
+    });
+    const accountLinesFormatted = notInDefaultState.map((node) => RippleStateToTrustLine(node, account));
+    return accountLinesFormatted;
+}
+exports.accountObjectsToAccountLines = accountObjectsToAccountLines;
+const RippleStateToTrustLine = (ledgerEntry, account) => {
+    const parties = [ledgerEntry.HighLimit, ledgerEntry.LowLimit];
+    const [self, counterparty] = ledgerEntry.HighLimit.issuer === account ? parties : parties.reverse();
+    const ripplingFlags = [
+        (RippleStateFlags.lsfHighNoRipple & ledgerEntry.Flags) === RippleStateFlags.lsfHighNoRipple,
+        (RippleStateFlags.lsfLowNoRipple & ledgerEntry.Flags) === RippleStateFlags.lsfLowNoRipple,
+    ];
+    const [no_ripple, no_ripple_peer] = ledgerEntry.HighLimit.issuer === account ? ripplingFlags : ripplingFlags.reverse();
+    const balance = ledgerEntry.HighLimit.issuer === account && ledgerEntry.Balance.value.startsWith("-")
+        ? ledgerEntry.Balance.value.slice(1)
+        : ledgerEntry.Balance.value;
+    return {
+        account: counterparty.issuer,
+        balance,
+        currency: self.currency,
+        limit: self.value,
+        limit_peer: counterparty.value,
+        no_ripple,
+        no_ripple_peer,
+    };
+};
+function accountObjectsToNFTOffers(accountObjects) {
+    const nftOfferObjects = accountObjects.filter((obj) => {
+        return obj.LedgerEntryType === "NFTokenOffer";
+    });
+    const nftOffers = nftOfferObjects.map((obj) => {
+        let expiration = obj.Expiration;
+        if (typeof expiration === "number") {
+            expiration = (0, ledger_1.ledgerTimeToUnixTime)(expiration);
+        }
+        return (0, common_1.removeUndefined)({
+            nft_id: obj.NFTokenID,
+            amount: obj.Amount,
+            flags: obj.Flags,
+            index: obj.index,
+            owner: obj.Owner,
+            destination: obj.Destination,
+            expiration,
+            ledger_index: obj.PreviousTxnLgrSeq,
+            transaction_hash: obj.PreviousTxnID,
+        });
+    });
+    return nftOffers;
+}
+exports.accountObjectsToNFTOffers = accountObjectsToNFTOffers;

package/lib/models/base_model.d.ts

@@ -0,0 +1,14 @@
+export interface ErrorResponse {
+    id?: number | string;
+    account?: string;
+    transaction?: string;
+    public_key?: string;
+    nft_id?: string;
+    status: "error" | "timeout";
+    error: string;
+    error_code?: string;
+    error_message?: string;
+    api_version?: number;
+    marker?: any;
+    validated?: boolean;
+}

package/lib/models/base_model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/book_offers.d.ts

@@ -0,0 +1,9 @@
+import { FormattedIssuedCurrency } from "../types";
+export type OrderbookInfo = {
+    base: FormattedIssuedCurrency;
+    counter: FormattedIssuedCurrency;
+};
+export declare function formatBidsAndAsks(orderbook: OrderbookInfo, offers: any[]): {
+    bids: any[];
+    asks: any[];
+};

package/lib/models/book_offers.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBidsAndAsks = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const orderbook_order_1 = require("../parse/ledger/orderbook-order");
+function isSameIssue(a, b) {
+    return a.currency === b.currency && a.counterparty === b.counterparty;
+}
+function directionFilter(direction, order) {
+    return order.specification.direction === direction;
+}
+function flipOrder(order) {
+    const specification = order.specification;
+    const flippedSpecification = {
+        quantity: specification.totalPrice,
+        totalPrice: specification.quantity,
+        direction: specification.direction === "buy" ? "sell" : "buy",
+    };
+    const newSpecification = lodash_1.default.merge({}, specification, flippedSpecification);
+    return lodash_1.default.merge({}, order, { specification: newSpecification });
+}
+function alignOrder(base, order) {
+    const quantity = order.specification.quantity;
+    return isSameIssue(quantity, base) ? order : flipOrder(order);
+}
+function formatBidsAndAsks(orderbook, offers) {
+    const orders = offers
+        .sort((a, b) => {
+        return new bignumber_js_1.default(a.quality).comparedTo(b.quality);
+    })
+        .map(orderbook_order_1.parseOrderbookOrder);
+    const alignedOrders = orders.map(lodash_1.default.partial(alignOrder, orderbook.base));
+    const bids = alignedOrders.filter(lodash_1.default.partial(directionFilter, "buy"));
+    const asks = alignedOrders.filter(lodash_1.default.partial(directionFilter, "sell"));
+    return { bids, asks };
+}
+exports.formatBidsAndAsks = formatBidsAndAsks;

package/lib/models/index.d.ts

@@ -0,0 +1,23 @@
+export * from "./account_info";
+export * from "./account_nfts";
+export * from "./account_object";
+export * from "./ledger";
+export * from "./manifest";
+export * from "./transaction";
+export * from "./account_lines";
+export * from "./vl";
+export { parseAffectedObjects } from "../parse/outcome/affected_objects";
+export { parseNFTokenChanges } from "../parse/outcome/nftoken_changes";
+export { parseNFTokenOfferChanges } from "../parse/outcome/nftoken_offer_changes";
+export { parseBalanceChanges } from "../parse/outcome/balance_changes";
+export { parseLockedBalanceChanges } from "../parse/outcome/locked_balance_changes";
+export { parseChannelChanges } from "../parse/outcome/channel_changes";
+export { parseOrderbookChanges } from "../parse/outcome/orderbook_changes";
+import parseNFTokenBurn from "../parse/specification/nftoken-burn";
+import parseNFTokenMint from "../parse/specification/nftoken-mint";
+import parseNFTokenFlags from "../parse/ledger/nftoken-flags";
+import parseNFTOfferFlags from "../parse/ledger/nftoken-offer-flags";
+import parseNFTokenAcceptOffer from "../parse/specification/nftoken-accept-offer";
+import parseNFTokenCancelOffer from "../parse/specification/nftoken-cancel-offer";
+import parseNFTokenCreateOffer from "../parse/specification/nftoken-create-offer";
+export { parseNFTokenMint, parseNFTokenBurn, parseNFTokenFlags, parseNFTOfferFlags, parseNFTokenAcceptOffer, parseNFTokenCancelOffer, parseNFTokenCreateOffer, };