@bithomp/xrpl-api 3.7.31 → 3.7.38

package/lib/src/models/mptoken.js

@@ -0,0 +1,59 @@
+"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.buildMPTokenIssuanceID = buildMPTokenIssuanceID;
+exports.parseMPTokenIssuanceID = parseMPTokenIssuanceID;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const AddressCodec = __importStar(require("ripple-address-codec"));
+const utils_1 = require("../parse/utils");
+function buildMPTokenIssuanceID(sequence, issuer) {
+    return (new bignumber_js_1.default(sequence).toString(16).padStart(8, "0").toUpperCase() +
+        (0, utils_1.bytesToHex)(AddressCodec.decodeAccountID(issuer).buffer));
+}
+function parseMPTokenIssuanceID(mptIssuanceID) {
+    if (typeof mptIssuanceID !== "string" || mptIssuanceID.length !== 48) {
+        return null;
+    }
+    const sequence = new bignumber_js_1.default(mptIssuanceID.slice(0, 8), 16).toNumber();
+    const issuer = AddressCodec.encodeAccountID(Buffer.from(mptIssuanceID.slice(8, 48), "hex"));
+    return {
+        MPTokenIssuanceID: mptIssuanceID,
+        Sequence: sequence,
+        Issuer: issuer,
+    };
+}

package/lib/src/models/path_find.d.ts

@@ -0,0 +1,11 @@
+import { Amount, PathFindPathOption } from "xrpl";
+export interface PathFindResponseResult {
+    alternatives: PathFindPathOption[];
+    destination_account: string;
+    destination_amount: Amount;
+    source_account: string;
+    full_reply: boolean;
+    id?: number | string;
+    closed?: true;
+    status?: true;
+}

package/lib/src/models/path_find.js

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

package/lib/src/models/server_definitions.d.ts

@@ -0,0 +1,33 @@
+interface FieldInfo {
+    nth: number;
+    isVLEncoded: boolean;
+    isSerialized: boolean;
+    isSigningField: boolean;
+    type: string;
+}
+interface DefinitionsData {
+    TYPES: Record<string, number>;
+    LEDGER_ENTRY_TYPES: Record<string, number>;
+    FIELDS: (string | FieldInfo)[][];
+    TRANSACTION_RESULTS: Record<string, number>;
+    TRANSACTION_TYPES: Record<string, number>;
+}
+interface AmendmentInterface {
+    count?: number;
+    enabled?: boolean;
+    name?: string;
+    supported?: boolean;
+    threshold?: number;
+    validations?: number;
+    vetoed?: string;
+}
+interface ServerDefinitionsResponseResultBase extends DefinitionsData {
+    features?: {
+        [key: string]: AmendmentInterface;
+    }[];
+}
+export type ServerDefinitionsResponseResult = {
+    hash: string;
+    native_currency_code?: string;
+} & ServerDefinitionsResponseResultBase;
+export {};

package/lib/src/models/server_definitions.js

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

package/lib/src/models/transaction.d.ts

@@ -0,0 +1,52 @@
+import { Transaction, TransactionMetadata } from "xrpl";
+import { XrplDefinitionsBase } from "ripple-binary-codec";
+import { FormattedSpecification, FormattedTransaction } from "../parse/transaction";
+export { FormattedTransaction } from "../parse/transaction";
+import { Outcome } from "../types/outcome";
+import { BalanceChanges } from "../parse/outcome/balance_changes";
+export interface TransactionBaseResponse {
+    hash: string;
+    ledger_index?: number;
+    meta?: TransactionMetadata | string;
+    validated?: boolean;
+    date?: number;
+    balanceChanges?: BalanceChanges;
+    specification?: FormattedSpecification;
+    outcome?: Outcome;
+    rawTransaction?: string;
+}
+export type TransactionResponse = TransactionBaseResponse & Transaction;
+export type AccountTransaction = {
+    tx: TransactionResponse;
+    meta: TransactionMetadata;
+    validated: boolean;
+};
+export type LedgerTransaction = TransactionBaseResponse & {
+    metaData?: TransactionMetadata;
+};
+export type StreamTransaction = TransactionBaseResponse & {
+    transaction: TransactionResponse;
+    meta: TransactionMetadata;
+};
+export interface AccountPaymentParamsInterface {
+    fee?: string;
+    sequence?: number;
+    lastLedgerSequence?: number;
+    networkID?: number;
+}
+export declare function getTxDetails(tx: TransactionResponse, includeRawTransaction?: boolean, nativeCurrency?: string, definitions?: XrplDefinitionsBase): FormattedTransaction;
+export declare function getAccountTxDetails(tx: AccountTransaction, includeRawTransaction?: boolean, nativeCurrency?: string): FormattedTransaction;
+export declare function getLedgerTxDetails(tx: LedgerTransaction, ledgerIndex: number, closeTime: number, includeRawTransaction?: boolean, nativeCurrency?: string, definitions?: XrplDefinitionsBase): FormattedTransaction;
+export declare function getStreamTxDetails(tx: StreamTransaction, includeRawTransaction?: boolean, nativeCurrency?: string, definitions?: XrplDefinitionsBase): FormattedTransaction;
+export declare function accountTxToTx(accountTx: AccountTransaction): TransactionResponse;
+export declare function ledgerTxToTx(ledgerTx: LedgerTransaction, ledgerIndex: number, closeTime: number): TransactionResponse;
+export declare function streamTxToTx(streamTx: StreamTransaction): TransactionResponse;
+export declare function isCTID(ctid: string | bigint): boolean;
+export declare function encodeCTIDforTransaction(transaction: TransactionResponse, networkID: number): string | undefined;
+export declare function encodeCTID(ledgerIndex: number, txIndex: number, networkID: number): string;
+export interface DecodeCTIDInterface {
+    ledgerIndex: number;
+    txIndex: number;
+    networkID: number;
+}
+export declare function decodeCTID(ctid: string | bigint): DecodeCTIDInterface;

package/lib/src/models/transaction.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTxDetails = getTxDetails;
+exports.getAccountTxDetails = getAccountTxDetails;
+exports.getLedgerTxDetails = getLedgerTxDetails;
+exports.getStreamTxDetails = getStreamTxDetails;
+exports.accountTxToTx = accountTxToTx;
+exports.ledgerTxToTx = ledgerTxToTx;
+exports.streamTxToTx = streamTxToTx;
+exports.isCTID = isCTID;
+exports.encodeCTIDforTransaction = encodeCTIDforTransaction;
+exports.encodeCTID = encodeCTID;
+exports.decodeCTID = decodeCTID;
+const lodash_1 = __importDefault(require("lodash"));
+const transaction_1 = require("../parse/transaction");
+const CTID_REGEX = /^[cC]{1}[a-fA-F0-9]{15}$/;
+function getTxDetails(tx, includeRawTransaction, nativeCurrency, definitions) {
+    return (0, transaction_1.parseTransaction)(tx, includeRawTransaction, nativeCurrency, definitions);
+}
+function getAccountTxDetails(tx, includeRawTransaction, nativeCurrency) {
+    return getTxDetails(accountTxToTx(tx), includeRawTransaction, nativeCurrency);
+}
+function getLedgerTxDetails(tx, ledgerIndex, closeTime, includeRawTransaction, nativeCurrency, definitions) {
+    return getTxDetails(ledgerTxToTx(tx, ledgerIndex, closeTime), includeRawTransaction, nativeCurrency, definitions);
+}
+function getStreamTxDetails(tx, includeRawTransaction, nativeCurrency, definitions) {
+    return getTxDetails(streamTxToTx(tx), includeRawTransaction, nativeCurrency, definitions);
+}
+function accountTxToTx(accountTx) {
+    return Object.assign({}, accountTx.tx, { meta: accountTx.meta, validated: accountTx.validated });
+}
+function ledgerTxToTx(ledgerTx, ledgerIndex, closeTime) {
+    const tx = lodash_1.default.omit(ledgerTx, "metaData");
+    return Object.assign({}, tx, {
+        meta: ledgerTx.metaData,
+        date: closeTime,
+        ledger_index: ledgerIndex,
+        validated: true,
+    });
+}
+function streamTxToTx(streamTx) {
+    return Object.assign({}, streamTx.transaction, {
+        meta: streamTx.meta,
+        ledger_index: streamTx.ledger_index,
+        validated: streamTx.validated,
+    });
+}
+function isCTID(ctid) {
+    let ctidValue;
+    if (typeof ctid === "string") {
+        if (!CTID_REGEX.test(ctid)) {
+            return false;
+        }
+        ctidValue = BigInt("0x" + ctid);
+    }
+    else if (typeof ctid === "bigint") {
+        ctidValue = ctid;
+    }
+    else {
+        return false;
+    }
+    if (ctidValue > 0xffffffffffffffffn || (ctidValue & 0xf000000000000000n) !== 0xc000000000000000n) {
+        return false;
+    }
+    return true;
+}
+function encodeCTIDforTransaction(transaction, networkID) {
+    let ledgerIndex;
+    if (transaction.ledger_index) {
+        ledgerIndex = transaction.ledger_index;
+    }
+    else if (transaction.tx && transaction.tx.ledger_index) {
+        ledgerIndex = transaction.tx.ledger_index;
+    }
+    else if (transaction.tx_json && transaction.tx_json.ledger_index) {
+        ledgerIndex = transaction.tx_json.ledger_index;
+    }
+    if (typeof ledgerIndex !== "number") {
+        return undefined;
+    }
+    const meta = (transaction.meta || transaction.metaData);
+    if (!meta || !meta.TransactionIndex) {
+        return undefined;
+    }
+    if (typeof networkID !== "number") {
+        return undefined;
+    }
+    return encodeCTID(ledgerIndex, meta.TransactionIndex, networkID);
+}
+function encodeCTID(ledgerIndex, txIndex, networkID) {
+    if (typeof ledgerIndex !== "number") {
+        throw new Error("ledgerIndex must be a number.");
+    }
+    if (ledgerIndex > 0xfffffff || ledgerIndex < 0) {
+        throw new Error("ledgerIndex must not be greater than 268435455 or less than 0.");
+    }
+    if (typeof txIndex !== "number") {
+        throw new Error("txIndex must be a number.");
+    }
+    if (txIndex > 0xffff || txIndex < 0) {
+        throw new Error("txIndex must not be greater than 65535 or less than 0.");
+    }
+    if (typeof networkID !== "number") {
+        throw new Error("networkID must be a number.");
+    }
+    if (networkID > 0xffff || networkID < 0) {
+        throw new Error("networkID must not be greater than 65535 or less than 0.");
+    }
+    return (((BigInt(0xc0000000) + BigInt(ledgerIndex)) << 32n) + (BigInt(txIndex) << 16n) + BigInt(networkID))
+        .toString(16)
+        .toUpperCase();
+}
+function decodeCTID(ctid) {
+    let ctidValue;
+    if (typeof ctid === "string") {
+        if (!CTID_REGEX.test(ctid)) {
+            throw new Error("CTID must be exactly 16 nibbles and start with a C");
+        }
+        ctidValue = BigInt("0x" + ctid);
+    }
+    else if (typeof ctid === "bigint") {
+        ctidValue = ctid;
+    }
+    else {
+        throw new Error("CTID must be a hexadecimal string or BigInt");
+    }
+    if (ctidValue > 0xffffffffffffffffn || (ctidValue & 0xf000000000000000n) !== 0xc000000000000000n) {
+        throw new Error("CTID must be exactly 16 nibbles and start with a C");
+    }
+    const ledgerIndex = Number((ctidValue >> 32n) & 0xfffffffn);
+    const txIndex = Number((ctidValue >> 16n) & 0xffffn);
+    const networkID = Number(ctidValue & 0xffffn);
+    return {
+        ledgerIndex,
+        txIndex,
+        networkID,
+    };
+}

package/lib/src/models/transactions/CronSet.d.ts

@@ -0,0 +1,3 @@
+export declare const enum CronSetFlags {
+    tfCronUnset = 1
+}

package/lib/src/models/transactions/CronSet.js

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

package/lib/src/models/transactions/SetRemarks.d.ts

@@ -0,0 +1,3 @@
+export declare const enum SetRemarksFlags {
+    tfImmutable = 1
+}

package/lib/src/models/transactions/SetRemarks.js

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

package/lib/src/models/transactions/URITokenMint.d.ts

@@ -0,0 +1,3 @@
+export declare const enum URITokenMintFlags {
+    tfBurnable = 1
+}

package/lib/src/models/transactions/URITokenMint.js

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

package/lib/src/models/vl.d.ts

@@ -0,0 +1,82 @@
+import { ManifestInterface } from "./manifest";
+export interface VLInterface {
+    version?: number;
+    public_key?: string;
+    manifest?: string;
+    blob?: string;
+    blobs_v2?: VLBlobInfoInterface[];
+    signature?: string;
+}
+export interface ParsedVLInterface {
+    version?: number;
+    PublicKey?: string;
+    manifest?: string;
+    decodedManifest?: ManifestInterface;
+    blob?: ParsedVLBlobInterface;
+    blobs?: ParsedVLBlobInterface[];
+    signature?: string;
+    error?: string;
+}
+export interface ValidatorInterface {
+    validation_public_key?: string;
+    manifest?: string;
+}
+export interface ParsedValidatorInterface {
+    PublicKey?: string;
+    manifest?: string;
+    decodedManifest?: ManifestInterface;
+}
+export interface VLBlobInterface {
+    sequence?: number;
+    effective?: number;
+    expiration?: number;
+    validators?: ValidatorInterface[];
+}
+export interface ParsedVLBlobInterface {
+    sequence?: number;
+    effective?: number;
+    expiration?: number;
+    validators?: ParsedValidatorInterface[];
+    signature?: string;
+    manifest?: string;
+    decodedManifest?: ManifestInterface;
+}
+export interface VLSecretKeysInterface {
+    privateKey: string;
+    publicKey: string;
+}
+export interface VLV2ValidatorsPublishBlobInterface {
+    sequence?: number;
+    effective?: number;
+    expiration?: number;
+    validatorsPublicKeys: string[];
+}
+export interface VLBlobInfoInterface {
+    blob?: string;
+    signature?: string;
+    manifest?: string;
+}
+export interface VLDataInterface {
+    Flags?: number;
+    LedgerSequence?: number;
+    CloseTime?: number;
+    SigningTime?: number;
+    LoadFee?: string;
+    ReserveBase?: string;
+    ReserveIncrement?: string;
+    BaseFee?: string;
+    Cookie?: string;
+    ServerVersion?: string;
+    LedgerHash?: string;
+    ConsensusHash?: string;
+    ValidatedHash?: string;
+    SigningPubKey?: string;
+    Signature?: string;
+    Amendments?: string[];
+    error?: string;
+    _verified?: boolean;
+}
+export declare function parseVL(vl: VLInterface): ParsedVLInterface;
+export declare function isValidVL(vl: VLInterface): string | null;
+export declare function encodeVLBlob(vlBlob: VLBlobInterface): string;
+export declare function parseValidationData(data: string, publicKey: string): VLDataInterface;