@ark-us/wasmxjs 0.0.1 → 0.0.2

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

@@ -2,20 +2,66 @@ 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": {
+        aminoType: string;
+        toAmino: ({ owner, domain }: import("./websrv/tx").MsgRegisterOAuthClient) => {
+            owner: string;
+            domain: string;
+        };
+        fromAmino: ({ owner, domain }: {
+            owner: string;
+            domain: string;
+        }) => import("./websrv/tx").MsgRegisterOAuthClient;
+    };
+    "/wasmx.websrv.MsgEditOAuthClient": {
+        aminoType: string;
+        toAmino: ({ owner, clientId, domain }: import("./websrv/tx").MsgEditOAuthClient) => {
+            owner: string;
+            client_id: string;
+            domain: string;
+        };
+        fromAmino: ({ owner, client_id, domain }: {
+            owner: string;
+            client_id: string;
+            domain: string;
+        }) => import("./websrv/tx").MsgEditOAuthClient;
+    };
+    "/wasmx.websrv.MsgDeregisterOAuthClient": {
+        aminoType: string;
+        toAmino: ({ owner, clientId }: import("./websrv/tx").MsgDeregisterOAuthClient) => {
+            owner: string;
+            client_id: string;
+        };
+        fromAmino: ({ owner, client_id }: {
+            owner: string;
+            client_id: string;
+        }) => import("./websrv/tx").MsgDeregisterOAuthClient;
+    };
     "/wasmx.wasmx.MsgStoreCode": {
         aminoType: string;
-        toAmino: ({ sender, wasmByteCode }: import(".").MsgStoreCode) => {
+        toAmino: ({ sender, wasmByteCode }: import("./wasmx/tx").MsgStoreCode) => {
             sender: string;
             wasm_byte_code: Uint8Array;
         };
         fromAmino: ({ sender, wasm_byte_code }: {
             sender: string;
             wasm_byte_code: Uint8Array;
-        }) => import(".").MsgStoreCode;
+        }) => import("./wasmx/tx").MsgStoreCode;
+    };
+    "/wasmx.wasmx.MsgStoreCodeEvm": {
+        aminoType: string;
+        toAmino: ({ sender, evmByteCode }: import("./wasmx/tx").MsgStoreCodeEvm) => {
+            sender: string;
+            evm_byte_code: Uint8Array;
+        };
+        fromAmino: ({ sender, evm_byte_code }: {
+            sender: string;
+            evm_byte_code: Uint8Array;
+        }) => import("./wasmx/tx").MsgStoreCodeEvm;
     };
     "/wasmx.wasmx.MsgInstantiateContract": {
         aminoType: string;
-        toAmino: ({ sender, codeId, label, msg, funds }: import(".").MsgInstantiateContract) => {
+        toAmino: ({ sender, codeId, label, msg, funds }: import("./wasmx/tx").MsgInstantiateContract) => {
             sender: string;
             code_id: string;
             label: string;
@@ -34,11 +80,11 @@ export declare const wasmxAminoConverters: {
                 denom: string;
                 amount: string;
             }[];
-        }) => import(".").MsgInstantiateContract;
+        }) => import("./wasmx/tx").MsgInstantiateContract;
     };
     "/wasmx.wasmx.MsgInstantiateContract2": {
         aminoType: string;
-        toAmino: ({ sender, codeId, label, msg, funds, salt, fixMsg }: import(".").MsgInstantiateContract2) => {
+        toAmino: ({ sender, codeId, label, msg, funds, salt, fixMsg }: import("./wasmx/tx").MsgInstantiateContract2) => {
             sender: string;
             code_id: string;
             label: string;
@@ -61,11 +107,11 @@ export declare const wasmxAminoConverters: {
             }[];
             salt: Uint8Array;
             fix_msg: boolean;
-        }) => import(".").MsgInstantiateContract2;
+        }) => import("./wasmx/tx").MsgInstantiateContract2;
     };
     "/wasmx.wasmx.MsgExecuteContract": {
         aminoType: string;
-        toAmino: ({ sender, contract, msg, funds, dependencies }: import(".").MsgExecuteContract) => {
+        toAmino: ({ sender, contract, msg, funds, dependencies }: import("./wasmx/tx").MsgExecuteContract) => {
             sender: string;
             contract: string;
             msg: Uint8Array;
@@ -84,11 +130,11 @@ export declare const wasmxAminoConverters: {
                 amount: string;
             }[];
             dependencies: string[];
-        }) => import(".").MsgExecuteContract;
+        }) => import("./wasmx/tx").MsgExecuteContract;
     };
     "/wasmx.wasmx.MsgExecuteWithOriginContract": {
         aminoType: string;
-        toAmino: ({ origin, sender, contract, msg, funds }: import(".").MsgExecuteWithOriginContract) => {
+        toAmino: ({ origin, sender, contract, msg, funds }: import("./wasmx/tx").MsgExecuteWithOriginContract) => {
             origin: string;
             sender: string;
             contract: string;
@@ -107,11 +153,11 @@ export declare const wasmxAminoConverters: {
                 denom: string;
                 amount: string;
             }[];
-        }) => import(".").MsgExecuteWithOriginContract;
+        }) => import("./wasmx/tx").MsgExecuteWithOriginContract;
     };
     "/wasmx.wasmx.MsgExecuteDelegateContract": {
         aminoType: string;
-        toAmino: ({ origin, sender, caller, codeContract, storageContract, msg, funds }: import(".").MsgExecuteDelegateContract) => {
+        toAmino: ({ origin, sender, caller, codeContract, storageContract, msg, funds }: import("./wasmx/tx").MsgExecuteDelegateContract) => {
             origin: string;
             sender: string;
             caller: string;
@@ -134,7 +180,18 @@ export declare const wasmxAminoConverters: {
                 denom: string;
                 amount: string;
             }[];
-        }) => import(".").MsgExecuteDelegateContract;
+        }) => import("./wasmx/tx").MsgExecuteDelegateContract;
+    };
+    "/wasmx.wasmx.MsgCompileContract": {
+        aminoType: string;
+        toAmino: ({ sender, codeId }: import("./wasmx/tx").MsgCompileContract) => {
+            sender: string;
+            codeId: string;
+        };
+        fromAmino: ({ sender, codeId }: {
+            sender: string;
+            codeId: string;
+        }) => import("./wasmx/tx").MsgCompileContract;
     };
 };
 export declare const wasmxProtoRegistry: ReadonlyArray<[string, GeneratedType]>;

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

@@ -18,15 +18,24 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
     };
     wasmx: {
         wasmx: {
-            contractInfo(request: import(".").QueryContractInfoRequest): Promise<import(".").QueryContractInfoResponse>;
-            contractsByCode(request: import(".").QueryContractsByCodeRequest): Promise<import(".").QueryContractsByCodeResponse>;
-            allContractState(request: import(".").QueryAllContractStateRequest): Promise<import(".").QueryAllContractStateResponse>;
-            rawContractState(request: import(".").QueryRawContractStateRequest): Promise<import(".").QueryRawContractStateResponse>;
-            smartContractCall(request: import(".").QuerySmartContractCallRequest): Promise<import(".").QuerySmartContractCallResponse>;
-            code(request: import(".").QueryCodeRequest): Promise<import(".").QueryCodeResponse>;
-            codes(request?: import(".").QueryCodesRequest): Promise<import(".").QueryCodesResponse>;
-            params(request?: import(".").QueryParamsRequest): Promise<import(".").QueryParamsResponse>;
-            contractsByCreator(request: import(".").QueryContractsByCreatorRequest): Promise<import(".").QueryContractsByCreatorResponse>;
+            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>;
+        };
+        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>;
         };
     };
 }>;

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

@@ -4,5 +4,6 @@ export declare const createRPCMsgClient: ({ rpc }: {
 }) => Promise<{
     wasmx: {
         wasmx: import("./wasmx/tx.rpc.msg").MsgClientImpl;
+        websrv: import("./websrv/tx.rpc.msg").MsgClientImpl;
     };
 }>;

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

@@ -25,8 +25,8 @@ export interface CodeInfo {
      * or versioned interface labels
      */
     deps: string[];
-    abi: string;
-    jsonSchema: string;
+    /** Pinned contract */
+    pinned: boolean;
 }
 /** CodeInfo is data for the uploaded contract WASM code */
 export interface CodeInfoSDKType {
@@ -39,6 +39,16 @@ export interface CodeInfoSDKType {
      * 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;
 }
@@ -106,6 +116,13 @@ export declare const 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;

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

@@ -1,5 +1,5 @@
 import { Params, ParamsSDKType } from "./params";
-import { CodeInfo, CodeInfoSDKType, ContractInfo, ContractInfoSDKType, ContractStorage, ContractStorageSDKType } from "./contract";
+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. */
@@ -11,6 +11,12 @@ export interface GenesisState {
     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 {
@@ -21,32 +27,40 @@ export interface GenesisStateSDKType {
     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;
-    /** Pinned to wasmvm cache */
-    pinned: boolean;
+    codeMetadata?: CodeMetadata;
 }
 /** Code - for importing and exporting code data */
 export interface CodeSDKType {
     code_id: Long;
     code_info?: CodeInfoSDKType;
     code_bytes: Uint8Array;
-    /** Pinned to wasmvm cache */
-    pinned: boolean;
+    code_metadata?: CodeMetadataSDKType;
 }
 /** Contract struct encompasses ContractAddress, ContractInfo, and ContractState */
 export interface Contract {

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

@@ -1,5 +1,5 @@
 import { AminoMsg } from "@cosmjs/amino";
-import { MsgStoreCode, MsgInstantiateContract, MsgInstantiateContract2, MsgExecuteContract, MsgExecuteWithOriginContract, MsgExecuteDelegateContract } from "./tx";
+import { MsgStoreCode, MsgStoreCodeEvm, MsgInstantiateContract, MsgInstantiateContract2, MsgExecuteContract, MsgExecuteWithOriginContract, MsgExecuteDelegateContract, MsgCompileContract } from "./tx";
 export interface AminoMsgStoreCode extends AminoMsg {
     type: "/wasmx.wasmx.MsgStoreCode";
     value: {
@@ -7,6 +7,13 @@ export interface AminoMsgStoreCode extends AminoMsg {
         wasm_byte_code: Uint8Array;
     };
 }
+export interface AminoMsgStoreCodeEvm extends AminoMsg {
+    type: "/wasmx.wasmx.MsgStoreCodeEvm";
+    value: {
+        sender: string;
+        evm_byte_code: Uint8Array;
+    };
+}
 export interface AminoMsgInstantiateContract extends AminoMsg {
     type: "/wasmx.wasmx.MsgInstantiateContract";
     value: {
@@ -76,12 +83,24 @@ export interface AminoMsgExecuteDelegateContract extends AminoMsg {
         }[];
     };
 }
+export interface AminoMsgCompileContract extends AminoMsg {
+    type: "/wasmx.wasmx.MsgCompileContract";
+    value: {
+        sender: string;
+        codeId: string;
+    };
+}
 export declare const AminoConverter: {
     "/wasmx.wasmx.MsgStoreCode": {
         aminoType: string;
         toAmino: ({ sender, wasmByteCode }: MsgStoreCode) => AminoMsgStoreCode["value"];
         fromAmino: ({ sender, wasm_byte_code }: AminoMsgStoreCode["value"]) => MsgStoreCode;
     };
+    "/wasmx.wasmx.MsgStoreCodeEvm": {
+        aminoType: string;
+        toAmino: ({ sender, evmByteCode }: MsgStoreCodeEvm) => AminoMsgStoreCodeEvm["value"];
+        fromAmino: ({ sender, evm_byte_code }: AminoMsgStoreCodeEvm["value"]) => MsgStoreCodeEvm;
+    };
     "/wasmx.wasmx.MsgInstantiateContract": {
         aminoType: string;
         toAmino: ({ sender, codeId, label, msg, funds }: MsgInstantiateContract) => AminoMsgInstantiateContract["value"];
@@ -107,4 +126,9 @@ export declare const AminoConverter: {
         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": {
+        aminoType: string;
+        toAmino: ({ sender, codeId }: MsgCompileContract) => AminoMsgCompileContract["value"];
+        fromAmino: ({ sender, codeId }: AminoMsgCompileContract["value"]) => MsgCompileContract;
+    };
 };

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

@@ -29,6 +29,34 @@ export interface MsgStoreCodeResponseSDKType {
     /** Checksum is the sha256 hash of the stored code */
     checksum: Uint8Array;
 }
+/** MsgStoreCodeEvm submit Wasm code to the system */
+export interface MsgStoreCodeEvm {
+    /** Sender is the that actor that signed the messages */
+    sender: string;
+    /** EVM bytecode */
+    evmByteCode: Uint8Array;
+}
+/** MsgStoreCodeEvm submit Wasm code to the system */
+export interface MsgStoreCodeEvmSDKType {
+    /** Sender is the that actor that signed the messages */
+    sender: string;
+    /** EVM bytecode */
+    evm_byte_code: Uint8Array;
+}
+/** MsgStoreCodeEvmResponse returns store result data. */
+export interface MsgStoreCodeEvmResponse {
+    /** CodeID is the reference to the stored WASM code */
+    codeId: Long;
+    /** Checksum is the sha256 hash of the stored code */
+    checksum: Uint8Array;
+}
+/** MsgStoreCodeEvmResponse returns store result data. */
+export interface MsgStoreCodeEvmResponseSDKType {
+    /** CodeID is the reference to the stored WASM code */
+    code_id: Long;
+    /** Checksum is the sha256 hash of the stored code */
+    checksum: Uint8Array;
+}
 /**
  * MsgInstantiateContract create a new smart contract instance for the given
  * code id.
@@ -253,6 +281,22 @@ export interface MsgExecuteDelegateContractResponseSDKType {
     /** Data contains bytes to returned from the contract */
     data: Uint8Array;
 }
+export interface MsgCompileContract {
+    /** Sender is the that actor that signed the messages */
+    sender: string;
+    /** Contract is the address of the smart contract */
+    codeId: Long;
+}
+export interface MsgCompileContractSDKType {
+    /** Sender is the that actor that signed the messages */
+    sender: string;
+    /** Contract is the address of the smart contract */
+    codeId: Long;
+}
+export interface MsgCompileContractResponse {
+}
+export interface MsgCompileContractResponseSDKType {
+}
 export declare const MsgStoreCode: {
     encode(message: MsgStoreCode, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): MsgStoreCode;
@@ -267,6 +311,20 @@ export declare const MsgStoreCodeResponse: {
     toJSON(message: MsgStoreCodeResponse): unknown;
     fromPartial(object: Partial<MsgStoreCodeResponse>): MsgStoreCodeResponse;
 };
+export declare const MsgStoreCodeEvm: {
+    encode(message: MsgStoreCodeEvm, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgStoreCodeEvm;
+    fromJSON(object: any): MsgStoreCodeEvm;
+    toJSON(message: MsgStoreCodeEvm): unknown;
+    fromPartial(object: Partial<MsgStoreCodeEvm>): MsgStoreCodeEvm;
+};
+export declare const MsgStoreCodeEvmResponse: {
+    encode(message: MsgStoreCodeEvmResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgStoreCodeEvmResponse;
+    fromJSON(object: any): MsgStoreCodeEvmResponse;
+    toJSON(message: MsgStoreCodeEvmResponse): unknown;
+    fromPartial(object: Partial<MsgStoreCodeEvmResponse>): MsgStoreCodeEvmResponse;
+};
 export declare const MsgInstantiateContract: {
     encode(message: MsgInstantiateContract, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): MsgInstantiateContract;
@@ -330,3 +388,17 @@ export declare const MsgExecuteDelegateContractResponse: {
     toJSON(message: MsgExecuteDelegateContractResponse): unknown;
     fromPartial(object: Partial<MsgExecuteDelegateContractResponse>): MsgExecuteDelegateContractResponse;
 };
+export declare const MsgCompileContract: {
+    encode(message: MsgCompileContract, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCompileContract;
+    fromJSON(object: any): MsgCompileContract;
+    toJSON(message: MsgCompileContract): unknown;
+    fromPartial(object: Partial<MsgCompileContract>): MsgCompileContract;
+};
+export declare const MsgCompileContractResponse: {
+    encode(_: MsgCompileContractResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCompileContractResponse;
+    fromJSON(_: any): MsgCompileContractResponse;
+    toJSON(_: MsgCompileContractResponse): unknown;
+    fromPartial(_: Partial<MsgCompileContractResponse>): MsgCompileContractResponse;
+};

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

@@ -1,5 +1,5 @@
 import { GeneratedType, Registry } from "@cosmjs/proto-signing";
-import { MsgStoreCode, MsgInstantiateContract, MsgInstantiateContract2, MsgExecuteContract, MsgExecuteWithOriginContract, MsgExecuteDelegateContract } from "./tx";
+import { MsgStoreCode, MsgStoreCodeEvm, MsgInstantiateContract, MsgInstantiateContract2, MsgExecuteContract, MsgExecuteWithOriginContract, MsgExecuteDelegateContract, MsgCompileContract } from "./tx";
 export declare const registry: ReadonlyArray<[string, GeneratedType]>;
 export declare const load: (protoRegistry: Registry) => void;
 export declare const MessageComposer: {
@@ -8,6 +8,10 @@ export declare const MessageComposer: {
             typeUrl: string;
             value: Uint8Array;
         };
+        storeCodeEvm(value: MsgStoreCodeEvm): {
+            typeUrl: string;
+            value: Uint8Array;
+        };
         instantiateContract(value: MsgInstantiateContract): {
             typeUrl: string;
             value: Uint8Array;
@@ -28,12 +32,20 @@ export declare const MessageComposer: {
             typeUrl: string;
             value: Uint8Array;
         };
+        compileContract(value: MsgCompileContract): {
+            typeUrl: string;
+            value: Uint8Array;
+        };
     };
     withTypeUrl: {
         storeCode(value: MsgStoreCode): {
             typeUrl: string;
             value: MsgStoreCode;
         };
+        storeCodeEvm(value: MsgStoreCodeEvm): {
+            typeUrl: string;
+            value: MsgStoreCodeEvm;
+        };
         instantiateContract(value: MsgInstantiateContract): {
             typeUrl: string;
             value: MsgInstantiateContract;
@@ -54,12 +66,20 @@ export declare const MessageComposer: {
             typeUrl: string;
             value: MsgExecuteDelegateContract;
         };
+        compileContract(value: MsgCompileContract): {
+            typeUrl: string;
+            value: MsgCompileContract;
+        };
     };
     toJSON: {
         storeCode(value: MsgStoreCode): {
             typeUrl: string;
             value: unknown;
         };
+        storeCodeEvm(value: MsgStoreCodeEvm): {
+            typeUrl: string;
+            value: unknown;
+        };
         instantiateContract(value: MsgInstantiateContract): {
             typeUrl: string;
             value: unknown;
@@ -80,12 +100,20 @@ export declare const MessageComposer: {
             typeUrl: string;
             value: unknown;
         };
+        compileContract(value: MsgCompileContract): {
+            typeUrl: string;
+            value: unknown;
+        };
     };
     fromJSON: {
         storeCode(value: any): {
             typeUrl: string;
             value: MsgStoreCode;
         };
+        storeCodeEvm(value: any): {
+            typeUrl: string;
+            value: MsgStoreCodeEvm;
+        };
         instantiateContract(value: any): {
             typeUrl: string;
             value: MsgInstantiateContract;
@@ -106,12 +134,20 @@ export declare const MessageComposer: {
             typeUrl: string;
             value: MsgExecuteDelegateContract;
         };
+        compileContract(value: any): {
+            typeUrl: string;
+            value: MsgCompileContract;
+        };
     };
     fromPartial: {
         storeCode(value: MsgStoreCode): {
             typeUrl: string;
             value: MsgStoreCode;
         };
+        storeCodeEvm(value: MsgStoreCodeEvm): {
+            typeUrl: string;
+            value: MsgStoreCodeEvm;
+        };
         instantiateContract(value: MsgInstantiateContract): {
             typeUrl: string;
             value: MsgInstantiateContract;
@@ -132,5 +168,9 @@ export declare const MessageComposer: {
             typeUrl: string;
             value: MsgExecuteDelegateContract;
         };
+        compileContract(value: MsgCompileContract): {
+            typeUrl: string;
+            value: MsgCompileContract;
+        };
     };
 };

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

@@ -1,9 +1,11 @@
 import { Rpc } from "../../helpers";
-import { MsgStoreCode, MsgStoreCodeResponse, MsgInstantiateContract, MsgInstantiateContractResponse, MsgInstantiateContract2, MsgInstantiateContract2Response, MsgExecuteContract, MsgExecuteContractResponse, MsgExecuteWithOriginContract, MsgExecuteDelegateContract, MsgExecuteDelegateContractResponse } from "./tx";
+import { MsgStoreCode, MsgStoreCodeResponse, MsgStoreCodeEvm, MsgStoreCodeEvmResponse, MsgInstantiateContract, MsgInstantiateContractResponse, MsgInstantiateContract2, MsgInstantiateContract2Response, MsgExecuteContract, MsgExecuteContractResponse, MsgExecuteWithOriginContract, MsgExecuteDelegateContract, MsgExecuteDelegateContractResponse, MsgCompileContract, MsgCompileContractResponse } from "./tx";
 /** Msg defines the wasm Msg service. */
 export interface Msg {
     /** StoreCode to submit Wasm code to the system */
     storeCode(request: MsgStoreCode): Promise<MsgStoreCodeResponse>;
+    /** StoreCode to submit Wasm code to the system */
+    storeCodeEvm(request: MsgStoreCodeEvm): Promise<MsgStoreCodeEvmResponse>;
     /**
      * InstantiateContract creates a new smart contract instance for the given
      *  code id.
@@ -20,14 +22,18 @@ export interface Msg {
     executeWithOriginContract(request: MsgExecuteWithOriginContract): Promise<MsgExecuteContractResponse>;
     /** ExecuteDelegate submits the given message data to a smart contract */
     executeDelegateContract(request: MsgExecuteDelegateContract): Promise<MsgExecuteDelegateContractResponse>;
+    /** CompileContract submits a smart contract to be precompiled */
+    compileContract(request: MsgCompileContract): Promise<MsgCompileContractResponse>;
 }
 export declare class MsgClientImpl implements Msg {
     private readonly rpc;
     constructor(rpc: Rpc);
     storeCode(request: MsgStoreCode): Promise<MsgStoreCodeResponse>;
+    storeCodeEvm(request: MsgStoreCodeEvm): Promise<MsgStoreCodeEvmResponse>;
     instantiateContract(request: MsgInstantiateContract): Promise<MsgInstantiateContractResponse>;
     instantiateContract2(request: MsgInstantiateContract2): Promise<MsgInstantiateContract2Response>;
     executeContract(request: MsgExecuteContract): Promise<MsgExecuteContractResponse>;
     executeWithOriginContract(request: MsgExecuteWithOriginContract): Promise<MsgExecuteContractResponse>;
     executeDelegateContract(request: MsgExecuteDelegateContract): Promise<MsgExecuteDelegateContractResponse>;
+    compileContract(request: MsgCompileContract): Promise<MsgCompileContractResponse>;
 }

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

@@ -0,0 +1,17 @@
+import { Params, ParamsSDKType } from "./params";
+import * as _m0 from "protobufjs/minimal";
+/** GenesisState defines the websrv module's genesis state. */
+export interface GenesisState {
+    params?: Params;
+}
+/** GenesisState defines the websrv module's genesis state. */
+export interface GenesisStateSDKType {
+    params?: ParamsSDKType;
+}
+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;
+};

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

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