Osmosis MCP Server

import { Gauge, GaugeAmino, GaugeSDKType } from "./gauge"; import { BinaryReader, BinaryWriter } from "../../binary"; /** SplittingPolicy determines the way we want to split incentives in groupGauges */ export declare enum SplittingPolicy { ByVolume = 0, UNRECOGNIZED = -1 } export declare const SplittingPolicySDKType: typeof SplittingPolicy; export declare const SplittingPolicyAmino: typeof SplittingPolicy; export declare function splittingPolicyFromJSON(object: any): SplittingPolicy; export declare function splittingPolicyToJSON(object: SplittingPolicy): string; /** * Note that while both InternalGaugeInfo and InternalGaugeRecord could * technically be replaced by DistrInfo and DistrRecord from the pool-incentives * module, we create separate types here to keep our abstractions clean and * readable (pool-incentives distribution abstractions are used in a very * specific way that does not directly relate to gauge logic). This also helps * us sidestep a refactor to avoid an import cycle. */ export interface InternalGaugeInfo { totalWeight: string; gaugeRecords: InternalGaugeRecord[]; } export interface InternalGaugeInfoProtoMsg { typeUrl: "/osmosis.incentives.InternalGaugeInfo"; value: Uint8Array; } /** * Note that while both InternalGaugeInfo and InternalGaugeRecord could * technically be replaced by DistrInfo and DistrRecord from the pool-incentives * module, we create separate types here to keep our abstractions clean and * readable (pool-incentives distribution abstractions are used in a very * specific way that does not directly relate to gauge logic). This also helps * us sidestep a refactor to avoid an import cycle. */ export interface InternalGaugeInfoAmino { total_weight?: string; gauge_records?: InternalGaugeRecordAmino[]; } export interface InternalGaugeInfoAminoMsg { type: "osmosis/incentives/internal-gauge-info"; value: InternalGaugeInfoAmino; } /** * Note that while both InternalGaugeInfo and InternalGaugeRecord could * technically be replaced by DistrInfo and DistrRecord from the pool-incentives * module, we create separate types here to keep our abstractions clean and * readable (pool-incentives distribution abstractions are used in a very * specific way that does not directly relate to gauge logic). This also helps * us sidestep a refactor to avoid an import cycle. */ export interface InternalGaugeInfoSDKType { total_weight: string; gauge_records: InternalGaugeRecordSDKType[]; } export interface InternalGaugeRecord { gaugeId: bigint; /** * CurrentWeight is the current weight of this gauge being distributed to for * this epoch. For instance, for volume splitting policy, this stores the * volume generated in the last epoch of the linked pool. */ currentWeight: string; /** * CumulativeWeight serves as a snapshot of the accumulator being tracked * based on splitting policy. For instance, for volume splitting policy, this * stores the cumulative volume for the linked pool at time of last update. */ cumulativeWeight: string; } export interface InternalGaugeRecordProtoMsg { typeUrl: "/osmosis.incentives.InternalGaugeRecord"; value: Uint8Array; } export interface InternalGaugeRecordAmino { gauge_id?: string; /** * CurrentWeight is the current weight of this gauge being distributed to for * this epoch. For instance, for volume splitting policy, this stores the * volume generated in the last epoch of the linked pool. */ current_weight?: string; /** * CumulativeWeight serves as a snapshot of the accumulator being tracked * based on splitting policy. For instance, for volume splitting policy, this * stores the cumulative volume for the linked pool at time of last update. */ cumulative_weight?: string; } export interface InternalGaugeRecordAminoMsg { type: "osmosis/incentives/internal-gauge-record"; value: InternalGaugeRecordAmino; } export interface InternalGaugeRecordSDKType { gauge_id: bigint; current_weight: string; cumulative_weight: string; } /** * Group is an object that stores a 1:1 mapped gauge ID, a list of pool gauge * info, and a splitting policy. These are grouped into a single abstraction to * allow for distribution of group incentives to internal gauges according to * the specified splitting policy. */ export interface Group { groupGaugeId: bigint; internalGaugeInfo: InternalGaugeInfo; splittingPolicy: SplittingPolicy; } export interface GroupProtoMsg { typeUrl: "/osmosis.incentives.Group"; value: Uint8Array; } /** * Group is an object that stores a 1:1 mapped gauge ID, a list of pool gauge * info, and a splitting policy. These are grouped into a single abstraction to * allow for distribution of group incentives to internal gauges according to * the specified splitting policy. */ export interface GroupAmino { group_gauge_id?: string; internal_gauge_info?: InternalGaugeInfoAmino; splitting_policy?: SplittingPolicy; } export interface GroupAminoMsg { type: "osmosis/incentives/group"; value: GroupAmino; } /** * Group is an object that stores a 1:1 mapped gauge ID, a list of pool gauge * info, and a splitting policy. These are grouped into a single abstraction to * allow for distribution of group incentives to internal gauges according to * the specified splitting policy. */ export interface GroupSDKType { group_gauge_id: bigint; internal_gauge_info: InternalGaugeInfoSDKType; splitting_policy: SplittingPolicy; } /** * CreateGroup is called via governance to create a new group. * It takes an array of pool IDs to split the incentives across. */ export interface CreateGroup { /** * CreateGroup is called via governance to create a new group. * It takes an array of pool IDs to split the incentives across. */ poolIds: bigint[]; } export interface CreateGroupProtoMsg { typeUrl: "/osmosis.incentives.CreateGroup"; value: Uint8Array; } /** * CreateGroup is called via governance to create a new group. * It takes an array of pool IDs to split the incentives across. */ export interface CreateGroupAmino { /** * CreateGroup is called via governance to create a new group. * It takes an array of pool IDs to split the incentives across. */ pool_ids?: string[]; } export interface CreateGroupAminoMsg { type: "osmosis/incentives/create-group"; value: CreateGroupAmino; } /** * CreateGroup is called via governance to create a new group. * It takes an array of pool IDs to split the incentives across. */ export interface CreateGroupSDKType { pool_ids: bigint[]; } /** * GroupsWithGauge is a helper struct that stores a group and its * associated gauge. */ export interface GroupsWithGauge { group: Group; gauge: Gauge; } export interface GroupsWithGaugeProtoMsg { typeUrl: "/osmosis.incentives.GroupsWithGauge"; value: Uint8Array; } /** * GroupsWithGauge is a helper struct that stores a group and its * associated gauge. */ export interface GroupsWithGaugeAmino { group?: GroupAmino; gauge?: GaugeAmino; } export interface GroupsWithGaugeAminoMsg { type: "osmosis/incentives/groups-with-gauge"; value: GroupsWithGaugeAmino; } /** * GroupsWithGauge is a helper struct that stores a group and its * associated gauge. */ export interface GroupsWithGaugeSDKType { group: GroupSDKType; gauge: GaugeSDKType; } export declare const InternalGaugeInfo: { typeUrl: string; aminoType: string; is(o: any): o is InternalGaugeInfo; isSDK(o: any): o is InternalGaugeInfoSDKType; isAmino(o: any): o is InternalGaugeInfoAmino; encode(message: InternalGaugeInfo, writer?: BinaryWriter): BinaryWriter; decode(input: BinaryReader | Uint8Array, length?: number): InternalGaugeInfo; fromPartial(object: Partial<InternalGaugeInfo>): InternalGaugeInfo; fromAmino(object: InternalGaugeInfoAmino): InternalGaugeInfo; toAmino(message: InternalGaugeInfo): InternalGaugeInfoAmino; fromAminoMsg(object: InternalGaugeInfoAminoMsg): InternalGaugeInfo; toAminoMsg(message: InternalGaugeInfo): InternalGaugeInfoAminoMsg; fromProtoMsg(message: InternalGaugeInfoProtoMsg): InternalGaugeInfo; toProto(message: InternalGaugeInfo): Uint8Array; toProtoMsg(message: InternalGaugeInfo): InternalGaugeInfoProtoMsg; }; export declare const InternalGaugeRecord: { typeUrl: string; aminoType: string; is(o: any): o is InternalGaugeRecord; isSDK(o: any): o is InternalGaugeRecordSDKType; isAmino(o: any): o is InternalGaugeRecordAmino; encode(message: InternalGaugeRecord, writer?: BinaryWriter): BinaryWriter; decode(input: BinaryReader | Uint8Array, length?: number): InternalGaugeRecord; fromPartial(object: Partial<InternalGaugeRecord>): InternalGaugeRecord; fromAmino(object: InternalGaugeRecordAmino): InternalGaugeRecord; toAmino(message: InternalGaugeRecord): InternalGaugeRecordAmino; fromAminoMsg(object: InternalGaugeRecordAminoMsg): InternalGaugeRecord; toAminoMsg(message: InternalGaugeRecord): InternalGaugeRecordAminoMsg; fromProtoMsg(message: InternalGaugeRecordProtoMsg): InternalGaugeRecord; toProto(message: InternalGaugeRecord): Uint8Array; toProtoMsg(message: InternalGaugeRecord): InternalGaugeRecordProtoMsg; }; export declare const Group: { typeUrl: string; aminoType: string; is(o: any): o is Group; isSDK(o: any): o is GroupSDKType; isAmino(o: any): o is GroupAmino; encode(message: Group, writer?: BinaryWriter): BinaryWriter; decode(input: BinaryReader | Uint8Array, length?: number): Group; fromPartial(object: Partial<Group>): Group; fromAmino(object: GroupAmino): Group; toAmino(message: Group): GroupAmino; fromAminoMsg(object: GroupAminoMsg): Group; toAminoMsg(message: Group): GroupAminoMsg; fromProtoMsg(message: GroupProtoMsg): Group; toProto(message: Group): Uint8Array; toProtoMsg(message: Group): GroupProtoMsg; }; export declare const CreateGroup: { typeUrl: string; aminoType: string; is(o: any): o is CreateGroup; isSDK(o: any): o is CreateGroupSDKType; isAmino(o: any): o is CreateGroupAmino; encode(message: CreateGroup, writer?: BinaryWriter): BinaryWriter; decode(input: BinaryReader | Uint8Array, length?: number): CreateGroup; fromPartial(object: Partial<CreateGroup>): CreateGroup; fromAmino(object: CreateGroupAmino): CreateGroup; toAmino(message: CreateGroup): CreateGroupAmino; fromAminoMsg(object: CreateGroupAminoMsg): CreateGroup; toAminoMsg(message: CreateGroup): CreateGroupAminoMsg; fromProtoMsg(message: CreateGroupProtoMsg): CreateGroup; toProto(message: CreateGroup): Uint8Array; toProtoMsg(message: CreateGroup): CreateGroupProtoMsg; }; export declare const GroupsWithGauge: { typeUrl: string; aminoType: string; is(o: any): o is GroupsWithGauge; isSDK(o: any): o is GroupsWithGaugeSDKType; isAmino(o: any): o is GroupsWithGaugeAmino; encode(message: GroupsWithGauge, writer?: BinaryWriter): BinaryWriter; decode(input: BinaryReader | Uint8Array, length?: number): GroupsWithGauge; fromPartial(object: Partial<GroupsWithGauge>): GroupsWithGauge; fromAmino(object: GroupsWithGaugeAmino): GroupsWithGauge; toAmino(message: GroupsWithGauge): GroupsWithGaugeAmino; fromAminoMsg(object: GroupsWithGaugeAminoMsg): GroupsWithGauge; toAminoMsg(message: GroupsWithGauge): GroupsWithGaugeAminoMsg; fromProtoMsg(message: GroupsWithGaugeProtoMsg): GroupsWithGauge; toProto(message: GroupsWithGauge): Uint8Array; toProtoMsg(message: GroupsWithGauge): GroupsWithGaugeProtoMsg; };