@bithomp/xrpl-api 2.3.6

package/lib/models/trustline.js

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

package/lib/models/utils.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare function parseUint32(buf: Buffer, cur: number): string;
+export declare function parseUint64(buf: Buffer, cur: number): string;

package/lib/models/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUint64 = exports.parseUint32 = void 0;
+function parseUint32(buf, cur) {
+    return ((BigInt(buf[cur]) << 24n) + (BigInt(buf[cur + 1]) << 16n) + (BigInt(buf[cur + 2]) << 8n) + BigInt(buf[cur + 3]) + "");
+}
+exports.parseUint32 = parseUint32;
+function parseUint64(buf, cur) {
+    return ((BigInt(buf[cur]) << 56n) +
+        (BigInt(buf[cur + 1]) << 48n) +
+        (BigInt(buf[cur + 2]) << 40n) +
+        (BigInt(buf[cur + 3]) << 32n) +
+        (BigInt(buf[cur + 4]) << 24n) +
+        (BigInt(buf[cur + 5]) << 16n) +
+        (BigInt(buf[cur + 6]) << 8n) +
+        BigInt(buf[cur + 7]) +
+        "");
+}
+exports.parseUint64 = parseUint64;

package/lib/models/vl.d.ts

@@ -0,0 +1,60 @@
+import { ManifestInterface } from "./manifest";
+export interface VLInterface {
+    version?: number;
+    public_key?: string;
+    manifest?: string;
+    blob?: string;
+    signature?: string;
+}
+export interface ParsedVLInterface {
+    version?: number;
+    PublicKey?: string;
+    manifest?: string;
+    decodedManifest?: ManifestInterface;
+    blob?: ParsedVLBlobInterface;
+    signature?: string;
+    error?: string;
+}
+export interface ValidatorInterface {
+    validation_public_key?: string;
+    manifest?: string;
+}
+export interface ParsedValidatorInterface {
+    PublicKey?: string;
+    manifest?: string;
+    decodedManifest?: ManifestInterface;
+}
+export interface VLBlobInterface {
+    sequence?: number;
+    expiration?: number;
+    validators?: ValidatorInterface[];
+}
+export interface ParsedVLBlobInterface {
+    sequence?: number;
+    expiration?: number;
+    validators?: ParsedValidatorInterface[];
+}
+export interface VLDataInterface {
+    Flags?: number;
+    LedgerSequence?: number;
+    CloseTime?: number;
+    SigningTime?: number;
+    LoadFee?: string;
+    ReserveBase?: string;
+    ReserveIncrement?: string;
+    BaseFee?: string;
+    Cookie?: string;
+    ServerVersion?: string;
+    LedgerHash?: string;
+    ConsensusHash?: string;
+    ValidatedHash?: string;
+    SigningPubKey?: string;
+    Signature?: string;
+    Amendments?: string[];
+    error?: string;
+    _verified?: boolean;
+}
+export declare function parseVL(vl: VLInterface): ParsedVLInterface;
+export declare function isValidVL(vl: VLInterface): string | null;
+export declare function encodeVLBlob(vlBlob: VLBlobInterface): string;
+export declare function parseValidationData(data: string, publicKey: string): VLDataInterface;

package/lib/models/vl.js

@@ -0,0 +1,377 @@
+"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.parseValidationData = exports.encodeVLBlob = exports.isValidVL = exports.parseVL = void 0;
+const manifest_1 = require("./manifest");
+const utils_1 = require("./utils");
+const Validator = __importStar(require("../validator"));
+function parseVL(vl) {
+    const decoded = {};
+    decoded.version = vl.version;
+    decoded.PublicKey = vl.public_key;
+    decoded.manifest = vl.manifest;
+    let error = isValidVLFormat(vl);
+    if (error) {
+        decoded.error = error;
+    }
+    decoded.decodedManifest = (0, manifest_1.parseManifest)(vl.manifest);
+    if (!decoded.error && decoded.decodedManifest.error) {
+        decoded.error = decoded.decodedManifest.error;
+    }
+    if (!decoded.error &&
+        decoded.PublicKey !== decoded.decodedManifest.PublicKey &&
+        decoded.PublicKey !== decoded.decodedManifest.SigningPubKey) {
+        decoded.error = "PublicKey does not match manifest";
+    }
+    decoded.signature = vl.signature;
+    if (!decoded.error && !decoded.signature) {
+        decoded.error = "Signature (blob) is missing";
+    }
+    if (decoded.signature && decoded.decodedManifest.SigningPubKey && vl.blob) {
+        if (!decoded.error &&
+            !Validator.verify(Buffer.from(vl.blob, "base64"), decoded.signature, decoded.decodedManifest.SigningPubKey)) {
+            decoded.error = "Signature is not valid";
+        }
+    }
+    const blob = decodeVLBlob(vl.blob);
+    error = isValidVLBlob(blob);
+    if (!decoded.error && error) {
+        decoded.error = error;
+    }
+    decoded.blob = {
+        sequence: blob?.sequence,
+        expiration: blob?.expiration,
+        validators: [],
+    };
+    for (const validator of blob?.validators) {
+        error = isValidVLBlobValidator(validator);
+        if (!decoded.error && error) {
+            decoded.error = error;
+        }
+        const validatorManifest = (0, manifest_1.parseManifest)(validator.manifest);
+        if (!decoded.error && validatorManifest.error) {
+            decoded.error = validatorManifest.error;
+        }
+        if (decoded.blob.validators) {
+            decoded.blob.validators.push({
+                PublicKey: validator.validation_public_key,
+                manifest: validator.manifest,
+                decodedManifest: validatorManifest,
+            });
+        }
+    }
+    return decoded;
+}
+exports.parseVL = parseVL;
+function isValidVL(vl) {
+    let error = isValidVLFormat(vl);
+    if (error) {
+        return error;
+    }
+    const vlManifest = (0, manifest_1.parseManifest)(vl.manifest);
+    if (vlManifest.error) {
+        return vlManifest.error;
+    }
+    const blob = decodeVLBlob(vl.blob);
+    error = isValidVLBlob(blob);
+    if (error) {
+        return error;
+    }
+    for (const validator of blob?.validators) {
+        error = isValidVLBlobValidator(validator);
+        if (error) {
+            return error;
+        }
+    }
+    return error;
+}
+exports.isValidVL = isValidVL;
+function isValidVLFormat(vl) {
+    const { version, public_key, manifest, blob } = vl;
+    let error = null;
+    if (version === undefined) {
+        error = "Version missing from vl";
+    }
+    if (public_key === undefined) {
+        error = "Public key missing from vl";
+    }
+    if (manifest === undefined) {
+        error = "Manifest missing from vl";
+    }
+    if (blob === undefined) {
+        error = "Blob missing from vl";
+    }
+    if (version !== 1) {
+        error = "Version is not supported";
+    }
+    return error;
+}
+function decodeVLBlob(blob) {
+    const decoded = Buffer.from(blob, "base64").toString("ascii");
+    return JSON.parse(decoded);
+}
+function encodeVLBlob(vlBlob) {
+    return Buffer.from(JSON.stringify(vlBlob)).toString("base64");
+}
+exports.encodeVLBlob = encodeVLBlob;
+function isValidVLBlob(blob) {
+    if (blob === null) {
+        return "Blob is not valid";
+    }
+    const { sequence, expiration, validators } = blob;
+    let error = null;
+    if (sequence === undefined) {
+        error = "Sequence missing from blob";
+    }
+    if (expiration === undefined) {
+        error = "Expiration missing from blob";
+    }
+    if (validators === undefined) {
+        error = "Validators missing from blob";
+    }
+    if (validators && validators.length === 0) {
+        error = "Validators is empty";
+    }
+    return error;
+}
+function isValidVLBlobValidator(validator) {
+    const { validation_public_key, manifest } = validator;
+    let error = null;
+    if (validation_public_key === undefined) {
+        error = "Validation public key missing from validator";
+    }
+    if (manifest === undefined) {
+        error = "Manifest missing from validator";
+    }
+    const parsedManifest = (0, manifest_1.parseManifest)(manifest);
+    if (parsedManifest.error) {
+        return parsedManifest.error;
+    }
+    return error;
+}
+function parseValidationData(data, publicKey) {
+    const buf = Buffer.from(data, "hex");
+    const decoded = {};
+    let cur = 0;
+    if (buf[cur++] !== 0x22 || buf.length - cur < 5) {
+        decoded.error = "sfFlags missing or incomplete";
+        return decoded;
+    }
+    decoded.Flags = parseInt((0, utils_1.parseUint32)(buf, cur), 10);
+    cur += 4;
+    if (buf[cur++] !== 0x26 || buf.length - cur < 5) {
+        decoded.error = "sfLedgerSequnece missing or incomplete";
+        return decoded;
+    }
+    decoded.LedgerSequence = parseInt((0, utils_1.parseUint32)(buf, cur), 10);
+    cur += 4;
+    if (buf[cur] === 0x27) {
+        cur++;
+        if (buf.length - cur < 4) {
+            decoded.error = "sfCloseTime missing or incomplete";
+            return decoded;
+        }
+        decoded.CloseTime = parseInt((0, utils_1.parseUint32)(buf, cur), 10);
+        cur += 4;
+    }
+    if (buf[cur++] !== 0x29 || buf.length - cur < 5) {
+        decoded.error = "sfSigningTime missing or incomplete";
+        return decoded;
+    }
+    decoded.SigningTime = parseInt((0, utils_1.parseUint32)(buf, cur), 10);
+    cur += 4;
+    if (buf[cur] === 0x20 && buf.length - cur >= 1 && buf[cur + 1] === 0x18) {
+        cur += 2;
+        if (buf.length - cur < 4) {
+            decoded.error = "sfLoadFee payload missing";
+            return decoded;
+        }
+        decoded.LoadFee = (0, utils_1.parseUint32)(buf, cur);
+        cur += 4;
+    }
+    if (buf[cur] === 0x20 && buf.length - cur >= 1 && buf[cur + 1] === 0x1f) {
+        cur += 2;
+        if (buf.length - cur < 4) {
+            decoded.error = "sfReserveBase payload missing";
+            return decoded;
+        }
+        decoded.ReserveBase = (0, utils_1.parseUint32)(buf, cur);
+        cur += 4;
+    }
+    if (buf[cur] === 0x20 && buf.length - cur >= 1 && buf[cur + 1] === 0x20) {
+        cur += 2;
+        if (buf.length - cur < 4) {
+            decoded.error = "sfReserveIncrement payload missing";
+            return decoded;
+        }
+        decoded.ReserveIncrement = (0, utils_1.parseUint32)(buf, cur);
+        cur += 4;
+    }
+    if (buf[cur] === 0x35) {
+        cur++;
+        if (buf.length - cur < 8) {
+            decoded.error = "sfBaseFee missing or incomplete";
+            return decoded;
+        }
+        decoded.BaseFee = (0, utils_1.parseUint64)(buf, cur);
+        cur += 8;
+    }
+    if (buf[cur] === 0x3a) {
+        cur++;
+        if (buf.length - cur < 8) {
+            decoded.error = "sfCookie missing or incomplete";
+            return decoded;
+        }
+        decoded.Cookie = (0, utils_1.parseUint64)(buf, cur);
+        cur += 8;
+    }
+    if (buf[cur] === 0x3b) {
+        cur++;
+        if (buf.length - cur < 8) {
+            decoded.error = "sfServerVersion missing or incomplete";
+            return decoded;
+        }
+        decoded.ServerVersion = (0, utils_1.parseUint64)(buf, cur);
+        cur += 8;
+    }
+    if (buf[cur++] !== 0x51 || buf.length - cur < 5) {
+        decoded.error = "sfLedgerHash missing or incomplete";
+        return decoded;
+    }
+    decoded.LedgerHash = buf
+        .slice(cur, cur + 32)
+        .toString("hex")
+        .toUpperCase();
+    cur += 32;
+    if (buf[cur] === 0x50 && buf.length - cur >= 1 && buf[cur + 1] === 0x17) {
+        cur += 2;
+        if (buf.length - cur < 32) {
+            decoded.error = "sfConsensusHash payload missing";
+            return decoded;
+        }
+        decoded.ConsensusHash = buf
+            .slice(cur, cur + 32)
+            .toString("hex")
+            .toUpperCase();
+        cur += 32;
+    }
+    if (buf[cur] === 0x50 && buf.length - cur >= 1 && buf[cur + 1] === 0x19) {
+        cur += 2;
+        if (buf.length - cur < 32) {
+            decoded.error = "sfValidatedHash payload missing";
+            return decoded;
+        }
+        decoded.ValidatedHash = buf
+            .slice(cur, cur + 32)
+            .toString("hex")
+            .toUpperCase();
+        cur += 32;
+    }
+    if (buf[cur++] !== 0x73 || buf.length - cur < 2) {
+        decoded.error = "sfSigningPubKey missing or incomplete";
+        return decoded;
+    }
+    const keySize = buf[cur++];
+    if (buf.length - cur < keySize) {
+        decoded.error = "sfSigningPubKey payload missing";
+        return decoded;
+    }
+    decoded.SigningPubKey = buf
+        .slice(cur, cur + keySize)
+        .toString("hex")
+        .toUpperCase();
+    cur += keySize;
+    const sigStart = cur;
+    if (buf[cur++] !== 0x76 || buf.length - cur < 2) {
+        decoded.error = "sfSignature missing or incomplete";
+        return decoded;
+    }
+    const sigSize = buf[cur++];
+    if (buf.length - cur < sigSize) {
+        decoded.error = "sfSignature payload missing";
+        return decoded;
+    }
+    decoded.Signature = buf
+        .slice(cur, cur + sigSize)
+        .toString("hex")
+        .toUpperCase();
+    cur += sigSize;
+    const sigEnd = cur;
+    if (buf.length - cur >= 1 && buf[cur] === 0x03 && buf[cur + 1] === 0x13) {
+        cur += 2;
+        if (buf.length - cur < 1) {
+            decoded.error = "sfAmendments payload missing or incomplete [1]";
+            return decoded;
+        }
+        let len = buf[cur++];
+        if (len <= 192) {
+        }
+        else if (len >= 193 && len <= 240) {
+            if (buf.length - cur < 1) {
+                decoded.error = "sfAmendments payload missing or incomplete [2]";
+                return decoded;
+            }
+            len = 193 + (len - 193) * 256 + buf[cur++];
+        }
+        else if (len >= 241 && len <= 254) {
+            if (buf.length - cur < 2) {
+                decoded.error = "sfAmendments payload missing or incomplete [3]";
+                return decoded;
+            }
+            len = 12481 + (len - 241) * 65536 + buf[cur + 1] * 256 + buf[cur + 2];
+            cur += 2;
+        }
+        if (buf.length - cur < len) {
+            decoded.error = "sfAmendments payload missing or incomplete [3]";
+            return decoded;
+        }
+        decoded.Amendments = [];
+        const amendmentsCurEnd = cur + len;
+        while (cur < amendmentsCurEnd) {
+            decoded.Amendments.push(buf.slice(cur, cur + 32).toString("hex"));
+            cur += 32;
+        }
+    }
+    if (publicKey.toUpperCase() !== decoded.SigningPubKey) {
+        decoded._verified = false;
+        decoded.error = "SigningPubKey did not match or was not present";
+        return decoded;
+    }
+    const verifyFields = Buffer.concat([
+        Buffer.from("VAL\x00", "utf-8"),
+        buf.slice(0, sigStart),
+        buf.slice(sigEnd, buf.length),
+    ]);
+    if (decoded.SigningPubKey && decoded.Signature) {
+        if (!Validator.verify(verifyFields, decoded.Signature, decoded.SigningPubKey)) {
+            decoded._verified = false;
+            decoded.error = "Signature did not match or was not present";
+            return decoded;
+        }
+    }
+    decoded._verified = true;
+    return decoded;
+}
+exports.parseValidationData = parseValidationData;

package/lib/parse/index.d.ts

@@ -0,0 +1,3 @@
+export * as Ledger from "./ledger";
+export { parseOutcome } from "./outcome";
+export { parseTransactionType, parseTransaction } from "./transaction";

package/lib/parse/index.js

@@ -0,0 +1,32 @@
+"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.parseTransaction = exports.parseTransactionType = exports.parseOutcome = exports.Ledger = void 0;
+exports.Ledger = __importStar(require("./ledger"));
+var outcome_1 = require("./outcome");
+Object.defineProperty(exports, "parseOutcome", { enumerable: true, get: function () { return outcome_1.parseOutcome; } });
+var transaction_1 = require("./transaction");
+Object.defineProperty(exports, "parseTransactionType", { enumerable: true, get: function () { return transaction_1.parseTransactionType; } });
+Object.defineProperty(exports, "parseTransaction", { enumerable: true, get: function () { return transaction_1.parseTransaction; } });

package/lib/parse/ledger/account-order.d.ts

@@ -0,0 +1,10 @@
+import { FormattedOfferCreateSpecification } from "../../v1/common/types/objects";
+export type FormattedAccountOrder = {
+    specification: FormattedOfferCreateSpecification;
+    properties: {
+        maker: string;
+        sequence: number;
+        makerExchangeRate: string;
+    };
+};
+export declare function parseAccountOrder(address: string, order: any): FormattedAccountOrder;

package/lib/parse/ledger/account-order.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAccountOrder = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const amount_1 = __importDefault(require("./amount"));
+const utils_1 = require("../utils");
+const common_1 = require("../../common");
+const flags_1 = require("../../v1/common/types/objects/flags");
+function computeQuality(takerGets, takerPays) {
+    const quotient = new bignumber_js_1.default(takerPays.value).dividedBy(takerGets.value);
+    return quotient.precision(16, bignumber_js_1.default.ROUND_HALF_UP).toString();
+}
+function parseAccountOrder(address, order) {
+    const direction = (order.flags & flags_1.orderFlags.Sell) === 0 ? "buy" : "sell";
+    const takerGetsAmount = (0, amount_1.default)(order.taker_gets);
+    const takerPaysAmount = (0, amount_1.default)(order.taker_pays);
+    const quantity = direction === "buy" ? takerPaysAmount : takerGetsAmount;
+    const totalPrice = direction === "buy" ? takerGetsAmount : takerPaysAmount;
+    const specification = (0, common_1.removeUndefined)({
+        direction: direction,
+        quantity: quantity,
+        totalPrice: totalPrice,
+        passive: (order.flags & flags_1.orderFlags.Passive) !== 0 || undefined,
+        expirationTime: (0, utils_1.parseTimestamp)(order.expiration),
+    });
+    const makerExchangeRate = order.quality
+        ? (0, utils_1.adjustQualityForXRP)(order.quality.toString(), takerGetsAmount.currency, takerPaysAmount.currency)
+        : computeQuality(takerGetsAmount, takerPaysAmount);
+    const properties = {
+        maker: address,
+        sequence: order.seq,
+        makerExchangeRate: makerExchangeRate,
+    };
+    return { specification, properties };
+}
+exports.parseAccountOrder = parseAccountOrder;

package/lib/parse/ledger/account-trustline.d.ts

@@ -0,0 +1,3 @@
+import { Trustline, FormattedTrustline } from "../../v1/common/types/objects/trustlines";
+declare function parseAccountTrustline(trustline: Trustline): FormattedTrustline;
+export default parseAccountTrustline;

package/lib/parse/ledger/account-trustline.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const common_1 = require("../../common");
+function parseAccountTrustline(trustline) {
+    const specification = (0, common_1.removeUndefined)({
+        limit: trustline.limit,
+        currency: trustline.currency,
+        counterparty: trustline.account,
+        qualityIn: (0, utils_1.parseQuality)(trustline.quality_in) || undefined,
+        qualityOut: (0, utils_1.parseQuality)(trustline.quality_out) || undefined,
+        ripplingDisabled: trustline.no_ripple,
+        frozen: trustline.freeze,
+        authorized: trustline.authorized,
+    });
+    const counterparty = (0, common_1.removeUndefined)({
+        limit: trustline.limit_peer,
+        ripplingDisabled: trustline.no_ripple_peer,
+        frozen: trustline.freeze_peer,
+        authorized: trustline.peer_authorized,
+    });
+    const state = {
+        balance: trustline.balance,
+    };
+    return { specification, counterparty, state };
+}
+exports.default = parseAccountTrustline;

package/lib/parse/ledger/amount.d.ts

@@ -0,0 +1,3 @@
+import { FormattedIssuedCurrencyAmount, Amount } from "../../v1/common/types/objects";
+declare function parseAmount(amount: Amount): FormattedIssuedCurrencyAmount;
+export default parseAmount;

package/lib/parse/ledger/amount.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("../../common");
+function parseAmount(amount) {
+    if (typeof amount === "string") {
+        return {
+            currency: "XRP",
+            value: (0, common_1.dropsToXrp)(amount),
+        };
+    }
+    return {
+        currency: amount.currency,
+        value: amount.value,
+        counterparty: amount.issuer,
+    };
+}
+exports.default = parseAmount;

package/lib/parse/ledger/currency-amount.d.ts

@@ -0,0 +1,3 @@
+import { FormattedAmount, Amount } from "../../v1/common/types/objects";
+declare function parseCurrencyAmount(amount: Amount): FormattedAmount | undefined;
+export default parseCurrencyAmount;

package/lib/parse/ledger/currency-amount.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const amount_1 = __importDefault(require("./amount"));
+function parseCurrencyAmount(amount) {
+    if (amount === undefined) {
+        return undefined;
+    }
+    return (0, amount_1.default)(amount);
+}
+exports.default = parseCurrencyAmount;

package/lib/parse/ledger/fields.d.ts

@@ -0,0 +1,2 @@
+declare function parseFields(data: any): object;
+export default parseFields;

package/lib/parse/ledger/fields.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 });
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const account_info_1 = require("../../models/account_info");
+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;
+}
+function parseFields(data) {
+    const settings = {};
+    for (const fieldName in account_info_1.AccountFields) {
+        const fieldValue = data[fieldName];
+        if (fieldValue != null) {
+            const info = account_info_1.AccountFields[fieldName];
+            settings[info.name] = parseField(info, fieldValue);
+        }
+    }
+    if (data.signer_lists && data.signer_lists.length === 1) {
+        settings.signers = {};
+        if (data.signer_lists[0].SignerQuorum) {
+            settings.signers.threshold = data.signer_lists[0].SignerQuorum;
+        }
+        if (data.signer_lists[0].SignerEntries) {
+            settings.signers.weights = data.signer_lists[0].SignerEntries.map((entry) => {
+                return {
+                    address: entry.SignerEntry.Account,
+                    weight: entry.SignerEntry.SignerWeight,
+                };
+            });
+        }
+    }
+    return settings;
+}
+exports.default = parseFields;

package/lib/parse/ledger/flags.d.ts

@@ -0,0 +1,4 @@
+declare function parseFlags(value: number, keys: any, options?: {
+    excludeFalse?: boolean;
+}): any;
+export { parseFlags };