@helios-lang/effect 0.1.15 → 0.3.0

package/dist/Cardano/TxBuilder.js

@@ -0,0 +1,963 @@
+import { Console, Context, Data, Effect } from "effect";
+import * as CoinSelection from "./CoinSelection.js";
+import { Address, Assets, DCert, MintingPolicy, NativeScript, RewardAddress, Tx, TxOutput, UTxO } from "./Ledger";
+import * as Network from "./Network";
+import * as Uplc from "./Uplc";
+import { Balancing as BalancingWallet } from "./Wallet.js";
+export class UTxOAlreadyAdded extends Data.TaggedError("Cardano.TxBuilder.UTxOAlreadyAdded") {
+    constructor(ref) {
+        super({ ref, message: `UTxO ${ref} already added to Tx` });
+    }
+}
+export class MissingDatum extends Data.TaggedError("Cardano.TxBuilder.MissingDatum") {
+    constructor() {
+        super({ message: "Datum missing" });
+    }
+}
+export class MissingRedeemer extends Data.TaggedError("Cardano.TxBuilder.MissingRedeemer") {
+    constructor() {
+        super({ message: "Redeemer missing" });
+    }
+}
+export class RedundantRedeemer extends Data.TaggedError("Cardano.TxBuilder.RedundantRedeemer") {
+    constructor() {
+        super({
+            message: "Redeemer is redundant (input not locked by uplc script)"
+        });
+    }
+}
+export class RedeemerAlreadyAdded extends Data.TaggedError("Cardano.TxBuilder.RedeemerAlreadyAdded") {
+    constructor() {
+        super({ message: "Redeemer already added" });
+    }
+}
+export class MissingScript extends Data.TaggedError("Cardano.TxBuilder.MissingScript") {
+    constructor(hash) {
+        super({ message: `Script missing for ${hash}` });
+    }
+}
+export class DatumNotFound extends Data.TaggedError("Cardano.TxBuilder.DatumNotFound") {
+    constructor(hash, cause) {
+        super({ message: `Datum for ${hash} not found (${cause})` });
+    }
+}
+export class ColleteralNotAvailable extends Data.TaggedError("Cardano.TxBuilder.CollateralNotAvailable") {
+    constructor() {
+        super({
+            message: `Colleteral not available (grabbing colleteral utxos from existing inputs or spare utxos still needs to be implemented)`
+        });
+    }
+}
+export class GetDatum extends Context.Tag("Cardano.TxBuilder.GetDatum")() {
+}
+const empty = {
+    datums: [],
+    dcerts: [],
+    inputs: [],
+    metadata: {},
+    minted: {},
+    outputs: [],
+    refInputs: [],
+    mintingRedeemers: [],
+    spendingRedeemers: [],
+    rewardingRedeemers: [],
+    certifyingRedeemers: [],
+    nativeScripts: [],
+    v1Scripts: [],
+    v2Scripts: [],
+    v3Scripts: [],
+    v2RefScripts: [],
+    v3RefScripts: [],
+    signers: [],
+    validFrom: undefined,
+    validTo: undefined,
+    withdrawals: []
+};
+export const start = Effect.succeed(empty);
+/**
+ * Automatically discards duplicates
+ */
+export const attachScript = (script) => (b) => {
+    if ("version" in script) {
+        if (Uplc.Script.isVersion(1)(script)) {
+            return addV1Script(b, script);
+        }
+        else if (Uplc.Script.isVersion(2)(script)) {
+            return addV2Script(b, script);
+        }
+        else if (Uplc.Script.isVersion(3)(script)) {
+            return addV3Script(b, script);
+        }
+        else {
+            throw new Error(`unhandled script version ${script.version}`);
+        }
+    }
+    else {
+        const hash = NativeScript.hash(script);
+        if (hasNativeScript(b, hash)) {
+            return b;
+        }
+        // assign result before returning so that return type is TxBuilder
+        b = {
+            ...b,
+            nativeScripts: [...b.nativeScripts, { script, hash }]
+        };
+        return b;
+    }
+};
+export const attachScriptEffect = (script) => Effect.map(attachScript(script));
+export const delegate = (credential, poolId, redeemer = undefined) => (b) => Effect.gen(function* () {
+    const dcert = {
+        _tag: "Delegation",
+        credential,
+        poolId
+    };
+    b = addDCert(b, dcert);
+    if (credential._tag == "Validator") {
+        if (redeemer) {
+            if (hasNativeScript(b, credential.hash)) {
+                return yield* Effect.fail(new RedundantRedeemer());
+            }
+            if (!hasUplcScript(b, credential.hash)) {
+                return yield* Effect.fail(new MissingScript(credential.hash));
+            }
+            b = yield* addCertifyingRedeemer(b, dcert, redeemer);
+        }
+        else {
+            if (!hasNativeScript(b, credential.hash)) {
+                return yield* Effect.fail(new MissingRedeemer());
+            }
+        }
+    }
+    else if (redeemer) {
+        return yield* Effect.fail(new RedundantRedeemer());
+    }
+    return b;
+});
+export const delegateEffect = (credential, poolId, redeemer = undefined) => Effect.flatMap(delegate(credential, poolId, redeemer));
+export const deregister = (credential, redeemer = undefined) => (b) => Effect.gen(function* () {
+    const dcert = {
+        _tag: "Deregistration",
+        credential
+    };
+    b = addDCert(b, dcert);
+    if (credential._tag == "Validator") {
+        if (redeemer) {
+            if (hasNativeScript(b, credential.hash)) {
+                return yield* Effect.fail(new RedundantRedeemer());
+            }
+            if (!hasUplcScript(b, credential.hash)) {
+                return yield* Effect.fail(new MissingScript(credential.hash));
+            }
+            b = yield* addCertifyingRedeemer(b, dcert, redeemer);
+        }
+        else {
+            if (!hasNativeScript(b, credential.hash)) {
+                return yield* Effect.fail(new MissingRedeemer());
+            }
+        }
+    }
+    else if (redeemer) {
+        return yield* Effect.fail(new RedundantRedeemer());
+    }
+    return b;
+});
+export const deregisterEffect = (credential, redeemer = undefined) => Effect.flatMap(deregister(credential, redeemer));
+export const metadata = (mdata) => (b) => {
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        metadata: { ...b.metadata, ...mdata }
+    };
+    return b;
+};
+export const metadataEffect = (mdata) => Effect.map(metadata(mdata));
+/**
+ * Filters out ADA
+ * Entries in assets can be negative for burning
+ */
+export const mint = (assets, redeemer = undefined) => (b) => Effect.gen(function* () {
+    const policies = Assets.nonAdaPolicies(assets);
+    for (const policy of policies) {
+        // assign result before returning so that return type is TxBuilder
+        b = {
+            ...b,
+            minted: Assets.add(b.minted, Assets.filterByPolicy(policy)(assets))
+        };
+        const hash = MintingPolicy.hash(policy);
+        if (redeemer) {
+            if (hasNativeScript(b, hash)) {
+                return yield* Effect.fail(new RedundantRedeemer());
+            }
+            if (!hasUplcScript(b, hash)) {
+                return yield* Effect.fail(new MissingScript(hash));
+            }
+            addMintingRedeemer(b, policy, redeemer);
+        }
+        else {
+            if (!hasNativeScript(b, hash)) {
+                return yield* Effect.fail(new MissingRedeemer());
+            }
+        }
+    }
+    return b;
+});
+export const mintEffect = (assets, redeemer = undefined) => Effect.flatMap(mint(assets, redeemer));
+export const pay = (...outputs) => (b) => Effect.gen(function* () {
+    for (const output of outputs) {
+        b = yield* addOutput(b, output);
+    }
+    return b;
+});
+export const payEffect = (...outputs) => Effect.flatMap(pay(...outputs));
+export const refer = (...utxos) => (b) => Effect.gen(function* () {
+    for (const utxo of utxos) {
+        b = yield* addRefInput(b, utxo);
+        const refScript = utxo.output.refScript;
+        switch (refScript?.version) {
+            case 2:
+                b = addV2RefScript(b, refScript);
+                break;
+            case 3:
+                b = addV3RefScript(b, refScript);
+                break;
+        }
+    }
+    return b;
+});
+export const referEffect = (...utxos) => Effect.flatMap(refer(...utxos));
+export const register = (credential) => (b) => {
+    b = addDCert(b, {
+        _tag: "Registration",
+        credential
+    });
+    return b;
+};
+export const registerEffect = (credential) => Effect.map(register(credential));
+export const sign = (...signers) => (b) => {
+    for (const signer of signers) {
+        b = addSigner(b, signer);
+    }
+    return b;
+};
+export const signEffect = (...signers) => Effect.map(sign(...signers));
+export const spend = (utxos, redeemer = undefined) => (b) => Effect.gen(function* () {
+    for (const utxo of Array.isArray(utxos) ? utxos : [utxos]) {
+        b = yield* addInput(b, utxo);
+        const spendingCred = Address.spendingCredential(utxo.output.address);
+        if (redeemer) {
+            if (spendingCred._tag != "Validator") {
+                return yield* Effect.fail(new RedundantRedeemer());
+            }
+            if (!hasUplcScript(b, spendingCred.hash)) {
+                return yield* Effect.fail(new MissingScript(spendingCred.hash));
+            }
+            b = yield* addSpendingRedeemer(b, utxo, redeemer);
+            const datum = utxo.output.datum;
+            if (!datum && !hasDatumlessScript(b, spendingCred.hash)) {
+                return yield* Effect.fail(new MissingDatum());
+            }
+            if (datum && datum._tag == "Hash") {
+                // provide datum through service
+                const getDatum = yield* GetDatum;
+                const datumData = yield* getDatum(datum.hash);
+                b = addDatum(b, datumData);
+            }
+        }
+        else if (spendingCred._tag == "Validator") {
+            if (!hasNativeScript(b, spendingCred.hash)) {
+                return yield* Effect.fail(new MissingRedeemer());
+            }
+        }
+    }
+    return b;
+});
+export const spendEffect = (utxos, redeemer = undefined) => Effect.flatMap(spend(utxos, redeemer));
+export const validFromSlot = (slot) => (b) => {
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        validFrom: { slot }
+    };
+    return b;
+};
+export const validFromSlotEffect = (slot) => Effect.map(validFromSlot(slot));
+/**
+ * @param time
+ * Milliseconds since 1970
+ */
+export const validFromTime = (time) => (b) => {
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        validFrom: { time }
+    };
+    return b;
+};
+export const validFromTimeEffect = (time) => Effect.map(validFromTime(time));
+export const validToSlot = (slot) => (b) => {
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        validTo: { slot }
+    };
+    return b;
+};
+export const validToSlotEffect = (slot) => Effect.map(validToSlot(slot));
+/**
+ * @param time
+ * Milliseconds since 1970
+ */
+export const validToTime = (time) => (b) => {
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        validTo: { time }
+    };
+    return b;
+};
+export const validToTimeEffect = (time) => Effect.map(validToTime(time));
+export const withdraw = (rewardAddress, lovelace, redeemer = undefined) => (b) => Effect.gen(function* () {
+    const i = b.withdrawals.findIndex((w) => w.address == rewardAddress);
+    if (redeemer) {
+        if (RewardAddress.credential(rewardAddress)._tag != "Validator") {
+            throw new Error("can't withdraw using redeemer from non-Validator rewards address");
+        }
+        b = yield* addRewardingRedeemer(b, rewardAddress, redeemer);
+    }
+    const withdrawals = b.withdrawals.slice();
+    if (i == -1) {
+        withdrawals.push({ address: rewardAddress, lovelace: BigInt(lovelace) });
+    }
+    else {
+        withdrawals[i] = {
+            address: rewardAddress,
+            lovelace: BigInt(lovelace) + withdrawals[i].lovelace
+        };
+    }
+    withdrawals.sort(({ address: a }, { address: b }) => RewardAddress.compare(a, b));
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        withdrawals
+    };
+    return b;
+});
+export const withdrawEffect = (rewardAddress, lovelace, redeemer = undefined) => Effect.flatMap(withdraw(rewardAddress, lovelace, redeemer));
+function addDatum(b, data) {
+    if (hasDatum(b, data)) {
+        return b;
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        datums: [...b.datums, data]
+    };
+    return b;
+}
+function hasDatum(b, data) {
+    return b.datums.some((d) => Uplc.Data.equals(d, data));
+}
+function addDCert(b, dcert) {
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        dcerts: [...b.dcerts, dcert]
+    };
+    if (dcert._tag == "Delegation" || dcert._tag == "Deregistration") {
+        if (dcert.credential._tag == "PubKey") {
+            b = addSigner(b, dcert.credential.hash);
+        }
+    }
+    return b;
+}
+const addInput = (b, input) => Effect.gen(function* () {
+    yield* Assets.assertAllPositive(input.output.assets);
+    if (hasInput(b, input.ref)) {
+        return yield* Effect.fail(new UTxOAlreadyAdded(input.ref));
+    }
+    if (hasRefInput(b, input.ref)) {
+        return yield* Effect.fail(new UTxOAlreadyAdded(input.ref));
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        inputs: UTxO.append(b.inputs, input)
+    };
+    return b;
+});
+function hasInput(b, ref) {
+    return b.inputs.some((utxo) => utxo.ref == ref);
+}
+const addRefInput = (b, refInput) => Effect.gen(function* () {
+    yield* Assets.assertAllPositive(refInput.output.assets);
+    if (b.inputs.some((utxo) => utxo.ref == refInput.ref)) {
+        return yield* Effect.fail(new UTxOAlreadyAdded(refInput.ref));
+    }
+    if (b.refInputs.some((utxo) => utxo.ref == refInput.ref)) {
+        return yield* Effect.fail(new UTxOAlreadyAdded(refInput.ref));
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        refInputs: UTxO.append(b.refInputs, refInput)
+    };
+    return b;
+});
+function hasRefInput(b, ref) {
+    return b.refInputs.some((utxo) => utxo.ref == ref);
+}
+const addOutput = (b, output) => Effect.gen(function* () {
+    yield* Assets.assertAllPositive(output.assets);
+    const outputCred = Address.spendingCredential(output.address);
+    if (outputCred._tag == "Validator" && output.datum === undefined) {
+        yield* Console.warn("TxOutput is sent to validator but doesn't have a datum");
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        outputs: [...b.outputs, output]
+    };
+    return b;
+});
+function addCertifyingRedeemer(b, dcert, redeemer) {
+    if (hasCertifyingRedeemer(b, dcert)) {
+        return Effect.fail(new RedeemerAlreadyAdded());
+    }
+    b = {
+        ...b,
+        certifyingRedeemers: [...b.certifyingRedeemers, { dcert, redeemer }]
+    };
+    return Effect.succeed(b);
+}
+function hasCertifyingRedeemer(b, dcert) {
+    return b.dcerts.some((d) => DCert.equals(d, dcert));
+}
+function addMintingRedeemer(b, policy, redeemer) {
+    if (hasMintingRedeemer(b, policy)) {
+        return Effect.fail(new RedeemerAlreadyAdded());
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        mintingRedeemers: [...b.mintingRedeemers, { policy, redeemer }]
+    };
+    return Effect.succeed(b);
+}
+function hasMintingRedeemer(b, policy) {
+    return b.mintingRedeemers.some((r) => r.policy == policy);
+}
+function addRewardingRedeemer(b, addr, redeemer) {
+    if (hasRewardingRedeemer(b, addr)) {
+        return Effect.fail(new RedeemerAlreadyAdded());
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        rewardingRedeemers: [...b.rewardingRedeemers, { addr, redeemer }]
+    };
+    return Effect.succeed(b);
+}
+function hasRewardingRedeemer(b, addr) {
+    return b.rewardingRedeemers.some((r) => r.addr == addr);
+}
+function addSpendingRedeemer(b, utxo, redeemer) {
+    if (hasSpendingRedeemer(b, utxo)) {
+        return Effect.fail(new RedeemerAlreadyAdded());
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        spendingRedeemers: [...b.spendingRedeemers, { utxo, redeemer }]
+    };
+    return Effect.succeed(b);
+}
+function hasSpendingRedeemer(b, utxo) {
+    return b.spendingRedeemers.some((r) => r.utxo.ref == utxo.ref);
+}
+function hasRedeemers(b) {
+    return (b.certifyingRedeemers.length > 0 ||
+        b.mintingRedeemers.length > 0 ||
+        b.rewardingRedeemers.length > 0 ||
+        b.spendingRedeemers.length > 0);
+}
+function addV1Script(b, script) {
+    const hash = Uplc.Script.hash(script);
+    if (hasV1Script(b, hash)) {
+        return b;
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        v1Scripts: [...b.v1Scripts, { script, hash }]
+    };
+    return b;
+}
+function hasV1Script(b, hash) {
+    return b.v1Scripts.some((s) => s.hash == hash);
+}
+function addV2Script(b, script) {
+    const hash = Uplc.Script.hash(script);
+    if (hasV2Script(b, hash)) {
+        return b;
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        v2Scripts: [...b.v2Scripts, { script, hash }]
+    };
+    return b;
+}
+function hasV2Script(b, hash) {
+    return b.v2Scripts.some((s) => s.hash == hash);
+}
+function addV3Script(b, script) {
+    const hash = Uplc.Script.hash(script);
+    if (hasV3Script(b, hash)) {
+        return b;
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        v3Scripts: [...b.v3Scripts, { script, hash }]
+    };
+    return b;
+}
+function hasV3Script(b, hash) {
+    return b.v3Scripts.some((s) => s.hash == hash);
+}
+function addV2RefScript(b, script) {
+    const hash = Uplc.Script.hash(script);
+    if (hasV2RefScript(b, hash)) {
+        return b;
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        v2RefScripts: [...b.v2RefScripts, { hash, script }]
+    };
+    return b;
+}
+function hasV2RefScript(b, hash) {
+    return b.v2RefScripts.some((s) => s.hash == hash);
+}
+function addV3RefScript(b, script) {
+    const hash = Uplc.Script.hash(script);
+    if (hasV3RefScript(b, hash)) {
+        return b;
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        v3RefScripts: [...b.v3RefScripts, { hash, script }]
+    };
+    return b;
+}
+function hasV3RefScript(b, hash) {
+    return b.v3RefScripts.some((s) => s.hash == hash);
+}
+function hasDatumlessScript(b, hash) {
+    return (hasNativeScript(b, hash) || hasV3Script(b, hash) || hasV3RefScript(b, hash));
+}
+function hasNativeScript(b, hash) {
+    return b.nativeScripts.some((s) => s.hash == hash);
+}
+function hasUplcScript(b, hash) {
+    return (hasV1Script(b, hash) ||
+        hasV2Script(b, hash) ||
+        hasV3Script(b, hash) ||
+        hasV2RefScript(b, hash) ||
+        hasV3RefScript(b, hash));
+}
+function allUplcScripts(b) {
+    return []
+        .concat(b.v1Scripts)
+        .concat(b.v2Scripts)
+        .concat(b.v3Scripts)
+        .concat(b.v2RefScripts)
+        .concat(b.v3RefScripts);
+}
+function getUplcScript(b, hash) {
+    const script = allUplcScripts(b).find((s) => s.hash == hash);
+    if (!script) {
+        throw new Error(`script with hash '${hash}' not found during redeemer building stage`);
+    }
+    return script.script;
+}
+function addSigner(b, signer) {
+    if (hasSigner(b, signer)) {
+        return b;
+    }
+    // assign result before returning so that return type is TxBuilder
+    b = {
+        ...b,
+        signers: [...b.signers, signer]
+    };
+    return b;
+}
+function hasSigner(b, signer) {
+    return b.signers.includes(signer);
+}
+class CurrentTxBuilder extends Context.Tag("Cardano.TxBuilder.CurrentTxBuilder")() {
+}
+export const build = (options = {}) => (b) => Effect.gen(function* () {
+    /**
+     * Calculate the metadata hash
+     */
+    const { metadata, metadataHash } = yield* buildMetadata;
+    /**
+     * Calculate the validity time range slots
+     */
+    const { firstValidSlot, lastValidSlot } = yield* buildValidityTimeRange;
+    /**
+     * Make sure the outputs contain enough lovelace
+     */
+    const outputs = yield* buildNonChangeOutputs;
+    /**
+     * Simple select a collateral input from the params if smart
+     */
+    const collateralInputs = yield* selectCollateralInputs;
+    /**
+     * Create an unbalanced tx. In this tx a few fields are not yet final:
+     *   - inputs
+     *   - outputs
+     *   - fee
+     *   - scriptDataHash
+     *   - redeemers
+     */
+    let tx = {
+        body: {
+            inputs: b.inputs,
+            outputs,
+            fee: 0n,
+            firstValidSlot,
+            lastValidSlot,
+            dcerts: b.dcerts,
+            scriptDataHash: hasRedeemers(b)
+                ? new Array(32).fill(0)
+                : undefined,
+            withdrawals: b.withdrawals.map((w) => [w.address, w.lovelace]),
+            minted: b.minted,
+            refInputs: b.refInputs,
+            totalCollateral: 0n,
+            collateral: collateralInputs,
+            signers: b.signers,
+            collateralReturn: undefined, // TODO
+            metadataHash,
+            encoding: options.bodyEncoding
+        },
+        witnesses: {
+            signatures: [],
+            datums: b.datums,
+            redeemers: [],
+            nativeScripts: b.nativeScripts.map((s) => s.script),
+            v1Scripts: b.v1Scripts.map((s) => s.script),
+            v2Scripts: b.v2Scripts.map((s) => s.script),
+            v3Scripts: b.v3Scripts.map((s) => s.script),
+            v2RefScripts: b.v2RefScripts.map((s) => s.script),
+            v3RefScripts: b.v3RefScripts.map((s) => s.script),
+            encoding: options.witnessesEncoding
+        },
+        isValid: false,
+        metadata
+    };
+    /**
+     * The redeemer indices depend on some tx body fields, so are initialized after the init tx is created
+     */
+    tx = yield* buildRedeemersWithoutCost(tx);
+    /**
+     * Now in a loop the transaction is updated:
+     *   - fee is set to min fee
+     *   - the tx is balanced, grabbing inputs from the spareUTxOs and creating a change UTxO if there wasn't already a change UTxO
+     *   - any lazy redeemer data is built (usually depends on order of inputs/outputs etc.)
+     *   - the cost of each redeemer is calculated
+     *   - the scriptDataHash is updated
+     *
+     * The loop continues as long as the tx.fee field is smaller than the min required field.
+     * We know that this loop will run at least once because initially tx.fee=0n, ensuring the tx is balanced
+     */
+    while (tx.body.fee < (yield* Tx.minFee(tx))) {
+        tx = yield* updateFee(tx);
+        tx = yield* balanceTx(tx);
+        tx = yield* buildRedeemersWithCost(tx);
+        tx = yield* updateScriptDataHash(tx);
+    }
+    /**
+     * Sign using balancing wallet
+     */
+    tx = {
+        ...tx,
+        witnesses: {
+            ...tx.witnesses,
+            signatures: [
+                ...tx.witnesses.signatures,
+                ...(yield* (yield* BalancingWallet).signTx(tx))
+            ]
+        }
+    };
+    return tx;
+}).pipe(Effect.provideService(CurrentTxBuilder, b));
+const buildMetadata = CurrentTxBuilder.pipe(Effect.map((b) => {
+    if (b.metadata !== undefined) {
+        return { metadata: b.metadata, metadataHash: Tx.hashMetadata(b.metadata) };
+    }
+    else {
+        return { metadata: undefined, metadataHash: undefined };
+    }
+}));
+const buildValidityTimeRange = CurrentTxBuilder.pipe(Effect.flatMap((b) => {
+    const calcSlot = (slotOrTime) => {
+        if (slotOrTime === undefined) {
+            return Effect.succeed(undefined);
+        }
+        else if ("time" in slotOrTime) {
+            return Network.Params.timeToSlot(slotOrTime.time);
+        }
+        else {
+            return Effect.succeed(slotOrTime.slot);
+        }
+    };
+    return Effect.zip(calcSlot(b.validFrom), calcSlot(b.validTo)).pipe(Effect.map(([firstValidSlot, lastValidSlot]) => ({
+        firstValidSlot,
+        lastValidSlot
+    })));
+}));
+const buildNonChangeOutputs = Effect.gen(function* () {
+    const b = yield* CurrentTxBuilder;
+    const outputs = b.outputs.slice();
+    for (let i = 0; i < outputs.length; i++) {
+        const output = outputs[i];
+        const lovelace = yield* TxOutput.minLovelace(output);
+        if (lovelace > output.assets[""]) {
+            outputs[i] = {
+                ...output,
+                assets: {
+                    ...output.assets,
+                    "": lovelace
+                }
+            };
+        }
+    }
+    return outputs;
+});
+const selectCollateralInputs = Effect.gen(function* () {
+    const b = yield* CurrentTxBuilder;
+    if (!hasRedeemers(b)) {
+        return [];
+    }
+    else {
+        const params = yield* Network.Params.params;
+        const ref = params.collateralUTXO;
+        if (!ref) {
+            return yield* Effect.fail(new ColleteralNotAvailable());
+        }
+        return [yield* (yield* Network.UTxO)(ref)];
+    }
+});
+const buildRedeemersWithoutCost = (tx) => CurrentTxBuilder.pipe(Effect.map((b) => {
+    const redeemers = b.mintingRedeemers
+        .map((r) => ({
+        _tag: "Minting",
+        policyIndex: Assets.nonAdaPolicies(tx.body.minted).indexOf(r.policy),
+        data: typeof r.redeemer == "function" ? r.redeemer(tx) : r.redeemer,
+        cost: { cpu: 0n, mem: 0n }
+    }))
+        .concat(b.spendingRedeemers.map((r) => ({
+        _tag: "Spending",
+        inputIndex: tx.body.inputs.map((u) => u.ref).indexOf(r.utxo.ref),
+        data: typeof r.redeemer == "function" ? r.redeemer(tx) : r.redeemer,
+        cost: { cpu: 0n, mem: 0n }
+    })))
+        .concat(b.rewardingRedeemers.map((r) => ({
+        _tag: "Rewarding",
+        withdrawalIndex: tx.body.withdrawals
+            .map((w) => w[0])
+            .indexOf(r.addr),
+        data: typeof r.redeemer == "function" ? r.redeemer(tx) : r.redeemer,
+        cost: { cpu: 0n, mem: 0n }
+    })))
+        .concat(b.certifyingRedeemers.map((r) => ({
+        _tag: "Certifying",
+        dcertIndex: tx.body.dcerts.findIndex((dcert) => DCert.equals(dcert, r.dcert)),
+        data: typeof r.redeemer == "function" ? r.redeemer(tx) : r.redeemer,
+        cost: { cpu: 0n, mem: 0n }
+    })));
+    // assign result before returning so that return type is Tx
+    tx = {
+        ...tx,
+        witnesses: {
+            ...tx.witnesses,
+            redeemers
+        }
+    };
+    return tx;
+}));
+const redeemerInfos = (b) => b.mintingRedeemers
+    .concat(b.spendingRedeemers)
+    .concat(b.rewardingRedeemers)
+    .concat(b.certifyingRedeemers);
+const buildRedeemersWithCost = (tx) => Effect.gen(function* () {
+    const b = yield* CurrentTxBuilder;
+    /**
+     * Rebuild the redeemers to make sure the indices point to the correct policy/input/withdrawal/dcert
+     */
+    tx = yield* buildRedeemersWithoutCost(tx);
+    /**
+     * Now calculate the cost of each redeemer
+     */
+    const costs = yield* Effect.all(redeemerInfos(b).map(redeemerValidatorHash).map(profileRedeemer(b, tx)));
+    // assign result before returning so that return type is Tx
+    tx = {
+        ...tx,
+        witnesses: {
+            ...tx.witnesses,
+            redeemers: tx.witnesses.redeemers.map((r, i) => ({
+                ...r,
+                cost: costs[i]
+            }))
+        }
+    };
+    return tx;
+});
+const redeemerValidatorHash = (redeemer) => {
+    if ("policy" in redeemer) {
+        return MintingPolicy.hash(redeemer.policy);
+    }
+    else if ("utxo" in redeemer) {
+        const cred = Address.spendingCredential(redeemer.utxo.output.address);
+        if (cred._tag != "Validator") {
+            throw new Error("unexpected pubkey address for utxo being spent by redeemer");
+        }
+        return cred.hash;
+    }
+    else if ("addr" in redeemer) {
+        const cred = RewardAddress.credential(redeemer.addr);
+        if (cred._tag != "Validator") {
+            throw new Error("unexpected pubkey rewardaddress for redeemer withdrawal");
+        }
+        return cred.hash;
+    }
+    else {
+        return DCert.validatorHash(redeemer.dcert);
+    }
+};
+const profileRedeemer = (b, tx) => (vh, redeemerIndex) => Effect.gen(function* () {
+    const script = getUplcScript(b, vh);
+    const args = yield* Uplc.ScriptContext.makeArgs(script.version, tx, redeemerIndex);
+    const costModel = yield* Network.Params.costModel(script.version);
+    const profile = yield* Uplc.Script.eval(script, args, costModel);
+    if (profile.value._tag == "Left") {
+        // TODO: return a RuntimeError with nice stack trace
+        return yield* Effect.fail(new Error(profile.value.left.error));
+    }
+    return profile.cost;
+});
+const updateScriptDataHash = (tx) => Effect.gen(function* () {
+    const scriptDataHash = yield* Tx.scriptDataHash(tx);
+    // assign result before returning so that return type is Tx
+    tx = {
+        ...tx,
+        body: {
+            ...tx.body,
+            scriptDataHash
+        }
+    };
+    return tx;
+});
+const updateFee = (tx) => Effect.gen(function* () {
+    const fee = yield* Tx.minFee(tx);
+    // assign result before returning so that return type is Tx
+    tx = {
+        ...tx,
+        body: {
+            ...tx.body,
+            fee
+        }
+    };
+    return tx;
+});
+const selectCoinsForBalancing = CoinSelection.smallestFirst({
+    allowSelectingUninvolvedAssets: true
+});
+const balanceTx = (tx) => Effect.gen(function* () {
+    const inputAssets = UTxO.sumAssets(...tx.body.inputs);
+    const outputAssets = Assets.sum(...tx.body.outputs.map((output) => output.assets));
+    const feeAssets = { "": tx.body.fee };
+    const mintedAssets = tx.body.minted;
+    let net = Assets.sum(inputAssets, mintedAssets, Assets.negate(outputAssets), Assets.negate(feeAssets));
+    /**
+     * Return if already balanced
+     */
+    if (Assets.isEmpty(net)) {
+        return tx;
+    }
+    const balancingWallet = yield* BalancingWallet;
+    const changeAddress = yield* balancingWallet.changeAddress;
+    const spareUTxOs = yield* balancingWallet.utxos;
+    const selectAndAddInputs = (amount) => Effect.gen(function* () {
+        const extraInputs = yield* selectCoinsForBalancing(UTxO.difference(spareUTxOs ?? [], tx.body.inputs.concat(tx.body.refInputs)), amount);
+        net = Assets.add(net, UTxO.sumAssets(...extraInputs));
+        tx = {
+            ...tx,
+            body: {
+                ...tx.body,
+                inputs: UTxO.append(tx.body.inputs, ...extraInputs)
+            }
+        };
+    });
+    /**
+     * Any negative assets must be added on the input side by using the spareUTxOs
+     */
+    if (!Assets.isEmpty(Assets.filterNegative(net))) {
+        yield* selectAndAddInputs(Assets.negate(Assets.filterNegative(net)));
+    }
+    /**
+     * Handle the unlikely event that the tx is already balanced with the extraInputs
+     */
+    if (Assets.isEmpty(net)) {
+        return tx;
+    }
+    if (Address.isValidator(changeAddress)) {
+        throw new Error("can't send change to validator");
+    }
+    /**
+     * Lookup or create the change output (TODO: support multiple change outputs?)
+     */
+    let changeOutput = tx.body.outputs.find((output) => output.address == changeAddress &&
+        output.datum === undefined &&
+        output.refScript === undefined);
+    const nonChangeOutputs = tx.body.outputs.filter((output) => output != changeOutput);
+    /**
+     * Create the change output if no change output was found
+     */
+    if (changeOutput === undefined) {
+        changeOutput = {
+            address: changeAddress,
+            assets: Assets.filterPositive(net)
+        };
+        net = {};
+    }
+    const minLovelace = yield* TxOutput.minLovelace(changeOutput);
+    let diff = minLovelace - (changeOutput.assets[""] ?? 0n);
+    while (diff > 0n) {
+        yield* selectAndAddInputs({ "": diff });
+        changeOutput = {
+            ...changeOutput,
+            assets: Assets.add(changeOutput.assets, Assets.filterPositive(net))
+        };
+        net = {};
+        diff =
+            (yield* TxOutput.minLovelace(changeOutput)) -
+                (changeOutput.assets[""] ?? 0n);
+    }
+    // assign result before returning so that return type is Tx
+    tx = {
+        ...tx,
+        body: {
+            ...tx.body,
+            outputs: [...nonChangeOutputs, changeOutput]
+        }
+    };
+    return tx;
+});
+//# sourceMappingURL=TxBuilder.js.map