@bithomp/xrpl-api 3.7.31 → 3.7.37

package/lib/src/types/trustlines.d.ts

@@ -0,0 +1,85 @@
+import { LedgerEntry, TrustSetFlags } from "xrpl";
+import { FormattedBaseSpecification } from "./specification";
+import { TxGlobalFlagsKeysInterface } from "./global";
+export declare const TrustSetFlagsKeys: {
+    setfAuth: TrustSetFlags;
+    setNoRipple: TrustSetFlags;
+    clearNoRipple: TrustSetFlags;
+    setFreeze: TrustSetFlags;
+    clearFreeze: TrustSetFlags;
+    setDeepFreeze: TrustSetFlags;
+    clearDeepFreeze: TrustSetFlags;
+};
+export declare function getTrustSetFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface TrustSetFlagsKeysInterface extends TxGlobalFlagsKeysInterface {
+    setfAuth?: boolean;
+    setNoRipple?: boolean;
+    clearNoRipple?: boolean;
+    setFreeze?: boolean;
+    clearFreeze?: boolean;
+    setDeepFreeze?: boolean;
+    clearDeepFreeze?: boolean;
+}
+export declare const TrustlineFlagsKeys: {
+    lowReserve: LedgerEntry.RippleStateFlags;
+    highReserve: LedgerEntry.RippleStateFlags;
+    lowAuth: LedgerEntry.RippleStateFlags;
+    highAuth: LedgerEntry.RippleStateFlags;
+    lowNoRipple: LedgerEntry.RippleStateFlags;
+    highNoRipple: LedgerEntry.RippleStateFlags;
+    lowFreeze: LedgerEntry.RippleStateFlags;
+    highFreeze: LedgerEntry.RippleStateFlags;
+    ammNode: LedgerEntry.RippleStateFlags;
+    lowDeepFreeze: LedgerEntry.RippleStateFlags;
+    highDeepFreeze: LedgerEntry.RippleStateFlags;
+};
+export interface TrustlineFlagsKeysInterface {
+    lowReserve: boolean;
+    highReserve: boolean;
+    lowAuth: boolean;
+    highAuth: boolean;
+    lowNoRipple: boolean;
+    highNoRipple: boolean;
+    lowFreeze: boolean;
+    highFreeze: boolean;
+    ammNode: boolean;
+    lowDeepFreeze: boolean;
+    highDeepFreeze: boolean;
+}
+export interface Trustline {
+    account: string;
+    balance: string;
+    currency: string;
+    limit: string;
+    limit_peer: string;
+    quality_in: number;
+    quality_out: number;
+    no_ripple?: boolean;
+    no_ripple_peer?: boolean;
+    freeze?: boolean;
+    freeze_peer?: boolean;
+    authorized?: boolean;
+    peer_authorized?: boolean;
+}
+export type FormattedTrustlineSpecification = {
+    currency: string;
+    counterparty: string;
+    limit: string;
+    qualityIn?: number;
+    qualityOut?: number;
+    ripplingDisabled?: boolean;
+    authorized?: boolean;
+    frozen?: boolean;
+} & FormattedBaseSpecification;
+export type FormattedTrustline = {
+    specification: FormattedTrustlineSpecification;
+    counterparty: {
+        limit: string;
+        ripplingDisabled?: boolean;
+        frozen?: boolean;
+        authorized?: boolean;
+    };
+    state: {
+        balance: string;
+    };
+};

package/lib/src/types/trustlines.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrustlineFlagsKeys = exports.TrustSetFlagsKeys = void 0;
+exports.getTrustSetFlagsKeys = getTrustSetFlagsKeys;
+const xrpl_1 = require("xrpl");
+const { RippleStateFlags } = xrpl_1.LedgerEntry;
+const global_1 = require("./global");
+const common_1 = require("../common");
+exports.TrustSetFlagsKeys = {
+    setfAuth: xrpl_1.TrustSetFlags.tfSetfAuth,
+    setNoRipple: xrpl_1.TrustSetFlags.tfSetNoRipple,
+    clearNoRipple: xrpl_1.TrustSetFlags.tfClearNoRipple,
+    setFreeze: xrpl_1.TrustSetFlags.tfSetFreeze,
+    clearFreeze: xrpl_1.TrustSetFlags.tfClearFreeze,
+    setDeepFreeze: xrpl_1.TrustSetFlags.tfSetDeepFreeze,
+    clearDeepFreeze: xrpl_1.TrustSetFlags.tfClearDeepFreeze,
+};
+const nativeCurrencyTrustSetFlags = {};
+function getTrustSetFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyTrustSetFlags[nativeCurrency]) {
+        nativeCurrencyTrustSetFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.TrustSetFlagsKeys,
+        };
+    }
+    return nativeCurrencyTrustSetFlags[nativeCurrency];
+}
+exports.TrustlineFlagsKeys = {
+    lowReserve: RippleStateFlags.lsfLowReserve,
+    highReserve: RippleStateFlags.lsfHighReserve,
+    lowAuth: RippleStateFlags.lsfLowAuth,
+    highAuth: RippleStateFlags.lsfHighAuth,
+    lowNoRipple: RippleStateFlags.lsfLowNoRipple,
+    highNoRipple: RippleStateFlags.lsfHighNoRipple,
+    lowFreeze: RippleStateFlags.lsfLowFreeze,
+    highFreeze: RippleStateFlags.lsfHighFreeze,
+    ammNode: RippleStateFlags.lsfAMMNode,
+    lowDeepFreeze: RippleStateFlags.lsfLowDeepFreeze,
+    highDeepFreeze: RippleStateFlags.lsfHighDeepFreeze,
+};

package/lib/src/types/unl_modify.d.ts

@@ -0,0 +1,6 @@
+import { FormattedBaseSpecification } from "./specification";
+export type FormattedUNLModifySpecification = {
+    nUNL?: boolean;
+    PublicKey?: string;
+    publicKey?: string;
+} & FormattedBaseSpecification;

package/lib/src/types/unl_modify.js

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

package/lib/src/types/unl_reports.d.ts

@@ -0,0 +1,5 @@
+import { FormattedBaseSpecification } from "./specification";
+export type FormattedUNLReportSpecification = {
+    activeValidator?: string;
+    importVLKey?: string;
+} & FormattedBaseSpecification;

package/lib/src/types/unl_reports.js

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

package/lib/src/types/unrecognized.d.ts

@@ -0,0 +1,5 @@
+import { FormattedBaseSpecification } from "./specification";
+export type FormattedUnrecognizedParserSpecification = {
+    UNAVAILABLE: string;
+    SEE_RAW_TRANSACTION: string;
+} & FormattedBaseSpecification;

package/lib/src/types/unrecognized.js

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

package/lib/src/types/uri_tokens.d.ts

@@ -0,0 +1,7 @@
+import { URITokenMintFlags } from "../models/transactions/URITokenMint";
+export declare const URITokenFlagsKeys: {
+    burnable: URITokenMintFlags;
+};
+export interface URITokenFlagsKeysInterface {
+    burnable?: boolean;
+}

package/lib/src/types/uri_tokens.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URITokenFlagsKeys = void 0;
+exports.URITokenFlagsKeys = {
+    burnable: 1,
+};

package/lib/src/types/uritokens.d.ts

@@ -0,0 +1,41 @@
+import { URITokenMintFlags } from "../models/transactions/URITokenMint";
+import { FormattedBaseSpecification } from "./specification";
+import { Amount } from "./amounts";
+import { FormattedSourceAddress, FormattedDestinationAddress } from "./account";
+import { TxGlobalFlagsKeysInterface } from "./global";
+export declare const URITokenFlagsKeys: {
+    burnable: URITokenMintFlags;
+};
+export declare function getURITokenMintFlagsKeys(nativeCurrency?: string): Record<string, number>;
+export interface URITokenFlagsKeysInterface extends TxGlobalFlagsKeysInterface {
+    burnable?: boolean;
+}
+export type FormattedURITokenBurnSpecification = {
+    uritokenID: string;
+} & FormattedBaseSpecification;
+export type FormattedURITokenBuySpecification = {
+    uritokenID: string;
+    amount: string;
+} & FormattedBaseSpecification;
+export type FormattedURITokenMintSpecification = {
+    uri?: string;
+    flags?: URITokenFlagsKeysInterface;
+    digest?: string;
+    amount: Amount;
+    source?: FormattedSourceAddress;
+    destination?: FormattedDestinationAddress;
+} & FormattedBaseSpecification;
+export type FormattedURITokenCancelSellOfferSpecification = {
+    uritokenID: string;
+} & FormattedBaseSpecification;
+export type FormattedURITokenCreateSellOfferSpecification = {
+    uritokenID: string;
+    amount: string;
+    source?: FormattedSourceAddress;
+    destination?: FormattedDestinationAddress;
+} & FormattedBaseSpecification;
+export type FormattedURITokenAcceptOfferSpecification = {
+    nftokenSellOffer?: string;
+    nftokenBuyOffer?: string;
+    nftokenBrokerFee?: string;
+} & FormattedBaseSpecification;

package/lib/src/types/uritokens.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URITokenFlagsKeys = void 0;
+exports.getURITokenMintFlagsKeys = getURITokenMintFlagsKeys;
+const global_1 = require("./global");
+const common_1 = require("../common");
+exports.URITokenFlagsKeys = {
+    burnable: 1,
+};
+const nativeCurrencyURITokenMintFlags = {};
+function getURITokenMintFlagsKeys(nativeCurrency) {
+    if (!nativeCurrency) {
+        nativeCurrency = common_1.MAINNET_NATIVE_CURRENCY;
+    }
+    if (!nativeCurrencyURITokenMintFlags[nativeCurrency]) {
+        nativeCurrencyURITokenMintFlags[nativeCurrency] = {
+            ...(0, global_1.getTxGlobalFlagsKeys)(nativeCurrency),
+            ...exports.URITokenFlagsKeys,
+        };
+    }
+    return nativeCurrencyURITokenMintFlags[nativeCurrency];
+}

package/lib/src/v1/transaction/payment.d.ts

@@ -0,0 +1,14 @@
+import { TransactionJSON } from "../types";
+import { Adjustment, MaxAdjustment, MinAdjustment, FormattedMemo } from "../../types";
+export interface Payment {
+    source: Adjustment | MaxAdjustment;
+    destination: Adjustment | MinAdjustment;
+    paths?: string;
+    networkID?: number;
+    memos?: FormattedMemo[];
+    invoiceID?: string;
+    allowPartialPayment?: boolean;
+    noDirectRipple?: boolean;
+    limitQuality?: boolean;
+}
+export declare function createPaymentTransaction(address: string, paymentArgument: Payment): TransactionJSON;

package/lib/src/v1/transaction/payment.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPaymentTransaction = createPaymentTransaction;
+const lodash_1 = __importDefault(require("lodash"));
+const xrpl_1 = require("xrpl");
+const common_1 = require("../../common");
+const utils_1 = require("../utils");
+const memos_1 = require("../../parse/ledger/memos");
+const client_1 = require("../../client");
+function isMaxAdjustment(source) {
+    return source.maxAmount != null;
+}
+function isMinAdjustment(destination) {
+    return destination.minAmount != null;
+}
+function isXRPToXRPPayment(payment) {
+    const { source, destination } = payment;
+    const sourceCurrency = isMaxAdjustment(source) ? source.maxAmount.currency : source.amount.currency;
+    const destinationCurrency = isMinAdjustment(destination)
+        ? destination.minAmount.currency
+        : destination.amount.currency;
+    return ((sourceCurrency === (0, client_1.getNativeCurrency)() || sourceCurrency === "drops") &&
+        (destinationCurrency === (0, client_1.getNativeCurrency)() || destinationCurrency === "drops"));
+}
+function isIOUWithoutCounterparty(amount) {
+    if (typeof amount === "object") {
+        if ("currency" in amount && amount.currency !== (0, client_1.getNativeCurrency)() && amount.currency !== "drops") {
+            return false;
+        }
+        if ("mpt_issuance_id" in amount && amount.mpt_issuance_id) {
+            return false;
+        }
+        if (amount.issuer == null &&
+            amount.counterparty == null) {
+            return true;
+        }
+    }
+    return false;
+}
+function applyAnyCounterpartyEncoding(payment) {
+    [payment.source, payment.destination].forEach((adjustment) => {
+        ["amount", "minAmount", "maxAmount"].forEach((key) => {
+            if (isIOUWithoutCounterparty(adjustment[key])) {
+                adjustment[key].issuer = adjustment.address;
+            }
+        });
+    });
+}
+function createMaximalAmount(amount) {
+    const maxXRPValue = "100000000000";
+    const maxIOUValue = "999999999999999900000000000000000000000000000000000000000000000000000000000000000000000000000000";
+    let maxValue;
+    if (amount.currency === (0, client_1.getNativeCurrency)()) {
+        maxValue = maxXRPValue;
+    }
+    else if (amount.currency === "drops") {
+        maxValue = (0, common_1.xrpToDrops)(maxXRPValue);
+    }
+    else {
+        maxValue = maxIOUValue;
+    }
+    return Object.assign({}, amount, { value: maxValue });
+}
+function validateAndNormalizeAddress(address, expectedTag) {
+    const classicAddress = (0, utils_1.getClassicAccountAndTag)(address, expectedTag);
+    classicAddress.tag = classicAddress.tag === false ? undefined : classicAddress.tag;
+    return classicAddress;
+}
+function createPaymentTransaction(address, paymentArgument) {
+    const payment = lodash_1.default.cloneDeep(paymentArgument);
+    applyAnyCounterpartyEncoding(payment);
+    const sourceAddressAndTag = validateAndNormalizeAddress(payment.source.address, payment.source.tag);
+    const addressToVerifyAgainst = validateAndNormalizeAddress(address, undefined);
+    if (addressToVerifyAgainst.classicAccount !== sourceAddressAndTag.classicAccount) {
+        throw new Error("address must match payment.source.address");
+    }
+    if (addressToVerifyAgainst.tag != null &&
+        sourceAddressAndTag.tag != null &&
+        addressToVerifyAgainst.tag !== sourceAddressAndTag.tag) {
+        throw new Error("address includes a tag that does not match payment.source.tag");
+    }
+    const destinationAddressAndTag = validateAndNormalizeAddress(payment.destination.address, payment.destination.tag);
+    if ((isMaxAdjustment(payment.source) && isMinAdjustment(payment.destination)) ||
+        (!isMaxAdjustment(payment.source) && !isMinAdjustment(payment.destination))) {
+        throw new Error("payment must specify either (source.maxAmount " +
+            "and destination.amount) or (source.amount and destination.minAmount)");
+    }
+    const destinationAmount = isMinAdjustment(payment.destination)
+        ? payment.destination.minAmount
+        : payment.destination.amount;
+    const sourceAmount = isMaxAdjustment(payment.source) ? payment.source.maxAmount : payment.source.amount;
+    const amount = isMinAdjustment(payment.destination) && !isXRPToXRPPayment(payment)
+        ? createMaximalAmount(destinationAmount)
+        : destinationAmount;
+    const txJSON = {
+        TransactionType: "Payment",
+        Account: sourceAddressAndTag.classicAccount,
+        Destination: destinationAddressAndTag.classicAccount,
+        Amount: (0, utils_1.toRippledAmount)(amount),
+        Flags: 0,
+    };
+    if (payment.invoiceID != null) {
+        txJSON.InvoiceID = payment.invoiceID;
+    }
+    if (sourceAddressAndTag.tag != null) {
+        txJSON.SourceTag = sourceAddressAndTag.tag;
+    }
+    if (destinationAddressAndTag.tag != null) {
+        txJSON.DestinationTag = destinationAddressAndTag.tag;
+    }
+    if (payment.networkID != null) {
+        txJSON.NetworkID = payment.networkID;
+    }
+    if (payment.memos != null) {
+        txJSON.Memos = payment.memos.map(memos_1.formattedMemoToMemo);
+    }
+    if (payment.noDirectRipple === true) {
+        txJSON.Flags |= xrpl_1.PaymentFlags.tfNoRippleDirect;
+    }
+    if (payment.limitQuality === true) {
+        txJSON.Flags |= xrpl_1.PaymentFlags.tfLimitQuality;
+    }
+    if (!isXRPToXRPPayment(payment)) {
+        if (payment.allowPartialPayment || isMinAdjustment(payment.destination)) {
+            txJSON.Flags |= xrpl_1.PaymentFlags.tfPartialPayment;
+        }
+        txJSON.SendMax = (0, utils_1.toRippledAmount)(sourceAmount);
+        if (isMinAdjustment(payment.destination)) {
+            txJSON.DeliverMin = (0, utils_1.toRippledAmount)(destinationAmount);
+        }
+        if (payment.paths != null) {
+            txJSON.Paths = JSON.parse(payment.paths);
+        }
+    }
+    else if (payment.allowPartialPayment === true) {
+        throw new Error("XRP to XRP payments cannot be partial payments");
+    }
+    return txJSON;
+}

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

@@ -0,0 +1,9 @@
+import { Amount, Memo } from "../types";
+export type TransactionJSON = {
+    Account: string;
+    TransactionType: string;
+    Memos?: Memo[];
+    Flags?: number;
+    Fulfillment?: string;
+    [Field: string]: string | number | any[] | Amount | undefined;
+};

package/lib/src/v1/types.js

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

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

@@ -0,0 +1,7 @@
+import { Amount, FormattedIssuedCurrencyAmount } from "../types";
+export declare function toRippledAmount(amount: Amount | FormattedIssuedCurrencyAmount): Amount | undefined;
+export interface ClassicAccountAndTag {
+    classicAccount: string;
+    tag: number | false | undefined;
+}
+export declare function getClassicAccountAndTag(Account: string, expectedTag?: number): ClassicAccountAndTag;

package/lib/src/v1/utils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRippledAmount = toRippledAmount;
+exports.getClassicAccountAndTag = getClassicAccountAndTag;
+const ripple_address_codec_1 = require("ripple-address-codec");
+const common_1 = require("../common");
+const client_1 = require("../client");
+function toRippledAmount(amount) {
+    if (typeof amount === "string")
+        return amount;
+    if ("currency" in amount) {
+        if (amount.currency === (0, client_1.getNativeCurrency)()) {
+            return (0, common_1.xrpToDrops)(amount.value);
+        }
+        else if (amount.currency === "drops") {
+            return amount.value;
+        }
+        const issuer = amount.counterparty || amount.issuer;
+        return {
+            currency: amount.currency,
+            issuer,
+            value: amount.value,
+        };
+    }
+    if ("mpt_issuance_id" in amount) {
+        return {
+            value: amount.value,
+            mpt_issuance_id: amount.mpt_issuance_id,
+        };
+    }
+}
+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,
+        };
+    }
+}

package/lib/src/validator.d.ts

@@ -0,0 +1,11 @@
+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/src/validator.js

@@ -0,0 +1,130 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classicAddressFromValidatorPK = classicAddressFromValidatorPK;
+exports.generateSecrets = generateSecrets;
+exports.sign = sign;
+exports.verify = verify;
+exports.verify2 = verify2;
+const assert = __importStar(require("assert"));
+const ripple_address_codec_1 = require("ripple-address-codec");
+const Crypto = __importStar(require("crypto"));
+const rippleKeypairs = __importStar(require("ripple-keypairs"));
+const utils_1 = require("./parse/utils");
+const secp256k1 = __importStar(require("@noble/secp256k1"));
+const ed25519 = __importStar(require("@noble/ed25519"));
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+ed25519.hashes.sha512 = sha2_js_1.sha512;
+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 = Buffer.from((0, ripple_address_codec_1.decodeNodePublic)(pk).buffer);
+    }
+    assert.ok(pubkey.length === 33);
+    assert.ok(Crypto.getHashes().includes("sha256"));
+    assert.ok(Crypto.getHashes().includes("ripemd160"));
+    const pubkeyInnerHash = Crypto.createHash("sha256").update(pubkey);
+    const pubkeyOuterHash = Crypto.createHash("ripemd160");
+    pubkeyOuterHash.update(pubkeyInnerHash.digest());
+    const accountID = pubkeyOuterHash.digest();
+    return (0, ripple_address_codec_1.encodeAccountID)(accountID);
+}
+function generateSecrets() {
+    const keypair = Crypto.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,
+    };
+}
+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 + (0, utils_1.bytesToHex)(decoded.bytes.buffer);
+    }
+    catch (_err) {
+    }
+    return rippleKeypairs.sign(message.toString("hex"), secret).toUpperCase();
+}
+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 = (0, utils_1.bytesToHex)(publicKeyBuffer.buffer);
+    }
+    try {
+        return rippleKeypairs.verify(message.toString("hex"), signature, publicKey);
+    }
+    catch (_err) {
+    }
+    return false;
+}
+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 = (0, utils_1.bytesToHex)(publicKeyBuffer.buffer);
+    }
+    if (publicKey.slice(0, 2) === VALIDATOR_HEX_PREFIX_ED25519) {
+        const publicKeyBytes = Buffer.from(publicKey.slice(2), "hex");
+        const signatureBytes = Buffer.from(signature, "hex");
+        return ed25519.verify(signatureBytes, message, publicKeyBytes);
+    }
+    else {
+        const computedHash = Crypto.createHash("sha512").update(message).digest().slice(0, 32);
+        const publicKeyBytes = Buffer.from(publicKey, "hex");
+        const signatureBytes = Buffer.from(signature, "hex");
+        return secp256k1.verify(signatureBytes, computedHash, publicKeyBytes);
+    }
+}

package/lib/src/wallet.d.ts

@@ -0,0 +1,34 @@
+import { Wallet, Transaction, ECDSA } from "xrpl";
+import { XrplDefinitionsBase, XrplDefinitions, DEFAULT_DEFINITIONS } from "ripple-binary-codec";
+interface GenerateAddressInterface {
+    publicKey: string;
+    privateKey: string;
+    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;
+    algorithm?: ECDSA;
+    seedAddress?: string;
+    ignoreSeedPayload?: boolean;
+}
+export declare function walletFromSeed(seed: string, options?: WalletFromSeedInterface): Wallet;
+export declare function generateAddress(): GenerateAddressInterface;
+export declare function isValidClassicAddress(address: string): boolean;
+export declare function checksumClassicAddress(buffer: Buffer): Buffer;
+export declare function signTransaction(wallet: Wallet, transaction: Transaction, multisign?: boolean | string, definitions?: XrplDefinitionsBase, validateTx?: boolean): {
+    tx_blob: string;
+    hash: string;
+};
+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;
+declare function getXahauDefinitions(): XrplDefinitionsBase | undefined;
+export { XrplDefinitionsBase, XrplDefinitions, DEFAULT_DEFINITIONS, hashSignedTx, getXahauDefinitions };