@bithomp/xrpl-api 3.7.31 → 3.7.37

package/lib/src/parse/ledger/nftoken-offer-flags.d.ts

@@ -0,0 +1,5 @@
+import { NFTokenOfferFlagsKeysInterface } from "../../types/nftokens";
+declare function parseNFTOfferFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): NFTokenOfferFlagsKeysInterface;
+export default parseNFTOfferFlags;

package/lib/src/parse/ledger/nftoken-offer-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nftokens_1 = require("../../types/nftokens");
+const flags_1 = require("./flags");
+function parseNFTOfferFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, nftokens_1.NFTokenOfferFlagsKeys, options);
+}
+exports.default = parseNFTOfferFlags;

package/lib/src/parse/ledger/offer-flags.d.ts

@@ -0,0 +1,5 @@
+import { OfferFlagsKeysInterface } from "../../types/offers";
+declare function parseOfferFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): OfferFlagsKeysInterface;
+export default parseOfferFlags;

package/lib/src/parse/ledger/offer-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const offers_1 = require("../../types/offers");
+const flags_1 = require("./flags");
+function parseOfferFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, offers_1.OfferFlagsKeys, options);
+}
+exports.default = parseOfferFlags;

package/lib/src/parse/ledger/orderbook-order.d.ts

@@ -0,0 +1,21 @@
+import { Amount, OfferLedgerEntry, IssuedCurrencyAmount, FormattedOfferCreateSpecification } from "../../types";
+export interface BookOffer extends OfferLedgerEntry {
+    quality?: string;
+    owner_funds?: string;
+    taker_gets_funded?: Amount;
+    taker_pays_funded?: Amount;
+}
+export type FormattedOrderbookOrder = {
+    specification: FormattedOfferCreateSpecification;
+    properties: {
+        maker: string;
+        sequence: number;
+        makerExchangeRate: string;
+    };
+    state?: {
+        fundedAmount?: IssuedCurrencyAmount;
+        priceOfFundedAmount?: IssuedCurrencyAmount;
+    };
+    data: BookOffer;
+};
+export declare function parseOrderbookOrder(data: BookOffer): FormattedOrderbookOrder;

package/lib/src/parse/ledger/orderbook-order.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOrderbookOrder = parseOrderbookOrder;
+const lodash_1 = __importDefault(require("lodash"));
+const xrpl_1 = require("xrpl");
+const utils_1 = require("../utils");
+const common_1 = require("../../common");
+const amount_1 = __importDefault(require("./amount"));
+const offer_flags_1 = __importDefault(require("../ledger/offer-flags"));
+function parseOrderbookOrder(data) {
+    const flags = (0, offer_flags_1.default)(data.Flags);
+    const takerGets = (0, amount_1.default)(data.TakerGets);
+    const takerPays = (0, amount_1.default)(data.TakerPays);
+    const quantity = flags.sell === true ? takerGets : takerPays;
+    const totalPrice = flags.sell === true ? takerPays : takerGets;
+    const specification = (0, common_1.removeUndefined)({
+        flags: flags,
+        expirationTime: (0, utils_1.parseTimestamp)(data.Expiration),
+        takerGets,
+        takerPays,
+        direction: (data.Flags & xrpl_1.LedgerEntry.OfferFlags.lsfSell) === 0 ? "buy" : "sell",
+        passive: (data.Flags & xrpl_1.LedgerEntry.OfferFlags.lsfPassive) !== 0 || undefined,
+        quantity: quantity,
+        totalPrice: totalPrice,
+    });
+    const properties = {
+        maker: data.Account,
+        sequence: data.Sequence,
+        makerExchangeRate: (0, utils_1.adjustQualityForXRP)(data.quality, takerGets.currency, takerPays.currency),
+    };
+    const takerGetsFunded = data.taker_gets_funded ? (0, amount_1.default)(data.taker_gets_funded) : undefined;
+    const takerPaysFunded = data.taker_pays_funded ? (0, amount_1.default)(data.taker_pays_funded) : undefined;
+    const available = (0, common_1.removeUndefined)({
+        fundedAmount: takerGetsFunded,
+        priceOfFundedAmount: takerPaysFunded,
+    });
+    const state = lodash_1.default.isEmpty(available) ? undefined : available;
+    return (0, common_1.removeUndefined)({ specification, properties, state, data });
+}

package/lib/src/parse/ledger/permissions.d.ts

@@ -0,0 +1,2 @@
+import { Permission } from "xrpl";
+export declare function parsePermissions(permissions: Permission[]): string[];

package/lib/src/parse/ledger/permissions.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePermissions = parsePermissions;
+function parsePermissions(permissions) {
+    if (!permissions) {
+        return [];
+    }
+    return permissions.map((perm) => perm.Permission.PermissionValue).sort();
+}

package/lib/src/parse/ledger/regular-key.d.ts

@@ -0,0 +1,2 @@
+import { FormattedSignerRegularKey } from "../../types";
+export declare function parseSignerRegularKey(tx: any): FormattedSignerRegularKey | undefined;

package/lib/src/parse/ledger/regular-key.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSignerRegularKey = parseSignerRegularKey;
+const ripple_keypairs_1 = require("ripple-keypairs");
+function parseSignerRegularKey(tx) {
+    if (tx && tx.SigningPubKey && !tx.Signers) {
+        const signedBy = (0, ripple_keypairs_1.deriveAddress)(tx.SigningPubKey);
+        if (signedBy !== tx.Account) {
+            return {
+                address: signedBy,
+            };
+        }
+    }
+}

package/lib/src/parse/ledger/remark-flags.d.ts

@@ -0,0 +1,5 @@
+import { RemarksFlagsKeysInterface } from "../../types/remarks";
+declare function parseRemarkFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): RemarksFlagsKeysInterface;
+export default parseRemarkFlags;

package/lib/src/parse/ledger/remark-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const remarks_1 = require("../../types/remarks");
+const flags_1 = require("./flags");
+function parseRemarkFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, remarks_1.RemarksFlagsKeys, options);
+}
+exports.default = parseRemarkFlags;

package/lib/src/parse/ledger/remarks.d.ts

@@ -0,0 +1,3 @@
+import { FormattedRemark, Remark } from "../../types";
+export declare const REMARKS_SUPPORTED_ENTRIES: string[];
+export declare function parseRemarks(remarks: Remark[]): FormattedRemark[];

package/lib/src/parse/ledger/remarks.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMARKS_SUPPORTED_ENTRIES = void 0;
+exports.parseRemarks = parseRemarks;
+const common_1 = require("../../common");
+const utils_1 = require("../utils");
+const remark_flags_1 = __importDefault(require("./remark-flags"));
+exports.REMARKS_SUPPORTED_ENTRIES = [
+    "AccountRoot",
+    "Offer",
+    "Escrow",
+    "Ticket",
+    "PayChannel",
+    "Check",
+    "DepositPreauth",
+    "URIToken",
+    "RippleState",
+];
+function parseRemarks(remarks) {
+    if (!Array.isArray(remarks)) {
+        return [];
+    }
+    return remarks.map((remark) => {
+        return (0, common_1.removeUndefined)(parseRemark(remark));
+    });
+}
+function parseRemark(remark) {
+    const { RemarkName, RemarkValue, Flags } = remark.Remark;
+    return (0, common_1.removeUndefined)({
+        name: (0, utils_1.hexToString)(RemarkName),
+        value: (0, utils_1.decodeHexData)(RemarkValue),
+        flags: (0, remark_flags_1.default)(Flags),
+    });
+}

package/lib/src/parse/ledger/signers.d.ts

@@ -0,0 +1,2 @@
+import { FormattedTransactionSigner } from "../../types";
+export declare function parseSigners(tx: any): FormattedTransactionSigner[] | undefined;

package/lib/src/parse/ledger/signers.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSigners = parseSigners;
+function parseSigners(tx) {
+    if (tx && tx.Signers) {
+        return tx.Signers.map((signer) => {
+            return {
+                address: signer.Signer.Account,
+            };
+        });
+    }
+}

package/lib/src/parse/ledger/source.d.ts

@@ -0,0 +1,3 @@
+import { FormattedSourceAddress } from "../../types/account";
+export declare function parseSourceWithAmount(tx: any): FormattedSourceAddress | undefined;
+export declare function parseSource(tx: any): FormattedSourceAddress | undefined;

package/lib/src/parse/ledger/source.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSourceWithAmount = parseSourceWithAmount;
+exports.parseSource = parseSource;
+const common_1 = require("../../common");
+const amount_1 = __importDefault(require("./amount"));
+const account_1 = require("./account");
+const utils_1 = require("../utils");
+function parseSourceWithAmount(tx) {
+    if (tx && (tx.Account || tx.Account === "")) {
+        return (0, common_1.removeUndefined)({
+            address: (0, account_1.parseAccount)(tx.Account),
+            maxAmount: (0, utils_1.removeGenericCounterparty)((0, amount_1.default)(tx.SendMax || tx.DeliverMax || tx.Amount), tx.Account),
+            tag: tx.SourceTag,
+        });
+    }
+}
+function parseSource(tx) {
+    if (tx && (tx.Account || tx.Account === "")) {
+        return (0, common_1.removeUndefined)({
+            address: (0, account_1.parseAccount)(tx.Account),
+            tag: tx.SourceTag,
+        });
+    }
+}

package/lib/src/parse/ledger/trustline-flags.d.ts

@@ -0,0 +1,5 @@
+import { TrustlineFlagsKeysInterface } from "../../types/trustlines";
+declare function parseTrustlineFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): TrustlineFlagsKeysInterface;
+export default parseTrustlineFlags;

package/lib/src/parse/ledger/trustline-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const trustlines_1 = require("../../types/trustlines");
+const flags_1 = require("./flags");
+function parseTrustlineFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, trustlines_1.TrustlineFlagsKeys, options);
+}
+exports.default = parseTrustlineFlags;

package/lib/src/parse/ledger/tx-account-set-flags.d.ts

@@ -0,0 +1,4 @@
+declare function parseTxAccountSetFlags(value: number, options?: {
+    nativeCurrency?: string;
+}): Record<string, number>;
+export default parseTxAccountSetFlags;

package/lib/src/parse/ledger/tx-account-set-flags.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const xrpl_1 = require("xrpl");
+const global_1 = require("../../types/global");
+const common_1 = require("../../common");
+function parseTxAccountSetFlags(value, options = {}) {
+    const flags = {};
+    if (options.nativeCurrency === common_1.MAINNET_NATIVE_CURRENCY) {
+        if (value & global_1.GlobalFlags.tfInnerBatchTxn) {
+            flags.innerBatchTxn = true;
+        }
+        else {
+            flags.innerBatchTxn = false;
+        }
+    }
+    if (value & xrpl_1.AccountSetTfFlags.tfRequireDestTag) {
+        flags.requireDestTag = true;
+    }
+    else if (value & xrpl_1.AccountSetTfFlags.tfOptionalDestTag) {
+        flags.requireDestTag = false;
+    }
+    if (value & xrpl_1.AccountSetTfFlags.tfRequireAuth) {
+        flags.requireAuth = true;
+    }
+    else if (value & xrpl_1.AccountSetTfFlags.tfOptionalAuth) {
+        flags.requireAuth = false;
+    }
+    if (value & xrpl_1.AccountSetTfFlags.tfDisallowXRP) {
+        flags.disallowXRP = true;
+    }
+    else if (value & xrpl_1.AccountSetTfFlags.tfAllowXRP) {
+        flags.disallowXRP = false;
+    }
+    return flags;
+}
+exports.default = parseTxAccountSetFlags;

package/lib/src/parse/ledger/tx-amm-clawback-flags.d.ts

@@ -0,0 +1,6 @@
+import { AMMClawbackFlagsKeysInterface } from "../../types/amm";
+declare function parseTxAmmClawbackFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): AMMClawbackFlagsKeysInterface;
+export default parseTxAmmClawbackFlags;

package/lib/src/parse/ledger/tx-amm-clawback-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const amm_1 = require("../../types/amm");
+const flags_1 = require("./flags");
+function parseTxAmmClawbackFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, amm_1.getAMMClawbackFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxAmmClawbackFlags;

package/lib/src/parse/ledger/tx-amm-deposit-flags.d.ts

@@ -0,0 +1,6 @@
+import { AMMDepositFlagsKeysInterface } from "../../types/amm";
+declare function parseTxAmmDepositFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): AMMDepositFlagsKeysInterface;
+export default parseTxAmmDepositFlags;

package/lib/src/parse/ledger/tx-amm-deposit-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const amm_1 = require("../../types/amm");
+const flags_1 = require("./flags");
+function parseTxAmmDepositFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, amm_1.getAMMDepositFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxAmmDepositFlags;

package/lib/src/parse/ledger/tx-amm-withdraw-flags.d.ts

@@ -0,0 +1,6 @@
+import { AMMDepositFlagsKeysInterface } from "../../types/amm";
+declare function parseTxAmmWithdrawFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): AMMDepositFlagsKeysInterface;
+export default parseTxAmmWithdrawFlags;

package/lib/src/parse/ledger/tx-amm-withdraw-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const amm_1 = require("../../types/amm");
+const flags_1 = require("./flags");
+function parseTxAmmWithdrawFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, amm_1.getAMMWithdrawFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxAmmWithdrawFlags;

package/lib/src/parse/ledger/tx-batch-flags.d.ts

@@ -0,0 +1,6 @@
+import { BatchFlagsKeysInterface } from "../../types/batch";
+declare function parseTxBatchFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): BatchFlagsKeysInterface;
+export default parseTxBatchFlags;

package/lib/src/parse/ledger/tx-batch-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const batch_1 = require("../../types/batch");
+const flags_1 = require("./flags");
+function parseTxBatchFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, batch_1.getBatchFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxBatchFlags;

package/lib/src/parse/ledger/tx-cron-set-flags.d.ts

@@ -0,0 +1,6 @@
+import { CronSetFlagsKeysInterface } from "../../types/cron";
+declare function parseTxCronSetFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): CronSetFlagsKeysInterface;
+export default parseTxCronSetFlags;

package/lib/src/parse/ledger/tx-cron-set-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cron_1 = require("../../types/cron");
+const flags_1 = require("./flags");
+function parseTxCronSetFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, cron_1.CronSetFlagsKeys, options);
+}
+exports.default = parseTxCronSetFlags;

package/lib/src/parse/ledger/tx-global-flags.d.ts

@@ -0,0 +1,5 @@
+import { TxGlobalFlagsKeysInterface } from "../../types/global";
+export declare function parseTxGlobalFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): TxGlobalFlagsKeysInterface;

package/lib/src/parse/ledger/tx-global-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTxGlobalFlags = parseTxGlobalFlags;
+const global_1 = require("../../types/global");
+const flags_1 = require("./flags");
+function parseTxGlobalFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, global_1.getTxGlobalFlagsKeys)(options.nativeCurrency), options);
+}

package/lib/src/parse/ledger/tx-mptoken-authorize-flags.d.ts

@@ -0,0 +1,6 @@
+import { MPTokenAuthorizeFlagsKeysInterface } from "../../types/mptokens";
+declare function parseTxMPTokenAuthorizeFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): MPTokenAuthorizeFlagsKeysInterface;
+export default parseTxMPTokenAuthorizeFlags;

package/lib/src/parse/ledger/tx-mptoken-authorize-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mptokens_1 = require("../../types/mptokens");
+const flags_1 = require("./flags");
+function parseTxMPTokenAuthorizeFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, mptokens_1.getMPTokenAuthorizeFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxMPTokenAuthorizeFlags;

package/lib/src/parse/ledger/tx-mptoken-issuance-create-flags.d.ts

@@ -0,0 +1,6 @@
+import { MPTokenIssuanceCreateFlagsKeysInterface } from "../../types/mptokens";
+declare function parseTxMPTokenIssuanceCreateFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): MPTokenIssuanceCreateFlagsKeysInterface;
+export default parseTxMPTokenIssuanceCreateFlags;

package/lib/src/parse/ledger/tx-mptoken-issuance-create-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mptokens_1 = require("../../types/mptokens");
+const flags_1 = require("./flags");
+function parseTxMPTokenIssuanceCreateFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, mptokens_1.getMPTokenIssuanceCreateFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxMPTokenIssuanceCreateFlags;

package/lib/src/parse/ledger/tx-mptoken-issuance-set-flags.d.ts

@@ -0,0 +1,6 @@
+import { MPTokenIssuanceSetFlagsKeysInterface } from "../../types/mptokens";
+declare function parseTxMPTokenIssuanceSetFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): MPTokenIssuanceSetFlagsKeysInterface;
+export default parseTxMPTokenIssuanceSetFlags;

package/lib/src/parse/ledger/tx-mptoken-issuance-set-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mptokens_1 = require("../../types/mptokens");
+const flags_1 = require("./flags");
+function parseTxMPTokenIssuanceSetFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, mptokens_1.getMPTokenIssuanceSetFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxMPTokenIssuanceSetFlags;

package/lib/src/parse/ledger/tx-nftoken-mint-flags.d.ts

@@ -0,0 +1,6 @@
+import { NFTokenFlagsKeysInterface } from "../../types/nftokens";
+declare function parseTxNFTokenMintFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): NFTokenFlagsKeysInterface;
+export default parseTxNFTokenMintFlags;

package/lib/src/parse/ledger/tx-nftoken-mint-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nftokens_1 = require("../../types/nftokens");
+const flags_1 = require("./flags");
+function parseTxNFTokenMintFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, nftokens_1.getNFTokenMintFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxNFTokenMintFlags;

package/lib/src/parse/ledger/tx-nftoken-offer-create-flags.d.ts

@@ -0,0 +1,6 @@
+import { NFTokenOfferFlagsKeysInterface } from "../../types/nftokens";
+declare function parseTxNFTOfferCreateFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): NFTokenOfferFlagsKeysInterface;
+export default parseTxNFTOfferCreateFlags;

package/lib/src/parse/ledger/tx-nftoken-offer-create-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nftokens_1 = require("../../types/nftokens");
+const flags_1 = require("./flags");
+function parseTxNFTOfferCreateFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, nftokens_1.getNFTokenOfferCreateFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxNFTOfferCreateFlags;

package/lib/src/parse/ledger/tx-offer-create-flags.d.ts

@@ -0,0 +1,6 @@
+import { OfferCreateFlagsKeysInterface } from "../../types/offers";
+declare function parseTxOfferCreateFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): OfferCreateFlagsKeysInterface;
+export default parseTxOfferCreateFlags;

package/lib/src/parse/ledger/tx-offer-create-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const offers_1 = require("../../types/offers");
+const flags_1 = require("./flags");
+function parseTxOfferCreateFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, offers_1.getOfferCreateFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxOfferCreateFlags;

package/lib/src/parse/ledger/tx-payment-flags.d.ts

@@ -0,0 +1,6 @@
+import { PaymentKeysInterface } from "../../types/payments";
+declare function parseTxPaymentFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): PaymentKeysInterface;
+export default parseTxPaymentFlags;

package/lib/src/parse/ledger/tx-payment-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const payments_1 = require("../../types/payments");
+const flags_1 = require("./flags");
+function parseTxPaymentFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, payments_1.getPaymentFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxPaymentFlags;

package/lib/src/parse/ledger/tx-trust-set-flags.d.ts

@@ -0,0 +1,6 @@
+import { TrustSetFlagsKeysInterface } from "../../types/trustlines";
+declare function parseTxTrustSetFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): TrustSetFlagsKeysInterface;
+export default parseTxTrustSetFlags;

package/lib/src/parse/ledger/tx-trust-set-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const trustlines_1 = require("../../types/trustlines");
+const flags_1 = require("./flags");
+function parseTxTrustSetFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, trustlines_1.getTrustSetFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxTrustSetFlags;

package/lib/src/parse/ledger/tx-uritoken-mint-flags.d.ts

@@ -0,0 +1,6 @@
+import { URITokenFlagsKeysInterface } from "../../types/uritokens";
+declare function parseTxURITokenMintFlags(value: number, options?: {
+    excludeFalse?: boolean;
+    nativeCurrency?: string;
+}): URITokenFlagsKeysInterface;
+export default parseTxURITokenMintFlags;

package/lib/src/parse/ledger/tx-uritoken-mint-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uritokens_1 = require("../../types/uritokens");
+const flags_1 = require("./flags");
+function parseTxURITokenMintFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, (0, uritokens_1.getURITokenMintFlagsKeys)(options.nativeCurrency), options);
+}
+exports.default = parseTxURITokenMintFlags;

package/lib/src/parse/ledger/uritoken-flags.d.ts

@@ -0,0 +1,5 @@
+import { URITokenFlagsKeysInterface } from "../../types/uritokens";
+declare function parseURITokenFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): URITokenFlagsKeysInterface;
+export default parseURITokenFlags;

package/lib/src/parse/ledger/uritoken-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uritokens_1 = require("../../types/uritokens");
+const flags_1 = require("./flags");
+function parseURITokenFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, uritokens_1.URITokenFlagsKeys, options);
+}
+exports.default = parseURITokenFlags;

package/lib/src/parse/mptoken_normalize.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeMPTokensPreviousFields(meta: any, tx: any): void;
+export declare function normalizeMPTokensPreviousFieldsEscrowCreate(meta: any): void;
+export declare function normalizeMPTokensPreviousFieldsEscrowFinish(meta: any): void;
+export declare function normalizeMPTokensPreviousFieldsEscrowCancel(meta: any): void;
+export declare function normalizeMPTokensPreviousFieldsTransfer(meta: any, tx: any): void;