@uniswap/client-data-api 0.0.224 → 0.0.226

package/dist/launches/v1/api_pb.js

@@ -0,0 +1,1464 @@
+// @generated by protoc-gen-es v1.10.1 with parameter "target=ts"
+// @generated from file launches/v1/api.proto (package launches.v1, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+import { Message, proto3, protoInt64 } 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 var ActivityStatsWindow;
+(function (ActivityStatsWindow) {
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_UNSPECIFIED = 0;
+     */
+    ActivityStatsWindow[ActivityStatsWindow["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_5M = 1;
+     */
+    ActivityStatsWindow[ActivityStatsWindow["LAST_5M"] = 1] = "LAST_5M";
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_1H = 2;
+     */
+    ActivityStatsWindow[ActivityStatsWindow["LAST_1H"] = 2] = "LAST_1H";
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_6H = 3;
+     */
+    ActivityStatsWindow[ActivityStatsWindow["LAST_6H"] = 3] = "LAST_6H";
+    /**
+     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_24H = 4;
+     */
+    ActivityStatsWindow[ActivityStatsWindow["LAST_24H"] = 4] = "LAST_24H";
+    /**
+     * 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;
+     */
+    ActivityStatsWindow[ActivityStatsWindow["SINCE_LAUNCH"] = 5] = "SINCE_LAUNCH";
+})(ActivityStatsWindow || (ActivityStatsWindow = {}));
+// Retrieve enum metadata with: proto3.getEnumType(ActivityStatsWindow)
+proto3.util.setEnumType(ActivityStatsWindow, "launches.v1.ActivityStatsWindow", [
+    { no: 0, name: "ACTIVITY_STATS_WINDOW_UNSPECIFIED" },
+    { no: 1, name: "ACTIVITY_STATS_WINDOW_LAST_5M" },
+    { no: 2, name: "ACTIVITY_STATS_WINDOW_LAST_1H" },
+    { no: 3, name: "ACTIVITY_STATS_WINDOW_LAST_6H" },
+    { no: 4, name: "ACTIVITY_STATS_WINDOW_LAST_24H" },
+    { no: 5, name: "ACTIVITY_STATS_WINDOW_SINCE_LAUNCH" },
+]);
+/**
+ * @generated from message launches.v1.TokenIdentifier
+ */
+export class TokenIdentifier extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * @generated from field: string address = 2;
+         */
+        this.address = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new TokenIdentifier().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new TokenIdentifier().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new TokenIdentifier().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(TokenIdentifier, a, b);
+    }
+}
+TokenIdentifier.runtime = proto3;
+TokenIdentifier.typeName = "launches.v1.TokenIdentifier";
+TokenIdentifier.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * The launchpad registry, for building launchpad filters/labels client-side.
+ *
+ * @generated from message launches.v1.ListLaunchpadsRequest
+ */
+export class ListLaunchpadsRequest extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new ListLaunchpadsRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ListLaunchpadsRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ListLaunchpadsRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ListLaunchpadsRequest, a, b);
+    }
+}
+ListLaunchpadsRequest.runtime = proto3;
+ListLaunchpadsRequest.typeName = "launches.v1.ListLaunchpadsRequest";
+ListLaunchpadsRequest.fields = proto3.util.newFieldList(() => []);
+/**
+ * @generated from message launches.v1.ListLaunchpadsResponse
+ */
+export class ListLaunchpadsResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: repeated launches.v1.Launchpad launchpads = 1;
+         */
+        this.launchpads = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new ListLaunchpadsResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ListLaunchpadsResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ListLaunchpadsResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ListLaunchpadsResponse, a, b);
+    }
+}
+ListLaunchpadsResponse.runtime = proto3;
+ListLaunchpadsResponse.typeName = "launches.v1.ListLaunchpadsResponse";
+ListLaunchpadsResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "launchpads", kind: "message", T: Launchpad, repeated: true },
+]);
+/**
+ * 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 class ListLaunchesRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * empty = all supported chains
+         *
+         * @generated from field: repeated uint32 chain_ids = 2;
+         */
+        this.chainIds = [];
+        /**
+         * 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;
+         */
+        this.sortBy = LaunchesOrderBy.UNSPECIFIED;
+        /**
+         * 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;
+         */
+        this.launchpadIds = [];
+        /**
+         * 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;
+         */
+        this.tokenAddresses = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new ListLaunchesRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ListLaunchesRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ListLaunchesRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ListLaunchesRequest, a, b);
+    }
+}
+ListLaunchesRequest.runtime = proto3;
+ListLaunchesRequest.typeName = "launches.v1.ListLaunchesRequest";
+ListLaunchesRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "launchpad_id", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 2, name: "chain_ids", kind: "scalar", T: 13 /* ScalarType.UINT32 */, repeated: true },
+    { no: 3, name: "sort_by", kind: "enum", T: proto3.getEnumType(LaunchesOrderBy) },
+    { no: 4, name: "page", kind: "message", T: PageRequest, opt: true },
+    { no: 5, name: "launchpad_ids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 6, name: "filter", kind: "message", T: LaunchListFilter, opt: true },
+    { no: 7, name: "ascending", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+    { no: 8, name: "query", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 9, name: "creator_address", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 10, name: "linked_x_only", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+    { no: 11, name: "token_addresses", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+]);
+/**
+ * @generated from message launches.v1.ListLaunchesResponse
+ */
+export class ListLaunchesResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: repeated launches.v1.Launch launches = 1;
+         */
+        this.launches = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new ListLaunchesResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ListLaunchesResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ListLaunchesResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ListLaunchesResponse, a, b);
+    }
+}
+ListLaunchesResponse.runtime = proto3;
+ListLaunchesResponse.typeName = "launches.v1.ListLaunchesResponse";
+ListLaunchesResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "launches", kind: "message", T: Launch, repeated: true },
+    { no: 2, name: "page", kind: "message", T: PageResponse },
+]);
+/**
+ * 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 class GetLaunchHoldersRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * @generated from field: string token_address = 2;
+         */
+        this.tokenAddress = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLaunchHoldersRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLaunchHoldersRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLaunchHoldersRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLaunchHoldersRequest, a, b);
+    }
+}
+GetLaunchHoldersRequest.runtime = proto3;
+GetLaunchHoldersRequest.typeName = "launches.v1.GetLaunchHoldersRequest";
+GetLaunchHoldersRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "token_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * 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 class GetLaunchHoldersResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * 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;
+         */
+        this.holders = [];
+        /**
+         * 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;
+         */
+        this.holderCountTrend = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLaunchHoldersResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLaunchHoldersResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLaunchHoldersResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLaunchHoldersResponse, a, b);
+    }
+}
+GetLaunchHoldersResponse.runtime = proto3;
+GetLaunchHoldersResponse.typeName = "launches.v1.GetLaunchHoldersResponse";
+GetLaunchHoldersResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "holders", kind: "message", T: LaunchHolder, repeated: true },
+    { no: 2, name: "holder_count", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
+    { no: 3, name: "holder_count_change_24h", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
+    { no: 4, name: "holder_count_trend", kind: "message", T: TimestampedValue, repeated: true },
+    { no: 5, name: "top10_supply_pct", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
+    { no: 6, name: "minted_supply", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 7, name: "burned_to_zero", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 8, name: "burned_to_dead", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+]);
+/**
+ * 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 class GetLaunchActivityStatsRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * @generated from field: string token_address = 2;
+         */
+        this.tokenAddress = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLaunchActivityStatsRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLaunchActivityStatsRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLaunchActivityStatsRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLaunchActivityStatsRequest, a, b);
+    }
+}
+GetLaunchActivityStatsRequest.runtime = proto3;
+GetLaunchActivityStatsRequest.typeName = "launches.v1.GetLaunchActivityStatsRequest";
+GetLaunchActivityStatsRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "token_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * @generated from message launches.v1.GetLaunchActivityStatsResponse
+ */
+export class GetLaunchActivityStatsResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * One entry per window, always all five, in enum order.
+         *
+         * @generated from field: repeated launches.v1.LaunchActivityStatsWindow windows = 1;
+         */
+        this.windows = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLaunchActivityStatsResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLaunchActivityStatsResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLaunchActivityStatsResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLaunchActivityStatsResponse, a, b);
+    }
+}
+GetLaunchActivityStatsResponse.runtime = proto3;
+GetLaunchActivityStatsResponse.typeName = "launches.v1.GetLaunchActivityStatsResponse";
+GetLaunchActivityStatsResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "windows", kind: "message", T: LaunchActivityStatsWindow, repeated: true },
+]);
+/**
+ * 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 class LaunchActivityStatsWindow extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: launches.v1.ActivityStatsWindow window = 1;
+         */
+        this.window = ActivityStatsWindow.UNSPECIFIED;
+        /**
+         * @generated from field: int32 buy_count = 2;
+         */
+        this.buyCount = 0;
+        /**
+         * @generated from field: int32 sell_count = 3;
+         */
+        this.sellCount = 0;
+        /**
+         * @generated from field: double buy_volume_usd = 4;
+         */
+        this.buyVolumeUsd = 0;
+        /**
+         * @generated from field: double sell_volume_usd = 5;
+         */
+        this.sellVolumeUsd = 0;
+        /**
+         * @generated from field: int32 unique_buyers = 6;
+         */
+        this.uniqueBuyers = 0;
+        /**
+         * @generated from field: int32 unique_sellers = 7;
+         */
+        this.uniqueSellers = 0;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new LaunchActivityStatsWindow().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new LaunchActivityStatsWindow().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new LaunchActivityStatsWindow().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(LaunchActivityStatsWindow, a, b);
+    }
+}
+LaunchActivityStatsWindow.runtime = proto3;
+LaunchActivityStatsWindow.typeName = "launches.v1.LaunchActivityStatsWindow";
+LaunchActivityStatsWindow.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "window", kind: "enum", T: proto3.getEnumType(ActivityStatsWindow) },
+    { no: 2, name: "buy_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 3, name: "sell_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 4, name: "buy_volume_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 5, name: "sell_volume_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 6, name: "unique_buyers", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 7, name: "unique_sellers", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+]);
+/**
+ * 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 class GetLaunchClaimsRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * @generated from field: string token_address = 2;
+         */
+        this.tokenAddress = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLaunchClaimsRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLaunchClaimsRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLaunchClaimsRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLaunchClaimsRequest, a, b);
+    }
+}
+GetLaunchClaimsRequest.runtime = proto3;
+GetLaunchClaimsRequest.typeName = "launches.v1.GetLaunchClaimsRequest";
+GetLaunchClaimsRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "token_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * 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 class LaunchClaim extends Message {
+    constructor(data) {
+        super();
+        /**
+         * EIP-55 checksummed wallet address.
+         *
+         * @generated from field: string wallet = 1;
+         */
+        this.wallet = "";
+        /**
+         * Total launch tokens the wallet received from the auction, raw uint256
+         * decimal string in token base units.
+         *
+         * @generated from field: string tokens_received = 2;
+         */
+        this.tokensReceived = "";
+        /**
+         * 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;
+         */
+        this.currencySpent = "";
+        /**
+         * 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;
+         */
+        this.claimCount = 0;
+        /**
+         * 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;
+         */
+        this.fullyClaimed = false;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new LaunchClaim().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new LaunchClaim().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new LaunchClaim().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(LaunchClaim, a, b);
+    }
+}
+LaunchClaim.runtime = proto3;
+LaunchClaim.typeName = "launches.v1.LaunchClaim";
+LaunchClaim.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "wallet", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "tokens_received", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "currency_spent", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "claim_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 5, name: "fully_claimed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+]);
+/**
+ * @generated from message launches.v1.GetLaunchClaimsResponse
+ */
+export class GetLaunchClaimsResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * 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;
+         */
+        this.claims = [];
+        /**
+         * 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;
+         */
+        this.totalClaimed = "";
+        /**
+         * 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;
+         */
+        this.uniqueClaimers = 0;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLaunchClaimsResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLaunchClaimsResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLaunchClaimsResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLaunchClaimsResponse, a, b);
+    }
+}
+GetLaunchClaimsResponse.runtime = proto3;
+GetLaunchClaimsResponse.typeName = "launches.v1.GetLaunchClaimsResponse";
+GetLaunchClaimsResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "claims", kind: "message", T: LaunchClaim, repeated: true },
+    { no: 2, name: "total_claimed", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "unique_claimers", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+]);
+/**
+ * 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 class GetLaunchCreatorFeesRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * The launched token's address (any casing).
+         *
+         * @generated from field: string token_address = 2;
+         */
+        this.tokenAddress = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLaunchCreatorFeesRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLaunchCreatorFeesRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLaunchCreatorFeesRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLaunchCreatorFeesRequest, a, b);
+    }
+}
+GetLaunchCreatorFeesRequest.runtime = proto3;
+GetLaunchCreatorFeesRequest.typeName = "launches.v1.GetLaunchCreatorFeesRequest";
+GetLaunchCreatorFeesRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "token_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * 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 class LaunchCreatorFeeAmounts extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string native_amount = 1;
+         */
+        this.nativeAmount = "";
+        /**
+         * @generated from field: string token_amount = 2;
+         */
+        this.tokenAmount = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new LaunchCreatorFeeAmounts().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new LaunchCreatorFeeAmounts().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new LaunchCreatorFeeAmounts().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(LaunchCreatorFeeAmounts, a, b);
+    }
+}
+LaunchCreatorFeeAmounts.runtime = proto3;
+LaunchCreatorFeeAmounts.typeName = "launches.v1.LaunchCreatorFeeAmounts";
+LaunchCreatorFeeAmounts.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "native_amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "token_amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * 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 class CreatorFeeTotals extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new CreatorFeeTotals().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new CreatorFeeTotals().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new CreatorFeeTotals().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(CreatorFeeTotals, a, b);
+    }
+}
+CreatorFeeTotals.runtime = proto3;
+CreatorFeeTotals.typeName = "launches.v1.CreatorFeeTotals";
+CreatorFeeTotals.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "accumulated", kind: "message", T: LaunchCreatorFeeAmounts },
+    { no: 2, name: "claimed", kind: "message", T: LaunchCreatorFeeAmounts },
+    { no: 3, name: "claimable", kind: "message", T: LaunchCreatorFeeAmounts },
+    { no: 4, name: "claimable_including_uncollected", kind: "message", T: LaunchCreatorFeeAmounts },
+]);
+/**
+ * @generated from message launches.v1.GetLaunchCreatorFeesResponse
+ */
+export class GetLaunchCreatorFeesResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * 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;
+         */
+        this.creatorFeesEnabled = false;
+        /**
+         * 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;
+         */
+        this.asOfTimestamp = protoInt64.zero;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLaunchCreatorFeesResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLaunchCreatorFeesResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLaunchCreatorFeesResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLaunchCreatorFeesResponse, a, b);
+    }
+}
+GetLaunchCreatorFeesResponse.runtime = proto3;
+GetLaunchCreatorFeesResponse.typeName = "launches.v1.GetLaunchCreatorFeesResponse";
+GetLaunchCreatorFeesResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "creator_fees_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 2, name: "creator", kind: "message", T: CreatorFeeTotals },
+    { no: 3, name: "auto_compounded", kind: "message", T: LaunchCreatorFeeAmounts },
+    { no: 4, name: "position_token_id", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 5, name: "fee_beneficiary", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 6, name: "as_of_timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+    { no: 7, name: "fee_splitter", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 8, name: "beneficiary_vault", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 9, name: "claimable_includes_uncollected", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+]);
+/**
+ * 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 class CheckLaunchNameTickerRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * Token name as entered in the create form (compared case-insensitively).
+         *
+         * @generated from field: string name = 2;
+         */
+        this.name = "";
+        /**
+         * Token ticker/symbol as entered in the create form (compared
+         * case-insensitively).
+         *
+         * @generated from field: string symbol = 3;
+         */
+        this.symbol = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new CheckLaunchNameTickerRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new CheckLaunchNameTickerRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new CheckLaunchNameTickerRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(CheckLaunchNameTickerRequest, a, b);
+    }
+}
+CheckLaunchNameTickerRequest.runtime = proto3;
+CheckLaunchNameTickerRequest.typeName = "launches.v1.CheckLaunchNameTickerRequest";
+CheckLaunchNameTickerRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "symbol", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * @generated from message launches.v1.CheckLaunchNameTickerResponse
+ */
+export class CheckLaunchNameTickerResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * 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;
+         */
+        this.recentlyLaunched = false;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new CheckLaunchNameTickerResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new CheckLaunchNameTickerResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new CheckLaunchNameTickerResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(CheckLaunchNameTickerResponse, a, b);
+    }
+}
+CheckLaunchNameTickerResponse.runtime = proto3;
+CheckLaunchNameTickerResponse.typeName = "launches.v1.CheckLaunchNameTickerResponse";
+CheckLaunchNameTickerResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "recently_launched", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 2, name: "original_token", kind: "message", T: RecentlyLaunchedToken },
+]);
+/**
+ * The already-launched token a CheckLaunchNameTicker warning points at.
+ *
+ * @generated from message launches.v1.RecentlyLaunchedToken
+ */
+export class RecentlyLaunchedToken extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * EIP-55 checksummed token address; with chain_id, enough to build the
+         * token-page link.
+         *
+         * @generated from field: string token_address = 2;
+         */
+        this.tokenAddress = "";
+        /**
+         * Stored name/symbol casing (the launched token's on-chain metadata).
+         *
+         * @generated from field: string name = 3;
+         */
+        this.name = "";
+        /**
+         * @generated from field: string symbol = 4;
+         */
+        this.symbol = "";
+        /**
+         * Unix seconds of the token's launch — the "launched X hours ago" the
+         * warning renders.
+         *
+         * @generated from field: int64 launched_at = 5;
+         */
+        this.launchedAt = protoInt64.zero;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new RecentlyLaunchedToken().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RecentlyLaunchedToken().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RecentlyLaunchedToken().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RecentlyLaunchedToken, a, b);
+    }
+}
+RecentlyLaunchedToken.runtime = proto3;
+RecentlyLaunchedToken.typeName = "launches.v1.RecentlyLaunchedToken";
+RecentlyLaunchedToken.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "token_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "symbol", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: "launched_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+]);
+/**
+ * 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 class GetLiquidityForTokensRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * max 100
+         *
+         * @generated from field: repeated launches.v1.TokenIdentifier tokens = 1;
+         */
+        this.tokens = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLiquidityForTokensRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLiquidityForTokensRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLiquidityForTokensRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLiquidityForTokensRequest, a, b);
+    }
+}
+GetLiquidityForTokensRequest.runtime = proto3;
+GetLiquidityForTokensRequest.typeName = "launches.v1.GetLiquidityForTokensRequest";
+GetLiquidityForTokensRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "tokens", kind: "message", T: TokenIdentifier, repeated: true },
+]);
+/**
+ * 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 class GetLiquidityForTokensResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: repeated launches.v1.TokenLiquidity liquidity = 1;
+         */
+        this.liquidity = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetLiquidityForTokensResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetLiquidityForTokensResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetLiquidityForTokensResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetLiquidityForTokensResponse, a, b);
+    }
+}
+GetLiquidityForTokensResponse.runtime = proto3;
+GetLiquidityForTokensResponse.typeName = "launches.v1.GetLiquidityForTokensResponse";
+GetLiquidityForTokensResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "liquidity", kind: "message", T: TokenLiquidity, repeated: true },
+]);
+/**
+ * @generated from message launches.v1.TokenLiquidity
+ */
+export class TokenLiquidity extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * EIP-55 checksummed token address, echoing the requested token.
+         *
+         * @generated from field: string address = 2;
+         */
+        this.address = "";
+        /**
+         * Summed pool TVL in USD. Always > 0 — see the omission rule above.
+         *
+         * @generated from field: double liquidity_usd = 3;
+         */
+        this.liquidityUsd = 0;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new TokenLiquidity().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new TokenLiquidity().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new TokenLiquidity().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(TokenLiquidity, a, b);
+    }
+}
+TokenLiquidity.runtime = proto3;
+TokenLiquidity.typeName = "launches.v1.TokenLiquidity";
+TokenLiquidity.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "liquidity_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+]);
+/**
+ * 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 class GetTokenTradesRequest extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetTokenTradesRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetTokenTradesRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetTokenTradesRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetTokenTradesRequest, a, b);
+    }
+}
+GetTokenTradesRequest.runtime = proto3;
+GetTokenTradesRequest.typeName = "launches.v1.GetTokenTradesRequest";
+GetTokenTradesRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "token", kind: "message", T: TokenIdentifier },
+    { no: 2, name: "page", kind: "message", T: PageRequest, opt: true },
+    { no: 3, name: "wallet", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 4, name: "min_amount_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
+]);
+/**
+ * @generated from message launches.v1.GetTokenTradesResponse
+ */
+export class GetTokenTradesResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: repeated launches.v1.TokenTrade trades = 1;
+         */
+        this.trades = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetTokenTradesResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetTokenTradesResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetTokenTradesResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetTokenTradesResponse, a, b);
+    }
+}
+GetTokenTradesResponse.runtime = proto3;
+GetTokenTradesResponse.typeName = "launches.v1.GetTokenTradesResponse";
+GetTokenTradesResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "trades", kind: "message", T: TokenTrade, repeated: true },
+    { no: 2, name: "page", kind: "message", T: PageResponse },
+]);
+/**
+ * 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 class GetTokenTopTradersRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: uint32 chain_id = 1;
+         */
+        this.chainId = 0;
+        /**
+         * @generated from field: string token_address = 2;
+         */
+        this.tokenAddress = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetTokenTopTradersRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetTokenTopTradersRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetTokenTopTradersRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetTokenTopTradersRequest, a, b);
+    }
+}
+GetTokenTopTradersRequest.runtime = proto3;
+GetTokenTopTradersRequest.typeName = "launches.v1.GetTokenTopTradersRequest";
+GetTokenTopTradersRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "chain_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "token_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "limit", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
+    { no: 4, name: "wallet_address", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+]);
+/**
+ * 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 class TokenTopTrader extends Message {
+    constructor(data) {
+        super();
+        /**
+         * EIP-55 checksummed trading wallet (the tx from-address, not the router).
+         *
+         * @generated from field: string wallet_address = 1;
+         */
+        this.walletAddress = "";
+        /**
+         * 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;
+         */
+        this.buyCount = 0;
+        /**
+         * @generated from field: int32 sell_count = 3;
+         */
+        this.sellCount = 0;
+        /**
+         * @generated from field: double bought_usd = 4;
+         */
+        this.boughtUsd = 0;
+        /**
+         * @generated from field: double sold_usd = 5;
+         */
+        this.soldUsd = 0;
+        /**
+         * Token amounts are whole (decimal-adjusted) tokens.
+         *
+         * @generated from field: double bought_tokens = 6;
+         */
+        this.boughtTokens = 0;
+        /**
+         * @generated from field: double sold_tokens = 7;
+         */
+        this.soldTokens = 0;
+        /**
+         * 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;
+         */
+        this.remainingTokens = 0;
+        /**
+         * 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;
+         */
+        this.costBasisUsd = 0;
+        /**
+         * 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;
+         */
+        this.avgCostUsd = 0;
+        /**
+         * 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;
+         */
+        this.realizedPnlUsd = 0;
+        /**
+         * 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;
+         */
+        this.auctionSpentUsd = 0;
+        /**
+         * 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;
+         */
+        this.hasClaims = false;
+        /**
+         * 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;
+         */
+        this.unrealizedPnlUsd = 0;
+        /**
+         * 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;
+         */
+        this.transferredIn = false;
+        /**
+         * 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;
+         */
+        this.basisUnknown = false;
+        /**
+         * 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;
+         */
+        this.unrealizedPnlUnknown = false;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new TokenTopTrader().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new TokenTopTrader().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new TokenTopTrader().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(TokenTopTrader, a, b);
+    }
+}
+TokenTopTrader.runtime = proto3;
+TokenTopTrader.typeName = "launches.v1.TokenTopTrader";
+TokenTopTrader.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "wallet_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "buy_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 3, name: "sell_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 4, name: "bought_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 5, name: "sold_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 6, name: "bought_tokens", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 7, name: "sold_tokens", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 8, name: "remaining_tokens", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 9, name: "cost_basis_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 10, name: "avg_cost_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 11, name: "realized_pnl_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 12, name: "auction_spent_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 13, name: "has_claims", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 14, name: "unrealized_pnl_usd", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+    { no: 15, name: "transferred_in", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 16, name: "basis_unknown", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 17, name: "unrealized_pnl_unknown", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+]);
+/**
+ * @generated from message launches.v1.GetTokenTopTradersResponse
+ */
+export class GetTokenTopTradersResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * 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;
+         */
+        this.traders = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new GetTokenTopTradersResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetTokenTopTradersResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetTokenTopTradersResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetTokenTopTradersResponse, a, b);
+    }
+}
+GetTokenTopTradersResponse.runtime = proto3;
+GetTokenTopTradersResponse.typeName = "launches.v1.GetTokenTopTradersResponse";
+GetTokenTopTradersResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "traders", kind: "message", T: TokenTopTrader, repeated: true },
+]);