@uniswap/client-data-api 0.0.224 → 0.0.226

package/dist/launches/v1/api_pb.d.ts

@@ -0,0 +1,1375 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Message, proto3 } from "@bufbuild/protobuf";
+import { Launch, LaunchesOrderBy, LaunchHolder, LaunchListFilter, Launchpad, TimestampedValue, TokenTrade } from "./types_pb.js";
+import { PageRequest, PageResponse } from "./common_pb.js";
+/**
+ * @generated from enum launches.v1.ActivityStatsWindow
+ */
+export declare enum ActivityStatsWindow {
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_5M = 1;
+     */
+    LAST_5M = 1,
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_1H = 2;
+     */
+    LAST_1H = 2,
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_6H = 3;
+     */
+    LAST_6H = 3,
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_24H = 4;
+     */
+    LAST_24H = 4,
+    /**
+     * Anchored at launch creation; for graduated CCA launches, at graduation
+     * (the auction's migration into its pool).
+     *
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_SINCE_LAUNCH = 5;
+     */
+    SINCE_LAUNCH = 5
+}
+/**
+ * @generated from message launches.v1.TokenIdentifier
+ */
+export declare class TokenIdentifier extends Message<TokenIdentifier> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * @generated from field: string address = 2;
+     */
+    address: string;
+    constructor(data?: PartialMessage<TokenIdentifier>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.TokenIdentifier";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenIdentifier;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenIdentifier;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenIdentifier;
+    static equals(a: TokenIdentifier | PlainMessage<TokenIdentifier> | undefined, b: TokenIdentifier | PlainMessage<TokenIdentifier> | undefined): boolean;
+}
+/**
+ * The launchpad registry, for building launchpad filters/labels client-side.
+ *
+ * @generated from message launches.v1.ListLaunchpadsRequest
+ */
+export declare class ListLaunchpadsRequest extends Message<ListLaunchpadsRequest> {
+    constructor(data?: PartialMessage<ListLaunchpadsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.ListLaunchpadsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListLaunchpadsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListLaunchpadsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListLaunchpadsRequest;
+    static equals(a: ListLaunchpadsRequest | PlainMessage<ListLaunchpadsRequest> | undefined, b: ListLaunchpadsRequest | PlainMessage<ListLaunchpadsRequest> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.ListLaunchpadsResponse
+ */
+export declare class ListLaunchpadsResponse extends Message<ListLaunchpadsResponse> {
+    /**
+     * @generated from field: repeated launches.v1.Launchpad launchpads = 1;
+     */
+    launchpads: Launchpad[];
+    constructor(data?: PartialMessage<ListLaunchpadsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.ListLaunchpadsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListLaunchpadsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListLaunchpadsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListLaunchpadsResponse;
+    static equals(a: ListLaunchpadsResponse | PlainMessage<ListLaunchpadsResponse> | undefined, b: ListLaunchpadsResponse | PlainMessage<ListLaunchpadsResponse> | undefined): boolean;
+}
+/**
+ * Token launches aggregated across launchpads, newest first by default
+ * (searched requests default to FDV instead — see sort_by and query). One
+ * entry per (token, launchpad) — the earliest pool wins when a launchpad
+ * creates several pools for the same token.
+ *
+ * @generated from message launches.v1.ListLaunchesRequest
+ */
+export declare class ListLaunchesRequest extends Message<ListLaunchesRequest> {
+    /**
+     * Deprecated: use launchpad_ids. When both are set they are unioned.
+     *
+     * @generated from field: optional string launchpad_id = 1 [deprecated = true];
+     * @deprecated
+     */
+    launchpadId?: string;
+    /**
+     * empty = all supported chains
+     *
+     * @generated from field: repeated uint32 chain_ids = 2;
+     */
+    chainIds: number[];
+    /**
+     * UNSPECIFIED resolves server-side: with a window -> VOLUME_1D, else with
+     * a query -> FDV descending (largest matches first, with the first page
+     * led by a small newest-first block of matches launched in the trailing
+     * hour so a just-launched token stays findable by its creator), else
+     * LAUNCHED_AT (newest first). An explicit value always wins.
+     *
+     * @generated from field: launches.v1.LaunchesOrderBy sort_by = 3;
+     */
+    sortBy: LaunchesOrderBy;
+    /**
+     * @generated from field: optional launches.v1.PageRequest page = 4;
+     */
+    page?: PageRequest;
+    /**
+     * Launchpads to serve. Empty = the server-side default scope (the
+     * listable set plus uniswap-cca), so clients don't have to pre-scope with
+     * ListLaunchpads. The Uniswap brand spans two ids behind one "Uniswap"
+     * filter — uniswap-bonding-curve (instant launches) and uniswap-cca (CCA
+     * crowd-launch auctions) — so an explicit filter naming either id expands
+     * to the full brand set (both ids); there is no mechanism-scoped opt-out.
+     * If a consumer ever needs one, the expansion moves client-side (the
+     * filter chip sends both ids itself).
+     *
+     * @generated from field: repeated string launchpad_ids = 5;
+     */
+    launchpadIds: string[];
+    /**
+     * launch-recency window
+     *
+     * @generated from field: optional launches.v1.LaunchListFilter filter = 6;
+     */
+    filter?: LaunchListFilter;
+    /**
+     * Sort direction for sort_by; false (default) = descending (highest first).
+     * Null/empty metric rows sort last in both directions.
+     *
+     * @generated from field: optional bool ascending = 7;
+     */
+    ascending?: boolean;
+    /**
+     * Launchpad search: keep only launches whose token name OR
+     * symbol starts with this string, compared case-insensitively (prefix
+     * match only — no fuzzy/substring matching). LIKE metacharacters in the
+     * query are treated literally. An EXPLICIT sort_by/ascending orders the
+     * filtered results exactly as it does the unfiltered list; with sort_by
+     * UNSPECIFIED a searched request ranks by FDV descending (see sort_by) so
+     * the launch a name is actually looking for outranks whatever launched
+     * since. Whitespace-only queries are treated as absent; input is trimmed,
+     * whitespace-collapsed, and capped at 100 characters server-side.
+     *
+     * @generated from field: optional string query = 8;
+     */
+    query?: string;
+    /**
+     * "My launches": keep only launches created by this wallet — the same
+     * address served as Launch.creator_address (launched_tokens.creator_wallet,
+     * the launch tx's from address). Any case is accepted; the server
+     * EIP-55-checksums it before comparing, and rejects a non-address with
+     * INVALID_ARGUMENT. Empty/absent applies no filter.
+     *
+     * Coverage is the Uniswap launchpads only (uniswap-cca crowd-launch
+     * auctions + uniswap-bonding-curve instant launches). Third-party-launchpad
+     * launches are served from a materialized table with no creator column and
+     * are dropped from a creator-filtered read — they carry no
+     * Launch.creator_address today either, so nothing filterable is lost.
+     *
+     * Not supported with sort_by = TRENDING: that ranking is built from a
+     * candidate scan with no creator column, so the combination is rejected
+     * rather than served unfiltered or silently re-sorted.
+     *
+     * @generated from field: optional string creator_address = 9;
+     */
+    creatorAddress?: string;
+    /**
+     * "Linked X": keep only launches that serve Launch.x_handle — i.e. whose
+     * creator-declared X handle passed its inline-at-ingest Ed25519
+     * verification (launched_tokens.x_handle_status = 'passed' with a
+     * non-empty handle). Exactly the rows the response decorates with
+     * x_handle, but filtered IN the ranked query before pagination, so the
+     * result is the top launches with a linked X across ALL launches — not a
+     * client-side pass over one pre-cut page. False/absent applies no filter.
+     *
+     * Coverage is the Uniswap launchpads only (uniswap-cca crowd-launch
+     * auctions + uniswap-bonding-curve instant launches): x_handle is only
+     * ever attested for factory launches, so third-party-launchpad launches —
+     * which never serve x_handle — are dropped from a filtered read and
+     * nothing filterable is lost.
+     *
+     * Not supported with sort_by = TRENDING: that ranking is built from a
+     * candidate scan with no X-handle column, so the combination is rejected
+     * with INVALID_ARGUMENT rather than served unfiltered or silently
+     * re-sorted. Composes with every other sort, VOLUME_1D included.
+     *
+     * @generated from field: optional bool linked_x_only = 10;
+     */
+    linkedXOnly?: boolean;
+    /**
+     * Launch lookup by token: keep only launches of these token addresses.
+     * Any casing is accepted (the server EIP-55-checksums and dedupes before
+     * comparing); a non-address entry fails the request with INVALID_ARGUMENT.
+     * Empty/absent applies no filter. At most 100 entries.
+     *
+     * Built for token pages resolving a launch by address — e.g. an instant
+     * launch that has aged off the newest-100 feed window — so it composes
+     * with launchpad_ids/chain_ids and serves the same row shape and stats
+     * sources as the unfiltered feed.
+     *
+     * Coverage is the Uniswap launchpads only (uniswap-cca crowd-launch
+     * auctions + uniswap-bonding-curve instant launches): neither
+     * third-party-launchpad read can express a token predicate, so that arm
+     * is dropped from a token-filtered read rather than served unfiltered.
+     * Not supported with sort_by = TRENDING (rejected), same contract as
+     * creator_address.
+     *
+     * CCA rows additionally inherit the crowd-launch feed's
+     * `is_quick_launch = true` gate; an unclassified or institutional
+     * auction will not match.
+     *
+     * @generated from field: repeated string token_addresses = 11;
+     */
+    tokenAddresses: string[];
+    constructor(data?: PartialMessage<ListLaunchesRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.ListLaunchesRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListLaunchesRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListLaunchesRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListLaunchesRequest;
+    static equals(a: ListLaunchesRequest | PlainMessage<ListLaunchesRequest> | undefined, b: ListLaunchesRequest | PlainMessage<ListLaunchesRequest> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.ListLaunchesResponse
+ */
+export declare class ListLaunchesResponse extends Message<ListLaunchesResponse> {
+    /**
+     * @generated from field: repeated launches.v1.Launch launches = 1;
+     */
+    launches: Launch[];
+    /**
+     * @generated from field: launches.v1.PageResponse page = 2;
+     */
+    page?: PageResponse;
+    constructor(data?: PartialMessage<ListLaunchesResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.ListLaunchesResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListLaunchesResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListLaunchesResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListLaunchesResponse;
+    static equals(a: ListLaunchesResponse | PlainMessage<ListLaunchesResponse> | undefined, b: ListLaunchesResponse | PlainMessage<ListLaunchesResponse> | undefined): boolean;
+}
+/**
+ * Holder data for ONE launch token (the TDP Holders module), computed at
+ * query time over the raw launch-transfers feed (ClickHouse,
+ * reorg-excluded) behind a short SWR cache. Only tokens created via the
+ * Uniswap token factory (CCA + bonding-curve launches) have transfer rows.
+ *
+ * @generated from message launches.v1.GetLaunchHoldersRequest
+ */
+export declare class GetLaunchHoldersRequest extends Message<GetLaunchHoldersRequest> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * @generated from field: string token_address = 2;
+     */
+    tokenAddress: string;
+    constructor(data?: PartialMessage<GetLaunchHoldersRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLaunchHoldersRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchHoldersRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchHoldersRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchHoldersRequest;
+    static equals(a: GetLaunchHoldersRequest | PlainMessage<GetLaunchHoldersRequest> | undefined, b: GetLaunchHoldersRequest | PlainMessage<GetLaunchHoldersRequest> | undefined): boolean;
+}
+/**
+ * Absence contract mirrors the Launch holder fields: when the token has no
+ * ingested transfers (non-factory token, ingestion lag, or every row
+ * reorged out) holders is empty and every optional field is unset, never a
+ * fake 0, so clients can tell no-data from a real zero. Upstream failures
+ * fail the RPC instead of serving empty.
+ *
+ * @generated from message launches.v1.GetLaunchHoldersResponse
+ */
+export declare class GetLaunchHoldersResponse extends Message<GetLaunchHoldersResponse> {
+    /**
+     * Top-100 holders by balance, descending. Raw Etherscan-style rows over
+     * net transfer balances, INCLUDING burned tokens: the 0x…dEaD burn sink
+     * appears while it holds a balance, and cumulative burns to the zero
+     * address appear as a synthetic zero-address row — so held + burned rows
+     * sum to minted_supply. Burn rows are flagged (is_burn_address); clients
+     * that want them out filter the flag.
+     *
+     * @generated from field: repeated launches.v1.LaunchHolder holders = 1;
+     */
+    holders: LaunchHolder[];
+    /**
+     * Exact holder count, same semantics as Launch.holder_count (addresses
+     * with a positive net balance; burn sinks like 0x…dEaD included while
+     * they hold a balance, the zero address never). The synthetic zero-address
+     * burn row is never counted.
+     *
+     * @generated from field: optional int32 holder_count = 2;
+     */
+    holderCount?: number;
+    /**
+     * holder_count minus the count as of 24h ago (signed).
+     *
+     * @generated from field: optional int32 holder_count_change_24h = 3;
+     */
+    holderCountChange24h?: number;
+    /**
+     * Trailing 7-day holder-count trend for the stat sparkline: one point per
+     * UTC-now-anchored 24h mark, oldest first, last point = holder_count now.
+     *
+     * @generated from field: repeated launches.v1.TimestampedValue holder_count_trend = 4;
+     */
+    holderCountTrend: TimestampedValue[];
+    /**
+     * Share of minted_supply held by the top 10 holder rows that are neither
+     * burn sinks nor the pool's custody row (LaunchHolder.is_pool_address),
+     * percent in [0, 100]. Burned tokens can never concentrate and the pool
+     * is the market itself, so both are excluded here (unlike the rows above).
+     *
+     * @generated from field: optional double top10_supply_pct = 5;
+     */
+    top10SupplyPct?: number;
+    /**
+     * Cumulative value ever minted, raw base units as a decimal string — the
+     * denominator of every supply_pct in this response. Burn-inclusive by
+     * construction: holder balances + burned rows sum to it. On-chain
+     * totalSupply-style circulating figures are client-derivable as
+     * minted_supply - burned_to_zero.
+     *
+     * @generated from field: optional string minted_supply = 6;
+     */
+    mintedSupply?: string;
+    /**
+     * Same definitions as Launch.burned_to_zero / burned_to_dead.
+     *
+     * @generated from field: optional string burned_to_zero = 7;
+     */
+    burnedToZero?: string;
+    /**
+     * @generated from field: optional string burned_to_dead = 8;
+     */
+    burnedToDead?: string;
+    constructor(data?: PartialMessage<GetLaunchHoldersResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLaunchHoldersResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchHoldersResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchHoldersResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchHoldersResponse;
+    static equals(a: GetLaunchHoldersResponse | PlainMessage<GetLaunchHoldersResponse> | undefined, b: GetLaunchHoldersResponse | PlainMessage<GetLaunchHoldersResponse> | undefined): boolean;
+}
+/**
+ * Server-computed per-window trade activity for a launch token (LP-1294):
+ * every window in one response, so the TDP Volume module's 5s poll is a
+ * single call instead of a client-side walk of GetTokenTrades. EVM-only.
+ * Served for tokens launched via the Uniswap token factory (CCA and
+ * bonding-curve launches); other tokens are a not_found error.
+ * CCA launches pre-graduation serve all-zero windows: bids are not trades,
+ * and the token does not swap until the auction migrates into its pool.
+ *
+ * @generated from message launches.v1.GetLaunchActivityStatsRequest
+ */
+export declare class GetLaunchActivityStatsRequest extends Message<GetLaunchActivityStatsRequest> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * @generated from field: string token_address = 2;
+     */
+    tokenAddress: string;
+    constructor(data?: PartialMessage<GetLaunchActivityStatsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLaunchActivityStatsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchActivityStatsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchActivityStatsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchActivityStatsRequest;
+    static equals(a: GetLaunchActivityStatsRequest | PlainMessage<GetLaunchActivityStatsRequest> | undefined, b: GetLaunchActivityStatsRequest | PlainMessage<GetLaunchActivityStatsRequest> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.GetLaunchActivityStatsResponse
+ */
+export declare class GetLaunchActivityStatsResponse extends Message<GetLaunchActivityStatsResponse> {
+    /**
+     * One entry per window, always all five, in enum order.
+     *
+     * @generated from field: repeated launches.v1.LaunchActivityStatsWindow windows = 1;
+     */
+    windows: LaunchActivityStatsWindow[];
+    constructor(data?: PartialMessage<GetLaunchActivityStatsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLaunchActivityStatsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchActivityStatsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchActivityStatsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchActivityStatsResponse;
+    static equals(a: GetLaunchActivityStatsResponse | PlainMessage<GetLaunchActivityStatsResponse> | undefined, b: GetLaunchActivityStatsResponse | PlainMessage<GetLaunchActivityStatsResponse> | undefined): boolean;
+}
+/**
+ * Trade activity over one trailing window, split by direction from the
+ * trader's perspective. Unique counts are per trading wallet (the tx
+ * from-address, not the router) and are HLL-approximate (<1% error). USD
+ * volume values each swap at its ASOF token price; swaps with no known
+ * price contribute to counts but not to USD volume.
+ *
+ * @generated from message launches.v1.LaunchActivityStatsWindow
+ */
+export declare class LaunchActivityStatsWindow extends Message<LaunchActivityStatsWindow> {
+    /**
+     * @generated from field: launches.v1.ActivityStatsWindow window = 1;
+     */
+    window: ActivityStatsWindow;
+    /**
+     * @generated from field: int32 buy_count = 2;
+     */
+    buyCount: number;
+    /**
+     * @generated from field: int32 sell_count = 3;
+     */
+    sellCount: number;
+    /**
+     * @generated from field: double buy_volume_usd = 4;
+     */
+    buyVolumeUsd: number;
+    /**
+     * @generated from field: double sell_volume_usd = 5;
+     */
+    sellVolumeUsd: number;
+    /**
+     * @generated from field: int32 unique_buyers = 6;
+     */
+    uniqueBuyers: number;
+    /**
+     * @generated from field: int32 unique_sellers = 7;
+     */
+    uniqueSellers: number;
+    constructor(data?: PartialMessage<LaunchActivityStatsWindow>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.LaunchActivityStatsWindow";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchActivityStatsWindow;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchActivityStatsWindow;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchActivityStatsWindow;
+    static equals(a: LaunchActivityStatsWindow | PlainMessage<LaunchActivityStatsWindow> | undefined, b: LaunchActivityStatsWindow | PlainMessage<LaunchActivityStatsWindow> | undefined): boolean;
+}
+/**
+ * Per-wallet CCA auction claim aggregates for a launch token (LP-1296):
+ * the cost-basis seed for Top Traders PnL. Serves CCA launches ONLY —
+ * tokens launched via a Uniswap CCA auction; bonding-curve launches and
+ * non-factory tokens are a not_found error (curve tokens have no claims:
+ * their cost basis is the swap history alone). EVM-only.
+ *
+ * @generated from message launches.v1.GetLaunchClaimsRequest
+ */
+export declare class GetLaunchClaimsRequest extends Message<GetLaunchClaimsRequest> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * @generated from field: string token_address = 2;
+     */
+    tokenAddress: string;
+    constructor(data?: PartialMessage<GetLaunchClaimsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLaunchClaimsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchClaimsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchClaimsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchClaimsRequest;
+    static equals(a: GetLaunchClaimsRequest | PlainMessage<GetLaunchClaimsRequest> | undefined, b: GetLaunchClaimsRequest | PlainMessage<GetLaunchClaimsRequest> | undefined): boolean;
+}
+/**
+ * One wallet's aggregate acquisition through the auction, folded across all
+ * of the wallet's bids (multiple bids per wallet are summed). Sourced from
+ * indexed bid terminal events, so bids exited post-auction with a partial
+ * fill are included — economically those tokens are auction acquisitions
+ * even when no explicit claim transaction exists.
+ *
+ * The client derives the wallet's TRUE unit cost as
+ * currency_spent / tokens_received. In a time-weighted CCA, bidders do NOT
+ * all pay the final clearing price (early accumulation is cheaper), so
+ * never seed cost basis from the auction-level clearing price when these
+ * rows are available.
+ *
+ * @generated from message launches.v1.LaunchClaim
+ */
+export declare class LaunchClaim extends Message<LaunchClaim> {
+    /**
+     * EIP-55 checksummed wallet address.
+     *
+     * @generated from field: string wallet = 1;
+     */
+    wallet: string;
+    /**
+     * Total launch tokens the wallet received from the auction, raw uint256
+     * decimal string in token base units.
+     *
+     * @generated from field: string tokens_received = 2;
+     */
+    tokensReceived: string;
+    /**
+     * What the wallet actually spent, NET of refunds, as a raw uint256
+     * decimal string in the auction's raise-currency base units (see
+     * GetAuction for the currency): sum over the wallet's terminal bids of
+     * (bid amount - exit refund).
+     *
+     * @generated from field: string currency_spent = 3;
+     */
+    currencySpent: string;
+    /**
+     * Number of the wallet's bids folded into this row (bids claimed or
+     * exited with a nonzero fill).
+     *
+     * @generated from field: int32 claim_count = 4;
+     */
+    claimCount: number;
+    /**
+     * True when every bid the wallet placed on this auction has reached a
+     * terminal state (claimed or exited); false while any bid is still
+     * pending, i.e. tokens_received may still grow.
+     *
+     * @generated from field: bool fully_claimed = 5;
+     */
+    fullyClaimed: boolean;
+    constructor(data?: PartialMessage<LaunchClaim>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.LaunchClaim";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchClaim;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchClaim;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchClaim;
+    static equals(a: LaunchClaim | PlainMessage<LaunchClaim> | undefined, b: LaunchClaim | PlainMessage<LaunchClaim> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.GetLaunchClaimsResponse
+ */
+export declare class GetLaunchClaimsResponse extends Message<GetLaunchClaimsResponse> {
+    /**
+     * One row per claiming wallet, ordered tokens_received DESC (wallet ASC
+     * tiebreak); empty when the auction has no terminal bids yet. Servers
+     * cap the list to the top wallets under that ordering (currently 1000),
+     * so the rows are the complete claimer set for any auction below the
+     * cap; total_claimed and unique_claimers ALWAYS cover every claimer,
+     * not just the returned rows.
+     *
+     * @generated from field: repeated launches.v1.LaunchClaim claims = 1;
+     */
+    claims: LaunchClaim[];
+    /**
+     * Total launch tokens received across ALL claiming wallets (the full
+     * population, even when claims is capped), raw uint256 decimal string
+     * in token base units.
+     *
+     * @generated from field: string total_claimed = 2;
+     */
+    totalClaimed: string;
+    /**
+     * Number of distinct claiming wallets in the full population (may
+     * exceed the number of rows in claims when the cap applies).
+     *
+     * @generated from field: int32 unique_claimers = 3;
+     */
+    uniqueClaimers: number;
+    constructor(data?: PartialMessage<GetLaunchClaimsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLaunchClaimsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchClaimsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchClaimsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchClaimsResponse;
+    static equals(a: GetLaunchClaimsResponse | PlainMessage<GetLaunchClaimsResponse> | undefined, b: GetLaunchClaimsResponse | PlainMessage<GetLaunchClaimsResponse> | undefined): boolean;
+}
+/**
+ * Creator-fee metrics for ONE Instant Launch token (LP-1332): the numbers
+ * behind the portfolio Fees panel — fees accumulated for the creator,
+ * claimable now, claimed to date, and auto-compounded back into the launch
+ * position. Computed from indexed FeeSplitter FeesCollected and claim
+ * recipient Claimed events with the launcher SDK's fee math, so the amounts
+ * match the on-chain per-position attribution exactly (per-collect
+ * multiply-before-divide flooring). Instant Launch tokens only: a token with
+ * neither indexed fee events nor a resolvable launch (CCA launches,
+ * non-factory tokens) is a not_found error. EVM-only.
+ *
+ * @generated from message launches.v1.GetLaunchCreatorFeesRequest
+ */
+export declare class GetLaunchCreatorFeesRequest extends Message<GetLaunchCreatorFeesRequest> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * The launched token's address (any casing).
+     *
+     * @generated from field: string token_address = 2;
+     */
+    tokenAddress: string;
+    constructor(data?: PartialMessage<GetLaunchCreatorFeesRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLaunchCreatorFeesRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchCreatorFeesRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesRequest;
+    static equals(a: GetLaunchCreatorFeesRequest | PlainMessage<GetLaunchCreatorFeesRequest> | undefined, b: GetLaunchCreatorFeesRequest | PlainMessage<GetLaunchCreatorFeesRequest> | undefined): boolean;
+}
+/**
+ * A native + launch-token amount pair, raw uint256 base units as decimal
+ * strings: native_amount in wei (the launch pool's currency0),
+ * token_amount in launch-token base units (currency1).
+ *
+ * @generated from message launches.v1.LaunchCreatorFeeAmounts
+ */
+export declare class LaunchCreatorFeeAmounts extends Message<LaunchCreatorFeeAmounts> {
+    /**
+     * @generated from field: string native_amount = 1;
+     */
+    nativeAmount: string;
+    /**
+     * @generated from field: string token_amount = 2;
+     */
+    tokenAmount: string;
+    constructor(data?: PartialMessage<LaunchCreatorFeeAmounts>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.LaunchCreatorFeeAmounts";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchCreatorFeeAmounts;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchCreatorFeeAmounts;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchCreatorFeeAmounts;
+    static equals(a: LaunchCreatorFeeAmounts | PlainMessage<LaunchCreatorFeeAmounts> | undefined, b: LaunchCreatorFeeAmounts | PlainMessage<LaunchCreatorFeeAmounts> | undefined): boolean;
+}
+/**
+ * The creator's own fee position — the ONLY amounts that belong to the
+ * creator. Grouped in their own message so no caller can read a
+ * protocol-custodied figure as part of the creator's total (see
+ * auto_compounded below). All three are POSITION-lifetime: the vault NFT is
+ * transferable, so they span every holder the position has had, not just the
+ * current beneficiary. When the launch settled into SEVERAL LP positions (a
+ * CCA/crowd-launch migration can mint more than one), all three aggregate
+ * across every position — claimable is clamped per position before summing.
+ *
+ * @generated from message launches.v1.CreatorFeeTotals
+ */
+export declare class CreatorFeeTotals extends Message<CreatorFeeTotals> {
+    /**
+     * The creator's share of all fees collected so far, floored per collect
+     * exactly as the FeeSplitter forwards it — equal to the beneficiary
+     * vault's cumulative on-chain attribution for the position.
+     *
+     * @generated from field: launches.v1.LaunchCreatorFeeAmounts accumulated = 1;
+     */
+    accumulated?: LaunchCreatorFeeAmounts;
+    /**
+     * Paid out by the beneficiary vault to date — across all holders of the
+     * transferable vault NFT (past holders' payouts are included).
+     *
+     * @generated from field: launches.v1.LaunchCreatorFeeAmounts claimed = 2;
+     */
+    claimed?: LaunchCreatorFeeAmounts;
+    /**
+     * accumulated − claimed, floored at zero per side: what a vault claim
+     * would pay right now (donations aside). Settles per-tokenId (the launch
+     * LP position), NOT per-beneficiary — whoever holds the vault NFT at
+     * claim time receives it.
+     *
+     * SETTLED-ONLY. Fees reach the beneficiary vault only when somebody calls
+     * the permissionless FeeSplitter.collectFees(tokenIds), so this
+     * UNDERSTATES the creator's earnings by everything the launch's Uniswap
+     * v4 position has accrued since the last collect. Its meaning is
+     * unchanged and will not change — see claimable_including_uncollected for
+     * the figure to show a creator as "your earnings".
+     *
+     * @generated from field: launches.v1.LaunchCreatorFeeAmounts claimable = 3;
+     */
+    claimable?: LaunchCreatorFeeAmounts;
+    /**
+     * `claimable` PLUS the creator's share of the fees still sitting
+     * uncollected in the launch's Uniswap v4 position: what a
+     * collectFees + claim sent right now would actually pay out.
+     *
+     * Computed by simulating FeeSplitter.collectFees(tokenIds) against the
+     * chain head (eth_simulateV1) and reading the beneficiary vault's
+     * amounts(tokenId) inside that same simulated state — no transaction is
+     * sent and no state is written. Aggregated across every LP position of
+     * the launch, exactly like `claimable`.
+     *
+     * Always populated: when the simulation cannot run (RPC error, or a
+     * collect that reverts) this degrades to the vault's settled on-chain
+     * balance, and finally to `claimable` itself, so a creator sees a
+     * slightly stale number rather than an error.
+     *
+     * Read claimable_includes_uncollected before deciding how to treat this.
+     *
+     * WHEN IT IS TRUE this is the post-collect figure: normally >=
+     * `claimable`, but it comes from chain state rather than indexed events,
+     * so it can also come in LOWER when the indexer is behind a claim that
+     * already landed. It is the authoritative figure in that case — do not
+     * max() the two.
+     *
+     * WHEN IT IS FALSE the collect could not be simulated and this degraded
+     * to a settled balance (or to `claimable` itself). It then carries no
+     * uncollected remainder and can only UNDERSTATE the creator's earnings,
+     * so max() with `claimable` is the right defence and the number must not
+     * be labelled "your earnings".
+     *
+     * @generated from field: launches.v1.LaunchCreatorFeeAmounts claimable_including_uncollected = 4;
+     */
+    claimableIncludingUncollected?: LaunchCreatorFeeAmounts;
+    constructor(data?: PartialMessage<CreatorFeeTotals>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.CreatorFeeTotals";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreatorFeeTotals;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreatorFeeTotals;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreatorFeeTotals;
+    static equals(a: CreatorFeeTotals | PlainMessage<CreatorFeeTotals> | undefined, b: CreatorFeeTotals | PlainMessage<CreatorFeeTotals> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.GetLaunchCreatorFeesResponse
+ */
+export declare class GetLaunchCreatorFeesResponse extends Message<GetLaunchCreatorFeesResponse> {
+    /**
+     * False for launches created through the fees-off strategy variant: every
+     * collected fee auto-compounds, so `creator` is all zeros and
+     * fee_beneficiary is never set. Distinguish this from "earned nothing
+     * yet" when rendering — they are different states.
+     *
+     * @generated from field: bool creator_fees_enabled = 1;
+     */
+    creatorFeesEnabled: boolean;
+    /**
+     * Everything the creator has earned, been paid, and can still claim.
+     *
+     * @generated from field: launches.v1.CreatorFeeTotals creator = 2;
+     */
+    creator?: CreatorFeeTotals;
+    /**
+     * NOT the creator's money, and NEVER additive with `creator`. Released to
+     * the CompoundingClaimRecipient, whose claims are enforced on-chain to
+     * increase the launch position's own liquidity in the same transaction, so
+     * it is protocol-custodied and the creator can never claim it.
+     *
+     * It is the COMPLEMENTARY leg of the very same collects that produced
+     * creator.accumulated — on the chain-4663 fees-on splitter the split is
+     * 40% creator / 60% compounded, verified exact against on-chain Claimed
+     * payouts. So creator.accumulated + auto_compounded is the position's whole
+     * fee revenue, i.e. 2.5x what the creator actually earned. Render it as
+     * pool growth if at all, never inside a creator earnings total.
+     *
+     * @generated from field: launches.v1.LaunchCreatorFeeAmounts auto_compounded = 3;
+     */
+    autoCompounded?: LaunchCreatorFeeAmounts;
+    /**
+     * The launch's v4 LP position id (uint256 decimal string) — the key the
+     * beneficiary vault settles claims on, so a client building a claim
+     * transaction needs it (it is not derivable client-side). Unset when the
+     * launch has neither a collect nor a vault mint yet, in which case there
+     * is nothing to claim. When a CCA/crowd-launch migration minted several
+     * positions, this is the EARLIEST-collecting one while the amounts
+     * aggregate all of them — a claim on it pays that position's share, not
+     * the whole claimable.
+     *
+     * @generated from field: optional string position_token_id = 4;
+     */
+    positionTokenId?: string;
+    /**
+     * Current beneficiary: the CREATOR'S WALLET (EIP-55) — the holder of the
+     * beneficiary ERC721 for the position_token_id position, who may claim
+     * and re-point the fee stream by transferring the NFT. This is NOT the
+     * vault contract; that is beneficiary_vault. Unset when creator fees are
+     * off, while vault ingestion lags (for a CCA launch: until the creator's
+     * graffiti claim mints the vault NFT), or transiently mid re-registration
+     * (NFT burned).
+     *
+     * @generated from field: optional string fee_beneficiary = 5;
+     */
+    feeBeneficiary?: string;
+    /**
+     * Freshness marker: unix seconds of the newest ingested event this
+     * response was computed from, across every feed read (fee collections,
+     * vault transfers, claims). 0 when no event has been ingested yet. A
+     * stalled sink freezes this value while on-chain fees keep accruing, so
+     * clients gating actions on creator.claimable (e.g. enabling a Claim
+     * button) should treat a stale marker as stale data.
+     *
+     * @generated from field: int64 as_of_timestamp = 6;
+     */
+    asOfTimestamp: bigint;
+    /**
+     * The launch's own FeeSplitter (EIP-55) — the contract to send the
+     * permissionless collectFees([position_token_id]) to, which sweeps the v4
+     * position's fees into the beneficiary vault and is what makes
+     * creator.claimable_including_uncollected actually claimable.
+     *
+     * PER LAUNCH, NOT A CHAIN CONSTANT: several FeeSplitter generations are
+     * deployed and live on the same chain (Robinhood Chain runs two), and a
+     * launch's fees only ever flow through the one its strategy was wired to.
+     * Clients MUST call the address in this field — a hardcoded per-chain
+     * splitter silently targets the wrong generation.
+     *
+     * Set for every launch this endpoint serves: where the indexed launch row
+     * carries no position recipient (a crowd launch, which never gets a row,
+     * or a row predating the column) the server falls back to the resolved
+     * strategy's own immutable FeeSplitter. Clients no longer need to gate the
+     * displayed figure down to the settled balance on an unset splitter.
+     *
+     * @generated from field: optional string fee_splitter = 7;
+     */
+    feeSplitter?: string;
+    /**
+     * The launch's own UERC20BeneficiaryVault (EIP-55) — the contract that
+     * custodies the creator's share and that claim(position_token_id, 0, 0)
+     * is sent to. Per launch for the same reason fee_splitter is.
+     *
+     * Read from fee_splitter's OWN on-chain splits, so this vault and that
+     * splitter are a matched pair by construction rather than two independent
+     * lookups that can name contracts from different generations. Falls back
+     * to the indexed beneficiary NFT when that read is unavailable. Unset only
+     * when creator fees are off (no vault exists) or neither source has one
+     * yet.
+     *
+     * @generated from field: optional string beneficiary_vault = 8;
+     */
+    beneficiaryVault?: string;
+    /**
+     * False when the collect could not be simulated and
+     * creator.claimable_including_uncollected is a settled balance (or the
+     * event-derived claimable) rather than the post-collect figure. Clients
+     * should not present it as "your earnings" when false.
+     *
+     * as_of_timestamp does NOT cover for this: that marker is computed from
+     * indexed events only, so it reads perfectly fresh during an RPC outage
+     * while the amount beside it has silently gone stale. This is the only
+     * signal that distinguishes the two.
+     *
+     * `optional` is load-bearing. A bare proto3 bool reads as false when
+     * absent, so a client built against <= 0.0.180 would see "degraded" on
+     * every response; the presence bit separates "this server does not send
+     * it" from "this response is degraded".
+     *
+     * @generated from field: optional bool claimable_includes_uncollected = 9;
+     */
+    claimableIncludesUncollected?: boolean;
+    constructor(data?: PartialMessage<GetLaunchCreatorFeesResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLaunchCreatorFeesResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchCreatorFeesResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesResponse;
+    static equals(a: GetLaunchCreatorFeesResponse | PlainMessage<GetLaunchCreatorFeesResponse> | undefined, b: GetLaunchCreatorFeesResponse | PlainMessage<GetLaunchCreatorFeesResponse> | undefined): boolean;
+}
+/**
+ * Anti-vamp create-flow check (LP-1311): has a token with this name + ticker
+ * combination launched on the chain within the trailing 8 hours? Matching is
+ * case-insensitive on both fields and covers every Uniswap token-factory
+ * launch (Crowd Launch and Instant Launch, created through our flow or
+ * directly against the contracts). The FE renders a soft warning ("this
+ * name + ticker launched X hours ago — here's that token") linking the
+ * original's token page; nothing is blocked server-side. Backed by the same
+ * table and predicate the indexer uses to vamp-flag copycat launches out of
+ * ListLaunches, so the warning and the listing filter cannot drift. EVM-only.
+ *
+ * @generated from message launches.v1.CheckLaunchNameTickerRequest
+ */
+export declare class CheckLaunchNameTickerRequest extends Message<CheckLaunchNameTickerRequest> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * Token name as entered in the create form (compared case-insensitively).
+     *
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    /**
+     * Token ticker/symbol as entered in the create form (compared
+     * case-insensitively).
+     *
+     * @generated from field: string symbol = 3;
+     */
+    symbol: string;
+    constructor(data?: PartialMessage<CheckLaunchNameTickerRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.CheckLaunchNameTickerRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CheckLaunchNameTickerRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CheckLaunchNameTickerRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CheckLaunchNameTickerRequest;
+    static equals(a: CheckLaunchNameTickerRequest | PlainMessage<CheckLaunchNameTickerRequest> | undefined, b: CheckLaunchNameTickerRequest | PlainMessage<CheckLaunchNameTickerRequest> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.CheckLaunchNameTickerResponse
+ */
+export declare class CheckLaunchNameTickerResponse extends Message<CheckLaunchNameTickerResponse> {
+    /**
+     * True when a matching token launched within the trailing 8h window —
+     * launching this name + ticker now would be vamp-flagged at ingest.
+     *
+     * @generated from field: bool recently_launched = 1;
+     */
+    recentlyLaunched: boolean;
+    /**
+     * The launch the warning should link to. Set iff recently_launched. When
+     * several launches match in the window (chained copycats), this is the
+     * earliest match that is not itself vamp-flagged, falling back to the
+     * earliest match.
+     *
+     * @generated from field: launches.v1.RecentlyLaunchedToken original_token = 2;
+     */
+    originalToken?: RecentlyLaunchedToken;
+    constructor(data?: PartialMessage<CheckLaunchNameTickerResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.CheckLaunchNameTickerResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CheckLaunchNameTickerResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CheckLaunchNameTickerResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CheckLaunchNameTickerResponse;
+    static equals(a: CheckLaunchNameTickerResponse | PlainMessage<CheckLaunchNameTickerResponse> | undefined, b: CheckLaunchNameTickerResponse | PlainMessage<CheckLaunchNameTickerResponse> | undefined): boolean;
+}
+/**
+ * The already-launched token a CheckLaunchNameTicker warning points at.
+ *
+ * @generated from message launches.v1.RecentlyLaunchedToken
+ */
+export declare class RecentlyLaunchedToken extends Message<RecentlyLaunchedToken> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * EIP-55 checksummed token address; with chain_id, enough to build the
+     * token-page link.
+     *
+     * @generated from field: string token_address = 2;
+     */
+    tokenAddress: string;
+    /**
+     * Stored name/symbol casing (the launched token's on-chain metadata).
+     *
+     * @generated from field: string name = 3;
+     */
+    name: string;
+    /**
+     * @generated from field: string symbol = 4;
+     */
+    symbol: string;
+    /**
+     * Unix seconds of the token's launch — the "launched X hours ago" the
+     * warning renders.
+     *
+     * @generated from field: int64 launched_at = 5;
+     */
+    launchedAt: bigint;
+    constructor(data?: PartialMessage<RecentlyLaunchedToken>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.RecentlyLaunchedToken";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RecentlyLaunchedToken;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RecentlyLaunchedToken;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RecentlyLaunchedToken;
+    static equals(a: RecentlyLaunchedToken | PlainMessage<RecentlyLaunchedToken> | undefined, b: RecentlyLaunchedToken | PlainMessage<RecentlyLaunchedToken> | undefined): boolean;
+}
+/**
+ * Total USD liquidity per token — the sum of the FULL (two-sided) TVL of every
+ * v2/v3/v4 pool the token sits in, which is the figure aggregators publish as a
+ * token's "liquidity". Batched on purpose: callers rendering a liquidity column
+ * must send the whole visible token set in one request rather than one request
+ * per row.
+ *
+ * @generated from message launches.v1.GetLiquidityForTokensRequest
+ */
+export declare class GetLiquidityForTokensRequest extends Message<GetLiquidityForTokensRequest> {
+    /**
+     * max 100
+     *
+     * @generated from field: repeated launches.v1.TokenIdentifier tokens = 1;
+     */
+    tokens: TokenIdentifier[];
+    constructor(data?: PartialMessage<GetLiquidityForTokensRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLiquidityForTokensRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLiquidityForTokensRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLiquidityForTokensRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLiquidityForTokensRequest;
+    static equals(a: GetLiquidityForTokensRequest | PlainMessage<GetLiquidityForTokensRequest> | undefined, b: GetLiquidityForTokensRequest | PlainMessage<GetLiquidityForTokensRequest> | undefined): boolean;
+}
+/**
+ * Best-effort response: one entry per requested token whose liquidity is known.
+ * A token with no pools, or whose pools have no computed TVL yet, is OMITTED
+ * rather than returned as 0 — so a caller can fall back to its own figure
+ * instead of rendering a wrong zero. Match entries back to the request by
+ * (chain_id, address).
+ *
+ * @generated from message launches.v1.GetLiquidityForTokensResponse
+ */
+export declare class GetLiquidityForTokensResponse extends Message<GetLiquidityForTokensResponse> {
+    /**
+     * @generated from field: repeated launches.v1.TokenLiquidity liquidity = 1;
+     */
+    liquidity: TokenLiquidity[];
+    constructor(data?: PartialMessage<GetLiquidityForTokensResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetLiquidityForTokensResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLiquidityForTokensResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLiquidityForTokensResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLiquidityForTokensResponse;
+    static equals(a: GetLiquidityForTokensResponse | PlainMessage<GetLiquidityForTokensResponse> | undefined, b: GetLiquidityForTokensResponse | PlainMessage<GetLiquidityForTokensResponse> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.TokenLiquidity
+ */
+export declare class TokenLiquidity extends Message<TokenLiquidity> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * EIP-55 checksummed token address, echoing the requested token.
+     *
+     * @generated from field: string address = 2;
+     */
+    address: string;
+    /**
+     * Summed pool TVL in USD. Always > 0 — see the omission rule above.
+     *
+     * @generated from field: double liquidity_usd = 3;
+     */
+    liquidityUsd: number;
+    constructor(data?: PartialMessage<TokenLiquidity>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.TokenLiquidity";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenLiquidity;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenLiquidity;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenLiquidity;
+    static equals(a: TokenLiquidity | PlainMessage<TokenLiquidity> | undefined, b: TokenLiquidity | PlainMessage<TokenLiquidity> | undefined): boolean;
+}
+/**
+ * Newest-first swap feed for a token, aggregated across ALL its pools
+ * (v2/v3/v4) on the chain. Non-swap events (mints/burns/liquidity) are
+ * excluded. Lookback is capped at 3 months. EVM-only.
+ *
+ * @generated from message launches.v1.GetTokenTradesRequest
+ */
+export declare class GetTokenTradesRequest extends Message<GetTokenTradesRequest> {
+    /**
+     * @generated from field: launches.v1.TokenIdentifier token = 1;
+     */
+    token?: TokenIdentifier;
+    /**
+     * page_size (default 25, max 100) + page_token
+     *
+     * @generated from field: optional launches.v1.PageRequest page = 2;
+     */
+    page?: PageRequest;
+    /**
+     * Restrict the feed to one trader: matches the trade's wallet (the tx
+     * sender, not the router). Any casing accepted. Omitted = all traders.
+     * page_token carries only a keyset position, not this filter — the client
+     * must resend the same wallet on every page; omitting or changing it
+     * resumes from that position under different filter semantics.
+     *
+     * @generated from field: optional string wallet = 3;
+     */
+    wallet?: string;
+    /**
+     * Minimum trade size: keep only trades whose amount_usd is >= this
+     * threshold. Trades with no known USD amount are excluded when set (they
+     * cannot be proven to clear the bar). Omitted or 0 = no filtering; negative
+     * or non-finite values are rejected. Applied before the page cut, so a page
+     * holds up to page_size MATCHING trades — but the server bounds how far it
+     * scans per request, so a page may come back short of page_size while
+     * next_page_token is still set; presence of next_page_token, not page
+     * fullness, signals more data under this filter. Deep scans also terminate
+     * after a bounded total: once a walk has scanned a server-defined number of
+     * rows (currently 5,000) the server stops issuing next_page_token and the
+     * feed ends early. Like wallet, page_token carries only the walk position —
+     * the client must resend the same min_amount_usd on every page.
+     *
+     * @generated from field: optional double min_amount_usd = 4;
+     */
+    minAmountUsd?: number;
+    constructor(data?: PartialMessage<GetTokenTradesRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetTokenTradesRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenTradesRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenTradesRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenTradesRequest;
+    static equals(a: GetTokenTradesRequest | PlainMessage<GetTokenTradesRequest> | undefined, b: GetTokenTradesRequest | PlainMessage<GetTokenTradesRequest> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.GetTokenTradesResponse
+ */
+export declare class GetTokenTradesResponse extends Message<GetTokenTradesResponse> {
+    /**
+     * @generated from field: repeated launches.v1.TokenTrade trades = 1;
+     */
+    trades: TokenTrade[];
+    /**
+     * next_page_token absent on last page
+     *
+     * @generated from field: launches.v1.PageResponse page = 2;
+     */
+    page?: PageResponse;
+    constructor(data?: PartialMessage<GetTokenTradesResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetTokenTradesResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenTradesResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenTradesResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenTradesResponse;
+    static equals(a: GetTokenTradesResponse | PlainMessage<GetTokenTradesResponse> | undefined, b: GetTokenTradesResponse | PlainMessage<GetTokenTradesResponse> | undefined): boolean;
+}
+/**
+ * Server-computed Top Traders leaderboard for a launch token: the token's
+ * FULL swap history (no page cap) folded into per-wallet cost-basis PnL,
+ * with CCA auction claims counted as buy-side acquisitions at what each
+ * wallet actually spent (the GetLaunchClaims aggregates). Replaces the
+ * client-side capped GetTokenTrades walk, whose 1,500-trade window
+ * fabricated zero-basis top rows for pre-window buyers. Non-launch tokens
+ * (no CCA auction) are served from their trade history alone — never an
+ * error; a token with no swaps and no claims serves an empty list. EVM-only.
+ *
+ * @generated from message launches.v1.GetTokenTopTradersRequest
+ */
+export declare class GetTokenTopTradersRequest extends Message<GetTokenTopTradersRequest> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * @generated from field: string token_address = 2;
+     */
+    tokenAddress: string;
+    /**
+     * Rows to return, best-ranked first. 0/unset defaults to 100; servers cap
+     * the limit (currently 1000).
+     *
+     * @generated from field: optional int32 limit = 3;
+     */
+    limit?: number;
+    /**
+     * Per-wallet lookup (LP-1558): serve only this wallet's row, covering ANY
+     * wallet in the token's history — the full cached ranking first, and past
+     * its cap the row comes from the same uncapped fold the ranking is cut
+     * from (server-cached per wallet). Unset/empty serves the ranked
+     * leaderboard as before. A wallet with no row (never traded or claimed
+     * the token) serves an empty list, never an error.
+     *
+     * @generated from field: optional string wallet_address = 4;
+     */
+    walletAddress?: string;
+    constructor(data?: PartialMessage<GetTokenTopTradersRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetTokenTopTradersRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenTopTradersRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenTopTradersRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenTopTradersRequest;
+    static equals(a: GetTokenTopTradersRequest | PlainMessage<GetTokenTopTradersRequest> | undefined, b: GetTokenTopTradersRequest | PlainMessage<GetTokenTopTradersRequest> | undefined): boolean;
+}
+/**
+ * One wallet's aggregate position on the token, derived from a
+ * moving-average cost-basis walk of its chronological trades: buys (and
+ * claim seeds) add to the position's basis; each sell realizes
+ * proceeds − average cost × amount AND consumes basis at the average cost,
+ * so re-entering wallets are accounted correctly. Auction claims are seeded
+ * before the trade walk as buys at the wallet's true auction cost, so
+ * bidders never show zero buys. Tokens sold beyond tracked inventory
+ * (transfers in) entered the wallet outside the swap tape — with the full
+ * history and explicit claims in hand, an unexplained inflow is a transfer,
+ * not a hidden buy — so the wallet's basis is UNKNOWN (not $0) and the row
+ * flags transferred_in.
+ *
+ * UNKNOWN-BASIS ROWS: when the server cannot compute a wallet's basis — the
+ * wallet transferred tokens in (transferred_in), its auction spend was not
+ * USD-convertible, or its attributed inventory contradicts its observed
+ * balance — basis_unknown is true and the four basis-derived
+ * money fields (cost_basis_usd, avg_cost_usd, realized_pnl_usd,
+ * unrealized_pnl_usd) are served as 0 and MUST be read as "unknown", never
+ * as a real $0.00. Such wallets rank strictly after every computable-PnL
+ * row — including loss-makers: an unknown 0 never outranks a real figure —
+ * so a transfer-in whale's raw proceeds can never crowd real traders out
+ * of the request limit. Observed figures (buys/sells/proceeds/tokens) are
+ * always set and always truthful. unrealized_pnl_unknown additionally
+ * covers the basis-known wallet whose unrealized leg alone is uncomputable
+ * (token has no spot price). (These are flags rather than proto3 `optional`
+ * on the money fields because changing an existing field's presence is a
+ * breaking gencode change for published clients.)
+ *
+ * @generated from message launches.v1.TokenTopTrader
+ */
+export declare class TokenTopTrader extends Message<TokenTopTrader> {
+    /**
+     * EIP-55 checksummed trading wallet (the tx from-address, not the router).
+     *
+     * @generated from field: string wallet_address = 1;
+     */
+    walletAddress: string;
+    /**
+     * Buy-side figures INCLUDE auction acquisitions: claims add one buy per
+     * terminal bid, their token amount, and their USD spend.
+     *
+     * @generated from field: int32 buy_count = 2;
+     */
+    buyCount: number;
+    /**
+     * @generated from field: int32 sell_count = 3;
+     */
+    sellCount: number;
+    /**
+     * @generated from field: double bought_usd = 4;
+     */
+    boughtUsd: number;
+    /**
+     * @generated from field: double sold_usd = 5;
+     */
+    soldUsd: number;
+    /**
+     * Token amounts are whole (decimal-adjusted) tokens.
+     *
+     * @generated from field: double bought_tokens = 6;
+     */
+    boughtTokens: number;
+    /**
+     * @generated from field: double sold_tokens = 7;
+     */
+    soldTokens: number;
+    /**
+     * Tokens still held. For launch tokens this is the wallet's OBSERVED net
+     * balance — the same sum over transfer logs GetLaunchHolders serves, so
+     * the two agree and Σ over wallets cannot exceed supply. Tokens outside
+     * that feed fall back to the swap walk (acquired minus sold, floored at
+     * 0), an attribution that can overstate a wallet signing swaps it does
+     * not receive (relayers, bundlers, smart-account signers).
+     *
+     * @generated from field: double remaining_tokens = 8;
+     */
+    remainingTokens: number;
+    /**
+     * USD cost basis of the REMAINING position: grows with buys/claims,
+     * shrinks by average cost × amount on every sell. Meaningless (served 0)
+     * when basis_unknown — read that as "unknown", not a zero basis.
+     *
+     * @generated from field: double cost_basis_usd = 9;
+     */
+    costBasisUsd: number;
+    /**
+     * cost_basis_usd ÷ the TRACKED quantity the basis was accumulated over
+     * (bought + claimed − sold), which is not necessarily remaining_tokens; 0
+     * when nothing is tracked. Meaningless (served 0) when basis_unknown.
+     *
+     * @generated from field: double avg_cost_usd = 10;
+     */
+    avgCostUsd: number;
+    /**
+     * Meaningless (served 0) when basis_unknown — proceeds booked against an
+     * unknowable basis are not a PnL; such rows rank as realized 0.
+     *
+     * @generated from field: double realized_pnl_usd = 11;
+     */
+    realizedPnlUsd: number;
+    /**
+     * USD the wallet spent in the launch auction (net of exit refunds),
+     * converted at the auction currency's USD rate. 0 when the wallet has no
+     * claims (always 0 for non-CCA tokens).
+     *
+     * @generated from field: double auction_spent_usd = 12;
+     */
+    auctionSpentUsd: number;
+    /**
+     * True when any of the wallet's auction bids reached a terminal state
+     * (claimed, or exited with a nonzero fill).
+     *
+     * @generated from field: bool has_claims = 13;
+     */
+    hasClaims: boolean;
+    /**
+     * Mark-to-market PnL of the remaining position at the token's latest
+     * known price: remaining_tokens × spot − cost_basis_usd. The documented
+     * ranking tiebreak, served so clients can render it. Meaningless (served
+     * 0) when unrealized_pnl_unknown — basis unknown, or no known spot price.
+     *
+     * @generated from field: double unrealized_pnl_usd = 14;
+     */
+    unrealizedPnlUsd: number;
+    /**
+     * True when the wallet sold beyond its tracked inventory at least once —
+     * the excess entered the wallet outside the swap tape (a transfer in),
+     * so its basis is unknown. Always implies basis_unknown.
+     *
+     * @generated from field: bool transferred_in = 15;
+     */
+    transferredIn: boolean;
+    /**
+     * True when the wallet's basis could not be computed — it transferred
+     * tokens in (transferred_in), its auction spend was not USD-convertible,
+     * or its attributed inventory contradicts its observed balance (the
+     * acquisitions were booked to the wrong address, so the basis they
+     * produced is not this wallet's). Clients should render the four
+     * basis-derived money
+     * fields as unknown ("–"), not $0.00; the row ranks after every
+     * computable-PnL row (see message doc). Implies unrealized_pnl_unknown.
+     *
+     * @generated from field: bool basis_unknown = 16;
+     */
+    basisUnknown: boolean;
+    /**
+     * True when unrealized_pnl_usd alone is not computable: basis_unknown, or
+     * the token has no known spot price (a missing spot must not read as a
+     * total loss). Served 0 then — render unknown ("–"), not $0.00. The other
+     * money fields stay real when basis_unknown is false.
+     *
+     * @generated from field: bool unrealized_pnl_unknown = 17;
+     */
+    unrealizedPnlUnknown: boolean;
+    constructor(data?: PartialMessage<TokenTopTrader>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.TokenTopTrader";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenTopTrader;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenTopTrader;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenTopTrader;
+    static equals(a: TokenTopTrader | PlainMessage<TokenTopTrader> | undefined, b: TokenTopTrader | PlainMessage<TokenTopTrader> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.GetTokenTopTradersResponse
+ */
+export declare class GetTokenTopTradersResponse extends Message<GetTokenTopTradersResponse> {
+    /**
+     * Ranked realized PnL desc, unrealized PnL desc as the tiebreak (orders
+     * never-sold claimers sensibly — all realized 0), wallet address asc as
+     * the final key, capped at the request limit. Unknown-basis rows
+     * (transferred_in, or an inconvertible auction spend) partition strictly
+     * after every computable-PnL row, including losses — so they cannot
+     * consume top slots on raw proceeds or displace losing traders. Only
+     * wallets with at least one trade or claim appear.
+     *
+     * @generated from field: repeated launches.v1.TokenTopTrader traders = 1;
+     */
+    traders: TokenTopTrader[];
+    constructor(data?: PartialMessage<GetTokenTopTradersResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.GetTokenTopTradersResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenTopTradersResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenTopTradersResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenTopTradersResponse;
+    static equals(a: GetTokenTopTradersResponse | PlainMessage<GetTokenTopTradersResponse> | undefined, b: GetTokenTopTradersResponse | PlainMessage<GetTokenTopTradersResponse> | undefined): boolean;
+}