Osmosis MCP Server
tx.js•23 kB
//@ts-nocheck
import { BinaryReader, BinaryWriter } from "../../../binary";
import { bytesFromBase64, base64FromBytes } from "../../../helpers";
import { GlobalDecoderRegistry } from "../../../registry";
function createBaseMsgAddAuthenticator() {
return {
sender: "",
type: "",
data: new Uint8Array()
};
}
export const MsgAddAuthenticator = {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgAddAuthenticator",
aminoType: "osmosis/smartaccount/add-authenticator",
is(o) {
return o && (o.$typeUrl === MsgAddAuthenticator.typeUrl || typeof o.sender === "string" && typeof o.type === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgAddAuthenticator.typeUrl || typeof o.sender === "string" && typeof o.type === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgAddAuthenticator.typeUrl || typeof o.sender === "string" && typeof o.type === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.type !== "") {
writer.uint32(18).string(message.type);
}
if (message.data.length !== 0) {
writer.uint32(26).bytes(message.data);
}
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 = createBaseMsgAddAuthenticator();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.type = reader.string();
break;
case 3:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgAddAuthenticator();
message.sender = object.sender ?? "";
message.type = object.type ?? "";
message.data = object.data ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgAddAuthenticator();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.type !== undefined && object.type !== null) {
message.type = object.type;
}
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.type = message.type === "" ? undefined : message.type;
obj.data = message.data ? base64FromBytes(message.data) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgAddAuthenticator.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/smartaccount/add-authenticator",
value: MsgAddAuthenticator.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgAddAuthenticator.decode(message.value);
},
toProto(message) {
return MsgAddAuthenticator.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgAddAuthenticator",
value: MsgAddAuthenticator.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgAddAuthenticator.typeUrl, MsgAddAuthenticator);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgAddAuthenticator.aminoType, MsgAddAuthenticator.typeUrl);
function createBaseMsgAddAuthenticatorResponse() {
return {
success: false
};
}
export const MsgAddAuthenticatorResponse = {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgAddAuthenticatorResponse",
aminoType: "osmosis/smartaccount/add-authenticator-response",
is(o) {
return o && (o.$typeUrl === MsgAddAuthenticatorResponse.typeUrl || typeof o.success === "boolean");
},
isSDK(o) {
return o && (o.$typeUrl === MsgAddAuthenticatorResponse.typeUrl || typeof o.success === "boolean");
},
isAmino(o) {
return o && (o.$typeUrl === MsgAddAuthenticatorResponse.typeUrl || typeof o.success === "boolean");
},
encode(message, writer = BinaryWriter.create()) {
if (message.success === true) {
writer.uint32(8).bool(message.success);
}
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 = createBaseMsgAddAuthenticatorResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.success = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgAddAuthenticatorResponse();
message.success = object.success ?? false;
return message;
},
fromAmino(object) {
const message = createBaseMsgAddAuthenticatorResponse();
if (object.success !== undefined && object.success !== null) {
message.success = object.success;
}
return message;
},
toAmino(message) {
const obj = {};
obj.success = message.success === false ? undefined : message.success;
return obj;
},
fromAminoMsg(object) {
return MsgAddAuthenticatorResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/smartaccount/add-authenticator-response",
value: MsgAddAuthenticatorResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgAddAuthenticatorResponse.decode(message.value);
},
toProto(message) {
return MsgAddAuthenticatorResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgAddAuthenticatorResponse",
value: MsgAddAuthenticatorResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgAddAuthenticatorResponse.typeUrl, MsgAddAuthenticatorResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgAddAuthenticatorResponse.aminoType, MsgAddAuthenticatorResponse.typeUrl);
function createBaseMsgRemoveAuthenticator() {
return {
sender: "",
id: BigInt(0)
};
}
export const MsgRemoveAuthenticator = {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgRemoveAuthenticator",
aminoType: "osmosis/smartaccount/remove-authenticator",
is(o) {
return o && (o.$typeUrl === MsgRemoveAuthenticator.typeUrl || typeof o.sender === "string" && typeof o.id === "bigint");
},
isSDK(o) {
return o && (o.$typeUrl === MsgRemoveAuthenticator.typeUrl || typeof o.sender === "string" && typeof o.id === "bigint");
},
isAmino(o) {
return o && (o.$typeUrl === MsgRemoveAuthenticator.typeUrl || typeof o.sender === "string" && typeof o.id === "bigint");
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.id !== BigInt(0)) {
writer.uint32(16).uint64(message.id);
}
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 = createBaseMsgRemoveAuthenticator();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.id = reader.uint64();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgRemoveAuthenticator();
message.sender = object.sender ?? "";
message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
return message;
},
fromAmino(object) {
const message = createBaseMsgRemoveAuthenticator();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.id !== undefined && object.id !== null) {
message.id = BigInt(object.id);
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.id = message.id !== BigInt(0) ? message.id.toString() : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgRemoveAuthenticator.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/smartaccount/remove-authenticator",
value: MsgRemoveAuthenticator.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgRemoveAuthenticator.decode(message.value);
},
toProto(message) {
return MsgRemoveAuthenticator.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgRemoveAuthenticator",
value: MsgRemoveAuthenticator.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgRemoveAuthenticator.typeUrl, MsgRemoveAuthenticator);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgRemoveAuthenticator.aminoType, MsgRemoveAuthenticator.typeUrl);
function createBaseMsgRemoveAuthenticatorResponse() {
return {
success: false
};
}
export const MsgRemoveAuthenticatorResponse = {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgRemoveAuthenticatorResponse",
aminoType: "osmosis/smartaccount/remove-authenticator-response",
is(o) {
return o && (o.$typeUrl === MsgRemoveAuthenticatorResponse.typeUrl || typeof o.success === "boolean");
},
isSDK(o) {
return o && (o.$typeUrl === MsgRemoveAuthenticatorResponse.typeUrl || typeof o.success === "boolean");
},
isAmino(o) {
return o && (o.$typeUrl === MsgRemoveAuthenticatorResponse.typeUrl || typeof o.success === "boolean");
},
encode(message, writer = BinaryWriter.create()) {
if (message.success === true) {
writer.uint32(8).bool(message.success);
}
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 = createBaseMsgRemoveAuthenticatorResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.success = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgRemoveAuthenticatorResponse();
message.success = object.success ?? false;
return message;
},
fromAmino(object) {
const message = createBaseMsgRemoveAuthenticatorResponse();
if (object.success !== undefined && object.success !== null) {
message.success = object.success;
}
return message;
},
toAmino(message) {
const obj = {};
obj.success = message.success === false ? undefined : message.success;
return obj;
},
fromAminoMsg(object) {
return MsgRemoveAuthenticatorResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/smartaccount/remove-authenticator-response",
value: MsgRemoveAuthenticatorResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgRemoveAuthenticatorResponse.decode(message.value);
},
toProto(message) {
return MsgRemoveAuthenticatorResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgRemoveAuthenticatorResponse",
value: MsgRemoveAuthenticatorResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgRemoveAuthenticatorResponse.typeUrl, MsgRemoveAuthenticatorResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgRemoveAuthenticatorResponse.aminoType, MsgRemoveAuthenticatorResponse.typeUrl);
function createBaseMsgSetActiveState() {
return {
sender: "",
active: false
};
}
export const MsgSetActiveState = {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgSetActiveState",
aminoType: "osmosis/smartaccount/set-active-state",
is(o) {
return o && (o.$typeUrl === MsgSetActiveState.typeUrl || typeof o.sender === "string" && typeof o.active === "boolean");
},
isSDK(o) {
return o && (o.$typeUrl === MsgSetActiveState.typeUrl || typeof o.sender === "string" && typeof o.active === "boolean");
},
isAmino(o) {
return o && (o.$typeUrl === MsgSetActiveState.typeUrl || typeof o.sender === "string" && typeof o.active === "boolean");
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.active === true) {
writer.uint32(16).bool(message.active);
}
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 = createBaseMsgSetActiveState();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.active = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgSetActiveState();
message.sender = object.sender ?? "";
message.active = object.active ?? false;
return message;
},
fromAmino(object) {
const message = createBaseMsgSetActiveState();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.active !== undefined && object.active !== null) {
message.active = object.active;
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.active = message.active === false ? undefined : message.active;
return obj;
},
fromAminoMsg(object) {
return MsgSetActiveState.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/smartaccount/set-active-state",
value: MsgSetActiveState.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgSetActiveState.decode(message.value);
},
toProto(message) {
return MsgSetActiveState.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgSetActiveState",
value: MsgSetActiveState.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgSetActiveState.typeUrl, MsgSetActiveState);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgSetActiveState.aminoType, MsgSetActiveState.typeUrl);
function createBaseMsgSetActiveStateResponse() {
return {};
}
export const MsgSetActiveStateResponse = {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgSetActiveStateResponse",
aminoType: "osmosis/smartaccount/set-active-state-response",
is(o) {
return o && o.$typeUrl === MsgSetActiveStateResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgSetActiveStateResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgSetActiveStateResponse.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 = createBaseMsgSetActiveStateResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgSetActiveStateResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgSetActiveStateResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgSetActiveStateResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/smartaccount/set-active-state-response",
value: MsgSetActiveStateResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgSetActiveStateResponse.decode(message.value);
},
toProto(message) {
return MsgSetActiveStateResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.smartaccount.v1beta1.MsgSetActiveStateResponse",
value: MsgSetActiveStateResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgSetActiveStateResponse.typeUrl, MsgSetActiveStateResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgSetActiveStateResponse.aminoType, MsgSetActiveStateResponse.typeUrl);
function createBaseTxExtension() {
return {
selectedAuthenticators: []
};
}
export const TxExtension = {
typeUrl: "/osmosis.smartaccount.v1beta1.TxExtension",
aminoType: "osmosis/smartaccount/tx-extension",
is(o) {
return o && (o.$typeUrl === TxExtension.typeUrl || Array.isArray(o.selectedAuthenticators) && (!o.selectedAuthenticators.length || typeof o.selectedAuthenticators[0] === "bigint"));
},
isSDK(o) {
return o && (o.$typeUrl === TxExtension.typeUrl || Array.isArray(o.selected_authenticators) && (!o.selected_authenticators.length || typeof o.selected_authenticators[0] === "bigint"));
},
isAmino(o) {
return o && (o.$typeUrl === TxExtension.typeUrl || Array.isArray(o.selected_authenticators) && (!o.selected_authenticators.length || typeof o.selected_authenticators[0] === "bigint"));
},
encode(message, writer = BinaryWriter.create()) {
writer.uint32(10).fork();
for (const v of message.selectedAuthenticators) {
writer.uint64(v);
}
writer.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 = createBaseTxExtension();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.selectedAuthenticators.push(reader.uint64());
}
}
else {
message.selectedAuthenticators.push(reader.uint64());
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseTxExtension();
message.selectedAuthenticators = object.selectedAuthenticators?.map(e => BigInt(e.toString())) || [];
return message;
},
fromAmino(object) {
const message = createBaseTxExtension();
message.selectedAuthenticators = object.selected_authenticators?.map(e => BigInt(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
if (message.selectedAuthenticators) {
obj.selected_authenticators = message.selectedAuthenticators.map(e => e.toString());
}
else {
obj.selected_authenticators = message.selectedAuthenticators;
}
return obj;
},
fromAminoMsg(object) {
return TxExtension.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "osmosis/smartaccount/tx-extension",
value: TxExtension.toAmino(message)
};
},
fromProtoMsg(message) {
return TxExtension.decode(message.value);
},
toProto(message) {
return TxExtension.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/osmosis.smartaccount.v1beta1.TxExtension",
value: TxExtension.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(TxExtension.typeUrl, TxExtension);
GlobalDecoderRegistry.registerAminoProtoMapping(TxExtension.aminoType, TxExtension.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