@bithomp/xrpl-api 3.7.30 → 3.7.37

package/lib/connection.js

@@ -45,7 +45,8 @@ const common_1 = require("./common");
 const utils_1 = require("./common/utils");
 const XRPLConnection = __importStar(require("xrpl/dist/npm/client/connection"));
 const RECONNECT_TIMEOUT = 1000 * 5;
-const LEDGER_CLOSED_TIMEOUT = 1000 * 20;
+const LEDGER_CLOSED_TIMEOUT = 1000 * 15;
+const SLOW_RECONNECT_TIMEOUT = LEDGER_CLOSED_TIMEOUT * 5;
 const SERVER_INFO_UPDATE_INTERVAL = 1000 * 60 * 5;
 const AVAILABLE_LEDGER_INDEX_WINDOW = 1000;
 exports.DEFAULT_API_VERSION = xrpl_1.RIPPLED_API_V1;
@@ -98,6 +99,7 @@ class Connection extends events_1.EventEmitter {
             this.client = new XRPLConnection.Connection(this.url, (0, common_1.removeUndefined)({ timeout: this.timeout, connectionTimeout: this.connectionTimeout }));
             this.setupEmitter();
             await this.client.connect();
+            this.latency = [];
             await this.updateServerInfo();
             await this.subscribe();
             this.connectionValidation("connect");
@@ -114,7 +116,7 @@ class Connection extends events_1.EventEmitter {
             this.removeClient();
             let reconnectDelay = LEDGER_CLOSED_TIMEOUT;
             if (SLOW_DOWN_ERROR_MESSAGES.includes(errorMessage)) {
-                reconnectDelay = LEDGER_CLOSED_TIMEOUT * 5;
+                reconnectDelay = SLOW_RECONNECT_TIMEOUT;
             }
             this.connectionWatchTimer = setTimeout(this.bindConnectionWatchTimeout, reconnectDelay);
         }
@@ -185,10 +187,10 @@ class Connection extends events_1.EventEmitter {
             }
             const waitTime = (0, utils_1.getTimestamp)() + RECONNECT_TIMEOUT;
             while (!this.client || !this.isConnected()) {
-                await (0, utils_1.sleep)(100);
                 if (this.shutdown) {
                     return { error: "shutdownConnection", error_message: "Connection is shutdown.", status: "error" };
                 }
+                await (0, utils_1.sleep)(100);
                 if ((0, utils_1.getTimestamp)() > waitTime) {
                     return { error: "notConnected", error_message: "Not connected.", status: "error" };
                 }

package/lib/parse/outcome/orderbook_changes.js

@@ -68,24 +68,25 @@ function parseChangeAmount(node, type) {
     return lodash_1.default.assign({}, finalAmount, { value: value });
 }
 function parseOrderChange(node) {
-    const flags = (0, offer_flags_1.default)(node.finalFields.Flags);
     const takerPays = parseChangeAmount(node, "TakerPays");
     const takerGets = parseChangeAmount(node, "TakerGets");
+    const fields = Object.keys(node.finalFields).length > 0 ? node.finalFields : node.newFields;
+    const flags = (0, offer_flags_1.default)(fields.Flags);
     const orderChange = (0, common_1.removeUndefined)({
         flags,
         takerGets,
         takerPays,
-        sequence: (node.finalFields.Sequence || node.newFields.Sequence),
+        sequence: fields.Sequence,
         status: parseOrderStatus(node),
         makerExchangeRate: getQuality(node),
         expirationTime: getExpirationTime(node),
-        domainID: node.finalFields.Domain,
+        domainID: fields.DomainID,
         direction: (node.finalFields.Flags & xrpl_1.LedgerEntry.OfferFlags.lsfSell) === 0 ? "buy" : "sell",
         quantity: flags.sell === true ? takerGets : takerPays,
         totalPrice: flags.sell === true ? takerPays : takerGets,
     });
     Object.defineProperty(orderChange, "account", {
-        value: node.finalFields.Account || node.newFields.Account,
+        value: fields.Account,
     });
     return orderChange;
 }

package/lib/parse/specification/offer-create.js

@@ -64,6 +64,7 @@ function parseOfferCreate(tx, nativeCurrency) {
         takerGets,
         takerPays,
         expirationTime: (0, utils_1.parseTimestamp)(tx.Expiration),
+        domainID: tx.DomainID,
         emittedDetails: (0, emit_details_1.parseEmittedDetails)(tx),
         memos: (0, memos_1.parseMemos)(tx),
         direction: (tx.Flags & xrpl_1.OfferCreateFlags.tfSell) === 0 ? "buy" : "sell",

package/lib/src/base58.d.ts

@@ -0,0 +1,2 @@
+export declare function decode(value: string): null | Buffer;
+export declare function encode(buffer: Buffer | number[] | Uint8Array): null | string;

package/lib/src/base58.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = decode;
+exports.encode = encode;
+const R_B58_DICT = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz";
+const base_x_1 = __importDefault(require("base-x"));
+const base58 = (0, base_x_1.default)(R_B58_DICT);
+function decode(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        return Buffer.from(base58.decode(value));
+    }
+    catch (_err) {
+    }
+    return null;
+}
+function encode(buffer) {
+    if (!buffer) {
+        return null;
+    }
+    try {
+        return base58.encode(buffer);
+    }
+    catch (_err) {
+    }
+    return null;
+}

package/lib/src/client.d.ts

@@ -0,0 +1,25 @@
+import { Connection, ConnectionOptions } from "./connection";
+import { LedgerIndex } from "./models/ledger";
+export * from "./ledger";
+export declare let feeCushion: number;
+export declare let logger: any;
+export interface ClientOptions extends ConnectionOptions {
+    feeCushion?: number;
+    maxFeeXRP?: string;
+    logger?: any;
+    nativeCurrency?: "XRP" | "XAH";
+    loadBalancing?: boolean;
+}
+export interface ClientConnection {
+    url: string;
+    type?: string;
+    timeout?: number;
+    connectionTimeout?: number;
+    networkID?: number;
+}
+export declare function setup(servers: ClientConnection[], options?: ClientOptions): void;
+export declare function connect(): Promise<void>;
+export declare function disconnect(): Promise<void>;
+export declare function getNativeCurrency(): string;
+export declare function findConnection(type?: string, url?: string, strongFilter?: boolean, hash?: string, networkID?: number): Connection | null;
+export declare function findConnectionByLedger(ledgerIndex?: LedgerIndex, ledgerHash?: string, networkID?: number): Connection | null;

package/lib/src/client.js

@@ -0,0 +1,192 @@
+"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 });
+exports.logger = exports.feeCushion = void 0;
+exports.setup = setup;
+exports.connect = connect;
+exports.disconnect = disconnect;
+exports.getNativeCurrency = getNativeCurrency;
+exports.findConnection = findConnection;
+exports.findConnectionByLedger = findConnectionByLedger;
+const connection_1 = require("./connection");
+const common_1 = require("./common");
+__exportStar(require("./ledger"), exports);
+exports.feeCushion = 1.3;
+let clientConnections = [];
+let loadBalancing = false;
+let nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+function setup(servers, options = {}) {
+    exports.logger = options.logger;
+    exports.logger?.debug({
+        service: "Bithomp::XRPL::Client",
+        function: "setup",
+    });
+    if (servers) {
+        disconnect();
+        clientConnections = [];
+        for (const server of servers) {
+            clientConnections.push(new connection_1.Connection(server.url, server.type, {
+                logger: options.logger,
+                timeout: server.timeout,
+                connectionTimeout: server.connectionTimeout,
+                networkID: server.networkID,
+                apiVersion: options.apiVersion,
+            }));
+        }
+    }
+    if (options.feeCushion) {
+        exports.feeCushion = options.feeCushion;
+    }
+    if (options.nativeCurrency) {
+        nativeCurrency = options.nativeCurrency;
+    }
+    loadBalancing = options.loadBalancing === true;
+}
+async function connect() {
+    exports.logger?.debug({
+        service: "Bithomp::XRPL::Client",
+        function: "connect",
+    });
+    await Promise.all(clientConnections.map(async (connection) => {
+        await connection.connect();
+    }));
+}
+async function disconnect() {
+    exports.logger?.debug({
+        service: "Bithomp::XRPL::Client",
+        function: "disconnect",
+    });
+    await Promise.all(clientConnections.map(async (connection) => {
+        await connection.disconnect();
+    }));
+}
+function getNativeCurrency() {
+    return nativeCurrency || common_1.MAINNET_NATIVE_CURRENCY;
+}
+function findConnection(type, url, strongFilter, hash, networkID) {
+    if (!strongFilter) {
+        if (clientConnections.length === 0) {
+            return null;
+        }
+        else if (clientConnections.length === 1) {
+            return clientConnections[0];
+        }
+    }
+    let connections = clientConnections.filter((con) => {
+        if (!con.isConnected()) {
+            return false;
+        }
+        if (typeof networkID === "number" && typeof con.getNetworkID() === "number") {
+            if (con.getNetworkID() !== networkID) {
+                return false;
+            }
+        }
+        if (typeof url === "string" && con.url !== url) {
+            return false;
+        }
+        if (typeof hash === "string" && con.hash !== hash) {
+            return false;
+        }
+        if (typeof type !== "string") {
+            return true;
+        }
+        if (con.types.length === 0) {
+            return false;
+        }
+        const foundTypes = type.split(",").map((t) => {
+            t = t.trim();
+            if (t[0] === "!") {
+                return !con.types.includes(t.slice(1));
+            }
+            else {
+                return con.types.includes(t);
+            }
+        });
+        for (const found of foundTypes) {
+            if (!found) {
+                return false;
+            }
+        }
+        return true;
+    });
+    if (strongFilter === undefined || strongFilter === false) {
+        if (connections.length === 0) {
+            connections = clientConnections.filter((con) => {
+                if (!con.isConnected()) {
+                    return false;
+                }
+                if (typeof networkID === "number" && typeof con.getNetworkID() === "number") {
+                    if (con.getNetworkID() !== networkID) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+    }
+    if (connections.length === 0) {
+        return null;
+    }
+    else if (connections.length === 1) {
+        return connections[0];
+    }
+    if (loadBalancing) {
+        const index = Math.floor(Math.random() * connections.length);
+        return connections[index];
+    }
+    connections = connections.sort(sortHelperConnections);
+    return connections[0];
+}
+function findConnectionByLedger(ledgerIndex, ledgerHash, networkID) {
+    if (ledgerHash) {
+        return findConnection("history", undefined, false, undefined, networkID);
+    }
+    if (typeof ledgerIndex === "string" || ledgerIndex === undefined) {
+        return findConnection(undefined, undefined, false, undefined, networkID);
+    }
+    const availableConnections = clientConnections.filter((con) => {
+        if (!con.isConnected()) {
+            return false;
+        }
+        if (typeof networkID === "number" && typeof con.getNetworkID() === "number") {
+            if (con.getNetworkID() !== networkID) {
+                return false;
+            }
+        }
+        return con.isLedgerIndexPresent(ledgerIndex);
+    });
+    if (availableConnections.length === 0) {
+        return findConnection(undefined, undefined, false, undefined, networkID);
+    }
+    else if (availableConnections.length === 1) {
+        return availableConnections[0];
+    }
+    if (loadBalancing) {
+        const index = Math.floor(Math.random() * availableConnections.length);
+        return availableConnections[index];
+    }
+    const sortedConnections = availableConnections.sort(sortHelperConnections);
+    return sortedConnections[0];
+}
+function sortHelperConnections(a, b) {
+    if (a.getLatencyMs() < b.getLatencyMs()) {
+        return -1;
+    }
+    if (a.getLatencyMs() > b.getLatencyMs()) {
+        return 1;
+    }
+    return 0;
+}

package/lib/src/common/errors/index.d.ts

@@ -0,0 +1,3 @@
+import { XrplApiError } from "./xrpl_api_error";
+import { ValidationError } from "./validation_error";
+export { XrplApiError, ValidationError };

package/lib/src/common/errors/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.XrplApiError = void 0;
+const xrpl_api_error_1 = require("./xrpl_api_error");
+Object.defineProperty(exports, "XrplApiError", { enumerable: true, get: function () { return xrpl_api_error_1.XrplApiError; } });
+const validation_error_1 = require("./validation_error");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return validation_error_1.ValidationError; } });

package/lib/src/common/errors/validation_error.d.ts

@@ -0,0 +1,4 @@
+import { XrplApiError } from "./xrpl_api_error";
+declare class ValidationError extends XrplApiError {
+}
+export { ValidationError };

package/lib/src/common/errors/validation_error.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+const xrpl_api_error_1 = require("./xrpl_api_error");
+class ValidationError extends xrpl_api_error_1.XrplApiError {
+}
+exports.ValidationError = ValidationError;

package/lib/src/common/errors/xrpl_api_error.d.ts

@@ -0,0 +1,9 @@
+declare class XrplApiError extends Error {
+    name: string;
+    message: string;
+    data?: any;
+    constructor(message?: string, data?: any);
+    toString(): string;
+    inspect(): string;
+}
+export { XrplApiError };

package/lib/src/common/errors/xrpl_api_error.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XrplApiError = void 0;
+const util_1 = require("util");
+const utils_1 = require("../utils");
+class XrplApiError extends Error {
+    constructor(message = "", data) {
+        super(message);
+        this.name = (0, utils_1.getConstructorName)(this);
+        this.message = message;
+        this.data = data;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    toString() {
+        let result = `[${this.name}(${this.message}`;
+        if (this.data) {
+            result += `, ${(0, util_1.inspect)(this.data)}`;
+        }
+        result += ")]";
+        return result;
+    }
+    inspect() {
+        return this.toString();
+    }
+}
+exports.XrplApiError = XrplApiError;

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

@@ -0,0 +1,9 @@
+import * as errors from "./errors";
+import sha512Half from "./sha512Half";
+export * from "./utils";
+export { errors, sha512Half };
+export declare const MAINNET_NATIVE_CURRENCY = "XRP";
+export declare const XAHAU_NATIVE_CURRENCY = "XAH";
+export declare const dropsInXRP = 1000000;
+export declare const ACCOUNT_ZERO = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
+export declare const BLACKHOLE_ACCOUNTS: string[];

package/lib/src/common/index.js

@@ -0,0 +1,57 @@
+"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 __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.BLACKHOLE_ACCOUNTS = exports.ACCOUNT_ZERO = exports.dropsInXRP = exports.XAHAU_NATIVE_CURRENCY = exports.MAINNET_NATIVE_CURRENCY = exports.sha512Half = exports.errors = void 0;
+const errors = __importStar(require("./errors"));
+exports.errors = errors;
+const sha512Half_1 = __importDefault(require("./sha512Half"));
+exports.sha512Half = sha512Half_1.default;
+__exportStar(require("./utils"), exports);
+exports.MAINNET_NATIVE_CURRENCY = "XRP";
+exports.XAHAU_NATIVE_CURRENCY = "XAH";
+exports.dropsInXRP = 1000000;
+exports.ACCOUNT_ZERO = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
+exports.BLACKHOLE_ACCOUNTS = [
+    exports.ACCOUNT_ZERO,
+    "rrrrrrrrrrrrrrrrrrrrBZbvji",
+    "rrrrrrrrrrrrrrrrrNAMEtxvNvQ",
+    "rrrrrrrrrrrrrrrrrrrn5RM1rHd",
+];

package/lib/src/common/sha512Half.d.ts

@@ -0,0 +1,2 @@
+declare function sha512Half(hex: string): string;
+export default sha512Half;

package/lib/src/common/sha512Half.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const HASH_SIZE = 64;
+function sha512Half(hex) {
+    return (0, crypto_1.createHash)('sha512')
+        .update(Buffer.from(hex, 'hex'))
+        .digest('hex')
+        .toUpperCase()
+        .slice(0, HASH_SIZE);
+}
+exports.default = sha512Half;

package/lib/src/common/utils.d.ts

@@ -0,0 +1,14 @@
+import BigNumber from "bignumber.js";
+export type SortDirection = -1 | 0 | 1;
+export declare function signum(num: number): SortDirection;
+export declare function compareTransactions(first: any, second: any): SortDirection;
+export declare function sleep(ms: number): Promise<void>;
+export declare function getTimestamp(): number;
+export declare function createMarker(hash: string, marker?: any): any;
+export declare function parseMarker(marker?: any): any;
+export declare function dropsToXrp(drops: BigNumber.Value): string;
+export declare function xrpToDrops(xrp: BigNumber.Value): string;
+export declare function removeUndefined<T extends object>(obj: T): T;
+export declare function emptyObjectToUndefined<T extends object>(obj: T): T | undefined;
+export declare function getConstructorName(object: object): string | undefined;
+export declare function isClioResponse(response: any): boolean;

package/lib/src/common/utils.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signum = signum;
+exports.compareTransactions = compareTransactions;
+exports.sleep = sleep;
+exports.getTimestamp = getTimestamp;
+exports.createMarker = createMarker;
+exports.parseMarker = parseMarker;
+exports.dropsToXrp = dropsToXrp;
+exports.xrpToDrops = xrpToDrops;
+exports.removeUndefined = removeUndefined;
+exports.emptyObjectToUndefined = emptyObjectToUndefined;
+exports.getConstructorName = getConstructorName;
+exports.isClioResponse = isClioResponse;
+const lodash_1 = __importDefault(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const errors_1 = require("./errors");
+const index_1 = require("./index");
+function signum(num) {
+    return num === 0 ? 0 : num > 0 ? 1 : -1;
+}
+function compareTransactions(first, second) {
+    if (!first.tx || !first.meta || !second.tx || !second.meta) {
+        return 0;
+    }
+    if (first.tx.ledger_index === second.tx.ledger_index) {
+        return signum(first.meta.TransactionIndex - second.meta.TransactionIndex);
+    }
+    return first.tx.ledger_index < second.tx.ledger_index ? -1 : 1;
+}
+async function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function getTimestamp() {
+    return new Date().getTime();
+}
+function createMarker(hash, marker) {
+    if (marker === undefined) {
+        return undefined;
+    }
+    if (marker === null) {
+        return undefined;
+    }
+    if (typeof marker === "string") {
+        return `${hash},${marker}`;
+    }
+    if (typeof marker === "object") {
+        marker.bithompHash = hash;
+    }
+    return marker;
+}
+function parseMarker(marker) {
+    let hash;
+    if (typeof marker === "object" && marker.bithompHash) {
+        hash = marker.bithompHash;
+        delete marker.bithompHash;
+        return { hash, marker };
+    }
+    if (typeof marker !== "string") {
+        return { hash, marker };
+    }
+    if (marker) {
+        const markerParams = marker.split(",");
+        if (markerParams.length > 1) {
+            hash = markerParams[0];
+            markerParams.shift();
+            marker = markerParams.join(",");
+        }
+    }
+    return { hash, marker };
+}
+function dropsToXrp(drops) {
+    if (typeof drops === "string") {
+        if (!drops.match(/^-?[0-9]*\.?[0-9]*$/)) {
+            throw new errors_1.ValidationError(`dropsToXrp: invalid value '${drops}', should be a number matching (^-?[0-9]*\\.?[0-9]*$).`);
+        }
+        else if (drops === ".") {
+            throw new errors_1.ValidationError(`dropsToXrp: invalid value '${drops}', should be a BigNumber or string-encoded number.`);
+        }
+    }
+    drops = new bignumber_js_1.default(drops).toString(10);
+    if (drops.includes(".")) {
+        throw new errors_1.ValidationError(`dropsToXrp: value '${drops}' has too many decimal places.`);
+    }
+    if (!drops.match(/^-?[0-9]+$/)) {
+        throw new errors_1.ValidationError(`dropsToXrp: failed sanity check - value '${drops}', does not match (^-?[0-9]+$).`);
+    }
+    return new bignumber_js_1.default(drops).dividedBy(index_1.dropsInXRP).toString(10);
+}
+function xrpToDrops(xrp) {
+    if (typeof xrp === "string") {
+        if (!xrp.match(/^-?[0-9]*\.?[0-9]*$/)) {
+            throw new errors_1.ValidationError(`xrpToDrops: invalid value '${xrp}', should be a number matching (^-?[0-9]*\\.?[0-9]*$).`);
+        }
+        else if (xrp === ".") {
+            throw new errors_1.ValidationError(`xrpToDrops: invalid value '${xrp}', should be a BigNumber or string-encoded number.`);
+        }
+    }
+    xrp = new bignumber_js_1.default(xrp).toString(10);
+    if (!xrp.match(/^-?[0-9.]+$/)) {
+        throw new errors_1.ValidationError(`xrpToDrops: failed sanity check - value '${xrp}', does not match (^-?[0-9.]+$).`);
+    }
+    const components = xrp.split(".");
+    if (components.length > 2) {
+        throw new errors_1.ValidationError(`xrpToDrops: failed sanity check - value '${xrp}' has too many decimal points.`);
+    }
+    const fraction = components[1] || "0";
+    if (fraction.length > 6) {
+        throw new errors_1.ValidationError(`xrpToDrops: value '${xrp}' has too many decimal places.`);
+    }
+    return new bignumber_js_1.default(xrp).times(index_1.dropsInXRP).integerValue(bignumber_js_1.default.ROUND_FLOOR).toString(10);
+}
+function removeUndefined(obj) {
+    return lodash_1.default.omitBy(obj, (value) => value == null);
+}
+function emptyObjectToUndefined(obj) {
+    if (lodash_1.default.isEmpty(obj)) {
+        return undefined;
+    }
+    return obj;
+}
+function getConstructorName(object) {
+    if (object.constructor.name) {
+        return object.constructor.name;
+    }
+    const constructorString = object.constructor.toString();
+    const functionConstructor = constructorString.match(/^function\s+([^(]*)/);
+    const classConstructor = constructorString.match(/^class\s([^\s]*)/);
+    if (functionConstructor) {
+        return functionConstructor[1];
+    }
+    else if (classConstructor) {
+        return classConstructor[1];
+    }
+    return undefined;
+}
+function isClioResponse(response) {
+    if (!response || !response.warnings) {
+        return false;
+    }
+    return response.warnings?.some((w) => w.id === 2001);
+}