@hazbase/simplicity 0.4.1 → 0.4.3

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

package/dist/core/types.d.ts

@@ -313,6 +313,50 @@ export interface ExecuteResult {
     broadcasted: boolean;
     contractUtxo: ContractUtxo;
 }
+export interface MultiAssetContractInput {
+    txid: string;
+    vout: number;
+    asset: string;
+    amountSat: number;
+    sequence?: number;
+    amountBlinder?: string;
+    assetBlinder?: string;
+}
+export interface MultiAssetContractOutput {
+    address: string;
+    asset: string;
+    amountSat: number;
+}
+export interface MultiAssetContractCallInput {
+    wallet: string;
+    signer: SignerConfig;
+    witness?: WitnessConfig;
+    contractInput?: {
+        txid: string;
+        vout?: number;
+        asset?: string;
+        amountSat?: number;
+        rawTxHex?: string;
+        blindingPrivateKey?: string;
+    };
+    extraInputs?: MultiAssetContractInput[];
+    outputs: MultiAssetContractOutput[];
+    feeSat?: number;
+    changeAddress?: string;
+    purpose?: string;
+    locktimeHeight?: number;
+    broadcast?: boolean;
+}
+export interface MultiAssetInspectResult extends InspectResult {
+    extraInputs: MultiAssetContractInput[];
+    requestedOutputs: MultiAssetContractOutput[];
+    changeOutputs: MultiAssetContractOutput[];
+}
+export interface MultiAssetExecuteResult extends ExecuteResult {
+    extraInputs: MultiAssetContractInput[];
+    requestedOutputs: MultiAssetContractOutput[];
+    changeOutputs: MultiAssetContractOutput[];
+}
 export interface GaslessExecuteInput {
     relayer?: import("../gasless/RelayerClient").RelayerClient;
     fromLabel?: string;

package/dist/docs/definitions/rwa-dvp-escrow.simf

@@ -0,0 +1,128 @@
+/*
+ * RWA DvP escrow machine.
+ *
+ * Delivery path:
+ * - output 0 is the payment asset sent to treasury.
+ * - output 1 is the Liquid RWA asset sent to the buyer.
+ *
+ * Refund path:
+ * - output 0 is the payment asset returned to the refund recipient after
+ *   TIMEOUT_HEIGHT.
+ *
+ * The SDK supplies output hash/script hash witnesses and signs sig_all_hash,
+ * so the operator signature covers the full transaction assembled by the SDK.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_hash_anchor(value: u256) {
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(value, zero_hash)));
+}
+
+fn require_terms_anchor() {
+    let terms_hash: u256 = 0x{{TERMS_HASH}};
+    require_hash_anchor(terms_hash);
+}
+
+fn require_policy_anchor() {
+    let policy_hash: u256 = 0x{{POLICY_HASH}};
+    require_hash_anchor(policy_hash);
+}
+
+fn require_bound_output(actual_output_hash: u256, actual_script_hash: u256, expected_output_hash: u256, expected_script_hash: u256, binding_mode: u8) {
+    match jet::eq_8(binding_mode, 0x03) {
+        true => {},
+        false => match jet::eq_8(binding_mode, 0x01) {
+            true => assert!(jet::eq_256(actual_output_hash, expected_output_hash)),
+            false => assert!(jet::eq_256(actual_script_hash, expected_script_hash)),
+        },
+    };
+}
+
+fn require_output_0(expected_output_hash: u256, expected_script_hash: u256, binding_mode: u8) {
+    let actual_output_hash: u256 = match jet::output_hash(0) {
+        Some(output_hash : u256) => output_hash,
+        None => panic!(),
+    };
+    let actual_script_hash: u256 = unwrap(jet::output_script_hash(0));
+    require_bound_output(actual_output_hash, actual_script_hash, expected_output_hash, expected_script_hash, binding_mode);
+}
+
+fn require_output_1(expected_output_hash: u256, expected_script_hash: u256, binding_mode: u8) {
+    let actual_output_hash: u256 = match jet::output_hash(1) {
+        Some(output_hash : u256) => output_hash,
+        None => panic!(),
+    };
+    let actual_script_hash: u256 = unwrap(jet::output_script_hash(1));
+    require_bound_output(actual_output_hash, actual_script_hash, expected_output_hash, expected_script_hash, binding_mode);
+}
+
+fn checksig(sig: Signature) {
+    let signer: Pubkey = 0x{{OPERATOR_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), sig);
+}
+
+fn delivery_spend(
+    payment_output_hash: u256,
+    payment_output_script_hash: u256,
+    payment_output_binding_mode: u8,
+    rwa_output_hash: u256,
+    rwa_output_script_hash: u256,
+    rwa_output_binding_mode: u8,
+    signer_signature: Signature
+) {
+    require_output_0(
+        payment_output_hash,
+        payment_output_script_hash,
+        payment_output_binding_mode
+    );
+    require_output_1(
+        rwa_output_hash,
+        rwa_output_script_hash,
+        rwa_output_binding_mode
+    );
+    checksig(signer_signature);
+}
+
+fn refund_spend(
+    refund_output_hash: u256,
+    refund_output_script_hash: u256,
+    refund_output_binding_mode: u8,
+    signer_signature: Signature
+) {
+    jet::check_lock_height({{TIMEOUT_HEIGHT}});
+    require_output_0(
+        refund_output_hash,
+        refund_output_script_hash,
+        refund_output_binding_mode
+    );
+    checksig(signer_signature);
+}
+
+fn main() {
+    require_terms_anchor();
+    require_policy_anchor();
+    let signer_signature: Signature = witness::SIGNER_SIGNATURE;
+    match witness::DELIVERY_OR_REFUND {
+        Some(marker: u8) => {
+            assert!(jet::eq_8(marker, 0x01));
+            delivery_spend(
+                witness::PAYMENT_OUTPUT_HASH,
+                witness::PAYMENT_OUTPUT_SCRIPT_HASH,
+                witness::PAYMENT_OUTPUT_BINDING_MODE,
+                witness::RWA_OUTPUT_HASH,
+                witness::RWA_OUTPUT_SCRIPT_HASH,
+                witness::RWA_OUTPUT_BINDING_MODE,
+                signer_signature
+            )
+        },
+        None => refund_spend(
+            witness::REFUND_OUTPUT_HASH,
+            witness::REFUND_OUTPUT_SCRIPT_HASH,
+            witness::REFUND_OUTPUT_BINDING_MODE,
+            signer_signature
+        ),
+    }
+}

package/dist/domain/rwaDvp.d.ts

@@ -1,5 +1,5 @@
 import type { SimplicityClient } from "../client/SimplicityClient";
-import type { BondOutputBindingMode, OutputRawFields } from "../core/types";
+import type { BondOutputBindingMode, MultiAssetContractInput, MultiAssetExecuteResult, MultiAssetInspectResult, OutputRawFields, SignerConfig, SimplicityArtifact, WitnessConfig } from "../core/types";
 import { type LiquidX402AssetKey, type LiquidX402Network, type LiquidX402PaymentPayload, type LiquidX402PaymentRequirements, type LiquidX402VerifyPaymentResult } from "../x402";
 export declare const RWA_DVP_PURCHASE_SCHEMA_VERSION: "rwa-dvp-purchase/v1";
 export declare const RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION: "rwa-dvp-delivery-claim/v1";
@@ -7,10 +7,12 @@ export declare const RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION: "rwa-dvp-refund-claim/
 export declare const RWA_DVP_VERIFICATION_SCHEMA_VERSION: "rwa-dvp-verification/v1";
 export declare const RWA_DVP_EVIDENCE_SCHEMA_VERSION: "rwa-dvp-evidence/v1";
 export type RwaDvpPaymentAsset = LiquidX402AssetKey;
+export type RwaDvpEvmTokenStandard = "ERC3475" | "ERC20" | "ERC721" | "ERC1155";
 export interface RwaDvpEvmLockReference {
     chainId: number;
     lockManager: string;
     orderKey: string;
+    tokenStandard?: RwaDvpEvmTokenStandard;
     token?: string;
     backingOwner?: string;
     classId?: string;
@@ -190,6 +192,74 @@ export interface RwaDvpPrepareRefundClaimInput {
     refundTxid?: string;
     createdAt?: string | Date;
 }
+export interface RwaDvpCompileEscrowContractInput {
+    purchase: RwaDvpPurchaseDefinition;
+    operatorXonly: string;
+    timeoutHeight: number;
+    simfPath?: string;
+}
+export interface RwaDvpCompiledEscrowContract {
+    compiled: Awaited<ReturnType<SimplicityClient["compileFromFile"]>>;
+    artifact: SimplicityArtifact;
+    contractAddress: string;
+    timeoutHeight: number;
+    termsHash: string;
+    policyHash: string;
+}
+export interface RwaDvpClaimOutputBinding {
+    outputHash: string;
+    outputScriptHash: string;
+    bindingMode: BondOutputBindingMode;
+}
+export interface RwaDvpClaimExecutionBaseInput {
+    purchase: RwaDvpPurchaseDefinition;
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    wallet: string;
+    signer: SignerConfig;
+    feeSat?: number;
+    changeAddress?: string;
+    extraInputs?: MultiAssetContractInput[];
+    contractInputRawTxHex?: string;
+    contractInputBlindingPrivateKey?: string;
+    witness?: WitnessConfig;
+    locktimeHeight?: number;
+}
+export interface RwaDvpInspectDeliveryClaimInput extends RwaDvpClaimExecutionBaseInput {
+    descriptor: RwaDvpDeliveryClaimDescriptor;
+}
+export interface RwaDvpExecuteDeliveryClaimInput extends RwaDvpInspectDeliveryClaimInput {
+    broadcast?: boolean;
+}
+export interface RwaDvpInspectRefundClaimInput extends RwaDvpClaimExecutionBaseInput {
+    descriptor: RwaDvpRefundClaimDescriptor;
+}
+export interface RwaDvpExecuteRefundClaimInput extends RwaDvpInspectRefundClaimInput {
+    broadcast?: boolean;
+}
+export interface RwaDvpDeliveryClaimInspection {
+    descriptor: RwaDvpDeliveryClaimDescriptor;
+    verification: RwaDvpVerificationReport;
+    outputBinding: {
+        paymentToTreasury: RwaDvpClaimOutputBinding;
+        rwaToBuyer: RwaDvpClaimOutputBinding;
+    };
+    inspect: MultiAssetInspectResult;
+}
+export interface RwaDvpDeliveryClaimExecution extends Omit<RwaDvpDeliveryClaimInspection, "inspect"> {
+    execution: MultiAssetExecuteResult;
+}
+export interface RwaDvpRefundClaimInspection {
+    descriptor: RwaDvpRefundClaimDescriptor;
+    verification: RwaDvpVerificationReport;
+    outputBinding: {
+        refund: RwaDvpClaimOutputBinding;
+    };
+    inspect: MultiAssetInspectResult;
+}
+export interface RwaDvpRefundClaimExecution extends Omit<RwaDvpRefundClaimInspection, "inspect"> {
+    execution: MultiAssetExecuteResult;
+}
 export interface RwaDvpVerificationReport {
     schemaVersion: typeof RWA_DVP_VERIFICATION_SCHEMA_VERSION;
     ok: boolean;
@@ -239,6 +309,11 @@ export declare function verifyRefundClaim(_sdk: SimplicityClient, input: {
     purchase: RwaDvpPurchaseDefinition;
     descriptor: RwaDvpRefundClaimDescriptor;
 }): RwaDvpVerificationReport;
+export declare function compileEscrowContract(sdk: SimplicityClient, input: RwaDvpCompileEscrowContractInput): Promise<RwaDvpCompiledEscrowContract>;
+export declare function inspectDeliveryClaim(sdk: SimplicityClient, input: RwaDvpInspectDeliveryClaimInput): Promise<RwaDvpDeliveryClaimInspection>;
+export declare function executeDeliveryClaim(sdk: SimplicityClient, input: RwaDvpExecuteDeliveryClaimInput): Promise<RwaDvpDeliveryClaimExecution>;
+export declare function inspectRefundClaim(sdk: SimplicityClient, input: RwaDvpInspectRefundClaimInput): Promise<RwaDvpRefundClaimInspection>;
+export declare function executeRefundClaim(sdk: SimplicityClient, input: RwaDvpExecuteRefundClaimInput): Promise<RwaDvpRefundClaimExecution>;
 export declare function exportEvidence(_sdk: SimplicityClient, input: Omit<RwaDvpEvidenceBundle, "schemaVersion" | "createdAt" | "termsHash" | "policyHash"> & {
     createdAt?: string | Date;
 }): RwaDvpEvidenceBundle;