@bithomp/xrpl-api 2.3.6

package/lib/ledger/account_tx.js

@@ -0,0 +1,256 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTransactions = exports.getTransactions = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const xrpl_1 = require("xrpl");
+const Client = __importStar(require("../client"));
+const utils_1 = require("../common/utils");
+const transaction_1 = require("../models/transaction");
+const MAX_LIMIT = 1000;
+const DEFAULT_LIMIT = 200;
+const MAX_LIMIT_WITH_FILTER = 20;
+const MAX_LIMIT_WITH_TAG = 3;
+const LIMIT_INCREASE_COUNT = 10;
+async function getTransactions(account, options = { limit: DEFAULT_LIMIT }) {
+    const { hash, marker } = (0, utils_1.parseMarker)(options.marker);
+    options.marker = marker;
+    const connection = Client.findConnection("history", undefined, undefined, hash);
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "account_tx",
+        account,
+        ledger_index_min: options.ledgerIndexMin,
+        ledger_index_max: options.ledgerIndexMax,
+        ledger_hash: options.ledgerHash,
+        ledger_index: options.ledgerIndex,
+        binary: !!options.binary,
+        forward: !!options.forward,
+        limit: options.limit,
+        marker: options.marker,
+    });
+    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,
+        };
+    }
+    const result = response?.result;
+    if (Array.isArray(result.transactions)) {
+        if (options.balanceChanges === true || options.specification === true) {
+            for (const transaction of result.transactions) {
+                if (options.balanceChanges === true) {
+                    transaction.balanceChanges = (0, xrpl_1.getBalanceChanges)(transaction.meta);
+                }
+                if (options.specification === true) {
+                    const details = (0, transaction_1.getAccountTxDetails)(transaction, true);
+                    transaction.specification = details.specification;
+                    transaction.outcome = details.outcome;
+                    transaction.rawTransaction = details.rawTransaction;
+                }
+            }
+        }
+    }
+    const newMarker = (0, utils_1.createMarker)(connection.hash, result.marker);
+    if (newMarker) {
+        result.marker = newMarker;
+    }
+    return result;
+}
+exports.getTransactions = getTransactions;
+async function findTransactions(account, options = { limit: DEFAULT_LIMIT, timeout: 15000 }) {
+    let transactions = [];
+    let accountTransactionsError = null;
+    const formatted = options.legacy === true || options.formatted === true;
+    const timeStart = new Date();
+    options.binary = false;
+    applyLimitOptions(options);
+    await applyStartTxOptions(options);
+    while (transactions.length !== options.limit) {
+        const currentTime = new Date();
+        if (options.timeout && currentTime.getTime() - timeStart.getTime() > options.timeout) {
+            break;
+        }
+        let limit = options.limit;
+        if (transactions.length === 0 && options.startTxHash) {
+            limit += LIMIT_INCREASE_COUNT;
+        }
+        if (options.sourceTag || options.destinationTag) {
+            limit += LIMIT_INCREASE_COUNT;
+        }
+        if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT;
+        }
+        const accountTransactions = await getTransactions(account, {
+            ...options,
+            ...{ balanceChanges: false, specification: false, limit },
+        });
+        if (!accountTransactions || accountTransactions.error) {
+            accountTransactionsError = accountTransactions;
+            break;
+        }
+        let newTransactions = accountTransactions.transactions;
+        options.marker = accountTransactions.marker;
+        newTransactions = newTransactions
+            .filter(lodash_1.default.partial(filterHelperTransactions, account, options))
+            .filter(lodash_1.default.partial(filterHelperStartTx, options));
+        if (formatted !== true && (options.balanceChanges === true || options.specification === true)) {
+            for (const newTransaction of newTransactions) {
+                if (options.balanceChanges === true) {
+                    newTransaction.balanceChanges = (0, xrpl_1.getBalanceChanges)(newTransaction.meta);
+                }
+                if (options.specification === true) {
+                    const details = (0, transaction_1.getAccountTxDetails)(newTransaction, true);
+                    newTransaction.specification = details.specification;
+                    newTransaction.outcome = details.outcome;
+                    newTransaction.rawTransaction = details.rawTransaction;
+                }
+            }
+        }
+        transactions = transactions.concat(newTransactions);
+        transactions = transactions.slice(0, options.limit);
+        if (options.marker === undefined) {
+            break;
+        }
+    }
+    if (accountTransactionsError) {
+        return accountTransactionsError;
+    }
+    if (options.marker && transactions.length === 0) {
+        return {
+            status: "timeout",
+            error: "searchTimeout",
+            marker: options.marker,
+        };
+    }
+    if (formatted === true) {
+        transactions = transactions.map((transaction) => (0, transaction_1.getAccountTxDetails)(transaction, options.includeRawTransactions === true));
+    }
+    return transactions;
+}
+exports.findTransactions = findTransactions;
+function applyLimitOptions(options) {
+    if (options.sourceTag > 0 || options.destinationTag > 0) {
+        if (options.limit > MAX_LIMIT_WITH_TAG) {
+            options.limit = MAX_LIMIT_WITH_TAG;
+        }
+    }
+    else if (options.types || options.initiated || options.counterparty) {
+        if (options.limit > MAX_LIMIT_WITH_FILTER) {
+            options.limit = MAX_LIMIT_WITH_FILTER;
+        }
+    }
+}
+async function applyStartTxOptions(options) {
+    if (options.startTxHash) {
+        const accountTransaction = await Client.getTransaction(options.startTxHash);
+        if (accountTransaction && !accountTransaction.error) {
+            options.startTx = {
+                tx: accountTransaction,
+                meta: accountTransaction.meta,
+            };
+            if (options.forward === true) {
+                options.ledgerIndexMin = options.startTx.tx.ledger_index;
+            }
+            else {
+                options.ledgerIndexMax = options.startTx.tx.ledger_index;
+            }
+        }
+    }
+}
+function filterHelperStartTx(options, transaction) {
+    return (!options.startTx ||
+        (options.forward === true
+            ? (0, utils_1.compareTransactions)(transaction, options.startTx) > 0
+            : (0, utils_1.compareTransactions)(transaction, options.startTx) < 0));
+}
+function filterHelperTransactions(account, options, transaction) {
+    if (transaction.validated === false) {
+        return false;
+    }
+    if (options.excludeFailures === true && transaction.meta.TransactionResult !== "tesSUCCESS") {
+        return false;
+    }
+    if (options.types && !options.types.includes(transaction.tx.TransactionType)) {
+        return false;
+    }
+    if (options.initiated === true && transaction.tx.Account !== account) {
+        return false;
+    }
+    if (options.initiated === false && transaction.tx.Account === account) {
+        return false;
+    }
+    if (options.counterparty && !counterpartyFilter(options, transaction)) {
+        return false;
+    }
+    if (typeof options.sourceTag === "number" && transaction.tx.SourceTag !== options.sourceTag) {
+        return false;
+    }
+    if (typeof options.destinationTag === "number" && transaction.tx.DestinationTag !== options.destinationTag) {
+        return false;
+    }
+    return true;
+}
+function counterpartyFilter(options, transaction) {
+    if (transaction.tx.Account === options.counterparty) {
+        return true;
+    }
+    if (transaction.tx.Destination === options.counterparty) {
+        return true;
+    }
+    if (transaction.tx.Amount?.issuer === options.counterparty) {
+        return true;
+    }
+    if (transaction.tx.SendMax?.issuer === options.counterparty) {
+        return true;
+    }
+    if (transaction.tx.LimitAmount?.issuer === options.counterparty) {
+        return true;
+    }
+    if (transaction.tx.Issuer === options.counterparty) {
+        return true;
+    }
+    if (transaction.tx.NFTokenMinter === options.counterparty) {
+        return true;
+    }
+    return false;
+}

package/lib/ledger/book_offers.d.ts

@@ -0,0 +1,11 @@
+import { LedgerIndex } from "../models/ledger";
+import { OrderbookInfo } from "../models/book_offers";
+import { IssuedCurrency } from "../types";
+import { ErrorResponse } from "../models/base_model";
+export interface GetGetBookOffers {
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: any;
+}
+export declare function getBookOffers(taker: string, takerGets: IssuedCurrency, takerPays: IssuedCurrency, options?: GetGetBookOffers): Promise<object | ErrorResponse>;
+export declare function getOrderbook(taker: string, orderbook: OrderbookInfo, options?: GetGetBookOffers): Promise<object | ErrorResponse>;

package/lib/ledger/book_offers.js

@@ -0,0 +1,90 @@
+"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.getOrderbook = exports.getBookOffers = void 0;
+const Client = __importStar(require("../client"));
+const book_offers_1 = require("../models/book_offers");
+const utils_1 = require("../common/utils");
+async function getBookOffers(taker, takerGets, takerPays, options = {}) {
+    const { hash, marker } = (0, utils_1.parseMarker)(options.marker);
+    options.marker = marker;
+    const connection = Client.findConnection(undefined, undefined, undefined, hash);
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "book_offers",
+        taker,
+        taker_gets: takerGets,
+        taker_pays: takerPays,
+        ledger_index: options.ledgerIndex || "validated",
+        limit: options.limit,
+    });
+    if (!response) {
+        return {
+            taker,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            taker,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    const result = response.result;
+    const newMarker = (0, utils_1.createMarker)(connection.hash, result.marker);
+    if (newMarker) {
+        result.marker = newMarker;
+    }
+    return result;
+}
+exports.getBookOffers = getBookOffers;
+function convertIssueToTakerAmount(obj) {
+    const issuer = obj.counterparty != null ? obj.counterparty : obj.issuer != null ? obj.issuer : undefined;
+    const withIssuer = Object.assign({}, obj, { issuer });
+    delete withIssuer.counterparty;
+    return withIssuer;
+}
+async function getOrderbook(taker, orderbook, options = {}) {
+    const [directOfferResults, reverseOfferResults] = await Promise.all([
+        getBookOffers(taker, convertIssueToTakerAmount(orderbook.base), convertIssueToTakerAmount(orderbook.counter), options),
+        getBookOffers(taker, convertIssueToTakerAmount(orderbook.counter), convertIssueToTakerAmount(orderbook.base), options),
+    ]);
+    if (directOfferResults.error) {
+        return directOfferResults;
+    }
+    if (reverseOfferResults.error) {
+        return reverseOfferResults;
+    }
+    return (0, book_offers_1.formatBidsAndAsks)(orderbook, [...directOfferResults.offers, ...reverseOfferResults.offers]);
+}
+exports.getOrderbook = getOrderbook;

package/lib/ledger/currency.d.ts

@@ -0,0 +1,27 @@
+export declare function parseCurrencyInformation(currency: any): Promise<null | DecodeHexCurrencyInterface | DecodedNFTCurrencyInterface>;
+interface DecodedNFTCurrencyInterface {
+    type: string;
+    currencyCode: string;
+    currency: string;
+    cti: number;
+    ctiLedger: number;
+    ctiTxIndex: number;
+    ctiValid: boolean;
+    ctiVerified: boolean;
+    timestamp?: number;
+    ctiTx: DecodedNFTCurrencyTransactionInterface;
+}
+interface DecodedNFTCurrencyTransactionInterface {
+    type?: string;
+    account?: string;
+    destination?: string;
+    counterparty?: string;
+    hash?: string;
+    memos?: string;
+}
+interface DecodeHexCurrencyInterface {
+    type: string;
+    currencyCode: string;
+    currency: string;
+}
+export {};

package/lib/ledger/currency.js

@@ -0,0 +1,167 @@
+"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.parseCurrencyInformation = void 0;
+const Client = __importStar(require("../client"));
+const utils_1 = require("../parse/utils");
+const transaction_1 = require("../parse/transaction");
+const maxLength = 12;
+async function parseCurrencyInformation(currency) {
+    if (!currency || typeof currency !== "string") {
+        return null;
+    }
+    if (currency.length < 3) {
+        return null;
+    }
+    if (currency.length === 3 && currency.trim().toLowerCase() !== "xrp") {
+        return decodeSimple(currency);
+    }
+    if (isHex(currency)) {
+        return await decodeCurrencyHex(currency);
+    }
+    return null;
+}
+exports.parseCurrencyInformation = parseCurrencyInformation;
+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 {
+        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 = {
+                    type,
+                    account,
+                    destination,
+                    counterparty: limit?.issuer,
+                    hash,
+                    memos,
+                };
+                break;
+            }
+        }
+    }
+    if (ledger) {
+        ctiVerified = true;
+        if (ctiTx.hash) {
+            ctiValid =
+                ctiLedgerCheck(cti) === ctiLedgerCheckGen(ledger.hash) &&
+                    ctiTransactionCheck(cti) === ctiTransactionCheckGen(ctiTx.hash);
+        }
+    }
+    else if (ledgerInfo.error === "lgrNotFound") {
+        ctiVerified = true;
+    }
+    return {
+        type: "nft",
+        currencyCode,
+        currency,
+        cti: Number(cti),
+        ctiLedger,
+        ctiTxIndex,
+        ctiValid,
+        ctiVerified,
+        timestamp,
+        ctiTx,
+    };
+}
+function decodeHex(currencyHex) {
+    const decodedHex = (0, utils_1.hexToString)(currencyHex)?.slice(0, maxLength)?.trim();
+    if (decodedHex.match(/[a-zA-Z0-9]{3,}/) && decodedHex.toLowerCase() !== "xrp") {
+        return {
+            type: "hex",
+            currencyCode: currencyHex,
+            currency: decodedHex.trim().replace(/\0/g, ""),
+        };
+    }
+    return null;
+}
+async function getLedger(ledgerIndex) {
+    let ledgerInfo = null;
+    try {
+        ledgerInfo = await Client.getLedger({ ledgerIndex, transactions: true, expand: true });
+    }
+    catch (e) {
+    }
+    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.toLowerCase() !== "xrp") {
+        return true;
+    }
+    return false;
+}
+function isHex(currencyCode) {
+    return !!currencyCode.match(/^[a-fA-F0-9]{40}$/) && !isNaN(parseInt(currencyCode, 16));
+}

package/lib/ledger/fee.d.ts

@@ -0,0 +1,5 @@
+import { Connection } from "../connection";
+export interface GetFeeOptions {
+    connection?: Connection;
+}
+export declare function getFee(options?: GetFeeOptions): Promise<string | null>;

package/lib/ledger/fee.js

@@ -0,0 +1,45 @@
+"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.getFee = void 0;
+const bignumber_js_1 = require("bignumber.js");
+const Client = __importStar(require("../client"));
+const common_1 = require("../common");
+async function getFee(options = {}) {
+    const connection = options.connection || Client.findConnection();
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "fee",
+    });
+    const baseFee = response?.result?.drops?.base_fee;
+    if (!baseFee) {
+        return null;
+    }
+    const fee = new bignumber_js_1.BigNumber(baseFee).multipliedBy(Client.feeCushion).dividedBy(common_1.dropsInXRP);
+    return fee.toString();
+}
+exports.getFee = getFee;

package/lib/ledger/gateway_balances.d.ts

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