@hazbase/simplicity 0.4.6 → 0.4.7

package/dist/domain/dampPolicy.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+exports.computeStrictPolicyHolderTapleafHash = computeStrictPolicyHolderTapleafHash;
+exports.computeStrictPolicyOwnerTapDataHash = computeStrictPolicyOwnerTapDataHash;
+exports.computeElementsTapBranch = computeElementsTapBranch;
+exports.deriveStrictPolicyHolderPosition = deriveStrictPolicyHolderPosition;
+exports.computeStrictPolicyWhitelistOwnerLeaf = computeStrictPolicyWhitelistOwnerLeaf;
+exports.computeStrictPolicyWhitelistEmptyLeaf = computeStrictPolicyWhitelistEmptyLeaf;
+exports.computeStrictPolicyWhitelistNode = computeStrictPolicyWhitelistNode;
+exports.buildStrictPolicyWhitelist = buildStrictPolicyWhitelist;
+exports.verifyStrictPolicyWhitelistProof = verifyStrictPolicyWhitelistProof;
+exports.normalizeStrictPolicyWhitelistProof = normalizeStrictPolicyWhitelistProof;
+exports.strictPolicyWhitelistTagHashes = strictPolicyWhitelistTagHashes;
+const node_crypto_1 = require("node:crypto");
+const errors_1 = require("../core/errors");
+const strictPolicyCrypto_1 = require("../core/strictPolicyCrypto");
+exports.STRICT_POLICY_WHITELIST_DEPTH = 8;
+exports.STRICT_POLICY_MAX_WHITELIST_OWNERS = 1 << exports.STRICT_POLICY_WHITELIST_DEPTH;
+exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN = "HAZBASE-RWA-STRICT-WHITELIST-OWNER-V1";
+exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN = "HAZBASE-RWA-STRICT-WHITELIST-EMPTY-V1";
+exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN = "HAZBASE-RWA-STRICT-WHITELIST-NODE-V1";
+function validationError(field, message) {
+    throw new errors_1.ValidationError(`${field} ${message}`, {
+        code: "STRICT_POLICY_COVENANT_INVALID",
+        field,
+    });
+}
+function hex32(value, field) {
+    if (typeof value !== "string")
+        validationError(field, "must be 32 bytes of hex");
+    const normalized = value.trim().toLowerCase().replace(/^0x/u, "");
+    if (!/^[0-9a-f]{64}$/u.test(normalized)) {
+        validationError(field, "must be 32 bytes of hex");
+    }
+    return normalized;
+}
+function bytes(hex) {
+    return Buffer.from(hex, "hex");
+}
+function sha256(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value).digest();
+}
+function concat(...values) {
+    return Buffer.concat(values.map((value) => Buffer.from(value)));
+}
+function taggedHash(tag, payload) {
+    const tagHash = sha256(Buffer.from(tag, "utf8"));
+    return sha256(concat(tagHash, tagHash, payload));
+}
+function taggedHashHex(tag, payload) {
+    return taggedHash(tag, payload).toString("hex");
+}
+async function loadSecp256k1() {
+    return (await (0, strictPolicyCrypto_1.loadStrictPolicyCrypto)()).secp256k1;
+}
+function computeStrictPolicyHolderTapleafHash(holderProgramCmrValue) {
+    const holderProgramCmr = hex32(holderProgramCmrValue, "holderProgramCmr");
+    return taggedHashHex("TapLeaf/elements", concat(Uint8Array.of(0xbe, 0x20), bytes(holderProgramCmr)));
+}
+function computeStrictPolicyOwnerTapDataHash(holderXonlyValue) {
+    const holderXonly = hex32(holderXonlyValue, "holderXonly");
+    return taggedHashHex("TapData", bytes(holderXonly));
+}
+function computeElementsTapBranch(leftValue, rightValue) {
+    const left = hex32(leftValue, "left");
+    const right = hex32(rightValue, "right");
+    const ordered = left < right ? [left, right] : [right, left];
+    return taggedHashHex("TapBranch/elements", concat(bytes(ordered[0]), bytes(ordered[1])));
+}
+async function deriveStrictPolicyHolderPosition(value) {
+    const holderProgramCmr = hex32(value.holderProgramCmr, "holderProgramCmr");
+    const numsInternalKey = hex32(value.numsInternalKey, "numsInternalKey");
+    const holderXonly = hex32(value.holderXonly, "holderXonly");
+    const holderTapleafHash = computeStrictPolicyHolderTapleafHash(holderProgramCmr);
+    const ownerTapDataHash = computeStrictPolicyOwnerTapDataHash(holderXonly);
+    const taprootRoot = computeElementsTapBranch(holderTapleafHash, ownerTapDataHash);
+    const tweak = taggedHash("TapTweak/elements", concat(bytes(numsInternalKey), bytes(taprootRoot)));
+    const secp256k1 = await loadSecp256k1();
+    const tweakScalar = BigInt(`0x${tweak.toString("hex")}`);
+    if (tweakScalar >= secp256k1.Point.Fn.ORDER) {
+        validationError("taprootTweak", "must be below the secp256k1 group order");
+    }
+    let outputPoint;
+    try {
+        const internalPoint = secp256k1.Point.fromBytes(concat(Uint8Array.of(0x02), bytes(numsInternalKey)));
+        outputPoint = internalPoint.add(secp256k1.Point.BASE.multiply(tweakScalar));
+        if (outputPoint.equals(secp256k1.Point.ZERO)) {
+            validationError("taprootTweak", "must not produce the point at infinity");
+        }
+    }
+    catch (error) {
+        if (error instanceof errors_1.ValidationError)
+            throw error;
+        validationError("numsInternalKey", "must be a valid x-only secp256k1 public key");
+    }
+    const outputKey = Buffer.from(outputPoint.toBytes(true)).subarray(1).toString("hex");
+    const scriptPubKey = `5120${outputKey}`;
+    const scriptHash = sha256(bytes(scriptPubKey)).toString("hex");
+    return {
+        holderProgramCmr,
+        holderTapleafHash,
+        holderXonly,
+        ownerTapDataHash,
+        taprootRoot,
+        numsInternalKey,
+        outputKey,
+        scriptPubKey,
+        scriptHash,
+    };
+}
+function computeStrictPolicyWhitelistOwnerLeaf(ownerXonlyValue) {
+    const ownerXonly = hex32(ownerXonlyValue, "ownerXonly");
+    return taggedHashHex(exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN, bytes(ownerXonly));
+}
+function computeStrictPolicyWhitelistEmptyLeaf() {
+    return taggedHashHex(exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN, new Uint8Array());
+}
+function computeStrictPolicyWhitelistNode(leftValue, rightValue) {
+    const left = hex32(leftValue, "left");
+    const right = hex32(rightValue, "right");
+    return taggedHashHex(exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN, concat(bytes(left), bytes(right)));
+}
+function buildStrictPolicyWhitelist(ownerXonlyValues) {
+    if (!Array.isArray(ownerXonlyValues) || ownerXonlyValues.length === 0) {
+        validationError("ownerXonlyValues", "must contain at least one owner");
+    }
+    if (ownerXonlyValues.length > exports.STRICT_POLICY_MAX_WHITELIST_OWNERS) {
+        validationError("ownerXonlyValues", `must contain at most ${exports.STRICT_POLICY_MAX_WHITELIST_OWNERS} owners`);
+    }
+    const owners = ownerXonlyValues
+        .map((owner, index) => hex32(owner, `ownerXonlyValues[${index}]`))
+        .sort();
+    if (new Set(owners).size !== owners.length) {
+        validationError("ownerXonlyValues", "must not contain duplicates");
+    }
+    const emptyLeaf = computeStrictPolicyWhitelistEmptyLeaf();
+    const leaves = Array.from({ length: exports.STRICT_POLICY_MAX_WHITELIST_OWNERS }, (_, index) => (index < owners.length ? computeStrictPolicyWhitelistOwnerLeaf(owners[index]) : emptyLeaf));
+    const levels = [leaves];
+    for (let depth = 0; depth < exports.STRICT_POLICY_WHITELIST_DEPTH; depth += 1) {
+        const current = levels[depth];
+        const next = [];
+        for (let index = 0; index < current.length; index += 2) {
+            next.push(computeStrictPolicyWhitelistNode(current[index], current[index + 1]));
+        }
+        levels.push(next);
+    }
+    const entries = owners.map((ownerXonly, ownerIndex) => {
+        const proof = [];
+        let index = ownerIndex;
+        for (let depth = 0; depth < exports.STRICT_POLICY_WHITELIST_DEPTH; depth += 1) {
+            const siblingIndex = index ^ 1;
+            proof.push({
+                siblingPosition: siblingIndex < index ? "left" : "right",
+                siblingHash: levels[depth][siblingIndex],
+            });
+            index = Math.floor(index / 2);
+        }
+        return {
+            ownerXonly,
+            leafHash: levels[0][ownerIndex],
+            proof,
+        };
+    });
+    return {
+        depth: exports.STRICT_POLICY_WHITELIST_DEPTH,
+        root: levels[exports.STRICT_POLICY_WHITELIST_DEPTH][0],
+        entries,
+    };
+}
+function verifyStrictPolicyWhitelistProof(input) {
+    const normalized = normalizeStrictPolicyWhitelistProof(input);
+    const ownerXonly = normalized.ownerXonly;
+    const expectedRoot = hex32(input.expectedRoot, "expectedRoot");
+    let node = computeStrictPolicyWhitelistOwnerLeaf(ownerXonly);
+    for (const step of normalized.proof) {
+        node = step.siblingPosition === "left"
+            ? computeStrictPolicyWhitelistNode(step.siblingHash, node)
+            : computeStrictPolicyWhitelistNode(node, step.siblingHash);
+    }
+    return node === expectedRoot;
+}
+function normalizeStrictPolicyWhitelistProof(input) {
+    const ownerXonly = hex32(input.ownerXonly, "ownerXonly");
+    if (!Array.isArray(input.proof) || input.proof.length !== exports.STRICT_POLICY_WHITELIST_DEPTH) {
+        validationError("proof", `must contain exactly ${exports.STRICT_POLICY_WHITELIST_DEPTH} sibling hashes`);
+    }
+    const proof = input.proof.map((step, index) => {
+        if (!step || typeof step !== "object") {
+            validationError(`proof[${index}]`, "must be an object");
+        }
+        if (step.siblingPosition !== "left" && step.siblingPosition !== "right") {
+            validationError(`proof[${index}].siblingPosition`, "must be left or right");
+        }
+        return {
+            siblingPosition: step.siblingPosition,
+            siblingHash: hex32(step.siblingHash, `proof[${index}].siblingHash`),
+        };
+    });
+    return { ownerXonly, proof };
+}
+function strictPolicyWhitelistTagHashes() {
+    return {
+        owner: sha256(Buffer.from(exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN, "utf8")).toString("hex"),
+        empty: sha256(Buffer.from(exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN, "utf8")).toString("hex"),
+        node: sha256(Buffer.from(exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN, "utf8")).toString("hex"),
+    };
+}

package/dist/domain/dampPset.d.ts

@@ -0,0 +1,51 @@
+import { type StrictPolicyNetwork } from "./damp";
+import { type StrictPolicyDecodedTransaction, type StrictPolicyProofBackedTransactionExpectation, type StrictPolicyProofBackedTransactionInspection } from "./dampTransaction";
+export declare const STRICT_POLICY_PSET_INSPECTION_SCHEMA: "hazbase_strict_policy_pset_inspection_v1";
+export interface StrictPolicySimplicityInputRequest {
+    inputIndex: number;
+    cmr: string;
+    genesisHash: string;
+}
+export interface StrictPolicySimplicityInputInspection extends StrictPolicySimplicityInputRequest {
+    sigAllHash: string;
+}
+export interface StrictPolicyPsetDecoderRequest {
+    psetBase64: string;
+    network: StrictPolicyNetwork;
+    simplicityInputs: StrictPolicySimplicityInputRequest[];
+}
+export type StrictPolicyPsetDecoder = (request: StrictPolicyPsetDecoderRequest) => Promise<unknown> | unknown;
+export interface StrictPolicyPsetInspection {
+    schema: typeof STRICT_POLICY_PSET_INSPECTION_SCHEMA;
+    psetVersion: 2;
+    inputCount: number;
+    outputCount: number;
+    inputSummaries: unknown[];
+    extractable: true;
+    canonicalPsetBase64: string;
+    psetHash: string;
+    canonicalPsetHash: string;
+    canonicalEncodingMatches: true;
+    unknownFieldCount: number;
+    proprietaryFieldCount: number;
+    decodedPset: Record<string, unknown>;
+    transaction: StrictPolicyDecodedTransaction;
+    simplicityInputs: StrictPolicySimplicityInputInspection[];
+}
+export interface StrictPolicyPsetSigningInspectionRequest {
+    psetBase64: string;
+    network: StrictPolicyNetwork;
+    simplicityInputs: StrictPolicySimplicityInputRequest[];
+    signingInputIndex: number;
+    serviceSighashHex?: string;
+    transactionExpectation: StrictPolicyProofBackedTransactionExpectation;
+    decodePset: StrictPolicyPsetDecoder;
+}
+export interface StrictPolicyPsetSigningInspection {
+    pset: StrictPolicyPsetInspection;
+    transaction: StrictPolicyProofBackedTransactionInspection;
+    signingInputIndex: number;
+    signingSighashHex: string;
+}
+export declare function normalizeStrictPolicyPsetInspection(value: unknown, expectedPsetBase64?: string): StrictPolicyPsetInspection;
+export declare function inspectStrictPolicyPsetForSigning(request: StrictPolicyPsetSigningInspectionRequest): Promise<StrictPolicyPsetSigningInspection>;

package/dist/domain/dampPset.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRICT_POLICY_PSET_INSPECTION_SCHEMA = void 0;
+exports.normalizeStrictPolicyPsetInspection = normalizeStrictPolicyPsetInspection;
+exports.inspectStrictPolicyPsetForSigning = inspectStrictPolicyPsetForSigning;
+const node_crypto_1 = require("node:crypto");
+const errors_1 = require("../core/errors");
+const damp_1 = require("./damp");
+const dampTransaction_1 = require("./dampTransaction");
+exports.STRICT_POLICY_PSET_INSPECTION_SCHEMA = "hazbase_strict_policy_pset_inspection_v1";
+function invalid(field, message) {
+    throw new errors_1.ValidationError(`${field} ${message}`, {
+        code: "STRICT_POLICY_PSET_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 uint(value, field) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        invalid(field, "must be a non-negative safe integer");
+    }
+    return value;
+}
+function uint32(value, field) {
+    const normalized = uint(value, field);
+    if (normalized > 0xffff_ffff)
+        invalid(field, "must be a uint32");
+    return normalized;
+}
+function trueValue(value, field) {
+    if (value !== true)
+        invalid(field, "must be true");
+    return true;
+}
+function strictBase64Bytes(value, field) {
+    const normalized = stringValue(value, field);
+    if (normalized.length % 4 !== 0
+        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(normalized)) {
+        invalid(field, "must be canonical standard base64");
+    }
+    const decoded = Buffer.from(normalized, "base64");
+    if (decoded.toString("base64") !== normalized) {
+        invalid(field, "must use canonical base64 encoding");
+    }
+    return decoded;
+}
+function psetHash(value, field) {
+    return (0, node_crypto_1.createHash)("sha256").update(strictBase64Bytes(value, field)).digest("hex");
+}
+function normalizeSimplicityInputRequest(value, field) {
+    const record = recordValue(value, field);
+    return {
+        inputIndex: uint32(record.inputIndex, `${field}.inputIndex`),
+        cmr: hex32(record.cmr, `${field}.cmr`),
+        genesisHash: hex32(record.genesisHash, `${field}.genesisHash`),
+    };
+}
+function normalizeSimplicityInputInspection(value, index) {
+    const field = `inspection.simplicityInputs[${index}]`;
+    const request = normalizeSimplicityInputRequest(value, field);
+    const record = value;
+    return {
+        ...request,
+        sigAllHash: hex32(record.sigAllHash, `${field}.sigAllHash`),
+    };
+}
+function normalizeNetwork(value, field) {
+    const network = stringValue(value, field);
+    if (!("liquid-regtest liquid-testnet liquid-mainnet".split(" ")).includes(network)) {
+        invalid(field, "is unsupported");
+    }
+    return network;
+}
+function normalizeStrictPolicyPsetInspection(value, expectedPsetBase64) {
+    const record = recordValue(value, "inspection");
+    if (typeof record.error === "string" && record.error.trim()) {
+        invalid("inspection.error", `reported ${record.error.trim()}`);
+    }
+    if (record.schema !== exports.STRICT_POLICY_PSET_INSPECTION_SCHEMA) {
+        invalid("inspection.schema", `must be ${exports.STRICT_POLICY_PSET_INSPECTION_SCHEMA}`);
+    }
+    if (record.psetVersion !== 2) {
+        invalid("inspection.psetVersion", "must be PSET v2");
+    }
+    const inputCount = uint(record.inputCount, "inspection.inputCount");
+    const outputCount = uint(record.outputCount, "inspection.outputCount");
+    if (!Array.isArray(record.inputs) || record.inputs.length !== inputCount) {
+        invalid("inspection.inputs", "must describe every PSET input exactly once");
+    }
+    if (record.extractable !== true) {
+        invalid("inspection.extractable", "must be true");
+    }
+    const canonicalPsetBase64 = stringValue(record.canonicalPsetBase64, "inspection.canonicalPsetBase64");
+    const canonicalPsetHash = hex32(record.canonicalPsetHash, "inspection.canonicalPsetHash");
+    const calculatedCanonicalHash = psetHash(canonicalPsetBase64, "inspection.canonicalPsetBase64");
+    if (canonicalPsetHash !== calculatedCanonicalHash) {
+        invalid("inspection.canonicalPsetHash", "does not match canonicalPsetBase64");
+    }
+    const inspectedPsetHash = hex32(record.psetHash, "inspection.psetHash");
+    trueValue(record.canonicalEncodingMatches, "inspection.canonicalEncodingMatches");
+    if (inspectedPsetHash !== canonicalPsetHash) {
+        invalid("inspection.psetHash", "does not match the canonical PSET hash");
+    }
+    if (expectedPsetBase64 !== undefined) {
+        const expectedHash = psetHash(expectedPsetBase64, "psetBase64");
+        if (inspectedPsetHash !== expectedHash) {
+            invalid("inspection.psetHash", "does not match the requested PSET");
+        }
+    }
+    const decodedPset = recordValue(record.decodedPset, "inspection.decodedPset");
+    const transaction = (0, dampTransaction_1.normalizeStrictPolicyDecodedTransaction)(record.transaction);
+    if (transaction.inputs.length !== inputCount) {
+        invalid("inspection.transaction.inputs", "count does not match the complete PSET");
+    }
+    if (transaction.outputs.length !== outputCount) {
+        invalid("inspection.transaction.outputs", "count does not match the complete PSET");
+    }
+    if (!Array.isArray(record.simplicityInputs)) {
+        invalid("inspection.simplicityInputs", "must be an array");
+    }
+    const simplicityInputs = record.simplicityInputs.map(normalizeSimplicityInputInspection);
+    const seenInputs = new Set();
+    for (const input of simplicityInputs) {
+        if (input.inputIndex >= inputCount) {
+            invalid("inspection.simplicityInputs", "contains an out-of-range input index");
+        }
+        if (seenInputs.has(input.inputIndex)) {
+            invalid("inspection.simplicityInputs", "must not contain duplicate input indexes");
+        }
+        seenInputs.add(input.inputIndex);
+    }
+    return {
+        schema: exports.STRICT_POLICY_PSET_INSPECTION_SCHEMA,
+        psetVersion: 2,
+        inputCount,
+        outputCount,
+        inputSummaries: record.inputs,
+        extractable: true,
+        canonicalPsetBase64,
+        psetHash: inspectedPsetHash,
+        canonicalPsetHash,
+        canonicalEncodingMatches: true,
+        unknownFieldCount: uint(record.unknownFieldCount, "inspection.unknownFieldCount"),
+        proprietaryFieldCount: uint(record.proprietaryFieldCount, "inspection.proprietaryFieldCount"),
+        decodedPset,
+        transaction,
+        simplicityInputs,
+    };
+}
+async function inspectStrictPolicyPsetForSigning(request) {
+    const psetBase64 = stringValue(request.psetBase64, "psetBase64");
+    const network = normalizeNetwork(request.network, "network");
+    if (typeof request.decodePset !== "function") {
+        invalid("decodePset", "must be a local complete-PSET decoder");
+    }
+    if (!Array.isArray(request.simplicityInputs) || request.simplicityInputs.length === 0) {
+        invalid("simplicityInputs", "must not be empty");
+    }
+    const simplicityInputs = request.simplicityInputs.map((input, index) => normalizeSimplicityInputRequest(input, `simplicityInputs[${index}]`));
+    const requestedIndexes = new Set();
+    for (const input of simplicityInputs) {
+        if (requestedIndexes.has(input.inputIndex)) {
+            invalid("simplicityInputs", "must not contain duplicate input indexes");
+        }
+        requestedIndexes.add(input.inputIndex);
+    }
+    const signingInputIndex = uint32(request.signingInputIndex, "signingInputIndex");
+    if (!requestedIndexes.has(signingInputIndex)) {
+        invalid("signingInputIndex", "must identify a requested Simplicity input");
+    }
+    const snapshot = (0, damp_1.normalizeStrictPolicySnapshotPayload)(request.transactionExpectation.snapshot);
+    if (network !== snapshot.network) {
+        invalid("network", "does not match the policy snapshot");
+    }
+    for (const input of simplicityInputs) {
+        if (input.genesisHash !== snapshot.liquidGenesisHash) {
+            invalid(`simplicityInputs[${input.inputIndex}].genesisHash`, "does not match the policy snapshot");
+        }
+    }
+    const signingRequest = simplicityInputs.find((input) => input.inputIndex === signingInputIndex);
+    if (signingRequest.cmr !== request.transactionExpectation.holderProgramCmr.toLowerCase()) {
+        invalid("signingInputIndex", "does not use the expected holder covenant CMR");
+    }
+    const decoded = await request.decodePset({
+        psetBase64,
+        network,
+        simplicityInputs,
+    });
+    const pset = normalizeStrictPolicyPsetInspection(decoded, psetBase64);
+    if (pset.transaction.network !== network) {
+        invalid("inspection.transaction.network", "does not match the signing request");
+    }
+    if (pset.simplicityInputs.length !== simplicityInputs.length) {
+        invalid("inspection.simplicityInputs", "must contain every requested input exactly once");
+    }
+    for (const expected of simplicityInputs) {
+        const inspected = pset.simplicityInputs.find((candidate) => candidate.inputIndex === expected.inputIndex);
+        if (!inspected || inspected.cmr !== expected.cmr || inspected.genesisHash !== expected.genesisHash) {
+            invalid(`inspection.simplicityInputs[${expected.inputIndex}]`, "does not match the requested input, CMR, and genesis hash");
+        }
+    }
+    const transaction = await (0, dampTransaction_1.inspectStrictPolicyTransactionWithProofs)(pset.transaction, request.transactionExpectation);
+    if (!transaction.summary.strictInputIndexes.includes(signingInputIndex)) {
+        invalid("signingInputIndex", "must identify a strict-asset input");
+    }
+    const signingInspection = pset.simplicityInputs.find((input) => input.inputIndex === signingInputIndex);
+    if (request.serviceSighashHex !== undefined) {
+        const serviceHint = hex32(request.serviceSighashHex, "serviceSighashHex");
+        if (serviceHint !== signingInspection.sigAllHash) {
+            invalid("serviceSighashHex", "does not match the locally recomputed sig_all_hash");
+        }
+    }
+    return {
+        pset,
+        transaction,
+        signingInputIndex,
+        signingSighashHex: signingInspection.sigAllHash,
+    };
+}

package/dist/domain/dampTransaction.d.ts

@@ -0,0 +1,96 @@
+import { type StrictPolicyNetwork, type StrictPolicySnapshotPayload } from "./damp";
+import { type StrictPolicyWhitelistProofStep } from "./dampPolicy";
+export declare const STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA: "hazbase_strict_policy_transaction_summary_v1";
+export type StrictPolicyOperation = "purchase" | "transfer" | "redemption";
+export interface StrictPolicyTransactionOutpoint {
+    txid: string;
+    vout: number;
+}
+export interface StrictPolicyDecodedInput {
+    outpoint: StrictPolicyTransactionOutpoint;
+    assetId: string;
+    amountAtomic: string;
+    scriptHash: string;
+    hasIssuance: boolean;
+}
+export interface StrictPolicyDecodedOutput {
+    assetId: string;
+    amountAtomic: string;
+    scriptHash: string;
+    isFee: boolean;
+}
+export interface StrictPolicyDecodedTransaction {
+    network: StrictPolicyNetwork;
+    inputs: StrictPolicyDecodedInput[];
+    outputs: StrictPolicyDecodedOutput[];
+    feeAmountAtomic: string;
+}
+export interface StrictPolicyTransactionExpectation {
+    operation: StrictPolicyOperation;
+    snapshot: StrictPolicySnapshotPayload | unknown;
+    feeAssetId: string;
+    maxFeeAmountAtomic: string;
+    /** Derived locally from a verified policy proof; never trust a service hint here. */
+    allowedStrictOutputScriptHashes: string[];
+}
+export interface StrictPolicyOutputAuthorization {
+    outputIndex: number;
+    ownerXonly: string;
+    proof: StrictPolicyWhitelistProofStep[];
+}
+export interface StrictPolicyProofBackedTransactionExpectation {
+    operation: StrictPolicyOperation;
+    snapshot: StrictPolicySnapshotPayload | unknown;
+    feeAssetId: string;
+    maxFeeAmountAtomic: string;
+    holderProgramCmr: string;
+    holderNumsInternalKey: string;
+    strictOutputAuthorizations: StrictPolicyOutputAuthorization[];
+}
+export interface StrictPolicyVerifiedOutputAuthorization extends StrictPolicyOutputAuthorization {
+    derivedScriptHash: string;
+}
+export interface StrictPolicyTransactionSummary {
+    schema: typeof STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA;
+    operation: StrictPolicyOperation;
+    network: StrictPolicyNetwork;
+    snapshotHash: string;
+    transactionViewHash: string;
+    allowedStrictOutputSetHash: string;
+    verifierOutpoint: StrictPolicyTransactionOutpoint;
+    verifierAssetId: string;
+    verifierAmountAtomic: string;
+    strictAssetId: string;
+    strictInputIndexes: number[];
+    strictOutputIndexes: number[];
+    strictAmountAtomic: string;
+    feeAssetId: string;
+    feeAmountAtomic: string;
+    feeOutputIndex: number;
+    inputCount: number;
+    outputCount: number;
+}
+export interface StrictPolicyTransactionInspection {
+    transaction: StrictPolicyDecodedTransaction;
+    snapshot: StrictPolicySnapshotPayload;
+    summary: StrictPolicyTransactionSummary;
+    canonicalSummary: string;
+    summaryHash: string;
+}
+export interface StrictPolicyProofBackedTransactionInspection extends StrictPolicyTransactionInspection {
+    strictOutputAuthorizations: StrictPolicyVerifiedOutputAuthorization[];
+}
+export declare function normalizeStrictPolicyDecodedTransaction(value: StrictPolicyDecodedTransaction | unknown): StrictPolicyDecodedTransaction;
+/**
+ * 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.
+ */
+export declare function inspectStrictPolicyTransaction(transactionValue: StrictPolicyDecodedTransaction | unknown, expectation: StrictPolicyTransactionExpectation): StrictPolicyTransactionInspection;
+/**
+ * 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.
+ */
+export declare function inspectStrictPolicyTransactionWithProofs(transactionValue: StrictPolicyDecodedTransaction | unknown, expectation: StrictPolicyProofBackedTransactionExpectation): Promise<StrictPolicyProofBackedTransactionInspection>;