tbc-tx-parser 0.1.9 → 0.2.0

package/dist/protocols/modern/analyze.js

@@ -0,0 +1,887 @@
+import { assetIdentities } from '../../core/asset-identity.js';
+import sdk from 'tbc-contract';
+import { tbc } from '../../adapters/tbc-lib.js';
+import { address, controllerHash, htlcCode, nftCode, orderCode, outpoint, poolCode, poolTape, poolMath, sha256, tokenCode, tokenState, } from './codecs.js';
+const sum = (items) => items.reduce((n, t) => n + t.state.balance, 0n);
+const owner = (s) => s.controller[20] === 0
+    ? { address: address(s.controller.subarray(0, 20)) }
+    : { hash: s.controller.subarray(0, 20).toString('hex') };
+const sameOwner = (a, b) => a.controller.equals(b.controller);
+function exactDisplay(n, decimal) {
+    const v = n.toString().padStart(decimal + 1, '0');
+    return decimal ? `${v.slice(0, -decimal)}.${v.slice(-decimal)}`.replace(/\.?0+$/, '') : v;
+}
+function classification(protocol, action, issues, description) {
+    return {
+        protocol,
+        action,
+        conformance: !issues.length
+            ? 'standard'
+            : issues.some((issue) => /MISSING|UNRESOLVED|UNVERIFIED|AMBIGUOUS|UNKNOWN|UNRECOGNIZED/.test(issue))
+                ? 'indeterminate'
+                : 'nonstandard',
+        description,
+        ...(issues.length ? { issues: [...new Set(issues)] } : {}),
+    };
+}
+function checkCertificate(inputs, outputs, s, amount) {
+    const cert = inputs.find((i) => i.prevout?.script.hex &&
+        sha256(Buffer.from(i.prevout.script.hex, 'hex')).toString('hex') === s.coinNftCodeHash);
+    if (!cert?.prevout)
+        return false;
+    const code = nftCode(cert.prevout.script.hex);
+    if (!code)
+        return false;
+    const before = cert.prevout.associatedTape;
+    if (!before ||
+        before.txid !== cert.prevTxid ||
+        before.outputIndex !== cert.vout + 2 ||
+        before.satoshis !== 0)
+        return false;
+    const old = before.script.data?.nftTape;
+    const newCode = outputs.find((o) => o.script.hex === cert.prevout.script.hex);
+    const next = newCode && outputs[newCode.index + 2]?.script.data?.nftTape;
+    const hold = inputs.find((i) => i.prevTxid === cert.prevTxid && i.vout === cert.vout + 1);
+    const newHold = newCode && outputs[newCode.index + 1];
+    if (!old || !next || !hold?.prevout || !newHold || hold.prevout.script.hex !== newHold.script.hex)
+        return false;
+    const h = new tbc.Script(newHold.script.hex);
+    if (h.chunks[2]?.buf?.toString('hex') !== s.adminPubKeyHash ||
+        !newHold.script.hex?.includes(Buffer.from('For Coin ').toString('hex')))
+        return false;
+    try {
+        return (BigInt(String(next.coinTotalSupply)) - BigInt(String(old.coinTotalSupply)) === amount &&
+            next.nftName === old.nftName &&
+            next.nftSymbol === old.nftSymbol &&
+            next.coinDecimal === old.coinDecimal);
+    }
+    catch {
+        return false;
+    }
+}
+/** Interpret modern versions within the established families, keeping the complete output ledger. */
+export function analyzeModern(inputs, outputs, txid, locktime, baseFlows, baseClassification) {
+    const issues = [];
+    const ins = [], outs = [];
+    for (const i of inputs) {
+        const p = i.prevout, hex = p?.script.hex;
+        if (!hex || !tokenCode(hex))
+            continue;
+        const tape = p.associatedTape;
+        if (!tape ||
+            tape.txid !== i.prevTxid ||
+            tape.outputIndex !== i.vout + 1 ||
+            tape.satoshis !== 0 ||
+            !tape.script.hex) {
+            issues.push('MISSING_OR_MISMATCHED_TOKEN_TAPE');
+            continue;
+        }
+        const state = tokenState(hex, tape.script.hex);
+        if (!state || p.satoshis !== 500) {
+            issues.push('INVALID_TOKEN_CODE_TAPE');
+            continue;
+        }
+        ins.push({
+            state,
+            index: i.index,
+            hex,
+            satoshis: p.satoshis,
+            id: p.contractId,
+        });
+    }
+    for (const o of outputs) {
+        const hex = o.script.hex;
+        if (!hex || !tokenCode(hex))
+            continue;
+        const tape = outputs[o.index + 1];
+        const state = tape?.script.hex && tape.satoshis === 0 && o.satoshis === 500
+            ? tokenState(hex, tape.script.hex)
+            : undefined;
+        if (!state) {
+            issues.push('INVALID_TOKEN_CODE_TAPE');
+            continue;
+        }
+        outs.push({ state, index: o.index, hex, satoshis: o.satoshis });
+    }
+    const poolInputs = inputs.flatMap((i) => {
+        const hex = i.prevout?.script.hex, p = hex && poolCode(hex);
+        return p
+            ? [
+                {
+                    index: i.index,
+                    hex: hex,
+                    code: p,
+                    tape: i.prevout.associatedTape,
+                    value: i.prevout.satoshis,
+                },
+            ]
+            : [];
+    });
+    const poolOutputs = outputs.flatMap((o) => {
+        const hex = o.script.hex, p = hex && poolCode(hex);
+        return p
+            ? [
+                {
+                    index: o.index,
+                    hex: hex,
+                    code: p,
+                    tape: outputs[o.index + 1],
+                    value: o.satoshis,
+                },
+            ]
+            : [];
+    });
+    const orderInputs = inputs.flatMap((i) => {
+        const p = i.prevout?.script.hex && orderCode(i.prevout.script.hex);
+        return p ? [{ ...p, index: i.index, hex: i.prevout.script.hex }] : [];
+    });
+    const orderOutputs = outputs.flatMap((o) => {
+        const p = o.script.hex && orderCode(o.script.hex);
+        return p ? [{ ...p, index: o.index, hex: o.script.hex }] : [];
+    });
+    const htlcInputs = inputs.flatMap((i) => {
+        const p = i.prevout?.script.hex && htlcCode(i.prevout.script.hex);
+        return p ? [{ ...p, index: i.index, hex: i.prevout.script.hex }] : [];
+    });
+    const htlcOutputs = outputs.flatMap((o) => {
+        const p = o.script.hex && htlcCode(o.script.hex);
+        return p ? [{ ...p, index: o.index, hex: o.script.hex }] : [];
+    });
+    const certOutput = outputs.find((o) => nftCode(o.script.hex ?? '') &&
+        outputs[o.index + 1]?.script.hex?.includes(Buffer.from('For Coin ').toString('hex')) &&
+        outputs[o.index + 2]?.script.data?.nftTape?.coinTotalSupply === '0');
+    const modernPresent = certOutput ||
+        ins.length ||
+        outs.length ||
+        issues.length ||
+        poolInputs.length ||
+        poolOutputs.length ||
+        htlcInputs.length ||
+        htlcOutputs.length ||
+        orderOutputs.some((o) => o.modern) ||
+        orderInputs.some((o) => o.modern);
+    if (!modernPresent)
+        return undefined;
+    const tokenFlows = [];
+    const flowOutputs = new Map();
+    const nativeSources = new Map();
+    function bindNativePayout(amount, hash, destination) {
+        const output = outputs.find((o) => o.script.type === 'P2PKH' &&
+            BigInt(o.satoshis) === amount &&
+            (!destination || o.address === destination));
+        if (output)
+            nativeSources.set(output.index, { hash });
+        else
+            issues.push('CONTRACT_NATIVE_PAYOUT_MISMATCH');
+    }
+    const tokenOutputIndexes = new Set(outs.map((t) => t.index));
+    let protocol = outs.some((t) => t.state.descriptor.family === 'stablecoin')
+        ? 'stablecoin'
+        : 'ft';
+    let action = 'transfer';
+    const identities = new Set([...ins, ...outs].map((t) => t.state.identity));
+    for (const identity of identities) {
+        const from = ins.filter((t) => t.state.identity === identity), to = outs.filter((t) => t.state.identity === identity), s = to[0]?.state ?? from[0].state;
+        const delta = sum(to) - sum(from);
+        const ids = [...new Set(from.map((t) => t.id).filter((v) => !!v))];
+        if (ids.length > 1)
+            issues.push('CONTRADICTORY_TOKEN_IDENTITY');
+        let id = ids.length === 1 ? ids[0] : undefined;
+        for (const t of [...from, ...to])
+            if (t.state.decimal !== s.decimal || t.state.name !== s.name || t.state.symbol !== s.symbol)
+                issues.push('TOKEN_METADATA_CHANGED');
+        for (const i of from) {
+            if (i.state.controller[20] === 1 &&
+                !inputs.some((p) => p.prevout?.script.hex && controllerHash(p.prevout.script.hex) === owner(i.state).hash))
+                issues.push('MISSING_TOKEN_CONTROLLER');
+        }
+        const origin = s.origin;
+        const source = origin &&
+            inputs.find((i) => i.prevTxid === origin.txid &&
+                i.vout === origin.vout &&
+                i.prevout?.script.type === 'P2PKH');
+        const standardMint = s.descriptor.family === 'ft' &&
+            !from.length &&
+            !!source &&
+            delta > 0n &&
+            (!s.declaredSupplyRaw || delta === s.declaredSupplyRaw);
+        const stableMint = s.descriptor.family === 'stablecoin' &&
+            delta > 0n &&
+            checkCertificate(inputs, outputs, s, delta);
+        const lpMint = s.descriptor.family === 'ftlp' &&
+            poolOutputs.some((p) => sha256(Buffer.from(p.hex, 'hex')).toString('hex') === s.poolCodeHash) &&
+            delta > 0n;
+        if (standardMint)
+            id = txid;
+        if (stableMint) {
+            const cert = inputs.find((i) => i.prevout?.script.hex &&
+                sha256(Buffer.from(i.prevout.script.hex, 'hex')).toString('hex') === s.coinNftCodeHash);
+            // The certificate creation txid is available when supplied by caller; never substitute each mint txid.
+            id =
+                cert?.prevout?.contractId ??
+                    (cert?.prevout?.associatedTape?.script.data?.nftTape?.coinTotalSupply === '0'
+                        ? cert.prevTxid
+                        : undefined);
+        }
+        const mint = standardMint || stableMint || lpMint;
+        if (delta !== 0n && !mint)
+            issues.push('TOKEN_AMOUNT_NOT_CONSERVED');
+        if (mint)
+            action = 'mint';
+        else if (from.length > to.length && to.length === 1)
+            action = 'merge';
+        if (!from.length && !mint && !(delta === 0n && poolOutputs.length))
+            issues.push('UNRESOLVED_TOKEN_ORIGIN');
+        if (s.descriptor.family === 'stablecoin' && from.length && to.length && delta === 0n) {
+            const maxBefore = Math.max(...from.map((t) => t.state.lockTime));
+            const maxAfter = Math.max(...to.map((t) => t.state.lockTime));
+            if (maxAfter > maxBefore)
+                action = 'freeze';
+            else if (maxAfter < maxBefore)
+                action = 'unfreeze';
+            if (maxAfter !== maxBefore &&
+                from.some((i) => to.some((o) => o.state.amounts[i.index] > 0n && !sameOwner(i.state, o.state))))
+                issues.push('STABLECOIN_ADMIN_CHANGED_OWNER');
+        }
+        for (const o of to) {
+            if (o.state.balance === 0n)
+                continue;
+            const endpoint = owner(o.state);
+            const sources = from.filter((t) => o.state.amounts[t.index] > 0n);
+            const owners = [
+                ...new Set((sources.length ? sources : from).map((t) => JSON.stringify(owner(t.state)))),
+            ].map((v) => JSON.parse(v));
+            const originEndpoint = owners.length === 1
+                ? owners[0]
+                : {
+                    outpoints: from.map((t) => ({
+                        txid: inputs[t.index].prevTxid,
+                        vout: inputs[t.index].vout,
+                    })),
+                };
+            const isSelf = (sources.length ? sources : from).length > 0 &&
+                (sources.length ? sources : from).every((t) => sameOwner(t.state, o.state));
+            const burned = endpoint.address === '1BitcoinEaterAddressDontSendf59kuE';
+            const context = {
+                protocol: s.descriptor.family === 'ftlp' ? 'poolNft' : s.descriptor.family,
+                recognized: issues.length === 0,
+                action,
+            };
+            const asset = {
+                type: s.descriptor.family,
+                symbol: s.symbol ?? (s.descriptor.family === 'stablecoin' ? 'StableCoin' : 'FT'),
+                ...(s.name ? { name: s.name } : {}),
+                ...(id ? { contractId: id } : {}),
+                ...(s.decimal !== undefined ? { decimal: s.decimal } : {}),
+            };
+            assetIdentities.set(asset, s.identity);
+            const amount = {
+                raw: o.state.balance.toString(),
+                ...(s.decimal !== undefined
+                    ? {
+                        decimal: s.decimal,
+                        display: exactDisplay(o.state.balance, s.decimal),
+                    }
+                    : {}),
+            };
+            if (burned && from.length)
+                tokenFlows.push({
+                    asset,
+                    amount,
+                    purpose: 'burn',
+                    direction: 'out',
+                    from: originEndpoint,
+                    context,
+                });
+            else if (mint && !from.length)
+                tokenFlows.push({
+                    asset,
+                    amount,
+                    purpose: 'mint',
+                    direction: 'in',
+                    to: endpoint,
+                    context,
+                });
+            else if (isSelf)
+                tokenFlows.push({
+                    asset,
+                    amount,
+                    purpose: 'self',
+                    direction: 'self',
+                    from: originEndpoint,
+                    to: endpoint,
+                    context,
+                });
+            else if (from.length)
+                tokenFlows.push({
+                    asset,
+                    amount,
+                    purpose: 'transfer',
+                    direction: 'out',
+                    from: originEndpoint,
+                    to: endpoint,
+                    context,
+                });
+            else
+                tokenFlows.push({
+                    asset,
+                    amount,
+                    purpose: 'unknown',
+                    direction: 'unknown',
+                    to: endpoint,
+                    context: { ...context, recognized: false },
+                });
+            flowOutputs.set(tokenFlows.at(-1), o);
+        }
+        // Per-input slot attribution is independently checked for ordinary conservation paths.
+        if (delta === 0n && from.length)
+            for (const i of from) {
+                if (to.reduce((n, o) => n + (o.state.amounts[i.index] ?? 0n), 0n) !== i.state.balance)
+                    issues.push('TOKEN_INPUT_SLOT_MISMATCH');
+            }
+    }
+    if (issues.length && !ins.length && !outs.length)
+        protocol =
+            inputs.some((i) => i.prevout?.script.contract?.family === 'stablecoin') ||
+                outputs.some((o) => o.script.contract?.family === 'stablecoin')
+                ? 'stablecoin'
+                : 'ft';
+    if (outs.length && outs.every((t) => t.state.descriptor.family === 'ftlp')) {
+        protocol = 'poolNft';
+        action = tokenFlows.some((f) => f.purpose === 'burn')
+            ? 'burnFtLp'
+            : ins.length > outs.length
+                ? 'mergeFtLp'
+                : 'transferFtLp';
+    }
+    if (certOutput && !outs.length && !ins.length) {
+        protocol = 'stablecoin';
+        action = 'bootstrap';
+        const origin = nftCode(certOutput.script.hex).origin;
+        if (!inputs.some((i) => i.prevTxid === origin.txid && i.vout === origin.vout) ||
+            certOutput.satoshis !== 200 ||
+            outputs[certOutput.index + 1]?.satoshis !== 100 ||
+            outputs[certOutput.index + 2]?.satoshis !== 0)
+            issues.push('INVALID_STABLECOIN_CERTIFICATE');
+    }
+    if (poolInputs.length || poolOutputs.length) {
+        protocol = 'poolNft';
+        action = 'unknown';
+        const p = poolInputs[0], q = poolOutputs[0];
+        if (poolInputs.length > 1 || poolOutputs.length !== 1 || !q)
+            issues.push('AMBIGUOUS_POOL_STATE');
+        const next = q?.tape?.script.hex && poolTape(q.tape.script.hex);
+        const previous = p?.tape?.script.hex && poolTape(p.tape.script.hex);
+        if (!next || q?.tape?.satoshis !== 0 || q.value < 1500)
+            issues.push('INVALID_POOL_TAPE');
+        if (p &&
+            (!previous ||
+                p.tape?.txid !== inputs[p.index].prevTxid ||
+                p.tape.outputIndex !== inputs[p.index].vout + 1 ||
+                p.hex !== q?.hex))
+            issues.push('INVALID_POOL_CONTINUITY');
+        if (next && q) {
+            const expectedOrigin = outpoint(q.code.originalUTXO);
+            if (!p) {
+                if (inputs.some((i) => i.prevTxid === expectedOrigin.txid && i.vout === expectedOrigin.vout) &&
+                    next.ftAAmount === 0n &&
+                    next.ftLpAmount === 0n &&
+                    next.tbcAmount === 0n)
+                    action = 'create';
+                else
+                    issues.push('UNVERIFIED_POOL_CREATION');
+            }
+            else if (previous) {
+                const config = (v) => JSON.stringify({ ...v, ftAAmount: '', ftLpAmount: '', tbcAmount: '' }, (_, v) => typeof v === 'bigint' ? v.toString() : v);
+                if (config(previous) !== config(next))
+                    issues.push('POOL_CONFIGURATION_CHANGED');
+                const dl = next.ftLpAmount - previous.ftLpAmount, df = next.ftAAmount - previous.ftAAmount, dt = next.tbcAmount - previous.tbcAmount;
+                if (dl > 0n && df > 0n && dt > 0n)
+                    action = previous.ftLpAmount === 0n ? 'init' : 'increaseLiquidity';
+                else if (dl < 0n && df < 0n && dt < 0n)
+                    action = 'consumeLiquidity';
+                else if (dl === 0n && df < 0n && dt > 0n)
+                    action = 'swapTbcToFt';
+                else if (dl === 0n && df > 0n && dt < 0n)
+                    action = 'swapFtToTbc';
+                else if (dl === 0n && df === 0n && dt === 0n)
+                    action = 'mergeFtInPool';
+                else
+                    issues.push('UNRECOGNIZED_POOL_TRANSITION');
+                try {
+                    const state = {
+                        ftLpAmount: previous.ftLpAmount,
+                        ftAAmount: previous.ftAAmount,
+                        tbcAmount: previous.tbcAmount,
+                        poolValue: BigInt(p.value),
+                    };
+                    const policy = sdk.resolveSwapFeePolicy(next.lpPlan, next.serviceFeeRate);
+                    const matches = (v) => v.ftLpAmount === next.ftLpAmount &&
+                        v.ftAAmount === next.ftAAmount &&
+                        v.tbcAmount === next.tbcAmount &&
+                        v.poolValue === BigInt(q.value);
+                    let valid = false;
+                    if (action === 'init' || action === 'increaseLiquidity')
+                        valid = matches(poolMath.quoteAddLP(state, BigInt(q.value - p.value), action === 'init' ? df : undefined).nextState);
+                    else if (action === 'consumeLiquidity') {
+                        const quote = poolMath.quoteRemoveLP(state, -dl);
+                        valid = matches(quote.nextState);
+                        bindNativePayout(quote.poolValueDecrementSat, controllerHash(p.hex));
+                    }
+                    else if (action === 'swapFtToTbc') {
+                        const quote = poolMath.quoteSwapTBC(state, df, policy);
+                        valid = matches(quote.nextState);
+                        bindNativePayout(quote.tbcOutSat, controllerHash(p.hex));
+                        if (quote.fees.serviceFeePaidSat > 0n &&
+                            !outputs.some((o) => BigInt(o.satoshis) === quote.fees.serviceFeePaidSat &&
+                                sha256(Buffer.from(o.script.hex, 'hex')).equals(q.code.tbcFeeScriptHash)))
+                            valid = false;
+                    }
+                    else if (action === 'swapTbcToFt') {
+                        const paid = [
+                            0,
+                            ...outputs
+                                .filter((o) => sha256(Buffer.from(o.script.hex, 'hex')).equals(q.code.tbcFeeScriptHash))
+                                .map((o) => o.satoshis),
+                        ];
+                        valid = paid.some((fee) => {
+                            try {
+                                const quote = poolMath.quoteSwapFT(state, BigInt(q.value - p.value + fee), policy);
+                                return matches(quote.nextState) && quote.fees.serviceFeePaidSat === BigInt(fee);
+                            }
+                            catch {
+                                return false;
+                            }
+                        });
+                    }
+                    else if (action === 'mergeFtInPool')
+                        valid = p.value === q.value;
+                    if (!valid)
+                        issues.push('POOL_AMOUNT_OR_FEE_MISMATCH');
+                }
+                catch {
+                    issues.push('POOL_AMOUNT_OR_FEE_MISMATCH');
+                }
+            }
+            const identity = next.ftAPartialHash.toString('hex');
+            const all = [...ins, ...outs];
+            if (all.some((t) => t.state.controller[20] === 1 &&
+                t.state.controller.subarray(0, 20).toString('hex') === controllerHash(q.hex) &&
+                t.state.identity.slice(0, 64) !== identity))
+                issues.push('POOL_TOKEN_IDENTITY_MISMATCH');
+            const lp = all.filter((t) => t.state.descriptor.family === 'ftlp');
+            if (lp.some((t) => t.state.poolCodeHash !== sha256(Buffer.from(q.hex, 'hex')).toString('hex') ||
+                t.state.identity.slice(0, 64) !== next.ftLpPartialHash.toString('hex')))
+                issues.push('POOL_LP_IDENTITY_MISMATCH');
+            for (const f of tokenFlows)
+                if (assetIdentities.get(f.asset)?.slice(0, 64) === identity)
+                    Object.assign(f.asset, { contractId: next.ftAContractId });
+            const poolOwner = controllerHash(q.hex);
+            const reserve = (list) => sum(list.filter((t) => t.state.controller[20] === 1 &&
+                t.state.controller.subarray(0, 20).toString('hex') === poolOwner &&
+                t.state.identity.slice(0, 64) === identity));
+            if (reserve(outs) !== next.ftAAmount || (previous && reserve(ins) !== previous.ftAAmount))
+                issues.push('POOL_TOKEN_RESERVE_MISMATCH');
+            if (previous) {
+                const lpInputs = ins.filter((t) => t.state.descriptor.family === 'ftlp'), lpOutputs = outs.filter((t) => t.state.descriptor.family === 'ftlp');
+                const burned = sum(lpOutputs.filter((t) => owner(t.state).address === '1BitcoinEaterAddressDontSendf59kuE'));
+                if (sum(lpOutputs) - sum(lpInputs) - burned !== next.ftLpAmount - previous.ftLpAmount)
+                    issues.push('POOL_LP_SUPPLY_MISMATCH');
+            }
+        }
+    }
+    if (orderInputs.length || orderOutputs.length) {
+        protocol = 'orderBook';
+        action = 'unknown';
+        for (const o of [...orderInputs, ...orderOutputs]) {
+            for (const token of [o.tokenA, ...(o.tokenB ? [o.tokenB] : [])]) {
+                const relevant = [...ins, ...outs].filter((t) => t.state.identity.slice(0, 64) === token.partialHash);
+                const lockedToken = o.tokenB
+                    ? o.side === 'sell'
+                        ? o.tokenA
+                        : o.tokenB
+                    : o.side === 'buy'
+                        ? o.tokenA
+                        : undefined;
+                const needsToken = orderInputs.length === 2 || lockedToken === token;
+                if (!relevant.length && needsToken)
+                    issues.push('ORDER_TOKEN_EVIDENCE_MISSING');
+                // StableCoin orders can refer to the first issuance txid, while the indexed
+                // asset ID names its certificate. The immutable partial hash binds the asset;
+                // preserve the caller's verified StableCoin ID instead of replacing it.
+                if (relevant.some((t) => t.state.descriptor.family !== 'stablecoin' && t.id && t.id !== token.id))
+                    issues.push('ORDER_TOKEN_IDENTITY_MISMATCH');
+                for (const f of tokenFlows) {
+                    if (assetIdentities.get(f.asset)?.slice(0, 64) === token.partialHash &&
+                        !('contractId' in f.asset && f.asset.contractId))
+                        Object.assign(f.asset, { contractId: token.id });
+                }
+            }
+        }
+        if (!orderInputs.length && orderOutputs.length === 1)
+            action = orderOutputs[0].side === 'buy' ? 'placeBuy' : 'placeSell';
+        else if (orderInputs.length === 1 && !orderOutputs.length) {
+            const i = inputs[orderInputs[0].index];
+            const chunks = new tbc.Script(i.unlockingScript.hex ?? '').chunks;
+            if (chunks.at(-1)?.opcodenum === tbc.Opcode.OP_2)
+                action = orderInputs[0].side === 'buy' ? 'cancelBuy' : 'cancelSell';
+            else
+                issues.push('UNVERIFIED_ORDER_CANCEL');
+            const order = orderInputs[0];
+            const controlled = ins.filter((t) => owner(t.state).hash === controllerHash(order.hex));
+            if (controlled.length) {
+                for (const token of controlled)
+                    if (!outs.some((t) => t.state.identity === token.state.identity &&
+                        owner(t.state).address === order.owner &&
+                        t.state.balance === token.state.balance))
+                        issues.push('ORDER_CANCEL_RECIPIENT_MISMATCH');
+            }
+            else {
+                bindNativePayout(order.volume, controllerHash(order.hex), order.owner);
+            }
+        }
+        else if (orderInputs.length === 2) {
+            const buy = orderInputs.find((o) => o.side === 'buy'), sell = orderInputs.find((o) => o.side === 'sell');
+            if (buy &&
+                sell &&
+                buy.tokenA.id === sell.tokenA.id &&
+                buy.tokenA.partialHash === sell.tokenA.partialHash &&
+                buy.tokenB?.id === sell.tokenB?.id &&
+                buy.tokenB?.partialHash === sell.tokenB?.partialHash &&
+                buy.price === sell.price) {
+                action = 'match';
+                if (orderOutputs.some((o) => !orderInputs.some((i) => i.owner === o.owner &&
+                    i.side === o.side &&
+                    i.price === o.price &&
+                    i.feeRate === o.feeRate &&
+                    i.taxAddress === o.taxAddress &&
+                    i.tokenA.id === o.tokenA.id &&
+                    i.tokenB?.id === o.tokenB?.id &&
+                    o.volume < i.volume)))
+                    issues.push('INVALID_ORDER_REMAINDER');
+                const matched = buy.volume < sell.volume ? buy.volume : sell.volume;
+                for (const original of [buy, sell]) {
+                    const remaining = original.volume - matched;
+                    const continuations = orderOutputs.filter((o) => o.side === original.side);
+                    if (remaining === 0n
+                        ? continuations.length !== 0
+                        : continuations.length !== 1 || continuations[0].volume !== remaining)
+                        issues.push('INVALID_ORDER_REMAINDER');
+                }
+                const aNet = matched - (matched * buy.feeRate) / 1000000n;
+                const payment = (matched * sell.price) / 1000000n;
+                const bNet = payment - (payment * sell.feeRate) / 1000000n;
+                const paid = (hash, to, n) => outs.some((t) => t.state.identity.slice(0, 64) === hash &&
+                    owner(t.state).address === to &&
+                    t.state.balance === n);
+                if (!buy.tokenB)
+                    bindNativePayout(aNet, controllerHash(sell.hex), buy.owner);
+                const aFee = matched - aNet, bFee = payment - bNet;
+                if (!buy.tokenB && aFee > 0n)
+                    bindNativePayout(aFee, controllerHash(sell.hex), buy.taxAddress);
+                if (bFee > 0n &&
+                    !paid(buy.tokenB?.partialHash ?? buy.tokenA.partialHash, sell.taxAddress, bFee))
+                    issues.push('ORDER_FEE_MISMATCH');
+                if (aFee > 0n &&
+                    (buy.tokenB
+                        ? !paid(buy.tokenA.partialHash, buy.taxAddress, aFee)
+                        : !outputs.some((o) => o.address === buy.taxAddress && BigInt(o.satoshis) === aFee)))
+                    issues.push('ORDER_FEE_MISMATCH');
+                if (buy.tokenB) {
+                    if (!paid(buy.tokenA.partialHash, buy.owner, aNet) ||
+                        !paid(buy.tokenB.partialHash, sell.owner, bNet))
+                        issues.push('ORDER_SETTLEMENT_MISMATCH');
+                }
+                else if (!outputs.some((o) => o.address === buy.owner && BigInt(o.satoshis) === aNet) ||
+                    !paid(buy.tokenA.partialHash, sell.owner, bNet))
+                    issues.push('ORDER_SETTLEMENT_MISMATCH');
+            }
+            else
+                issues.push('ORDER_PAIR_MISMATCH');
+        }
+        else
+            issues.push('AMBIGUOUS_ORDER_OPERATION');
+    }
+    for (const o of [
+        ...orderInputs.map((o) => ({ ...o, source: 'input' })),
+        ...orderOutputs.map((o) => ({ ...o, source: 'output' })),
+    ]) {
+        const locked = o.tokenB
+            ? o.side === 'sell'
+                ? o.tokenA
+                : o.tokenB
+            : o.side === 'buy'
+                ? o.tokenA
+                : undefined;
+        if (!locked)
+            continue;
+        const list = o.source === 'input' ? ins : outs;
+        const n = sum(list.filter((t) => t.state.identity.slice(0, 64) === locked.partialHash &&
+            owner(t.state).hash === controllerHash(o.hex)));
+        const needed = o.side === 'buy' ? (o.volume * o.price) / 1000000n : o.volume;
+        if (n < needed)
+            issues.push('ORDER_LOCKED_BALANCE_MISMATCH');
+    }
+    if (htlcInputs.length || htlcOutputs.length) {
+        protocol = 'htlc';
+        action = 'deploy';
+        if (htlcInputs.length === 1) {
+            const h = htlcInputs[0], i = inputs[h.index], chunks = new tbc.Script(i.unlockingScript.hex ?? '').chunks;
+            const branch = chunks.at(-1)?.opcodenum;
+            if (branch === tbc.Opcode.OP_1) {
+                const secret = chunks.at(-2)?.buf;
+                if (secret && sha256(secret).toString('hex') === h.hashlock)
+                    action = 'withdraw';
+                else
+                    issues.push('HTLC_PREIMAGE_MISMATCH');
+            }
+            else if (branch === tbc.Opcode.OP_0) {
+                action = 'refund';
+                if (i.sequence === 0xffffffff ||
+                    locktime < h.timelock ||
+                    locktime < 500000000 !== h.timelock < 500000000)
+                    issues.push('HTLC_LOCK_UNSATISFIED');
+            }
+            else {
+                action = 'unknown';
+                issues.push('HTLC_UNKNOWN_BRANCH');
+            }
+            const receiver = action === 'refund' ? h.sender : h.receiver;
+            const controlled = ins.filter((t) => owner(t.state).hash === controllerHash(h.hex));
+            if (controlled.length) {
+                for (const t of controlled)
+                    if (!outs.some((o) => o.state.identity === t.state.identity &&
+                        owner(o.state).address === receiver &&
+                        o.state.balance === t.state.balance))
+                        issues.push('HTLC_TOKEN_RECIPIENT_MISMATCH');
+            }
+            else if (!outputs.some((o) => o.address === receiver && o.satoshis > 0))
+                issues.push('HTLC_RECIPIENT_MISMATCH');
+        }
+        else if (htlcInputs.length > 1)
+            issues.push('AMBIGUOUS_HTLC_OPERATION');
+    }
+    if ((protocol === 'ft' || protocol === 'stablecoin') && action === 'transfer') {
+        const senders = inputs
+            .filter((i) => i.prevout?.script.type === 'P2PKH')
+            .map((i) => i.prevout?.address);
+        if (outputs.some((o) => o.script.type === 'P2PKH' && o.satoshis > 0 && o.address && !senders.includes(o.address)))
+            action = 'transferWithTbc';
+    }
+    for (const token of [...ins, ...outs]) {
+        const tape = ins.includes(token)
+            ? inputs[token.index].prevout?.associatedTape?.script
+            : outputs[token.index + 1]?.script;
+        const state = token.state;
+        if (!tape || state.decimal === undefined)
+            continue;
+        tape.data = { ...tape.data, ftTape: {
+                name: state.name ?? '', symbol: state.symbol ?? '', decimal: state.decimal,
+                rawAmount: state.balance.toString(), amountSlots: state.amounts.map(String),
+                displayAmount: exactDisplay(state.balance, state.decimal),
+                amount: Number(state.balance) / 10 ** state.decimal,
+                lockTime: state.lockTime, isStableCoin: state.descriptor.family === 'stablecoin',
+            } };
+    }
+    // Preserve the established OrderBook state fields on Code outputs and prevouts.
+    // Continuation outputs are state, not a second asset movement.
+    for (const order of orderInputs) {
+        const script = inputs[order.index].prevout.script;
+        script.data = { ...script.data, orderBook: {
+                side: order.side, holdAddress: order.owner, saleVolumeSatoshis: Number(order.volume),
+                feeRateRaw: order.feeRate.toString(), unitPriceRaw: order.price.toString(),
+                ftPartialHash: order.tokenA.partialHash, ftID: order.tokenA.id,
+            } };
+    }
+    for (const order of orderOutputs) {
+        const script = outputs[order.index].script;
+        script.data = { ...script.data, orderBook: {
+                side: order.side, holdAddress: order.owner, saleVolumeSatoshis: Number(order.volume),
+                feeRateRaw: order.feeRate.toString(), unitPriceRaw: order.price.toString(),
+                ftPartialHash: order.tokenA.partialHash, ftID: order.tokenA.id,
+            } };
+    }
+    // Public flows describe economic movements. Output locations and reserve/carrier
+    // balances stay in chain, using the same conventions as earlier contract generations.
+    const flows = baseFlows.filter((f) => f.asset.type !== 'tbc');
+    const nativeSenders = [...new Set(inputs
+            .filter((i) => i.prevout?.script.type === 'P2PKH')
+            .map((i) => i.prevout?.address).filter((a) => !!a))];
+    const nativeFrom = nativeSenders.length === 1
+        ? { address: nativeSenders[0] }
+        : nativeSenders.length ? { addresses: nativeSenders }
+            : { outpoints: inputs.map((i) => ({ txid: i.prevTxid, vout: i.vout })) };
+    const pool = poolOutputs[0];
+    const poolHash = pool && controllerHash(pool.hex);
+    const poolId = poolInputs[0] && inputs[poolInputs[0].index].prevout?.contractId;
+    const poolEndpoint = poolHash
+        ? poolId ? { poolId } : { hash: poolHash } : undefined;
+    const publicOwner = (endpoint) => {
+        if (endpoint.hash === poolHash && poolEndpoint)
+            return poolEndpoint;
+        const order = orderInputs.find((o) => controllerHash(o.hex) === endpoint.hash);
+        return order && action === 'match' ? { address: order.owner } : endpoint;
+    };
+    const sourceOf = (tokens) => {
+        const owners = [...new Map(tokens.map((t) => {
+                const endpoint = publicOwner(owner(t.state));
+                return [JSON.stringify(endpoint), endpoint];
+            })).values()];
+        return owners.length === 1 ? owners[0] : {
+            outpoints: tokens.map((t) => ({ txid: inputs[t.index].prevTxid, vout: inputs[t.index].vout })),
+        };
+    };
+    for (let flow of tokenFlows) {
+        const output = flowOutputs.get(flow);
+        const identity = assetIdentities.get(flow.asset);
+        const sources = ins.filter((t) => t.state.identity === identity && output.state.amounts[t.index] > 0n);
+        const destination = owner(output.state);
+        // A pool reserve output combines old reserves and a deposit. Expose only the deposit.
+        if (poolHash && destination.hash === poolHash && action !== 'mergeFtInPool') {
+            const deposits = sources.filter((t) => owner(t.state).hash !== poolHash);
+            const amount = deposits.reduce((n, t) => n + output.state.amounts[t.index], 0n);
+            if (!amount)
+                continue;
+            flow.amount = { raw: amount.toString(), ...(output.state.decimal !== undefined
+                    ? { decimal: output.state.decimal, display: exactDisplay(amount, output.state.decimal) } : {}) };
+            flow.from = sourceOf(deposits);
+            flow.purpose = 'transfer';
+            flow.direction = 'out';
+        }
+        if (flow.from)
+            flow.from = publicOwner(flow.from);
+        if (flow.to)
+            flow.to = publicOwner(flow.to);
+        delete flow.context;
+        if (protocol === 'poolNft' && action === 'consumeLiquidity' && flow.asset.type === 'ftlp') {
+            if (flow.purpose !== 'burn')
+                continue; // LP change is part of the redemption, not another payment.
+            if (!poolEndpoint)
+                continue;
+            flow = { ...flow, purpose: 'transfer', direction: 'out', to: poolEndpoint };
+        }
+        const destinationOrder = orderOutputs.find((o) => controllerHash(o.hex) === destination.hash);
+        if (destinationOrder) {
+            if (action === 'match')
+                continue; // Remaining locked order state is not a second placement.
+            flow.purpose = 'lock';
+            flow.direction = 'out';
+            flow.context = { protocol: 'orderBook', action, recognized: issues.length === 0 };
+        }
+        else if (protocol === 'orderBook' && action.startsWith('cancel') &&
+            sources.some((t) => orderInputs.some((o) => controllerHash(o.hex) === owner(t.state).hash))) {
+            flow.purpose = 'release';
+            flow.direction = 'in';
+        }
+        if (htlcOutputs.some((h) => controllerHash(h.hex) === destination.hash)) {
+            flow.purpose = 'lock';
+            flow.direction = 'out';
+            flow.context = { protocol: 'htlc', action, recognized: issues.length === 0 };
+        }
+        else if (htlcInputs.some((h) => sources.some((t) => owner(t.state).hash === controllerHash(h.hex)))) {
+            flow.purpose = 'release';
+            flow.direction = 'in';
+            flow.context = { protocol: 'htlc', action, recognized: issues.length === 0 };
+        }
+        if (issues.length)
+            flow.context = { protocol, action, recognized: false };
+        flows.push(flow);
+    }
+    if (pool && poolEndpoint) {
+        const next = pool.tape?.script.hex && poolTape(pool.tape.script.hex);
+        const previous = poolInputs[0]?.tape?.script.hex && poolTape(poolInputs[0].tape.script.hex);
+        if (next && action === 'create')
+            flows.push({
+                asset: { type: 'nft', subtype: 'poolNft', contractId: txid, poolNft: {
+                        serviceFeeRate: next.serviceFeeRate, lpPlan: next.lpPlan,
+                        withLock: next.variant.startsWith('controller'), withLockTime: next.variant.endsWith('timelocked'),
+                    } }, purpose: 'mint', direction: 'in',
+            });
+        if (next && previous && next.tbcAmount > previous.tbcAmount)
+            flows.push({
+                asset: { type: 'tbc', symbol: 'TBC' },
+                amount: { satoshis: Number(next.tbcAmount - previous.tbcAmount) },
+                purpose: 'transfer', direction: 'out', from: nativeFrom, to: poolEndpoint,
+            });
+        // Keep AMM state under the existing PoolNFT tape schema, without a public generation field.
+        for (const p of [...poolInputs, ...poolOutputs]) {
+            const tape = p.tape, state = tape?.script.hex && poolTape(tape.script.hex);
+            if (!state || !tape)
+                continue;
+            tape.script.data = { ...tape.script.data, poolNft: {
+                    version: 2, combinedPartialHash: state.ftLpPartialHash.toString('hex') + state.ftAPartialHash.toString('hex'),
+                    ftLpPartialHash: state.ftLpPartialHash.toString('hex'), ftAPartialHash: state.ftAPartialHash.toString('hex'),
+                    ftLpAmountRaw: state.ftLpAmount.toString(), ftLpDisplayAmount: exactDisplay(state.ftLpAmount, 6),
+                    ftAAmountRaw: state.ftAAmount.toString(), tbcSatoshis: Number(state.tbcAmount),
+                    ftContractTxid: state.ftAContractId, serviceFeeRate: state.serviceFeeRate, lpPlan: state.lpPlan,
+                    withLock: state.variant.startsWith('controller'), withLockTime: state.variant.endsWith('timelocked'),
+                } };
+        }
+    }
+    for (const o of outputs) {
+        if (o.satoshis <= 0)
+            continue;
+        const order = orderOutputs.find((p) => p.index === o.index);
+        const htlc = htlcOutputs.find((p) => p.index === o.index);
+        const controlledTokens = (hex) => outs.some((t) => owner(t.state).hash === controllerHash(hex));
+        const nftCarrier = o.script.contract?.family === 'nft' ||
+            outputs.some((code) => nftCode(code.script.hex ?? '') && code.index + 1 === o.index);
+        if (poolOutputs.some((p) => p.index === o.index) ||
+            (tokenOutputIndexes.has(o.index) || nftCarrier) && o.satoshis < 5000 ||
+            order && (controlledTokens(order.hex) || action === 'match') ||
+            htlc && controlledTokens(htlc.hex))
+            continue;
+        const to = o.address ? { address: o.address }
+            : o.script.data?.hash ? { hash: o.script.data.hash } : { script: { hex: o.script.hex } };
+        const amount = { satoshis: o.satoshis };
+        const asset = { type: 'tbc', symbol: 'TBC' };
+        if (order || htlc) {
+            flows.push({ asset, amount, purpose: 'lock', direction: 'out', from: nativeFrom,
+                to: { hash: controllerHash((order ?? htlc).hex) },
+                context: { protocol, action, recognized: issues.length === 0 } });
+        }
+        else if (o.script.type === 'P2PKH') {
+            const h = htlcInputs[0];
+            const nativeHtlc = h && !ins.some((t) => owner(t.state).hash === controllerHash(h.hex));
+            const htlcPayout = nativeHtlc && o.address === (action === 'refund' ? h.sender : h.receiver);
+            const bound = nativeSources.get(o.index);
+            const contractSource = htlcPayout ? { hash: controllerHash(h.hex) } : bound && publicOwner(bound);
+            const release = !!htlcPayout || !!bound && action.startsWith('cancel');
+            const self = !contractSource && !!o.address && nativeSenders.includes(o.address);
+            flows.push({ asset, amount,
+                ...(release ? { purpose: 'release', direction: 'in' }
+                    : self ? { purpose: 'self', direction: 'self' }
+                        : { purpose: 'transfer', direction: 'out' }),
+                from: contractSource ?? nativeFrom, to,
+                ...(htlcPayout ? { context: { protocol, action, recognized: issues.length === 0 } } : {}), });
+        }
+        else {
+            flows.push({ asset, amount, purpose: 'transfer', direction: 'out', from: nativeFrom, to,
+                context: { protocol: 'unknown', recognized: false } });
+            issues.push('UNKNOWN_NONZERO_OUTPUT');
+        }
+    }
+    if (outputs.reduce((n, o) => n + BigInt(o.satoshis), 0n) >
+        inputs.reduce((n, i) => n + BigInt(i.prevout?.satoshis ?? 0), 0n))
+        issues.push('NATIVE_VALUE_NOT_CONSERVED');
+    for (const f of flows)
+        if (f.context && f.context.protocol !== 'unknown')
+            f.context = { protocol, action, recognized: issues.length === 0 };
+    // An independent NFT action retains the legacy classifier when no fungible or controller family wins.
+    if (!issues.length &&
+        !certOutput &&
+        !ins.length &&
+        !outs.length &&
+        !poolInputs.length &&
+        !poolOutputs.length &&
+        !orderInputs.length &&
+        !orderOutputs.length &&
+        !htlcInputs.length &&
+        !htlcOutputs.length)
+        return { assetFlows: flows, classification: baseClassification };
+    return {
+        assetFlows: flows,
+        classification: classification(protocol, action, issues, `${protocol} ${action}${issues.length ? ' (incomplete or inconsistent evidence)' : ''}.`),
+    };
+}
+//# sourceMappingURL=analyze.js.map