injectivejs 1.4.0 → 1.6.0

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

@@ -0,0 +1,1122 @@
+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
+ */
+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
+ */
+export interface MsgSetOrchestratorAddressesAmino {
+    sender: string;
+    orchestrator: string;
+    eth_address: string;
+}
+export interface MsgSetOrchestratorAddressesAminoMsg {
+    type: "peggy/MsgSetOrchestratorAddresses";
+    value: MsgSetOrchestratorAddressesAmino;
+}
+export interface MsgSetOrchestratorAddressesResponse {
+}
+export interface MsgSetOrchestratorAddressesResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgSetOrchestratorAddressesResponse";
+    value: Uint8Array;
+}
+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
+ * -------------
+ */
+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
+ * -------------
+ */
+export interface MsgValsetConfirmAmino {
+    nonce: string;
+    orchestrator: string;
+    eth_address: string;
+    signature: string;
+}
+export interface MsgValsetConfirmAminoMsg {
+    type: "peggy/MsgValsetConfirm";
+    value: MsgValsetConfirmAmino;
+}
+export interface MsgValsetConfirmResponse {
+}
+export interface MsgValsetConfirmResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgValsetConfirmResponse";
+    value: Uint8Array;
+}
+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
+ */
+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
+ */
+export interface MsgSendToEthAmino {
+    sender: string;
+    eth_dest: string;
+    amount: CoinAmino;
+    bridge_fee: CoinAmino;
+}
+export interface MsgSendToEthAminoMsg {
+    type: "peggy/MsgSendToEth";
+    value: MsgSendToEthAmino;
+}
+export interface MsgSendToEthResponse {
+}
+export interface MsgSendToEthResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgSendToEthResponse";
+    value: Uint8Array;
+}
+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
+ * -------------
+ */
+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
+ * -------------
+ */
+export interface MsgRequestBatchAmino {
+    orchestrator: string;
+    denom: string;
+}
+export interface MsgRequestBatchAminoMsg {
+    type: "peggy/MsgRequestBatch";
+    value: MsgRequestBatchAmino;
+}
+export interface MsgRequestBatchResponse {
+}
+export interface MsgRequestBatchResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgRequestBatchResponse";
+    value: Uint8Array;
+}
+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
+ * -------------
+ */
+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
+ * -------------
+ */
+export interface MsgConfirmBatchAmino {
+    nonce: string;
+    token_contract: string;
+    eth_signer: string;
+    orchestrator: string;
+    signature: string;
+}
+export interface MsgConfirmBatchAminoMsg {
+    type: "peggy/MsgConfirmBatch";
+    value: MsgConfirmBatchAmino;
+}
+export interface MsgConfirmBatchResponse {
+}
+export interface MsgConfirmBatchResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgConfirmBatchResponse";
+    value: Uint8Array;
+}
+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
+ * -------------
+ */
+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
+ * -------------
+ */
+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;
+}
+export interface MsgDepositClaimResponse {
+}
+export interface MsgDepositClaimResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgDepositClaimResponse";
+    value: Uint8Array;
+}
+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.
+ */
+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.
+ */
+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;
+}
+export interface MsgWithdrawClaimResponse {
+}
+export interface MsgWithdrawClaimResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgWithdrawClaimResponse";
+    value: Uint8Array;
+}
+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
+ */
+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
+ */
+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;
+}
+export interface MsgERC20DeployedClaimResponse {
+}
+export interface MsgERC20DeployedClaimResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgERC20DeployedClaimResponse";
+    value: Uint8Array;
+}
+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
+ */
+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
+ */
+export interface MsgCancelSendToEthAmino {
+    transaction_id: string;
+    sender: string;
+}
+export interface MsgCancelSendToEthAminoMsg {
+    type: "peggy/MsgCancelSendToEth";
+    value: MsgCancelSendToEthAmino;
+}
+export interface MsgCancelSendToEthResponse {
+}
+export interface MsgCancelSendToEthResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgCancelSendToEthResponse";
+    value: Uint8Array;
+}
+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.
+ */
+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.
+ */
+export interface MsgSubmitBadSignatureEvidenceAmino {
+    subject?: AnyAmino;
+    signature: string;
+    sender: string;
+}
+export interface MsgSubmitBadSignatureEvidenceAminoMsg {
+    type: "peggy/MsgSubmitBadSignatureEvidence";
+    value: MsgSubmitBadSignatureEvidenceAmino;
+}
+export interface MsgSubmitBadSignatureEvidenceResponse {
+}
+export interface MsgSubmitBadSignatureEvidenceResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgSubmitBadSignatureEvidenceResponse";
+    value: Uint8Array;
+}
+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.
+ */
+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.
+ */
+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;
+}
+export interface MsgValsetUpdatedClaimResponse {
+}
+export interface MsgValsetUpdatedClaimResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgValsetUpdatedClaimResponse";
+    value: Uint8Array;
+}
+export interface MsgValsetUpdatedClaimResponseAmino {
+}
+export interface MsgValsetUpdatedClaimResponseAminoMsg {
+    type: "/injective.peggy.v1.MsgValsetUpdatedClaimResponse";
+    value: MsgValsetUpdatedClaimResponseAmino;
+}
+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;
+}
+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;
+}
+export interface MsgUpdateParamsResponse {
+}
+export interface MsgUpdateParamsResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgUpdateParamsResponse";
+    value: Uint8Array;
+}
+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.
+ */
+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.
+ */
+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.
+ */
+export interface MsgBlacklistEthereumAddressesResponse {
+}
+export interface MsgBlacklistEthereumAddressesResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgBlacklistEthereumAddressesResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgBlacklistEthereumAddressesResponse defines the
+ * MsgBlacklistEthereumAddresses response type.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+export interface MsgRevokeEthereumBlacklistResponse {
+}
+export interface MsgRevokeEthereumBlacklistResponseProtoMsg {
+    typeUrl: "/injective.peggy.v1.MsgRevokeEthereumBlacklistResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgRevokeEthereumBlacklistResponse defines the MsgRevokeEthereumBlacklist
+ * response type.
+ */
+export interface MsgRevokeEthereumBlacklistResponseAmino {
+}
+export interface MsgRevokeEthereumBlacklistResponseAminoMsg {
+    type: "/injective.peggy.v1.MsgRevokeEthereumBlacklistResponse";
+    value: MsgRevokeEthereumBlacklistResponseAmino;
+}
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};