@hazbase/simplicity 0.4.5 → 0.4.7

package/dist/domain/dampTransaction.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA = void 0;
+exports.normalizeStrictPolicyDecodedTransaction = normalizeStrictPolicyDecodedTransaction;
+exports.inspectStrictPolicyTransaction = inspectStrictPolicyTransaction;
+exports.inspectStrictPolicyTransactionWithProofs = inspectStrictPolicyTransactionWithProofs;
+const errors_1 = require("../core/errors");
+const summary_1 = require("../core/summary");
+const damp_1 = require("./damp");
+const dampPolicy_1 = require("./dampPolicy");
+exports.STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA = "hazbase_strict_policy_transaction_summary_v1";
+function invalid(field, message) {
+    throw new errors_1.ValidationError(`${field} ${message}`, {
+        code: "STRICT_POLICY_TRANSACTION_INVALID",
+        field,
+    });
+}
+function recordValue(value, field) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        invalid(field, "must be an object");
+    }
+    return value;
+}
+function stringValue(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        invalid(field, "must be a non-empty string");
+    }
+    return value.trim();
+}
+function hex32(value, field) {
+    const normalized = stringValue(value, field).toLowerCase().replace(/^0x/u, "");
+    if (!/^[0-9a-f]{64}$/u.test(normalized)) {
+        invalid(field, "must be 32 bytes of hex");
+    }
+    return normalized;
+}
+function uintDecimal(value, field) {
+    const normalized = stringValue(value, field);
+    if (!/^(0|[1-9][0-9]*)$/u.test(normalized)) {
+        invalid(field, "must be a canonical unsigned decimal string");
+    }
+    if (BigInt(normalized) > 0xffffffffffffffffn) {
+        invalid(field, "must fit in an unsigned 64-bit integer");
+    }
+    return normalized;
+}
+function uint32(value, field) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffff_ffff) {
+        invalid(field, "must be a uint32");
+    }
+    return value;
+}
+function booleanValue(value, field) {
+    if (typeof value !== "boolean")
+        invalid(field, "must be a boolean");
+    return value;
+}
+function normalizeOutpoint(value, field) {
+    const record = recordValue(value, field);
+    return {
+        txid: hex32(record.txid, `${field}.txid`),
+        vout: uint32(record.vout, `${field}.vout`),
+    };
+}
+function normalizeInput(value, index) {
+    const field = `transaction.inputs[${index}]`;
+    const record = recordValue(value, field);
+    return {
+        outpoint: normalizeOutpoint(record.outpoint, `${field}.outpoint`),
+        assetId: hex32(record.assetId, `${field}.assetId`),
+        amountAtomic: uintDecimal(record.amountAtomic, `${field}.amountAtomic`),
+        scriptHash: hex32(record.scriptHash, `${field}.scriptHash`),
+        hasIssuance: booleanValue(record.hasIssuance, `${field}.hasIssuance`),
+    };
+}
+function normalizeOutput(value, index) {
+    const field = `transaction.outputs[${index}]`;
+    const record = recordValue(value, field);
+    return {
+        assetId: hex32(record.assetId, `${field}.assetId`),
+        amountAtomic: uintDecimal(record.amountAtomic, `${field}.amountAtomic`),
+        scriptHash: hex32(record.scriptHash, `${field}.scriptHash`),
+        isFee: booleanValue(record.isFee, `${field}.isFee`),
+    };
+}
+function normalizeStrictPolicyDecodedTransaction(value) {
+    const record = recordValue(value, "transaction");
+    if (!Array.isArray(record.inputs) || record.inputs.length < 2) {
+        invalid("transaction.inputs", "must contain verifier input 0 and at least one strict asset input");
+    }
+    if (record.inputs.length > damp_1.STRICT_POLICY_VERIFIER_MAX_INPUTS) {
+        invalid("transaction.inputs", `must contain at most ${damp_1.STRICT_POLICY_VERIFIER_MAX_INPUTS} inputs for this policy profile`);
+    }
+    if (!Array.isArray(record.outputs) || record.outputs.length < 3) {
+        invalid("transaction.outputs", "must contain verifier, strict asset, and fee outputs");
+    }
+    if (record.outputs.length > damp_1.STRICT_POLICY_VERIFIER_MAX_OUTPUTS) {
+        invalid("transaction.outputs", `must contain at most ${damp_1.STRICT_POLICY_VERIFIER_MAX_OUTPUTS} outputs for this policy profile`);
+    }
+    const network = stringValue(record.network, "transaction.network");
+    if (!["liquid-regtest", "liquid-testnet", "liquid-mainnet"].includes(network)) {
+        invalid("transaction.network", "is unsupported");
+    }
+    return {
+        network: network,
+        inputs: record.inputs.map((input, index) => normalizeInput(input, index)),
+        outputs: record.outputs.map((output, index) => normalizeOutput(output, index)),
+        feeAmountAtomic: uintDecimal(record.feeAmountAtomic, "transaction.feeAmountAtomic"),
+    };
+}
+function sameOutpoint(left, right) {
+    return left.txid === right.txid && left.vout === right.vout;
+}
+function sumAmounts(values) {
+    return values.reduce((total, value) => total + BigInt(value), 0n);
+}
+/**
+ * Validates a complete, locally decoded transaction view. Callers must first
+ * verify the snapshot approval and must derive the allowed scripts from the
+ * snapshot's policy proof. This function does not decode a PSET or compute its
+ * Simplicity sighash.
+ */
+function inspectStrictPolicyTransaction(transactionValue, expectation) {
+    const transaction = normalizeStrictPolicyDecodedTransaction(transactionValue);
+    const snapshot = (0, damp_1.normalizeStrictPolicySnapshotPayload)(expectation.snapshot);
+    const operation = stringValue(expectation.operation, "expectation.operation");
+    if (!["purchase", "transfer", "redemption"].includes(operation)) {
+        invalid("expectation.operation", "is unsupported");
+    }
+    const feeAssetId = hex32(expectation.feeAssetId, "expectation.feeAssetId");
+    const maxFeeAmountAtomic = uintDecimal(expectation.maxFeeAmountAtomic, "expectation.maxFeeAmountAtomic");
+    if (!Array.isArray(expectation.allowedStrictOutputScriptHashes)
+        || expectation.allowedStrictOutputScriptHashes.length === 0) {
+        invalid("expectation.allowedStrictOutputScriptHashes", "must not be empty");
+    }
+    const allowedStrictOutputScriptHashes = new Set(expectation.allowedStrictOutputScriptHashes.map((value, index) => hex32(value, `expectation.allowedStrictOutputScriptHashes[${index}]`)));
+    if (allowedStrictOutputScriptHashes.size !== expectation.allowedStrictOutputScriptHashes.length) {
+        invalid("expectation.allowedStrictOutputScriptHashes", "must not contain duplicates");
+    }
+    const sortedAllowedStrictOutputScriptHashes = [...allowedStrictOutputScriptHashes].sort();
+    if (transaction.network !== snapshot.network) {
+        invalid("transaction.network", "does not match the policy snapshot");
+    }
+    if (snapshot.liquidAssetId === snapshot.verifier.assetId
+        || snapshot.liquidAssetId === feeAssetId
+        || snapshot.verifier.assetId === feeAssetId) {
+        invalid("expectation", "strict, verifier, and fee assets must be distinct");
+    }
+    if (transaction.inputs.some((input) => input.hasIssuance)) {
+        invalid("transaction.inputs", "must not contain issuance or reissuance");
+    }
+    const verifierInput = transaction.inputs[0];
+    if (!sameOutpoint(verifierInput.outpoint, snapshot.verifier.outpoint)) {
+        invalid("transaction.inputs[0].outpoint", "does not match the active verifier outpoint");
+    }
+    if (verifierInput.assetId !== snapshot.verifier.assetId
+        || verifierInput.amountAtomic !== snapshot.verifier.amountAtomic
+        || verifierInput.scriptHash !== snapshot.verifier.scriptHash) {
+        invalid("transaction.inputs[0]", "does not match the active verifier asset, amount, and script");
+    }
+    const verifierOutput = transaction.outputs[0];
+    if (verifierOutput.isFee
+        || verifierOutput.assetId !== snapshot.verifier.assetId
+        || verifierOutput.amountAtomic !== snapshot.verifier.amountAtomic
+        || verifierOutput.scriptHash !== snapshot.verifier.scriptHash) {
+        invalid("transaction.outputs[0]", "must recreate the active verifier output");
+    }
+    if (transaction.inputs.slice(1).some((input) => input.assetId === snapshot.verifier.assetId)
+        || transaction.outputs.slice(1).some((output) => output.assetId === snapshot.verifier.assetId)) {
+        invalid("transaction", "must contain exactly one verifier input and successor output at index 0");
+    }
+    const strictInputIndexes = transaction.inputs
+        .map((input, index) => ({ input, index }))
+        .filter(({ input, index }) => index > 0 && input.assetId === snapshot.liquidAssetId)
+        .map(({ index }) => index);
+    const strictOutputIndexes = transaction.outputs
+        .map((output, index) => ({ output, index }))
+        .filter(({ output }) => output.assetId === snapshot.liquidAssetId)
+        .map(({ index }) => index);
+    if (strictInputIndexes.length === 0) {
+        invalid("transaction.inputs", "must contain at least one strict asset input after the verifier");
+    }
+    if (strictOutputIndexes.length === 0) {
+        invalid("transaction.outputs", "must contain at least one confined strict asset output");
+    }
+    for (const index of strictOutputIndexes) {
+        const output = transaction.outputs[index];
+        if (output.isFee || !allowedStrictOutputScriptHashes.has(output.scriptHash)) {
+            invalid(`transaction.outputs[${index}]`, "sends the strict asset outside an allowed covenant");
+        }
+    }
+    const strictInputAmount = sumAmounts(strictInputIndexes.map((index) => transaction.inputs[index].amountAtomic));
+    const strictOutputAmount = sumAmounts(strictOutputIndexes.map((index) => transaction.outputs[index].amountAtomic));
+    if (strictInputAmount === 0n || strictInputAmount !== strictOutputAmount) {
+        invalid("transaction", "must conserve the complete strict asset amount");
+    }
+    const feeIndexes = transaction.outputs
+        .map((output, index) => ({ output, index }))
+        .filter(({ output }) => output.isFee)
+        .map(({ index }) => index);
+    if (feeIndexes.length !== 1) {
+        invalid("transaction.outputs", "must contain exactly one fee output");
+    }
+    const feeOutputIndex = feeIndexes[0];
+    const feeOutput = transaction.outputs[feeOutputIndex];
+    if (feeOutput.assetId !== feeAssetId || feeOutput.amountAtomic !== transaction.feeAmountAtomic) {
+        invalid(`transaction.outputs[${feeOutputIndex}]`, "does not match the declared fee asset and amount");
+    }
+    if (BigInt(transaction.feeAmountAtomic) > BigInt(maxFeeAmountAtomic)) {
+        invalid("transaction.feeAmountAtomic", "exceeds the wallet fee limit");
+    }
+    const summary = {
+        schema: exports.STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA,
+        operation: operation,
+        network: transaction.network,
+        snapshotHash: (0, summary_1.sha256HexUtf8)((0, summary_1.stableStringify)(snapshot)),
+        transactionViewHash: (0, summary_1.sha256HexUtf8)((0, summary_1.stableStringify)(transaction)),
+        allowedStrictOutputSetHash: (0, summary_1.sha256HexUtf8)((0, summary_1.stableStringify)(sortedAllowedStrictOutputScriptHashes)),
+        verifierOutpoint: { ...snapshot.verifier.outpoint },
+        verifierAssetId: snapshot.verifier.assetId,
+        verifierAmountAtomic: snapshot.verifier.amountAtomic,
+        strictAssetId: snapshot.liquidAssetId,
+        strictInputIndexes,
+        strictOutputIndexes,
+        strictAmountAtomic: strictInputAmount.toString(),
+        feeAssetId,
+        feeAmountAtomic: transaction.feeAmountAtomic,
+        feeOutputIndex,
+        inputCount: transaction.inputs.length,
+        outputCount: transaction.outputs.length,
+    };
+    const canonicalSummary = (0, summary_1.stableStringify)(summary);
+    return {
+        transaction,
+        snapshot,
+        summary,
+        canonicalSummary,
+        summaryHash: (0, summary_1.sha256HexUtf8)(canonicalSummary),
+    };
+}
+/**
+ * High-level wallet inspection. Every strict-asset output must carry a proof
+ * for its output index. The destination script is derived locally from the
+ * verified snapshot root, fixed holder CMR, NUMS key, and owner key.
+ */
+async function inspectStrictPolicyTransactionWithProofs(transactionValue, expectation) {
+    const transaction = normalizeStrictPolicyDecodedTransaction(transactionValue);
+    const snapshot = (0, damp_1.normalizeStrictPolicySnapshotPayload)(expectation.snapshot);
+    const holderProgramCmr = hex32(expectation.holderProgramCmr, "expectation.holderProgramCmr");
+    const holderNumsInternalKey = hex32(expectation.holderNumsInternalKey, "expectation.holderNumsInternalKey");
+    if (!Array.isArray(expectation.strictOutputAuthorizations)) {
+        invalid("expectation.strictOutputAuthorizations", "must be an array");
+    }
+    const strictOutputIndexes = transaction.outputs
+        .map((output, outputIndex) => ({ output, outputIndex }))
+        .filter(({ output }) => output.assetId === snapshot.liquidAssetId)
+        .map(({ outputIndex }) => outputIndex);
+    if (expectation.strictOutputAuthorizations.length !== strictOutputIndexes.length) {
+        invalid("expectation.strictOutputAuthorizations", "must contain exactly one proof for every strict-asset output");
+    }
+    const authorizedIndexes = new Set();
+    const verifiedAuthorizations = [];
+    for (let index = 0; index < expectation.strictOutputAuthorizations.length; index += 1) {
+        const authorization = expectation.strictOutputAuthorizations[index];
+        if (!authorization || typeof authorization !== "object") {
+            invalid(`expectation.strictOutputAuthorizations[${index}]`, "must be an object");
+        }
+        const outputIndex = uint32(authorization.outputIndex, `expectation.strictOutputAuthorizations[${index}].outputIndex`);
+        if (authorizedIndexes.has(outputIndex)) {
+            invalid("expectation.strictOutputAuthorizations", "must not repeat an output index");
+        }
+        const output = transaction.outputs[outputIndex];
+        if (!output || output.assetId !== snapshot.liquidAssetId || output.isFee) {
+            invalid(`expectation.strictOutputAuthorizations[${index}].outputIndex`, "must identify a non-fee strict-asset output");
+        }
+        const normalizedProof = (0, dampPolicy_1.normalizeStrictPolicyWhitelistProof)({
+            ownerXonly: authorization.ownerXonly,
+            proof: authorization.proof,
+        });
+        if (!(0, dampPolicy_1.verifyStrictPolicyWhitelistProof)({
+            ...normalizedProof,
+            expectedRoot: snapshot.whitelistRoot,
+        })) {
+            invalid(`expectation.strictOutputAuthorizations[${index}].proof`, "does not prove an owner in the active whitelist");
+        }
+        const position = await (0, dampPolicy_1.deriveStrictPolicyHolderPosition)({
+            holderProgramCmr,
+            numsInternalKey: holderNumsInternalKey,
+            holderXonly: normalizedProof.ownerXonly,
+        });
+        if (output.scriptHash !== position.scriptHash) {
+            invalid(`transaction.outputs[${outputIndex}].scriptHash`, "does not match the canonical covenant for its proven owner");
+        }
+        authorizedIndexes.add(outputIndex);
+        verifiedAuthorizations.push({
+            outputIndex,
+            ownerXonly: normalizedProof.ownerXonly,
+            proof: normalizedProof.proof,
+            derivedScriptHash: position.scriptHash,
+        });
+    }
+    for (const outputIndex of strictOutputIndexes) {
+        if (!authorizedIndexes.has(outputIndex)) {
+            invalid(`transaction.outputs[${outputIndex}]`, "does not have an owner proof for its canonical covenant");
+        }
+    }
+    const inspection = inspectStrictPolicyTransaction(transaction, {
+        operation: expectation.operation,
+        snapshot,
+        feeAssetId: expectation.feeAssetId,
+        maxFeeAmountAtomic: expectation.maxFeeAmountAtomic,
+        allowedStrictOutputScriptHashes: [
+            ...new Set(verifiedAuthorizations.map(({ derivedScriptHash }) => derivedScriptHash)),
+        ],
+    });
+    return {
+        ...inspection,
+        strictOutputAuthorizations: verifiedAuthorizations.sort((left, right) => left.outputIndex - right.outputIndex),
+    };
+}

package/dist/index.d.ts

@@ -21,3 +21,13 @@ export { applyReceivableRepayment, buildDefaultedReceivableState, buildFundedRec
 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, 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";
+export { configureStrictPolicyCrypto, } from "./core/strictPolicyCrypto";
+export type { StrictPolicyCryptoProvider, } from "./core/strictPolicyCrypto";
+export { STRICT_POLICY_SNAPSHOT_SCHEMA, STRICT_POLICY_SNAPSHOT_APPROVAL_SCHEMA, STRICT_POLICY_SNAPSHOT_APPROVAL_DOMAIN, STRICT_POLICY_AUTHORITY_SET_DOMAIN, STRICT_POLICY_VERIFIER_MAX_INPUTS, STRICT_POLICY_VERIFIER_MAX_OUTPUTS, normalizeStrictPolicySnapshotPayload, normalizeStrictPolicySnapshotAuthority, normalizeStrictPolicySnapshotApprovalProof, taggedHashHexUtf8, computeStrictPolicyAuthoritySetHash, normalizeStrictPolicyHolderCovenantParams, normalizeStrictPolicyVerifierCovenantParams, strictPolicyHolderCovenantTemplatePath, strictPolicyVerifierCovenantTemplatePath, renderStrictPolicyHolderCovenantSource, renderStrictPolicyVerifierCovenantSource, compileStrictPolicyHolderCovenant, compileStrictPolicyVerifierCovenant, prepareStrictPolicySnapshot, finalizeStrictPolicySnapshot, verifyStrictPolicySnapshot, } from "./domain/damp";
+export type { StrictPolicyNetwork, StrictPolicyVerifierReference, StrictPolicySnapshotPayload, StrictPolicySnapshotAuthority, StrictPolicySnapshotApprovalProof, PreparedStrictPolicySnapshot, StrictPolicySnapshotEnvelope, StrictPolicyHolderCovenantParams, StrictPolicyVerifierCovenantParams, } from "./domain/damp";
+export { STRICT_POLICY_WHITELIST_DEPTH, STRICT_POLICY_MAX_WHITELIST_OWNERS, STRICT_POLICY_WHITELIST_OWNER_DOMAIN, STRICT_POLICY_WHITELIST_EMPTY_DOMAIN, STRICT_POLICY_WHITELIST_NODE_DOMAIN, computeStrictPolicyHolderTapleafHash, computeStrictPolicyOwnerTapDataHash, computeElementsTapBranch, deriveStrictPolicyHolderPosition, computeStrictPolicyWhitelistOwnerLeaf, computeStrictPolicyWhitelistEmptyLeaf, computeStrictPolicyWhitelistNode, buildStrictPolicyWhitelist, normalizeStrictPolicyWhitelistProof, verifyStrictPolicyWhitelistProof, strictPolicyWhitelistTagHashes, } from "./domain/dampPolicy";
+export type { StrictPolicyHolderPositionParams, StrictPolicyHolderPosition, StrictPolicyWhitelistProofStep, StrictPolicyWhitelistProof, StrictPolicyWhitelistEntry, StrictPolicyWhitelist, } from "./domain/dampPolicy";
+export { STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA, normalizeStrictPolicyDecodedTransaction, inspectStrictPolicyTransaction, inspectStrictPolicyTransactionWithProofs, } from "./domain/dampTransaction";
+export type { StrictPolicyOperation, StrictPolicyTransactionOutpoint, StrictPolicyDecodedInput, StrictPolicyDecodedOutput, StrictPolicyDecodedTransaction, StrictPolicyTransactionExpectation, StrictPolicyTransactionSummary, StrictPolicyTransactionInspection, StrictPolicyOutputAuthorization, StrictPolicyProofBackedTransactionExpectation, StrictPolicyVerifiedOutputAuthorization, StrictPolicyProofBackedTransactionInspection, } from "./domain/dampTransaction";
+export { STRICT_POLICY_PSET_INSPECTION_SCHEMA, normalizeStrictPolicyPsetInspection, inspectStrictPolicyPsetForSigning, } from "./domain/dampPset";
+export type { StrictPolicySimplicityInputRequest, StrictPolicySimplicityInputInspection, StrictPolicyPsetDecoderRequest, StrictPolicyPsetDecoder, StrictPolicyPsetInspection, StrictPolicyPsetSigningInspectionRequest, StrictPolicyPsetSigningInspection, } from "./domain/dampPset";

package/dist/index.js

@@ -17,7 +17,8 @@ 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.inspectRwaDvpDeliveryClaim = exports.exportRwaDvpEvidence = exports.executeRwaDvpRefundClaim = exports.executeRwaDvpDeliveryClaim = exports.defineRwaDvpPurchase = exports.compileRwaDvpEscrowContract = 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 = exports.verifyRwaDvpDeliveryClaim = exports.summarizeRwaDvpPurchase = exports.prepareRwaDvpRefundClaim = exports.prepareRwaDvpDeliveryClaim = exports.inspectRwaDvpRefundClaim = void 0;
+exports.verifyStrictPolicySnapshot = exports.finalizeStrictPolicySnapshot = exports.prepareStrictPolicySnapshot = exports.compileStrictPolicyVerifierCovenant = exports.compileStrictPolicyHolderCovenant = exports.renderStrictPolicyVerifierCovenantSource = exports.renderStrictPolicyHolderCovenantSource = exports.strictPolicyVerifierCovenantTemplatePath = exports.strictPolicyHolderCovenantTemplatePath = exports.normalizeStrictPolicyVerifierCovenantParams = exports.normalizeStrictPolicyHolderCovenantParams = exports.computeStrictPolicyAuthoritySetHash = exports.taggedHashHexUtf8 = exports.normalizeStrictPolicySnapshotApprovalProof = exports.normalizeStrictPolicySnapshotAuthority = exports.normalizeStrictPolicySnapshotPayload = exports.STRICT_POLICY_VERIFIER_MAX_OUTPUTS = exports.STRICT_POLICY_VERIFIER_MAX_INPUTS = exports.STRICT_POLICY_AUTHORITY_SET_DOMAIN = exports.STRICT_POLICY_SNAPSHOT_APPROVAL_DOMAIN = exports.STRICT_POLICY_SNAPSHOT_APPROVAL_SCHEMA = exports.STRICT_POLICY_SNAPSHOT_SCHEMA = exports.configureStrictPolicyCrypto = 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 = exports.verifyRwaDvpDeliveryClaim = exports.summarizeRwaDvpPurchase = exports.prepareRwaDvpRefundClaim = exports.prepareRwaDvpDeliveryClaim = exports.inspectRwaDvpRefundClaim = void 0;
+exports.inspectStrictPolicyPsetForSigning = exports.normalizeStrictPolicyPsetInspection = exports.STRICT_POLICY_PSET_INSPECTION_SCHEMA = exports.inspectStrictPolicyTransactionWithProofs = exports.inspectStrictPolicyTransaction = exports.normalizeStrictPolicyDecodedTransaction = exports.STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA = exports.strictPolicyWhitelistTagHashes = exports.verifyStrictPolicyWhitelistProof = exports.normalizeStrictPolicyWhitelistProof = exports.buildStrictPolicyWhitelist = exports.computeStrictPolicyWhitelistNode = exports.computeStrictPolicyWhitelistEmptyLeaf = exports.computeStrictPolicyWhitelistOwnerLeaf = exports.deriveStrictPolicyHolderPosition = exports.computeElementsTapBranch = exports.computeStrictPolicyOwnerTapDataHash = exports.computeStrictPolicyHolderTapleafHash = exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN = exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN = exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN = exports.STRICT_POLICY_MAX_WHITELIST_OWNERS = exports.STRICT_POLICY_WHITELIST_DEPTH = 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; } });
@@ -217,3 +218,54 @@ Object.defineProperty(exports, "summarizePolicyTransferDescriptor", { enumerable
 Object.defineProperty(exports, "validatePolicyState", { enumerable: true, get: function () { return policies_1.validatePolicyState; } });
 Object.defineProperty(exports, "validatePolicyOutputDescriptor", { enumerable: true, get: function () { return policies_1.validatePolicyOutputDescriptor; } });
 Object.defineProperty(exports, "validatePolicyTransferDescriptor", { enumerable: true, get: function () { return policies_1.validatePolicyTransferDescriptor; } });
+var strictPolicyCrypto_1 = require("./core/strictPolicyCrypto");
+Object.defineProperty(exports, "configureStrictPolicyCrypto", { enumerable: true, get: function () { return strictPolicyCrypto_1.configureStrictPolicyCrypto; } });
+var damp_1 = require("./domain/damp");
+Object.defineProperty(exports, "STRICT_POLICY_SNAPSHOT_SCHEMA", { enumerable: true, get: function () { return damp_1.STRICT_POLICY_SNAPSHOT_SCHEMA; } });
+Object.defineProperty(exports, "STRICT_POLICY_SNAPSHOT_APPROVAL_SCHEMA", { enumerable: true, get: function () { return damp_1.STRICT_POLICY_SNAPSHOT_APPROVAL_SCHEMA; } });
+Object.defineProperty(exports, "STRICT_POLICY_SNAPSHOT_APPROVAL_DOMAIN", { enumerable: true, get: function () { return damp_1.STRICT_POLICY_SNAPSHOT_APPROVAL_DOMAIN; } });
+Object.defineProperty(exports, "STRICT_POLICY_AUTHORITY_SET_DOMAIN", { enumerable: true, get: function () { return damp_1.STRICT_POLICY_AUTHORITY_SET_DOMAIN; } });
+Object.defineProperty(exports, "STRICT_POLICY_VERIFIER_MAX_INPUTS", { enumerable: true, get: function () { return damp_1.STRICT_POLICY_VERIFIER_MAX_INPUTS; } });
+Object.defineProperty(exports, "STRICT_POLICY_VERIFIER_MAX_OUTPUTS", { enumerable: true, get: function () { return damp_1.STRICT_POLICY_VERIFIER_MAX_OUTPUTS; } });
+Object.defineProperty(exports, "normalizeStrictPolicySnapshotPayload", { enumerable: true, get: function () { return damp_1.normalizeStrictPolicySnapshotPayload; } });
+Object.defineProperty(exports, "normalizeStrictPolicySnapshotAuthority", { enumerable: true, get: function () { return damp_1.normalizeStrictPolicySnapshotAuthority; } });
+Object.defineProperty(exports, "normalizeStrictPolicySnapshotApprovalProof", { enumerable: true, get: function () { return damp_1.normalizeStrictPolicySnapshotApprovalProof; } });
+Object.defineProperty(exports, "taggedHashHexUtf8", { enumerable: true, get: function () { return damp_1.taggedHashHexUtf8; } });
+Object.defineProperty(exports, "computeStrictPolicyAuthoritySetHash", { enumerable: true, get: function () { return damp_1.computeStrictPolicyAuthoritySetHash; } });
+Object.defineProperty(exports, "normalizeStrictPolicyHolderCovenantParams", { enumerable: true, get: function () { return damp_1.normalizeStrictPolicyHolderCovenantParams; } });
+Object.defineProperty(exports, "normalizeStrictPolicyVerifierCovenantParams", { enumerable: true, get: function () { return damp_1.normalizeStrictPolicyVerifierCovenantParams; } });
+Object.defineProperty(exports, "strictPolicyHolderCovenantTemplatePath", { enumerable: true, get: function () { return damp_1.strictPolicyHolderCovenantTemplatePath; } });
+Object.defineProperty(exports, "strictPolicyVerifierCovenantTemplatePath", { enumerable: true, get: function () { return damp_1.strictPolicyVerifierCovenantTemplatePath; } });
+Object.defineProperty(exports, "renderStrictPolicyHolderCovenantSource", { enumerable: true, get: function () { return damp_1.renderStrictPolicyHolderCovenantSource; } });
+Object.defineProperty(exports, "renderStrictPolicyVerifierCovenantSource", { enumerable: true, get: function () { return damp_1.renderStrictPolicyVerifierCovenantSource; } });
+Object.defineProperty(exports, "compileStrictPolicyHolderCovenant", { enumerable: true, get: function () { return damp_1.compileStrictPolicyHolderCovenant; } });
+Object.defineProperty(exports, "compileStrictPolicyVerifierCovenant", { enumerable: true, get: function () { return damp_1.compileStrictPolicyVerifierCovenant; } });
+Object.defineProperty(exports, "prepareStrictPolicySnapshot", { enumerable: true, get: function () { return damp_1.prepareStrictPolicySnapshot; } });
+Object.defineProperty(exports, "finalizeStrictPolicySnapshot", { enumerable: true, get: function () { return damp_1.finalizeStrictPolicySnapshot; } });
+Object.defineProperty(exports, "verifyStrictPolicySnapshot", { enumerable: true, get: function () { return damp_1.verifyStrictPolicySnapshot; } });
+var dampPolicy_1 = require("./domain/dampPolicy");
+Object.defineProperty(exports, "STRICT_POLICY_WHITELIST_DEPTH", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_WHITELIST_DEPTH; } });
+Object.defineProperty(exports, "STRICT_POLICY_MAX_WHITELIST_OWNERS", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_MAX_WHITELIST_OWNERS; } });
+Object.defineProperty(exports, "STRICT_POLICY_WHITELIST_OWNER_DOMAIN", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_WHITELIST_OWNER_DOMAIN; } });
+Object.defineProperty(exports, "STRICT_POLICY_WHITELIST_EMPTY_DOMAIN", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN; } });
+Object.defineProperty(exports, "STRICT_POLICY_WHITELIST_NODE_DOMAIN", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_WHITELIST_NODE_DOMAIN; } });
+Object.defineProperty(exports, "computeStrictPolicyHolderTapleafHash", { enumerable: true, get: function () { return dampPolicy_1.computeStrictPolicyHolderTapleafHash; } });
+Object.defineProperty(exports, "computeStrictPolicyOwnerTapDataHash", { enumerable: true, get: function () { return dampPolicy_1.computeStrictPolicyOwnerTapDataHash; } });
+Object.defineProperty(exports, "computeElementsTapBranch", { enumerable: true, get: function () { return dampPolicy_1.computeElementsTapBranch; } });
+Object.defineProperty(exports, "deriveStrictPolicyHolderPosition", { enumerable: true, get: function () { return dampPolicy_1.deriveStrictPolicyHolderPosition; } });
+Object.defineProperty(exports, "computeStrictPolicyWhitelistOwnerLeaf", { enumerable: true, get: function () { return dampPolicy_1.computeStrictPolicyWhitelistOwnerLeaf; } });
+Object.defineProperty(exports, "computeStrictPolicyWhitelistEmptyLeaf", { enumerable: true, get: function () { return dampPolicy_1.computeStrictPolicyWhitelistEmptyLeaf; } });
+Object.defineProperty(exports, "computeStrictPolicyWhitelistNode", { enumerable: true, get: function () { return dampPolicy_1.computeStrictPolicyWhitelistNode; } });
+Object.defineProperty(exports, "buildStrictPolicyWhitelist", { enumerable: true, get: function () { return dampPolicy_1.buildStrictPolicyWhitelist; } });
+Object.defineProperty(exports, "normalizeStrictPolicyWhitelistProof", { enumerable: true, get: function () { return dampPolicy_1.normalizeStrictPolicyWhitelistProof; } });
+Object.defineProperty(exports, "verifyStrictPolicyWhitelistProof", { enumerable: true, get: function () { return dampPolicy_1.verifyStrictPolicyWhitelistProof; } });
+Object.defineProperty(exports, "strictPolicyWhitelistTagHashes", { enumerable: true, get: function () { return dampPolicy_1.strictPolicyWhitelistTagHashes; } });
+var dampTransaction_1 = require("./domain/dampTransaction");
+Object.defineProperty(exports, "STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA", { enumerable: true, get: function () { return dampTransaction_1.STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA; } });
+Object.defineProperty(exports, "normalizeStrictPolicyDecodedTransaction", { enumerable: true, get: function () { return dampTransaction_1.normalizeStrictPolicyDecodedTransaction; } });
+Object.defineProperty(exports, "inspectStrictPolicyTransaction", { enumerable: true, get: function () { return dampTransaction_1.inspectStrictPolicyTransaction; } });
+Object.defineProperty(exports, "inspectStrictPolicyTransactionWithProofs", { enumerable: true, get: function () { return dampTransaction_1.inspectStrictPolicyTransactionWithProofs; } });
+var dampPset_1 = require("./domain/dampPset");
+Object.defineProperty(exports, "STRICT_POLICY_PSET_INSPECTION_SCHEMA", { enumerable: true, get: function () { return dampPset_1.STRICT_POLICY_PSET_INSPECTION_SCHEMA; } });
+Object.defineProperty(exports, "normalizeStrictPolicyPsetInspection", { enumerable: true, get: function () { return dampPset_1.normalizeStrictPolicyPsetInspection; } });
+Object.defineProperty(exports, "inspectStrictPolicyPsetForSigning", { enumerable: true, get: function () { return dampPset_1.inspectStrictPolicyPsetForSigning; } });

package/dist/x402/atomicDvp.d.ts

@@ -137,6 +137,16 @@ export interface LiquidAtomicDvpTakeProposalInput {
     proposal?: string;
     proposalPsetBase64?: string;
     proposalTxHex?: string;
+    /**
+     * Optional recipient for the maker-delivered asset when the taker PSET is
+     * completed. Use this for policy/Simplicity delivery addresses that are not a
+     * normal wallet receive address.
+     */
+    takerDeliveryAddress?: string;
+    /**
+     * Backwards-friendly alias for `takerDeliveryAddress`.
+     */
+    deliveryAddress?: string;
     payer?: string;
     esploraUrl?: string;
     waterfalls?: boolean;
@@ -154,6 +164,7 @@ export type LiquidAtomicDvpTakeProposalResult = ReturnType<typeof buildLiquidAto
     dwid?: string;
     proposalInput: LiquidAtomicDvpOutputRequirement;
     proposalOutput: LiquidAtomicDvpOutputRequirement;
+    takerDeliveryAddress?: string;
 };
 export interface LiquidAtomicDvpVerifyPayloadResult {
     isValid: boolean;

package/dist/x402/atomicDvp.js

@@ -113,7 +113,8 @@ async function prepareLiquidAtomicDvpLwkWasmTakerPayment(input) {
     let builder = network.txBuilder();
     if (input.feeRate !== undefined)
         builder = builder.feeRate(input.feeRate);
-    builder = builder.liquidexTake([validated]);
+    const takerDeliveryAddress = normalizeOptionalString(input.takerDeliveryAddress ?? input.deliveryAddress, "takerDeliveryAddress");
+    builder = applyLiquidexTake(lwk, builder, [validated], network, takerDeliveryAddress);
     const unsigned = builder.finish(wollet);
     const signed = signer.sign(unsigned);
     const pset = input.finalize === false ? signed : wollet.finalize(signed);
@@ -128,6 +129,7 @@ async function prepareLiquidAtomicDvpLwkWasmTakerPayment(input) {
         ...(typeof wollet.dwid === "function" ? { dwid: wollet.dwid() } : {}),
         proposalInput,
         proposalOutput,
+        ...(takerDeliveryAddress ? { takerDeliveryAddress } : {}),
     };
 }
 function buildLiquidAtomicDvpSummaryHash(input) {
@@ -360,6 +362,18 @@ function parseLwkTransaction(lwk, txHex) {
         return new lwk.Transaction(txHex);
     throw new Error("LWK Transaction support is required to validate a Liquidex proposal against a transaction.");
 }
+function applyLiquidexTake(lwk, builder, validatedProposals, network, takerDeliveryAddress) {
+    if (!takerDeliveryAddress)
+        return builder.liquidexTake(validatedProposals);
+    const deliveryAddress = parseLwkAddress(lwk, takerDeliveryAddress, network);
+    for (const method of ["liquidexTakeWithRecipient", "liquidexTakeToAddress", "liquidexTakeTo"]) {
+        if (typeof builder[method] === "function") {
+            return builder[method](validatedProposals, deliveryAddress);
+        }
+    }
+    throw new Error("Liquidex taker delivery address override is not supported by the loaded LWK module. " +
+        "Upgrade LWK or use a fixed-recipient/manual atomic DvP PSET builder.");
+}
 function parseLiquidexProposal(lwk, value) {
     const encoded = String(value ?? "").trim();
     if (!encoded)
@@ -435,6 +449,16 @@ function normalizeOutput(value, name) {
         recipient: requiredString(raw.recipient, `${name}.recipient`),
     };
 }
+function normalizeOptionalString(value, name) {
+    if (value === undefined || value === null)
+        return undefined;
+    const text = String(value).trim();
+    if (!text)
+        return undefined;
+    if (text.length > 2048)
+        throw new Error(`${name} is too long`);
+    return text;
+}
 function normalizeServiceSigner(value) {
     if (value === null || value === undefined)
         return null;

package/dist/x402/index.d.ts

@@ -63,6 +63,7 @@ export interface LiquidX402PaymentPayload {
     summaryHash: string;
     payer?: string;
     expiresAt: string;
+    metadata?: Record<string, unknown>;
 }
 export interface LiquidX402PreparePsetPaymentInput {
     requirements: LiquidX402PaymentRequirements;
@@ -89,12 +90,29 @@ export interface LiquidPolicyLockedRedemptionSpendProposal {
     psetBase64?: string;
     summaryHash?: string;
     holderSignatureRequired?: boolean;
+    holderSignatureRequest?: LiquidPolicyLockedRedemptionHolderSignatureRequest;
     metadata?: Record<string, unknown>;
 }
+export interface LiquidPolicyLockedRedemptionHolderSignatureRequest {
+    scheme: "simplicity_bip340_sig_all_hash_v1" | string;
+    inputIndex: number;
+    sighashHex: string;
+    signerXonly: string;
+    cmr: string;
+}
+export interface LiquidPolicyLockedRedemptionHolderSignature {
+    scheme: "simplicity_bip340_sig_all_hash_v1" | string;
+    inputIndex: number;
+    sighashHex: string;
+    signerXonly: string;
+    cmr: string;
+    signatureHex: string;
+}
 export interface LiquidPolicyLockedRedemptionPaymentFromProposalInput {
     requirements: LiquidX402PaymentRequirements | Record<string, unknown>;
     proposal?: LiquidPolicyLockedRedemptionSpendProposal | Record<string, unknown>;
     proposalPsetBase64?: string;
+    holderSignature?: LiquidPolicyLockedRedemptionHolderSignature | Record<string, unknown>;
     summaryHash?: string;
     payer?: string;
     metadata?: Record<string, unknown>;

package/dist/x402/index.js

@@ -212,7 +212,20 @@ function buildLiquidX402PaymentFromPset(input) {
 function buildLiquidPolicyLockedRedemptionPaymentFromProposal(input) {
     const requirements = coercePolicyLockedRedemptionRequirements(input.requirements);
     const proposal = coercePolicyLockedRedemptionProposal(input.proposal ?? getRecordValue(input.requirements, "policySpendProposal") ?? getExtraRecord(input.requirements).policySpendProposal, input.proposalPsetBase64);
+    const holderSignature = coercePolicyLockedRedemptionHolderSignature(input.holderSignature);
+    if (proposal.holderSignatureRequired === true && !holderSignature) {
+        throw new Error("holderSignature is required for holder-signed policy-locked redemption proposal");
+    }
     const summaryHash = input.summaryHash ?? proposal.summaryHash ?? requirements.summaryHash ?? buildLiquidPolicyLockedRedemptionSummaryHash(requirements);
+    const metadata = {
+        ...(input.metadata ?? {}),
+        policySpendProposal: {
+            mode: proposal.mode ?? "service_prepared_policy_spend_v1",
+            holderSignatureRequired: proposal.holderSignatureRequired === true,
+            ...(proposal.holderSignatureRequest ? { holderSignatureRequest: proposal.holderSignatureRequest } : {}),
+        },
+        ...(holderSignature ? { holderSignature } : {}),
+    };
     const paymentPayload = {
         scheme: exports.LIQUID_X402_SCHEME,
         network: requirements.network,
@@ -225,6 +238,7 @@ function buildLiquidPolicyLockedRedemptionPaymentFromProposal(input) {
         summaryHash,
         ...(input.payer ? { payer: input.payer } : {}),
         expiresAt: requirements.expiresAt,
+        metadata,
     };
     return {
         paymentPayload,
@@ -532,22 +546,59 @@ function coercePolicyLockedRedemptionProposal(value, proposalPsetBase64) {
     const raw = value && typeof value === "object" && !Array.isArray(value)
         ? value
         : {};
-    if (raw.holderSignatureRequired === true) {
-        throw new Error("policy-locked redemption proposal still requires holder-side Simplicity signing; provide a service-prepared spend proposal");
-    }
+    const metadata = raw.metadata && typeof raw.metadata === "object" && !Array.isArray(raw.metadata)
+        ? raw.metadata
+        : undefined;
     const psetBase64 = String(proposalPsetBase64 ?? raw.psetBase64 ?? "").trim();
     if (!psetBase64)
         throw new Error("policy spend proposal psetBase64 is required");
+    const holderSignatureRequest = coercePolicyLockedRedemptionHolderSignatureRequest(raw.holderSignatureRequest ?? metadata?.holderSignatureRequest);
     return {
         psetBase64,
         ...(raw.mode ? { mode: String(raw.mode) } : {}),
         ...(raw.summaryHash ? { summaryHash: String(raw.summaryHash) } : {}),
         ...(raw.holderSignatureRequired !== undefined ? { holderSignatureRequired: raw.holderSignatureRequired === true } : {}),
-        ...(raw.metadata && typeof raw.metadata === "object" && !Array.isArray(raw.metadata)
-            ? { metadata: raw.metadata }
-            : {}),
+        ...(holderSignatureRequest ? { holderSignatureRequest } : {}),
+        ...(metadata ? { metadata } : {}),
+    };
+}
+function coercePolicyLockedRedemptionHolderSignatureRequest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const scheme = stringValue(raw.scheme, "holderSignatureRequest.scheme");
+    const inputIndex = Number(raw.inputIndex ?? 0);
+    if (!Number.isInteger(inputIndex) || inputIndex < 0) {
+        throw new Error("holderSignatureRequest.inputIndex must be a non-negative integer");
+    }
+    return {
+        scheme,
+        inputIndex,
+        sighashHex: hexStringValue(raw.sighashHex, "holderSignatureRequest.sighashHex", 32),
+        signerXonly: hexStringValue(raw.signerXonly, "holderSignatureRequest.signerXonly", 32),
+        cmr: hexStringValue(raw.cmr, "holderSignatureRequest.cmr", 32),
+    };
+}
+function coercePolicyLockedRedemptionHolderSignature(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const request = coercePolicyLockedRedemptionHolderSignatureRequest(raw);
+    if (!request)
+        return undefined;
+    return {
+        ...request,
+        signatureHex: hexStringValue(raw.signatureHex ?? raw.signature, "holderSignature.signatureHex", 64),
     };
 }
+function hexStringValue(value, name, bytes) {
+    const normalized = stringValue(value, name).toLowerCase().replace(/^0x/u, "");
+    const expectedLength = bytes * 2;
+    if (!new RegExp(`^[0-9a-f]{${expectedLength}}$`, "u").test(normalized)) {
+        throw new Error(`${name} must be a ${bytes}-byte hex string`);
+    }
+    return normalized;
+}
 function buildLiquidPolicyLockedRedemptionSummaryHash(requirements) {
     return sha256Hex(stableStringify({
         scheme: exports.LIQUID_X402_SCHEME,