@bithomp/xrpl-api 2.3.6

package/lib/ledger/gateway_balances.js

@@ -0,0 +1,101 @@
+"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.getAccountObligations = exports.getBalanceSheet = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const Client = __importStar(require("../client"));
+async function getBalanceSheet(account, options = {}) {
+    const connection = Client.findConnection("gateway_balances");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "gateway_balances",
+        account,
+        ledger_index: options.ledgerIndex || "validated",
+        hotwallet: options.hotwallet,
+        strict: !!options.strict,
+    });
+    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.getBalanceSheet = getBalanceSheet;
+async function getAccountObligations(account) {
+    const response = (await getBalanceSheet(account));
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            account,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    const obligations = response.obligations;
+    const obligationsLines = [];
+    lodash_1.default.map(obligations, (value, currency) => {
+        obligationsLines.push(ObligationToObligationTrustline(account, value, currency));
+    });
+    delete response.obligations;
+    delete response.assets;
+    response.lines = obligationsLines;
+    return response;
+}
+exports.getAccountObligations = getAccountObligations;
+function ObligationToObligationTrustline(account, value, currency) {
+    return {
+        account,
+        currency,
+        balance: new bignumber_js_1.default(-value).toString(),
+        limit: "0",
+        limit_peer: "0",
+        quality_in: 0,
+        quality_out: 0,
+        obligation: true,
+    };
+}

package/lib/ledger/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./account_info";
+export * from "./account_lines";
+export * from "./account_nfts";
+export * from "./account_objects";
+export * from "./account_offers";
+export * from "./account_tx";
+export * from "./book_offers";
+export * from "./currency";
+export * from "./fee";
+export * from "./gateway_balances";
+export * from "./ledger";
+export * from "./manifest";
+export * from "./nft_info";
+export * from "./server_info";
+export * from "./transaction";
+export * from "./vl";

package/lib/ledger/index.js

@@ -0,0 +1,32 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./account_info"), exports);
+__exportStar(require("./account_lines"), exports);
+__exportStar(require("./account_nfts"), exports);
+__exportStar(require("./account_objects"), exports);
+__exportStar(require("./account_offers"), exports);
+__exportStar(require("./account_tx"), exports);
+__exportStar(require("./book_offers"), exports);
+__exportStar(require("./currency"), exports);
+__exportStar(require("./fee"), exports);
+__exportStar(require("./gateway_balances"), exports);
+__exportStar(require("./ledger"), exports);
+__exportStar(require("./manifest"), exports);
+__exportStar(require("./nft_info"), exports);
+__exportStar(require("./server_info"), exports);
+__exportStar(require("./transaction"), exports);
+__exportStar(require("./vl"), exports);

package/lib/ledger/ledger.d.ts

@@ -0,0 +1,11 @@
+import { LedgerIndex } from "../models/ledger";
+export interface GetLedgerOptions {
+    ledgerIndex?: LedgerIndex;
+    transactions?: boolean;
+    expand?: boolean;
+    legacy?: boolean;
+    formatted?: boolean;
+    includeRawTransactions?: boolean;
+}
+export declare function getLedger(options?: GetLedgerOptions): Promise<object>;
+export declare function getLedgerIndex(options?: GetLedgerOptions): Promise<number | undefined>;

package/lib/ledger/ledger.js

@@ -0,0 +1,72 @@
+"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.getLedgerIndex = exports.getLedger = void 0;
+const Client = __importStar(require("../client"));
+const ledger_1 = require("../parse/ledger/ledger");
+async function getLedger(options = {}) {
+    const formatted = options.legacy === true || options.formatted === true;
+    const connection = Client.findConnection("history");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "ledger",
+        ledger_index: options.ledgerIndex || "validated",
+        transactions: !!options.transactions,
+        expand: !!options.expand,
+    });
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    const result = response?.result;
+    if (!result) {
+        return {
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (formatted === true) {
+        result.ledger = (0, ledger_1.parseLedger)(result.ledger, options.includeRawTransactions === true);
+    }
+    return result;
+}
+exports.getLedger = getLedger;
+async function getLedgerIndex(options = {}) {
+    const ledgerInfo = await Client.getLedger(options);
+    const ledger = ledgerInfo?.ledger;
+    if (ledger) {
+        return parseInt(ledger.ledger_index, 10);
+    }
+    return undefined;
+}
+exports.getLedgerIndex = getLedgerIndex;

package/lib/ledger/manifest.d.ts

@@ -0,0 +1,8 @@
+import { Connection } from "../connection";
+import { LedgerIndex } from "../models/ledger";
+import { ErrorResponse } from "../models/base_model";
+export interface GetManifestOptions {
+    ledgerIndex?: LedgerIndex;
+    connection?: Connection;
+}
+export declare function getManifest(publicKey: string, options?: GetManifestOptions): Promise<object | ErrorResponse>;

package/lib/ledger/manifest.js

@@ -0,0 +1,56 @@
+"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.getManifest = void 0;
+const Client = __importStar(require("../client"));
+async function getManifest(publicKey, options = {}) {
+    const connection = options.connection || Client.findConnection("manifest");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "manifest",
+        public_key: publicKey,
+    });
+    if (!response) {
+        return {
+            public_key: publicKey,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    return response?.result;
+}
+exports.getManifest = getManifest;

package/lib/ledger/nft_info.d.ts

@@ -0,0 +1,4 @@
+import { ErrorResponse } from "../models/base_model";
+export interface GetNftInfoOptions {
+}
+export declare function getNftInfo(nft_id: string, options?: GetNftInfoOptions): Promise<object | ErrorResponse>;

package/lib/ledger/nft_info.js

@@ -0,0 +1,56 @@
+"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.getNftInfo = void 0;
+const Client = __importStar(require("../client"));
+async function getNftInfo(nft_id, options = {}) {
+    const connection = Client.findConnection("clio", undefined, true);
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "nft_info",
+        nft_id,
+    });
+    if (!response) {
+        return {
+            nft_id,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    return response?.result;
+}
+exports.getNftInfo = getNftInfo;

package/lib/ledger/server_info.d.ts

@@ -0,0 +1,8 @@
+import { Connection } from "../connection";
+import { ErrorResponse } from "../models/base_model";
+export interface GetServerInfoOptions {
+    url?: string;
+    type?: string;
+    connection?: Connection;
+}
+export declare function getServerInfo(options?: GetServerInfoOptions): Promise<object | ErrorResponse>;

package/lib/ledger/server_info.js

@@ -0,0 +1,54 @@
+"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.getServerInfo = void 0;
+const Client = __importStar(require("../client"));
+async function getServerInfo(options = {}) {
+    const connection = options.connection || Client.findConnection(options.type, options.url, true);
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "server_info",
+    });
+    if (!response) {
+        return {
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    return response?.result;
+}
+exports.getServerInfo = getServerInfo;

package/lib/ledger/transaction.d.ts

@@ -0,0 +1,37 @@
+import { XrplDefinitionsBase } from "ripple-binary-codec";
+import { Connection } from "../connection";
+import { TransactionResponse, FormattedTransaction, AccountPaymentParamsInterface } from "../models/transaction";
+import { FormattedMemo } from "../v1/common/types/objects";
+import { ErrorResponse } from "../models/base_model";
+export interface GetTransactionOptions {
+    binary?: boolean;
+    minLedger?: number;
+    maxLedger?: number;
+    balanceChanges?: boolean;
+    specification?: boolean;
+    legacy?: boolean;
+    formatted?: boolean;
+    includeRawTransaction?: boolean;
+}
+export declare function getTransaction(transaction: string, options?: GetTransactionOptions): Promise<TransactionResponse | FormattedTransaction | ErrorResponse>;
+interface LegacyPaymentInterface {
+    sourceAddress: string;
+    sourceTag?: number;
+    sourceValue: string;
+    sourceCurrency: string;
+    destinationAddress: string;
+    destinationTag?: number;
+    destinationValue: string;
+    destinationCurrency: string;
+    networkID?: number;
+    memos: FormattedMemo[];
+    secret: string;
+}
+export declare function legacyPayment(data: LegacyPaymentInterface, definitions?: XrplDefinitionsBase): Promise<TransactionResponse | FormattedTransaction | ErrorResponse>;
+export declare function getAccountPaymentParams(account: string, connection?: Connection): Promise<AccountPaymentParamsInterface | ErrorResponse>;
+export interface SubmitOptionsInterface {
+    connection?: Connection;
+    definitions?: XrplDefinitionsBase;
+}
+export declare function submit(signedTransaction: string, options?: SubmitOptionsInterface): Promise<TransactionResponse | FormattedTransaction | ErrorResponse>;
+export {};

package/lib/ledger/transaction.js

@@ -0,0 +1,214 @@
+"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.submit = exports.getAccountPaymentParams = exports.legacyPayment = exports.getTransaction = void 0;
+const xrpl = __importStar(require("xrpl"));
+const ripple_binary_codec_1 = require("ripple-binary-codec");
+const Client = __importStar(require("../client"));
+const utils_1 = require("../common/utils");
+const transaction_1 = require("../models/transaction");
+const payment_1 = require("../v1/transaction/payment");
+const common_1 = require("../common");
+const wallet_1 = require("../wallet");
+const submitErrorsGroup = ["tem", "tef", "tel", "ter"];
+const FEE_LIMIT = 0.5;
+const LEDGER_CLOSE_TIME_AWAIT = 2000;
+const MAX_LEDGERS_AWAIT = 5;
+async function getTransaction(transaction, options = {}) {
+    const formatted = options.legacy === true || options.formatted === true;
+    const connection = Client.findConnection("history");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "tx",
+        transaction,
+        binary: !!options.binary,
+        min_ledger: options.minLedger,
+        max_ledger: options.maxLedger,
+    });
+    if (!response) {
+        return {
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, status, validated } = response;
+        return {
+            transaction,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    const result = response?.result;
+    if (typeof result === "object") {
+        if (formatted === true) {
+            return (0, transaction_1.getTxDetails)(result, options.includeRawTransaction === true);
+        }
+        if (options.balanceChanges === true && typeof result.meta === "object") {
+            result.balanceChanges = xrpl.getBalanceChanges(result.meta);
+        }
+        if (options.specification === true) {
+            const details = (0, transaction_1.getTxDetails)(result, true);
+            result.specification = details.specification;
+            result.outcome = details.outcome;
+            result.rawTransaction = details.rawTransaction;
+        }
+    }
+    return result;
+}
+exports.getTransaction = getTransaction;
+async function legacyPayment(data, definitions) {
+    const connection = Client.findConnection();
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const txPayment = {
+        source: {
+            address: data.sourceAddress,
+            tag: data.sourceTag,
+            maxAmount: {
+                value: data.sourceValue.toString(),
+                currency: data.sourceCurrency,
+            },
+        },
+        destination: {
+            address: data.destinationAddress,
+            tag: data.destinationTag,
+            amount: {
+                value: data.destinationValue.toString(),
+                currency: data.destinationCurrency,
+            },
+        },
+        networkID: data.networkID,
+        memos: data.memos,
+    };
+    const transaction = (0, payment_1.createPaymentTransaction)(data.sourceAddress, txPayment);
+    const paymentParams = await getAccountPaymentParams(data.sourceAddress, connection);
+    if ("error" in paymentParams) {
+        return paymentParams;
+    }
+    transaction.Fee = paymentParams.fee;
+    transaction.Sequence = paymentParams.sequence;
+    transaction.LastLedgerSequence = paymentParams.lastLedgerSequence;
+    const wallet = xrpl.Wallet.fromSeed(data.secret);
+    const signedTransaction = (0, wallet_1.singTransaction)(wallet, transaction, false, definitions).tx_blob;
+    return await submit(signedTransaction, { connection, definitions });
+}
+exports.legacyPayment = legacyPayment;
+async function getAccountPaymentParams(account, connection) {
+    try {
+        const feePromise = new Promise(async (resolve) => {
+            const baseFee = await Client.getFee({ connection });
+            let fee = parseFloat(baseFee);
+            if (fee > FEE_LIMIT) {
+                fee = FEE_LIMIT;
+            }
+            resolve((0, common_1.xrpToDrops)(fee));
+        });
+        const sequencePromise = new Promise(async (resolve, rejects) => {
+            const accountInfo = await Client.getAccountInfo(account, { connection });
+            if (!accountInfo) {
+                return rejects(new Error("Account not found"));
+            }
+            if ("error" in accountInfo) {
+                return rejects(new Error(accountInfo.error));
+            }
+            resolve(accountInfo?.account_data?.Sequence);
+        });
+        const lastLedgerSequencePromise = new Promise(async (resolve) => {
+            const ledgerIndex = await Client.getLedgerIndex();
+            if (ledgerIndex !== undefined) {
+                resolve(ledgerIndex + MAX_LEDGERS_AWAIT);
+            }
+            resolve(undefined);
+        });
+        const result = await Promise.all([feePromise, sequencePromise, lastLedgerSequencePromise]);
+        return {
+            fee: result[0],
+            sequence: result[1],
+            lastLedgerSequence: result[2],
+        };
+    }
+    catch (e) {
+        return {
+            account,
+            status: "error",
+            error: e.message,
+        };
+    }
+}
+exports.getAccountPaymentParams = getAccountPaymentParams;
+async function submit(signedTransaction, options = {}) {
+    const connection = options.connection || Client.findConnection();
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.submit(signedTransaction);
+    if (response.error) {
+        return response;
+    }
+    const result = response?.result;
+    const resultGroup = result?.engine_result.slice(0, 3);
+    if (submitErrorsGroup.includes(resultGroup) && result?.engine_result !== "terQUEUED") {
+        return result;
+    }
+    const txHash = result.tx_json?.hash;
+    if (!txHash) {
+        return result;
+    }
+    let lastLedger = 0;
+    const transaction = (0, ripple_binary_codec_1.decode)(signedTransaction, options.definitions);
+    if (transaction.LastLedgerSequence) {
+        lastLedger = transaction.LastLedgerSequence;
+    }
+    else {
+        const ledgerIndex = await Client.getLedgerIndex();
+        if (ledgerIndex !== undefined) {
+            lastLedger = ledgerIndex + MAX_LEDGERS_AWAIT;
+        }
+    }
+    return await waitForFinalTransactionOutcome(txHash, lastLedger);
+}
+exports.submit = submit;
+async function waitForFinalTransactionOutcome(txHash, lastLedger) {
+    await (0, utils_1.sleep)(LEDGER_CLOSE_TIME_AWAIT);
+    const tx = await getTransaction(txHash);
+    const error = tx?.error;
+    if (error === "Not connected") {
+        return tx;
+    }
+    if (!tx || error === "txnNotFound" || tx.validated !== true) {
+        const ledgerIndex = await Client.getLedgerIndex();
+        if (ledgerIndex === undefined || lastLedger > ledgerIndex) {
+            return waitForFinalTransactionOutcome(txHash, lastLedger);
+        }
+    }
+    return tx;
+}