@bithomp/xrpl-api 3.7.31 → 3.7.38

package/lib/src/models/account_object.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountObjectsToAccountLines = accountObjectsToAccountLines;
+exports.accountObjectsToNFTOffers = accountObjectsToNFTOffers;
+exports.accountObjectsToURITokens = accountObjectsToURITokens;
+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) => {
+        if (node.LedgerEntryType !== "RippleState") {
+            return false;
+        }
+        if (node.HighLimit.issuer === account) {
+            if (node.Flags & RippleStateFlags.lsfHighReserve) {
+                if (isPositiveBalance(node.Balance.value)) {
+                    return false;
+                }
+                return true;
+            }
+            if (isNegativeBalance(node.Balance.value)) {
+                return true;
+            }
+        }
+        else {
+            if (node.Flags & RippleStateFlags.lsfLowReserve) {
+                if (isNegativeBalance(node.Balance.value)) {
+                    return false;
+                }
+                return true;
+            }
+            if (isPositiveBalance(node.Balance.value)) {
+                return true;
+            }
+        }
+        return false;
+    });
+    const accountLinesFormatted = notInDefaultState.map((node) => RippleStateToTrustLine(node, account));
+    return accountLinesFormatted;
+}
+function isPositiveBalance(balance) {
+    return balance !== "0" && balance[0] !== "-";
+}
+function isNegativeBalance(balance) {
+    return balance !== "0" && balance[0] === "-";
+}
+const RippleStateToTrustLine = (ledgerEntry, account) => {
+    const viewLowest = ledgerEntry.LowLimit.issuer === account;
+    const flags = ledgerEntry.Flags;
+    const self = viewLowest ? ledgerEntry.LowLimit : ledgerEntry.HighLimit;
+    const counterparty = viewLowest ? ledgerEntry.HighLimit : ledgerEntry.LowLimit;
+    const { lsfLowNoRipple, lsfHighNoRipple, lsfLowAuth, lsfHighAuth } = RippleStateFlags;
+    const no_ripple = (flags & (viewLowest ? lsfLowNoRipple : lsfHighNoRipple)) !== 0;
+    const no_ripple_peer = (flags & (viewLowest ? lsfHighNoRipple : lsfLowNoRipple)) !== 0;
+    const authorized = (flags & (viewLowest ? lsfLowAuth : lsfHighAuth)) !== 0;
+    const peer_authorized = (flags & (viewLowest ? lsfHighAuth : lsfLowAuth)) !== 0;
+    const balance = ledgerEntry.HighLimit.issuer === account && ledgerEntry.Balance.value.startsWith("-")
+        ? ledgerEntry.Balance.value.slice(1)
+        : ledgerEntry.Balance.value;
+    let lockedBalance = ledgerEntry.LockedBalance?.value;
+    if (lockedBalance && lockedBalance.startsWith("-")) {
+        lockedBalance = lockedBalance.slice(1);
+    }
+    let lockCount = undefined;
+    if (lockedBalance) {
+        lockCount = ledgerEntry.LockCount;
+    }
+    return (0, common_1.removeUndefined)({
+        account: counterparty.issuer,
+        balance,
+        currency: self.currency,
+        limit: self.value,
+        limit_peer: counterparty.value,
+        lock_count: lockCount,
+        locked_balance: lockedBalance,
+        no_ripple,
+        no_ripple_peer,
+        authorized,
+        peer_authorized,
+    });
+};
+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;
+}
+function accountObjectsToURITokens(accountObjects) {
+    const uriTokenObjects = accountObjects.filter((obj) => {
+        return obj.LedgerEntryType === "URIToken";
+    });
+    const uritokens = uriTokenObjects.map((obj) => {
+        return (0, common_1.removeUndefined)({
+            flags: obj.Flags,
+            index: obj.index,
+            owner: obj.Owner,
+            issuer: obj.Issuer,
+            uri: obj.URI,
+            digest: obj.Digest,
+            amount: obj.Amount,
+            destination: obj.Destination,
+            ledger_index: obj.PreviousTxnLgrSeq,
+            transaction_hash: obj.PreviousTxnID,
+        });
+    });
+    return uritokens;
+}

package/lib/src/models/account_offers.d.ts

@@ -0,0 +1,9 @@
+import { AccountOffer } from "xrpl";
+export interface AccountOffers {
+    account: string;
+    offers?: AccountOffer[];
+    ledger_current_index?: number;
+    ledger_index?: number;
+    ledger_hash?: string;
+    marker?: unknown;
+}

package/lib/src/models/account_offers.js

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

package/lib/src/models/account_uritokens.d.ts

@@ -0,0 +1,11 @@
+import { Amount } from "../types";
+export interface URITokenInterface {
+    Digest?: string;
+    Flags: number;
+    Issuer: string;
+    Owner: string;
+    URITokenID: string;
+    URI: string;
+    Amount?: Amount;
+    Destination?: string;
+}

package/lib/src/models/account_uritokens.js

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

package/lib/src/models/amm_info.d.ts

@@ -0,0 +1 @@
+export declare const AMM_LP_TOKEN_REGEX: RegExp;

package/lib/src/models/amm_info.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AMM_LP_TOKEN_REGEX = void 0;
+exports.AMM_LP_TOKEN_REGEX = /^03[A-F0-9]{38}$/;

package/lib/src/models/base_model.d.ts

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

package/lib/src/models/base_model.js

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

package/lib/src/models/book_offers.d.ts

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

package/lib/src/models/book_offers.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBidsAndAsks = formatBidsAndAsks;
+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.issuer === b.issuer;
+}
+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) ?? 0;
+    })
+        .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 };
+}

package/lib/src/models/gateway_balances.d.ts

@@ -0,0 +1,19 @@
+export interface GatewayBalance {
+    currency: string;
+    value: string;
+}
+export interface GatewayBalances {
+    account: string;
+    obligations?: {
+        [currency: string]: string;
+    };
+    balances?: {
+        [address: string]: GatewayBalance[];
+    };
+    assets?: {
+        [address: string]: GatewayBalance[];
+    };
+    ledger_hash?: string;
+    ledger_current_index?: number;
+    ledger_index?: number;
+}

package/lib/src/models/gateway_balances.js

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

package/lib/src/models/index.d.ts

@@ -0,0 +1,38 @@
+export * from "./account_info";
+export * from "./account_nfts";
+export * from "./account_object";
+export * from "./amm_info";
+export * from "./ledger";
+export * from "./manifest";
+export * from "./transaction";
+export * from "./account_lines";
+export * from "./account_namespace";
+export * from "./account_uritokens";
+export * from "./vl";
+export * from "./server_definitions";
+export * from "./mptoken";
+export { parseAffectedObjects } from "../parse/outcome/affected_objects";
+export { parseNFTokenChanges } from "../parse/outcome/nftoken_changes";
+export { parseNFTokenOfferChanges } from "../parse/outcome/nftoken_offer_changes";
+export { parseURITokenChanges } from "../parse/outcome/uritoken_changes";
+export { parseURITokenSellOfferChanges } from "../parse/outcome/uritoken_sell_offer_changes";
+export { parseBalanceChanges, parseFinalBalances } 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";
+export { parseMPTokenIssuanceChanges } from "../parse/outcome/mptoken_issuance_changes";
+export { parseMPTokenChanges } from "../parse/outcome/mptoken_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";
+import parseURITokenFlags from "../parse/ledger/uritoken-flags";
+import parseTrustlineFlags from "../parse/ledger/trustline-flags";
+import parseOfferFlags from "../parse/ledger/offer-flags";
+import parseCredentialFlags from "../parse/ledger/credential-flags";
+import parseMPTokenIssuanceFlags from "../parse/ledger/mptoken-issuance-flags";
+import parseMPTokenFlags from "../parse/ledger/mptoken-flags";
+export { parseNFTokenMint, parseNFTokenBurn, parseNFTokenFlags, parseNFTOfferFlags, parseNFTokenAcceptOffer, parseNFTokenCancelOffer, parseNFTokenCreateOffer, parseURITokenFlags, parseTrustlineFlags, parseOfferFlags, parseCredentialFlags, parseMPTokenIssuanceFlags, parseMPTokenFlags, };

package/lib/src/models/index.js

@@ -0,0 +1,82 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMPTokenFlags = exports.parseMPTokenIssuanceFlags = exports.parseCredentialFlags = exports.parseOfferFlags = exports.parseTrustlineFlags = exports.parseURITokenFlags = exports.parseNFTokenCreateOffer = exports.parseNFTokenCancelOffer = exports.parseNFTokenAcceptOffer = exports.parseNFTOfferFlags = exports.parseNFTokenFlags = exports.parseNFTokenBurn = exports.parseNFTokenMint = exports.parseMPTokenChanges = exports.parseMPTokenIssuanceChanges = exports.parseOrderbookChanges = exports.parseChannelChanges = exports.parseLockedBalanceChanges = exports.parseFinalBalances = exports.parseBalanceChanges = exports.parseURITokenSellOfferChanges = exports.parseURITokenChanges = exports.parseNFTokenOfferChanges = exports.parseNFTokenChanges = exports.parseAffectedObjects = void 0;
+__exportStar(require("./account_info"), exports);
+__exportStar(require("./account_nfts"), exports);
+__exportStar(require("./account_object"), exports);
+__exportStar(require("./amm_info"), exports);
+__exportStar(require("./ledger"), exports);
+__exportStar(require("./manifest"), exports);
+__exportStar(require("./transaction"), exports);
+__exportStar(require("./account_lines"), exports);
+__exportStar(require("./account_namespace"), exports);
+__exportStar(require("./account_uritokens"), exports);
+__exportStar(require("./vl"), exports);
+__exportStar(require("./server_definitions"), exports);
+__exportStar(require("./mptoken"), exports);
+var affected_objects_1 = require("../parse/outcome/affected_objects");
+Object.defineProperty(exports, "parseAffectedObjects", { enumerable: true, get: function () { return affected_objects_1.parseAffectedObjects; } });
+var nftoken_changes_1 = require("../parse/outcome/nftoken_changes");
+Object.defineProperty(exports, "parseNFTokenChanges", { enumerable: true, get: function () { return nftoken_changes_1.parseNFTokenChanges; } });
+var nftoken_offer_changes_1 = require("../parse/outcome/nftoken_offer_changes");
+Object.defineProperty(exports, "parseNFTokenOfferChanges", { enumerable: true, get: function () { return nftoken_offer_changes_1.parseNFTokenOfferChanges; } });
+var uritoken_changes_1 = require("../parse/outcome/uritoken_changes");
+Object.defineProperty(exports, "parseURITokenChanges", { enumerable: true, get: function () { return uritoken_changes_1.parseURITokenChanges; } });
+var uritoken_sell_offer_changes_1 = require("../parse/outcome/uritoken_sell_offer_changes");
+Object.defineProperty(exports, "parseURITokenSellOfferChanges", { enumerable: true, get: function () { return uritoken_sell_offer_changes_1.parseURITokenSellOfferChanges; } });
+var balance_changes_1 = require("../parse/outcome/balance_changes");
+Object.defineProperty(exports, "parseBalanceChanges", { enumerable: true, get: function () { return balance_changes_1.parseBalanceChanges; } });
+Object.defineProperty(exports, "parseFinalBalances", { enumerable: true, get: function () { return balance_changes_1.parseFinalBalances; } });
+var locked_balance_changes_1 = require("../parse/outcome/locked_balance_changes");
+Object.defineProperty(exports, "parseLockedBalanceChanges", { enumerable: true, get: function () { return locked_balance_changes_1.parseLockedBalanceChanges; } });
+var channel_changes_1 = require("../parse/outcome/channel_changes");
+Object.defineProperty(exports, "parseChannelChanges", { enumerable: true, get: function () { return channel_changes_1.parseChannelChanges; } });
+var orderbook_changes_1 = require("../parse/outcome/orderbook_changes");
+Object.defineProperty(exports, "parseOrderbookChanges", { enumerable: true, get: function () { return orderbook_changes_1.parseOrderbookChanges; } });
+var mptoken_issuance_changes_1 = require("../parse/outcome/mptoken_issuance_changes");
+Object.defineProperty(exports, "parseMPTokenIssuanceChanges", { enumerable: true, get: function () { return mptoken_issuance_changes_1.parseMPTokenIssuanceChanges; } });
+var mptoken_changes_1 = require("../parse/outcome/mptoken_changes");
+Object.defineProperty(exports, "parseMPTokenChanges", { enumerable: true, get: function () { return mptoken_changes_1.parseMPTokenChanges; } });
+const nftoken_burn_1 = __importDefault(require("../parse/specification/nftoken-burn"));
+exports.parseNFTokenBurn = nftoken_burn_1.default;
+const nftoken_mint_1 = __importDefault(require("../parse/specification/nftoken-mint"));
+exports.parseNFTokenMint = nftoken_mint_1.default;
+const nftoken_flags_1 = __importDefault(require("../parse/ledger/nftoken-flags"));
+exports.parseNFTokenFlags = nftoken_flags_1.default;
+const nftoken_offer_flags_1 = __importDefault(require("../parse/ledger/nftoken-offer-flags"));
+exports.parseNFTOfferFlags = nftoken_offer_flags_1.default;
+const nftoken_accept_offer_1 = __importDefault(require("../parse/specification/nftoken-accept-offer"));
+exports.parseNFTokenAcceptOffer = nftoken_accept_offer_1.default;
+const nftoken_cancel_offer_1 = __importDefault(require("../parse/specification/nftoken-cancel-offer"));
+exports.parseNFTokenCancelOffer = nftoken_cancel_offer_1.default;
+const nftoken_create_offer_1 = __importDefault(require("../parse/specification/nftoken-create-offer"));
+exports.parseNFTokenCreateOffer = nftoken_create_offer_1.default;
+const uritoken_flags_1 = __importDefault(require("../parse/ledger/uritoken-flags"));
+exports.parseURITokenFlags = uritoken_flags_1.default;
+const trustline_flags_1 = __importDefault(require("../parse/ledger/trustline-flags"));
+exports.parseTrustlineFlags = trustline_flags_1.default;
+const offer_flags_1 = __importDefault(require("../parse/ledger/offer-flags"));
+exports.parseOfferFlags = offer_flags_1.default;
+const credential_flags_1 = __importDefault(require("../parse/ledger/credential-flags"));
+exports.parseCredentialFlags = credential_flags_1.default;
+const mptoken_issuance_flags_1 = __importDefault(require("../parse/ledger/mptoken-issuance-flags"));
+exports.parseMPTokenIssuanceFlags = mptoken_issuance_flags_1.default;
+const mptoken_flags_1 = __importDefault(require("../parse/ledger/mptoken-flags"));
+exports.parseMPTokenFlags = mptoken_flags_1.default;

package/lib/src/models/ledger.d.ts

@@ -0,0 +1,7 @@
+export declare const RIPPLE_UNIX_DIFF = 946684800;
+export type LedgerIndex = number | ("validated" | "closed" | "current");
+export type StreamType = "consensus" | "ledger" | "manifests" | "peer_status" | "transactions" | "transactions_proposed" | "server" | "validations";
+export declare function unixTimeToLedgerTime(time: number): number;
+export declare function ledgerTimeToUnixTime(ledgerTime: number): number;
+export declare function ledgerTimeToTimestamp(ledgerTime: number): number;
+export declare function ledgerTimeToISO8601(ledgerTime: number): string;

package/lib/src/models/ledger.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RIPPLE_UNIX_DIFF = void 0;
+exports.unixTimeToLedgerTime = unixTimeToLedgerTime;
+exports.ledgerTimeToUnixTime = ledgerTimeToUnixTime;
+exports.ledgerTimeToTimestamp = ledgerTimeToTimestamp;
+exports.ledgerTimeToISO8601 = ledgerTimeToISO8601;
+exports.RIPPLE_UNIX_DIFF = 946684800;
+function unixTimeToLedgerTime(time) {
+    return time - exports.RIPPLE_UNIX_DIFF;
+}
+function ledgerTimeToUnixTime(ledgerTime) {
+    return ledgerTime + exports.RIPPLE_UNIX_DIFF;
+}
+function ledgerTimeToTimestamp(ledgerTime) {
+    return ledgerTimeToUnixTime(ledgerTime) * 1000;
+}
+function ledgerTimeToISO8601(ledgerTime) {
+    return new Date(ledgerTimeToTimestamp(ledgerTime)).toISOString();
+}

package/lib/src/models/manifest.d.ts

@@ -0,0 +1,25 @@
+export interface ManifestInterface {
+    Sequence?: number;
+    PublicKey?: string;
+    publicKey?: string;
+    address?: string;
+    SigningPubKey?: string;
+    signingPubKey?: string;
+    Signature?: string;
+    Domain?: string;
+    domain?: string;
+    MasterSignature?: string;
+    verifyFields?: Buffer;
+    error?: string;
+}
+export declare function decodeManifest(manifest: string): ManifestInterface;
+export declare function parseManifest(manifest: string): ManifestInterface;
+export interface GenerateManifestInterface {
+    Sequence: number;
+    PublicKey: string;
+    SigningPubKey: string;
+    Domain?: string;
+    SigningPrivateKey: string;
+    MasterPrivateKey: string;
+}
+export declare function generateManifest(manifest: GenerateManifestInterface): string;

package/lib/src/models/manifest.js

@@ -0,0 +1,199 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeManifest = decodeManifest;
+exports.parseManifest = parseManifest;
+exports.generateManifest = generateManifest;
+const ripple_binary_codec_1 = require("ripple-binary-codec");
+const ripple_address_codec_1 = require("ripple-address-codec");
+const Validator = __importStar(require("../validator"));
+function decodeManifest(manifest) {
+    const manifestHex = Buffer.from(manifest, "base64").toString("hex").toUpperCase();
+    const manifestDecoded = (0, ripple_binary_codec_1.decode)(manifestHex);
+    if (!manifestDecoded) {
+        return manifestDecoded;
+    }
+    const { PublicKey, SigningPubKey, Domain } = manifestDecoded;
+    if (typeof PublicKey === "string") {
+        const publicKeyBuffer = Buffer.from(PublicKey, "hex");
+        manifestDecoded.publicKey = (0, ripple_address_codec_1.encodeNodePublic)(publicKeyBuffer);
+        manifestDecoded.address = Validator.classicAddressFromValidatorPK(publicKeyBuffer);
+    }
+    if (typeof SigningPubKey === "string") {
+        const signingKeyBuffer = Buffer.from(SigningPubKey, "hex");
+        manifestDecoded.signingPubKey = (0, ripple_address_codec_1.encodeNodePublic)(signingKeyBuffer);
+    }
+    if (typeof Domain === "string") {
+        manifestDecoded.domain = Buffer.from(Domain, "hex").toString("utf8");
+    }
+    return manifestDecoded;
+}
+function parseManifest(manifest) {
+    const buf = Buffer.from(manifest, "base64");
+    const decoded = {};
+    let cur = 0;
+    const verifyFields = [Buffer.from("MAN\x00", "utf-8")];
+    let lastSigning = 0;
+    if (buf[cur] === 0x24) {
+        cur++;
+        decoded.Sequence = (buf[cur] << 24) + (buf[cur + 1] << 16) + (buf[cur + 2] << 8) + buf[cur + 3];
+        cur += 4;
+        verifyFields.push(buf.slice(lastSigning, cur));
+        lastSigning = cur;
+    }
+    if (buf[cur++] !== 0x71) {
+        decoded.error = "Missing Public Key";
+        return decoded;
+    }
+    if (buf[cur++] !== 33) {
+        decoded.error = "Missing Public Key size";
+        return decoded;
+    }
+    decoded.PublicKey = buf
+        .slice(cur, cur + 33)
+        .toString("hex")
+        .toUpperCase();
+    decoded.publicKey = (0, ripple_address_codec_1.encodeNodePublic)(buf.slice(cur, cur + 33));
+    decoded.address = Validator.classicAddressFromValidatorPK(buf.slice(cur, cur + 33));
+    cur += 33;
+    verifyFields.push(buf.slice(lastSigning, cur));
+    lastSigning = cur;
+    if (buf[cur++] === 0x73) {
+        if (buf[cur++] !== 33) {
+            decoded.error = "Missing Signing Public Key size";
+            return decoded;
+        }
+        decoded.SigningPubKey = buf
+            .slice(cur, cur + 33)
+            .toString("hex")
+            .toUpperCase();
+        decoded.signingPubKey = (0, ripple_address_codec_1.encodeNodePublic)(buf.slice(cur, cur + 33));
+        cur += 33;
+        verifyFields.push(buf.slice(lastSigning, cur));
+        lastSigning = cur;
+    }
+    if (buf[cur++] === 0x76) {
+        const signatureSize = buf[cur++];
+        decoded.Signature = buf
+            .slice(cur, cur + signatureSize)
+            .toString("hex")
+            .toUpperCase();
+        cur += signatureSize;
+        lastSigning = cur;
+    }
+    if (buf[cur] === 0x77) {
+        cur++;
+        const domainSize = buf[cur++];
+        decoded.Domain = buf
+            .slice(cur, cur + domainSize)
+            .toString("hex")
+            .toUpperCase();
+        decoded.domain = buf.slice(cur, cur + domainSize).toString("utf-8");
+        cur += domainSize;
+        verifyFields.push(buf.slice(lastSigning, cur));
+        lastSigning = cur;
+    }
+    if (buf[cur++] !== 0x70) {
+        decoded.error = "Missing Master Signature";
+        return decoded;
+    }
+    if (buf[cur++] !== 0x12) {
+        decoded.error = "Missing Master Signature follow byte";
+        return decoded;
+    }
+    const masterSize = buf[cur++];
+    decoded.MasterSignature = buf
+        .slice(cur, cur + masterSize)
+        .toString("hex")
+        .toUpperCase();
+    cur += masterSize;
+    lastSigning = cur;
+    if (cur !== buf.length) {
+        decoded.error = "Extra bytes at end of manifest";
+        return decoded;
+    }
+    const verify = Buffer.concat(verifyFields);
+    if (decoded.SigningPubKey && decoded.Signature) {
+        if (!Validator.verify(verify, decoded.Signature, decoded.SigningPubKey)) {
+            decoded.error = "Ephemeral signature does not match";
+            return decoded;
+        }
+    }
+    if (!Validator.verify(verify, decoded.MasterSignature, decoded.PublicKey)) {
+        decoded.error = "Master signature does not match";
+        return decoded;
+    }
+    if (decoded.SigningPubKey && decoded.PublicKey && decoded.SigningPubKey === decoded.PublicKey) {
+        decoded.error = "Master and ephemeral public keys must be different";
+        return decoded;
+    }
+    return decoded;
+}
+function generateManifest(manifest) {
+    const verifyFields = [Buffer.from("MAN\x00", "utf-8")];
+    const sequenceBuffer = Buffer.alloc(5);
+    sequenceBuffer.writeUInt8(0x24);
+    sequenceBuffer.writeUInt32BE(manifest.Sequence, 1);
+    verifyFields.push(sequenceBuffer);
+    const publicKeyBuffer = Buffer.alloc(35);
+    publicKeyBuffer.writeUInt8(0x71);
+    publicKeyBuffer.writeUInt8(manifest.PublicKey.length / 2, 1);
+    publicKeyBuffer.write(manifest.PublicKey, 2, "hex");
+    verifyFields.push(publicKeyBuffer);
+    const signingPubKeyBuffer = Buffer.alloc(35);
+    signingPubKeyBuffer.writeUInt8(0x73);
+    signingPubKeyBuffer.writeUInt8(manifest.SigningPubKey.length / 2, 1);
+    signingPubKeyBuffer.write(manifest.SigningPubKey, 2, "hex");
+    verifyFields.push(signingPubKeyBuffer);
+    if (manifest.Domain) {
+        const domainBuffer = Buffer.alloc(2 + manifest.Domain.length / 2);
+        domainBuffer.writeUInt8(0x77);
+        domainBuffer.writeUInt8(manifest.Domain.length / 2, 1);
+        domainBuffer.write(manifest.Domain, 2, "hex");
+        verifyFields.push(domainBuffer);
+    }
+    const verifyData = Buffer.concat(verifyFields);
+    const ephemeralSignature = Validator.sign(verifyData, manifest.SigningPrivateKey);
+    const masterSignature = Validator.sign(verifyData, manifest.MasterPrivateKey);
+    const manifestBuffer = Buffer.from((0, ripple_binary_codec_1.encode)({
+        Sequence: manifest.Sequence,
+        PublicKey: manifest.PublicKey,
+        SigningPubKey: manifest.SigningPubKey,
+        Signature: ephemeralSignature,
+        Domain: manifest.Domain,
+        MasterSignature: masterSignature,
+    }), "hex");
+    return manifestBuffer.toString("base64");
+}

package/lib/src/models/mptoken.d.ts

@@ -0,0 +1,7 @@
+export interface MPTokenInterface {
+    MPTokenIssuanceID: string;
+    Issuer: string;
+    Sequence: number;
+}
+export declare function buildMPTokenIssuanceID(sequence: number, issuer: string): string;
+export declare function parseMPTokenIssuanceID(mptIssuanceID: string): MPTokenInterface | null;