From 98213dc514fe9c3e951597d50e6b1b0f766f2a63 Mon Sep 17 00:00:00 2001 From: 0xPatrick Date: Thu, 2 May 2024 17:00:27 -0400 Subject: [PATCH] feat(cosmic-proto): add icq/v1 proto + codegen for @agoric/orchestration - sourced from: https://github.com/cosmos/ibc-apps/tree/18248c35e913b3ccba99a2756612b1fcb3370a0d/modules/async-icq/proto/icq/v1 - refs: #9072 --- .../interchain_accounts/README.md | 1 + packages/cosmic-proto/proto/icq/README.md | 3 + .../cosmic-proto/proto/icq/v1/genesis.proto | 14 + packages/cosmic-proto/proto/icq/v1/icq.proto | 15 + .../cosmic-proto/proto/icq/v1/packet.proto | 32 ++ .../cosmic-proto/proto/icq/v1/query.proto | 25 ++ packages/cosmic-proto/proto/icq/v1/tx.proto | 41 ++ .../cosmic-proto/src/codegen/icq/bundle.ts | 15 + .../src/codegen/icq/v1/genesis.ts | 94 +++++ .../cosmic-proto/src/codegen/icq/v1/icq.ts | 100 +++++ .../cosmic-proto/src/codegen/icq/v1/packet.ts | 364 ++++++++++++++++++ .../cosmic-proto/src/codegen/icq/v1/query.ts | 147 +++++++ .../cosmic-proto/src/codegen/icq/v1/tx.ts | 183 +++++++++ .../cosmic-proto/src/codegen/ics23/bundle.ts | 4 +- packages/cosmic-proto/src/codegen/index.ts | 1 + .../src/codegen/tendermint/bundle.ts | 44 +-- .../test/snapshots/test-exports.js.md | 1 + .../test/snapshots/test-exports.js.snap | Bin 1196 -> 1201 bytes 18 files changed, 1060 insertions(+), 24 deletions(-) create mode 100644 packages/cosmic-proto/proto/ibc/applications/interchain_accounts/README.md create mode 100644 packages/cosmic-proto/proto/icq/README.md create mode 100644 packages/cosmic-proto/proto/icq/v1/genesis.proto create mode 100644 packages/cosmic-proto/proto/icq/v1/icq.proto create mode 100644 packages/cosmic-proto/proto/icq/v1/packet.proto create mode 100644 packages/cosmic-proto/proto/icq/v1/query.proto create mode 100644 packages/cosmic-proto/proto/icq/v1/tx.proto create mode 100644 packages/cosmic-proto/src/codegen/icq/bundle.ts create mode 100644 packages/cosmic-proto/src/codegen/icq/v1/genesis.ts create mode 100644 packages/cosmic-proto/src/codegen/icq/v1/icq.ts create mode 100644 packages/cosmic-proto/src/codegen/icq/v1/packet.ts create mode 100644 packages/cosmic-proto/src/codegen/icq/v1/query.ts create mode 100644 packages/cosmic-proto/src/codegen/icq/v1/tx.ts diff --git a/packages/cosmic-proto/proto/ibc/applications/interchain_accounts/README.md b/packages/cosmic-proto/proto/ibc/applications/interchain_accounts/README.md new file mode 100644 index 00000000000..a197f83216f --- /dev/null +++ b/packages/cosmic-proto/proto/ibc/applications/interchain_accounts/README.md @@ -0,0 +1 @@ +# interchain accounts diff --git a/packages/cosmic-proto/proto/icq/README.md b/packages/cosmic-proto/proto/icq/README.md new file mode 100644 index 00000000000..85789a7a96d --- /dev/null +++ b/packages/cosmic-proto/proto/icq/README.md @@ -0,0 +1,3 @@ +# icq (interchain queries) + +These protos were sourced from: [cosmos/ibc-apps/async-icq/v1#18248c3](https://github.com/cosmos/ibc-apps/tree/18248c35e913b3ccba99a2756612b1fcb3370a0d/modules/async-icq/proto/icq/v1) diff --git a/packages/cosmic-proto/proto/icq/v1/genesis.proto b/packages/cosmic-proto/proto/icq/v1/genesis.proto new file mode 100644 index 00000000000..d8a8fe055f1 --- /dev/null +++ b/packages/cosmic-proto/proto/icq/v1/genesis.proto @@ -0,0 +1,14 @@ +syntax = "proto3"; + +package icq.v1; + +option go_package = "github.com/cosmos/ibc-apps/modules/async-icq/v8/types"; + +import "gogoproto/gogo.proto"; +import "icq/v1/icq.proto"; + +// GenesisState defines the interchain query genesis state +message GenesisState { + string host_port = 1; + Params params = 4 [(gogoproto.nullable) = false]; +} \ No newline at end of file diff --git a/packages/cosmic-proto/proto/icq/v1/icq.proto b/packages/cosmic-proto/proto/icq/v1/icq.proto new file mode 100644 index 00000000000..3b63f05f63d --- /dev/null +++ b/packages/cosmic-proto/proto/icq/v1/icq.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package icq.v1; + +option go_package = "github.com/cosmos/ibc-apps/modules/async-icq/v8/types"; + +import "gogoproto/gogo.proto"; + +// Params defines the set of on-chain interchain query parameters. +message Params { + // host_enabled enables or disables the host submodule. + bool host_enabled = 2 [(gogoproto.moretags) = "yaml:\"host_enabled\""]; + // allow_queries defines a list of query paths allowed to be queried on a host chain. + repeated string allow_queries = 3 [(gogoproto.moretags) = "yaml:\"allow_queries\""]; +} diff --git a/packages/cosmic-proto/proto/icq/v1/packet.proto b/packages/cosmic-proto/proto/icq/v1/packet.proto new file mode 100644 index 00000000000..f16d8e76d8c --- /dev/null +++ b/packages/cosmic-proto/proto/icq/v1/packet.proto @@ -0,0 +1,32 @@ +syntax = "proto3"; + +package icq.v1; + +import "gogoproto/gogo.proto"; +import "tendermint/abci/types.proto"; + +option go_package = "github.com/cosmos/ibc-apps/modules/async-icq/v8/types"; + + + +// InterchainQueryPacketData is comprised of raw query. +message InterchainQueryPacketData { + bytes data = 1; + // optional memo + string memo = 2; +} + +// InterchainQueryPacketAck is comprised of an ABCI query response with non-deterministic fields left empty (e.g. Codespace, Log, Info and ...). +message InterchainQueryPacketAck { + bytes data = 1; +} + +// CosmosQuery contains a list of tendermint ABCI query requests. It should be used when sending queries to an SDK host chain. +message CosmosQuery { + repeated tendermint.abci.RequestQuery requests = 1 [(gogoproto.nullable) = false]; +} + +// CosmosResponse contains a list of tendermint ABCI query responses. It should be used when receiving responses from an SDK host chain. +message CosmosResponse { + repeated tendermint.abci.ResponseQuery responses = 1 [(gogoproto.nullable) = false]; +} \ No newline at end of file diff --git a/packages/cosmic-proto/proto/icq/v1/query.proto b/packages/cosmic-proto/proto/icq/v1/query.proto new file mode 100644 index 00000000000..f32dbd9aefd --- /dev/null +++ b/packages/cosmic-proto/proto/icq/v1/query.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; + +package icq.v1; + +option go_package = "github.com/cosmos/ibc-apps/modules/async-icq/v8/types"; + +import "google/api/annotations.proto"; +import "icq/v1/icq.proto"; + +// Query provides defines the gRPC querier service. +service Query { + // Params queries all parameters of the ICQ module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/async-icq/v1/params"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1; +} \ No newline at end of file diff --git a/packages/cosmic-proto/proto/icq/v1/tx.proto b/packages/cosmic-proto/proto/icq/v1/tx.proto new file mode 100644 index 00000000000..a618b4b4373 --- /dev/null +++ b/packages/cosmic-proto/proto/icq/v1/tx.proto @@ -0,0 +1,41 @@ +syntax = "proto3"; +package icq.v1; + +import "cosmos/msg/v1/msg.proto"; +import "icq/v1/icq.proto"; +import "gogoproto/gogo.proto"; +import "cosmos_proto/cosmos.proto"; + +option go_package = "github.com/cosmos/ibc-apps/modules/async-icq/v8/types"; + +// Msg defines the Msg service. +service Msg { + option (cosmos.msg.v1.service) = true; + + // UpdateParams defines a governance operation for updating the x/async-icq module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); +} + +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + + // authority is the address of the governance account. + string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // params defines the x/async-icq parameters to update. + // + // NOTE: All parameters must be supplied. + Params params = 2 [(gogoproto.nullable) = false]; +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParamsResponse {} \ No newline at end of file diff --git a/packages/cosmic-proto/src/codegen/icq/bundle.ts b/packages/cosmic-proto/src/codegen/icq/bundle.ts new file mode 100644 index 00000000000..262be354b2f --- /dev/null +++ b/packages/cosmic-proto/src/codegen/icq/bundle.ts @@ -0,0 +1,15 @@ +//@ts-nocheck +import * as _118 from './v1/genesis.js'; +import * as _119 from './v1/icq.js'; +import * as _120 from './v1/packet.js'; +import * as _121 from './v1/query.js'; +import * as _122 from './v1/tx.js'; +export namespace icq { + export const v1 = { + ..._118, + ..._119, + ..._120, + ..._121, + ..._122, + }; +} diff --git a/packages/cosmic-proto/src/codegen/icq/v1/genesis.ts b/packages/cosmic-proto/src/codegen/icq/v1/genesis.ts new file mode 100644 index 00000000000..c110f465921 --- /dev/null +++ b/packages/cosmic-proto/src/codegen/icq/v1/genesis.ts @@ -0,0 +1,94 @@ +//@ts-nocheck +import { Params, ParamsSDKType } from './icq.js'; +import { BinaryReader, BinaryWriter } from '../../binary.js'; +import { isSet } from '../../helpers.js'; +/** GenesisState defines the interchain query genesis state */ +export interface GenesisState { + hostPort: string; + params: Params; +} +export interface GenesisStateProtoMsg { + typeUrl: '/icq.v1.GenesisState'; + value: Uint8Array; +} +/** GenesisState defines the interchain query genesis state */ +export interface GenesisStateSDKType { + host_port: string; + params: ParamsSDKType; +} +function createBaseGenesisState(): GenesisState { + return { + hostPort: '', + params: Params.fromPartial({}), + }; +} +export const GenesisState = { + typeUrl: '/icq.v1.GenesisState', + encode( + message: GenesisState, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + if (message.hostPort !== '') { + writer.uint32(10).string(message.hostPort); + } + if (message.params !== undefined) { + Params.encode(message.params, writer.uint32(34).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): GenesisState { + const reader = + input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenesisState(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.hostPort = reader.string(); + break; + case 4: + message.params = Params.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GenesisState { + return { + hostPort: isSet(object.hostPort) ? String(object.hostPort) : '', + params: isSet(object.params) ? Params.fromJSON(object.params) : undefined, + }; + }, + toJSON(message: GenesisState): unknown { + const obj: any = {}; + message.hostPort !== undefined && (obj.hostPort = message.hostPort); + message.params !== undefined && + (obj.params = message.params ? Params.toJSON(message.params) : undefined); + return obj; + }, + fromPartial(object: Partial): GenesisState { + const message = createBaseGenesisState(); + message.hostPort = object.hostPort ?? ''; + message.params = + object.params !== undefined && object.params !== null + ? Params.fromPartial(object.params) + : undefined; + return message; + }, + fromProtoMsg(message: GenesisStateProtoMsg): GenesisState { + return GenesisState.decode(message.value); + }, + toProto(message: GenesisState): Uint8Array { + return GenesisState.encode(message).finish(); + }, + toProtoMsg(message: GenesisState): GenesisStateProtoMsg { + return { + typeUrl: '/icq.v1.GenesisState', + value: GenesisState.encode(message).finish(), + }; + }, +}; diff --git a/packages/cosmic-proto/src/codegen/icq/v1/icq.ts b/packages/cosmic-proto/src/codegen/icq/v1/icq.ts new file mode 100644 index 00000000000..200842b91cc --- /dev/null +++ b/packages/cosmic-proto/src/codegen/icq/v1/icq.ts @@ -0,0 +1,100 @@ +//@ts-nocheck +import { BinaryReader, BinaryWriter } from '../../binary.js'; +import { isSet } from '../../helpers.js'; +/** Params defines the set of on-chain interchain query parameters. */ +export interface Params { + /** host_enabled enables or disables the host submodule. */ + hostEnabled: boolean; + /** allow_queries defines a list of query paths allowed to be queried on a host chain. */ + allowQueries: string[]; +} +export interface ParamsProtoMsg { + typeUrl: '/icq.v1.Params'; + value: Uint8Array; +} +/** Params defines the set of on-chain interchain query parameters. */ +export interface ParamsSDKType { + host_enabled: boolean; + allow_queries: string[]; +} +function createBaseParams(): Params { + return { + hostEnabled: false, + allowQueries: [], + }; +} +export const Params = { + typeUrl: '/icq.v1.Params', + encode( + message: Params, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + if (message.hostEnabled === true) { + writer.uint32(16).bool(message.hostEnabled); + } + for (const v of message.allowQueries) { + writer.uint32(26).string(v!); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): Params { + 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 2: + message.hostEnabled = reader.bool(); + break; + case 3: + message.allowQueries.push(reader.string()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): Params { + return { + hostEnabled: isSet(object.hostEnabled) + ? Boolean(object.hostEnabled) + : false, + allowQueries: Array.isArray(object?.allowQueries) + ? object.allowQueries.map((e: any) => String(e)) + : [], + }; + }, + toJSON(message: Params): unknown { + const obj: any = {}; + message.hostEnabled !== undefined && + (obj.hostEnabled = message.hostEnabled); + if (message.allowQueries) { + obj.allowQueries = message.allowQueries.map(e => e); + } else { + obj.allowQueries = []; + } + return obj; + }, + fromPartial(object: Partial): Params { + const message = createBaseParams(); + message.hostEnabled = object.hostEnabled ?? false; + message.allowQueries = object.allowQueries?.map(e => e) || []; + return message; + }, + fromProtoMsg(message: ParamsProtoMsg): Params { + return Params.decode(message.value); + }, + toProto(message: Params): Uint8Array { + return Params.encode(message).finish(); + }, + toProtoMsg(message: Params): ParamsProtoMsg { + return { + typeUrl: '/icq.v1.Params', + value: Params.encode(message).finish(), + }; + }, +}; diff --git a/packages/cosmic-proto/src/codegen/icq/v1/packet.ts b/packages/cosmic-proto/src/codegen/icq/v1/packet.ts new file mode 100644 index 00000000000..e9293539421 --- /dev/null +++ b/packages/cosmic-proto/src/codegen/icq/v1/packet.ts @@ -0,0 +1,364 @@ +//@ts-nocheck +import { + RequestQuery, + RequestQuerySDKType, + ResponseQuery, + ResponseQuerySDKType, +} from '../../tendermint/abci/types.js'; +import { BinaryReader, BinaryWriter } from '../../binary.js'; +import { isSet, bytesFromBase64, base64FromBytes } from '../../helpers.js'; +/** InterchainQueryPacketData is comprised of raw query. */ +export interface InterchainQueryPacketData { + data: Uint8Array; + /** optional memo */ + memo: string; +} +export interface InterchainQueryPacketDataProtoMsg { + typeUrl: '/icq.v1.InterchainQueryPacketData'; + value: Uint8Array; +} +/** InterchainQueryPacketData is comprised of raw query. */ +export interface InterchainQueryPacketDataSDKType { + data: Uint8Array; + memo: string; +} +/** InterchainQueryPacketAck is comprised of an ABCI query response with non-deterministic fields left empty (e.g. Codespace, Log, Info and ...). */ +export interface InterchainQueryPacketAck { + data: Uint8Array; +} +export interface InterchainQueryPacketAckProtoMsg { + typeUrl: '/icq.v1.InterchainQueryPacketAck'; + value: Uint8Array; +} +/** InterchainQueryPacketAck is comprised of an ABCI query response with non-deterministic fields left empty (e.g. Codespace, Log, Info and ...). */ +export interface InterchainQueryPacketAckSDKType { + data: Uint8Array; +} +/** CosmosQuery contains a list of tendermint ABCI query requests. It should be used when sending queries to an SDK host chain. */ +export interface CosmosQuery { + requests: RequestQuery[]; +} +export interface CosmosQueryProtoMsg { + typeUrl: '/icq.v1.CosmosQuery'; + value: Uint8Array; +} +/** CosmosQuery contains a list of tendermint ABCI query requests. It should be used when sending queries to an SDK host chain. */ +export interface CosmosQuerySDKType { + requests: RequestQuerySDKType[]; +} +/** CosmosResponse contains a list of tendermint ABCI query responses. It should be used when receiving responses from an SDK host chain. */ +export interface CosmosResponse { + responses: ResponseQuery[]; +} +export interface CosmosResponseProtoMsg { + typeUrl: '/icq.v1.CosmosResponse'; + value: Uint8Array; +} +/** CosmosResponse contains a list of tendermint ABCI query responses. It should be used when receiving responses from an SDK host chain. */ +export interface CosmosResponseSDKType { + responses: ResponseQuerySDKType[]; +} +function createBaseInterchainQueryPacketData(): InterchainQueryPacketData { + return { + data: new Uint8Array(), + memo: '', + }; +} +export const InterchainQueryPacketData = { + typeUrl: '/icq.v1.InterchainQueryPacketData', + encode( + message: InterchainQueryPacketData, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + if (message.data.length !== 0) { + writer.uint32(10).bytes(message.data); + } + if (message.memo !== '') { + writer.uint32(18).string(message.memo); + } + return writer; + }, + decode( + input: BinaryReader | Uint8Array, + length?: number, + ): InterchainQueryPacketData { + const reader = + input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseInterchainQueryPacketData(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.data = reader.bytes(); + break; + case 2: + message.memo = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): InterchainQueryPacketData { + return { + data: isSet(object.data) + ? bytesFromBase64(object.data) + : new Uint8Array(), + memo: isSet(object.memo) ? String(object.memo) : '', + }; + }, + toJSON(message: InterchainQueryPacketData): unknown { + const obj: any = {}; + message.data !== undefined && + (obj.data = base64FromBytes( + message.data !== undefined ? message.data : new Uint8Array(), + )); + message.memo !== undefined && (obj.memo = message.memo); + return obj; + }, + fromPartial( + object: Partial, + ): InterchainQueryPacketData { + const message = createBaseInterchainQueryPacketData(); + message.data = object.data ?? new Uint8Array(); + message.memo = object.memo ?? ''; + return message; + }, + fromProtoMsg( + message: InterchainQueryPacketDataProtoMsg, + ): InterchainQueryPacketData { + return InterchainQueryPacketData.decode(message.value); + }, + toProto(message: InterchainQueryPacketData): Uint8Array { + return InterchainQueryPacketData.encode(message).finish(); + }, + toProtoMsg( + message: InterchainQueryPacketData, + ): InterchainQueryPacketDataProtoMsg { + return { + typeUrl: '/icq.v1.InterchainQueryPacketData', + value: InterchainQueryPacketData.encode(message).finish(), + }; + }, +}; +function createBaseInterchainQueryPacketAck(): InterchainQueryPacketAck { + return { + data: new Uint8Array(), + }; +} +export const InterchainQueryPacketAck = { + typeUrl: '/icq.v1.InterchainQueryPacketAck', + encode( + message: InterchainQueryPacketAck, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + if (message.data.length !== 0) { + writer.uint32(10).bytes(message.data); + } + return writer; + }, + decode( + input: BinaryReader | Uint8Array, + length?: number, + ): InterchainQueryPacketAck { + const reader = + input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseInterchainQueryPacketAck(); + 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; + }, + fromJSON(object: any): InterchainQueryPacketAck { + return { + data: isSet(object.data) + ? bytesFromBase64(object.data) + : new Uint8Array(), + }; + }, + toJSON(message: InterchainQueryPacketAck): unknown { + const obj: any = {}; + message.data !== undefined && + (obj.data = base64FromBytes( + message.data !== undefined ? message.data : new Uint8Array(), + )); + return obj; + }, + fromPartial( + object: Partial, + ): InterchainQueryPacketAck { + const message = createBaseInterchainQueryPacketAck(); + message.data = object.data ?? new Uint8Array(); + return message; + }, + fromProtoMsg( + message: InterchainQueryPacketAckProtoMsg, + ): InterchainQueryPacketAck { + return InterchainQueryPacketAck.decode(message.value); + }, + toProto(message: InterchainQueryPacketAck): Uint8Array { + return InterchainQueryPacketAck.encode(message).finish(); + }, + toProtoMsg( + message: InterchainQueryPacketAck, + ): InterchainQueryPacketAckProtoMsg { + return { + typeUrl: '/icq.v1.InterchainQueryPacketAck', + value: InterchainQueryPacketAck.encode(message).finish(), + }; + }, +}; +function createBaseCosmosQuery(): CosmosQuery { + return { + requests: [], + }; +} +export const CosmosQuery = { + typeUrl: '/icq.v1.CosmosQuery', + encode( + message: CosmosQuery, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + for (const v of message.requests) { + RequestQuery.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): CosmosQuery { + const reader = + input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCosmosQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.requests.push(RequestQuery.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): CosmosQuery { + return { + requests: Array.isArray(object?.requests) + ? object.requests.map((e: any) => RequestQuery.fromJSON(e)) + : [], + }; + }, + toJSON(message: CosmosQuery): unknown { + const obj: any = {}; + if (message.requests) { + obj.requests = message.requests.map(e => + e ? RequestQuery.toJSON(e) : undefined, + ); + } else { + obj.requests = []; + } + return obj; + }, + fromPartial(object: Partial): CosmosQuery { + const message = createBaseCosmosQuery(); + message.requests = + object.requests?.map(e => RequestQuery.fromPartial(e)) || []; + return message; + }, + fromProtoMsg(message: CosmosQueryProtoMsg): CosmosQuery { + return CosmosQuery.decode(message.value); + }, + toProto(message: CosmosQuery): Uint8Array { + return CosmosQuery.encode(message).finish(); + }, + toProtoMsg(message: CosmosQuery): CosmosQueryProtoMsg { + return { + typeUrl: '/icq.v1.CosmosQuery', + value: CosmosQuery.encode(message).finish(), + }; + }, +}; +function createBaseCosmosResponse(): CosmosResponse { + return { + responses: [], + }; +} +export const CosmosResponse = { + typeUrl: '/icq.v1.CosmosResponse', + encode( + message: CosmosResponse, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + for (const v of message.responses) { + ResponseQuery.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): CosmosResponse { + const reader = + input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCosmosResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.responses.push(ResponseQuery.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): CosmosResponse { + return { + responses: Array.isArray(object?.responses) + ? object.responses.map((e: any) => ResponseQuery.fromJSON(e)) + : [], + }; + }, + toJSON(message: CosmosResponse): unknown { + const obj: any = {}; + if (message.responses) { + obj.responses = message.responses.map(e => + e ? ResponseQuery.toJSON(e) : undefined, + ); + } else { + obj.responses = []; + } + return obj; + }, + fromPartial(object: Partial): CosmosResponse { + const message = createBaseCosmosResponse(); + message.responses = + object.responses?.map(e => ResponseQuery.fromPartial(e)) || []; + return message; + }, + fromProtoMsg(message: CosmosResponseProtoMsg): CosmosResponse { + return CosmosResponse.decode(message.value); + }, + toProto(message: CosmosResponse): Uint8Array { + return CosmosResponse.encode(message).finish(); + }, + toProtoMsg(message: CosmosResponse): CosmosResponseProtoMsg { + return { + typeUrl: '/icq.v1.CosmosResponse', + value: CosmosResponse.encode(message).finish(), + }; + }, +}; diff --git a/packages/cosmic-proto/src/codegen/icq/v1/query.ts b/packages/cosmic-proto/src/codegen/icq/v1/query.ts new file mode 100644 index 00000000000..be0bfe0a992 --- /dev/null +++ b/packages/cosmic-proto/src/codegen/icq/v1/query.ts @@ -0,0 +1,147 @@ +//@ts-nocheck +import { Params, ParamsSDKType } from './icq.js'; +import { BinaryReader, BinaryWriter } from '../../binary.js'; +import { isSet } from '../../helpers.js'; +/** QueryParamsRequest is the request type for the Query/Params RPC method. */ +export interface QueryParamsRequest {} +export interface QueryParamsRequestProtoMsg { + typeUrl: '/icq.v1.QueryParamsRequest'; + value: Uint8Array; +} +/** QueryParamsRequest is the request type for the Query/Params RPC method. */ +export interface QueryParamsRequestSDKType {} +/** QueryParamsResponse is the response type for the Query/Params RPC method. */ +export interface QueryParamsResponse { + /** params defines the parameters of the module. */ + params?: Params; +} +export interface QueryParamsResponseProtoMsg { + typeUrl: '/icq.v1.QueryParamsResponse'; + value: Uint8Array; +} +/** QueryParamsResponse is the response type for the Query/Params RPC method. */ +export interface QueryParamsResponseSDKType { + params?: ParamsSDKType; +} +function createBaseQueryParamsRequest(): QueryParamsRequest { + return {}; +} +export const QueryParamsRequest = { + typeUrl: '/icq.v1.QueryParamsRequest', + encode( + _: QueryParamsRequest, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + return writer; + }, + decode( + input: BinaryReader | Uint8Array, + length?: number, + ): QueryParamsRequest { + const reader = + input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryParamsRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(_: any): QueryParamsRequest { + return {}; + }, + toJSON(_: QueryParamsRequest): unknown { + const obj: any = {}; + return obj; + }, + fromPartial(_: Partial): QueryParamsRequest { + const message = createBaseQueryParamsRequest(); + return message; + }, + fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest { + return QueryParamsRequest.decode(message.value); + }, + toProto(message: QueryParamsRequest): Uint8Array { + return QueryParamsRequest.encode(message).finish(); + }, + toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg { + return { + typeUrl: '/icq.v1.QueryParamsRequest', + value: QueryParamsRequest.encode(message).finish(), + }; + }, +}; +function createBaseQueryParamsResponse(): QueryParamsResponse { + return { + params: undefined, + }; +} +export const QueryParamsResponse = { + typeUrl: '/icq.v1.QueryParamsResponse', + encode( + message: QueryParamsResponse, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + if (message.params !== undefined) { + Params.encode(message.params, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode( + input: BinaryReader | Uint8Array, + length?: number, + ): QueryParamsResponse { + const reader = + input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryParamsResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.params = Params.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): QueryParamsResponse { + return { + params: isSet(object.params) ? Params.fromJSON(object.params) : undefined, + }; + }, + toJSON(message: QueryParamsResponse): unknown { + const obj: any = {}; + message.params !== undefined && + (obj.params = message.params ? Params.toJSON(message.params) : undefined); + return obj; + }, + fromPartial(object: Partial): QueryParamsResponse { + const message = createBaseQueryParamsResponse(); + message.params = + object.params !== undefined && object.params !== null + ? Params.fromPartial(object.params) + : undefined; + return message; + }, + fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse { + return QueryParamsResponse.decode(message.value); + }, + toProto(message: QueryParamsResponse): Uint8Array { + return QueryParamsResponse.encode(message).finish(); + }, + toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg { + return { + typeUrl: '/icq.v1.QueryParamsResponse', + value: QueryParamsResponse.encode(message).finish(), + }; + }, +}; diff --git a/packages/cosmic-proto/src/codegen/icq/v1/tx.ts b/packages/cosmic-proto/src/codegen/icq/v1/tx.ts new file mode 100644 index 00000000000..531882b1e0c --- /dev/null +++ b/packages/cosmic-proto/src/codegen/icq/v1/tx.ts @@ -0,0 +1,183 @@ +//@ts-nocheck +import { Params, ParamsSDKType } from './icq.js'; +import { BinaryReader, BinaryWriter } from '../../binary.js'; +import { isSet } from '../../helpers.js'; +/** + * MsgUpdateParams is the Msg/UpdateParams request type. + * + * Since: cosmos-sdk 0.47 + */ +export interface MsgUpdateParams { + /** authority is the address of the governance account. */ + authority: string; + /** + * params defines the x/async-icq parameters to update. + * + * NOTE: All parameters must be supplied. + */ + params: Params; +} +export interface MsgUpdateParamsProtoMsg { + typeUrl: '/icq.v1.MsgUpdateParams'; + value: Uint8Array; +} +/** + * MsgUpdateParams is the Msg/UpdateParams request type. + * + * Since: cosmos-sdk 0.47 + */ +export interface MsgUpdateParamsSDKType { + authority: string; + params: ParamsSDKType; +} +/** + * MsgUpdateParamsResponse defines the response structure for executing a + * MsgUpdateParams message. + * + * Since: cosmos-sdk 0.47 + */ +export interface MsgUpdateParamsResponse {} +export interface MsgUpdateParamsResponseProtoMsg { + typeUrl: '/icq.v1.MsgUpdateParamsResponse'; + value: Uint8Array; +} +/** + * MsgUpdateParamsResponse defines the response structure for executing a + * MsgUpdateParams message. + * + * Since: cosmos-sdk 0.47 + */ +export interface MsgUpdateParamsResponseSDKType {} +function createBaseMsgUpdateParams(): MsgUpdateParams { + return { + authority: '', + params: Params.fromPartial({}), + }; +} +export const MsgUpdateParams = { + typeUrl: '/icq.v1.MsgUpdateParams', + encode( + message: MsgUpdateParams, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + 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: BinaryReader | Uint8Array, length?: number): MsgUpdateParams { + 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; + }, + fromJSON(object: any): MsgUpdateParams { + return { + authority: isSet(object.authority) ? String(object.authority) : '', + params: isSet(object.params) ? Params.fromJSON(object.params) : undefined, + }; + }, + toJSON(message: MsgUpdateParams): unknown { + const obj: any = {}; + message.authority !== undefined && (obj.authority = message.authority); + message.params !== undefined && + (obj.params = message.params ? Params.toJSON(message.params) : undefined); + return obj; + }, + fromPartial(object: Partial): MsgUpdateParams { + const message = createBaseMsgUpdateParams(); + message.authority = object.authority ?? ''; + message.params = + object.params !== undefined && object.params !== null + ? Params.fromPartial(object.params) + : undefined; + return message; + }, + fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams { + return MsgUpdateParams.decode(message.value); + }, + toProto(message: MsgUpdateParams): Uint8Array { + return MsgUpdateParams.encode(message).finish(); + }, + toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg { + return { + typeUrl: '/icq.v1.MsgUpdateParams', + value: MsgUpdateParams.encode(message).finish(), + }; + }, +}; +function createBaseMsgUpdateParamsResponse(): MsgUpdateParamsResponse { + return {}; +} +export const MsgUpdateParamsResponse = { + typeUrl: '/icq.v1.MsgUpdateParamsResponse', + encode( + _: MsgUpdateParamsResponse, + writer: BinaryWriter = BinaryWriter.create(), + ): BinaryWriter { + return writer; + }, + decode( + input: BinaryReader | Uint8Array, + length?: number, + ): MsgUpdateParamsResponse { + 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; + }, + fromJSON(_: any): MsgUpdateParamsResponse { + return {}; + }, + toJSON(_: MsgUpdateParamsResponse): unknown { + const obj: any = {}; + return obj; + }, + fromPartial(_: Partial): MsgUpdateParamsResponse { + const message = createBaseMsgUpdateParamsResponse(); + return message; + }, + fromProtoMsg( + message: MsgUpdateParamsResponseProtoMsg, + ): MsgUpdateParamsResponse { + return MsgUpdateParamsResponse.decode(message.value); + }, + toProto(message: MsgUpdateParamsResponse): Uint8Array { + return MsgUpdateParamsResponse.encode(message).finish(); + }, + toProtoMsg( + message: MsgUpdateParamsResponse, + ): MsgUpdateParamsResponseProtoMsg { + return { + typeUrl: '/icq.v1.MsgUpdateParamsResponse', + value: MsgUpdateParamsResponse.encode(message).finish(), + }; + }, +}; diff --git a/packages/cosmic-proto/src/codegen/ics23/bundle.ts b/packages/cosmic-proto/src/codegen/ics23/bundle.ts index a9aec6d102c..48c7c303a2f 100644 --- a/packages/cosmic-proto/src/codegen/ics23/bundle.ts +++ b/packages/cosmic-proto/src/codegen/ics23/bundle.ts @@ -1,5 +1,5 @@ //@ts-nocheck -import * as _118 from '../proofs.js'; +import * as _123 from '../proofs.js'; export const ics23 = { - ..._118, + ..._123, }; diff --git a/packages/cosmic-proto/src/codegen/index.ts b/packages/cosmic-proto/src/codegen/index.ts index 0efa1d1d8d9..70310462595 100644 --- a/packages/cosmic-proto/src/codegen/index.ts +++ b/packages/cosmic-proto/src/codegen/index.ts @@ -12,6 +12,7 @@ export * from './cosmos/bundle.js'; export * from './gogoproto/bundle.js'; export * from './google/bundle.js'; export * from './ibc/bundle.js'; +export * from './icq/bundle.js'; export * from './ics23/bundle.js'; export * from './tendermint/bundle.js'; export * from './varint.js'; diff --git a/packages/cosmic-proto/src/codegen/tendermint/bundle.ts b/packages/cosmic-proto/src/codegen/tendermint/bundle.ts index e5033961e08..9f3f4108611 100644 --- a/packages/cosmic-proto/src/codegen/tendermint/bundle.ts +++ b/packages/cosmic-proto/src/codegen/tendermint/bundle.ts @@ -1,39 +1,39 @@ //@ts-nocheck -import * as _119 from './abci/types.js'; -import * as _120 from './crypto/keys.js'; -import * as _121 from './crypto/proof.js'; -import * as _122 from './libs/bits/types.js'; -import * as _123 from './p2p/types.js'; -import * as _124 from './types/block.js'; -import * as _125 from './types/evidence.js'; -import * as _126 from './types/params.js'; -import * as _127 from './types/types.js'; -import * as _128 from './types/validator.js'; -import * as _129 from './version/types.js'; +import * as _124 from './abci/types.js'; +import * as _125 from './crypto/keys.js'; +import * as _126 from './crypto/proof.js'; +import * as _127 from './libs/bits/types.js'; +import * as _128 from './p2p/types.js'; +import * as _129 from './types/block.js'; +import * as _130 from './types/evidence.js'; +import * as _131 from './types/params.js'; +import * as _132 from './types/types.js'; +import * as _133 from './types/validator.js'; +import * as _134 from './version/types.js'; export namespace tendermint { export const abci = { - ..._119, + ..._124, }; export const crypto = { - ..._120, - ..._121, + ..._125, + ..._126, }; export namespace libs { export const bits = { - ..._122, + ..._127, }; } export const p2p = { - ..._123, + ..._128, }; export const types = { - ..._124, - ..._125, - ..._126, - ..._127, - ..._128, + ..._129, + ..._130, + ..._131, + ..._132, + ..._133, }; export const version = { - ..._129, + ..._134, }; } diff --git a/packages/cosmic-proto/test/snapshots/test-exports.js.md b/packages/cosmic-proto/test/snapshots/test-exports.js.md index 33dcdb4d395..1c607d72e86 100644 --- a/packages/cosmic-proto/test/snapshots/test-exports.js.md +++ b/packages/cosmic-proto/test/snapshots/test-exports.js.md @@ -19,6 +19,7 @@ Generated by [AVA](https://avajs.dev). 'gogoproto', 'google', 'ibc', + 'icq', 'ics23', 'int64FromString', 'int64Length', diff --git a/packages/cosmic-proto/test/snapshots/test-exports.js.snap b/packages/cosmic-proto/test/snapshots/test-exports.js.snap index 36cef32851d4b0607a502cf578bc231d0cf3d911..9f20ab80b822920f65484fca2f2248176b041322 100644 GIT binary patch literal 1201 zcmV;i1Wx-wRzVFwf@g9_pwsgg_I z0C)u834lKVR0wd90E+~8hX4Tq?i|IwBEa_q_=Nz^2tW$Jg#z$e0k~BFbOE?q0KP5& zj|;#b1%NofoC92SfZGnR?*R84;9CcH;sAd+z(f(aTm)uFd5V;lq@*1}%)ffQ4l)Mv zGDry(K*ykUzP8wA}w z6CAgda#vlMH{qHI*SXM(3#&40Ue}Tf-w-AYVZ2Ltn+ad<81S?KC%WK`Fuk^J4A5N}y@!~>i@e8)7 zZg{yffaYx8F0{%Im^YC2MVq&a-t1Rq;0wdx#RUUjv??7Qt}r+B?5-~*kZU4F`VP}n z`&{^n=~tS{S9zx)zb2e!d;`Eu00#gb0{9ug-vA~EFi(IR1o(&m56LlZFqU8uKX<;1WYfvI+4aY%GnGdo2i=IuSdKdG2x}tS+|)R#xgnk zofo$Ado3nALt1|+(fZ0809FBT0AB$34!~0Y|KgZdm$R*&emCClnlG7Bn{2Pel+N{f zCdC=iKMwXEkc44*>jlVhM`@XCkLr)qEW}ol5Nn6}vfMitWS;Z*>@N2cb&?cZc%4 zcT~--F(>a09Yb!<fZvXc`5yq&1h`Cq*ZYPXkAI&M;7bBL zI?kBuIeBPn@C;jdN^$fsr%iFVGz~iBij-a1iFAG>t9e{$$s4VtvsovtZZqafIv6;t zg*txN&e>(jmtiZ)`C~CTveBJrpppXNe%>l3Efa^J6KL>oC z1McR42RYzT4saacf&*N1fVUmsrUQKG0QVf=HwXCJ0Z!(DIZ~VHX-I;wOR$4 z0C^guf;p1IJaIq@Go-S@Ln_-_jCxECKtfXJj^uiX<_uci;gW5)BW4iCAVum6$z2oA zn|OgXcqmM`VCk+<4WUfDXt(dj--)Eqc2&usCw$?H1XQ*OeIfk7)^)ebc+!NcJk-leYf?0>YRN<25GsZ+*(1EhLSNSnIAy@89=I)%YfswRC8OSYs23Lu zR5j2<7kVRsOq?CGUQLj4eEEwK3>^eDRso;^n3I;lO2HG@ZjbM|DH_J2VKGzU1my8fzY>Q-pM;a(ur&@oL0EFPY97%lT0(lXKAd(02Yt zlgajo);|+#ed!{Awaz=j0elMJ2LKNN{EH)6T}-!n_Vw<5mwm~U+G01FOzBLo=MtPT zUG9@MC=Y7lAeG5BdOk@S)8u|ln^e+9x~4*MJHtt8*-~0a>a*i%`7VIZ0Nexc2Y~;M zt!2NaS823LH617Be3CRq%>k><15dJWoSdgptTB2{_h=)EvTDx67zr(R`;T=-!#5v} zlJGi!CV)=>+y?ODu_eq0oP`<9%I0=tbSkuJG~CMwlW)ZybF0H-D-bRX+&bl1?SV>!jsf#(YVK1BbOx z#}}=PT^4*Pno-6d^YM|zPF}^RcegX6S4nBQH)`a{>4VIqRcc1Qq{Elj&RC@uQ<{hV zpxG|3jX2{U#~Phq0`L-m9RQ7^&b5;nrD+re+@)O^Ri=S?SIDdfR08hTwcEWBTKx}F KJr|{P3;+OlJUKQ1