@hazbase/simplicity 0.0.5 → 0.1.1

package/dist/core/executor.js

@@ -15,6 +15,7 @@ const summary_1 = require("./summary");
 const templating_1 = require("./templating");
 const presets_1 = require("./presets");
 const toolchain_1 = require("./toolchain");
+const rpc_1 = require("./rpc");
 const DEFAULT_FEE_SAT = 100;
 const DEFAULT_SEQUENCE = 4294967293;
 const DUST_MARGIN_SAT = 600;
@@ -51,6 +52,13 @@ function getArtifactLocktime(artifact) {
     }
     return 0;
 }
+function getEffectiveLocktime(artifact, input) {
+    const candidate = input.locktimeHeight;
+    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0) {
+        return Math.trunc(candidate);
+    }
+    return getArtifactLocktime(artifact);
+}
 function parseSimcWitness(output) {
     const lines = output
         .split("\n")
@@ -97,13 +105,15 @@ function chooseUtxo(utxos, minSat, policy) {
     const unconfirmed = sortCandidates(utxos.filter((utxo) => !utxo.confirmed).filter((utxo) => utxo.sat >= minSat));
     return unconfirmed[0] ?? null;
 }
-async function findContractUtxosInMempool(elementsCliPath, contractAddress) {
-    const mempool = await (0, toolchain_1.runCommand)(elementsCliPath, ["getrawmempool"]);
-    const txids = JSON.parse(mempool.stdout);
+async function callRpc(config, method, params = [], wallet) {
+    const client = new rpc_1.ElementsRpcClient(config.rpc);
+    return client.call(method, params, wallet);
+}
+async function findContractUtxosInMempool(config, contractAddress) {
+    const txids = await callRpc(config, "getrawmempool", []);
     const matches = [];
     for (const txid of txids) {
-        const tx = await (0, toolchain_1.runCommand)(elementsCliPath, ["getrawtransaction", txid, "true"]);
-        const parsed = JSON.parse(tx.stdout);
+        const parsed = await callRpc(config, "getrawtransaction", [txid, true]);
         for (const output of parsed.vout ?? []) {
             if (output.scriptPubKey?.address !== contractAddress)
                 continue;
@@ -119,10 +129,8 @@ async function findContractUtxosInMempool(elementsCliPath, contractAddress) {
     }
     return matches;
 }
-async function scanUtxosByAddress(elementsCliPath, contractAddress) {
-    const pattern = `["addr(${contractAddress})"]`;
-    const result = await (0, toolchain_1.runCommand)(elementsCliPath, ["scantxoutset", "start", pattern]);
-    const parsed = JSON.parse(result.stdout);
+async function scanUtxosByAddress(config, contractAddress) {
+    const parsed = await callRpc(config, "scantxoutset", ["start", [`addr(${contractAddress})`]]);
     if (!parsed.success || !Array.isArray(parsed.unspents)) {
         throw new errors_1.ExecutionError("scantxoutset failed", parsed);
     }
@@ -135,33 +143,29 @@ async function scanUtxosByAddress(elementsCliPath, contractAddress) {
         height: utxo.height,
         confirmed: true,
     }));
-    const mempool = confirmed.length === 0 ? await findContractUtxosInMempool(elementsCliPath, contractAddress) : [];
+    const mempool = confirmed.length === 0 ? await findContractUtxosInMempool(config, contractAddress) : [];
     return [...confirmed, ...mempool];
 }
-async function decodePsbt(elementsCliPath, psetBase64, wallet) {
-    const result = await (0, toolchain_1.runCommand)(elementsCliPath, [`-rpcwallet=${wallet}`, "decodepsbt", psetBase64]);
-    return JSON.parse(result.stdout);
+async function decodePsbt(config, psetBase64, wallet) {
+    return callRpc(config, "decodepsbt", [psetBase64], wallet);
 }
-async function getAddressInfo(elementsCliPath, wallet, address) {
-    const result = await (0, toolchain_1.runCommand)(elementsCliPath, [`-rpcwallet=${wallet}`, "getaddressinfo", address]);
-    const parsed = JSON.parse(result.stdout);
+async function getAddressInfo(config, wallet, address) {
+    const parsed = await callRpc(config, "getaddressinfo", [address], wallet);
     if (!parsed.scriptPubKey) {
         throw new errors_1.ExecutionError(`Could not get scriptPubKey from address: ${address}`);
     }
     return { scriptPubKey: parsed.scriptPubKey, unconfidential: parsed.unconfidential };
 }
-async function allocateWalletAddress(elementsCliPath, wallet) {
-    const result = await (0, toolchain_1.runCommand)(elementsCliPath, [`-rpcwallet=${wallet}`, "getnewaddress"]);
-    const address = result.stdout.trim();
-    const info = await getAddressInfo(elementsCliPath, wallet, address);
+async function allocateWalletAddress(config, wallet) {
+    const address = await callRpc(config, "getnewaddress", [], wallet);
+    const info = await getAddressInfo(config, wallet, address);
     return {
         address: info.unconfidential ?? address,
         scriptPubKey: info.scriptPubKey,
     };
 }
-async function listWalletUtxos(elementsCliPath, wallet) {
-    const result = await (0, toolchain_1.runCommand)(elementsCliPath, [`-rpcwallet=${wallet}`, "listunspent", "0", "9999999", "[]", "true"]);
-    const parsed = JSON.parse(result.stdout);
+async function listWalletUtxos(config, wallet) {
+    const parsed = await callRpc(config, "listunspent", [0, 9999999, [], true], wallet);
     return parsed.map((entry) => ({
         txid: entry.txid,
         vout: entry.vout,
@@ -233,18 +237,17 @@ function buildPsetSummary(decoded, meta) {
         fee: decoded.fees ?? decoded.fee ?? null,
     };
 }
-async function getScriptPubKeyHexFromAddress(elementsCliPath, address) {
-    const result = await (0, toolchain_1.runCommand)(elementsCliPath, ["getaddressinfo", address]);
-    const parsed = JSON.parse(result.stdout);
+async function getScriptPubKeyHexFromAddress(config, address, wallet) {
+    const parsed = await callRpc(config, "getaddressinfo", [address], wallet);
     if (!parsed.scriptPubKey) {
         throw new errors_1.ExecutionError(`Could not get scriptPubKey from address: ${address}`);
     }
     return parsed.scriptPubKey.toLowerCase();
 }
-async function assertSummaryPolicy(elementsCliPath, summary, expectedLiquidReceiver) {
+async function assertSummaryPolicy(config, summary, expectedLiquidReceiver, wallet) {
     if (!expectedLiquidReceiver)
         return;
-    const expectedSpk = await getScriptPubKeyHexFromAddress(elementsCliPath, expectedLiquidReceiver);
+    const expectedSpk = await getScriptPubKeyHexFromAddress(config, expectedLiquidReceiver, wallet);
     const normalOutputs = summary.outputs.filter((output) => output.isFee !== true);
     const found = normalOutputs.some((output) => (output.scriptPubKeyHex ?? "").toLowerCase() === expectedSpk);
     if (!found) {
@@ -256,14 +259,13 @@ async function assertSummaryPolicy(elementsCliPath, summary, expectedLiquidRecei
     }
 }
 async function buildExecutionState(config, artifact, input) {
-    const elementsCliPath = config.toolchain.elementsCliPath ?? "eltc";
-    await (0, toolchain_1.runCommand)(elementsCliPath, [`-rpcwallet=${input.wallet}`, "getwalletinfo"]);
+    await callRpc(config, "getwalletinfo", [], input.wallet);
     const feeSat = input.feeSat ?? config.defaults?.feeSat ?? DEFAULT_FEE_SAT;
     const minSat = feeSat + DUST_MARGIN_SAT;
     const utxoPolicy = input.utxoPolicy ?? config.defaults?.utxoPolicy ?? "smallest_over";
-    const recipientInfo = await getAddressInfo(elementsCliPath, input.wallet, input.toAddress);
+    const recipientInfo = await getAddressInfo(config, input.wallet, input.toAddress);
     const recipientAddress = recipientInfo.unconfidential ?? input.toAddress;
-    const utxos = await scanUtxosByAddress(elementsCliPath, artifact.compiled.contractAddress);
+    const utxos = await scanUtxosByAddress(config, artifact.compiled.contractAddress);
     const contractUtxo = chooseUtxo(utxos, minSat, utxoPolicy);
     if (!contractUtxo) {
         throw new errors_1.UtxoNotFoundError(`No contract UTXO found for address=${artifact.compiled.contractAddress} satisfying minSat=${minSat}`);
@@ -278,29 +280,24 @@ async function buildExecutionState(config, artifact, input) {
             sendSat,
         });
     }
-    const inputsJson = JSON.stringify([
+    const inputsJson = [
         {
             txid: contractUtxo.txid,
             vout: contractUtxo.vout,
             sequence: input.sequence ?? DEFAULT_SEQUENCE,
         },
-    ]);
-    const outputsJson = JSON.stringify([{ [recipientAddress]: satToBtcNumber(sendSat) }, { fee: satToBtcNumber(feeSat) }]);
-    const pset1 = await (0, toolchain_1.runCommand)(elementsCliPath, [
-        "createpsbt",
-        inputsJson,
-        outputsJson,
-        String(getArtifactLocktime(artifact)),
-        "true",
-    ]);
-    const psetUpdated = await (0, toolchain_1.runCommand)(elementsCliPath, ["utxoupdatepsbt", pset1.stdout]);
+    ];
+    const outputsJson = [{ [recipientAddress]: satToBtcNumber(sendSat) }, { fee: satToBtcNumber(feeSat) }];
+    const locktime = getEffectiveLocktime(artifact, input);
+    const pset1 = await callRpc(config, "createpsbt", [inputsJson, outputsJson, locktime, true], input.wallet);
+    const psetUpdated = await callRpc(config, "utxoupdatepsbt", [pset1], input.wallet);
     const utxoSpec = `${contractUtxo.scriptPubKey}:${contractUtxo.asset}:${satToBtcStringFromNumber(contractUtxo.sat)}`;
-    const updateJson = (await (0, toolchain_1.runHalUpdateInput)(config.toolchain.halSimplicityPath, psetUpdated.stdout, 0, utxoSpec, artifact.compiled.cmr, artifact.compiled.internalKey));
+    const updateJson = (await (0, toolchain_1.runHalUpdateInput)(config.toolchain.halSimplicityPath, psetUpdated, 0, utxoSpec, artifact.compiled.cmr, artifact.compiled.internalKey));
     const pset2 = updateJson.pset;
     if (!pset2) {
         throw new errors_1.ExecutionError("update-input did not return a pset", updateJson);
     }
-    const decoded = await decodePsbt(elementsCliPath, pset2, input.wallet);
+    const decoded = await decodePsbt(config, pset2, input.wallet);
     const summary = buildPsetSummary(decoded, {
         network: artifact.network,
         purpose: input.purpose ?? "sdk_execute",
@@ -321,7 +318,7 @@ async function buildExecutionState(config, artifact, input) {
         cmr: artifact.compiled.cmr,
         internalKey: artifact.compiled.internalKey,
         program: artifact.compiled.program,
-        minHeight: getArtifactLocktime(artifact) || undefined,
+        minHeight: locktime || undefined,
     });
     const { canonicalJson: summaryCanonicalJson, hash: summaryHash } = (0, summary_1.summarize)(summary);
     return {
@@ -347,9 +344,8 @@ async function inspectContractCall(config, artifact, input) {
     };
 }
 async function executeContractCall(config, artifact, input) {
-    const elementsCliPath = config.toolchain.elementsCliPath ?? "eltc";
     const state = await buildExecutionState(config, artifact, input);
-    await assertSummaryPolicy(elementsCliPath, state.summary, input.expectedLiquidReceiver);
+    await assertSummaryPolicy(config, state.summary, input.expectedLiquidReceiver, input.wallet);
     const finalizedPset = await signContractInput(config, artifact, state.pset2, input.signer.privkeyHex, input.witness);
     const finalized = { pset: finalizedPset };
     if (!finalized.pset) {
@@ -358,13 +354,11 @@ async function executeContractCall(config, artifact, input) {
     const rawTxHex = normalizeRawTx(await (0, toolchain_1.runHalExtract)(config.toolchain.halSimplicityPath, finalized.pset));
     let txId;
     if (input.broadcast) {
-        const mempool = await (0, toolchain_1.runCommand)(elementsCliPath, ["testmempoolaccept", `["${rawTxHex}"]`]);
-        const mempoolParsed = JSON.parse(mempool.stdout);
+        const mempoolParsed = await callRpc(config, "testmempoolaccept", [[rawTxHex]], input.wallet);
         if (!Array.isArray(mempoolParsed) || mempoolParsed[0]?.allowed !== true) {
             throw new errors_1.ExecutionError("testmempoolaccept rejected transaction", mempoolParsed);
         }
-        const sendTx = await (0, toolchain_1.runCommand)(elementsCliPath, ["sendrawtransaction", rawTxHex]);
-        txId = sendTx.stdout.trim();
+        txId = await callRpc(config, "sendrawtransaction", [rawTxHex], input.wallet);
     }
     return {
         mode: "execute",
@@ -379,21 +373,19 @@ async function executeContractCall(config, artifact, input) {
     };
 }
 async function findContractUtxos(config, artifact) {
-    const elementsCliPath = config.toolchain.elementsCliPath ?? "eltc";
-    return scanUtxosByAddress(elementsCliPath, artifact.compiled.contractAddress);
+    return scanUtxosByAddress(config, artifact.compiled.contractAddress);
 }
 async function executeGaslessContractCall(config, artifact, input) {
     if (input.relayer) {
         return executeRelayedGaslessContractCall(config, artifact, input, input.relayer);
     }
-    const elementsCliPath = config.toolchain.elementsCliPath ?? "eltc";
     const wallet = input.wallet ?? config.rpc.wallet ?? "simplicity-test";
     if (!input.sponsorWallet) {
         throw new errors_1.ValidationError("sponsorWallet is required when relayer is not provided");
     }
-    await (0, toolchain_1.runCommand)(elementsCliPath, [`-rpcwallet=${wallet}`, "getwalletinfo"]);
-    await (0, toolchain_1.runCommand)(elementsCliPath, [`-rpcwallet=${input.sponsorWallet}`, "getwalletinfo"]);
-    const contractUtxos = await scanUtxosByAddress(elementsCliPath, artifact.compiled.contractAddress);
+    await callRpc(config, "getwalletinfo", [], wallet);
+    await callRpc(config, "getwalletinfo", [], input.sponsorWallet);
+    const contractUtxos = await scanUtxosByAddress(config, artifact.compiled.contractAddress);
     const contractUtxo = chooseUtxo(contractUtxos, input.sendAmount ? Math.round(input.sendAmount * 1e8) : 1, input.utxoPolicy ?? config.defaults?.utxoPolicy ?? "smallest_over");
     if (!contractUtxo) {
         throw new errors_1.UtxoNotFoundError(`No contract UTXO found for address=${artifact.compiled.contractAddress}`);
@@ -410,11 +402,11 @@ async function executeGaslessContractCall(config, artifact, input) {
         if (!input.contractChangeAddress) {
             throw new errors_1.ValidationError("contractChangeAddress is required when sendAmount is smaller than the contract UTXO");
         }
-        const changeInfo = await getAddressInfo(elementsCliPath, wallet, input.contractChangeAddress);
+        const changeInfo = await getAddressInfo(config, wallet, input.contractChangeAddress);
         contractChangeAddress = changeInfo.unconfidential ?? input.contractChangeAddress;
         contractChangeScriptPubKey = changeInfo.scriptPubKey;
     }
-    const sponsorUtxos = await listWalletUtxos(elementsCliPath, input.sponsorWallet);
+    const sponsorUtxos = await listWalletUtxos(config, input.sponsorWallet);
     const sponsorInput = chooseSponsorUtxo(sponsorUtxos, feeSat);
     if (!sponsorInput) {
         throw new errors_1.UtxoNotFoundError(`No sponsor UTXO found in wallet=${input.sponsorWallet} for feeSat=${feeSat}`);
@@ -424,17 +416,17 @@ async function executeGaslessContractCall(config, artifact, input) {
     let sponsorChangeScriptPubKey;
     if (sponsorChangeSat > 0) {
         if (input.sponsorChangeAddress) {
-            const info = await getAddressInfo(elementsCliPath, input.sponsorWallet, input.sponsorChangeAddress);
+            const info = await getAddressInfo(config, input.sponsorWallet, input.sponsorChangeAddress);
             sponsorChangeAddress = info.unconfidential ?? input.sponsorChangeAddress;
             sponsorChangeScriptPubKey = info.scriptPubKey;
         }
         else {
-            const allocated = await allocateWalletAddress(elementsCliPath, input.sponsorWallet);
+            const allocated = await allocateWalletAddress(config, input.sponsorWallet);
             sponsorChangeAddress = allocated.address;
             sponsorChangeScriptPubKey = allocated.scriptPubKey;
         }
     }
-    const recipientInfo = await getAddressInfo(elementsCliPath, wallet, input.toAddress);
+    const recipientInfo = await getAddressInfo(config, wallet, input.toAddress);
     const recipientAddress = recipientInfo.unconfidential ?? input.toAddress;
     const outputs = [{ [recipientAddress]: satToBtcNumber(sendSat) }];
     if (contractChangeSat > 0 && contractChangeAddress) {
@@ -444,25 +436,19 @@ async function executeGaslessContractCall(config, artifact, input) {
         outputs.push({ [sponsorChangeAddress]: satToBtcNumber(sponsorChangeSat) });
     }
     outputs.push({ fee: satToBtcNumber(feeSat) });
-    const inputsJson = JSON.stringify([
+    const inputsJson = [
         { txid: contractUtxo.txid, vout: contractUtxo.vout, sequence: DEFAULT_SEQUENCE },
         { txid: sponsorInput.txid, vout: sponsorInput.vout, sequence: DEFAULT_SEQUENCE },
-    ]);
-    const outputsJson = JSON.stringify(outputs);
-    const pset1 = await (0, toolchain_1.runCommand)(elementsCliPath, [
-        "createpsbt",
-        inputsJson,
-        outputsJson,
-        String(getArtifactLocktime(artifact)),
-        "true",
-    ]);
-    const psetUpdated = await (0, toolchain_1.runCommand)(elementsCliPath, ["utxoupdatepsbt", pset1.stdout]);
+    ];
+    const locktime = getEffectiveLocktime(artifact, input);
+    const pset1 = await callRpc(config, "createpsbt", [inputsJson, outputs, locktime, true], wallet);
+    const psetUpdated = await callRpc(config, "utxoupdatepsbt", [pset1], wallet);
     const contractSpec = `${contractUtxo.scriptPubKey}:${contractUtxo.asset}:${satToBtcStringFromNumber(contractUtxo.sat)}`;
-    const contractUpdated = (await (0, toolchain_1.runHalUpdateInput)(config.toolchain.halSimplicityPath, psetUpdated.stdout, 0, contractSpec, artifact.compiled.cmr, artifact.compiled.internalKey));
+    const contractUpdated = (await (0, toolchain_1.runHalUpdateInput)(config.toolchain.halSimplicityPath, psetUpdated, 0, contractSpec, artifact.compiled.cmr, artifact.compiled.internalKey));
     if (!contractUpdated.pset) {
         throw new errors_1.ExecutionError("update-input did not return a pset", contractUpdated);
     }
-    const decoded = await decodePsbt(elementsCliPath, contractUpdated.pset, input.sponsorWallet);
+    const decoded = await decodePsbt(config, contractUpdated.pset, input.sponsorWallet);
     const summary = buildPsetSummary(decoded, {
         network: artifact.network,
         purpose: "sdk_gasless_execute",
@@ -481,37 +467,26 @@ async function executeGaslessContractCall(config, artifact, input) {
         cmr: artifact.compiled.cmr,
         internalKey: artifact.compiled.internalKey,
         program: artifact.compiled.program,
-        minHeight: getArtifactLocktime(artifact) || undefined,
+        minHeight: locktime || undefined,
         expectedLiquidReceiver: recipientAddress,
     });
     const { canonicalJson: summaryCanonicalJson, hash: summaryHash } = (0, summary_1.summarize)(summary);
     const contractSignedPset = await signContractInput(config, artifact, contractUpdated.pset, input.signer.privkeyHex, input.witness);
-    const sponsorSigned = await (0, toolchain_1.runCommand)(elementsCliPath, [
-        `-rpcwallet=${input.sponsorWallet}`,
-        "walletprocesspsbt",
-        contractSignedPset,
-        "true",
-        "ALL",
-        "true",
-    ]);
-    const sponsorSignedParsed = JSON.parse(sponsorSigned.stdout);
+    const sponsorSignedParsed = await callRpc(config, "walletprocesspsbt", [contractSignedPset, true, "ALL", true], input.sponsorWallet);
     if (!sponsorSignedParsed.psbt) {
         throw new errors_1.ExecutionError("walletprocesspsbt did not return a sponsor-signed pset", sponsorSignedParsed);
     }
-    const finalized = await (0, toolchain_1.runCommand)(elementsCliPath, ["finalizepsbt", sponsorSignedParsed.psbt, "true"]);
-    const finalizedParsed = JSON.parse(finalized.stdout);
+    const finalizedParsed = await callRpc(config, "finalizepsbt", [sponsorSignedParsed.psbt, true]);
     if (!finalizedParsed.complete || !finalizedParsed.hex) {
         throw new errors_1.ExecutionError("PSET was not complete after sponsor signing", finalizedParsed);
     }
     let txId;
     if (input.broadcast) {
-        const mempool = await (0, toolchain_1.runCommand)(elementsCliPath, ["testmempoolaccept", `[\"${finalizedParsed.hex}\"]`]);
-        const mempoolParsed = JSON.parse(mempool.stdout);
+        const mempoolParsed = await callRpc(config, "testmempoolaccept", [[finalizedParsed.hex]], input.sponsorWallet);
         if (!Array.isArray(mempoolParsed) || mempoolParsed[0]?.allowed !== true) {
             throw new errors_1.ExecutionError("testmempoolaccept rejected transaction", mempoolParsed);
         }
-        const sent = await (0, toolchain_1.runCommand)(elementsCliPath, ["sendrawtransaction", finalizedParsed.hex]);
-        txId = sent.stdout.trim();
+        txId = await callRpc(config, "sendrawtransaction", [finalizedParsed.hex], input.sponsorWallet);
     }
     return {
         mode: "gasless-execute",

package/dist/core/outputBinding.d.ts

@@ -0,0 +1,61 @@
+import type { SimplicityClient } from "../client/SimplicityClient";
+import type { BondOutputBindingMode, OutputBindingSupportEvaluation, OutputBindingSupportMatrix, OutputBindingReasonCode, OutputBindingSupportedForm, OutputForm, OutputRawFields } from "./types";
+export declare const OUTPUT_BINDING_SUPPORT_MATRIX: OutputBindingSupportMatrix;
+export declare function describeOutputBindingSupport(): OutputBindingSupportMatrix;
+export declare function normalizeOutputForm(input?: Partial<OutputForm>): OutputForm;
+interface ResolvedOutputRawFields {
+    assetBytesHex: string;
+    amountBytesHex: string;
+    nonceBytesHex: string;
+    scriptPubKeyHashHex: string;
+    rangeProofHashHex: string;
+    scriptComponentSource: "raw-bytes" | "hash";
+    rangeProofComponentSource: "raw-bytes" | "hash";
+}
+export declare function normalizeOutputRawFields(input?: Partial<OutputRawFields>): Partial<OutputRawFields> | undefined;
+export declare function analyzeOutputRawFields(input?: Partial<OutputRawFields>): {
+    provided: boolean;
+    complete: boolean;
+    valid: boolean;
+    normalized?: ResolvedOutputRawFields;
+    missingFields: string[];
+    invalidFields: string[];
+};
+export declare function isExplicitV1OutputForm(input: OutputForm): boolean;
+export declare function isExplicitAssetInputSupported(assetId: string): boolean;
+export declare function resolveOutputBindingMode(requested: BondOutputBindingMode | undefined, nextOutputHash: string | undefined, nextOutputScriptHash: string | undefined): BondOutputBindingMode;
+export declare function hashHexBytes(hex: string): string;
+export declare function computeExplicitV1OutputHash(input: {
+    assetHex: string;
+    nextAmountSat: number;
+    nextOutputScriptHash: string;
+}): string;
+export declare function computeRawOutputV1Hash(input: Partial<OutputRawFields>): string;
+export declare function getScriptPubKeyHexViaRpc(sdk: SimplicityClient, address: string): Promise<string>;
+export declare function resolveExplicitAssetHex(sdk: SimplicityClient, assetId: string): Promise<string | undefined>;
+export declare function resolveOutputBindingDecision(input: {
+    requestedBindingMode?: BondOutputBindingMode;
+    nextOutputHash?: string;
+    nextOutputScriptHash?: string;
+    autoDerivedNextOutputHash?: boolean;
+    explicitAssetSupported: boolean;
+    outputForm?: Partial<OutputForm>;
+    rawOutput?: Partial<OutputRawFields>;
+}): {
+    requestedBindingMode: BondOutputBindingMode;
+    outputBindingMode: BondOutputBindingMode;
+    supportedForm: OutputBindingSupportedForm;
+    reasonCode: OutputBindingReasonCode;
+    autoDerived: boolean;
+    fallbackReason?: string;
+    outputForm: OutputForm;
+};
+export declare function evaluateOutputBindingSupport(input: {
+    assetId: string;
+    requestedBindingMode?: BondOutputBindingMode;
+    outputForm?: Partial<OutputForm>;
+    rawOutput?: Partial<OutputRawFields>;
+    nextOutputHash?: string;
+    nextOutputScriptAvailable?: boolean;
+}): OutputBindingSupportEvaluation;
+export {};