injectivejs 1.4.0 → 1.6.0

package/injective/peggy/v1/events.d.ts

@@ -0,0 +1,598 @@
+import { ClaimType } from "./attestation";
+import { BridgeValidator, BridgeValidatorAmino } from "./types";
+import { DeepPartial } from "../../../helpers";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+export interface EventAttestationObserved {
+    attestationType: ClaimType;
+    bridgeContract: string;
+    bridgeChainId: bigint;
+    attestationId: Uint8Array;
+    nonce: bigint;
+}
+export interface EventAttestationObservedProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventAttestationObserved";
+    value: Uint8Array;
+}
+export interface EventAttestationObservedAmino {
+    attestation_type: ClaimType;
+    bridge_contract: string;
+    bridge_chain_id: string;
+    attestation_id: string;
+    nonce: string;
+}
+export interface EventAttestationObservedAminoMsg {
+    type: "/injective.peggy.v1.EventAttestationObserved";
+    value: EventAttestationObservedAmino;
+}
+export interface EventBridgeWithdrawCanceled {
+    bridgeContract: string;
+    bridgeChainId: bigint;
+}
+export interface EventBridgeWithdrawCanceledProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventBridgeWithdrawCanceled";
+    value: Uint8Array;
+}
+export interface EventBridgeWithdrawCanceledAmino {
+    bridge_contract: string;
+    bridge_chain_id: string;
+}
+export interface EventBridgeWithdrawCanceledAminoMsg {
+    type: "/injective.peggy.v1.EventBridgeWithdrawCanceled";
+    value: EventBridgeWithdrawCanceledAmino;
+}
+export interface EventOutgoingBatch {
+    denom: string;
+    orchestratorAddress: string;
+    batchNonce: bigint;
+    batchTimeout: bigint;
+    batchTxIds: bigint[];
+}
+export interface EventOutgoingBatchProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventOutgoingBatch";
+    value: Uint8Array;
+}
+export interface EventOutgoingBatchAmino {
+    denom: string;
+    orchestrator_address: string;
+    batch_nonce: string;
+    batch_timeout: string;
+    batch_tx_ids: string[];
+}
+export interface EventOutgoingBatchAminoMsg {
+    type: "/injective.peggy.v1.EventOutgoingBatch";
+    value: EventOutgoingBatchAmino;
+}
+export interface EventOutgoingBatchCanceled {
+    bridgeContract: string;
+    bridgeChainId: bigint;
+    batchId: bigint;
+    nonce: bigint;
+}
+export interface EventOutgoingBatchCanceledProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventOutgoingBatchCanceled";
+    value: Uint8Array;
+}
+export interface EventOutgoingBatchCanceledAmino {
+    bridge_contract: string;
+    bridge_chain_id: string;
+    batch_id: string;
+    nonce: string;
+}
+export interface EventOutgoingBatchCanceledAminoMsg {
+    type: "/injective.peggy.v1.EventOutgoingBatchCanceled";
+    value: EventOutgoingBatchCanceledAmino;
+}
+export interface EventValsetUpdateRequest {
+    valsetNonce: bigint;
+    valsetHeight: bigint;
+    valsetMembers: BridgeValidator[];
+    rewardAmount: string;
+    rewardToken: string;
+}
+export interface EventValsetUpdateRequestProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventValsetUpdateRequest";
+    value: Uint8Array;
+}
+export interface EventValsetUpdateRequestAmino {
+    valset_nonce: string;
+    valset_height: string;
+    valset_members: BridgeValidatorAmino[];
+    reward_amount: string;
+    reward_token: string;
+}
+export interface EventValsetUpdateRequestAminoMsg {
+    type: "/injective.peggy.v1.EventValsetUpdateRequest";
+    value: EventValsetUpdateRequestAmino;
+}
+export interface EventSetOrchestratorAddresses {
+    validatorAddress: string;
+    orchestratorAddress: string;
+    operatorEthAddress: string;
+}
+export interface EventSetOrchestratorAddressesProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventSetOrchestratorAddresses";
+    value: Uint8Array;
+}
+export interface EventSetOrchestratorAddressesAmino {
+    validator_address: string;
+    orchestrator_address: string;
+    operator_eth_address: string;
+}
+export interface EventSetOrchestratorAddressesAminoMsg {
+    type: "/injective.peggy.v1.EventSetOrchestratorAddresses";
+    value: EventSetOrchestratorAddressesAmino;
+}
+export interface EventValsetConfirm {
+    valsetNonce: bigint;
+    orchestratorAddress: string;
+}
+export interface EventValsetConfirmProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventValsetConfirm";
+    value: Uint8Array;
+}
+export interface EventValsetConfirmAmino {
+    valset_nonce: string;
+    orchestrator_address: string;
+}
+export interface EventValsetConfirmAminoMsg {
+    type: "/injective.peggy.v1.EventValsetConfirm";
+    value: EventValsetConfirmAmino;
+}
+export interface EventSendToEth {
+    outgoingTxId: bigint;
+    sender: string;
+    receiver: string;
+    amount: string;
+    bridgeFee: string;
+}
+export interface EventSendToEthProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventSendToEth";
+    value: Uint8Array;
+}
+export interface EventSendToEthAmino {
+    outgoing_tx_id: string;
+    sender: string;
+    receiver: string;
+    amount: string;
+    bridge_fee: string;
+}
+export interface EventSendToEthAminoMsg {
+    type: "/injective.peggy.v1.EventSendToEth";
+    value: EventSendToEthAmino;
+}
+export interface EventConfirmBatch {
+    batchNonce: bigint;
+    orchestratorAddress: string;
+}
+export interface EventConfirmBatchProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventConfirmBatch";
+    value: Uint8Array;
+}
+export interface EventConfirmBatchAmino {
+    batch_nonce: string;
+    orchestrator_address: string;
+}
+export interface EventConfirmBatchAminoMsg {
+    type: "/injective.peggy.v1.EventConfirmBatch";
+    value: EventConfirmBatchAmino;
+}
+export interface EventAttestationVote {
+    eventNonce: bigint;
+    attestationId: Uint8Array;
+    voter: string;
+}
+export interface EventAttestationVoteProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventAttestationVote";
+    value: Uint8Array;
+}
+export interface EventAttestationVoteAmino {
+    event_nonce: string;
+    attestation_id: string;
+    voter: string;
+}
+export interface EventAttestationVoteAminoMsg {
+    type: "/injective.peggy.v1.EventAttestationVote";
+    value: EventAttestationVoteAmino;
+}
+export interface EventDepositClaim {
+    eventNonce: bigint;
+    eventHeight: bigint;
+    attestationId: Uint8Array;
+    ethereumSender: string;
+    cosmosReceiver: string;
+    tokenContract: string;
+    amount: string;
+    orchestratorAddress: string;
+    data: string;
+}
+export interface EventDepositClaimProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventDepositClaim";
+    value: Uint8Array;
+}
+export interface EventDepositClaimAmino {
+    event_nonce: string;
+    event_height: string;
+    attestation_id: string;
+    ethereum_sender: string;
+    cosmos_receiver: string;
+    token_contract: string;
+    amount: string;
+    orchestrator_address: string;
+    data: string;
+}
+export interface EventDepositClaimAminoMsg {
+    type: "/injective.peggy.v1.EventDepositClaim";
+    value: EventDepositClaimAmino;
+}
+export interface EventWithdrawClaim {
+    eventNonce: bigint;
+    eventHeight: bigint;
+    attestationId: Uint8Array;
+    batchNonce: bigint;
+    tokenContract: string;
+    orchestratorAddress: string;
+}
+export interface EventWithdrawClaimProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventWithdrawClaim";
+    value: Uint8Array;
+}
+export interface EventWithdrawClaimAmino {
+    event_nonce: string;
+    event_height: string;
+    attestation_id: string;
+    batch_nonce: string;
+    token_contract: string;
+    orchestrator_address: string;
+}
+export interface EventWithdrawClaimAminoMsg {
+    type: "/injective.peggy.v1.EventWithdrawClaim";
+    value: EventWithdrawClaimAmino;
+}
+export interface EventERC20DeployedClaim {
+    eventNonce: bigint;
+    eventHeight: bigint;
+    attestationId: Uint8Array;
+    cosmosDenom: string;
+    tokenContract: string;
+    name: string;
+    symbol: string;
+    decimals: bigint;
+    orchestratorAddress: string;
+}
+export interface EventERC20DeployedClaimProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventERC20DeployedClaim";
+    value: Uint8Array;
+}
+export interface EventERC20DeployedClaimAmino {
+    event_nonce: string;
+    event_height: string;
+    attestation_id: string;
+    cosmos_denom: string;
+    token_contract: string;
+    name: string;
+    symbol: string;
+    decimals: string;
+    orchestrator_address: string;
+}
+export interface EventERC20DeployedClaimAminoMsg {
+    type: "/injective.peggy.v1.EventERC20DeployedClaim";
+    value: EventERC20DeployedClaimAmino;
+}
+export interface EventValsetUpdateClaim {
+    eventNonce: bigint;
+    eventHeight: bigint;
+    attestationId: Uint8Array;
+    valsetNonce: bigint;
+    valsetMembers: BridgeValidator[];
+    rewardAmount: string;
+    rewardToken: string;
+    orchestratorAddress: string;
+}
+export interface EventValsetUpdateClaimProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventValsetUpdateClaim";
+    value: Uint8Array;
+}
+export interface EventValsetUpdateClaimAmino {
+    event_nonce: string;
+    event_height: string;
+    attestation_id: string;
+    valset_nonce: string;
+    valset_members: BridgeValidatorAmino[];
+    reward_amount: string;
+    reward_token: string;
+    orchestrator_address: string;
+}
+export interface EventValsetUpdateClaimAminoMsg {
+    type: "/injective.peggy.v1.EventValsetUpdateClaim";
+    value: EventValsetUpdateClaimAmino;
+}
+export interface EventCancelSendToEth {
+    outgoingTxId: bigint;
+}
+export interface EventCancelSendToEthProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventCancelSendToEth";
+    value: Uint8Array;
+}
+export interface EventCancelSendToEthAmino {
+    outgoing_tx_id: string;
+}
+export interface EventCancelSendToEthAminoMsg {
+    type: "/injective.peggy.v1.EventCancelSendToEth";
+    value: EventCancelSendToEthAmino;
+}
+export interface EventSubmitBadSignatureEvidence {
+    badEthSignature: string;
+    badEthSignatureSubject: string;
+}
+export interface EventSubmitBadSignatureEvidenceProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventSubmitBadSignatureEvidence";
+    value: Uint8Array;
+}
+export interface EventSubmitBadSignatureEvidenceAmino {
+    bad_eth_signature: string;
+    bad_eth_signature_subject: string;
+}
+export interface EventSubmitBadSignatureEvidenceAminoMsg {
+    type: "/injective.peggy.v1.EventSubmitBadSignatureEvidence";
+    value: EventSubmitBadSignatureEvidenceAmino;
+}
+export interface EventValidatorSlash {
+    power: bigint;
+    reason: string;
+    consensusAddress: string;
+    operatorAddress: string;
+    moniker: string;
+}
+export interface EventValidatorSlashProtoMsg {
+    typeUrl: "/injective.peggy.v1.EventValidatorSlash";
+    value: Uint8Array;
+}
+export interface EventValidatorSlashAmino {
+    power: string;
+    reason: string;
+    consensus_address: string;
+    operator_address: string;
+    moniker: string;
+}
+export interface EventValidatorSlashAminoMsg {
+    type: "/injective.peggy.v1.EventValidatorSlash";
+    value: EventValidatorSlashAmino;
+}
+export declare const EventAttestationObserved: {
+    typeUrl: string;
+    is(o: any): o is EventAttestationObserved;
+    isAmino(o: any): o is EventAttestationObservedAmino;
+    encode(message: EventAttestationObserved, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventAttestationObserved;
+    fromPartial(object: DeepPartial<EventAttestationObserved>): EventAttestationObserved;
+    fromAmino(object: EventAttestationObservedAmino): EventAttestationObserved;
+    toAmino(message: EventAttestationObserved): EventAttestationObservedAmino;
+    fromAminoMsg(object: EventAttestationObservedAminoMsg): EventAttestationObserved;
+    fromProtoMsg(message: EventAttestationObservedProtoMsg): EventAttestationObserved;
+    toProto(message: EventAttestationObserved): Uint8Array;
+    toProtoMsg(message: EventAttestationObserved): EventAttestationObservedProtoMsg;
+};
+export declare const EventBridgeWithdrawCanceled: {
+    typeUrl: string;
+    is(o: any): o is EventBridgeWithdrawCanceled;
+    isAmino(o: any): o is EventBridgeWithdrawCanceledAmino;
+    encode(message: EventBridgeWithdrawCanceled, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventBridgeWithdrawCanceled;
+    fromPartial(object: DeepPartial<EventBridgeWithdrawCanceled>): EventBridgeWithdrawCanceled;
+    fromAmino(object: EventBridgeWithdrawCanceledAmino): EventBridgeWithdrawCanceled;
+    toAmino(message: EventBridgeWithdrawCanceled): EventBridgeWithdrawCanceledAmino;
+    fromAminoMsg(object: EventBridgeWithdrawCanceledAminoMsg): EventBridgeWithdrawCanceled;
+    fromProtoMsg(message: EventBridgeWithdrawCanceledProtoMsg): EventBridgeWithdrawCanceled;
+    toProto(message: EventBridgeWithdrawCanceled): Uint8Array;
+    toProtoMsg(message: EventBridgeWithdrawCanceled): EventBridgeWithdrawCanceledProtoMsg;
+};
+export declare const EventOutgoingBatch: {
+    typeUrl: string;
+    is(o: any): o is EventOutgoingBatch;
+    isAmino(o: any): o is EventOutgoingBatchAmino;
+    encode(message: EventOutgoingBatch, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventOutgoingBatch;
+    fromPartial(object: DeepPartial<EventOutgoingBatch>): EventOutgoingBatch;
+    fromAmino(object: EventOutgoingBatchAmino): EventOutgoingBatch;
+    toAmino(message: EventOutgoingBatch): EventOutgoingBatchAmino;
+    fromAminoMsg(object: EventOutgoingBatchAminoMsg): EventOutgoingBatch;
+    fromProtoMsg(message: EventOutgoingBatchProtoMsg): EventOutgoingBatch;
+    toProto(message: EventOutgoingBatch): Uint8Array;
+    toProtoMsg(message: EventOutgoingBatch): EventOutgoingBatchProtoMsg;
+};
+export declare const EventOutgoingBatchCanceled: {
+    typeUrl: string;
+    is(o: any): o is EventOutgoingBatchCanceled;
+    isAmino(o: any): o is EventOutgoingBatchCanceledAmino;
+    encode(message: EventOutgoingBatchCanceled, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventOutgoingBatchCanceled;
+    fromPartial(object: DeepPartial<EventOutgoingBatchCanceled>): EventOutgoingBatchCanceled;
+    fromAmino(object: EventOutgoingBatchCanceledAmino): EventOutgoingBatchCanceled;
+    toAmino(message: EventOutgoingBatchCanceled): EventOutgoingBatchCanceledAmino;
+    fromAminoMsg(object: EventOutgoingBatchCanceledAminoMsg): EventOutgoingBatchCanceled;
+    fromProtoMsg(message: EventOutgoingBatchCanceledProtoMsg): EventOutgoingBatchCanceled;
+    toProto(message: EventOutgoingBatchCanceled): Uint8Array;
+    toProtoMsg(message: EventOutgoingBatchCanceled): EventOutgoingBatchCanceledProtoMsg;
+};
+export declare const EventValsetUpdateRequest: {
+    typeUrl: string;
+    is(o: any): o is EventValsetUpdateRequest;
+    isAmino(o: any): o is EventValsetUpdateRequestAmino;
+    encode(message: EventValsetUpdateRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventValsetUpdateRequest;
+    fromPartial(object: DeepPartial<EventValsetUpdateRequest>): EventValsetUpdateRequest;
+    fromAmino(object: EventValsetUpdateRequestAmino): EventValsetUpdateRequest;
+    toAmino(message: EventValsetUpdateRequest): EventValsetUpdateRequestAmino;
+    fromAminoMsg(object: EventValsetUpdateRequestAminoMsg): EventValsetUpdateRequest;
+    fromProtoMsg(message: EventValsetUpdateRequestProtoMsg): EventValsetUpdateRequest;
+    toProto(message: EventValsetUpdateRequest): Uint8Array;
+    toProtoMsg(message: EventValsetUpdateRequest): EventValsetUpdateRequestProtoMsg;
+};
+export declare const EventSetOrchestratorAddresses: {
+    typeUrl: string;
+    is(o: any): o is EventSetOrchestratorAddresses;
+    isAmino(o: any): o is EventSetOrchestratorAddressesAmino;
+    encode(message: EventSetOrchestratorAddresses, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventSetOrchestratorAddresses;
+    fromPartial(object: DeepPartial<EventSetOrchestratorAddresses>): EventSetOrchestratorAddresses;
+    fromAmino(object: EventSetOrchestratorAddressesAmino): EventSetOrchestratorAddresses;
+    toAmino(message: EventSetOrchestratorAddresses): EventSetOrchestratorAddressesAmino;
+    fromAminoMsg(object: EventSetOrchestratorAddressesAminoMsg): EventSetOrchestratorAddresses;
+    fromProtoMsg(message: EventSetOrchestratorAddressesProtoMsg): EventSetOrchestratorAddresses;
+    toProto(message: EventSetOrchestratorAddresses): Uint8Array;
+    toProtoMsg(message: EventSetOrchestratorAddresses): EventSetOrchestratorAddressesProtoMsg;
+};
+export declare const EventValsetConfirm: {
+    typeUrl: string;
+    is(o: any): o is EventValsetConfirm;
+    isAmino(o: any): o is EventValsetConfirmAmino;
+    encode(message: EventValsetConfirm, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventValsetConfirm;
+    fromPartial(object: DeepPartial<EventValsetConfirm>): EventValsetConfirm;
+    fromAmino(object: EventValsetConfirmAmino): EventValsetConfirm;
+    toAmino(message: EventValsetConfirm): EventValsetConfirmAmino;
+    fromAminoMsg(object: EventValsetConfirmAminoMsg): EventValsetConfirm;
+    fromProtoMsg(message: EventValsetConfirmProtoMsg): EventValsetConfirm;
+    toProto(message: EventValsetConfirm): Uint8Array;
+    toProtoMsg(message: EventValsetConfirm): EventValsetConfirmProtoMsg;
+};
+export declare const EventSendToEth: {
+    typeUrl: string;
+    is(o: any): o is EventSendToEth;
+    isAmino(o: any): o is EventSendToEthAmino;
+    encode(message: EventSendToEth, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventSendToEth;
+    fromPartial(object: DeepPartial<EventSendToEth>): EventSendToEth;
+    fromAmino(object: EventSendToEthAmino): EventSendToEth;
+    toAmino(message: EventSendToEth): EventSendToEthAmino;
+    fromAminoMsg(object: EventSendToEthAminoMsg): EventSendToEth;
+    fromProtoMsg(message: EventSendToEthProtoMsg): EventSendToEth;
+    toProto(message: EventSendToEth): Uint8Array;
+    toProtoMsg(message: EventSendToEth): EventSendToEthProtoMsg;
+};
+export declare const EventConfirmBatch: {
+    typeUrl: string;
+    is(o: any): o is EventConfirmBatch;
+    isAmino(o: any): o is EventConfirmBatchAmino;
+    encode(message: EventConfirmBatch, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventConfirmBatch;
+    fromPartial(object: DeepPartial<EventConfirmBatch>): EventConfirmBatch;
+    fromAmino(object: EventConfirmBatchAmino): EventConfirmBatch;
+    toAmino(message: EventConfirmBatch): EventConfirmBatchAmino;
+    fromAminoMsg(object: EventConfirmBatchAminoMsg): EventConfirmBatch;
+    fromProtoMsg(message: EventConfirmBatchProtoMsg): EventConfirmBatch;
+    toProto(message: EventConfirmBatch): Uint8Array;
+    toProtoMsg(message: EventConfirmBatch): EventConfirmBatchProtoMsg;
+};
+export declare const EventAttestationVote: {
+    typeUrl: string;
+    is(o: any): o is EventAttestationVote;
+    isAmino(o: any): o is EventAttestationVoteAmino;
+    encode(message: EventAttestationVote, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventAttestationVote;
+    fromPartial(object: DeepPartial<EventAttestationVote>): EventAttestationVote;
+    fromAmino(object: EventAttestationVoteAmino): EventAttestationVote;
+    toAmino(message: EventAttestationVote): EventAttestationVoteAmino;
+    fromAminoMsg(object: EventAttestationVoteAminoMsg): EventAttestationVote;
+    fromProtoMsg(message: EventAttestationVoteProtoMsg): EventAttestationVote;
+    toProto(message: EventAttestationVote): Uint8Array;
+    toProtoMsg(message: EventAttestationVote): EventAttestationVoteProtoMsg;
+};
+export declare const EventDepositClaim: {
+    typeUrl: string;
+    is(o: any): o is EventDepositClaim;
+    isAmino(o: any): o is EventDepositClaimAmino;
+    encode(message: EventDepositClaim, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventDepositClaim;
+    fromPartial(object: DeepPartial<EventDepositClaim>): EventDepositClaim;
+    fromAmino(object: EventDepositClaimAmino): EventDepositClaim;
+    toAmino(message: EventDepositClaim): EventDepositClaimAmino;
+    fromAminoMsg(object: EventDepositClaimAminoMsg): EventDepositClaim;
+    fromProtoMsg(message: EventDepositClaimProtoMsg): EventDepositClaim;
+    toProto(message: EventDepositClaim): Uint8Array;
+    toProtoMsg(message: EventDepositClaim): EventDepositClaimProtoMsg;
+};
+export declare const EventWithdrawClaim: {
+    typeUrl: string;
+    is(o: any): o is EventWithdrawClaim;
+    isAmino(o: any): o is EventWithdrawClaimAmino;
+    encode(message: EventWithdrawClaim, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventWithdrawClaim;
+    fromPartial(object: DeepPartial<EventWithdrawClaim>): EventWithdrawClaim;
+    fromAmino(object: EventWithdrawClaimAmino): EventWithdrawClaim;
+    toAmino(message: EventWithdrawClaim): EventWithdrawClaimAmino;
+    fromAminoMsg(object: EventWithdrawClaimAminoMsg): EventWithdrawClaim;
+    fromProtoMsg(message: EventWithdrawClaimProtoMsg): EventWithdrawClaim;
+    toProto(message: EventWithdrawClaim): Uint8Array;
+    toProtoMsg(message: EventWithdrawClaim): EventWithdrawClaimProtoMsg;
+};
+export declare const EventERC20DeployedClaim: {
+    typeUrl: string;
+    is(o: any): o is EventERC20DeployedClaim;
+    isAmino(o: any): o is EventERC20DeployedClaimAmino;
+    encode(message: EventERC20DeployedClaim, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventERC20DeployedClaim;
+    fromPartial(object: DeepPartial<EventERC20DeployedClaim>): EventERC20DeployedClaim;
+    fromAmino(object: EventERC20DeployedClaimAmino): EventERC20DeployedClaim;
+    toAmino(message: EventERC20DeployedClaim): EventERC20DeployedClaimAmino;
+    fromAminoMsg(object: EventERC20DeployedClaimAminoMsg): EventERC20DeployedClaim;
+    fromProtoMsg(message: EventERC20DeployedClaimProtoMsg): EventERC20DeployedClaim;
+    toProto(message: EventERC20DeployedClaim): Uint8Array;
+    toProtoMsg(message: EventERC20DeployedClaim): EventERC20DeployedClaimProtoMsg;
+};
+export declare const EventValsetUpdateClaim: {
+    typeUrl: string;
+    is(o: any): o is EventValsetUpdateClaim;
+    isAmino(o: any): o is EventValsetUpdateClaimAmino;
+    encode(message: EventValsetUpdateClaim, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventValsetUpdateClaim;
+    fromPartial(object: DeepPartial<EventValsetUpdateClaim>): EventValsetUpdateClaim;
+    fromAmino(object: EventValsetUpdateClaimAmino): EventValsetUpdateClaim;
+    toAmino(message: EventValsetUpdateClaim): EventValsetUpdateClaimAmino;
+    fromAminoMsg(object: EventValsetUpdateClaimAminoMsg): EventValsetUpdateClaim;
+    fromProtoMsg(message: EventValsetUpdateClaimProtoMsg): EventValsetUpdateClaim;
+    toProto(message: EventValsetUpdateClaim): Uint8Array;
+    toProtoMsg(message: EventValsetUpdateClaim): EventValsetUpdateClaimProtoMsg;
+};
+export declare const EventCancelSendToEth: {
+    typeUrl: string;
+    is(o: any): o is EventCancelSendToEth;
+    isAmino(o: any): o is EventCancelSendToEthAmino;
+    encode(message: EventCancelSendToEth, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventCancelSendToEth;
+    fromPartial(object: DeepPartial<EventCancelSendToEth>): EventCancelSendToEth;
+    fromAmino(object: EventCancelSendToEthAmino): EventCancelSendToEth;
+    toAmino(message: EventCancelSendToEth): EventCancelSendToEthAmino;
+    fromAminoMsg(object: EventCancelSendToEthAminoMsg): EventCancelSendToEth;
+    fromProtoMsg(message: EventCancelSendToEthProtoMsg): EventCancelSendToEth;
+    toProto(message: EventCancelSendToEth): Uint8Array;
+    toProtoMsg(message: EventCancelSendToEth): EventCancelSendToEthProtoMsg;
+};
+export declare const EventSubmitBadSignatureEvidence: {
+    typeUrl: string;
+    is(o: any): o is EventSubmitBadSignatureEvidence;
+    isAmino(o: any): o is EventSubmitBadSignatureEvidenceAmino;
+    encode(message: EventSubmitBadSignatureEvidence, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventSubmitBadSignatureEvidence;
+    fromPartial(object: DeepPartial<EventSubmitBadSignatureEvidence>): EventSubmitBadSignatureEvidence;
+    fromAmino(object: EventSubmitBadSignatureEvidenceAmino): EventSubmitBadSignatureEvidence;
+    toAmino(message: EventSubmitBadSignatureEvidence): EventSubmitBadSignatureEvidenceAmino;
+    fromAminoMsg(object: EventSubmitBadSignatureEvidenceAminoMsg): EventSubmitBadSignatureEvidence;
+    fromProtoMsg(message: EventSubmitBadSignatureEvidenceProtoMsg): EventSubmitBadSignatureEvidence;
+    toProto(message: EventSubmitBadSignatureEvidence): Uint8Array;
+    toProtoMsg(message: EventSubmitBadSignatureEvidence): EventSubmitBadSignatureEvidenceProtoMsg;
+};
+export declare const EventValidatorSlash: {
+    typeUrl: string;
+    is(o: any): o is EventValidatorSlash;
+    isAmino(o: any): o is EventValidatorSlashAmino;
+    encode(message: EventValidatorSlash, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventValidatorSlash;
+    fromPartial(object: DeepPartial<EventValidatorSlash>): EventValidatorSlash;
+    fromAmino(object: EventValidatorSlashAmino): EventValidatorSlash;
+    toAmino(message: EventValidatorSlash): EventValidatorSlashAmino;
+    fromAminoMsg(object: EventValidatorSlashAminoMsg): EventValidatorSlash;
+    fromProtoMsg(message: EventValidatorSlashProtoMsg): EventValidatorSlash;
+    toProto(message: EventValidatorSlash): Uint8Array;
+    toProtoMsg(message: EventValidatorSlash): EventValidatorSlashProtoMsg;
+};