@hazbase/simplicity 0.3.1 → 0.4.0

package/dist/client/SimplicityClient.d.ts

@@ -4,6 +4,7 @@ import { BondEvidenceBundle, OutputBindingSupportEvaluation, OutputBindingSuppor
 import { RelayerClient } from "../gasless/RelayerClient";
 import { GaslessTransferInput, GaslessTransferResult, RelayerClientConfig } from "../gasless/types";
 import * as liquidX402 from "../x402";
+import * as rwaDvp from "../domain/rwaDvp";
 import { CompiledContract } from "./ContractFactory";
 import { DeployedContract } from "./DeployedContract";
 import { prepareRedemption, prepareClosing, exportFinalityPayload, buildSettlement, verifySettlement, define, executeClosing, executeRedemption, exportEvidence, inspectClosing, inspectRedemption, issue, load, verify, verifyIssuanceHistory, verifyClosing, verifyRedemption } from "../domain/bond";
@@ -33,6 +34,16 @@ export declare class SimplicityClient {
         describeSupport: () => OutputBindingSupportMatrix;
         evaluateSupport: (input: Parameters<typeof evaluateOutputBindingSupport>[0]) => OutputBindingSupportEvaluation;
     };
+    readonly rwaDvp: {
+        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>;
+        prepareDeliveryClaim: (input: Parameters<typeof rwaDvp.prepareDeliveryClaim>[1]) => ReturnType<typeof rwaDvp.prepareDeliveryClaim>;
+        verifyDeliveryClaim: (input: Parameters<typeof rwaDvp.verifyDeliveryClaim>[1]) => ReturnType<typeof rwaDvp.verifyDeliveryClaim>;
+        prepareRefundClaim: (input: Parameters<typeof rwaDvp.prepareRefundClaim>[1]) => ReturnType<typeof rwaDvp.prepareRefundClaim>;
+        verifyRefundClaim: (input: Parameters<typeof rwaDvp.verifyRefundClaim>[1]) => ReturnType<typeof rwaDvp.verifyRefundClaim>;
+        exportEvidence: (input: Parameters<typeof rwaDvp.exportEvidence>[1]) => ReturnType<typeof rwaDvp.exportEvidence>;
+    };
     readonly policies: {
         listTemplates: () => ReturnType<typeof listPolicyTemplates>;
         describeTemplate: (input: Parameters<typeof describePolicyTemplate>[0]) => ReturnType<typeof describePolicyTemplate>;

package/dist/client/SimplicityClient.js

@@ -44,6 +44,7 @@ const outputBinding_1 = require("../core/outputBinding");
 const rpc_1 = require("../core/rpc");
 const RelayerClient_1 = require("../gasless/RelayerClient");
 const liquidX402 = __importStar(require("../x402"));
+const rwaDvp = __importStar(require("../domain/rwaDvp"));
 const ContractFactory_1 = require("./ContractFactory");
 const DeployedContract_1 = require("./DeployedContract");
 const bond_1 = require("../domain/bond");
@@ -55,6 +56,7 @@ class SimplicityClient {
     rpc;
     payments;
     outputBinding;
+    rwaDvp;
     policies;
     bonds;
     funds;
@@ -82,6 +84,16 @@ class SimplicityClient {
             describeSupport: () => (0, outputBinding_1.describeOutputBindingSupport)(),
             evaluateSupport: (input) => (0, outputBinding_1.evaluateOutputBindingSupport)(input),
         };
+        this.rwaDvp = {
+            definePurchase: (input) => rwaDvp.definePurchase(this, input),
+            buildPaymentRequirements: (input) => rwaDvp.buildPaymentRequirements(this, input),
+            verifyPaymentPset: (input) => rwaDvp.verifyPaymentPset(this, input),
+            prepareDeliveryClaim: (input) => rwaDvp.prepareDeliveryClaim(this, input),
+            verifyDeliveryClaim: (input) => rwaDvp.verifyDeliveryClaim(this, input),
+            prepareRefundClaim: (input) => rwaDvp.prepareRefundClaim(this, input),
+            verifyRefundClaim: (input) => rwaDvp.verifyRefundClaim(this, input),
+            exportEvidence: (input) => rwaDvp.exportEvidence(this, input),
+        };
         this.policies = {
             listTemplates: () => (0, policies_1.listPolicyTemplates)(),
             describeTemplate: (input) => (0, policies_1.describePolicyTemplate)(input),

package/dist/domain/rwaDvp.d.ts

@@ -0,0 +1,244 @@
+import type { SimplicityClient } from "../client/SimplicityClient";
+import type { BondOutputBindingMode, OutputRawFields } 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";
+export declare const RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION: "rwa-dvp-refund-claim/v1";
+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 interface RwaDvpEvmLockReference {
+    chainId: number;
+    lockManager: string;
+    orderKey: string;
+    token?: string;
+    backingOwner?: string;
+    classId?: string;
+    nonceId?: string;
+    amountAtomic: string;
+    termsHash?: string;
+    lockTxHash?: string;
+    consumeTxHash?: string;
+    releaseTxHash?: string;
+}
+export interface RwaDvpPurchaseDefinition {
+    schemaVersion: typeof RWA_DVP_PURCHASE_SCHEMA_VERSION;
+    purchaseId: string;
+    network: LiquidX402Network;
+    evmLock: RwaDvpEvmLockReference;
+    payment: {
+        asset: RwaDvpPaymentAsset;
+        assetId: string;
+        amountAtomic: string;
+        escrowAddress: string;
+        treasuryAddress: string;
+    };
+    delivery: {
+        assetId: string;
+        amountAtomic: string;
+        recipientAddress: string;
+    };
+    refund: {
+        recipientAddress: string;
+        after: string;
+    };
+    expiresAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RwaDvpDefinePurchaseInput {
+    purchaseId: string;
+    network?: LiquidX402Network;
+    evmLock: RwaDvpEvmLockReference;
+    payment: {
+        asset: RwaDvpPaymentAsset;
+        assetId?: string;
+        amountAtomic: string | number | bigint;
+        escrowAddress: string;
+        treasuryAddress?: string;
+    };
+    delivery: {
+        assetId: string;
+        amountAtomic: string | number | bigint;
+        recipientAddress: string;
+    };
+    refund: {
+        recipientAddress: string;
+        after: string | Date;
+    };
+    expiresAt: string | Date;
+    metadata?: Record<string, unknown>;
+}
+export interface RwaDvpSummary {
+    canonicalJson: string;
+    hash: string;
+}
+export interface RwaDvpPreparedPurchase {
+    definition: RwaDvpPurchaseDefinition;
+    summary: RwaDvpSummary;
+    termsHash: string;
+    policyHash: string;
+}
+export interface RwaDvpBuildPaymentRequirementsInput {
+    purchase: RwaDvpPurchaseDefinition;
+    resource: string;
+    description?: string;
+    mimeType?: string;
+    maxTimeoutSeconds?: number;
+    maxFeeSat?: string | number | bigint;
+    metadata?: Record<string, unknown>;
+}
+export interface RwaDvpVerifyPaymentPsetInput {
+    purchase: RwaDvpPurchaseDefinition;
+    requirements: LiquidX402PaymentRequirements | Record<string, unknown>;
+    paymentPayload: LiquidX402PaymentPayload | Record<string, unknown>;
+    now?: Date;
+    verifyPsetOutputs?: boolean;
+}
+export interface RwaDvpDeliveryClaimDescriptor {
+    schemaVersion: typeof RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION;
+    purchaseId: string;
+    network: LiquidX402Network;
+    termsHash: string;
+    policyHash: string;
+    mode: "simplicity-multi-asset-claim" | "operator-wallet-delivery-bridge";
+    paymentInput?: {
+        txid: string;
+        vout?: number;
+        assetId: string;
+        amountAtomic: string;
+    };
+    operatorRwaInput?: {
+        txid?: string;
+        vout?: number;
+        assetId: string;
+        amountAtomic: string;
+        reissuanceAllowed?: boolean;
+    };
+    outputs: {
+        paymentToTreasury: {
+            recipientAddress: string;
+            assetId: string;
+            amountAtomic: string;
+            outputIndex: number;
+        };
+        rwaToBuyer: {
+            recipientAddress: string;
+            assetId: string;
+            amountAtomic: string;
+            outputIndex: number;
+            outputBindingMode: BondOutputBindingMode;
+            rawOutput?: Partial<OutputRawFields>;
+        };
+    };
+    fee: {
+        asset: "lbtc";
+        maxFeeSat: number;
+        feeOutputIndex?: number;
+    };
+    fundingTxid?: string;
+    deliveryTxid?: string;
+    createdAt: string;
+}
+export interface RwaDvpPrepareDeliveryClaimInput {
+    purchase: RwaDvpPurchaseDefinition;
+    fundingTxid?: string;
+    paymentInput?: RwaDvpDeliveryClaimDescriptor["paymentInput"];
+    operatorRwaInput?: RwaDvpDeliveryClaimDescriptor["operatorRwaInput"];
+    mode?: RwaDvpDeliveryClaimDescriptor["mode"];
+    outputBindingMode?: BondOutputBindingMode;
+    nextRawOutput?: Partial<OutputRawFields>;
+    paymentOutputIndex?: number;
+    deliveryOutputIndex?: number;
+    maxFeeSat?: number;
+    feeOutputIndex?: number;
+    deliveryTxid?: string;
+    createdAt?: string | Date;
+}
+export interface RwaDvpRefundClaimDescriptor {
+    schemaVersion: typeof RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION;
+    purchaseId: string;
+    network: LiquidX402Network;
+    termsHash: string;
+    policyHash: string;
+    paymentInput?: {
+        txid: string;
+        vout?: number;
+        assetId: string;
+        amountAtomic: string;
+    };
+    refundOutput: {
+        recipientAddress: string;
+        assetId: string;
+        amountAtomic: string;
+        outputIndex: number;
+    };
+    notBefore: string;
+    fee: {
+        asset: "lbtc";
+        maxFeeSat: number;
+        feeOutputIndex?: number;
+    };
+    refundTxid?: string;
+    createdAt: string;
+}
+export interface RwaDvpPrepareRefundClaimInput {
+    purchase: RwaDvpPurchaseDefinition;
+    paymentInput?: RwaDvpRefundClaimDescriptor["paymentInput"];
+    refundOutputIndex?: number;
+    maxFeeSat?: number;
+    feeOutputIndex?: number;
+    refundTxid?: string;
+    createdAt?: string | Date;
+}
+export interface RwaDvpVerificationReport {
+    schemaVersion: typeof RWA_DVP_VERIFICATION_SCHEMA_VERSION;
+    ok: boolean;
+    reason?: string;
+    purchaseId: string;
+    termsHash: string;
+    policyHash: string;
+    checks: Record<string, boolean>;
+}
+export interface RwaDvpEvidenceBundle {
+    schemaVersion: typeof RWA_DVP_EVIDENCE_SCHEMA_VERSION;
+    purchase: RwaDvpPurchaseDefinition;
+    termsHash: string;
+    policyHash: string;
+    paymentRequirements?: LiquidX402PaymentRequirements | Record<string, unknown>;
+    paymentVerification?: LiquidX402VerifyPaymentResult;
+    deliveryClaim?: RwaDvpDeliveryClaimDescriptor;
+    deliveryVerification?: RwaDvpVerificationReport;
+    refundClaim?: RwaDvpRefundClaimDescriptor;
+    refundVerification?: RwaDvpVerificationReport;
+    evm?: {
+        lockTxHash?: string;
+        consumeTxHash?: string;
+        releaseTxHash?: string;
+    };
+    createdAt: string;
+}
+export declare function definePurchase(_sdk: SimplicityClient, input: RwaDvpDefinePurchaseInput): RwaDvpPreparedPurchase;
+export declare function summarizePurchase(purchase: RwaDvpPurchaseDefinition): RwaDvpSummary;
+export declare function buildPaymentRequirements(_sdk: SimplicityClient, input: RwaDvpBuildPaymentRequirementsInput): LiquidX402PaymentRequirements;
+export declare function verifyPaymentPset(sdk: SimplicityClient, input: RwaDvpVerifyPaymentPsetInput): Promise<LiquidX402VerifyPaymentResult>;
+export declare function prepareDeliveryClaim(sdk: SimplicityClient, input: RwaDvpPrepareDeliveryClaimInput): {
+    descriptor: RwaDvpDeliveryClaimDescriptor;
+    summary: RwaDvpSummary;
+    verification: RwaDvpVerificationReport;
+};
+export declare function verifyDeliveryClaim(_sdk: SimplicityClient, input: {
+    purchase: RwaDvpPurchaseDefinition;
+    descriptor: RwaDvpDeliveryClaimDescriptor;
+}): RwaDvpVerificationReport;
+export declare function prepareRefundClaim(sdk: SimplicityClient, input: RwaDvpPrepareRefundClaimInput): {
+    descriptor: RwaDvpRefundClaimDescriptor;
+    summary: RwaDvpSummary;
+    verification: RwaDvpVerificationReport;
+};
+export declare function verifyRefundClaim(_sdk: SimplicityClient, input: {
+    purchase: RwaDvpPurchaseDefinition;
+    descriptor: RwaDvpRefundClaimDescriptor;
+}): RwaDvpVerificationReport;
+export declare function exportEvidence(_sdk: SimplicityClient, input: Omit<RwaDvpEvidenceBundle, "schemaVersion" | "createdAt" | "termsHash" | "policyHash"> & {
+    createdAt?: string | Date;
+}): RwaDvpEvidenceBundle;

package/dist/domain/rwaDvp.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RWA_DVP_EVIDENCE_SCHEMA_VERSION = exports.RWA_DVP_VERIFICATION_SCHEMA_VERSION = exports.RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION = exports.RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION = exports.RWA_DVP_PURCHASE_SCHEMA_VERSION = void 0;
+exports.definePurchase = definePurchase;
+exports.summarizePurchase = summarizePurchase;
+exports.buildPaymentRequirements = buildPaymentRequirements;
+exports.verifyPaymentPset = verifyPaymentPset;
+exports.prepareDeliveryClaim = prepareDeliveryClaim;
+exports.verifyDeliveryClaim = verifyDeliveryClaim;
+exports.prepareRefundClaim = prepareRefundClaim;
+exports.verifyRefundClaim = verifyRefundClaim;
+exports.exportEvidence = exportEvidence;
+const errors_1 = require("../core/errors");
+const summary_1 = require("../core/summary");
+const x402_1 = require("../x402");
+exports.RWA_DVP_PURCHASE_SCHEMA_VERSION = "rwa-dvp-purchase/v1";
+exports.RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION = "rwa-dvp-delivery-claim/v1";
+exports.RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION = "rwa-dvp-refund-claim/v1";
+exports.RWA_DVP_VERIFICATION_SCHEMA_VERSION = "rwa-dvp-verification/v1";
+exports.RWA_DVP_EVIDENCE_SCHEMA_VERSION = "rwa-dvp-evidence/v1";
+function definePurchase(_sdk, input) {
+    const network = input.network ?? "liquidtestnet";
+    assertNonEmpty(input.purchaseId, "purchaseId");
+    assertNonEmpty(input.payment.escrowAddress, "payment.escrowAddress");
+    assertNonEmpty(input.delivery.recipientAddress, "delivery.recipientAddress");
+    assertNonEmpty(input.refund.recipientAddress, "refund.recipientAddress");
+    assertPositiveInteger(input.payment.amountAtomic, "payment.amountAtomic");
+    assertPositiveInteger(input.delivery.amountAtomic, "delivery.amountAtomic");
+    assertPositiveInteger(input.evmLock.amountAtomic, "evmLock.amountAtomic");
+    assertFutureishDate(input.expiresAt, "expiresAt");
+    assertFutureishDate(input.refund.after, "refund.after");
+    const assetId = input.payment.assetId ?? (0, x402_1.resolveLiquidX402Asset)(input.payment.asset, network).assetId;
+    const definition = {
+        schemaVersion: exports.RWA_DVP_PURCHASE_SCHEMA_VERSION,
+        purchaseId: input.purchaseId,
+        network,
+        evmLock: {
+            ...input.evmLock,
+            amountAtomic: normalizeInteger(input.evmLock.amountAtomic),
+        },
+        payment: {
+            asset: input.payment.asset,
+            assetId,
+            amountAtomic: normalizeInteger(input.payment.amountAtomic),
+            escrowAddress: input.payment.escrowAddress,
+            treasuryAddress: input.payment.treasuryAddress ?? input.payment.escrowAddress,
+        },
+        delivery: {
+            assetId: input.delivery.assetId,
+            amountAtomic: normalizeInteger(input.delivery.amountAtomic),
+            recipientAddress: input.delivery.recipientAddress,
+        },
+        refund: {
+            recipientAddress: input.refund.recipientAddress,
+            after: normalizeIso(input.refund.after),
+        },
+        expiresAt: normalizeIso(input.expiresAt),
+        ...(input.metadata ? { metadata: input.metadata } : {}),
+    };
+    const summary = summarizePurchase(definition);
+    return {
+        definition,
+        summary,
+        termsHash: summary.hash,
+        policyHash: summarizePolicy(definition).hash,
+    };
+}
+function summarizePurchase(purchase) {
+    return summarizeCanonical(purchase);
+}
+function buildPaymentRequirements(_sdk, input) {
+    const summary = summarizePurchase(input.purchase);
+    return (0, x402_1.buildLiquidX402Requirements)({
+        paymentRequestId: input.purchase.purchaseId,
+        resource: input.resource,
+        payTo: input.purchase.payment.escrowAddress,
+        amountAtomic: input.purchase.payment.amountAtomic,
+        network: input.purchase.network,
+        asset: input.purchase.payment.asset,
+        description: input.description ?? "Hazbase RWA Liquid delivery-versus-payment",
+        mimeType: input.mimeType ?? "application/json",
+        maxTimeoutSeconds: input.maxTimeoutSeconds,
+        expiresAt: input.purchase.expiresAt,
+        maxFeeSat: input.maxFeeSat,
+        metadata: {
+            ...input.metadata,
+            purchaseId: input.purchase.purchaseId,
+            termsHash: summary.hash,
+            policyHash: summarizePolicy(input.purchase).hash,
+            deliveryAssetId: input.purchase.delivery.assetId,
+            deliveryAmountAtomic: input.purchase.delivery.amountAtomic,
+            deliveryRecipientAddress: input.purchase.delivery.recipientAddress,
+        },
+    });
+}
+async function verifyPaymentPset(sdk, input) {
+    const rpc = input.verifyPsetOutputs === false ? null : sdk.rpc;
+    const result = await (0, x402_1.verifyLiquidX402Payment)(rpc, {
+        requirements: input.requirements,
+        paymentPayload: input.paymentPayload,
+        now: input.now,
+    });
+    if (!result.isValid)
+        return result;
+    if (result.paymentRequestId !== input.purchase.purchaseId) {
+        return { ...result, isValid: false, invalidReason: "purchase_mismatch" };
+    }
+    return result;
+}
+function prepareDeliveryClaim(sdk, input) {
+    const purchaseSummary = summarizePurchase(input.purchase);
+    const policy = summarizePolicy(input.purchase);
+    const descriptor = {
+        schemaVersion: exports.RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION,
+        purchaseId: input.purchase.purchaseId,
+        network: input.purchase.network,
+        termsHash: purchaseSummary.hash,
+        policyHash: policy.hash,
+        mode: input.mode ?? "simplicity-multi-asset-claim",
+        ...(input.paymentInput ? { paymentInput: input.paymentInput } : {}),
+        operatorRwaInput: input.operatorRwaInput ?? {
+            assetId: input.purchase.delivery.assetId,
+            amountAtomic: input.purchase.delivery.amountAtomic,
+            reissuanceAllowed: true,
+        },
+        outputs: {
+            paymentToTreasury: {
+                recipientAddress: input.purchase.payment.treasuryAddress,
+                assetId: input.purchase.payment.assetId,
+                amountAtomic: input.purchase.payment.amountAtomic,
+                outputIndex: input.paymentOutputIndex ?? 0,
+            },
+            rwaToBuyer: {
+                recipientAddress: input.purchase.delivery.recipientAddress,
+                assetId: input.purchase.delivery.assetId,
+                amountAtomic: input.purchase.delivery.amountAtomic,
+                outputIndex: input.deliveryOutputIndex ?? 1,
+                outputBindingMode: input.outputBindingMode ?? "descriptor-bound",
+                ...(input.nextRawOutput ? { rawOutput: input.nextRawOutput } : {}),
+            },
+        },
+        fee: {
+            asset: "lbtc",
+            maxFeeSat: input.maxFeeSat ?? sdk.config.defaults?.feeSat ?? 1000,
+            ...(input.feeOutputIndex !== undefined ? { feeOutputIndex: input.feeOutputIndex } : {}),
+        },
+        ...(input.fundingTxid ? { fundingTxid: input.fundingTxid } : {}),
+        ...(input.deliveryTxid ? { deliveryTxid: input.deliveryTxid } : {}),
+        createdAt: input.createdAt ? normalizeIso(input.createdAt) : new Date().toISOString(),
+    };
+    const verification = verifyDeliveryClaim(sdk, { purchase: input.purchase, descriptor });
+    return {
+        descriptor,
+        summary: summarizeCanonical(descriptor),
+        verification,
+    };
+}
+function verifyDeliveryClaim(_sdk, input) {
+    const termsHash = summarizePurchase(input.purchase).hash;
+    const policyHash = summarizePolicy(input.purchase).hash;
+    const checks = {
+        schemaVersion: input.descriptor.schemaVersion === exports.RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION,
+        purchaseId: input.descriptor.purchaseId === input.purchase.purchaseId,
+        network: input.descriptor.network === input.purchase.network,
+        termsHash: input.descriptor.termsHash === termsHash,
+        policyHash: input.descriptor.policyHash === policyHash,
+        paymentOutputAsset: input.descriptor.outputs.paymentToTreasury.assetId === input.purchase.payment.assetId,
+        paymentOutputAmount: input.descriptor.outputs.paymentToTreasury.amountAtomic === input.purchase.payment.amountAtomic,
+        paymentOutputRecipient: input.descriptor.outputs.paymentToTreasury.recipientAddress === input.purchase.payment.treasuryAddress,
+        deliveryOutputAsset: input.descriptor.outputs.rwaToBuyer.assetId === input.purchase.delivery.assetId,
+        deliveryOutputAmount: input.descriptor.outputs.rwaToBuyer.amountAtomic === input.purchase.delivery.amountAtomic,
+        deliveryOutputRecipient: input.descriptor.outputs.rwaToBuyer.recipientAddress === input.purchase.delivery.recipientAddress,
+        fee: Number.isInteger(input.descriptor.fee.maxFeeSat) && input.descriptor.fee.maxFeeSat >= 0,
+    };
+    return report(input.purchase.purchaseId, termsHash, policyHash, checks, "RWA DvP delivery claim descriptor mismatch");
+}
+function prepareRefundClaim(sdk, input) {
+    const termsHash = summarizePurchase(input.purchase).hash;
+    const policyHash = summarizePolicy(input.purchase).hash;
+    const descriptor = {
+        schemaVersion: exports.RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION,
+        purchaseId: input.purchase.purchaseId,
+        network: input.purchase.network,
+        termsHash,
+        policyHash,
+        ...(input.paymentInput ? { paymentInput: input.paymentInput } : {}),
+        refundOutput: {
+            recipientAddress: input.purchase.refund.recipientAddress,
+            assetId: input.purchase.payment.assetId,
+            amountAtomic: input.purchase.payment.amountAtomic,
+            outputIndex: input.refundOutputIndex ?? 0,
+        },
+        notBefore: input.purchase.refund.after,
+        fee: {
+            asset: "lbtc",
+            maxFeeSat: input.maxFeeSat ?? sdk.config.defaults?.feeSat ?? 1000,
+            ...(input.feeOutputIndex !== undefined ? { feeOutputIndex: input.feeOutputIndex } : {}),
+        },
+        ...(input.refundTxid ? { refundTxid: input.refundTxid } : {}),
+        createdAt: input.createdAt ? normalizeIso(input.createdAt) : new Date().toISOString(),
+    };
+    const verification = verifyRefundClaim(sdk, { purchase: input.purchase, descriptor });
+    return {
+        descriptor,
+        summary: summarizeCanonical(descriptor),
+        verification,
+    };
+}
+function verifyRefundClaim(_sdk, input) {
+    const termsHash = summarizePurchase(input.purchase).hash;
+    const policyHash = summarizePolicy(input.purchase).hash;
+    const checks = {
+        schemaVersion: input.descriptor.schemaVersion === exports.RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION,
+        purchaseId: input.descriptor.purchaseId === input.purchase.purchaseId,
+        network: input.descriptor.network === input.purchase.network,
+        termsHash: input.descriptor.termsHash === termsHash,
+        policyHash: input.descriptor.policyHash === policyHash,
+        refundAsset: input.descriptor.refundOutput.assetId === input.purchase.payment.assetId,
+        refundAmount: input.descriptor.refundOutput.amountAtomic === input.purchase.payment.amountAtomic,
+        refundRecipient: input.descriptor.refundOutput.recipientAddress === input.purchase.refund.recipientAddress,
+        notBefore: input.descriptor.notBefore === input.purchase.refund.after,
+        fee: Number.isInteger(input.descriptor.fee.maxFeeSat) && input.descriptor.fee.maxFeeSat >= 0,
+    };
+    return report(input.purchase.purchaseId, termsHash, policyHash, checks, "RWA DvP refund claim descriptor mismatch");
+}
+function exportEvidence(_sdk, input) {
+    return {
+        schemaVersion: exports.RWA_DVP_EVIDENCE_SCHEMA_VERSION,
+        purchase: input.purchase,
+        termsHash: summarizePurchase(input.purchase).hash,
+        policyHash: summarizePolicy(input.purchase).hash,
+        ...(input.paymentRequirements ? { paymentRequirements: input.paymentRequirements } : {}),
+        ...(input.paymentVerification ? { paymentVerification: input.paymentVerification } : {}),
+        ...(input.deliveryClaim ? { deliveryClaim: input.deliveryClaim } : {}),
+        ...(input.deliveryVerification ? { deliveryVerification: input.deliveryVerification } : {}),
+        ...(input.refundClaim ? { refundClaim: input.refundClaim } : {}),
+        ...(input.refundVerification ? { refundVerification: input.refundVerification } : {}),
+        ...(input.evm ? { evm: input.evm } : {}),
+        createdAt: input.createdAt ? normalizeIso(input.createdAt) : new Date().toISOString(),
+    };
+}
+function summarizePolicy(purchase) {
+    return summarizeCanonical({
+        schemaVersion: "rwa-dvp-policy/v1",
+        purchaseId: purchase.purchaseId,
+        network: purchase.network,
+        evmLock: purchase.evmLock,
+        paymentMustFundEscrow: {
+            asset: purchase.payment.asset,
+            assetId: purchase.payment.assetId,
+            amountAtomic: purchase.payment.amountAtomic,
+            escrowAddress: purchase.payment.escrowAddress,
+        },
+        deliveryClaimMustPay: {
+            treasuryAddress: purchase.payment.treasuryAddress,
+            buyerAddress: purchase.delivery.recipientAddress,
+            paymentAssetId: purchase.payment.assetId,
+            paymentAmountAtomic: purchase.payment.amountAtomic,
+            rwaAssetId: purchase.delivery.assetId,
+            rwaAmountAtomic: purchase.delivery.amountAtomic,
+        },
+        refundAfter: purchase.refund,
+        expiresAt: purchase.expiresAt,
+    });
+}
+function summarizeCanonical(value) {
+    const canonicalJson = (0, summary_1.stableStringify)(value);
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function report(purchaseId, termsHash, policyHash, checks, reason) {
+    const ok = Object.values(checks).every(Boolean);
+    return {
+        schemaVersion: exports.RWA_DVP_VERIFICATION_SCHEMA_VERSION,
+        ok,
+        ...(ok ? {} : { reason }),
+        purchaseId,
+        termsHash,
+        policyHash,
+        checks,
+    };
+}
+function assertNonEmpty(value, name) {
+    if (!value || !value.trim()) {
+        throw new errors_1.ValidationError(`${name} must be a non-empty string`, { code: "RWA_DVP_FIELD_REQUIRED", field: name });
+    }
+}
+function assertPositiveInteger(value, name) {
+    normalizeInteger(value);
+    if (BigInt(value) <= 0n) {
+        throw new errors_1.ValidationError(`${name} must be positive`, { code: "RWA_DVP_AMOUNT_INVALID", field: name });
+    }
+}
+function normalizeInteger(value) {
+    const text = typeof value === "bigint" ? value.toString() : String(value).trim();
+    if (!/^[0-9]+$/u.test(text)) {
+        throw new errors_1.ValidationError("amount must be an integer string", { code: "RWA_DVP_AMOUNT_INVALID" });
+    }
+    return BigInt(text).toString();
+}
+function assertFutureishDate(value, name) {
+    const time = new Date(value).getTime();
+    if (!Number.isFinite(time)) {
+        throw new errors_1.ValidationError(`${name} must be a valid date`, { code: "RWA_DVP_DATE_INVALID", field: name });
+    }
+}
+function normalizeIso(value) {
+    return new Date(value).toISOString();
+}

package/dist/index.d.ts

@@ -18,4 +18,6 @@ export { validateBondDefinition, validateBondIssuanceState, validateBondCrossChe
 export { summarizeBondSettlementDescriptor, validateBondSettlementDescriptor, validateBondSettlementMatchesExpected, } from "./domain/bondSettlementValidation";
 export { summarizeFundDefinition, summarizeCapitalCallState, summarizeLPPositionReceipt, summarizeDistributionDescriptor, summarizeFundClosingDescriptor, summarizeFundFinalityPayload, validateFundDefinition, validateCapitalCallState, validateLPPositionReceipt, validateDistributionDescriptor, validateFundClosingDescriptor, validateFundCrossChecks, validateDistributionAgainstReceipt, validateClosingAgainstReceipt, buildClaimedCapitalCallState, buildRefundedCapitalCallState, buildLPPositionReceipt, applyDistributionToReceipt, applyDistributionsToReceipt, buildDistributionDescriptor, buildFundClosingDescriptor, } from "./domain/fundValidation";
 export { applyReceivableRepayment, buildDefaultedReceivableState, buildFundedReceivableState, buildReceivableClosingDescriptor, buildReceivableFundingClaimDescriptor, buildReceivableRepaymentClaimDescriptor, summarizeReceivableClosingDescriptor, summarizeReceivableDefinition, summarizeReceivableFundingClaimDescriptor, summarizeReceivableRepaymentClaimDescriptor, summarizeReceivableState, validateReceivableClosingAgainstState, validateReceivableClosingDescriptor, validateReceivableDefinition, validateReceivableFundingClaimAgainstState, validateReceivableFundingClaimDescriptor, validateReceivableRepaymentClaimAgainstState, validateReceivableRepaymentClaimDescriptor, validateReceivableState, validateReceivableCrossChecks, validateReceivableFundingTransition, validateReceivableRepaymentTransition, validateReceivableWriteOffTransition, verifyReceivableStateHistory as verifyReceivableStateHistoryValidation, } from "./domain/receivableValidation";
+export { RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION, RWA_DVP_EVIDENCE_SCHEMA_VERSION, RWA_DVP_PURCHASE_SCHEMA_VERSION, RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION, RWA_DVP_VERIFICATION_SCHEMA_VERSION, buildPaymentRequirements as buildRwaDvpPaymentRequirements, definePurchase as defineRwaDvpPurchase, exportEvidence as exportRwaDvpEvidence, prepareDeliveryClaim as prepareRwaDvpDeliveryClaim, prepareRefundClaim as prepareRwaDvpRefundClaim, summarizePurchase as summarizeRwaDvpPurchase, verifyDeliveryClaim as verifyRwaDvpDeliveryClaim, verifyPaymentPset as verifyRwaDvpPaymentPset, verifyRefundClaim as verifyRwaDvpRefundClaim, } from "./domain/rwaDvp";
+export type { RwaDvpDefinePurchaseInput, RwaDvpDeliveryClaimDescriptor, RwaDvpEvidenceBundle, RwaDvpEvmLockReference, RwaDvpPaymentAsset, RwaDvpPreparedPurchase, RwaDvpPrepareDeliveryClaimInput, RwaDvpPrepareRefundClaimInput, RwaDvpPurchaseDefinition, RwaDvpRefundClaimDescriptor, RwaDvpSummary, RwaDvpVerificationReport, } from "./domain/rwaDvp";
 export { compilePolicyStateContract, buildPolicyOutputDescriptor, listPolicyTemplates, loadPolicyTemplateManifest, validatePolicyTemplateManifest, describePolicyTemplate, validatePolicyTemplateParams, issue, prepareTransfer, executeTransfer, inspectTransfer, verifyState, verifyTransfer, exportEvidence as exportPolicyEvidence, summarizePolicyState, summarizePolicyOutputDescriptor, summarizePolicyTransferDescriptor, validatePolicyState, validatePolicyOutputDescriptor, validatePolicyTransferDescriptor, } from "./domain/policies";

package/dist/index.js

@@ -16,8 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.signPositionReceipt = exports.verifyCapitalCall = exports.executeCapitalCallRefund = exports.inspectCapitalCallRefund = exports.executeCapitalCallRollover = exports.inspectCapitalCallRollover = exports.executeCapitalCallClaim = exports.inspectCapitalCallClaim = exports.prepareCapitalCall = exports.loadFund = exports.verifyFund = exports.defineFund = exports.exportFinalityPayload = exports.exportBondEvidence = exports.verifyClosing = exports.executeClosing = exports.inspectClosing = exports.prepareClosing = exports.verifySettlement = exports.buildSettlement = exports.verifyRedemption = exports.executeRedemption = exports.inspectRedemption = exports.prepareRedemption = exports.issueBond = exports.loadBond = exports.verifyIssuanceHistory = exports.verifyBond = exports.defineBond = exports.verifyStateDescriptorAgainstArtifact = exports.verifyStateAgainstArtifact = exports.buildArtifactStateMetadata = exports.loadStateInput = exports.verifyDefinitionDescriptorAgainstArtifact = exports.verifyDefinitionAgainstArtifact = exports.buildArtifactDefinitionMetadata = exports.loadDefinitionInput = exports.evaluateOutputBindingSupport = exports.describeOutputBindingSupport = exports.normalizeArtifact = exports.saveArtifact = exports.loadArtifact = exports.getPresetOrThrow = exports.listPresets = exports.ElementsRpcClient = exports.RelayerClient = exports.DeployedContract = exports.CompiledContract = exports.SimplicityClient = exports.createSimplicityClient = void 0;
 exports.validateFundDefinition = exports.summarizeFundFinalityPayload = exports.summarizeFundClosingDescriptor = exports.summarizeDistributionDescriptor = exports.summarizeLPPositionReceipt = exports.summarizeCapitalCallState = exports.summarizeFundDefinition = exports.validateBondSettlementMatchesExpected = exports.validateBondSettlementDescriptor = exports.summarizeBondSettlementDescriptor = exports.verifyBondIssuanceHistory = exports.summarizeBondIssuanceState = exports.buildRedeemedBondIssuanceState = exports.validateBondStateTransition = exports.validateBondCrossChecks = exports.validateBondIssuanceState = exports.validateBondDefinition = exports.exportReceivableFinalityPayload = exports.exportReceivableEvidence = exports.verifyReceivableStateHistory = exports.verifyReceivableClosing = exports.prepareReceivableClosing = exports.verifyReceivableWriteOff = exports.prepareReceivableWriteOff = exports.verifyReceivableRepaymentClaim = exports.executeReceivableRepaymentClaim = exports.inspectReceivableRepaymentClaim = exports.prepareReceivableRepaymentClaim = exports.verifyReceivableRepayment = exports.prepareReceivableRepayment = exports.verifyReceivableFundingClaim = exports.executeReceivableFundingClaim = exports.inspectReceivableFundingClaim = exports.prepareReceivableFundingClaim = exports.verifyReceivableFunding = exports.prepareReceivableFunding = exports.loadReceivable = exports.verifyReceivable = exports.defineReceivable = exports.exportFundFinalityPayload = exports.exportFundEvidence = exports.verifyFundClosing = exports.prepareFundClosing = exports.verifyDistribution = exports.executeDistributionClaim = exports.inspectDistributionClaim = exports.reconcilePosition = exports.prepareDistribution = exports.verifyPositionReceiptChain = exports.verifyPositionReceipt = void 0;
-exports.verifyState = exports.inspectTransfer = exports.executeTransfer = exports.prepareTransfer = exports.issue = exports.validatePolicyTemplateParams = exports.describePolicyTemplate = exports.validatePolicyTemplateManifest = exports.loadPolicyTemplateManifest = exports.listPolicyTemplates = exports.buildPolicyOutputDescriptor = exports.compilePolicyStateContract = exports.verifyReceivableStateHistoryValidation = exports.validateReceivableWriteOffTransition = exports.validateReceivableRepaymentTransition = exports.validateReceivableFundingTransition = exports.validateReceivableCrossChecks = exports.validateReceivableState = exports.validateReceivableRepaymentClaimDescriptor = exports.validateReceivableRepaymentClaimAgainstState = exports.validateReceivableFundingClaimDescriptor = exports.validateReceivableFundingClaimAgainstState = exports.validateReceivableDefinition = exports.validateReceivableClosingDescriptor = exports.validateReceivableClosingAgainstState = exports.summarizeReceivableState = exports.summarizeReceivableRepaymentClaimDescriptor = exports.summarizeReceivableFundingClaimDescriptor = exports.summarizeReceivableDefinition = exports.summarizeReceivableClosingDescriptor = exports.buildReceivableRepaymentClaimDescriptor = exports.buildReceivableFundingClaimDescriptor = exports.buildReceivableClosingDescriptor = exports.buildFundedReceivableState = exports.buildDefaultedReceivableState = exports.applyReceivableRepayment = exports.buildFundClosingDescriptor = exports.buildDistributionDescriptor = exports.applyDistributionsToReceipt = exports.applyDistributionToReceipt = exports.buildLPPositionReceipt = exports.buildRefundedCapitalCallState = exports.buildClaimedCapitalCallState = exports.validateClosingAgainstReceipt = exports.validateDistributionAgainstReceipt = exports.validateFundCrossChecks = exports.validateFundClosingDescriptor = exports.validateDistributionDescriptor = exports.validateLPPositionReceipt = exports.validateCapitalCallState = void 0;
-exports.validatePolicyTransferDescriptor = exports.validatePolicyOutputDescriptor = exports.validatePolicyState = exports.summarizePolicyTransferDescriptor = exports.summarizePolicyOutputDescriptor = exports.summarizePolicyState = exports.exportPolicyEvidence = exports.verifyTransfer = void 0;
+exports.verifyRwaDvpDeliveryClaim = exports.summarizeRwaDvpPurchase = exports.prepareRwaDvpRefundClaim = exports.prepareRwaDvpDeliveryClaim = exports.exportRwaDvpEvidence = exports.defineRwaDvpPurchase = exports.buildRwaDvpPaymentRequirements = exports.RWA_DVP_VERIFICATION_SCHEMA_VERSION = exports.RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION = exports.RWA_DVP_PURCHASE_SCHEMA_VERSION = exports.RWA_DVP_EVIDENCE_SCHEMA_VERSION = exports.RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION = exports.verifyReceivableStateHistoryValidation = exports.validateReceivableWriteOffTransition = exports.validateReceivableRepaymentTransition = exports.validateReceivableFundingTransition = exports.validateReceivableCrossChecks = exports.validateReceivableState = exports.validateReceivableRepaymentClaimDescriptor = exports.validateReceivableRepaymentClaimAgainstState = exports.validateReceivableFundingClaimDescriptor = exports.validateReceivableFundingClaimAgainstState = exports.validateReceivableDefinition = exports.validateReceivableClosingDescriptor = exports.validateReceivableClosingAgainstState = exports.summarizeReceivableState = exports.summarizeReceivableRepaymentClaimDescriptor = exports.summarizeReceivableFundingClaimDescriptor = exports.summarizeReceivableDefinition = exports.summarizeReceivableClosingDescriptor = exports.buildReceivableRepaymentClaimDescriptor = exports.buildReceivableFundingClaimDescriptor = exports.buildReceivableClosingDescriptor = exports.buildFundedReceivableState = exports.buildDefaultedReceivableState = exports.applyReceivableRepayment = exports.buildFundClosingDescriptor = exports.buildDistributionDescriptor = exports.applyDistributionsToReceipt = exports.applyDistributionToReceipt = exports.buildLPPositionReceipt = exports.buildRefundedCapitalCallState = exports.buildClaimedCapitalCallState = exports.validateClosingAgainstReceipt = exports.validateDistributionAgainstReceipt = exports.validateFundCrossChecks = exports.validateFundClosingDescriptor = exports.validateDistributionDescriptor = exports.validateLPPositionReceipt = exports.validateCapitalCallState = void 0;
+exports.validatePolicyTransferDescriptor = exports.validatePolicyOutputDescriptor = exports.validatePolicyState = exports.summarizePolicyTransferDescriptor = exports.summarizePolicyOutputDescriptor = exports.summarizePolicyState = exports.exportPolicyEvidence = exports.verifyTransfer = exports.verifyState = exports.inspectTransfer = exports.executeTransfer = exports.prepareTransfer = exports.issue = exports.validatePolicyTemplateParams = exports.describePolicyTemplate = exports.validatePolicyTemplateManifest = exports.loadPolicyTemplateManifest = exports.listPolicyTemplates = exports.buildPolicyOutputDescriptor = exports.compilePolicyStateContract = exports.verifyRwaDvpRefundClaim = exports.verifyRwaDvpPaymentPset = void 0;
 var SimplicityClient_1 = require("./client/SimplicityClient");
 Object.defineProperty(exports, "createSimplicityClient", { enumerable: true, get: function () { return SimplicityClient_1.createSimplicityClient; } });
 Object.defineProperty(exports, "SimplicityClient", { enumerable: true, get: function () { return SimplicityClient_1.SimplicityClient; } });
@@ -176,6 +176,21 @@ Object.defineProperty(exports, "validateReceivableFundingTransition", { enumerab
 Object.defineProperty(exports, "validateReceivableRepaymentTransition", { enumerable: true, get: function () { return receivableValidation_1.validateReceivableRepaymentTransition; } });
 Object.defineProperty(exports, "validateReceivableWriteOffTransition", { enumerable: true, get: function () { return receivableValidation_1.validateReceivableWriteOffTransition; } });
 Object.defineProperty(exports, "verifyReceivableStateHistoryValidation", { enumerable: true, get: function () { return receivableValidation_1.verifyReceivableStateHistory; } });
+var rwaDvp_1 = require("./domain/rwaDvp");
+Object.defineProperty(exports, "RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION", { enumerable: true, get: function () { return rwaDvp_1.RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "RWA_DVP_EVIDENCE_SCHEMA_VERSION", { enumerable: true, get: function () { return rwaDvp_1.RWA_DVP_EVIDENCE_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "RWA_DVP_PURCHASE_SCHEMA_VERSION", { enumerable: true, get: function () { return rwaDvp_1.RWA_DVP_PURCHASE_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION", { enumerable: true, get: function () { return rwaDvp_1.RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "RWA_DVP_VERIFICATION_SCHEMA_VERSION", { enumerable: true, get: function () { return rwaDvp_1.RWA_DVP_VERIFICATION_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "buildRwaDvpPaymentRequirements", { enumerable: true, get: function () { return rwaDvp_1.buildPaymentRequirements; } });
+Object.defineProperty(exports, "defineRwaDvpPurchase", { enumerable: true, get: function () { return rwaDvp_1.definePurchase; } });
+Object.defineProperty(exports, "exportRwaDvpEvidence", { enumerable: true, get: function () { return rwaDvp_1.exportEvidence; } });
+Object.defineProperty(exports, "prepareRwaDvpDeliveryClaim", { enumerable: true, get: function () { return rwaDvp_1.prepareDeliveryClaim; } });
+Object.defineProperty(exports, "prepareRwaDvpRefundClaim", { enumerable: true, get: function () { return rwaDvp_1.prepareRefundClaim; } });
+Object.defineProperty(exports, "summarizeRwaDvpPurchase", { enumerable: true, get: function () { return rwaDvp_1.summarizePurchase; } });
+Object.defineProperty(exports, "verifyRwaDvpDeliveryClaim", { enumerable: true, get: function () { return rwaDvp_1.verifyDeliveryClaim; } });
+Object.defineProperty(exports, "verifyRwaDvpPaymentPset", { enumerable: true, get: function () { return rwaDvp_1.verifyPaymentPset; } });
+Object.defineProperty(exports, "verifyRwaDvpRefundClaim", { enumerable: true, get: function () { return rwaDvp_1.verifyRefundClaim; } });
 var policies_1 = require("./domain/policies");
 Object.defineProperty(exports, "compilePolicyStateContract", { enumerable: true, get: function () { return policies_1.compilePolicyStateContract; } });
 Object.defineProperty(exports, "buildPolicyOutputDescriptor", { enumerable: true, get: function () { return policies_1.buildPolicyOutputDescriptor; } });

package/dist/x402/index.d.ts

@@ -152,6 +152,10 @@ export type DecodePsbtResult = {
             address?: string;
             hex?: string;
         };
+        scriptPubKey?: {
+            address?: string;
+            hex?: string;
+        };
     }>;
 };
 export type LiquidX402LwkWasmModule = {

package/dist/x402/index.js

@@ -219,6 +219,9 @@ async function prepareLiquidX402LwkWasmPayment(input) {
     if (requirements.extra.asset === "lbtc") {
         builder = builder.addLbtcRecipient(recipient, amount);
     }
+    else if (typeof recipient.isBlinded === "function" && recipient.isBlinded() === false && typeof builder.addExplicitRecipient === "function") {
+        builder = builder.addExplicitRecipient(recipient, amount, parseLwkAssetId(lwk, requirements.asset));
+    }
     else {
         builder = builder.addRecipient(recipient, amount, parseLwkAssetId(lwk, requirements.asset));
     }
@@ -270,12 +273,13 @@ async function verifyLiquidX402Payment(rpc, input) {
         return basic;
     }
     try {
+        const expectedTarget = await resolveExpectedLiquidOutputTarget(rpc, requirements);
         const decoded = await rpc.call("decodepsbt", [payload.psetBase64]);
         const actualSummaryHash = buildLiquidPsetSummaryHash(decoded, requirements);
         if (actualSummaryHash !== payload.summaryHash) {
             return { ...basic, isValid: false, invalidReason: "pset_summary_mismatch" };
         }
-        if (!decodedContainsExpectedOutput(decoded, requirements)) {
+        if (!decodedContainsExpectedOutput(decoded, requirements, expectedTarget)) {
             return { ...basic, isValid: false, invalidReason: "pset_expected_output_missing" };
         }
         if (!decodedFeeWithinCap(decoded, requirements)) {
@@ -302,7 +306,7 @@ async function settleLiquidX402Payment(rpc, input) {
         if (mempool[0]?.allowed !== true) {
             return {
                 success: false,
-                errorCode: mempool[0]?.reject_reason || "mempool_rejected",
+                errorCode: mempoolRejectReason(mempool[0]),
                 rawTxHex: finalized.hex,
                 summaryHash: payload.summaryHash,
             };
@@ -376,12 +380,62 @@ function buildLiquidPsetSummaryHash(_decoded, requirements) {
         maxFeeSat: req.extra.maxFeeSat ?? null,
     }));
 }
-function decodedContainsExpectedOutput(decoded, requirements) {
+function decodedContainsExpectedOutput(decoded, requirements, expectedTarget = buildFallbackExpectedLiquidOutputTarget(requirements)) {
     const expectedAmount = atomicToDecimalNumber(requirements.maxAmountRequired, requirements.extra.decimals);
     return (decoded.outputs ?? []).some((output) => (String(output.asset ?? "").toLowerCase() === requirements.asset.toLowerCase() &&
         Math.round(Number(output.amount ?? 0) * 10 ** requirements.extra.decimals) ===
             Math.round(expectedAmount * 10 ** requirements.extra.decimals) &&
-        String(output.script?.address ?? "") === requirements.payTo));
+        decodedOutputMatchesLiquidTarget(output, expectedTarget)));
+}
+async function resolveExpectedLiquidOutputTarget(rpc, requirements) {
+    const target = buildFallbackExpectedLiquidOutputTarget(requirements);
+    try {
+        const info = await rpc.call("validateaddress", [requirements.payTo]);
+        if (info?.isvalid !== false) {
+            addNormalizedAddress(target.addresses, info.address);
+            addNormalizedAddress(target.addresses, info.unconfidential);
+            addNormalizedAddress(target.addresses, info.confidential);
+            addNormalizedHex(target.scriptHexes, info.scriptPubKey);
+        }
+    }
+    catch {
+        // Older or mocked RPC clients may not expose validateaddress. Exact payTo
+        // matching remains safe for unconfidential outputs in that case.
+    }
+    return target;
+}
+function buildFallbackExpectedLiquidOutputTarget(requirements) {
+    const target = { addresses: new Set(), scriptHexes: new Set() };
+    addNormalizedAddress(target.addresses, requirements.payTo);
+    return target;
+}
+function decodedOutputMatchesLiquidTarget(output, expectedTarget) {
+    const address = output.script?.address ?? output.scriptPubKey?.address;
+    const scriptHex = output.script?.hex ?? output.scriptPubKey?.hex;
+    return (expectedTarget.addresses.has(normalizeAddressForComparison(address)) ||
+        expectedTarget.scriptHexes.has(normalizeHexForComparison(scriptHex)));
+}
+function addNormalizedAddress(target, value) {
+    const normalized = normalizeAddressForComparison(value);
+    if (normalized)
+        target.add(normalized);
+}
+function addNormalizedHex(target, value) {
+    const normalized = normalizeHexForComparison(value);
+    if (normalized)
+        target.add(normalized);
+}
+function normalizeAddressForComparison(value) {
+    return String(value ?? "").trim().toLowerCase();
+}
+function normalizeHexForComparison(value) {
+    return String(value ?? "").trim().toLowerCase().replace(/^0x/u, "");
+}
+function mempoolRejectReason(result) {
+    if (!result || typeof result !== "object")
+        return "mempool_rejected";
+    const raw = result;
+    return String(raw["reject-reason"] ?? raw.reject_reason ?? raw.error ?? "mempool_rejected").trim() || "mempool_rejected";
 }
 function coerceRequirements(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -454,7 +508,17 @@ function ensureLwkWasmNodeTimerCompat() {
     }
 }
 function parseLwkAddress(lwk, address, network) {
-    return typeof lwk.Address.parse === "function" ? lwk.Address.parse(address, network) : new lwk.Address(address);
+    if (typeof lwk.Address.parse === "function") {
+        try {
+            return lwk.Address.parse(address, network);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes("non-blinded"))
+                throw error;
+        }
+    }
+    return new lwk.Address(address);
 }
 function parseLwkAssetId(lwk, assetId) {
     return typeof lwk.AssetId.fromString === "function" ? lwk.AssetId.fromString(assetId) : new lwk.AssetId(assetId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazbase/simplicity",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "An SDK for Simplicity on Liquid",
   "author": "IndieSquare Inc <info@hazbase.com>",
   "keywords": [