@hazbase/simplicity 0.4.1 → 0.4.2

package/README.md

@@ -164,6 +164,34 @@ testnet issuer or deployment uses a different USDt asset id, set
 payment requirements will preserve that asset id instead of replacing it with
 the SDK's default registry id.
 
+Typical entrypoints:
+- `sdk.rwaDvp.definePurchase(...)`
+- `sdk.rwaDvp.buildPaymentRequirements(...)`
+- `sdk.rwaDvp.verifyPaymentPset(...)`
+- `sdk.rwaDvp.compileEscrowContract(...)`
+- `sdk.rwaDvp.prepareDeliveryClaim(...)`
+- `sdk.rwaDvp.inspectDeliveryClaim(...)`
+- `sdk.rwaDvp.executeDeliveryClaim(...)`
+- `sdk.rwaDvp.prepareRefundClaim(...)`
+- `sdk.rwaDvp.inspectRefundClaim(...)`
+- `sdk.rwaDvp.executeRefundClaim(...)`
+- `sdk.rwaDvp.exportEvidence(...)`
+
+For a delivery claim, the operator spends the funded escrow output and sends
+the payment asset to the treasury while delivering the RWA asset to the buyer.
+For a refund claim, the operator spends the same escrow output after the
+configured timeout and returns the payment asset to the buyer. The inspect
+methods build and validate the candidate spend without broadcasting it; the
+execute methods finalize the Simplicity input, optionally test mempool
+acceptance, and broadcast when `broadcast: true`.
+
+The claim execution helpers assume the Elements wallet can provide any extra
+inputs needed for RWA delivery and L-BTC fees. You can also pass explicit
+`extraInputs` when the service wants deterministic coin selection. Script-bound
+delivery/refund output checks are the practical default; descriptor-bound checks
+should be used only when the caller can provide the exact output data required
+by the descriptor.
+
 ## CLI and Confidence Commands
 
 ### Validation Surface

package/dist/client/SimplicityClient.d.ts

@@ -38,10 +38,15 @@ export declare class SimplicityClient {
         definePurchase: (input: Parameters<typeof rwaDvp.definePurchase>[1]) => ReturnType<typeof rwaDvp.definePurchase>;
         buildPaymentRequirements: (input: Parameters<typeof rwaDvp.buildPaymentRequirements>[1]) => ReturnType<typeof rwaDvp.buildPaymentRequirements>;
         verifyPaymentPset: (input: Parameters<typeof rwaDvp.verifyPaymentPset>[1]) => ReturnType<typeof rwaDvp.verifyPaymentPset>;
+        compileEscrowContract: (input: Parameters<typeof rwaDvp.compileEscrowContract>[1]) => ReturnType<typeof rwaDvp.compileEscrowContract>;
         prepareDeliveryClaim: (input: Parameters<typeof rwaDvp.prepareDeliveryClaim>[1]) => ReturnType<typeof rwaDvp.prepareDeliveryClaim>;
         verifyDeliveryClaim: (input: Parameters<typeof rwaDvp.verifyDeliveryClaim>[1]) => ReturnType<typeof rwaDvp.verifyDeliveryClaim>;
+        inspectDeliveryClaim: (input: Parameters<typeof rwaDvp.inspectDeliveryClaim>[1]) => ReturnType<typeof rwaDvp.inspectDeliveryClaim>;
+        executeDeliveryClaim: (input: Parameters<typeof rwaDvp.executeDeliveryClaim>[1]) => ReturnType<typeof rwaDvp.executeDeliveryClaim>;
         prepareRefundClaim: (input: Parameters<typeof rwaDvp.prepareRefundClaim>[1]) => ReturnType<typeof rwaDvp.prepareRefundClaim>;
         verifyRefundClaim: (input: Parameters<typeof rwaDvp.verifyRefundClaim>[1]) => ReturnType<typeof rwaDvp.verifyRefundClaim>;
+        inspectRefundClaim: (input: Parameters<typeof rwaDvp.inspectRefundClaim>[1]) => ReturnType<typeof rwaDvp.inspectRefundClaim>;
+        executeRefundClaim: (input: Parameters<typeof rwaDvp.executeRefundClaim>[1]) => ReturnType<typeof rwaDvp.executeRefundClaim>;
         exportEvidence: (input: Parameters<typeof rwaDvp.exportEvidence>[1]) => ReturnType<typeof rwaDvp.exportEvidence>;
     };
     readonly policies: {

package/dist/client/SimplicityClient.js

@@ -88,10 +88,15 @@ class SimplicityClient {
             definePurchase: (input) => rwaDvp.definePurchase(this, input),
             buildPaymentRequirements: (input) => rwaDvp.buildPaymentRequirements(this, input),
             verifyPaymentPset: (input) => rwaDvp.verifyPaymentPset(this, input),
+            compileEscrowContract: (input) => rwaDvp.compileEscrowContract(this, input),
             prepareDeliveryClaim: (input) => rwaDvp.prepareDeliveryClaim(this, input),
             verifyDeliveryClaim: (input) => rwaDvp.verifyDeliveryClaim(this, input),
+            inspectDeliveryClaim: (input) => rwaDvp.inspectDeliveryClaim(this, input),
+            executeDeliveryClaim: (input) => rwaDvp.executeDeliveryClaim(this, input),
             prepareRefundClaim: (input) => rwaDvp.prepareRefundClaim(this, input),
             verifyRefundClaim: (input) => rwaDvp.verifyRefundClaim(this, input),
+            inspectRefundClaim: (input) => rwaDvp.inspectRefundClaim(this, input),
+            executeRefundClaim: (input) => rwaDvp.executeRefundClaim(this, input),
             exportEvidence: (input) => rwaDvp.exportEvidence(this, input),
         };
         this.policies = {

package/dist/core/executor.d.ts

@@ -1,5 +1,7 @@
-import { ContractUtxo, ExecuteCallInput, ExecuteResult, GaslessExecuteInput, GaslessExecuteResult, InspectCallInput, InspectResult, SimplicityArtifact, SimplicityClientConfig } from "./types";
+import { ContractUtxo, ExecuteCallInput, ExecuteResult, GaslessExecuteInput, GaslessExecuteResult, InspectCallInput, InspectResult, MultiAssetContractCallInput, MultiAssetExecuteResult, MultiAssetInspectResult, SimplicityArtifact, SimplicityClientConfig } from "./types";
 export declare function inspectContractCall(config: SimplicityClientConfig, artifact: SimplicityArtifact, input: InspectCallInput): Promise<InspectResult>;
 export declare function executeContractCall(config: SimplicityClientConfig, artifact: SimplicityArtifact, input: ExecuteCallInput): Promise<ExecuteResult>;
 export declare function findContractUtxos(config: SimplicityClientConfig, artifact: SimplicityArtifact): Promise<ContractUtxo[]>;
+export declare function inspectMultiAssetContractCall(config: SimplicityClientConfig, artifact: SimplicityArtifact, input: MultiAssetContractCallInput): Promise<MultiAssetInspectResult>;
+export declare function executeMultiAssetContractCall(config: SimplicityClientConfig, artifact: SimplicityArtifact, input: MultiAssetContractCallInput): Promise<MultiAssetExecuteResult>;
 export declare function executeGaslessContractCall(config: SimplicityClientConfig, artifact: SimplicityArtifact, input: GaslessExecuteInput): Promise<GaslessExecuteResult>;

package/dist/core/executor.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.inspectContractCall = inspectContractCall;
 exports.executeContractCall = executeContractCall;
 exports.findContractUtxos = findContractUtxos;
+exports.inspectMultiAssetContractCall = inspectMultiAssetContractCall;
+exports.executeMultiAssetContractCall = executeMultiAssetContractCall;
 exports.executeGaslessContractCall = executeGaslessContractCall;
 const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
@@ -25,6 +27,11 @@ function btcStringToSatNumber(btcStr) {
         throw new errors_1.ValidationError(`Invalid BTC amount: ${btcStr}`);
     return Math.round(x * 1e8);
 }
+function optionalBtcStringToSatNumber(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    return btcStringToSatNumber(String(value));
+}
 function satToBtcNumber(sat) {
     return Number((sat / 1e8).toFixed(8));
 }
@@ -34,6 +41,24 @@ function satToBtcStringFromNumber(sat) {
     const frac = value % 100000000n;
     return `${whole}.${frac.toString().padStart(8, "0")}`;
 }
+function normalizeAssetId(asset) {
+    return asset.trim().toLowerCase();
+}
+function addAssetAmount(target, asset, amountSat) {
+    if (!Number.isSafeInteger(amountSat) || amountSat < 0) {
+        throw new errors_1.ValidationError("amountSat must be a non-negative safe integer");
+    }
+    const key = normalizeAssetId(asset);
+    target.set(key, (target.get(key) ?? 0) + amountSat);
+}
+async function resolveLbtcAssetId(config) {
+    const sidechain = await callRpc(config, "getsidechaininfo", []);
+    const asset = sidechain.pegged_asset;
+    if (asset && /^[0-9a-f]{64}$/i.test(asset)) {
+        return asset.toLowerCase();
+    }
+    return "bitcoin";
+}
 function getArtifactLocktime(artifact) {
     const legacyMinHeight = artifact.legacy?.params?.minHeight;
     if (typeof legacyMinHeight === "number" && Number.isFinite(legacyMinHeight) && legacyMinHeight >= 0) {
@@ -59,21 +84,49 @@ function getEffectiveLocktime(artifact, input) {
     }
     return getArtifactLocktime(artifact);
 }
-function parseSimcWitness(output) {
+function parseSimcWitnessOutput(output) {
     const lines = output
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean);
+    let program;
+    for (const line of lines) {
+        if (line.startsWith("{")) {
+            try {
+                const parsed = JSON.parse(line);
+                if (typeof parsed.witness === "string" && parsed.witness.trim()) {
+                    return {
+                        ...(typeof parsed.program === "string" && parsed.program.trim() ? { program: parsed.program.trim() } : {}),
+                        witness: parsed.witness.trim(),
+                    };
+                }
+            }
+            catch {
+                // Continue with the human-readable simc output format.
+            }
+        }
+    }
+    for (const line of lines) {
+        if (line.startsWith("Program:")) {
+            const rest = line.slice("Program:".length).trim();
+            if (rest)
+                program = rest;
+        }
+    }
+    const programLineIndex = lines.findIndex((line) => line === "Program:");
+    if (!program && programLineIndex >= 0 && lines[programLineIndex + 1]) {
+        program = lines[programLineIndex + 1];
+    }
     for (const line of lines) {
         if (line.startsWith("Witness:")) {
             const rest = line.slice("Witness:".length).trim();
             if (rest)
-                return rest;
+                return { ...(program ? { program } : {}), witness: rest };
         }
     }
     const nextLineIndex = lines.findIndex((line) => line === "Witness:");
     if (nextLineIndex >= 0 && lines[nextLineIndex + 1]) {
-        return lines[nextLineIndex + 1];
+        return { ...(program ? { program } : {}), witness: lines[nextLineIndex + 1] };
     }
     throw new errors_1.ExecutionError("Could not parse Witness from simc output", { output });
 }
@@ -139,7 +192,7 @@ async function scanUtxosByAddress(config, contractAddress) {
         vout: utxo.vout,
         scriptPubKey: utxo.scriptPubKey,
         asset: utxo.asset,
-        sat: btcStringToSatNumber(String(utxo.amount)),
+        sat: optionalBtcStringToSatNumber(utxo.amount) ?? 0,
         height: utxo.height,
         confirmed: true,
     }));
@@ -160,7 +213,7 @@ async function allocateWalletAddress(config, wallet) {
     const address = await callRpc(config, "getnewaddress", [], wallet);
     const info = await getAddressInfo(config, wallet, address);
     return {
-        address: info.unconfidential ?? address,
+        address,
         scriptPubKey: info.scriptPubKey,
     };
 }
@@ -375,6 +428,252 @@ async function executeContractCall(config, artifact, input) {
 async function findContractUtxos(config, artifact) {
     return scanUtxosByAddress(config, artifact.compiled.contractAddress);
 }
+function findRequestedContractUtxo(utxos, input) {
+    if (!input)
+        return null;
+    const requested = utxos.find((utxo) => (utxo.txid === input.txid
+        && (input.vout === undefined || utxo.vout === input.vout))) ?? null;
+    if (!requested)
+        return null;
+    return {
+        ...requested,
+        asset: input.asset ?? requested.asset,
+        sat: input.amountSat ?? requested.sat,
+    };
+}
+function buildMultiAssetBlindingSecrets(input) {
+    const secrets = [];
+    if (input.contractInput?.rawTxHex && input.contractInput.blindingPrivateKey) {
+        secrets.push({
+            index: 0,
+            rawTxHex: input.contractInput.rawTxHex,
+            vout: input.contractInput.vout ?? input.contractUtxo.vout,
+            blindingPrivateKey: input.contractInput.blindingPrivateKey,
+        });
+    }
+    input.extraInputs.forEach((extra, index) => {
+        if (extra.amountBlinder && extra.assetBlinder) {
+            secrets.push({
+                index: index + 1,
+                asset: extra.asset,
+                amountSat: extra.amountSat,
+                amountBlinder: extra.amountBlinder,
+                assetBlinder: extra.assetBlinder,
+            });
+        }
+    });
+    return secrets;
+}
+async function buildMultiAssetExecutionState(config, artifact, input) {
+    await callRpc(config, "getwalletinfo", [], input.wallet);
+    if (input.outputs.length === 0) {
+        throw new errors_1.ValidationError("outputs must contain at least one recipient");
+    }
+    const contractUtxos = await scanUtxosByAddress(config, artifact.compiled.contractAddress);
+    const feeSat = input.feeSat ?? config.defaults?.feeSat ?? DEFAULT_FEE_SAT;
+    const requested = findRequestedContractUtxo(contractUtxos, input.contractInput);
+    const contractUtxo = requested ?? chooseUtxo(contractUtxos, 1, config.defaults?.utxoPolicy ?? "smallest_over");
+    if (!contractUtxo) {
+        throw new errors_1.UtxoNotFoundError(`No contract UTXO found for address=${artifact.compiled.contractAddress}`);
+    }
+    const extraInputs = input.extraInputs ?? [];
+    const inputTotals = new Map();
+    addAssetAmount(inputTotals, contractUtxo.asset, contractUtxo.sat);
+    for (const extra of extraInputs) {
+        addAssetAmount(inputTotals, extra.asset, extra.amountSat);
+    }
+    const lbtcAssetId = await resolveLbtcAssetId(config);
+    const outputTotals = new Map();
+    for (const output of input.outputs) {
+        addAssetAmount(outputTotals, output.asset, output.amountSat);
+    }
+    addAssetAmount(outputTotals, lbtcAssetId, feeSat);
+    const changeOutputs = [];
+    let changeAddress;
+    if (input.changeAddress) {
+        await getAddressInfo(config, input.wallet, input.changeAddress);
+        changeAddress = input.changeAddress;
+    }
+    else {
+        changeAddress = (await allocateWalletAddress(config, input.wallet)).address;
+    }
+    const assetKeys = Array.from(new Set([...inputTotals.keys(), ...outputTotals.keys()])).sort();
+    for (const asset of assetKeys) {
+        const available = inputTotals.get(asset) ?? 0;
+        const required = outputTotals.get(asset) ?? 0;
+        if (available < required) {
+            throw new errors_1.ValidationError("Insufficient inputs for multi-asset contract call", {
+                asset,
+                available,
+                required,
+            });
+        }
+        const changeSat = available - required;
+        if (changeSat > 0) {
+            changeOutputs.push({
+                address: changeAddress,
+                asset,
+                amountSat: changeSat,
+            });
+        }
+    }
+    const inputsJson = [
+        {
+            txid: contractUtxo.txid,
+            vout: contractUtxo.vout,
+            sequence: input.locktimeHeight ? DEFAULT_SEQUENCE : DEFAULT_SEQUENCE,
+        },
+        ...extraInputs.map((extra) => ({
+            txid: extra.txid,
+            vout: extra.vout,
+            sequence: extra.sequence ?? DEFAULT_SEQUENCE,
+        })),
+    ];
+    const inputAssets = [contractUtxo.asset, ...extraInputs.map((extra) => extra.asset)];
+    const blinderIndexFor = (asset) => {
+        const normalized = normalizeAssetId(asset);
+        const extraIndex = extraInputs.findIndex((input) => normalizeAssetId(input.asset) === normalized);
+        if (extraIndex >= 0)
+            return extraIndex + 1;
+        const index = inputAssets.findIndex((inputAsset) => normalizeAssetId(inputAsset) === normalized);
+        return index >= 0 ? index : undefined;
+    };
+    const psetOutputs = await Promise.all([...input.outputs, ...changeOutputs].map(async (output) => {
+        await getAddressInfo(config, input.wallet, output.address);
+        return output;
+    }));
+    const outputsJson = [
+        ...psetOutputs.map((output) => ({
+            [output.address]: satToBtcNumber(output.amountSat),
+            asset: output.asset,
+        })),
+        { fee: satToBtcNumber(feeSat) },
+    ];
+    const halOutputsJson = [
+        ...psetOutputs.map((output) => ({
+            address: output.address,
+            asset: output.asset,
+            amount: satToBtcNumber(output.amountSat),
+            blinderIndex: blinderIndexFor(output.asset),
+        })),
+        {
+            address: "fee",
+            asset: lbtcAssetId,
+            amount: satToBtcNumber(feeSat),
+        },
+    ];
+    const locktime = getEffectiveLocktime(artifact, input);
+    const createResult = locktime
+        ? {
+            pset: await callRpc(config, "createpsbt", [inputsJson, outputsJson, locktime, true], input.wallet),
+        }
+        : (await (0, toolchain_1.runSimplicityCreatePset)(config.toolchain.halSimplicityPath, inputsJson, halOutputsJson));
+    const pset1 = createResult.pset;
+    if (!pset1) {
+        throw new errors_1.ExecutionError("pset create did not return a pset", createResult);
+    }
+    const contractSpec = `${contractUtxo.scriptPubKey}:${contractUtxo.asset}:${satToBtcStringFromNumber(contractUtxo.sat)}`;
+    const psetWithUtxos = await callRpc(config, "utxoupdatepsbt", [pset1], input.wallet);
+    const contractUpdated = (await (0, toolchain_1.runSimplicityUpdateInput)(config.toolchain.halSimplicityPath, psetWithUtxos, 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 psetUpdated = await callRpc(config, "utxoupdatepsbt", [contractUpdated.pset], input.wallet);
+    const decoded = await decodePsbt(config, psetUpdated, input.wallet);
+    const summary = buildPsetSummary(decoded, {
+        network: artifact.network,
+        purpose: input.purpose ?? "sdk_multi_asset_contract_call",
+        bondDefinitionId: null,
+        definitionType: artifact.definition?.definitionType,
+        definitionId: artifact.definition?.definitionId,
+        definitionHash: artifact.definition?.hash,
+        definitionTrustMode: artifact.definition?.trustMode,
+        definitionAnchorMode: artifact.definition?.anchorMode,
+        stateType: artifact.state?.stateType,
+        stateId: artifact.state?.stateId,
+        stateHash: artifact.state?.hash,
+        stateTrustMode: artifact.state?.trustMode,
+        stateAnchorMode: artifact.state?.anchorMode,
+        expectedLiquidReceiver: input.outputs[0]?.address,
+        contractAddress: artifact.compiled.contractAddress,
+        cmr: artifact.compiled.cmr,
+        internalKey: artifact.compiled.internalKey,
+        program: artifact.compiled.program,
+        minHeight: locktime || undefined,
+    });
+    const { canonicalJson: summaryCanonicalJson, hash: summaryHash } = (0, summary_1.summarize)(summary);
+    return {
+        psetBase64: psetUpdated,
+        summary,
+        summaryHash,
+        summaryCanonicalJson,
+        contractUtxo,
+        extraInputs,
+        requestedOutputs: psetOutputs,
+        changeOutputs,
+    };
+}
+async function inspectMultiAssetContractCall(config, artifact, input) {
+    const state = await buildMultiAssetExecutionState(config, artifact, input);
+    return {
+        mode: "inspect",
+        summary: state.summary,
+        summaryHash: state.summaryHash,
+        summaryCanonicalJson: state.summaryCanonicalJson,
+        psetBase64: state.psetBase64,
+        contractUtxo: state.contractUtxo,
+        warnings: [],
+        extraInputs: state.extraInputs,
+        requestedOutputs: state.requestedOutputs,
+        changeOutputs: state.changeOutputs,
+    };
+}
+async function executeMultiAssetContractCall(config, artifact, input) {
+    const state = await buildMultiAssetExecutionState(config, artifact, input);
+    const blindingSecrets = buildMultiAssetBlindingSecrets({
+        contractInput: input.contractInput,
+        contractUtxo: state.contractUtxo,
+        extraInputs: state.extraInputs,
+    });
+    const blindedPset = blindingSecrets.length > 0
+        ? (await (0, toolchain_1.runSimplicityBlindPset)(state.psetBase64, blindingSecrets))
+        : { pset: state.psetBase64 };
+    if (!blindedPset.pset) {
+        throw new errors_1.ExecutionError(`blind PSET did not return a pset${blindedPset.error ? `: ${blindedPset.error}` : ""}`, blindedPset);
+    }
+    const contractSignedPset = await signContractInput(config, artifact, blindedPset.pset, input.signer.privkeyHex, input.witness);
+    const walletSignedParsed = await callRpc(config, "walletprocesspsbt", [contractSignedPset, true, "ALL", true], input.wallet);
+    if (!walletSignedParsed.psbt) {
+        throw new errors_1.ExecutionError("walletprocesspsbt did not return a signed pset", walletSignedParsed);
+    }
+    const finalizedParsed = await callRpc(config, "finalizepsbt", [walletSignedParsed.psbt, true]);
+    if (!finalizedParsed.complete || !finalizedParsed.hex) {
+        throw new errors_1.ExecutionError("PSET was not complete after wallet signing", finalizedParsed);
+    }
+    const rawTxHex = normalizeRawTx(finalizedParsed.hex);
+    let txId;
+    if (input.broadcast) {
+        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);
+        }
+        txId = await callRpc(config, "sendrawtransaction", [rawTxHex], input.wallet);
+    }
+    return {
+        mode: "execute",
+        summary: state.summary,
+        summaryHash: state.summaryHash,
+        summaryCanonicalJson: state.summaryCanonicalJson,
+        psetBase64: walletSignedParsed.psbt,
+        rawTxHex,
+        txId,
+        broadcasted: Boolean(input.broadcast),
+        contractUtxo: state.contractUtxo,
+        extraInputs: state.extraInputs,
+        requestedOutputs: state.requestedOutputs,
+        changeOutputs: state.changeOutputs,
+    };
+}
 async function executeGaslessContractCall(config, artifact, input) {
     if (input.relayer) {
         return executeRelayedGaslessContractCall(config, artifact, input, input.relayer);
@@ -520,10 +819,10 @@ async function signContractInput(config, artifact, psetBase64, privkeyHex, witne
     const simfRenderedPath = node_path_1.default.join(workDir, "program.simf");
     await (0, promises_1.writeFile)(simfRenderedPath, simfRendered, "utf8");
     const witnessOutput = await (0, toolchain_1.runSimcWithWitness)(config.toolchain.simcPath, simfRenderedPath, witnessPath);
-    const witness = parseSimcWitness(witnessOutput);
-    const contractFinalized = (await (0, toolchain_1.runHalFinalize)(config.toolchain.halSimplicityPath, psetBase64, 0, artifact.compiled.program, witness));
+    const simc = parseSimcWitnessOutput(witnessOutput);
+    const contractFinalized = (await (0, toolchain_1.runSimplicityFinalize)(config.toolchain.halSimplicityPath, psetBase64, 0, artifact.compiled.program, simc.witness, { ...(simc.program ? { redeemProgram: simc.program } : {}) }));
     if (!contractFinalized.pset) {
-        throw new errors_1.ExecutionError("finalize did not return a pset", contractFinalized);
+        throw new errors_1.ExecutionError(`finalize did not return a pset${contractFinalized.error ? `: ${contractFinalized.error}` : ""}`, contractFinalized);
     }
     return contractFinalized.pset;
 }

package/dist/core/rpc.js

@@ -26,7 +26,9 @@ class ElementsRpcClient {
         });
         const payload = (await response.json());
         if (!response.ok || payload.error) {
-            throw new errors_1.ExecutionError(`RPC ${method} failed`, {
+            const rpcMessage = payload.error?.message ? `: ${payload.error.message}` : "";
+            const rpcCode = payload.error?.code === undefined ? "" : ` (code ${payload.error.code})`;
+            throw new errors_1.ExecutionError(`RPC ${method} failed${rpcCode}${rpcMessage}`, {
                 status: response.status,
                 error: payload.error,
             });

package/dist/core/toolchain.d.ts

@@ -9,6 +9,30 @@ export declare function runSimcCompile(simcPath: string, simfPath: string): Prom
 export declare function runSimcWithWitness(simcPath: string, simfPath: string, witnessPath: string): Promise<string>;
 export declare function runHalInfo(halPath: string, program: string): Promise<unknown>;
 export declare function runHalUpdateInput(halPath: string, pset: string, inputIndex: number, utxoSpec: string, cmr: string, internalKey: string): Promise<unknown>;
+export declare function runHalCreatePset(halPath: string, inputs: Array<{
+    txid: string;
+    vout: number;
+    sequence?: number;
+}>, outputs: Array<{
+    address: string;
+    asset: string;
+    amount: number;
+}>): Promise<unknown>;
+export declare function runSimplicityCreatePset(halPath: string, inputs: Array<{
+    txid: string;
+    vout: number;
+    sequence?: number;
+}>, outputs: Array<{
+    address: string;
+    asset: string;
+    amount: number;
+    blinderIndex?: number;
+}>): Promise<unknown>;
+export declare function runSimplicityUpdateInput(halPath: string, pset: string, inputIndex: number, inputUtxo: string, cmr: string, internalKey: string): Promise<unknown>;
+export declare function runSimplicityBlindPset(pset: string, inputSecrets: Array<Record<string, unknown>>): Promise<unknown>;
 export declare function runHalSighash(halPath: string, pset: string, inputIndex: number, cmr: string, privkeyHex: string): Promise<unknown>;
 export declare function runHalFinalize(halPath: string, pset: string, inputIndex: number, program: string, witness: string): Promise<unknown>;
+export declare function runSimplicityFinalize(halPath: string, pset: string, inputIndex: number, program: string, witness: string, options?: {
+    redeemProgram?: string;
+}): Promise<unknown>;
 export declare function runHalExtract(halPath: string, pset: string): Promise<string>;

package/dist/core/toolchain.js

@@ -5,8 +5,13 @@ exports.runSimcCompile = runSimcCompile;
 exports.runSimcWithWitness = runSimcWithWitness;
 exports.runHalInfo = runHalInfo;
 exports.runHalUpdateInput = runHalUpdateInput;
+exports.runHalCreatePset = runHalCreatePset;
+exports.runSimplicityCreatePset = runSimplicityCreatePset;
+exports.runSimplicityUpdateInput = runSimplicityUpdateInput;
+exports.runSimplicityBlindPset = runSimplicityBlindPset;
 exports.runHalSighash = runHalSighash;
 exports.runHalFinalize = runHalFinalize;
+exports.runSimplicityFinalize = runSimplicityFinalize;
 exports.runHalExtract = runHalExtract;
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
@@ -21,7 +26,13 @@ async function runCommand(command, args, options = {}) {
         return { stdout: stdout.trim(), stderr: stderr.trim() };
     }
     catch (error) {
-        throw new errors_1.ToolchainError(`Command failed: ${command} ${args.join(" ")}`, error);
+        const cause = error;
+        const details = [
+            cause.message ? `message=${cause.message}` : "",
+            cause.stderr ? `stderr=${cause.stderr.trim()}` : "",
+            cause.stdout ? `stdout=${cause.stdout.trim()}` : "",
+        ].filter(Boolean);
+        throw new errors_1.ToolchainError(`Command failed: ${command} ${args.slice(0, 3).join(" ")}${details.length ? ` | ${details.join(" | ")}` : ""}`, error);
     }
 }
 async function runSimcCompile(simcPath, simfPath) {
@@ -41,6 +52,7 @@ async function runHalUpdateInput(halPath, pset, inputIndex, utxoSpec, cmr, inter
         "simplicity",
         "pset",
         "update-input",
+        "--liquid",
         pset,
         String(inputIndex),
         "-i",
@@ -52,10 +64,73 @@ async function runHalUpdateInput(halPath, pset, inputIndex, utxoSpec, cmr, inter
     ]);
     return JSON.parse(result.stdout);
 }
+async function runHalCreatePset(halPath, inputs, outputs) {
+    const result = await runCommand(halPath, [
+        "simplicity",
+        "pset",
+        "create",
+        "--liquid",
+        JSON.stringify(inputs),
+        JSON.stringify(outputs),
+    ]);
+    return JSON.parse(result.stdout);
+}
+async function runSimplicityCreatePset(halPath, inputs, outputs) {
+    const helperPath = process.env.HAZBASE_SIMPLICITY_CREATE_PATH ?? "hazbase-simplicity-create";
+    try {
+        const helper = await runCommand(helperPath, [
+            "--liquid",
+            JSON.stringify(inputs),
+            JSON.stringify(outputs),
+        ]);
+        return JSON.parse(helper.stdout);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("ENOENT")) {
+            return {
+                error: message,
+            };
+        }
+    }
+    return runHalCreatePset(halPath, inputs, outputs);
+}
+async function runSimplicityUpdateInput(halPath, pset, inputIndex, inputUtxo, cmr, internalKey) {
+    const helperPath = process.env.HAZBASE_SIMPLICITY_UPDATE_INPUT_PATH ?? "hazbase-simplicity-update-input";
+    try {
+        const helper = await runCommand(helperPath, [
+            "--liquid",
+            pset,
+            String(inputIndex),
+            internalKey,
+            cmr,
+        ]);
+        return JSON.parse(helper.stdout);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("ENOENT")) {
+            return {
+                error: message,
+            };
+        }
+    }
+    return runHalUpdateInput(halPath, pset, inputIndex, inputUtxo, cmr, internalKey);
+}
+async function runSimplicityBlindPset(pset, inputSecrets) {
+    const helperPath = process.env.HAZBASE_SIMPLICITY_BLIND_PSET_PATH ?? "hazbase-simplicity-blind-pset";
+    const helper = await runCommand(helperPath, [
+        "--liquid",
+        pset,
+        JSON.stringify(inputSecrets),
+    ]);
+    return JSON.parse(helper.stdout);
+}
 async function runHalSighash(halPath, pset, inputIndex, cmr, privkeyHex) {
     const result = await runCommand(halPath, [
         "simplicity",
         "sighash",
+        "--liquid",
         pset,
         String(inputIndex),
         cmr,
@@ -69,6 +144,7 @@ async function runHalFinalize(halPath, pset, inputIndex, program, witness) {
         "simplicity",
         "pset",
         "finalize",
+        "--liquid",
         pset,
         String(inputIndex),
         program,
@@ -76,7 +152,35 @@ async function runHalFinalize(halPath, pset, inputIndex, program, witness) {
     ]);
     return JSON.parse(result.stdout);
 }
+async function runSimplicityFinalize(halPath, pset, inputIndex, program, witness, options = {}) {
+    const helperPath = process.env.HAZBASE_SIMPLICITY_FINALIZE_PATH ?? "hazbase-simplicity-finalize";
+    if (options.redeemProgram) {
+        try {
+            const helper = await runCommand(helperPath, [
+                "--liquid",
+                pset,
+                String(inputIndex),
+                options.redeemProgram,
+                witness,
+            ]);
+            return JSON.parse(helper.stdout);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes("ENOENT")) {
+                const halFallback = await runHalFinalize(halPath, pset, inputIndex, program, witness);
+                if (halFallback.pset)
+                    return halFallback;
+                return {
+                    ...halFallback,
+                    helperError: message,
+                };
+            }
+        }
+    }
+    return runHalFinalize(halPath, pset, inputIndex, program, witness);
+}
 async function runHalExtract(halPath, pset) {
-    const result = await runCommand(halPath, ["simplicity", "pset", "extract", pset]);
+    const result = await runCommand(halPath, ["simplicity", "pset", "extract", "--liquid", pset]);
     return result.stdout;
 }