@indexing/jiti 0.1.12 → 0.1.14

package/dist/main.js

@@ -3,9 +3,14 @@ var $8zHUo$viem = require("viem");
 var $8zHUo$tronweb = require("tronweb");
 var $8zHUo$cosmjsprotosigning = require("@cosmjs/proto-signing");
 var $8zHUo$cosmjsstargate = require("@cosmjs/stargate");
+var $8zHUo$toncore = require("@ton/core");
 var $8zHUo$bs58 = require("bs58");
 
 
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
 function $parcel$exportWildcard(dest, source) {
   Object.keys(source).forEach(function(key) {
     if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
@@ -23,18 +28,122 @@ function $parcel$exportWildcard(dest, source) {
   return dest;
 }
 
-function $parcel$export(e, n, v, s) {
-  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
-}
-
 function $parcel$interopDefault(a) {
   return a && a.__esModule ? a.default : a;
 }
 
+      var $parcel$global = globalThis;
+    
+var $parcel$modules = {};
+var $parcel$inits = {};
+
+var parcelRequire = $parcel$global["parcelRequire3fdc"];
+
+if (parcelRequire == null) {
+  parcelRequire = function(id) {
+    if (id in $parcel$modules) {
+      return $parcel$modules[id].exports;
+    }
+    if (id in $parcel$inits) {
+      var init = $parcel$inits[id];
+      delete $parcel$inits[id];
+      var module = {id: id, exports: {}};
+      $parcel$modules[id] = module;
+      init.call(module.exports, module, module.exports);
+      return module.exports;
+    }
+    var err = new Error("Cannot find module '" + id + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+  };
+
+  parcelRequire.register = function register(id, init) {
+    $parcel$inits[id] = init;
+  };
+
+  $parcel$global["parcelRequire3fdc"] = parcelRequire;
+}
+
+var parcelRegister = parcelRequire.register;
+parcelRegister("lCdWD", function(module, exports) {
+
+$parcel$export(module.exports, "createPostgresCacheStorage", () => createPostgresCacheStorage);
+function createPostgresCacheStorage(opts) {
+    const table = (opts.table ?? "jiti_cache").replace(/[^a-zA-Z0-9_]/g, "");
+    let pool = opts.pool;
+    function getPool() {
+        if (!pool) {
+            // Obscure the require so jiti's bundler leaves `pg` external (loaded from the consumer).
+            const requirePg = eval("require");
+            const pg = requirePg("pg");
+            pool = new pg.Pool({
+                connectionString: opts.connectionUri
+            });
+        }
+        return pool;
+    }
+    let ready;
+    function ensureTable() {
+        if (!ready) ready = (async ()=>{
+            const p = getPool();
+            await p.query(`CREATE TABLE IF NOT EXISTS ${table} (
+             namespace   text        NOT NULL,
+             key         text        NOT NULL,
+             value       jsonb,
+             found       boolean     NOT NULL DEFAULT true,
+             resolved_at timestamptz NOT NULL DEFAULT now(),
+             expires_at  timestamptz,
+             PRIMARY KEY (namespace, key)
+           );`);
+            await p.query(`CREATE INDEX IF NOT EXISTS ${table}_expires_idx ON ${table} (expires_at) WHERE expires_at IS NOT NULL;`);
+        })();
+        return ready;
+    }
+    return {
+        async get (namespace, key) {
+            await ensureTable();
+            const { rows } = await getPool().query(`SELECT value, found, expires_at FROM ${table} WHERE namespace = $1 AND key = $2`, [
+                namespace,
+                key
+            ]);
+            if (!rows.length) return null;
+            const row = rows[0];
+            return {
+                value: row.value ?? null,
+                found: row.found,
+                expiresAt: row.expires_at ? new Date(row.expires_at).getTime() : null
+            };
+        },
+        async set (namespace, key, row) {
+            await ensureTable();
+            await getPool().query(`INSERT INTO ${table} (namespace, key, value, found, resolved_at, expires_at)
+         VALUES ($1, $2, $3::jsonb, $4, now(), $5)
+         ON CONFLICT (namespace, key) DO UPDATE
+           SET value = EXCLUDED.value, found = EXCLUDED.found, resolved_at = now(), expires_at = EXCLUDED.expires_at`, [
+                namespace,
+                key,
+                row.value === null || row.value === undefined ? null : JSON.stringify(row.value),
+                row.found,
+                row.expiresAt ? new Date(row.expiresAt).toISOString() : null
+            ]);
+        }
+    };
+}
+
+});
+
+
 $parcel$export(module.exports, "utils", () => $882b6d93070905b3$export$eab97d15b1788b8d);
 $parcel$export(module.exports, "templates", () => $882b6d93070905b3$export$a8fc3402335b0b04);
 $parcel$export(module.exports, "getAllTemplates", () => $882b6d93070905b3$export$cceb5167b935aafb);
 $parcel$export(module.exports, "getTemplateByKey", () => $882b6d93070905b3$export$a07bfd14bbc36e4b);
+$parcel$export(module.exports, "cacheGet", () => $45fec2af5a17964d$export$2aca74ef9665e35d);
+$parcel$export(module.exports, "cacheSet", () => $45fec2af5a17964d$export$59c69e19e33761f6);
+$parcel$export(module.exports, "registerCacheNamespace", () => $226820b1648da9ad$export$2b845901f37b4099);
+$parcel$export(module.exports, "createPostgresCacheStorage", () => (parcelRequire("lCdWD")).createPostgresCacheStorage);
+$parcel$export(module.exports, "lookupJettonWallet", () => $b2a2726ff5c26695$export$77ffdf974cb300ec);
+$parcel$export(module.exports, "resolveJettonWalletData", () => $b2a2726ff5c26695$export$cef9e9799d863462);
+$parcel$export(module.exports, "TON_JETTON_NAMESPACE", () => $b2a2726ff5c26695$export$a0a0f70252f1386f);
 var $d7167569386d0d4c$exports = {};
 var $56acd58307ebf8e6$exports = {};
 
@@ -1359,6 +1468,219 @@ const $5a4d345db3c04a51$export$d7ac970e8e789607 = {
 
 
 
+// Per-namespace policy registry. Namespaces differ only here: immutable vs TTL
+// (`ttlSeconds`), and resolve-on-miss vs externally-populated (presence of `resolve`).
+// jiti registers the namespaces it can resolve itself (e.g. ton-jetton-wallet); a consumer
+// may register its own (e.g. token-price with no resolver, populated via cacheSet).
+const $226820b1648da9ad$var$REGISTRY = new Map();
+function $226820b1648da9ad$export$2b845901f37b4099(namespace, policy) {
+    $226820b1648da9ad$var$REGISTRY.set(namespace, policy);
+}
+function $226820b1648da9ad$export$d23e4dbc7b86eaca(namespace) {
+    return $226820b1648da9ad$var$REGISTRY.get(namespace) ?? {};
+}
+
+
+// cache-or-lookup core. jiti owns the orchestration — in-process L1, single-flight, negative
+// caching, TTL/immutability, read-through/write-through — and the per-namespace resolvers.
+// The consumer injects only durable storage (see createPostgresCacheStorage for a ready-made
+// Postgres adapter). With no storage available, callers simply don't invoke cacheGet.
+const $45fec2af5a17964d$var$L1_MAX = 50000;
+const $45fec2af5a17964d$var$L1 = new Map();
+function $45fec2af5a17964d$var$l1Get(id) {
+    const e = $45fec2af5a17964d$var$L1.get(id);
+    if (!e) return undefined;
+    if (e.expiresAt !== null && e.expiresAt <= Date.now()) {
+        $45fec2af5a17964d$var$L1.delete(id);
+        return undefined;
+    }
+    $45fec2af5a17964d$var$L1.delete(id);
+    $45fec2af5a17964d$var$L1.set(id, e); // bump recency
+    return e;
+}
+function $45fec2af5a17964d$var$l1Set(id, value, expiresAt) {
+    if ($45fec2af5a17964d$var$L1.size >= $45fec2af5a17964d$var$L1_MAX) {
+        const oldest = $45fec2af5a17964d$var$L1.keys().next().value;
+        if (oldest !== undefined) $45fec2af5a17964d$var$L1.delete(oldest);
+    }
+    $45fec2af5a17964d$var$L1.set(id, {
+        value: value,
+        expiresAt: expiresAt
+    });
+}
+const $45fec2af5a17964d$var$inflight = new Map();
+function $45fec2af5a17964d$var$cacheId(namespace, key) {
+    return `${namespace} ${key}`;
+}
+async function $45fec2af5a17964d$export$2aca74ef9665e35d(storage, namespace, key) {
+    const id = $45fec2af5a17964d$var$cacheId(namespace, key);
+    const l1 = $45fec2af5a17964d$var$l1Get(id);
+    if (l1) return l1.value;
+    const existing = $45fec2af5a17964d$var$inflight.get(id);
+    if (existing !== undefined) return existing;
+    const p = (async ()=>{
+        const row = await storage.get(namespace, key);
+        if (row && (row.expiresAt === null || row.expiresAt > Date.now())) {
+            const value = row.found ? row.value : null;
+            $45fec2af5a17964d$var$l1Set(id, value, row.expiresAt);
+            return value;
+        }
+        const policy = (0, $226820b1648da9ad$export$d23e4dbc7b86eaca)(namespace);
+        if (!policy.resolve) return null; // externally-populated namespace: miss ⇒ null (no write)
+        let resolved = null;
+        try {
+            resolved = await policy.resolve(key);
+        } catch  {
+            // Transient resolver failure (e.g. RPC) — do NOT cache so it retries next time.
+            return null;
+        }
+        const found = resolved !== null && resolved !== undefined;
+        const negativeTtl = policy.negativeTtlSeconds ?? 3600;
+        if (!found && negativeTtl === 0) return null; // negative caching disabled for this namespace
+        const ttlSeconds = found ? policy.ttlSeconds : negativeTtl;
+        const expiresAt = ttlSeconds === null || ttlSeconds === undefined ? null : Date.now() + ttlSeconds * 1000;
+        await storage.set(namespace, key, {
+            value: found ? resolved : null,
+            found: found,
+            expiresAt: expiresAt
+        });
+        $45fec2af5a17964d$var$l1Set(id, found ? resolved : null, expiresAt);
+        return found ? resolved : null;
+    })().finally(()=>$45fec2af5a17964d$var$inflight.delete(id));
+    $45fec2af5a17964d$var$inflight.set(id, p);
+    return p;
+}
+async function $45fec2af5a17964d$export$59c69e19e33761f6(storage, namespace, key, value, ttlSecondsOverride) {
+    const policy = (0, $226820b1648da9ad$export$d23e4dbc7b86eaca)(namespace);
+    const ttlSeconds = ttlSecondsOverride !== undefined ? ttlSecondsOverride : policy.ttlSeconds;
+    const expiresAt = ttlSeconds === null || ttlSeconds === undefined ? null : Date.now() + ttlSeconds * 1000;
+    await storage.set(namespace, key, {
+        value: value,
+        found: true,
+        expiresAt: expiresAt
+    });
+    $45fec2af5a17964d$var$l1Set($45fec2af5a17964d$var$cacheId(namespace, key), value, expiresAt);
+}
+
+
+
+const $b2a2726ff5c26695$export$a0a0f70252f1386f = "ton-jetton-wallet";
+const $b2a2726ff5c26695$var$ORBS_MANAGER_URL = "https://ton.access.orbs.network/mngr/nodes";
+const $b2a2726ff5c26695$var$ORBS_REFRESH_MS = 300000;
+let $b2a2726ff5c26695$var$orbsHosts = [];
+let $b2a2726ff5c26695$var$orbsRefreshedAt = 0;
+function $b2a2726ff5c26695$var$shuffled(hosts) {
+    const a = [
+        ...hosts
+    ];
+    for(let i = a.length - 1; i > 0; i--){
+        const j = Math.floor(Math.random() * (i + 1));
+        [a[i], a[j]] = [
+            a[j],
+            a[i]
+        ];
+    }
+    return a;
+}
+async function $b2a2726ff5c26695$var$getHosts() {
+    if ($b2a2726ff5c26695$var$orbsHosts.length && Date.now() - $b2a2726ff5c26695$var$orbsRefreshedAt < $b2a2726ff5c26695$var$ORBS_REFRESH_MS) return $b2a2726ff5c26695$var$shuffled($b2a2726ff5c26695$var$orbsHosts);
+    try {
+        const resp = await fetch($b2a2726ff5c26695$var$ORBS_MANAGER_URL, {
+            signal: AbortSignal.timeout(8000)
+        });
+        const nodes = await resp.json();
+        const healthy = nodes.filter((n)=>n.Healthy === "1" && n.Mngr?.health?.["v2-mainnet"]).map((n)=>`https://ton.access.orbs.network/${n.NodeId}/1/mainnet/toncenter-api-v2/jsonRPC`);
+        if (healthy.length) {
+            $b2a2726ff5c26695$var$orbsHosts = healthy;
+            $b2a2726ff5c26695$var$orbsRefreshedAt = Date.now();
+        }
+    } catch  {
+    // keep prior cached set
+    }
+    return $b2a2726ff5c26695$var$shuffled($b2a2726ff5c26695$var$orbsHosts);
+}
+function $b2a2726ff5c26695$export$938b62d04991c792(addr) {
+    try {
+        return (0, $8zHUo$toncore.Address).parse(addr).toString({
+            urlSafe: true,
+            bounceable: true,
+            testOnly: false
+        });
+    } catch  {
+        return addr;
+    }
+}
+function $b2a2726ff5c26695$var$parseAddressFromStackEntry(entry) {
+    // toncenter v2 runGetMethod returns slice/cell results as ['cell', { bytes: <base64 BoC> }].
+    const value = entry?.[1];
+    const b64 = typeof value === "string" ? value : value?.bytes;
+    if (!b64) return null;
+    return $b2a2726ff5c26695$export$938b62d04991c792((0, $8zHUo$toncore.Cell).fromBase64(b64).beginParse().loadAddress().toString());
+}
+async function $b2a2726ff5c26695$var$runGetMethod(host, address, method, stack) {
+    const resp = await fetch(host, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json"
+        },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "runGetMethod",
+            params: {
+                address: address,
+                method: method,
+                stack: stack
+            }
+        }),
+        signal: AbortSignal.timeout(15000)
+    });
+    const json = await resp.json();
+    if (!json.ok || !json.result) throw new Error(`TON runGetMethod ${method} error: ${json.error || "unknown"}`);
+    return {
+        exitCode: json.result.exit_code,
+        stack: json.result.stack
+    };
+}
+async function $b2a2726ff5c26695$export$cef9e9799d863462(wallet) {
+    const hosts = await $b2a2726ff5c26695$var$getHosts();
+    if (!hosts.length) throw new Error("TON: no Orbs hosts available for get_wallet_data");
+    let sawDefiniteMiss = false;
+    let lastErr;
+    for(let attempt = 0; attempt < 2; attempt++){
+        for (const host of hosts)try {
+            const { exitCode: exitCode, stack: stack } = await $b2a2726ff5c26695$var$runGetMethod(host, wallet, "get_wallet_data", []);
+            if (exitCode !== 0) {
+                sawDefiniteMiss = true; // no get_wallet_data → not a jetton wallet
+                continue;
+            }
+            const owner = $b2a2726ff5c26695$var$parseAddressFromStackEntry(stack[1]);
+            const master = $b2a2726ff5c26695$var$parseAddressFromStackEntry(stack[2]);
+            if (owner && master) return {
+                owner: owner,
+                master: master
+            };
+            sawDefiniteMiss = true;
+        } catch (e) {
+            lastErr = e;
+        }
+    }
+    if (sawDefiniteMiss) return null; // definitive: not a jetton wallet → negative-cache
+    throw new Error(`TON: get_wallet_data failed for ${wallet}: ${lastErr?.message}`); // transient → don't cache
+}
+async function $b2a2726ff5c26695$export$77ffdf974cb300ec(storage, wallet) {
+    return await (0, $45fec2af5a17964d$export$2aca74ef9665e35d)(storage, $b2a2726ff5c26695$export$a0a0f70252f1386f, $b2a2726ff5c26695$export$938b62d04991c792(wallet));
+}
+// Register on import: immutable mapping, resolve-on-miss via get_wallet_data; non-jetton
+// accounts negative-cached for a day.
+(0, $226820b1648da9ad$export$2b845901f37b4099)($b2a2726ff5c26695$export$a0a0f70252f1386f, {
+    resolve: (key)=>$b2a2726ff5c26695$export$cef9e9799d863462(key),
+    ttlSeconds: null,
+    negativeTtlSeconds: 86400
+});
+
+
+
 const $2e46ec862e47c14f$export$400f08bfae9ee97f = {
     match: (block)=>(0, $6bd2ca253e883278$export$ae001c77434c5340)(block) === "RIPPLE",
     transform (block) {
@@ -3533,65 +3855,150 @@ const $11a2c5b0fd56c033$export$bc6c7ab7e0727dd7 = {
 
 
 
+
+
+var $cd430dd11c31e572$require$Buffer = $8zHUo$buffer.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 $cd430dd11c31e572$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 $cd430dd11c31e572$var$decodeJettonInternalTransfer(body) {
+    if (!body) return null;
+    try {
+        const slice = (0, $8zHUo$toncore.Cell).fromBoc($cd430dd11c31e572$require$Buffer.from(body, "base64"))[0].beginParse();
+        if (slice.loadUint(32) !== $cd430dd11c31e572$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 $cd430dd11c31e572$export$608f3f42810b9879 = {
     match: (block)=>(0, $6bd2ca253e883278$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 = $cd430dd11c31e572$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
                 }
             ]
         }
@@ -3689,6 +4096,27 @@ const $7dd402f6ad0dab6a$var$UNIVERSAL_SUB_TEMPLATES = [
     (0, $f9ab50a3e879ac1c$export$b5fd4920e8b7d913),
     (0, $8deaea1ef39b6485$export$5beebc5708fabf3c)
 ];
+// Drops zero-amount + duplicate transfers and applies the optional contractAddress /
+// walletAddress / transactionHash param filters. Runs AFTER any jetton enrichment so the
+// filters see the resolved owner/master.
+function $7dd402f6ad0dab6a$var$applyTransferFilters(transfers, _ctx) {
+    const seenTransfers = new Set();
+    return transfers.filter((txfer)=>{
+        if (txfer.amount <= BigInt(0)) return false;
+        if (_ctx?.params) {
+            if (_ctx.params.contractAddress && _ctx.params.contractAddress !== txfer.token) return false;
+            if (_ctx.params.walletAddress && ![
+                txfer.from,
+                txfer.to
+            ].includes(_ctx.params.walletAddress)) return false;
+            if (_ctx.params.transactionHash && txfer.transactionHash !== _ctx.params.transactionHash) return false;
+        }
+        const key = `${txfer.transactionHash}-${txfer.from}-${txfer.to}-${txfer.amount}-${txfer.token}-${txfer.index}`;
+        if (seenTransfers.has(key)) return false;
+        seenTransfers.add(key);
+        return true;
+    });
+}
 const $7dd402f6ad0dab6a$var$tokenTransfersTemplate = {
     key: "token_transfers",
     name: "Token Transfers",
@@ -3741,23 +4169,27 @@ const $7dd402f6ad0dab6a$var$tokenTransfersTemplate = {
             transfers = sub.transform(block, _ctx);
             break;
         }
-        const seenTransfers = new Set();
-        transfers = transfers.filter((txfer)=>{
-            if (txfer.amount <= BigInt(0)) return false;
-            if (_ctx?.params) {
-                if (_ctx.params.contractAddress && _ctx.params.contractAddress !== txfer.token) return false;
-                if (_ctx.params.walletAddress && ![
-                    txfer.from,
-                    txfer.to
-                ].includes(_ctx.params.walletAddress)) return false;
-                if (_ctx.params.transactionHash && txfer.transactionHash !== _ctx.params.transactionHash) return false;
-            }
-            const key = `${txfer.transactionHash}-${txfer.from}-${txfer.to}-${txfer.amount}-${txfer.token}-${txfer.index}`;
-            if (seenTransfers.has(key)) return false;
-            seenTransfers.add(key);
-            return true;
-        });
-        return transfers;
+        // Optional enrichment for account-model token transfers (TON jettons) where the block
+        // only carries the token-WALLET address and no master: they come out as
+        // `tokenType: 'TOKEN'`, `to` = wallet, `token` = undefined. When the caller injects a
+        // `_ctx.cacheStorage` (durable cache), jiti resolves the wallet → { owner, master } via
+        // its own cache+RPC and rewrites `to`/`token` BEFORE filtering, so contractAddress /
+        // walletAddress filters match the real owner + master. jiti owns the cache + resolver
+        // (get_wallet_data over Orbs); the consumer injects only storage. Async only when storage
+        // is provided; the sync path is unchanged for every existing caller.
+        const cacheStorage = _ctx?.cacheStorage;
+        if (cacheStorage) return (async ()=>{
+            await Promise.all(transfers.map(async (txfer)=>{
+                if (txfer.tokenType !== "TOKEN" || txfer.token || !txfer.to) return;
+                const info = await (0, $b2a2726ff5c26695$export$77ffdf974cb300ec)(cacheStorage, txfer.to);
+                if (info) {
+                    txfer.to = info.owner;
+                    txfer.token = info.master;
+                }
+            }));
+            return $7dd402f6ad0dab6a$var$applyTransferFilters(transfers, _ctx);
+        })();
+        return $7dd402f6ad0dab6a$var$applyTransferFilters(transfers, _ctx);
     },
     tests: $7dd402f6ad0dab6a$var$SUB_TEMPLATES.concat($7dd402f6ad0dab6a$var$UNIVERSAL_SUB_TEMPLATES).map((v)=>v.tests).flat()
 };
@@ -11514,6 +11946,10 @@ $parcel$exportWildcard($b4b970cc11bce2a5$exports, $4828ba704a8a504f$exports);
 $parcel$exportWildcard($b4b970cc11bce2a5$exports, $4a8e5fd52443a474$exports);
 
 
+
+
+var $lCdWD = parcelRequire("lCdWD");
+
 const $882b6d93070905b3$export$eab97d15b1788b8d = {
     ...$d7167569386d0d4c$exports
 };