@bithomp/xrpl-api 3.7.31 → 3.7.38

package/lib/src/wallet.js

@@ -0,0 +1,284 @@
+"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.DEFAULT_DEFINITIONS = exports.XrplDefinitions = exports.XrplDefinitionsBase = void 0;
+exports.isValidSecret = isValidSecret;
+exports.walletFromSeed = walletFromSeed;
+exports.generateAddress = generateAddress;
+exports.isValidClassicAddress = isValidClassicAddress;
+exports.checksumClassicAddress = checksumClassicAddress;
+exports.signTransaction = signTransaction;
+exports.verifyTransaction = verifyTransaction;
+exports.verifySignature = verifySignature;
+exports.hashSignedTx = hashSignedTx;
+exports.getXahauDefinitions = getXahauDefinitions;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const omitBy_1 = __importDefault(require("lodash/omitBy"));
+const Crypto = __importStar(require("crypto"));
+const xrpl_1 = require("xrpl");
+const ripple_address_codec_1 = require("ripple-address-codec");
+const ripple_binary_codec_1 = require("ripple-binary-codec");
+Object.defineProperty(exports, "XrplDefinitionsBase", { enumerable: true, get: function () { return ripple_binary_codec_1.XrplDefinitionsBase; } });
+Object.defineProperty(exports, "XrplDefinitions", { enumerable: true, get: function () { return ripple_binary_codec_1.XrplDefinitions; } });
+Object.defineProperty(exports, "DEFAULT_DEFINITIONS", { enumerable: true, get: function () { return ripple_binary_codec_1.DEFAULT_DEFINITIONS; } });
+const ripple_keypairs_1 = require("ripple-keypairs");
+const Base58 = __importStar(require("./base58"));
+const common_1 = require("./common");
+var HashPrefix;
+(function (HashPrefix) {
+    HashPrefix[HashPrefix["TRANSACTION_ID"] = 1415073280] = "TRANSACTION_ID";
+})(HashPrefix || (HashPrefix = {}));
+function isValidSecret(secret) {
+    try {
+        (0, ripple_keypairs_1.deriveKeypair)(secret);
+        return true;
+    }
+    catch (_err) {
+    }
+    return false;
+}
+function walletFromSeed(seed, options) {
+    options = { ignoreSeedPayload: false, ...options };
+    let algorithm = options.algorithm;
+    if (!options.ignoreSeedPayload && !options.algorithm) {
+        const decodedSeed = (0, ripple_address_codec_1.decodeSeed)(seed);
+        if (decodedSeed.type === "secp256k1") {
+            if (options.seedAddress) {
+                const { publicKey } = (0, ripple_keypairs_1.deriveKeypair)(seed, { algorithm: xrpl_1.ECDSA.secp256k1 });
+                const classicAddress = (0, ripple_keypairs_1.deriveAddress)(publicKey);
+                if (classicAddress === options.seedAddress) {
+                    algorithm = xrpl_1.ECDSA.secp256k1;
+                }
+                else {
+                    algorithm = xrpl_1.ECDSA.ed25519;
+                }
+            }
+            else {
+                algorithm = xrpl_1.ECDSA.secp256k1;
+            }
+        }
+    }
+    const wallet = xrpl_1.Wallet.fromSeed(seed, { algorithm, masterAddress: options.masterAddress });
+    return wallet;
+}
+function generateAddress() {
+    const wallet = xrpl_1.Wallet.generate();
+    const { publicKey, privateKey, classicAddress, seed } = wallet;
+    return { publicKey, privateKey, address: classicAddress, seed: seed };
+}
+function isValidClassicAddress(address) {
+    if (!address || address.length === 0) {
+        return false;
+    }
+    const buffer = Base58.decode(address);
+    if (buffer === null) {
+        return false;
+    }
+    const checksum = checksumClassicAddress(buffer);
+    if (checksum[0] !== buffer[21] ||
+        checksum[1] !== buffer[22] ||
+        checksum[2] !== buffer[23] ||
+        checksum[3] !== buffer[24]) {
+        return false;
+    }
+    return true;
+}
+function checksumClassicAddress(buffer) {
+    const hash = buffer.slice(0, 21);
+    const checksumPrepare = Crypto.createHash("sha256").update(Buffer.from(hash)).digest();
+    const checksum = Crypto.createHash("sha256").update(checksumPrepare).digest();
+    return checksum;
+}
+function signTransaction(wallet, transaction, multisign, definitions, validateTx) {
+    let multisignAddress = false;
+    if (typeof multisign === "string" && multisign.startsWith("X")) {
+        multisignAddress = multisign;
+    }
+    else if (multisign) {
+        multisignAddress = wallet.classicAddress;
+    }
+    const tx = (0, omitBy_1.default)({ ...transaction }, (value) => value == null);
+    if (tx.TxnSignature || tx.Signers) {
+        throw new xrpl_1.ValidationError('txJSON must not contain "TxnSignature" or "Signers" properties');
+    }
+    removeTrailingZeros(tx);
+    if (validateTx !== false) {
+        (0, xrpl_1.validate)(tx);
+    }
+    const txToSignAndEncode = { ...tx };
+    txToSignAndEncode.SigningPubKey = multisignAddress ? "" : wallet.publicKey;
+    if (multisignAddress) {
+        const signer = {
+            Account: multisignAddress,
+            SigningPubKey: wallet.publicKey,
+            TxnSignature: computeSignature(txToSignAndEncode, wallet.privateKey, multisignAddress, definitions),
+        };
+        txToSignAndEncode.Signers = [{ Signer: signer }];
+    }
+    else {
+        txToSignAndEncode.TxnSignature = computeSignature(txToSignAndEncode, wallet.privateKey, undefined, definitions);
+    }
+    const serialized = (0, ripple_binary_codec_1.encode)(txToSignAndEncode, definitions);
+    return {
+        tx_blob: serialized,
+        hash: hashSignedTx(serialized, definitions),
+    };
+}
+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;
+    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) {
+        const classicAddress = (0, ripple_address_codec_1.isValidXAddress)(signAs) ? (0, ripple_address_codec_1.xAddressToClassicAddress)(signAs).classicAddress : signAs;
+        return (0, ripple_keypairs_1.sign)((0, ripple_binary_codec_1.encodeForMultisigning)(tx, classicAddress, definitions), privateKey);
+    }
+    return (0, ripple_keypairs_1.sign)((0, ripple_binary_codec_1.encodeForSigning)(tx, definitions), privateKey);
+}
+function removeTrailingZeros(tx) {
+    if (tx.TransactionType === "Payment" &&
+        typeof tx.Amount !== "string" &&
+        tx.Amount.value.includes(".") &&
+        tx.Amount.value.endsWith("0")) {
+        tx.Amount = { ...tx.Amount };
+        tx.Amount.value = new bignumber_js_1.default(tx.Amount.value).toString();
+    }
+}
+function hashSignedTx(tx, definitions, validateTx) {
+    let txBlob;
+    let txObject;
+    if (typeof tx === "string") {
+        txBlob = tx;
+        txObject = (0, ripple_binary_codec_1.decode)(tx, definitions);
+    }
+    else {
+        txBlob = (0, ripple_binary_codec_1.encode)(tx, definitions);
+        txObject = tx;
+    }
+    if (validateTx !== false) {
+        if (txObject.TxnSignature === undefined && txObject.Signers === undefined) {
+            throw new xrpl_1.ValidationError("The transaction must be signed to hash it.");
+        }
+    }
+    const prefix = HashPrefix.TRANSACTION_ID.toString(16).toUpperCase();
+    return (0, common_1.sha512Half)(prefix.concat(txBlob));
+}
+function getXahauDefinitions() {
+    try {
+        const xahauEnums = require("../config/xahau_definitions.json");
+        const xahauDefinitions = new ripple_binary_codec_1.XrplDefinitions(xahauEnums);
+        return xahauDefinitions;
+    }
+    catch (_err) {
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bithomp/xrpl-api",
-  "version": "3.7.31",
+  "version": "3.7.38",
   "description": "A Bithomp JavaScript/TypeScript library for interacting with the XRP Ledger",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -42,7 +42,7 @@
     "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
     "lint": "eslint",
     "prepare": "npm run build",
-    "-prepublishOnly": "npm test && npm run lint",
+    "prepublishOnly": "npm test && npm run lint",
     "preversion": "npm run lint",
     "version": "npm run format && git add -A src",
     "postversion": "git push && git push --tags"
@@ -51,39 +51,39 @@
     "lib/**/*"
   ],
   "dependencies": {
-    "@noble/ed25519": "^3.0.0",
-    "@noble/hashes": "^2.0.1",
-    "@noble/secp256k1": "^3.0.0",
-    "axios": "^1.13.5",
+    "@noble/ed25519": "^3.1.0",
+    "@noble/hashes": "^2.2.0",
+    "@noble/secp256k1": "^3.1.0",
+    "axios": "^1.16.1",
     "base-x": "^5.0.1",
-    "bignumber.js": "^9.3.1",
-    "lodash": "^4.17.23",
+    "bignumber.js": "^11.1.2",
+    "lodash": "^4.18.1",
     "ripple-address-codec": "5.0.0",
     "ripple-binary-codec": "2.7.0",
     "ripple-keypairs": "2.0.0",
     "xrpl": "4.6.0"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/eslintrc": "^3.3.5",
     "@types/chai": "^5.2.3",
     "@types/chai-as-promised": "^8.0.2",
-    "@types/lodash": "^4.17.23",
+    "@types/lodash": "^4.17.24",
     "@types/mocha": "^10.0.10",
     "@types/nconf": "^0.10.7",
-    "@types/node": "^25.2.3",
-    "@typescript-eslint/eslint-plugin": "^8.56.0",
-    "@typescript-eslint/parser": "^8.56.0",
+    "@types/node": "^25.9.1",
+    "@typescript-eslint/eslint-plugin": "^8.60.0",
+    "@typescript-eslint/parser": "^8.60.0",
     "chai": "^6.2.2",
     "chai-as-promised": "^8.0.2",
-    "eslint": "^9.39.2",
+    "eslint": "^9.39.4",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-chai-friendly": "^1.1.0",
+    "eslint-plugin-chai-friendly": "^1.2.0",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^17.24.0",
-    "eslint-plugin-promise": "^7.2.1",
-    "mocha": "^11.7.5",
+    "eslint-plugin-n": "^18.0.1",
+    "eslint-plugin-promise": "^7.3.0",
+    "mocha": "^11.7.6",
     "nconf": "^0.13.0",
-    "ts-jest": "^29.4.6",
+    "ts-jest": "^29.4.11",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   }