@hazbase/simplicity 0.4.1 → 0.4.3

package/README.md

@@ -20,20 +20,25 @@ With the current public SDK you can build and test:
 - bond redemption / settlement / close-out flows
 - LP fund capital call / distribution / close-out flows
 - receivable repayment-first funding / partial repayment / closing flows
+- RWA delivery-versus-payment flows over Liquid PSETs and Liquid x402
+- atomic Liquid DvP proposals where service delivery and buyer payment settle in one PSET
 - evidence, trust summary, lineage, and finality exports
 
 ## Public Architecture
 
-The public SDK is organized into five layers:
+The public SDK is organized into domain clients and lower-level payment helpers:
 - `sdk.outputBinding`: shared output-binding support, evaluation, and fallback behavior
 - `sdk.policies`: generic constrained transfer and recursive policy engine
 - `sdk.bonds`: private bond / credit settlement business layer
 - `sdk.funds`: LP fund settlement business layer
 - `sdk.receivables`: repayment-first receivable business layer
+- `sdk.rwaDvp`: RWA purchase terms, payment requirements, claim descriptors, and evidence
+- `sdk.payments.x402`: Liquid x402 assets, PSET payment helpers, verification, and settlement
 
 A useful mental model is:
 - `sdk.outputBinding` + `sdk.policies` provide the shared settlement kernel
-- `sdk.bonds`, `sdk.funds`, and `sdk.receivables` build domain flows on top of that kernel
+- `sdk.bonds`, `sdk.funds`, `sdk.receivables`, and `sdk.rwaDvp` build domain flows on top of that kernel
+- `sdk.payments.x402` and the root-level `x402` exports provide the Liquid PSET payment layer used by those flows
 
 ## Quickstart
 
@@ -158,12 +163,121 @@ Use `sdk.rwaDvp` when a purchase flow needs a Liquid PSET payment request,
 delivery/refund claim descriptors, and an evidence bundle that ties the Liquid
 payment and delivery to an external lock or allocation record.
 
+The EVM-side lock reference can describe the source asset being held for
+settlement. Set `evmLock.tokenStandard` to `"ERC3475"`, `"ERC20"`, `"ERC721"`,
+or `"ERC1155"` and include the token address / id fields used by your lock
+manager. Existing callers that omit `tokenStandard` are treated as `"ERC3475"`
+for backwards compatibility.
+
 For standard Liquid assets, `payment.asset` can be `"lbtc"` or `"usdt"`. If a
 testnet issuer or deployment uses a different USDt asset id, set
 `payment.asset: "usdt"` and pass the explicit `payment.assetId`; the generated
 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.
+
+#### Atomic Liquid DvP PSET helpers
+
+For flows that should avoid a separate "buyer pays first, service delivers
+later" step, the SDK also exposes lower-level atomic DvP helpers from the root
+package:
+
+- `buildLiquidAtomicDvpRequirements(...)`
+- `prepareLiquidAtomicDvpLwkWasmMakerProposal(...)`
+- `prepareLiquidAtomicDvpLwkWasmTakerPayment(...)`
+- `buildLiquidAtomicDvpPaymentFromPset(...)`
+- `verifyLiquidAtomicDvpPayment(...)`
+- `encodeLiquidAtomicDvpPayment(...)`
+- `decodeLiquidAtomicDvpPayment(...)`
+
+These helpers model a Liquidex-style exchange:
+- the service/maker selects an exact RWA delivery UTXO and creates a proposal
+- the buyer/taker adds the required payment output and signs the combined PSET
+- the resulting `X-PAYMENT` payload commits to both the payment output and the
+  delivery output through a summary hash
+
+The LWK convenience helpers dynamically load `lwk_node` or `lwk_wasm` from the
+consuming application. Install one of them in the application that prepares or
+takes proposals:
+
+```bash
+npm install lwk_node
+```
+
+Typical server-side shape:
+
+```ts
+import {
+  buildLiquidAtomicDvpRequirements,
+  prepareLiquidAtomicDvpLwkWasmMakerProposal,
+  verifyLiquidAtomicDvpPayment,
+} from "@hazbase/simplicity";
+
+const requirements = buildLiquidAtomicDvpRequirements({
+  network: "liquidtestnet",
+  resource: "/v1/orders/<order-id>/liquid-atomic-pset",
+  paymentToTreasury: {
+    assetId: "<lbtc-or-usdt-asset-id>",
+    amountAtomic: "10000",
+    recipient: "<treasury-confidential-address>",
+  },
+  rwaToBuyer: {
+    assetId: "<rwa-liquid-asset-id>",
+    amountAtomic: "10",
+    recipient: "<buyer-confidential-address>",
+  },
+  expiresAt: new Date(Date.now() + 15 * 60_000),
+});
+
+const maker = await prepareLiquidAtomicDvpLwkWasmMakerProposal({
+  requirements,
+  mnemonic: process.env.SERVICE_LIQUID_MNEMONIC!,
+  descriptor: process.env.SERVICE_LIQUID_DESCRIPTOR!,
+  electrumUrl: process.env.LIQUID_ELECTRUM_URL!,
+});
+
+// Store maker.proposalPsetBase64 with the order/payment requirements.
+// When the buyer submits X-PAYMENT, verify it before broadcasting.
+const verified = verifyLiquidAtomicDvpPayment({
+  requirements,
+  paymentPayload: buyerPaymentPayload,
+});
+if (!verified.ok) throw new Error(verified.reason);
+```
+
+The SDK-level payload check is intentionally lightweight: it verifies the
+scheme, network, resource, expiry, PSET value, and summary hash. Production
+settlement services should still decode the final PSET with their Liquid node or
+wallet stack, verify the concrete payment and delivery outputs, and only then
+broadcast.
+
 ## 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>;