@indexing/jiti 0.1.12 → 0.1.14

package/dist/module.js

@@ -3,9 +3,14 @@ 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 $hgUW1$bs58 from "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,9 +28,106 @@ 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});
+      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("cP1H0", 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
+            ]);
+        }
+    };
+}
+
+});
+
 var $fde9406d76ec24a9$exports = {};
 var $82293038337e7b3f$exports = {};
 
@@ -1350,6 +1452,219 @@ const $548ae36ea3681b01$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 $caa0db003a346aa2$var$REGISTRY = new Map();
+function $caa0db003a346aa2$export$2b845901f37b4099(namespace, policy) {
+    $caa0db003a346aa2$var$REGISTRY.set(namespace, policy);
+}
+function $caa0db003a346aa2$export$d23e4dbc7b86eaca(namespace) {
+    return $caa0db003a346aa2$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 $692184cb0ed76c37$var$L1_MAX = 50000;
+const $692184cb0ed76c37$var$L1 = new Map();
+function $692184cb0ed76c37$var$l1Get(id) {
+    const e = $692184cb0ed76c37$var$L1.get(id);
+    if (!e) return undefined;
+    if (e.expiresAt !== null && e.expiresAt <= Date.now()) {
+        $692184cb0ed76c37$var$L1.delete(id);
+        return undefined;
+    }
+    $692184cb0ed76c37$var$L1.delete(id);
+    $692184cb0ed76c37$var$L1.set(id, e); // bump recency
+    return e;
+}
+function $692184cb0ed76c37$var$l1Set(id, value, expiresAt) {
+    if ($692184cb0ed76c37$var$L1.size >= $692184cb0ed76c37$var$L1_MAX) {
+        const oldest = $692184cb0ed76c37$var$L1.keys().next().value;
+        if (oldest !== undefined) $692184cb0ed76c37$var$L1.delete(oldest);
+    }
+    $692184cb0ed76c37$var$L1.set(id, {
+        value: value,
+        expiresAt: expiresAt
+    });
+}
+const $692184cb0ed76c37$var$inflight = new Map();
+function $692184cb0ed76c37$var$cacheId(namespace, key) {
+    return `${namespace} ${key}`;
+}
+async function $692184cb0ed76c37$export$2aca74ef9665e35d(storage, namespace, key) {
+    const id = $692184cb0ed76c37$var$cacheId(namespace, key);
+    const l1 = $692184cb0ed76c37$var$l1Get(id);
+    if (l1) return l1.value;
+    const existing = $692184cb0ed76c37$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;
+            $692184cb0ed76c37$var$l1Set(id, value, row.expiresAt);
+            return value;
+        }
+        const policy = (0, $caa0db003a346aa2$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
+        });
+        $692184cb0ed76c37$var$l1Set(id, found ? resolved : null, expiresAt);
+        return found ? resolved : null;
+    })().finally(()=>$692184cb0ed76c37$var$inflight.delete(id));
+    $692184cb0ed76c37$var$inflight.set(id, p);
+    return p;
+}
+async function $692184cb0ed76c37$export$59c69e19e33761f6(storage, namespace, key, value, ttlSecondsOverride) {
+    const policy = (0, $caa0db003a346aa2$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
+    });
+    $692184cb0ed76c37$var$l1Set($692184cb0ed76c37$var$cacheId(namespace, key), value, expiresAt);
+}
+
+
+
+const $cfe9a1176e32c0c3$export$a0a0f70252f1386f = "ton-jetton-wallet";
+const $cfe9a1176e32c0c3$var$ORBS_MANAGER_URL = "https://ton.access.orbs.network/mngr/nodes";
+const $cfe9a1176e32c0c3$var$ORBS_REFRESH_MS = 300000;
+let $cfe9a1176e32c0c3$var$orbsHosts = [];
+let $cfe9a1176e32c0c3$var$orbsRefreshedAt = 0;
+function $cfe9a1176e32c0c3$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 $cfe9a1176e32c0c3$var$getHosts() {
+    if ($cfe9a1176e32c0c3$var$orbsHosts.length && Date.now() - $cfe9a1176e32c0c3$var$orbsRefreshedAt < $cfe9a1176e32c0c3$var$ORBS_REFRESH_MS) return $cfe9a1176e32c0c3$var$shuffled($cfe9a1176e32c0c3$var$orbsHosts);
+    try {
+        const resp = await fetch($cfe9a1176e32c0c3$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) {
+            $cfe9a1176e32c0c3$var$orbsHosts = healthy;
+            $cfe9a1176e32c0c3$var$orbsRefreshedAt = Date.now();
+        }
+    } catch  {
+    // keep prior cached set
+    }
+    return $cfe9a1176e32c0c3$var$shuffled($cfe9a1176e32c0c3$var$orbsHosts);
+}
+function $cfe9a1176e32c0c3$export$938b62d04991c792(addr) {
+    try {
+        return (0, $hgUW1$Address).parse(addr).toString({
+            urlSafe: true,
+            bounceable: true,
+            testOnly: false
+        });
+    } catch  {
+        return addr;
+    }
+}
+function $cfe9a1176e32c0c3$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 $cfe9a1176e32c0c3$export$938b62d04991c792((0, $hgUW1$Cell).fromBase64(b64).beginParse().loadAddress().toString());
+}
+async function $cfe9a1176e32c0c3$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 $cfe9a1176e32c0c3$export$cef9e9799d863462(wallet) {
+    const hosts = await $cfe9a1176e32c0c3$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 $cfe9a1176e32c0c3$var$runGetMethod(host, wallet, "get_wallet_data", []);
+            if (exitCode !== 0) {
+                sawDefiniteMiss = true; // no get_wallet_data → not a jetton wallet
+                continue;
+            }
+            const owner = $cfe9a1176e32c0c3$var$parseAddressFromStackEntry(stack[1]);
+            const master = $cfe9a1176e32c0c3$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 $cfe9a1176e32c0c3$export$77ffdf974cb300ec(storage, wallet) {
+    return await (0, $692184cb0ed76c37$export$2aca74ef9665e35d)(storage, $cfe9a1176e32c0c3$export$a0a0f70252f1386f, $cfe9a1176e32c0c3$export$938b62d04991c792(wallet));
+}
+// Register on import: immutable mapping, resolve-on-miss via get_wallet_data; non-jetton
+// accounts negative-cached for a day.
+(0, $caa0db003a346aa2$export$2b845901f37b4099)($cfe9a1176e32c0c3$export$a0a0f70252f1386f, {
+    resolve: (key)=>$cfe9a1176e32c0c3$export$cef9e9799d863462(key),
+    ttlSeconds: null,
+    negativeTtlSeconds: 86400
+});
+
+
+
 const $07b3982e2fc4c8b2$export$400f08bfae9ee97f = {
     match: (block)=>(0, $09654dffcb68affa$export$ae001c77434c5340)(block) === "RIPPLE",
     transform (block) {
@@ -3524,65 +3839,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
                 }
             ]
         }
@@ -3680,6 +4080,27 @@ const $0ab1acc1eff391f6$var$UNIVERSAL_SUB_TEMPLATES = [
     (0, $8d6646508fb2fa58$export$b5fd4920e8b7d913),
     (0, $5ec62a2088d070a8$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 $0ab1acc1eff391f6$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 $0ab1acc1eff391f6$var$tokenTransfersTemplate = {
     key: "token_transfers",
     name: "Token Transfers",
@@ -3732,23 +4153,27 @@ const $0ab1acc1eff391f6$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, $cfe9a1176e32c0c3$export$77ffdf974cb300ec)(cacheStorage, txfer.to);
+                if (info) {
+                    txfer.to = info.owner;
+                    txfer.token = info.master;
+                }
+            }));
+            return $0ab1acc1eff391f6$var$applyTransferFilters(transfers, _ctx);
+        })();
+        return $0ab1acc1eff391f6$var$applyTransferFilters(transfers, _ctx);
     },
     tests: $0ab1acc1eff391f6$var$SUB_TEMPLATES.concat($0ab1acc1eff391f6$var$UNIVERSAL_SUB_TEMPLATES).map((v)=>v.tests).flat()
 };
@@ -11505,6 +11930,10 @@ $parcel$exportWildcard($a4e0e4b4a62175c4$exports, $f3761421850600fb$exports);
 $parcel$exportWildcard($a4e0e4b4a62175c4$exports, $e64a550a52a9d690$exports);
 
 
+
+
+var $cP1H0 = parcelRequire("cP1H0");
+
 const $149c1bd638913645$export$eab97d15b1788b8d = {
     ...$fde9406d76ec24a9$exports
 };
@@ -11519,5 +11948,6 @@ function $149c1bd638913645$export$a07bfd14bbc36e4b(key) {
 }
 
 
-export {$149c1bd638913645$export$eab97d15b1788b8d as utils, $149c1bd638913645$export$a8fc3402335b0b04 as templates, $149c1bd638913645$export$cceb5167b935aafb as getAllTemplates, $149c1bd638913645$export$a07bfd14bbc36e4b as getTemplateByKey};
+var createPostgresCacheStorage = parcelRequire("cP1H0").createPostgresCacheStorage;
+export {$149c1bd638913645$export$eab97d15b1788b8d as utils, $149c1bd638913645$export$a8fc3402335b0b04 as templates, $149c1bd638913645$export$cceb5167b935aafb as getAllTemplates, $149c1bd638913645$export$a07bfd14bbc36e4b as getTemplateByKey, $692184cb0ed76c37$export$2aca74ef9665e35d as cacheGet, $692184cb0ed76c37$export$59c69e19e33761f6 as cacheSet, $caa0db003a346aa2$export$2b845901f37b4099 as registerCacheNamespace, createPostgresCacheStorage as createPostgresCacheStorage, $cfe9a1176e32c0c3$export$77ffdf974cb300ec as lookupJettonWallet, $cfe9a1176e32c0c3$export$cef9e9799d863462 as resolveJettonWalletData, $cfe9a1176e32c0c3$export$a0a0f70252f1386f as TON_JETTON_NAMESPACE};
 //# sourceMappingURL=module.js.map