@indexing/jiti 0.1.12 → 0.1.14

package/dist/types.d.ts

@@ -2065,6 +2065,59 @@ export type NetworkTransfer = {
     transactionGasFee: bigint;
     transactionHash: string;
 };
+export type CacheRow = {
+    value: unknown | null;
+    found: boolean;
+    expiresAt: number | null;
+};
+export type CacheStorage = {
+    get: (namespace: string, key: string) => Promise<CacheRow | null>;
+    set: (namespace: string, key: string, row: CacheRow) => Promise<void>;
+};
+export type CacheResolver = (key: string) => Promise<unknown | null>;
+export type NamespacePolicy = {
+    resolve?: CacheResolver;
+    ttlSeconds?: number | null;
+    negativeTtlSeconds?: number;
+};
+export type JettonWalletData = {
+    owner: string;
+    master: string;
+};
+export function registerCacheNamespace(namespace: string, policy: NamespacePolicy): void;
+/**
+ * Read an enrichment value for (namespace, key) against the injected storage. On a miss, if
+ * the namespace has a registered resolver, resolve + write-through; otherwise return null
+ * (externally-populated namespaces). Returns null for negative hits; a resolver that throws
+ * (transient, e.g. RPC) is NOT cached so it retries next time.
+ */
+export function cacheGet(storage: CacheStorage, namespace: string, key: string): Promise<unknown | null>;
+/**
+ * Write an enrichment value out-of-band (for externally-populated namespaces like token-price
+ * / wallet-label, or to pre-seed a row). TTL comes from the namespace policy unless overridden.
+ */
+export function cacheSet(storage: CacheStorage, namespace: string, key: string, value: unknown, ttlSecondsOverride?: number | null): Promise<void>;
+export const TON_JETTON_NAMESPACE = "ton-jetton-wallet";
+/**
+ * Resolve a jetton wallet to its { owner, master }. Returns null if the account isn't a jetton
+ * wallet (definitive miss → negative-cached). Throws on transient RPC failure so the cache layer
+ * does NOT cache it (retries next time).
+ */
+export function resolveJettonWalletData(wallet: string): Promise<JettonWalletData | null>;
+/** Enrich a TON jetton wallet (any address form) → { owner, master } via the cache. */
+export function lookupJettonWallet(storage: CacheStorage, wallet: string): Promise<JettonWalletData | null>;
+type PgPool = {
+    query: (text: string, values?: unknown[]) => Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+};
+type PostgresCacheStorageOptions = {
+    connectionUri: string;
+    table?: string;
+    /** Provide your own pool/client (must have `.query(text, values)`) instead of a URI. */
+    pool?: PgPool;
+};
+export function createPostgresCacheStorage(opts: PostgresCacheStorageOptions): CacheStorage;
 export const utils: {
     blockToBeat(block: Record<string, unknown>): number;
     blockToTransactionHashes(block: Record<string, unknown>): string[];