@indexing/jiti 0.1.13 → 0.1.14

package/dist/main.js

@@ -3,9 +3,13 @@ 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$bs58 = require("bs58");
 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) {
@@ -24,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 = {};
 
@@ -1360,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) {
@@ -3775,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",
@@ -3827,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()
 };
@@ -11600,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
 };