@indexing/jiti 0.1.12 → 0.1.13

package/dist/module.js

@@ -4,6 +4,7 @@ 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 $hgUW1$bs58 from "bs58";
+import {Cell as $hgUW1$Cell} from "@ton/core";
 
 
 function $parcel$exportWildcard(dest, source) {
@@ -3524,65 +3525,150 @@ const $13c3ff41f568666f$export$bc6c7ab7e0727dd7 = {
 
 
 
+
+
+var $e97546fe39f2692a$require$Buffer = $hgUW1$Buffer;
+// TEP-74 jetton `internal_transfer` op-code. This is the message a recipient's
+// jetton wallet receives when it is credited, so it is the canonical signal of a
+// jetton deposit landing — and the only jetton message whose executing account
+// (`tx.address`) is the recipient jetton wallet itself.
+const $e97546fe39f2692a$var$JETTON_INTERNAL_TRANSFER_OP = 0x178d4519;
+// Decode a jetton `internal_transfer` message body (a base64-encoded BoC).
+// Returns null when the body is absent, is not a BoC, or carries a different
+// op-code (text comments, other jetton ops, arbitrary contract calls) — the
+// caller then falls back to the native path. Body layout (TEP-74):
+//   internal_transfer#0x178d4519 query_id:uint64 amount:(VarUInteger 16)
+//     from:MsgAddress response_address:MsgAddress ...
+function $e97546fe39f2692a$var$decodeJettonInternalTransfer(body) {
+    if (!body) return null;
+    try {
+        const slice = (0, $hgUW1$Cell).fromBoc($e97546fe39f2692a$require$Buffer.from(body, "base64"))[0].beginParse();
+        if (slice.loadUint(32) !== $e97546fe39f2692a$var$JETTON_INTERNAL_TRANSFER_OP) return null;
+        slice.loadUintBig(64); // query_id
+        const amount = slice.loadCoins();
+        // `from` is the sending owner, read best-effort: it can be addr_none on some
+        // mints/airdrops, and rare non-standard address encodings can throw. In
+        // either case keep the (valid) amount and let the caller fall back to the
+        // message source rather than dropping a real jetton transfer.
+        let from;
+        try {
+            const fromAddress = slice.loadMaybeAddress();
+            from = fromAddress ? fromAddress.toString({
+                urlSafe: true,
+                bounceable: true,
+                testOnly: false
+            }) : undefined;
+        } catch  {
+            from = undefined;
+        }
+        return {
+            amount: amount,
+            from: from
+        };
+    } catch  {
+        return null;
+    }
+}
 const $e97546fe39f2692a$export$608f3f42810b9879 = {
     match: (block)=>(0, $09654dffcb68affa$export$ae001c77434c5340)(block) === "TON",
     transform (block) {
-        let transfers = [];
+        const transfers = [];
         const typedBlock = block;
         const blockNumber = typedBlock.seqno;
-        const blockTimestamp = new Date(typedBlock.shards?.[0]?.gen_utime * 1000).toISOString();
         for (const shard of typedBlock.shards || [])for (const tx of shard.transactions || []){
-            const transactionLT = tx.transaction_id.lt;
-            const transactionHash = tx.transaction_id.hash;
-            const transactionFee = BigInt(tx.fee || "0");
-            const inVal = BigInt(tx.in_msg?.value || "0");
-            if (inVal > 0n) transfers.push({
+            const inMsg = tx.in_msg;
+            if (!inMsg) continue;
+            const transactionHash = tx.transaction_id?.hash;
+            const transactionGasFee = BigInt(tx.fee || "0");
+            // Per-transaction time. shards[0].gen_utime — the previous source — is
+            // wrong for any transaction outside the first shard and is undefined for
+            // empty shards (producing `Invalid Date`).
+            const timestamp = new Date((tx.utime || 0) * 1000).toISOString();
+            // The account this transaction executed on: the recipient account for a
+            // native transfer, or the recipient's jetton wallet for a jetton one
+            // (== in_msg.destination).
+            const to = tx.address?.account_address;
+            // Walk `in_msg` only: every transfer is recorded once, at the
+            // recipient's transaction, with `from` carried on the row so sender
+            // queries still match. Walking `out_msgs` too would double-emit each hop
+            // — the sender's and the recipient's transactions both fall in range.
+            const jetton = $e97546fe39f2692a$var$decodeJettonInternalTransfer(inMsg.msg_data?.body);
+            if (jetton) {
+                // Jetton and native value are mutually exclusive per message: a jetton
+                // `internal_transfer` also carries forwarded gas as `in_msg.value`, so
+                // emitting a native transfer here too would surface a phantom TON hop.
+                transfers.push({
+                    blockNumber: blockNumber,
+                    from: jetton.from || inMsg.source?.account_address,
+                    to: to,
+                    amount: jetton.amount,
+                    // The jetton master is not carried in the wallet-to-wallet
+                    // `internal_transfer`; a stateless template can't resolve it without
+                    // an RPC call, so `token` is intentionally left undefined.
+                    tokenType: "TOKEN",
+                    timestamp: timestamp,
+                    transactionHash: transactionHash,
+                    transactionGasFee: transactionGasFee
+                });
+                continue;
+            }
+            const inValue = BigInt(inMsg.value || "0");
+            if (inValue > 0n) transfers.push({
                 blockNumber: blockNumber,
-                from: tx.in_msg?.source?.account_address,
-                to: tx.address?.account_address,
-                amount: inVal,
+                from: inMsg.source?.account_address,
+                to: to,
+                amount: inValue,
                 token: "TON",
                 tokenType: "NATIVE",
-                timestamp: blockTimestamp,
+                timestamp: timestamp,
                 transactionHash: transactionHash,
-                transactionGasFee: transactionFee
+                transactionGasFee: transactionGasFee
             });
-            for (const outMsg of tx.out_msgs || []){
-                const outVal = BigInt(outMsg.value || "0");
-                if (outVal > 0n) transfers.push({
-                    blockNumber: blockNumber,
-                    from: outMsg.source?.account_address,
-                    to: outMsg.destination?.account_address,
-                    amount: outVal,
-                    token: "TON",
-                    tokenType: "NATIVE",
-                    timestamp: blockTimestamp,
-                    transactionHash: transactionHash,
-                    transactionGasFee: transactionFee
-                });
-            }
         }
         return transfers;
     },
     tests: [
         {
+            // Native TON transfer — `in_msg` carries value and no jetton body.
             params: {
                 network: "TON",
-                walletAddress: "EQAFukUyzmHjUvOYDOjNE-wbZFFl2FWas1rFJoh8IiTsWD40",
-                contractAddress: ""
+                transactionHash: "rwDRQeWniNdxBayFcDavE/Wo35B+MsfO4lJJmvz5Edk="
             },
-            payload: "https://jiti.indexing.co/networks/ton/44919328",
+            payload: "https://jiti.indexing.co/networks/ton/71399000",
             output: [
                 {
-                    blockNumber: 44919328,
-                    from: "EQAFukUyzmHjUvOYDOjNE-wbZFFl2FWas1rFJoh8IiTsWD40",
-                    to: "EQCFTFAHOU3vFt2NiZhRD5dwuS0k7GS59vIg3WfCKwfaQGW2",
-                    amount: 10000000n,
+                    blockNumber: 71399000,
+                    from: "EQBkhlXTyZjri7SfyZcgFbRkjlLvq4kU3UjBTtiTtwLITn0H",
+                    to: "EQABGo8KCza3ea8DNHMnSWZmbRzW-05332eTdfvW-XDQEjQM",
+                    amount: 203686310466n,
                     token: "TON",
                     tokenType: "NATIVE",
-                    timestamp: "2025-02-13T23:10:18.000Z",
-                    transactionHash: "Vh5cWr2uvCsdhoouBQ+EiUcF54os9oqvh8A/62EroQc=",
-                    transactionGasFee: 2355233n
+                    timestamp: "2026-06-05T15:31:47.000Z",
+                    transactionHash: "rwDRQeWniNdxBayFcDavE/Wo35B+MsfO4lJJmvz5Edk=",
+                    transactionGasFee: 6668n
+                }
+            ]
+        },
+        {
+            // Jetton transfer — `in_msg` is an internal_transfer (op 0x178d4519). The
+            // message also carries 49740664 nanoTON of forwarded gas, which must NOT
+            // surface as a phantom native transfer. `token` is left undefined (the
+            // jetton master is not in the wallet-to-wallet message).
+            params: {
+                network: "TON",
+                transactionHash: "Tx+nOxUzqo8kYpNkX20C2OTg6Dd9d6MHadQsknv4620="
+            },
+            payload: "https://jiti.indexing.co/networks/ton/71399000",
+            output: [
+                {
+                    blockNumber: 71399000,
+                    from: "EQDshc_H_RAJNi5CG1oBQfUQ1lQBB6tz54Kf2h756Xp14_Cv",
+                    to: "EQBMzIc7YUB_WkSkmaIooZyONQDayNfipt3PQ4IJRsGXsPGI",
+                    amount: 2800000000n,
+                    tokenType: "TOKEN",
+                    timestamp: "2026-06-05T15:31:47.000Z",
+                    transactionHash: "Tx+nOxUzqo8kYpNkX20C2OTg6Dd9d6MHadQsknv4620=",
+                    transactionGasFee: 233386n
                 }
             ]
         }