tbc-tx-parser 0.1.0

package/dist/protocols/pool-nft/movements.js

@@ -0,0 +1,804 @@
+import { calculatePartialSha256 } from '../../adapters/partial-sha256.js';
+import { COIN_CODE_LENGTH, COIN_PARTIAL_HASH_OFFSET, FT_A_CODE_MARKER_HEX, FT_LP_CODE_MARKER_HEX, FT_V1_CODE_LENGTH, FT_V1_PARTIAL_HASH_OFFSET, FT_V2_CODE_LENGTH, FT_V2_PARTIAL_HASH_OFFSET, } from './constants.js';
+import { allPoolNftAmountsAreZero, collectPoolNftFacts, formatPoolNftFtAmount, hasPoolStateCarrier, inputPoolNftTape, isPoolNftBurnReceiver, } from './facts.js';
+import { actionRequiresExistingPoolState, actionRequiresFtAReserveDecrease, actionRequiresFtAReserveIncrease, actionRequiresFtContractMatch, actionRequiresLiquidityAmountMatch, actionRequiresLpReserveDecrease, actionRequiresLpReserveIncrease, actionRequiresLpTokenIdentityMatch, actionRequiresTbcReserveDecrease, actionRequiresTbcReserveIncrease, createPoolNftActionMatch, downgradePoolNftMatch, poolNftTransactionType, } from './actions.js';
+import { parsePoolNftRawAmount, poolNftAbsoluteRawAmount, poolNftFtADelta, poolNftLpDelta, poolNftRawDeltaString, poolNftTbcDelta, } from './amounts.js';
+import { findPoolNftReceiver, findPoolNftReceiverHash, firstBurnFtMovement, poolNftFtAOutputMovementForAction, poolNftExpectedFeeCollector, poolNftFeeOutputs, poolNftFtAMovementByRaw, poolNftFtAMovementForAction, poolNftFtAMovementForEvidence, poolNftFtAPartialHash, poolNftTapeIdentity, poolNftLpMovementByRaw, poolNftLpMovementForAction, poolNftLpPartialHash, poolNftLpTokenId, poolNftLpTokenIdSource, poolNftMovementHasFtACodeMarker, poolNftSender, poolNftSenderFromInputs, poolNftStateOutputAddress, poolNftStateOutputHash, poolNftTbcPayoutOutput, } from './selectors.js';
+import { hasTbcOutPayoutOrFeeMismatch, hasTbcPayoutOrFeeRelationMismatch, poolNftServiceFeeQuote, poolNftVisibleTbcOutSatoshis, withSwapServiceFeeFormulaConfidence, } from './fees.js';
+function withPoolStateConfidence(match, facts) {
+    if (!actionRequiresExistingPoolState(match.action) || facts.poolInputs.length) {
+        return match;
+    }
+    return downgradePoolNftMatch(match, 'no previous PoolNFT state input is available');
+}
+function hasKnownFtContractMismatch(action, facts) {
+    const ftContractTxid = facts.tape?.ftContractTxid;
+    const ftAMovement = poolNftFtAMovementForEvidence(action, facts);
+    if (!ftContractTxid || !ftAMovement?.contractId) {
+        return false;
+    }
+    return ftAMovement.contractId !== ftContractTxid;
+}
+function withFtContractConfidence(match, facts) {
+    if (!actionRequiresFtContractMatch(match.action) || !hasKnownFtContractMismatch(match.action, facts)) {
+        return match;
+    }
+    return downgradePoolNftMatch(match, 'no related FT movement matches PoolNFT tape ftContractTxid');
+}
+function hasLiquidityAmountMismatch(action, facts) {
+    if (action === 'increaseLiquidity' && poolNftFtADelta(facts) !== undefined && poolNftLpDelta(facts) !== undefined) {
+        return false;
+    }
+    const rawAmounts = new Set(facts.relatedFtMovements.map((movement) => movement.rawAmount));
+    const ftAAmountRaw = facts.tape?.ftAAmountRaw;
+    const ftLpAmountRaw = facts.tape?.ftLpAmountRaw;
+    const hasFtAAmount = ftAAmountRaw !== undefined && rawAmounts.has(ftAAmountRaw);
+    const hasFtLpAmount = ftLpAmountRaw !== undefined && rawAmounts.has(ftLpAmountRaw);
+    return !hasFtAAmount || !hasFtLpAmount;
+}
+function withLiquidityAmountConfidence(match, facts) {
+    if (!actionRequiresLiquidityAmountMatch(match.action) || !hasLiquidityAmountMismatch(match.action, facts)) {
+        return match;
+    }
+    return downgradePoolNftMatch(match, 'liquidity FT movements do not match PoolNFT tape FT A and LP amounts');
+}
+function hasLpTokenIdentityMismatch(action, facts) {
+    const ftContractTxid = facts.tape?.ftContractTxid;
+    if (!ftContractTxid) {
+        return false;
+    }
+    const lpMovement = action === 'consumeLiquidity'
+        ? firstBurnFtMovement(facts)
+        : poolNftLpMovementForAction(action, facts);
+    const expectedLpRawAmount = action === 'increaseLiquidity'
+        ? poolNftRawDeltaString(poolNftLpDelta(facts))
+        : facts.tape?.ftLpAmountRaw;
+    const matchingRawMovements = facts.relatedFtMovements.filter((movement) => movement.rawAmount === expectedLpRawAmount);
+    return lpMovement?.contractId === ftContractTxid ||
+        (!lpMovement && matchingRawMovements.some((movement) => movement.contractId === ftContractTxid));
+}
+function withLpTokenIdentityConfidence(match, facts) {
+    if (!actionRequiresLpTokenIdentityMatch(match.action) || !hasLpTokenIdentityMismatch(match.action, facts)) {
+        return match;
+    }
+    return downgradePoolNftMatch(match, 'PoolNFT LP movement uses the FT A contractId');
+}
+function hasPoolIdentityMismatch(facts) {
+    const currentPoolId = poolNftTapeIdentity(facts.tape);
+    const poolInputTapes = facts.poolInputs
+        .map((input) => input.tape)
+        .filter((tape) => Boolean(tape));
+    if (!currentPoolId || !poolInputTapes.length) {
+        return false;
+    }
+    return poolInputTapes.some((tape) => poolNftTapeIdentity(tape) !== currentPoolId);
+}
+function hasCombinedPartialHashMismatch(facts) {
+    const combinedPartialHash = facts.tape?.combinedPartialHash;
+    const ftLpPartialHash = facts.tape?.ftLpPartialHash;
+    const ftAPartialHash = facts.tape?.ftAPartialHash;
+    if (!combinedPartialHash || !ftLpPartialHash || !ftAPartialHash) {
+        return false;
+    }
+    const expectedCombinedPartialHash = `${ftLpPartialHash}${ftAPartialHash}`;
+    if (combinedPartialHash.length !== expectedCombinedPartialHash.length) {
+        return false;
+    }
+    return combinedPartialHash !== expectedCombinedPartialHash;
+}
+function hasPoolStateScriptMismatch(facts) {
+    const previousScriptHex = facts.poolInputs[0]?.script.hex;
+    const currentScriptHex = facts.poolOutput?.script.hex;
+    if (!previousScriptHex || !currentScriptHex) {
+        return false;
+    }
+    return previousScriptHex !== currentScriptHex;
+}
+function hasMultiplePoolStateInputs(facts) {
+    return facts.poolInputs.length > 1;
+}
+function withPoolIdentityConfidence(match, facts) {
+    if (!actionRequiresExistingPoolState(match.action) || !hasPoolIdentityMismatch(facts)) {
+        return match;
+    }
+    return downgradePoolNftMatch(match, 'previous PoolNFT state uses a different pool identity');
+}
+function withTbcReserveDeltaConfidence(match, facts) {
+    const delta = poolNftTbcDelta(facts);
+    if (delta === undefined) {
+        return match;
+    }
+    if (actionRequiresTbcReserveIncrease(match.action) && delta <= 0) {
+        return downgradePoolNftMatch(match, 'PoolNFT TBC reserve did not increase for this action');
+    }
+    if (actionRequiresTbcReserveDecrease(match.action) && delta >= 0) {
+        return downgradePoolNftMatch(match, 'PoolNFT TBC reserve did not decrease for this action');
+    }
+    return match;
+}
+function withFtAReserveDeltaConfidence(match, facts) {
+    const delta = poolNftFtADelta(facts);
+    if (delta === undefined) {
+        return match;
+    }
+    if (actionRequiresFtAReserveIncrease(match.action) && delta <= 0n) {
+        return downgradePoolNftMatch(match, 'PoolNFT FT A reserve did not increase for this action');
+    }
+    if (actionRequiresFtAReserveDecrease(match.action) && delta >= 0n) {
+        return downgradePoolNftMatch(match, 'PoolNFT FT A reserve did not decrease for this action');
+    }
+    return match;
+}
+function withLpReserveDeltaConfidence(match, facts) {
+    const delta = poolNftLpDelta(facts);
+    if (delta === undefined) {
+        return match;
+    }
+    if (actionRequiresLpReserveIncrease(match.action) && delta <= 0n) {
+        return downgradePoolNftMatch(match, 'PoolNFT LP reserve did not increase for this action');
+    }
+    if (actionRequiresLpReserveDecrease(match.action) && delta >= 0n) {
+        return downgradePoolNftMatch(match, 'PoolNFT LP reserve did not decrease for this action');
+    }
+    return match;
+}
+function withSwapAmountRelationConfidence(match, facts) {
+    if (match.confidence === 'heuristic') {
+        return match;
+    }
+    if (match.action === 'swapTbcToFt') {
+        const ftADelta = poolNftFtADelta(facts);
+        const ftOutAmount = parsePoolNftRawAmount(poolNftFtAOutputMovementForAction(match.action, facts)?.rawAmount);
+        if (ftADelta !== undefined && ftOutAmount !== undefined && poolNftAbsoluteRawAmount(ftADelta) !== ftOutAmount) {
+            return downgradePoolNftMatch(match, 'PoolNFT FT A swap output does not match reserve delta');
+        }
+    }
+    if (match.action === 'swapFtToTbc') {
+        const ftADelta = poolNftFtADelta(facts);
+        const ftInAmount = parsePoolNftRawAmount(facts.relatedFtMovements[0]?.rawAmount);
+        if (ftADelta !== undefined && ftInAmount !== undefined && poolNftAbsoluteRawAmount(ftADelta) !== ftInAmount) {
+            return downgradePoolNftMatch(match, 'PoolNFT FT A swap input does not match reserve delta');
+        }
+        const tbcDelta = poolNftTbcDelta(facts);
+        const tbcOutSatoshis = poolNftVisibleTbcOutSatoshis(match.action, facts);
+        const hasFormula = poolNftServiceFeeQuote(BigInt(Math.abs(tbcDelta ?? 0)), facts) !== undefined;
+        if (!hasFormula && tbcDelta !== undefined && tbcOutSatoshis !== undefined && Math.abs(tbcDelta) !== tbcOutSatoshis) {
+            return downgradePoolNftMatch(match, 'PoolNFT TBC swap payout plus fee does not match reserve delta');
+        }
+    }
+    return match;
+}
+function withLiquidityAmountRelationConfidence(match, facts) {
+    if (match.confidence === 'heuristic') {
+        return match;
+    }
+    if (match.action === 'increaseLiquidity') {
+        const ftADelta = poolNftFtADelta(facts);
+        const ftInMovement = poolNftFtAMovementByRaw(facts, poolNftRawDeltaString(ftADelta));
+        if (ftADelta !== undefined && parsePoolNftRawAmount(ftInMovement?.rawAmount) !== poolNftAbsoluteRawAmount(ftADelta)) {
+            return downgradePoolNftMatch(match, 'PoolNFT FT A liquidity input does not match reserve delta');
+        }
+        const lpDelta = poolNftLpDelta(facts);
+        const lpOutMovement = poolNftLpMovementByRaw(facts, poolNftRawDeltaString(lpDelta));
+        if (lpDelta !== undefined && parsePoolNftRawAmount(lpOutMovement?.rawAmount) !== poolNftAbsoluteRawAmount(lpDelta)) {
+            return downgradePoolNftMatch(match, 'PoolNFT LP liquidity output does not match reserve delta');
+        }
+    }
+    if (match.action === 'consumeLiquidity') {
+        const ftADelta = poolNftFtADelta(facts);
+        const ftOutMovement = poolNftFtAOutputMovementForAction(match.action, facts);
+        if (ftADelta !== undefined && parsePoolNftRawAmount(ftOutMovement?.rawAmount) !== poolNftAbsoluteRawAmount(ftADelta)) {
+            return downgradePoolNftMatch(match, 'PoolNFT FT A liquidity output does not match reserve delta');
+        }
+        const lpDelta = poolNftLpDelta(facts);
+        const lpInMovement = firstBurnFtMovement(facts);
+        if (lpDelta !== undefined && parsePoolNftRawAmount(lpInMovement?.rawAmount) !== poolNftAbsoluteRawAmount(lpDelta)) {
+            return downgradePoolNftMatch(match, 'PoolNFT LP liquidity burn does not match reserve delta');
+        }
+        const tbcDelta = poolNftTbcDelta(facts);
+        if (tbcDelta !== undefined && hasTbcOutPayoutOrFeeMismatch('consumeLiquidity', facts)) {
+            return downgradePoolNftMatch(match, 'PoolNFT TBC liquidity payout plus fee does not match reserve delta');
+        }
+    }
+    return match;
+}
+function isPoolNftPartialHashMismatch(verification) {
+    return verification === 'computedPartialHashMismatch' ||
+        verification === 'matchedWrongPartialHashLiteral' ||
+        verification === 'codeTypeMismatch';
+}
+function actionRequiresFtAAndLpPartialHashIdentity(action) {
+    return action === 'init' || action === 'increaseLiquidity' || action === 'consumeLiquidity';
+}
+function hasBothPartialHashIdentitiesMismatched(action, facts) {
+    if (!actionRequiresFtAAndLpPartialHashIdentity(action)) {
+        return false;
+    }
+    return isPoolNftPartialHashMismatch(poolNftFtAPartialHashVerification(action, facts)) &&
+        isPoolNftPartialHashMismatch(poolNftLpPartialHashVerification(action, facts));
+}
+function hasLpPartialHashIdentityMismatched(action, facts) {
+    return actionRequiresLpTokenIdentityMatch(action) &&
+        isPoolNftPartialHashMismatch(poolNftLpPartialHashVerification(action, facts));
+}
+function poolNftFtMovementsExpectedToLockToPool(action, facts) {
+    if (action === 'init' || action === 'increaseLiquidity') {
+        return [poolNftFtAMovementForAction(action, facts)];
+    }
+    if (action === 'swapFtToTbc' || action === 'mergeFtInPool') {
+        return [facts.relatedFtMovements[0]];
+    }
+    return [];
+}
+function poolNftFtMovementsExpectedToLockAwayFromPool(action, facts) {
+    if (action === 'init' || action === 'increaseLiquidity') {
+        return [poolNftLpMovementForAction(action, facts)];
+    }
+    if (action === 'consumeLiquidity' || action === 'swapTbcToFt') {
+        return [poolNftFtAOutputMovementForAction(action, facts)];
+    }
+    return [];
+}
+function hasPoolDirectedFtReceiverHashMismatch(action, facts) {
+    const poolStateHash = poolNftStateOutputHash(facts);
+    if (!poolStateHash) {
+        return false;
+    }
+    return poolNftFtMovementsExpectedToLockToPool(action, facts).some((movement) => Boolean(movement?.receiverHash && movement.receiverHash !== poolStateHash));
+}
+function hasUserDirectedFtReceiverHashLocksToPool(action, facts) {
+    const poolStateHash = poolNftStateOutputHash(facts);
+    if (!poolStateHash) {
+        return false;
+    }
+    return poolNftFtMovementsExpectedToLockAwayFromPool(action, facts).some((movement) => Boolean(movement?.receiverHash && movement.receiverHash === poolStateHash));
+}
+function hasTbcReserveDirectionReversed(action, facts) {
+    const delta = poolNftTbcDelta(facts);
+    if (delta === undefined) {
+        return false;
+    }
+    return (actionRequiresTbcReserveIncrease(action) && delta < 0) ||
+        (actionRequiresTbcReserveDecrease(action) && delta > 0);
+}
+function hasFtAReserveDirectionReversed(action, facts) {
+    const delta = poolNftFtADelta(facts);
+    if (delta === undefined) {
+        return false;
+    }
+    return (actionRequiresFtAReserveIncrease(action) && delta < 0n) ||
+        (actionRequiresFtAReserveDecrease(action) && delta > 0n);
+}
+function hasLpReserveDirectionReversed(action, facts) {
+    const delta = poolNftLpDelta(facts);
+    if (delta === undefined) {
+        return false;
+    }
+    return (actionRequiresLpReserveIncrease(action) && delta < 0n) ||
+        (actionRequiresLpReserveDecrease(action) && delta > 0n);
+}
+function hasReserveDirectionReversed(action, facts) {
+    return hasTbcReserveDirectionReversed(action, facts) ||
+        hasFtAReserveDirectionReversed(action, facts) ||
+        hasLpReserveDirectionReversed(action, facts);
+}
+function poolNftRawAmountDoesNotMatchDelta(delta, movement) {
+    const amount = parsePoolNftRawAmount(movement?.rawAmount);
+    return delta !== undefined && delta !== 0n && amount !== undefined && amount !== poolNftAbsoluteRawAmount(delta);
+}
+function poolNftIncreaseFtAInputMovement(facts) {
+    const ftContractTxid = facts.tape?.ftContractTxid;
+    return facts.relatedFtMovements.find((movement) => !movement.receiver && (!ftContractTxid || !movement.contractId || movement.contractId === ftContractTxid));
+}
+function poolNftIncreaseLpOutputMovement(facts) {
+    const ftContractTxid = facts.tape?.ftContractTxid;
+    const receiverMovements = facts.relatedFtMovements.filter((movement) => Boolean(movement.receiver && !isPoolNftBurnReceiver(movement.receiver)));
+    return receiverMovements.find((movement) => movement.contractId && movement.contractId !== ftContractTxid) ??
+        receiverMovements.find((movement) => movement.contractId !== ftContractTxid);
+}
+function hasSwapRawAmountRelationMismatch(action, facts) {
+    const ftADelta = poolNftFtADelta(facts);
+    if (action === 'swapTbcToFt') {
+        return poolNftRawAmountDoesNotMatchDelta(ftADelta, poolNftFtAOutputMovementForAction(action, facts));
+    }
+    if (action === 'swapFtToTbc') {
+        return poolNftRawAmountDoesNotMatchDelta(ftADelta, facts.relatedFtMovements[0]);
+    }
+    return false;
+}
+function hasMergeFtInPoolRawAmountRelationMismatch(action, facts) {
+    if (action !== 'mergeFtInPool') {
+        return false;
+    }
+    const currentFtAAmount = parsePoolNftRawAmount(facts.tape?.ftAAmountRaw);
+    const movementAmount = parsePoolNftRawAmount(facts.relatedFtMovements[0]?.rawAmount);
+    return currentFtAAmount !== undefined && movementAmount !== undefined && movementAmount !== currentFtAAmount;
+}
+function hasLiquidityRawAmountRelationMismatch(action, facts) {
+    if (action === 'increaseLiquidity') {
+        return poolNftRawAmountDoesNotMatchDelta(poolNftFtADelta(facts), poolNftIncreaseFtAInputMovement(facts)) ||
+            poolNftRawAmountDoesNotMatchDelta(poolNftLpDelta(facts), poolNftIncreaseLpOutputMovement(facts));
+    }
+    if (action === 'consumeLiquidity') {
+        return poolNftRawAmountDoesNotMatchDelta(poolNftFtADelta(facts), poolNftFtAOutputMovementForAction(action, facts)) ||
+            poolNftRawAmountDoesNotMatchDelta(poolNftLpDelta(facts), firstBurnFtMovement(facts));
+    }
+    return false;
+}
+function hasRawAmountRelationMismatch(action, facts) {
+    return hasSwapRawAmountRelationMismatch(action, facts) ||
+        hasMergeFtInPoolRawAmountRelationMismatch(action, facts) ||
+        hasLiquidityRawAmountRelationMismatch(action, facts);
+}
+function isPoolNftFtAMovementByIdentity(facts, movement) {
+    return movement.contractId === facts.tape?.ftContractTxid ||
+        poolNftMovementHasFtACodeMarker(facts, movement);
+}
+function isPoolNftUserDirectedMovement(facts, movement) {
+    const poolStateAddress = poolNftStateOutputAddress(facts);
+    const poolStateHash = poolNftStateOutputHash(facts);
+    return !isPoolNftBurnReceiver(movement.receiver) &&
+        Boolean(movement.receiver || movement.receiverHash) &&
+        (!movement.receiver || movement.receiver !== poolStateAddress) &&
+        (!movement.receiverHash || movement.receiverHash !== poolStateHash);
+}
+function hasUnexplainedUserFtAOutput(action, facts) {
+    if (action !== 'consumeLiquidity' && action !== 'swapTbcToFt') {
+        return false;
+    }
+    const ftADelta = poolNftFtADelta(facts);
+    const selectedOutput = poolNftFtAOutputMovementForAction(action, facts);
+    const selectedAmount = parsePoolNftRawAmount(selectedOutput?.rawAmount);
+    if (ftADelta === undefined ||
+        selectedAmount === undefined ||
+        selectedAmount !== poolNftAbsoluteRawAmount(ftADelta)) {
+        return false;
+    }
+    return facts.relatedFtMovements.some((movement) => movement !== selectedOutput &&
+        isPoolNftUserDirectedMovement(facts, movement) &&
+        isPoolNftFtAMovementByIdentity(facts, movement));
+}
+function hasUnexpectedFtMovementCount(action, facts) {
+    if (action === 'consumeLiquidity') {
+        return facts.burnMovements.length > 1;
+    }
+    if (action === 'init') {
+        return facts.relatedFtMovements.length > 3;
+    }
+    if (action === 'increaseLiquidity') {
+        return facts.relatedFtMovements.length > 3;
+    }
+    return false;
+}
+function withPartialHashIdentityConfidence(match, facts) {
+    if (match.confidence === 'heuristic') {
+        return match;
+    }
+    const ftAVerification = poolNftFtAPartialHashVerification(match.action, facts);
+    const lpVerification = poolNftLpPartialHashVerification(match.action, facts);
+    if (isPoolNftPartialHashMismatch(ftAVerification) || isPoolNftPartialHashMismatch(lpVerification)) {
+        return downgradePoolNftMatch(match, 'PoolNFT partial hash identity does not match related FT Code output');
+    }
+    return match;
+}
+function shouldRejectPoolNftActionMatch(match, facts) {
+    return (actionRequiresExistingPoolState(match.action) && hasMultiplePoolStateInputs(facts)) ||
+        (actionRequiresExistingPoolState(match.action) && hasPoolIdentityMismatch(facts)) ||
+        (actionRequiresExistingPoolState(match.action) && hasPoolStateScriptMismatch(facts)) ||
+        (actionRequiresFtContractMatch(match.action) && hasKnownFtContractMismatch(match.action, facts)) ||
+        hasReserveDirectionReversed(match.action, facts) ||
+        hasRawAmountRelationMismatch(match.action, facts) ||
+        hasUnexplainedUserFtAOutput(match.action, facts) ||
+        hasTbcPayoutOrFeeRelationMismatch(match.action, facts) ||
+        hasUnexpectedFtMovementCount(match.action, facts) ||
+        hasCombinedPartialHashMismatch(facts) ||
+        hasPoolDirectedFtReceiverHashMismatch(match.action, facts) ||
+        hasUserDirectedFtReceiverHashLocksToPool(match.action, facts) ||
+        hasLpPartialHashIdentityMismatched(match.action, facts) ||
+        hasBothPartialHashIdentitiesMismatched(match.action, facts);
+}
+function applyPoolNftConfidenceChecks(match, facts) {
+    return [
+        withPoolStateConfidence,
+        withPoolIdentityConfidence,
+        withFtContractConfidence,
+        withLiquidityAmountConfidence,
+        withLpTokenIdentityConfidence,
+        withFtAReserveDeltaConfidence,
+        withLpReserveDeltaConfidence,
+        withTbcReserveDeltaConfidence,
+        withSwapAmountRelationConfidence,
+        withSwapServiceFeeFormulaConfidence,
+        withLiquidityAmountRelationConfidence,
+        withPartialHashIdentityConfidence,
+    ].reduce((currentMatch, confidenceCheck) => confidenceCheck(currentMatch, facts), match);
+}
+function matchCreate(facts) {
+    if (!allPoolNftAmountsAreZero(facts.tape) || facts.relatedFtMovements.length) {
+        return undefined;
+    }
+    return createPoolNftActionMatch('create', [
+        'PoolNFT tape amounts are all zero',
+        'no related FT movement after tape',
+    ]);
+}
+function matchConsumeLiquidity(facts) {
+    if (!facts.burnMovements.length) {
+        return undefined;
+    }
+    return createPoolNftActionMatch('consumeLiquidity', [
+        'related FT movement is sent to a PoolNFT burn address',
+    ]);
+}
+function matchSwapFtToTbc(facts) {
+    const firstRelatedFt = facts.relatedFtMovements[0];
+    const tbcPayoutBeforeFirstFt = facts.tbcOutputsAfterTape.some((output) => output.index < (firstRelatedFt?.outputIndex ?? Number.POSITIVE_INFINITY));
+    if (!tbcPayoutBeforeFirstFt || !firstRelatedFt || firstRelatedFt.receiver) {
+        return undefined;
+    }
+    return createPoolNftActionMatch('swapFtToTbc', [
+        'TBC payout appears after PoolNFT tape and before first related FT movement',
+        'first related FT movement has no external receiver',
+    ]);
+}
+function matchSwapTbcToFt(facts) {
+    const firstRelatedFt = facts.relatedFtMovements[0];
+    if (facts.relatedFtMovements.length !== 2 || !firstRelatedFt?.receiver) {
+        return undefined;
+    }
+    return createPoolNftActionMatch('swapTbcToFt', [
+        'two related FT movements appear after PoolNFT tape',
+        'first related FT movement has an external receiver',
+    ]);
+}
+function matchInit(facts) {
+    if (facts.relatedFtMovements.length < 3) {
+        return undefined;
+    }
+    const lpMovement = facts.relatedFtMovements[1];
+    if (lpMovement?.rawAmount !== facts.tape?.ftLpAmountRaw) {
+        return undefined;
+    }
+    return createPoolNftActionMatch('init', [
+        'at least three related FT movements appear after PoolNFT tape',
+        'LP movement amount matches PoolNFT tape LP amount',
+    ]);
+}
+function matchIncreaseLiquidity(facts) {
+    const tbcDelta = poolNftTbcDelta(facts);
+    const ftADelta = poolNftFtADelta(facts);
+    const lpDelta = poolNftLpDelta(facts);
+    const ftAMovement = poolNftFtAMovementByRaw(facts, poolNftRawDeltaString(ftADelta));
+    const lpMovement = poolNftLpMovementByRaw(facts, poolNftRawDeltaString(lpDelta));
+    const hasLpMovementCandidate = facts.relatedFtMovements.some((movement) => Boolean(movement.contractId && movement.contractId !== facts.tape?.ftContractTxid));
+    if (tbcDelta !== undefined &&
+        tbcDelta > 0 &&
+        ftADelta !== undefined &&
+        ftADelta > 0n &&
+        lpDelta !== undefined &&
+        lpDelta > 0n &&
+        ftAMovement) {
+        return createPoolNftActionMatch('increaseLiquidity', [
+            'pool TBC, FT A, and LP reserves all increase',
+            lpMovement
+                ? 'related FT A and LP movements match reserve deltas'
+                : hasLpMovementCandidate
+                    ? 'related FT A movement matches reserve delta'
+                    : 'LP output movement is inferred from PoolNFT reserve delta',
+        ], lpMovement || hasLpMovementCandidate ? 'exact' : 'heuristic');
+    }
+    if (facts.relatedFtMovements.length < 3) {
+        return undefined;
+    }
+    return createPoolNftActionMatch('increaseLiquidity', [
+        'at least three related FT movements appear after PoolNFT tape',
+        'LP movement amount does not match PoolNFT tape LP amount',
+    ]);
+}
+function matchMergeFtInPool(facts) {
+    const firstRelatedFt = facts.relatedFtMovements[0];
+    if (facts.relatedFtMovements.length !== 1 || firstRelatedFt?.receiver) {
+        return undefined;
+    }
+    return createPoolNftActionMatch('mergeFtInPool', [
+        'single related FT movement appears after PoolNFT tape',
+        'related FT movement has no external receiver',
+    ]);
+}
+function matchUnknownPoolNftAction() {
+    return createPoolNftActionMatch('unknown', [
+        'no PoolNFT action matcher accepted the collected facts',
+    ]);
+}
+function inferPoolNftAction(facts) {
+    // Preserve the existing heuristic priority; matcher extraction allows rules and counterexamples to tighten incrementally.
+    const matchers = [
+        matchCreate,
+        matchConsumeLiquidity,
+        matchSwapFtToTbc,
+        matchSwapTbcToFt,
+        matchInit,
+        matchIncreaseLiquidity,
+        matchMergeFtInPool,
+    ];
+    for (const matcher of matchers) {
+        const match = matcher(facts);
+        if (match) {
+            return applyPoolNftConfidenceChecks(match, facts);
+        }
+    }
+    return matchUnknownPoolNftAction();
+}
+function poolNftLpTokenIdEvidence(action, facts) {
+    const source = poolNftLpTokenIdSource(action, facts);
+    if (source === 'movementContractId') {
+        const scriptEvidence = poolNftLpPartialHashVerification(action, facts);
+        return scriptEvidence === 'notChecked' ? 'movementContractId' : scriptEvidence;
+    }
+    if (source === 'poolNftTape') {
+        return poolNftLpPartialHashVerification(action, facts);
+    }
+    return undefined;
+}
+function poolNftPartialHashVerification(partialHash, movement, facts, expectedCodeMarkerHex, wrongPartialHashes = []) {
+    const output = facts.outputs.find((candidate) => candidate.index === movement?.outputIndex);
+    const scriptHex = output?.script.hex?.toLowerCase();
+    if (!partialHash || !scriptHex) {
+        return 'notChecked';
+    }
+    if (!scriptHex.endsWith(expectedCodeMarkerHex)) {
+        return 'codeTypeMismatch';
+    }
+    const computedPartialHash = poolNftComputedPartialHash(scriptHex);
+    if (computedPartialHash && partialHash.length === 64) {
+        return computedPartialHash === partialHash ? 'matchedComputedPartialHash' : 'computedPartialHashMismatch';
+    }
+    if (scriptHex.includes(partialHash)) {
+        return 'matchedScriptLiteral';
+    }
+    if (wrongPartialHashes.some((wrongPartialHash) => wrongPartialHash && scriptHex.includes(wrongPartialHash))) {
+        return 'matchedWrongPartialHashLiteral';
+    }
+    return 'notStaticallyVisible';
+}
+function poolNftPartialHashOffset(scriptByteLength) {
+    if (scriptByteLength === FT_V1_CODE_LENGTH) {
+        return FT_V1_PARTIAL_HASH_OFFSET;
+    }
+    if (scriptByteLength === FT_V2_CODE_LENGTH) {
+        return FT_V2_PARTIAL_HASH_OFFSET;
+    }
+    if (scriptByteLength === COIN_CODE_LENGTH) {
+        return COIN_PARTIAL_HASH_OFFSET;
+    }
+    return undefined;
+}
+function poolNftComputedPartialHash(scriptHex) {
+    if (scriptHex.length % 2 !== 0) {
+        return undefined;
+    }
+    const script = Buffer.from(scriptHex, 'hex');
+    const offset = poolNftPartialHashOffset(script.length);
+    if (offset === undefined || script.length < offset) {
+        return undefined;
+    }
+    return calculatePartialSha256(script.subarray(0, offset));
+}
+function poolNftFtAPartialHashVerification(action, facts) {
+    return poolNftPartialHashVerification(poolNftFtAPartialHash(facts.tape), poolNftFtAMovementForEvidence(action, facts), facts, FT_A_CODE_MARKER_HEX, [poolNftLpPartialHash(facts.tape)]);
+}
+function poolNftLpPartialHashVerification(action, facts) {
+    const lpMovement = action === 'consumeLiquidity'
+        ? firstBurnFtMovement(facts)
+        : poolNftLpMovementForAction(action, facts);
+    return poolNftPartialHashVerification(poolNftLpPartialHash(facts.tape), lpMovement, facts, FT_LP_CODE_MARKER_HEX, [poolNftFtAPartialHash(facts.tape)]);
+}
+function poolNftTbcAmountFields(action, facts) {
+    const delta = poolNftTbcDelta(facts);
+    const positiveDelta = delta !== undefined && delta > 0 ? delta : undefined;
+    const negativeDelta = delta !== undefined && delta < 0 ? Math.abs(delta) : undefined;
+    const payoutOutput = poolNftTbcPayoutOutput(action, facts);
+    if (action === 'init') {
+        return {
+            tbcInSatoshis: facts.tape?.tbcSatoshis,
+            stateTbcSatoshis: facts.tape?.tbcSatoshis,
+        };
+    }
+    if (action === 'increaseLiquidity' || action === 'swapTbcToFt') {
+        return {
+            tbcInSatoshis: positiveDelta,
+            stateTbcSatoshis: facts.tape?.tbcSatoshis,
+        };
+    }
+    if (action === 'consumeLiquidity') {
+        return {
+            tbcOutSatoshis: payoutOutput?.satoshis ?? negativeDelta,
+            tbcOutOutputIndex: payoutOutput?.index,
+            stateTbcSatoshis: facts.tape?.tbcSatoshis,
+        };
+    }
+    if (action === 'swapFtToTbc') {
+        return {
+            tbcOutSatoshis: payoutOutput?.satoshis ?? negativeDelta,
+            tbcOutOutputIndex: payoutOutput?.index,
+            stateTbcSatoshis: facts.tape?.tbcSatoshis,
+        };
+    }
+    return {
+        stateTbcSatoshis: facts.tape?.tbcSatoshis,
+    };
+}
+function poolNftFtAmountFields(action, facts) {
+    const ftAMovement = poolNftFtAMovementForAction(action, facts);
+    const ftLpMovement = poolNftLpMovementForAction(action, facts);
+    const firstFtMovement = facts.relatedFtMovements[0];
+    const firstBurnMovement = firstBurnFtMovement(facts);
+    const ftAOutputMovement = poolNftFtAOutputMovementForAction(action, facts);
+    if (action === 'init' || action === 'increaseLiquidity') {
+        const ftInRawAmount = action === 'increaseLiquidity'
+            ? poolNftRawDeltaString(poolNftFtADelta(facts))
+            : facts.tape?.ftAAmountRaw;
+        const ftLpOutRawAmount = action === 'increaseLiquidity'
+            ? poolNftRawDeltaString(poolNftLpDelta(facts))
+            : facts.tape?.ftLpAmountRaw;
+        return {
+            ftInRawAmount: ftAMovement?.rawAmount ?? ftInRawAmount,
+            ftInOutputIndex: ftAMovement?.outputIndex,
+            ftLpOutRawAmount: ftLpMovement?.rawAmount ?? ftLpOutRawAmount,
+            ftLpOutOutputIndex: ftLpMovement?.outputIndex,
+        };
+    }
+    if (action === 'consumeLiquidity') {
+        return {
+            ftOutRawAmount: ftAOutputMovement?.rawAmount,
+            ftOutOutputIndex: ftAOutputMovement?.outputIndex,
+            ftLpInRawAmount: firstBurnMovement?.rawAmount,
+            ftLpInOutputIndex: firstBurnMovement?.outputIndex,
+        };
+    }
+    if (action === 'swapTbcToFt') {
+        return {
+            ftOutRawAmount: ftAOutputMovement?.rawAmount,
+            ftOutOutputIndex: ftAOutputMovement?.outputIndex,
+        };
+    }
+    if (action === 'swapFtToTbc' || action === 'mergeFtInPool') {
+        return {
+            ftInRawAmount: firstFtMovement?.rawAmount,
+            ftInOutputIndex: firstFtMovement?.outputIndex,
+        };
+    }
+    return {};
+}
+function poolNftMovementMetadata(action, facts, actionMatch) {
+    const sender = poolNftSender(facts);
+    const feeOutputs = poolNftFeeOutputs(action, facts);
+    const firstFeeOutput = feeOutputs[0];
+    const feeSatoshis = feeOutputs.reduce((total, output) => total + output.satoshis, 0);
+    const expectedFeeCollector = poolNftExpectedFeeCollector(facts);
+    const poolStateAddress = poolNftStateOutputAddress(facts);
+    const poolStateHash = poolNftStateOutputHash(facts);
+    return {
+        reasons: actionMatch.reasons,
+        poolId: facts.poolInputs[0]?.contractId,
+        poolStateInputIndex: facts.poolInputs[0]?.inputIndex,
+        poolStateOutputIndex: facts.poolOutput?.index,
+        poolStateAddress,
+        poolStateHash: poolStateAddress ? undefined : poolStateHash,
+        poolOutputIndex: facts.poolOutput?.index,
+        sender: sender.sender,
+        senderHash: sender.senderHash,
+        receiverHash: findPoolNftReceiverHash(action, facts),
+        ftTokenId: facts.tape?.ftContractTxid,
+        ftAPartialHash: poolNftFtAPartialHash(facts.tape),
+        ftAPartialHashSource: facts.tape?.ftAPartialHash ? 'poolNftTape' : undefined,
+        ftAPartialHashVerification: poolNftFtAPartialHashVerification(action, facts),
+        lpTokenId: poolNftLpTokenId(action, facts),
+        lpTokenIdSource: poolNftLpTokenIdSource(action, facts),
+        lpTokenIdEvidence: poolNftLpTokenIdEvidence(action, facts),
+        lpPartialHash: poolNftLpPartialHash(facts.tape),
+        lpPartialHashSource: facts.tape?.ftLpPartialHash ? 'poolNftTape' : undefined,
+        lpPartialHashVerification: poolNftLpPartialHashVerification(action, facts),
+        expectedFeeCollector,
+        ...(feeOutputs.length ? {
+            feeSatoshis,
+            feeCollector: firstFeeOutput?.address,
+            feeOutputIndex: firstFeeOutput?.outputIndex,
+            feeOutputs,
+        } : {}),
+        ...poolNftFtAmountFields(action, facts),
+        ...poolNftTbcAmountFields(action, facts),
+        ...(actionMatch.confidence === 'heuristic' ? { note: actionMatch.reasons.at(-1) } : {}),
+    };
+}
+function matchBurnFtLp(inputs, ftMovements) {
+    if (ftMovements.length !== 1 ||
+        inputs.length <= 1 ||
+        inputs.some((input) => Boolean(inputPoolNftTape(input))) ||
+        !isPoolNftBurnReceiver(ftMovements[0]?.receiver)) {
+        return undefined;
+    }
+    return createPoolNftActionMatch('burnFtLp', [
+        'single FT movement is sent to a PoolNFT burn address',
+        'transaction has multiple inputs and no PoolNFT tape movement',
+    ]);
+}
+export function collectPoolNftMovements(inputs, outputs, ftMovements, currentTxid) {
+    const poolNftTapeOutputs = outputs.filter((output) => output.script.data?.poolNft);
+    if (poolNftTapeOutputs.length > 1) {
+        return [];
+    }
+    // Collect primary movements from PoolNFT tape outputs, then detect standalone LP burns when no tape exists.
+    const tapeMovements = poolNftTapeOutputs
+        .map((output) => {
+        const facts = collectPoolNftFacts(inputs, outputs, ftMovements, output);
+        const tape = facts.tape;
+        if (!tape || !hasPoolStateCarrier(facts)) {
+            return undefined;
+        }
+        const firstFtMovement = facts.relatedFtMovements[0];
+        const actionMatch = inferPoolNftAction(facts);
+        if (shouldRejectPoolNftActionMatch(actionMatch, facts)) {
+            return undefined;
+        }
+        const action = actionMatch.action;
+        const ftDecimal = firstFtMovement?.decimal;
+        return {
+            action,
+            transactionType: poolNftTransactionType(action),
+            version: tape.version,
+            ...poolNftMovementMetadata(action, facts, actionMatch),
+            ...(action === 'create' && currentTxid ? { contractId: currentTxid, poolId: currentTxid } : {}),
+            tapeOutputIndex: output.index,
+            receiver: findPoolNftReceiver(action, facts),
+            ftName: firstFtMovement?.name,
+            ftSymbol: firstFtMovement?.symbol,
+            ftDecimal,
+            ftContractTxid: tape.ftContractTxid,
+            ftLpAmountRaw: tape.ftLpAmountRaw,
+            ftLpDisplayAmount: tape.ftLpDisplayAmount,
+            ftAAmountRaw: tape.ftAAmountRaw,
+            ftADisplayAmount: formatPoolNftFtAmount(tape.ftAAmountRaw, ftDecimal),
+            tbcSatoshis: tape.tbcSatoshis,
+            serviceFeeRate: tape.serviceFeeRate,
+            lpPlan: tape.lpPlan,
+            withLock: tape.withLock,
+            withLockTime: tape.withLockTime,
+            confidence: actionMatch.confidence,
+        };
+    })
+        .filter((movement) => Boolean(movement));
+    if (tapeMovements.length) {
+        return tapeMovements;
+    }
+    // An LP burn may contain only an FT movement and burn address with no new PoolNFT tape.
+    const burnMatch = matchBurnFtLp(inputs, ftMovements);
+    if (burnMatch) {
+        const movement = ftMovements[0];
+        const sender = poolNftSenderFromInputs(inputs);
+        return [
+            {
+                action: burnMatch.action,
+                transactionType: poolNftTransactionType(burnMatch.action),
+                sender: sender.sender,
+                senderHash: sender.senderHash,
+                receiver: movement.receiver,
+                ftName: movement.name,
+                ftSymbol: movement.symbol,
+                ftDecimal: movement.decimal,
+                lpTokenId: movement.contractId,
+                ftLpAmountRaw: movement.rawAmount,
+                ftLpDisplayAmount: movement.displayAmount,
+                ftLpInRawAmount: movement.rawAmount,
+                ftLpInOutputIndex: movement.outputIndex,
+                reasons: burnMatch.reasons,
+                confidence: burnMatch.confidence,
+            },
+        ];
+    }
+    return [];
+}
+export function inferPoolNftTransactionType(movements) {
+    return movements[0]?.transactionType;
+}
+//# sourceMappingURL=movements.js.map