@uniswap/client-data-api 0.0.228 → 0.0.230

package/dist/data/v1/auction_pb.d.ts

@@ -686,6 +686,16 @@ export declare class Auction extends Message<Auction> {
      * @generated from field: optional string hooks = 56;
      */
     hooks?: string;
+    /**
+     * Badges earned by the auction's token (LP badges), one per badge type,
+     * highest tier only, canonical order — the data.v1 twin of
+     * data.v2.Launch.badges, because a crowd launch's canonical row on every
+     * client surface (list rows AND the token page) is the auction, which a
+     * graduated token never leaves. Empty until the token has earned any.
+     *
+     * @generated from field: repeated data.v1.LaunchBadge badges = 57;
+     */
+    badges: LaunchBadge[];
     constructor(data?: PartialMessage<Auction>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "data.v1.Auction";
@@ -695,6 +705,56 @@ export declare class Auction extends Message<Auction> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Auction;
     static equals(a: Auction | PlainMessage<Auction> | undefined, b: Auction | PlainMessage<Auction> | undefined): boolean;
 }
+/**
+ * One badge earned by a launch's token — the data.v1 twin of
+ * data.v2.LaunchBadge (data/v1 cannot import data/v2). type/tier are
+ * deliberately plain strings, NOT enums: the client contract pins the
+ * lowercase ids on the wire, and proto-JSON would serialize an enum's
+ * VALUE NAMES instead.
+ *
+ * @generated from message data.v1.LaunchBadge
+ */
+export declare class LaunchBadge extends Message<LaunchBadge> {
+    /**
+     * "original" | "frontrunner" | "volume" | "holders" | "badger".
+     *
+     * @generated from field: string type = 1;
+     */
+    type: string;
+    /**
+     * Tier id, present only for the tiered types — volume: "5m" | "10m" |
+     * "50m"; holders: "100" | "1k" | "10k". Unset for untiered types.
+     *
+     * @generated from field: optional string tier = 2;
+     */
+    tier?: string;
+    /**
+     * When the badge was earned (proto-JSON serializes this as an ISO-8601
+     * string, which is the client contract). Exact on-chain launch time for
+     * original/frontrunner; observation time for tier crossings.
+     *
+     * @generated from field: google.protobuf.Timestamp earned_at = 3;
+     */
+    earnedAt?: Timestamp;
+    /**
+     * Rarity: percentage (0-100) of eligible tokens that hold this badge
+     * TYPE (any tier), for the client's rarity-tag hover. The denominator is
+     * every factory-launched token (the launched_tokens registry). Served
+     * from a short-TTL cached aggregate; unset when the aggregate is
+     * unavailable — clients hide the rarity detail rather than showing 0.
+     *
+     * @generated from field: optional double holder_percentage = 4;
+     */
+    holderPercentage?: number;
+    constructor(data?: PartialMessage<LaunchBadge>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "data.v1.LaunchBadge";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchBadge;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchBadge;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchBadge;
+    static equals(a: LaunchBadge | PlainMessage<LaunchBadge> | undefined, b: LaunchBadge | PlainMessage<LaunchBadge> | undefined): boolean;
+}
 /**
  * Response containing auctions.
  *

package/dist/data/v1/auction_pb.js

@@ -632,6 +632,16 @@ export class Auction extends Message {
          * @generated from field: bool is_blocked = 51;
          */
         this.isBlocked = false;
+        /**
+         * Badges earned by the auction's token (LP badges), one per badge type,
+         * highest tier only, canonical order — the data.v1 twin of
+         * data.v2.Launch.badges, because a crowd launch's canonical row on every
+         * client surface (list rows AND the token page) is the auction, which a
+         * graduated token never leaves. Empty until the token has earned any.
+         *
+         * @generated from field: repeated data.v1.LaunchBadge badges = 57;
+         */
+        this.badges = [];
         proto3.util.initPartial(data, this);
     }
     static fromBinary(bytes, options) {
@@ -706,6 +716,48 @@ Auction.fields = proto3.util.newFieldList(() => [
     { no: 54, name: "fee", kind: "scalar", T: 13 /* ScalarType.UINT32 */, opt: true },
     { no: 55, name: "tick_spacing", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
     { no: 56, name: "hooks", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 57, name: "badges", kind: "message", T: LaunchBadge, repeated: true },
+]);
+/**
+ * One badge earned by a launch's token — the data.v1 twin of
+ * data.v2.LaunchBadge (data/v1 cannot import data/v2). type/tier are
+ * deliberately plain strings, NOT enums: the client contract pins the
+ * lowercase ids on the wire, and proto-JSON would serialize an enum's
+ * VALUE NAMES instead.
+ *
+ * @generated from message data.v1.LaunchBadge
+ */
+export class LaunchBadge extends Message {
+    constructor(data) {
+        super();
+        /**
+         * "original" | "frontrunner" | "volume" | "holders" | "badger".
+         *
+         * @generated from field: string type = 1;
+         */
+        this.type = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new LaunchBadge().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new LaunchBadge().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new LaunchBadge().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(LaunchBadge, a, b);
+    }
+}
+LaunchBadge.runtime = proto3;
+LaunchBadge.typeName = "data.v1.LaunchBadge";
+LaunchBadge.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "tier", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "earned_at", kind: "message", T: Timestamp },
+    { no: 4, name: "holder_percentage", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
 ]);
 /**
  * Response containing auctions.

package/dist/data/v2/types_pb.d.ts

@@ -1,7 +1,7 @@
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
 import { Message, proto3, Timestamp } from "@bufbuild/protobuf";
 import { TimestampedValue, TokenType } from "../v1/types_pb.js";
-import { ProtocolVersion } from "../v1/poolTypes_pb.js";
+import { ProtocolVersion, Token as Token$1 } from "../v1/poolTypes_pb.js";
 /**
  * @generated from enum data.v2.TokensOrderBy
  */
@@ -1026,6 +1026,36 @@ export declare class PoolsSort extends Message<PoolsSort> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolsSort;
     static equals(a: PoolsSort | PlainMessage<PoolsSort> | undefined, b: PoolsSort | PlainMessage<PoolsSort> | undefined): boolean;
 }
+/**
+ * A pool's boosted APR in one reward token: the sum of that token's live
+ * campaign APRs on the pool, in percent, on top of the pool's fee APR. Ended
+ * campaigns are excluded — they accrue no yield.
+ *
+ * Deliberately carries no campaign detail (windows, allocations, distributed
+ * amounts): only the pool details page renders that, and it reads
+ * GetPoolRewards. Keeping it off this message keeps the per-row payload small
+ * enough to repeat across a page of pools.
+ *
+ * @generated from message data.v2.PoolTokenBoost
+ */
+export declare class PoolTokenBoost extends Message<PoolTokenBoost> {
+    /**
+     * @generated from field: pools.v1.Token token = 1;
+     */
+    token?: Token$1;
+    /**
+     * @generated from field: double apr = 2;
+     */
+    apr: number;
+    constructor(data?: PartialMessage<PoolTokenBoost>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "data.v2.PoolTokenBoost";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PoolTokenBoost;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PoolTokenBoost;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolTokenBoost;
+    static equals(a: PoolTokenBoost | PlainMessage<PoolTokenBoost> | undefined, b: PoolTokenBoost | PlainMessage<PoolTokenBoost> | undefined): boolean;
+}
 /**
  * Ranking stats for a pool.
  * apr = annualised fee revenue / TVL.
@@ -1065,6 +1095,19 @@ export declare class PoolRankStats extends Message<PoolRankStats> {
      * @generated from field: optional double volume_1d_tvl_ratio = 7;
      */
     volume1dTvlRatio?: number;
+    /**
+     * What reward_apr is paid in, per reward token — so a client can denominate
+     * a boost ("+2.1% in UNI") instead of rendering a bare number under a
+     * guessed symbol. reward_apr stays the cross-token sum and is derived from
+     * these, so reward_apr == sum(token_boosts[].apr) always holds.
+     *
+     * Empty when the pool runs no live campaign, and empty when the incentive
+     * lookup degraded — in which case reward_apr is unset too. Never one
+     * without the other: a boost nobody can denominate is worse than no boost.
+     *
+     * @generated from field: repeated data.v2.PoolTokenBoost token_boosts = 8;
+     */
+    tokenBoosts: PoolTokenBoost[];
     constructor(data?: PartialMessage<PoolRankStats>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "data.v2.PoolRankStats";
@@ -1885,6 +1928,15 @@ export declare class Launch extends Message<Launch> {
      * @generated from field: repeated data.v2.TokenTrade recent_trades = 24;
      */
     recentTrades: TokenTrade[];
+    /**
+     * Badges earned by the launch's token (LP badges), one per badge type,
+     * highest tier only, canonical order. Empty until the token has earned
+     * any (badges are awarded at ingest and by a slow tier cron, so the
+     * common row serves an empty list).
+     *
+     * @generated from field: repeated data.v2.LaunchBadge badges = 25;
+     */
+    badges: LaunchBadge[];
     constructor(data?: PartialMessage<Launch>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "data.v2.Launch";
@@ -1894,6 +1946,54 @@ export declare class Launch extends Message<Launch> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Launch;
     static equals(a: Launch | PlainMessage<Launch> | undefined, b: Launch | PlainMessage<Launch> | undefined): boolean;
 }
+/**
+ * One badge earned by a launch's token. type/tier are deliberately plain
+ * strings, NOT enums: the client contract pins the lowercase ids on the
+ * wire, and proto-JSON would serialize an enum's VALUE NAMES instead.
+ *
+ * @generated from message data.v2.LaunchBadge
+ */
+export declare class LaunchBadge extends Message<LaunchBadge> {
+    /**
+     * "original" | "frontrunner" | "volume" | "holders" | "badger".
+     *
+     * @generated from field: string type = 1;
+     */
+    type: string;
+    /**
+     * Tier id, present only for the tiered types — volume: "5m" | "10m" |
+     * "50m"; holders: "100" | "1k" | "10k". Unset for untiered types.
+     *
+     * @generated from field: optional string tier = 2;
+     */
+    tier?: string;
+    /**
+     * When the badge was earned (proto-JSON serializes this as an ISO-8601
+     * string, which is the client contract). Exact on-chain launch time for
+     * original/frontrunner; observation time for tier crossings.
+     *
+     * @generated from field: google.protobuf.Timestamp earned_at = 3;
+     */
+    earnedAt?: Timestamp;
+    /**
+     * Rarity: percentage (0-100) of eligible tokens that hold this badge
+     * TYPE (any tier), for the client's rarity-tag hover. The denominator is
+     * every factory-launched token (the launched_tokens registry). Served
+     * from a short-TTL cached aggregate; unset when the aggregate is
+     * unavailable — clients hide the rarity detail rather than showing 0.
+     *
+     * @generated from field: optional double holder_percentage = 4;
+     */
+    holderPercentage?: number;
+    constructor(data?: PartialMessage<LaunchBadge>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "data.v2.LaunchBadge";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchBadge;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchBadge;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchBadge;
+    static equals(a: LaunchBadge | PlainMessage<LaunchBadge> | undefined, b: LaunchBadge | PlainMessage<LaunchBadge> | undefined): boolean;
+}
 /**
  * One row of a launch token's holder list (GetLaunchHolders).
  *

package/dist/data/v2/types_pb.js

@@ -4,7 +4,7 @@
 // @ts-nocheck
 import { Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
 import { TimestampedValue, TokenType } from "../v1/types_pb.js";
-import { ProtocolVersion } from "../v1/poolTypes_pb.js";
+import { ProtocolVersion, Token as Token$1 } from "../v1/poolTypes_pb.js";
 /**
  * @generated from enum data.v2.TokensOrderBy
  */
@@ -1174,6 +1174,46 @@ PoolsSort.fields = proto3.util.newFieldList(() => [
     { no: 1, name: "order_by", kind: "enum", T: proto3.getEnumType(PoolsOrderBy), opt: true },
     { no: 2, name: "ascending", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
 ]);
+/**
+ * A pool's boosted APR in one reward token: the sum of that token's live
+ * campaign APRs on the pool, in percent, on top of the pool's fee APR. Ended
+ * campaigns are excluded — they accrue no yield.
+ *
+ * Deliberately carries no campaign detail (windows, allocations, distributed
+ * amounts): only the pool details page renders that, and it reads
+ * GetPoolRewards. Keeping it off this message keeps the per-row payload small
+ * enough to repeat across a page of pools.
+ *
+ * @generated from message data.v2.PoolTokenBoost
+ */
+export class PoolTokenBoost extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: double apr = 2;
+         */
+        this.apr = 0;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new PoolTokenBoost().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new PoolTokenBoost().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new PoolTokenBoost().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(PoolTokenBoost, a, b);
+    }
+}
+PoolTokenBoost.runtime = proto3;
+PoolTokenBoost.typeName = "data.v2.PoolTokenBoost";
+PoolTokenBoost.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "token", kind: "message", T: Token$1 },
+    { no: 2, name: "apr", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+]);
 /**
  * Ranking stats for a pool.
  * apr = annualised fee revenue / TVL.
@@ -1185,6 +1225,19 @@ PoolsSort.fields = proto3.util.newFieldList(() => [
 export class PoolRankStats extends Message {
     constructor(data) {
         super();
+        /**
+         * What reward_apr is paid in, per reward token — so a client can denominate
+         * a boost ("+2.1% in UNI") instead of rendering a bare number under a
+         * guessed symbol. reward_apr stays the cross-token sum and is derived from
+         * these, so reward_apr == sum(token_boosts[].apr) always holds.
+         *
+         * Empty when the pool runs no live campaign, and empty when the incentive
+         * lookup degraded — in which case reward_apr is unset too. Never one
+         * without the other: a boost nobody can denominate is worse than no boost.
+         *
+         * @generated from field: repeated data.v2.PoolTokenBoost token_boosts = 8;
+         */
+        this.tokenBoosts = [];
         proto3.util.initPartial(data, this);
     }
     static fromBinary(bytes, options) {
@@ -1210,6 +1263,7 @@ PoolRankStats.fields = proto3.util.newFieldList(() => [
     { no: 5, name: "reward_apr", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
     { no: 6, name: "total_apr", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
     { no: 7, name: "volume_1d_tvl_ratio", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
+    { no: 8, name: "token_boosts", kind: "message", T: PoolTokenBoost, repeated: true },
 ]);
 /**
  * A pool's protocol identity, token pair, and current on-chain state (state
@@ -1833,6 +1887,15 @@ export class Launch extends Message {
          * @generated from field: repeated data.v2.TokenTrade recent_trades = 24;
          */
         this.recentTrades = [];
+        /**
+         * Badges earned by the launch's token (LP badges), one per badge type,
+         * highest tier only, canonical order. Empty until the token has earned
+         * any (badges are awarded at ingest and by a slow tier cron, so the
+         * common row serves an empty list).
+         *
+         * @generated from field: repeated data.v2.LaunchBadge badges = 25;
+         */
+        this.badges = [];
         proto3.util.initPartial(data, this);
     }
     static fromBinary(bytes, options) {
@@ -1875,6 +1938,46 @@ Launch.fields = proto3.util.newFieldList(() => [
     { no: 22, name: "x_profile_image_url", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 23, name: "x_verified", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
     { no: 24, name: "recent_trades", kind: "message", T: TokenTrade, repeated: true },
+    { no: 25, name: "badges", kind: "message", T: LaunchBadge, repeated: true },
+]);
+/**
+ * One badge earned by a launch's token. type/tier are deliberately plain
+ * strings, NOT enums: the client contract pins the lowercase ids on the
+ * wire, and proto-JSON would serialize an enum's VALUE NAMES instead.
+ *
+ * @generated from message data.v2.LaunchBadge
+ */
+export class LaunchBadge extends Message {
+    constructor(data) {
+        super();
+        /**
+         * "original" | "frontrunner" | "volume" | "holders" | "badger".
+         *
+         * @generated from field: string type = 1;
+         */
+        this.type = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new LaunchBadge().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new LaunchBadge().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new LaunchBadge().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(LaunchBadge, a, b);
+    }
+}
+LaunchBadge.runtime = proto3;
+LaunchBadge.typeName = "data.v2.LaunchBadge";
+LaunchBadge.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "tier", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "earned_at", kind: "message", T: Timestamp },
+    { no: 4, name: "holder_percentage", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
 ]);
 /**
  * One row of a launch token's holder list (GetLaunchHolders).

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

@@ -505,6 +505,15 @@ export declare class Launch extends Message<Launch> {
      * @generated from field: repeated launches.v1.TokenTrade recent_trades = 24;
      */
     recentTrades: TokenTrade[];
+    /**
+     * Badges earned by the launch's token (LP badges), one per badge type,
+     * highest tier only, canonical order. Empty until the token has earned
+     * any (badges are awarded at ingest and by a slow tier cron, so the
+     * common row serves an empty list).
+     *
+     * @generated from field: repeated launches.v1.LaunchBadge badges = 25;
+     */
+    badges: LaunchBadge[];
     constructor(data?: PartialMessage<Launch>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "launches.v1.Launch";
@@ -514,6 +523,54 @@ export declare class Launch extends Message<Launch> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Launch;
     static equals(a: Launch | PlainMessage<Launch> | undefined, b: Launch | PlainMessage<Launch> | undefined): boolean;
 }
+/**
+ * One badge earned by a launch's token. type/tier are deliberately plain
+ * strings, NOT enums: the client contract pins the lowercase ids on the
+ * wire, and proto-JSON would serialize an enum's VALUE NAMES instead.
+ *
+ * @generated from message launches.v1.LaunchBadge
+ */
+export declare class LaunchBadge extends Message<LaunchBadge> {
+    /**
+     * "original" | "frontrunner" | "volume" | "holders" | "badger".
+     *
+     * @generated from field: string type = 1;
+     */
+    type: string;
+    /**
+     * Tier id, present only for the tiered types — volume: "5m" | "10m" |
+     * "50m"; holders: "100" | "1k" | "10k". Unset for untiered types.
+     *
+     * @generated from field: optional string tier = 2;
+     */
+    tier?: string;
+    /**
+     * When the badge was earned (proto-JSON serializes this as an ISO-8601
+     * string, which is the client contract). Exact on-chain launch time for
+     * original/frontrunner; observation time for tier crossings.
+     *
+     * @generated from field: google.protobuf.Timestamp earned_at = 3;
+     */
+    earnedAt?: Timestamp;
+    /**
+     * Rarity: percentage (0-100) of eligible tokens that hold this badge
+     * TYPE (any tier), for the client's rarity-tag hover. The denominator is
+     * every factory-launched token (the launched_tokens registry). Served
+     * from a short-TTL cached aggregate; unset when the aggregate is
+     * unavailable — clients hide the rarity detail rather than showing 0.
+     *
+     * @generated from field: optional double holder_percentage = 4;
+     */
+    holderPercentage?: number;
+    constructor(data?: PartialMessage<LaunchBadge>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "launches.v1.LaunchBadge";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchBadge;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchBadge;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchBadge;
+    static equals(a: LaunchBadge | PlainMessage<LaunchBadge> | undefined, b: LaunchBadge | PlainMessage<LaunchBadge> | undefined): boolean;
+}
 /**
  * One row of a launch token's holder list (GetLaunchHolders).
  *

package/dist/launches/v1/types_pb.js

@@ -401,6 +401,15 @@ export class Launch extends Message {
          * @generated from field: repeated launches.v1.TokenTrade recent_trades = 24;
          */
         this.recentTrades = [];
+        /**
+         * Badges earned by the launch's token (LP badges), one per badge type,
+         * highest tier only, canonical order. Empty until the token has earned
+         * any (badges are awarded at ingest and by a slow tier cron, so the
+         * common row serves an empty list).
+         *
+         * @generated from field: repeated launches.v1.LaunchBadge badges = 25;
+         */
+        this.badges = [];
         proto3.util.initPartial(data, this);
     }
     static fromBinary(bytes, options) {
@@ -443,6 +452,46 @@ Launch.fields = proto3.util.newFieldList(() => [
     { no: 22, name: "x_profile_image_url", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 23, name: "x_verified", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
     { no: 24, name: "recent_trades", kind: "message", T: TokenTrade, repeated: true },
+    { no: 25, name: "badges", kind: "message", T: LaunchBadge, repeated: true },
+]);
+/**
+ * One badge earned by a launch's token. type/tier are deliberately plain
+ * strings, NOT enums: the client contract pins the lowercase ids on the
+ * wire, and proto-JSON would serialize an enum's VALUE NAMES instead.
+ *
+ * @generated from message launches.v1.LaunchBadge
+ */
+export class LaunchBadge extends Message {
+    constructor(data) {
+        super();
+        /**
+         * "original" | "frontrunner" | "volume" | "holders" | "badger".
+         *
+         * @generated from field: string type = 1;
+         */
+        this.type = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new LaunchBadge().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new LaunchBadge().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new LaunchBadge().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(LaunchBadge, a, b);
+    }
+}
+LaunchBadge.runtime = proto3;
+LaunchBadge.typeName = "launches.v1.LaunchBadge";
+LaunchBadge.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "tier", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "earned_at", kind: "message", T: Timestamp },
+    { no: 4, name: "holder_percentage", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
 ]);
 /**
  * One row of a launch token's holder list (GetLaunchHolders).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uniswap/client-data-api",
-    "version": "0.0.228",
+    "version": "0.0.230",
     "publishConfig": {
       "access": "public"
     },