@indexing/jiti 0.1.13 → 0.1.14

package/dist/module.js

@@ -3,10 +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";
-import {Cell as $hgUW1$Cell} from "@ton/core";
 
 
+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)) {
@@ -24,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 = {};
 
@@ -1351,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) {
@@ -3766,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",
@@ -3818,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()
 };
@@ -11591,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
 };
@@ -11605,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