@hazbase/simplicity 0.4.1 → 0.4.2

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";
@@ -190,6 +190,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 +307,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;