interchainjs/cosmwasm/wasm/v1/types.d.ts

InterchainJS is a JavaScript library for interacting with Cosmos SDK based blockchains.

import { Any, AnyProtoMsg, AnyAmino } from "../../../google/protobuf/any";
import { DeepPartial } from "../../../helpers";
import { BinaryReader, BinaryWriter } from "../../../binary";
/** AccessType permission types */
export declare enum AccessType {
    /** ACCESS_TYPE_UNSPECIFIED - AccessTypeUnspecified placeholder for empty value */
    ACCESS_TYPE_UNSPECIFIED = 0,
    /** ACCESS_TYPE_NOBODY - AccessTypeNobody forbidden */
    ACCESS_TYPE_NOBODY = 1,
    /** ACCESS_TYPE_EVERYBODY - AccessTypeEverybody unrestricted */
    ACCESS_TYPE_EVERYBODY = 3,
    /** ACCESS_TYPE_ANY_OF_ADDRESSES - AccessTypeAnyOfAddresses allow any of the addresses */
    ACCESS_TYPE_ANY_OF_ADDRESSES = 4,
    UNRECOGNIZED = -1
}
export declare const AccessTypeAmino: typeof AccessType;
export declare function accessTypeFromJSON(object: any): AccessType;
export declare function accessTypeToJSON(object: AccessType): string;
/** ContractCodeHistoryOperationType actions that caused a code change */
export declare enum ContractCodeHistoryOperationType {
    /** CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED - ContractCodeHistoryOperationTypeUnspecified placeholder for empty value */
    CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED = 0,
    /** CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT - ContractCodeHistoryOperationTypeInit on chain contract instantiation */
    CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT = 1,
    /** CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE - ContractCodeHistoryOperationTypeMigrate code migration */
    CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE = 2,
    /** CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS - ContractCodeHistoryOperationTypeGenesis based on genesis data */
    CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS = 3,
    UNRECOGNIZED = -1
}
export declare const ContractCodeHistoryOperationTypeAmino: typeof ContractCodeHistoryOperationType;
export declare function contractCodeHistoryOperationTypeFromJSON(object: any): ContractCodeHistoryOperationType;
export declare function contractCodeHistoryOperationTypeToJSON(object: ContractCodeHistoryOperationType): string;
/**
 * AccessTypeParam
 * @name AccessTypeParam
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AccessTypeParam
 */
export interface AccessTypeParam {
    value: AccessType;
}
export interface AccessTypeParamProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.AccessTypeParam";
    value: Uint8Array;
}
/**
 * AccessTypeParam
 * @name AccessTypeParamAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AccessTypeParam
 */
export interface AccessTypeParamAmino {
    value: AccessType;
}
export interface AccessTypeParamAminoMsg {
    type: "wasm/AccessTypeParam";
    value: AccessTypeParamAmino;
}
/**
 * AccessConfig access control type.
 * @name AccessConfig
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AccessConfig
 */
export interface AccessConfig {
    permission: AccessType;
    addresses: string[];
}
export interface AccessConfigProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.AccessConfig";
    value: Uint8Array;
}
/**
 * AccessConfig access control type.
 * @name AccessConfigAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AccessConfig
 */
export interface AccessConfigAmino {
    permission: AccessType;
    addresses: string[];
}
export interface AccessConfigAminoMsg {
    type: "wasm/AccessConfig";
    value: AccessConfigAmino;
}
/**
 * Params defines the set of wasm parameters.
 * @name Params
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.Params
 */
export interface Params {
    codeUploadAccess: AccessConfig;
    instantiateDefaultPermission: AccessType;
}
export interface ParamsProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.Params";
    value: Uint8Array;
}
/**
 * Params defines the set of wasm parameters.
 * @name ParamsAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.Params
 */
export interface ParamsAmino {
    code_upload_access: AccessConfigAmino;
    instantiate_default_permission: AccessType;
}
export interface ParamsAminoMsg {
    type: "wasm/Params";
    value: ParamsAmino;
}
/**
 * CodeInfo is data for the uploaded contract WASM code
 * @name CodeInfo
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.CodeInfo
 */
export interface CodeInfo {
    /**
     * CodeHash is the unique identifier created by wasmvm
     */
    codeHash: Uint8Array;
    /**
     * Creator address who initially stored the code
     */
    creator: string;
    /**
     * InstantiateConfig access control to apply on contract creation, optional
     */
    instantiateConfig: AccessConfig;
}
export interface CodeInfoProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.CodeInfo";
    value: Uint8Array;
}
/**
 * CodeInfo is data for the uploaded contract WASM code
 * @name CodeInfoAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.CodeInfo
 */
export interface CodeInfoAmino {
    /**
     * CodeHash is the unique identifier created by wasmvm
     */
    code_hash: string;
    /**
     * Creator address who initially stored the code
     */
    creator: string;
    /**
     * InstantiateConfig access control to apply on contract creation, optional
     */
    instantiate_config: AccessConfigAmino;
}
export interface CodeInfoAminoMsg {
    type: "wasm/CodeInfo";
    value: CodeInfoAmino;
}
/**
 * ContractInfo stores a WASM contract instance
 * @name ContractInfo
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.ContractInfo
 */
export interface ContractInfo {
    /**
     * CodeID is the reference to the stored Wasm code
     */
    codeId: bigint;
    /**
     * Creator address who initially instantiated the contract
     */
    creator: string;
    /**
     * Admin is an optional address that can execute migrations
     */
    admin: string;
    /**
     * Label is optional metadata to be stored with a contract instance.
     */
    label: string;
    /**
     * Created Tx position when the contract was instantiated.
     */
    created?: AbsoluteTxPosition;
    ibcPortId: string;
    /**
     * Extension is an extension point to store custom metadata within the
     * persistence model.
     */
    extension?: Any | undefined;
}
export interface ContractInfoProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.ContractInfo";
    value: Uint8Array;
}
export type ContractInfoEncoded = Omit<ContractInfo, "extension"> & {
    /**
     * Extension is an extension point to store custom metadata within the
     * persistence model.
     */
    extension?: AnyProtoMsg | undefined;
};
/**
 * ContractInfo stores a WASM contract instance
 * @name ContractInfoAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.ContractInfo
 */
export interface ContractInfoAmino {
    /**
     * CodeID is the reference to the stored Wasm code
     */
    code_id: string;
    /**
     * Creator address who initially instantiated the contract
     */
    creator: string;
    /**
     * Admin is an optional address that can execute migrations
     */
    admin: string;
    /**
     * Label is optional metadata to be stored with a contract instance.
     */
    label: string;
    /**
     * Created Tx position when the contract was instantiated.
     */
    created?: AbsoluteTxPositionAmino;
    ibc_port_id: string;
    /**
     * Extension is an extension point to store custom metadata within the
     * persistence model.
     */
    extension?: AnyAmino;
}
export interface ContractInfoAminoMsg {
    type: "wasm/ContractInfo";
    value: ContractInfoAmino;
}
/**
 * ContractCodeHistoryEntry metadata to a contract.
 * @name ContractCodeHistoryEntry
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.ContractCodeHistoryEntry
 */
export interface ContractCodeHistoryEntry {
    operation: ContractCodeHistoryOperationType;
    /**
     * CodeID is the reference to the stored WASM code
     */
    codeId: bigint;
    /**
     * Updated Tx position when the operation was executed.
     */
    updated?: AbsoluteTxPosition;
    msg: Uint8Array;
}
export interface ContractCodeHistoryEntryProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.ContractCodeHistoryEntry";
    value: Uint8Array;
}
/**
 * ContractCodeHistoryEntry metadata to a contract.
 * @name ContractCodeHistoryEntryAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.ContractCodeHistoryEntry
 */
export interface ContractCodeHistoryEntryAmino {
    operation: ContractCodeHistoryOperationType;
    /**
     * CodeID is the reference to the stored WASM code
     */
    code_id: string;
    /**
     * Updated Tx position when the operation was executed.
     */
    updated?: AbsoluteTxPositionAmino;
    msg: any;
}
export interface ContractCodeHistoryEntryAminoMsg {
    type: "wasm/ContractCodeHistoryEntry";
    value: ContractCodeHistoryEntryAmino;
}
/**
 * AbsoluteTxPosition is a unique transaction position that allows for global
 * ordering of transactions.
 * @name AbsoluteTxPosition
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AbsoluteTxPosition
 */
export interface AbsoluteTxPosition {
    /**
     * BlockHeight is the block the contract was created at
     */
    blockHeight: bigint;
    /**
     * TxIndex is a monotonic counter within the block (actual transaction index,
     * or gas consumed)
     */
    txIndex: bigint;
}
export interface AbsoluteTxPositionProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.AbsoluteTxPosition";
    value: Uint8Array;
}
/**
 * AbsoluteTxPosition is a unique transaction position that allows for global
 * ordering of transactions.
 * @name AbsoluteTxPositionAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AbsoluteTxPosition
 */
export interface AbsoluteTxPositionAmino {
    /**
     * BlockHeight is the block the contract was created at
     */
    block_height: string;
    /**
     * TxIndex is a monotonic counter within the block (actual transaction index,
     * or gas consumed)
     */
    tx_index: string;
}
export interface AbsoluteTxPositionAminoMsg {
    type: "wasm/AbsoluteTxPosition";
    value: AbsoluteTxPositionAmino;
}
/**
 * Model is a struct that holds a KV pair
 * @name Model
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.Model
 */
export interface Model {
    /**
     * hex-encode key to read it better (this is often ascii)
     */
    key: Uint8Array;
    /**
     * base64-encode raw value
     */
    value: Uint8Array;
}
export interface ModelProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.Model";
    value: Uint8Array;
}
/**
 * Model is a struct that holds a KV pair
 * @name ModelAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.Model
 */
export interface ModelAmino {
    /**
     * hex-encode key to read it better (this is often ascii)
     */
    key: string;
    /**
     * base64-encode raw value
     */
    value: string;
}
export interface ModelAminoMsg {
    type: "wasm/Model";
    value: ModelAmino;
}
/**
 * AccessTypeParam
 * @name AccessTypeParam
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AccessTypeParam
 */
export declare const AccessTypeParam: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is AccessTypeParam;
    isAmino(o: any): o is AccessTypeParamAmino;
    encode(message: AccessTypeParam, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): AccessTypeParam;
    fromPartial(object: DeepPartial<AccessTypeParam>): AccessTypeParam;
    fromAmino(object: AccessTypeParamAmino): AccessTypeParam;
    toAmino(message: AccessTypeParam): AccessTypeParamAmino;
    fromAminoMsg(object: AccessTypeParamAminoMsg): AccessTypeParam;
    toAminoMsg(message: AccessTypeParam): AccessTypeParamAminoMsg;
    fromProtoMsg(message: AccessTypeParamProtoMsg): AccessTypeParam;
    toProto(message: AccessTypeParam): Uint8Array;
    toProtoMsg(message: AccessTypeParam): AccessTypeParamProtoMsg;
    registerTypeUrl(): void;
};
/**
 * AccessConfig access control type.
 * @name AccessConfig
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AccessConfig
 */
export declare const AccessConfig: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is AccessConfig;
    isAmino(o: any): o is AccessConfigAmino;
    encode(message: AccessConfig, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): AccessConfig;
    fromPartial(object: DeepPartial<AccessConfig>): AccessConfig;
    fromAmino(object: AccessConfigAmino): AccessConfig;
    toAmino(message: AccessConfig): AccessConfigAmino;
    fromAminoMsg(object: AccessConfigAminoMsg): AccessConfig;
    toAminoMsg(message: AccessConfig): AccessConfigAminoMsg;
    fromProtoMsg(message: AccessConfigProtoMsg): AccessConfig;
    toProto(message: AccessConfig): Uint8Array;
    toProtoMsg(message: AccessConfig): AccessConfigProtoMsg;
    registerTypeUrl(): void;
};
/**
 * Params defines the set of wasm parameters.
 * @name Params
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.Params
 */
export declare const Params: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is Params;
    isAmino(o: any): o is ParamsAmino;
    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Params;
    fromPartial(object: DeepPartial<Params>): Params;
    fromAmino(object: ParamsAmino): Params;
    toAmino(message: Params): ParamsAmino;
    fromAminoMsg(object: ParamsAminoMsg): Params;
    toAminoMsg(message: Params): ParamsAminoMsg;
    fromProtoMsg(message: ParamsProtoMsg): Params;
    toProto(message: Params): Uint8Array;
    toProtoMsg(message: Params): ParamsProtoMsg;
    registerTypeUrl(): void;
};
/**
 * CodeInfo is data for the uploaded contract WASM code
 * @name CodeInfo
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.CodeInfo
 */
export declare const CodeInfo: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is CodeInfo;
    isAmino(o: any): o is CodeInfoAmino;
    encode(message: CodeInfo, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): CodeInfo;
    fromPartial(object: DeepPartial<CodeInfo>): CodeInfo;
    fromAmino(object: CodeInfoAmino): CodeInfo;
    toAmino(message: CodeInfo): CodeInfoAmino;
    fromAminoMsg(object: CodeInfoAminoMsg): CodeInfo;
    toAminoMsg(message: CodeInfo): CodeInfoAminoMsg;
    fromProtoMsg(message: CodeInfoProtoMsg): CodeInfo;
    toProto(message: CodeInfo): Uint8Array;
    toProtoMsg(message: CodeInfo): CodeInfoProtoMsg;
    registerTypeUrl(): void;
};
/**
 * ContractInfo stores a WASM contract instance
 * @name ContractInfo
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.ContractInfo
 */
export declare const ContractInfo: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is ContractInfo;
    isAmino(o: any): o is ContractInfoAmino;
    encode(message: ContractInfo, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ContractInfo;
    fromPartial(object: DeepPartial<ContractInfo>): ContractInfo;
    fromAmino(object: ContractInfoAmino): ContractInfo;
    toAmino(message: ContractInfo): ContractInfoAmino;
    fromAminoMsg(object: ContractInfoAminoMsg): ContractInfo;
    toAminoMsg(message: ContractInfo): ContractInfoAminoMsg;
    fromProtoMsg(message: ContractInfoProtoMsg): ContractInfo;
    toProto(message: ContractInfo): Uint8Array;
    toProtoMsg(message: ContractInfo): ContractInfoProtoMsg;
    registerTypeUrl(): void;
};
/**
 * ContractCodeHistoryEntry metadata to a contract.
 * @name ContractCodeHistoryEntry
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.ContractCodeHistoryEntry
 */
export declare const ContractCodeHistoryEntry: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is ContractCodeHistoryEntry;
    isAmino(o: any): o is ContractCodeHistoryEntryAmino;
    encode(message: ContractCodeHistoryEntry, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ContractCodeHistoryEntry;
    fromPartial(object: DeepPartial<ContractCodeHistoryEntry>): ContractCodeHistoryEntry;
    fromAmino(object: ContractCodeHistoryEntryAmino): ContractCodeHistoryEntry;
    toAmino(message: ContractCodeHistoryEntry): ContractCodeHistoryEntryAmino;
    fromAminoMsg(object: ContractCodeHistoryEntryAminoMsg): ContractCodeHistoryEntry;
    toAminoMsg(message: ContractCodeHistoryEntry): ContractCodeHistoryEntryAminoMsg;
    fromProtoMsg(message: ContractCodeHistoryEntryProtoMsg): ContractCodeHistoryEntry;
    toProto(message: ContractCodeHistoryEntry): Uint8Array;
    toProtoMsg(message: ContractCodeHistoryEntry): ContractCodeHistoryEntryProtoMsg;
    registerTypeUrl(): void;
};
/**
 * AbsoluteTxPosition is a unique transaction position that allows for global
 * ordering of transactions.
 * @name AbsoluteTxPosition
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.AbsoluteTxPosition
 */
export declare const AbsoluteTxPosition: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is AbsoluteTxPosition;
    isAmino(o: any): o is AbsoluteTxPositionAmino;
    encode(message: AbsoluteTxPosition, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): AbsoluteTxPosition;
    fromPartial(object: DeepPartial<AbsoluteTxPosition>): AbsoluteTxPosition;
    fromAmino(object: AbsoluteTxPositionAmino): AbsoluteTxPosition;
    toAmino(message: AbsoluteTxPosition): AbsoluteTxPositionAmino;
    fromAminoMsg(object: AbsoluteTxPositionAminoMsg): AbsoluteTxPosition;
    toAminoMsg(message: AbsoluteTxPosition): AbsoluteTxPositionAminoMsg;
    fromProtoMsg(message: AbsoluteTxPositionProtoMsg): AbsoluteTxPosition;
    toProto(message: AbsoluteTxPosition): Uint8Array;
    toProtoMsg(message: AbsoluteTxPosition): AbsoluteTxPositionProtoMsg;
    registerTypeUrl(): void;
};
/**
 * Model is a struct that holds a KV pair
 * @name Model
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.Model
 */
export declare const Model: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is Model;
    isAmino(o: any): o is ModelAmino;
    encode(message: Model, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Model;
    fromPartial(object: DeepPartial<Model>): Model;
    fromAmino(object: ModelAmino): Model;
    toAmino(message: Model): ModelAmino;
    fromAminoMsg(object: ModelAminoMsg): Model;
    toAminoMsg(message: Model): ModelAminoMsg;
    fromProtoMsg(message: ModelProtoMsg): Model;
    toProto(message: Model): Uint8Array;
    toProtoMsg(message: Model): ModelProtoMsg;
    registerTypeUrl(): void;
};