@harmoniclabs/buildooor 0.1.0

package/dist/TxBuilder/TxBuilderProtocolParams.d.ts

@@ -0,0 +1,42 @@
+import { Coin } from "@harmoniclabs/cardano-ledger-ts";
+import { CanBeUInteger } from "../utils/ints.js";
+import { CborPositiveRational } from "@harmoniclabs/cbor";
+import { ExBudget, ExBudgetJson } from "@harmoniclabs/plutus-machine";
+import { Rational } from "../utils/Rational.js";
+import { CostModels } from "@harmoniclabs/cardano-costmodels-ts";
+export interface ValidatedTxBuilderProtocolParams {
+    txFeePerByte: bigint;
+    txFeeFixed: bigint;
+    utxoCostPerByte: bigint;
+    maxTxSize: bigint;
+    maxTxExecutionUnits: ExBudget;
+    maxCollateralInputs: bigint;
+    collateralPercentage: bigint;
+    minfeeRefScriptCostPerByte: CborPositiveRational;
+    executionUnitPrices: [
+        mem_price: CborPositiveRational,
+        step_price: CborPositiveRational
+    ];
+    costModels: CostModels;
+}
+export interface TxBuilderProtocolParams {
+    txFeePerByte: CanBeUInteger;
+    txFeeFixed: CanBeUInteger;
+    utxoCostPerByte: Coin;
+    maxTxSize: CanBeUInteger;
+    maxTxExecutionUnits: ExBudget | ExBudgetJson;
+    maxCollateralInputs: CanBeUInteger;
+    collateralPercentage: CanBeUInteger;
+    minfeeRefScriptCostPerByte: Rational;
+    executionUnitPrices: [
+        mem_price: CborPositiveRational,
+        step_price: CborPositiveRational
+    ] | {
+        priceMemory: number;
+        priceSteps: number;
+    };
+    costModels: CostModels;
+}
+export declare const defaultTxBuilderProtocolParameters: Readonly<ValidatedTxBuilderProtocolParams>;
+export declare function isValidatedTxBuilderProtocolParams(stuff: any): stuff is ValidatedTxBuilderProtocolParams;
+export declare function completeTxBuilderProtocolParams(partial: TxBuilderProtocolParams | undefined): ValidatedTxBuilderProtocolParams;

package/dist/TxBuilder/TxBuilderProtocolParams.js

@@ -0,0 +1,121 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completeTxBuilderProtocolParams = exports.isValidatedTxBuilderProtocolParams = exports.defaultTxBuilderProtocolParameters = void 0;
+var cardano_ledger_ts_1 = require("@harmoniclabs/cardano-ledger-ts");
+var ints_1 = require("../utils/ints.js");
+var cbor_1 = require("@harmoniclabs/cbor");
+var plutus_machine_1 = require("@harmoniclabs/plutus-machine");
+var Rational_1 = require("../utils/Rational.js");
+var cardano_costmodels_ts_1 = require("@harmoniclabs/cardano-costmodels-ts");
+var obj_utils_1 = require("@harmoniclabs/obj-utils");
+exports.defaultTxBuilderProtocolParameters = Object.freeze({
+    txFeePerByte: BigInt((_a = cardano_ledger_ts_1.defaultProtocolParameters.txFeePerByte) !== null && _a !== void 0 ? _a : 0),
+    txFeeFixed: BigInt((_b = cardano_ledger_ts_1.defaultProtocolParameters.txFeeFixed) !== null && _b !== void 0 ? _b : 0),
+    utxoCostPerByte: BigInt((_c = cardano_ledger_ts_1.defaultProtocolParameters.utxoCostPerByte) !== null && _c !== void 0 ? _c : 0),
+    maxTxSize: BigInt((_d = cardano_ledger_ts_1.defaultProtocolParameters.maxTxSize) !== null && _d !== void 0 ? _d : 0),
+    maxTxExecutionUnits: forceExBudget((_e = cardano_ledger_ts_1.defaultProtocolParameters.maxTxExecutionUnits) !== null && _e !== void 0 ? _e : { steps: 0, memory: 0 }),
+    maxCollateralInputs: BigInt((_f = cardano_ledger_ts_1.defaultProtocolParameters.maxCollateralInputs) !== null && _f !== void 0 ? _f : 0),
+    collateralPercentage: BigInt((_g = cardano_ledger_ts_1.defaultProtocolParameters.collateralPercentage) !== null && _g !== void 0 ? _g : 0),
+    minfeeRefScriptCostPerByte: (0, Rational_1.cborFromRational)((_h = cardano_ledger_ts_1.defaultProtocolParameters.minfeeRefScriptCostPerByte) !== null && _h !== void 0 ? _h : 0),
+    executionUnitPrices: forceExecUnitPricesArray((_j = cardano_ledger_ts_1.defaultProtocolParameters.executionUnitPrices) !== null && _j !== void 0 ? _j : [0, 0]),
+    costModels: (_k = cardano_ledger_ts_1.defaultProtocolParameters.costModels) !== null && _k !== void 0 ? _k : {
+        PlutusScriptV1: cardano_costmodels_ts_1.defaultV1Costs,
+        PlutusScriptV2: cardano_costmodels_ts_1.defaultV2Costs,
+        PlutusScriptV3: cardano_costmodels_ts_1.defaultV3Costs
+    }
+});
+function forceExBudget(ex) {
+    return ex instanceof plutus_machine_1.ExBudget ? ex.clone() : plutus_machine_1.ExBudget.fromJson(ex);
+}
+function forceExecUnitPricesArray(ex) {
+    return Array.isArray(ex) ? ex.slice() : [
+        cbor_1.CborPositiveRational.fromNumber(ex.priceMemory),
+        cbor_1.CborPositiveRational.fromNumber(ex.priceSteps),
+    ];
+}
+var keysOfTxBuilderProtocolParameters = Object.freeze(Object.keys(exports.defaultTxBuilderProtocolParameters));
+function isValidatedTxBuilderProtocolParams(stuff) {
+    if (!(0, obj_utils_1.isObject)(stuff))
+        return false;
+    var keys = Object.keys(stuff);
+    // all keys must be present
+    if (!keysOfTxBuilderProtocolParameters.every(function (key) { return keys.includes(key); }))
+        return false;
+    var ppexecCosts = stuff.executionUnitPrices;
+    if (!((Array.isArray(ppexecCosts) &&
+        ppexecCosts.length >= 2 &&
+        ppexecCosts[0] instanceof cbor_1.CborPositiveRational &&
+        ppexecCosts[1] instanceof cbor_1.CborPositiveRational) ||
+        ((0, obj_utils_1.isObject)(ppexecCosts) &&
+            typeof ppexecCosts.priceSteps === "number" &&
+            typeof ppexecCosts.priceMemory === "number")))
+        return false;
+    return ((0, ints_1.canBeUInteger)(stuff.txFeePerByte) &&
+        (0, ints_1.canBeUInteger)(stuff.txFeeFixed) &&
+        (0, ints_1.canBeUInteger)(stuff.utxoCostPerByte) &&
+        (0, ints_1.canBeUInteger)(stuff.maxTxSize) &&
+        (stuff.maxTxExecutionUnits instanceof plutus_machine_1.ExBudget || plutus_machine_1.ExBudget.isJson(stuff.maxTxExecutionUnits)) &&
+        (0, ints_1.canBeUInteger)(stuff.maxCollateralInputs) &&
+        (0, ints_1.canBeUInteger)(stuff.collateralPercentage) &&
+        (0, Rational_1.isRational)(stuff.minfeeRefScriptCostPerByte) &&
+        (0, cardano_costmodels_ts_1.isCostModels)(stuff.costModels));
+}
+exports.isValidatedTxBuilderProtocolParams = isValidatedTxBuilderProtocolParams;
+function completeTxBuilderProtocolParams(partial) {
+    if (partial === undefined)
+        return __assign({}, exports.defaultTxBuilderProtocolParameters);
+    var result = {};
+    result.executionUnitPrices = (partial.executionUnitPrices ?
+        forceExecUnitPricesArray(partial.executionUnitPrices) :
+        undefined);
+    var ppexecCosts = result.executionUnitPrices;
+    if (!(Array.isArray(ppexecCosts) &&
+        ppexecCosts.length >= 2 &&
+        ppexecCosts[0] instanceof cbor_1.CborPositiveRational &&
+        ppexecCosts[1] instanceof cbor_1.CborPositiveRational))
+        result.executionUnitPrices = exports.defaultTxBuilderProtocolParameters.executionUnitPrices.slice();
+    result.txFeePerByte = ((0, ints_1.canBeUInteger)(partial.txFeePerByte) ?
+        BigInt(partial.txFeePerByte) :
+        exports.defaultTxBuilderProtocolParameters.txFeePerByte);
+    result.txFeeFixed = ((0, ints_1.canBeUInteger)(partial.txFeeFixed) ?
+        BigInt(partial.txFeeFixed) :
+        exports.defaultTxBuilderProtocolParameters.txFeeFixed);
+    result.utxoCostPerByte = ((0, ints_1.canBeUInteger)(partial.utxoCostPerByte) ?
+        BigInt(partial.utxoCostPerByte) :
+        exports.defaultTxBuilderProtocolParameters.utxoCostPerByte);
+    result.maxTxSize = ((0, ints_1.canBeUInteger)(partial.maxTxSize) ?
+        BigInt(partial.maxTxSize) :
+        exports.defaultTxBuilderProtocolParameters.maxTxSize);
+    result.maxTxExecutionUnits = ((partial.maxTxExecutionUnits instanceof plutus_machine_1.ExBudget || plutus_machine_1.ExBudget.isJson(partial.maxTxExecutionUnits)) ?
+        forceExBudget(partial.maxTxExecutionUnits) :
+        exports.defaultTxBuilderProtocolParameters.maxTxExecutionUnits.clone());
+    result.maxCollateralInputs = ((0, ints_1.canBeUInteger)(partial.maxCollateralInputs) ?
+        BigInt(partial.maxCollateralInputs) :
+        exports.defaultTxBuilderProtocolParameters.maxCollateralInputs);
+    result.collateralPercentage = ((0, ints_1.canBeUInteger)(partial.collateralPercentage) ?
+        BigInt(partial.collateralPercentage) :
+        exports.defaultTxBuilderProtocolParameters.collateralPercentage);
+    result.collateralPercentage = ((0, ints_1.canBeUInteger)(partial.collateralPercentage) ?
+        BigInt(partial.collateralPercentage) :
+        exports.defaultTxBuilderProtocolParameters.collateralPercentage);
+    result.minfeeRefScriptCostPerByte = ((0, Rational_1.isRational)(partial.minfeeRefScriptCostPerByte) ?
+        (0, Rational_1.cborFromRational)(partial.minfeeRefScriptCostPerByte) :
+        exports.defaultTxBuilderProtocolParameters.minfeeRefScriptCostPerByte);
+    result.costModels = ((0, cardano_costmodels_ts_1.isCostModels)(partial.costModels) ?
+        partial.costModels :
+        exports.defaultTxBuilderProtocolParameters.costModels);
+    return result;
+}
+exports.completeTxBuilderProtocolParams = completeTxBuilderProtocolParams;

package/dist/TxBuilder/TxBuilderRunner/CanBePoolKeyHash.d.ts

@@ -0,0 +1,3 @@
+import { Hash28, PoolKeyHash } from "@harmoniclabs/cardano-ledger-ts";
+export type CanBePoolKeyHash = Hash28 | `pool1${string}` | `pool_test1${string}` | string | Uint8Array;
+export declare function forcePoolKeyHash(canBe: CanBePoolKeyHash): PoolKeyHash;

package/dist/TxBuilder/TxBuilderRunner/CanBePoolKeyHash.js

@@ -0,0 +1,33 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forcePoolKeyHash = void 0;
+var cardano_ledger_ts_1 = require("@harmoniclabs/cardano-ledger-ts");
+var crypto_1 = require("@harmoniclabs/crypto");
+var uint8array_utils_1 = require("@harmoniclabs/uint8array-utils");
+function forcePoolKeyHash(canBe) {
+    if (typeof canBe === "string") {
+        if (canBe.startsWith("pool")) {
+            var _a = __read((0, crypto_1.decodeBech32)(canBe), 2), _hrp = _a[0], decoded = _a[1];
+            return new cardano_ledger_ts_1.PoolKeyHash(new Uint8Array(decoded));
+        }
+        return new cardano_ledger_ts_1.PoolKeyHash((0, uint8array_utils_1.fromHex)(canBe));
+    }
+    return new cardano_ledger_ts_1.PoolKeyHash(canBe);
+}
+exports.forcePoolKeyHash = forcePoolKeyHash;

package/dist/TxBuilder/TxBuilderRunner/CanBeStakeCreds.d.ts

@@ -0,0 +1,3 @@
+import { StakeAddress, Credential, StakeAddressBech32, StakeCredentials, Script, PlutusScriptType } from "@harmoniclabs/cardano-ledger-ts";
+export type CanBeStakeCreds = StakeAddress | StakeAddressBech32 | StakeCredentials | Script<PlutusScriptType> | Credential;
+export declare function forceStakeCreds(creds: CanBeStakeCreds): Credential;

package/dist/TxBuilder/TxBuilderRunner/CanBeStakeCreds.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forceStakeCreds = void 0;
+var cardano_ledger_ts_1 = require("@harmoniclabs/cardano-ledger-ts");
+function forceStakeCreds(creds) {
+    if (creds instanceof cardano_ledger_ts_1.Credential)
+        return creds;
+    if (typeof creds === "string") {
+        if (!creds.startsWith("stake")) {
+            throw new Error("invalid bech32 stake address");
+        }
+        creds = cardano_ledger_ts_1.StakeAddress.fromString(creds);
+    }
+    if (creds instanceof cardano_ledger_ts_1.StakeAddress) {
+        return creds.toCredential();
+    }
+    if (creds instanceof cardano_ledger_ts_1.Script) {
+        return cardano_ledger_ts_1.Credential.script(new cardano_ledger_ts_1.StakeValidatorHash(creds.hash));
+    }
+    if (creds.type === "pointer") {
+        throw new Error("pointer stake credentials not supported");
+    }
+    return new cardano_ledger_ts_1.Credential(creds.type === "script" ? cardano_ledger_ts_1.CredentialType.Script : cardano_ledger_ts_1.CredentialType.KeyHash, creds.hash);
+}
+exports.forceStakeCreds = forceStakeCreds;

package/dist/TxBuilder/TxBuilderRunner/TxBuilderRunner.d.ts

@@ -0,0 +1,280 @@
+import type { ITxRunnerProvider } from "../IProvider/index.js";
+import type { TxBuilder } from "../TxBuilder.js";
+import { NormalizedITxBuildArgs } from "../../txBuild/index.js";
+import { Address, AddressStr, Hash28, ITxOut, ITxOutRef, IUTxO, IValuePolicyEntry, PlutusScriptType, Script, ScriptType, StakeAddress, StakeAddressBech32, Credential, Tx, TxIn, TxMetadatum, TxOutRefStr, UTxO, Value, IPoolParams, CanBeHash28, Vote, IAnchor, IVoter, ProtocolParameters, IProposalProcedure, ITxWithdrawals, TxWithdrawals, INewCommitteeEntry, IConstitution } from "@harmoniclabs/cardano-ledger-ts";
+import { CanBeUInteger } from "../../utils/ints.js";
+import { CanResolveToUTxO } from "../CanResolveToUTxO/CanResolveToUTxO.js";
+import { CanBeData } from "../../utils/CanBeData.js";
+import { CanBePoolKeyHash } from "./CanBePoolKeyHash.js";
+import { CanBeStakeCreds } from "./CanBeStakeCreds.js";
+import { IProtocolVerision } from "@harmoniclabs/cardano-ledger-ts/dist/ledger/protocol/protocolVersion";
+import { Rational } from "../../utils/Rational.js";
+declare const enum TxBuilderTaskKind {
+    ResolveUTxO = 0,
+    ResolveTxIn = 1,
+    ValidFromPOSIX = 2,
+    ValidToPOSIX = 3,
+    DelegateTo = 4,
+    DeregisterStake = 5,
+    Withdraw = 6,
+    RegisterStake = 7
+}
+/** async */
+interface TxBuilderPromiseTask {
+    kind: TxBuilderTaskKind;
+    getPromise: () => Promise<void>;
+}
+interface TxBuilderResolveUTxOTask {
+    kind: TxBuilderTaskKind.ResolveUTxO;
+    arg: ITxOutRef | TxOutRefStr | IUTxO;
+    onResolved: (utxo: UTxO) => void;
+}
+interface TxBuilderResolveTxInTask {
+    kind: TxBuilderTaskKind.ResolveTxIn;
+    arg: ITxOutRef | TxOutRefStr | IUTxO;
+    onResolved: (utxo: TxIn) => void;
+}
+type TxBuilderTask = TxBuilderPromiseTask | TxBuilderResolveUTxOTask | TxBuilderResolveTxInTask;
+export declare class TxBuilderRunner {
+    /**
+     *  if any unresolved data was passed it is resolved via the provider passed;
+     *
+     *  if the method needed are not present on the provider throws an `Error`;
+     *
+     *  finalizes the `TxBuilderRunner` instance,
+     *  so that it can be re-used for other transactions,
+     *
+     *  @returns {Promise<Tx>} a `Tx` instance
+     */
+    readonly build: () => Promise<Tx>;
+    /**
+     * clears the `TxBuilderRunner` instance,
+     * so that it can be re-used for other transactions,
+     * making sure no other action where specified
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly reset: () => TxBuilderRunner;
+    /**
+     * @deprecated use `addRequiredSigner` instead
+     */
+    readonly addSigner: (signer: Address | StakeAddress | AddressStr | StakeAddressBech32) => TxBuilderRunner;
+    /**
+     * adds the **all** credentials of the address to the `requiredSigners`
+     * field of a `Tx` instance.
+     *
+     * only the signers included in that field are passed to a contract's `ScriptContext`.
+     *
+     * that includes payment credentials and, if present, stake credentials.
+     *
+     * if you have an address with both payment and stake credentials,
+     * but wish only to include one of them,
+     * consider using  the `addRequiredSignerKey` method
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly addRequiredSigner: (signer: Address | StakeAddress | AddressStr | StakeAddressBech32) => TxBuilderRunner;
+    /**
+     * @deprecated use `addRequiredSignerKey` instead
+     */
+    readonly addSignerKey: (signerKey: Hash28) => TxBuilderRunner;
+    /**
+     * adds the given key hash to the `requiredSigners` field of a `Tx` instance.
+     *
+     * only the signers included in that field are passed to a contract's `ScriptContext`.
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly addRequiredSignerKey: (signerKey: Hash28) => TxBuilderRunner;
+    /** adds a metadata message according to cip 20 */
+    readonly attachMemo: (memo: string) => TxBuilderRunner;
+    /** alias for `attachValidator` */
+    readonly attachCertificateValidator: (validator: Script<PlutusScriptType>) => TxBuilderRunner;
+    /** alias for `attachValidator` */
+    readonly attachMintingValidator: (validator: Script<PlutusScriptType>) => TxBuilderRunner;
+    /** alias for `attachValidator` */
+    readonly attachSpendingValidator: (validator: Script<PlutusScriptType>) => TxBuilderRunner;
+    /** alias for `attachValidator` */
+    readonly attachWithdrawalValidator: (validator: Script<PlutusScriptType>) => TxBuilderRunner;
+    /**
+     * includes the script in the witnessSet field of the resulting `Tx`
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly attachValidator: (validator: Script<PlutusScriptType>) => TxBuilderRunner;
+    /**
+     * adds a metadata entry for the given `label`,
+     * or overrides if the same `label` was already present.
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly attachMetadata: (label: CanBeUInteger, metadata: TxMetadatum) => TxBuilderRunner;
+    /**
+     * alias for `attachMetadata`
+     *
+     * adds a metadata entry for the given `label`,
+     * or overrides if the same `label` was already present.
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly setMetadata: (label: CanBeUInteger, metadata: TxMetadatum) => TxBuilderRunner;
+    /**
+     * like [`attachMetadata`](./attachMetadata),
+     * adds a metadata entry for the given `label`,
+     * or overrides if the same `label` was already present.
+     *
+     * `metadataJson` is a jsavascript value converted as follows
+     *
+     * - `object` -> `TxMetadatumMap`
+     * - `array` -> `TxMetadatumList`
+     * - `string` -> `TxMetadatumText`
+     * (use `attachMetadataJsonWithConversion`
+     * for explicit conversion to `TxMetadatumBytes`
+     * or consider using `attachMetadata`)
+     * - `number` -> `TxMetadatumInt`
+     * - `bigint` -> `TxMetadatumInt`
+     *
+     * @returns a reference to the same [`TxBuilderRunner`](./TxBuilderRunner).
+     */
+    readonly attachMetadataJson: (label: CanBeUInteger, metadataJson: any) => TxBuilderRunner;
+    /** like `attachMetadataJson` but if a string starts with `0x` is treated as an hexadecimal byte string */
+    readonly attachMetadataJsonWithConversion: (label: CanBeUInteger, metadataJson: any) => TxBuilderRunner;
+    /**
+     * explicitly sets the change address;
+     *
+     * if missing, an attempt to call the `ITxRunnerProvider` `getChangeAddress` method is done
+     *
+     * if still missing the first input's address with `PubKeyHash`
+     * payment credentials (not script) will be used
+     *
+     * if all the above fail, a call to the `build` method will throw an `Error`.
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly setChangeAddress: (changeAddr: Address | AddressStr) => TxBuilderRunner;
+    /**
+     * Sets the collateral input, and optionally output, for a transaction.
+     *
+     * If this method is not used,
+     * but the transaction needs collateral due to the presence of a plutus script,
+     * the `TxBuilderRunner` instance will try to use one of the normal inputs as collateral,
+     * see `setCollateralAmount`./setCollateralAmount for more infos.
+     *
+     * `collateral` can either be a resolved `UTxO`
+     * or an unresolved `ITxOutRef`
+     *
+     * in case it is an unresolved `ITxOutRef`
+     * a call to the `ITxRunnerProvider` `resolveUtxos` method
+     * is done in the `build` method;
+     * if `resolveUtxos` is missing on the provider the `build` method will throw an `Error`.
+     *
+     * an additional `collateralOutput` may be specified.
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly setCollateral: (collateral: CanResolveToUTxO, collateralOutput?: ITxOut) => TxBuilderRunner;
+    /**
+     * Sets the collateral amount for a transaction.
+     *
+     * If `setCollateral` is not used,
+     * but the transaction needs collateral due to the presence of a plutus script,
+     * the `TxBuilderRunner` instance will try to use one of the normal inputs as collateral.
+     *
+     * In case this happens, it is possible to limit the amount of the collateral using this method.
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+    **/
+    readonly setCollateralAmount: (lovelaces: CanBeUInteger) => TxBuilderRunner;
+    /**
+     * @deprecated `collectFrom` is unclear; use `addInputs` instead.
+     */
+    readonly collectFrom: (utxos: CanResolveToUTxO[], redeemer?: CanBeData) => TxBuilderRunner;
+    /**
+     * adds the given `utxos` to the transaction inputs;
+     * the elements of the array that don't satisfy the `IUTxO` interface
+     * will be resolved using the provider `resolveUtxos` method.
+     *
+     * this method does not allow to specify plutus realated arguments.
+     *
+     * for inputs that need redeemers, scripts and datums use `addInput`.
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+    **/
+    readonly addInputs: (utxos: CanResolveToUTxO[]) => TxBuilderRunner;
+    /**
+     * adds the given `utxo` to the transaction inputs;
+     * if`utxo` doesn't satisfy the `IUTxO` interface
+     * it will be resolved using the provider `resolveUtxos` method.
+     *
+     * `redeemer` and `script_or_ref` must be specified together;
+     * if `datum` is missing defaults to `"inline"`.
+     *
+     * if `script_or_ref` is a `Script`
+     * it will be included in the `witnesses`
+     * field of the resulting `Tx`;
+     *
+     * if `script_or_ref` satisfies the `IUTxO` interface
+     * it will be used as reference input to provide the attached reference script
+     * (`build` fails if missing)
+     *
+     * if `script_or_ref` satisfies the `ITxOutRef` interface
+     * or the `TxOutRefStr` type alias
+     * it will be resolved using the provider `resolveUtxos` method and
+     * it will be used as reference input to provide the attached reference script
+     * (`build` fails if missing)
+     *
+     * @returns a reference to the same `TxBuilderRunner`.
+    **/
+    readonly addInput: (utxos: CanResolveToUTxO, redeemer?: CanBeData, script_or_ref?: CanResolveToUTxO | Script<PlutusScriptType>, datum?: CanBeData | "inline") => TxBuilderRunner;
+    /**
+     * adds a transaction output.
+     *
+     * if `amount` is `number` or `bigint` it is intended to be lovelaces only.
+     *
+     * if `datum` is present is always added as inline datum.
+     *
+     * @param address receiver address
+     * @param amount Value to sent
+     * @param datum optional inline datum to attach
+     * @param refScript optional reference script to attach
+     * @returns a reference to the same `TxBuilderRunner`.
+     */
+    readonly payTo: (address: Address | AddressStr, amount: CanBeUInteger | Value, datum?: CanBeData, refScript?: Script<ScriptType.PlutusV2>) => TxBuilderRunner;
+    readonly mintAssets: (assets: IValuePolicyEntry, script_or_ref: Script | CanResolveToUTxO, redeemer?: CanBeData) => TxBuilderRunner;
+    readonly withdraw: (stakeAddress: CanBeStakeCreds, amount: CanBeUInteger, redeemer?: CanBeData, script_or_ref?: Script | CanResolveToUTxO) => TxBuilderRunner;
+    readonly delegateTo: (delegator: CanBeStakeCreds, poolId: CanBePoolKeyHash, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly registerPool: (params: IPoolParams) => TxBuilderRunner;
+    readonly retirePool: (poolId: CanBeHash28, epoch: CanBeUInteger) => TxBuilderRunner;
+    readonly registerStake: (delegator: CanBeStakeCreds, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly registerStakeAddress: (delegator: CanBeStakeCreds, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly deregisterStake: (delegator: CanBeStakeCreds, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    /**
+     * @deprecated `readFrom` is an ugly name; use `referenceUtxos` instead
+     */
+    readonly readFrom: (utxos: CanResolveToUTxO[]) => TxBuilderRunner;
+    readonly referenceUtxos: (utxos: CanResolveToUTxO[]) => TxBuilderRunner;
+    readonly validFrom: (POSIX: CanBeUInteger) => TxBuilderRunner;
+    readonly validFromSlot: (slot: CanBeUInteger) => TxBuilderRunner;
+    readonly invalidBeforeSlot: (slot: CanBeUInteger) => TxBuilderRunner;
+    readonly validTo: (POSIX: CanBeUInteger) => TxBuilderRunner;
+    readonly validToSlot: (slot: CanBeUInteger) => TxBuilderRunner;
+    readonly invalidAfterSlot: (slot: CanBeUInteger) => TxBuilderRunner;
+    readonly vote: (voter: IVoter, governanceActionId: ITxOutRef | TxOutRefStr, vote: Vote, anchor?: IAnchor | undefined, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly voteDRep: (drepKeyHash: CanBeHash28, governanceActionId: ITxOutRef | TxOutRefStr, vote: Vote, anchor?: IAnchor | undefined) => TxBuilderRunner;
+    readonly voteScriptDRep: (drepScriptHash: CanBeHash28, governanceActionId: ITxOutRef | TxOutRefStr, vote: Vote, anchor?: IAnchor | undefined, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly voteConstitutionalComittee: (memberKeyHash: CanBeHash28, governanceActionId: ITxOutRef | TxOutRefStr, vote: Vote, anchor?: IAnchor | undefined) => TxBuilderRunner;
+    readonly voteScriptConstitutionalComittee: (memberScriptHash: CanBeHash28, governanceActionId: ITxOutRef | TxOutRefStr, vote: Vote, anchor?: IAnchor | undefined, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly voteStakePool: (poolId: CanBeHash28, governanceActionId: ITxOutRef | TxOutRefStr, vote: Vote, anchor?: IAnchor | undefined) => TxBuilderRunner;
+    readonly propose: (proposal: IProposalProcedure, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly proposeParametersChanges: (changes: Partial<ProtocolParameters>, procedureInfos: Omit<IProposalProcedure, "govAction">, govActionId?: ITxOutRef | TxOutRefStr, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly proposeHardForkInitiation: (nextProtocolVersion: IProtocolVerision, procedureInfos: Omit<IProposalProcedure, "govAction">, govActionId?: ITxOutRef | TxOutRefStr, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly proposeTreasuryWithdrawal: (withdrawals: ITxWithdrawals | TxWithdrawals, procedureInfos: Omit<IProposalProcedure, "govAction">, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly proposeNoConfidence: (procedureInfos: Omit<IProposalProcedure, "govAction">, govActionId?: ITxOutRef | TxOutRefStr, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly proposeComitteeUpdate: (toRemove: Credential[], toAdd: INewCommitteeEntry[], threshold: Rational, procedureInfos: Omit<IProposalProcedure, "govAction">, govActionId?: ITxOutRef | TxOutRefStr, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly proposeNewConstitution: (constitution: IConstitution, procedureInfos: Omit<IProposalProcedure, "govAction">, govActionId?: ITxOutRef | TxOutRefStr, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly proposeInfos: (procedureInfos: Omit<IProposalProcedure, "govAction">, redeemer?: CanBeData, script_or_ref?: Script<PlutusScriptType> | CanResolveToUTxO) => TxBuilderRunner;
+    readonly tasks: TxBuilderTask[];
+    readonly buildArgs: NormalizedITxBuildArgs;
+    constructor(txBuilder: TxBuilder, provider: Partial<ITxRunnerProvider>);
+}
+export {};