@uniswap/client-data-api 0.0.224 → 0.0.226

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

@@ -0,0 +1,694 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Message, proto3, Timestamp } from "@bufbuild/protobuf";
+/**
+ * Sort field for ListLaunches; UNSPECIFIED defaults to LAUNCHED_AT (newest first).
+ *
+ * @generated from enum launches.v1.LaunchesOrderBy
+ */
+export declare enum LaunchesOrderBy {
+    /**
+     * @generated from enum value: LAUNCHES_ORDER_BY_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: LAUNCHES_ORDER_BY_LAUNCHED_AT = 1;
+     */
+    LAUNCHED_AT = 1,
+    /**
+     * @generated from enum value: LAUNCHES_ORDER_BY_VOLUME_1D = 2;
+     */
+    VOLUME_1D = 2,
+    /**
+     * @generated from enum value: LAUNCHES_ORDER_BY_TVL = 3;
+     */
+    TVL = 3,
+    /**
+     * @generated from enum value: LAUNCHES_ORDER_BY_PRICE_CHANGE_1H = 4;
+     */
+    PRICE_CHANGE_1H = 4,
+    /**
+     * @generated from enum value: LAUNCHES_ORDER_BY_PRICE_CHANGE_1D = 5;
+     */
+    PRICE_CHANGE_1D = 5,
+    /**
+     * Trending: launches with recent buy-side momentum. Candidates are tokens
+     * with buy activity in the trailing hour REGARDLESS of launch age; gated
+     * (non-negative 1h price change, minimum FDV, minimum distinct 1h buyers)
+     * and scored by volume/buyer acceleration vs the preceding hours, with the
+     * remainder of the page backfilled by 24h volume so the module never
+     * renders empty. Needs no LaunchListFilter.window — any window filter is
+     * ignored under this sort.
+     *
+     * @generated from enum value: LAUNCHES_ORDER_BY_TRENDING = 6;
+     */
+    TRENDING = 6
+}
+/**
+ * Launch-recency window for ListLaunches. UNSPECIFIED applies no window (all
+ * launches); LAST_24H / LAST_1H keep only launches whose launched_at is within
+ * the trailing 24 hours / 1 hour respectively.
+ *
+ * @generated from enum launches.v1.LaunchWindow
+ */
+export declare enum LaunchWindow {
+    /**
+     * @generated from enum value: LAUNCH_WINDOW_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: LAUNCH_WINDOW_LAST_24H = 1;
+     */
+    LAST_24H = 1,
+    /**
+     * @generated from enum value: LAUNCH_WINDOW_LAST_1H = 2;
+     */
+    LAST_1H = 2
+}
+/**
+ * The trade's direction from the trader's perspective: BUY = the trader
+ * received the requested token, SELL = the trader gave it up. UNSPECIFIED
+ * when the direction can't be derived (zero/unknown amount).
+ *
+ * @generated from enum launches.v1.TradeSide
+ */
+export declare enum TradeSide {
+    /**
+     * @generated from enum value: TRADE_SIDE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: TRADE_SIDE_BUY = 1;
+     */
+    BUY = 1,
+    /**
+     * @generated from enum value: TRADE_SIDE_SELL = 2;
+     */
+    SELL = 2
+}
+/**
+ * @generated from message launches.v1.TimestampedValue
+ */
+export declare class TimestampedValue extends Message<TimestampedValue> {
+    /**
+     * @generated from field: uint64 timestamp = 1;
+     */
+    timestamp: bigint;
+    /**
+     * @generated from field: double value = 2;
+     */
+    value: number;
+    constructor(data?: PartialMessage<TimestampedValue>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.TimestampedValue";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimestampedValue;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimestampedValue;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimestampedValue;
+    static equals(a: TimestampedValue | PlainMessage<TimestampedValue> | undefined, b: TimestampedValue | PlainMessage<TimestampedValue> | undefined): boolean;
+}
+/**
+ * @generated from message launches.v1.TokenSafety
+ */
+export declare class TokenSafety extends Message<TokenSafety> {
+    /**
+     * @generated from field: bool is_spam = 1;
+     */
+    isSpam: boolean;
+    /**
+     * @generated from field: bool is_verified = 2;
+     */
+    isVerified: boolean;
+    /**
+     * @generated from field: bool is_blocked = 3;
+     */
+    isBlocked: boolean;
+    /**
+     * @generated from field: optional string verdict = 4;
+     */
+    verdict?: string;
+    /**
+     * @generated from field: repeated string features = 5;
+     */
+    features: string[];
+    constructor(data?: PartialMessage<TokenSafety>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.TokenSafety";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenSafety;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenSafety;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenSafety;
+    static equals(a: TokenSafety | PlainMessage<TokenSafety> | undefined, b: TokenSafety | PlainMessage<TokenSafety> | undefined): boolean;
+}
+/**
+ * A token launchpad known to the Launches surface (see the data-api
+ * launchpad registry). A launchpad is the launching FRONTEND users see; id is
+ * the stable slug used in launchpad_id filters.
+ *
+ * @generated from message launches.v1.Launchpad
+ */
+export declare class Launchpad extends Message<Launchpad> {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    /**
+     * @generated from field: optional string logo_url = 3;
+     */
+    logoUrl?: string;
+    /**
+     * Underlying shared launch protocol (e.g. "doppler") when the frontend
+     * launches through contracts it doesn't own. Unset for self-contained
+     * launchpads; several frontends can share one protocol value.
+     *
+     * @generated from field: optional string protocol = 4;
+     */
+    protocol?: string;
+    constructor(data?: PartialMessage<Launchpad>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.Launchpad";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Launchpad;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Launchpad;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Launchpad;
+    static equals(a: Launchpad | PlainMessage<Launchpad> | undefined, b: Launchpad | PlainMessage<Launchpad> | undefined): boolean;
+}
+/**
+ * Optional filters for ListLaunches. When a window is set and sort_by is
+ * UNSPECIFIED the server sorts by 24h volume (VOLUME_1D).
+ *
+ * @generated from message launches.v1.LaunchListFilter
+ */
+export declare class LaunchListFilter extends Message<LaunchListFilter> {
+    /**
+     * @generated from field: launches.v1.LaunchWindow window = 1;
+     */
+    window: LaunchWindow;
+    constructor(data?: PartialMessage<LaunchListFilter>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.LaunchListFilter";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchListFilter;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchListFilter;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchListFilter;
+    static equals(a: LaunchListFilter | PlainMessage<LaunchListFilter> | undefined, b: LaunchListFilter | PlainMessage<LaunchListFilter> | undefined): boolean;
+}
+/**
+ * The launched token's identity and display metadata.
+ *
+ * @generated from message launches.v1.LaunchToken
+ */
+export declare class LaunchToken extends Message<LaunchToken> {
+    /**
+     * @generated from field: uint32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * @generated from field: string address = 2;
+     */
+    address: string;
+    /**
+     * @generated from field: string symbol = 3;
+     */
+    symbol: string;
+    /**
+     * @generated from field: string name = 4;
+     */
+    name: string;
+    /**
+     * @generated from field: optional string logo_url = 5;
+     */
+    logoUrl?: string;
+    /**
+     * Safety classification from Aurora canonical_tokens — the same source and
+     * shape GetToken serves (safety.is_blocked carries the compliance
+     * blocklist). Unset when the token has no canonical row yet (fresh
+     * launches lag ingestion) or the read failed: treat as not blocked.
+     *
+     * @generated from field: launches.v1.TokenSafety safety = 6;
+     */
+    safety?: TokenSafety;
+    constructor(data?: PartialMessage<LaunchToken>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.LaunchToken";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchToken;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchToken;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchToken;
+    static equals(a: LaunchToken | PlainMessage<LaunchToken> | undefined, b: LaunchToken | PlainMessage<LaunchToken> | undefined): boolean;
+}
+/**
+ * Live USD stats for a launch's pool/token. Each field is unset when its
+ * source has no data yet (fresh launches lag the stats pipelines).
+ *
+ * @generated from message launches.v1.LaunchStats
+ */
+export declare class LaunchStats extends Message<LaunchStats> {
+    /**
+     * @generated from field: optional double volume_24h_usd = 1;
+     */
+    volume24hUsd?: number;
+    /**
+     * @generated from field: optional double tvl_usd = 2;
+     */
+    tvlUsd?: number;
+    /**
+     * @generated from field: optional double price_usd = 3;
+     */
+    priceUsd?: number;
+    /**
+     * price x total supply; unset where no supply source
+     *
+     * @generated from field: optional double fdv_usd = 4;
+     */
+    fdvUsd?: number;
+    /**
+     * @generated from field: optional double price_change_percent_1h = 5;
+     */
+    priceChangePercent1h?: number;
+    /**
+     * @generated from field: optional double price_change_percent_24h = 6;
+     */
+    priceChangePercent24h?: number;
+    /**
+     * USD price sparkline over the trailing 24h, oldest first. Same shape as
+     * RankedMultichainToken.sparkline (Aurora-side timestamps are synthesized;
+     * CCA points are observed). Empty when no series is available.
+     *
+     * @generated from field: repeated launches.v1.TimestampedValue sparkline = 7;
+     */
+    sparkline: TimestampedValue[];
+    /**
+     * price_usd in ETH terms, derived at serve time as price_usd divided by
+     * the chain's native-ETH USD rate. Only set on chains whose native
+     * currency is ETH; unset when either price is unavailable.
+     *
+     * @generated from field: optional double price_eth = 8;
+     */
+    priceEth?: number;
+    /**
+     * USD price ~24h ago — the anchor price_change_percent_24h is measured
+     * against. When set, price_change_percent_24h is computed at serve time
+     * from the live current price against this anchor; unset when the stats
+     * pipeline has not resolved an anchor yet.
+     *
+     * @generated from field: optional double price_24h_ago_usd = 9;
+     */
+    price24hAgoUsd?: number;
+    constructor(data?: PartialMessage<LaunchStats>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.LaunchStats";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchStats;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchStats;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchStats;
+    static equals(a: LaunchStats | PlainMessage<LaunchStats> | undefined, b: LaunchStats | PlainMessage<LaunchStats> | undefined): boolean;
+}
+/**
+ * One token launch: the earliest pool a (token, launchpad) pair created.
+ *
+ * @generated from message launches.v1.Launch
+ */
+export declare class Launch extends Message<Launch> {
+    /**
+     * @generated from field: string launchpad_id = 1;
+     */
+    launchpadId: string;
+    /**
+     * @generated from field: launches.v1.LaunchToken token = 2;
+     */
+    token?: LaunchToken;
+    /**
+     * v4 pool id for hook-attributed and direct launches; CCA pool key hash
+     * once the auction has migrated to a pool, empty before then.
+     *
+     * @generated from field: string pool_id = 3;
+     */
+    poolId: string;
+    /**
+     * @generated from field: optional string hooks_address = 4;
+     */
+    hooksAddress?: string;
+    /**
+     * unix seconds
+     *
+     * @generated from field: int64 launched_at = 5;
+     */
+    launchedAt: bigint;
+    /**
+     * @generated from field: launches.v1.LaunchStats stats = 6;
+     */
+    stats?: LaunchStats;
+    /**
+     * CCA + direct-launch launches: true once the launch graduated. CCA:
+     * auction migrated into its pool (on-chain fact). Direct launches
+     * (launchpad "uniswap-bonding-curve") have NO on-chain graduation — the
+     * pool is a vanilla v4 pool from block one — so this is currently always
+     * false for them; a serving-side FDV-threshold graduation rule may set it
+     * later. Unset for other hook-attributed launches, which are pools
+     * already.
+     *
+     * @generated from field: optional bool graduated = 7;
+     */
+    graduated?: boolean;
+    /**
+     * CCA launches only, pre-graduation: bid volume as a percent of the
+     * required raise, clamped to [0, 100]. Unset once graduated, when the
+     * auction has no required raise, and for hook-attributed launches.
+     *
+     * @generated from field: optional double auction_fill_pct = 8;
+     */
+    auctionFillPct?: number;
+    /**
+     * CCA launches only, pre-graduation: the auction's end block number
+     * (bigint as string). Clients estimate calendar time from blocks, like the
+     * v1 auction start_block/end_block. Unset once graduated.
+     *
+     * @generated from field: optional string auction_end_block = 9;
+     */
+    auctionEndBlock?: string;
+    /**
+     * CCA launches only: distinct wallets that have placed bids in the auction
+     * (all bids, including withdrawn/exited — historical participation, so it
+     * stays set after graduation). Unset for hook-attributed launches, which
+     * have no auction. int32 matches the v1 auction total_bid_count.
+     *
+     * @generated from field: optional int32 bidder_count = 10;
+     */
+    bidderCount?: number;
+    /**
+     * Direct-launch overlay (see BondingCurveInfo), set only for launches of
+     * the Uniswap direct-launch launchpad ("uniswap-bonding-curve").
+     *
+     * @generated from field: optional launches.v1.BondingCurveInfo bonding_curve = 11;
+     */
+    bondingCurve?: BondingCurveInfo;
+    /**
+     * Launchpad token metadata (12-15), joined from launched_tokens — present
+     * only for launches whose token was created via the Uniswap token factory
+     * (CCA and bonding-curve launches); other launchpads' tokens have no row
+     * and serve unset. Verification gating mirrors v1 GetAuction
+     * (AuctionsBL.enrichWithLaunchpadMetadata): the description is on-chain
+     * creator text at the same trust level as name/symbol, served ungated.
+     *
+     * @generated from field: optional string token_description = 12;
+     */
+    tokenDescription?: string;
+    /**
+     * The launch tx's from address (launched_tokens.creator_wallet),
+     * EIP-55 checksummed. Public on-chain data, served ungated.
+     *
+     * @generated from field: optional string creator_address = 13;
+     */
+    creatorAddress?: string;
+    /**
+     * Creator-declared project website. Served only once website verification
+     * passes; verification is deferred today (status stays 'pending', same
+     * rule that keeps the token mirror's homepageUrl null), so this stays
+     * unset until that ships.
+     *
+     * @generated from field: optional string website_url = 14;
+     */
+    websiteUrl?: string;
+    /**
+     * X handle, only when its inline-at-ingest Ed25519 verification passed.
+     *
+     * @generated from field: optional string x_handle = 15;
+     */
+    xHandle?: string;
+    /**
+     * Bonding-curve launches only (16-17): distinct wallets (swap tx senders)
+     * that bought the launch token on its curve pool — all-time and trailing
+     * hour. Served from ClickHouse v4 swaps; absent (never 0) when the stats
+     * source fails or for non-curve launches, so clients can tell degraded
+     * from a real zero.
+     *
+     * @generated from field: optional int32 unique_buyer_count = 16;
+     */
+    uniqueBuyerCount?: number;
+    /**
+     * @generated from field: optional int32 buyers_last_1h = 17;
+     */
+    buyersLast1h?: number;
+    /**
+     * Exact on-chain holder count of the launch token, computed at query time
+     * over the raw launch-transfers feed (ClickHouse, reorg-excluded):
+     * addresses with a positive net balance, contracts included, burn sinks
+     * like 0x…dEaD included while they hold a balance — raw Etherscan-style
+     * semantics. Present only for tokens created via the Uniswap token
+     * factory (CCA + bonding-curve launches, whose transfers the feed
+     * whitelists); absent — never 0 — while the token has no ingested
+     * transfers or when the enrichment fails.
+     *
+     * @generated from field: optional int32 holder_count = 18;
+     */
+    holderCount?: number;
+    /**
+     * Cumulative burned amount of the launch token, split by burn sink and
+     * computed from the same transfer feed. Raw uint256 base units as decimal
+     * strings; total burned = burned_to_zero + burned_to_dead. Because burn
+     * addresses never spend, a holders-excluding-burn count is
+     * client-derivable as holder_count - (burned_to_dead > 0 ? 1 : 0). Same
+     * presence rule as holder_count (absent without ingested transfers), but
+     * once the token has transfers a genuine "0" is served.
+     *
+     * @generated from field: optional string burned_to_zero = 19;
+     */
+    burnedToZero?: string;
+    /**
+     * @generated from field: optional string burned_to_dead = 20;
+     */
+    burnedToDead?: string;
+    /**
+     * CCA launches only, pre-graduation (same lifecycle as auction_end_block):
+     * wall-clock time of the auction's end block in unix seconds, computed
+     * server-side (LP-1300) — the exact block timestamp once the end block is
+     * mined, otherwise an estimate from a per-chain block-time model. Unset
+     * once graduated, when the source data is unavailable, and for
+     * hook-attributed launches.
+     *
+     * @generated from field: optional int64 auction_end_time = 21;
+     */
+    auctionEndTime?: bigint;
+    /**
+     * X profile image URL of the verified launcher account, captured from the
+     * launch's signed x-verification claims. Same gate as x_handle: served only
+     * when the inline-at-ingest Ed25519 verification passed. Unset for launches
+     * that predate claim capture (backfill pending) or carry no avatar.
+     *
+     * @generated from field: optional string x_profile_image_url = 22;
+     */
+    xProfileImageUrl?: string;
+    /**
+     * Whether the launcher's X account was verified (blue check) when captured.
+     * Tri-state via presence: unset = unknown (pre-feature launch, not yet
+     * backfilled), false = X reported not verified, true = verified. Same
+     * x_handle_status gate as x_handle / x_profile_image_url.
+     *
+     * @generated from field: optional bool x_verified = 23;
+     */
+    xVerified?: boolean;
+    /**
+     * Home-card trade tape: the launch token's most recent swaps, newest
+     * first, capped at the last 5 within the trailing 24h — same rows (and
+     * message) GetTokenTrades serves, aggregated across all the token's pools
+     * on its chain. Served from a short-TTL cache refreshed off the request
+     * path, so entries can lag live trades by the cache TTL (~30s) and a
+     * cold cache serves an empty list — clients treat empty as "no recent
+     * activity known", not an error. Pre-graduation CCA launches have no
+     * swaps by construction (bids are not trades) — the auction tape is
+     * AuctionWithStats.recent_bids on ListTopAuctions.
+     *
+     * @generated from field: repeated launches.v1.TokenTrade recent_trades = 24;
+     */
+    recentTrades: TokenTrade[];
+    constructor(data?: PartialMessage<Launch>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.Launch";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Launch;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Launch;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Launch;
+    static equals(a: Launch | PlainMessage<Launch> | undefined, b: Launch | PlainMessage<Launch> | undefined): boolean;
+}
+/**
+ * One row of a launch token's holder list (GetLaunchHolders).
+ *
+ * @generated from message launches.v1.LaunchHolder
+ */
+export declare class LaunchHolder extends Message<LaunchHolder> {
+    /**
+     * EIP-55 checksummed, so clients can equality-match against
+     * Launch.creator_address and well-known addresses (LP, burn sinks).
+     *
+     * @generated from field: string address = 1;
+     */
+    address: string;
+    /**
+     * Net balance, raw base units as a decimal string. For the synthetic
+     * zero-address burn row this is the cumulative amount burned to 0x0.
+     *
+     * @generated from field: string balance = 2;
+     */
+    balance: string;
+    /**
+     * balance as a percent of minted_supply, in [0, 100].
+     *
+     * @generated from field: double supply_pct = 3;
+     */
+    supplyPct: number;
+    /**
+     * True for burn-sink rows (the zero address and 0x…dEaD). Burn rows are
+     * served in the list (burned tokens stay visible) but excluded from
+     * top10_supply_pct; the synthetic zero-address row is also excluded from
+     * holder_count (0x…dEaD counts, matching Launch.holder_count).
+     *
+     * @generated from field: bool is_burn_address = 4;
+     */
+    isBurnAddress: boolean;
+    /**
+     * True for the launch pool's custody row — the chain's v4 PoolManager
+     * singleton, which holds the pool's token-side balance (the LP NFT sits
+     * in the FeeSplitter, the ERC-20 supply does not). Served in the list so
+     * clients can label it, but excluded from top10_supply_pct like burn rows
+     * (the pool is the market, not a dumpable holder); it stays inside
+     * holder_count.
+     *
+     * @generated from field: bool is_pool_address = 5;
+     */
+    isPoolAddress: boolean;
+    constructor(data?: PartialMessage<LaunchHolder>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.LaunchHolder";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchHolder;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchHolder;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchHolder;
+    static equals(a: LaunchHolder | PlainMessage<LaunchHolder> | undefined, b: LaunchHolder | PlainMessage<LaunchHolder> | undefined): boolean;
+}
+/**
+ * Overlay for launches of the Uniswap direct-launch launchpad (launchpad_id
+ * "uniswap-bonding-curve", kept for client compatibility). The current
+ * launcher generation (DirectLaunchStrategy, LP-1289) is hookless with NO
+ * on-chain graduation lifecycle: launch pools are vanilla v4 pools from
+ * block one, and "graduation" is a serving/frontend concept (an FDV
+ * threshold), not a contract event. Fields 1-5 and 7-9 belong to the
+ * never-launched bonding-curve hook generation and are no longer set for
+ * new launches; they are kept so the message shape stays wire-compatible.
+ *
+ * @generated from message launches.v1.BondingCurveInfo
+ */
+export declare class BondingCurveInfo extends Message<BondingCurveInfo> {
+    /**
+     * Legacy bonding-curve-hook fields (1-5, 7-9): never set for direct-launch
+     * (hookless) launches — there is no curve and no on-chain graduation.
+     *
+     * @generated from field: optional string graduation_sqrt_price_x96 = 1;
+     */
+    graduationSqrtPriceX96?: string;
+    /**
+     * @generated from field: optional int32 curve_tick_lower = 2;
+     */
+    curveTickLower?: number;
+    /**
+     * @generated from field: optional int32 curve_tick_upper = 3;
+     */
+    curveTickUpper?: number;
+    /**
+     * @generated from field: optional string curve_supply = 4;
+     */
+    curveSupply?: string;
+    /**
+     * @generated from field: optional string reserve_supply = 5;
+     */
+    reserveSupply?: string;
+    /**
+     * @generated from field: optional string graduated_tx_hash = 7;
+     */
+    graduatedTxHash?: string;
+    /**
+     * @generated from field: optional double curve_progress_pct = 8;
+     */
+    curveProgressPct?: number;
+    /**
+     * @generated from field: optional int64 graduated_at = 9;
+     */
+    graduatedAt?: bigint;
+    /**
+     * The launch's fee beneficiary, EIP-55 checksummed: the CURRENT holder of
+     * the launch's BeneficiaryVault NFT, i.e. the address receiving the
+     * creator share of the launch pool's trading fees. Freely chosen at
+     * launch time by whoever built the launch transaction — a payee, NOT
+     * proven authorship (see Launch.creator_address for the launch tx
+     * sender) — and it MOVES with later NFT transfers. Unset while ingestion
+     * of the vault events lags the launch, or when the position is
+     * unregistered.
+     *
+     * @generated from field: optional string fee_beneficiary = 10;
+     */
+    feeBeneficiary?: string;
+    constructor(data?: PartialMessage<BondingCurveInfo>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.BondingCurveInfo";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BondingCurveInfo;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BondingCurveInfo;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BondingCurveInfo;
+    static equals(a: BondingCurveInfo | PlainMessage<BondingCurveInfo> | undefined, b: BondingCurveInfo | PlainMessage<BondingCurveInfo> | undefined): boolean;
+}
+/**
+ * One swap involving the requested token, returned by GetTokenTrades.
+ *
+ * @generated from message launches.v1.TokenTrade
+ */
+export declare class TokenTrade extends Message<TokenTrade> {
+    /**
+     * @generated from field: string tx_hash = 1;
+     */
+    txHash: string;
+    /**
+     * @generated from field: launches.v1.TradeSide side = 2;
+     */
+    side: TradeSide;
+    /**
+     * The transaction's from-address (the EOA that signed it), not the router
+     * contract that forwarded the swap to the pool.
+     *
+     * @generated from field: string wallet = 3;
+     */
+    wallet: string;
+    /**
+     * Whole-swap USD value at trade time; unset when no USD price is known.
+     *
+     * @generated from field: optional double amount_usd = 4;
+     */
+    amountUsd?: number;
+    /**
+     * Absolute amount of the requested token traded, decimal string in token
+     * units (decimals applied). Empty when the token's decimals are unknown.
+     *
+     * @generated from field: string token_amount = 5;
+     */
+    tokenAmount: string;
+    /**
+     * USD price of the requested token at trade time; unset when unknown.
+     *
+     * @generated from field: optional double price_usd = 6;
+     */
+    priceUsd?: number;
+    /**
+     * @generated from field: google.protobuf.Timestamp timestamp = 7;
+     */
+    timestamp?: Timestamp;
+    constructor(data?: PartialMessage<TokenTrade>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.TokenTrade";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenTrade;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenTrade;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenTrade;
+    static equals(a: TokenTrade | PlainMessage<TokenTrade> | undefined, b: TokenTrade | PlainMessage<TokenTrade> | undefined): boolean;
+}