@oracle-agent/oracle 0.24.1 → 0.24.2

package/dist/assets/skills/chain/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: chain
+description: "Use when the user types /chain or wants to list/select oracle working chains (hyperliquid, base, solana, bitcoin, ...)."
+version: 1.0.0
+disable-model-invocation: true
+---
+
+> Oracle native tools: `oracle_cli` (read/prepare), `vault_status`, `signer_status`, `signer_execute` (needs human confirmationNonce), `skill_load`. No generic shell. No fleet SSH.
+
+
+# /chain
+
+Run the local oracle chain selector. Do not invent chains.
+
+```bash
+# list
+oracle chain list
+
+# select build surface
+oracle chain use {{arg1}}
+
+# show / clear
+oracle chain show
+oracle chain clear
+```
+
+If `{{arg1}}` is empty, run `oracle chain list`.
+If `{{arg1}}` is `show`, `status`, `clear`, `list`, or a chain key, pass it through:
+
+```bash
+oracle chain {{arg1}} {{arg2}}
+```
+
+After selection, confirm active chain key + id + agent in lowercase.

package/dist/assets/skills/chain-defi-ecosystem-analysis/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: chain-defi-ecosystem-analysis
+description: "Size a chain's DeFi ecosystem, TVL, gaps, and build PMF."
+version: 1.0.0
+author: agent
+license: MIT
+platforms: [linux, macos, windows]
+metadata:
+  hermes:
+    tags: [defi, tvl, defillama, ecosystem, pmf, chain-research, morpho, perps]
+    related_skills: [evm-contract-research, oracle-desk, verification-gate, retrieval-first-answering]
+---
+
+> Oracle native tools: `oracle_cli` (read/prepare), `vault_status`, `signer_status`, `signer_execute` (needs human confirmationNonce), `skill_load`. No generic shell. No fleet SSH.
+
+
+# Chain DeFi Ecosystem Analysis
+
+Use when the question is about a **chain**, not a token or a contract:
+
+- "what DeFi protocols are on chain X" / "top TVL on X"
+- "which are native to X vs just deployed there"
+- "what's missing / where's the gap in X's ecosystem"
+- "is there product-market fit for building X on this chain"
+- "is this chain's TVL real or rented"
+
+Sibling lanes: contract/router/calldata work → `evm-contract-research`.
+Swap and bridge cost comparison → `oracle-desk`.
+
+## Non-negotiables
+
+1. **Every number comes from a live API pull this turn.** No memory, no search
+   snippets. Chain facts go stale in days on a young chain.
+2. **Reconcile sum-of-parts against the headline before publishing any table.**
+   If they disagree, you have a double-count and must explain it.
+3. **Falsify before you recommend.** A build recommendation you did not try to
+   kill is a guess with a table attached. See "The falsification pass".
+4. State confidence per claim: high / moderate / low / unknown. Separate
+   "the numbers" (usually high) from "the judgment" (usually moderate).
+
+## Workflow
+
+### 1. Chain totals first
+Establish the frame before naming a single protocol:
+
+| Metric | Endpoint |
+|---|---|
+| Chain TVL | `api.llama.fi/v2/chains` (match on `name`/`chainId`) |
+| TVL history | `api.llama.fi/v2/historicalChainTvl/<Chain%20Name>` |
+| DEX volume | `api.llama.fi/overview/dexs/<Chain%20Name>` |
+| Chain fees | `api.llama.fi/overview/fees/<Chain%20Name>` |
+| Stablecoins | `stablecoins.llama.fi/stablecoinchains` |
+
+**Fees are the strongest realness signal.** TVL can be farmed and volume can be
+wash-traded; fees paid are revealed willingness to pay. Also read fees for *who*
+earns them — a launchpad ranking #3 chain-wide tells you extraction, not utility,
+is the economy.
+
+**Always pull both TVL trend and volume trend.** TVL rising while volume falls is
+capital rotating in for yield, not users arriving. Reporting only the rising one is
+how a dying chain gets written up as growing.
+
+### 2. Protocol census + double-count reconciliation
+Pull `api.llama.fi/protocols` once (~8MB), filter in Python, never print raw.
+Select protocols whose `chainTvls` has a plain key for the chain (exclude
+`-borrowed`, `-staking`, `-pool2` suffixed keys).
+
+Then **reconcile**: sum of per-protocol TVL vs the chain headline. A large gap is
+normal and must be explained, not smoothed over. Curators, vault wrappers, yield
+frontends and capital allocators sit *on top of* a base venue and re-count the same
+deposits. DefiLlama does **not** reliably set the `doublecounted` flag, so infer the
+overlap from the gap and name the specific offenders.
+
+Recipe and reconciliation worked example: `references/defillama-chain-census.md`.
+Re-runnable: `scripts/chain-census.py "<Chain Name>"`.
+
+### 3. Native vs multichain split
+`len(protocol["chains"]) == 1` ⇒ built only for this chain. This one line separates
+"the chain has an ecosystem" from "the chain has deployments." Report both sums.
+A chain can hold hundreds of millions while its entire native builder scene is
+low-single-digit millions.
+
+### 4. Category gap diff
+Aggregate category → (TVL, count) for the target chain and for two mature
+comparators (Base, Arbitrum). Diff the category sets into three tables:
+**absent entirely**, **present but dead (<$100k)**, **healthy**.
+
+### 5. Concentration analysis on whichever number carries the thesis
+Never let a headline TVL number stand unexamined. For the dominant venue pull
+depositor/position distribution: holder counts, median position, top-1/5/10 share,
+and whether large holders are EOAs or contracts.
+
+Supply and borrow sides routinely have **opposite** distributions — a broad retail
+supply base with a handful of whales levered on top. Those imply different things
+about stickiness, so measure them separately.
+
+### 6. The falsification pass
+Before recommending anything be built, spend the tool calls to kill it:
+
+- Pull the **venue's own docs** for the mechanism you plan to exploit.
+- Pull **historical data** and test the effect empirically, split by the condition
+  you claim creates it.
+- If a market for your idea already exists, check whether it exists **and is empty**.
+
+Only then write the recommendation.
+
+## Pitfalls
+
+- **Sum of protocols ≠ chain TVL.** Curator / risk-manager / yield-wrapper /
+  capital-allocator rows re-count base-venue deposits. Never add a curator's TVL to
+  the venue it curates. Reconcile the delta out loud.
+- **"Absent category" and "built and rejected" are opposite conclusions.** An empty
+  category may be whitespace. A *deployed market sitting at near-zero* is a demand
+  refusal — capital looked and declined. Check which one you have before calling it
+  an opportunity; the second one means you must first solve why it was refused.
+- **Category false positives in any DefiLlama diff.** `CEX` is exchange
+  proof-of-reserve wallets, not deployable protocols — it is the single biggest
+  fake opportunity in a category diff. `Chain` and `Bug Bounty` are bookkeeping
+  rows. Strike them explicitly.
+- **Always compute top-2 concentration per category before calling it a market.**
+  A category can show large TVL and be one protocol's book; the real addressable
+  market is then ~1% of the headline.
+- **Protocol count is a mirage.** Count the long tail's combined TVL. Thirty DEXes
+  where three hold 92% is one DEX plus twenty-seven forks.
+- **Never call TVL "mercenary" without measuring it.** Distribution decides:
+  tens of thousands of holders with a four-figure median is retail and sticky;
+  ten addresses holding most of it is not. Check whether top holders are smart
+  accounts belonging to an app's wallet infrastructure — that is a distribution
+  asset, and often the most valuable thing on a young chain.
+- **Markets can exist and never launch.** Filter for zero price / zero volume before
+  quoting a venue's market count. "43 markets" including seven that never opened and
+  sixteen doing under $25k/day is a different venue than the headline.
+- **DefiLlama per-chain `overview/derivatives/<chain>` is paywalled** ("Upgrade to
+  the paid API plan") while `overview/dexs/` and `overview/fees/` are free. Use the
+  full URL-encoded chain name (`Robinhood%20Chain`), not a lowercase slug — a slug
+  returns the paywall string for every category and looks like a plan limit.
+- **Do not loop a public data API inside one Python process** when sweeping many
+  symbols; you get uniform errors for every symbol and it reads like the API is
+  down. Fetch with `curl` into files with a small sleep, then parse the files in a
+  separate pass. This turned 20 failures into 20 successes.
+
+## Venue docs discovery
+
+Modern docs sites (Mintlify and similar) publish a machine index and a markdown
+twin of every page. This is the fastest path to a venue's real API and mechanism
+docs:
+
+```
+curl -sL https://docs.<venue>/llms.txt        # full page index w/ descriptions
+grep -iE "funding|oracle|margin|liquidat" llms.txt
+curl -sL https://docs.<venue>/<path>.md       # markdown twin of a page
+```
+
+The bare HTML page URL may 404 while the `.md` twin returns 200. The `llms.txt`
+index also reveals REST/WS hostnames and endpoint paths without reverse-engineering
+JS bundles.
+
+## Reporting shape (DEMI)
+
+- Lead with the verdict or the number. Tables over paragraphs.
+- Give the de-duplicated view, not just the raw one — show what the chain
+  *actually* is once wrappers are collapsed.
+- Name what is dead: zero-TVL protocols, never-launched markets, empty categories.
+- Say plainly when your own earlier claim was overturned by new data, and why.
+- End with the risk that would flip the answer.
+
+## References
+
+- `references/defillama-chain-census.md` — endpoint map, Python filtering patterns,
+  double-count reconciliation worked example, category-diff false positives.
+- `references/morpho-blue-graphql.md` — Morpho Blue API schema quirks that cost
+  ~8 failed round trips: `vaults` vs `vaultV2s`, field-name traps, pagination.
+- `references/perp-venue-funding-regimes.md` — how to read a perp venue's funding
+  mechanism before trading it, incl. RWA off-hours rate locks and price bands, and
+  the worked falsification of a weekend-basis thesis.
+
+## Scripts
+
+- `scripts/chain-census.py` — re-runnable census: chain totals, protocol list,
+  native/multichain split, category rollup, and sum-vs-headline reconciliation.
+  `python3 scripts/chain-census.py "Robinhood Chain"`

package/dist/assets/skills/chain-ecosystem-gap-analysis/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: chain-ecosystem-gap-analysis
+description: Use when surveying a chain's protocols, gaps, or build PMF.
+---
+
+> Oracle native tools: `oracle_cli` (read/prepare), `vault_status`, `signer_status`, `signer_execute` (needs human confirmationNonce), `skill_load`. No generic shell. No fleet SSH.
+
+
+# Chain ecosystem and gap analysis
+
+Use when the question is about a **chain's whole landscape** rather than one contract or
+one trade: "what DeFi is on X", "what's the top TVL", "what's missing", "is there PMF for
+building Y here". For single-contract verification use `evm-contract-research`; for
+routing one trade use `oracle-desk`.
+
+The deliverable is a **decision**, not a protocol catalog. Most of the work is separating
+real capital from double-counted, rented, or fake-wide numbers, and then trying hard to
+disprove whatever build thesis emerges.
+
+## Step 1 — Chain-level totals from live APIs
+
+Pull these in parallel; each answers a different question.
+
+| Source | Endpoint | Answers |
+|---|---|---|
+| DefiLlama chains | `api.llama.fi/v2/chains` | headline chain TVL |
+| DefiLlama protocols | `api.llama.fi/protocols` (~8MB) | every protocol + `chainTvls` |
+| DefiLlama DEX overview | `api.llama.fi/overview/dexs/<Chain>` | volume, per-DEX and daily series |
+| DefiLlama fees | `api.llama.fi/overview/fees/<Chain>` | **real willingness to pay** |
+| Stablecoins | `stablecoins.llama.fi/stablecoinchains` | idle capital sitting on chain |
+
+Filter the 8MB protocol list **in Python**, never print it raw. Match chains by scanning
+each protocol's `chainTvls` for a key starting with the chain name, excluding the
+`-borrowed` / `-staking` / `-pool2` suffixed keys.
+
+Use the **URL-encoded display name** (`Robinhood%20Chain`), not a slug. Slugs return
+`Upgrade to the paid API plan`, which is a naming error, not a paywall — the
+derivatives-by-chain breakdown genuinely is paywalled, so report perps as TVL-only.
+
+**Fees are the strongest single signal.** TVL can be farmed and volume can be washed;
+fees are money users chose to hand over. A five-week-old chain doing $1.5M/day in fees is
+telling you something TVL cannot.
+
+## Step 2 — Correct the four ways TVL lies
+
+Do this before quoting any number to the user.
+
+1. **Curator double-counting.** Sum-of-protocols will exceed chain TVL. On RH 4663 the
+   parts summed to $784M against a $422M chain. The gap was Steakhouse Financial
+   ($331M, "Risk Curators") sitting *on top of* Morpho Blue's $318M — the same deposits
+   counted twice. DefiLlama does **not** always set the `doublecounted` flag. Treat
+   `Risk Curators`, `Liquidity Manager`, and `Onchain Capital Allocator` as re-counts of
+   an underlying venue, and reconcile sum-of-parts against the headline explicitly.
+2. **Category counts that are one incumbent.** "30 DEXes" was Uniswap at 92.6% and 27
+   others splitting $5.3M. "19 launchpads" was one at 98%. Always report the top-2
+   concentration share next to any category total.
+3. **Single-chain ≠ native.** Split protocols by `len(chains) == 1`. On RH, 52 protocols
+   were single-chain but two perp venues held 92% of that TVL; every other "native"
+   project combined was ~$2.7M. This is the difference between a real builder scene and
+   a wall of forks.
+4. **Rented vs sticky capital.** Query the dominant protocol's own API for market-level
+   detail. Uniform high LLTV plus ~90% utilization across a few stablecoin collaterals is
+   a **leveraged carry loop**, not organic demand — capital that leaves when an external
+   yield compresses.
+
+## Step 3 — Separate the supply side from the borrow side
+
+The single highest-value check, and the one that overturned a wrong conclusion this
+session. Concentration on one side says nothing about the other.
+
+On RH Morpho: **47,060 depositors**, median position $7,506, top-1 only 3.5%, and steakUSDG
+holders (46,856) ≈ USDG holders (46,828) — meaning essentially everyone holding the
+stablecoin had it in the vault. Every large holder was a `SemiModularAccount7702` contract,
+i.e. an EIP-7702 smart account = **the app's own retail wallet**. Meanwhile the borrow side
+was 542 positions with top-10 at 68.7% and two addresses holding $103M.
+
+Read: **retail supplies, a handful of whales lever.** Retail deposits are sticky (they are
+app users, not yield tourists); the leverage on top is not. Calling the whole stack
+"mercenary capital" was wrong.
+
+Method: pull vault positions with pagination (`positions(first:1000, skip:N)`), sort, and
+report top-1 / top-5 / top-N shares plus median — then cross-check depositor count against
+the underlying token's `holders_count` on the explorer. Identify what the top holders
+*are* (`implementations[]` on the address record names the contract).
+
+## Step 4 — Diff categories against mature L2s
+
+Aggregate category → (TVL, protocol count) for the target chain and for Base and Arbitrum,
+then bucket: **absent entirely**, **present but dead (<$100k)**, **healthy**.
+
+Two mandatory corrections:
+- **Strip false positives.** `CEX` is exchange proof-of-reserve wallets, not deployable
+  protocols; it will top any naive diff at >$1B. `Chain` and `Bug Bounty` are bookkeeping
+  rows. Exclude them and say why.
+- **Rank by concentration, not just size.** A category worth $100M where one protocol holds
+  100% is a ~$0 addressable market. A smaller category at 40% top-2 concentration is
+  genuinely competitive and a better target.
+
+"Present but dead" is often more informative than "absent" — it means someone tried and
+capital declined.
+
+## Step 5 — Try to KILL the thesis before recommending it
+
+This is the part that separates analysis from pitch. **Fetch the incumbent venue's actual
+docs and API and attempt to disprove your own idea.**
+
+A worked example from this session. Thesis: equity perps trade 24/7 while the underlying
+trades 6.5h/day, so weekend funding should dislocate — build a basis vault.
+
+- The venue's docs stated funding is **locked to a base rate (SOFR + 0.5%) when the
+  underlying is dark**, explicitly to remove weekend uncertainty.
+- Confirmed live: 20 of 28 RWA perps pinned to the byte-identical hourly rate.
+- Confirmed historically: 1,000 hourly points x 41.6 days showed dark-window mean funding
+  **below** lit-window on 2 of 3 names, with variance collapsing (stdev 0.85-5.28 dark vs
+  7.87-18.20 lit).
+
+The thesis was dead — the venue engineered the gap away by design. **Run a control**:
+crypto perps over the identical window varied normally, proving the flatness was a real
+regime and not an API artifact. A flat series with no control is indistinguishable from a
+broken query.
+
+Also check whether the "gap" is actually **built-and-rejected** rather than unbuilt. Equity
+collateral markets existed on Morpho and held $2,789 total against $315M of stablecoin
+collateral. That is not a hole to fill; it is a demonstrated capital-side refusal you would
+have to overturn. Those are very different difficulty levels and the distinction must reach
+the user.
+
+**Salvage the insight, change the instrument.** When a thesis dies, ask what *is* still true.
+Weekend volatility was real; only the funding channel was closed. That points at options
+(sell the gamma) rather than basis (harvest the funding) — same underlying observation,
+different product.
+
+## Step 6 — Report
+
+- Lead with the corrected, de-duplicated picture, not the raw table.
+- Show concentration next to every total.
+- State confidence separately for **data** (high, from live APIs) and **judgment**
+  (usually moderate — a 5-week-old chain cannot distinguish "wave dying" from
+  "post-launch normalization").
+- Name what would invalidate the read.
+- When you were wrong earlier in the session, say so plainly and show the number that
+  overturned it. Do not quietly revise.
+
+## Pitfalls
+
+- Trailing-volume trend matters more than the TVL snapshot. TVL at an all-time high while
+  volume is down 28% fortnight-over-fortnight is a stablecoin loop growing while users
+  leave, not adoption.
+- Count only markets with real state. Filter out zero-price / never-launched markets before
+  computing venue totals, and mention them separately as a signal.
+- A venue can be "an equities exchange" by market count and a crypto exchange by flow. RH's
+  Arcus had 34 of 43 markets in RWA but RWA was only 12.9% of volume.
+- Aggregate liquidity across many pools hides that most are dust. 226 equity pools, 194
+  under $50k. Report the count above a meaningful threshold, not the sum.
+- Verify subagent findings independently before folding them into a conclusion — and run a
+  control when a result looks suspiciously uniform.
+
+## References
+
+- `references/rh-4663-worked-example.md` — the full Robinhood Chain 4663 pass: corrected
+  TVL table, category diff vs Base/Arbitrum, the Morpho depositor-vs-borrower split, the
+  killed basis thesis with its control, and the Arcus API endpoint map.

package/dist/assets/skills/cross-chain-twap-execution/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: cross-chain-twap-execution
+description: Use when TWAPing token buys or sells across chains.
+created_by: agent
+---
+
+> Oracle native tools: `oracle_cli` (read/prepare), `vault_status`, `signer_status`, `signer_execute` (needs human confirmationNonce), `skill_load`. No generic shell. No fleet SSH.
+
+
+# Cross-chain TWAP execution
+
+Use when DEMI asks to TWAP buy, TWAP sell, ladder in/out, or chunk an order across one or more chains.
+
+## Core rule
+
+"TWAP anything across chains" means **any supported fungible asset with a live quoteable + executable route inside a bounded owner-approved order envelope**. It does **not** mean blind arbitrary-token authority or reusable scanner-wide trading permission.
+
+## Required order envelope
+
+Before live execution, require the exact:
+
+- side: `buy` / `sell`
+- token(s): contract + chain, or a precise portfolio slice
+- source wallet / signer lane
+- total size: raw amount, notional, or % balance
+- allowed source/destination chains
+- duration and interval/chunk count
+- max slippage cap and max price impact
+- max gas / bridge fee budget
+- min receive / limit-price guard
+- deadline
+- kill switch / cancel path
+
+`paper` and `prepare` can run without live authority. Live chunks require DEMI confirmation of this exact envelope.
+
+## Per-chunk loop
+
+Each chunk must repeat the full protection stack; do not reuse stale quote data from an earlier chunk.
+
+1. Resolve token + chain identity.
+2. Check balance, allowance, native gas, and venue support tier.
+3. Quote best route ranked **net of gas and fees**, not gross amount out.
+4. Split smaller or skip if price impact/liquidity is outside bounds.
+5. Re-quote immediately before prepare.
+6. Prepare exact artifact and simulate it when the path supports simulation.
+7. Execute only if quote age, min receive, slippage, gas, chain, destination, spender, and deadline still match the envelope.
+8. Record tx/order id, receipt status, balance delta, chunk price, cumulative average price, and remaining notional.
+9. Stop or pause on drift, failed simulation, missing allowance, missing gas, provider failure, bridge ambiguity, or DEMI cancel.
+
+## Cross-chain chunking
+
+- If funds must bridge before a swap, prove **every leg** quotes executable before firing leg 1.
+- Bridge destination native gas when the destination leg needs gas; token-only bridges can leave the executor unable to continue.
+- Track pending bridge state. Origin confirmation is not destination arrival.
+- Never double-send a pending bridge leg because the next chunk timer fired.
+- Multi-hop is allowed only when every hop has fresh quote/prepare support and a bounded failure plan.
+
+## Sell path
+
+Selling is stricter than buying because unsupported exits strand risk.
+
+- Run sellability / sell-sim first for illiquid, honeypot-prone, custom-router, or custom-pool tokens.
+- Unsupported exits are `blocked`, not guessed or routed through an unverified contract.
+- Custom pools may need a separate raw-pair or venue-native adapter; do not pretend a generic aggregator failure is a working sell route.
+
+## Asset boundaries
+
+This skill covers fungible token swaps/bridges. Do not reuse the same engine unchanged for:
+
+- NFTs / marketplace laddering
+- Bitcoin UTXOs, inscriptions, runes, rare sats
+- Solana/Jupiter transactions
+- Hyperliquid orders
+
+Those lanes can share the chunking concept but need their own signer, settlement, receipt, and asset-safety rules.
+
+## Reporting
+
+For every run or prepared schedule, report:
+
+- mode: `paper`, `prepare`, or `live`
+- envelope summary
+- chunks completed / pending / skipped / failed
+- realized average price and cumulative balance delta
+- hashes / order ids for completed chunks
+- current blocker or next scheduled chunk
+- confidence: high / moderate / low / unknown
+
+## Pitfalls
+
+- Treating a broad phrase like "anything" as reusable authority. It is a routing universe, not a signing grant.
+- Computing a TWAP schedule once and reusing stale quotes for every chunk.
+- Firing bridge leg 1 before proving leg 2 is executable.
+- Forgetting destination native gas after a token bridge.
+- Letting a timer continue after a failed chunk without checking why it failed.
+- Reporting a prepared chunk as executed. Prepared != signed != broadcast != filled.
+- Applying EVM fungible assumptions to NFTs, BTC inscriptions/runes, Solana, or venue orderbooks.
+
+## Related skills
+
+- `oracle-best-execution` — route ranking net of gas and fees. **Same-chain over-time swaps use Li.Fi directly** (`https://li.quest/v1/quote`, keyless, returns `transactionRequest` with calldata), not the public server's risk pipeline (which requires on-chain data probes — sellability/approval/liquidity — unsuitable for aggregator quotes). Cross-chain still uses `/public/convert`.
+- `multichain-exec-desk` — Oracle desk execution surfaces and provider guardrails.
+- `trade-loop-circuit-breaker` — live-money loop halts, caps, and deploy discipline.
+- `oracle-action-semantics` — watch / prepare / arm / sign / send vocabulary.
+
+## Oracle App over-time (primary surface)
+
+The live implementation ships in `~/projects/oracle-app/` with a full engine, durable store, background worker, and API routes. See `references/oracle-app-over-time.md` for architecture, endpoints, env vars, and desk API contract.
+
+Quick dev loop:
+```bash
+# Terminal 1: desk server (required for live quotes)
+cd ~/projects/multiagent-desk && node bin/oracle-public-server.mjs
+
+# Terminal 2: Oracle app dev server
+cd ~/projects/oracle-app && ORACLE_DESK_URL=http://127.0.0.1:8799 npm run dev
+
+# Test paper mode end-to-end:
+curl -X POST http://localhost:3000/api/oracle/over-time \
+  -H 'Content-Type: application/json' \
+  -d '{"side":"buy","mode":"paper","ownerAddress":"0x1111111111111111111111111111111111111111","chainId":"base","sellSymbol":"USDC","buySymbol":"ETH","totalAmount":"100","durationMs":120000,"chunkCount":4}'
+
+# Check activity + receipts:
+curl http://localhost:3000/api/oracle/over-time/activity?owner=0x1111111111111111111111111111111111111111
+```