Osmosis MCP Server
tx.js•132 kB
//@ts-nocheck
import { AccessConfig, Params } from "./types";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { fromBase64, toBase64, toUtf8, fromUtf8 } from "@cosmjs/encoding";
import { GlobalDecoderRegistry } from "../../../registry";
import { bytesFromBase64, base64FromBytes } from "../../../helpers";
function createBaseMsgStoreCode() {
return {
sender: "",
wasmByteCode: new Uint8Array(),
instantiatePermission: undefined
};
}
export const MsgStoreCode = {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreCode",
aminoType: "wasm/MsgStoreCode",
is(o) {
return o && (o.$typeUrl === MsgStoreCode.typeUrl || typeof o.sender === "string" && (o.wasmByteCode instanceof Uint8Array || typeof o.wasmByteCode === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgStoreCode.typeUrl || typeof o.sender === "string" && (o.wasm_byte_code instanceof Uint8Array || typeof o.wasm_byte_code === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgStoreCode.typeUrl || typeof o.sender === "string" && (o.wasm_byte_code instanceof Uint8Array || typeof o.wasm_byte_code === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.wasmByteCode.length !== 0) {
writer.uint32(18).bytes(message.wasmByteCode);
}
if (message.instantiatePermission !== undefined) {
AccessConfig.encode(message.instantiatePermission, writer.uint32(42).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 = createBaseMsgStoreCode();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.wasmByteCode = reader.bytes();
break;
case 5:
message.instantiatePermission = AccessConfig.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgStoreCode();
message.sender = object.sender ?? "";
message.wasmByteCode = object.wasmByteCode ?? new Uint8Array();
message.instantiatePermission = object.instantiatePermission !== undefined && object.instantiatePermission !== null ? AccessConfig.fromPartial(object.instantiatePermission) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseMsgStoreCode();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.wasm_byte_code !== undefined && object.wasm_byte_code !== null) {
message.wasmByteCode = fromBase64(object.wasm_byte_code);
}
if (object.instantiate_permission !== undefined && object.instantiate_permission !== null) {
message.instantiatePermission = AccessConfig.fromAmino(object.instantiate_permission);
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.wasm_byte_code = message.wasmByteCode ? toBase64(message.wasmByteCode) : undefined;
obj.instantiate_permission = message.instantiatePermission ? AccessConfig.toAmino(message.instantiatePermission) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgStoreCode.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgStoreCode",
value: MsgStoreCode.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgStoreCode.decode(message.value);
},
toProto(message) {
return MsgStoreCode.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreCode",
value: MsgStoreCode.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgStoreCode.typeUrl, MsgStoreCode);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgStoreCode.aminoType, MsgStoreCode.typeUrl);
function createBaseMsgStoreCodeResponse() {
return {
codeId: BigInt(0),
checksum: new Uint8Array()
};
}
export const MsgStoreCodeResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreCodeResponse",
aminoType: "wasm/MsgStoreCodeResponse",
is(o) {
return o && (o.$typeUrl === MsgStoreCodeResponse.typeUrl || typeof o.codeId === "bigint" && (o.checksum instanceof Uint8Array || typeof o.checksum === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgStoreCodeResponse.typeUrl || typeof o.code_id === "bigint" && (o.checksum instanceof Uint8Array || typeof o.checksum === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgStoreCodeResponse.typeUrl || typeof o.code_id === "bigint" && (o.checksum instanceof Uint8Array || typeof o.checksum === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.codeId !== BigInt(0)) {
writer.uint32(8).uint64(message.codeId);
}
if (message.checksum.length !== 0) {
writer.uint32(18).bytes(message.checksum);
}
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 = createBaseMsgStoreCodeResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.codeId = reader.uint64();
break;
case 2:
message.checksum = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgStoreCodeResponse();
message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
message.checksum = object.checksum ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgStoreCodeResponse();
if (object.code_id !== undefined && object.code_id !== null) {
message.codeId = BigInt(object.code_id);
}
if (object.checksum !== undefined && object.checksum !== null) {
message.checksum = bytesFromBase64(object.checksum);
}
return message;
},
toAmino(message) {
const obj = {};
obj.code_id = message.codeId !== BigInt(0) ? message.codeId.toString() : undefined;
obj.checksum = message.checksum ? base64FromBytes(message.checksum) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgStoreCodeResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgStoreCodeResponse",
value: MsgStoreCodeResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgStoreCodeResponse.decode(message.value);
},
toProto(message) {
return MsgStoreCodeResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreCodeResponse",
value: MsgStoreCodeResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgStoreCodeResponse.typeUrl, MsgStoreCodeResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgStoreCodeResponse.aminoType, MsgStoreCodeResponse.typeUrl);
function createBaseMsgInstantiateContract() {
return {
sender: "",
admin: "",
codeId: BigInt(0),
label: "",
msg: new Uint8Array(),
funds: []
};
}
export const MsgInstantiateContract = {
typeUrl: "/cosmwasm.wasm.v1.MsgInstantiateContract",
aminoType: "wasm/MsgInstantiateContract",
is(o) {
return o && (o.$typeUrl === MsgInstantiateContract.typeUrl || typeof o.sender === "string" && typeof o.admin === "string" && typeof o.codeId === "bigint" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.is(o.funds[0])));
},
isSDK(o) {
return o && (o.$typeUrl === MsgInstantiateContract.typeUrl || typeof o.sender === "string" && typeof o.admin === "string" && typeof o.code_id === "bigint" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.isSDK(o.funds[0])));
},
isAmino(o) {
return o && (o.$typeUrl === MsgInstantiateContract.typeUrl || typeof o.sender === "string" && typeof o.admin === "string" && typeof o.code_id === "bigint" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.isAmino(o.funds[0])));
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.admin !== "") {
writer.uint32(18).string(message.admin);
}
if (message.codeId !== BigInt(0)) {
writer.uint32(24).uint64(message.codeId);
}
if (message.label !== "") {
writer.uint32(34).string(message.label);
}
if (message.msg.length !== 0) {
writer.uint32(42).bytes(message.msg);
}
for (const v of message.funds) {
Coin.encode(v, writer.uint32(50).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 = createBaseMsgInstantiateContract();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.admin = reader.string();
break;
case 3:
message.codeId = reader.uint64();
break;
case 4:
message.label = reader.string();
break;
case 5:
message.msg = reader.bytes();
break;
case 6:
message.funds.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgInstantiateContract();
message.sender = object.sender ?? "";
message.admin = object.admin ?? "";
message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
message.label = object.label ?? "";
message.msg = object.msg ?? new Uint8Array();
message.funds = object.funds?.map(e => Coin.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgInstantiateContract();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.admin !== undefined && object.admin !== null) {
message.admin = object.admin;
}
if (object.code_id !== undefined && object.code_id !== null) {
message.codeId = BigInt(object.code_id);
}
if (object.label !== undefined && object.label !== null) {
message.label = object.label;
}
if (object.msg !== undefined && object.msg !== null) {
message.msg = toUtf8(JSON.stringify(object.msg));
}
message.funds = object.funds?.map(e => Coin.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.admin = message.admin === "" ? undefined : message.admin;
obj.code_id = message.codeId !== BigInt(0) ? message.codeId.toString() : undefined;
obj.label = message.label === "" ? undefined : message.label;
obj.msg = message.msg ? JSON.parse(fromUtf8(message.msg)) : undefined;
if (message.funds) {
obj.funds = message.funds.map(e => e ? Coin.toAmino(e) : undefined);
}
else {
obj.funds = message.funds;
}
return obj;
},
fromAminoMsg(object) {
return MsgInstantiateContract.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgInstantiateContract",
value: MsgInstantiateContract.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgInstantiateContract.decode(message.value);
},
toProto(message) {
return MsgInstantiateContract.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgInstantiateContract",
value: MsgInstantiateContract.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgInstantiateContract.typeUrl, MsgInstantiateContract);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgInstantiateContract.aminoType, MsgInstantiateContract.typeUrl);
function createBaseMsgInstantiateContractResponse() {
return {
address: "",
data: new Uint8Array()
};
}
export const MsgInstantiateContractResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgInstantiateContractResponse",
aminoType: "wasm/MsgInstantiateContractResponse",
is(o) {
return o && (o.$typeUrl === MsgInstantiateContractResponse.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgInstantiateContractResponse.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgInstantiateContractResponse.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.address !== "") {
writer.uint32(10).string(message.address);
}
if (message.data.length !== 0) {
writer.uint32(18).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 = createBaseMsgInstantiateContractResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.address = reader.string();
break;
case 2:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgInstantiateContractResponse();
message.address = object.address ?? "";
message.data = object.data ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgInstantiateContractResponse();
if (object.address !== undefined && object.address !== null) {
message.address = object.address;
}
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toAmino(message) {
const obj = {};
obj.address = message.address === "" ? undefined : message.address;
obj.data = message.data ? base64FromBytes(message.data) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgInstantiateContractResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgInstantiateContractResponse",
value: MsgInstantiateContractResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgInstantiateContractResponse.decode(message.value);
},
toProto(message) {
return MsgInstantiateContractResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgInstantiateContractResponse",
value: MsgInstantiateContractResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgInstantiateContractResponse.typeUrl, MsgInstantiateContractResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgInstantiateContractResponse.aminoType, MsgInstantiateContractResponse.typeUrl);
function createBaseMsgInstantiateContract2() {
return {
sender: "",
admin: "",
codeId: BigInt(0),
label: "",
msg: new Uint8Array(),
funds: [],
salt: new Uint8Array(),
fixMsg: false
};
}
export const MsgInstantiateContract2 = {
typeUrl: "/cosmwasm.wasm.v1.MsgInstantiateContract2",
aminoType: "wasm/MsgInstantiateContract2",
is(o) {
return o && (o.$typeUrl === MsgInstantiateContract2.typeUrl || typeof o.sender === "string" && typeof o.admin === "string" && typeof o.codeId === "bigint" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.is(o.funds[0])) && (o.salt instanceof Uint8Array || typeof o.salt === "string") && typeof o.fixMsg === "boolean");
},
isSDK(o) {
return o && (o.$typeUrl === MsgInstantiateContract2.typeUrl || typeof o.sender === "string" && typeof o.admin === "string" && typeof o.code_id === "bigint" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.isSDK(o.funds[0])) && (o.salt instanceof Uint8Array || typeof o.salt === "string") && typeof o.fix_msg === "boolean");
},
isAmino(o) {
return o && (o.$typeUrl === MsgInstantiateContract2.typeUrl || typeof o.sender === "string" && typeof o.admin === "string" && typeof o.code_id === "bigint" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.isAmino(o.funds[0])) && (o.salt instanceof Uint8Array || typeof o.salt === "string") && typeof o.fix_msg === "boolean");
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.admin !== "") {
writer.uint32(18).string(message.admin);
}
if (message.codeId !== BigInt(0)) {
writer.uint32(24).uint64(message.codeId);
}
if (message.label !== "") {
writer.uint32(34).string(message.label);
}
if (message.msg.length !== 0) {
writer.uint32(42).bytes(message.msg);
}
for (const v of message.funds) {
Coin.encode(v, writer.uint32(50).fork()).ldelim();
}
if (message.salt.length !== 0) {
writer.uint32(58).bytes(message.salt);
}
if (message.fixMsg === true) {
writer.uint32(64).bool(message.fixMsg);
}
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 = createBaseMsgInstantiateContract2();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.admin = reader.string();
break;
case 3:
message.codeId = reader.uint64();
break;
case 4:
message.label = reader.string();
break;
case 5:
message.msg = reader.bytes();
break;
case 6:
message.funds.push(Coin.decode(reader, reader.uint32()));
break;
case 7:
message.salt = reader.bytes();
break;
case 8:
message.fixMsg = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgInstantiateContract2();
message.sender = object.sender ?? "";
message.admin = object.admin ?? "";
message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
message.label = object.label ?? "";
message.msg = object.msg ?? new Uint8Array();
message.funds = object.funds?.map(e => Coin.fromPartial(e)) || [];
message.salt = object.salt ?? new Uint8Array();
message.fixMsg = object.fixMsg ?? false;
return message;
},
fromAmino(object) {
const message = createBaseMsgInstantiateContract2();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.admin !== undefined && object.admin !== null) {
message.admin = object.admin;
}
if (object.code_id !== undefined && object.code_id !== null) {
message.codeId = BigInt(object.code_id);
}
if (object.label !== undefined && object.label !== null) {
message.label = object.label;
}
if (object.msg !== undefined && object.msg !== null) {
message.msg = toUtf8(JSON.stringify(object.msg));
}
message.funds = object.funds?.map(e => Coin.fromAmino(e)) || [];
if (object.salt !== undefined && object.salt !== null) {
message.salt = bytesFromBase64(object.salt);
}
if (object.fix_msg !== undefined && object.fix_msg !== null) {
message.fixMsg = object.fix_msg;
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.admin = message.admin === "" ? undefined : message.admin;
obj.code_id = message.codeId !== BigInt(0) ? message.codeId.toString() : undefined;
obj.label = message.label === "" ? undefined : message.label;
obj.msg = message.msg ? JSON.parse(fromUtf8(message.msg)) : undefined;
if (message.funds) {
obj.funds = message.funds.map(e => e ? Coin.toAmino(e) : undefined);
}
else {
obj.funds = message.funds;
}
obj.salt = message.salt ? base64FromBytes(message.salt) : undefined;
obj.fix_msg = message.fixMsg === false ? undefined : message.fixMsg;
return obj;
},
fromAminoMsg(object) {
return MsgInstantiateContract2.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgInstantiateContract2",
value: MsgInstantiateContract2.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgInstantiateContract2.decode(message.value);
},
toProto(message) {
return MsgInstantiateContract2.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgInstantiateContract2",
value: MsgInstantiateContract2.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgInstantiateContract2.typeUrl, MsgInstantiateContract2);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgInstantiateContract2.aminoType, MsgInstantiateContract2.typeUrl);
function createBaseMsgInstantiateContract2Response() {
return {
address: "",
data: new Uint8Array()
};
}
export const MsgInstantiateContract2Response = {
typeUrl: "/cosmwasm.wasm.v1.MsgInstantiateContract2Response",
aminoType: "wasm/MsgInstantiateContract2Response",
is(o) {
return o && (o.$typeUrl === MsgInstantiateContract2Response.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgInstantiateContract2Response.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgInstantiateContract2Response.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.address !== "") {
writer.uint32(10).string(message.address);
}
if (message.data.length !== 0) {
writer.uint32(18).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 = createBaseMsgInstantiateContract2Response();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.address = reader.string();
break;
case 2:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgInstantiateContract2Response();
message.address = object.address ?? "";
message.data = object.data ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgInstantiateContract2Response();
if (object.address !== undefined && object.address !== null) {
message.address = object.address;
}
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toAmino(message) {
const obj = {};
obj.address = message.address === "" ? undefined : message.address;
obj.data = message.data ? base64FromBytes(message.data) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgInstantiateContract2Response.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgInstantiateContract2Response",
value: MsgInstantiateContract2Response.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgInstantiateContract2Response.decode(message.value);
},
toProto(message) {
return MsgInstantiateContract2Response.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgInstantiateContract2Response",
value: MsgInstantiateContract2Response.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgInstantiateContract2Response.typeUrl, MsgInstantiateContract2Response);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgInstantiateContract2Response.aminoType, MsgInstantiateContract2Response.typeUrl);
function createBaseMsgExecuteContract() {
return {
sender: "",
contract: "",
msg: new Uint8Array(),
funds: []
};
}
export const MsgExecuteContract = {
typeUrl: "/cosmwasm.wasm.v1.MsgExecuteContract",
aminoType: "wasm/MsgExecuteContract",
is(o) {
return o && (o.$typeUrl === MsgExecuteContract.typeUrl || typeof o.sender === "string" && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.is(o.funds[0])));
},
isSDK(o) {
return o && (o.$typeUrl === MsgExecuteContract.typeUrl || typeof o.sender === "string" && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.isSDK(o.funds[0])));
},
isAmino(o) {
return o && (o.$typeUrl === MsgExecuteContract.typeUrl || typeof o.sender === "string" && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.isAmino(o.funds[0])));
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.contract !== "") {
writer.uint32(18).string(message.contract);
}
if (message.msg.length !== 0) {
writer.uint32(26).bytes(message.msg);
}
for (const v of message.funds) {
Coin.encode(v, writer.uint32(42).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 = createBaseMsgExecuteContract();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.contract = reader.string();
break;
case 3:
message.msg = reader.bytes();
break;
case 5:
message.funds.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgExecuteContract();
message.sender = object.sender ?? "";
message.contract = object.contract ?? "";
message.msg = object.msg ?? new Uint8Array();
message.funds = object.funds?.map(e => Coin.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgExecuteContract();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.contract !== undefined && object.contract !== null) {
message.contract = object.contract;
}
if (object.msg !== undefined && object.msg !== null) {
message.msg = toUtf8(JSON.stringify(object.msg));
}
message.funds = object.funds?.map(e => Coin.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.contract = message.contract === "" ? undefined : message.contract;
obj.msg = message.msg ? JSON.parse(fromUtf8(message.msg)) : undefined;
if (message.funds) {
obj.funds = message.funds.map(e => e ? Coin.toAmino(e) : undefined);
}
else {
obj.funds = message.funds;
}
return obj;
},
fromAminoMsg(object) {
return MsgExecuteContract.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgExecuteContract",
value: MsgExecuteContract.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgExecuteContract.decode(message.value);
},
toProto(message) {
return MsgExecuteContract.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgExecuteContract",
value: MsgExecuteContract.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgExecuteContract.typeUrl, MsgExecuteContract);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgExecuteContract.aminoType, MsgExecuteContract.typeUrl);
function createBaseMsgExecuteContractResponse() {
return {
data: new Uint8Array()
};
}
export const MsgExecuteContractResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgExecuteContractResponse",
aminoType: "wasm/MsgExecuteContractResponse",
is(o) {
return o && (o.$typeUrl === MsgExecuteContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
isSDK(o) {
return o && (o.$typeUrl === MsgExecuteContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
isAmino(o) {
return o && (o.$typeUrl === MsgExecuteContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
encode(message, writer = BinaryWriter.create()) {
if (message.data.length !== 0) {
writer.uint32(10).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 = createBaseMsgExecuteContractResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgExecuteContractResponse();
message.data = object.data ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgExecuteContractResponse();
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toAmino(message) {
const obj = {};
obj.data = message.data ? base64FromBytes(message.data) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgExecuteContractResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgExecuteContractResponse",
value: MsgExecuteContractResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgExecuteContractResponse.decode(message.value);
},
toProto(message) {
return MsgExecuteContractResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgExecuteContractResponse",
value: MsgExecuteContractResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgExecuteContractResponse.typeUrl, MsgExecuteContractResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgExecuteContractResponse.aminoType, MsgExecuteContractResponse.typeUrl);
function createBaseMsgMigrateContract() {
return {
sender: "",
contract: "",
codeId: BigInt(0),
msg: new Uint8Array()
};
}
export const MsgMigrateContract = {
typeUrl: "/cosmwasm.wasm.v1.MsgMigrateContract",
aminoType: "wasm/MsgMigrateContract",
is(o) {
return o && (o.$typeUrl === MsgMigrateContract.typeUrl || typeof o.sender === "string" && typeof o.contract === "string" && typeof o.codeId === "bigint" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgMigrateContract.typeUrl || typeof o.sender === "string" && typeof o.contract === "string" && typeof o.code_id === "bigint" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgMigrateContract.typeUrl || typeof o.sender === "string" && typeof o.contract === "string" && typeof o.code_id === "bigint" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.contract !== "") {
writer.uint32(18).string(message.contract);
}
if (message.codeId !== BigInt(0)) {
writer.uint32(24).uint64(message.codeId);
}
if (message.msg.length !== 0) {
writer.uint32(34).bytes(message.msg);
}
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 = createBaseMsgMigrateContract();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.contract = reader.string();
break;
case 3:
message.codeId = reader.uint64();
break;
case 4:
message.msg = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgMigrateContract();
message.sender = object.sender ?? "";
message.contract = object.contract ?? "";
message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
message.msg = object.msg ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgMigrateContract();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.contract !== undefined && object.contract !== null) {
message.contract = object.contract;
}
if (object.code_id !== undefined && object.code_id !== null) {
message.codeId = BigInt(object.code_id);
}
if (object.msg !== undefined && object.msg !== null) {
message.msg = toUtf8(JSON.stringify(object.msg));
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.contract = message.contract === "" ? undefined : message.contract;
obj.code_id = message.codeId !== BigInt(0) ? message.codeId.toString() : undefined;
obj.msg = message.msg ? JSON.parse(fromUtf8(message.msg)) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgMigrateContract.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgMigrateContract",
value: MsgMigrateContract.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgMigrateContract.decode(message.value);
},
toProto(message) {
return MsgMigrateContract.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgMigrateContract",
value: MsgMigrateContract.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgMigrateContract.typeUrl, MsgMigrateContract);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgMigrateContract.aminoType, MsgMigrateContract.typeUrl);
function createBaseMsgMigrateContractResponse() {
return {
data: new Uint8Array()
};
}
export const MsgMigrateContractResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgMigrateContractResponse",
aminoType: "wasm/MsgMigrateContractResponse",
is(o) {
return o && (o.$typeUrl === MsgMigrateContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
isSDK(o) {
return o && (o.$typeUrl === MsgMigrateContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
isAmino(o) {
return o && (o.$typeUrl === MsgMigrateContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
encode(message, writer = BinaryWriter.create()) {
if (message.data.length !== 0) {
writer.uint32(10).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 = createBaseMsgMigrateContractResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgMigrateContractResponse();
message.data = object.data ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgMigrateContractResponse();
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toAmino(message) {
const obj = {};
obj.data = message.data ? base64FromBytes(message.data) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgMigrateContractResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgMigrateContractResponse",
value: MsgMigrateContractResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgMigrateContractResponse.decode(message.value);
},
toProto(message) {
return MsgMigrateContractResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgMigrateContractResponse",
value: MsgMigrateContractResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgMigrateContractResponse.typeUrl, MsgMigrateContractResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgMigrateContractResponse.aminoType, MsgMigrateContractResponse.typeUrl);
function createBaseMsgUpdateAdmin() {
return {
sender: "",
newAdmin: "",
contract: ""
};
}
export const MsgUpdateAdmin = {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateAdmin",
aminoType: "wasm/MsgUpdateAdmin",
is(o) {
return o && (o.$typeUrl === MsgUpdateAdmin.typeUrl || typeof o.sender === "string" && typeof o.newAdmin === "string" && typeof o.contract === "string");
},
isSDK(o) {
return o && (o.$typeUrl === MsgUpdateAdmin.typeUrl || typeof o.sender === "string" && typeof o.new_admin === "string" && typeof o.contract === "string");
},
isAmino(o) {
return o && (o.$typeUrl === MsgUpdateAdmin.typeUrl || typeof o.sender === "string" && typeof o.new_admin === "string" && typeof o.contract === "string");
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.newAdmin !== "") {
writer.uint32(18).string(message.newAdmin);
}
if (message.contract !== "") {
writer.uint32(26).string(message.contract);
}
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 = createBaseMsgUpdateAdmin();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.newAdmin = reader.string();
break;
case 3:
message.contract = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUpdateAdmin();
message.sender = object.sender ?? "";
message.newAdmin = object.newAdmin ?? "";
message.contract = object.contract ?? "";
return message;
},
fromAmino(object) {
const message = createBaseMsgUpdateAdmin();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.new_admin !== undefined && object.new_admin !== null) {
message.newAdmin = object.new_admin;
}
if (object.contract !== undefined && object.contract !== null) {
message.contract = object.contract;
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.new_admin = message.newAdmin === "" ? undefined : message.newAdmin;
obj.contract = message.contract === "" ? undefined : message.contract;
return obj;
},
fromAminoMsg(object) {
return MsgUpdateAdmin.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUpdateAdmin",
value: MsgUpdateAdmin.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateAdmin.decode(message.value);
},
toProto(message) {
return MsgUpdateAdmin.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateAdmin",
value: MsgUpdateAdmin.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUpdateAdmin.typeUrl, MsgUpdateAdmin);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateAdmin.aminoType, MsgUpdateAdmin.typeUrl);
function createBaseMsgUpdateAdminResponse() {
return {};
}
export const MsgUpdateAdminResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateAdminResponse",
aminoType: "wasm/MsgUpdateAdminResponse",
is(o) {
return o && o.$typeUrl === MsgUpdateAdminResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgUpdateAdminResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgUpdateAdminResponse.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 = createBaseMsgUpdateAdminResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUpdateAdminResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUpdateAdminResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUpdateAdminResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUpdateAdminResponse",
value: MsgUpdateAdminResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateAdminResponse.decode(message.value);
},
toProto(message) {
return MsgUpdateAdminResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateAdminResponse",
value: MsgUpdateAdminResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUpdateAdminResponse.typeUrl, MsgUpdateAdminResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateAdminResponse.aminoType, MsgUpdateAdminResponse.typeUrl);
function createBaseMsgClearAdmin() {
return {
sender: "",
contract: ""
};
}
export const MsgClearAdmin = {
typeUrl: "/cosmwasm.wasm.v1.MsgClearAdmin",
aminoType: "wasm/MsgClearAdmin",
is(o) {
return o && (o.$typeUrl === MsgClearAdmin.typeUrl || typeof o.sender === "string" && typeof o.contract === "string");
},
isSDK(o) {
return o && (o.$typeUrl === MsgClearAdmin.typeUrl || typeof o.sender === "string" && typeof o.contract === "string");
},
isAmino(o) {
return o && (o.$typeUrl === MsgClearAdmin.typeUrl || typeof o.sender === "string" && typeof o.contract === "string");
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.contract !== "") {
writer.uint32(26).string(message.contract);
}
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 = createBaseMsgClearAdmin();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 3:
message.contract = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgClearAdmin();
message.sender = object.sender ?? "";
message.contract = object.contract ?? "";
return message;
},
fromAmino(object) {
const message = createBaseMsgClearAdmin();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.contract !== undefined && object.contract !== null) {
message.contract = object.contract;
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.contract = message.contract === "" ? undefined : message.contract;
return obj;
},
fromAminoMsg(object) {
return MsgClearAdmin.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgClearAdmin",
value: MsgClearAdmin.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgClearAdmin.decode(message.value);
},
toProto(message) {
return MsgClearAdmin.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgClearAdmin",
value: MsgClearAdmin.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgClearAdmin.typeUrl, MsgClearAdmin);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgClearAdmin.aminoType, MsgClearAdmin.typeUrl);
function createBaseMsgClearAdminResponse() {
return {};
}
export const MsgClearAdminResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgClearAdminResponse",
aminoType: "wasm/MsgClearAdminResponse",
is(o) {
return o && o.$typeUrl === MsgClearAdminResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgClearAdminResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgClearAdminResponse.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 = createBaseMsgClearAdminResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgClearAdminResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgClearAdminResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgClearAdminResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgClearAdminResponse",
value: MsgClearAdminResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgClearAdminResponse.decode(message.value);
},
toProto(message) {
return MsgClearAdminResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgClearAdminResponse",
value: MsgClearAdminResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgClearAdminResponse.typeUrl, MsgClearAdminResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgClearAdminResponse.aminoType, MsgClearAdminResponse.typeUrl);
function createBaseMsgUpdateInstantiateConfig() {
return {
sender: "",
codeId: BigInt(0),
newInstantiatePermission: undefined
};
}
export const MsgUpdateInstantiateConfig = {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateInstantiateConfig",
aminoType: "wasm/MsgUpdateInstantiateConfig",
is(o) {
return o && (o.$typeUrl === MsgUpdateInstantiateConfig.typeUrl || typeof o.sender === "string" && typeof o.codeId === "bigint");
},
isSDK(o) {
return o && (o.$typeUrl === MsgUpdateInstantiateConfig.typeUrl || typeof o.sender === "string" && typeof o.code_id === "bigint");
},
isAmino(o) {
return o && (o.$typeUrl === MsgUpdateInstantiateConfig.typeUrl || typeof o.sender === "string" && typeof o.code_id === "bigint");
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.codeId !== BigInt(0)) {
writer.uint32(16).uint64(message.codeId);
}
if (message.newInstantiatePermission !== undefined) {
AccessConfig.encode(message.newInstantiatePermission, 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 = createBaseMsgUpdateInstantiateConfig();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.codeId = reader.uint64();
break;
case 3:
message.newInstantiatePermission = AccessConfig.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUpdateInstantiateConfig();
message.sender = object.sender ?? "";
message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
message.newInstantiatePermission = object.newInstantiatePermission !== undefined && object.newInstantiatePermission !== null ? AccessConfig.fromPartial(object.newInstantiatePermission) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseMsgUpdateInstantiateConfig();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.code_id !== undefined && object.code_id !== null) {
message.codeId = BigInt(object.code_id);
}
if (object.new_instantiate_permission !== undefined && object.new_instantiate_permission !== null) {
message.newInstantiatePermission = AccessConfig.fromAmino(object.new_instantiate_permission);
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.code_id = message.codeId !== BigInt(0) ? message.codeId.toString() : undefined;
obj.new_instantiate_permission = message.newInstantiatePermission ? AccessConfig.toAmino(message.newInstantiatePermission) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgUpdateInstantiateConfig.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUpdateInstantiateConfig",
value: MsgUpdateInstantiateConfig.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateInstantiateConfig.decode(message.value);
},
toProto(message) {
return MsgUpdateInstantiateConfig.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateInstantiateConfig",
value: MsgUpdateInstantiateConfig.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUpdateInstantiateConfig.typeUrl, MsgUpdateInstantiateConfig);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateInstantiateConfig.aminoType, MsgUpdateInstantiateConfig.typeUrl);
function createBaseMsgUpdateInstantiateConfigResponse() {
return {};
}
export const MsgUpdateInstantiateConfigResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateInstantiateConfigResponse",
aminoType: "wasm/MsgUpdateInstantiateConfigResponse",
is(o) {
return o && o.$typeUrl === MsgUpdateInstantiateConfigResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgUpdateInstantiateConfigResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgUpdateInstantiateConfigResponse.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 = createBaseMsgUpdateInstantiateConfigResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUpdateInstantiateConfigResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUpdateInstantiateConfigResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUpdateInstantiateConfigResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUpdateInstantiateConfigResponse",
value: MsgUpdateInstantiateConfigResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateInstantiateConfigResponse.decode(message.value);
},
toProto(message) {
return MsgUpdateInstantiateConfigResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateInstantiateConfigResponse",
value: MsgUpdateInstantiateConfigResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUpdateInstantiateConfigResponse.typeUrl, MsgUpdateInstantiateConfigResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateInstantiateConfigResponse.aminoType, MsgUpdateInstantiateConfigResponse.typeUrl);
function createBaseMsgUpdateParams() {
return {
authority: "",
params: Params.fromPartial({})
};
}
export const MsgUpdateParams = {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateParams",
aminoType: "wasm/MsgUpdateParams",
is(o) {
return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.is(o.params));
},
isSDK(o) {
return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.isSDK(o.params));
},
isAmino(o) {
return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.isAmino(o.params));
},
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
if (message.params !== undefined) {
Params.encode(message.params, 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 = createBaseMsgUpdateParams();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 2:
message.params = Params.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUpdateParams();
message.authority = object.authority ?? "";
message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseMsgUpdateParams();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
if (object.params !== undefined && object.params !== null) {
message.params = Params.fromAmino(object.params);
}
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
return obj;
},
fromAminoMsg(object) {
return MsgUpdateParams.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUpdateParams",
value: MsgUpdateParams.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateParams.decode(message.value);
},
toProto(message) {
return MsgUpdateParams.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateParams",
value: MsgUpdateParams.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
function createBaseMsgUpdateParamsResponse() {
return {};
}
export const MsgUpdateParamsResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateParamsResponse",
aminoType: "wasm/MsgUpdateParamsResponse",
is(o) {
return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgUpdateParamsResponse.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 = createBaseMsgUpdateParamsResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUpdateParamsResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUpdateParamsResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUpdateParamsResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUpdateParamsResponse",
value: MsgUpdateParamsResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateParamsResponse.decode(message.value);
},
toProto(message) {
return MsgUpdateParamsResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateParamsResponse",
value: MsgUpdateParamsResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParamsResponse.aminoType, MsgUpdateParamsResponse.typeUrl);
function createBaseMsgSudoContract() {
return {
authority: "",
contract: "",
msg: new Uint8Array()
};
}
export const MsgSudoContract = {
typeUrl: "/cosmwasm.wasm.v1.MsgSudoContract",
aminoType: "wasm/MsgSudoContract",
is(o) {
return o && (o.$typeUrl === MsgSudoContract.typeUrl || typeof o.authority === "string" && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgSudoContract.typeUrl || typeof o.authority === "string" && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgSudoContract.typeUrl || typeof o.authority === "string" && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
if (message.contract !== "") {
writer.uint32(18).string(message.contract);
}
if (message.msg.length !== 0) {
writer.uint32(26).bytes(message.msg);
}
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 = createBaseMsgSudoContract();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 2:
message.contract = reader.string();
break;
case 3:
message.msg = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgSudoContract();
message.authority = object.authority ?? "";
message.contract = object.contract ?? "";
message.msg = object.msg ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgSudoContract();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
if (object.contract !== undefined && object.contract !== null) {
message.contract = object.contract;
}
if (object.msg !== undefined && object.msg !== null) {
message.msg = toUtf8(JSON.stringify(object.msg));
}
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
obj.contract = message.contract === "" ? undefined : message.contract;
obj.msg = message.msg ? JSON.parse(fromUtf8(message.msg)) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgSudoContract.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgSudoContract",
value: MsgSudoContract.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgSudoContract.decode(message.value);
},
toProto(message) {
return MsgSudoContract.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgSudoContract",
value: MsgSudoContract.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgSudoContract.typeUrl, MsgSudoContract);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgSudoContract.aminoType, MsgSudoContract.typeUrl);
function createBaseMsgSudoContractResponse() {
return {
data: new Uint8Array()
};
}
export const MsgSudoContractResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgSudoContractResponse",
aminoType: "wasm/MsgSudoContractResponse",
is(o) {
return o && (o.$typeUrl === MsgSudoContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
isSDK(o) {
return o && (o.$typeUrl === MsgSudoContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
isAmino(o) {
return o && (o.$typeUrl === MsgSudoContractResponse.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
},
encode(message, writer = BinaryWriter.create()) {
if (message.data.length !== 0) {
writer.uint32(10).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 = createBaseMsgSudoContractResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgSudoContractResponse();
message.data = object.data ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgSudoContractResponse();
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toAmino(message) {
const obj = {};
obj.data = message.data ? base64FromBytes(message.data) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgSudoContractResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgSudoContractResponse",
value: MsgSudoContractResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgSudoContractResponse.decode(message.value);
},
toProto(message) {
return MsgSudoContractResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgSudoContractResponse",
value: MsgSudoContractResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgSudoContractResponse.typeUrl, MsgSudoContractResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgSudoContractResponse.aminoType, MsgSudoContractResponse.typeUrl);
function createBaseMsgPinCodes() {
return {
authority: "",
codeIds: []
};
}
export const MsgPinCodes = {
typeUrl: "/cosmwasm.wasm.v1.MsgPinCodes",
aminoType: "wasm/MsgPinCodes",
is(o) {
return o && (o.$typeUrl === MsgPinCodes.typeUrl || typeof o.authority === "string" && Array.isArray(o.codeIds) && (!o.codeIds.length || typeof o.codeIds[0] === "bigint"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgPinCodes.typeUrl || typeof o.authority === "string" && Array.isArray(o.code_ids) && (!o.code_ids.length || typeof o.code_ids[0] === "bigint"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgPinCodes.typeUrl || typeof o.authority === "string" && Array.isArray(o.code_ids) && (!o.code_ids.length || typeof o.code_ids[0] === "bigint"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
writer.uint32(18).fork();
for (const v of message.codeIds) {
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 = createBaseMsgPinCodes();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 2:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.codeIds.push(reader.uint64());
}
}
else {
message.codeIds.push(reader.uint64());
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgPinCodes();
message.authority = object.authority ?? "";
message.codeIds = object.codeIds?.map(e => BigInt(e.toString())) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgPinCodes();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
message.codeIds = object.code_ids?.map(e => BigInt(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
if (message.codeIds) {
obj.code_ids = message.codeIds.map(e => e.toString());
}
else {
obj.code_ids = message.codeIds;
}
return obj;
},
fromAminoMsg(object) {
return MsgPinCodes.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgPinCodes",
value: MsgPinCodes.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgPinCodes.decode(message.value);
},
toProto(message) {
return MsgPinCodes.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgPinCodes",
value: MsgPinCodes.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgPinCodes.typeUrl, MsgPinCodes);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgPinCodes.aminoType, MsgPinCodes.typeUrl);
function createBaseMsgPinCodesResponse() {
return {};
}
export const MsgPinCodesResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgPinCodesResponse",
aminoType: "wasm/MsgPinCodesResponse",
is(o) {
return o && o.$typeUrl === MsgPinCodesResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgPinCodesResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgPinCodesResponse.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 = createBaseMsgPinCodesResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgPinCodesResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgPinCodesResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgPinCodesResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgPinCodesResponse",
value: MsgPinCodesResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgPinCodesResponse.decode(message.value);
},
toProto(message) {
return MsgPinCodesResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgPinCodesResponse",
value: MsgPinCodesResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgPinCodesResponse.typeUrl, MsgPinCodesResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgPinCodesResponse.aminoType, MsgPinCodesResponse.typeUrl);
function createBaseMsgUnpinCodes() {
return {
authority: "",
codeIds: []
};
}
export const MsgUnpinCodes = {
typeUrl: "/cosmwasm.wasm.v1.MsgUnpinCodes",
aminoType: "wasm/MsgUnpinCodes",
is(o) {
return o && (o.$typeUrl === MsgUnpinCodes.typeUrl || typeof o.authority === "string" && Array.isArray(o.codeIds) && (!o.codeIds.length || typeof o.codeIds[0] === "bigint"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgUnpinCodes.typeUrl || typeof o.authority === "string" && Array.isArray(o.code_ids) && (!o.code_ids.length || typeof o.code_ids[0] === "bigint"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgUnpinCodes.typeUrl || typeof o.authority === "string" && Array.isArray(o.code_ids) && (!o.code_ids.length || typeof o.code_ids[0] === "bigint"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
writer.uint32(18).fork();
for (const v of message.codeIds) {
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 = createBaseMsgUnpinCodes();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 2:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.codeIds.push(reader.uint64());
}
}
else {
message.codeIds.push(reader.uint64());
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUnpinCodes();
message.authority = object.authority ?? "";
message.codeIds = object.codeIds?.map(e => BigInt(e.toString())) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgUnpinCodes();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
message.codeIds = object.code_ids?.map(e => BigInt(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
if (message.codeIds) {
obj.code_ids = message.codeIds.map(e => e.toString());
}
else {
obj.code_ids = message.codeIds;
}
return obj;
},
fromAminoMsg(object) {
return MsgUnpinCodes.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUnpinCodes",
value: MsgUnpinCodes.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUnpinCodes.decode(message.value);
},
toProto(message) {
return MsgUnpinCodes.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUnpinCodes",
value: MsgUnpinCodes.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUnpinCodes.typeUrl, MsgUnpinCodes);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUnpinCodes.aminoType, MsgUnpinCodes.typeUrl);
function createBaseMsgUnpinCodesResponse() {
return {};
}
export const MsgUnpinCodesResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgUnpinCodesResponse",
aminoType: "wasm/MsgUnpinCodesResponse",
is(o) {
return o && o.$typeUrl === MsgUnpinCodesResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgUnpinCodesResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgUnpinCodesResponse.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 = createBaseMsgUnpinCodesResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUnpinCodesResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUnpinCodesResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUnpinCodesResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUnpinCodesResponse",
value: MsgUnpinCodesResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUnpinCodesResponse.decode(message.value);
},
toProto(message) {
return MsgUnpinCodesResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUnpinCodesResponse",
value: MsgUnpinCodesResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUnpinCodesResponse.typeUrl, MsgUnpinCodesResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUnpinCodesResponse.aminoType, MsgUnpinCodesResponse.typeUrl);
function createBaseMsgStoreAndInstantiateContract() {
return {
authority: "",
wasmByteCode: new Uint8Array(),
instantiatePermission: undefined,
unpinCode: false,
admin: "",
label: "",
msg: new Uint8Array(),
funds: [],
source: "",
builder: "",
codeHash: new Uint8Array()
};
}
export const MsgStoreAndInstantiateContract = {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreAndInstantiateContract",
aminoType: "wasm/MsgStoreAndInstantiateContract",
is(o) {
return o && (o.$typeUrl === MsgStoreAndInstantiateContract.typeUrl || typeof o.authority === "string" && (o.wasmByteCode instanceof Uint8Array || typeof o.wasmByteCode === "string") && typeof o.unpinCode === "boolean" && typeof o.admin === "string" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.is(o.funds[0])) && typeof o.source === "string" && typeof o.builder === "string" && (o.codeHash instanceof Uint8Array || typeof o.codeHash === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgStoreAndInstantiateContract.typeUrl || typeof o.authority === "string" && (o.wasm_byte_code instanceof Uint8Array || typeof o.wasm_byte_code === "string") && typeof o.unpin_code === "boolean" && typeof o.admin === "string" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.isSDK(o.funds[0])) && typeof o.source === "string" && typeof o.builder === "string" && (o.code_hash instanceof Uint8Array || typeof o.code_hash === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgStoreAndInstantiateContract.typeUrl || typeof o.authority === "string" && (o.wasm_byte_code instanceof Uint8Array || typeof o.wasm_byte_code === "string") && typeof o.unpin_code === "boolean" && typeof o.admin === "string" && typeof o.label === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string") && Array.isArray(o.funds) && (!o.funds.length || Coin.isAmino(o.funds[0])) && typeof o.source === "string" && typeof o.builder === "string" && (o.code_hash instanceof Uint8Array || typeof o.code_hash === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
if (message.wasmByteCode.length !== 0) {
writer.uint32(26).bytes(message.wasmByteCode);
}
if (message.instantiatePermission !== undefined) {
AccessConfig.encode(message.instantiatePermission, writer.uint32(34).fork()).ldelim();
}
if (message.unpinCode === true) {
writer.uint32(40).bool(message.unpinCode);
}
if (message.admin !== "") {
writer.uint32(50).string(message.admin);
}
if (message.label !== "") {
writer.uint32(58).string(message.label);
}
if (message.msg.length !== 0) {
writer.uint32(66).bytes(message.msg);
}
for (const v of message.funds) {
Coin.encode(v, writer.uint32(74).fork()).ldelim();
}
if (message.source !== "") {
writer.uint32(82).string(message.source);
}
if (message.builder !== "") {
writer.uint32(90).string(message.builder);
}
if (message.codeHash.length !== 0) {
writer.uint32(98).bytes(message.codeHash);
}
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 = createBaseMsgStoreAndInstantiateContract();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 3:
message.wasmByteCode = reader.bytes();
break;
case 4:
message.instantiatePermission = AccessConfig.decode(reader, reader.uint32());
break;
case 5:
message.unpinCode = reader.bool();
break;
case 6:
message.admin = reader.string();
break;
case 7:
message.label = reader.string();
break;
case 8:
message.msg = reader.bytes();
break;
case 9:
message.funds.push(Coin.decode(reader, reader.uint32()));
break;
case 10:
message.source = reader.string();
break;
case 11:
message.builder = reader.string();
break;
case 12:
message.codeHash = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgStoreAndInstantiateContract();
message.authority = object.authority ?? "";
message.wasmByteCode = object.wasmByteCode ?? new Uint8Array();
message.instantiatePermission = object.instantiatePermission !== undefined && object.instantiatePermission !== null ? AccessConfig.fromPartial(object.instantiatePermission) : undefined;
message.unpinCode = object.unpinCode ?? false;
message.admin = object.admin ?? "";
message.label = object.label ?? "";
message.msg = object.msg ?? new Uint8Array();
message.funds = object.funds?.map(e => Coin.fromPartial(e)) || [];
message.source = object.source ?? "";
message.builder = object.builder ?? "";
message.codeHash = object.codeHash ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgStoreAndInstantiateContract();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
if (object.wasm_byte_code !== undefined && object.wasm_byte_code !== null) {
message.wasmByteCode = fromBase64(object.wasm_byte_code);
}
if (object.instantiate_permission !== undefined && object.instantiate_permission !== null) {
message.instantiatePermission = AccessConfig.fromAmino(object.instantiate_permission);
}
if (object.unpin_code !== undefined && object.unpin_code !== null) {
message.unpinCode = object.unpin_code;
}
if (object.admin !== undefined && object.admin !== null) {
message.admin = object.admin;
}
if (object.label !== undefined && object.label !== null) {
message.label = object.label;
}
if (object.msg !== undefined && object.msg !== null) {
message.msg = toUtf8(JSON.stringify(object.msg));
}
message.funds = object.funds?.map(e => Coin.fromAmino(e)) || [];
if (object.source !== undefined && object.source !== null) {
message.source = object.source;
}
if (object.builder !== undefined && object.builder !== null) {
message.builder = object.builder;
}
if (object.code_hash !== undefined && object.code_hash !== null) {
message.codeHash = bytesFromBase64(object.code_hash);
}
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
obj.wasm_byte_code = message.wasmByteCode ? toBase64(message.wasmByteCode) : undefined;
obj.instantiate_permission = message.instantiatePermission ? AccessConfig.toAmino(message.instantiatePermission) : undefined;
obj.unpin_code = message.unpinCode === false ? undefined : message.unpinCode;
obj.admin = message.admin === "" ? undefined : message.admin;
obj.label = message.label === "" ? undefined : message.label;
obj.msg = message.msg ? JSON.parse(fromUtf8(message.msg)) : undefined;
if (message.funds) {
obj.funds = message.funds.map(e => e ? Coin.toAmino(e) : undefined);
}
else {
obj.funds = message.funds;
}
obj.source = message.source === "" ? undefined : message.source;
obj.builder = message.builder === "" ? undefined : message.builder;
obj.code_hash = message.codeHash ? base64FromBytes(message.codeHash) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgStoreAndInstantiateContract.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgStoreAndInstantiateContract",
value: MsgStoreAndInstantiateContract.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgStoreAndInstantiateContract.decode(message.value);
},
toProto(message) {
return MsgStoreAndInstantiateContract.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreAndInstantiateContract",
value: MsgStoreAndInstantiateContract.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgStoreAndInstantiateContract.typeUrl, MsgStoreAndInstantiateContract);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgStoreAndInstantiateContract.aminoType, MsgStoreAndInstantiateContract.typeUrl);
function createBaseMsgStoreAndInstantiateContractResponse() {
return {
address: "",
data: new Uint8Array()
};
}
export const MsgStoreAndInstantiateContractResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreAndInstantiateContractResponse",
aminoType: "wasm/MsgStoreAndInstantiateContractResponse",
is(o) {
return o && (o.$typeUrl === MsgStoreAndInstantiateContractResponse.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgStoreAndInstantiateContractResponse.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgStoreAndInstantiateContractResponse.typeUrl || typeof o.address === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.address !== "") {
writer.uint32(10).string(message.address);
}
if (message.data.length !== 0) {
writer.uint32(18).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 = createBaseMsgStoreAndInstantiateContractResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.address = reader.string();
break;
case 2:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgStoreAndInstantiateContractResponse();
message.address = object.address ?? "";
message.data = object.data ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgStoreAndInstantiateContractResponse();
if (object.address !== undefined && object.address !== null) {
message.address = object.address;
}
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toAmino(message) {
const obj = {};
obj.address = message.address === "" ? undefined : message.address;
obj.data = message.data ? base64FromBytes(message.data) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgStoreAndInstantiateContractResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgStoreAndInstantiateContractResponse",
value: MsgStoreAndInstantiateContractResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgStoreAndInstantiateContractResponse.decode(message.value);
},
toProto(message) {
return MsgStoreAndInstantiateContractResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreAndInstantiateContractResponse",
value: MsgStoreAndInstantiateContractResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgStoreAndInstantiateContractResponse.typeUrl, MsgStoreAndInstantiateContractResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgStoreAndInstantiateContractResponse.aminoType, MsgStoreAndInstantiateContractResponse.typeUrl);
function createBaseMsgAddCodeUploadParamsAddresses() {
return {
authority: "",
addresses: []
};
}
export const MsgAddCodeUploadParamsAddresses = {
typeUrl: "/cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddresses",
aminoType: "wasm/MsgAddCodeUploadParamsAddresses",
is(o) {
return o && (o.$typeUrl === MsgAddCodeUploadParamsAddresses.typeUrl || typeof o.authority === "string" && Array.isArray(o.addresses) && (!o.addresses.length || typeof o.addresses[0] === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgAddCodeUploadParamsAddresses.typeUrl || typeof o.authority === "string" && Array.isArray(o.addresses) && (!o.addresses.length || typeof o.addresses[0] === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgAddCodeUploadParamsAddresses.typeUrl || typeof o.authority === "string" && Array.isArray(o.addresses) && (!o.addresses.length || typeof o.addresses[0] === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
for (const v of message.addresses) {
writer.uint32(18).string(v);
}
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 = createBaseMsgAddCodeUploadParamsAddresses();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 2:
message.addresses.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgAddCodeUploadParamsAddresses();
message.authority = object.authority ?? "";
message.addresses = object.addresses?.map(e => e) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgAddCodeUploadParamsAddresses();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
message.addresses = object.addresses?.map(e => e) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
if (message.addresses) {
obj.addresses = message.addresses.map(e => e);
}
else {
obj.addresses = message.addresses;
}
return obj;
},
fromAminoMsg(object) {
return MsgAddCodeUploadParamsAddresses.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgAddCodeUploadParamsAddresses",
value: MsgAddCodeUploadParamsAddresses.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgAddCodeUploadParamsAddresses.decode(message.value);
},
toProto(message) {
return MsgAddCodeUploadParamsAddresses.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddresses",
value: MsgAddCodeUploadParamsAddresses.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgAddCodeUploadParamsAddresses.typeUrl, MsgAddCodeUploadParamsAddresses);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgAddCodeUploadParamsAddresses.aminoType, MsgAddCodeUploadParamsAddresses.typeUrl);
function createBaseMsgAddCodeUploadParamsAddressesResponse() {
return {};
}
export const MsgAddCodeUploadParamsAddressesResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddressesResponse",
aminoType: "wasm/MsgAddCodeUploadParamsAddressesResponse",
is(o) {
return o && o.$typeUrl === MsgAddCodeUploadParamsAddressesResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgAddCodeUploadParamsAddressesResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgAddCodeUploadParamsAddressesResponse.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 = createBaseMsgAddCodeUploadParamsAddressesResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgAddCodeUploadParamsAddressesResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgAddCodeUploadParamsAddressesResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgAddCodeUploadParamsAddressesResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgAddCodeUploadParamsAddressesResponse",
value: MsgAddCodeUploadParamsAddressesResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgAddCodeUploadParamsAddressesResponse.decode(message.value);
},
toProto(message) {
return MsgAddCodeUploadParamsAddressesResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddressesResponse",
value: MsgAddCodeUploadParamsAddressesResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgAddCodeUploadParamsAddressesResponse.typeUrl, MsgAddCodeUploadParamsAddressesResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgAddCodeUploadParamsAddressesResponse.aminoType, MsgAddCodeUploadParamsAddressesResponse.typeUrl);
function createBaseMsgRemoveCodeUploadParamsAddresses() {
return {
authority: "",
addresses: []
};
}
export const MsgRemoveCodeUploadParamsAddresses = {
typeUrl: "/cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddresses",
aminoType: "wasm/MsgRemoveCodeUploadParamsAddresses",
is(o) {
return o && (o.$typeUrl === MsgRemoveCodeUploadParamsAddresses.typeUrl || typeof o.authority === "string" && Array.isArray(o.addresses) && (!o.addresses.length || typeof o.addresses[0] === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgRemoveCodeUploadParamsAddresses.typeUrl || typeof o.authority === "string" && Array.isArray(o.addresses) && (!o.addresses.length || typeof o.addresses[0] === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgRemoveCodeUploadParamsAddresses.typeUrl || typeof o.authority === "string" && Array.isArray(o.addresses) && (!o.addresses.length || typeof o.addresses[0] === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
for (const v of message.addresses) {
writer.uint32(18).string(v);
}
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 = createBaseMsgRemoveCodeUploadParamsAddresses();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 2:
message.addresses.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgRemoveCodeUploadParamsAddresses();
message.authority = object.authority ?? "";
message.addresses = object.addresses?.map(e => e) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgRemoveCodeUploadParamsAddresses();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
message.addresses = object.addresses?.map(e => e) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
if (message.addresses) {
obj.addresses = message.addresses.map(e => e);
}
else {
obj.addresses = message.addresses;
}
return obj;
},
fromAminoMsg(object) {
return MsgRemoveCodeUploadParamsAddresses.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgRemoveCodeUploadParamsAddresses",
value: MsgRemoveCodeUploadParamsAddresses.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgRemoveCodeUploadParamsAddresses.decode(message.value);
},
toProto(message) {
return MsgRemoveCodeUploadParamsAddresses.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddresses",
value: MsgRemoveCodeUploadParamsAddresses.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgRemoveCodeUploadParamsAddresses.typeUrl, MsgRemoveCodeUploadParamsAddresses);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgRemoveCodeUploadParamsAddresses.aminoType, MsgRemoveCodeUploadParamsAddresses.typeUrl);
function createBaseMsgRemoveCodeUploadParamsAddressesResponse() {
return {};
}
export const MsgRemoveCodeUploadParamsAddressesResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddressesResponse",
aminoType: "wasm/MsgRemoveCodeUploadParamsAddressesResponse",
is(o) {
return o && o.$typeUrl === MsgRemoveCodeUploadParamsAddressesResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgRemoveCodeUploadParamsAddressesResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgRemoveCodeUploadParamsAddressesResponse.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 = createBaseMsgRemoveCodeUploadParamsAddressesResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgRemoveCodeUploadParamsAddressesResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgRemoveCodeUploadParamsAddressesResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgRemoveCodeUploadParamsAddressesResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgRemoveCodeUploadParamsAddressesResponse",
value: MsgRemoveCodeUploadParamsAddressesResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgRemoveCodeUploadParamsAddressesResponse.decode(message.value);
},
toProto(message) {
return MsgRemoveCodeUploadParamsAddressesResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddressesResponse",
value: MsgRemoveCodeUploadParamsAddressesResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgRemoveCodeUploadParamsAddressesResponse.typeUrl, MsgRemoveCodeUploadParamsAddressesResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgRemoveCodeUploadParamsAddressesResponse.aminoType, MsgRemoveCodeUploadParamsAddressesResponse.typeUrl);
function createBaseMsgStoreAndMigrateContract() {
return {
authority: "",
wasmByteCode: new Uint8Array(),
instantiatePermission: undefined,
contract: "",
msg: new Uint8Array()
};
}
export const MsgStoreAndMigrateContract = {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreAndMigrateContract",
aminoType: "wasm/MsgStoreAndMigrateContract",
is(o) {
return o && (o.$typeUrl === MsgStoreAndMigrateContract.typeUrl || typeof o.authority === "string" && (o.wasmByteCode instanceof Uint8Array || typeof o.wasmByteCode === "string") && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgStoreAndMigrateContract.typeUrl || typeof o.authority === "string" && (o.wasm_byte_code instanceof Uint8Array || typeof o.wasm_byte_code === "string") && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgStoreAndMigrateContract.typeUrl || typeof o.authority === "string" && (o.wasm_byte_code instanceof Uint8Array || typeof o.wasm_byte_code === "string") && typeof o.contract === "string" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
if (message.wasmByteCode.length !== 0) {
writer.uint32(18).bytes(message.wasmByteCode);
}
if (message.instantiatePermission !== undefined) {
AccessConfig.encode(message.instantiatePermission, writer.uint32(26).fork()).ldelim();
}
if (message.contract !== "") {
writer.uint32(34).string(message.contract);
}
if (message.msg.length !== 0) {
writer.uint32(42).bytes(message.msg);
}
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 = createBaseMsgStoreAndMigrateContract();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 2:
message.wasmByteCode = reader.bytes();
break;
case 3:
message.instantiatePermission = AccessConfig.decode(reader, reader.uint32());
break;
case 4:
message.contract = reader.string();
break;
case 5:
message.msg = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgStoreAndMigrateContract();
message.authority = object.authority ?? "";
message.wasmByteCode = object.wasmByteCode ?? new Uint8Array();
message.instantiatePermission = object.instantiatePermission !== undefined && object.instantiatePermission !== null ? AccessConfig.fromPartial(object.instantiatePermission) : undefined;
message.contract = object.contract ?? "";
message.msg = object.msg ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgStoreAndMigrateContract();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
if (object.wasm_byte_code !== undefined && object.wasm_byte_code !== null) {
message.wasmByteCode = fromBase64(object.wasm_byte_code);
}
if (object.instantiate_permission !== undefined && object.instantiate_permission !== null) {
message.instantiatePermission = AccessConfig.fromAmino(object.instantiate_permission);
}
if (object.contract !== undefined && object.contract !== null) {
message.contract = object.contract;
}
if (object.msg !== undefined && object.msg !== null) {
message.msg = toUtf8(JSON.stringify(object.msg));
}
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
obj.wasm_byte_code = message.wasmByteCode ? toBase64(message.wasmByteCode) : undefined;
obj.instantiate_permission = message.instantiatePermission ? AccessConfig.toAmino(message.instantiatePermission) : undefined;
obj.contract = message.contract === "" ? undefined : message.contract;
obj.msg = message.msg ? JSON.parse(fromUtf8(message.msg)) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgStoreAndMigrateContract.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgStoreAndMigrateContract",
value: MsgStoreAndMigrateContract.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgStoreAndMigrateContract.decode(message.value);
},
toProto(message) {
return MsgStoreAndMigrateContract.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreAndMigrateContract",
value: MsgStoreAndMigrateContract.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgStoreAndMigrateContract.typeUrl, MsgStoreAndMigrateContract);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgStoreAndMigrateContract.aminoType, MsgStoreAndMigrateContract.typeUrl);
function createBaseMsgStoreAndMigrateContractResponse() {
return {
codeId: BigInt(0),
checksum: new Uint8Array(),
data: new Uint8Array()
};
}
export const MsgStoreAndMigrateContractResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreAndMigrateContractResponse",
aminoType: "wasm/MsgStoreAndMigrateContractResponse",
is(o) {
return o && (o.$typeUrl === MsgStoreAndMigrateContractResponse.typeUrl || typeof o.codeId === "bigint" && (o.checksum instanceof Uint8Array || typeof o.checksum === "string") && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isSDK(o) {
return o && (o.$typeUrl === MsgStoreAndMigrateContractResponse.typeUrl || typeof o.code_id === "bigint" && (o.checksum instanceof Uint8Array || typeof o.checksum === "string") && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === MsgStoreAndMigrateContractResponse.typeUrl || typeof o.code_id === "bigint" && (o.checksum instanceof Uint8Array || typeof o.checksum === "string") && (o.data instanceof Uint8Array || typeof o.data === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.codeId !== BigInt(0)) {
writer.uint32(8).uint64(message.codeId);
}
if (message.checksum.length !== 0) {
writer.uint32(18).bytes(message.checksum);
}
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 = createBaseMsgStoreAndMigrateContractResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.codeId = reader.uint64();
break;
case 2:
message.checksum = reader.bytes();
break;
case 3:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgStoreAndMigrateContractResponse();
message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
message.checksum = object.checksum ?? new Uint8Array();
message.data = object.data ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseMsgStoreAndMigrateContractResponse();
if (object.code_id !== undefined && object.code_id !== null) {
message.codeId = BigInt(object.code_id);
}
if (object.checksum !== undefined && object.checksum !== null) {
message.checksum = bytesFromBase64(object.checksum);
}
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toAmino(message) {
const obj = {};
obj.code_id = message.codeId !== BigInt(0) ? message.codeId.toString() : undefined;
obj.checksum = message.checksum ? base64FromBytes(message.checksum) : undefined;
obj.data = message.data ? base64FromBytes(message.data) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgStoreAndMigrateContractResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgStoreAndMigrateContractResponse",
value: MsgStoreAndMigrateContractResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgStoreAndMigrateContractResponse.decode(message.value);
},
toProto(message) {
return MsgStoreAndMigrateContractResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgStoreAndMigrateContractResponse",
value: MsgStoreAndMigrateContractResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgStoreAndMigrateContractResponse.typeUrl, MsgStoreAndMigrateContractResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgStoreAndMigrateContractResponse.aminoType, MsgStoreAndMigrateContractResponse.typeUrl);
function createBaseMsgUpdateContractLabel() {
return {
sender: "",
newLabel: "",
contract: ""
};
}
export const MsgUpdateContractLabel = {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateContractLabel",
aminoType: "wasm/MsgUpdateContractLabel",
is(o) {
return o && (o.$typeUrl === MsgUpdateContractLabel.typeUrl || typeof o.sender === "string" && typeof o.newLabel === "string" && typeof o.contract === "string");
},
isSDK(o) {
return o && (o.$typeUrl === MsgUpdateContractLabel.typeUrl || typeof o.sender === "string" && typeof o.new_label === "string" && typeof o.contract === "string");
},
isAmino(o) {
return o && (o.$typeUrl === MsgUpdateContractLabel.typeUrl || typeof o.sender === "string" && typeof o.new_label === "string" && typeof o.contract === "string");
},
encode(message, writer = BinaryWriter.create()) {
if (message.sender !== "") {
writer.uint32(10).string(message.sender);
}
if (message.newLabel !== "") {
writer.uint32(18).string(message.newLabel);
}
if (message.contract !== "") {
writer.uint32(26).string(message.contract);
}
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 = createBaseMsgUpdateContractLabel();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sender = reader.string();
break;
case 2:
message.newLabel = reader.string();
break;
case 3:
message.contract = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUpdateContractLabel();
message.sender = object.sender ?? "";
message.newLabel = object.newLabel ?? "";
message.contract = object.contract ?? "";
return message;
},
fromAmino(object) {
const message = createBaseMsgUpdateContractLabel();
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
}
if (object.new_label !== undefined && object.new_label !== null) {
message.newLabel = object.new_label;
}
if (object.contract !== undefined && object.contract !== null) {
message.contract = object.contract;
}
return message;
},
toAmino(message) {
const obj = {};
obj.sender = message.sender === "" ? undefined : message.sender;
obj.new_label = message.newLabel === "" ? undefined : message.newLabel;
obj.contract = message.contract === "" ? undefined : message.contract;
return obj;
},
fromAminoMsg(object) {
return MsgUpdateContractLabel.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUpdateContractLabel",
value: MsgUpdateContractLabel.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateContractLabel.decode(message.value);
},
toProto(message) {
return MsgUpdateContractLabel.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateContractLabel",
value: MsgUpdateContractLabel.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUpdateContractLabel.typeUrl, MsgUpdateContractLabel);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateContractLabel.aminoType, MsgUpdateContractLabel.typeUrl);
function createBaseMsgUpdateContractLabelResponse() {
return {};
}
export const MsgUpdateContractLabelResponse = {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateContractLabelResponse",
aminoType: "wasm/MsgUpdateContractLabelResponse",
is(o) {
return o && o.$typeUrl === MsgUpdateContractLabelResponse.typeUrl;
},
isSDK(o) {
return o && o.$typeUrl === MsgUpdateContractLabelResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === MsgUpdateContractLabelResponse.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 = createBaseMsgUpdateContractLabelResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUpdateContractLabelResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUpdateContractLabelResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUpdateContractLabelResponse.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/MsgUpdateContractLabelResponse",
value: MsgUpdateContractLabelResponse.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateContractLabelResponse.decode(message.value);
},
toProto(message) {
return MsgUpdateContractLabelResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.MsgUpdateContractLabelResponse",
value: MsgUpdateContractLabelResponse.encode(message).finish()
};
}
};
GlobalDecoderRegistry.register(MsgUpdateContractLabelResponse.typeUrl, MsgUpdateContractLabelResponse);
GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateContractLabelResponse.aminoType, MsgUpdateContractLabelResponse.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