Learn

Crypto Spot Research

Check asset identity, supply, protocol activity and the limits of on-chain observations.

78 guides

• Contract decoding: a matching selector is not a verified action

  Verify contract calldata with the block-specific implementation and ABI, then connect decoded names and events to actual economic state changes.

• State proofs: connect an account value to a trusted block root

  Build an account and storage proof packet anchored to a separately trusted block root, then distinguish cryptographic verification from economic interpretation.

• Active addresses: define the activity before counting

  Define qualifying actions, unique-address windows, campaign cohorts, and coverage before interpreting an active-address growth chart.

• Address labels: separate identity from observation

  Build an address-attribution record that separates technical observations, identity evidence, operational roles, and uncertain clusters across time.

• Airdrop claims: distinguish eligibility from distribution

  Reconcile airdrop leaves, eligible accounts, successful claims, actual token receipts and remaining allocations before interpreting campaign adoption.

• Token allowances: map delegated spending exposure

  Map token allowances as owner-token-spender permission edges, reconcile current balance bounds, and avoid double-counting overlapping authorizations.

• AMM reserves: distinguish recorded reserves from token balances

  Reconcile Uniswap v2 recorded reserves and token balances through direct transfers, skim and sync, with separate LP ownership and token-behavior checks.

• Bitcoin transfer volume: separate change from payments

  Reconcile bitcoin inputs, outputs, fees and candidate change before interpreting transfer volume as payments between economic owners.

• Coinbase maturity: separate issued from spendable bitcoin

  Build a block-height maturity schedule for Bitcoin coinbase reward outputs, distinguishing issued inventory from consensus-eligible spending.

• Coin age destroyed: old outputs do not prove old holders sold

  Reconstruct spent-output coin-days and test consolidation, change allocation and origin-history coverage before inferring holder selling.

• Wallet descriptors: reconcile derivation ranges before balances

  Reconcile descriptor branches, derivation ranges and rescan start times before treating a watch-only wallet balance as complete or spendable.

• Bitcoin hashrate: distinguish an estimate from difficulty

  Reproduce Bitcoin hashrate estimates from work and elapsed time, compare window sensitivity, and distinguish estimates from difficulty and hardware.

• Compact block filters: a match is a candidate, not a payment

  Audit compact-filter candidates through full-block inspection and filter-header trust, keeping candidate precision separate from a population false-positive rate.

• Bitcoin inclusion proofs: a confirmed transfer can already be spent

  Verify Bitcoin transaction inclusion and current output status separately, preserving block identity, mempool treatment and the evidence behind missing responses.

• Bitcoin timelocks: derive when a restricted spend is eligible

  Express Bitcoin absolute and relative timelocks as explicit validity predicates, combine their boundaries, and preserve clock and script requirements.

• Transaction identity: distinguish txid from the witness commitment

  Preserve base and witness serializations, map txid and wtxid to their commitments, and avoid treating a changed witness as a second valid payment.

• Small UTXOs: separate relay dust from economic spendability

  Compare small-output value with assumed marginal input fees while keeping Bitcoin Core v30.0 relay dust policy separate from consensus spendability.

• Blob costs: keep data gas separate from execution gas

  Separate blob gas and execution gas quantities, prices and batch allocations to explain rollup posting costs without mixing resource units.

• Bridged assets: trace the claim behind the token

  Map a bridged token to its origin asset, custody mechanism, verification dependencies, and return path before treating matching symbols as matching rights.

• Client diversity: measure shared failure dependencies

  Build a client dependency matrix that separates software bugs, shared infrastructure, unknown deployments, and changes in measurement methods.

• CREATE2 addresses: prefunding does not prove a deployed wallet

  Trace a CREATE2 address from factory, salt and initialization bytes, then distinguish prefunding from successful deployment and verified control.

• Crosschain supply: remove duplicated economic claims

  Consolidate origin assets, bridged representations, and receipt layers with a dependency graph that preserves gross balances and unresolved mismatches.

• Contract signatures: verify validity at the relevant state

  Verify ERC-1271 signatures against the relevant historical contract state, preserving the digest, signature bytes, return value and unresolved call failures.

• Decentralization claims: separate consensus from access

  Assess decentralization by function: reading state, submitting transactions, reaching finality, changing rules, and replacing access services.

• ENS research: verify resolved addresses at the observation time

  Trace ENS registry, resolver and record evidence at a specified block, verify reverse-forward matches, and keep names as dated address metadata.

• Data availability versus historical retrievability

  Distinguish data publication from historical retrieval by inventorying payloads, state, execution rules, archive copies, and reconstruction gaps.

• EOA delegation: follow code authority beyond one transaction

  Trace EIP-7702 authorization processing, persistent delegation and later clearing on an assumed enabled network, separately from application success.

• Exchange flows: what a transfer can actually establish

  Rebuild exchange flows within a documented address perimeter, distinguish internal transfers, and separate movement evidence from trading intentions.

• Frozen token balances: reconcile ownership with transfer access

  Reconcile blacklisted token balances with sender, recipient and spender checks, separating ledger ownership from the availability of a particular transfer route.

• Crosschain packets: prove completion, timeout or pending status

  Track IBC transport acknowledgements, ICS-20 application results and actual refunds separately, using pinned specifications and packet-level balances.

• Governance research: follow a proposal into execution

  Follow a governance proposal from discussion and voting through queueing, execution, and effective state, with a separate record of administrative powers.

• Holder concentration: adjust for custody and contracts

  Compare raw address concentration with documented custody and treasury adjustments while preserving uncertain ownership and denominator assumptions.

• Issuance and burn: build a net supply ledger

  Rebuild issuance, burn, and net supply between two blocks, test the removal mechanism, and keep historical examples separate from current observations.

• Lending utilization: separate demand from available cash

  Explain lending utilization by reconciling debt, cash, interest and denominator changes before interpreting demand or variable-rate exposure.

• L2 sequencer outages: distinguish delay from asset loss

  Trace an L2 outage through acknowledgment, inclusion, publication, settlement, and withdrawal instead of treating every delay as asset loss.

• Lending withdrawals: separate solvency from access

  Diagnose lending withdrawals through account claims, reserve cash, collateral eligibility and operational restrictions without conflating access and solvency.

• Lightning capacity: public channels do not reveal payment room

  Separate Lightning public channel capacity, directional balances and route bottlenecks before interpreting payment availability or network usage.

• Liquid staking exits: market sale versus protocol claim

  Compare liquid staking exits through market liquidity, underlying conversion, protocol claim stages and timing without treating a discount as guaranteed return.

• Mempool replacement: count spend attempts without double counting

  Group conflicting mempool attempts by spent outpoints, reconcile replacement versions to confirmation, and prevent double counting payment value.

• LP fees versus divergence loss: align the benchmark

  Compare LP fees and divergence loss using a matched holding benchmark, a constant-product example, and explicit cost and double-count checks.

• Liquidation dependencies: price input to debt recovery

  Map liquidation dependencies from consumed oracle inputs through thresholds, execution prerequisites and realized recovery for spot protocol research.

• Mining hashprice: rebuild revenue per unit of computing work

  Rebuild mining revenue per PH/s-day in bitcoin and reporting currency, then separate network hashprice from operator receipts and costs.

• Native asset flows: reconcile call traces with net balances

  Reconcile native asset call trees into committed address-level flows, excluding reverted descendants and separating execution fees from transferred value.

• MEV research: trace the user's execution outcome

  Audit MEV claims with actual user receipts, surrounding transactions, a defined counterfactual, and explicit limits on causal attribution.

• NFT metadata: separate token ownership from persistence

  Trace NFT persistence from tokenURI through metadata, media hosts and mutability controls while separating access from ownership and licenses.

• NFT owner counts: tokens, wallets and beneficial owners

  Interpret NFT owner counts by separating direct addresses, custody claims, operators and unknown beneficial-owner overlap at a fixed snapshot.

• Onchain data windows: blocks, finality, missing history

  Specify onchain block boundaries, query coverage, historical state, and revision rules so another researcher can reproduce the observation window.

• Oracle evidence: timestamp, pair, network, fallback

  Verify oracle pair identity, deployment, decimals, update time, and consumer behavior before using a feed observation in a research conclusion.

• Gas sponsorship: trace who funds the paymaster

  Reconcile paymaster deposits, top-ups, withdrawals and actual gas charges, then distinguish user subsidies, reimbursement and conditional funding runway.

• Signed permits: zero allowance does not prove zero authorization

  Distinguish current ERC-2612 allowances from known unsubmitted permits and signatures the chain cannot enumerate, using nonce, expiry and domain evidence.

• Protocol fees and revenue: follow the recipient

  Reconcile user fees with supplier payments, protocol receipts, expenses, and token-holder distributions using a recipient-based payment waterfall.

• Proof of reserves: test the missing liability denominator

  Distinguish customer inclusion from liability completeness, test negative-balance netting, and qualify reserve coverage by the examined population.

• Rebasing tokens: reconcile balances through shares

  Reconcile rebasing token balances through shares, conversion factors, event ordering and rounding, with a worked balance bridge.

• Protocol bad debt: map the loss allocation waterfall

  Map protocol bad debt from the relevant claim through realized recoveries, funded coverage, proposed support, and unresolved loss allocation.

• Failed transactions: measure gas spent per successful action

  Include reverted-transaction gas in cost per completed application action, align receipt and economic outcomes, and separate usage from gas prices.

• Forced exits: verify the path behind a rollup claim

  Verify forced-exit claims as a complete conditional path, including state data, proof construction, finalization, and destination execution.

• Security audits: compare the report with deployed code

  Compare a security report with deployed code through version, scope, configuration, findings, and dependencies instead of relying on audit badges.

• Staking losses: distinguish missed rewards from slashing

  Reconcile staking balances and opportunity shortfalls, distinguish ordinary penalties from slashing, and trace pool losses and later reimbursements.

• Replay domains: an address match does not bind a signed action

  Audit the replay domain of legacy transactions and permit messages separately, preserving chain identifiers, signed fields and verification context.

• Smart account activity: transactions are not users

  Count smart-account adoption across transactions, UserOperations, execution outcomes and distinct accounts without equating infrastructure with users.

• Solana balances: separate account deposits from transaction fees

  Reconcile Solana wallet movements into transaction fees, account storage deposits and closure refunds, with explicit authority and recoverability checks.

• Spot liquidity research: depth beyond headline TVL

  Examine spot liquidity with a timestamped size ladder, market identity, route coverage, and cost treatment rather than relying on headline TVL.

• Stablecoin reserves: read dates, scope, redemption

  Review stablecoin reserves through matched observation dates, report scope, asset categories, and holder-specific redemption conditions.

• Staking rewards: distinguish token income from dilution

  Separate gross staking rewards, charges, supply dilution, and access conditions using a token-unit ownership-share calculation.

• Taproot evidence: a visible key does not reveal every spend path

  Audit Taproot spending claims through revealed keys, scripts and control blocks while preserving the limits of evidence about hidden alternative paths.

• Token supply reconciliation: three different denominators

  Reconcile contract supply, circulating estimates, and future dilution using an address-level adjustment table with dates, exclusions, and unresolved differences.

• Token migrations: preserve an economic unit history

  Preserve token migration continuity with contract identities, conversion direction, completion status, and a worked redenomination ledger.

• Transfer taxes: reconcile sent and received token units

  Reconcile transfer-tax tokens through gross requests, per-hop debits, net receipts, deduction destinations, and version-specific compatibility.

• Crypto treasury runway: spendable assets and obligations

  Estimate treasury runway from accessible assets, known obligations, and defined operating outflows, with separate scenarios for own-token holdings.

• TWAP evidence: reconstruct the averaging rule behind the price

  Reconstruct Uniswap v3 price averages from cumulative ticks, exact windows and rounding rules, while checking history coverage and quote units.

• Token unlock research: schedule, claim, transfer

  Trace token allocations through scheduled release, claim eligibility, actual claims, and transfers without treating an unlock calendar as evidence of selling.

• Unlocks plus issuance: avoid counting supply twice

  Separate issuance from unlock reclassification with a dual-axis supply bridge that removes overlapping emission and vesting events.

• TVL research: separate deposits from asset prices

  Decompose TVL changes into asset quantities, prices, and coverage adjustments, then inspect receipt-token layers for duplicated economic claims.

• Contract upgrades: map who can change the rules

  Map proxy implementations, upgrade authority, controlling accounts, delays, and emergency permissions to test claims about immutable rules.

• Validator concentration: count control, not validator keys

  Measure validator control with effective stake weights, operator groupings, unknown attribution bounds, and a hypothetical regrouping worksheet.

• Validator withdrawals: verify the recipient beyond the fee address

  Match validator credentials, withdrawal indices and execution recipients, converting Gwei correctly and keeping fee addresses and request costs separate.

• Vault shares: compare conversions with withdrawable assets

  Distinguish vault share conversions, transaction previews, owner-specific limits and realized redemptions before calling represented assets liquid.

• Wrapped native assets: reconcile collateral and token units

  Compare wrapped-native collateral with independently reconstructed account claims, including the WETH9 totalSupply implementation and unmatched credits.