@pushchain/core 5.1.5-alpha.1 → 5.1.5

package/src/lib/universal-tx-detector/__tests__/fixtures/scenarios.js

@@ -0,0 +1,669 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivePcUniversalTxId = exports.deriveChildUniversalTxId = exports.SCENARIOS = void 0;
+exports.matchingLogsForFixture = matchingLogsForFixture;
+exports.receiptForFixture = receiptForFixture;
+exports.receiptForExtra = receiptForExtra;
+exports.utxRecordMap = utxRecordMap;
+exports.receiptMap = receiptMap;
+const enums_1 = require("../../../constants/enums");
+const events_1 = require("../../events");
+const child_inbounds_1 = require("../../child-inbounds");
+Object.defineProperty(exports, "deriveChildUniversalTxId", { enumerable: true, get: function () { return child_inbounds_1.deriveChildUniversalTxId; } });
+Object.defineProperty(exports, "derivePcUniversalTxId", { enumerable: true, get: function () { return child_inbounds_1.derivePcUniversalTxId; } });
+const builders_1 = require("./builders");
+// ── Shared constants ──────────────────────────────────────────────────
+const ADDR = {
+    gatewayBsc: '0x44aFFC61983F4348DdddB886349eb992C061EaC0',
+    vaultBsc: '0xE52AC4f8DD3e0263bDF748F3390cdFA1f02be881',
+    gatewaySepolia: '0x05bD7a3D18324c1F7e216f7fbf2b15985aE5281A',
+    vaultSepolia: '0xD019Eb12D0d6eF8D299661f22B4B7d262eD4b965',
+    pcGateway: '0x00000000000000000000000000000000000000c1',
+    uea: '0x4A701114F991bf75685584c8156Db983c0DF95a0',
+    cea: '0x30a9dB8E3cCe83e8A8720EB61B8728F98449ee6b',
+    sender: '0xaaaa000000000000000000000000000000000001',
+    recipient: '0xbbbb000000000000000000000000000000000002',
+    token: '0x0000000000000000000000000000000000000000',
+    pushToken: '0x7169D38820dfd117C3FA1f22a697dBA58d90BA06',
+    revertTo: '0xdddd000000000000000000000000000000000004',
+};
+const HASH = {
+    // Stable test hashes — each pattern identifies one scenario.
+    sA: '0xaa01000000000000000000000000000000000000000000000000000000000001',
+    sC: '0xcc01000000000000000000000000000000000000000000000000000000000001',
+    sD: '0xdd01000000000000000000000000000000000000000000000000000000000001',
+    sE: '0xee01000000000000000000000000000000000000000000000000000000000001',
+    sF: '0xff01000000000000000000000000000000000000000000000000000000000001',
+    sG: '0x0701000000000000000000000000000000000000000000000000000000000001',
+    sH: '0x0801000000000000000000000000000000000000000000000000000000000001',
+    sI: '0x0901000000000000000000000000000000000000000000000000000000000001',
+    sJ: '0x0a01000000000000000000000000000000000000000000000000000000000001',
+    sK: '0x0b01000000000000000000000000000000000000000000000000000000000001',
+    sL: '0x0c01000000000000000000000000000000000000000000000000000000000001',
+    sM: '0x0d01000000000000000000000000000000000000000000000000000000000001',
+    sN: '0x0e01000000000000000000000000000000000000000000000000000000000001',
+    // Destinations for cascade follow-ups.
+    bscDest: '0xbcbc000000000000000000000000000000000000000000000000000000000001',
+    sepoliaDest: '0x5e5e000000000000000000000000000000000000000000000000000000000001',
+    solanaDest: '0x5a5a000000000000000000000000000000000000000000000000000000000001',
+    // Refund txs on Push Chain.
+    pcRefundA: '0xfa01000000000000000000000000000000000000000000000000000000000001',
+    pcRefundB: '0xfb01000000000000000000000000000000000000000000000000000000000001',
+    pcRevertA: '0xfc01000000000000000000000000000000000000000000000000000000000001',
+};
+const SUB_TX = '0x1111111111111111111111111111111111111111111111111111111111111111';
+const SUB_TX_2 = '0x2222222222222222222222222222222222222222222222222222222222222222';
+const SUB_TX_3 = '0x3333333333333333333333333333333333333333333333333333333333333333';
+const UTX_A = '0xabcd000000000000000000000000000000000000000000000000000000000001';
+// ── Derived helpers ───────────────────────────────────────────────────
+function matchingLogsForFixture(f) {
+    return f.logs.map((l) => ({
+        eventName: l.event.name,
+        address: l.address,
+        logIndex: l.logIndex,
+        args: l.args,
+    }));
+}
+function receiptForFixture(f) {
+    const built = f.logs.map((l) => (0, builders_1.buildLog)(l.event, l.args, l.address, l.logIndex, f.txHash));
+    return (0, builders_1.buildReceipt)(built, f.to, f.txHash);
+}
+function receiptForExtra(r) {
+    const built = r.logs.map((l) => (0, builders_1.buildLog)(l.event, l.args, l.address, l.logIndex, r.txHash));
+    return (0, builders_1.buildReceipt)(built, r.to, r.txHash);
+}
+/**
+ * Flatten all utxRecord entries across a scenario and its linked fixtures
+ * into a single Map keyed by the lowercased id (no 0x prefix).
+ */
+function utxRecordMap(fixtures) {
+    var _a;
+    const out = new Map();
+    for (const f of fixtures) {
+        for (const r of (_a = f.utxRecords) !== null && _a !== void 0 ? _a : []) {
+            out.set(r.id.toLowerCase().replace(/^0x/, ''), r.record);
+        }
+    }
+    return out;
+}
+/**
+ * Build a Map<txHashLower, TransactionReceipt> covering the primary tx +
+ * all extraReceipts across every fixture.
+ */
+function receiptMap(fixtures) {
+    var _a;
+    const out = new Map();
+    for (const f of fixtures) {
+        out.set(f.txHash.toLowerCase(), receiptForFixture(f));
+        for (const r of (_a = f.extraReceipts) !== null && _a !== void 0 ? _a : []) {
+            out.set(r.txHash.toLowerCase(), receiptForExtra(r));
+        }
+    }
+    return out;
+}
+// ── Catalogue ─────────────────────────────────────────────────────────
+const REVERT_INSTRUCTION_TUPLE = [ADDR.revertTo, '0xcafe'];
+const universalTxArgs = (fromCEA, txType = 2) => ({
+    sender: ADDR.sender,
+    recipient: ADDR.recipient,
+    token: ADDR.token,
+    amount: BigInt(1000),
+    payload: '0x',
+    revertRecipient: ADDR.revertTo,
+    txType,
+    signatureData: '0x',
+    fromCEA,
+});
+const outboundArgs = (subTxId, chainNamespace, txType = 3) => ({
+    subTxId,
+    sender: ADDR.sender,
+    chainNamespace,
+    token: ADDR.token,
+    recipient: '0xdead',
+    amount: BigInt(42),
+    gasToken: ADDR.token,
+    gasFee: BigInt(3),
+    gasLimit: BigInt(100000),
+    payload: '0x',
+    protocolFee: BigInt(1),
+    revertRecipient: ADDR.revertTo,
+    txType,
+    gasPrice: BigInt(9),
+});
+// Helper — synthesize the utx record that expandPushOutbounds expects.
+function pcUtxRecord(opts) {
+    var _a;
+    return {
+        id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, opts.txHash).slice(2),
+        universalStatus: (_a = opts.universalStatus) !== null && _a !== void 0 ? _a : 7,
+        pcTx: [{ txHash: opts.txHash }],
+        outboundTx: opts.outboundTx,
+    };
+}
+function outboundTuple(opts) {
+    var _a;
+    return {
+        id: opts.subTxId.slice(2),
+        outboundStatus: (_a = opts.outboundStatus) !== null && _a !== void 0 ? _a : 2,
+        destinationChain: opts.destinationChain,
+        observedTx: opts.externalTxHash
+            ? { txHash: opts.externalTxHash, success: true, gasFeeUsed: '100' }
+            : { txHash: '', success: false },
+        amount: '0',
+        recipient: ADDR.recipient,
+        pcRefundExecution: opts.pcRefundExecution,
+        pcRevertExecution: opts.pcRevertExecution,
+    };
+}
+function refundTx(txHash, gasUsed = 100000) {
+    return {
+        txHash,
+        sender: ADDR.sender,
+        gasUsed,
+        blockHeight: 1,
+        status: 'SUCCESS',
+        errorMsg: '',
+    };
+}
+// ── Fixtures ──────────────────────────────────────────────────────────
+exports.SCENARIOS = [
+    // S-A — INBOUND_FROM_EOA (EOA sends FUNDS to UEA)
+    {
+        id: 'S-A',
+        name: 'INBOUND_FROM_EOA — Sepolia EOA sends FUNDS',
+        kind: 'INBOUND_FROM_EOA',
+        chain: enums_1.CHAIN.ETHEREUM_SEPOLIA,
+        txHash: HASH.sA,
+        to: ADDR.gatewaySepolia,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX,
+                args: universalTxArgs(false, 2),
+                address: ADDR.gatewaySepolia,
+                logIndex: 10,
+            },
+        ],
+        expectedDecoded: { fromCEA: false, txType: 2, txTypeName: 'FUNDS' },
+        expectedClassifyAll: ['INBOUND_FROM_EOA'],
+    },
+    // S-C — INBOUND_FROM_CEA (CEA round-trip inbound)
+    {
+        id: 'S-C',
+        name: 'INBOUND_FROM_CEA — Sepolia CEA round-trip',
+        kind: 'INBOUND_FROM_CEA',
+        chain: enums_1.CHAIN.ETHEREUM_SEPOLIA,
+        txHash: HASH.sC,
+        to: ADDR.gatewaySepolia,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX,
+                args: universalTxArgs(true, 1),
+                address: ADDR.gatewaySepolia,
+                logIndex: 20,
+            },
+        ],
+        expectedDecoded: { fromCEA: true, txTypeName: 'GAS_AND_PAYLOAD' },
+        expectedClassifyAll: ['INBOUND_FROM_CEA'],
+    },
+    // S-D — OUTBOUND_INITIATED (Push root with one EVM outbound)
+    {
+        id: 'S-D',
+        name: 'OUTBOUND_INITIATED — Push root with one OBSERVED outbound to BSC',
+        kind: 'OUTBOUND_INITIATED',
+        chain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+        txHash: HASH.sD,
+        to: ADDR.pcGateway,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_OUTBOUND,
+                args: outboundArgs(SUB_TX, enums_1.CHAIN.BNB_TESTNET, 3),
+                address: ADDR.pcGateway,
+                logIndex: 5,
+            },
+        ],
+        extraReceipts: [
+            {
+                txHash: HASH.bscDest,
+                chain: enums_1.CHAIN.BNB_TESTNET,
+                to: ADDR.vaultBsc,
+                logs: [
+                    {
+                        event: events_1.EVENT_UNIVERSAL_TX_FINALIZED,
+                        args: {
+                            subTxId: SUB_TX,
+                            universalTxId: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.sD),
+                            pushAccount: ADDR.uea,
+                            recipient: ADDR.recipient,
+                            token: ADDR.token,
+                            amount: BigInt(42),
+                            data: '0x',
+                        },
+                        address: ADDR.vaultBsc,
+                        logIndex: 0,
+                    },
+                ],
+            },
+        ],
+        utxRecords: [
+            {
+                id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.sD).slice(2),
+                record: pcUtxRecord({
+                    txHash: HASH.sD,
+                    outboundTx: [
+                        outboundTuple({
+                            subTxId: SUB_TX,
+                            destinationChain: enums_1.CHAIN.BNB_TESTNET,
+                            externalTxHash: HASH.bscDest,
+                            pcRefundExecution: refundTx(HASH.pcRefundA),
+                        }),
+                    ],
+                }),
+            },
+            // Refund tx has no utx record of its own (terminal).
+            {
+                id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.pcRefundA).slice(2),
+                record: null,
+            },
+        ],
+        expectedDecoded: { subTxId: SUB_TX, destinationChainNamespace: enums_1.CHAIN.BNB_TESTNET },
+        expectedClassifyAll: ['OUTBOUND_INITIATED'],
+        expectedCascade: {
+            rootKind: 'OUTBOUND_INITIATED',
+            outboundCount: 1,
+            refundCount: 1,
+            childInboundCount: 0,
+            outboundDestinations: [enums_1.CHAIN.BNB_TESTNET],
+            totalFlatNodes: 3, // root + bsc dest + pc-refund
+        },
+    },
+    // S-E — OUTBOUND_FINALIZED (destination Vault finalize with executed sibling)
+    {
+        id: 'S-E',
+        name: 'OUTBOUND_FINALIZED — Sepolia Vault finalize',
+        kind: 'OUTBOUND_FINALIZED',
+        chain: enums_1.CHAIN.ETHEREUM_SEPOLIA,
+        txHash: HASH.sE,
+        to: ADDR.vaultSepolia,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_FINALIZED,
+                args: {
+                    subTxId: SUB_TX,
+                    universalTxId: UTX_A,
+                    pushAccount: ADDR.uea,
+                    recipient: ADDR.recipient,
+                    token: ADDR.token,
+                    amount: BigInt(500),
+                    data: '0x',
+                },
+                address: ADDR.vaultSepolia,
+                logIndex: 5,
+            },
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_EXECUTED,
+                args: {
+                    subTxId: SUB_TX,
+                    universalTxId: UTX_A,
+                    pushAccount: ADDR.uea,
+                    target: ADDR.recipient,
+                    token: ADDR.token,
+                    amount: BigInt(500),
+                    data: '0x',
+                },
+                address: ADDR.gatewaySepolia,
+                logIndex: 6,
+            },
+        ],
+        expectedDecoded: {
+            subTxId: SUB_TX,
+            universalTxId: UTX_A,
+            pushAccount: ADDR.uea,
+        },
+        expectedClassifyAll: ['OUTBOUND_FINALIZED', 'EXECUTED_ON_DEST'],
+    },
+    // S-F — OUTBOUND_REVERTED (Vault reverted; pcRevertExecution refund)
+    {
+        id: 'S-F',
+        name: 'OUTBOUND_REVERTED — BSC Vault emitted UniversalTxReverted',
+        kind: 'OUTBOUND_REVERTED',
+        chain: enums_1.CHAIN.BNB_TESTNET,
+        txHash: HASH.sF,
+        to: ADDR.vaultBsc,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_REVERTED,
+                args: {
+                    subTxId: SUB_TX,
+                    universalTxId: UTX_A,
+                    token: ADDR.token,
+                    amount: BigInt(999),
+                    revertInstruction: REVERT_INSTRUCTION_TUPLE,
+                },
+                address: ADDR.vaultBsc,
+                logIndex: 3,
+            },
+        ],
+        expectedDecoded: {
+            subTxId: SUB_TX,
+            universalTxId: UTX_A,
+            revertRecipient: ADDR.revertTo,
+        },
+        expectedClassifyAll: ['OUTBOUND_REVERTED'],
+    },
+    // S-G — INBOUND_REVERTED (RevertUniversalTx on external chain)
+    {
+        id: 'S-G',
+        name: 'INBOUND_REVERTED — Sepolia RevertUniversalTx',
+        kind: 'INBOUND_REVERTED',
+        chain: enums_1.CHAIN.ETHEREUM_SEPOLIA,
+        txHash: HASH.sG,
+        to: ADDR.gatewaySepolia,
+        logs: [
+            {
+                event: events_1.EVENT_REVERT_UNIVERSAL_TX,
+                args: {
+                    subTxId: SUB_TX,
+                    universalTxId: UTX_A,
+                    to: ADDR.recipient,
+                    token: ADDR.token,
+                    amount: BigInt(1),
+                    revertInstruction: REVERT_INSTRUCTION_TUPLE,
+                },
+                address: ADDR.gatewaySepolia,
+                logIndex: 12,
+            },
+        ],
+        expectedDecoded: {
+            subTxId: SUB_TX,
+            universalTxId: UTX_A,
+            revertRecipient: ADDR.revertTo,
+        },
+        expectedClassifyAll: ['INBOUND_REVERTED'],
+    },
+    // S-H — EXECUTED_ON_DEST (only UniversalTxExecuted log)
+    {
+        id: 'S-H',
+        name: 'EXECUTED_ON_DEST — Destination payload executed',
+        kind: 'EXECUTED_ON_DEST',
+        chain: enums_1.CHAIN.BNB_TESTNET,
+        txHash: HASH.sH,
+        to: ADDR.gatewayBsc,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_EXECUTED,
+                args: {
+                    subTxId: SUB_TX,
+                    universalTxId: UTX_A,
+                    pushAccount: ADDR.uea,
+                    target: ADDR.recipient,
+                    token: ADDR.token,
+                    amount: BigInt(100),
+                    data: '0xdeadbeef',
+                },
+                address: ADDR.gatewayBsc,
+                logIndex: 0,
+            },
+        ],
+        expectedDecoded: { subTxId: SUB_TX, universalTxId: UTX_A, pushAccount: ADDR.uea },
+        expectedClassifyAll: ['EXECUTED_ON_DEST'],
+    },
+    // S-I — RESCUED_FUNDS (FundsRescued event)
+    {
+        id: 'S-I',
+        name: 'RESCUED_FUNDS — Vault-side FundsRescued',
+        kind: 'RESCUED_FUNDS',
+        chain: enums_1.CHAIN.BNB_TESTNET,
+        txHash: HASH.sI,
+        to: ADDR.vaultBsc,
+        logs: [
+            {
+                event: events_1.EVENT_FUNDS_RESCUED,
+                args: {
+                    subTxId: SUB_TX,
+                    universalTxId: UTX_A,
+                    token: ADDR.token,
+                    amount: BigInt(777),
+                    revertInstruction: REVERT_INSTRUCTION_TUPLE,
+                },
+                address: ADDR.vaultBsc,
+                logIndex: 0,
+            },
+        ],
+        expectedDecoded: { subTxId: SUB_TX, universalTxId: UTX_A },
+        expectedClassifyAll: ['RESCUED_FUNDS'],
+    },
+    // S-J — UNKNOWN (receipt with no universal-tx events)
+    {
+        id: 'S-J',
+        name: 'UNKNOWN — receipt with no universal-tx events',
+        kind: 'UNKNOWN',
+        chain: enums_1.CHAIN.BNB_TESTNET,
+        txHash: HASH.sJ,
+        to: ADDR.gatewayBsc,
+        logs: [],
+        expectedClassifyAll: [],
+    },
+    // S-K — PENDING outbound (cascade-only; externalTxHash empty)
+    {
+        id: 'S-K',
+        name: 'PENDING outbound — Push root, outbound not yet observed',
+        kind: 'OUTBOUND_INITIATED',
+        chain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+        txHash: HASH.sK,
+        to: ADDR.pcGateway,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_OUTBOUND,
+                args: outboundArgs(SUB_TX, enums_1.CHAIN.BNB_TESTNET, 3),
+                address: ADDR.pcGateway,
+                logIndex: 0,
+            },
+        ],
+        utxRecords: [
+            {
+                id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.sK).slice(2),
+                record: pcUtxRecord({
+                    txHash: HASH.sK,
+                    universalStatus: 6, // OUTBOUND_PENDING
+                    outboundTx: [
+                        outboundTuple({
+                            subTxId: SUB_TX,
+                            destinationChain: enums_1.CHAIN.BNB_TESTNET,
+                            outboundStatus: 1, // PENDING
+                            // No externalTxHash → cascade edge has node=null
+                        }),
+                    ],
+                }),
+            },
+        ],
+        expectedCascade: {
+            rootKind: 'OUTBOUND_INITIATED',
+            outboundCount: 1,
+            refundCount: 0,
+            outboundDestinations: [enums_1.CHAIN.BNB_TESTNET],
+            totalFlatNodes: 1, // root only (outbound edge has node=null)
+        },
+    },
+    // S-L — Hash with no utx record (cascade-only)
+    {
+        id: 'S-L',
+        name: 'UNKNOWN + no utx record — cascade root resolves with zero children',
+        kind: 'UNKNOWN',
+        chain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+        txHash: HASH.sL,
+        to: ADDR.pcGateway,
+        logs: [],
+        utxRecords: [
+            {
+                id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.sL).slice(2),
+                record: null,
+            },
+        ],
+        expectedClassifyAll: [],
+        expectedCascade: {
+            rootKind: 'UNKNOWN',
+            outboundCount: 0,
+            refundCount: 0,
+            childInboundCount: 0,
+            totalFlatNodes: 1,
+        },
+    },
+    // S-M — Mixed-destination fan-out (BSC + Sepolia EVM + Solana non-EVM)
+    {
+        id: 'S-M',
+        name: 'Mixed-destination fan-out — BSC + Sepolia + Solana',
+        kind: 'OUTBOUND_INITIATED',
+        chain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+        txHash: HASH.sM,
+        to: ADDR.pcGateway,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_OUTBOUND,
+                args: outboundArgs(SUB_TX, enums_1.CHAIN.BNB_TESTNET, 3),
+                address: ADDR.pcGateway,
+                logIndex: 0,
+            },
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_OUTBOUND,
+                args: outboundArgs(SUB_TX_2, enums_1.CHAIN.ETHEREUM_SEPOLIA, 3),
+                address: ADDR.pcGateway,
+                logIndex: 1,
+            },
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_OUTBOUND,
+                args: outboundArgs(SUB_TX_3, enums_1.CHAIN.SOLANA_DEVNET, 3),
+                address: ADDR.pcGateway,
+                logIndex: 2,
+            },
+        ],
+        extraReceipts: [
+            {
+                txHash: HASH.bscDest,
+                chain: enums_1.CHAIN.BNB_TESTNET,
+                to: ADDR.vaultBsc,
+                logs: [], // terminal — no events needed for this scenario's assertions
+            },
+            {
+                txHash: HASH.sepoliaDest,
+                chain: enums_1.CHAIN.ETHEREUM_SEPOLIA,
+                to: ADDR.vaultSepolia,
+                logs: [],
+            },
+        ],
+        utxRecords: [
+            {
+                id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.sM).slice(2),
+                record: pcUtxRecord({
+                    txHash: HASH.sM,
+                    outboundTx: [
+                        outboundTuple({
+                            subTxId: SUB_TX,
+                            destinationChain: enums_1.CHAIN.BNB_TESTNET,
+                            externalTxHash: HASH.bscDest,
+                        }),
+                        outboundTuple({
+                            subTxId: SUB_TX_2,
+                            destinationChain: enums_1.CHAIN.ETHEREUM_SEPOLIA,
+                            externalTxHash: HASH.sepoliaDest,
+                        }),
+                        outboundTuple({
+                            subTxId: SUB_TX_3,
+                            destinationChain: enums_1.CHAIN.SOLANA_DEVNET,
+                            externalTxHash: HASH.solanaDest,
+                        }),
+                    ],
+                }),
+            },
+        ],
+        expectedCascade: {
+            rootKind: 'OUTBOUND_INITIATED',
+            outboundCount: 3,
+            refundCount: 0,
+            outboundDestinations: [
+                enums_1.CHAIN.BNB_TESTNET,
+                enums_1.CHAIN.ETHEREUM_SEPOLIA,
+                enums_1.CHAIN.SOLANA_DEVNET,
+            ],
+            // root + BSC + Sepolia + Solana (SVM now expands; with no SVM fixture
+            // the Solana destination resolves to an empty UNKNOWN node but still
+            // contributes a CascadeNode to the flattened list)
+            totalFlatNodes: 4,
+        },
+    },
+    // S-N — Fan-out with one delivered + one reverted leg (dual refund edges)
+    {
+        id: 'S-N',
+        name: 'Fan-out delivered + reverted — dual pc-refund/pc-revert edges',
+        kind: 'OUTBOUND_INITIATED',
+        chain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+        txHash: HASH.sN,
+        to: ADDR.pcGateway,
+        logs: [
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_OUTBOUND,
+                args: outboundArgs(SUB_TX, enums_1.CHAIN.BNB_TESTNET, 3),
+                address: ADDR.pcGateway,
+                logIndex: 0,
+            },
+            {
+                event: events_1.EVENT_UNIVERSAL_TX_OUTBOUND,
+                args: outboundArgs(SUB_TX_2, enums_1.CHAIN.BNB_TESTNET, 3),
+                address: ADDR.pcGateway,
+                logIndex: 1,
+            },
+        ],
+        extraReceipts: [
+            {
+                txHash: HASH.bscDest,
+                chain: enums_1.CHAIN.BNB_TESTNET,
+                to: ADDR.vaultBsc,
+                logs: [],
+            },
+        ],
+        utxRecords: [
+            {
+                id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.sN).slice(2),
+                record: pcUtxRecord({
+                    txHash: HASH.sN,
+                    outboundTx: [
+                        // Delivered leg
+                        outboundTuple({
+                            subTxId: SUB_TX,
+                            destinationChain: enums_1.CHAIN.BNB_TESTNET,
+                            externalTxHash: HASH.bscDest,
+                            outboundStatus: 2, // OBSERVED
+                            pcRefundExecution: refundTx(HASH.pcRefundA),
+                        }),
+                        // Reverted leg
+                        outboundTuple({
+                            subTxId: SUB_TX_2,
+                            destinationChain: enums_1.CHAIN.BNB_TESTNET,
+                            externalTxHash: HASH.bscDest,
+                            outboundStatus: 3, // REVERTED
+                            pcRevertExecution: refundTx(HASH.pcRevertA, 50000),
+                        }),
+                    ],
+                }),
+            },
+            {
+                id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.pcRefundA).slice(2),
+                record: null,
+            },
+            {
+                id: (0, child_inbounds_1.derivePcUniversalTxId)(enums_1.CHAIN.PUSH_TESTNET_DONUT, HASH.pcRevertA).slice(2),
+                record: null,
+            },
+        ],
+        expectedCascade: {
+            rootKind: 'OUTBOUND_INITIATED',
+            outboundCount: 2,
+            refundCount: 2,
+            outboundDestinations: [enums_1.CHAIN.BNB_TESTNET, enums_1.CHAIN.BNB_TESTNET],
+            // root + 2 BSC dest nodes (only 1 visited due to cycle dedupe) + 2 refunds
+            // The walker visits each unique (chain, txHash) once — both outbound legs
+            // point at HASH.bscDest, so the second walk returns null (cycle guard).
+            totalFlatNodes: 4,
+        },
+    },
+];
+//# sourceMappingURL=scenarios.js.map