@indexing/jiti 0.1.4 → 0.1.6

package/dist/main.js

@@ -1154,6 +1154,8 @@ const $f9ab50a3e879ac1c$export$b5fd4920e8b7d913 = {
 
 
 const $8deaea1ef39b6485$var$NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
+// zkSync Era wraps native ETH as an ERC-20 at this address; Transfer logs from it represent native ETH movements
+const $8deaea1ef39b6485$var$ZKSYNC_NATIVE_ETH = "0x000000000000000000000000000000000000800a";
 const $8deaea1ef39b6485$export$5beebc5708fabf3c = {
     match: (block)=>(0, $6bd2ca253e883278$export$ae001c77434c5340)(block) === "EVM",
     transform (block, _ctx) {
@@ -1164,10 +1166,39 @@ const $8deaea1ef39b6485$export$5beebc5708fabf3c = {
             if (!tx.receipt) continue;
             const timestamp = new Date(typedBlock.timestamp * 1000).toISOString();
             const transactionGasFee = BigInt(tx.receipt.gasUsed) * BigInt(tx.receipt.effectiveGasPrice);
+            // check if this tx has zkSync native ETH Transfer logs (used to skip unreliable traces)
+            const hasZkSyncEthLogs = tx.receipt.logs.some((log)=>log.address.toLowerCase() === $8deaea1ef39b6485$var$ZKSYNC_NATIVE_ETH);
             // track direct ETH transfers
             if (!TOKEN_TYPES.length || TOKEN_TYPES.includes("NATIVE")) {
-                // pull from traces, if available
-                if (Array.isArray(tx.traces)) for (const trace of tx.traces.filter((t)=>t.action)){
+                // handle L1→L2 deposit transactions (OP Stack type 0x7e) as native mints
+                if (tx.mint && BigInt(tx.mint) > 0n) transfers.push({
+                    amount: BigInt(tx.mint),
+                    blockNumber: tx.blockNumber,
+                    from: $8deaea1ef39b6485$var$NULL_ADDRESS,
+                    timestamp: timestamp,
+                    to: tx.to?.toLowerCase() || tx.from?.toLowerCase() || $8deaea1ef39b6485$var$NULL_ADDRESS,
+                    tokenType: "NATIVE",
+                    transactionGasFee: transactionGasFee,
+                    transactionHash: tx.hash
+                });
+                else if (hasZkSyncEthLogs) for (const log of tx.receipt.logs){
+                    if (log.address.toLowerCase() !== $8deaea1ef39b6485$var$ZKSYNC_NATIVE_ETH) continue;
+                    const txfer = (0, $da55be3e40667945$export$cf548b70626e2eb9)(log, [
+                        "Transfer(address indexed from, address indexed to, uint256 value)"
+                    ]);
+                    if (txfer) transfers.push({
+                        amount: txfer.decoded.value,
+                        blockNumber: tx.blockNumber,
+                        from: txfer.decoded.from?.toLowerCase() || $8deaea1ef39b6485$var$NULL_ADDRESS,
+                        index: log.logIndex,
+                        timestamp: timestamp,
+                        to: txfer.decoded.to?.toLowerCase() || $8deaea1ef39b6485$var$NULL_ADDRESS,
+                        tokenType: "NATIVE",
+                        transactionGasFee: transactionGasFee,
+                        transactionHash: tx.hash
+                    });
+                }
+                else if (Array.isArray(tx.traces)) for (const trace of tx.traces.filter((t)=>t.action)){
                     const action = trace.action;
                     if (!action?.value) continue;
                     transfers.push({
@@ -1195,6 +1226,8 @@ const $8deaea1ef39b6485$export$5beebc5708fabf3c = {
             }
             // track ERC20 transfers
             if (!TOKEN_TYPES.length || TOKEN_TYPES.includes("TOKEN")) for (const log of tx.receipt.logs){
+                // skip zkSync native ETH logs (already handled as NATIVE above)
+                if (log.address.toLowerCase() === $8deaea1ef39b6485$var$ZKSYNC_NATIVE_ETH) continue;
                 const txfer = (0, $da55be3e40667945$export$cf548b70626e2eb9)(log, [
                     "Transfer(address indexed from, address indexed to, uint256 value)"
                 ]);
@@ -1294,6 +1327,51 @@ const $8deaea1ef39b6485$export$5beebc5708fabf3c = {
                 }
             ]
         },
+        {
+            params: {
+                network: "BASE",
+                walletAddress: "0xDa863f802Cc8CBA3C436bF801BD7785d9E7d4F36",
+                tokenTypes: [
+                    "NATIVE"
+                ]
+            },
+            payload: "https://jiti.indexing.co/networks/base/13170774",
+            output: [
+                {
+                    amount: 80000000000000000n,
+                    blockNumber: 13170774,
+                    from: "0x0000000000000000000000000000000000000000",
+                    timestamp: "2024-04-14T21:41:35.000Z",
+                    to: "0xda863f802cc8cba3c436bf801bd7785d9e7d4f36",
+                    tokenType: "NATIVE",
+                    transactionGasFee: 0n,
+                    transactionHash: "0xa3c7cbece45ff18b18e001c4bc096567c85526dad3453dba88791054a61fc444"
+                }
+            ]
+        },
+        {
+            params: {
+                network: "ZKSYNC",
+                walletAddress: "0xf70da97812CB96aCDF810712Aa562db8dfA3dBEf",
+                tokenTypes: [
+                    "NATIVE"
+                ]
+            },
+            payload: "https://jiti.indexing.co/networks/zksync/55005000",
+            output: [
+                {
+                    amount: 1615028132795916n,
+                    blockNumber: 55005000,
+                    from: "0xebd1e414ebb98522cfd932104ba41fac10a4ef35",
+                    index: 4,
+                    timestamp: "2025-02-01T06:14:12.000Z",
+                    to: "0xf70da97812cb96acdf810712aa562db8dfa3dbef",
+                    tokenType: "NATIVE",
+                    transactionGasFee: 6389164250000n,
+                    transactionHash: "0xc0e1850d24af965e6a02836301a696e9f021b07fed765d8affe3bda1846d5700"
+                }
+            ]
+        },
         {
             params: {
                 network: "POLYGON",
@@ -1389,6 +1467,23 @@ const $2e46ec862e47c14f$export$400f08bfae9ee97f = {
         if (!Array.isArray(typedBlock.transactions)) return [];
         for (const typedTx of typedBlock.transactions || []){
             if (typedTx.TransactionType !== "Payment") continue;
+            // Failed XRPL payments still burn Fee. Emit a fee-only transfer (to: null) so
+            // callers account for the gas, and skip the payment amount that never landed.
+            if (typedTx.metaData?.TransactionResult && typedTx.metaData.TransactionResult !== "tesSUCCESS") {
+                transfers.push({
+                    amount: BigInt(typedTx.Fee ?? "0"),
+                    blockNumber: parseInt(typedBlock.ledger_index, 10),
+                    from: typedTx.Account ?? "UNKNOWN",
+                    memo: typedTx.DestinationTag,
+                    timestamp: typedBlock.close_time_iso || null,
+                    to: null,
+                    token: "XRP",
+                    tokenType: "NATIVE",
+                    transactionGasFee: BigInt(typedTx.Fee ?? "0"),
+                    transactionHash: typedTx.hash ?? ""
+                });
+                continue;
+            }
             const deliveredOrAmount = typedTx.metaData?.delivered_amount ?? typedTx.Amount ?? "0";
             let tokenSymbol = "XRP";
             let tokenType = "NATIVE";
@@ -1437,6 +1532,45 @@ const $2e46ec862e47c14f$export$400f08bfae9ee97f = {
                     transactionHash: "B32A6A5455777283212407FBD8CCA701505C654E5F4ADFFBE9D4D22F00889D87"
                 }
             ]
+        },
+        // Failed XRPL payments emit ONLY a fee transfer (to: null) — the payment Amount
+        // never reached the Destination, but the Fee was still burned.
+        {
+            params: {
+                network: "RIPPLE"
+            },
+            payload: {
+                _network: "RIPPLE",
+                ledger_index: "100000000",
+                close_time_iso: "2026-04-04T08:02:44Z",
+                transactions: [
+                    {
+                        TransactionType: "Payment",
+                        Account: "rFAILFROMxxxxxxxxxxxxxxxxxxxxxxxxx",
+                        Destination: "rFAILTOxxxxxxxxxxxxxxxxxxxxxxxxxx",
+                        Amount: "1000000",
+                        Fee: "10",
+                        hash: "FAILEDXRPLTXHASH",
+                        metaData: {
+                            TransactionResult: "tecPATH_DRY"
+                        }
+                    }
+                ]
+            },
+            output: [
+                {
+                    amount: 10n,
+                    blockNumber: 100000000,
+                    from: "rFAILFROMxxxxxxxxxxxxxxxxxxxxxxxxx",
+                    memo: undefined,
+                    timestamp: "2026-04-04T08:02:44Z",
+                    to: null,
+                    token: "XRP",
+                    tokenType: "NATIVE",
+                    transactionGasFee: 10n,
+                    transactionHash: "FAILEDXRPLTXHASH"
+                }
+            ]
         }
     ]
 };
@@ -3173,6 +3307,23 @@ const $3478cd776d185339$export$681f497010b17679 = {
         let transfers = [];
         const typedBlock = block;
         for (const typedTx of typedBlock.transactions || []){
+            // Failed txs still burn fee_charged — emit a fee transfer (to: null) so callers
+            // can account for the gas, but skip the payment ops that never actually moved funds.
+            if (!typedTx.successful) {
+                transfers.push({
+                    amount: BigInt(typedTx.fee_charged),
+                    blockNumber: typedBlock.sequence,
+                    from: typedTx.source_account,
+                    memo: typedTx.memo,
+                    timestamp: typedTx.created_at,
+                    to: null,
+                    token: null,
+                    tokenType: "NATIVE",
+                    transactionGasFee: BigInt(typedTx.fee_charged),
+                    transactionHash: typedTx.hash
+                });
+                continue;
+            }
             for (const op of typedTx.operations)if (op.type === "payment") transfers.push({
                 amount: BigInt(op.amount.replace(".", "")),
                 blockNumber: typedBlock.sequence,
@@ -3221,6 +3372,31 @@ const $3478cd776d185339$export$681f497010b17679 = {
                     transactionHash: "c554aed41145304e03c0877c9de526cdcb8a8255c9bf156ff0dec202ab12e20d"
                 }
             ]
+        },
+        // Failed Stellar txs emit ONLY a fee transfer (to: null), never the failed payment
+        // operations. Ledger 61961851 / tx 9024ba4b... is the Mesh incident — the source
+        // tried to send 1_000_000_000 stroops to GAGLH6..., the tx reverted, and the only
+        // on-chain effect was the 100-stroop fee being charged.
+        {
+            params: {
+                network: "STELLAR",
+                transactionHash: "9024ba4b558b09042cb02afd1d46eea72597891691801375acee332273c5c26d"
+            },
+            payload: "https://jiti.indexing.co/networks/stellar/61961851",
+            output: [
+                {
+                    amount: 100n,
+                    blockNumber: 61961851,
+                    from: "GCP7I54JXTOZ4SJG4UARWJOMJ25JQXRHSHXQWDSV4TRVRJFDG67VUEXP",
+                    memo: undefined,
+                    timestamp: "2026-04-04T08:02:44Z",
+                    to: null,
+                    token: null,
+                    tokenType: "NATIVE",
+                    transactionGasFee: 100n,
+                    transactionHash: "9024ba4b558b09042cb02afd1d46eea72597891691801375acee332273c5c26d"
+                }
+            ]
         }
     ]
 };