@indexing/jiti 0.1.20 → 0.1.22

package/dist/module.js

@@ -3,7 +3,7 @@ import {sha256 as $hgUW1$sha256, keccak256 as $hgUW1$keccak256, decodeEventLog a
 import $hgUW1$tronweb from "tronweb";
 import {decodeTxRaw as $hgUW1$decodeTxRaw, Registry as $hgUW1$Registry} from "@cosmjs/proto-signing";
 import {defaultRegistryTypes as $hgUW1$defaultRegistryTypes} from "@cosmjs/stargate";
-import {Address as $hgUW1$Address, Cell as $hgUW1$Cell} from "@ton/core";
+import {Address as $hgUW1$Address, Cell as $hgUW1$Cell, beginCell as $hgUW1$beginCell} from "@ton/core";
 import $hgUW1$bs58 from "bs58";
 
 
@@ -178,6 +178,9 @@ const $09654dffcb68affa$var$PARTIAL_VM_TO_NETWORK_MAP = {
     TON: [
         "TON"
     ],
+    TRON: [
+        "TRON"
+    ],
     UTXO: [
         "BITCOIN",
         "BITCOIN_TESTNET",
@@ -4497,6 +4500,30 @@ function $e97546fe39f2692a$var$decodeJettonInternalTransfer(body) {
         return null;
     }
 }
+// Other TEP-74 jetton messages whose `in_msg.value` is only forwarded gas or a
+// refund — never a user-facing TON transfer. Emitting a native transfer for
+// these surfaces phantom TON hops around every jetton send:
+//   0x0f8a7ea5 transfer              — owner → own jetton wallet (attached gas)
+//   0x7362d09c transfer_notification — jetton wallet → owner (forwarded gas)
+//   0xd53276db excesses              — jetton wallet → response addr (gas refund)
+// `internal_transfer` (0x178d4519) is handled above as the jetton TOKEN row.
+const $e97546fe39f2692a$var$JETTON_GAS_ONLY_OPS = new Set([
+    0x0f8a7ea5,
+    0x7362d09c,
+    0xd53276db
+]);
+// True when the message body carries one of the jetton gas-only op-codes above.
+// Reads only the 32-bit op-code; returns false for text comments, empty/non-BoC
+// bodies, or any other op — which fall through to the native path.
+function $e97546fe39f2692a$var$isJettonGasOnlyMessage(body) {
+    if (!body) return false;
+    try {
+        const slice = (0, $hgUW1$Cell).fromBoc($e97546fe39f2692a$require$Buffer.from(body, "base64"))[0].beginParse();
+        return $e97546fe39f2692a$var$JETTON_GAS_ONLY_OPS.has(slice.loadUint(32));
+    } catch  {
+        return false;
+    }
+}
 const $e97546fe39f2692a$export$608f3f42810b9879 = {
     match: (block)=>(0, $09654dffcb68affa$export$ae001c77434c5340)(block) === "TON",
     transform (block) {
@@ -4540,6 +4567,11 @@ const $e97546fe39f2692a$export$608f3f42810b9879 = {
                 });
                 continue;
             }
+            // A jetton send's own gas hops (transfer / transfer_notification /
+            // excesses) carry `in_msg.value` as forwarded gas, not a real TON
+            // transfer — skip them so they don't surface as phantom native transfers
+            // alongside the jetton `internal_transfer` row emitted above.
+            if ($e97546fe39f2692a$var$isJettonGasOnlyMessage(inMsg.msg_data?.body)) continue;
             const inValue = BigInt(inMsg.value || "0");
             if (inValue > 0n) transfers.push({
                 blockNumber: blockNumber,
@@ -4599,6 +4631,259 @@ const $e97546fe39f2692a$export$608f3f42810b9879 = {
                     transactionGasFee: 233386n
                 }
             ]
+        },
+        {
+            // Jetton gas hops must not surface as native transfers. Synthetic block
+            // (inline payload, no network) with four txs: a genuine native transfer,
+            // an `excesses` (0xd53276db), a `transfer_notification` (0x7362d09c), and a
+            // jetton `internal_transfer` (0x178d4519). Only the native and the jetton
+            // rows survive; the two gas-only ops are dropped despite carrying value.
+            params: {
+                network: "TON"
+            },
+            payload: {
+                _network: "TON",
+                seqno: 76697922,
+                shards: [
+                    {
+                        transactions: [
+                            {
+                                address: {
+                                    account_address: "EQrecipient_native"
+                                },
+                                utime: 1782844609,
+                                fee: "100",
+                                transaction_id: {
+                                    hash: "native-hash"
+                                },
+                                in_msg: {
+                                    value: "1000000000",
+                                    source: {
+                                        account_address: "EQsender_native"
+                                    },
+                                    msg_data: {}
+                                }
+                            },
+                            {
+                                address: {
+                                    account_address: "EQsubject"
+                                },
+                                utime: 1782844609,
+                                fee: "100",
+                                transaction_id: {
+                                    hash: "excesses-hash"
+                                },
+                                in_msg: {
+                                    value: "49490794",
+                                    source: {
+                                        account_address: "EQjetton_wallet"
+                                    },
+                                    msg_data: {
+                                        body: (0, $hgUW1$beginCell)().storeUint(0xd53276db, 32).storeUint(0, 64).endCell().toBoc().toString("base64")
+                                    }
+                                }
+                            },
+                            {
+                                address: {
+                                    account_address: "EQowner"
+                                },
+                                utime: 1782844609,
+                                fee: "100",
+                                transaction_id: {
+                                    hash: "notification-hash"
+                                },
+                                in_msg: {
+                                    value: "49490794",
+                                    source: {
+                                        account_address: "EQowner_jetton_wallet"
+                                    },
+                                    msg_data: {
+                                        body: (0, $hgUW1$beginCell)().storeUint(0x7362d09c, 32).storeUint(0, 64).endCell().toBoc().toString("base64")
+                                    }
+                                }
+                            },
+                            {
+                                address: {
+                                    account_address: "EQrecipient_jetton_wallet"
+                                },
+                                utime: 1782844609,
+                                fee: "200",
+                                transaction_id: {
+                                    hash: "jetton-hash"
+                                },
+                                in_msg: {
+                                    value: "49740664",
+                                    source: {
+                                        account_address: "EQsender_jetton_wallet"
+                                    },
+                                    msg_data: {
+                                        body: (0, $hgUW1$beginCell)().storeUint(0x178d4519, 32).storeUint(0, 64).storeCoins(2800000000n).storeAddress(null).endCell().toBoc().toString("base64")
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ]
+            },
+            output: [
+                {
+                    blockNumber: 76697922,
+                    from: "EQsender_native",
+                    to: "EQrecipient_native",
+                    amount: 1000000000n,
+                    token: "TON",
+                    tokenType: "NATIVE",
+                    timestamp: "2026-06-30T18:36:49.000Z",
+                    transactionHash: "native-hash",
+                    transactionGasFee: 100n
+                },
+                {
+                    blockNumber: 76697922,
+                    from: "EQsender_jetton_wallet",
+                    to: "EQrecipient_jetton_wallet",
+                    amount: 2800000000n,
+                    tokenType: "TOKEN",
+                    timestamp: "2026-06-30T18:36:49.000Z",
+                    transactionHash: "jetton-hash",
+                    transactionGasFee: 200n
+                }
+            ]
+        }
+    ]
+};
+
+
+
+
+const $7de02413bc6a8204$export$3cb99d88eca41d3b = {
+    match: (block)=>(0, $09654dffcb68affa$export$ae001c77434c5340)(block) === "TRON",
+    transform (block, _ctx = {
+        params: {}
+    }) {
+        // Reuse the full EVM extraction — native TRX + TRC-20 (Transfer logs ride on the
+        // receipts the eth-compat path already fetches).
+        const evmTransfers = (0, $5ec62a2088d070a8$export$5beebc5708fabf3c).transform(block, _ctx);
+        const trc10 = block._trc10 || [];
+        if (!trc10.length) return evmTransfers;
+        const trc10ByHash = new Map(trc10.map((t)=>[
+                t.hash,
+                t
+            ]));
+        const relabeled = new Set();
+        // Relabel the phantom NATIVE that eth-compat produced for each TRC-10 tx (amount
+        // → tx.value) into the real TOKEN row, keeping the EVM-computed block / timestamp
+        // / gas fee and taking the authoritative asset id + amount + owner/to from the
+        // native data.
+        const transfers = evmTransfers.map((t)=>{
+            const match = t.tokenType === "NATIVE" ? trc10ByHash.get(t.transactionHash) : undefined;
+            if (!match) return t;
+            relabeled.add(match.hash);
+            return {
+                ...t,
+                tokenType: "TOKEN",
+                token: match.token,
+                amount: BigInt(match.amount),
+                from: match.from,
+                to: match.to
+            };
+        });
+        // Defensive: a TRC-10 tx that left no phantom NATIVE to relabel (a positive-amount
+        // asset transfer always sets tx.value, so this should not happen — but never drop
+        // a real transfer). Emit it directly, borrowing block/timestamp/fee from any EVM
+        // row on the same tx, else the block header.
+        const evmByHash = new Map(evmTransfers.map((t)=>[
+                t.transactionHash,
+                t
+            ]));
+        const typedBlock = block;
+        for (const m of trc10){
+            if (relabeled.has(m.hash)) continue;
+            const ref = evmByHash.get(m.hash);
+            transfers.push({
+                amount: BigInt(m.amount),
+                blockNumber: ref?.blockNumber ?? Number(typedBlock.number),
+                from: m.from,
+                timestamp: ref?.timestamp ?? new Date(typedBlock.timestamp * 1000).toISOString(),
+                to: m.to,
+                token: m.token,
+                tokenType: "TOKEN",
+                transactionGasFee: ref?.transactionGasFee ?? 0n,
+                transactionHash: m.hash
+            });
+        }
+        return transfers;
+    },
+    tests: [
+        {
+            // Synthetic TRON block: a native TRX transfer and a TRC-10 transfer. The TRC-10
+            // arrives EVM-shaped (its amount in `tx.value`, empty logs) so EVM emits a
+            // phantom NATIVE; the `_trc10` supplement (asset id 1005168, à la Mircea's
+            // Pay.bi repro) relabels it to a TOKEN, while the genuine native TRX is untouched.
+            params: {
+                network: "TRON"
+            },
+            payload: {
+                _network: "TRON",
+                number: 84058381,
+                timestamp: 1782844609,
+                transactions: [
+                    {
+                        hash: "native-trx-hash",
+                        blockNumber: 84058381,
+                        from: "0x1111111111111111111111111111111111111111",
+                        to: "0x2222222222222222222222222222222222222222",
+                        value: "1000000",
+                        receipt: {
+                            gasUsed: "0",
+                            logs: []
+                        }
+                    },
+                    {
+                        hash: "trc10-hash",
+                        blockNumber: 84058381,
+                        from: "0x3333333333333333333333333333333333333333",
+                        to: "0x4444444444444444444444444444444444444444",
+                        // eth-compat mapped the TRC-10 amount into value; asset id is gone here.
+                        value: "4444444444",
+                        receipt: {
+                            gasUsed: "0",
+                            logs: []
+                        }
+                    }
+                ],
+                _trc10: [
+                    {
+                        hash: "trc10-hash",
+                        token: "1005168",
+                        amount: "4444444444",
+                        from: "0x3333333333333333333333333333333333333333",
+                        to: "0x4444444444444444444444444444444444444444"
+                    }
+                ]
+            },
+            output: [
+                {
+                    amount: 1000000n,
+                    blockNumber: 84058381,
+                    from: "0x1111111111111111111111111111111111111111",
+                    timestamp: "2026-06-30T18:36:49.000Z",
+                    to: "0x2222222222222222222222222222222222222222",
+                    tokenType: "NATIVE",
+                    transactionGasFee: 0n,
+                    transactionHash: "native-trx-hash"
+                },
+                {
+                    amount: 4444444444n,
+                    blockNumber: 84058381,
+                    from: "0x3333333333333333333333333333333333333333",
+                    timestamp: "2026-06-30T18:36:49.000Z",
+                    to: "0x4444444444444444444444444444444444444444",
+                    token: "1005168",
+                    tokenType: "TOKEN",
+                    transactionGasFee: 0n,
+                    transactionHash: "trc10-hash"
+                }
+            ]
         }
     ]
 };
@@ -4688,6 +4973,7 @@ const $0ab1acc1eff391f6$var$SUB_TEMPLATES = [
     (0, $13c3ff41f568666f$export$bc6c7ab7e0727dd7),
     (0, $f9f6601c9222cc8e$export$722698bc663d0ac0),
     (0, $e97546fe39f2692a$export$608f3f42810b9879),
+    (0, $7de02413bc6a8204$export$3cb99d88eca41d3b),
     (0, $532fac82d96b89f2$export$4f5322cf4718bd30)
 ];
 const $0ab1acc1eff391f6$var$UNIVERSAL_SUB_TEMPLATES = [
@@ -12513,6 +12799,9 @@ var $f3761421850600fb$exports = {};
 // Samples: 3
 
 
+var $ff207d45a6836c21$exports = {};
+
+
 var $e64a550a52a9d690$exports = {};
 // Auto-generated by scripts/generate-block-types.ts
 // Generated: 2026-03-17
@@ -12541,6 +12830,7 @@ $parcel$exportWildcard($a4e0e4b4a62175c4$exports, $e964f2aee2d00bfe$exports);
 $parcel$exportWildcard($a4e0e4b4a62175c4$exports, $bb1ffb53a3b14860$exports);
 $parcel$exportWildcard($a4e0e4b4a62175c4$exports, $480b559416e5cd89$exports);
 $parcel$exportWildcard($a4e0e4b4a62175c4$exports, $f3761421850600fb$exports);
+$parcel$exportWildcard($a4e0e4b4a62175c4$exports, $ff207d45a6836c21$exports);
 $parcel$exportWildcard($a4e0e4b4a62175c4$exports, $e64a550a52a9d690$exports);