@bithomp/xrpl-api 3.1.16 → 3.1.18

package/lib/connection.js

@@ -99,6 +99,7 @@ class Connection extends events_1.EventEmitter {
             }
             const response = await this.client.connection.request(request);
             this.updateLatency((0, utils_1.getTimestamp)() - startTimestamp);
+            this.connectionValidation();
             return response;
         }
         catch (err) {

package/lib/ledger/account_tx.js

@@ -45,7 +45,7 @@ async function getTransactions(account, options = { limit: DEFAULT_LIMIT }) {
     if (!connection) {
         throw new Error("There is no connection");
     }
-    const response = await connection.request({
+    const command = {
         command: "account_tx",
         account,
         ledger_index_min: options.ledgerIndexMin,
@@ -56,7 +56,8 @@ async function getTransactions(account, options = { limit: DEFAULT_LIMIT }) {
         forward: !!options.forward,
         limit: options.limit,
         marker: options.marker,
-    });
+    };
+    const response = await connection.request(command);
     if (!response) {
         return {
             account,

package/lib/models/account_info.d.ts

@@ -1,5 +1,9 @@
 import { LedgerEntry, AccountSetAsfFlags } from "xrpl";
 import { QueueData } from "../types/queue_data";
+export declare enum XahauAccountRootFlags {
+    lsfURITokenIssuer = 1073741824,
+    lsfDisallowIncomingRemit = 2147483648
+}
 export declare const AccountRootFlagsKeys: {
     passwordSpent: LedgerEntry.AccountRootFlags;
     requireDestTag: LedgerEntry.AccountRootFlags;
@@ -15,6 +19,41 @@ export declare const AccountRootFlagsKeys: {
     disallowIncomingPayChan: LedgerEntry.AccountRootFlags;
     disallowIncomingTrustline: LedgerEntry.AccountRootFlags;
 };
+export declare const XRPLAccountRootFlagsKeys: {
+    amm: LedgerEntry.AccountRootFlags;
+    allowTrustLineClawback: LedgerEntry.AccountRootFlags;
+    passwordSpent: LedgerEntry.AccountRootFlags;
+    requireDestTag: LedgerEntry.AccountRootFlags;
+    requireAuth: LedgerEntry.AccountRootFlags;
+    depositAuth: LedgerEntry.AccountRootFlags;
+    disallowXRP: LedgerEntry.AccountRootFlags;
+    disableMaster: LedgerEntry.AccountRootFlags;
+    noFreeze: LedgerEntry.AccountRootFlags;
+    globalFreeze: LedgerEntry.AccountRootFlags;
+    defaultRipple: LedgerEntry.AccountRootFlags;
+    disallowIncomingNFTokenOffer: LedgerEntry.AccountRootFlags;
+    disallowIncomingCheck: LedgerEntry.AccountRootFlags;
+    disallowIncomingPayChan: LedgerEntry.AccountRootFlags;
+    disallowIncomingTrustline: LedgerEntry.AccountRootFlags;
+};
+export declare const XahauAccountRootFlagsKeys: {
+    uriTokenIssuer: XahauAccountRootFlags;
+    disallowIncomingRemit: XahauAccountRootFlags;
+    passwordSpent: LedgerEntry.AccountRootFlags;
+    requireDestTag: LedgerEntry.AccountRootFlags;
+    requireAuth: LedgerEntry.AccountRootFlags;
+    depositAuth: LedgerEntry.AccountRootFlags;
+    disallowXRP: LedgerEntry.AccountRootFlags;
+    disableMaster: LedgerEntry.AccountRootFlags;
+    noFreeze: LedgerEntry.AccountRootFlags;
+    globalFreeze: LedgerEntry.AccountRootFlags;
+    defaultRipple: LedgerEntry.AccountRootFlags;
+    disallowIncomingNFTokenOffer: LedgerEntry.AccountRootFlags;
+    disallowIncomingCheck: LedgerEntry.AccountRootFlags;
+    disallowIncomingPayChan: LedgerEntry.AccountRootFlags;
+    disallowIncomingTrustline: LedgerEntry.AccountRootFlags;
+};
+export declare function getAccountRootFlagsKeys(): Record<string, number>;
 export interface AccountRootFlagsKeysInterface {
     passwordSpent?: boolean;
     requireDestTag?: boolean;
@@ -29,6 +68,13 @@ export interface AccountRootFlagsKeysInterface {
     disallowIncomingCheck?: boolean;
     disallowIncomingPayChan?: boolean;
     disallowIncomingTrustline?: boolean;
+    amm?: boolean;
+    allowTrustLineClawback?: boolean;
+    uriTokenIssuer?: boolean;
+    disallowIncomingRemit?: boolean;
+}
+export declare enum XahauAccountSetAsfFlags {
+    asfDisallowIncomingRemit = 16
 }
 export declare const AccountSetFlags: {
     requireDestinationTag: AccountSetAsfFlags;
@@ -45,6 +91,8 @@ export declare const AccountSetFlags: {
     disallowIncomingCheck: AccountSetAsfFlags;
     disallowIncomingPayChan: AccountSetAsfFlags;
     disallowIncomingTrustline: AccountSetAsfFlags;
+    allowTrustLineClawback: AccountSetAsfFlags;
+    disallowIncomingRemit: XahauAccountSetAsfFlags;
 };
 export declare const SignerListFlagsKeys: {
     oneOwnerCount: LedgerEntry.SignerListFlags;

package/lib/models/account_info.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AccountFields = exports.SignerListFlagsKeys = exports.AccountSetFlags = exports.AccountRootFlagsKeys = void 0;
+exports.AccountFields = exports.SignerListFlagsKeys = exports.AccountSetFlags = exports.XahauAccountSetAsfFlags = exports.XahauAccountRootFlagsKeys = exports.XRPLAccountRootFlagsKeys = exports.AccountRootFlagsKeys = exports.XahauAccountRootFlags = void 0;
+exports.getAccountRootFlagsKeys = getAccountRootFlagsKeys;
 exports.getSettings = getSettings;
 exports.parseAccountFlags = parseAccountFlags;
 exports.parseAccountFields = parseAccountFields;
@@ -12,6 +13,12 @@ const xrpl_1 = require("xrpl");
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const common_1 = require("../common");
 const flags_1 = require("../parse/ledger/flags");
+const client_1 = require("../client");
+var XahauAccountRootFlags;
+(function (XahauAccountRootFlags) {
+    XahauAccountRootFlags[XahauAccountRootFlags["lsfURITokenIssuer"] = 1073741824] = "lsfURITokenIssuer";
+    XahauAccountRootFlags[XahauAccountRootFlags["lsfDisallowIncomingRemit"] = 2147483648] = "lsfDisallowIncomingRemit";
+})(XahauAccountRootFlags || (exports.XahauAccountRootFlags = XahauAccountRootFlags = {}));
 exports.AccountRootFlagsKeys = {
     passwordSpent: xrpl_1.LedgerEntry.AccountRootFlags.lsfPasswordSpent,
     requireDestTag: xrpl_1.LedgerEntry.AccountRootFlags.lsfRequireDestTag,
@@ -27,6 +34,29 @@ exports.AccountRootFlagsKeys = {
     disallowIncomingPayChan: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingPayChan,
     disallowIncomingTrustline: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingTrustline,
 };
+exports.XRPLAccountRootFlagsKeys = {
+    ...exports.AccountRootFlagsKeys,
+    amm: xrpl_1.LedgerEntry.AccountRootFlags.lsfAMM,
+    allowTrustLineClawback: xrpl_1.LedgerEntry.AccountRootFlags.lsfAllowTrustLineClawback,
+};
+exports.XahauAccountRootFlagsKeys = {
+    ...exports.AccountRootFlagsKeys,
+    uriTokenIssuer: XahauAccountRootFlags.lsfURITokenIssuer,
+    disallowIncomingRemit: XahauAccountRootFlags.lsfDisallowIncomingRemit,
+};
+function getAccountRootFlagsKeys() {
+    const nativeCurrency = (0, client_1.getNativeCurrency)();
+    if (nativeCurrency === "XAH") {
+        return exports.XahauAccountRootFlagsKeys;
+    }
+    else {
+        return exports.XRPLAccountRootFlagsKeys;
+    }
+}
+var XahauAccountSetAsfFlags;
+(function (XahauAccountSetAsfFlags) {
+    XahauAccountSetAsfFlags[XahauAccountSetAsfFlags["asfDisallowIncomingRemit"] = 16] = "asfDisallowIncomingRemit";
+})(XahauAccountSetAsfFlags || (exports.XahauAccountSetAsfFlags = XahauAccountSetAsfFlags = {}));
 exports.AccountSetFlags = {
     requireDestinationTag: xrpl_1.AccountSetAsfFlags.asfRequireDest,
     requireAuthorization: xrpl_1.AccountSetAsfFlags.asfRequireAuth,
@@ -42,6 +72,8 @@ exports.AccountSetFlags = {
     disallowIncomingCheck: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingCheck,
     disallowIncomingPayChan: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingPayChan,
     disallowIncomingTrustline: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingTrustline,
+    allowTrustLineClawback: xrpl_1.AccountSetAsfFlags.asfAllowTrustLineClawback,
+    disallowIncomingRemit: XahauAccountSetAsfFlags.asfDisallowIncomingRemit,
 };
 exports.SignerListFlagsKeys = {
     oneOwnerCount: xrpl_1.LedgerEntry.SignerListFlags.lsfOneOwnerCount,
@@ -65,7 +97,7 @@ function getSettings(accountInfo, excludeFalse = true) {
     };
 }
 function parseAccountFlags(value, options = {}) {
-    return (0, flags_1.parseFlags)(value, exports.AccountRootFlagsKeys, options);
+    return (0, flags_1.parseFlags)(value, getAccountRootFlagsKeys(), options);
 }
 function parseAccountFields(accountInfo, options = {}) {
     const settings = {};

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

@@ -0,0 +1,3 @@
+import { FormattedIssuedCurrencyAmount } from "../../types";
+declare function parseDeliveredAmount(tx: any): FormattedIssuedCurrencyAmount | undefined;
+export { parseDeliveredAmount };

package/lib/parse/outcome/delivered_amount.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDeliveredAmount = parseDeliveredAmount;
+const import_1 = require("../ledger/import");
+const amount_1 = __importDefault(require("../ledger/amount"));
+const utils_1 = require("../utils");
+const balance_changes_1 = require("./balance_changes");
+function parseDeliveredAmount(tx) {
+    if (!["Import", "Payment"].includes(tx.TransactionType) || tx.meta.TransactionResult !== "tesSUCCESS") {
+        return undefined;
+    }
+    if (tx.meta.delivered_amount && tx.meta.delivered_amount === "unavailable") {
+        return undefined;
+    }
+    if (tx.meta.delivered_amount) {
+        return (0, amount_1.default)(tx.meta.delivered_amount);
+    }
+    if (tx.meta.DeliveredAmount) {
+        return (0, amount_1.default)(tx.meta.DeliveredAmount);
+    }
+    if (tx.Amount && !(0, utils_1.isPartialPayment)(tx)) {
+        return (0, amount_1.default)(tx.Amount);
+    }
+    if (tx.TransactionType === "Import") {
+        const balanceChanges = (0, balance_changes_1.parseBalanceChanges)(tx.meta);
+        const blob = (0, import_1.parseImportBlob)(tx.Blob);
+        if (typeof blob === "string") {
+            return undefined;
+        }
+        const account = blob.transaction.tx.Account;
+        const balanceChange = balanceChanges[account];
+        if (!balanceChange || balanceChange.length !== 1) {
+            return undefined;
+        }
+        return {
+            currency: balanceChange[0].currency,
+            value: balanceChange[0].value,
+        };
+    }
+    return undefined;
+}

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

@@ -14,3 +14,4 @@ export { parseUNLReportChanges } from "./unl_report_changes";
 export { parseAmmChanges } from "./amm_changes";
 export { parseDIDChanges } from "./did_changes";
 export { parseOracleChanges } from "./oracle_changes";
+export { parseDeliveredAmount } from "./delivered_amount";

package/lib/parse/outcome/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOracleChanges = exports.parseDIDChanges = exports.parseAmmChanges = exports.parseUNLReportChanges = exports.parseEscrowChanges = exports.parseEmittedTxns = exports.parseHooksExecutions = exports.parseOrderbookChanges = exports.parseChannelChanges = exports.parseLockedBalanceChanges = exports.parseBalanceChanges = exports.parseURITokenSellOfferChanges = exports.parseURITokenChanges = exports.parseNFTokenOfferChanges = exports.parseNFTokenChanges = exports.parseAffectedObjects = void 0;
+exports.parseDeliveredAmount = exports.parseOracleChanges = exports.parseDIDChanges = exports.parseAmmChanges = exports.parseUNLReportChanges = exports.parseEscrowChanges = exports.parseEmittedTxns = exports.parseHooksExecutions = exports.parseOrderbookChanges = exports.parseChannelChanges = exports.parseLockedBalanceChanges = exports.parseBalanceChanges = exports.parseURITokenSellOfferChanges = exports.parseURITokenChanges = exports.parseNFTokenOfferChanges = exports.parseNFTokenChanges = exports.parseAffectedObjects = void 0;
 var affected_objects_1 = require("./affected_objects");
 Object.defineProperty(exports, "parseAffectedObjects", { enumerable: true, get: function () { return affected_objects_1.parseAffectedObjects; } });
 var nftoken_changes_1 = require("./nftoken_changes");
@@ -33,3 +33,5 @@ var did_changes_1 = require("./did_changes");
 Object.defineProperty(exports, "parseDIDChanges", { enumerable: true, get: function () { return did_changes_1.parseDIDChanges; } });
 var oracle_changes_1 = require("./oracle_changes");
 Object.defineProperty(exports, "parseOracleChanges", { enumerable: true, get: function () { return oracle_changes_1.parseOracleChanges; } });
+var delivered_amount_1 = require("./delivered_amount");
+Object.defineProperty(exports, "parseDeliveredAmount", { enumerable: true, get: function () { return delivered_amount_1.parseDeliveredAmount; } });

package/lib/parse/outcome.js

@@ -1,12 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseOutcome = parseOutcome;
 const index_1 = require("./outcome/index");
-const import_1 = require("./ledger/import");
-const amount_1 = __importDefault(require("./ledger/amount"));
 const utils_1 = require("./utils");
 const common_1 = require("../common");
 function removeEmptyCounterparty(amount) {
@@ -26,40 +21,6 @@ function removeEmptyCounterpartyInOrderbookChanges(orderbookChanges) {
         });
     });
 }
-function parseDeliveredAmount(tx) {
-    if (!["Import", "Payment"].includes(tx.TransactionType) || tx.meta.TransactionResult !== "tesSUCCESS") {
-        return undefined;
-    }
-    if (tx.meta.delivered_amount && tx.meta.delivered_amount === "unavailable") {
-        return undefined;
-    }
-    if (tx.meta.delivered_amount) {
-        return (0, amount_1.default)(tx.meta.delivered_amount);
-    }
-    if (tx.meta.DeliveredAmount) {
-        return (0, amount_1.default)(tx.meta.DeliveredAmount);
-    }
-    if (tx.Amount && !(0, utils_1.isPartialPayment)(tx)) {
-        return (0, amount_1.default)(tx.Amount);
-    }
-    if (tx.TransactionType === "Import") {
-        const balanceChanges = (0, index_1.parseBalanceChanges)(tx.meta);
-        const blob = (0, import_1.parseImportBlob)(tx.Blob);
-        if (typeof blob === "string") {
-            return undefined;
-        }
-        const account = blob.transaction.tx.Account;
-        const balanceChange = balanceChanges[account];
-        if (!balanceChange || balanceChange.length !== 1) {
-            return undefined;
-        }
-        return {
-            currency: balanceChange[0].currency,
-            value: balanceChange[0].value,
-        };
-    }
-    return undefined;
-}
 function parseOutcome(tx, nativeCurrency, definitions) {
     const metadata = tx.meta || tx.metaData;
     if (!metadata) {
@@ -106,6 +67,6 @@ function parseOutcome(tx, nativeCurrency, definitions) {
         emittedTxns,
         ledgerVersion: tx.ledger_index,
         indexInLedger: tx.meta.TransactionIndex,
-        deliveredAmount: parseDeliveredAmount(tx),
+        deliveredAmount: (0, index_1.parseDeliveredAmount)(tx),
     });
 }

package/lib/parse/specification/settings.js

@@ -50,7 +50,7 @@ function parseSettingsFlags(tx) {
         const changedFlags = oldFlags ^ newFlags;
         const setFlags = newFlags & changedFlags;
         const clearedFlags = oldFlags & changedFlags;
-        Object.entries(account_info_1.AccountRootFlagsKeys).forEach((entry) => {
+        Object.entries((0, account_info_1.getAccountRootFlagsKeys)()).forEach((entry) => {
             const [flagName, flagValue] = entry;
             if (setFlags & flagValue) {
                 settings[flagName] = true;

package/lib/wallet.d.ts

@@ -6,6 +6,12 @@ interface GenerateAddressInterface {
     address: string;
     seed: string;
 }
+export interface VerifySignatureInterface {
+    signedBy?: string;
+    signatureValid?: boolean;
+    signatureMultiSign?: boolean;
+    error?: string;
+}
 export declare function isValidSecret(secret: string): boolean;
 export interface WalletFromSeedInterface {
     masterAddress?: string;
@@ -21,6 +27,7 @@ export declare function signTransaction(wallet: Wallet, transaction: Transaction
     tx_blob: string;
     hash: string;
 };
-export declare function verifyTransaction(wallet: Wallet, signedTransaction: Transaction | string): boolean;
+export declare function verifyTransaction(signedTransaction: Transaction | string, definitions?: XrplDefinitionsBase): boolean;
+export declare function verifySignature(signedTransaction: Transaction | string, explicitMultiSigner?: string | null, definitions?: XrplDefinitionsBase): VerifySignatureInterface;
 declare function hashSignedTx(tx: Transaction | string, definitions?: XrplDefinitionsBase, validateTx?: boolean): string;
 export { XrplDefinitionsBase, XrplDefinitions, DEFAULT_DEFINITIONS, hashSignedTx };

package/lib/wallet.js

@@ -34,6 +34,7 @@ exports.isValidClassicAddress = isValidClassicAddress;
 exports.checksumClassicAddress = checksumClassicAddress;
 exports.signTransaction = signTransaction;
 exports.verifyTransaction = verifyTransaction;
+exports.verifySignature = verifySignature;
 exports.hashSignedTx = hashSignedTx;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const omitBy_1 = __importDefault(require("lodash/omitBy"));
@@ -147,11 +148,83 @@ function signTransaction(wallet, transaction, multisign, definitions, validateTx
         hash: hashSignedTx(serialized, definitions),
     };
 }
-function verifyTransaction(wallet, signedTransaction) {
-    const tx = typeof signedTransaction === "string" ? (0, ripple_binary_codec_1.decode)(signedTransaction) : signedTransaction;
-    const messageHex = (0, ripple_binary_codec_1.encodeForSigning)(tx);
+function verifyTransaction(signedTransaction, definitions) {
+    const tx = typeof signedTransaction === "string" ? (0, ripple_binary_codec_1.decode)(signedTransaction, definitions) : signedTransaction;
+    const messageHex = (0, ripple_binary_codec_1.encodeForSigning)(tx, definitions);
     const signature = tx.TxnSignature;
-    return (0, ripple_keypairs_1.verify)(messageHex, signature, wallet.publicKey);
+    const publicKey = tx.SigningPubKey;
+    return (0, ripple_keypairs_1.verify)(messageHex, signature, publicKey);
+}
+function verifySignature(signedTransaction, explicitMultiSigner, definitions) {
+    let tx;
+    let signedBy = "";
+    let signatureValid = false;
+    try {
+        if (typeof signedTransaction === "string") {
+            tx = (0, ripple_binary_codec_1.decode)(signedTransaction, definitions);
+        }
+        else if (signedTransaction !== null && typeof signedTransaction === "object") {
+            tx = signedTransaction;
+        }
+    }
+    catch (err) {
+        return { signatureValid: false, error: err.message };
+    }
+    if (!tx) {
+        return { signatureValid: false, error: "The transaction could not be decoded." };
+    }
+    if (!tx.TxnSignature && !tx.Signers) {
+        return { signatureValid: false, error: "The transaction must be signed to verify the signature." };
+    }
+    const signatureMultiSign = typeof tx.Signers !== "undefined" &&
+        Array.isArray(tx.Signers) &&
+        tx.Signers.length > 0 &&
+        typeof tx.SigningPubKey === "string" &&
+        tx.SigningPubKey === "";
+    try {
+        if (signatureMultiSign && explicitMultiSigner && explicitMultiSigner.match(/^r/)) {
+            signedBy = explicitMultiSigner;
+        }
+        else if (signatureMultiSign && explicitMultiSigner) {
+            signedBy = (0, ripple_keypairs_1.deriveAddress)(explicitMultiSigner);
+        }
+        else {
+            let signer = tx.SigningPubKey;
+            if (signatureMultiSign && tx.Signers && tx.Signers.length > 0) {
+                const firstSigner = Object.values(tx.Signers)[0];
+                signer = firstSigner.Signer.SigningPubKey;
+            }
+            signedBy = (0, ripple_keypairs_1.deriveAddress)(signer);
+        }
+    }
+    catch (err) {
+        return { signatureValid: false, error: err.message };
+    }
+    try {
+        if (signatureMultiSign && tx.Signers) {
+            const matchingSigners = Object.values(tx.Signers).filter((signer) => {
+                return (0, ripple_keypairs_1.deriveAddress)(signer.Signer.SigningPubKey) === signedBy;
+            });
+            if (matchingSigners.length > 0) {
+                const multiSigner = matchingSigners[0];
+                signatureValid = (0, ripple_keypairs_1.verify)((0, ripple_binary_codec_1.encodeForMultisigning)(tx, signedBy, definitions), multiSigner.Signer.TxnSignature, multiSigner.Signer.SigningPubKey);
+            }
+            else {
+                return { signatureValid: false, error: "Explicit MultiSigner not in Signers" };
+            }
+        }
+        else {
+            signatureValid = (0, ripple_keypairs_1.verify)((0, ripple_binary_codec_1.encodeForSigning)(tx, definitions), tx.TxnSignature, tx.SigningPubKey);
+        }
+    }
+    catch (err) {
+        return { signedBy, signatureValid: false, error: err.message };
+    }
+    return {
+        signedBy,
+        signatureValid,
+        signatureMultiSign,
+    };
 }
 function computeSignature(tx, privateKey, signAs, definitions) {
     if (signAs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bithomp/xrpl-api",
-  "version": "3.1.16",
+  "version": "3.1.18",
   "description": "A Bithomp JavaScript/TypeScript library for interacting with the XRP Ledger",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -55,28 +55,28 @@
     "axios": "^1.7.7",
     "base-x": "^5.0.0",
     "bignumber.js": "^9.1.2",
-    "elliptic": "^6.6.0",
+    "elliptic": "^6.6.1",
     "lodash": "^4.17.21",
     "ripple-address-codec": "^5.0.0",
     "ripple-binary-codec": "^2.1.0",
     "xrpl": "^4.0.0"
   },
   "devDependencies": {
-    "@types/chai": "^4.3.19",
-    "@types/chai-as-promised": "^7.1.8",
-    "@types/lodash": "^4.17.12",
+    "@types/chai": "^5.0.1",
+    "@types/chai-as-promised": "^8.0.1",
+    "@types/lodash": "^4.17.13",
     "@types/mocha": "^10.0.9",
     "@types/nconf": "^0.10.7",
     "@types/node": "^20.14.15",
-    "@typescript-eslint/eslint-plugin": "^8.10.0",
-    "@typescript-eslint/parser": "^8.10.0",
+    "@typescript-eslint/eslint-plugin": "^8.14.0",
+    "@typescript-eslint/parser": "^8.14.0",
     "chai": "^4.5.0",
     "chai-as-promised": "^7.1.2",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-chai-friendly": "^1.0.1",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-n": "^17.12.0",
+    "eslint-plugin-n": "^17.13.2",
     "eslint-plugin-promise": "^7.1.0",
     "mocha": "^10.8.2",
     "nconf": "^0.12.1",