@bithomp/xrpl-api 3.7.31 → 3.7.38

package/lib/src/connection.js

@@ -0,0 +1,645 @@
+"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.Connection = exports.DEFAULT_API_VERSION = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const events_1 = require("events");
+const xrpl_1 = require("xrpl");
+const ledger_1 = require("./models/ledger");
+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 * 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;
+const SLOW_DOWN_ERROR_MESSAGES = [
+    "slowDown",
+    "Unexpected server response: 429",
+    "You are placing too much load on the server.",
+];
+class Connection extends events_1.EventEmitter {
+    constructor(url, type, options = {}) {
+        super();
+        this.types = [];
+        this.latency = [];
+        this.onlineSince = null;
+        this.serverInfo = {};
+        this.shutdown = false;
+        this.connectionWatchTimer = null;
+        this.bindConnectionWatchTimeout = this.connectionWatchTimeout.bind(this);
+        this.shutdown = false;
+        this.url = url;
+        this.type = type;
+        this.resetTypes();
+        this.client = null;
+        this.logger = options.logger;
+        this.timeout = options.timeout || LEDGER_CLOSED_TIMEOUT;
+        this.connectionTimeout = options.connectionTimeout || RECONNECT_TIMEOUT;
+        this.hash = crypto_1.default.createHash("sha256").update(url).digest("hex");
+        if (typeof options.networkID === "number") {
+            this.networkID = options.networkID;
+        }
+        this.apiVersion = options.apiVersion || exports.DEFAULT_API_VERSION;
+        this.serverInfoUpdating = false;
+        this.serverInfo = null;
+        this.streams = {
+            ledger: 1,
+        };
+        this.accounts = {};
+        this.streamsSubscribed = false;
+    }
+    async connect() {
+        try {
+            this.logger?.debug({
+                service: "Bithomp::XRPL::Connection",
+                function: "connect",
+                url: this.url,
+                shutdown: this.shutdown,
+            });
+            this.removeWatchTimer();
+            this.removeClient();
+            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");
+        }
+        catch (err) {
+            const errorMessage = err?.message || err?.name || err;
+            this.logger?.warn({
+                service: "Bithomp::XRPL::Connection",
+                function: "connect",
+                url: this.url,
+                error: errorMessage,
+            });
+            this.removeWatchTimer();
+            this.removeClient();
+            let reconnectDelay = LEDGER_CLOSED_TIMEOUT;
+            if (SLOW_DOWN_ERROR_MESSAGES.includes(errorMessage)) {
+                reconnectDelay = SLOW_RECONNECT_TIMEOUT;
+            }
+            this.connectionWatchTimer = setTimeout(this.bindConnectionWatchTimeout, reconnectDelay);
+        }
+    }
+    async disconnect() {
+        this.logger?.debug({
+            service: "Bithomp::XRPL::Connection",
+            function: "disconnect",
+            url: this.url,
+        });
+        this.shutdown = true;
+        if (this.isConnected()) {
+            await this.unsubscribe();
+        }
+        this.removeWatchTimer();
+        this.removeClient();
+    }
+    async request(request, options) {
+        const result = await this._request(request, options);
+        let validResponse = true;
+        if (result?.error) {
+            if (SLOW_DOWN_ERROR_MESSAGES.includes(result.error)) {
+                this.logger?.debug({
+                    service: "Bithomp::XRPL::Connection",
+                    function: "request",
+                    url: this.url,
+                    error: `Received slowdown error, reconnecting...`,
+                });
+                validResponse = false;
+            }
+            else if (result.error === "timeout") {
+                const timeouts = this.latency.filter((info) => info.delta >= this.timeout).length;
+                if (timeouts >= 3) {
+                    this.logger?.debug({
+                        service: "Bithomp::XRPL::Connection",
+                        function: "request",
+                        url: this.url,
+                        error: `Too many timeouts (${timeouts}) in last ${this.latency.length} requests, reconnecting...`,
+                    });
+                    validResponse = false;
+                }
+            }
+            else if (result.error.toLowerCase().startsWith("websocket was closed")) {
+                this.logger?.debug({
+                    service: "Bithomp::XRPL::Connection",
+                    function: "request",
+                    url: this.url,
+                    error: "Websocket was closed, reconnecting...",
+                });
+                validResponse = false;
+            }
+        }
+        if (validResponse) {
+            if (result?.error !== "notConnected") {
+                this.connectionValidation("request");
+            }
+        }
+        else {
+            this.removeClient();
+        }
+        return result;
+    }
+    async _request(request, options) {
+        try {
+            if (options?.skip_subscription_update !== true &&
+                (request.command === "subscribe" || request.command === "unsubscribe")) {
+                return this.updateSubscriptions(request);
+            }
+            const waitTime = (0, utils_1.getTimestamp)() + RECONNECT_TIMEOUT;
+            while (!this.client || !this.isConnected()) {
+                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" };
+                }
+            }
+            const startTimestamp = (0, utils_1.getTimestamp)();
+            if (this.apiVersion && !request.hasOwnProperty("api_version") && exports.DEFAULT_API_VERSION !== this.apiVersion) {
+                request.api_version = this.apiVersion;
+            }
+            const response = await this.client.request(request);
+            this.updateLatency((0, utils_1.getTimestamp)() - startTimestamp);
+            return response;
+        }
+        catch (err) {
+            this.updateLatency(err.name === "TimeoutError" ? this.timeout : this.connectionTimeout);
+            this.logger?.debug({
+                service: "Bithomp::XRPL::Connection",
+                function: "request",
+                url: this.url,
+                error: err?.message || err?.name || err,
+            });
+            if (err.name === "TimeoutError") {
+                return { error: "timeout", error_message: "Request timeout.", status: "error" };
+            }
+            else if (err.data) {
+                return err.data;
+            }
+            else {
+                return { error: err?.message || err?.name || err, status: "error" };
+            }
+        }
+    }
+    async submit(transaction) {
+        try {
+            return await this.request({ command: "submit", tx_blob: transaction });
+        }
+        catch (err) {
+            this.logger?.debug({
+                service: "Bithomp::XRPL::Connection",
+                function: "submit",
+                url: this.url,
+                error: err?.message || err?.name || err,
+            });
+            if (err.data) {
+                return err.data;
+            }
+            else {
+                return { error: err?.message || err?.name || err };
+            }
+        }
+    }
+    isConnected() {
+        if (!this.client) {
+            return false;
+        }
+        if (!this.client.isConnected()) {
+            return false;
+        }
+        return true;
+    }
+    getOnlinePeriodMs() {
+        if (this.isConnected()) {
+            return this.onlineSince ? (0, utils_1.getTimestamp)() - this.onlineSince : 0;
+        }
+        return null;
+    }
+    getLatencyMs() {
+        return this.latency.map((info) => info.delta).reduce((a, b) => a + b, 0) / this.latency.length || 0;
+    }
+    getNetworkID() {
+        if (typeof this.serverInfo?.network_id === "number") {
+            return this.serverInfo.network_id;
+        }
+        return this.networkID;
+    }
+    isLedgerIndexAvailable(ledgerIndex) {
+        if (typeof ledgerIndex !== "number") {
+            return true;
+        }
+        if (!this.serverInfo?.complete_ledgers) {
+            return true;
+        }
+        const completeLedgers = this.serverInfo.complete_ledgers.split("-");
+        if (completeLedgers.length !== 2) {
+            return true;
+        }
+        completeLedgers[0] = parseInt(completeLedgers[0], 10);
+        completeLedgers[1] = parseInt(completeLedgers[1], 10);
+        if (ledgerIndex < completeLedgers[0] - AVAILABLE_LEDGER_INDEX_WINDOW ||
+            ledgerIndex > completeLedgers[1] + AVAILABLE_LEDGER_INDEX_WINDOW) {
+            return false;
+        }
+        return true;
+    }
+    isLedgerIndexPresent(ledgerIndex) {
+        if (typeof ledgerIndex !== "number") {
+            return true;
+        }
+        if (!this.serverInfo?.complete_ledgers) {
+            return false;
+        }
+        const completeLedgers = this.serverInfo.complete_ledgers.split("-");
+        if (completeLedgers.length !== 2) {
+            return true;
+        }
+        completeLedgers[0] = parseInt(completeLedgers[0], 10);
+        completeLedgers[1] = parseInt(completeLedgers[1], 10);
+        if (ledgerIndex < completeLedgers[0] || ledgerIndex > completeLedgers[1]) {
+            return false;
+        }
+        return true;
+    }
+    updateLatency(delta) {
+        this.latency.push({
+            timestamp: new Date(),
+            delta,
+        });
+        this.latency.splice(0, this.latency.length - 10);
+    }
+    async reconnect() {
+        this.logger?.debug({
+            service: "Bithomp::XRPL::Connection",
+            function: "reconnect",
+            url: this.url,
+            shutdown: this.shutdown,
+        });
+        if (this.shutdown) {
+            return;
+        }
+        this.emit("reconnect");
+        try {
+            this.removeClient();
+            this.resetTypes();
+            this.serverInfoUpdating = false;
+            this.onlineSince = 0;
+            this.serverInfo = null;
+            this.streamsSubscribed = false;
+            await this.connect();
+        }
+        catch (e) {
+            this.logger?.warn({
+                service: "Bithomp::XRPL::Connection",
+                function: "reconnect",
+                url: this.url,
+                error: e.message,
+            });
+            this.connectionValidation("reconnect");
+        }
+    }
+    removeClient(code = 1000) {
+        try {
+            if (this.client) {
+                this.client.removeAllListeners();
+                this.client.disconnect();
+                this.client = undefined;
+                this.emit("disconnected", code);
+            }
+        }
+        catch (_err) {
+        }
+    }
+    removeWatchTimer() {
+        if (this.connectionWatchTimer !== null) {
+            clearTimeout(this.connectionWatchTimer);
+            this.connectionWatchTimer = null;
+        }
+    }
+    setupEmitter() {
+        if (!this.client) {
+            return;
+        }
+        this.client.on("connected", () => {
+            this.logger?.debug({
+                service: "Bithomp::XRPL::Connection",
+                emit: "connected",
+                url: this.url,
+            });
+            this.emit("connected");
+            this.onlineSince = (0, utils_1.getTimestamp)();
+        });
+        this.client.on("disconnected", (code) => {
+            this.logger?.debug({
+                service: "Bithomp::XRPL::Connection",
+                emit: "disconnected",
+                code,
+                url: this.url,
+            });
+            if (this.client) {
+                this.client.removeAllListeners();
+                this.client = undefined;
+            }
+            this.emit("disconnected", code);
+        });
+        this.client.on("error", (source, message, error) => {
+            try {
+                if (source === "noPermission") {
+                    if (!error.status) {
+                        error.status = "error";
+                    }
+                    if (this.client) {
+                        this.client.requestManager.handleResponse(error);
+                        return;
+                    }
+                }
+                this.logger?.error({
+                    service: "Bithomp::XRPL::Connection",
+                    emit: "error",
+                    source,
+                    url: this.url,
+                    error: message || error?.name || error,
+                });
+                this.emit("error", source, message, error);
+            }
+            catch (err) {
+                this.logger?.warn({
+                    service: "Bithomp::XRPL::Connection",
+                    emit: "error",
+                    url: this.url,
+                    error: err?.message || err?.name || err,
+                });
+            }
+        });
+        this.client.on("ledgerClosed", (ledgerStream) => {
+            this.onLedgerClosed(ledgerStream);
+            this.emit("ledgerClosed", ledgerStream);
+        });
+        this.client.on("transaction", (transactionStream) => {
+            this.emit("transaction", transactionStream);
+        });
+        this.client.on("validationReceived", (validation) => {
+            this.emit("validationReceived", validation);
+        });
+        this.client.on("manifestReceived", (manifest) => {
+            this.emit("manifestReceived", manifest);
+        });
+        this.client.on("peerStatusChange", (status) => {
+            this.emit("peerStatusChange", status);
+        });
+        this.client.on("consensusPhase", (consensus) => {
+            this.emit("consensusPhase", consensus);
+        });
+        this.client.on("path_find", (path) => {
+            this.emit("path_find", path);
+        });
+    }
+    resetTypes() {
+        if (typeof this.type === "string") {
+            this.types = this.type.split(",").map((v) => v.trim());
+        }
+        else {
+            this.types = [];
+        }
+    }
+    async updateSubscriptions(request) {
+        if (request.command === "subscribe") {
+            const addStreams = [];
+            const addAccounts = [];
+            if (request.streams) {
+                for (const stream of request.streams) {
+                    if (this.streams[stream] === undefined) {
+                        this.streams[stream] = 1;
+                        addStreams.push(stream);
+                    }
+                    else if (stream !== "ledger") {
+                        this.streams[stream]++;
+                    }
+                }
+            }
+            if (request.accounts) {
+                for (const account of request.accounts) {
+                    if (this.accounts[account] === undefined) {
+                        this.accounts[account] = 1;
+                        addAccounts.push(account);
+                    }
+                    else {
+                        this.accounts[account]++;
+                    }
+                }
+            }
+            if (addStreams.length > 0 || addAccounts.length > 0) {
+                return await this.subscribe(addStreams, addAccounts);
+            }
+        }
+        else if (request.command === "unsubscribe") {
+            const removeStreams = [];
+            const removeAccounts = [];
+            if (request.streams) {
+                for (const stream of request.streams) {
+                    if (this.streams[stream] === undefined) {
+                        continue;
+                    }
+                    if (stream !== "ledger") {
+                        this.streams[stream]--;
+                    }
+                    if (this.streams[stream] === 0) {
+                        delete this.streams[stream];
+                        removeStreams.push(stream);
+                    }
+                }
+            }
+            if (request.accounts) {
+                for (const account of request.accounts) {
+                    if (this.accounts[account] === undefined) {
+                        continue;
+                    }
+                    this.accounts[account]--;
+                    if (this.accounts[account] === 0) {
+                        delete this.accounts[account];
+                        removeAccounts.push(account);
+                    }
+                }
+            }
+            if (removeStreams.length > 0 || removeAccounts.length > 0) {
+                return await this.unsubscribe(removeStreams, removeAccounts);
+            }
+        }
+        return { status: "success" };
+    }
+    async subscribe(streams, accounts) {
+        if (this.shutdown) {
+            return { error: "shutdownConnection", error_message: "Connection is shutdown.", status: "error" };
+        }
+        if (this.streamsSubscribed === true && streams === undefined && accounts === undefined) {
+            return { status: "success" };
+        }
+        streams = streams || Object.keys(this.streams);
+        accounts = accounts || Object.keys(this.accounts);
+        const request = { command: "subscribe" };
+        if (streams.length > 0) {
+            request.streams = streams;
+        }
+        if (accounts.length > 0) {
+            request.accounts = accounts;
+        }
+        const result = await this.request(request, { skip_subscription_update: true });
+        if (result.result && !result.error) {
+            this.streamsSubscribed = true;
+        }
+        return result;
+    }
+    async unsubscribe(streams, accounts) {
+        if (streams === undefined && accounts === undefined) {
+            this.streamsSubscribed = false;
+        }
+        streams = streams || Object.keys(this.streams);
+        accounts = accounts || Object.keys(this.accounts);
+        const request = { command: "unsubscribe" };
+        if (streams.length > 0) {
+            request.streams = streams;
+        }
+        if (accounts.length > 0) {
+            request.accounts = accounts;
+        }
+        return await this.request(request, { skip_subscription_update: true });
+    }
+    onLedgerClosed(ledgerStream) {
+        const time = (0, utils_1.getTimestamp)();
+        const ledgerTime = (0, ledger_1.ledgerTimeToTimestamp)(ledgerStream.ledger_time);
+        if (ledgerTime < time) {
+            this.updateLatency(time - ledgerTime);
+        }
+        if (this.serverInfo) {
+            this.serverInfo.complete_ledgers = ledgerStream.validated_ledgers;
+            if (this.serverInfo.validated_ledger) {
+                this.serverInfo.validated_ledger.age = Math.round((time - ledgerTime) / 1000);
+                this.serverInfo.validated_ledger.seq = ledgerStream.ledger_index;
+                this.serverInfo.validated_ledger.hash = ledgerStream.ledger_hash;
+                this.serverInfo.validated_ledger.base_fee_xrp = (0, common_1.dropsToXrp)(ledgerStream.fee_base);
+                this.serverInfo.validated_ledger.reserve_base_xrp = (0, common_1.dropsToXrp)(ledgerStream.reserve_base);
+                this.serverInfo.validated_ledger.reserve_inc_xrp = (0, common_1.dropsToXrp)(ledgerStream.reserve_inc);
+            }
+            const serverInfoTime = new Date(this.serverInfo.time).getTime();
+            if (serverInfoTime + SERVER_INFO_UPDATE_INTERVAL < time) {
+                this.updateServerInfo();
+            }
+        }
+        else {
+            this.updateServerInfo();
+        }
+        this.connectionValidation("ledgerClosed");
+    }
+    async updateServerInfo() {
+        if (this.serverInfoUpdating || this.shutdown) {
+            return;
+        }
+        this.serverInfoUpdating = true;
+        try {
+            const serverInfo = await this.request({ command: "server_info" });
+            if (serverInfo?.result?.info) {
+                this.serverInfo = serverInfo.result.info;
+                if (typeof this.serverInfo?.clio_version === "string") {
+                    if (!this.types.includes("clio")) {
+                        this.types.push("clio");
+                    }
+                }
+                else {
+                    const index = this.types.indexOf("clio");
+                    if (index !== -1) {
+                        this.types.splice(index, 1);
+                    }
+                }
+            }
+        }
+        catch (_err) {
+        }
+        this.serverInfoUpdating = false;
+    }
+    connectionValidation(event) {
+        this.logger?.debug({
+            service: "Bithomp::XRPL::Connection",
+            function: "connectionValidation",
+            event,
+            url: this.url,
+            shutdown: this.shutdown,
+        });
+        this.removeWatchTimer();
+        if (this.shutdown) {
+            this.removeClient();
+            return;
+        }
+        this.connectionWatchTimer = setTimeout(this.bindConnectionWatchTimeout, LEDGER_CLOSED_TIMEOUT);
+        if (this.streamsSubscribed === false) {
+            this.subscribe();
+        }
+        if (this.serverInfo === null && this.isConnected()) {
+            this.updateServerInfo();
+        }
+    }
+    async connectionWatchTimeout() {
+        this.logger?.debug({
+            service: "Bithomp::XRPL::Connection",
+            function: "connectionWatchTimeout",
+            url: this.url,
+            timeout: LEDGER_CLOSED_TIMEOUT,
+            shutdown: this.shutdown,
+        });
+        this.connectionWatchTimer = null;
+        this.updateLatency(LEDGER_CLOSED_TIMEOUT);
+        try {
+            await this.reconnect();
+        }
+        catch (e) {
+            this.logger?.warn({
+                service: "Bithomp::XRPL::Connection",
+                function: "connectionWatchTimeout",
+                url: this.url,
+                error: e.message,
+            });
+            this.connectionWatchTimer = setTimeout(this.bindConnectionWatchTimeout, RECONNECT_TIMEOUT);
+        }
+    }
+}
+exports.Connection = Connection;

package/lib/src/faucet.d.ts

@@ -0,0 +1,58 @@
+interface FaucetNetworkInterface {
+    url: string;
+    format?: string;
+}
+interface AxiosFaucetOptionsDataInterface {
+    destination: string;
+}
+interface AxiosFaucetOptionsInterface {
+    method: string;
+    url: string;
+    data?: AxiosFaucetOptionsDataInterface;
+}
+interface XrplLabsSuccessResponseInterface {
+    address: string;
+    secret: string;
+    xrp: number;
+    hash: string;
+    code: string;
+}
+interface XrplSuccessResponseAccountInterface {
+    xAddress: string;
+    secret?: string;
+    classicAddress: string;
+    address: string;
+}
+interface XrplSuccessResponseInterface {
+    account: XrplSuccessResponseAccountInterface;
+    amount: number;
+    balance: number;
+    hash?: string;
+}
+export declare const FaucetNetworks: {
+    test: {
+        url: string;
+        format: string;
+    };
+    dev: {
+        url: string;
+        format: string;
+    };
+    alphanet: {
+        url: string;
+        format: string;
+    };
+    "xahau-test": {
+        url: string;
+        format: string;
+    };
+    "xahau-jshooks": {
+        url: string;
+        format: string;
+    };
+};
+export declare function getFaucetNetwork(network: string): FaucetNetworkInterface | undefined;
+export declare function foundWallet(network: string | FaucetNetworkInterface, account?: string): Promise<any>;
+export declare function getAxiosFaucetOptions(network: FaucetNetworkInterface, account?: string): AxiosFaucetOptionsInterface;
+export declare function xrplLabsToXrplResponse(data: XrplLabsSuccessResponseInterface): XrplSuccessResponseInterface;
+export {};