@bithomp/xrpl-api 2.7.12 → 2.7.15

package/lib/ledger/fee.d.ts

@@ -1,5 +1,8 @@
+import { XrplDefinitionsBase } from "ripple-binary-codec";
 import { Connection } from "../connection";
 export interface GetFeeOptions {
     connection?: Connection;
+    tx?: any;
+    definitions?: XrplDefinitionsBase;
 }
 export declare function getFee(options?: GetFeeOptions): Promise<string | null>;

package/lib/ledger/fee.js

@@ -25,6 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFee = void 0;
 const bignumber_js_1 = require("bignumber.js");
+const ripple_binary_codec_1 = require("ripple-binary-codec");
 const Client = __importStar(require("../client"));
 const common_1 = require("../common");
 async function getFee(options = {}) {
@@ -32,14 +33,25 @@ async function getFee(options = {}) {
     if (!connection) {
         throw new Error("There is no connection");
     }
+    let txBlob;
+    if (typeof options.tx === "string") {
+        txBlob = options.tx;
+    }
+    else if (typeof options.tx === "object") {
+        txBlob = (0, ripple_binary_codec_1.encode)(options.tx, options.definitions);
+    }
     const response = await connection.request({
         command: "fee",
+        tx_blob: txBlob,
     });
-    const baseFee = response?.result?.drops?.base_fee;
-    if (!baseFee) {
+    const openLedgerFee = response?.result?.drops?.open_ledger_fee;
+    if (!openLedgerFee) {
         return null;
     }
-    const fee = new bignumber_js_1.BigNumber(baseFee).multipliedBy(Client.feeCushion).dividedBy(common_1.dropsInXRP);
+    const fee = new bignumber_js_1.BigNumber(openLedgerFee)
+        .multipliedBy(Client.feeCushion)
+        .dividedBy(common_1.dropsInXRP)
+        .decimalPlaces(6, bignumber_js_1.BigNumber.ROUND_UP);
     return fee.toString();
 }
 exports.getFee = getFee;

package/lib/ledger/transaction.d.ts

@@ -32,6 +32,7 @@ interface LegacyPaymentInterface {
 }
 export declare function legacyPayment(data: LegacyPaymentInterface, definitions?: XrplDefinitionsBase, validateTx?: boolean): Promise<TransactionResponse | FormattedTransaction | ErrorResponse>;
 export declare function getAccountPaymentParams(account: string, connection?: Connection): Promise<AccountPaymentParamsInterface | ErrorResponse>;
+export declare function getTxSubmitParams(account: string, tx?: string | any, definitions?: XrplDefinitionsBase, connection?: Connection): Promise<AccountPaymentParamsInterface | ErrorResponse>;
 export interface SubmitOptionsInterface {
     connection?: Connection;
     definitions?: XrplDefinitionsBase;

package/lib/ledger/transaction.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.submit = exports.getAccountPaymentParams = exports.legacyPayment = exports.getTransactionByCTID = exports.getTransaction = void 0;
+exports.submit = exports.getTxSubmitParams = exports.getAccountPaymentParams = exports.legacyPayment = exports.getTransactionByCTID = exports.getTransaction = void 0;
 const xrpl = __importStar(require("xrpl"));
 const ripple_binary_codec_1 = require("ripple-binary-codec");
 const Client = __importStar(require("../client"));
@@ -184,18 +184,18 @@ async function legacyPayment(data, definitions, validateTx) {
         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;
+    const submitParams = await getTxSubmitParams(data.sourceAddress, transaction, definitions, connection);
+    if ("error" in submitParams) {
+        return submitParams;
     }
     if (data.fee) {
         transaction.Fee = (0, common_1.xrpToDrops)(data.fee);
     }
     else {
-        transaction.Fee = paymentParams.fee;
+        transaction.Fee = submitParams.fee;
     }
-    transaction.Sequence = paymentParams.sequence;
-    transaction.LastLedgerSequence = paymentParams.lastLedgerSequence;
+    transaction.Sequence = submitParams.sequence;
+    transaction.LastLedgerSequence = submitParams.lastLedgerSequence;
     const wallet = xrpl.Wallet.fromSeed(data.secret);
     const signedTransaction = (0, wallet_1.signTransaction)(wallet, transaction, false, definitions, validateTx).tx_blob;
     return await submit(signedTransaction, { connection, definitions });
@@ -213,24 +213,34 @@ async function getAccountPaymentParams(account, connection) {
             if (fee > FEE_LIMIT) {
                 fee = FEE_LIMIT;
             }
-            resolve((0, common_1.xrpToDrops)(fee));
+            resolve((0, common_1.xrpToDrops)(fee.toString()));
         });
         const sequencePromise = new Promise(async (resolve, rejects) => {
-            const accountInfo = await Client.getAccountInfo(account, { connection });
-            if (!accountInfo) {
-                return rejects(new Error("Account not found"));
+            try {
+                const accountData = await Client.getAccountInfoData(account, { connection });
+                if (!accountData) {
+                    return rejects(new Error("Account not found"));
+                }
+                if ("error" in accountData) {
+                    return rejects(new Error(accountData.error));
+                }
+                resolve(accountData.Sequence);
             }
-            if ("error" in accountInfo) {
-                return rejects(new Error(accountInfo.error));
+            catch (e) {
+                rejects(e);
             }
-            resolve(accountInfo?.account_data?.Sequence);
         });
         const lastLedgerSequencePromise = new Promise(async (resolve) => {
-            const ledgerIndex = await Client.getLedgerIndex();
-            if (ledgerIndex !== undefined) {
-                resolve(ledgerIndex + MAX_LEDGERS_AWAIT);
+            try {
+                const ledgerIndex = await Client.getLedgerIndex();
+                if (ledgerIndex !== undefined) {
+                    resolve(ledgerIndex + MAX_LEDGERS_AWAIT);
+                }
+                resolve(undefined);
+            }
+            catch (e) {
+                resolve(undefined);
             }
-            resolve(undefined);
         });
         const result = await Promise.all([feePromise, sequencePromise, lastLedgerSequencePromise]);
         return {
@@ -249,6 +259,72 @@ async function getAccountPaymentParams(account, connection) {
     }
 }
 exports.getAccountPaymentParams = getAccountPaymentParams;
+async function getTxSubmitParams(account, tx, definitions, connection) {
+    try {
+        connection = connection || Client.findConnection("submit") || undefined;
+        if (!connection) {
+            throw new Error("There is no connection");
+        }
+        const feePromise = new Promise(async (resolve, rejects) => {
+            try {
+                if (tx && typeof tx === "object") {
+                    tx = { ...tx, Sequence: 0, Fee: "0", SigningPubKey: "" };
+                }
+                const baseFee = await Client.getFee({ connection, tx, definitions });
+                let fee = parseFloat(baseFee);
+                if (fee > FEE_LIMIT) {
+                    fee = FEE_LIMIT;
+                }
+                resolve((0, common_1.xrpToDrops)(fee.toString()));
+            }
+            catch (e) {
+                rejects(e);
+            }
+        });
+        const sequencePromise = new Promise(async (resolve, rejects) => {
+            try {
+                const accountData = await Client.getAccountInfoData(account, { connection });
+                if (!accountData) {
+                    return rejects(new Error("Account not found"));
+                }
+                if ("error" in accountData) {
+                    return rejects(new Error(accountData.error));
+                }
+                resolve(accountData.Sequence);
+            }
+            catch (e) {
+                rejects(e);
+            }
+        });
+        const lastLedgerSequencePromise = new Promise(async (resolve) => {
+            try {
+                const ledgerIndex = await Client.getLedgerIndex();
+                if (ledgerIndex !== undefined) {
+                    resolve(ledgerIndex + MAX_LEDGERS_AWAIT);
+                }
+                resolve(undefined);
+            }
+            catch (e) {
+                resolve(undefined);
+            }
+        });
+        const result = await Promise.all([feePromise, sequencePromise, lastLedgerSequencePromise]);
+        return {
+            fee: result[0],
+            sequence: result[1],
+            lastLedgerSequence: result[2],
+            networkID: connection.getNetworkID(),
+        };
+    }
+    catch (e) {
+        return {
+            account,
+            status: "error",
+            error: e.message,
+        };
+    }
+}
+exports.getTxSubmitParams = getTxSubmitParams;
 async function submit(signedTransaction, options = {}) {
     const connection = options.connection || Client.findConnection("submit");
     if (!connection) {
@@ -259,11 +335,11 @@ async function submit(signedTransaction, options = {}) {
         return response;
     }
     const result = response?.result;
-    const resultGroup = result?.engine_result.slice(0, 3);
+    const resultGroup = result?.engine_result?.slice(0, 3);
     if ((submitErrorsGroup.includes(resultGroup) && result?.engine_result !== "terQUEUED") || result?.kept === false) {
         return result;
     }
-    const txHash = result.tx_json?.hash;
+    const txHash = result?.tx_json?.hash;
     if (!txHash) {
         return result;
     }
@@ -275,10 +351,12 @@ async function submit(signedTransaction, options = {}) {
     else {
         const ledgerIndex = await Client.getLedgerIndex();
         if (ledgerIndex !== undefined) {
-            lastLedger = ledgerIndex + MAX_LEDGERS_AWAIT;
+            const ledgersToWait = MAX_LEDGERS_AWAIT * 2;
+            lastLedger = ledgerIndex + ledgersToWait;
         }
     }
-    return await waitForFinalTransactionOutcome(txHash, lastLedger);
+    const finalResult = await waitForFinalTransactionOutcome(txHash, lastLedger);
+    return finalResult;
 }
 exports.submit = submit;
 async function waitForFinalTransactionOutcome(txHash, lastLedger) {
@@ -294,5 +372,13 @@ async function waitForFinalTransactionOutcome(txHash, lastLedger) {
             return waitForFinalTransactionOutcome(txHash, lastLedger);
         }
     }
+    if (tx && !tx.hasOwnProperty("error") && tx.validated === false) {
+        if (tx.hasOwnProperty("LastLedgerSequence")) {
+            return { ...tx, status: "timeout", error: "lastLedgerIndexReached" };
+        }
+        else {
+            return { ...tx, status: "timeout", error: "waitingForValidation" };
+        }
+    }
     return tx;
 }

package/lib/models/account_lines.d.ts

@@ -4,6 +4,8 @@ export interface Trustline {
     currency: string;
     limit: string;
     limit_peer: string;
+    lock_count?: number;
+    locked_balance?: string;
     quality_in: number;
     quality_out: number;
     no_ripple?: boolean;

package/lib/models/account_object.js

@@ -25,15 +25,22 @@ const RippleStateToTrustLine = (ledgerEntry, account) => {
     const balance = ledgerEntry.HighLimit.issuer === account && ledgerEntry.Balance.value.startsWith("-")
         ? ledgerEntry.Balance.value.slice(1)
         : ledgerEntry.Balance.value;
-    return {
+    const lockedBalance = ledgerEntry.LockedBalance?.value;
+    let lockCount = undefined;
+    if (lockedBalance) {
+        lockCount = ledgerEntry.LockCount;
+    }
+    return (0, common_1.removeUndefined)({
         account: counterparty.issuer,
         balance,
         currency: self.currency,
         limit: self.value,
         limit_peer: counterparty.value,
+        lock_count: lockCount,
+        locked_balance: lockedBalance,
         no_ripple,
         no_ripple_peer,
-    };
+    });
 };
 function accountObjectsToNFTOffers(accountObjects) {
     const nftOfferObjects = accountObjects.filter((obj) => {

package/lib/parse/outcome/balance_changes.d.ts

@@ -1,7 +1,8 @@
-declare function parseBalanceChanges(metadata: any, nativeCurrency?: string): {
+import { TransactionMetadata } from "xrpl";
+declare function parseBalanceChanges(metadata: TransactionMetadata, nativeCurrency?: string): {
     [x: string]: any[];
 };
-declare function parseFinalBalances(metadata: any): {
+declare function parseFinalBalances(metadata: TransactionMetadata): {
     [x: string]: any[];
 };
 export { parseBalanceChanges, parseFinalBalances };

package/lib/parse/outcome/locked_balance_changes.d.ts

@@ -1,7 +1,8 @@
-declare function parseLockedBalanceChanges(metadata: any): {
+import { TransactionMetadata } from "xrpl";
+declare function parseLockedBalanceChanges(metadata: TransactionMetadata): {
     [x: string]: any[];
 };
-declare function parseFinalLockedBalances(metadata: any): {
+declare function parseFinalLockedBalances(metadata: TransactionMetadata): {
     [x: string]: any[];
 };
 export { parseLockedBalanceChanges, parseFinalLockedBalances };

package/lib/parse/outcome/locked_balance_changes.js

@@ -30,6 +30,9 @@ function computeBalanceChange(node) {
     else if (node.previousFields.LockedBalance && node.finalFields.LockedBalance) {
         value = parseValue(node.finalFields.LockedBalance).minus(parseValue(node.previousFields.LockedBalance));
     }
+    else if (node.previousFields.LockedBalance) {
+        value = parseValue(node.previousFields.LockedBalance).negated();
+    }
     return value === null ? null : value.isZero() ? null : value;
 }
 function parseFinalBalance(node) {
@@ -61,11 +64,12 @@ function parseTrustlineQuantity(node, valueParser) {
         return null;
     }
     const fields = lodash_1.default.isEmpty(node.newFields) ? node.finalFields : node.newFields;
+    const LockedBalanceFields = lodash_1.default.isEmpty(node.newFields?.LockedBalance) ? lodash_1.default.isEmpty(node.finalFields?.LockedBalance) ? node.previousFields : node.finalFields : node.newFields;
     const result = {
         address: fields.LowLimit.issuer,
         lockedBalance: {
-            counterparty: fields.HighLimit.issuer,
-            currency: fields.LockedBalance.currency,
+            counterparty: LockedBalanceFields.LockedBalance.issuer,
+            currency: LockedBalanceFields.LockedBalance.currency,
             value: value.toString(),
         },
     };

package/lib/parse/transaction.js

@@ -134,6 +134,7 @@ function parseTransaction(tx, includeRawTransaction, nativeCurrency, definitions
         address: (0, account_1.parseAccount)(tx.Account),
         sequence: tx.Sequence,
         id: tx.hash,
+        ctid: tx.ctid,
         specification: (0, common_1.removeUndefined)(specification),
         outcome: outcome ? (0, common_1.removeUndefined)(outcome) : undefined,
         rawTransaction: includeRawTransaction ? JSON.stringify(tx) : undefined,

package/lib/v1/common/utils.d.ts

@@ -1,6 +1,7 @@
+import { TransactionMetadata } from "xrpl";
 import { Amount, FormattedIssuedCurrencyAmount } from "./types/objects";
 declare function isValidSecret(secret: string): boolean;
 declare function toRippledAmount(amount: Amount | FormattedIssuedCurrencyAmount): Amount;
 declare function iso8601ToRippleTime(iso8601: string): number;
-declare function normalizeNodes(metadata: any): any;
+declare function normalizeNodes(metadata: TransactionMetadata): any[];
 export { toRippledAmount, iso8601ToRippleTime, isValidSecret, normalizeNodes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bithomp/xrpl-api",
-  "version": "2.7.12",
+  "version": "2.7.15",
   "description": "A Bithomp JavaScript/TypeScript library for interacting with the XRP Ledger",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",