kira-wallet 0.1.13 → 0.1.14

package/curve_pricing.py

@@ -60,7 +60,9 @@ def enrich(snapshot,market,folder,deadline=None):
     networks=json.loads((h.ASSETS/'sources/rpc-candidates.json').read_text())
     input_path=folder/'reserve-graph-input.json'
     atomic(input_path,{'wallet':snapshot['wallet_address'],'tokens':snapshot['tokens'],'networks':networks,
-        'market_budget_ms':max(0,int((deadline-time.monotonic())*1000)) if deadline is not None else 180_000})
+        # Leave time for Node startup and the final atomic graph publication
+        # before the parent's hard stop. Completed checkpoints remain useful.
+        'market_budget_ms':max(0,int((deadline-time.monotonic()-1)*1000)) if deadline is not None else 180_000})
     run_node('reserves',input_path,folder/'reserve-graph.json',deadline=deadline)
     recorded=json.loads((folder/'reserve-graph.json').read_text());graph=recorded['tokens']
     if recorded.get('market_pending'):raise MarketPause('Reserve checks reached the market time budget. Resume saved checks in Activity.')

package/docs/ALCHEMY_SETUP.md

@@ -46,6 +46,13 @@ candidates. Reachable Mint Club registries are enumerated too. There is no
 128-candidate cutoff. Unsupported indexes, failed balances and missing prices
 or artwork remain unknown.
 
+Price responses also supply artwork by network and contract. Kira reuses that
+metadata instead of requiring another successful lookup for the same logo.
+Completed reserve-price paths remain usable when a bounded pass pauses;
+unfinished paths keep their original unknown state.
+Further reserve traversal focuses on funded curves whose USD price is still
+unknown. Bounded checks leave time to save their completed results.
+
 **Analyze sell routes** is optional. It uses the saved balances and their
 original blocks to estimate a representative sale or redemption. It is not
 required for tokens, prices or logos and does not expand the holdings inventory.
@@ -61,3 +68,11 @@ required for tokens, prices or logos and does not expand the holdings inventory.
 
 Kira makes requests locally through your account. Review Alchemy’s current
 [plans and limits](https://www.alchemy.com/docs/reference/pricing-plans).
+
+The research engine spaces its private Alchemy node reads at least 250 ms apart
+in one shared lane across Alchemy networks. An Alchemy throughput response cools
+that lane before queued reads can use another Alchemy host. Public and other
+custom RPC endpoints keep their existing pacing and fallback behavior. Canonical
+block checks and provider backoff still apply. This is a local scheduling policy,
+not a guarantee about an account's available capacity. Alchemy's
+[throughput allowance is shared across apps and chains](https://support.alchemy.com/articles/3788245542-is-alchemy-s-throughput-cu-s-limit-shared-across-all-apps-or-set-per-chain).

package/docs/RELEASE.md

@@ -79,7 +79,7 @@ The earlier unpublished 0.1.2 candidate is preserved in the ignored
 `dist/preserved-0.1.2-bad8f02/` directory. Use the current `dist/release.json`
 and its matching archive for publication; do not mix manifests from candidates.
 
-Keep published GitHub tags, release assets and npm versions through 0.1.12
+Keep published GitHub tags, release assets and npm versions through 0.1.13
 immutable. Do not rebuild them from later documentation commits. Future package
 changes need a new version. Release preparation does not publish a GitHub
 release, promote the website or publish to npm.
@@ -95,12 +95,12 @@ python3 scripts/prepare-release.py
 ```
 
 `prepare-release.py` scans the package boundary and creates
-`dist/kira-wallet-0.1.13.tgz`. The ignored `dist/release.json` records its source
+`dist/kira-wallet-0.1.14.tgz`. The ignored `dist/release.json` records its source
 commit, SHA-256 and member count. It never publishes. After reviewing that
 manifest, the operator's final command from the project root is:
 
 ```sh
-npm publish ./dist/kira-wallet-0.1.13.tgz --access public
+npm publish ./dist/kira-wallet-0.1.14.tgz --access public
 ```
 
 Use the operator's npm account and complete authentication or OTP personally.
@@ -299,7 +299,7 @@ commit and hashes belong in `dist/release.json`. Actual npm publication remains
 operator-only. Personal installations and paused automation are separate from
 release preparation.
 
-## Release candidate: 0.1.13
+## Published 0.1.13
 
 Version 0.1.13 requires a locally available Alchemy key reference before wallet
 research. `kira connect alchemy` accepts the key privately in an interactive
@@ -348,3 +348,47 @@ Prepare the final archive from the landed version PR. Freeze its source commit,
 SHA-256 and member hashes, then dry-run that exact archive. npm publication is
 operator-only. Do not upgrade the personal app, resume paused automation,
 publish a GitHub release or deploy the website during preparation.
+
+The operator published 0.1.13 on October 17, 2026. Its registry archive matched
+the frozen manifest and all 90 installed package members. The published archive
+remains immutable.
+
+## Release candidate: 0.1.14
+
+Version 0.1.14 includes merged PR33. Private Alchemy RPC requests use a shared
+250 ms lane across hosts, with cooldown after HTTP or JSON-RPC rate limits.
+Public RPC pacing, canonical-block checks, retries and fallback order remain.
+This removes the inherited two-second public-provider delay from private
+Alchemy reads without promising a fixed completion time.
+
+Artwork refreshes reuse safe chain-and-contract metadata already returned by
+DEX discovery. A separate provider failure preserves successful artwork, and
+canonical Base and Unichain USDC receive verified fallback images. Unknown
+tokens can still display initials when no supported image is available.
+
+Reserve pricing focuses on funded curves with missing USD quotes. Bounded
+lookups retain completed price paths and leave time to publish their partial
+graph before the parent deadline. Unfinished paths remain unknown. Existing
+thin-pool exclusions and portfolio total rules remain. Metadata passes preserve
+saved token quantities, blocks and observation times.
+
+PR33 acceptance compared 47 important token balances and eight native balances
+with explorer pages, including direct token-holder pages. A cold holdings run
+with the revised RPC pacing saved first evidence in 19.9 seconds and completed
+in 475.7 seconds. A separate live pass using the final metadata changes completed
+in 45.6 seconds over that wallet's own captured holdings, saved a partial reserve
+graph and preserved every quantity. These are individual observations under
+differing provider conditions. Exhaustive spam-token pricing or artwork coverage
+is outside this acceptance scope.
+
+Release preparation requires the full suite, a clean installation, tracked and
+history privacy scans, and comparison of every archive member with the landed
+source and isolated installation. Preserve strict history findings and assess
+only the exact authorized normal CLI merge metadata under the ruling above.
+Review not selected. The version PR changes only package metadata and release
+documentation; existing product acceptance applies to identical product bytes.
+
+Prepare and freeze the final archive from the landed version PR, then dry-run
+that exact archive. npm publication remains operator-only. Keep the personal
+0.1.13 installation, published archives and paused automation unchanged. This
+preparation does not publish a GitHub release or deploy the website.

package/onchain.cjs

@@ -10,7 +10,7 @@ const root=runtime.data_root;
 const networks=JSON.parse(fs.readFileSync(path.join(assets,'sources/rpc-candidates.json')));
 const bondAbi=JSON.parse(fs.readFileSync(path.join(assets,'sources/mintclub-bond-abi.json')));
 const {RpcPool,RouteRecorder}=require('./rpc-pool.cjs');
-const pool=new RpcPool({publicUrls:networks.flatMap(n=>n.public_rpc||[]),healthFile:runtime.health_file});
+const pool=new RpcPool({publicUrls:networks.flatMap(n=>n.public_rpc||[]),healthFile:runtime.health_file,alchemyInterval:250});
 function endpoints(chainId){return runtime.endpoints[String(chainId)] || [];}
 const endpointReads=new WeakMap();
 const endpointOutcomes=new WeakMap();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-wallet",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Manage your wallets with your own AI. Track tokens, research markets and refresh holdings in a local workspace.",
   "license": "MIT",
   "private": false,

package/rpc-pool.cjs

@@ -7,7 +7,7 @@ function classify(error) {
   let quotaCode=false;
   for (let e = error, depth = 0; e && depth < 10; e = e.cause, depth++) {
     const text = e.shortMessage || e.message || '';
-    if (e.status === 429 || /rate.?limit|too many requests|quota|backpressure|capacity exceeded/i.test(text)) return 'throttle';
+    if (e.status === 429 || e.code === 429 || /rate.?limit|too many requests|quota|backpressure|capacity exceeded/i.test(text)) return 'throttle';
     if (e.status === 413 || /(?:payload|batch|response|request body).*(?:large|size|exceed)|gas.*(?:cap|limit).*exceed/i.test(text)) return 'size';
     // viem wraps both quota and payload failures in generic -32005 errors.
     // Inspect the underlying cause before using that ambiguous code.
@@ -85,9 +85,10 @@ class RouteRecorder {
   snapshot(){return [...this.rows.values(),...this.overflow.values()].map(row=>({...row}));}
 }
 class RpcPool {
-  constructor({publicUrls = [], healthFile = null, interval = 2000, deadline = 12000, attemptTimeout = 4000, cooldown = 60000} = {}) {
+  constructor({publicUrls = [], healthFile = null, interval = 2000, alchemyInterval = null, deadline = 12000, attemptTimeout = 4000, cooldown = 60000} = {}) {
     this.publicUrls = new Set(publicUrls); this.healthFile = healthFile;
     this.interval = interval; this.deadline = deadline; this.attemptTimeout = attemptTimeout; this.cooldown = cooldown;
+    this.alchemyInterval = Number.isFinite(alchemyInterval) && alchemyInterval >= 0 ? alchemyInterval : null;
     this.states = new Map(); this.families = new Map(); this.pins = new Map(); this.pending = new Map(); this.cache = new Map();
     this.saved = {};
     try { if (healthFile && fs.statSync(healthFile).size <= 65536) {
@@ -104,11 +105,23 @@ class RpcPool {
       const id = crypto.createHash('sha256').update(key).digest('hex');
       const saved = this.saved[id] || {}, now = Date.now();
       const until = Number.isFinite(saved.until) && saved.until > now && saved.until <= now + 1800000 ? saved.until : 0;
-      let host; try { host = new URL(url).hostname; } catch { host = url; }
+      let host,alchemy=false;
+      try {
+        const parsed=new URL(url);host=parsed.hostname;
+        alchemy=this.alchemyInterval!==null && parsed.protocol==='https:' && !parsed.username && !parsed.password
+          && (!parsed.port||parsed.port==='443') && !parsed.search && !parsed.hash
+          && /^[a-z0-9-]+\.g\.alchemy\.com$/.test(host)
+          && /^\/v2\/[A-Za-z0-9_-]+\/?$/.test(parsed.pathname)
+          && !['demo','docs-demo'].includes(parsed.pathname.split('/')[2].toLowerCase());
+      } catch { host = url; }
       const publicEndpoint = this.publicUrls.has(url);
-      const family = publicEndpoint ? host.endsWith('publicnode.com') ? 'publicnode' : host.endsWith('drpc.org') ? 'drpc' : host.endsWith('1rpc.io') ? '1rpc' : host : host;
-      if (!this.families.has(family)) this.families.set(family, {gate:new Gate(), next:0});
-      this.states.set(key, {id, publicEndpoint, family, gate:new Gate(), until, strikes:until ? Math.min(Number(saved.strikes) || 1, 5) : 0,
+      alchemy=alchemy&&!publicEndpoint;
+      // Alchemy throughput is shared across chains and apps. One engine uses
+      // a shared paced lane; an account throttle cools that whole lane.
+      const family = alchemy ? 'provider:alchemy' : publicEndpoint ? host.endsWith('publicnode.com') ? 'publicnode' : host.endsWith('drpc.org') ? 'drpc' : host.endsWith('1rpc.io') ? '1rpc' : host : host;
+      const pacingInterval=alchemy?this.alchemyInterval:this.interval;
+      if (!this.families.has(family)) this.families.set(family, {gate:new Gate(), next:0, interval:pacingInterval, until:0});
+      this.states.set(key, {id, publicEndpoint, family, alchemy, interval:pacingInterval, gate:new Gate(), until, strikes:until ? Math.min(Number(saved.strikes) || 1, 5) : 0,
         methods:new Map(), verified:false, blocks:new Set(), inner:transport(url,{timeout:this.attemptTimeout,retryCount:0})(options)});
     }
     return this.states.get(key);
@@ -134,8 +147,10 @@ class RpcPool {
   async send(state, request, signal, timeout = this.attemptTimeout) {
     const family = this.families.get(state.family), release = await family.gate.acquire(signal);
     try {
+      if(family.until>Date.now())throw failure('Provider is cooling down.','RpcFamilyCooldown');
       await wait(family.next - Date.now(), signal);
-      family.next = Date.now() + this.interval;
+      if(family.until>Date.now())throw failure('Provider is cooling down.','RpcFamilyCooldown');
+      family.next = Date.now() + family.interval;
       const controller = new AbortController(), abort = () => controller.abort(signal.reason);
       signal.addEventListener('abort', abort, {once:true});
       const timer = setTimeout(() => controller.abort(failure('RPC read timed out.', 'TimeoutError')), timeout);
@@ -149,7 +164,7 @@ class RpcPool {
     for (const [index, url] of choices.entries()) {
       if (signal.aborted) throw signal.reason;
       const state = this.state(chain, url, transport, options);
-      if (state.until > Date.now() || (state.methods.get(request.method) || 0) > Date.now()) {onOutcome(index,{method:request.method,outcome:'skipped',reason:'cooldown'});last=state.error||last;continue;}
+      if (state.until > Date.now() || this.families.get(state.family).until > Date.now() || (state.methods.get(request.method) || 0) > Date.now()) {onOutcome(index,{method:request.method,outcome:'skipped',reason:'cooldown'});last=state.error||last;continue;}
       // An endpoint attempt includes its queue, cold verification and family pacing.
       // Public outages must leave time for the personal backup's actual read.
       const remaining=deadlineAt-Date.now();
@@ -158,8 +173,8 @@ class RpcPool {
       const qualification=Number(!state.verified)+Number(!!hash&&!state.blocks.has(tag));
       const timeout=attempts===0?this.attemptTimeout:Math.min(this.attemptTimeout,2000);
       const reserve=backupAhead?Math.min(this.deadline/2,2*this.interval+Math.min(this.attemptTimeout,2000)):0;
-      const budget=backupAhead?Math.max(1,Math.min(qualification*this.interval+timeout,remaining-reserve)):remaining;
-      if(backupAhead&&budget<=qualification*this.interval){onOutcome(index,{method:request.method,outcome:'skipped',reason:'qualification'});continue;}
+      const budget=backupAhead?Math.max(1,Math.min(qualification*state.interval+timeout,remaining-reserve)):remaining;
+      if(backupAhead&&budget<=qualification*state.interval){onOutcome(index,{method:request.method,outcome:'skipped',reason:'qualification'});continue;}
       const controller=new AbortController(), abort=()=>controller.abort(signal.reason);
       signal.addEventListener('abort',abort,{once:true});
       const timer=budget<remaining?setTimeout(()=>controller.abort(failure('Local RPC scheduling deadline reached.', 'RpcSchedulingTimeout')),budget):null;
@@ -168,7 +183,7 @@ class RpcPool {
       try {
         release=await state.gate.acquire(controller.signal);
         // A request ahead of us may have cooled this endpoint while we waited.
-        if (state.until > Date.now() || (state.methods.get(request.method) || 0) > Date.now()) {onOutcome(index,{method:request.method,outcome:'skipped',reason:'cooldown'});last=state.error||last;continue;}
+        if (state.until > Date.now() || this.families.get(state.family).until > Date.now() || (state.methods.get(request.method) || 0) > Date.now()) {onOutcome(index,{method:request.method,outcome:'skipped',reason:'cooldown'});last=state.error||last;continue;}
         if (++attempts > 4) break;
         attempted=true;
         phase='qualification';
@@ -199,6 +214,9 @@ class RpcPool {
         return result;
       } catch (error) {
         last = error;
+        if(error.name==='RpcFamilyCooldown'){
+          onOutcome(index,{method:request.method,outcome:'skipped',reason:'cooldown'});continue;
+        }
         if(signal.aborted||error.name==='RpcSchedulingTimeout'){
           onOutcome(index,{method:request.method,outcome:attempted?'local_timeout':'queue_timeout',reason:phase==='queue'?'queue':phase==='qualification'?'qualification':'local_deadline'});
           if(signal.aborted)throw signal.reason;
@@ -217,6 +235,7 @@ class RpcPool {
         else {
           state.strikes = Math.min(state.strikes + 1, 5);
           state.until = Date.now() + (kind === 'throttle' ? Math.max(retryAfter(error), Math.min(this.cooldown * 2 ** (state.strikes - 1), 1800000)) : 5000);
+          if(state.alchemy&&kind==='throttle')this.families.get(state.family).until=Math.max(this.families.get(state.family).until,state.until);
           state.verified = false; state.blocks.clear(); this.persist();
         }
       } finally { clearTimeout(timer);signal.removeEventListener('abort',abort);release?.(); }

package/viewer/refresh_prices.py

@@ -139,7 +139,7 @@ for w in selected:
   published[key]={**p,'retained_from_previous':True};retained+=1
  output['tokens']=list(published.values());output['retained_price_records']=retained
  if retained:output['note']+=f' {retained} token price references retain their earlier observation times because fresh USD was unavailable.'
- try:refresh_catalog([snapshot],h.ROOT,native_images=native_market['images'])
+ try:refresh_catalog([snapshot],h.ROOT,native_images=native_market['images'],market_metadata=fetched)
  except (OSError,ValueError):output['image_refresh_status']='unavailable'
  if os.environ.get('KIRA_JOB_SNAPSHOT'):
   from kira_jobs import atomic

package/viewer/token_images.py

@@ -21,8 +21,15 @@ DEX_CHAINS = {1:'ethereum', 8453:'base', 81457:'blast', 4663:'robinhood',
               10:'optimism', 42161:'arbitrum', 56:'bsc', 137:'polygon',
               43114:'avalanche', 130:'unichain', 33139:'apechain'}
 LP_CATALOG = 'https://lptoken.fun/api/markets?sort=volume&limit=100'
-# Contract-verified CoinGecko artwork fallback, checked 2026-10-05.
+# Contract-verified artwork fallback. Successful catalog metadata takes priority.
 KNOWN_TOKEN_ARTWORK = {
+    # Circle mainnet identities, checked 2026-10-17:
+    # https://developers.circle.com/stablecoins/usdc-contract-addresses
+    '8453:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913':
+        'https://static.alchemyapi.io/images/assets/3408.png',
+    '130:0x078d782b760474a361dda0af3839290b0ef57ad6':
+        'https://static.alchemyapi.io/images/assets/3408.png',
+    # CoinGecko Blast artwork, checked 2026-10-05.
     '81457:0xb1a5700fa2358173fe465e6ea4ff52e36e88e2ad':
         'https://coin-images.coingecko.com/coins/images/35494/small/Blast.jpg?1719385662',
     '81457:0x4300000000000000000000000000000000000003':
@@ -74,7 +81,12 @@ def image_for(catalog, chain_id, address=None, *, mint=False, native_symbol=None
         return chain_image(1 if native_symbol == 'ETH' else chain_id)
     row = catalog.get('tokens', {}).get(identity(chain_id, address)) or {}
     if mint:return safe_image(row.get('image_url')) or mint_logo(chain_id,address)
-    image = safe_image(row.get('image_url')) or KNOWN_TOKEN_ARTWORK.get(identity(chain_id,address))
+    image = safe_image(row.get('image_url'))
+    known = KNOWN_TOKEN_ARTWORK.get(identity(chain_id,address))
+    # Reserve catalogs can synthesize Hunt URLs even when no logo was supplied.
+    # A verified identity has a canonical fallback before that unverified URL.
+    if known and (not image or urlparse(image).hostname in ('fc.hunt.town','tokens.1inch.io')):
+        return known
     # Mint Club still returns legacy 1inch URLs that reject requests with HTTP 403.
     # Its Hunt token-image endpoint serves the same reserve contract's logo.
     if image and urlparse(image).hostname == 'tokens.1inch.io':
@@ -100,7 +112,7 @@ def checksum_addresses(addresses):
     except (OSError,ValueError,subprocess.SubprocessError):return {}
 
 
-def refresh_catalog(snapshots, root=ROOT, *, force=False, fetch=fetch_metadata, native_images=None):
+def refresh_catalog(snapshots, root=ROOT, *, force=False, fetch=fetch_metadata, native_images=None, market_metadata=()):
     """Share images by chain/address. Reuse successful metadata for 24 hours."""
     catalog = read_catalog(root)
     now = datetime.now(timezone.utc)
@@ -109,20 +121,46 @@ def refresh_catalog(snapshots, root=ROOT, *, force=False, fetch=fetch_metadata,
         try: return 0 <= (now - datetime.fromisoformat(raw)).total_seconds() < 86400
         except (ValueError, TypeError): return False
     records = catalog.setdefault('tokens', {})
+    wanted = {identity(t.get('chain_id'),t.get('token_address')):t
+              for snapshot in snapshots for t in snapshot.get('tokens',[])
+              if not t.get('mintclub') and identity(t.get('chain_id'),t.get('token_address'))}
+    # Price discovery already carries contract-scoped artwork. Keep that evidence
+    # before a second provider pass can exhaust the remaining metadata budget.
+    chains={slug:cid for cid,slug in DEX_CHAINS.items()}
+    for record in market_metadata:
+        if not isinstance(record,dict):continue
+        source=record.get('source')
+        try:
+            parsed=urlparse(source) if isinstance(source,str) else None
+            if not parsed or parsed.scheme!='https' or parsed.hostname!='api.dexscreener.com' or parsed.port not in (None,443) or parsed.username or parsed.password:continue
+        except ValueError:continue
+        response=record.get('response')
+        pairs=response if isinstance(response,list) else response.get('pairs',[]) if isinstance(response,dict) else []
+        for pair in pairs if isinstance(pairs,list) else []:
+            if not isinstance(pair,dict):continue
+            token=pair.get('baseToken') or {};info=pair.get('info') or {}
+            if not isinstance(token,dict) or not isinstance(info,dict):continue
+            slug=pair.get('chainId')
+            key=identity(chains.get(slug) if isinstance(slug,str) else None,token.get('address'))
+            image=safe_image(info.get('imageUrl'))
+            if key in wanted and image:
+                records[key]={'image_url':image,'source':source,'observed_at':record.get('observed_at') or observed}
     for snapshot in snapshots:
         for token in snapshot.get('tokens',[]):
             key=identity(token.get('chain_id'),token.get('token_address'))
             image=safe_image(token.get('indexer_image_url'))
             if key and image:records[key]={'image_url':image,'source':'Alchemy token metadata','observed_at':observed}
     artwork_checked=catalog.setdefault('artwork_checked',{})
-    wanted = {identity(t.get('chain_id'),t.get('token_address')):t
-              for snapshot in snapshots for t in snapshot.get('tokens',[])
-              if not t.get('mintclub') and identity(t.get('chain_id'),t.get('token_address'))}
     for asset,row in (native_images or {}).items():
         image = safe_image(row.get('image_url'))
         if image and asset in {value[1] for value in NATIVE_ASSETS.values()}:
             catalog.setdefault('native', {})[asset] = {**row, 'image_url': image}
     errors = 0
+    provider_fetch=fetch
+    def fetch(source):
+        # A failed optional source must not discard successful metadata above.
+        try:return provider_fetch(source)
+        except (OSError,ValueError):return None
     # lpTOKEN uses chain-specific imageUrl metadata, often from DEX Screener.
     # Read public catalog metadata without sending a wallet address.
     missing = {key:t for key,t in wanted.items()

package/wallet.py

@@ -431,6 +431,7 @@ def refresh_metadata(snapshot, market, folder, *, native_images=None, discover_p
         if mint and t['chain_id'] in mainnets:
             key=(t['chain_id'],mint['reserve_token'].lower())
             wanted.setdefault(key,{'chain_id':key[0],'token_address':key[1]})
+    metadata=read(folder/'token-market-metadata.json') if (folder/'token-market-metadata.json').exists() else []
     if discover_prices and wanted:
         event('dex_discovery',tokens=len(wanted))
         requests=[]
@@ -456,6 +457,7 @@ def refresh_metadata(snapshot, market, folder, *, native_images=None, discover_p
                     p=dex_price({'token_address':address,'dex_pools':group},record['observed_at'])
                     if p:rows[(cid,address)]={'chain_id':cid,'address':address,**p}
         atomic(folder/'token-market-metadata.json',evidence)
+        metadata=evidence
         for key,t in wanted.items():
             if key not in rows:
                 p=dex_price(t,None)
@@ -472,14 +474,24 @@ def refresh_metadata(snapshot, market, folder, *, native_images=None, discover_p
     for p in resolve(graph,list(rows.values())):rows[(p['chain_id'],p['address'].lower())]=p
     market={**market,'tokens':list(rows.values()),'markets':list(markets.values())}
     pricing_tokens=[t for t in tokens if t['chain_id'] in mainnets]
-    missing=any(t['mintclub'].get('funded') and rows.get((t['chain_id'],t['token_address'].lower()),{}).get('usd') is None for t in pricing_tokens if t.get('mintclub'))
+    missing=[t for t in pricing_tokens if t.get('mintclub') and t['mintclub'].get('funded')
+             and rows.get((t['chain_id'],t['token_address'].lower()),{}).get('usd') is None
+             and rows.get((t['chain_id'],t['token_address'].lower()),{}).get('quality') not in ('unfunded','unreliable')]
     if missing and time.monotonic()<price_deadline:
-        try:market=enrich({**snapshot,'tokens':pricing_tokens},market,folder,deadline=price_deadline)
-        except (MarketPause,OSError,ValueError):market['reserve_price_status']='partial'
+        try:market=enrich({**snapshot,'tokens':missing},market,folder,deadline=price_deadline)
+        except (MarketPause,OSError,ValueError):
+            market['reserve_price_status']='partial'
+            partial=folder/'reserve-graph.json'
+            if partial.exists():
+                try:
+                    for p in resolve(read(partial).get('tokens',[]),market['tokens']):
+                        rows[(p['chain_id'],p['address'].lower())]=p
+                    market['tokens']=list(rows.values())
+                except (OSError,ValueError):pass
     if tokens or native_images:
         try:
             event('token_images',tokens=len(tokens))
-            event('token_images',**refresh_catalog([snapshot],ROOT,native_images=native_images or {},fetch=lambda url:fetch(url,deadline=deadline)))
+            event('token_images',**refresh_catalog([snapshot],ROOT,native_images=native_images or {},market_metadata=metadata,fetch=lambda url:fetch(url,deadline=deadline)))
         except (OSError,ValueError):market['image_refresh_status']='unavailable'
     return market