@bithomp/xrpl-api 3.7.31 → 3.7.37

package/lib/src/ledger/transaction.js

@@ -0,0 +1,440 @@
+"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.getTransaction = getTransaction;
+exports.getTransactionByCTID = getTransactionByCTID;
+exports.submitPaymentTransactionV1 = submitPaymentTransactionV1;
+exports.getAccountPaymentParams = getAccountPaymentParams;
+exports.getTxSubmitParams = getTxSubmitParams;
+exports.submit = submit;
+const ripple_binary_codec_1 = require("ripple-binary-codec");
+const balance_changes_1 = require("../parse/outcome/balance_changes");
+const Client = __importStar(require("../client"));
+const common_1 = require("../common");
+const utils_1 = require("../common/utils");
+const payment_1 = require("../v1/transaction/payment");
+const transaction_1 = require("../models/transaction");
+const wallet_1 = require("../wallet");
+const submitErrorsGroup = ["tem", "tef", "tel", "ter"];
+const FEE_LIMIT = 0.5;
+const LEDGER_CLOSE_TIME_AWAIT = 2000;
+const MAX_LEDGERS_AWAIT = 5;
+async function getTransaction(transaction, options = {}) {
+    if ((0, transaction_1.isCTID)(transaction)) {
+        return getTransactionByCTID(transaction, options);
+    }
+    const formatted = options.legacy === true || options.formatted === true;
+    const connection = Client.findConnection("history");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.request({
+        command: "tx",
+        transaction,
+        binary: !!options.binary,
+        min_ledger: options.minLedger,
+        max_ledger: options.maxLedger,
+    });
+    if (!response) {
+        return {
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if (response.error) {
+        const { error, error_code, error_message, error_exception, status, validated } = response;
+        return (0, utils_1.removeUndefined)({
+            transaction,
+            error,
+            error_code,
+            error_message,
+            error_exception,
+            status,
+            validated,
+        });
+    }
+    const result = response?.result;
+    if (typeof result === "object") {
+        if (formatted === true) {
+            return (0, transaction_1.getTxDetails)(result, options.includeRawTransaction === true, Client.getNativeCurrency(), options.definitions);
+        }
+        if (options.balanceChanges === true && typeof result.meta === "object") {
+            const tx = result.tx || result.tx_json || result;
+            result.balanceChanges = (0, balance_changes_1.parseBalanceChanges)(result.meta, Client.getNativeCurrency(), tx);
+        }
+        if (options.specification === true) {
+            const details = (0, transaction_1.getTxDetails)(result, options.includeRawTransaction, Client.getNativeCurrency(), options.definitions);
+            result.specification = details.specification;
+            result.outcome = details.outcome;
+            if (details.rawTransaction) {
+                result.rawTransaction = details.rawTransaction;
+            }
+        }
+    }
+    if (!result.hasOwnProperty("ctid")) {
+        const ctid = (0, transaction_1.encodeCTIDforTransaction)(result, connection.getNetworkID());
+        if (ctid) {
+            result.ctid = ctid;
+        }
+    }
+    if (result.hasOwnProperty("tx_json") && result.tx_json.hasOwnProperty("ctid")) {
+        delete result.tx_json.ctid;
+    }
+    return result;
+}
+async function getTransactionByCTID(ctid, options = {}) {
+    if (!(0, transaction_1.isCTID)(ctid)) {
+        return {
+            status: "error",
+            error: "invalidCTID",
+        };
+    }
+    const { ledgerIndex, txIndex, networkID } = (0, transaction_1.decodeCTID)(ctid);
+    const formatted = options.legacy === true || options.formatted === true;
+    const connection = Client.findConnection("history", undefined, undefined, undefined, networkID);
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const ledgerInfo = await Client.getLedger({
+        ledgerIndex,
+        transactions: true,
+        expand: true,
+        connection,
+    });
+    if (!ledgerInfo) {
+        return {
+            transaction: ctid,
+            ledger_index: ledgerIndex,
+            status: "error",
+            error: "invalidResponse",
+        };
+    }
+    if ("error" in ledgerInfo) {
+        const { error, error_code, error_message, status, validated } = ledgerInfo;
+        return {
+            transaction: ctid,
+            error,
+            error_code,
+            error_message,
+            status,
+            validated,
+        };
+    }
+    const ledger = ledgerInfo.ledger;
+    const { transactions } = ledger;
+    if (!Array.isArray(transactions)) {
+        return {
+            transaction: ctid,
+            status: "error",
+            error: "txnNotFound",
+        };
+    }
+    const ledgerTx = transactions.find((tx) => tx.metaData.TransactionIndex === txIndex);
+    if (!ledgerTx) {
+        return {
+            transaction: ctid,
+            status: "error",
+            error: "txnNotFound",
+        };
+    }
+    ledgerTx.ctid = ctid;
+    const result = (0, transaction_1.ledgerTxToTx)(ledgerTx, ledgerIndex, ledger.close_time);
+    if (formatted === true) {
+        return (0, transaction_1.getTxDetails)(result, options.includeRawTransaction === true, Client.getNativeCurrency(), options.definitions);
+    }
+    if (options.balanceChanges === true && typeof result.meta === "object") {
+        const tx = result.tx || result.tx_json || result;
+        result.balanceChanges = (0, balance_changes_1.parseBalanceChanges)(result.meta, Client.getNativeCurrency(), tx);
+    }
+    if (options.specification === true) {
+        const details = (0, transaction_1.getTxDetails)(result, options.includeRawTransaction, Client.getNativeCurrency(), options.definitions);
+        result.specification = details.specification;
+        result.outcome = details.outcome;
+        if (details.rawTransaction) {
+            result.rawTransaction = details.rawTransaction;
+        }
+    }
+    return result;
+}
+async function submitPaymentTransactionV1(data, definitions, validateTx) {
+    const connection = Client.findConnection("payment, submit, !clio");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const txPayment = {
+        source: {
+            address: data.sourceAddress,
+            tag: data.sourceTag,
+            maxAmount: {
+                value: data.sourceValue.toString(),
+                currency: data.sourceCurrency,
+            },
+        },
+        destination: {
+            address: data.destinationAddress,
+            tag: data.destinationTag,
+            amount: {
+                value: data.destinationValue.toString(),
+                currency: data.destinationCurrency,
+            },
+        },
+        networkID: data.networkID,
+        memos: data.memos,
+    };
+    const transaction = (0, payment_1.createPaymentTransaction)(data.sourceAddress, txPayment);
+    const skip = {
+        fee: data.fee ? true : false,
+        sequence: data.sequence ? true : false,
+        lastLedgerSequence: data.lastLedgerSequence ? true : false,
+    };
+    const submitParams = await getTxSubmitParams(data.sourceAddress, transaction, definitions, connection, skip);
+    if ("error" in submitParams) {
+        return submitParams;
+    }
+    if (data.fee) {
+        transaction.Fee = (0, common_1.xrpToDrops)(data.fee);
+    }
+    else {
+        transaction.Fee = submitParams.fee;
+    }
+    if (data.sequence) {
+        transaction.Sequence = data.sequence;
+    }
+    else {
+        transaction.Sequence = submitParams.sequence;
+    }
+    if (data.lastLedgerSequence) {
+        transaction.LastLedgerSequence = data.lastLedgerSequence;
+    }
+    else if (submitParams.lastLedgerSequence) {
+        transaction.LastLedgerSequence = submitParams.lastLedgerSequence;
+    }
+    const wallet = (0, wallet_1.walletFromSeed)(data.secret, { seedAddress: transaction.Account });
+    const signedTransaction = (0, wallet_1.signTransaction)(wallet, transaction, false, definitions, validateTx).tx_blob;
+    return await submit(signedTransaction, { connection, definitions });
+}
+async function getAccountPaymentParams(account, connection) {
+    try {
+        connection = connection || Client.findConnection("submit") || undefined;
+        if (!connection) {
+            throw new Error("There is no connection");
+        }
+        const feePromise = new Promise(async (resolve) => {
+            const baseFee = await Client.getFee({ connection });
+            let fee = parseFloat(baseFee);
+            if (fee > FEE_LIMIT) {
+                fee = FEE_LIMIT;
+            }
+            if (!fee) {
+                throw new Error("Fee is not defined");
+            }
+            resolve((0, common_1.xrpToDrops)(fee.toString()));
+        });
+        const sequencePromise = new Promise(async (resolve, rejects) => {
+            try {
+                const accountData = (await Client.getAccountInfoData(account, { connection }));
+                if (!accountData) {
+                    return rejects(new Error("Account not found"));
+                }
+                if ("error" in accountData) {
+                    return rejects(new Error(accountData.error));
+                }
+                resolve(accountData.Sequence);
+            }
+            catch (e) {
+                rejects(e);
+            }
+        });
+        const lastLedgerSequencePromise = new Promise(async (resolve) => {
+            try {
+                const ledgerIndex = await Client.getLedgerIndex();
+                if (ledgerIndex !== undefined) {
+                    resolve(ledgerIndex + MAX_LEDGERS_AWAIT);
+                }
+                resolve(undefined);
+            }
+            catch (_err) {
+                resolve(undefined);
+            }
+        });
+        const result = await Promise.all([feePromise, sequencePromise, lastLedgerSequencePromise]);
+        return {
+            fee: result[0],
+            sequence: result[1],
+            lastLedgerSequence: result[2],
+            networkID: connection.getNetworkID(),
+        };
+    }
+    catch (e) {
+        return {
+            account,
+            status: "error",
+            error: e.message,
+        };
+    }
+}
+async function getTxSubmitParams(account, tx, definitions, connection, skip) {
+    try {
+        connection = connection || Client.findConnection("submit") || undefined;
+        if (!connection) {
+            throw new Error("There is no connection");
+        }
+        let feePromise;
+        let sequencePromise;
+        let lastLedgerSequencePromise;
+        if (skip?.fee !== true) {
+            feePromise = new Promise(async (resolve, rejects) => {
+                try {
+                    if (tx && typeof tx === "object") {
+                        tx = { ...tx, Sequence: 0, Fee: "0", SigningPubKey: "" };
+                    }
+                    const baseFee = await Client.getFee({ connection, tx, definitions });
+                    let fee = parseFloat(baseFee);
+                    if (fee > FEE_LIMIT) {
+                        fee = FEE_LIMIT;
+                    }
+                    if (!fee) {
+                        throw new Error("Fee is not defined");
+                    }
+                    resolve((0, common_1.xrpToDrops)(fee.toString()));
+                }
+                catch (e) {
+                    rejects(e);
+                }
+            });
+        }
+        if (skip?.sequence !== true) {
+            sequencePromise = new Promise(async (resolve, rejects) => {
+                try {
+                    const accountData = (await Client.getAccountInfoData(account, { connection }));
+                    if (!accountData) {
+                        return rejects(new Error("Account not found"));
+                    }
+                    if ("error" in accountData) {
+                        return rejects(new Error(accountData.error));
+                    }
+                    resolve(accountData.Sequence);
+                }
+                catch (e) {
+                    rejects(e);
+                }
+            });
+        }
+        if (skip?.lastLedgerSequence !== true) {
+            lastLedgerSequencePromise = new Promise(async (resolve) => {
+                try {
+                    const ledgerIndex = await Client.getLedgerIndex();
+                    if (ledgerIndex !== undefined) {
+                        resolve(ledgerIndex + MAX_LEDGERS_AWAIT);
+                    }
+                    resolve(undefined);
+                }
+                catch (_err) {
+                    resolve(undefined);
+                }
+            });
+        }
+        const result = await Promise.all([feePromise, sequencePromise, lastLedgerSequencePromise]);
+        return {
+            fee: result[0],
+            sequence: result[1],
+            lastLedgerSequence: result[2],
+            networkID: connection.getNetworkID(),
+        };
+    }
+    catch (e) {
+        return {
+            account,
+            status: "error",
+            error: e.message,
+        };
+    }
+}
+async function submit(signedTransaction, options = {}) {
+    const connection = options.connection || Client.findConnection("submit");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const response = await connection.submit(signedTransaction);
+    if (response.error) {
+        return response;
+    }
+    const result = response?.result;
+    const resultGroup = result?.engine_result?.slice(0, 3);
+    if ((submitErrorsGroup.includes(resultGroup) && result?.engine_result !== "terQUEUED") || result?.kept === false) {
+        return result;
+    }
+    const txHash = result?.tx_json?.hash;
+    if (!txHash) {
+        return result;
+    }
+    let lastLedger = 0;
+    const transaction = (0, ripple_binary_codec_1.decode)(signedTransaction, options.definitions);
+    if (transaction.LastLedgerSequence) {
+        lastLedger = transaction.LastLedgerSequence;
+    }
+    else {
+        const ledgerIndex = await Client.getLedgerIndex();
+        if (ledgerIndex !== undefined) {
+            const ledgersToWait = MAX_LEDGERS_AWAIT * 2;
+            lastLedger = ledgerIndex + ledgersToWait;
+        }
+    }
+    const finalResult = await waitForFinalTransactionOutcome(txHash, lastLedger);
+    return finalResult;
+}
+async function waitForFinalTransactionOutcome(txHash, lastLedger) {
+    await (0, utils_1.sleep)(LEDGER_CLOSE_TIME_AWAIT);
+    const tx = await getTransaction(txHash);
+    const error = tx?.error;
+    if (error === "notConnected" || error === "shutdownConnection") {
+        return tx;
+    }
+    if (!tx || error === "txnNotFound" || tx.validated !== true) {
+        const ledgerIndex = await Client.getLedgerIndex();
+        if (ledgerIndex === undefined || lastLedger > ledgerIndex) {
+            return waitForFinalTransactionOutcome(txHash, lastLedger);
+        }
+    }
+    if (tx && !tx.hasOwnProperty("error") && tx.validated === false) {
+        if (tx.hasOwnProperty("LastLedgerSequence")) {
+            return { ...tx, status: "error", error: "lastLedgerIndexReached" };
+        }
+        else {
+            return { ...tx, status: "error", error: "waitingForValidation" };
+        }
+    }
+    return tx;
+}

package/lib/src/ledger/vl-v2.d.ts

@@ -0,0 +1,3 @@
+import { VLInterface, VLBlobInterface, VLV2ValidatorsPublishBlobInterface, VLSecretKeysInterface } from "../models/vl";
+export declare function createVLv2(masterKey: VLSecretKeysInterface, ephemeralKey: VLSecretKeysInterface, publishBlobs: VLV2ValidatorsPublishBlobInterface[]): Promise<VLInterface>;
+export declare function createVLBlobV2(sequence: number, effective: number | undefined, expiration: number, validatorsPublicKeys: string[]): Promise<VLBlobInterface>;

package/lib/src/ledger/vl-v2.js

@@ -0,0 +1,124 @@
+"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.createVLv2 = createVLv2;
+exports.createVLBlobV2 = createVLBlobV2;
+const vl_1 = require("../models/vl");
+const manifest_1 = require("../models/manifest");
+const ledger_1 = require("../models/ledger");
+const Validator = __importStar(require("../validator"));
+const vl_2 = require("./vl");
+const common_1 = require("../common");
+async function createVLv2(masterKey, ephemeralKey, publishBlobs) {
+    if (!masterKey) {
+        throw new Error("Master key is required");
+    }
+    if (!ephemeralKey) {
+        throw new Error("Ephemeral key is required");
+    }
+    if (masterKey.publicKey === ephemeralKey.publicKey) {
+        throw new Error("Master and ephemeral keys must be different.");
+    }
+    let globalSequence;
+    const blobs = [];
+    for (const publishBlob of publishBlobs) {
+        const { sequence, effective, expiration, validatorsPublicKeys } = publishBlob;
+        if (typeof sequence !== "number") {
+            throw new Error("sequence must be a number.");
+        }
+        if (typeof effective !== "number" && effective !== undefined) {
+            throw new Error("effective must be a number.");
+        }
+        if (typeof expiration !== "number") {
+            throw new Error("expiration must be a number.");
+        }
+        if (Array.isArray(validatorsPublicKeys) === false) {
+            throw new Error("validatorsPublicKeys must be an array.");
+        }
+        if (validatorsPublicKeys.length === 0) {
+            throw new Error("validatorsPublicKeys must not be empty.");
+        }
+        for (const publicKey of validatorsPublicKeys) {
+            if (typeof publicKey !== "string") {
+                throw new Error("validatorsPublicKeys must be an array of strings.");
+            }
+            if (publicKey[0] !== "n") {
+                throw new Error("validatorsPublicKeys must be an array of strings starting with 'n'.");
+            }
+        }
+        const blobInfo = {};
+        const vlBlob = await createVLBlobV2(sequence, effective, expiration, validatorsPublicKeys);
+        blobInfo.blob = (0, vl_1.encodeVLBlob)(vlBlob);
+        blobInfo.signature = Validator.sign(Buffer.from(blobInfo.blob, "base64"), ephemeralKey.privateKey);
+        if (globalSequence === undefined) {
+            globalSequence = sequence;
+        }
+        else if (globalSequence !== sequence) {
+            blobInfo.manifest = (0, manifest_1.generateManifest)({
+                Sequence: sequence,
+                PublicKey: masterKey.publicKey,
+                SigningPubKey: ephemeralKey.publicKey,
+                SigningPrivateKey: ephemeralKey.privateKey,
+                MasterPrivateKey: masterKey.privateKey,
+            });
+        }
+        blobs.push(blobInfo);
+    }
+    if (globalSequence === undefined) {
+        throw new Error("sequence must be a number.");
+    }
+    const globalManifest = (0, manifest_1.generateManifest)({
+        Sequence: globalSequence,
+        PublicKey: masterKey.publicKey,
+        SigningPubKey: ephemeralKey.publicKey,
+        SigningPrivateKey: ephemeralKey.privateKey,
+        MasterPrivateKey: masterKey.privateKey,
+    });
+    return {
+        "blobs_v2": blobs,
+        manifest: globalManifest,
+        public_key: masterKey.publicKey,
+        version: 2,
+    };
+}
+async function createVLBlobV2(sequence, effective, expiration, validatorsPublicKeys) {
+    const validators = await (0, vl_2.getVLBlobValidatorsManifest)(validatorsPublicKeys);
+    return (0, common_1.removeUndefined)({
+        sequence,
+        effective: effective ? (0, ledger_1.unixTimeToLedgerTime)(effective) : undefined,
+        expiration: (0, ledger_1.unixTimeToLedgerTime)(expiration),
+        validators,
+    });
+}

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

@@ -0,0 +1,4 @@
+import { VLInterface, ValidatorInterface, VLBlobInterface, VLSecretKeysInterface } from "../models/vl";
+export declare function createVL(masterKey: VLSecretKeysInterface, ephemeralKey: VLSecretKeysInterface, sequence: number, expiration: number, validatorsPublicKeys: string[]): Promise<VLInterface>;
+export declare function createVLBlob(sequence: number, expiration: number, validatorsPublicKeys: string[]): Promise<VLBlobInterface>;
+export declare function getVLBlobValidatorsManifest(validatorsPublicKeys: string[]): Promise<ValidatorInterface[]>;