Osmosis MCP Server
tx.js•44 kB
//@ts-nocheck
import { ValidatorPreference } from "./state";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { GlobalDecoderRegistry } from "../../../registry";
function createBaseMsgSetValidatorSetPreference() {
return {
delegator: "",
preferences: []
};
}
export const MsgSetValidatorSetPreference = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgSetValidatorSetPreference",
aminoType: "osmosis/MsgSetValidatorSetPreference",
is(o) {
return o && (o.$typeUrl === MsgSetValidatorSetPreference.typeUrl || typeof o.delegator === "string" && Array.isArray(o.preferences) && (!o.preferences.length || ValidatorPreference.is(o.preferences[0])));
},
isSDK(o) {
return o && (o.$typeUrl === MsgSetValidatorSetPreference.typeUrl || typeof o.delegator === "string" && Array.isArray(o.preferences) && (!o.preferences.length || ValidatorPreference.isSDK(o.preferences[0])));
},
isAmino(o) {
return o && (o.$typeUrl === MsgSetValidatorSetPreference.typeUrl || typeof o.delegator === "string" && Array.isArray(o.preferences) && (!o.preferences.length || ValidatorPreference.isAmino(o.preferences[0])));
},
encode(message, writer = BinaryWriter.create()) {
if (message.delegator !== "") {
writer.uint32(10).string(message.delegator);
}
for (const v of message.preferences) {
ValidatorPreference.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgSetValidatorSetPreference();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegator = reader.string();
break;
case 2:
message.preferences.push(ValidatorPreference.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgSetValidatorSetPreference();
message.delegator = object.delegator ?? "";
message.preferences = object.preferences?.map(e => ValidatorPreference.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgSetValidatorSetPreference();
if (object.delegator !== undefined && object.delegator !== null) {
message.delegator = object.delegator;
}
message.preferences = object.preferences?.map(e => ValidatorPreference.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.delegator = message.delegator === "" ? undefined : message.delegator;
if (message.preferences) {
obj.preferences = message.preferences.map(e => e ? ValidatorPreference.toAmino(e) : undefined);
}
else {
obj.preferences = message.preferences;
}
return obj;
},
fromAminoMsg(object) {
return MsgSetValidatorSetPreference.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/MsgSetValidatorSetPreference",
value: MsgSetValidatorSetPreference.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgSetValidatorSetPreference.decode(message.value);
},
toProto(message) {
return MsgSetValidatorSetPreference.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgSetValidatorSetPreference",
value: MsgSetValidatorSetPreference.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgSetValidatorSetPreference.typeUrl, MsgSetValidatorSetPreference);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgSetValidatorSetPreference.aminoType, MsgSetValidatorSetPreference.typeUrl);
function createBaseMsgSetValidatorSetPreferenceResponse() {
return {};
}
export const MsgSetValidatorSetPreferenceResponse = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgSetValidatorSetPreferenceResponse",
aminoType: "osmosis/valsetpref/set-validator-set-preference-response",
is(o) {
return o && o.$typeUrl === MsgSetValidatorSetPreferenceResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgSetValidatorSetPreferenceResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgSetValidatorSetPreferenceResponse.typeUrl;
},
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgSetValidatorSetPreferenceResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgSetValidatorSetPreferenceResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgSetValidatorSetPreferenceResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgSetValidatorSetPreferenceResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/valsetpref/set-validator-set-preference-response",
value: MsgSetValidatorSetPreferenceResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgSetValidatorSetPreferenceResponse.decode(message.value);
},
toProto(message) {
return MsgSetValidatorSetPreferenceResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgSetValidatorSetPreferenceResponse",
value: MsgSetValidatorSetPreferenceResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgSetValidatorSetPreferenceResponse.typeUrl, MsgSetValidatorSetPreferenceResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgSetValidatorSetPreferenceResponse.aminoType, MsgSetValidatorSetPreferenceResponse.typeUrl);
function createBaseMsgDelegateToValidatorSet() {
return {
delegator: "",
coin: Coin.fromPartial({})
};
}
export const MsgDelegateToValidatorSet = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgDelegateToValidatorSet",
aminoType: "osmosis/MsgDelegateToValidatorSet",
is(o) {
return o && (o.$typeUrl === MsgDelegateToValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.is(o.coin));
},
isSDK(o) {
return o && (o.$typeUrl === MsgDelegateToValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.isSDK(o.coin));
},
isAmino(o) {
return o && (o.$typeUrl === MsgDelegateToValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.isAmino(o.coin));
},
encode(message, writer = BinaryWriter.create()) {
if (message.delegator !== "") {
writer.uint32(10).string(message.delegator);
}
if (message.coin !== undefined) {
Coin.encode(message.coin, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgDelegateToValidatorSet();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegator = reader.string();
break;
case 2:
message.coin = Coin.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgDelegateToValidatorSet();
message.delegator = object.delegator ?? "";
message.coin = object.coin !== undefined && object.coin !== null ? Coin.fromPartial(object.coin) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseMsgDelegateToValidatorSet();
if (object.delegator !== undefined && object.delegator !== null) {
message.delegator = object.delegator;
}
if (object.coin !== undefined && object.coin !== null) {
message.coin = Coin.fromAmino(object.coin);
}
return message;
},
toAmino(message) {
const obj = {};
obj.delegator = message.delegator === "" ? undefined : message.delegator;
obj.coin = message.coin ? Coin.toAmino(message.coin) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgDelegateToValidatorSet.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/MsgDelegateToValidatorSet",
value: MsgDelegateToValidatorSet.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgDelegateToValidatorSet.decode(message.value);
},
toProto(message) {
return MsgDelegateToValidatorSet.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgDelegateToValidatorSet",
value: MsgDelegateToValidatorSet.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgDelegateToValidatorSet.typeUrl, MsgDelegateToValidatorSet);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgDelegateToValidatorSet.aminoType, MsgDelegateToValidatorSet.typeUrl);
function createBaseMsgDelegateToValidatorSetResponse() {
return {};
}
export const MsgDelegateToValidatorSetResponse = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgDelegateToValidatorSetResponse",
aminoType: "osmosis/valsetpref/delegate-to-validator-set-response",
is(o) {
return o && o.$typeUrl === MsgDelegateToValidatorSetResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgDelegateToValidatorSetResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgDelegateToValidatorSetResponse.typeUrl;
},
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgDelegateToValidatorSetResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgDelegateToValidatorSetResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgDelegateToValidatorSetResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgDelegateToValidatorSetResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/valsetpref/delegate-to-validator-set-response",
value: MsgDelegateToValidatorSetResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgDelegateToValidatorSetResponse.decode(message.value);
},
toProto(message) {
return MsgDelegateToValidatorSetResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgDelegateToValidatorSetResponse",
value: MsgDelegateToValidatorSetResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgDelegateToValidatorSetResponse.typeUrl, MsgDelegateToValidatorSetResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgDelegateToValidatorSetResponse.aminoType, MsgDelegateToValidatorSetResponse.typeUrl);
function createBaseMsgUndelegateFromValidatorSet() {
return {
delegator: "",
coin: Coin.fromPartial({})
};
}
export const MsgUndelegateFromValidatorSet = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgUndelegateFromValidatorSet",
aminoType: "osmosis/MsgUndelegateFromValidatorSet",
is(o) {
return o && (o.$typeUrl === MsgUndelegateFromValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.is(o.coin));
},
isSDK(o) {
return o && (o.$typeUrl === MsgUndelegateFromValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.isSDK(o.coin));
},
isAmino(o) {
return o && (o.$typeUrl === MsgUndelegateFromValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.isAmino(o.coin));
},
encode(message, writer = BinaryWriter.create()) {
if (message.delegator !== "") {
writer.uint32(10).string(message.delegator);
}
if (message.coin !== undefined) {
Coin.encode(message.coin, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgUndelegateFromValidatorSet();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegator = reader.string();
break;
case 3:
message.coin = Coin.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUndelegateFromValidatorSet();
message.delegator = object.delegator ?? "";
message.coin = object.coin !== undefined && object.coin !== null ? Coin.fromPartial(object.coin) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseMsgUndelegateFromValidatorSet();
if (object.delegator !== undefined && object.delegator !== null) {
message.delegator = object.delegator;
}
if (object.coin !== undefined && object.coin !== null) {
message.coin = Coin.fromAmino(object.coin);
}
return message;
},
toAmino(message) {
const obj = {};
obj.delegator = message.delegator === "" ? undefined : message.delegator;
obj.coin = message.coin ? Coin.toAmino(message.coin) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgUndelegateFromValidatorSet.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/MsgUndelegateFromValidatorSet",
value: MsgUndelegateFromValidatorSet.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUndelegateFromValidatorSet.decode(message.value);
},
toProto(message) {
return MsgUndelegateFromValidatorSet.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgUndelegateFromValidatorSet",
value: MsgUndelegateFromValidatorSet.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUndelegateFromValidatorSet.typeUrl, MsgUndelegateFromValidatorSet);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUndelegateFromValidatorSet.aminoType, MsgUndelegateFromValidatorSet.typeUrl);
function createBaseMsgUndelegateFromValidatorSetResponse() {
return {};
}
export const MsgUndelegateFromValidatorSetResponse = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgUndelegateFromValidatorSetResponse",
aminoType: "osmosis/valsetpref/undelegate-from-validator-set-response",
is(o) {
return o && o.$typeUrl === MsgUndelegateFromValidatorSetResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgUndelegateFromValidatorSetResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgUndelegateFromValidatorSetResponse.typeUrl;
},
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgUndelegateFromValidatorSetResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUndelegateFromValidatorSetResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUndelegateFromValidatorSetResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUndelegateFromValidatorSetResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/valsetpref/undelegate-from-validator-set-response",
value: MsgUndelegateFromValidatorSetResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUndelegateFromValidatorSetResponse.decode(message.value);
},
toProto(message) {
return MsgUndelegateFromValidatorSetResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgUndelegateFromValidatorSetResponse",
value: MsgUndelegateFromValidatorSetResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUndelegateFromValidatorSetResponse.typeUrl, MsgUndelegateFromValidatorSetResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUndelegateFromValidatorSetResponse.aminoType, MsgUndelegateFromValidatorSetResponse.typeUrl);
function createBaseMsgUndelegateFromRebalancedValidatorSet() {
return {
delegator: "",
coin: Coin.fromPartial({})
};
}
export const MsgUndelegateFromRebalancedValidatorSet = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgUndelegateFromRebalancedValidatorSet",
aminoType: "osmosis/MsgUndelegateFromRebalValset",
is(o) {
return o && (o.$typeUrl === MsgUndelegateFromRebalancedValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.is(o.coin));
},
isSDK(o) {
return o && (o.$typeUrl === MsgUndelegateFromRebalancedValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.isSDK(o.coin));
},
isAmino(o) {
return o && (o.$typeUrl === MsgUndelegateFromRebalancedValidatorSet.typeUrl || typeof o.delegator === "string" && Coin.isAmino(o.coin));
},
encode(message, writer = BinaryWriter.create()) {
if (message.delegator !== "") {
writer.uint32(10).string(message.delegator);
}
if (message.coin !== undefined) {
Coin.encode(message.coin, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgUndelegateFromRebalancedValidatorSet();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegator = reader.string();
break;
case 2:
message.coin = Coin.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUndelegateFromRebalancedValidatorSet();
message.delegator = object.delegator ?? "";
message.coin = object.coin !== undefined && object.coin !== null ? Coin.fromPartial(object.coin) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseMsgUndelegateFromRebalancedValidatorSet();
if (object.delegator !== undefined && object.delegator !== null) {
message.delegator = object.delegator;
}
if (object.coin !== undefined && object.coin !== null) {
message.coin = Coin.fromAmino(object.coin);
}
return message;
},
toAmino(message) {
const obj = {};
obj.delegator = message.delegator === "" ? undefined : message.delegator;
obj.coin = message.coin ? Coin.toAmino(message.coin) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgUndelegateFromRebalancedValidatorSet.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/MsgUndelegateFromRebalValset",
value: MsgUndelegateFromRebalancedValidatorSet.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUndelegateFromRebalancedValidatorSet.decode(message.value);
},
toProto(message) {
return MsgUndelegateFromRebalancedValidatorSet.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgUndelegateFromRebalancedValidatorSet",
value: MsgUndelegateFromRebalancedValidatorSet.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUndelegateFromRebalancedValidatorSet.typeUrl, MsgUndelegateFromRebalancedValidatorSet);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUndelegateFromRebalancedValidatorSet.aminoType, MsgUndelegateFromRebalancedValidatorSet.typeUrl);
function createBaseMsgUndelegateFromRebalancedValidatorSetResponse() {
return {};
}
export const MsgUndelegateFromRebalancedValidatorSetResponse = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgUndelegateFromRebalancedValidatorSetResponse",
aminoType: "osmosis/valsetpref/undelegate-from-rebalanced-validator-set-response",
is(o) {
return o && o.$typeUrl === MsgUndelegateFromRebalancedValidatorSetResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgUndelegateFromRebalancedValidatorSetResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgUndelegateFromRebalancedValidatorSetResponse.typeUrl;
},
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgUndelegateFromRebalancedValidatorSetResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUndelegateFromRebalancedValidatorSetResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUndelegateFromRebalancedValidatorSetResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUndelegateFromRebalancedValidatorSetResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/valsetpref/undelegate-from-rebalanced-validator-set-response",
value: MsgUndelegateFromRebalancedValidatorSetResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUndelegateFromRebalancedValidatorSetResponse.decode(message.value);
},
toProto(message) {
return MsgUndelegateFromRebalancedValidatorSetResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgUndelegateFromRebalancedValidatorSetResponse",
value: MsgUndelegateFromRebalancedValidatorSetResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUndelegateFromRebalancedValidatorSetResponse.typeUrl, MsgUndelegateFromRebalancedValidatorSetResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUndelegateFromRebalancedValidatorSetResponse.aminoType, MsgUndelegateFromRebalancedValidatorSetResponse.typeUrl);
function createBaseMsgRedelegateValidatorSet() {
return {
delegator: "",
preferences: []
};
}
export const MsgRedelegateValidatorSet = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgRedelegateValidatorSet",
aminoType: "osmosis/MsgRedelegateValidatorSet",
is(o) {
return o && (o.$typeUrl === MsgRedelegateValidatorSet.typeUrl || typeof o.delegator === "string" && Array.isArray(o.preferences) && (!o.preferences.length || ValidatorPreference.is(o.preferences[0])));
},
isSDK(o) {
return o && (o.$typeUrl === MsgRedelegateValidatorSet.typeUrl || typeof o.delegator === "string" && Array.isArray(o.preferences) && (!o.preferences.length || ValidatorPreference.isSDK(o.preferences[0])));
},
isAmino(o) {
return o && (o.$typeUrl === MsgRedelegateValidatorSet.typeUrl || typeof o.delegator === "string" && Array.isArray(o.preferences) && (!o.preferences.length || ValidatorPreference.isAmino(o.preferences[0])));
},
encode(message, writer = BinaryWriter.create()) {
if (message.delegator !== "") {
writer.uint32(10).string(message.delegator);
}
for (const v of message.preferences) {
ValidatorPreference.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgRedelegateValidatorSet();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegator = reader.string();
break;
case 2:
message.preferences.push(ValidatorPreference.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgRedelegateValidatorSet();
message.delegator = object.delegator ?? "";
message.preferences = object.preferences?.map(e => ValidatorPreference.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgRedelegateValidatorSet();
if (object.delegator !== undefined && object.delegator !== null) {
message.delegator = object.delegator;
}
message.preferences = object.preferences?.map(e => ValidatorPreference.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.delegator = message.delegator === "" ? undefined : message.delegator;
if (message.preferences) {
obj.preferences = message.preferences.map(e => e ? ValidatorPreference.toAmino(e) : undefined);
}
else {
obj.preferences = message.preferences;
}
return obj;
},
fromAminoMsg(object) {
return MsgRedelegateValidatorSet.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/MsgRedelegateValidatorSet",
value: MsgRedelegateValidatorSet.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgRedelegateValidatorSet.decode(message.value);
},
toProto(message) {
return MsgRedelegateValidatorSet.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgRedelegateValidatorSet",
value: MsgRedelegateValidatorSet.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgRedelegateValidatorSet.typeUrl, MsgRedelegateValidatorSet);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgRedelegateValidatorSet.aminoType, MsgRedelegateValidatorSet.typeUrl);
function createBaseMsgRedelegateValidatorSetResponse() {
return {};
}
export const MsgRedelegateValidatorSetResponse = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgRedelegateValidatorSetResponse",
aminoType: "osmosis/valsetpref/redelegate-validator-set-response",
is(o) {
return o && o.$typeUrl === MsgRedelegateValidatorSetResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgRedelegateValidatorSetResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgRedelegateValidatorSetResponse.typeUrl;
},
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgRedelegateValidatorSetResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgRedelegateValidatorSetResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgRedelegateValidatorSetResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgRedelegateValidatorSetResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/valsetpref/redelegate-validator-set-response",
value: MsgRedelegateValidatorSetResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgRedelegateValidatorSetResponse.decode(message.value);
},
toProto(message) {
return MsgRedelegateValidatorSetResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgRedelegateValidatorSetResponse",
value: MsgRedelegateValidatorSetResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgRedelegateValidatorSetResponse.typeUrl, MsgRedelegateValidatorSetResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgRedelegateValidatorSetResponse.aminoType, MsgRedelegateValidatorSetResponse.typeUrl);
function createBaseMsgWithdrawDelegationRewards() {
return {
delegator: ""
};
}
export const MsgWithdrawDelegationRewards = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgWithdrawDelegationRewards",
aminoType: "osmosis/MsgWithdrawDelegationRewards",
is(o) {
return o && (o.$typeUrl === MsgWithdrawDelegationRewards.typeUrl || typeof o.delegator === "string");
},
isSDK(o) {
return o && (o.$typeUrl === MsgWithdrawDelegationRewards.typeUrl || typeof o.delegator === "string");
},
isAmino(o) {
return o && (o.$typeUrl === MsgWithdrawDelegationRewards.typeUrl || typeof o.delegator === "string");
},
encode(message, writer = BinaryWriter.create()) {
if (message.delegator !== "") {
writer.uint32(10).string(message.delegator);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgWithdrawDelegationRewards();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegator = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgWithdrawDelegationRewards();
message.delegator = object.delegator ?? "";
return message;
},
fromAmino(object) {
const message = createBaseMsgWithdrawDelegationRewards();
if (object.delegator !== undefined && object.delegator !== null) {
message.delegator = object.delegator;
}
return message;
},
toAmino(message) {
const obj = {};
obj.delegator = message.delegator === "" ? undefined : message.delegator;
return obj;
},
fromAminoMsg(object) {
return MsgWithdrawDelegationRewards.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/MsgWithdrawDelegationRewards",
value: MsgWithdrawDelegationRewards.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgWithdrawDelegationRewards.decode(message.value);
},
toProto(message) {
return MsgWithdrawDelegationRewards.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgWithdrawDelegationRewards",
value: MsgWithdrawDelegationRewards.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgWithdrawDelegationRewards.typeUrl, MsgWithdrawDelegationRewards);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgWithdrawDelegationRewards.aminoType, MsgWithdrawDelegationRewards.typeUrl);
function createBaseMsgWithdrawDelegationRewardsResponse() {
return {};
}
export const MsgWithdrawDelegationRewardsResponse = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgWithdrawDelegationRewardsResponse",
aminoType: "osmosis/valsetpref/withdraw-delegation-rewards-response",
is(o) {
return o && o.$typeUrl === MsgWithdrawDelegationRewardsResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgWithdrawDelegationRewardsResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgWithdrawDelegationRewardsResponse.typeUrl;
},
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgWithdrawDelegationRewardsResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgWithdrawDelegationRewardsResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgWithdrawDelegationRewardsResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgWithdrawDelegationRewardsResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/valsetpref/withdraw-delegation-rewards-response",
value: MsgWithdrawDelegationRewardsResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgWithdrawDelegationRewardsResponse.decode(message.value);
},
toProto(message) {
return MsgWithdrawDelegationRewardsResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgWithdrawDelegationRewardsResponse",
value: MsgWithdrawDelegationRewardsResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgWithdrawDelegationRewardsResponse.typeUrl, MsgWithdrawDelegationRewardsResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgWithdrawDelegationRewardsResponse.aminoType, MsgWithdrawDelegationRewardsResponse.typeUrl);
function createBaseMsgDelegateBondedTokens() {
return {
delegator: "",
lockID: BigInt(0)
};
}
export const MsgDelegateBondedTokens = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgDelegateBondedTokens",
aminoType: "osmosis/valsetpref/delegate-bonded-tokens",
is(o) {
return o && (o.$typeUrl === MsgDelegateBondedTokens.typeUrl || typeof o.delegator === "string" && typeof o.lockID === "bigint");
},
isSDK(o) {
return o && (o.$typeUrl === MsgDelegateBondedTokens.typeUrl || typeof o.delegator === "string" && typeof o.lockID === "bigint");
},
isAmino(o) {
return o && (o.$typeUrl === MsgDelegateBondedTokens.typeUrl || typeof o.delegator === "string" && typeof o.lockID === "bigint");
},
encode(message, writer = BinaryWriter.create()) {
if (message.delegator !== "") {
writer.uint32(10).string(message.delegator);
}
if (message.lockID !== BigInt(0)) {
writer.uint32(16).uint64(message.lockID);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgDelegateBondedTokens();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegator = reader.string();
break;
case 2:
message.lockID = reader.uint64();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgDelegateBondedTokens();
message.delegator = object.delegator ?? "";
message.lockID = object.lockID !== undefined && object.lockID !== null ? BigInt(object.lockID.toString()) : BigInt(0);
return message;
},
fromAmino(object) {
const message = createBaseMsgDelegateBondedTokens();
if (object.delegator !== undefined && object.delegator !== null) {
message.delegator = object.delegator;
}
if (object.lockID !== undefined && object.lockID !== null) {
message.lockID = BigInt(object.lockID);
}
return message;
},
toAmino(message) {
const obj = {};
obj.delegator = message.delegator === "" ? undefined : message.delegator;
obj.lockID = message.lockID !== BigInt(0) ? message.lockID.toString() : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgDelegateBondedTokens.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/valsetpref/delegate-bonded-tokens",
value: MsgDelegateBondedTokens.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgDelegateBondedTokens.decode(message.value);
},
toProto(message) {
return MsgDelegateBondedTokens.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgDelegateBondedTokens",
value: MsgDelegateBondedTokens.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgDelegateBondedTokens.typeUrl, MsgDelegateBondedTokens);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgDelegateBondedTokens.aminoType, MsgDelegateBondedTokens.typeUrl);
function createBaseMsgDelegateBondedTokensResponse() {
return {};
}
export const MsgDelegateBondedTokensResponse = {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgDelegateBondedTokensResponse",
aminoType: "osmosis/valsetpref/delegate-bonded-tokens-response",
is(o) {
return o && o.$typeUrl === MsgDelegateBondedTokensResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgDelegateBondedTokensResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgDelegateBondedTokensResponse.typeUrl;
},
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgDelegateBondedTokensResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgDelegateBondedTokensResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgDelegateBondedTokensResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgDelegateBondedTokensResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/valsetpref/delegate-bonded-tokens-response",
value: MsgDelegateBondedTokensResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgDelegateBondedTokensResponse.decode(message.value);
},
toProto(message) {
return MsgDelegateBondedTokensResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.valsetpref.v1beta1.MsgDelegateBondedTokensResponse",
value: MsgDelegateBondedTokensResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgDelegateBondedTokensResponse.typeUrl, MsgDelegateBondedTokensResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgDelegateBondedTokensResponse.aminoType, MsgDelegateBondedTokensResponse.typeUrl);
Latest Blog Posts
- MCP Moves to the Linux Foundation: Neutral Stewardship for Agentic InfrastructureBy Om-Shree-0709 on .mcpanthropicLinux Foundation
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/MyronKoch-dev/osmosis-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server