@bithomp/xrpl-api 2.3.6

package/lib/connection.js

@@ -0,0 +1,369 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = 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 LEDGER_CLOSED_TIMEOUT = 1000 * 15;
+class Connection extends events_1.EventEmitter {
+    constructor(url, type, options = {}) {
+        super();
+        this.shutdown = false;
+        this.connectionTimer = null;
+        this.shutdown = false;
+        this.url = url;
+        this.hash = crypto_1.default.createHash("sha256").update(url).digest("hex");
+        this.type = type;
+        if (typeof this.type === "string") {
+            this.types = this.type.split(",").map((v) => v.trim());
+        }
+        else {
+            this.types = [];
+        }
+        this.latency = [];
+        this.client = null;
+        this.logger = options.logger;
+        this.timeout = options.timeout;
+        this.connectionTimeout = options.connectionTimeout;
+        this.streams = {
+            ledger: 1,
+        };
+        this.accounts = {};
+        this.streamsSubscribed = false;
+    }
+    async connect() {
+        try {
+            if (this.client) {
+                this.client.disconnect();
+            }
+            this.client = new xrpl_1.Client(this.url, (0, common_1.removeUndefined)({ timeout: this.timeout, connectionTimeout: this.connectionTimeout }));
+            this.setupEmitter();
+            await this.client.connect();
+            await this.subscribe();
+        }
+        catch (err) {
+            this.logger?.warn({
+                service: "Bithomp::XRPL::Connection",
+                function: "connect",
+                url: this.url,
+                error: err?.message || err?.name || err,
+            });
+        }
+        this.connectionValidation();
+    }
+    async disconnect() {
+        this.shutdown = true;
+        await this.unsubscribe();
+        await this.client?.disconnect();
+        delete this.client;
+        clearTimeout(this.connectionTimer);
+    }
+    async request(request, options) {
+        try {
+            if (options?.skip_subscription_update !== true &&
+                (request.command === "subscribe" || request.command === "unsubscribe")) {
+                return this.updateSubscriptions(request);
+            }
+            if (!this.client || !this.isConnected()) {
+                return { error: "Not connected" };
+            }
+            const startDate = new Date();
+            const response = await this.client.request(request);
+            const endDate = new Date();
+            this.updateLatency(endDate.getTime() - startDate.getTime());
+            return response;
+        }
+        catch (err) {
+            this.updateLatency(1000);
+            this.logger?.debug({
+                service: "Bithomp::XRPL::Connection",
+                function: "request",
+                url: this.url,
+                error: err?.message || err?.name || err,
+            });
+            if (err.data) {
+                return err.data;
+            }
+            else {
+                return { error: err?.message || err?.name || err };
+            }
+        }
+    }
+    async submit(transaction) {
+        try {
+            return await this.request({ command: "submit", tx_blob: transaction, fail_hard: true });
+        }
+        catch (err) {
+            this.updateLatency(1000);
+            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;
+        }
+        return this.client.isConnected();
+    }
+    getLatencyMs() {
+        return this.latency.map((info) => info.delta).reduce((a, b) => a + b, 0) / this.latency.length || 0;
+    }
+    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) {
+            this.emit("reconnect");
+            try {
+                if (this.client) {
+                    await this.client.disconnect();
+                }
+                await this.connect();
+            }
+            catch (e) {
+                this.logger?.warn({
+                    service: "Bithomp::XRPL::Connection",
+                    function: "reconnect",
+                    error: e.message,
+                });
+            }
+            this.connectionValidation();
+        }
+    }
+    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.client.on("disconnected", (code) => {
+            this.logger?.debug({
+                service: "Bithomp::XRPL::Connection",
+                emit: "disconnected",
+                code,
+                url: this.url,
+            });
+            this.streamsSubscribed = false;
+            this.emit("disconnected", code);
+        });
+        this.client.on("error", (source, message, error) => {
+            this.logger?.error({
+                service: "Bithomp::XRPL::Connection",
+                emit: "error",
+                source,
+                error: message || error?.name || error,
+            });
+            try {
+                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) => {
+            const time = new Date().getTime();
+            const ledgerTime = (0, ledger_1.ledgerTimeToTimestamp)(ledgerStream.ledger_time);
+            if (ledgerTime < time) {
+                this.updateLatency(time - ledgerTime);
+            }
+            this.connectionValidation();
+            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("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);
+        });
+    }
+    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.streamsSubscribed === true && streams === undefined && accounts === undefined) {
+            return null;
+        }
+        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) {
+            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 });
+    }
+    connectionValidation() {
+        this.logger?.debug({
+            service: "Bithomp::XRPL::Connection",
+            function: "connectionValidation",
+            url: this.url,
+            shutdown: this.shutdown,
+        });
+        if (this.connectionTimer !== null) {
+            clearTimeout(this.connectionTimer);
+            this.connectionTimer = null;
+        }
+        if (!this.shutdown) {
+            if (this.streamsSubscribed === false) {
+                this.subscribe();
+            }
+            this.connectionTimer = setTimeout(() => {
+                this.connectionValidationTimeout();
+            }, LEDGER_CLOSED_TIMEOUT);
+        }
+        else {
+            this.client?.disconnect();
+        }
+    }
+    async connectionValidationTimeout() {
+        this.logger?.debug({
+            service: "Bithomp::XRPL::Connection",
+            function: "connectionValidationTimeout",
+            url: this.url,
+            timeout: LEDGER_CLOSED_TIMEOUT,
+            shutdown: this.shutdown,
+        });
+        this.connectionTimer = null;
+        this.updateLatency(LEDGER_CLOSED_TIMEOUT);
+        try {
+            await this.reconnect();
+        }
+        catch (e) {
+            this.logger?.warn({
+                service: "Bithomp::XRPL::Connection",
+                function: "connectionValidationTimeout",
+                error: e.message,
+            });
+            this.connectionValidation();
+        }
+    }
+}
+exports.Connection = Connection;

package/lib/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;
+    };
+    beta: {
+        url: string;
+        format: string;
+    };
+    "hooks-testnet-v3": {
+        url: string;
+        format: string;
+    };
+    amm: {
+        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 {};

package/lib/faucet.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xrplLabsToXrplResponse = exports.getAxiosFaucetOptions = exports.foundWallet = exports.getFaucetNetwork = exports.FaucetNetworks = void 0;
+const axios_1 = __importDefault(require("axios"));
+const AddressCodec = require("ripple-address-codec");
+exports.FaucetNetworks = {
+    test: {
+        url: "https://faucet.altnet.rippletest.net/accounts",
+        format: "xrpl",
+    },
+    dev: {
+        url: "https://faucet.devnet.rippletest.net/accounts",
+        format: "xrpl",
+    },
+    beta: {
+        url: "https://hooks-testnet-v3.xrpl-labs.com/newcreds",
+        format: "xrpl-labs",
+    },
+    "hooks-testnet-v3": {
+        url: "https://hooks-testnet-v3.xrpl-labs.com/newcreds",
+        format: "xrpl-labs",
+    },
+    amm: {
+        url: "https://ammfaucet.devnet.rippletest.net/accounts",
+        format: "xrpl",
+    },
+};
+function getFaucetNetwork(network) {
+    if (network in exports.FaucetNetworks) {
+        return exports.FaucetNetworks[network];
+    }
+    return undefined;
+}
+exports.getFaucetNetwork = getFaucetNetwork;
+async function foundWallet(network, account) {
+    if (typeof network === "string") {
+        network = getFaucetNetwork(network);
+    }
+    if (!network) {
+        throw new Error("Invalid network");
+    }
+    const options = getAxiosFaucetOptions(network, account);
+    const data = (await (0, axios_1.default)(options)).data;
+    if (network.format === "xrpl-labs" && data.code === "tesSUCCESS") {
+        return xrplLabsToXrplResponse(data);
+    }
+    return data;
+}
+exports.foundWallet = foundWallet;
+function getAxiosFaucetOptions(network, account) {
+    const options = {
+        method: "post",
+        url: network.url,
+    };
+    if (account) {
+        if (network.format === "xrpl-labs") {
+            options.url += `?account=${account}`;
+        }
+        else {
+            options.data = { destination: account };
+        }
+    }
+    return options;
+}
+exports.getAxiosFaucetOptions = getAxiosFaucetOptions;
+function xrplLabsToXrplResponse(data) {
+    const secret = data.secret === "" ? undefined : data.secret;
+    const balance = secret ? data.xrp : undefined;
+    const response = {
+        account: {
+            xAddress: AddressCodec.classicAddressToXAddress(data.address, false, true),
+            classicAddress: data.address,
+            address: data.address,
+        },
+        amount: data.xrp,
+        hash: data.hash,
+    };
+    if (secret) {
+        response.account.secret = secret;
+    }
+    if (balance) {
+        response.balance = balance;
+    }
+    return response;
+}
+exports.xrplLabsToXrplResponse = xrplLabsToXrplResponse;

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * as xrpl from "xrpl";
+export * as Client from "./client";
+export * as Models from "./models";
+export * as Wallet from "./wallet";
+export * as Faucet from "./faucet";
+export * as Validator from "./validator";
+export * as Parse from "./parse";
+export * as Common from "./common";
+export * as Types from "./types";

package/lib/index.js

@@ -0,0 +1,35 @@
+"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.Types = exports.Common = exports.Parse = exports.Validator = exports.Faucet = exports.Wallet = exports.Models = exports.Client = exports.xrpl = void 0;
+exports.xrpl = __importStar(require("xrpl"));
+exports.Client = __importStar(require("./client"));
+exports.Models = __importStar(require("./models"));
+exports.Wallet = __importStar(require("./wallet"));
+exports.Faucet = __importStar(require("./faucet"));
+exports.Validator = __importStar(require("./validator"));
+exports.Parse = __importStar(require("./parse"));
+exports.Common = __importStar(require("./common"));
+exports.Types = __importStar(require("./types"));

package/lib/ledger/account_info.d.ts

@@ -0,0 +1,12 @@
+import { Connection } from "../connection";
+import { LedgerIndex } from "../models/ledger";
+import { AccountInfoResponse, AccountInfoDataResponse } from "../models/account_info";
+import { ErrorResponse } from "../models/base_model";
+export interface GetAccountInfoOptions {
+    ledgerIndex?: LedgerIndex;
+    signerLists?: boolean;
+    connection?: Connection;
+}
+export declare function getAccountInfo(account: string, options?: GetAccountInfoOptions): Promise<AccountInfoResponse | ErrorResponse>;
+export declare function getAccountInfoData(account: string, options?: GetAccountInfoOptions): Promise<AccountInfoDataResponse | ErrorResponse>;
+export declare function isActivated(account: string): Promise<boolean>;

package/lib/ledger/account_info.js

@@ -0,0 +1,78 @@
+"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.isActivated = exports.getAccountInfoData = exports.getAccountInfo = void 0;
+const Client = __importStar(require("../client"));
+async function getAccountInfo(account, options = {}) {
+    const connection = Client.findConnection();
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "account_info",
+        account,
+        ledger_index: options.ledgerIndex || "validated",
+        signer_lists: !!options.signerLists,
+    });
+    if (!response) {
+        return {
+            account,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            account,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    return response?.result;
+}
+exports.getAccountInfo = getAccountInfo;
+async function getAccountInfoData(account, options = {}) {
+    const response = await getAccountInfo(account, options);
+    if ("error" in response) {
+        return response;
+    }
+    return response?.account_data;
+}
+exports.getAccountInfoData = getAccountInfoData;
+async function isActivated(account) {
+    const response = await getAccountInfo(account);
+    if (!response) {
+        return false;
+    }
+    if ("error" in response) {
+        return false;
+    }
+    return true;
+}
+exports.isActivated = isActivated;

package/lib/ledger/account_lines.d.ts

@@ -0,0 +1,11 @@
+import { LedgerIndex } from "../models/ledger";
+import { AccountLinesResponse } from "../models/account_lines";
+import { ErrorResponse } from "../models/base_model";
+export interface GetAccountLinesOptions {
+    counterparty?: string;
+    currency?: string;
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: any;
+}
+export declare function getAccountLines(account: string, options?: GetAccountLinesOptions): Promise<AccountLinesResponse | ErrorResponse>;