@bithomp/xrpl-api 3.7.31 → 3.7.38

package/lib/src/ledger/currency.js

@@ -0,0 +1,250 @@
+"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.parseCurrencyInformation = parseCurrencyInformation;
+const Client = __importStar(require("../client"));
+const utils_1 = require("../parse/utils");
+const transaction_1 = require("../parse/transaction");
+const client_1 = require("../client");
+const common_1 = require("../common");
+const amm_info_1 = require("../models/amm_info");
+const maxLength = 20;
+const DECODED_HEX_CURRENCY_REGEX = /[^-\w\(\)\[\]\u0020-\u007E\u00A0-\uFFFF]*/g;
+async function parseCurrencyInformation(currency) {
+    if (!currency || typeof currency !== "string") {
+        return null;
+    }
+    if (currency.length < 3) {
+        return null;
+    }
+    if (currency.length === 3 && currency.trim().toUpperCase() !== (0, client_1.getNativeCurrency)()) {
+        return decodeSimple(currency);
+    }
+    if (isHex(currency)) {
+        return await decodeCurrencyHex(currency);
+    }
+    return null;
+}
+function decodeSimple(currencyCode) {
+    return {
+        type: "simple",
+        currencyCode,
+        currency: currencyCode.trim(),
+    };
+}
+async function decodeCurrencyHex(currencyCode) {
+    const prefix = currencyCode.substring(0, 2);
+    if (prefix === "02" && isXlf15d(currencyCode)) {
+        return await decodeXlf15d(currencyCode);
+    }
+    else if (prefix === "03" && amm_info_1.AMM_LP_TOKEN_REGEX.test(currencyCode)) {
+        return decodeLPTokenHex(currencyCode);
+    }
+    else if (prefix === "01" && isDemurrageHex(currencyCode)) {
+        return decodeDemurrageHex(currencyCode);
+    }
+    else {
+        return decodeHex(currencyCode);
+    }
+}
+async function decodeXlf15d(currencyCode) {
+    const hex = currencyCode.toString().replace(/(00)+$/g, "");
+    const ctiHex = hex.substring(2, 16);
+    const cti = BigInt("0x" + ctiHex);
+    const ctiLedger = Number(ctiLedgerIndex(cti));
+    const ctiTxIndex = Number(ctiTransactionIndex(cti));
+    const currencyHex = hex.substring(16, hex.length);
+    const currency = (0, utils_1.hexToString)(currencyHex)?.trim()?.replace(/\0/g, "");
+    const ledgerInfo = await getLedger(ctiLedger);
+    const ledger = ledgerInfo?.ledger;
+    let ctiVerified = false;
+    let ctiValid = false;
+    let timestamp;
+    let ctiTx = {};
+    if (ledger) {
+        timestamp = Math.round(new Date(ledger.close_time_human).getTime() / 1000);
+        for (const transaction of ledger.transactions) {
+            if (transaction.metaData.TransactionIndex === ctiTxIndex) {
+                const { Account: account, Destination: destination, LimitAmount: limit, Memos: memos, hash: hash, } = transaction;
+                const type = (0, transaction_1.parseTransactionType)(transaction.TransactionType);
+                ctiTx = (0, common_1.removeUndefined)({
+                    type,
+                    account,
+                    destination,
+                    issuer: limit?.issuer,
+                    counterparty: limit?.issuer,
+                    hash,
+                    memos,
+                });
+                break;
+            }
+        }
+    }
+    if (ledger) {
+        ctiVerified = true;
+        if (ctiTx.hash) {
+            ctiValid =
+                ctiLedgerCheck(cti) === ctiLedgerCheckGen(ledger.hash || ledger.ledger_hash) &&
+                    ctiTransactionCheck(cti) === ctiTransactionCheckGen(ctiTx.hash);
+        }
+    }
+    return {
+        type: "nft",
+        currencyCode,
+        currency,
+        cti: Number(cti),
+        ctiLedger,
+        ctiTxIndex,
+        ctiValid,
+        ctiVerified,
+        timestamp,
+        ctiTx,
+    };
+}
+function decodeHex(currencyHex) {
+    let hex = currencyHex;
+    const prefix = currencyHex.substring(0, 2);
+    if (prefix === "02") {
+        hex = currencyHex.substring(16, currencyHex.length);
+    }
+    const decoded = (0, utils_1.hexToString)(hex)
+        ?.slice(0, maxLength)
+        ?.replace(/^\u0000+/, "")
+        ?.replace(/\u0000+$/, "")
+        ?.trim();
+    const trimmed = decoded
+        .replace(DECODED_HEX_CURRENCY_REGEX, "")
+        .replace(/[�]*/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (trimmed.length > 1 &&
+        trimmed.length >= decoded.length / 2 &&
+        trimmed.toUpperCase() !== (0, client_1.getNativeCurrency)()) {
+        return {
+            type: "hex",
+            currencyCode: currencyHex,
+            currency: trimmed,
+        };
+    }
+    return null;
+}
+function decodeLPTokenHex(currencyHex) {
+    return {
+        type: "lp_token",
+        currencyCode: currencyHex,
+        currency: "LP Token",
+    };
+}
+function decodeDemurrageHex(currencyHex) {
+    const hex = currencyHex.substring(2, 8);
+    const currencyText = (0, utils_1.hexToString)(hex)?.trim()?.replace(/\0/g, "");
+    let valuePrefix = "";
+    const year = 31536000;
+    const decimals = 2;
+    const interestPeriod = hex2double(currencyHex.substring(16, 32));
+    const interest = Math.exp(year / interestPeriod);
+    const percentage = (interest * 100) - 100;
+    const decimalMultiplier = decimals ? Math.pow(10, decimals) : 100;
+    const rate = Math.round(percentage * decimalMultiplier) / decimalMultiplier;
+    valuePrefix = `(${rate > 0 ? "+" : ""}${rate}%pa)`;
+    const currency = `${currencyText} ${valuePrefix}`;
+    return {
+        type: "demurrage",
+        currencyCode: currencyHex,
+        currency,
+    };
+}
+function isDemurrageHex(currencyHex) {
+    const hex = currencyHex.substring(2, 8);
+    const currencyText = (0, utils_1.hexToString)(hex)?.trim()?.replace(/\0/g, "");
+    if (!currencyText || currencyText.length < 3) {
+        return false;
+    }
+    if (!currencyText.match(/^[a-zA-Z0-9\s]+$/)) {
+        return false;
+    }
+    const interestPeriod = hex2double(currencyHex.substring(16, 32));
+    if (isNaN(interestPeriod)) {
+        return false;
+    }
+    const interestStart = Buffer.from(currencyHex.substring(8, 16), "hex").readUInt32BE(0);
+    if (isNaN(interestStart) || interestStart < 0) {
+        return false;
+    }
+    return true;
+}
+function hex2double(hex) {
+    const buffer = Buffer.from(hex, "hex");
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    return view.getFloat64(0, false);
+}
+async function getLedger(ledgerIndex) {
+    let ledgerInfo = null;
+    try {
+        ledgerInfo = await Client.getLedger({ ledgerIndex, transactions: true, expand: true });
+    }
+    catch (_err) {
+    }
+    return ledgerInfo;
+}
+function ctiTransactionIndex(cti) {
+    return (cti >> 32n) & 0xffffn;
+}
+function ctiLedgerIndex(cti) {
+    return cti & 0xffffffffn;
+}
+function ctiLedgerCheck(cti) {
+    return (cti >> 52n) & 0xfn;
+}
+function ctiTransactionCheck(cti) {
+    return (cti >> 48n) & 0xfn;
+}
+function ctiLedgerCheckGen(ledgerHash) {
+    return BigInt(parseInt(ledgerHash.slice(0, 1), 16));
+}
+function ctiTransactionCheckGen(txHash) {
+    return BigInt(parseInt(txHash.slice(0, 1), 16));
+}
+function isXlf15d(currencyHex) {
+    const hex = currencyHex.toString().replace(/(00)+$/g, "");
+    const xlf15d = Buffer.from(hex, "hex").slice(8).toString("utf-8").slice(0, maxLength).trim();
+    if (xlf15d.match(/[a-zA-Z0-9]{3,}/) && xlf15d.toUpperCase() !== (0, client_1.getNativeCurrency)()) {
+        return true;
+    }
+    return false;
+}
+function isHex(currencyCode) {
+    return !!currencyCode.match(/^[a-fA-F0-9]{40}$/) && !isNaN(parseInt(currencyCode, 16));
+}

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

@@ -0,0 +1,13 @@
+import { XrplDefinitionsBase } from "ripple-binary-codec";
+import { Connection } from "../connection";
+import { ErrorResponse } from "../models/base_model";
+export interface GetFeeOptions {
+    connection?: Connection;
+    tx?: any;
+    definitions?: XrplDefinitionsBase;
+}
+export interface GetFeeDataResult {
+    fee: string | null;
+}
+export declare function getFeeData(options?: GetFeeOptions): Promise<GetFeeDataResult | ErrorResponse>;
+export declare function getFee(options?: GetFeeOptions): Promise<string | null>;

package/lib/src/ledger/fee.js

@@ -0,0 +1,99 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFeeData = getFeeData;
+exports.getFee = getFee;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ripple_binary_codec_1 = require("ripple-binary-codec");
+const Client = __importStar(require("../client"));
+const common_1 = require("../common");
+async function getFeeData(options = {}) {
+    const connection = options.connection || Client.findConnection();
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    let txBlob;
+    if (typeof options.tx === "string") {
+        txBlob = options.tx;
+    }
+    else if (typeof options.tx === "object") {
+        txBlob = (0, ripple_binary_codec_1.encode)(options.tx, options.definitions);
+    }
+    const response = await connection.request({
+        command: "fee",
+        tx_blob: txBlob,
+    });
+    if (!response) {
+        return {
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, common_1.removeUndefined)({
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    const openLedgerFee = response?.result?.drops?.open_ledger_fee;
+    if (!openLedgerFee) {
+        return {
+            status: "error",
+            error: "No open_ledger_fee data in response",
+        };
+    }
+    const fee = new bignumber_js_1.default(openLedgerFee)
+        .multipliedBy(Client.feeCushion)
+        .dividedBy(common_1.dropsInXRP)
+        .decimalPlaces(6, bignumber_js_1.default.ROUND_UP);
+    return {
+        fee: fee.toString(),
+    };
+}
+async function getFee(options = {}) {
+    const response = await getFeeData(options);
+    if ("fee" in response) {
+        return response.fee;
+    }
+    return null;
+}

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

@@ -0,0 +1,16 @@
+import { Trustline } from "../models/account_lines";
+import { LedgerIndex } from "../models/ledger";
+import { ErrorResponse } from "../models/base_model";
+import { GatewayBalances } from "../models/gateway_balances";
+import { FormattedGatewayBalances } from "../types";
+export interface GetBalanceSheetOptions {
+    ledgerIndex?: LedgerIndex;
+    hotwallet?: string;
+    strict?: boolean;
+    formatted?: boolean;
+}
+export declare function getBalanceSheet(account: string, options?: GetBalanceSheetOptions): Promise<GatewayBalances | FormattedGatewayBalances | ErrorResponse>;
+export interface ObligationTrustline extends Trustline {
+    obligation?: boolean;
+}
+export declare function getAccountObligations(account: string): Promise<object | ErrorResponse>;

package/lib/src/ledger/gateway_balances.js

@@ -0,0 +1,119 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBalanceSheet = getBalanceSheet;
+exports.getAccountObligations = getAccountObligations;
+const lodash_1 = __importDefault(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const Client = __importStar(require("../client"));
+const gateway_balances_1 = require("../parse/ledger/gateway-balances");
+const utils_1 = require("../common/utils");
+async function getBalanceSheet(account, options = {}) {
+    const formatted = options.formatted === true;
+    const connection = Client.findConnection("gateway_balances");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "gateway_balances",
+        account,
+        ledger_index: options.ledgerIndex || "validated",
+        hotwallet: options.hotwallet,
+        strict: !!options.strict,
+    });
+    if (!response) {
+        return {
+            account,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, utils_1.removeUndefined)({
+            account,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    const result = response.result;
+    if (formatted) {
+        return (0, gateway_balances_1.parseGatewayBalances)(result);
+    }
+    return result;
+}
+async function getAccountObligations(account) {
+    const response = (await getBalanceSheet(account));
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, utils_1.removeUndefined)({
+            account,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    const obligations = response.obligations;
+    const obligationsLines = [];
+    lodash_1.default.map(obligations, (value, currency) => {
+        obligationsLines.push(ObligationToObligationTrustline(account, value, currency));
+    });
+    delete response.obligations;
+    delete response.assets;
+    response.lines = obligationsLines;
+    return response;
+}
+function ObligationToObligationTrustline(account, value, currency) {
+    return {
+        account,
+        currency,
+        balance: new bignumber_js_1.default(value).times(-1).toString(),
+        limit: "0",
+        limit_peer: "0",
+        quality_in: 0,
+        quality_out: 0,
+        obligation: true,
+    };
+}

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

@@ -0,0 +1,21 @@
+export * from "./account_info";
+export * from "./account_lines";
+export * from "./account_namespace";
+export * from "./account_nfts";
+export * from "./account_objects";
+export * from "./account_offers";
+export * from "./account_tx";
+export * from "./amm_info";
+export * from "./book_offers";
+export * from "./currency";
+export * from "./fee";
+export * from "./gateway_balances";
+export * from "./ledger";
+export * from "./ledger_entry";
+export * from "./manifest";
+export * from "./nft_info";
+export * from "./server_info";
+export * from "./server_definitions";
+export * from "./transaction";
+export * from "./vl";
+export * from "./vl-v2";

package/lib/src/ledger/index.js

@@ -0,0 +1,37 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./account_info"), exports);
+__exportStar(require("./account_lines"), exports);
+__exportStar(require("./account_namespace"), exports);
+__exportStar(require("./account_nfts"), exports);
+__exportStar(require("./account_objects"), exports);
+__exportStar(require("./account_offers"), exports);
+__exportStar(require("./account_tx"), exports);
+__exportStar(require("./amm_info"), exports);
+__exportStar(require("./book_offers"), exports);
+__exportStar(require("./currency"), exports);
+__exportStar(require("./fee"), exports);
+__exportStar(require("./gateway_balances"), exports);
+__exportStar(require("./ledger"), exports);
+__exportStar(require("./ledger_entry"), exports);
+__exportStar(require("./manifest"), exports);
+__exportStar(require("./nft_info"), exports);
+__exportStar(require("./server_info"), exports);
+__exportStar(require("./server_definitions"), exports);
+__exportStar(require("./transaction"), exports);
+__exportStar(require("./vl"), exports);
+__exportStar(require("./vl-v2"), exports);

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

@@ -0,0 +1,16 @@
+import { Connection } from "../connection";
+import { LedgerIndex } from "../models/ledger";
+import { ErrorResponse } from "../models/base_model";
+import { FormattedLedger } from "../types";
+export interface GetLedgerOptions {
+    ledgerIndex?: LedgerIndex;
+    ledgerHash?: string;
+    transactions?: boolean;
+    expand?: boolean;
+    legacy?: boolean;
+    formatted?: boolean;
+    includeRawTransactions?: boolean;
+    connection?: Connection;
+}
+export declare function getLedger(options?: GetLedgerOptions): Promise<object | FormattedLedger | ErrorResponse>;
+export declare function getLedgerIndex(options?: GetLedgerOptions): Promise<number | undefined>;

package/lib/src/ledger/ledger.js

@@ -0,0 +1,99 @@
+"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.getLedger = getLedger;
+exports.getLedgerIndex = getLedgerIndex;
+const Client = __importStar(require("../client"));
+const ledger_1 = require("../parse/ledger/ledger");
+const utils_1 = require("../common/utils");
+async function getLedger(options = {}) {
+    const formatted = options.legacy === true || options.formatted === true;
+    const connection = options.connection || Client.findConnectionByLedger(options.ledgerIndex, options.ledgerHash);
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    if (options.ledgerIndex && !connection.isLedgerIndexAvailable(options.ledgerIndex)) {
+        return {
+            status: "error",
+            error: "lgrNotFound",
+            error_message: "ledger number is out of available range",
+        };
+    }
+    const request = {
+        command: "ledger",
+        transactions: !!options.transactions,
+        expand: !!options.expand,
+    };
+    if (options.ledgerHash) {
+        request.ledger_hash = options.ledgerHash;
+    }
+    else if (options.ledgerIndex) {
+        request.ledger_index = options.ledgerIndex;
+    }
+    else {
+        request.ledger_index = "validated";
+    }
+    const response = await connection.request(request);
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, utils_1.removeUndefined)({
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    const result = response?.result;
+    if (!result) {
+        return {
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (formatted === true) {
+        result.ledger = (0, ledger_1.parseLedger)(result.ledger, options.includeRawTransactions === true);
+    }
+    return result;
+}
+async function getLedgerIndex(options = {}) {
+    const ledgerInfo = await Client.getLedger(options);
+    const ledger = ledgerInfo?.ledger;
+    if (ledger) {
+        return parseInt(ledger.ledger_index, 10);
+    }
+    return undefined;
+}