@hazbase/simplicity 0.0.4 → 0.1.1

package/dist/client/SimplicityClient.d.ts

@@ -1,40 +1,79 @@
+import { evaluateOutputBindingSupport } from "../core/outputBinding";
 import { ElementsRpcClient } from "../core/rpc";
-import { BondDefinition, BondIssuanceState, DefinitionInput, DefinitionVerificationResult, CompileFromFileInput, CompileFromPresetInput, DefinitionDescriptor, StateDocumentDescriptor, StateDocumentInput, StateVerificationResult, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+import { BondEvidenceBundle, OutputBindingSupportEvaluation, OutputBindingSupportMatrix, PolicyEvidenceBundle, PolicyTemplateManifestValidationResult, DefinitionInput, DefinitionVerificationResult, CompileFromFileInput, CompileFromPresetInput, DefinitionDescriptor, StateDocumentDescriptor, StateDocumentInput, StateVerificationResult, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
 import { RelayerClient } from "../gasless/RelayerClient";
 import { GaslessTransferInput, GaslessTransferResult, RelayerClientConfig } from "../gasless/types";
 import { CompiledContract } from "./ContractFactory";
 import { DeployedContract } from "./DeployedContract";
-import { loadBond, verifyBond } from "../domain/bond";
+import { prepareRedemption, prepareClosing, exportFinalityPayload, buildSettlement, verifySettlement, define, executeClosing, executeRedemption, exportEvidence, inspectClosing, inspectRedemption, issue, load, verify, verifyClosing, verifyRedemption } from "../domain/bond";
+import { define as defineFund, verify as verifyFund, load as loadFund, prepareCapitalCall, inspectCapitalCallClaim, executeCapitalCallClaim, inspectCapitalCallRollover, executeCapitalCallRollover, inspectCapitalCallRefund, executeCapitalCallRefund, verifyCapitalCall, signPositionReceipt, verifyPositionReceipt, prepareDistribution, reconcilePosition, inspectDistributionClaim, executeDistributionClaim, verifyDistribution, prepareClosing as prepareFundClosing, verifyClosing as verifyFundClosing, exportEvidence as exportFundEvidence, exportFinalityPayload as exportFundFinalityPayload } from "../domain/fund";
+import { buildPolicyOutputDescriptor, describePolicyTemplate, listPolicyTemplates, loadPolicyTemplateManifest, executeTransfer as executePolicyTransfer, exportEvidence as exportPolicyEvidence, inspectTransfer as inspectPolicyTransfer, issue as issuePolicy, prepareTransfer as preparePolicyTransfer, validatePolicyTemplateManifest, validatePolicyTemplateParams, verifyState as verifyPolicyState, verifyTransfer as verifyPolicyTransfer } from "../domain/policies";
 export declare class SimplicityClient {
     readonly config: SimplicityClientConfig;
     readonly rpc: ElementsRpcClient;
     readonly payments: {
         gaslessTransfer: (input: GaslessTransferInput) => Promise<GaslessTransferResult>;
     };
+    readonly outputBinding: {
+        describeSupport: () => OutputBindingSupportMatrix;
+        evaluateSupport: (input: Parameters<typeof evaluateOutputBindingSupport>[0]) => OutputBindingSupportEvaluation;
+    };
+    readonly policies: {
+        listTemplates: () => ReturnType<typeof listPolicyTemplates>;
+        describeTemplate: (input: Parameters<typeof describePolicyTemplate>[0]) => ReturnType<typeof describePolicyTemplate>;
+        loadTemplateManifest: (input: Parameters<typeof loadPolicyTemplateManifest>[0]) => ReturnType<typeof loadPolicyTemplateManifest>;
+        validateTemplateManifest: (input: Parameters<typeof validatePolicyTemplateManifest>[0]) => PolicyTemplateManifestValidationResult;
+        validateTemplateParams: (input: Parameters<typeof validatePolicyTemplateParams>[0]) => ReturnType<typeof validatePolicyTemplateParams>;
+        buildOutputDescriptor: (input: Parameters<typeof buildPolicyOutputDescriptor>[1]) => ReturnType<typeof buildPolicyOutputDescriptor>;
+        issue: (input: Parameters<typeof issuePolicy>[1]) => ReturnType<typeof issuePolicy>;
+        prepareTransfer: (input: Parameters<typeof preparePolicyTransfer>[1]) => ReturnType<typeof preparePolicyTransfer>;
+        inspectTransfer: (input: Parameters<typeof inspectPolicyTransfer>[1]) => ReturnType<typeof inspectPolicyTransfer>;
+        executeTransfer: (input: Parameters<typeof executePolicyTransfer>[1]) => ReturnType<typeof executePolicyTransfer>;
+        verifyState: (input: Parameters<typeof verifyPolicyState>[1]) => ReturnType<typeof verifyPolicyState>;
+        verifyTransfer: (input: Parameters<typeof verifyPolicyTransfer>[1]) => ReturnType<typeof verifyPolicyTransfer>;
+        exportEvidence: (input: Parameters<typeof exportPolicyEvidence>[1]) => Promise<PolicyEvidenceBundle>;
+    };
     readonly bonds: {
-        defineBond: (input: {
-            definitionPath?: string;
-            definitionValue?: BondDefinition;
-            issuancePath?: string;
-            issuanceValue?: BondIssuanceState;
-            simfPath?: string;
-            artifactPath?: string;
-        }) => Promise<CompiledContract>;
-        verifyBond: (input: {
-            artifactPath?: string;
-            artifact?: SimplicityArtifact;
-            definitionPath?: string;
-            definitionValue?: BondDefinition;
-            issuancePath?: string;
-            issuanceValue?: BondIssuanceState;
-        }) => ReturnType<typeof verifyBond>;
-        loadBond: (input: {
-            artifactPath: string;
-            definitionPath?: string;
-            definitionValue?: BondDefinition;
-            issuancePath?: string;
-            issuanceValue?: BondIssuanceState;
-        }) => ReturnType<typeof loadBond>;
+        define: (input: Parameters<typeof define>[1]) => ReturnType<typeof define>;
+        verify: (input: Parameters<typeof verify>[1]) => ReturnType<typeof verify>;
+        load: (input: Parameters<typeof load>[1]) => ReturnType<typeof load>;
+        issue: (input: Parameters<typeof issue>[1]) => ReturnType<typeof issue>;
+        prepareRedemption: (input: Parameters<typeof prepareRedemption>[1]) => ReturnType<typeof prepareRedemption>;
+        inspectRedemption: (input: Parameters<typeof inspectRedemption>[1]) => ReturnType<typeof inspectRedemption>;
+        executeRedemption: (input: Parameters<typeof executeRedemption>[1]) => ReturnType<typeof executeRedemption>;
+        verifyRedemption: (input: Parameters<typeof verifyRedemption>[1]) => ReturnType<typeof verifyRedemption>;
+        buildSettlement: (input: Parameters<typeof buildSettlement>[1]) => ReturnType<typeof buildSettlement>;
+        verifySettlement: (input: Parameters<typeof verifySettlement>[1]) => ReturnType<typeof verifySettlement>;
+        prepareClosing: (input: Parameters<typeof prepareClosing>[1]) => ReturnType<typeof prepareClosing>;
+        inspectClosing: (input: Parameters<typeof inspectClosing>[1]) => ReturnType<typeof inspectClosing>;
+        executeClosing: (input: Parameters<typeof executeClosing>[1]) => ReturnType<typeof executeClosing>;
+        verifyClosing: (input: Parameters<typeof verifyClosing>[1]) => ReturnType<typeof verifyClosing>;
+        exportEvidence: (input: Parameters<typeof exportEvidence>[1]) => Promise<BondEvidenceBundle>;
+        exportFinalityPayload: (input: Parameters<typeof exportFinalityPayload>[1]) => ReturnType<typeof exportFinalityPayload>;
+    };
+    readonly funds: {
+        define: (input: Parameters<typeof defineFund>[1]) => ReturnType<typeof defineFund>;
+        verify: (input: Parameters<typeof verifyFund>[1]) => ReturnType<typeof verifyFund>;
+        load: (input: Parameters<typeof loadFund>[1]) => ReturnType<typeof loadFund>;
+        prepareCapitalCall: (input: Parameters<typeof prepareCapitalCall>[1]) => ReturnType<typeof prepareCapitalCall>;
+        inspectCapitalCallClaim: (input: Parameters<typeof inspectCapitalCallClaim>[1]) => ReturnType<typeof inspectCapitalCallClaim>;
+        executeCapitalCallClaim: (input: Parameters<typeof executeCapitalCallClaim>[1]) => ReturnType<typeof executeCapitalCallClaim>;
+        inspectCapitalCallRollover: (input: Parameters<typeof inspectCapitalCallRollover>[1]) => ReturnType<typeof inspectCapitalCallRollover>;
+        executeCapitalCallRollover: (input: Parameters<typeof executeCapitalCallRollover>[1]) => ReturnType<typeof executeCapitalCallRollover>;
+        inspectCapitalCallRefund: (input: Parameters<typeof inspectCapitalCallRefund>[1]) => ReturnType<typeof inspectCapitalCallRefund>;
+        executeCapitalCallRefund: (input: Parameters<typeof executeCapitalCallRefund>[1]) => ReturnType<typeof executeCapitalCallRefund>;
+        verifyCapitalCall: (input: Parameters<typeof verifyCapitalCall>[1]) => ReturnType<typeof verifyCapitalCall>;
+        signPositionReceipt: (input: Parameters<typeof signPositionReceipt>[1]) => ReturnType<typeof signPositionReceipt>;
+        verifyPositionReceipt: (input: Parameters<typeof verifyPositionReceipt>[1]) => ReturnType<typeof verifyPositionReceipt>;
+        prepareDistribution: (input: Parameters<typeof prepareDistribution>[1]) => ReturnType<typeof prepareDistribution>;
+        reconcilePosition: (input: Parameters<typeof reconcilePosition>[1]) => ReturnType<typeof reconcilePosition>;
+        inspectDistributionClaim: (input: Parameters<typeof inspectDistributionClaim>[1]) => ReturnType<typeof inspectDistributionClaim>;
+        executeDistributionClaim: (input: Parameters<typeof executeDistributionClaim>[1]) => ReturnType<typeof executeDistributionClaim>;
+        verifyDistribution: (input: Parameters<typeof verifyDistribution>[1]) => ReturnType<typeof verifyDistribution>;
+        prepareClosing: (input: Parameters<typeof prepareFundClosing>[1]) => ReturnType<typeof prepareFundClosing>;
+        verifyClosing: (input: Parameters<typeof verifyFundClosing>[1]) => ReturnType<typeof verifyFundClosing>;
+        exportEvidence: (input: Parameters<typeof exportFundEvidence>[1]) => ReturnType<typeof exportFundEvidence>;
+        exportFinalityPayload: (input: Parameters<typeof exportFundFinalityPayload>[1]) => ReturnType<typeof exportFundFinalityPayload>;
     };
     constructor(config: SimplicityClientConfig);
     compileFromFile(input: CompileFromFileInput): Promise<CompiledContract>;

package/dist/client/SimplicityClient.js

@@ -7,26 +7,88 @@ const compiler_1 = require("../core/compiler");
 const definition_1 = require("../core/definition");
 const state_1 = require("../core/state");
 const errors_1 = require("../core/errors");
+const outputBinding_1 = require("../core/outputBinding");
 const rpc_1 = require("../core/rpc");
 const RelayerClient_1 = require("../gasless/RelayerClient");
 const ContractFactory_1 = require("./ContractFactory");
 const DeployedContract_1 = require("./DeployedContract");
 const bond_1 = require("../domain/bond");
+const fund_1 = require("../domain/fund");
+const policies_1 = require("../domain/policies");
 class SimplicityClient {
     config;
     rpc;
     payments;
+    outputBinding;
+    policies;
     bonds;
+    funds;
     constructor(config) {
         this.config = config;
         this.rpc = new rpc_1.ElementsRpcClient(config.rpc);
         this.payments = {
             gaslessTransfer: async (input) => this.gaslessTransfer(input),
         };
+        this.outputBinding = {
+            describeSupport: () => (0, outputBinding_1.describeOutputBindingSupport)(),
+            evaluateSupport: (input) => (0, outputBinding_1.evaluateOutputBindingSupport)(input),
+        };
+        this.policies = {
+            listTemplates: () => (0, policies_1.listPolicyTemplates)(),
+            describeTemplate: (input) => (0, policies_1.describePolicyTemplate)(input),
+            loadTemplateManifest: async (input) => (0, policies_1.loadPolicyTemplateManifest)(input),
+            validateTemplateManifest: (input) => (0, policies_1.validatePolicyTemplateManifest)(input),
+            validateTemplateParams: (input) => (0, policies_1.validatePolicyTemplateParams)(input),
+            buildOutputDescriptor: async (input) => (0, policies_1.buildPolicyOutputDescriptor)(this, input),
+            issue: async (input) => (0, policies_1.issue)(this, input),
+            prepareTransfer: async (input) => (0, policies_1.prepareTransfer)(this, input),
+            inspectTransfer: async (input) => (0, policies_1.inspectTransfer)(this, input),
+            executeTransfer: async (input) => (0, policies_1.executeTransfer)(this, input),
+            verifyState: async (input) => (0, policies_1.verifyState)(this, input),
+            verifyTransfer: async (input) => (0, policies_1.verifyTransfer)(this, input),
+            exportEvidence: async (input) => (0, policies_1.exportEvidence)(this, input),
+        };
         this.bonds = {
-            defineBond: async (input) => (0, bond_1.defineBond)(this, input),
-            verifyBond: async (input) => (0, bond_1.verifyBond)(this, input),
-            loadBond: async (input) => (0, bond_1.loadBond)(this, input),
+            define: async (input) => (0, bond_1.define)(this, input),
+            verify: async (input) => (0, bond_1.verify)(this, input),
+            load: async (input) => (0, bond_1.load)(this, input),
+            issue: async (input) => (0, bond_1.issue)(this, input),
+            prepareRedemption: async (input) => (0, bond_1.prepareRedemption)(this, input),
+            inspectRedemption: async (input) => (0, bond_1.inspectRedemption)(this, input),
+            executeRedemption: async (input) => (0, bond_1.executeRedemption)(this, input),
+            verifyRedemption: async (input) => (0, bond_1.verifyRedemption)(this, input),
+            buildSettlement: async (input) => (0, bond_1.buildSettlement)(this, input),
+            verifySettlement: async (input) => (0, bond_1.verifySettlement)(this, input),
+            prepareClosing: async (input) => (0, bond_1.prepareClosing)(this, input),
+            inspectClosing: async (input) => (0, bond_1.inspectClosing)(this, input),
+            executeClosing: async (input) => (0, bond_1.executeClosing)(this, input),
+            verifyClosing: async (input) => (0, bond_1.verifyClosing)(this, input),
+            exportEvidence: async (input) => (0, bond_1.exportEvidence)(this, input),
+            exportFinalityPayload: async (input) => (0, bond_1.exportFinalityPayload)(this, input),
+        };
+        this.funds = {
+            define: async (input) => (0, fund_1.define)(this, input),
+            verify: async (input) => (0, fund_1.verify)(this, input),
+            load: async (input) => (0, fund_1.load)(this, input),
+            prepareCapitalCall: async (input) => (0, fund_1.prepareCapitalCall)(this, input),
+            inspectCapitalCallClaim: async (input) => (0, fund_1.inspectCapitalCallClaim)(this, input),
+            executeCapitalCallClaim: async (input) => (0, fund_1.executeCapitalCallClaim)(this, input),
+            inspectCapitalCallRollover: async (input) => (0, fund_1.inspectCapitalCallRollover)(this, input),
+            executeCapitalCallRollover: async (input) => (0, fund_1.executeCapitalCallRollover)(this, input),
+            inspectCapitalCallRefund: async (input) => (0, fund_1.inspectCapitalCallRefund)(this, input),
+            executeCapitalCallRefund: async (input) => (0, fund_1.executeCapitalCallRefund)(this, input),
+            verifyCapitalCall: async (input) => (0, fund_1.verifyCapitalCall)(this, input),
+            signPositionReceipt: async (input) => (0, fund_1.signPositionReceipt)(this, input),
+            verifyPositionReceipt: async (input) => (0, fund_1.verifyPositionReceipt)(this, input),
+            prepareDistribution: async (input) => (0, fund_1.prepareDistribution)(this, input),
+            reconcilePosition: async (input) => (0, fund_1.reconcilePosition)(this, input),
+            inspectDistributionClaim: async (input) => (0, fund_1.inspectDistributionClaim)(this, input),
+            executeDistributionClaim: async (input) => (0, fund_1.executeDistributionClaim)(this, input),
+            verifyDistribution: async (input) => (0, fund_1.verifyDistribution)(this, input),
+            prepareClosing: async (input) => (0, fund_1.prepareClosing)(this, input),
+            verifyClosing: async (input) => (0, fund_1.verifyClosing)(this, input),
+            exportEvidence: async (input) => (0, fund_1.exportEvidence)(this, input),
+            exportFinalityPayload: async (input) => (0, fund_1.exportFinalityPayload)(this, input),
         };
     }
     async compileFromFile(input) {

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 {};