import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
import { BridgeValidator, BridgeValidatorAmino } from "./types";
import { Any, AnyAmino } from "../../../google/protobuf/any";
import { Params, ParamsAmino } from "./params";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { DeepPartial } from "../../../helpers";
/**
 * MsgSetOrchestratorAddresses
 * this message allows validators to delegate their voting responsibilities
 * to a given key. This key is then used as an optional authentication method
 * for sigining oracle claims
 * VALIDATOR
 * The validator field is a cosmosvaloper1... string (i.e. sdk.ValAddress)
 * that references a validator in the active set
 * ORCHESTRATOR
 * The orchestrator field is a cosmos1... string  (i.e. sdk.AccAddress) that
 * references the key that is being delegated to
 * ETH_ADDRESS
 * This is a hex encoded 0x Ethereum public key that will be used by this
 * validator on Ethereum
 * @name MsgSetOrchestratorAddresses
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSetOrchestratorAddresses
 */
export interface MsgSetOrchestratorAddresses {
    sender: string;
    orchestrator: string;
    ethAddress: string;
}
export interface MsgSetOrchestratorAddressesProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgSetOrchestratorAddresses";
    value: Uint8Array;
}
/**
 * MsgSetOrchestratorAddresses
 * this message allows validators to delegate their voting responsibilities
 * to a given key. This key is then used as an optional authentication method
 * for sigining oracle claims
 * VALIDATOR
 * The validator field is a cosmosvaloper1... string (i.e. sdk.ValAddress)
 * that references a validator in the active set
 * ORCHESTRATOR
 * The orchestrator field is a cosmos1... string  (i.e. sdk.AccAddress) that
 * references the key that is being delegated to
 * ETH_ADDRESS
 * This is a hex encoded 0x Ethereum public key that will be used by this
 * validator on Ethereum
 * @name MsgSetOrchestratorAddressesAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSetOrchestratorAddresses
 */
export interface MsgSetOrchestratorAddressesAmino {
    sender: string;
    orchestrator: string;
    eth_address: string;
}
export interface MsgSetOrchestratorAddressesAminoMsg {
    type: "peggy/MsgSetOrchestratorAddresses";
    value: MsgSetOrchestratorAddressesAmino;
}
/**
 * @name MsgSetOrchestratorAddressesResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSetOrchestratorAddressesResponse
 */
export interface MsgSetOrchestratorAddressesResponse {
}
export interface MsgSetOrchestratorAddressesResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgSetOrchestratorAddressesResponse";
    value: Uint8Array;
}
/**
 * @name MsgSetOrchestratorAddressesResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSetOrchestratorAddressesResponse
 */
export interface MsgSetOrchestratorAddressesResponseAmino {
}
export interface MsgSetOrchestratorAddressesResponseAminoMsg {
    type: "/injective.peggy.v1.MsgSetOrchestratorAddressesResponse";
    value: MsgSetOrchestratorAddressesResponseAmino;
}
/**
 * MsgValsetConfirm
 * this is the message sent by the validators when they wish to submit their
 * signatures over the validator set at a given block height. A validator must
 * first call MsgSetEthAddress to set their Ethereum address to be used for
 * signing. Then someone (anyone) must make a ValsetRequest the request is
 * essentially a messaging mechanism to determine which block all validators
 * should submit signatures over. Finally validators sign the validator set,
 * powers, and Ethereum addresses of the entire validator set at the height of a
 * ValsetRequest and submit that signature with this message.
 *
 * If a sufficient number of validators (66% of voting power) (A) have set
 * Ethereum addresses and (B) submit ValsetConfirm messages with their
 * signatures it is then possible for anyone to view these signatures in the
 * chain store and submit them to Ethereum to update the validator set
 * -------------
 * @name MsgValsetConfirm
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetConfirm
 */
export interface MsgValsetConfirm {
    nonce: bigint;
    orchestrator: string;
    ethAddress: string;
    signature: string;
}
export interface MsgValsetConfirmProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgValsetConfirm";
    value: Uint8Array;
}
/**
 * MsgValsetConfirm
 * this is the message sent by the validators when they wish to submit their
 * signatures over the validator set at a given block height. A validator must
 * first call MsgSetEthAddress to set their Ethereum address to be used for
 * signing. Then someone (anyone) must make a ValsetRequest the request is
 * essentially a messaging mechanism to determine which block all validators
 * should submit signatures over. Finally validators sign the validator set,
 * powers, and Ethereum addresses of the entire validator set at the height of a
 * ValsetRequest and submit that signature with this message.
 *
 * If a sufficient number of validators (66% of voting power) (A) have set
 * Ethereum addresses and (B) submit ValsetConfirm messages with their
 * signatures it is then possible for anyone to view these signatures in the
 * chain store and submit them to Ethereum to update the validator set
 * -------------
 * @name MsgValsetConfirmAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetConfirm
 */
export interface MsgValsetConfirmAmino {
    nonce: string;
    orchestrator: string;
    eth_address: string;
    signature: string;
}
export interface MsgValsetConfirmAminoMsg {
    type: "peggy/MsgValsetConfirm";
    value: MsgValsetConfirmAmino;
}
/**
 * @name MsgValsetConfirmResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetConfirmResponse
 */
export interface MsgValsetConfirmResponse {
}
export interface MsgValsetConfirmResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgValsetConfirmResponse";
    value: Uint8Array;
}
/**
 * @name MsgValsetConfirmResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetConfirmResponse
 */
export interface MsgValsetConfirmResponseAmino {
}
export interface MsgValsetConfirmResponseAminoMsg {
    type: "/injective.peggy.v1.MsgValsetConfirmResponse";
    value: MsgValsetConfirmResponseAmino;
}
/**
 * MsgSendToEth
 * This is the message that a user calls when they want to bridge an asset
 * it will later be removed when it is included in a batch and successfully
 * submitted tokens are removed from the users balance immediately
 * -------------
 * AMOUNT:
 * the coin to send across the bridge, note the restriction that this is a
 * single coin not a set of coins that is normal in other Cosmos messages
 * FEE:
 * the fee paid for the bridge, distinct from the fee paid to the chain to
 * actually send this message in the first place. So a successful send has
 * two layers of fees for the user
 * @name MsgSendToEth
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSendToEth
 */
export interface MsgSendToEth {
    sender: string;
    ethDest: string;
    amount: Coin;
    bridgeFee: Coin;
}
export interface MsgSendToEthProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgSendToEth";
    value: Uint8Array;
}
/**
 * MsgSendToEth
 * This is the message that a user calls when they want to bridge an asset
 * it will later be removed when it is included in a batch and successfully
 * submitted tokens are removed from the users balance immediately
 * -------------
 * AMOUNT:
 * the coin to send across the bridge, note the restriction that this is a
 * single coin not a set of coins that is normal in other Cosmos messages
 * FEE:
 * the fee paid for the bridge, distinct from the fee paid to the chain to
 * actually send this message in the first place. So a successful send has
 * two layers of fees for the user
 * @name MsgSendToEthAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSendToEth
 */
export interface MsgSendToEthAmino {
    sender: string;
    eth_dest: string;
    amount: CoinAmino;
    bridge_fee: CoinAmino;
}
export interface MsgSendToEthAminoMsg {
    type: "peggy/MsgSendToEth";
    value: MsgSendToEthAmino;
}
/**
 * @name MsgSendToEthResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSendToEthResponse
 */
export interface MsgSendToEthResponse {
}
export interface MsgSendToEthResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgSendToEthResponse";
    value: Uint8Array;
}
/**
 * @name MsgSendToEthResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSendToEthResponse
 */
export interface MsgSendToEthResponseAmino {
}
export interface MsgSendToEthResponseAminoMsg {
    type: "/injective.peggy.v1.MsgSendToEthResponse";
    value: MsgSendToEthResponseAmino;
}
/**
 * MsgRequestBatch
 * this is a message anyone can send that requests a batch of transactions to
 * send across the bridge be created for whatever block height this message is
 * included in. This acts as a coordination point, the handler for this message
 * looks at the AddToOutgoingPool tx's in the store and generates a batch, also
 * available in the store tied to this message. The validators then grab this
 * batch, sign it, submit the signatures with a MsgConfirmBatch before a relayer
 * can finally submit the batch
 * -------------
 * @name MsgRequestBatch
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRequestBatch
 */
export interface MsgRequestBatch {
    orchestrator: string;
    denom: string;
}
export interface MsgRequestBatchProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgRequestBatch";
    value: Uint8Array;
}
/**
 * MsgRequestBatch
 * this is a message anyone can send that requests a batch of transactions to
 * send across the bridge be created for whatever block height this message is
 * included in. This acts as a coordination point, the handler for this message
 * looks at the AddToOutgoingPool tx's in the store and generates a batch, also
 * available in the store tied to this message. The validators then grab this
 * batch, sign it, submit the signatures with a MsgConfirmBatch before a relayer
 * can finally submit the batch
 * -------------
 * @name MsgRequestBatchAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRequestBatch
 */
export interface MsgRequestBatchAmino {
    orchestrator: string;
    denom: string;
}
export interface MsgRequestBatchAminoMsg {
    type: "peggy/MsgRequestBatch";
    value: MsgRequestBatchAmino;
}
/**
 * @name MsgRequestBatchResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRequestBatchResponse
 */
export interface MsgRequestBatchResponse {
}
export interface MsgRequestBatchResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgRequestBatchResponse";
    value: Uint8Array;
}
/**
 * @name MsgRequestBatchResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRequestBatchResponse
 */
export interface MsgRequestBatchResponseAmino {
}
export interface MsgRequestBatchResponseAminoMsg {
    type: "/injective.peggy.v1.MsgRequestBatchResponse";
    value: MsgRequestBatchResponseAmino;
}
/**
 * MsgConfirmBatch
 * When validators observe a MsgRequestBatch they form a batch by ordering
 * transactions currently in the txqueue in order of highest to lowest fee,
 * cutting off when the batch either reaches a hardcoded maximum size (to be
 * decided, probably around 100) or when transactions stop being profitable
 * (TODO determine this without nondeterminism) This message includes the batch
 * as well as an Ethereum signature over this batch by the validator
 * -------------
 * @name MsgConfirmBatch
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgConfirmBatch
 */
export interface MsgConfirmBatch {
    nonce: bigint;
    tokenContract: string;
    ethSigner: string;
    orchestrator: string;
    signature: string;
}
export interface MsgConfirmBatchProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgConfirmBatch";
    value: Uint8Array;
}
/**
 * MsgConfirmBatch
 * When validators observe a MsgRequestBatch they form a batch by ordering
 * transactions currently in the txqueue in order of highest to lowest fee,
 * cutting off when the batch either reaches a hardcoded maximum size (to be
 * decided, probably around 100) or when transactions stop being profitable
 * (TODO determine this without nondeterminism) This message includes the batch
 * as well as an Ethereum signature over this batch by the validator
 * -------------
 * @name MsgConfirmBatchAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgConfirmBatch
 */
export interface MsgConfirmBatchAmino {
    nonce: string;
    token_contract: string;
    eth_signer: string;
    orchestrator: string;
    signature: string;
}
export interface MsgConfirmBatchAminoMsg {
    type: "peggy/MsgConfirmBatch";
    value: MsgConfirmBatchAmino;
}
/**
 * @name MsgConfirmBatchResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgConfirmBatchResponse
 */
export interface MsgConfirmBatchResponse {
}
export interface MsgConfirmBatchResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgConfirmBatchResponse";
    value: Uint8Array;
}
/**
 * @name MsgConfirmBatchResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgConfirmBatchResponse
 */
export interface MsgConfirmBatchResponseAmino {
}
export interface MsgConfirmBatchResponseAminoMsg {
    type: "/injective.peggy.v1.MsgConfirmBatchResponse";
    value: MsgConfirmBatchResponseAmino;
}
/**
 * EthereumBridgeDepositClaim
 * When more than 66% of the active validator set has
 * claimed to have seen the deposit enter the ethereum blockchain coins are
 * issued to the Cosmos address in question
 * -------------
 * @name MsgDepositClaim
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgDepositClaim
 */
export interface MsgDepositClaim {
    eventNonce: bigint;
    blockHeight: bigint;
    tokenContract: string;
    amount: string;
    ethereumSender: string;
    cosmosReceiver: string;
    orchestrator: string;
    data: string;
}
export interface MsgDepositClaimProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgDepositClaim";
    value: Uint8Array;
}
/**
 * EthereumBridgeDepositClaim
 * When more than 66% of the active validator set has
 * claimed to have seen the deposit enter the ethereum blockchain coins are
 * issued to the Cosmos address in question
 * -------------
 * @name MsgDepositClaimAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgDepositClaim
 */
export interface MsgDepositClaimAmino {
    event_nonce: string;
    block_height: string;
    token_contract: string;
    amount: string;
    ethereum_sender: string;
    cosmos_receiver: string;
    orchestrator: string;
    data: string;
}
export interface MsgDepositClaimAminoMsg {
    type: "peggy/MsgDepositClaim";
    value: MsgDepositClaimAmino;
}
/**
 * @name MsgDepositClaimResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgDepositClaimResponse
 */
export interface MsgDepositClaimResponse {
}
export interface MsgDepositClaimResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgDepositClaimResponse";
    value: Uint8Array;
}
/**
 * @name MsgDepositClaimResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgDepositClaimResponse
 */
export interface MsgDepositClaimResponseAmino {
}
export interface MsgDepositClaimResponseAminoMsg {
    type: "/injective.peggy.v1.MsgDepositClaimResponse";
    value: MsgDepositClaimResponseAmino;
}
/**
 * WithdrawClaim claims that a batch of withdrawal
 * operations on the bridge contract was executed.
 * @name MsgWithdrawClaim
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgWithdrawClaim
 */
export interface MsgWithdrawClaim {
    eventNonce: bigint;
    blockHeight: bigint;
    batchNonce: bigint;
    tokenContract: string;
    orchestrator: string;
}
export interface MsgWithdrawClaimProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgWithdrawClaim";
    value: Uint8Array;
}
/**
 * WithdrawClaim claims that a batch of withdrawal
 * operations on the bridge contract was executed.
 * @name MsgWithdrawClaimAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgWithdrawClaim
 */
export interface MsgWithdrawClaimAmino {
    event_nonce: string;
    block_height: string;
    batch_nonce: string;
    token_contract: string;
    orchestrator: string;
}
export interface MsgWithdrawClaimAminoMsg {
    type: "peggy/MsgWithdrawClaim";
    value: MsgWithdrawClaimAmino;
}
/**
 * @name MsgWithdrawClaimResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgWithdrawClaimResponse
 */
export interface MsgWithdrawClaimResponse {
}
export interface MsgWithdrawClaimResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgWithdrawClaimResponse";
    value: Uint8Array;
}
/**
 * @name MsgWithdrawClaimResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgWithdrawClaimResponse
 */
export interface MsgWithdrawClaimResponseAmino {
}
export interface MsgWithdrawClaimResponseAminoMsg {
    type: "/injective.peggy.v1.MsgWithdrawClaimResponse";
    value: MsgWithdrawClaimResponseAmino;
}
/**
 * ERC20DeployedClaim allows the Cosmos module
 * to learn about an ERC20 that someone deployed
 * to represent a Cosmos asset
 * @name MsgERC20DeployedClaim
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgERC20DeployedClaim
 */
export interface MsgERC20DeployedClaim {
    eventNonce: bigint;
    blockHeight: bigint;
    cosmosDenom: string;
    tokenContract: string;
    name: string;
    symbol: string;
    decimals: bigint;
    orchestrator: string;
}
export interface MsgERC20DeployedClaimProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgERC20DeployedClaim";
    value: Uint8Array;
}
/**
 * ERC20DeployedClaim allows the Cosmos module
 * to learn about an ERC20 that someone deployed
 * to represent a Cosmos asset
 * @name MsgERC20DeployedClaimAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgERC20DeployedClaim
 */
export interface MsgERC20DeployedClaimAmino {
    event_nonce: string;
    block_height: string;
    cosmos_denom: string;
    token_contract: string;
    name: string;
    symbol: string;
    decimals: string;
    orchestrator: string;
}
export interface MsgERC20DeployedClaimAminoMsg {
    type: "peggy/MsgERC20DeployedClaim";
    value: MsgERC20DeployedClaimAmino;
}
/**
 * @name MsgERC20DeployedClaimResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgERC20DeployedClaimResponse
 */
export interface MsgERC20DeployedClaimResponse {
}
export interface MsgERC20DeployedClaimResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgERC20DeployedClaimResponse";
    value: Uint8Array;
}
/**
 * @name MsgERC20DeployedClaimResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgERC20DeployedClaimResponse
 */
export interface MsgERC20DeployedClaimResponseAmino {
}
export interface MsgERC20DeployedClaimResponseAminoMsg {
    type: "/injective.peggy.v1.MsgERC20DeployedClaimResponse";
    value: MsgERC20DeployedClaimResponseAmino;
}
/**
 * This call allows the sender (and only the sender)
 * to cancel a given MsgSendToEth and recieve a refund
 * of the tokens
 * @name MsgCancelSendToEth
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgCancelSendToEth
 */
export interface MsgCancelSendToEth {
    transactionId: bigint;
    sender: string;
}
export interface MsgCancelSendToEthProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgCancelSendToEth";
    value: Uint8Array;
}
/**
 * This call allows the sender (and only the sender)
 * to cancel a given MsgSendToEth and recieve a refund
 * of the tokens
 * @name MsgCancelSendToEthAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgCancelSendToEth
 */
export interface MsgCancelSendToEthAmino {
    transaction_id: string;
    sender: string;
}
export interface MsgCancelSendToEthAminoMsg {
    type: "peggy/MsgCancelSendToEth";
    value: MsgCancelSendToEthAmino;
}
/**
 * @name MsgCancelSendToEthResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgCancelSendToEthResponse
 */
export interface MsgCancelSendToEthResponse {
}
export interface MsgCancelSendToEthResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgCancelSendToEthResponse";
    value: Uint8Array;
}
/**
 * @name MsgCancelSendToEthResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgCancelSendToEthResponse
 */
export interface MsgCancelSendToEthResponseAmino {
}
export interface MsgCancelSendToEthResponseAminoMsg {
    type: "/injective.peggy.v1.MsgCancelSendToEthResponse";
    value: MsgCancelSendToEthResponseAmino;
}
/**
 * This call allows anyone to submit evidence that a
 * validator has signed a valset, batch, or logic call that never
 * existed. Subject contains the batch, valset, or logic call.
 * @name MsgSubmitBadSignatureEvidence
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSubmitBadSignatureEvidence
 */
export interface MsgSubmitBadSignatureEvidence {
    subject?: Any;
    signature: string;
    sender: string;
}
export interface MsgSubmitBadSignatureEvidenceProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgSubmitBadSignatureEvidence";
    value: Uint8Array;
}
/**
 * This call allows anyone to submit evidence that a
 * validator has signed a valset, batch, or logic call that never
 * existed. Subject contains the batch, valset, or logic call.
 * @name MsgSubmitBadSignatureEvidenceAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSubmitBadSignatureEvidence
 */
export interface MsgSubmitBadSignatureEvidenceAmino {
    subject?: AnyAmino;
    signature: string;
    sender: string;
}
export interface MsgSubmitBadSignatureEvidenceAminoMsg {
    type: "peggy/MsgSubmitBadSignatureEvidence";
    value: MsgSubmitBadSignatureEvidenceAmino;
}
/**
 * @name MsgSubmitBadSignatureEvidenceResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSubmitBadSignatureEvidenceResponse
 */
export interface MsgSubmitBadSignatureEvidenceResponse {
}
export interface MsgSubmitBadSignatureEvidenceResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgSubmitBadSignatureEvidenceResponse";
    value: Uint8Array;
}
/**
 * @name MsgSubmitBadSignatureEvidenceResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSubmitBadSignatureEvidenceResponse
 */
export interface MsgSubmitBadSignatureEvidenceResponseAmino {
}
export interface MsgSubmitBadSignatureEvidenceResponseAminoMsg {
    type: "/injective.peggy.v1.MsgSubmitBadSignatureEvidenceResponse";
    value: MsgSubmitBadSignatureEvidenceResponseAmino;
}
/**
 * This informs the Cosmos module that a validator
 * set has been updated.
 * @name MsgValsetUpdatedClaim
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetUpdatedClaim
 */
export interface MsgValsetUpdatedClaim {
    eventNonce: bigint;
    valsetNonce: bigint;
    blockHeight: bigint;
    members: BridgeValidator[];
    rewardAmount: string;
    rewardToken: string;
    orchestrator: string;
}
export interface MsgValsetUpdatedClaimProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgValsetUpdatedClaim";
    value: Uint8Array;
}
/**
 * This informs the Cosmos module that a validator
 * set has been updated.
 * @name MsgValsetUpdatedClaimAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetUpdatedClaim
 */
export interface MsgValsetUpdatedClaimAmino {
    event_nonce: string;
    valset_nonce: string;
    block_height: string;
    members: BridgeValidatorAmino[];
    reward_amount: string;
    reward_token: string;
    orchestrator: string;
}
export interface MsgValsetUpdatedClaimAminoMsg {
    type: "peggy/MsgValsetUpdatedClaim";
    value: MsgValsetUpdatedClaimAmino;
}
/**
 * @name MsgValsetUpdatedClaimResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetUpdatedClaimResponse
 */
export interface MsgValsetUpdatedClaimResponse {
}
export interface MsgValsetUpdatedClaimResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgValsetUpdatedClaimResponse";
    value: Uint8Array;
}
/**
 * @name MsgValsetUpdatedClaimResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetUpdatedClaimResponse
 */
export interface MsgValsetUpdatedClaimResponseAmino {
}
export interface MsgValsetUpdatedClaimResponseAminoMsg {
    type: "/injective.peggy.v1.MsgValsetUpdatedClaimResponse";
    value: MsgValsetUpdatedClaimResponseAmino;
}
/**
 * @name MsgUpdateParams
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgUpdateParams
 */
export interface MsgUpdateParams {
    /**
     * authority is the address of the governance account.
     */
    authority: string;
    /**
     * params defines the peggy parameters to update.
     *
     * NOTE: All parameters must be supplied.
     */
    params: Params;
}
export interface MsgUpdateParamsProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgUpdateParams";
    value: Uint8Array;
}
/**
 * @name MsgUpdateParamsAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgUpdateParams
 */
export interface MsgUpdateParamsAmino {
    /**
     * authority is the address of the governance account.
     */
    authority: string;
    /**
     * params defines the peggy parameters to update.
     *
     * NOTE: All parameters must be supplied.
     */
    params: ParamsAmino;
}
export interface MsgUpdateParamsAminoMsg {
    type: "peggy/MsgUpdateParams";
    value: MsgUpdateParamsAmino;
}
/**
 * @name MsgUpdateParamsResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgUpdateParamsResponse
 */
export interface MsgUpdateParamsResponse {
}
export interface MsgUpdateParamsResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgUpdateParamsResponse";
    value: Uint8Array;
}
/**
 * @name MsgUpdateParamsResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgUpdateParamsResponse
 */
export interface MsgUpdateParamsResponseAmino {
}
export interface MsgUpdateParamsResponseAminoMsg {
    type: "/injective.peggy.v1.MsgUpdateParamsResponse";
    value: MsgUpdateParamsResponseAmino;
}
/**
 * MsgBlacklistEthereumAddresses defines the message used to add Ethereum
 * addresses to peggy blacklist.
 * @name MsgBlacklistEthereumAddresses
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgBlacklistEthereumAddresses
 */
export interface MsgBlacklistEthereumAddresses {
    /**
     * signer address
     */
    signer: string;
    /**
     * Ethereum addresses to include in the blacklist
     */
    blacklistAddresses: string[];
}
export interface MsgBlacklistEthereumAddressesProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgBlacklistEthereumAddresses";
    value: Uint8Array;
}
/**
 * MsgBlacklistEthereumAddresses defines the message used to add Ethereum
 * addresses to peggy blacklist.
 * @name MsgBlacklistEthereumAddressesAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgBlacklistEthereumAddresses
 */
export interface MsgBlacklistEthereumAddressesAmino {
    /**
     * signer address
     */
    signer: string;
    /**
     * Ethereum addresses to include in the blacklist
     */
    blacklist_addresses: string[];
}
export interface MsgBlacklistEthereumAddressesAminoMsg {
    type: "peggy/MsgBlacklistEthereumAddresses";
    value: MsgBlacklistEthereumAddressesAmino;
}
/**
 * MsgBlacklistEthereumAddressesResponse defines the
 * MsgBlacklistEthereumAddresses response type.
 * @name MsgBlacklistEthereumAddressesResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgBlacklistEthereumAddressesResponse
 */
export interface MsgBlacklistEthereumAddressesResponse {
}
export interface MsgBlacklistEthereumAddressesResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgBlacklistEthereumAddressesResponse";
    value: Uint8Array;
}
/**
 * MsgBlacklistEthereumAddressesResponse defines the
 * MsgBlacklistEthereumAddresses response type.
 * @name MsgBlacklistEthereumAddressesResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgBlacklistEthereumAddressesResponse
 */
export interface MsgBlacklistEthereumAddressesResponseAmino {
}
export interface MsgBlacklistEthereumAddressesResponseAminoMsg {
    type: "/injective.peggy.v1.MsgBlacklistEthereumAddressesResponse";
    value: MsgBlacklistEthereumAddressesResponseAmino;
}
/**
 * MsgRevokeEthereumBlacklist defines the message used to remove Ethereum
 * addresses from peggy blacklist.
 * @name MsgRevokeEthereumBlacklist
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRevokeEthereumBlacklist
 */
export interface MsgRevokeEthereumBlacklist {
    /**
     * signer address
     */
    signer: string;
    /**
     * Ethereum addresses to include in the blacklist
     */
    blacklistAddresses: string[];
}
export interface MsgRevokeEthereumBlacklistProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgRevokeEthereumBlacklist";
    value: Uint8Array;
}
/**
 * MsgRevokeEthereumBlacklist defines the message used to remove Ethereum
 * addresses from peggy blacklist.
 * @name MsgRevokeEthereumBlacklistAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRevokeEthereumBlacklist
 */
export interface MsgRevokeEthereumBlacklistAmino {
    /**
     * signer address
     */
    signer: string;
    /**
     * Ethereum addresses to include in the blacklist
     */
    blacklist_addresses: string[];
}
export interface MsgRevokeEthereumBlacklistAminoMsg {
    type: "peggy/MsgRevokeEthereumBlacklist";
    value: MsgRevokeEthereumBlacklistAmino;
}
/**
 * MsgRevokeEthereumBlacklistResponse defines the MsgRevokeEthereumBlacklist
 * response type.
 * @name MsgRevokeEthereumBlacklistResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRevokeEthereumBlacklistResponse
 */
export interface MsgRevokeEthereumBlacklistResponse {
}
export interface MsgRevokeEthereumBlacklistResponseProtoMsg {
    typeUrl: "/injective.peggy.v1.MsgRevokeEthereumBlacklistResponse";
    value: Uint8Array;
}
/**
 * MsgRevokeEthereumBlacklistResponse defines the MsgRevokeEthereumBlacklist
 * response type.
 * @name MsgRevokeEthereumBlacklistResponseAmino
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRevokeEthereumBlacklistResponse
 */
export interface MsgRevokeEthereumBlacklistResponseAmino {
}
export interface MsgRevokeEthereumBlacklistResponseAminoMsg {
    type: "/injective.peggy.v1.MsgRevokeEthereumBlacklistResponse";
    value: MsgRevokeEthereumBlacklistResponseAmino;
}
/**
 * MsgSetOrchestratorAddresses
 * this message allows validators to delegate their voting responsibilities
 * to a given key. This key is then used as an optional authentication method
 * for sigining oracle claims
 * VALIDATOR
 * The validator field is a cosmosvaloper1... string (i.e. sdk.ValAddress)
 * that references a validator in the active set
 * ORCHESTRATOR
 * The orchestrator field is a cosmos1... string  (i.e. sdk.AccAddress) that
 * references the key that is being delegated to
 * ETH_ADDRESS
 * This is a hex encoded 0x Ethereum public key that will be used by this
 * validator on Ethereum
 * @name MsgSetOrchestratorAddresses
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSetOrchestratorAddresses
 */
export declare const MsgSetOrchestratorAddresses: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgSetOrchestratorAddresses;
    isAmino(o: any): o is MsgSetOrchestratorAddressesAmino;
    encode(message: MsgSetOrchestratorAddresses, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSetOrchestratorAddresses;
    fromPartial(object: DeepPartial<MsgSetOrchestratorAddresses>): MsgSetOrchestratorAddresses;
    fromAmino(object: MsgSetOrchestratorAddressesAmino): MsgSetOrchestratorAddresses;
    toAmino(message: MsgSetOrchestratorAddresses): MsgSetOrchestratorAddressesAmino;
    fromAminoMsg(object: MsgSetOrchestratorAddressesAminoMsg): MsgSetOrchestratorAddresses;
    toAminoMsg(message: MsgSetOrchestratorAddresses): MsgSetOrchestratorAddressesAminoMsg;
    fromProtoMsg(message: MsgSetOrchestratorAddressesProtoMsg): MsgSetOrchestratorAddresses;
    toProto(message: MsgSetOrchestratorAddresses): Uint8Array;
    toProtoMsg(message: MsgSetOrchestratorAddresses): MsgSetOrchestratorAddressesProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgSetOrchestratorAddressesResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSetOrchestratorAddressesResponse
 */
export declare const MsgSetOrchestratorAddressesResponse: {
    typeUrl: string;
    is(o: any): o is MsgSetOrchestratorAddressesResponse;
    isAmino(o: any): o is MsgSetOrchestratorAddressesResponseAmino;
    encode(_: MsgSetOrchestratorAddressesResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSetOrchestratorAddressesResponse;
    fromPartial(_: DeepPartial<MsgSetOrchestratorAddressesResponse>): MsgSetOrchestratorAddressesResponse;
    fromAmino(_: MsgSetOrchestratorAddressesResponseAmino): MsgSetOrchestratorAddressesResponse;
    toAmino(_: MsgSetOrchestratorAddressesResponse): MsgSetOrchestratorAddressesResponseAmino;
    fromAminoMsg(object: MsgSetOrchestratorAddressesResponseAminoMsg): MsgSetOrchestratorAddressesResponse;
    fromProtoMsg(message: MsgSetOrchestratorAddressesResponseProtoMsg): MsgSetOrchestratorAddressesResponse;
    toProto(message: MsgSetOrchestratorAddressesResponse): Uint8Array;
    toProtoMsg(message: MsgSetOrchestratorAddressesResponse): MsgSetOrchestratorAddressesResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * MsgValsetConfirm
 * this is the message sent by the validators when they wish to submit their
 * signatures over the validator set at a given block height. A validator must
 * first call MsgSetEthAddress to set their Ethereum address to be used for
 * signing. Then someone (anyone) must make a ValsetRequest the request is
 * essentially a messaging mechanism to determine which block all validators
 * should submit signatures over. Finally validators sign the validator set,
 * powers, and Ethereum addresses of the entire validator set at the height of a
 * ValsetRequest and submit that signature with this message.
 *
 * If a sufficient number of validators (66% of voting power) (A) have set
 * Ethereum addresses and (B) submit ValsetConfirm messages with their
 * signatures it is then possible for anyone to view these signatures in the
 * chain store and submit them to Ethereum to update the validator set
 * -------------
 * @name MsgValsetConfirm
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetConfirm
 */
export declare const MsgValsetConfirm: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgValsetConfirm;
    isAmino(o: any): o is MsgValsetConfirmAmino;
    encode(message: MsgValsetConfirm, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgValsetConfirm;
    fromPartial(object: DeepPartial<MsgValsetConfirm>): MsgValsetConfirm;
    fromAmino(object: MsgValsetConfirmAmino): MsgValsetConfirm;
    toAmino(message: MsgValsetConfirm): MsgValsetConfirmAmino;
    fromAminoMsg(object: MsgValsetConfirmAminoMsg): MsgValsetConfirm;
    toAminoMsg(message: MsgValsetConfirm): MsgValsetConfirmAminoMsg;
    fromProtoMsg(message: MsgValsetConfirmProtoMsg): MsgValsetConfirm;
    toProto(message: MsgValsetConfirm): Uint8Array;
    toProtoMsg(message: MsgValsetConfirm): MsgValsetConfirmProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgValsetConfirmResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetConfirmResponse
 */
export declare const MsgValsetConfirmResponse: {
    typeUrl: string;
    is(o: any): o is MsgValsetConfirmResponse;
    isAmino(o: any): o is MsgValsetConfirmResponseAmino;
    encode(_: MsgValsetConfirmResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgValsetConfirmResponse;
    fromPartial(_: DeepPartial<MsgValsetConfirmResponse>): MsgValsetConfirmResponse;
    fromAmino(_: MsgValsetConfirmResponseAmino): MsgValsetConfirmResponse;
    toAmino(_: MsgValsetConfirmResponse): MsgValsetConfirmResponseAmino;
    fromAminoMsg(object: MsgValsetConfirmResponseAminoMsg): MsgValsetConfirmResponse;
    fromProtoMsg(message: MsgValsetConfirmResponseProtoMsg): MsgValsetConfirmResponse;
    toProto(message: MsgValsetConfirmResponse): Uint8Array;
    toProtoMsg(message: MsgValsetConfirmResponse): MsgValsetConfirmResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * MsgSendToEth
 * This is the message that a user calls when they want to bridge an asset
 * it will later be removed when it is included in a batch and successfully
 * submitted tokens are removed from the users balance immediately
 * -------------
 * AMOUNT:
 * the coin to send across the bridge, note the restriction that this is a
 * single coin not a set of coins that is normal in other Cosmos messages
 * FEE:
 * the fee paid for the bridge, distinct from the fee paid to the chain to
 * actually send this message in the first place. So a successful send has
 * two layers of fees for the user
 * @name MsgSendToEth
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSendToEth
 */
export declare const MsgSendToEth: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgSendToEth;
    isAmino(o: any): o is MsgSendToEthAmino;
    encode(message: MsgSendToEth, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSendToEth;
    fromPartial(object: DeepPartial<MsgSendToEth>): MsgSendToEth;
    fromAmino(object: MsgSendToEthAmino): MsgSendToEth;
    toAmino(message: MsgSendToEth): MsgSendToEthAmino;
    fromAminoMsg(object: MsgSendToEthAminoMsg): MsgSendToEth;
    toAminoMsg(message: MsgSendToEth): MsgSendToEthAminoMsg;
    fromProtoMsg(message: MsgSendToEthProtoMsg): MsgSendToEth;
    toProto(message: MsgSendToEth): Uint8Array;
    toProtoMsg(message: MsgSendToEth): MsgSendToEthProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgSendToEthResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSendToEthResponse
 */
export declare const MsgSendToEthResponse: {
    typeUrl: string;
    is(o: any): o is MsgSendToEthResponse;
    isAmino(o: any): o is MsgSendToEthResponseAmino;
    encode(_: MsgSendToEthResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSendToEthResponse;
    fromPartial(_: DeepPartial<MsgSendToEthResponse>): MsgSendToEthResponse;
    fromAmino(_: MsgSendToEthResponseAmino): MsgSendToEthResponse;
    toAmino(_: MsgSendToEthResponse): MsgSendToEthResponseAmino;
    fromAminoMsg(object: MsgSendToEthResponseAminoMsg): MsgSendToEthResponse;
    fromProtoMsg(message: MsgSendToEthResponseProtoMsg): MsgSendToEthResponse;
    toProto(message: MsgSendToEthResponse): Uint8Array;
    toProtoMsg(message: MsgSendToEthResponse): MsgSendToEthResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * MsgRequestBatch
 * this is a message anyone can send that requests a batch of transactions to
 * send across the bridge be created for whatever block height this message is
 * included in. This acts as a coordination point, the handler for this message
 * looks at the AddToOutgoingPool tx's in the store and generates a batch, also
 * available in the store tied to this message. The validators then grab this
 * batch, sign it, submit the signatures with a MsgConfirmBatch before a relayer
 * can finally submit the batch
 * -------------
 * @name MsgRequestBatch
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRequestBatch
 */
export declare const MsgRequestBatch: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgRequestBatch;
    isAmino(o: any): o is MsgRequestBatchAmino;
    encode(message: MsgRequestBatch, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgRequestBatch;
    fromPartial(object: DeepPartial<MsgRequestBatch>): MsgRequestBatch;
    fromAmino(object: MsgRequestBatchAmino): MsgRequestBatch;
    toAmino(message: MsgRequestBatch): MsgRequestBatchAmino;
    fromAminoMsg(object: MsgRequestBatchAminoMsg): MsgRequestBatch;
    toAminoMsg(message: MsgRequestBatch): MsgRequestBatchAminoMsg;
    fromProtoMsg(message: MsgRequestBatchProtoMsg): MsgRequestBatch;
    toProto(message: MsgRequestBatch): Uint8Array;
    toProtoMsg(message: MsgRequestBatch): MsgRequestBatchProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgRequestBatchResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRequestBatchResponse
 */
export declare const MsgRequestBatchResponse: {
    typeUrl: string;
    is(o: any): o is MsgRequestBatchResponse;
    isAmino(o: any): o is MsgRequestBatchResponseAmino;
    encode(_: MsgRequestBatchResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgRequestBatchResponse;
    fromPartial(_: DeepPartial<MsgRequestBatchResponse>): MsgRequestBatchResponse;
    fromAmino(_: MsgRequestBatchResponseAmino): MsgRequestBatchResponse;
    toAmino(_: MsgRequestBatchResponse): MsgRequestBatchResponseAmino;
    fromAminoMsg(object: MsgRequestBatchResponseAminoMsg): MsgRequestBatchResponse;
    fromProtoMsg(message: MsgRequestBatchResponseProtoMsg): MsgRequestBatchResponse;
    toProto(message: MsgRequestBatchResponse): Uint8Array;
    toProtoMsg(message: MsgRequestBatchResponse): MsgRequestBatchResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * MsgConfirmBatch
 * When validators observe a MsgRequestBatch they form a batch by ordering
 * transactions currently in the txqueue in order of highest to lowest fee,
 * cutting off when the batch either reaches a hardcoded maximum size (to be
 * decided, probably around 100) or when transactions stop being profitable
 * (TODO determine this without nondeterminism) This message includes the batch
 * as well as an Ethereum signature over this batch by the validator
 * -------------
 * @name MsgConfirmBatch
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgConfirmBatch
 */
export declare const MsgConfirmBatch: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgConfirmBatch;
    isAmino(o: any): o is MsgConfirmBatchAmino;
    encode(message: MsgConfirmBatch, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgConfirmBatch;
    fromPartial(object: DeepPartial<MsgConfirmBatch>): MsgConfirmBatch;
    fromAmino(object: MsgConfirmBatchAmino): MsgConfirmBatch;
    toAmino(message: MsgConfirmBatch): MsgConfirmBatchAmino;
    fromAminoMsg(object: MsgConfirmBatchAminoMsg): MsgConfirmBatch;
    toAminoMsg(message: MsgConfirmBatch): MsgConfirmBatchAminoMsg;
    fromProtoMsg(message: MsgConfirmBatchProtoMsg): MsgConfirmBatch;
    toProto(message: MsgConfirmBatch): Uint8Array;
    toProtoMsg(message: MsgConfirmBatch): MsgConfirmBatchProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgConfirmBatchResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgConfirmBatchResponse
 */
export declare const MsgConfirmBatchResponse: {
    typeUrl: string;
    is(o: any): o is MsgConfirmBatchResponse;
    isAmino(o: any): o is MsgConfirmBatchResponseAmino;
    encode(_: MsgConfirmBatchResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgConfirmBatchResponse;
    fromPartial(_: DeepPartial<MsgConfirmBatchResponse>): MsgConfirmBatchResponse;
    fromAmino(_: MsgConfirmBatchResponseAmino): MsgConfirmBatchResponse;
    toAmino(_: MsgConfirmBatchResponse): MsgConfirmBatchResponseAmino;
    fromAminoMsg(object: MsgConfirmBatchResponseAminoMsg): MsgConfirmBatchResponse;
    fromProtoMsg(message: MsgConfirmBatchResponseProtoMsg): MsgConfirmBatchResponse;
    toProto(message: MsgConfirmBatchResponse): Uint8Array;
    toProtoMsg(message: MsgConfirmBatchResponse): MsgConfirmBatchResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EthereumBridgeDepositClaim
 * When more than 66% of the active validator set has
 * claimed to have seen the deposit enter the ethereum blockchain coins are
 * issued to the Cosmos address in question
 * -------------
 * @name MsgDepositClaim
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgDepositClaim
 */
export declare const MsgDepositClaim: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgDepositClaim;
    isAmino(o: any): o is MsgDepositClaimAmino;
    encode(message: MsgDepositClaim, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgDepositClaim;
    fromPartial(object: DeepPartial<MsgDepositClaim>): MsgDepositClaim;
    fromAmino(object: MsgDepositClaimAmino): MsgDepositClaim;
    toAmino(message: MsgDepositClaim): MsgDepositClaimAmino;
    fromAminoMsg(object: MsgDepositClaimAminoMsg): MsgDepositClaim;
    toAminoMsg(message: MsgDepositClaim): MsgDepositClaimAminoMsg;
    fromProtoMsg(message: MsgDepositClaimProtoMsg): MsgDepositClaim;
    toProto(message: MsgDepositClaim): Uint8Array;
    toProtoMsg(message: MsgDepositClaim): MsgDepositClaimProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgDepositClaimResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgDepositClaimResponse
 */
export declare const MsgDepositClaimResponse: {
    typeUrl: string;
    is(o: any): o is MsgDepositClaimResponse;
    isAmino(o: any): o is MsgDepositClaimResponseAmino;
    encode(_: MsgDepositClaimResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgDepositClaimResponse;
    fromPartial(_: DeepPartial<MsgDepositClaimResponse>): MsgDepositClaimResponse;
    fromAmino(_: MsgDepositClaimResponseAmino): MsgDepositClaimResponse;
    toAmino(_: MsgDepositClaimResponse): MsgDepositClaimResponseAmino;
    fromAminoMsg(object: MsgDepositClaimResponseAminoMsg): MsgDepositClaimResponse;
    fromProtoMsg(message: MsgDepositClaimResponseProtoMsg): MsgDepositClaimResponse;
    toProto(message: MsgDepositClaimResponse): Uint8Array;
    toProtoMsg(message: MsgDepositClaimResponse): MsgDepositClaimResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * WithdrawClaim claims that a batch of withdrawal
 * operations on the bridge contract was executed.
 * @name MsgWithdrawClaim
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgWithdrawClaim
 */
export declare const MsgWithdrawClaim: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgWithdrawClaim;
    isAmino(o: any): o is MsgWithdrawClaimAmino;
    encode(message: MsgWithdrawClaim, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgWithdrawClaim;
    fromPartial(object: DeepPartial<MsgWithdrawClaim>): MsgWithdrawClaim;
    fromAmino(object: MsgWithdrawClaimAmino): MsgWithdrawClaim;
    toAmino(message: MsgWithdrawClaim): MsgWithdrawClaimAmino;
    fromAminoMsg(object: MsgWithdrawClaimAminoMsg): MsgWithdrawClaim;
    toAminoMsg(message: MsgWithdrawClaim): MsgWithdrawClaimAminoMsg;
    fromProtoMsg(message: MsgWithdrawClaimProtoMsg): MsgWithdrawClaim;
    toProto(message: MsgWithdrawClaim): Uint8Array;
    toProtoMsg(message: MsgWithdrawClaim): MsgWithdrawClaimProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgWithdrawClaimResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgWithdrawClaimResponse
 */
export declare const MsgWithdrawClaimResponse: {
    typeUrl: string;
    is(o: any): o is MsgWithdrawClaimResponse;
    isAmino(o: any): o is MsgWithdrawClaimResponseAmino;
    encode(_: MsgWithdrawClaimResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgWithdrawClaimResponse;
    fromPartial(_: DeepPartial<MsgWithdrawClaimResponse>): MsgWithdrawClaimResponse;
    fromAmino(_: MsgWithdrawClaimResponseAmino): MsgWithdrawClaimResponse;
    toAmino(_: MsgWithdrawClaimResponse): MsgWithdrawClaimResponseAmino;
    fromAminoMsg(object: MsgWithdrawClaimResponseAminoMsg): MsgWithdrawClaimResponse;
    fromProtoMsg(message: MsgWithdrawClaimResponseProtoMsg): MsgWithdrawClaimResponse;
    toProto(message: MsgWithdrawClaimResponse): Uint8Array;
    toProtoMsg(message: MsgWithdrawClaimResponse): MsgWithdrawClaimResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * ERC20DeployedClaim allows the Cosmos module
 * to learn about an ERC20 that someone deployed
 * to represent a Cosmos asset
 * @name MsgERC20DeployedClaim
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgERC20DeployedClaim
 */
export declare const MsgERC20DeployedClaim: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgERC20DeployedClaim;
    isAmino(o: any): o is MsgERC20DeployedClaimAmino;
    encode(message: MsgERC20DeployedClaim, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgERC20DeployedClaim;
    fromPartial(object: DeepPartial<MsgERC20DeployedClaim>): MsgERC20DeployedClaim;
    fromAmino(object: MsgERC20DeployedClaimAmino): MsgERC20DeployedClaim;
    toAmino(message: MsgERC20DeployedClaim): MsgERC20DeployedClaimAmino;
    fromAminoMsg(object: MsgERC20DeployedClaimAminoMsg): MsgERC20DeployedClaim;
    toAminoMsg(message: MsgERC20DeployedClaim): MsgERC20DeployedClaimAminoMsg;
    fromProtoMsg(message: MsgERC20DeployedClaimProtoMsg): MsgERC20DeployedClaim;
    toProto(message: MsgERC20DeployedClaim): Uint8Array;
    toProtoMsg(message: MsgERC20DeployedClaim): MsgERC20DeployedClaimProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgERC20DeployedClaimResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgERC20DeployedClaimResponse
 */
export declare const MsgERC20DeployedClaimResponse: {
    typeUrl: string;
    is(o: any): o is MsgERC20DeployedClaimResponse;
    isAmino(o: any): o is MsgERC20DeployedClaimResponseAmino;
    encode(_: MsgERC20DeployedClaimResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgERC20DeployedClaimResponse;
    fromPartial(_: DeepPartial<MsgERC20DeployedClaimResponse>): MsgERC20DeployedClaimResponse;
    fromAmino(_: MsgERC20DeployedClaimResponseAmino): MsgERC20DeployedClaimResponse;
    toAmino(_: MsgERC20DeployedClaimResponse): MsgERC20DeployedClaimResponseAmino;
    fromAminoMsg(object: MsgERC20DeployedClaimResponseAminoMsg): MsgERC20DeployedClaimResponse;
    fromProtoMsg(message: MsgERC20DeployedClaimResponseProtoMsg): MsgERC20DeployedClaimResponse;
    toProto(message: MsgERC20DeployedClaimResponse): Uint8Array;
    toProtoMsg(message: MsgERC20DeployedClaimResponse): MsgERC20DeployedClaimResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * This call allows the sender (and only the sender)
 * to cancel a given MsgSendToEth and recieve a refund
 * of the tokens
 * @name MsgCancelSendToEth
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgCancelSendToEth
 */
export declare const MsgCancelSendToEth: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgCancelSendToEth;
    isAmino(o: any): o is MsgCancelSendToEthAmino;
    encode(message: MsgCancelSendToEth, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgCancelSendToEth;
    fromPartial(object: DeepPartial<MsgCancelSendToEth>): MsgCancelSendToEth;
    fromAmino(object: MsgCancelSendToEthAmino): MsgCancelSendToEth;
    toAmino(message: MsgCancelSendToEth): MsgCancelSendToEthAmino;
    fromAminoMsg(object: MsgCancelSendToEthAminoMsg): MsgCancelSendToEth;
    toAminoMsg(message: MsgCancelSendToEth): MsgCancelSendToEthAminoMsg;
    fromProtoMsg(message: MsgCancelSendToEthProtoMsg): MsgCancelSendToEth;
    toProto(message: MsgCancelSendToEth): Uint8Array;
    toProtoMsg(message: MsgCancelSendToEth): MsgCancelSendToEthProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgCancelSendToEthResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgCancelSendToEthResponse
 */
export declare const MsgCancelSendToEthResponse: {
    typeUrl: string;
    is(o: any): o is MsgCancelSendToEthResponse;
    isAmino(o: any): o is MsgCancelSendToEthResponseAmino;
    encode(_: MsgCancelSendToEthResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgCancelSendToEthResponse;
    fromPartial(_: DeepPartial<MsgCancelSendToEthResponse>): MsgCancelSendToEthResponse;
    fromAmino(_: MsgCancelSendToEthResponseAmino): MsgCancelSendToEthResponse;
    toAmino(_: MsgCancelSendToEthResponse): MsgCancelSendToEthResponseAmino;
    fromAminoMsg(object: MsgCancelSendToEthResponseAminoMsg): MsgCancelSendToEthResponse;
    fromProtoMsg(message: MsgCancelSendToEthResponseProtoMsg): MsgCancelSendToEthResponse;
    toProto(message: MsgCancelSendToEthResponse): Uint8Array;
    toProtoMsg(message: MsgCancelSendToEthResponse): MsgCancelSendToEthResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * This call allows anyone to submit evidence that a
 * validator has signed a valset, batch, or logic call that never
 * existed. Subject contains the batch, valset, or logic call.
 * @name MsgSubmitBadSignatureEvidence
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSubmitBadSignatureEvidence
 */
export declare const MsgSubmitBadSignatureEvidence: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgSubmitBadSignatureEvidence;
    isAmino(o: any): o is MsgSubmitBadSignatureEvidenceAmino;
    encode(message: MsgSubmitBadSignatureEvidence, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSubmitBadSignatureEvidence;
    fromPartial(object: DeepPartial<MsgSubmitBadSignatureEvidence>): MsgSubmitBadSignatureEvidence;
    fromAmino(object: MsgSubmitBadSignatureEvidenceAmino): MsgSubmitBadSignatureEvidence;
    toAmino(message: MsgSubmitBadSignatureEvidence): MsgSubmitBadSignatureEvidenceAmino;
    fromAminoMsg(object: MsgSubmitBadSignatureEvidenceAminoMsg): MsgSubmitBadSignatureEvidence;
    toAminoMsg(message: MsgSubmitBadSignatureEvidence): MsgSubmitBadSignatureEvidenceAminoMsg;
    fromProtoMsg(message: MsgSubmitBadSignatureEvidenceProtoMsg): MsgSubmitBadSignatureEvidence;
    toProto(message: MsgSubmitBadSignatureEvidence): Uint8Array;
    toProtoMsg(message: MsgSubmitBadSignatureEvidence): MsgSubmitBadSignatureEvidenceProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgSubmitBadSignatureEvidenceResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgSubmitBadSignatureEvidenceResponse
 */
export declare const MsgSubmitBadSignatureEvidenceResponse: {
    typeUrl: string;
    is(o: any): o is MsgSubmitBadSignatureEvidenceResponse;
    isAmino(o: any): o is MsgSubmitBadSignatureEvidenceResponseAmino;
    encode(_: MsgSubmitBadSignatureEvidenceResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgSubmitBadSignatureEvidenceResponse;
    fromPartial(_: DeepPartial<MsgSubmitBadSignatureEvidenceResponse>): MsgSubmitBadSignatureEvidenceResponse;
    fromAmino(_: MsgSubmitBadSignatureEvidenceResponseAmino): MsgSubmitBadSignatureEvidenceResponse;
    toAmino(_: MsgSubmitBadSignatureEvidenceResponse): MsgSubmitBadSignatureEvidenceResponseAmino;
    fromAminoMsg(object: MsgSubmitBadSignatureEvidenceResponseAminoMsg): MsgSubmitBadSignatureEvidenceResponse;
    fromProtoMsg(message: MsgSubmitBadSignatureEvidenceResponseProtoMsg): MsgSubmitBadSignatureEvidenceResponse;
    toProto(message: MsgSubmitBadSignatureEvidenceResponse): Uint8Array;
    toProtoMsg(message: MsgSubmitBadSignatureEvidenceResponse): MsgSubmitBadSignatureEvidenceResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * This informs the Cosmos module that a validator
 * set has been updated.
 * @name MsgValsetUpdatedClaim
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetUpdatedClaim
 */
export declare const MsgValsetUpdatedClaim: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgValsetUpdatedClaim;
    isAmino(o: any): o is MsgValsetUpdatedClaimAmino;
    encode(message: MsgValsetUpdatedClaim, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgValsetUpdatedClaim;
    fromPartial(object: DeepPartial<MsgValsetUpdatedClaim>): MsgValsetUpdatedClaim;
    fromAmino(object: MsgValsetUpdatedClaimAmino): MsgValsetUpdatedClaim;
    toAmino(message: MsgValsetUpdatedClaim): MsgValsetUpdatedClaimAmino;
    fromAminoMsg(object: MsgValsetUpdatedClaimAminoMsg): MsgValsetUpdatedClaim;
    toAminoMsg(message: MsgValsetUpdatedClaim): MsgValsetUpdatedClaimAminoMsg;
    fromProtoMsg(message: MsgValsetUpdatedClaimProtoMsg): MsgValsetUpdatedClaim;
    toProto(message: MsgValsetUpdatedClaim): Uint8Array;
    toProtoMsg(message: MsgValsetUpdatedClaim): MsgValsetUpdatedClaimProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgValsetUpdatedClaimResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgValsetUpdatedClaimResponse
 */
export declare const MsgValsetUpdatedClaimResponse: {
    typeUrl: string;
    is(o: any): o is MsgValsetUpdatedClaimResponse;
    isAmino(o: any): o is MsgValsetUpdatedClaimResponseAmino;
    encode(_: MsgValsetUpdatedClaimResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgValsetUpdatedClaimResponse;
    fromPartial(_: DeepPartial<MsgValsetUpdatedClaimResponse>): MsgValsetUpdatedClaimResponse;
    fromAmino(_: MsgValsetUpdatedClaimResponseAmino): MsgValsetUpdatedClaimResponse;
    toAmino(_: MsgValsetUpdatedClaimResponse): MsgValsetUpdatedClaimResponseAmino;
    fromAminoMsg(object: MsgValsetUpdatedClaimResponseAminoMsg): MsgValsetUpdatedClaimResponse;
    fromProtoMsg(message: MsgValsetUpdatedClaimResponseProtoMsg): MsgValsetUpdatedClaimResponse;
    toProto(message: MsgValsetUpdatedClaimResponse): Uint8Array;
    toProtoMsg(message: MsgValsetUpdatedClaimResponse): MsgValsetUpdatedClaimResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgUpdateParams
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgUpdateParams
 */
export declare const MsgUpdateParams: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgUpdateParams;
    isAmino(o: any): o is MsgUpdateParamsAmino;
    encode(message: MsgUpdateParams, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams;
    fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams;
    fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams;
    toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino;
    fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams;
    toAminoMsg(message: MsgUpdateParams): MsgUpdateParamsAminoMsg;
    fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams;
    toProto(message: MsgUpdateParams): Uint8Array;
    toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg;
    registerTypeUrl(): void;
};
/**
 * @name MsgUpdateParamsResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgUpdateParamsResponse
 */
export declare const MsgUpdateParamsResponse: {
    typeUrl: string;
    is(o: any): o is MsgUpdateParamsResponse;
    isAmino(o: any): o is MsgUpdateParamsResponseAmino;
    encode(_: MsgUpdateParamsResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse;
    fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse;
    fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse;
    toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino;
    fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse;
    fromProtoMsg(message: MsgUpdateParamsResponseProtoMsg): MsgUpdateParamsResponse;
    toProto(message: MsgUpdateParamsResponse): Uint8Array;
    toProtoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * MsgBlacklistEthereumAddresses defines the message used to add Ethereum
 * addresses to peggy blacklist.
 * @name MsgBlacklistEthereumAddresses
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgBlacklistEthereumAddresses
 */
export declare const MsgBlacklistEthereumAddresses: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgBlacklistEthereumAddresses;
    isAmino(o: any): o is MsgBlacklistEthereumAddressesAmino;
    encode(message: MsgBlacklistEthereumAddresses, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgBlacklistEthereumAddresses;
    fromPartial(object: DeepPartial<MsgBlacklistEthereumAddresses>): MsgBlacklistEthereumAddresses;
    fromAmino(object: MsgBlacklistEthereumAddressesAmino): MsgBlacklistEthereumAddresses;
    toAmino(message: MsgBlacklistEthereumAddresses): MsgBlacklistEthereumAddressesAmino;
    fromAminoMsg(object: MsgBlacklistEthereumAddressesAminoMsg): MsgBlacklistEthereumAddresses;
    toAminoMsg(message: MsgBlacklistEthereumAddresses): MsgBlacklistEthereumAddressesAminoMsg;
    fromProtoMsg(message: MsgBlacklistEthereumAddressesProtoMsg): MsgBlacklistEthereumAddresses;
    toProto(message: MsgBlacklistEthereumAddresses): Uint8Array;
    toProtoMsg(message: MsgBlacklistEthereumAddresses): MsgBlacklistEthereumAddressesProtoMsg;
    registerTypeUrl(): void;
};
/**
 * MsgBlacklistEthereumAddressesResponse defines the
 * MsgBlacklistEthereumAddresses response type.
 * @name MsgBlacklistEthereumAddressesResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgBlacklistEthereumAddressesResponse
 */
export declare const MsgBlacklistEthereumAddressesResponse: {
    typeUrl: string;
    is(o: any): o is MsgBlacklistEthereumAddressesResponse;
    isAmino(o: any): o is MsgBlacklistEthereumAddressesResponseAmino;
    encode(_: MsgBlacklistEthereumAddressesResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgBlacklistEthereumAddressesResponse;
    fromPartial(_: DeepPartial<MsgBlacklistEthereumAddressesResponse>): MsgBlacklistEthereumAddressesResponse;
    fromAmino(_: MsgBlacklistEthereumAddressesResponseAmino): MsgBlacklistEthereumAddressesResponse;
    toAmino(_: MsgBlacklistEthereumAddressesResponse): MsgBlacklistEthereumAddressesResponseAmino;
    fromAminoMsg(object: MsgBlacklistEthereumAddressesResponseAminoMsg): MsgBlacklistEthereumAddressesResponse;
    fromProtoMsg(message: MsgBlacklistEthereumAddressesResponseProtoMsg): MsgBlacklistEthereumAddressesResponse;
    toProto(message: MsgBlacklistEthereumAddressesResponse): Uint8Array;
    toProtoMsg(message: MsgBlacklistEthereumAddressesResponse): MsgBlacklistEthereumAddressesResponseProtoMsg;
    registerTypeUrl(): void;
};
/**
 * MsgRevokeEthereumBlacklist defines the message used to remove Ethereum
 * addresses from peggy blacklist.
 * @name MsgRevokeEthereumBlacklist
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRevokeEthereumBlacklist
 */
export declare const MsgRevokeEthereumBlacklist: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is MsgRevokeEthereumBlacklist;
    isAmino(o: any): o is MsgRevokeEthereumBlacklistAmino;
    encode(message: MsgRevokeEthereumBlacklist, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeEthereumBlacklist;
    fromPartial(object: DeepPartial<MsgRevokeEthereumBlacklist>): MsgRevokeEthereumBlacklist;
    fromAmino(object: MsgRevokeEthereumBlacklistAmino): MsgRevokeEthereumBlacklist;
    toAmino(message: MsgRevokeEthereumBlacklist): MsgRevokeEthereumBlacklistAmino;
    fromAminoMsg(object: MsgRevokeEthereumBlacklistAminoMsg): MsgRevokeEthereumBlacklist;
    toAminoMsg(message: MsgRevokeEthereumBlacklist): MsgRevokeEthereumBlacklistAminoMsg;
    fromProtoMsg(message: MsgRevokeEthereumBlacklistProtoMsg): MsgRevokeEthereumBlacklist;
    toProto(message: MsgRevokeEthereumBlacklist): Uint8Array;
    toProtoMsg(message: MsgRevokeEthereumBlacklist): MsgRevokeEthereumBlacklistProtoMsg;
    registerTypeUrl(): void;
};
/**
 * MsgRevokeEthereumBlacklistResponse defines the MsgRevokeEthereumBlacklist
 * response type.
 * @name MsgRevokeEthereumBlacklistResponse
 * @package injective.peggy.v1
 * @see proto type: injective.peggy.v1.MsgRevokeEthereumBlacklistResponse
 */
export declare const MsgRevokeEthereumBlacklistResponse: {
    typeUrl: string;
    is(o: any): o is MsgRevokeEthereumBlacklistResponse;
    isAmino(o: any): o is MsgRevokeEthereumBlacklistResponseAmino;
    encode(_: MsgRevokeEthereumBlacklistResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeEthereumBlacklistResponse;
    fromPartial(_: DeepPartial<MsgRevokeEthereumBlacklistResponse>): MsgRevokeEthereumBlacklistResponse;
    fromAmino(_: MsgRevokeEthereumBlacklistResponseAmino): MsgRevokeEthereumBlacklistResponse;
    toAmino(_: MsgRevokeEthereumBlacklistResponse): MsgRevokeEthereumBlacklistResponseAmino;
    fromAminoMsg(object: MsgRevokeEthereumBlacklistResponseAminoMsg): MsgRevokeEthereumBlacklistResponse;
    fromProtoMsg(message: MsgRevokeEthereumBlacklistResponseProtoMsg): MsgRevokeEthereumBlacklistResponse;
    toProto(message: MsgRevokeEthereumBlacklistResponse): Uint8Array;
    toProtoMsg(message: MsgRevokeEthereumBlacklistResponse): MsgRevokeEthereumBlacklistResponseProtoMsg;
    registerTypeUrl(): void;
};