@bithomp/xrpl-api 2.3.6

package/lib/ledger/account_lines.js

@@ -0,0 +1,69 @@
+"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.getAccountLines = void 0;
+const Client = __importStar(require("../client"));
+const utils_1 = require("../common/utils");
+async function getAccountLines(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_lines",
+        account,
+        counterparty: options.counterparty,
+        currency: options.currency,
+        ledger_index: options.ledgerIndex || "validated",
+        limit: options.limit,
+    });
+    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;
+    const newMarker = (0, utils_1.createMarker)(connection.hash, result.marker);
+    if (newMarker) {
+        result.marker = newMarker;
+    }
+    return result;
+}
+exports.getAccountLines = getAccountLines;

package/lib/ledger/account_nfts.d.ts

@@ -0,0 +1,21 @@
+import { LedgerIndex } from "../models/ledger";
+import { ErrorResponse } from "../models/base_model";
+export interface GetAccountNftsOptions {
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: any;
+}
+export declare function getAccountNfts(account: string, options?: GetAccountNftsOptions): Promise<object[] | ErrorResponse>;
+interface FindAccountNftsOptions extends GetAccountNftsOptions {
+    timeout?: number;
+}
+export declare function findAccountNfts(account: string, options?: FindAccountNftsOptions): Promise<object[] | ErrorResponse>;
+export interface GetAccountNftSellOffersOptions {
+    ledgerIndex?: LedgerIndex;
+}
+export declare function getAccountNftSellOffers(nftID: string, options?: GetAccountNftSellOffersOptions): Promise<object[] | ErrorResponse>;
+export interface GetAccountNftBuyOffersOptions {
+    ledgerIndex?: LedgerIndex;
+}
+export declare function getAccountNftBuyOffers(nftID: string, options?: GetAccountNftBuyOffersOptions): Promise<object[] | object>;
+export {};

package/lib/ledger/account_nfts.js

@@ -0,0 +1,185 @@
+"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.getAccountNftBuyOffers = exports.getAccountNftSellOffers = exports.findAccountNfts = exports.getAccountNfts = void 0;
+const Client = __importStar(require("../client"));
+const account_nfts_1 = require("../models/account_nfts");
+const utils_1 = require("../common/utils");
+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, status, validated } = response;
+        return {
+            account,
+            error,
+            error_code,
+            error_message,
+            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;
+}
+exports.getAccountNfts = getAccountNfts;
+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, status, validated } = response;
+        return {
+            account,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    response.account_nfts = accountNfts;
+    return response;
+}
+exports.findAccountNfts = findAccountNfts;
+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, status, validated } = response;
+        return {
+            nft_id: nftID,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    return response?.result;
+}
+exports.getAccountNftSellOffers = getAccountNftSellOffers;
+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, status, validated } = response;
+        return {
+            nft_id: nftID,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    return response?.result;
+}
+exports.getAccountNftBuyOffers = getAccountNftBuyOffers;

package/lib/ledger/account_objects.d.ts

@@ -0,0 +1,28 @@
+import { AccountObjectType, AccountObjectsResponse, AccountNFTObjectsResponse } 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;
+}
+export declare function getAccountObjects(account: string, options?: GetAccountObjectsOptions): Promise<AccountObjectsResponse | ErrorResponse>;
+export interface GetAccountAllObjectsOptions extends GetAccountObjectsOptions {
+    timeout?: number;
+}
+export declare function getAccountAllObjects(account: string, options?: GetAccountAllObjectsOptions): Promise<AccountObjectsResponse | 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>;

package/lib/ledger/account_objects.js

@@ -0,0 +1,169 @@
+"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.getAccountNFTOffersObjects = exports.getAccountLinesObjects = exports.getAccountAllObjects = exports.getAccountObjects = void 0;
+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 = 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, status, validated } = response;
+        return {
+            account,
+            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.getAccountObjects = getAccountObjects;
+async function getAccountAllObjects(account, options = {}) {
+    const timeStart = new Date();
+    const limit = options.limit;
+    let response;
+    const accountObjects = [];
+    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) {
+            const left = limit - accountObjects.length;
+            const parts = Math.floor(left / OBJECTS_LIMIT_MAX);
+            if (parts === 0) {
+                options.limit = left;
+            }
+            else {
+                options.limit = left - OBJECTS_LIMIT_MIN;
+            }
+        }
+        response = await getAccountObjects(account, options);
+        if (response.error) {
+            return response;
+        }
+        accountObjects.push(...response.account_objects);
+        if (limit && accountObjects.length >= limit) {
+            response.limit = accountObjects.length;
+            break;
+        }
+        if (response.marker) {
+            options.marker = response.marker;
+        }
+        else {
+            break;
+        }
+    }
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            account,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    response.account_objects = accountObjects;
+    return response;
+}
+exports.getAccountAllObjects = getAccountAllObjects;
+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,
+    };
+}
+exports.getAccountLinesObjects = getAccountLinesObjects;
+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,
+    };
+}
+exports.getAccountNFTOffersObjects = getAccountNFTOffersObjects;

package/lib/ledger/account_offers.d.ts

@@ -0,0 +1,8 @@
+import { LedgerIndex } from "../models/ledger";
+import { ErrorResponse } from "../models/base_model";
+export interface GetAccountOffers {
+    ledgerIndex?: LedgerIndex;
+    limit?: number;
+    marker?: any;
+}
+export declare function getAccountOffers(account: string, options?: GetAccountOffers): Promise<object | ErrorResponse>;

package/lib/ledger/account_offers.js

@@ -0,0 +1,67 @@
+"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.getAccountOffers = void 0;
+const Client = __importStar(require("../client"));
+const utils_1 = require("../common/utils");
+async function getAccountOffers(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_offers",
+        account,
+        ledger_index: options.ledgerIndex || "validated",
+        limit: options.limit,
+    });
+    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;
+    const newMarker = (0, utils_1.createMarker)(connection.hash, result.marker);
+    if (newMarker) {
+        result.marker = newMarker;
+    }
+    return result;
+}
+exports.getAccountOffers = getAccountOffers;

package/lib/ledger/account_tx.d.ts

@@ -0,0 +1,29 @@
+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;
+}
+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;
+    includeRawTransactions?: boolean;
+}
+export declare function findTransactions(account: string, options?: FindTransactionsOptions): Promise<object[] | ErrorResponse>;