HALOWERK kettenwerk

Endpoints (24 live)

• POST /contract/verification — Checks one address on Ethereum, Base, Arbitrum, Optimism, Polygon or BNB Smart Chain against the open verification registry and against the chain itself. For a proxy the answer is deliberately split in two: whether the proxy is verified says almost nothing, whether the implementation it currently points to is verified is the real question, and both are reported separately with the implementation address read from the EIP-1967 storage slot, the EIP-1167 clone pattern or an implementation() call — (0.004 USDC on Base)
• POST /token/unlocks — Looks up a crypto asset by its exact NetSupply slug or an unambiguous symbol, then returns the scheduled releases inside a caller-selected window of up to 365 days. Unlock amounts remain decimal strings so large token quantities are not rounded. Each event states whether the schedule is enforced on-chain, how many lock objects it combines, when the promise was first recorded and how often it was revised. The percentage of float uses current circulating supply from CoinGecko, or a caller-supplied (0.008 USDC on Base)
• POST /graph/patterns — Analyzes only the transaction graph supplied in the request. It detects four mechanical graph patterns: directed rings, pass-through nodes that receive and send similar amounts within a configured time gap, star patterns around one high-degree node, and chain-like structuring where similar amounts move across several hops. Every pattern includes the edge ids that support it. The endpoint is stateless and deterministic, does not query blockchains or outside datasets, does not score people or wall (0.006 USDC on Base)
• POST /wallet/portfolio — Lists token and native balances of one wallet across chains and prices them where a price exists. priced_pct is mandatory and says how much of the portfolio is actually backed by a price - a total where a third of the holdings have none is not an answer without that number. Tokens that carry the marks of unsolicited airdrops are flagged with the reason but never silently removed; whether they count is the buyer decision. Holdings that cannot be priced appear in unknown_tokens with a reason inste (0.005 USDC on Base)
• POST /token/honeypot — Runs each step separately as a simulation (eth_call with state override) against the current chain state and reports each result on its own, so a token that can be received but not moved on is visible as exactly that. Nothing is ever executed: no transaction is broadcast, no key is held, no approval is given. Limits, and they are decisive: can_buy and can_sell through a DEX router are NOT simulated - that needs a funded account and a router path this service cannot back, so both stay null. What (0.01 USDC on Base)
• POST /wallet/pnl — Reads token movements of a wallet, prices every inflow and outflow at the time it happened, and derives cost basis, realised and unrealised profit or loss per asset. The method is stated because the result depends on it. Uncertainty is a mandatory field, not a footnote: an on-chain history knows nothing about deposits from exchanges, transfers between wallets of the same owner, or assets no price source covers. coverage_pct says which share of the movements carries a price; below sixty percent t (0.012 USDC on Base)
• POST /wallet/counterparties — Collects the addresses a wallet interacted with from its transactions and token transfers, counts the interactions per edge and names the type of each contract where it can be backed by a curated entry or a verified contract name. Depth is capped at two by design: anything deeper turns this into a tool for de-anonymisation, and that is not built here. Limits and the rule that matters: only contract designations and service types are reported. There is NO assignment to natural persons, no names, (0.01 USDC on Base)
• POST /token/restrictions — Scans the deployed bytecode for function selectors that grant control over trading, and reads the values that can be read directly. The decisive field is tax_modifiable: a tax of zero that the owner can raise to ninety-nine percent at any time is more dangerous than a fixed five percent, so the ability is reported, not just the current number. detection_method is given per field, because reading a selector out of bytecode is a different kind of evidence than calling the contract. Limits: current (0.008 USDC on Base)
• POST /wallet/balances — Reads token balances of one wallet on several chains from a public index and the native balance from the node itself. The same asset exists on several chains in different versions; canonical and bridged issues are reported separately and still summed, because both together are the answer. Every chain carries its block height, without which the sum cannot be checked. A chain that cannot be reached drops out with a reason under chains_failed and the call stays valid. Limits: the index exists for E (0.006 USDC on Base)
• POST /token/liquidity-ownership — Reads the holders of an LP token and splits them into burned, locked in a named locker, and free. Burned and locked are two different things and are reported separately - burned is gone for good, locked comes back. A locker contract that is not in the curated table yields is_locker "unbekannt" rather than false, because an unknown lock contract is not the same as a demonstrably free holder. Limits: earliest_unlock_ts is NOT read - the unlock time lives inside each locker contract in its own layo (0.006 USDC on Base)
• POST /wallet/allowances — Reads Approval events of one wallet from the chain, resolves the CURRENT allowance for every token and spender pair with a direct call, and weighs it against the balance actually held. An unlimited approval on an empty balance carries no risk and is reported as such. Every entry carries ready-made call data to revoke it - this service never signs and never sends anything, the caller decides. Limits: Approval events are read from a bounded block window, not from the whole chain history; the windo (0.004 USDC on Base)
• POST /bridge/track — Reads the source transaction on chain, identifies the bridge from the contracts it touched, and reports what actually left the wallet. overdue is measured against the usual duration of THAT bridge, and the comparison value is part of the answer - not against a fixed number. For bridges that need a manual claim, next_step says which step is missing and who has to trigger it; that is the real answer for a transfer that looks stuck. amount_delta shows what was deducted on the way, so a smaller arri (0.004 USDC on Base)
• POST /wallet/classify — Derives behaviour classes from on-chain activity: share of swaps, regularity of intervals, hour-of-day spread, counterparty count and contract code. Several classes at once are allowed and usually more accurate than one. Every class carries its evidence; without evidence no class is set. automation_likelihood comes from measurable traits - interval regularity and how evenly activity spreads over the day - listed in features_used, never from a hunch. Limits: this classifies BEHAVIOUR, not people. (0.006 USDC on Base)
• POST /wallet/activity — Reads the transaction history of one wallet from a public block explorer index and groups it by kind of action. Classification follows the called contract and method, never the amount - a transfer to a known router is a swap, not a payment. Anything that cannot be backed by a method name stays in the category "unbekannt", which is a valid answer here: a large honest remainder beats an invented assignment. Limits: history comes from a public index available for Ethereum, Base, Arbitrum and Optimi (0.005 USDC on Base)
• POST /token/holders — Reads the holder list of an ERC-20 token from a public block explorer index and reports concentration. Addresses that do not represent a person or entity - liquidity pools, bridges, burn addresses and exchange custody - are excluded from the adjusted figure and every exclusion is listed with its evidence. The raw top-10 share is reported alongside so both numbers can be compared. Labels are only set when they can be backed by on-chain code or a public tag; otherwise the label is "unbekannt". Lim (0.004 USDC on Base)
• POST /tx/status — Reads one transaction hash on Ethereum, Base, Arbitrum, Optimism, Polygon or BNB Smart Chain and answers the question an agent actually has: did it go through, is it final yet, and what did it cost. Finality is defined differently per chain, so the rule used and the required block count are part of the answer instead of a single hard-coded number. A hash that no node knows is reported as "unbekannt", never as "fehlgeschlagen" — the two are not the same. A pending transaction whose nonce has alre (0.002 USDC on Base)
• POST /chain/health — Queries every public RPC endpoint this hub knows for a chain in parallel — at least three, usually five — and reports what each one says instead of trusting one. Disagreement is the valuable finding: a single endpoint that lags or serves a different fork is exactly the failure mode this endpoint is built to expose, so agreement is reported per endpoint and the tolerance in blocks is derived from that chain's block time and stated. Beyond height it compares the actual block hash six blocks deep a (0.003 USDC on Base)
• POST /token/authorities — Reads the contract itself rather than a project's claims. Ownership renouncement is checked, not believed: the zero address in owner() is evidence, a sentence in a whitepaper is not. Dangerous functions are found by their four-byte selectors in the runtime bytecode, and every finding names the function and the selector — a selector that is merely absent from the dispatch table is not reported. Whether a function is actually restricted is then tested by simulating the call from a neutral address (0.005 USDC on Base)
• POST /contract/upgrade-risk — Upgradeability alone is not a finding — every serious protocol is upgradeable. The finding is who holds the key and how much warning holders get. This endpoint reads the proxy pattern from the EIP-1967 slots, the clone bytecode or an implementation() call, resolves the admin, checks whether that admin is a multisig by asking it for its threshold and signer count, and checks whether it is a timelock by asking for getMinDelay() or delay() — a timelock with a delay of zero is not a timelock and is (0.006 USDC on Base)
• POST /tx/decode — Turns opaque call data into something an agent can reason about before signing. The method signature is resolved from the verified source of the contract first, then from this hub's own list of common signatures, then from the open selector directory — and the answer always names which of the three was used, because a four-byte selector is short enough to collide and colliding entries are listed. An unknown selector stays unknown: parameters are returned raw and nothing is guessed. Approvals and (0.003 USDC on Base)

+4 more endpoints.