@hazbase/simplicity 0.4.2 → 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,6 +163,12 @@ 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
@@ -192,6 +203,81 @@ 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/domain/rwaDvp.d.ts

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

package/dist/domain/rwaDvp.js

@@ -48,6 +48,7 @@ function definePurchase(_sdk, input) {
         network,
         evmLock: {
             ...input.evmLock,
+            tokenStandard: input.evmLock.tokenStandard ?? "ERC3475",
             amountAtomic: normalizeInteger(input.evmLock.amountAtomic),
         },
         payment: {

package/dist/index.d.ts

@@ -19,5 +19,5 @@ export { summarizeBondSettlementDescriptor, validateBondSettlementDescriptor, va
 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, compileEscrowContract as compileRwaDvpEscrowContract, definePurchase as defineRwaDvpPurchase, executeDeliveryClaim as executeRwaDvpDeliveryClaim, executeRefundClaim as executeRwaDvpRefundClaim, exportEvidence as exportRwaDvpEvidence, inspectDeliveryClaim as inspectRwaDvpDeliveryClaim, inspectRefundClaim as inspectRwaDvpRefundClaim, prepareDeliveryClaim as prepareRwaDvpDeliveryClaim, prepareRefundClaim as prepareRwaDvpRefundClaim, summarizePurchase as summarizeRwaDvpPurchase, verifyDeliveryClaim as verifyRwaDvpDeliveryClaim, verifyPaymentPset as verifyRwaDvpPaymentPset, verifyRefundClaim as verifyRwaDvpRefundClaim, } from "./domain/rwaDvp";
-export type { RwaDvpDefinePurchaseInput, RwaDvpClaimOutputBinding, RwaDvpCompiledEscrowContract, RwaDvpCompileEscrowContractInput, RwaDvpDeliveryClaimDescriptor, RwaDvpDeliveryClaimExecution, RwaDvpDeliveryClaimInspection, RwaDvpEvidenceBundle, RwaDvpEvmLockReference, RwaDvpExecuteDeliveryClaimInput, RwaDvpExecuteRefundClaimInput, RwaDvpInspectDeliveryClaimInput, RwaDvpInspectRefundClaimInput, RwaDvpPaymentAsset, RwaDvpPreparedPurchase, RwaDvpPrepareDeliveryClaimInput, RwaDvpPrepareRefundClaimInput, RwaDvpPurchaseDefinition, RwaDvpRefundClaimDescriptor, RwaDvpRefundClaimExecution, RwaDvpRefundClaimInspection, RwaDvpSummary, RwaDvpVerificationReport, } from "./domain/rwaDvp";
+export type { RwaDvpDefinePurchaseInput, RwaDvpClaimOutputBinding, RwaDvpCompiledEscrowContract, RwaDvpCompileEscrowContractInput, RwaDvpDeliveryClaimDescriptor, RwaDvpDeliveryClaimExecution, RwaDvpDeliveryClaimInspection, RwaDvpEvidenceBundle, RwaDvpEvmLockReference, RwaDvpEvmTokenStandard, RwaDvpExecuteDeliveryClaimInput, RwaDvpExecuteRefundClaimInput, RwaDvpInspectDeliveryClaimInput, RwaDvpInspectRefundClaimInput, RwaDvpPaymentAsset, RwaDvpPreparedPurchase, RwaDvpPrepareDeliveryClaimInput, RwaDvpPrepareRefundClaimInput, RwaDvpPurchaseDefinition, RwaDvpRefundClaimDescriptor, RwaDvpRefundClaimExecution, RwaDvpRefundClaimInspection, 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/x402/atomicDvp.d.ts

@@ -0,0 +1,197 @@
+export declare const LIQUID_ATOMIC_DVP_PSET_SCHEME: "rwa-liquid-atomic-dvp-pset";
+export declare const LIQUID_ATOMIC_DVP_PSET_MODE: "service_cosign_atomic_pset_v1";
+export type LiquidAtomicDvpNetwork = "liquidtestnet" | "liquidv1";
+export interface LiquidAtomicDvpOutputRequirement {
+    assetId: string;
+    amountAtomic: string;
+    recipient: string;
+}
+export interface LiquidAtomicDvpServiceSigner {
+    type: "operator_wallet" | "simplicity";
+    xonly?: string;
+}
+export interface LiquidAtomicDvpRequirementsInput {
+    network?: LiquidAtomicDvpNetwork;
+    paymentRequestId: string;
+    resource: string;
+    termsHash: string;
+    policyHash?: string | null;
+    expiresAt: string | Date;
+    maxTimeoutSeconds?: number;
+    description?: string;
+    mimeType?: string;
+    payment: {
+        assetId: string;
+        amountAtomic: string | number | bigint;
+        recipient: string;
+    };
+    delivery: {
+        assetId: string;
+        amountAtomic: string | number | bigint;
+        recipient: string;
+    };
+    maxFeeSat?: string | number | bigint;
+    serviceSigner?: LiquidAtomicDvpServiceSigner | null;
+}
+export interface LiquidAtomicDvpRequirements {
+    scheme: typeof LIQUID_ATOMIC_DVP_PSET_SCHEME;
+    mode: typeof LIQUID_ATOMIC_DVP_PSET_MODE;
+    network: LiquidAtomicDvpNetwork;
+    paymentRequestId: string;
+    resource: string;
+    description: string;
+    mimeType: string;
+    expiresAt: string;
+    maxTimeoutSeconds: number;
+    termsHash: string;
+    policyHash: string | null;
+    summaryHash: string;
+    maxFeeSat: string | null;
+    outputs: {
+        paymentToTreasury: LiquidAtomicDvpOutputRequirement;
+        rwaToBuyer: LiquidAtomicDvpOutputRequirement;
+    };
+    serviceSigner: LiquidAtomicDvpServiceSigner | null;
+    extra: {
+        settlementMode: typeof LIQUID_ATOMIC_DVP_PSET_MODE;
+        payment: LiquidAtomicDvpOutputRequirement;
+        delivery: LiquidAtomicDvpOutputRequirement;
+        feeAsset: "lbtc";
+        maxFeeSat: string | null;
+    };
+}
+export interface LiquidAtomicDvpPaymentPayload {
+    scheme: typeof LIQUID_ATOMIC_DVP_PSET_SCHEME;
+    mode?: typeof LIQUID_ATOMIC_DVP_PSET_MODE;
+    network: LiquidAtomicDvpNetwork;
+    paymentRequestId: string;
+    psetBase64: string;
+    summaryHash: string;
+    expiresAt?: string;
+    payer?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LiquidAtomicDvpLwkWasmModule {
+    Address: {
+        new (value: string): any;
+        parse?: (value: string, network: any) => any;
+    };
+    AssetId: {
+        new (value: string): any;
+        fromString?: (value: string) => any;
+    };
+    EsploraClient: new (network: any, url: string, waterfalls: boolean, concurrency: number, utxoOnly: boolean) => any;
+    Mnemonic: new (value: string) => any;
+    Network: {
+        mainnet: () => any;
+        testnet: () => any;
+    };
+    OutPoint: {
+        new (value: string): any;
+    };
+    Pset: {
+        new (value: string): any;
+    };
+    Signer: new (mnemonic: any, network: any) => any;
+    Transaction?: {
+        new (value: string): any;
+        fromString?: (value: string) => any;
+    };
+    UnvalidatedLiquidexProposal: {
+        fromPset: (pset: any) => any;
+        new?: (value: string) => any;
+    };
+    Wollet: new (network: any, descriptor: any) => any;
+}
+export interface LiquidAtomicDvpPrepareMakerProposalInput {
+    requirements: LiquidAtomicDvpRequirements | Record<string, unknown>;
+    mnemonic: string;
+    deliveryOutpoint?: string;
+    esploraUrl?: string;
+    waterfalls?: boolean;
+    concurrency?: number;
+    utxoOnly?: boolean;
+    scan?: boolean;
+    scanToIndex?: number;
+    feeRate?: number;
+    sign?: boolean;
+    lwk?: LiquidAtomicDvpLwkWasmModule;
+    importLwk?: () => Promise<LiquidAtomicDvpLwkWasmModule>;
+}
+export interface LiquidAtomicDvpPrepareMakerProposalResult {
+    proposalPsetBase64: string;
+    proposal: string;
+    deliveryOutpoint: string;
+    deliveryAssetId: string;
+    deliveryAmountAtomic: string;
+    paymentAssetId: string;
+    paymentAmountAtomic: string;
+    paymentRecipient: string;
+    summaryHash: string;
+    descriptor: string;
+    dwid?: string;
+}
+export interface LiquidAtomicDvpTakeProposalInput {
+    requirements: LiquidAtomicDvpRequirements | Record<string, unknown>;
+    mnemonic: string;
+    proposal?: string;
+    proposalPsetBase64?: string;
+    proposalTxHex?: string;
+    payer?: string;
+    esploraUrl?: string;
+    waterfalls?: boolean;
+    concurrency?: number;
+    utxoOnly?: boolean;
+    scan?: boolean;
+    scanToIndex?: number;
+    feeRate?: number;
+    finalize?: boolean;
+    lwk?: LiquidAtomicDvpLwkWasmModule;
+    importLwk?: () => Promise<LiquidAtomicDvpLwkWasmModule>;
+}
+export type LiquidAtomicDvpTakeProposalResult = ReturnType<typeof buildLiquidAtomicDvpPaymentFromPset> & {
+    descriptor: string;
+    dwid?: string;
+    proposalInput: LiquidAtomicDvpOutputRequirement;
+    proposalOutput: LiquidAtomicDvpOutputRequirement;
+};
+export interface LiquidAtomicDvpVerifyPayloadResult {
+    isValid: boolean;
+    invalidReason?: string;
+    network?: LiquidAtomicDvpNetwork;
+    paymentRequestId?: string;
+    summaryHash?: string;
+}
+export declare function buildLiquidAtomicDvpRequirements(input: LiquidAtomicDvpRequirementsInput): LiquidAtomicDvpRequirements;
+export declare function prepareLiquidAtomicDvpLwkWasmMakerProposal(input: LiquidAtomicDvpPrepareMakerProposalInput): Promise<LiquidAtomicDvpPrepareMakerProposalResult>;
+export declare function prepareLiquidAtomicDvpLwkWasmTakerPayment(input: LiquidAtomicDvpTakeProposalInput): Promise<LiquidAtomicDvpTakeProposalResult>;
+export declare function buildLiquidAtomicDvpSummaryHash(input: {
+    network: LiquidAtomicDvpNetwork;
+    paymentRequestId: string;
+    termsHash: string;
+    policyHash: string | null;
+    expiresAt: string;
+    maxFeeSat: string | null;
+    payment: LiquidAtomicDvpOutputRequirement;
+    delivery: LiquidAtomicDvpOutputRequirement;
+    serviceSigner: LiquidAtomicDvpServiceSigner | null;
+}): string;
+export declare function encodeLiquidAtomicDvpPayment(payload: LiquidAtomicDvpPaymentPayload): string;
+export declare function decodeLiquidAtomicDvpPayment(raw: string): LiquidAtomicDvpPaymentPayload | null;
+export declare function buildLiquidAtomicDvpPaymentFromPset(input: {
+    requirements: LiquidAtomicDvpRequirements | Record<string, unknown>;
+    psetBase64: string;
+    payer?: string;
+    metadata?: Record<string, unknown>;
+}): {
+    paymentPayload: LiquidAtomicDvpPaymentPayload;
+    xPayment: string;
+    psetBase64: string;
+    summaryHash: string;
+};
+export declare function verifyLiquidAtomicDvpPayment(input: {
+    requirements: LiquidAtomicDvpRequirements | Record<string, unknown>;
+    paymentPayload: LiquidAtomicDvpPaymentPayload | Record<string, unknown>;
+    now?: Date;
+}): LiquidAtomicDvpVerifyPayloadResult;
+export declare function coerceAtomicRequirements(value: LiquidAtomicDvpRequirements | Record<string, unknown>): LiquidAtomicDvpRequirements;

package/dist/x402/atomicDvp.js

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIQUID_ATOMIC_DVP_PSET_MODE = exports.LIQUID_ATOMIC_DVP_PSET_SCHEME = void 0;
+exports.buildLiquidAtomicDvpRequirements = buildLiquidAtomicDvpRequirements;
+exports.prepareLiquidAtomicDvpLwkWasmMakerProposal = prepareLiquidAtomicDvpLwkWasmMakerProposal;
+exports.prepareLiquidAtomicDvpLwkWasmTakerPayment = prepareLiquidAtomicDvpLwkWasmTakerPayment;
+exports.buildLiquidAtomicDvpSummaryHash = buildLiquidAtomicDvpSummaryHash;
+exports.encodeLiquidAtomicDvpPayment = encodeLiquidAtomicDvpPayment;
+exports.decodeLiquidAtomicDvpPayment = decodeLiquidAtomicDvpPayment;
+exports.buildLiquidAtomicDvpPaymentFromPset = buildLiquidAtomicDvpPaymentFromPset;
+exports.verifyLiquidAtomicDvpPayment = verifyLiquidAtomicDvpPayment;
+exports.coerceAtomicRequirements = coerceAtomicRequirements;
+const node_crypto_1 = require("node:crypto");
+const summary_1 = require("../core/summary");
+exports.LIQUID_ATOMIC_DVP_PSET_SCHEME = "rwa-liquid-atomic-dvp-pset";
+exports.LIQUID_ATOMIC_DVP_PSET_MODE = "service_cosign_atomic_pset_v1";
+;
+function buildLiquidAtomicDvpRequirements(input) {
+    const network = normalizeAtomicNetwork(input.network ?? "liquidtestnet");
+    const paymentRequestId = requiredString(input.paymentRequestId, "paymentRequestId");
+    const resource = requiredString(input.resource, "resource");
+    const termsHash = requiredString(input.termsHash, "termsHash");
+    const policyHash = input.policyHash ?? null;
+    const expiresAt = normalizeDateTime(input.expiresAt, "expiresAt");
+    const maxTimeoutSeconds = normalizeTimeout(input.maxTimeoutSeconds);
+    const payment = normalizeOutput(input.payment, "payment");
+    const delivery = normalizeOutput(input.delivery, "delivery");
+    const maxFeeSat = input.maxFeeSat === undefined ? null : normalizeInteger(input.maxFeeSat, "maxFeeSat");
+    const serviceSigner = normalizeServiceSigner(input.serviceSigner);
+    const summaryHash = buildLiquidAtomicDvpSummaryHash({
+        network,
+        paymentRequestId,
+        termsHash,
+        policyHash,
+        expiresAt,
+        maxFeeSat,
+        payment,
+        delivery,
+        serviceSigner,
+    });
+    return {
+        scheme: exports.LIQUID_ATOMIC_DVP_PSET_SCHEME,
+        mode: exports.LIQUID_ATOMIC_DVP_PSET_MODE,
+        network,
+        paymentRequestId,
+        resource,
+        description: String(input.description ?? "").trim() || "Hazbase RWA atomic Liquid DvP payment",
+        mimeType: String(input.mimeType ?? "").trim() || "application/json",
+        expiresAt,
+        maxTimeoutSeconds,
+        termsHash,
+        policyHash,
+        summaryHash,
+        maxFeeSat,
+        outputs: {
+            paymentToTreasury: payment,
+            rwaToBuyer: delivery,
+        },
+        serviceSigner,
+        extra: {
+            settlementMode: exports.LIQUID_ATOMIC_DVP_PSET_MODE,
+            payment,
+            delivery,
+            feeAsset: "lbtc",
+            maxFeeSat,
+        },
+    };
+}
+async function prepareLiquidAtomicDvpLwkWasmMakerProposal(input) {
+    const requirements = coerceAtomicRequirements(input.requirements);
+    ensureLwkWasmNodeTimerCompat();
+    const lwk = input.lwk ?? await loadLwkWasm(input.importLwk);
+    const { network, signer, descriptor, wollet } = await buildLwkContext(lwk, requirements.network, input.mnemonic, input);
+    const delivery = requirements.outputs.rwaToBuyer;
+    const payment = requirements.outputs.paymentToTreasury;
+    const deliveryUtxo = selectExactDeliveryUtxo(wollet, delivery, input.deliveryOutpoint);
+    const paymentRecipient = parseLwkAddress(lwk, payment.recipient, network);
+    let builder = network.txBuilder();
+    if (input.feeRate !== undefined)
+        builder = builder.feeRate(input.feeRate);
+    builder = builder.liquidexMake(deliveryUtxo.outpoint, paymentRecipient, BigInt(payment.amountAtomic), parseLwkAssetId(lwk, payment.assetId));
+    const unsigned = builder.finish(wollet);
+    const proposalPset = input.sign === false ? unsigned : signer.sign(unsigned);
+    const proposalPsetBase64 = proposalPset.toString();
+    const proposal = lwk.UnvalidatedLiquidexProposal.fromPset(proposalPset).toString();
+    return {
+        proposalPsetBase64,
+        proposal,
+        deliveryOutpoint: deliveryUtxo.outpointText,
+        deliveryAssetId: delivery.assetId,
+        deliveryAmountAtomic: delivery.amountAtomic,
+        paymentAssetId: payment.assetId,
+        paymentAmountAtomic: payment.amountAtomic,
+        paymentRecipient: payment.recipient,
+        summaryHash: requirements.summaryHash,
+        descriptor: descriptor.toString(),
+        ...(typeof wollet.dwid === "function" ? { dwid: wollet.dwid() } : {}),
+    };
+}
+async function prepareLiquidAtomicDvpLwkWasmTakerPayment(input) {
+    const requirements = coerceAtomicRequirements(input.requirements);
+    ensureLwkWasmNodeTimerCompat();
+    const lwk = input.lwk ?? await loadLwkWasm(input.importLwk);
+    const { network, signer, descriptor, wollet } = await buildLwkContext(lwk, requirements.network, input.mnemonic, input);
+    const proposal = parseLiquidexProposal(lwk, input.proposalPsetBase64 ?? input.proposal);
+    const validated = input.proposalTxHex
+        ? proposal.validate(parseLwkTransaction(lwk, input.proposalTxHex))
+        : proposal.insecureValidate();
+    const proposalInput = assetAmountRequirement(validated.input());
+    const proposalOutput = assetAmountRequirement(validated.output());
+    assertOutputMatches(proposalInput, requirements.outputs.rwaToBuyer, "Liquidex maker input");
+    assertOutputMatches(proposalOutput, requirements.outputs.paymentToTreasury, "Liquidex maker output");
+    let builder = network.txBuilder();
+    if (input.feeRate !== undefined)
+        builder = builder.feeRate(input.feeRate);
+    builder = builder.liquidexTake([validated]);
+    const unsigned = builder.finish(wollet);
+    const signed = signer.sign(unsigned);
+    const pset = input.finalize === false ? signed : wollet.finalize(signed);
+    const payment = buildLiquidAtomicDvpPaymentFromPset({
+        requirements,
+        psetBase64: pset.toString(),
+        payer: input.payer,
+    });
+    return {
+        ...payment,
+        descriptor: descriptor.toString(),
+        ...(typeof wollet.dwid === "function" ? { dwid: wollet.dwid() } : {}),
+        proposalInput,
+        proposalOutput,
+    };
+}
+function buildLiquidAtomicDvpSummaryHash(input) {
+    return sha256Hex((0, summary_1.stableStringify)({
+        scheme: exports.LIQUID_ATOMIC_DVP_PSET_SCHEME,
+        mode: exports.LIQUID_ATOMIC_DVP_PSET_MODE,
+        network: input.network,
+        paymentRequestId: input.paymentRequestId,
+        termsHash: input.termsHash,
+        policyHash: input.policyHash,
+        expiresAt: input.expiresAt,
+        maxFeeSat: input.maxFeeSat,
+        outputs: {
+            paymentToTreasury: input.payment,
+            rwaToBuyer: input.delivery,
+        },
+        serviceSigner: input.serviceSigner
+            ? {
+                type: input.serviceSigner.type,
+                xonly: input.serviceSigner.xonly ?? null,
+            }
+            : null,
+    }));
+}
+function encodeLiquidAtomicDvpPayment(payload) {
+    return Buffer.from(JSON.stringify(payload)).toString("base64url");
+}
+function decodeLiquidAtomicDvpPayment(raw) {
+    const value = String(raw ?? "").trim();
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        if (String(parsed.scheme ?? "") !== exports.LIQUID_ATOMIC_DVP_PSET_SCHEME)
+            return null;
+        return coerceAtomicPayload(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function buildLiquidAtomicDvpPaymentFromPset(input) {
+    const requirements = coerceAtomicRequirements(input.requirements);
+    const psetBase64 = requiredString(input.psetBase64, "psetBase64");
+    const paymentPayload = {
+        scheme: exports.LIQUID_ATOMIC_DVP_PSET_SCHEME,
+        mode: exports.LIQUID_ATOMIC_DVP_PSET_MODE,
+        network: requirements.network,
+        paymentRequestId: requirements.paymentRequestId,
+        psetBase64,
+        summaryHash: requirements.summaryHash,
+        expiresAt: requirements.expiresAt,
+        ...(input.payer ? { payer: input.payer } : {}),
+        ...(input.metadata ? { metadata: input.metadata } : {}),
+    };
+    return {
+        paymentPayload,
+        xPayment: encodeLiquidAtomicDvpPayment(paymentPayload),
+        psetBase64,
+        summaryHash: requirements.summaryHash,
+    };
+}
+function verifyLiquidAtomicDvpPayment(input) {
+    const requirements = coerceAtomicRequirements(input.requirements);
+    const payload = coerceAtomicPayload(input.paymentPayload);
+    const now = input.now ?? new Date();
+    const base = {
+        network: payload.network,
+        paymentRequestId: payload.paymentRequestId,
+        summaryHash: payload.summaryHash,
+    };
+    if (payload.scheme !== exports.LIQUID_ATOMIC_DVP_PSET_SCHEME) {
+        return { ...base, isValid: false, invalidReason: "scheme_mismatch" };
+    }
+    if (payload.network !== requirements.network)
+        return { ...base, isValid: false, invalidReason: "network_mismatch" };
+    if (payload.paymentRequestId !== requirements.paymentRequestId) {
+        return { ...base, isValid: false, invalidReason: "payment_request_id_mismatch" };
+    }
+    if (normalizeHexHash(payload.summaryHash) !== normalizeHexHash(requirements.summaryHash)) {
+        return { ...base, isValid: false, invalidReason: "summary_hash_mismatch" };
+    }
+    if (!payload.psetBase64)
+        return { ...base, isValid: false, invalidReason: "pset_missing" };
+    if (!looksBase64(payload.psetBase64))
+        return { ...base, isValid: false, invalidReason: "pset_invalid_base64" };
+    if (new Date(payload.expiresAt ?? requirements.expiresAt).getTime() <= now.getTime()) {
+        return { ...base, isValid: false, invalidReason: "payment_expired" };
+    }
+    return { ...base, isValid: true };
+}
+function coerceAtomicRequirements(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("atomic DvP requirements must be an object");
+    }
+    const raw = value;
+    const outputs = raw.outputs && typeof raw.outputs === "object" && !Array.isArray(raw.outputs) ? raw.outputs : {};
+    const extra = raw.extra && typeof raw.extra === "object" && !Array.isArray(raw.extra) ? raw.extra : {};
+    const payment = normalizeOutput(outputs.paymentToTreasury ?? extra.payment, "paymentToTreasury");
+    const delivery = normalizeOutput(outputs.rwaToBuyer ?? extra.delivery, "rwaToBuyer");
+    const network = normalizeAtomicNetwork(raw.network);
+    const policyHash = typeof raw.policyHash === "string" && raw.policyHash.trim() ? raw.policyHash.trim() : null;
+    const maxFeeSat = raw.maxFeeSat === null || raw.maxFeeSat === undefined ? null : normalizeInteger(raw.maxFeeSat, "maxFeeSat");
+    const serviceSigner = normalizeServiceSigner(raw.serviceSigner);
+    const fallbackSummaryHash = buildLiquidAtomicDvpSummaryHash({
+        network,
+        paymentRequestId: requiredString(raw.paymentRequestId, "paymentRequestId"),
+        termsHash: requiredString(raw.termsHash, "termsHash"),
+        policyHash,
+        expiresAt: normalizeDateTime(raw.expiresAt, "expiresAt"),
+        maxFeeSat,
+        payment,
+        delivery,
+        serviceSigner,
+    });
+    return {
+        scheme: exports.LIQUID_ATOMIC_DVP_PSET_SCHEME,
+        mode: exports.LIQUID_ATOMIC_DVP_PSET_MODE,
+        network,
+        paymentRequestId: requiredString(raw.paymentRequestId, "paymentRequestId"),
+        resource: requiredString(raw.resource, "resource"),
+        description: String(raw.description ?? "").trim() || "Hazbase RWA atomic Liquid DvP payment",
+        mimeType: String(raw.mimeType ?? "").trim() || "application/json",
+        expiresAt: normalizeDateTime(raw.expiresAt, "expiresAt"),
+        maxTimeoutSeconds: normalizeTimeout(raw.maxTimeoutSeconds),
+        termsHash: requiredString(raw.termsHash, "termsHash"),
+        policyHash,
+        summaryHash: typeof raw.summaryHash === "string" && raw.summaryHash.trim() ? raw.summaryHash.trim() : fallbackSummaryHash,
+        maxFeeSat,
+        outputs: {
+            paymentToTreasury: payment,
+            rwaToBuyer: delivery,
+        },
+        serviceSigner,
+        extra: {
+            settlementMode: exports.LIQUID_ATOMIC_DVP_PSET_MODE,
+            payment,
+            delivery,
+            feeAsset: "lbtc",
+            maxFeeSat,
+        },
+    };
+}
+function coerceAtomicPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("atomic DvP payment payload must be an object");
+    }
+    const raw = value;
+    return {
+        scheme: String(raw.scheme ?? exports.LIQUID_ATOMIC_DVP_PSET_SCHEME),
+        mode: raw.mode === exports.LIQUID_ATOMIC_DVP_PSET_MODE ? exports.LIQUID_ATOMIC_DVP_PSET_MODE : undefined,
+        network: normalizeAtomicNetwork(raw.network),
+        paymentRequestId: requiredString(raw.paymentRequestId, "paymentRequestId"),
+        psetBase64: requiredString(raw.psetBase64, "psetBase64"),
+        summaryHash: requiredString(raw.summaryHash, "summaryHash"),
+        expiresAt: typeof raw.expiresAt === "string" ? raw.expiresAt : undefined,
+        ...(typeof raw.payer === "string" && raw.payer.trim() ? { payer: raw.payer.trim() } : {}),
+        ...(raw.metadata && typeof raw.metadata === "object" && !Array.isArray(raw.metadata)
+            ? { metadata: raw.metadata }
+            : {}),
+    };
+}
+async function loadLwkWasm(importer) {
+    ensureLwkWasmNodeTimerCompat();
+    if (importer)
+        return importer();
+    const dynamicImport = new Function("specifier", "return import(specifier)");
+    const failures = [];
+    for (const specifier of ["lwk_wasm", "lwk_node"]) {
+        try {
+            const imported = await dynamicImport(specifier);
+            return imported.default ?? imported;
+        }
+        catch (error) {
+            failures.push(`${specifier}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    throw new Error("lwk_wasm or lwk_node is required for atomic Liquid DvP PSETs. " +
+        `Import failed: ${failures.join("; ")}`);
+}
+function ensureLwkWasmNodeTimerCompat() {
+    const scope = globalThis;
+    if (typeof scope.window === "undefined" && typeof scope.setTimeout === "function") {
+        scope.window = scope;
+    }
+    if (typeof scope.Window === "undefined" && typeof scope.window !== "undefined") {
+        scope.Window = Object;
+    }
+}
+async function buildLwkContext(lwk, networkKey, mnemonicText, options) {
+    const network = networkKey === "liquidv1" ? lwk.Network.mainnet() : lwk.Network.testnet();
+    const mnemonic = new lwk.Mnemonic(mnemonicText);
+    const signer = new lwk.Signer(mnemonic, network);
+    const descriptor = signer.wpkhSlip77Descriptor();
+    const wollet = new lwk.Wollet(network, descriptor);
+    if (options.scan !== false) {
+        const client = options.esploraUrl
+            ? new lwk.EsploraClient(network, options.esploraUrl, options.waterfalls ?? false, options.concurrency ?? 4, options.utxoOnly ?? false)
+            : network.defaultEsploraClient();
+        const update = options.scanToIndex !== undefined
+            ? await client.fullScanToIndex(wollet, options.scanToIndex)
+            : await client.fullScan(wollet);
+        if (update)
+            wollet.applyUpdate(update);
+    }
+    return { network, signer, descriptor, wollet };
+}
+function parseLwkAddress(lwk, address, network) {
+    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);
+}
+function parseLwkTransaction(lwk, txHex) {
+    if (lwk.Transaction?.fromString)
+        return lwk.Transaction.fromString(txHex);
+    if (lwk.Transaction)
+        return new lwk.Transaction(txHex);
+    throw new Error("LWK Transaction support is required to validate a Liquidex proposal against a transaction.");
+}
+function parseLiquidexProposal(lwk, value) {
+    const encoded = String(value ?? "").trim();
+    if (!encoded)
+        throw new Error("Liquidex proposal PSET is required");
+    try {
+        return lwk.UnvalidatedLiquidexProposal.fromPset(new lwk.Pset(encoded));
+    }
+    catch (psetError) {
+        if (typeof lwk.UnvalidatedLiquidexProposal.new === "function") {
+            try {
+                return lwk.UnvalidatedLiquidexProposal.new(encoded);
+            }
+            catch { }
+        }
+        throw psetError;
+    }
+}
+function selectExactDeliveryUtxo(wollet, delivery, requestedOutpoint) {
+    const utxos = typeof wollet.utxos === "function" ? wollet.utxos() : [];
+    for (const utxo of utxos) {
+        const outpoint = utxo.outpoint();
+        const outpointText = outpointString(outpoint);
+        if (requestedOutpoint && outpointText !== requestedOutpoint)
+            continue;
+        const secrets = utxo.unblinded();
+        const assetId = secrets?.asset?.().toString?.();
+        const amountAtomic = secrets?.value?.().toString?.();
+        if (assetId === delivery.assetId && amountAtomic === delivery.amountAtomic) {
+            return { outpoint, outpointText };
+        }
+    }
+    if (requestedOutpoint) {
+        throw new Error(`Delivery UTXO ${requestedOutpoint} is not an exact match for the atomic DvP delivery output.`);
+    }
+    throw new Error("No exact Liquid RWA UTXO is available for the atomic DvP delivery output.");
+}
+function outpointString(outpoint) {
+    try {
+        return `${outpoint.txid().toString()}:${outpoint.vout()}`;
+    }
+    catch {
+        return String(outpoint);
+    }
+}
+function assetAmountRequirement(value) {
+    return {
+        assetId: value.asset().toString(),
+        amountAtomic: value.amount().toString(),
+        recipient: "",
+    };
+}
+function assertOutputMatches(actual, expected, label) {
+    if (actual.assetId !== expected.assetId || actual.amountAtomic !== expected.amountAtomic) {
+        throw new Error(`${label} does not match atomic DvP requirements: ` +
+            `expected ${expected.amountAtomic} ${expected.assetId}, got ${actual.amountAtomic} ${actual.assetId}`);
+    }
+}
+function normalizeAtomicNetwork(value) {
+    if (value === "liquidv1")
+        return "liquidv1";
+    if (value === "liquidtestnet" || value === undefined || value === null || value === "")
+        return "liquidtestnet";
+    throw new Error(`unsupported Liquid atomic DvP network: ${String(value)}`);
+}
+function normalizeOutput(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${name} output requirement is required`);
+    }
+    const raw = value;
+    return {
+        assetId: requiredString(raw.assetId, `${name}.assetId`),
+        amountAtomic: normalizeInteger(raw.amountAtomic, `${name}.amountAtomic`),
+        recipient: requiredString(raw.recipient, `${name}.recipient`),
+    };
+}
+function normalizeServiceSigner(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const raw = value;
+    const type = raw.type === "simplicity" ? "simplicity" : raw.type === "operator_wallet" ? "operator_wallet" : null;
+    if (!type)
+        return null;
+    const xonly = typeof raw.xonly === "string" && raw.xonly.trim() ? raw.xonly.trim() : undefined;
+    return { type, ...(xonly ? { xonly } : {}) };
+}
+function normalizeInteger(value, name) {
+    const text = String(value ?? "").trim();
+    if (!/^\d+$/u.test(text))
+        throw new Error(`${name} must be a non-negative integer string`);
+    return BigInt(text).toString();
+}
+function normalizeDateTime(value, name) {
+    const date = value instanceof Date ? value : new Date(String(value ?? ""));
+    if (!Number.isFinite(date.getTime()))
+        throw new Error(`${name} must be a valid date`);
+    return date.toISOString();
+}
+function normalizeTimeout(value) {
+    const timeout = Number(value ?? 60);
+    if (!Number.isFinite(timeout) || timeout <= 0)
+        return 60;
+    return Math.floor(timeout);
+}
+function requiredString(value, name) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        throw new Error(`${name} is required`);
+    return text;
+}
+function looksBase64(value) {
+    return /^[A-Za-z0-9+/]+={0,2}$/u.test(value) || /^[A-Za-z0-9_-]+={0,2}$/u.test(value);
+}
+function sha256Hex(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value, "utf8").digest("hex");
+}
+function normalizeHexHash(value) {
+    return value.trim().toLowerCase().replace(/^0x/u, "");
+}

package/dist/x402/index.d.ts

@@ -1,4 +1,5 @@
 import { ElementsRpcClient } from "../core/rpc";
+export * from "./atomicDvp";
 export declare const LIQUID_X402_SCHEME: "exact-liquid-pset";
 export declare const LIQUID_X402_VERSION: 1;
 export declare const LIQUID_X402_DEFAULT_NETWORK: "liquidtestnet";

package/dist/x402/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIQUID_X402_ASSETS = exports.LIQUID_X402_DEFAULT_TIMEOUT_SECONDS = exports.LIQUID_X402_DEFAULT_NETWORK = exports.LIQUID_X402_VERSION = exports.LIQUID_X402_SCHEME = void 0;
 exports.listLiquidX402Assets = listLiquidX402Assets;
@@ -15,6 +29,7 @@ exports.settleLiquidX402Payment = settleLiquidX402Payment;
 exports.verifyLiquidX402PayloadFields = verifyLiquidX402PayloadFields;
 exports.buildLiquidPsetSummaryHash = buildLiquidPsetSummaryHash;
 const node_crypto_1 = require("node:crypto");
+__exportStar(require("./atomicDvp"), exports);
 exports.LIQUID_X402_SCHEME = "exact-liquid-pset";
 exports.LIQUID_X402_VERSION = 1;
 exports.LIQUID_X402_DEFAULT_NETWORK = "liquidtestnet";

package/package.json

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