@koralabs/kora-labs-common 6.13.4 → 6.14.1

package/txBuild/blockfrost.d.ts

@@ -0,0 +1,66 @@
+import { Cardano } from '@cardano-sdk/core';
+import { ProviderRequestOptions } from '../chain/transport/fetchProviderJson';
+import { ExUnits } from './fees';
+import { RedeemerKey, ScriptTxProtocolParameters } from './scriptTx';
+type BlockfrostAmount = {
+    unit: string;
+    quantity: string;
+}[];
+export interface BlockfrostScript {
+    hash: string;
+    language: Cardano.PlutusLanguageVersion | 'native';
+    /** Serialized size (the ledger's reference-script size). */
+    size: number;
+    script?: Cardano.Script;
+}
+export declare class BlockfrostEvaluationError extends Error {
+    readonly failure: unknown;
+    constructor(failure: unknown);
+}
+export declare const valueFromBlockfrost: (amount: BlockfrostAmount) => Cardano.Value;
+/** Additional-UTxO shape Blockfrost's evaluator accepts: Ogmios value `{ ada: { lovelace }, [policy]: { [asset]: qty } }`. */
+export declare const toOgmiosUtxo: ([txIn, txOut]: Cardano.Utxo) => ({
+    txId: any;
+    index: number;
+} | {
+    datumHash?: any;
+    datum?: any;
+    address: Tagged<string, T>;
+    value: Record<string, Record<string, number>>;
+    txId?: undefined;
+    index?: undefined;
+})[];
+export declare class BlockfrostTxClient {
+    private readonly config;
+    private readonly scripts;
+    private readonly host;
+    constructor(config: {
+        network: string;
+        blockfrostApiKey: string;
+        fetcher?: ProviderRequestOptions['fetcher'];
+    });
+    private request;
+    private getOrNull;
+    getProtocolParameters(): Promise<ScriptTxProtocolParameters>;
+    getLatestBlock(): Promise<{
+        slot: number;
+        time: number;
+        hash: string;
+        height: number;
+    }>;
+    /** Slot of a POSIX time (ms), from the tip (1-second slots since Shelley on every network). */
+    slotAt(posixMs: number): Promise<number>;
+    getScript(hash: string): Promise<BlockfrostScript>;
+    private toUtxo;
+    /** Every UTxO at `address` (paginated). */
+    getAddressUtxos(address: string): Promise<Cardano.Utxo[]>;
+    /** UTxOs at `address` holding `unit`. */
+    getAddressAssetUtxos(address: string, unit: string): Promise<Cardano.Utxo[]>;
+    /** The UTxO `txHash#index`; throws `already spent` when it has been consumed. */
+    getUtxo(ref: string): Promise<Cardano.Utxo>;
+    /** Node (Ogmios) evaluation of every redeemer; `additionalUtxos` supplies inputs not yet on chain. */
+    evaluateTx(cbor: string, additionalUtxos?: Cardano.Utxo[]): Promise<Map<RedeemerKey, ExUnits>>;
+    /** Submit a signed tx; returns its hash. */
+    submitTx(cbor: string): Promise<string>;
+}
+export {};

package/txBuild/blockfrost.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockfrostTxClient = exports.toOgmiosUtxo = exports.valueFromBlockfrost = exports.BlockfrostEvaluationError = void 0;
+// Blockfrost access for building/evaluating/submitting script transactions, returning @cardano-sdk/core
+// types. Every call goes through the shared rate-limited transport (fetchProviderJson), which honors
+// Retry-After and friends process-wide.
+const core_1 = require("@cardano-sdk/core");
+const fetchProviderJson_1 = require("../chain/transport/fetchProviderJson");
+const fees_1 = require("./fees");
+const PLUTUS_LANGUAGE = {
+    plutusV1: core_1.Cardano.PlutusLanguageVersion.V1,
+    plutusV2: core_1.Cardano.PlutusLanguageVersion.V2,
+    plutusV3: core_1.Cardano.PlutusLanguageVersion.V3
+};
+const OGMIOS_PURPOSE = {
+    spend: 'spend',
+    mint: 'mint',
+    certificate: 'certificate',
+    withdrawal: 'withdrawal',
+    withdraw: 'withdrawal',
+    reward: 'withdrawal'
+};
+class BlockfrostEvaluationError extends Error {
+    constructor(failure) {
+        super(`Transaction failed evaluation: ${JSON.stringify(failure)}`);
+        this.failure = failure;
+        this.name = 'BlockfrostEvaluationError';
+    }
+}
+exports.BlockfrostEvaluationError = BlockfrostEvaluationError;
+const valueFromBlockfrost = (amount) => {
+    let coins = BigInt(0);
+    const assets = new Map();
+    for (const { unit, quantity } of amount) {
+        if (unit === 'lovelace')
+            coins = BigInt(quantity);
+        else
+            assets.set(core_1.Cardano.AssetId.fromParts(core_1.Cardano.PolicyId(unit.slice(0, 56)), core_1.Cardano.AssetName(unit.slice(56))), BigInt(quantity));
+    }
+    return { coins, ...(assets.size ? { assets } : {}) };
+};
+exports.valueFromBlockfrost = valueFromBlockfrost;
+/** Additional-UTxO shape Blockfrost's evaluator accepts: Ogmios value `{ ada: { lovelace }, [policy]: { [asset]: qty } }`. */
+const toOgmiosUtxo = ([txIn, txOut]) => {
+    var _a, _b;
+    const value = { ada: { lovelace: Number(txOut.value.coins) } };
+    for (const [id, qty] of (_a = txOut.value.assets) !== null && _a !== void 0 ? _a : []) {
+        const policy = core_1.Cardano.AssetId.getPolicyId(id);
+        value[policy] = { ...((_b = value[policy]) !== null && _b !== void 0 ? _b : {}), [core_1.Cardano.AssetId.getAssetName(id)]: Number(qty) };
+    }
+    return [
+        { txId: txIn.txId, index: txIn.index },
+        {
+            address: txOut.address,
+            value,
+            ...(txOut.datum ? { datum: core_1.Serialization.PlutusData.fromCore(txOut.datum).toCbor() } : {}),
+            ...(txOut.datumHash ? { datumHash: txOut.datumHash } : {})
+        }
+    ];
+};
+exports.toOgmiosUtxo = toOgmiosUtxo;
+class BlockfrostTxClient {
+    constructor(config) {
+        this.config = config;
+        this.scripts = new Map();
+        this.host = `https://cardano-${config.network.toLowerCase()}.blockfrost.io/api/v0`;
+    }
+    request(path, init = {}) {
+        var _a, _b;
+        return (0, fetchProviderJson_1.fetchProviderJson)({
+            provider: 'Blockfrost',
+            url: `${this.host}/${path.replace(/^\//, '')}`,
+            method: (_a = init.method) !== null && _a !== void 0 ? _a : 'GET',
+            headers: { project_id: this.config.blockfrostApiKey, 'Content-Type': (_b = init.contentType) !== null && _b !== void 0 ? _b : 'application/json' },
+            body: init.body,
+            fetcher: this.config.fetcher,
+            // Submission/evaluation are not idempotent-safe to blind-retry on 5xx; rate limits are still honored.
+            ...(init.method === 'POST' ? { maxRetries: 0 } : {})
+        });
+    }
+    async getOrNull(path) {
+        try {
+            return await this.request(path);
+        }
+        catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.status) === 404)
+                return null;
+            throw error;
+        }
+    }
+    async getProtocolParameters() {
+        var _a;
+        const p = await this.request('epochs/latest/parameters');
+        const raw = p.cost_models_raw;
+        if (!raw)
+            throw new Error('Protocol parameters carry no cost_models_raw');
+        // cost_models_raw is the LEDGER-ordered array; the named `cost_models` object is not (its
+        // alphabetical order produced script_data_hash mismatches once the models were extended).
+        const costModels = new Map();
+        for (const [name, model] of Object.entries(raw)) {
+            const language = PLUTUS_LANGUAGE[name.charAt(0).toLowerCase() + name.slice(1)];
+            if (language !== undefined)
+                costModels.set(language, model);
+        }
+        return {
+            minFeeA: BigInt(p.min_fee_a),
+            minFeeB: BigInt(p.min_fee_b),
+            priceMemory: (0, fees_1.ratio)(p.price_mem),
+            priceSteps: (0, fees_1.ratio)(p.price_step),
+            minFeeRefScriptCostPerByte: (0, fees_1.ratio)((_a = p.min_fee_ref_script_cost_per_byte) !== null && _a !== void 0 ? _a : 0),
+            coinsPerUtxoByte: BigInt(p.coins_per_utxo_size),
+            maxTxSize: Number(p.max_tx_size),
+            maxTxExUnits: { memory: Number(p.max_tx_ex_mem), steps: Number(p.max_tx_ex_steps) },
+            costModels
+        };
+    }
+    getLatestBlock() {
+        return this.request('blocks/latest');
+    }
+    /** Slot of a POSIX time (ms), from the tip (1-second slots since Shelley on every network). */
+    async slotAt(posixMs) {
+        const tip = await this.getLatestBlock();
+        return tip.slot + Math.floor((posixMs - tip.time * 1000) / 1000);
+    }
+    getScript(hash) {
+        let cached = this.scripts.get(hash);
+        if (!cached) {
+            cached = (async () => {
+                var _a, _b;
+                const info = await this.request(`scripts/${hash}`);
+                if (info.type === 'timelock')
+                    return { hash, language: 'native', size: Number((_a = info.serialised_size) !== null && _a !== void 0 ? _a : 0) };
+                const language = PLUTUS_LANGUAGE[info.type];
+                if (language === undefined)
+                    throw new Error(`Unknown script type ${info.type} for ${hash}`);
+                const { cbor } = await this.request(`scripts/${hash}/cbor`);
+                // Blockfrost's `cbor` is the script as the ledger hashes it (a CBOR byte string of the flat program).
+                const script = { __type: core_1.Cardano.ScriptType.Plutus, version: language, bytes: cbor };
+                if (core_1.Serialization.Script.fromCore(script).hash() !== hash)
+                    throw new Error(`Script ${hash} CBOR does not hash to ${hash}`);
+                return { hash, language, size: Number((_b = info.serialised_size) !== null && _b !== void 0 ? _b : cbor.length / 2), script };
+            })();
+            cached.catch(() => this.scripts.delete(hash));
+            this.scripts.set(hash, cached);
+        }
+        return cached;
+    }
+    async toUtxo(item, txHash, address) {
+        const scriptReference = item.reference_script_hash ? (await this.getScript(item.reference_script_hash)).script : undefined;
+        return [
+            { txId: core_1.Cardano.TransactionId(txHash), index: item.output_index, address: address },
+            {
+                address: address,
+                value: (0, exports.valueFromBlockfrost)(item.amount),
+                ...(item.inline_datum ? { datum: core_1.Serialization.PlutusData.fromCbor(item.inline_datum).toCore() } : {}),
+                ...(!item.inline_datum && item.data_hash ? { datumHash: item.data_hash } : {}),
+                ...(scriptReference ? { scriptReference } : {})
+            }
+        ];
+    }
+    /** Every UTxO at `address` (paginated). */
+    async getAddressUtxos(address) {
+        var _a;
+        const utxos = [];
+        for (let page = 1;; page++) {
+            const items = (_a = (await this.getOrNull(`addresses/${address}/utxos?page=${page}&count=100`))) !== null && _a !== void 0 ? _a : [];
+            for (const item of items)
+                utxos.push(await this.toUtxo(item, item.tx_hash, address));
+            if (items.length < 100)
+                return utxos;
+        }
+    }
+    /** UTxOs at `address` holding `unit`. */
+    async getAddressAssetUtxos(address, unit) {
+        var _a;
+        const items = (_a = (await this.getOrNull(`addresses/${address}/utxos/${unit}`))) !== null && _a !== void 0 ? _a : [];
+        return Promise.all(items.map((item) => this.toUtxo(item, item.tx_hash, address)));
+    }
+    /** The UTxO `txHash#index`; throws `already spent` when it has been consumed. */
+    async getUtxo(ref) {
+        const [txHash, index] = ref.split('#');
+        const tx = await this.request(`txs/${txHash}/utxos`);
+        const output = tx.outputs.find((o) => o.output_index === Number(index));
+        if (!output)
+            throw new Error(`${ref} does not exist`);
+        if (output.consumed_by_tx)
+            throw new Error(`${ref} already spent by ${output.consumed_by_tx}`);
+        return this.toUtxo(output, txHash, output.address);
+    }
+    /** Node (Ogmios) evaluation of every redeemer; `additionalUtxos` supplies inputs not yet on chain. */
+    async evaluateTx(cbor, additionalUtxos = []) {
+        var _a, _b, _c, _d, _e;
+        const response = await this.request('utils/txs/evaluate/utxos', { method: 'POST', body: JSON.stringify({ cbor, additionalUtxoSet: additionalUtxos.map(exports.toOgmiosUtxo) }) });
+        const result = (_a = response.result) === null || _a === void 0 ? void 0 : _a.EvaluationResult;
+        if (!result)
+            throw new BlockfrostEvaluationError((_d = (_c = (_b = response.result) === null || _b === void 0 ? void 0 : _b.EvaluationFailure) !== null && _c !== void 0 ? _c : response.fault) !== null && _d !== void 0 ? _d : response);
+        const units = new Map();
+        for (const [pointer, { memory, steps }] of Object.entries(result)) {
+            const [purpose, index] = pointer.split(':');
+            units.set(`${(_e = OGMIOS_PURPOSE[purpose]) !== null && _e !== void 0 ? _e : purpose}:${index}`, { memory, steps });
+        }
+        return units;
+    }
+    /** Submit a signed tx; returns its hash. */
+    submitTx(cbor) {
+        return this.request('tx/submit', { method: 'POST', body: Buffer.from(cbor, 'hex'), contentType: 'application/cbor' });
+    }
+}
+exports.BlockfrostTxClient = BlockfrostTxClient;

package/txBuild/fees.d.ts

@@ -0,0 +1,32 @@
+/** A non-negative rational n/d. */
+export interface Ratio {
+    n: bigint;
+    d: bigint;
+}
+/** Exact rational from a decimal number/string as providers report it (0.0577, "0.0000721", 7.21e-5). */
+export declare const ratio: (value: number | string | bigint) => Ratio;
+export interface FeeParameters {
+    /** min_fee_a (lovelace per byte) */
+    minFeeA: bigint;
+    /** min_fee_b (constant lovelace) */
+    minFeeB: bigint;
+    priceMemory: Ratio;
+    priceSteps: Ratio;
+    /** min_fee_ref_script_cost_per_byte (Conway) */
+    minFeeRefScriptCostPerByte: Ratio;
+}
+export interface ExUnits {
+    memory: number | bigint;
+    steps: number | bigint;
+}
+/** ceiling(priceMem * Σmem + priceSteps * Σsteps) — the ledger prices the TOTAL, then rounds once. */
+export declare const scriptExecutionFee: (params: Pick<FeeParameters, "priceMemory" | "priceSteps">, exUnits: ExUnits[]) => bigint;
+/**
+ * Conway's tiered reference-script fee: every 25,600 bytes the per-byte price is multiplied by 1.2;
+ * the sum is floored. `totalBytes` counts every reference script of every spent AND referenced input.
+ */
+export declare const referenceScriptFee: (costPerByte: Ratio, totalBytes: number | bigint) => bigint;
+/** The ledger minimum fee for a tx of `sizeBytes` (as submitted, witnesses included). */
+export declare const minFee: (params: FeeParameters, sizeBytes: number, exUnits: ExUnits[], referenceScriptBytes: number) => bigint;
+/** Babbage/Conway min-UTxO: (160 + |serialized output|) * coinsPerUtxoByte. */
+export declare const minAdaForOutputSize: (coinsPerUtxoByte: bigint, outputSizeBytes: number) => bigint;

package/txBuild/fees.js

@@ -0,0 +1,62 @@
+"use strict";
+// Exact Conway fee / deposit arithmetic (BigInt rationals — no floating point anywhere a ledger rule
+// uses a ratio). Pure: no network, no cardano-sdk.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minAdaForOutputSize = exports.minFee = exports.referenceScriptFee = exports.scriptExecutionFee = exports.ratio = void 0;
+/** Exact rational from a decimal number/string as providers report it (0.0577, "0.0000721", 7.21e-5). */
+const ratio = (value) => {
+    if (typeof value === 'bigint')
+        return { n: value, d: BigInt(1) };
+    const text = typeof value === 'number' ? value.toString() : value.trim();
+    const match = /^(\d+)(?:\.(\d+))?(?:e([+-]?\d+))?$/i.exec(text);
+    if (!match)
+        throw new Error(`Not a non-negative decimal: ${value}`);
+    const [, whole, fraction = '', exponent = '0'] = match;
+    let n = BigInt(whole + fraction);
+    let d = BigInt(10) ** BigInt(fraction.length);
+    const exp = Number(exponent);
+    if (exp > 0)
+        n *= BigInt(10) ** BigInt(exp);
+    if (exp < 0)
+        d *= BigInt(10) ** BigInt(-exp);
+    return { n, d };
+};
+exports.ratio = ratio;
+const ceilDiv = (n, d) => (n + d - BigInt(1)) / d;
+/** ceiling(priceMem * Σmem + priceSteps * Σsteps) — the ledger prices the TOTAL, then rounds once. */
+const scriptExecutionFee = (params, exUnits) => {
+    const memory = exUnits.reduce((sum, e) => sum + BigInt(e.memory), BigInt(0));
+    const steps = exUnits.reduce((sum, e) => sum + BigInt(e.steps), BigInt(0));
+    const { priceMemory: pm, priceSteps: ps } = params;
+    return ceilDiv(pm.n * memory * ps.d + ps.n * steps * pm.d, pm.d * ps.d);
+};
+exports.scriptExecutionFee = scriptExecutionFee;
+const REF_SCRIPT_SIZE_INCREMENT = BigInt(25600);
+const REF_SCRIPT_MULTIPLIER = { n: BigInt(6), d: BigInt(5) };
+/**
+ * Conway's tiered reference-script fee: every 25,600 bytes the per-byte price is multiplied by 1.2;
+ * the sum is floored. `totalBytes` counts every reference script of every spent AND referenced input.
+ */
+const referenceScriptFee = (costPerByte, totalBytes) => {
+    let remaining = BigInt(totalBytes);
+    let price = costPerByte;
+    let acc = { n: BigInt(0), d: BigInt(1) };
+    const add = (a, b) => ({ n: a.n * b.d + b.n * a.d, d: a.d * b.d });
+    while (remaining >= REF_SCRIPT_SIZE_INCREMENT) {
+        acc = add(acc, { n: price.n * REF_SCRIPT_SIZE_INCREMENT, d: price.d });
+        price = { n: price.n * REF_SCRIPT_MULTIPLIER.n, d: price.d * REF_SCRIPT_MULTIPLIER.d };
+        remaining -= REF_SCRIPT_SIZE_INCREMENT;
+    }
+    acc = add(acc, { n: price.n * remaining, d: price.d });
+    return acc.n / acc.d;
+};
+exports.referenceScriptFee = referenceScriptFee;
+/** The ledger minimum fee for a tx of `sizeBytes` (as submitted, witnesses included). */
+const minFee = (params, sizeBytes, exUnits, referenceScriptBytes) => params.minFeeA * BigInt(sizeBytes) +
+    params.minFeeB +
+    (0, exports.scriptExecutionFee)(params, exUnits) +
+    (0, exports.referenceScriptFee)(params.minFeeRefScriptCostPerByte, referenceScriptBytes);
+exports.minFee = minFee;
+/** Babbage/Conway min-UTxO: (160 + |serialized output|) * coinsPerUtxoByte. */
+const minAdaForOutputSize = (coinsPerUtxoByte, outputSizeBytes) => (BigInt(160) + BigInt(outputSizeBytes)) * coinsPerUtxoByte;
+exports.minAdaForOutputSize = minAdaForOutputSize;

package/txBuild/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fees';
+export * from './scriptTx';
+export * from './blockfrost';

package/txBuild/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Subpath module: `@koralabs/kora-labs-common/txBuild`. Server-side Plutus transaction building on
+// @cardano-sdk/core (optional peer dependency). NOT re-exported from the root index.
+__exportStar(require("./fees"), exports);
+__exportStar(require("./scriptTx"), exports);
+__exportStar(require("./blockfrost"), exports);

package/txBuild/scriptTx.d.ts

@@ -0,0 +1,79 @@
+import { Cardano, Serialization } from '@cardano-sdk/core';
+import { ExUnits, FeeParameters } from './fees';
+export type PlutusData = Serialization.PlutusData;
+export interface ScriptTxProtocolParameters extends FeeParameters {
+    coinsPerUtxoByte: bigint;
+    maxTxSize: number;
+    maxTxExUnits: {
+        memory: number;
+        steps: number;
+    };
+    /** Ledger-ordered cost models (Blockfrost `cost_models_raw`), keyed by Plutus language. */
+    costModels: Map<Cardano.PlutusLanguageVersion, number[]>;
+}
+export interface ScriptTxPlan {
+    /** Every spent input, resolved. A redeemer marks a Plutus script spend. */
+    inputs: {
+        utxo: Cardano.Utxo;
+        redeemer?: PlutusData;
+    }[];
+    referenceInputs?: Cardano.TxIn[];
+    collateral?: Cardano.TxIn[];
+    /** Kept in this order. Outputs below min-UTxO are topped up to it. */
+    outputs: Cardano.TxOut[];
+    /** One entry per policy. A redeemer marks a Plutus policy (native policies need `nativeScripts`). */
+    mint?: {
+        policyId: string;
+        assets: Map<string, bigint>;
+        redeemer?: PlutusData;
+    }[];
+    withdrawals?: {
+        rewardAccount: string;
+        quantity: bigint;
+        redeemer?: PlutusData;
+    }[];
+    requiredSigners?: string[];
+    nativeScripts?: Cardano.NativeScript[];
+    validityInterval?: Cardano.ValidityInterval;
+    changeAddress: string;
+    /** vkey witnesses the signed tx will carry (sizes the fee). */
+    signerCount: number;
+    /** Languages of every Plutus script the tx runs (from their reference scripts). */
+    plutusLanguages: Cardano.PlutusLanguageVersion[];
+    /** Σ size of every reference script on spent + referenced inputs (Conway ref-script fee). */
+    referenceScriptBytes: number;
+}
+/** Redeemer pointer key: `${purpose}:${index}` (e.g. `spend:1`, `mint:0`, `withdrawal:0`). */
+export type RedeemerKey = string;
+export type Evaluator = (unsignedTxCbor: string) => Promise<Map<RedeemerKey, ExUnits>>;
+export interface FinalizedScriptTx {
+    /** Unsigned tx CBOR (empty vkey witness set). */
+    cbor: string;
+    txId: string;
+    fee: bigint;
+    /** Final outputs, change last. */
+    outputs: Cardano.TxOut[];
+    redeemers: Cardano.Redeemer[];
+}
+/** Raise `output` to its min-UTxO (the coin's own CBOR width is part of the size, so iterate). */
+export declare const withMinAda: (output: Cardano.TxOut, coinsPerUtxoByte: bigint) => Cardano.TxOut;
+/**
+ * script_data_hash = blake2b-256(redeemers ‖ datums? ‖ language_views), over the exact bytes of the
+ * serialized witness-set fields. `datumsCbor` is only for witness-set datums (never inline datums).
+ */
+export declare const computeScriptDataHash: ({ redeemersCbor, datumsCbor, costModels, languages }: {
+    redeemersCbor?: string;
+    datumsCbor?: string;
+    costModels: Map<Cardano.PlutusLanguageVersion, number[]>;
+    languages: Cardano.PlutusLanguageVersion[];
+}) => string | undefined;
+export declare const finalizeScriptTx: (plan: ScriptTxPlan, params: ScriptTxProtocolParameters, evaluate: Evaluator) => Promise<FinalizedScriptTx>;
+/**
+ * Add vkey witnesses to an unsigned tx by splicing them into its witness set byte-for-byte
+ * (`mergeWitnessSet`): the body (so the tx id and every signature) and the redeemer bytes the
+ * script_data_hash covers are untouched.
+ */
+export declare const addVkeyWitnesses: (unsignedCbor: string, witnesses: {
+    vkey: string;
+    signature: string;
+}[]) => string;