interchainjs
Version:
InterchainJS is a JavaScript library for interacting with Cosmos SDK based blockchains.
979 lines (978 loc) • 38 kB
JavaScript
import { Any } from "../../../google/protobuf/any";
import { isSet, bytesFromBase64, base64FromBytes } from "../../../helpers";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { GlobalDecoderRegistry } from "../../../registry";
import { toUtf8, fromUtf8 } from "@interchainjs/encoding";
/** AccessType permission types */
export var AccessType;
(function (AccessType) {
/** ACCESS_TYPE_UNSPECIFIED - AccessTypeUnspecified placeholder for empty value */
AccessType[AccessType["ACCESS_TYPE_UNSPECIFIED"] = 0] = "ACCESS_TYPE_UNSPECIFIED";
/** ACCESS_TYPE_NOBODY - AccessTypeNobody forbidden */
AccessType[AccessType["ACCESS_TYPE_NOBODY"] = 1] = "ACCESS_TYPE_NOBODY";
/** ACCESS_TYPE_EVERYBODY - AccessTypeEverybody unrestricted */
AccessType[AccessType["ACCESS_TYPE_EVERYBODY"] = 3] = "ACCESS_TYPE_EVERYBODY";
/** ACCESS_TYPE_ANY_OF_ADDRESSES - AccessTypeAnyOfAddresses allow any of the addresses */
AccessType[AccessType["ACCESS_TYPE_ANY_OF_ADDRESSES"] = 4] = "ACCESS_TYPE_ANY_OF_ADDRESSES";
AccessType[AccessType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(AccessType || (AccessType = {}));
export const AccessTypeAmino = AccessType;
export function accessTypeFromJSON(object) {
switch (object) {
case 0:
case "ACCESS_TYPE_UNSPECIFIED":
return AccessType.ACCESS_TYPE_UNSPECIFIED;
case 1:
case "ACCESS_TYPE_NOBODY":
return AccessType.ACCESS_TYPE_NOBODY;
case 3:
case "ACCESS_TYPE_EVERYBODY":
return AccessType.ACCESS_TYPE_EVERYBODY;
case 4:
case "ACCESS_TYPE_ANY_OF_ADDRESSES":
return AccessType.ACCESS_TYPE_ANY_OF_ADDRESSES;
case -1:
case "UNRECOGNIZED":
default:
return AccessType.UNRECOGNIZED;
}
}
export function accessTypeToJSON(object) {
switch (object) {
case AccessType.ACCESS_TYPE_UNSPECIFIED:
return "ACCESS_TYPE_UNSPECIFIED";
case AccessType.ACCESS_TYPE_NOBODY:
return "ACCESS_TYPE_NOBODY";
case AccessType.ACCESS_TYPE_EVERYBODY:
return "ACCESS_TYPE_EVERYBODY";
case AccessType.ACCESS_TYPE_ANY_OF_ADDRESSES:
return "ACCESS_TYPE_ANY_OF_ADDRESSES";
case AccessType.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
/** ContractCodeHistoryOperationType actions that caused a code change */
export var ContractCodeHistoryOperationType;
(function (ContractCodeHistoryOperationType) {
/** CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED - ContractCodeHistoryOperationTypeUnspecified placeholder for empty value */
ContractCodeHistoryOperationType[ContractCodeHistoryOperationType["CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED"] = 0] = "CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED";
/** CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT - ContractCodeHistoryOperationTypeInit on chain contract instantiation */
ContractCodeHistoryOperationType[ContractCodeHistoryOperationType["CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT"] = 1] = "CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT";
/** CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE - ContractCodeHistoryOperationTypeMigrate code migration */
ContractCodeHistoryOperationType[ContractCodeHistoryOperationType["CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE"] = 2] = "CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE";
/** CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS - ContractCodeHistoryOperationTypeGenesis based on genesis data */
ContractCodeHistoryOperationType[ContractCodeHistoryOperationType["CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS"] = 3] = "CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS";
ContractCodeHistoryOperationType[ContractCodeHistoryOperationType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ContractCodeHistoryOperationType || (ContractCodeHistoryOperationType = {}));
export const ContractCodeHistoryOperationTypeAmino = ContractCodeHistoryOperationType;
export function contractCodeHistoryOperationTypeFromJSON(object) {
switch (object) {
case 0:
case "CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED":
return ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED;
case 1:
case "CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT":
return ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT;
case 2:
case "CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE":
return ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE;
case 3:
case "CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS":
return ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS;
case -1:
case "UNRECOGNIZED":
default:
return ContractCodeHistoryOperationType.UNRECOGNIZED;
}
}
export function contractCodeHistoryOperationTypeToJSON(object) {
switch (object) {
case ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED:
return "CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED";
case ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT:
return "CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT";
case ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE:
return "CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE";
case ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS:
return "CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS";
case ContractCodeHistoryOperationType.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
function createBaseAccessTypeParam() {
return {
value: 0
};
}
/**
* AccessTypeParam
* @name AccessTypeParam
* @package cosmwasm.wasm.v1
* @see proto type: cosmwasm.wasm.v1.AccessTypeParam
*/
export const AccessTypeParam = {
typeUrl: "/cosmwasm.wasm.v1.AccessTypeParam",
aminoType: "wasm/AccessTypeParam",
is(o) {
return o && (o.$typeUrl === AccessTypeParam.typeUrl || isSet(o.value));
},
isAmino(o) {
return o && (o.$typeUrl === AccessTypeParam.typeUrl || isSet(o.value));
},
encode(message, writer = BinaryWriter.create()) {
if (message.value !== 0) {
writer.uint32(8).int32(message.value);
}
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 = createBaseAccessTypeParam();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.value = reader.int32();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseAccessTypeParam();
message.value = object.value ?? 0;
return message;
},
fromAmino(object) {
const message = createBaseAccessTypeParam();
if (object.value !== undefined && object.value !== null) {
message.value = object.value;
}
return message;
},
toAmino(message) {
const obj = {};
obj.value = message.value === 0 ? undefined : message.value;
return obj;
},
fromAminoMsg(object) {
return AccessTypeParam.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/AccessTypeParam",
value: AccessTypeParam.toAmino(message)
};
},
fromProtoMsg(message) {
return AccessTypeParam.decode(message.value);
},
toProto(message) {
return AccessTypeParam.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.AccessTypeParam",
value: AccessTypeParam.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseAccessConfig() {
return {
permission: 0,
addresses: []
};
}
/**
* AccessConfig access control type.
* @name AccessConfig
* @package cosmwasm.wasm.v1
* @see proto type: cosmwasm.wasm.v1.AccessConfig
*/
export const AccessConfig = {
typeUrl: "/cosmwasm.wasm.v1.AccessConfig",
aminoType: "wasm/AccessConfig",
is(o) {
return o && (o.$typeUrl === AccessConfig.typeUrl || isSet(o.permission) && Array.isArray(o.addresses) && (!o.addresses.length || typeof o.addresses[0] === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === AccessConfig.typeUrl || isSet(o.permission) && Array.isArray(o.addresses) && (!o.addresses.length || typeof o.addresses[0] === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.permission !== 0) {
writer.uint32(8).int32(message.permission);
}
for (const v of message.addresses) {
writer.uint32(26).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 = createBaseAccessConfig();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.permission = reader.int32();
break;
case 3:
message.addresses.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseAccessConfig();
message.permission = object.permission ?? 0;
message.addresses = object.addresses?.map(e => e) || [];
return message;
},
fromAmino(object) {
const message = createBaseAccessConfig();
if (object.permission !== undefined && object.permission !== null) {
message.permission = object.permission;
}
message.addresses = object.addresses?.map(e => e) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.permission = message.permission === 0 ? undefined : message.permission;
if (message.addresses) {
obj.addresses = message.addresses.map(e => e);
}
else {
obj.addresses = message.addresses;
}
return obj;
},
fromAminoMsg(object) {
return AccessConfig.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/AccessConfig",
value: AccessConfig.toAmino(message)
};
},
fromProtoMsg(message) {
return AccessConfig.decode(message.value);
},
toProto(message) {
return AccessConfig.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.AccessConfig",
value: AccessConfig.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseParams() {
return {
codeUploadAccess: AccessConfig.fromPartial({}),
instantiateDefaultPermission: 0
};
}
/**
* Params defines the set of wasm parameters.
* @name Params
* @package cosmwasm.wasm.v1
* @see proto type: cosmwasm.wasm.v1.Params
*/
export const Params = {
typeUrl: "/cosmwasm.wasm.v1.Params",
aminoType: "wasm/Params",
is(o) {
return o && (o.$typeUrl === Params.typeUrl || AccessConfig.is(o.codeUploadAccess) && isSet(o.instantiateDefaultPermission));
},
isAmino(o) {
return o && (o.$typeUrl === Params.typeUrl || AccessConfig.isAmino(o.code_upload_access) && isSet(o.instantiate_default_permission));
},
encode(message, writer = BinaryWriter.create()) {
if (message.codeUploadAccess !== undefined) {
AccessConfig.encode(message.codeUploadAccess, writer.uint32(10).fork()).ldelim();
}
if (message.instantiateDefaultPermission !== 0) {
writer.uint32(16).int32(message.instantiateDefaultPermission);
}
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 = createBaseParams();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.codeUploadAccess = AccessConfig.decode(reader, reader.uint32());
break;
case 2:
message.instantiateDefaultPermission = reader.int32();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseParams();
message.codeUploadAccess = object.codeUploadAccess !== undefined && object.codeUploadAccess !== null ? AccessConfig.fromPartial(object.codeUploadAccess) : undefined;
message.instantiateDefaultPermission = object.instantiateDefaultPermission ?? 0;
return message;
},
fromAmino(object) {
const message = createBaseParams();
if (object.code_upload_access !== undefined && object.code_upload_access !== null) {
message.codeUploadAccess = AccessConfig.fromAmino(object.code_upload_access);
}
if (object.instantiate_default_permission !== undefined && object.instantiate_default_permission !== null) {
message.instantiateDefaultPermission = object.instantiate_default_permission;
}
return message;
},
toAmino(message) {
const obj = {};
obj.code_upload_access = message.codeUploadAccess ? AccessConfig.toAmino(message.codeUploadAccess) : AccessConfig.toAmino(AccessConfig.fromPartial({}));
obj.instantiate_default_permission = message.instantiateDefaultPermission === 0 ? undefined : message.instantiateDefaultPermission;
return obj;
},
fromAminoMsg(object) {
return Params.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/Params",
value: Params.toAmino(message)
};
},
fromProtoMsg(message) {
return Params.decode(message.value);
},
toProto(message) {
return Params.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.Params",
value: Params.encode(message).finish()
};
},
registerTypeUrl() {
if (!GlobalDecoderRegistry.registerExistingTypeUrl(Params.typeUrl)) {
return;
}
AccessConfig.registerTypeUrl();
}
};
function createBaseCodeInfo() {
return {
codeHash: new Uint8Array(),
creator: "",
instantiateConfig: AccessConfig.fromPartial({})
};
}
/**
* CodeInfo is data for the uploaded contract WASM code
* @name CodeInfo
* @package cosmwasm.wasm.v1
* @see proto type: cosmwasm.wasm.v1.CodeInfo
*/
export const CodeInfo = {
typeUrl: "/cosmwasm.wasm.v1.CodeInfo",
aminoType: "wasm/CodeInfo",
is(o) {
return o && (o.$typeUrl === CodeInfo.typeUrl || (o.codeHash instanceof Uint8Array || typeof o.codeHash === "string") && typeof o.creator === "string" && AccessConfig.is(o.instantiateConfig));
},
isAmino(o) {
return o && (o.$typeUrl === CodeInfo.typeUrl || (o.code_hash instanceof Uint8Array || typeof o.code_hash === "string") && typeof o.creator === "string" && AccessConfig.isAmino(o.instantiate_config));
},
encode(message, writer = BinaryWriter.create()) {
if (message.codeHash.length !== 0) {
writer.uint32(10).bytes(message.codeHash);
}
if (message.creator !== "") {
writer.uint32(18).string(message.creator);
}
if (message.instantiateConfig !== undefined) {
AccessConfig.encode(message.instantiateConfig, 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 = createBaseCodeInfo();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.codeHash = reader.bytes();
break;
case 2:
message.creator = reader.string();
break;
case 5:
message.instantiateConfig = AccessConfig.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseCodeInfo();
message.codeHash = object.codeHash ?? new Uint8Array();
message.creator = object.creator ?? "";
message.instantiateConfig = object.instantiateConfig !== undefined && object.instantiateConfig !== null ? AccessConfig.fromPartial(object.instantiateConfig) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseCodeInfo();
if (object.code_hash !== undefined && object.code_hash !== null) {
message.codeHash = bytesFromBase64(object.code_hash);
}
if (object.creator !== undefined && object.creator !== null) {
message.creator = object.creator;
}
if (object.instantiate_config !== undefined && object.instantiate_config !== null) {
message.instantiateConfig = AccessConfig.fromAmino(object.instantiate_config);
}
return message;
},
toAmino(message) {
const obj = {};
obj.code_hash = message.codeHash ? base64FromBytes(message.codeHash) : undefined;
obj.creator = message.creator === "" ? undefined : message.creator;
obj.instantiate_config = message.instantiateConfig ? AccessConfig.toAmino(message.instantiateConfig) : AccessConfig.toAmino(AccessConfig.fromPartial({}));
return obj;
},
fromAminoMsg(object) {
return CodeInfo.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/CodeInfo",
value: CodeInfo.toAmino(message)
};
},
fromProtoMsg(message) {
return CodeInfo.decode(message.value);
},
toProto(message) {
return CodeInfo.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.CodeInfo",
value: CodeInfo.encode(message).finish()
};
},
registerTypeUrl() {
if (!GlobalDecoderRegistry.registerExistingTypeUrl(CodeInfo.typeUrl)) {
return;
}
AccessConfig.registerTypeUrl();
}
};
function createBaseContractInfo() {
return {
codeId: BigInt(0),
creator: "",
admin: "",
label: "",
created: undefined,
ibcPortId: "",
ibc2PortId: "",
extension: undefined
};
}
/**
* ContractInfo stores a WASM contract instance
* @name ContractInfo
* @package cosmwasm.wasm.v1
* @see proto type: cosmwasm.wasm.v1.ContractInfo
*/
export const ContractInfo = {
typeUrl: "/cosmwasm.wasm.v1.ContractInfo",
aminoType: "wasm/ContractInfo",
is(o) {
return o && (o.$typeUrl === ContractInfo.typeUrl || typeof o.codeId === "bigint" && typeof o.creator === "string" && typeof o.admin === "string" && typeof o.label === "string" && typeof o.ibcPortId === "string" && typeof o.ibc2PortId === "string");
},
isAmino(o) {
return o && (o.$typeUrl === ContractInfo.typeUrl || typeof o.code_id === "bigint" && typeof o.creator === "string" && typeof o.admin === "string" && typeof o.label === "string" && typeof o.ibc_port_id === "string" && typeof o.ibc2_port_id === "string");
},
encode(message, writer = BinaryWriter.create()) {
if (message.codeId !== BigInt(0)) {
writer.uint32(8).uint64(message.codeId);
}
if (message.creator !== "") {
writer.uint32(18).string(message.creator);
}
if (message.admin !== "") {
writer.uint32(26).string(message.admin);
}
if (message.label !== "") {
writer.uint32(34).string(message.label);
}
if (message.created !== undefined) {
AbsoluteTxPosition.encode(message.created, writer.uint32(42).fork()).ldelim();
}
if (message.ibcPortId !== "") {
writer.uint32(50).string(message.ibcPortId);
}
if (message.ibc2PortId !== "") {
writer.uint32(58).string(message.ibc2PortId);
}
if (message.extension !== undefined) {
Any.encode(GlobalDecoderRegistry.wrapAny(message.extension), writer.uint32(66).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 = createBaseContractInfo();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.codeId = reader.uint64();
break;
case 2:
message.creator = reader.string();
break;
case 3:
message.admin = reader.string();
break;
case 4:
message.label = reader.string();
break;
case 5:
message.created = AbsoluteTxPosition.decode(reader, reader.uint32());
break;
case 6:
message.ibcPortId = reader.string();
break;
case 7:
message.ibc2PortId = reader.string();
break;
case 8:
message.extension = GlobalDecoderRegistry.unwrapAny(reader);
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseContractInfo();
message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
message.creator = object.creator ?? "";
message.admin = object.admin ?? "";
message.label = object.label ?? "";
message.created = object.created !== undefined && object.created !== null ? AbsoluteTxPosition.fromPartial(object.created) : undefined;
message.ibcPortId = object.ibcPortId ?? "";
message.ibc2PortId = object.ibc2PortId ?? "";
message.extension = object.extension !== undefined && object.extension !== null ? GlobalDecoderRegistry.fromPartial(object.extension) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseContractInfo();
if (object.code_id !== undefined && object.code_id !== null) {
message.codeId = BigInt(object.code_id);
}
if (object.creator !== undefined && object.creator !== null) {
message.creator = object.creator;
}
if (object.admin !== undefined && object.admin !== null) {
message.admin = object.admin;
}
if (object.label !== undefined && object.label !== null) {
message.label = object.label;
}
if (object.created !== undefined && object.created !== null) {
message.created = AbsoluteTxPosition.fromAmino(object.created);
}
if (object.ibc_port_id !== undefined && object.ibc_port_id !== null) {
message.ibcPortId = object.ibc_port_id;
}
if (object.ibc2_port_id !== undefined && object.ibc2_port_id !== null) {
message.ibc2PortId = object.ibc2_port_id;
}
if (object.extension !== undefined && object.extension !== null) {
message.extension = GlobalDecoderRegistry.fromAminoMsg(object.extension);
}
return message;
},
toAmino(message) {
const obj = {};
obj.code_id = message.codeId !== BigInt(0) ? message.codeId?.toString() : undefined;
obj.creator = message.creator === "" ? undefined : message.creator;
obj.admin = message.admin === "" ? undefined : message.admin;
obj.label = message.label === "" ? undefined : message.label;
obj.created = message.created ? AbsoluteTxPosition.toAmino(message.created) : undefined;
obj.ibc_port_id = message.ibcPortId === "" ? undefined : message.ibcPortId;
obj.ibc2_port_id = message.ibc2PortId === "" ? undefined : message.ibc2PortId;
obj.extension = message.extension ? GlobalDecoderRegistry.toAminoMsg(message.extension) : undefined;
return obj;
},
fromAminoMsg(object) {
return ContractInfo.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/ContractInfo",
value: ContractInfo.toAmino(message)
};
},
fromProtoMsg(message) {
return ContractInfo.decode(message.value);
},
toProto(message) {
return ContractInfo.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.ContractInfo",
value: ContractInfo.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseContractCodeHistoryEntry() {
return {
operation: 0,
codeId: BigInt(0),
updated: undefined,
msg: new Uint8Array()
};
}
/**
* ContractCodeHistoryEntry metadata to a contract.
* @name ContractCodeHistoryEntry
* @package cosmwasm.wasm.v1
* @see proto type: cosmwasm.wasm.v1.ContractCodeHistoryEntry
*/
export const ContractCodeHistoryEntry = {
typeUrl: "/cosmwasm.wasm.v1.ContractCodeHistoryEntry",
aminoType: "wasm/ContractCodeHistoryEntry",
is(o) {
return o && (o.$typeUrl === ContractCodeHistoryEntry.typeUrl || isSet(o.operation) && typeof o.codeId === "bigint" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === ContractCodeHistoryEntry.typeUrl || isSet(o.operation) && typeof o.code_id === "bigint" && (o.msg instanceof Uint8Array || typeof o.msg === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.operation !== 0) {
writer.uint32(8).int32(message.operation);
}
if (message.codeId !== BigInt(0)) {
writer.uint32(16).uint64(message.codeId);
}
if (message.updated !== undefined) {
AbsoluteTxPosition.encode(message.updated, writer.uint32(26).fork()).ldelim();
}
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 = createBaseContractCodeHistoryEntry();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.operation = reader.int32();
break;
case 2:
message.codeId = reader.uint64();
break;
case 3:
message.updated = AbsoluteTxPosition.decode(reader, reader.uint32());
break;
case 4:
message.msg = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseContractCodeHistoryEntry();
message.operation = object.operation ?? 0;
message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
message.updated = object.updated !== undefined && object.updated !== null ? AbsoluteTxPosition.fromPartial(object.updated) : undefined;
message.msg = object.msg ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseContractCodeHistoryEntry();
if (object.operation !== undefined && object.operation !== null) {
message.operation = object.operation;
}
if (object.code_id !== undefined && object.code_id !== null) {
message.codeId = BigInt(object.code_id);
}
if (object.updated !== undefined && object.updated !== null) {
message.updated = AbsoluteTxPosition.fromAmino(object.updated);
}
if (object.msg !== undefined && object.msg !== null) {
message.msg = toUtf8(JSON.stringify(object.msg));
}
return message;
},
toAmino(message) {
const obj = {};
obj.operation = message.operation === 0 ? undefined : message.operation;
obj.code_id = message.codeId !== BigInt(0) ? message.codeId?.toString() : undefined;
obj.updated = message.updated ? AbsoluteTxPosition.toAmino(message.updated) : undefined;
obj.msg = message.msg ? JSON.parse(fromUtf8(message.msg)) : undefined;
return obj;
},
fromAminoMsg(object) {
return ContractCodeHistoryEntry.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/ContractCodeHistoryEntry",
value: ContractCodeHistoryEntry.toAmino(message)
};
},
fromProtoMsg(message) {
return ContractCodeHistoryEntry.decode(message.value);
},
toProto(message) {
return ContractCodeHistoryEntry.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.ContractCodeHistoryEntry",
value: ContractCodeHistoryEntry.encode(message).finish()
};
},
registerTypeUrl() {
if (!GlobalDecoderRegistry.registerExistingTypeUrl(ContractCodeHistoryEntry.typeUrl)) {
return;
}
AbsoluteTxPosition.registerTypeUrl();
}
};
function createBaseAbsoluteTxPosition() {
return {
blockHeight: BigInt(0),
txIndex: BigInt(0)
};
}
/**
* AbsoluteTxPosition is a unique transaction position that allows for global
* ordering of transactions.
* @name AbsoluteTxPosition
* @package cosmwasm.wasm.v1
* @see proto type: cosmwasm.wasm.v1.AbsoluteTxPosition
*/
export const AbsoluteTxPosition = {
typeUrl: "/cosmwasm.wasm.v1.AbsoluteTxPosition",
aminoType: "wasm/AbsoluteTxPosition",
is(o) {
return o && (o.$typeUrl === AbsoluteTxPosition.typeUrl || typeof o.blockHeight === "bigint" && typeof o.txIndex === "bigint");
},
isAmino(o) {
return o && (o.$typeUrl === AbsoluteTxPosition.typeUrl || typeof o.block_height === "bigint" && typeof o.tx_index === "bigint");
},
encode(message, writer = BinaryWriter.create()) {
if (message.blockHeight !== BigInt(0)) {
writer.uint32(8).uint64(message.blockHeight);
}
if (message.txIndex !== BigInt(0)) {
writer.uint32(16).uint64(message.txIndex);
}
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 = createBaseAbsoluteTxPosition();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.blockHeight = reader.uint64();
break;
case 2:
message.txIndex = reader.uint64();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseAbsoluteTxPosition();
message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? BigInt(object.blockHeight.toString()) : BigInt(0);
message.txIndex = object.txIndex !== undefined && object.txIndex !== null ? BigInt(object.txIndex.toString()) : BigInt(0);
return message;
},
fromAmino(object) {
const message = createBaseAbsoluteTxPosition();
if (object.block_height !== undefined && object.block_height !== null) {
message.blockHeight = BigInt(object.block_height);
}
if (object.tx_index !== undefined && object.tx_index !== null) {
message.txIndex = BigInt(object.tx_index);
}
return message;
},
toAmino(message) {
const obj = {};
obj.block_height = message.blockHeight !== BigInt(0) ? message.blockHeight?.toString() : undefined;
obj.tx_index = message.txIndex !== BigInt(0) ? message.txIndex?.toString() : undefined;
return obj;
},
fromAminoMsg(object) {
return AbsoluteTxPosition.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/AbsoluteTxPosition",
value: AbsoluteTxPosition.toAmino(message)
};
},
fromProtoMsg(message) {
return AbsoluteTxPosition.decode(message.value);
},
toProto(message) {
return AbsoluteTxPosition.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.AbsoluteTxPosition",
value: AbsoluteTxPosition.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseModel() {
return {
key: new Uint8Array(),
value: new Uint8Array()
};
}
/**
* Model is a struct that holds a KV pair
* @name Model
* @package cosmwasm.wasm.v1
* @see proto type: cosmwasm.wasm.v1.Model
*/
export const Model = {
typeUrl: "/cosmwasm.wasm.v1.Model",
aminoType: "wasm/Model",
is(o) {
return o && (o.$typeUrl === Model.typeUrl || (o.key instanceof Uint8Array || typeof o.key === "string") && (o.value instanceof Uint8Array || typeof o.value === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === Model.typeUrl || (o.key instanceof Uint8Array || typeof o.key === "string") && (o.value instanceof Uint8Array || typeof o.value === "string"));
},
encode(message, writer = BinaryWriter.create()) {
if (message.key.length !== 0) {
writer.uint32(10).bytes(message.key);
}
if (message.value.length !== 0) {
writer.uint32(18).bytes(message.value);
}
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 = createBaseModel();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.bytes();
break;
case 2:
message.value = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseModel();
message.key = object.key ?? new Uint8Array();
message.value = object.value ?? new Uint8Array();
return message;
},
fromAmino(object) {
const message = createBaseModel();
if (object.key !== undefined && object.key !== null) {
message.key = bytesFromBase64(object.key);
}
if (object.value !== undefined && object.value !== null) {
message.value = bytesFromBase64(object.value);
}
return message;
},
toAmino(message) {
const obj = {};
obj.key = message.key ? base64FromBytes(message.key) : undefined;
obj.value = message.value ? base64FromBytes(message.value) : undefined;
return obj;
},
fromAminoMsg(object) {
return Model.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "wasm/Model",
value: Model.toAmino(message)
};
},
fromProtoMsg(message) {
return Model.decode(message.value);
},
toProto(message) {
return Model.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmwasm.wasm.v1.Model",
value: Model.encode(message).finish()
};
},
registerTypeUrl() { }
};