@bithomp/xrpl-api 3.7.31 → 3.7.37

package/lib/src/ledger/account_nfts.js

@@ -0,0 +1,199 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountNfts = getAccountNfts;
+exports.findAccountNfts = findAccountNfts;
+exports.getAccountNftSellOffers = getAccountNftSellOffers;
+exports.getAccountNftBuyOffers = getAccountNftBuyOffers;
+const Client = __importStar(require("../client"));
+const account_nfts_1 = require("../models/account_nfts");
+const utils_1 = require("../common/utils");
+const common_1 = require("../common");
+async function getAccountNfts(account, 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: "account_nfts",
+        account,
+        ledger_index: options.ledgerIndex || "validated",
+        marker: options.marker,
+    });
+    if (!response) {
+        return {
+            account,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, common_1.removeUndefined)({
+            account,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    const result = response?.result;
+    if (!result) {
+        return {
+            account,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (Array.isArray(result.account_nfts)) {
+        result.account_nfts = result.account_nfts.sort(account_nfts_1.sortHelperAccountNFToken);
+    }
+    const newMarker = (0, utils_1.createMarker)(connection.hash, result.marker);
+    if (newMarker) {
+        result.marker = newMarker;
+    }
+    return result;
+}
+async function findAccountNfts(account, options = { timeout: 15000 }) {
+    const timeStart = new Date();
+    const limit = options.limit;
+    let response;
+    const accountNfts = [];
+    while (true) {
+        const currentTime = new Date();
+        if (options.timeout && currentTime.getTime() - timeStart.getTime() > options.timeout) {
+            options.timeout = currentTime.getTime() - timeStart.getTime();
+            break;
+        }
+        if (options.limit && limit) {
+            options.limit = limit - accountNfts.length;
+        }
+        response = await getAccountNfts(account, options);
+        if (!response || response.error) {
+            return response;
+        }
+        accountNfts.push(...response.account_nfts);
+        if (limit && accountNfts.length >= limit) {
+            response.limit = accountNfts.length;
+            break;
+        }
+        if (response.marker) {
+            options.marker = response.marker;
+        }
+        else {
+            break;
+        }
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, common_1.removeUndefined)({
+            account,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    response.account_nfts = accountNfts;
+    return response;
+}
+async function getAccountNftSellOffers(nftID, options = {}) {
+    const connection = Client.findConnection("!clio");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "nft_sell_offers",
+        nft_id: nftID,
+        ledger_index: options.ledgerIndex || "validated",
+    });
+    if (!response) {
+        return {
+            nft_id: nftID,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, common_1.removeUndefined)({
+            nft_id: nftID,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    return response?.result;
+}
+async function getAccountNftBuyOffers(nftID, options = {}) {
+    const connection = Client.findConnection("!clio");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "nft_buy_offers",
+        nft_id: nftID,
+        ledger_index: options.ledgerIndex || "validated",
+    });
+    if (!response) {
+        return {
+            nft_id: nftID,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, common_1.removeUndefined)({
+            nft_id: nftID,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    return response?.result;
+}

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

@@ -0,0 +1,44 @@
+import { Connection } from "../connection";
+import { AccountObjectType, AccountObjects, AccountNFTObjectsResponse, AccountURITokensObjectsResponse } from "../models/account_object";
+import { AccountLinesResponse } from "../models/account_lines";
+import { ErrorResponse } from "../models/base_model";
+import { LedgerIndex } from "../models/ledger";
+export interface GetAccountObjectsOptions {
+    type?: AccountObjectType;
+    ledgerHash?: string;
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: string;
+    connection?: Connection;
+}
+export declare function getAccountObjects(account: string, options?: GetAccountObjectsOptions): Promise<AccountObjects | ErrorResponse>;
+export interface GetAccountAllObjectsOptions extends GetAccountObjectsOptions {
+    timeout?: number;
+}
+export declare function getAccountAllObjects(account: string, options?: GetAccountAllObjectsOptions): Promise<AccountObjects | ErrorResponse>;
+export interface GetAccountLinesObjectsOptions {
+    ledgerHash?: string;
+    ledgerIndex?: LedgerIndex;
+}
+export declare function getAccountLinesObjects(account: string, options?: GetAccountLinesObjectsOptions): Promise<AccountLinesResponse | ErrorResponse>;
+export interface GetAccountNFTOffersObjectsOptions {
+    ledgerHash?: string;
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: string;
+}
+export declare function getAccountNFTOffersObjects(account: string, options?: GetAccountNFTOffersObjectsOptions): Promise<AccountNFTObjectsResponse | ErrorResponse>;
+export interface GetAccountDepositPreauthObjectsOptions {
+    ledgerHash?: string;
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: string;
+}
+export declare function getAccountDepositPreauthObjects(account: string, options?: GetAccountDepositPreauthObjectsOptions): Promise<any | ErrorResponse>;
+export interface GetAccountURITokensObjectsOptions {
+    ledgerHash?: string;
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: string;
+}
+export declare function getAccountURITokensObjects(account: string, options?: GetAccountURITokensObjectsOptions): Promise<AccountURITokensObjectsResponse | ErrorResponse>;

package/lib/src/ledger/account_objects.js

@@ -0,0 +1,222 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountObjects = getAccountObjects;
+exports.getAccountAllObjects = getAccountAllObjects;
+exports.getAccountLinesObjects = getAccountLinesObjects;
+exports.getAccountNFTOffersObjects = getAccountNFTOffersObjects;
+exports.getAccountDepositPreauthObjects = getAccountDepositPreauthObjects;
+exports.getAccountURITokensObjects = getAccountURITokensObjects;
+const Client = __importStar(require("../client"));
+const account_object_1 = require("../models/account_object");
+const utils_1 = require("../common/utils");
+const OBJECTS_LIMIT_DEFAULT = 200;
+const OBJECTS_LIMIT_MAX = 400;
+const OBJECTS_LIMIT_MIN = 10;
+async function getAccountObjects(account, options = {}) {
+    const { hash, marker } = (0, utils_1.parseMarker)(options.marker);
+    options.marker = marker;
+    const connection = options.connection || Client.findConnection("account_objects", undefined, undefined, hash);
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const request = {
+        command: "account_objects",
+        account,
+        type: options.type,
+        ledger_hash: options.ledgerHash,
+        ledger_index: options.ledgerIndex || "validated",
+        limit: options.limit || OBJECTS_LIMIT_DEFAULT,
+        marker: options.marker,
+    };
+    const response = await connection.request(request);
+    if (!response) {
+        return {
+            account,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, utils_1.removeUndefined)({
+            account,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    const result = response.result;
+    const newMarker = (0, utils_1.createMarker)(connection.hash, result.marker);
+    if (newMarker) {
+        result.marker = newMarker;
+    }
+    return result;
+}
+async function getAccountAllObjects(account, options = {}) {
+    const loadOptions = { ...options };
+    loadOptions.connection =
+        loadOptions.connection || Client.findConnection("account_objects", undefined, undefined);
+    const timeStart = new Date();
+    const limit = loadOptions.limit;
+    let response;
+    const accountObjects = [];
+    while (true) {
+        const currentTime = new Date();
+        if (loadOptions.timeout && currentTime.getTime() - timeStart.getTime() > loadOptions.timeout) {
+            loadOptions.timeout = currentTime.getTime() - timeStart.getTime();
+            break;
+        }
+        if (loadOptions.limit && limit) {
+            const left = limit - accountObjects.length;
+            const parts = Math.floor(left / OBJECTS_LIMIT_MAX);
+            if (parts === 0) {
+                loadOptions.limit = left;
+            }
+            else {
+                loadOptions.limit = left - OBJECTS_LIMIT_MIN;
+            }
+        }
+        response = await getAccountObjects(account, loadOptions);
+        if (response.error) {
+            return response;
+        }
+        accountObjects.push(...response.account_objects);
+        if (limit && accountObjects.length >= limit) {
+            response.limit = accountObjects.length;
+            break;
+        }
+        if (response.marker) {
+            loadOptions.marker = response.marker;
+        }
+        else {
+            break;
+        }
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, utils_1.removeUndefined)({
+            account,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    response.account_objects = accountObjects;
+    if (!options.hasOwnProperty("limit") || options.limit === undefined) {
+        delete response.limit;
+    }
+    return response;
+}
+async function getAccountLinesObjects(account, options = {}) {
+    const response = await getAccountAllObjects(account, {
+        type: "state",
+        ledgerHash: options.ledgerHash,
+        ledgerIndex: options.ledgerIndex,
+    });
+    if ("error" in response) {
+        return response;
+    }
+    const accountObjects = response.account_objects;
+    const accountLines = (0, account_object_1.accountObjectsToAccountLines)(account, accountObjects);
+    return {
+        account: response.account,
+        ledger_hash: response.ledger_hash,
+        ledger_index: response.ledger_index,
+        validated: response.validated,
+        lines: accountLines,
+    };
+}
+async function getAccountNFTOffersObjects(account, options = {}) {
+    const response = await getAccountAllObjects(account, {
+        type: "nft_offer",
+        ledgerHash: options.ledgerHash,
+        ledgerIndex: options.ledgerIndex,
+        limit: options.limit,
+        marker: options.marker,
+    });
+    if ("error" in response) {
+        return response;
+    }
+    const accountObjects = response.account_objects;
+    const nftOffers = (0, account_object_1.accountObjectsToNFTOffers)(accountObjects);
+    return {
+        account: response.account,
+        ledger_hash: response.ledger_hash,
+        ledger_index: response.ledger_index,
+        validated: response.validated,
+        nft_offers: nftOffers,
+    };
+}
+async function getAccountDepositPreauthObjects(account, options = {}) {
+    const response = await getAccountAllObjects(account, {
+        type: "deposit_preauth",
+        ledgerHash: options.ledgerHash,
+        ledgerIndex: options.ledgerIndex,
+        limit: options.limit,
+        marker: options.marker,
+    });
+    if ("error" in response) {
+        return response;
+    }
+    return response;
+}
+async function getAccountURITokensObjects(account, options = {}) {
+    const response = await getAccountAllObjects(account, {
+        type: "uri_token",
+        ledgerHash: options.ledgerHash,
+        ledgerIndex: options.ledgerIndex,
+        limit: options.limit,
+        marker: options.marker,
+    });
+    if ("error" in response) {
+        return response;
+    }
+    const accountObjects = response.account_objects;
+    const uritokens = (0, account_object_1.accountObjectsToURITokens)(accountObjects);
+    return {
+        account: response.account,
+        ledger_hash: response.ledger_hash,
+        ledger_index: response.ledger_index,
+        validated: response.validated,
+        uritokens: uritokens,
+    };
+}

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

@@ -0,0 +1,13 @@
+import { LedgerIndex } from "../models/ledger";
+import { AccountOffers } from "../models/account_offers";
+import { ErrorResponse } from "../models/base_model";
+import { FormattedAccountOrders } from "../parse/ledger/account-order";
+export interface GetAccountOffers {
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: any;
+    legacy?: boolean;
+    formatted?: boolean;
+}
+export declare function getAccountOffers(account: string, options?: GetAccountOffers): Promise<AccountOffers | FormattedAccountOrders | ErrorResponse>;
+export declare function getAccountAllOffers(account: string, options?: GetAccountOffers): Promise<AccountOffers | FormattedAccountOrders | ErrorResponse>;

package/lib/src/ledger/account_offers.js

@@ -0,0 +1,142 @@
+"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.getAccountOffers = getAccountOffers;
+exports.getAccountAllOffers = getAccountAllOffers;
+const lodash_1 = __importDefault(require("lodash"));
+const Client = __importStar(require("../client"));
+const utils_1 = require("../common/utils");
+const account_order_1 = require("../parse/ledger/account-order");
+const common_1 = require("../common");
+const OFFERS_LIMIT_MAX = 400;
+async function getAccountOffers(account, options = {}) {
+    const formatted = options.legacy === true || options.formatted === true;
+    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: "account_offers",
+        account,
+        ledger_index: options.ledgerIndex || "validated",
+        limit: options.limit,
+        marker: options.marker,
+    });
+    if (!response) {
+        return {
+            account,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, common_1.removeUndefined)({
+            account,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    const result = response.result;
+    const newMarker = (0, utils_1.createMarker)(connection.hash, result.marker);
+    if (newMarker) {
+        result.marker = newMarker;
+    }
+    if (formatted === true) {
+        result.offers = formatResponse(account, result.offers);
+    }
+    return result;
+}
+async function getAccountAllOffers(account, options = {}) {
+    const limit = options.limit;
+    let response;
+    const accountOffers = [];
+    while (true) {
+        if (options.limit && limit) {
+            const left = limit - accountOffers.length;
+            const parts = Math.floor(left / OFFERS_LIMIT_MAX);
+            if (parts === 0) {
+                options.limit = left;
+            }
+            else {
+                options.limit = left;
+            }
+        }
+        response = await getAccountOffers(account, options);
+        if (response.error) {
+            return response;
+        }
+        accountOffers.push(...response.offers);
+        if (limit && accountOffers.length >= limit) {
+            response.limit = accountOffers.length;
+            break;
+        }
+        if (response.marker) {
+            options.marker = response.marker;
+        }
+        else {
+            break;
+        }
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, common_1.removeUndefined)({
+            account,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    response.offers = accountOffers;
+    return response;
+}
+function formatResponse(address, offers) {
+    const orders = offers.map((offer) => {
+        return (0, account_order_1.parseAccountOrder)(address, offer);
+    });
+    return lodash_1.default.sortBy(orders, (order) => order.properties.sequence);
+}

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

@@ -0,0 +1,37 @@
+import { LedgerIndex } from "../models/ledger";
+import { ErrorResponse } from "../models/base_model";
+export interface GetTransactionsOptions {
+    ledgerIndexMin?: number;
+    ledgerIndexMax?: number;
+    ledgerHash?: string;
+    ledgerIndex?: LedgerIndex;
+    binary?: boolean;
+    forward?: boolean;
+    limit: number;
+    marker?: any;
+    balanceChanges?: boolean;
+    specification?: boolean;
+    includeRawTransactions?: boolean;
+}
+export declare function getTransactions(account: string, options?: GetTransactionsOptions): Promise<object | ErrorResponse>;
+export interface FindTransactionsOptions extends GetTransactionsOptions {
+    startTxHash?: string;
+    excludeFailures?: boolean;
+    initiated?: boolean;
+    counterparty?: string;
+    types?: string[];
+    sourceTag?: number;
+    destinationTag?: number;
+    timeout?: number;
+    legacy?: boolean;
+    formatted?: boolean;
+}
+interface FindTransactionsResponse {
+    account: string;
+    transactions: any[];
+    marker?: any;
+    validated?: boolean;
+}
+export declare function findTransactionsExt(account: string, options?: FindTransactionsOptions): Promise<FindTransactionsResponse | ErrorResponse>;
+export declare function findTransactions(account: string, options?: FindTransactionsOptions): Promise<object[] | ErrorResponse>;
+export {};