@bithomp/xrpl-api 2.3.6

package/lib/v1/transaction/types.d.ts

@@ -0,0 +1,40 @@
+import { Amount, Memo } from "../common/types/objects";
+export type TransactionJSON = {
+    Account: string;
+    TransactionType: string;
+    Memos?: Memo[];
+    Flags?: number;
+    Fulfillment?: string;
+    [Field: string]: string | number | any[] | Amount | undefined;
+};
+export type Outcome = {
+    result?: string;
+    ledgerVersion?: number;
+    indexInLedger?: number;
+    fee?: string;
+    balanceChanges?: {
+        [key: string]: {
+            currency: string;
+            counterparty?: string;
+            value: string;
+        }[];
+    };
+    lockedBalanceChanges?: {
+        [key: string]: {
+            currency: string;
+            counterparty?: string;
+            value: string;
+        }[];
+    };
+    orderbookChanges?: object;
+    channelChanges?: object;
+    nftokenChanges?: object;
+    nftokenOfferChanges?: object;
+    affectedObjects?: object;
+    deliveredAmount?: {
+        currency: string;
+        counterparty?: string;
+        value: string;
+    };
+    timestamp?: string;
+};

package/lib/v1/transaction/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import { FormattedMemo, Memo } from "../common/types/objects";
+export interface ClassicAccountAndTag {
+    classicAccount: string;
+    tag: number | false | undefined;
+}
+export declare function getClassicAccountAndTag(Account: string, expectedTag?: number): ClassicAccountAndTag;
+export declare function convertStringToHex(value: string): string;
+export declare function convertMemo(memo: FormattedMemo): Memo;

package/lib/v1/transaction/utils.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertMemo = exports.convertStringToHex = exports.getClassicAccountAndTag = void 0;
+const ripple_address_codec_1 = require("ripple-address-codec");
+const common_1 = require("../../common");
+function getClassicAccountAndTag(Account, expectedTag) {
+    if ((0, ripple_address_codec_1.isValidXAddress)(Account)) {
+        const classic = (0, ripple_address_codec_1.xAddressToClassicAddress)(Account);
+        if (expectedTag != null && classic.tag !== expectedTag) {
+            throw new Error("address includes a tag that does not match the tag specified in the transaction");
+        }
+        return {
+            classicAccount: classic.classicAddress,
+            tag: classic.tag,
+        };
+    }
+    else {
+        return {
+            classicAccount: Account,
+            tag: expectedTag,
+        };
+    }
+}
+exports.getClassicAccountAndTag = getClassicAccountAndTag;
+function convertStringToHex(value) {
+    return Buffer.from(value, "utf8").toString("hex").toUpperCase();
+}
+exports.convertStringToHex = convertStringToHex;
+function convertMemo(memo) {
+    return {
+        Memo: (0, common_1.removeUndefined)({
+            MemoData: memo.data ? convertStringToHex(memo.data) : undefined,
+            MemoType: memo.type ? convertStringToHex(memo.type) : undefined,
+            MemoFormat: memo.format ? convertStringToHex(memo.format) : undefined,
+        }),
+    };
+}
+exports.convertMemo = convertMemo;

package/lib/validator.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+export declare function classicAddressFromValidatorPK(pk: string | Buffer): string | null;
+export interface GenerateSecretsInterface {
+    key_type: string;
+    secret_key: string;
+    public_key: string;
+    PublicKey: string;
+}
+export declare function generateSecrets(): GenerateSecretsInterface;
+export declare function sign(message: Buffer | string, secret: string): string;
+export declare function verify(message: Buffer | string, signature: string, publicKey: string): boolean;
+export declare function verify2(message: Buffer, signature: string, publicKey: string): boolean;

package/lib/validator.js

@@ -0,0 +1,134 @@
+"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.verify2 = exports.verify = exports.sign = exports.generateSecrets = exports.classicAddressFromValidatorPK = void 0;
+const assert = __importStar(require("assert"));
+const ripple_address_codec_1 = require("ripple-address-codec");
+const Crypto = __importStar(require("crypto"));
+const Base58 = __importStar(require("./base58"));
+const crypto_1 = __importDefault(require("crypto"));
+const elliptic_1 = __importDefault(require("elliptic"));
+const secp256k1 = new elliptic_1.default.ec("secp256k1");
+const ed25519 = new elliptic_1.default.eddsa("ed25519");
+const rippleKeypairs = __importStar(require("ripple-keypairs"));
+const DER_PRIVATE_KEY_PREFIX = Buffer.from("302E020100300506032B657004220420", "hex");
+const DER_PUBLIC_KEY_PREFIX = Buffer.from("302A300506032B6570032100", "hex");
+const VALIDATOR_HEX_PREFIX_ED25519 = "ED";
+const VALIDATOR_NODE_PUBLIC_KEY_PREFIX = "n";
+function classicAddressFromValidatorPK(pk) {
+    let pubkey = pk;
+    if (typeof pk === "string") {
+        pubkey = (0, ripple_address_codec_1.decodeNodePublic)(pk);
+    }
+    assert.ok(pubkey.length === 33);
+    assert.ok(Crypto.getHashes().includes("sha256"));
+    assert.ok(Crypto.getHashes().includes("ripemd160"));
+    const pubkeyInnerHash = Crypto.createHash("sha256").update(Buffer.from(pubkey));
+    const pubkeyOuterHash = Crypto.createHash("ripemd160");
+    pubkeyOuterHash.update(pubkeyInnerHash.digest());
+    const accountID = pubkeyOuterHash.digest();
+    const addressTypePrefix = Buffer.from([0x00]);
+    const payload = Buffer.concat([addressTypePrefix, accountID]);
+    const chksumHash1 = Crypto.createHash("sha256").update(payload).digest();
+    const chksumHash2 = Crypto.createHash("sha256").update(chksumHash1).digest();
+    const checksum = chksumHash2.slice(0, 4);
+    const dataToEncode = Buffer.concat([payload, checksum]);
+    const address = Base58.encode(dataToEncode);
+    return address;
+}
+exports.classicAddressFromValidatorPK = classicAddressFromValidatorPK;
+function generateSecrets() {
+    const keypair = crypto_1.default.generateKeyPairSync("ed25519", {
+        privateKeyEncoding: { format: "der", type: "pkcs8" },
+        publicKeyEncoding: { format: "der", type: "spki" },
+    });
+    const { privateKey, publicKey } = keypair;
+    const PublicKey = VALIDATOR_HEX_PREFIX_ED25519 +
+        publicKey.slice(DER_PUBLIC_KEY_PREFIX.length, publicKey.length).toString("hex").toUpperCase();
+    const secretKey = ripple_address_codec_1.codec.encode(privateKey.slice(DER_PRIVATE_KEY_PREFIX.length, privateKey.length), {
+        versions: [0x20],
+        expectedLength: 32,
+    });
+    return {
+        key_type: "ed25519",
+        secret_key: secretKey,
+        public_key: (0, ripple_address_codec_1.encodeNodePublic)(Buffer.from(PublicKey, "hex")),
+        PublicKey,
+    };
+}
+exports.generateSecrets = generateSecrets;
+function sign(message, secret) {
+    if (typeof message === "string") {
+        message = Buffer.from(message, "utf8");
+    }
+    try {
+        const decoded = ripple_address_codec_1.codec.decode(secret, { versions: [0x20] });
+        secret = VALIDATOR_HEX_PREFIX_ED25519 + decoded.bytes.toString("hex");
+    }
+    catch (err) {
+    }
+    return rippleKeypairs.sign(message.toString("hex"), secret).toUpperCase();
+}
+exports.sign = sign;
+function verify(message, signature, publicKey) {
+    if (typeof message === "string") {
+        message = Buffer.from(message, "utf8");
+    }
+    if (publicKey.slice(0, 1) === VALIDATOR_NODE_PUBLIC_KEY_PREFIX) {
+        const publicKeyBuffer = (0, ripple_address_codec_1.decodeNodePublic)(publicKey);
+        publicKey = publicKeyBuffer.toString("hex").toUpperCase();
+    }
+    try {
+        return rippleKeypairs.verify(message.toString("hex"), signature, publicKey);
+    }
+    catch (err) {
+    }
+    return false;
+}
+exports.verify = verify;
+function verify2(message, signature, publicKey) {
+    if (publicKey.slice(0, 1) === VALIDATOR_NODE_PUBLIC_KEY_PREFIX) {
+        const publicKeyBuffer = (0, ripple_address_codec_1.decodeNodePublic)(publicKey);
+        publicKey = publicKeyBuffer.toString("hex").toUpperCase();
+    }
+    if (publicKey.slice(0, 2) === VALIDATOR_HEX_PREFIX_ED25519) {
+        const verifyKey = ed25519.keyFromPublic(publicKey.slice(2), "hex");
+        if (verifyKey.verify(message.toString("hex"), signature)) {
+            return true;
+        }
+    }
+    else {
+        const computedHash = crypto_1.default.createHash("sha512").update(message).digest().toString("hex").slice(0, 64);
+        const verifyKey = secp256k1.keyFromPublic(publicKey, "hex");
+        if (verifyKey.verify(computedHash, signature)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.verify2 = verify2;

package/lib/wallet.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { Wallet, Transaction } from "xrpl";
+import { XrplDefinitionsBase } from "ripple-binary-codec";
+interface GenerateAddressInterface {
+    publicKey: string;
+    privateKey: string;
+    address: string;
+    seed: string;
+}
+export declare function generateAddress(): GenerateAddressInterface;
+export declare function isValidClassicAddress(address: string): boolean;
+export declare function checksumClassicAddress(buffer: Buffer): Buffer;
+export declare function singTransaction(wallet: Wallet, transaction: Transaction, multisign?: boolean | string, definitions?: XrplDefinitionsBase): {
+    tx_blob: string;
+    hash: string;
+};
+export {};

package/lib/wallet.js

@@ -0,0 +1,140 @@
+"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.singTransaction = exports.checksumClassicAddress = exports.isValidClassicAddress = exports.generateAddress = void 0;
+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");
+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 generateAddress() {
+    const wallet = xrpl_1.Wallet.generate();
+    const { publicKey, privateKey, classicAddress, seed } = wallet;
+    return { publicKey, privateKey, address: classicAddress, seed: seed };
+}
+exports.generateAddress = generateAddress;
+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;
+}
+exports.isValidClassicAddress = isValidClassicAddress;
+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;
+}
+exports.checksumClassicAddress = checksumClassicAddress;
+function singTransaction(wallet, transaction, multisign, definitions) {
+    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);
+    (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),
+    };
+}
+exports.singTransaction = singTransaction;
+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) {
+    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);
+        txObject = tx;
+    }
+    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));
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@bithomp/xrpl-api",
+  "version": "2.3.6",
+  "description": "A Bithomp JavaScript/TypeScript library for interacting with the XRP Ledger",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "author": "Bithomp AB",
+  "license": "GPL-3.0",
+  "-publishConfig": {
+    "-registry": "https://npm.pkg.github.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bithomp/xrpl-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Bithomp/xrpl-api/issues"
+  },
+  "homepage": "https://github.com/Bithomp/xrpl-api#readme",
+  "scripts": {
+    "test": "node ./node_modules/mocha/bin/mocha",
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "prepare": "npm run build",
+    "-prepublishOnly": "npm test && npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src",
+    "postversion": "git push && git push --tags"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "dependencies": {
+    "@types/nconf": "^0.10.3",
+    "axios": "^0.27.2",
+    "base-x": "^4.0.0",
+    "bignumber.js": "^9.1.1",
+    "elliptic": "^6.5.4",
+    "lodash": "^4.17.21",
+    "ripple-address-codec": "^4.3.0",
+    "ripple-binary-codec": "^1.6.0",
+    "xrpl": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.195",
+    "@types/chai": "^4.3.5",
+    "@types/chai-as-promised": "^7.1.5",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^18.16.3",
+    "chai": "^4.3.7",
+    "chai-as-promised": "^7.1.1",
+    "mocha": "^10.2.0",
+    "nconf": "^0.12.0",
+    "prettier": "^2.8.8",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^5.1.3"
+  }
+}