@ark-us/wasmxjs 0.0.2 → 0.0.3

package/types/codegen/wasmx/client.d.ts

@@ -2,20 +2,20 @@ import { GeneratedType, Registry, OfflineSigner } from "@cosmjs/proto-signing";
 import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
 import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
 export declare const wasmxAminoConverters: {
-    "/wasmx.websrv.MsgRegisterOAuthClient": {
+    "/wasmx.websrv.v1.MsgRegisterOAuthClient": {
         aminoType: string;
-        toAmino: ({ owner, domain }: import("./websrv/tx").MsgRegisterOAuthClient) => {
+        toAmino: ({ owner, domain }: import("./websrv/v1/tx").MsgRegisterOAuthClient) => {
             owner: string;
             domain: string;
         };
         fromAmino: ({ owner, domain }: {
             owner: string;
             domain: string;
-        }) => import("./websrv/tx").MsgRegisterOAuthClient;
+        }) => import("./websrv/v1/tx").MsgRegisterOAuthClient;
     };
-    "/wasmx.websrv.MsgEditOAuthClient": {
+    "/wasmx.websrv.v1.MsgEditOAuthClient": {
         aminoType: string;
-        toAmino: ({ owner, clientId, domain }: import("./websrv/tx").MsgEditOAuthClient) => {
+        toAmino: ({ owner, clientId, domain }: import("./websrv/v1/tx").MsgEditOAuthClient) => {
             owner: string;
             client_id: string;
             domain: string;
@@ -24,44 +24,44 @@ export declare const wasmxAminoConverters: {
             owner: string;
             client_id: string;
             domain: string;
-        }) => import("./websrv/tx").MsgEditOAuthClient;
+        }) => import("./websrv/v1/tx").MsgEditOAuthClient;
     };
-    "/wasmx.websrv.MsgDeregisterOAuthClient": {
+    "/wasmx.websrv.v1.MsgDeregisterOAuthClient": {
         aminoType: string;
-        toAmino: ({ owner, clientId }: import("./websrv/tx").MsgDeregisterOAuthClient) => {
+        toAmino: ({ owner, clientId }: import("./websrv/v1/tx").MsgDeregisterOAuthClient) => {
             owner: string;
             client_id: string;
         };
         fromAmino: ({ owner, client_id }: {
             owner: string;
             client_id: string;
-        }) => import("./websrv/tx").MsgDeregisterOAuthClient;
+        }) => import("./websrv/v1/tx").MsgDeregisterOAuthClient;
     };
-    "/wasmx.wasmx.MsgStoreCode": {
+    "/wasmx.wasmx.v1.MsgStoreCode": {
         aminoType: string;
-        toAmino: ({ sender, wasmByteCode }: import("./wasmx/tx").MsgStoreCode) => {
+        toAmino: ({ sender, wasmByteCode }: import("./wasmx/v1/tx").MsgStoreCode) => {
             sender: string;
             wasm_byte_code: Uint8Array;
         };
         fromAmino: ({ sender, wasm_byte_code }: {
             sender: string;
             wasm_byte_code: Uint8Array;
-        }) => import("./wasmx/tx").MsgStoreCode;
+        }) => import("./wasmx/v1/tx").MsgStoreCode;
     };
-    "/wasmx.wasmx.MsgStoreCodeEvm": {
+    "/wasmx.wasmx.v1.MsgStoreCodeEvm": {
         aminoType: string;
-        toAmino: ({ sender, evmByteCode }: import("./wasmx/tx").MsgStoreCodeEvm) => {
+        toAmino: ({ sender, evmByteCode }: import("./wasmx/v1/tx").MsgStoreCodeEvm) => {
             sender: string;
             evm_byte_code: Uint8Array;
         };
         fromAmino: ({ sender, evm_byte_code }: {
             sender: string;
             evm_byte_code: Uint8Array;
-        }) => import("./wasmx/tx").MsgStoreCodeEvm;
+        }) => import("./wasmx/v1/tx").MsgStoreCodeEvm;
     };
-    "/wasmx.wasmx.MsgInstantiateContract": {
+    "/wasmx.wasmx.v1.MsgInstantiateContract": {
         aminoType: string;
-        toAmino: ({ sender, codeId, label, msg, funds }: import("./wasmx/tx").MsgInstantiateContract) => {
+        toAmino: ({ sender, codeId, label, msg, funds }: import("./wasmx/v1/tx").MsgInstantiateContract) => {
             sender: string;
             code_id: string;
             label: string;
@@ -80,11 +80,11 @@ export declare const wasmxAminoConverters: {
                 denom: string;
                 amount: string;
             }[];
-        }) => import("./wasmx/tx").MsgInstantiateContract;
+        }) => import("./wasmx/v1/tx").MsgInstantiateContract;
     };
-    "/wasmx.wasmx.MsgInstantiateContract2": {
+    "/wasmx.wasmx.v1.MsgInstantiateContract2": {
         aminoType: string;
-        toAmino: ({ sender, codeId, label, msg, funds, salt, fixMsg }: import("./wasmx/tx").MsgInstantiateContract2) => {
+        toAmino: ({ sender, codeId, label, msg, funds, salt, fixMsg }: import("./wasmx/v1/tx").MsgInstantiateContract2) => {
             sender: string;
             code_id: string;
             label: string;
@@ -107,11 +107,11 @@ export declare const wasmxAminoConverters: {
             }[];
             salt: Uint8Array;
             fix_msg: boolean;
-        }) => import("./wasmx/tx").MsgInstantiateContract2;
+        }) => import("./wasmx/v1/tx").MsgInstantiateContract2;
     };
-    "/wasmx.wasmx.MsgExecuteContract": {
+    "/wasmx.wasmx.v1.MsgExecuteContract": {
         aminoType: string;
-        toAmino: ({ sender, contract, msg, funds, dependencies }: import("./wasmx/tx").MsgExecuteContract) => {
+        toAmino: ({ sender, contract, msg, funds, dependencies }: import("./wasmx/v1/tx").MsgExecuteContract) => {
             sender: string;
             contract: string;
             msg: Uint8Array;
@@ -130,11 +130,11 @@ export declare const wasmxAminoConverters: {
                 amount: string;
             }[];
             dependencies: string[];
-        }) => import("./wasmx/tx").MsgExecuteContract;
+        }) => import("./wasmx/v1/tx").MsgExecuteContract;
     };
-    "/wasmx.wasmx.MsgExecuteWithOriginContract": {
+    "/wasmx.wasmx.v1.MsgExecuteWithOriginContract": {
         aminoType: string;
-        toAmino: ({ origin, sender, contract, msg, funds }: import("./wasmx/tx").MsgExecuteWithOriginContract) => {
+        toAmino: ({ origin, sender, contract, msg, funds }: import("./wasmx/v1/tx").MsgExecuteWithOriginContract) => {
             origin: string;
             sender: string;
             contract: string;
@@ -153,11 +153,11 @@ export declare const wasmxAminoConverters: {
                 denom: string;
                 amount: string;
             }[];
-        }) => import("./wasmx/tx").MsgExecuteWithOriginContract;
+        }) => import("./wasmx/v1/tx").MsgExecuteWithOriginContract;
     };
-    "/wasmx.wasmx.MsgExecuteDelegateContract": {
+    "/wasmx.wasmx.v1.MsgExecuteDelegateContract": {
         aminoType: string;
-        toAmino: ({ origin, sender, caller, codeContract, storageContract, msg, funds }: import("./wasmx/tx").MsgExecuteDelegateContract) => {
+        toAmino: ({ origin, sender, caller, codeContract, storageContract, msg, funds }: import("./wasmx/v1/tx").MsgExecuteDelegateContract) => {
             origin: string;
             sender: string;
             caller: string;
@@ -180,18 +180,18 @@ export declare const wasmxAminoConverters: {
                 denom: string;
                 amount: string;
             }[];
-        }) => import("./wasmx/tx").MsgExecuteDelegateContract;
+        }) => import("./wasmx/v1/tx").MsgExecuteDelegateContract;
     };
-    "/wasmx.wasmx.MsgCompileContract": {
+    "/wasmx.wasmx.v1.MsgCompileContract": {
         aminoType: string;
-        toAmino: ({ sender, codeId }: import("./wasmx/tx").MsgCompileContract) => {
+        toAmino: ({ sender, codeId }: import("./wasmx/v1/tx").MsgCompileContract) => {
             sender: string;
             codeId: string;
         };
         fromAmino: ({ sender, codeId }: {
             sender: string;
             codeId: string;
-        }) => import("./wasmx/tx").MsgCompileContract;
+        }) => import("./wasmx/v1/tx").MsgCompileContract;
     };
 };
 export declare const wasmxProtoRegistry: ReadonlyArray<[string, GeneratedType]>;

package/types/codegen/wasmx/rpc.query.d.ts

@@ -18,24 +18,28 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
     };
     wasmx: {
         wasmx: {
-            contractInfo(request: import("./wasmx/query").QueryContractInfoRequest): Promise<import("./wasmx/query").QueryContractInfoResponse>;
-            contractsByCode(request: import("./wasmx/query").QueryContractsByCodeRequest): Promise<import("./wasmx/query").QueryContractsByCodeResponse>;
-            allContractState(request: import("./wasmx/query").QueryAllContractStateRequest): Promise<import("./wasmx/query").QueryAllContractStateResponse>;
-            rawContractState(request: import("./wasmx/query").QueryRawContractStateRequest): Promise<import("./wasmx/query").QueryRawContractStateResponse>;
-            smartContractCall(request: import("./wasmx/query").QuerySmartContractCallRequest): Promise<import("./wasmx/query").QuerySmartContractCallResponse>;
-            code(request: import("./wasmx/query").QueryCodeRequest): Promise<import("./wasmx/query").QueryCodeResponse>;
-            codes(request?: import("./wasmx/query").QueryCodesRequest): Promise<import("./wasmx/query").QueryCodesResponse>;
-            params(request?: import("./wasmx/query").QueryParamsRequest): Promise<import("./wasmx/query").QueryParamsResponse>;
-            contractsByCreator(request: import("./wasmx/query").QueryContractsByCreatorRequest): Promise<import("./wasmx/query").QueryContractsByCreatorResponse>;
+            v1: {
+                contractInfo(request: import("./wasmx/v1/query").QueryContractInfoRequest): Promise<import("./wasmx/v1/query").QueryContractInfoResponse>;
+                contractsByCode(request: import("./wasmx/v1/query").QueryContractsByCodeRequest): Promise<import("./wasmx/v1/query").QueryContractsByCodeResponse>;
+                allContractState(request: import("./wasmx/v1/query").QueryAllContractStateRequest): Promise<import("./wasmx/v1/query").QueryAllContractStateResponse>;
+                rawContractState(request: import("./wasmx/v1/query").QueryRawContractStateRequest): Promise<import("./wasmx/v1/query").QueryRawContractStateResponse>;
+                smartContractCall(request: import("./wasmx/v1/query").QuerySmartContractCallRequest): Promise<import("./wasmx/v1/query").QuerySmartContractCallResponse>;
+                code(request: import("./wasmx/v1/query").QueryCodeRequest): Promise<import("./wasmx/v1/query").QueryCodeResponse>;
+                codes(request?: import("./wasmx/v1/query").QueryCodesRequest): Promise<import("./wasmx/v1/query").QueryCodesResponse>;
+                params(request?: import("./wasmx/v1/query").QueryParamsRequest): Promise<import("./wasmx/v1/query").QueryParamsResponse>;
+                contractsByCreator(request: import("./wasmx/v1/query").QueryContractsByCreatorRequest): Promise<import("./wasmx/v1/query").QueryContractsByCreatorResponse>;
+            };
         };
         websrv: {
-            httpGet(request: import("./websrv/query").QueryHttpRequestGet): Promise<import("./websrv/query").QueryHttpResponseGet>;
-            contractByRoute(request: import("./websrv/query").QueryContractByRouteRequest): Promise<import("./websrv/query").QueryContractByRouteResponse>;
-            routeByContract(request: import("./websrv/query").QueryRouteByContractRequest): Promise<import("./websrv/query").QueryRouteByContractResponse>;
-            params(request?: import("./websrv/query").QueryParamsRequest): Promise<import("./websrv/query").QueryParamsResponse>;
-            getAllOauthClients(request?: import("./websrv/query").QueryGetAllOauthClientsRequest): Promise<import("./websrv/query").QueryGetAllOauthClientsResponse>;
-            getOauthClient(request: import("./websrv/query").QueryGetOauthClientRequest): Promise<import("./websrv/query").QueryGetOauthClientResponse>;
-            getOauthClientsByOwner(request: import("./websrv/query").QueryGetOauthClientsByOwnerRequest): Promise<import("./websrv/query").QueryGetOauthClientsByOwnerResponse>;
+            v1: {
+                httpGet(request: import("./websrv/v1/query").QueryHttpRequestGet): Promise<import("./websrv/v1/query").QueryHttpResponseGet>;
+                contractByRoute(request: import("./websrv/v1/query").QueryContractByRouteRequest): Promise<import("./websrv/v1/query").QueryContractByRouteResponse>;
+                routeByContract(request: import("./websrv/v1/query").QueryRouteByContractRequest): Promise<import("./websrv/v1/query").QueryRouteByContractResponse>;
+                params(request?: import("./websrv/v1/query").QueryParamsRequest): Promise<import("./websrv/v1/query").QueryParamsResponse>;
+                getAllOauthClients(request?: import("./websrv/v1/query").QueryGetAllOauthClientsRequest): Promise<import("./websrv/v1/query").QueryGetAllOauthClientsResponse>;
+                getOauthClient(request: import("./websrv/v1/query").QueryGetOauthClientRequest): Promise<import("./websrv/v1/query").QueryGetOauthClientResponse>;
+                getOauthClientsByOwner(request: import("./websrv/v1/query").QueryGetOauthClientsByOwnerRequest): Promise<import("./websrv/v1/query").QueryGetOauthClientsByOwnerResponse>;
+            };
         };
     };
 }>;

package/types/codegen/wasmx/rpc.tx.d.ts

@@ -3,7 +3,11 @@ export declare const createRPCMsgClient: ({ rpc }: {
     rpc: Rpc;
 }) => Promise<{
     wasmx: {
-        wasmx: import("./wasmx/tx.rpc.msg").MsgClientImpl;
-        websrv: import("./websrv/tx.rpc.msg").MsgClientImpl;
+        wasmx: {
+            v1: import("./wasmx/v1/tx.rpc.msg").MsgClientImpl;
+        };
+        websrv: {
+            v1: import("./websrv/v1/tx.rpc.msg").MsgClientImpl;
+        };
     };
 }>;

package/types/codegen/wasmx/wasmx/tx.amino.d.ts

@@ -1,21 +1,21 @@
 import { AminoMsg } from "@cosmjs/amino";
 import { MsgStoreCode, MsgStoreCodeEvm, MsgInstantiateContract, MsgInstantiateContract2, MsgExecuteContract, MsgExecuteWithOriginContract, MsgExecuteDelegateContract, MsgCompileContract } from "./tx";
 export interface AminoMsgStoreCode extends AminoMsg {
-    type: "/wasmx.wasmx.MsgStoreCode";
+    type: "/wasmx.wasmx.v1.MsgStoreCode";
     value: {
         sender: string;
         wasm_byte_code: Uint8Array;
     };
 }
 export interface AminoMsgStoreCodeEvm extends AminoMsg {
-    type: "/wasmx.wasmx.MsgStoreCodeEvm";
+    type: "/wasmx.wasmx.v1.MsgStoreCodeEvm";
     value: {
         sender: string;
         evm_byte_code: Uint8Array;
     };
 }
 export interface AminoMsgInstantiateContract extends AminoMsg {
-    type: "/wasmx.wasmx.MsgInstantiateContract";
+    type: "/wasmx.wasmx.v1.MsgInstantiateContract";
     value: {
         sender: string;
         code_id: string;
@@ -28,7 +28,7 @@ export interface AminoMsgInstantiateContract extends AminoMsg {
     };
 }
 export interface AminoMsgInstantiateContract2 extends AminoMsg {
-    type: "/wasmx.wasmx.MsgInstantiateContract2";
+    type: "/wasmx.wasmx.v1.MsgInstantiateContract2";
     value: {
         sender: string;
         code_id: string;
@@ -43,7 +43,7 @@ export interface AminoMsgInstantiateContract2 extends AminoMsg {
     };
 }
 export interface AminoMsgExecuteContract extends AminoMsg {
-    type: "/wasmx.wasmx.MsgExecuteContract";
+    type: "/wasmx.wasmx.v1.MsgExecuteContract";
     value: {
         sender: string;
         contract: string;
@@ -56,7 +56,7 @@ export interface AminoMsgExecuteContract extends AminoMsg {
     };
 }
 export interface AminoMsgExecuteWithOriginContract extends AminoMsg {
-    type: "/wasmx.wasmx.MsgExecuteWithOriginContract";
+    type: "/wasmx.wasmx.v1.MsgExecuteWithOriginContract";
     value: {
         origin: string;
         sender: string;
@@ -69,7 +69,7 @@ export interface AminoMsgExecuteWithOriginContract extends AminoMsg {
     };
 }
 export interface AminoMsgExecuteDelegateContract extends AminoMsg {
-    type: "/wasmx.wasmx.MsgExecuteDelegateContract";
+    type: "/wasmx.wasmx.v1.MsgExecuteDelegateContract";
     value: {
         origin: string;
         sender: string;
@@ -84,49 +84,49 @@ export interface AminoMsgExecuteDelegateContract extends AminoMsg {
     };
 }
 export interface AminoMsgCompileContract extends AminoMsg {
-    type: "/wasmx.wasmx.MsgCompileContract";
+    type: "/wasmx.wasmx.v1.MsgCompileContract";
     value: {
         sender: string;
         codeId: string;
     };
 }
 export declare const AminoConverter: {
-    "/wasmx.wasmx.MsgStoreCode": {
+    "/wasmx.wasmx.v1.MsgStoreCode": {
         aminoType: string;
         toAmino: ({ sender, wasmByteCode }: MsgStoreCode) => AminoMsgStoreCode["value"];
         fromAmino: ({ sender, wasm_byte_code }: AminoMsgStoreCode["value"]) => MsgStoreCode;
     };
-    "/wasmx.wasmx.MsgStoreCodeEvm": {
+    "/wasmx.wasmx.v1.MsgStoreCodeEvm": {
         aminoType: string;
         toAmino: ({ sender, evmByteCode }: MsgStoreCodeEvm) => AminoMsgStoreCodeEvm["value"];
         fromAmino: ({ sender, evm_byte_code }: AminoMsgStoreCodeEvm["value"]) => MsgStoreCodeEvm;
     };
-    "/wasmx.wasmx.MsgInstantiateContract": {
+    "/wasmx.wasmx.v1.MsgInstantiateContract": {
         aminoType: string;
         toAmino: ({ sender, codeId, label, msg, funds }: MsgInstantiateContract) => AminoMsgInstantiateContract["value"];
         fromAmino: ({ sender, code_id, label, msg, funds }: AminoMsgInstantiateContract["value"]) => MsgInstantiateContract;
     };
-    "/wasmx.wasmx.MsgInstantiateContract2": {
+    "/wasmx.wasmx.v1.MsgInstantiateContract2": {
         aminoType: string;
         toAmino: ({ sender, codeId, label, msg, funds, salt, fixMsg }: MsgInstantiateContract2) => AminoMsgInstantiateContract2["value"];
         fromAmino: ({ sender, code_id, label, msg, funds, salt, fix_msg }: AminoMsgInstantiateContract2["value"]) => MsgInstantiateContract2;
     };
-    "/wasmx.wasmx.MsgExecuteContract": {
+    "/wasmx.wasmx.v1.MsgExecuteContract": {
         aminoType: string;
         toAmino: ({ sender, contract, msg, funds, dependencies }: MsgExecuteContract) => AminoMsgExecuteContract["value"];
         fromAmino: ({ sender, contract, msg, funds, dependencies }: AminoMsgExecuteContract["value"]) => MsgExecuteContract;
     };
-    "/wasmx.wasmx.MsgExecuteWithOriginContract": {
+    "/wasmx.wasmx.v1.MsgExecuteWithOriginContract": {
         aminoType: string;
         toAmino: ({ origin, sender, contract, msg, funds }: MsgExecuteWithOriginContract) => AminoMsgExecuteWithOriginContract["value"];
         fromAmino: ({ origin, sender, contract, msg, funds }: AminoMsgExecuteWithOriginContract["value"]) => MsgExecuteWithOriginContract;
     };
-    "/wasmx.wasmx.MsgExecuteDelegateContract": {
+    "/wasmx.wasmx.v1.MsgExecuteDelegateContract": {
         aminoType: string;
         toAmino: ({ origin, sender, caller, codeContract, storageContract, msg, funds }: MsgExecuteDelegateContract) => AminoMsgExecuteDelegateContract["value"];
         fromAmino: ({ origin, sender, caller, code_contract, storage_contract, msg, funds }: AminoMsgExecuteDelegateContract["value"]) => MsgExecuteDelegateContract;
     };
-    "/wasmx.wasmx.MsgCompileContract": {
+    "/wasmx.wasmx.v1.MsgCompileContract": {
         aminoType: string;
         toAmino: ({ sender, codeId }: MsgCompileContract) => AminoMsgCompileContract["value"];
         fromAmino: ({ sender, codeId }: AminoMsgCompileContract["value"]) => MsgCompileContract;

package/types/codegen/wasmx/wasmx/v1/contract.d.ts

@@ -0,0 +1,139 @@
+import * as _m0 from "protobufjs/minimal";
+import { Long } from "../../../helpers";
+/** ContractStorage */
+export interface ContractStorage {
+    /** hex-encode key */
+    key: Uint8Array;
+    /** raw value */
+    value: Uint8Array;
+}
+/** ContractStorage */
+export interface ContractStorageSDKType {
+    /** hex-encode key */
+    key: Uint8Array;
+    /** raw value */
+    value: Uint8Array;
+}
+/** CodeInfo is data for the uploaded contract WASM code */
+export interface CodeInfo {
+    /** CodeHash is the unique identifier created by hashing the wasm code */
+    codeHash: Uint8Array;
+    /** Creator address who initially stored the code */
+    creator: string;
+    /**
+     * deps can be hex-formatted contract addresses (32 bytes)
+     * or versioned interface labels
+     */
+    deps: string[];
+    /** Pinned contract */
+    pinned: boolean;
+}
+/** CodeInfo is data for the uploaded contract WASM code */
+export interface CodeInfoSDKType {
+    /** CodeHash is the unique identifier created by hashing the wasm code */
+    code_hash: Uint8Array;
+    /** Creator address who initially stored the code */
+    creator: string;
+    /**
+     * deps can be hex-formatted contract addresses (32 bytes)
+     * or versioned interface labels
+     */
+    deps: string[];
+    /** Pinned contract */
+    pinned: boolean;
+}
+/** Metadata for each codeId */
+export interface CodeMetadata {
+    abi: string;
+    jsonSchema: string;
+}
+/** Metadata for each codeId */
+export interface CodeMetadataSDKType {
+    abi: string;
+    json_schema: string;
+}
+/** ContractInfo stores a WASM contract instance */
+export interface ContractInfo {
+    /** CodeID is the reference to the stored Wasm code */
+    codeId: Long;
+    /** Creator address who initially instantiated the contract */
+    creator: string;
+    /** Label is optional metadata to be stored with a contract instance. */
+    label: string;
+    /** Initialization message */
+    initMessage: Uint8Array;
+    ibcPortId: string;
+}
+/** ContractInfo stores a WASM contract instance */
+export interface ContractInfoSDKType {
+    /** CodeID is the reference to the stored Wasm code */
+    code_id: Long;
+    /** Creator address who initially instantiated the contract */
+    creator: string;
+    /** Label is optional metadata to be stored with a contract instance. */
+    label: string;
+    /** Initialization message */
+    init_message: Uint8Array;
+    ibc_port_id: string;
+}
+/**
+ * AbsoluteTxPosition is a unique transaction position that allows for global
+ * ordering of transactions.
+ */
+export interface AbsoluteTxPosition {
+    /** BlockHeight is the block the contract was created at */
+    blockHeight: Long;
+    /**
+     * TxIndex is a monotonic counter within the block (actual transaction index,
+     * or gas consumed)
+     */
+    txIndex: Long;
+}
+/**
+ * AbsoluteTxPosition is a unique transaction position that allows for global
+ * ordering of transactions.
+ */
+export interface AbsoluteTxPositionSDKType {
+    /** BlockHeight is the block the contract was created at */
+    block_height: Long;
+    /**
+     * TxIndex is a monotonic counter within the block (actual transaction index,
+     * or gas consumed)
+     */
+    tx_index: Long;
+}
+export declare const ContractStorage: {
+    encode(message: ContractStorage, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ContractStorage;
+    fromJSON(object: any): ContractStorage;
+    toJSON(message: ContractStorage): unknown;
+    fromPartial(object: Partial<ContractStorage>): ContractStorage;
+};
+export declare const CodeInfo: {
+    encode(message: CodeInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CodeInfo;
+    fromJSON(object: any): CodeInfo;
+    toJSON(message: CodeInfo): unknown;
+    fromPartial(object: Partial<CodeInfo>): CodeInfo;
+};
+export declare const CodeMetadata: {
+    encode(message: CodeMetadata, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CodeMetadata;
+    fromJSON(object: any): CodeMetadata;
+    toJSON(message: CodeMetadata): unknown;
+    fromPartial(object: Partial<CodeMetadata>): CodeMetadata;
+};
+export declare const ContractInfo: {
+    encode(message: ContractInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ContractInfo;
+    fromJSON(object: any): ContractInfo;
+    toJSON(message: ContractInfo): unknown;
+    fromPartial(object: Partial<ContractInfo>): ContractInfo;
+};
+export declare const AbsoluteTxPosition: {
+    encode(message: AbsoluteTxPosition, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): AbsoluteTxPosition;
+    fromJSON(object: any): AbsoluteTxPosition;
+    toJSON(message: AbsoluteTxPosition): unknown;
+    fromPartial(object: Partial<AbsoluteTxPosition>): AbsoluteTxPosition;
+};

package/types/codegen/wasmx/wasmx/v1/genesis.d.ts

@@ -0,0 +1,121 @@
+import { Params, ParamsSDKType } from "./params";
+import { CodeInfo, CodeInfoSDKType, CodeMetadata, CodeMetadataSDKType, ContractInfo, ContractInfoSDKType, ContractStorage, ContractStorageSDKType } from "./contract";
+import * as _m0 from "protobufjs/minimal";
+import { Long } from "../../../helpers";
+/** GenesisState defines the wasmx module's genesis state. */
+export interface GenesisState {
+    params?: Params;
+    /** bootstrap address */
+    bootstrapAccountAddress: string;
+    systemContracts: SystemContract[];
+    codes: Code[];
+    contracts: Contract[];
+    sequences: Sequence[];
+    /**
+     * not recommended
+     * initiate pinned/AOT compiled contracts from a provided folder
+     * instead of compiling the contracts from wasm
+     */
+    compiledFolderPath: string;
+}
+/** GenesisState defines the wasmx module's genesis state. */
+export interface GenesisStateSDKType {
+    params?: ParamsSDKType;
+    /** bootstrap address */
+    bootstrap_account_address: string;
+    system_contracts: SystemContractSDKType[];
+    codes: CodeSDKType[];
+    contracts: ContractSDKType[];
+    sequences: SequenceSDKType[];
+    /**
+     * not recommended
+     * initiate pinned/AOT compiled contracts from a provided folder
+     * instead of compiling the contracts from wasm
+     */
+    compiled_folder_path: string;
+}
+export interface SystemContract {
+    address: string;
+    label: string;
+    initMessage: Uint8Array;
+    pinned: boolean;
+    native: boolean;
+}
+export interface SystemContractSDKType {
+    address: string;
+    label: string;
+    init_message: Uint8Array;
+    pinned: boolean;
+    native: boolean;
+}
+/** Code - for importing and exporting code data */
+export interface Code {
+    codeId: Long;
+    codeInfo?: CodeInfo;
+    codeBytes: Uint8Array;
+    codeMetadata?: CodeMetadata;
+}
+/** Code - for importing and exporting code data */
+export interface CodeSDKType {
+    code_id: Long;
+    code_info?: CodeInfoSDKType;
+    code_bytes: Uint8Array;
+    code_metadata?: CodeMetadataSDKType;
+}
+/** Contract struct encompasses ContractAddress, ContractInfo, and ContractState */
+export interface Contract {
+    contractAddress: string;
+    contractInfo?: ContractInfo;
+    contractState: ContractStorage[];
+}
+/** Contract struct encompasses ContractAddress, ContractInfo, and ContractState */
+export interface ContractSDKType {
+    contract_address: string;
+    contract_info?: ContractInfoSDKType;
+    contract_state: ContractStorageSDKType[];
+}
+/** Sequence key and value of an id generation counter */
+export interface Sequence {
+    idKey: Uint8Array;
+    value: Long;
+}
+/** Sequence key and value of an id generation counter */
+export interface SequenceSDKType {
+    id_key: Uint8Array;
+    value: Long;
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial(object: Partial<GenesisState>): GenesisState;
+};
+export declare const SystemContract: {
+    encode(message: SystemContract, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SystemContract;
+    fromJSON(object: any): SystemContract;
+    toJSON(message: SystemContract): unknown;
+    fromPartial(object: Partial<SystemContract>): SystemContract;
+};
+export declare const Code: {
+    encode(message: Code, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Code;
+    fromJSON(object: any): Code;
+    toJSON(message: Code): unknown;
+    fromPartial(object: Partial<Code>): Code;
+};
+export declare const Contract: {
+    encode(message: Contract, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Contract;
+    fromJSON(object: any): Contract;
+    toJSON(message: Contract): unknown;
+    fromPartial(object: Partial<Contract>): Contract;
+};
+export declare const Sequence: {
+    encode(message: Sequence, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Sequence;
+    fromJSON(object: any): Sequence;
+    toJSON(message: Sequence): unknown;
+    fromPartial(object: Partial<Sequence>): Sequence;
+};

package/types/codegen/wasmx/wasmx/v1/params.d.ts

@@ -0,0 +1,14 @@
+import * as _m0 from "protobufjs/minimal";
+/** Params defines the parameters for the module. */
+export interface Params {
+}
+/** Params defines the parameters for the module. */
+export interface ParamsSDKType {
+}
+export declare const Params: {
+    encode(_: Params, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Params;
+    fromJSON(_: any): Params;
+    toJSON(_: Params): unknown;
+    fromPartial(_: Partial<Params>): Params;
+};