types

package
v0.0.0-...-69ee090 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 9, 2024 License: Apache-2.0 Imports: 36 Imported by: 15

Documentation

Overview

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *

  • Licensed under the Apache License, Version 2.0 (the "License");

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

Package types is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

  • Copyright (c) 2023, © Circle Internet Financial, LTD. *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License.

Index

Constants

View Source 
const (
	// Indices of each field in message
	VersionIndex           = 0
	SourceDomainIndex      = 4
	DestinationDomainIndex = 8
	NonceIndex             = 12
	SenderIndex            = 20
	RecipientIndex         = 52
	DestinationCallerIndex = 84
	MessageBodyIndex       = 116

	// Indices of each field in BurnMessage
	BurnMsgVersionIndex = 0
	VersionLen          = 4
	BurnTokenIndex      = 4
	BurnTokenLen        = 32
	MintRecipientIndex  = 36
	MintRecipientLen    = 32
	AmountIndex         = 68
	AmountLen           = 32
	MsgSenderIndex      = 100
	MsgSenderLen        = 32
	// 4 byte version + 32 bytes burnToken + 32 bytes mintRecipient + 32 bytes amount + 32 bytes messageSender
	BurnMessageLen = 132

	NobleMessageVersion = 0
	MessageBodyVersion  = 0
	NobleDomainId       = 4

	DomainBytesLen  = 4
	UsedNonceLen    = 8
	NonceBytesLen   = 8
	AddressBytesLen = 32

	DomainBitLen                = 32
	NonceBitLen                 = 32
	DestinationCallerLen        = 32
	SignatureThresholdBitLength = 32
	BaseTen                     = 10

	SignatureLength = 65
)
View Source 
const (
	// ModuleName defines the module name
	ModuleName = "cctp"

	// StoreKey defines the primary module store key
	StoreKey = "cctp"

	// RouterKey defines the module's message routing key
	RouterKey = StoreKey

	// MemStoreKey defines the in-memory store key
	MemStoreKey = "mem_" + StoreKey

	BurningAndMintingPausedKey           = "BurningAndMintingPaused/value/"
	MaxMessageBodySizeKey                = "MaxMessageBodySize/value/"
	NextAvailableNonceKey                = "NextAvailableNonce/value/"
	SendingAndReceivingMessagesPausedKey = "SendingAndReceivingMessagesPaused/value/"
	SignatureThresholdKey                = "SignatureThreshold/value/"

	AttesterKeyPrefix             = "Attester/value/"
	PerMessageBurnLimitKeyPrefix  = "PerMessageBurnLimit/value/"
	RemoteTokenMessengerKeyPrefix = "RemoteTokenMessenger/value/"
	TokenPairKeyPrefix            = "TokenPair/value/"
	UsedNonceKeyPrefix            = "UsedNonce/value/"
)
View Source 
const TypeMsgAcceptOwner = "accept_owner"
View Source 
const TypeMsgAddRemoteTokenMessenger = "add_remote_token_messenger"
View Source 
const TypeMsgDepositForBurn = "deposit_for_burn"
View Source 
const TypeMsgDepositForBurnWithCaller = "deposit_for_burn_with_caller"
View Source 
const TypeMsgDisableAttester = "disable_attester"
View Source 
const TypeMsgEnableAttester = "enable_attester"
View Source 
const TypeMsgLinkTokenPair = "link_token_pair"
View Source 
const TypeMsgPauseBurningAndMinting = "pause_burning_and_minting"
View Source 
const TypeMsgPauseSendingAndReceivingMessages = "pause_sending_and_receiving_messages"
View Source 
const TypeMsgReceiveMessage = "receive_message"
View Source 
const TypeMsgRemoveRemoteTokenMessenger = "remove_remote_token_messenger"
View Source 
const TypeMsgReplaceDepositForBurn = "replace_deposit_for_burn"
View Source 
const TypeMsgReplaceMessage = "replace_message"
View Source 
const TypeMsgSendMessage = "send_message"
View Source 
const TypeMsgSendMessageWithCaller = "send_message_with_caller"
View Source 
const TypeMsgSetMaxBurnAmountPerMessage = "set_max_burn_amount_per_message"
View Source 
const TypeMsgUnlinkTokenPair = "unlink_token_pair"
View Source 
const TypeMsgUnpauseBurningAndMinting = "unpause_burning_and_minting"
View Source 
const TypeMsgUnpauseSendingAndReceivingMessages = "unpause_sending_and_receiving_messages"
View Source 
const TypeMsgUpdateAttesterManager = "update_attester_manager"
View Source 
const TypeMsgUpdateMaxMessageBodySize = "update_max_message_body_size"
View Source 
const TypeMsgUpdateOwner = "update_owner"
View Source 
const TypeMsgUpdatePauser = "update_pauser"
View Source 
const TypeMsgUpdateSignatureThreshold = "update_signature_threshold"
View Source 
const TypeMsgUpdateTokenController = "update_token_controller"

Variables

View Source 
var (
	ErrInvalidLengthAttester        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAttester          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAttester = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthBurnMessage        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBurnMessage          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBurnMessage = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthBurningAndMintingPaused        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBurningAndMintingPaused          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBurningAndMintingPaused = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrUnauthorized                     = sdkerrors.Register(ModuleName, 30, "unauthorized")
	ErrMint                             = sdkerrors.Register(ModuleName, 31, "tokens can not be minted")
	ErrBurn                             = sdkerrors.Register(ModuleName, 32, "tokens can not be burned")
	ErrAttesterAlreadyFound             = sdkerrors.Register(ModuleName, 33, "attester is already present")
	ErrAuthorityNotSet                  = sdkerrors.Register(ModuleName, 34, "authority not set")
	ErrMalformedField                   = sdkerrors.Register(ModuleName, 35, "field cannot be empty or nil")
	ErrReceiveMessage                   = sdkerrors.Register(ModuleName, 36, "err in receive message")
	ErrDisableAttester                  = sdkerrors.Register(ModuleName, 37, "err in disable attester")
	ErrUpdateSignatureThreshold         = sdkerrors.Register(ModuleName, 38, "err in update signature threshold")
	ErrMinterAllowanceNotFound          = sdkerrors.Register(ModuleName, 39, "minter allowance not found")
	ErrTokenPairAlreadyFound            = sdkerrors.Register(ModuleName, 40, "token pair already exists")
	ErrTokenPairNotFound                = sdkerrors.Register(ModuleName, 41, "token pair not found")
	ErrSendMessage                      = sdkerrors.Register(ModuleName, 42, "error in send message")
	ErrSendMessageWithCaller            = sdkerrors.Register(ModuleName, 43, "error in send message with caller")
	ErrDepositForBurn                   = sdkerrors.Register(ModuleName, 44, "error in deposit for burn")
	ErrInvalidDestinationCaller         = sdkerrors.Register(ModuleName, 45, "malformed destination caller")
	ErrSignatureVerification            = sdkerrors.Register(ModuleName, 46, "unable to verify signature")
	ErrReplaceMessage                   = sdkerrors.Register(ModuleName, 47, "error in replace message")
	ErrDuringPause                      = sdkerrors.Register(ModuleName, 48, "error while trying to pause or unpause")
	ErrInvalidAmount                    = sdkerrors.Register(ModuleName, 49, "invalid amount")
	ErrNextAvailableNonce               = sdkerrors.Register(ModuleName, 50, "error while retrieving next available nonce")
	ErrRemoteTokenMessengerAlreadyFound = sdkerrors.Register(ModuleName, 51, "this remote token messenger mapping already exists")
	ErrRemoteTokenMessengerNotFound     = sdkerrors.Register(ModuleName, 53, "remote token messenger not found")
	ErrParsingMessage                   = sdkerrors.Register(ModuleName, 54, "error while parsing message into bytes")
	ErrParsingBurnMessage               = sdkerrors.Register(ModuleName, 55, "error while parsing burn message into bytes")
	ErrInvalidRemoteToken               = sdkerrors.Register(ModuleName, 56, "invalid remote token")
)

x/cctp module sentinel errors

View Source 
var (
	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	OwnerKey           = []byte("owner")
	PendingOwnerKey    = []byte("pending-owner")
	AttesterManagerKey = []byte("attester-manager")
	PauserKey          = []byte("pauser")
	TokenControllerKey = []byte("token-controller")
)
View Source 
var (
	ErrInvalidLengthMaxMessageBodySize        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMaxMessageBodySize          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMaxMessageBodySize = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthMessage        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMessage          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMessage = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthNonce        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowNonce          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupNonce = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthParams        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowParams          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthPerMessageBurnLimit        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowPerMessageBurnLimit          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupPerMessageBurnLimit = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthRemoteTokenMessenger        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRemoteTokenMessenger          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRemoteTokenMessenger = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthSendingAndReceivingMessagesPaused        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSendingAndReceivingMessagesPaused          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSendingAndReceivingMessagesPaused = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthSignatureThreshold        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSignatureThreshold          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSignatureThreshold = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthTokenPair        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTokenPair          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTokenPair = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var ModuleAddress = authTypes.NewModuleAddress(ModuleName)
View Source 
var (
	ModuleCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry())
)
View Source 
var PaddedModuleAddress = make([]byte, 32)

Functions

func AttesterKey 

func AttesterKey(key []byte) []byte

AttesterKey returns the store key to retrieve an Attester from the index fields

func KeyPrefix 

func KeyPrefix(p string) []byte

func ParamKeyTable 

func ParamKeyTable() paramtypes.KeyTable

ParamKeyTable the param key table for launch module

func PerMessageBurnLimitKey 

func PerMessageBurnLimitKey(denom string) []byte

PerMessageBurnLimitKey returns the store key to retrieve a PerMessageBurnLimit from the index fields

func RegisterInterfaces 

func RegisterInterfaces(registry cdctypes.InterfaceRegistry)

func RegisterLegacyAminoCodec 

func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino)

func RegisterMsgServer 

func RegisterMsgServer(s grpc1.Server, srv MsgServer)

func RegisterQueryHandler 

func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterQueryHandler registers the http handlers for service Query to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterQueryHandlerClient 

func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error

RegisterQueryHandlerClient registers the http handlers for service Query to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "QueryClient" to call the correct interceptors.

func RegisterQueryHandlerFromEndpoint 

func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterQueryHandlerServer 

func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error

RegisterQueryHandlerServer registers the http handlers for service Query to "mux". UnaryRPC :call QueryServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.

func RegisterQueryServer 

func RegisterQueryServer(s grpc1.Server, srv QueryServer)

func RemoteTokenMessengerKey 

func RemoteTokenMessengerKey(domain uint32) []byte

RemoteTokenMessengerKey returns the store key to retrieve a RemoteTokenMessenger from the index fields

func RemoteTokenPadded 

func RemoteTokenPadded(remoteTokenHex string) ([]byte, error)

RemoteTokenPadded returns the remote token as a byte array, padded to 32 bytes

func TokenPairKey 

func TokenPairKey(remoteDomain uint32, remoteToken []byte) []byte

TokenPairKey returns the store key to retrieve a TokenPair from the index fields

func UsedNonceKey 

func UsedNonceKey(nonce uint64, sourceDomain uint32) []byte

UsedNonceKey returns the store key to retrieve a UsedNonce from the index fields

Types

type AccountKeeper 

type AccountKeeper interface {
	GetAccount(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI
}

AccountKeeper defines the expected account keeper used for simulations (noalias)

type Attester 

type Attester struct {
	Attester string `protobuf:"bytes,1,opt,name=attester,proto3" json:"attester,omitempty"`
}

* A public key used to verify message signatures @param attester ECDSA uncompressed public key, hex encoded

func (*Attester) Descriptor 

func (*Attester) Descriptor() ([]byte, []int)

func (*Attester) GetAttester 

func (m *Attester) GetAttester() string

func (*Attester) Marshal 

func (m *Attester) Marshal() (dAtA []byte, err error)

func (*Attester) MarshalTo 

func (m *Attester) MarshalTo(dAtA []byte) (int, error)

func (*Attester) MarshalToSizedBuffer 

func (m *Attester) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Attester) ProtoMessage 

func (*Attester) ProtoMessage()

func (*Attester) Reset 

func (m *Attester) Reset()

func (*Attester) Size 

func (m *Attester) Size() (n int)

func (*Attester) String 

func (m *Attester) String() string

func (*Attester) Unmarshal 

func (m *Attester) Unmarshal(dAtA []byte) error

func (*Attester) XXX_DiscardUnknown 

func (m *Attester) XXX_DiscardUnknown()

func (*Attester) XXX_Marshal 

func (m *Attester) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Attester) XXX_Merge 

func (m *Attester) XXX_Merge(src proto.Message)

func (*Attester) XXX_Size 

func (m *Attester) XXX_Size() int

func (*Attester) XXX_Unmarshal 

func (m *Attester) XXX_Unmarshal(b []byte) error

type AttesterDisabled 

type AttesterDisabled struct {
	Attester string `protobuf:"bytes,1,opt,name=attester,proto3" json:"attester,omitempty"`
}

* Emitted when an attester is disabled @param attester newly disabled attester

func (*AttesterDisabled) Descriptor 

func (*AttesterDisabled) Descriptor() ([]byte, []int)

func (*AttesterDisabled) GetAttester 

func (m *AttesterDisabled) GetAttester() string

func (*AttesterDisabled) Marshal 

func (m *AttesterDisabled) Marshal() (dAtA []byte, err error)

func (*AttesterDisabled) MarshalTo 

func (m *AttesterDisabled) MarshalTo(dAtA []byte) (int, error)

func (*AttesterDisabled) MarshalToSizedBuffer 

func (m *AttesterDisabled) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*AttesterDisabled) ProtoMessage 

func (*AttesterDisabled) ProtoMessage()

func (*AttesterDisabled) Reset 

func (m *AttesterDisabled) Reset()

func (*AttesterDisabled) Size 

func (m *AttesterDisabled) Size() (n int)

func (*AttesterDisabled) String 

func (m *AttesterDisabled) String() string

func (*AttesterDisabled) Unmarshal 

func (m *AttesterDisabled) Unmarshal(dAtA []byte) error

func (*AttesterDisabled) XXX_DiscardUnknown 

func (m *AttesterDisabled) XXX_DiscardUnknown()

func (*AttesterDisabled) XXX_Marshal 

func (m *AttesterDisabled) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AttesterDisabled) XXX_Merge 

func (m *AttesterDisabled) XXX_Merge(src proto.Message)

func (*AttesterDisabled) XXX_Size 

func (m *AttesterDisabled) XXX_Size() int

func (*AttesterDisabled) XXX_Unmarshal 

func (m *AttesterDisabled) XXX_Unmarshal(b []byte) error

type AttesterEnabled 

type AttesterEnabled struct {
	Attester string `protobuf:"bytes,1,opt,name=attester,proto3" json:"attester,omitempty"`
}

* Emitted when an attester is enabled @param attester newly enabled attester

func (*AttesterEnabled) Descriptor 

func (*AttesterEnabled) Descriptor() ([]byte, []int)

func (*AttesterEnabled) GetAttester 

func (m *AttesterEnabled) GetAttester() string

func (*AttesterEnabled) Marshal 

func (m *AttesterEnabled) Marshal() (dAtA []byte, err error)

func (*AttesterEnabled) MarshalTo 

func (m *AttesterEnabled) MarshalTo(dAtA []byte) (int, error)

func (*AttesterEnabled) MarshalToSizedBuffer 

func (m *AttesterEnabled) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*AttesterEnabled) ProtoMessage 

func (*AttesterEnabled) ProtoMessage()

func (*AttesterEnabled) Reset 

func (m *AttesterEnabled) Reset()

func (*AttesterEnabled) Size 

func (m *AttesterEnabled) Size() (n int)

func (*AttesterEnabled) String 

func (m *AttesterEnabled) String() string

func (*AttesterEnabled) Unmarshal 

func (m *AttesterEnabled) Unmarshal(dAtA []byte) error

func (*AttesterEnabled) XXX_DiscardUnknown 

func (m *AttesterEnabled) XXX_DiscardUnknown()

func (*AttesterEnabled) XXX_Marshal 

func (m *AttesterEnabled) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AttesterEnabled) XXX_Merge 

func (m *AttesterEnabled) XXX_Merge(src proto.Message)

func (*AttesterEnabled) XXX_Size 

func (m *AttesterEnabled) XXX_Size() int

func (*AttesterEnabled) XXX_Unmarshal 

func (m *AttesterEnabled) XXX_Unmarshal(b []byte) error

type AttesterManagerUpdated 

type AttesterManagerUpdated struct {
	PreviousAttesterManager string `` /* 132-byte string literal not displayed */
	NewAttesterManager      string `protobuf:"bytes,2,opt,name=new_attester_manager,json=newAttesterManager,proto3" json:"new_attester_manager,omitempty"`
}

* Emitted when attester manager address is updated @param previous_attester_manager representing the address of the previous attester manager @param new_attester_manager representing the address of the new attester manager

func (*AttesterManagerUpdated) Descriptor 

func (*AttesterManagerUpdated) Descriptor() ([]byte, []int)

func (*AttesterManagerUpdated) GetNewAttesterManager 

func (m *AttesterManagerUpdated) GetNewAttesterManager() string

func (*AttesterManagerUpdated) GetPreviousAttesterManager 

func (m *AttesterManagerUpdated) GetPreviousAttesterManager() string

func (*AttesterManagerUpdated) Marshal 

func (m *AttesterManagerUpdated) Marshal() (dAtA []byte, err error)

func (*AttesterManagerUpdated) MarshalTo 

func (m *AttesterManagerUpdated) MarshalTo(dAtA []byte) (int, error)

func (*AttesterManagerUpdated) MarshalToSizedBuffer 

func (m *AttesterManagerUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*AttesterManagerUpdated) ProtoMessage 

func (*AttesterManagerUpdated) ProtoMessage()

func (*AttesterManagerUpdated) Reset 

func (m *AttesterManagerUpdated) Reset()

func (*AttesterManagerUpdated) Size 

func (m *AttesterManagerUpdated) Size() (n int)

func (*AttesterManagerUpdated) String 

func (m *AttesterManagerUpdated) String() string

func (*AttesterManagerUpdated) Unmarshal 

func (m *AttesterManagerUpdated) Unmarshal(dAtA []byte) error

func (*AttesterManagerUpdated) XXX_DiscardUnknown 

func (m *AttesterManagerUpdated) XXX_DiscardUnknown()

func (*AttesterManagerUpdated) XXX_Marshal 

func (m *AttesterManagerUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AttesterManagerUpdated) XXX_Merge 

func (m *AttesterManagerUpdated) XXX_Merge(src proto.Message)

func (*AttesterManagerUpdated) XXX_Size 

func (m *AttesterManagerUpdated) XXX_Size() int

func (*AttesterManagerUpdated) XXX_Unmarshal 

func (m *AttesterManagerUpdated) XXX_Unmarshal(b []byte) error

type BankKeeper 

type BankKeeper interface {
	GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Coin
	SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
}

type BurnMessage 

type BurnMessage struct {
	Version       uint32                `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	BurnToken     []byte                `protobuf:"bytes,2,opt,name=burn_token,json=burnToken,proto3" json:"burn_token,omitempty"`
	MintRecipient []byte                `protobuf:"bytes,3,opt,name=mint_recipient,json=mintRecipient,proto3" json:"mint_recipient,omitempty"`
	Amount        cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
	MessageSender []byte                `protobuf:"bytes,5,opt,name=message_sender,json=messageSender,proto3" json:"message_sender,omitempty"`
}

* Message format for BurnMessages @param version the message body version @param burn_token the burn token address on source domain as bytes32 @param mint_recipient the mint recipient address as bytes32 @param amount the burn amount @param message_sender the message sender

func (*BurnMessage) Bytes 

func (msg *BurnMessage) Bytes() ([]byte, error)

Bytes parses a BurnMessage struct into a byte array burn token, mint recipient, and message sender must be 32 bytes

func (*BurnMessage) Descriptor 

func (*BurnMessage) Descriptor() ([]byte, []int)

func (*BurnMessage) GetBurnToken 

func (m *BurnMessage) GetBurnToken() []byte

func (*BurnMessage) GetMessageSender 

func (m *BurnMessage) GetMessageSender() []byte

func (*BurnMessage) GetMintRecipient 

func (m *BurnMessage) GetMintRecipient() []byte

func (*BurnMessage) GetVersion 

func (m *BurnMessage) GetVersion() uint32

func (*BurnMessage) Marshal 

func (m *BurnMessage) Marshal() (dAtA []byte, err error)

func (*BurnMessage) MarshalTo 

func (m *BurnMessage) MarshalTo(dAtA []byte) (int, error)

func (*BurnMessage) MarshalToSizedBuffer 

func (m *BurnMessage) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*BurnMessage) Parse 

func (msg *BurnMessage) Parse(bz []byte) (*BurnMessage, error)

Parse parses a byte array into a BurnMessage struct https://developers.circle.com/stablecoin/docs/cctp-technical-reference#burnmessage

func (*BurnMessage) ProtoMessage 

func (*BurnMessage) ProtoMessage()

func (*BurnMessage) Reset 

func (m *BurnMessage) Reset()

func (*BurnMessage) Size 

func (m *BurnMessage) Size() (n int)

func (*BurnMessage) String 

func (m *BurnMessage) String() string

func (*BurnMessage) Unmarshal 

func (m *BurnMessage) Unmarshal(dAtA []byte) error

func (*BurnMessage) XXX_DiscardUnknown 

func (m *BurnMessage) XXX_DiscardUnknown()

func (*BurnMessage) XXX_Marshal 

func (m *BurnMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BurnMessage) XXX_Merge 

func (m *BurnMessage) XXX_Merge(src proto.Message)

func (*BurnMessage) XXX_Size 

func (m *BurnMessage) XXX_Size() int

func (*BurnMessage) XXX_Unmarshal 

func (m *BurnMessage) XXX_Unmarshal(b []byte) error

type BurningAndMintingPaused 

type BurningAndMintingPaused struct {
	Paused bool `protobuf:"varint,1,opt,name=paused,proto3" json:"paused,omitempty"`
}

* Message format for BurningAndMintingPaused @param paused true if paused, false if not paused

func (*BurningAndMintingPaused) Descriptor 

func (*BurningAndMintingPaused) Descriptor() ([]byte, []int)

func (*BurningAndMintingPaused) GetPaused 

func (m *BurningAndMintingPaused) GetPaused() bool

func (*BurningAndMintingPaused) Marshal 

func (m *BurningAndMintingPaused) Marshal() (dAtA []byte, err error)

func (*BurningAndMintingPaused) MarshalTo 

func (m *BurningAndMintingPaused) MarshalTo(dAtA []byte) (int, error)

func (*BurningAndMintingPaused) MarshalToSizedBuffer 

func (m *BurningAndMintingPaused) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*BurningAndMintingPaused) ProtoMessage 

func (*BurningAndMintingPaused) ProtoMessage()

func (*BurningAndMintingPaused) Reset 

func (m *BurningAndMintingPaused) Reset()

func (*BurningAndMintingPaused) Size 

func (m *BurningAndMintingPaused) Size() (n int)

func (*BurningAndMintingPaused) String 

func (m *BurningAndMintingPaused) String() string

func (*BurningAndMintingPaused) Unmarshal 

func (m *BurningAndMintingPaused) Unmarshal(dAtA []byte) error

func (*BurningAndMintingPaused) XXX_DiscardUnknown 

func (m *BurningAndMintingPaused) XXX_DiscardUnknown()

func (*BurningAndMintingPaused) XXX_Marshal 

func (m *BurningAndMintingPaused) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BurningAndMintingPaused) XXX_Merge 

func (m *BurningAndMintingPaused) XXX_Merge(src proto.Message)

func (*BurningAndMintingPaused) XXX_Size 

func (m *BurningAndMintingPaused) XXX_Size() int

func (*BurningAndMintingPaused) XXX_Unmarshal 

func (m *BurningAndMintingPaused) XXX_Unmarshal(b []byte) error

type BurningAndMintingPausedEvent 

type BurningAndMintingPausedEvent struct {
}

* Emitted when burning and minting tokens is paused

func (*BurningAndMintingPausedEvent) Descriptor 

func (*BurningAndMintingPausedEvent) Descriptor() ([]byte, []int)

func (*BurningAndMintingPausedEvent) Marshal 

func (m *BurningAndMintingPausedEvent) Marshal() (dAtA []byte, err error)

func (*BurningAndMintingPausedEvent) MarshalTo 

func (m *BurningAndMintingPausedEvent) MarshalTo(dAtA []byte) (int, error)

func (*BurningAndMintingPausedEvent) MarshalToSizedBuffer 

func (m *BurningAndMintingPausedEvent) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*BurningAndMintingPausedEvent) ProtoMessage 

func (*BurningAndMintingPausedEvent) ProtoMessage()

func (*BurningAndMintingPausedEvent) Reset 

func (m *BurningAndMintingPausedEvent) Reset()

func (*BurningAndMintingPausedEvent) Size 

func (m *BurningAndMintingPausedEvent) Size() (n int)

func (*BurningAndMintingPausedEvent) String 

func (m *BurningAndMintingPausedEvent) String() string

func (*BurningAndMintingPausedEvent) Unmarshal 

func (m *BurningAndMintingPausedEvent) Unmarshal(dAtA []byte) error

func (*BurningAndMintingPausedEvent) XXX_DiscardUnknown 

func (m *BurningAndMintingPausedEvent) XXX_DiscardUnknown()

func (*BurningAndMintingPausedEvent) XXX_Marshal 

func (m *BurningAndMintingPausedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BurningAndMintingPausedEvent) XXX_Merge 

func (m *BurningAndMintingPausedEvent) XXX_Merge(src proto.Message)

func (*BurningAndMintingPausedEvent) XXX_Size 

func (m *BurningAndMintingPausedEvent) XXX_Size() int

func (*BurningAndMintingPausedEvent) XXX_Unmarshal 

func (m *BurningAndMintingPausedEvent) XXX_Unmarshal(b []byte) error

type BurningAndMintingUnpausedEvent 

type BurningAndMintingUnpausedEvent struct {
}

* Emitted when burning and minting tokens is unpaused

func (*BurningAndMintingUnpausedEvent) Descriptor 

func (*BurningAndMintingUnpausedEvent) Descriptor() ([]byte, []int)

func (*BurningAndMintingUnpausedEvent) Marshal 

func (m *BurningAndMintingUnpausedEvent) Marshal() (dAtA []byte, err error)

func (*BurningAndMintingUnpausedEvent) MarshalTo 

func (m *BurningAndMintingUnpausedEvent) MarshalTo(dAtA []byte) (int, error)

func (*BurningAndMintingUnpausedEvent) MarshalToSizedBuffer 

func (m *BurningAndMintingUnpausedEvent) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*BurningAndMintingUnpausedEvent) ProtoMessage 

func (*BurningAndMintingUnpausedEvent) ProtoMessage()

func (*BurningAndMintingUnpausedEvent) Reset 

func (m *BurningAndMintingUnpausedEvent) Reset()

func (*BurningAndMintingUnpausedEvent) Size 

func (m *BurningAndMintingUnpausedEvent) Size() (n int)

func (*BurningAndMintingUnpausedEvent) String 

func (m *BurningAndMintingUnpausedEvent) String() string

func (*BurningAndMintingUnpausedEvent) Unmarshal 

func (m *BurningAndMintingUnpausedEvent) Unmarshal(dAtA []byte) error

func (*BurningAndMintingUnpausedEvent) XXX_DiscardUnknown 

func (m *BurningAndMintingUnpausedEvent) XXX_DiscardUnknown()

func (*BurningAndMintingUnpausedEvent) XXX_Marshal 

func (m *BurningAndMintingUnpausedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BurningAndMintingUnpausedEvent) XXX_Merge 

func (m *BurningAndMintingUnpausedEvent) XXX_Merge(src proto.Message)

func (*BurningAndMintingUnpausedEvent) XXX_Size 

func (m *BurningAndMintingUnpausedEvent) XXX_Size() int

func (*BurningAndMintingUnpausedEvent) XXX_Unmarshal 

func (m *BurningAndMintingUnpausedEvent) XXX_Unmarshal(b []byte) error

type DepositForBurn 

type DepositForBurn struct {
	Nonce                     uint64                `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	BurnToken                 string                `protobuf:"bytes,2,opt,name=burn_token,json=burnToken,proto3" json:"burn_token,omitempty"`
	Amount                    cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
	Depositor                 string                `protobuf:"bytes,4,opt,name=depositor,proto3" json:"depositor,omitempty"`
	MintRecipient             []byte                `protobuf:"bytes,5,opt,name=mint_recipient,json=mintRecipient,proto3" json:"mint_recipient,omitempty"`
	DestinationDomain         uint32                `protobuf:"varint,6,opt,name=destination_domain,json=destinationDomain,proto3" json:"destination_domain,omitempty"`
	DestinationTokenMessenger []byte                `` /* 138-byte string literal not displayed */
	DestinationCaller         []byte                `protobuf:"bytes,8,opt,name=destination_caller,json=destinationCaller,proto3" json:"destination_caller,omitempty"`
}

* Emitted when a DepositForBurn message is sent @param nonce unique nonce reserved by message @param burn_token address of token burnt on source domain @param amount deposit amount @param depositor address where deposit is transferred from @param mint_recipient address receiving minted tokens on destination domain as bytes32 @param destination_domain destination domain @param destination_token_messenger address of TokenMessenger on destination domain as bytes32 @param destination_caller authorized caller as bytes32 of receiveMessage() on destination domain, if not equal to bytes32(0). If equal to bytes32(0), any address can call receiveMessage().

func (*DepositForBurn) Descriptor 

func (*DepositForBurn) Descriptor() ([]byte, []int)

func (*DepositForBurn) GetBurnToken 

func (m *DepositForBurn) GetBurnToken() string

func (*DepositForBurn) GetDepositor 

func (m *DepositForBurn) GetDepositor() string

func (*DepositForBurn) GetDestinationCaller 

func (m *DepositForBurn) GetDestinationCaller() []byte

func (*DepositForBurn) GetDestinationDomain 

func (m *DepositForBurn) GetDestinationDomain() uint32

func (*DepositForBurn) GetDestinationTokenMessenger 

func (m *DepositForBurn) GetDestinationTokenMessenger() []byte

func (*DepositForBurn) GetMintRecipient 

func (m *DepositForBurn) GetMintRecipient() []byte

func (*DepositForBurn) GetNonce 

func (m *DepositForBurn) GetNonce() uint64

func (*DepositForBurn) Marshal 

func (m *DepositForBurn) Marshal() (dAtA []byte, err error)

func (*DepositForBurn) MarshalTo 

func (m *DepositForBurn) MarshalTo(dAtA []byte) (int, error)

func (*DepositForBurn) MarshalToSizedBuffer 

func (m *DepositForBurn) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*DepositForBurn) ProtoMessage 

func (*DepositForBurn) ProtoMessage()

func (*DepositForBurn) Reset 

func (m *DepositForBurn) Reset()

func (*DepositForBurn) Size 

func (m *DepositForBurn) Size() (n int)

func (*DepositForBurn) String 

func (m *DepositForBurn) String() string

func (*DepositForBurn) Unmarshal 

func (m *DepositForBurn) Unmarshal(dAtA []byte) error

func (*DepositForBurn) XXX_DiscardUnknown 

func (m *DepositForBurn) XXX_DiscardUnknown()

func (*DepositForBurn) XXX_Marshal 

func (m *DepositForBurn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DepositForBurn) XXX_Merge 

func (m *DepositForBurn) XXX_Merge(src proto.Message)

func (*DepositForBurn) XXX_Size 

func (m *DepositForBurn) XXX_Size() int

func (*DepositForBurn) XXX_Unmarshal 

func (m *DepositForBurn) XXX_Unmarshal(b []byte) error

type FiatTokenfactoryKeeper 

type FiatTokenfactoryKeeper interface {
	Burn(ctx sdk.Context, msg *fiattokenfactorytypes.MsgBurn) (*fiattokenfactorytypes.MsgBurnResponse, error)
	Mint(ctx sdk.Context, msg *fiattokenfactorytypes.MsgMint) (*fiattokenfactorytypes.MsgMintResponse, error)
	GetMintingDenom(ctx sdk.Context) (val fiattokenfactorytypes.MintingDenom)
}

type GenesisState 

type GenesisState struct {
	Owner                             string                             `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
	AttesterManager                   string                             `protobuf:"bytes,3,opt,name=attester_manager,json=attesterManager,proto3" json:"attester_manager,omitempty"`
	Pauser                            string                             `protobuf:"bytes,4,opt,name=pauser,proto3" json:"pauser,omitempty"`
	TokenController                   string                             `protobuf:"bytes,5,opt,name=token_controller,json=tokenController,proto3" json:"token_controller,omitempty"`
	AttesterList                      []Attester                         `protobuf:"bytes,6,rep,name=attester_list,json=attesterList,proto3" json:"attester_list"`
	PerMessageBurnLimitList           []PerMessageBurnLimit              `` /* 126-byte string literal not displayed */
	BurningAndMintingPaused           *BurningAndMintingPaused           `` /* 134-byte string literal not displayed */
	SendingAndReceivingMessagesPaused *SendingAndReceivingMessagesPaused `` /* 166-byte string literal not displayed */
	MaxMessageBodySize                *MaxMessageBodySize                `protobuf:"bytes,10,opt,name=max_message_body_size,json=maxMessageBodySize,proto3" json:"max_message_body_size,omitempty"`
	NextAvailableNonce                *Nonce                             `protobuf:"bytes,11,opt,name=next_available_nonce,json=nextAvailableNonce,proto3" json:"next_available_nonce,omitempty"`
	SignatureThreshold                *SignatureThreshold                `protobuf:"bytes,12,opt,name=signature_threshold,json=signatureThreshold,proto3" json:"signature_threshold,omitempty"`
	TokenPairList                     []TokenPair                        `protobuf:"bytes,13,rep,name=token_pair_list,json=tokenPairList,proto3" json:"token_pair_list"`
	UsedNoncesList                    []Nonce                            `protobuf:"bytes,14,rep,name=used_nonces_list,json=usedNoncesList,proto3" json:"used_nonces_list"`
	TokenMessengerList                []RemoteTokenMessenger             `protobuf:"bytes,15,rep,name=token_messenger_list,json=tokenMessengerList,proto3" json:"token_messenger_list"`
}

GenesisState defines the cctp module's genesis state.

func DefaultGenesis 

func DefaultGenesis() *GenesisState

DefaultGenesis returns the default genesis state

func (*GenesisState) Descriptor 

func (*GenesisState) Descriptor() ([]byte, []int)

func (*GenesisState) GetAttesterList 

func (m *GenesisState) GetAttesterList() []Attester

func (*GenesisState) GetAttesterManager 

func (m *GenesisState) GetAttesterManager() string

func (*GenesisState) GetBurningAndMintingPaused 

func (m *GenesisState) GetBurningAndMintingPaused() *BurningAndMintingPaused

func (*GenesisState) GetMaxMessageBodySize 

func (m *GenesisState) GetMaxMessageBodySize() *MaxMessageBodySize

func (*GenesisState) GetNextAvailableNonce 

func (m *GenesisState) GetNextAvailableNonce() *Nonce

func (*GenesisState) GetOwner 

func (m *GenesisState) GetOwner() string

func (*GenesisState) GetPauser 

func (m *GenesisState) GetPauser() string

func (*GenesisState) GetPerMessageBurnLimitList 

func (m *GenesisState) GetPerMessageBurnLimitList() []PerMessageBurnLimit

func (*GenesisState) GetSendingAndReceivingMessagesPaused 

func (m *GenesisState) GetSendingAndReceivingMessagesPaused() *SendingAndReceivingMessagesPaused

func (*GenesisState) GetSignatureThreshold 

func (m *GenesisState) GetSignatureThreshold() *SignatureThreshold

func (*GenesisState) GetTokenController 

func (m *GenesisState) GetTokenController() string

func (*GenesisState) GetTokenMessengerList 

func (m *GenesisState) GetTokenMessengerList() []RemoteTokenMessenger

func (*GenesisState) GetTokenPairList 

func (m *GenesisState) GetTokenPairList() []TokenPair

func (*GenesisState) GetUsedNoncesList 

func (m *GenesisState) GetUsedNoncesList() []Nonce

func (*GenesisState) Marshal 

func (m *GenesisState) Marshal() (dAtA []byte, err error)

func (*GenesisState) MarshalTo 

func (m *GenesisState) MarshalTo(dAtA []byte) (int, error)

func (*GenesisState) MarshalToSizedBuffer 

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*GenesisState) ProtoMessage 

func (*GenesisState) ProtoMessage()

func (*GenesisState) Reset 

func (m *GenesisState) Reset()

func (*GenesisState) Size 

func (m *GenesisState) Size() (n int)

func (*GenesisState) String 

func (m *GenesisState) String() string

func (*GenesisState) Unmarshal 

func (m *GenesisState) Unmarshal(dAtA []byte) error

func (GenesisState) Validate 

func (gs GenesisState) Validate() error

Validate performs basic genesis state validation returning an error upon any failure. Stateful checks are performed in InitGenesis

func (*GenesisState) XXX_DiscardUnknown 

func (m *GenesisState) XXX_DiscardUnknown()

func (*GenesisState) XXX_Marshal 

func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GenesisState) XXX_Merge 

func (m *GenesisState) XXX_Merge(src proto.Message)

func (*GenesisState) XXX_Size 

func (m *GenesisState) XXX_Size() int

func (*GenesisState) XXX_Unmarshal 

func (m *GenesisState) XXX_Unmarshal(b []byte) error

type MaxMessageBodySize 

type MaxMessageBodySize struct {
	Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
}

* Message format for BurningAndMintingPaused @param paused true if paused, false if not paused

func (*MaxMessageBodySize) Descriptor 

func (*MaxMessageBodySize) Descriptor() ([]byte, []int)

func (*MaxMessageBodySize) GetAmount 

func (m *MaxMessageBodySize) GetAmount() uint64

func (*MaxMessageBodySize) Marshal 

func (m *MaxMessageBodySize) Marshal() (dAtA []byte, err error)

func (*MaxMessageBodySize) MarshalTo 

func (m *MaxMessageBodySize) MarshalTo(dAtA []byte) (int, error)

func (*MaxMessageBodySize) MarshalToSizedBuffer 

func (m *MaxMessageBodySize) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MaxMessageBodySize) ProtoMessage 

func (*MaxMessageBodySize) ProtoMessage()

func (*MaxMessageBodySize) Reset 

func (m *MaxMessageBodySize) Reset()

func (*MaxMessageBodySize) Size 

func (m *MaxMessageBodySize) Size() (n int)

func (*MaxMessageBodySize) String 

func (m *MaxMessageBodySize) String() string

func (*MaxMessageBodySize) Unmarshal 

func (m *MaxMessageBodySize) Unmarshal(dAtA []byte) error

func (*MaxMessageBodySize) XXX_DiscardUnknown 

func (m *MaxMessageBodySize) XXX_DiscardUnknown()

func (*MaxMessageBodySize) XXX_Marshal 

func (m *MaxMessageBodySize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MaxMessageBodySize) XXX_Merge 

func (m *MaxMessageBodySize) XXX_Merge(src proto.Message)

func (*MaxMessageBodySize) XXX_Size 

func (m *MaxMessageBodySize) XXX_Size() int

func (*MaxMessageBodySize) XXX_Unmarshal 

func (m *MaxMessageBodySize) XXX_Unmarshal(b []byte) error

type MaxMessageBodySizeUpdated 

type MaxMessageBodySizeUpdated struct {
	NewMaxMessageBodySize uint64 `` /* 131-byte string literal not displayed */
}

* Emitted when max message body size is updated @param new_max_message_body_size new maximum message body size, in bytes

func (*MaxMessageBodySizeUpdated) Descriptor 

func (*MaxMessageBodySizeUpdated) Descriptor() ([]byte, []int)

func (*MaxMessageBodySizeUpdated) GetNewMaxMessageBodySize 

func (m *MaxMessageBodySizeUpdated) GetNewMaxMessageBodySize() uint64

func (*MaxMessageBodySizeUpdated) Marshal 

func (m *MaxMessageBodySizeUpdated) Marshal() (dAtA []byte, err error)

func (*MaxMessageBodySizeUpdated) MarshalTo 

func (m *MaxMessageBodySizeUpdated) MarshalTo(dAtA []byte) (int, error)

func (*MaxMessageBodySizeUpdated) MarshalToSizedBuffer 

func (m *MaxMessageBodySizeUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MaxMessageBodySizeUpdated) ProtoMessage 

func (*MaxMessageBodySizeUpdated) ProtoMessage()

func (*MaxMessageBodySizeUpdated) Reset 

func (m *MaxMessageBodySizeUpdated) Reset()

func (*MaxMessageBodySizeUpdated) Size 

func (m *MaxMessageBodySizeUpdated) Size() (n int)

func (*MaxMessageBodySizeUpdated) String 

func (m *MaxMessageBodySizeUpdated) String() string

func (*MaxMessageBodySizeUpdated) Unmarshal 

func (m *MaxMessageBodySizeUpdated) Unmarshal(dAtA []byte) error

func (*MaxMessageBodySizeUpdated) XXX_DiscardUnknown 

func (m *MaxMessageBodySizeUpdated) XXX_DiscardUnknown()

func (*MaxMessageBodySizeUpdated) XXX_Marshal 

func (m *MaxMessageBodySizeUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MaxMessageBodySizeUpdated) XXX_Merge 

func (m *MaxMessageBodySizeUpdated) XXX_Merge(src proto.Message)

func (*MaxMessageBodySizeUpdated) XXX_Size 

func (m *MaxMessageBodySizeUpdated) XXX_Size() int

func (*MaxMessageBodySizeUpdated) XXX_Unmarshal 

func (m *MaxMessageBodySizeUpdated) XXX_Unmarshal(b []byte) error

type Message 

type Message struct {
	Version           uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	SourceDomain      uint32 `protobuf:"varint,2,opt,name=source_domain,json=sourceDomain,proto3" json:"source_domain,omitempty"`
	DestinationDomain uint32 `protobuf:"varint,3,opt,name=destination_domain,json=destinationDomain,proto3" json:"destination_domain,omitempty"`
	Nonce             uint64 `protobuf:"varint,4,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Sender            []byte `protobuf:"bytes,5,opt,name=sender,proto3" json:"sender,omitempty"`
	Recipient         []byte `protobuf:"bytes,6,opt,name=recipient,proto3" json:"recipient,omitempty"`
	DestinationCaller []byte `protobuf:"bytes,7,opt,name=destination_caller,json=destinationCaller,proto3" json:"destination_caller,omitempty"`
	MessageBody       []byte `protobuf:"bytes,8,opt,name=message_body,json=messageBody,proto3" json:"message_body,omitempty"`
}

* Generic message header for all messages passing through CCTP The message body is dynamically-sized to support custom message body formats. Other fields must be fixed-size to avoid hash collisions.

Padding: uintNN fields are left-padded, and bytesNN fields are right-padded.

@param version the version of the message format @param source_domain domain of home chain @param destination_domain domain of destination chain @param nonce destination-specific nonce @param sender address of sender on source chain as bytes32 @param recipient address of recipient on destination chain as bytes32 @param destination_caller address of caller on destination chain as bytes32 @param message_body raw bytes of message body

func (*Message) Bytes 

func (msg *Message) Bytes() ([]byte, error)

Bytes parses a Message struct into a byte array sender, recipient, destination caller must be 32 bytes

func (*Message) Descriptor 

func (*Message) Descriptor() ([]byte, []int)

func (*Message) GetDestinationCaller 

func (m *Message) GetDestinationCaller() []byte

func (*Message) GetDestinationDomain 

func (m *Message) GetDestinationDomain() uint32

func (*Message) GetMessageBody 

func (m *Message) GetMessageBody() []byte

func (*Message) GetNonce 

func (m *Message) GetNonce() uint64

func (*Message) GetRecipient 

func (m *Message) GetRecipient() []byte

func (*Message) GetSender 

func (m *Message) GetSender() []byte

func (*Message) GetSourceDomain 

func (m *Message) GetSourceDomain() uint32

func (*Message) GetVersion 

func (m *Message) GetVersion() uint32

func (*Message) Marshal 

func (m *Message) Marshal() (dAtA []byte, err error)

func (*Message) MarshalTo 

func (m *Message) MarshalTo(dAtA []byte) (int, error)

func (*Message) MarshalToSizedBuffer 

func (m *Message) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Message) Parse 

func (msg *Message) Parse(bz []byte) (*Message, error)

Parse parses a byte array into a Message struct https://developers.circle.com/stablecoin/docs/cctp-technical-reference#message

func (*Message) ProtoMessage 

func (*Message) ProtoMessage()

func (*Message) Reset 

func (m *Message) Reset()

func (*Message) Size 

func (m *Message) Size() (n int)

func (*Message) String 

func (m *Message) String() string

func (*Message) Unmarshal 

func (m *Message) Unmarshal(dAtA []byte) error

func (*Message) XXX_DiscardUnknown 

func (m *Message) XXX_DiscardUnknown()

func (*Message) XXX_Marshal 

func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Message) XXX_Merge 

func (m *Message) XXX_Merge(src proto.Message)

func (*Message) XXX_Size 

func (m *Message) XXX_Size() int

func (*Message) XXX_Unmarshal 

func (m *Message) XXX_Unmarshal(b []byte) error

type MessageReceived 

type MessageReceived struct {
	Caller       string `protobuf:"bytes,1,opt,name=caller,proto3" json:"caller,omitempty"`
	SourceDomain uint32 `protobuf:"varint,2,opt,name=source_domain,json=sourceDomain,proto3" json:"source_domain,omitempty"`
	Nonce        uint64 `protobuf:"varint,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Sender       []byte `protobuf:"bytes,4,opt,name=sender,proto3" json:"sender,omitempty"`
	MessageBody  []byte `protobuf:"bytes,5,opt,name=message_body,json=messageBody,proto3" json:"message_body,omitempty"`
}

* Emitted when a new message is received @param caller caller (msg.sender) on destination domain @param source_domain the source domain this message originated from @param nonce the nonce unique to this message @param sender the sender of this message @param message_body message body bytes

func (*MessageReceived) Descriptor 

func (*MessageReceived) Descriptor() ([]byte, []int)

func (*MessageReceived) GetCaller 

func (m *MessageReceived) GetCaller() string

func (*MessageReceived) GetMessageBody 

func (m *MessageReceived) GetMessageBody() []byte

func (*MessageReceived) GetNonce 

func (m *MessageReceived) GetNonce() uint64

func (*MessageReceived) GetSender 

func (m *MessageReceived) GetSender() []byte

func (*MessageReceived) GetSourceDomain 

func (m *MessageReceived) GetSourceDomain() uint32

func (*MessageReceived) Marshal 

func (m *MessageReceived) Marshal() (dAtA []byte, err error)

func (*MessageReceived) MarshalTo 

func (m *MessageReceived) MarshalTo(dAtA []byte) (int, error)

func (*MessageReceived) MarshalToSizedBuffer 

func (m *MessageReceived) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MessageReceived) ProtoMessage 

func (*MessageReceived) ProtoMessage()

func (*MessageReceived) Reset 

func (m *MessageReceived) Reset()

func (*MessageReceived) Size 

func (m *MessageReceived) Size() (n int)

func (*MessageReceived) String 

func (m *MessageReceived) String() string

func (*MessageReceived) Unmarshal 

func (m *MessageReceived) Unmarshal(dAtA []byte) error

func (*MessageReceived) XXX_DiscardUnknown 

func (m *MessageReceived) XXX_DiscardUnknown()

func (*MessageReceived) XXX_Marshal 

func (m *MessageReceived) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MessageReceived) XXX_Merge 

func (m *MessageReceived) XXX_Merge(src proto.Message)

func (*MessageReceived) XXX_Size 

func (m *MessageReceived) XXX_Size() int

func (*MessageReceived) XXX_Unmarshal 

func (m *MessageReceived) XXX_Unmarshal(b []byte) error

type MessageSent 

type MessageSent struct {
	Message []byte `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}

* Emitted when a new message is dispatched @param message Raw bytes of message

func (*MessageSent) Descriptor 

func (*MessageSent) Descriptor() ([]byte, []int)

func (*MessageSent) GetMessage 

func (m *MessageSent) GetMessage() []byte

func (*MessageSent) Marshal 

func (m *MessageSent) Marshal() (dAtA []byte, err error)

func (*MessageSent) MarshalTo 

func (m *MessageSent) MarshalTo(dAtA []byte) (int, error)

func (*MessageSent) MarshalToSizedBuffer 

func (m *MessageSent) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MessageSent) ProtoMessage 

func (*MessageSent) ProtoMessage()

func (*MessageSent) Reset 

func (m *MessageSent) Reset()

func (*MessageSent) Size 

func (m *MessageSent) Size() (n int)

func (*MessageSent) String 

func (m *MessageSent) String() string

func (*MessageSent) Unmarshal 

func (m *MessageSent) Unmarshal(dAtA []byte) error

func (*MessageSent) XXX_DiscardUnknown 

func (m *MessageSent) XXX_DiscardUnknown()

func (*MessageSent) XXX_Marshal 

func (m *MessageSent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MessageSent) XXX_Merge 

func (m *MessageSent) XXX_Merge(src proto.Message)

func (*MessageSent) XXX_Size 

func (m *MessageSent) XXX_Size() int

func (*MessageSent) XXX_Unmarshal 

func (m *MessageSent) XXX_Unmarshal(b []byte) error

type MintAndWithdraw 

type MintAndWithdraw struct {
	MintRecipient []byte                `protobuf:"bytes,1,opt,name=mint_recipient,json=mintRecipient,proto3" json:"mint_recipient,omitempty"`
	Amount        cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
	MintToken     string                `protobuf:"bytes,3,opt,name=mint_token,json=mintToken,proto3" json:"mint_token,omitempty"`
}

* Emitted when tokens are minted @param mint_recipient recipient address of minted tokens @param amount amount of minted tokens @param mint_token contract address of minted token

func (*MintAndWithdraw) Descriptor 

func (*MintAndWithdraw) Descriptor() ([]byte, []int)

func (*MintAndWithdraw) GetMintRecipient 

func (m *MintAndWithdraw) GetMintRecipient() []byte

func (*MintAndWithdraw) GetMintToken 

func (m *MintAndWithdraw) GetMintToken() string

func (*MintAndWithdraw) Marshal 

func (m *MintAndWithdraw) Marshal() (dAtA []byte, err error)

func (*MintAndWithdraw) MarshalTo 

func (m *MintAndWithdraw) MarshalTo(dAtA []byte) (int, error)

func (*MintAndWithdraw) MarshalToSizedBuffer 

func (m *MintAndWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MintAndWithdraw) ProtoMessage 

func (*MintAndWithdraw) ProtoMessage()

func (*MintAndWithdraw) Reset 

func (m *MintAndWithdraw) Reset()

func (*MintAndWithdraw) Size 

func (m *MintAndWithdraw) Size() (n int)

func (*MintAndWithdraw) String 

func (m *MintAndWithdraw) String() string

func (*MintAndWithdraw) Unmarshal 

func (m *MintAndWithdraw) Unmarshal(dAtA []byte) error

func (*MintAndWithdraw) XXX_DiscardUnknown 

func (m *MintAndWithdraw) XXX_DiscardUnknown()

func (*MintAndWithdraw) XXX_Marshal 

func (m *MintAndWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MintAndWithdraw) XXX_Merge 

func (m *MintAndWithdraw) XXX_Merge(src proto.Message)

func (*MintAndWithdraw) XXX_Size 

func (m *MintAndWithdraw) XXX_Size() int

func (*MintAndWithdraw) XXX_Unmarshal 

func (m *MintAndWithdraw) XXX_Unmarshal(b []byte) error

type MsgAcceptOwner 

type MsgAcceptOwner struct {
	From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
}

func NewMsgAcceptOwner 

func NewMsgAcceptOwner(from string) *MsgAcceptOwner

func (*MsgAcceptOwner) Descriptor 

func (*MsgAcceptOwner) Descriptor() ([]byte, []int)

func (*MsgAcceptOwner) GetFrom 

func (m *MsgAcceptOwner) GetFrom() string

func (*MsgAcceptOwner) GetSignBytes 

func (msg *MsgAcceptOwner) GetSignBytes() []byte

func (*MsgAcceptOwner) GetSigners 

func (msg *MsgAcceptOwner) GetSigners() []sdk.AccAddress

func (*MsgAcceptOwner) Marshal 

func (m *MsgAcceptOwner) Marshal() (dAtA []byte, err error)

func (*MsgAcceptOwner) MarshalTo 

func (m *MsgAcceptOwner) MarshalTo(dAtA []byte) (int, error)

func (*MsgAcceptOwner) MarshalToSizedBuffer 

func (m *MsgAcceptOwner) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgAcceptOwner) ProtoMessage 

func (*MsgAcceptOwner) ProtoMessage()

func (*MsgAcceptOwner) Reset 

func (m *MsgAcceptOwner) Reset()

func (*MsgAcceptOwner) Route 

func (msg *MsgAcceptOwner) Route() string

func (*MsgAcceptOwner) Size 

func (m *MsgAcceptOwner) Size() (n int)

func (*MsgAcceptOwner) String 

func (m *MsgAcceptOwner) String() string

func (*MsgAcceptOwner) Type 

func (msg *MsgAcceptOwner) Type() string

func (*MsgAcceptOwner) Unmarshal 

func (m *MsgAcceptOwner) Unmarshal(dAtA []byte) error

func (*MsgAcceptOwner) ValidateBasic 

func (msg *MsgAcceptOwner) ValidateBasic() error

func (*MsgAcceptOwner) XXX_DiscardUnknown 

func (m *MsgAcceptOwner) XXX_DiscardUnknown()

func (*MsgAcceptOwner) XXX_Marshal 

func (m *MsgAcceptOwner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgAcceptOwner) XXX_Merge 

func (m *MsgAcceptOwner) XXX_Merge(src proto.Message)

func (*MsgAcceptOwner) XXX_Size 

func (m *MsgAcceptOwner) XXX_Size() int

func (*MsgAcceptOwner) XXX_Unmarshal 

func (m *MsgAcceptOwner) XXX_Unmarshal(b []byte) error

type MsgAcceptOwnerResponse 

type MsgAcceptOwnerResponse struct {
}

func (*MsgAcceptOwnerResponse) Descriptor 

func (*MsgAcceptOwnerResponse) Descriptor() ([]byte, []int)

func (*MsgAcceptOwnerResponse) Marshal 

func (m *MsgAcceptOwnerResponse) Marshal() (dAtA []byte, err error)

func (*MsgAcceptOwnerResponse) MarshalTo 

func (m *MsgAcceptOwnerResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgAcceptOwnerResponse) MarshalToSizedBuffer 

func (m *MsgAcceptOwnerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgAcceptOwnerResponse) ProtoMessage 

func (*MsgAcceptOwnerResponse) ProtoMessage()

func (*MsgAcceptOwnerResponse) Reset 

func (m *MsgAcceptOwnerResponse) Reset()

func (*MsgAcceptOwnerResponse) Size 

func (m *MsgAcceptOwnerResponse) Size() (n int)

func (*MsgAcceptOwnerResponse) String 

func (m *MsgAcceptOwnerResponse) String() string

func (*MsgAcceptOwnerResponse) Unmarshal 

func (m *MsgAcceptOwnerResponse) Unmarshal(dAtA []byte) error

func (*MsgAcceptOwnerResponse) XXX_DiscardUnknown 

func (m *MsgAcceptOwnerResponse) XXX_DiscardUnknown()

func (*MsgAcceptOwnerResponse) XXX_Marshal 

func (m *MsgAcceptOwnerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgAcceptOwnerResponse) XXX_Merge 

func (m *MsgAcceptOwnerResponse) XXX_Merge(src proto.Message)

func (*MsgAcceptOwnerResponse) XXX_Size 

func (m *MsgAcceptOwnerResponse) XXX_Size() int

func (*MsgAcceptOwnerResponse) XXX_Unmarshal 

func (m *MsgAcceptOwnerResponse) XXX_Unmarshal(b []byte) error

type MsgAddRemoteTokenMessenger 

type MsgAddRemoteTokenMessenger struct {
	From     string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	DomainId uint32 `protobuf:"varint,2,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
	Address  []byte `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
}

func NewMsgAddRemoteTokenMessenger 

func NewMsgAddRemoteTokenMessenger(from string, domainId uint32, address []byte) *MsgAddRemoteTokenMessenger

func (*MsgAddRemoteTokenMessenger) Descriptor 

func (*MsgAddRemoteTokenMessenger) Descriptor() ([]byte, []int)

func (*MsgAddRemoteTokenMessenger) GetAddress 

func (m *MsgAddRemoteTokenMessenger) GetAddress() []byte

func (*MsgAddRemoteTokenMessenger) GetDomainId 

func (m *MsgAddRemoteTokenMessenger) GetDomainId() uint32

func (*MsgAddRemoteTokenMessenger) GetFrom 

func (m *MsgAddRemoteTokenMessenger) GetFrom() string

func (*MsgAddRemoteTokenMessenger) GetSignBytes 

func (msg *MsgAddRemoteTokenMessenger) GetSignBytes() []byte

func (*MsgAddRemoteTokenMessenger) GetSigners 

func (msg *MsgAddRemoteTokenMessenger) GetSigners() []sdk.AccAddress

func (*MsgAddRemoteTokenMessenger) Marshal 

func (m *MsgAddRemoteTokenMessenger) Marshal() (dAtA []byte, err error)

func (*MsgAddRemoteTokenMessenger) MarshalTo 

func (m *MsgAddRemoteTokenMessenger) MarshalTo(dAtA []byte) (int, error)

func (*MsgAddRemoteTokenMessenger) MarshalToSizedBuffer 

func (m *MsgAddRemoteTokenMessenger) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgAddRemoteTokenMessenger) ProtoMessage 

func (*MsgAddRemoteTokenMessenger) ProtoMessage()

func (*MsgAddRemoteTokenMessenger) Reset 

func (m *MsgAddRemoteTokenMessenger) Reset()

func (*MsgAddRemoteTokenMessenger) Route 

func (msg *MsgAddRemoteTokenMessenger) Route() string

func (*MsgAddRemoteTokenMessenger) Size 

func (m *MsgAddRemoteTokenMessenger) Size() (n int)

func (*MsgAddRemoteTokenMessenger) String 

func (m *MsgAddRemoteTokenMessenger) String() string

func (*MsgAddRemoteTokenMessenger) Type 

func (msg *MsgAddRemoteTokenMessenger) Type() string

func (*MsgAddRemoteTokenMessenger) Unmarshal 

func (m *MsgAddRemoteTokenMessenger) Unmarshal(dAtA []byte) error

func (*MsgAddRemoteTokenMessenger) ValidateBasic 

func (msg *MsgAddRemoteTokenMessenger) ValidateBasic() error

func (*MsgAddRemoteTokenMessenger) XXX_DiscardUnknown 

func (m *MsgAddRemoteTokenMessenger) XXX_DiscardUnknown()

func (*MsgAddRemoteTokenMessenger) XXX_Marshal 

func (m *MsgAddRemoteTokenMessenger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgAddRemoteTokenMessenger) XXX_Merge 

func (m *MsgAddRemoteTokenMessenger) XXX_Merge(src proto.Message)

func (*MsgAddRemoteTokenMessenger) XXX_Size 

func (m *MsgAddRemoteTokenMessenger) XXX_Size() int

func (*MsgAddRemoteTokenMessenger) XXX_Unmarshal 

func (m *MsgAddRemoteTokenMessenger) XXX_Unmarshal(b []byte) error

type MsgAddRemoteTokenMessengerResponse 

type MsgAddRemoteTokenMessengerResponse struct {
}

func (*MsgAddRemoteTokenMessengerResponse) Descriptor 

func (*MsgAddRemoteTokenMessengerResponse) Descriptor() ([]byte, []int)

func (*MsgAddRemoteTokenMessengerResponse) Marshal 

func (m *MsgAddRemoteTokenMessengerResponse) Marshal() (dAtA []byte, err error)

func (*MsgAddRemoteTokenMessengerResponse) MarshalTo 

func (m *MsgAddRemoteTokenMessengerResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgAddRemoteTokenMessengerResponse) MarshalToSizedBuffer 

func (m *MsgAddRemoteTokenMessengerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgAddRemoteTokenMessengerResponse) ProtoMessage 

func (*MsgAddRemoteTokenMessengerResponse) ProtoMessage()

func (*MsgAddRemoteTokenMessengerResponse) Reset 

func (m *MsgAddRemoteTokenMessengerResponse) Reset()

func (*MsgAddRemoteTokenMessengerResponse) Size 

func (m *MsgAddRemoteTokenMessengerResponse) Size() (n int)

func (*MsgAddRemoteTokenMessengerResponse) String 

func (m *MsgAddRemoteTokenMessengerResponse) String() string

func (*MsgAddRemoteTokenMessengerResponse) Unmarshal 

func (m *MsgAddRemoteTokenMessengerResponse) Unmarshal(dAtA []byte) error

func (*MsgAddRemoteTokenMessengerResponse) XXX_DiscardUnknown 

func (m *MsgAddRemoteTokenMessengerResponse) XXX_DiscardUnknown()

func (*MsgAddRemoteTokenMessengerResponse) XXX_Marshal 

func (m *MsgAddRemoteTokenMessengerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgAddRemoteTokenMessengerResponse) XXX_Merge 

func (m *MsgAddRemoteTokenMessengerResponse) XXX_Merge(src proto.Message)

func (*MsgAddRemoteTokenMessengerResponse) XXX_Size 

func (m *MsgAddRemoteTokenMessengerResponse) XXX_Size() int

func (*MsgAddRemoteTokenMessengerResponse) XXX_Unmarshal 

func (m *MsgAddRemoteTokenMessengerResponse) XXX_Unmarshal(b []byte) error

type MsgClient 

type MsgClient interface {
	AcceptOwner(ctx context.Context, in *MsgAcceptOwner, opts ...grpc.CallOption) (*MsgAcceptOwnerResponse, error)
	AddRemoteTokenMessenger(ctx context.Context, in *MsgAddRemoteTokenMessenger, opts ...grpc.CallOption) (*MsgAddRemoteTokenMessengerResponse, error)
	DepositForBurn(ctx context.Context, in *MsgDepositForBurn, opts ...grpc.CallOption) (*MsgDepositForBurnResponse, error)
	DepositForBurnWithCaller(ctx context.Context, in *MsgDepositForBurnWithCaller, opts ...grpc.CallOption) (*MsgDepositForBurnWithCallerResponse, error)
	DisableAttester(ctx context.Context, in *MsgDisableAttester, opts ...grpc.CallOption) (*MsgDisableAttesterResponse, error)
	EnableAttester(ctx context.Context, in *MsgEnableAttester, opts ...grpc.CallOption) (*MsgEnableAttesterResponse, error)
	LinkTokenPair(ctx context.Context, in *MsgLinkTokenPair, opts ...grpc.CallOption) (*MsgLinkTokenPairResponse, error)
	PauseBurningAndMinting(ctx context.Context, in *MsgPauseBurningAndMinting, opts ...grpc.CallOption) (*MsgPauseBurningAndMintingResponse, error)
	PauseSendingAndReceivingMessages(ctx context.Context, in *MsgPauseSendingAndReceivingMessages, opts ...grpc.CallOption) (*MsgPauseSendingAndReceivingMessagesResponse, error)
	ReceiveMessage(ctx context.Context, in *MsgReceiveMessage, opts ...grpc.CallOption) (*MsgReceiveMessageResponse, error)
	RemoveRemoteTokenMessenger(ctx context.Context, in *MsgRemoveRemoteTokenMessenger, opts ...grpc.CallOption) (*MsgRemoveRemoteTokenMessengerResponse, error)
	ReplaceDepositForBurn(ctx context.Context, in *MsgReplaceDepositForBurn, opts ...grpc.CallOption) (*MsgReplaceDepositForBurnResponse, error)
	ReplaceMessage(ctx context.Context, in *MsgReplaceMessage, opts ...grpc.CallOption) (*MsgReplaceMessageResponse, error)
	SendMessage(ctx context.Context, in *MsgSendMessage, opts ...grpc.CallOption) (*MsgSendMessageResponse, error)
	SendMessageWithCaller(ctx context.Context, in *MsgSendMessageWithCaller, opts ...grpc.CallOption) (*MsgSendMessageWithCallerResponse, error)
	UnlinkTokenPair(ctx context.Context, in *MsgUnlinkTokenPair, opts ...grpc.CallOption) (*MsgUnlinkTokenPairResponse, error)
	UnpauseBurningAndMinting(ctx context.Context, in *MsgUnpauseBurningAndMinting, opts ...grpc.CallOption) (*MsgUnpauseBurningAndMintingResponse, error)
	UnpauseSendingAndReceivingMessages(ctx context.Context, in *MsgUnpauseSendingAndReceivingMessages, opts ...grpc.CallOption) (*MsgUnpauseSendingAndReceivingMessagesResponse, error)
	UpdateOwner(ctx context.Context, in *MsgUpdateOwner, opts ...grpc.CallOption) (*MsgUpdateOwnerResponse, error)
	UpdateAttesterManager(ctx context.Context, in *MsgUpdateAttesterManager, opts ...grpc.CallOption) (*MsgUpdateAttesterManagerResponse, error)
	UpdateTokenController(ctx context.Context, in *MsgUpdateTokenController, opts ...grpc.CallOption) (*MsgUpdateTokenControllerResponse, error)
	UpdatePauser(ctx context.Context, in *MsgUpdatePauser, opts ...grpc.CallOption) (*MsgUpdatePauserResponse, error)
	UpdateMaxMessageBodySize(ctx context.Context, in *MsgUpdateMaxMessageBodySize, opts ...grpc.CallOption) (*MsgUpdateMaxMessageBodySizeResponse, error)
	SetMaxBurnAmountPerMessage(ctx context.Context, in *MsgSetMaxBurnAmountPerMessage, opts ...grpc.CallOption) (*MsgSetMaxBurnAmountPerMessageResponse, error)
	UpdateSignatureThreshold(ctx context.Context, in *MsgUpdateSignatureThreshold, opts ...grpc.CallOption) (*MsgUpdateSignatureThresholdResponse, error)
}

MsgClient is the client API for Msg service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewMsgClient 

func NewMsgClient(cc grpc1.ClientConn) MsgClient

type MsgDepositForBurn 

type MsgDepositForBurn struct {
	From              string                `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Amount            cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
	DestinationDomain uint32                `protobuf:"varint,3,opt,name=destination_domain,json=destinationDomain,proto3" json:"destination_domain,omitempty"`
	MintRecipient     []byte                `protobuf:"bytes,4,opt,name=mint_recipient,json=mintRecipient,proto3" json:"mint_recipient,omitempty"`
	BurnToken         string                `protobuf:"bytes,5,opt,name=burn_token,json=burnToken,proto3" json:"burn_token,omitempty"`
}

func NewMsgDepositForBurn 

func NewMsgDepositForBurn(from string, amount math.Int, destinationDomain uint32, mintRecipient []byte, burnToken string) *MsgDepositForBurn

func (*MsgDepositForBurn) Descriptor 

func (*MsgDepositForBurn) Descriptor() ([]byte, []int)

func (*MsgDepositForBurn) GetBurnToken 

func (m *MsgDepositForBurn) GetBurnToken() string

func (*MsgDepositForBurn) GetDestinationDomain 

func (m *MsgDepositForBurn) GetDestinationDomain() uint32

func (*MsgDepositForBurn) GetFrom 

func (m *MsgDepositForBurn) GetFrom() string

func (*MsgDepositForBurn) GetMintRecipient 

func (m *MsgDepositForBurn) GetMintRecipient() []byte

func (*MsgDepositForBurn) GetSignBytes 

func (msg *MsgDepositForBurn) GetSignBytes() []byte

func (*MsgDepositForBurn) GetSigners 

func (msg *MsgDepositForBurn) GetSigners() []sdk.AccAddress

func (*MsgDepositForBurn) Marshal 

func (m *MsgDepositForBurn) Marshal() (dAtA []byte, err error)

func (*MsgDepositForBurn) MarshalTo 

func (m *MsgDepositForBurn) MarshalTo(dAtA []byte) (int, error)

func (*MsgDepositForBurn) MarshalToSizedBuffer 

func (m *MsgDepositForBurn) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgDepositForBurn) ProtoMessage 

func (*MsgDepositForBurn) ProtoMessage()

func (*MsgDepositForBurn) Reset 

func (m *MsgDepositForBurn) Reset()

func (*MsgDepositForBurn) Route 

func (msg *MsgDepositForBurn) Route() string

func (*MsgDepositForBurn) Size 

func (m *MsgDepositForBurn) Size() (n int)

func (*MsgDepositForBurn) String 

func (m *MsgDepositForBurn) String() string

func (*MsgDepositForBurn) Type 

func (msg *MsgDepositForBurn) Type() string

func (*MsgDepositForBurn) Unmarshal 

func (m *MsgDepositForBurn) Unmarshal(dAtA []byte) error

func (*MsgDepositForBurn) ValidateBasic 

func (msg *MsgDepositForBurn) ValidateBasic() error

func (*MsgDepositForBurn) XXX_DiscardUnknown 

func (m *MsgDepositForBurn) XXX_DiscardUnknown()

func (*MsgDepositForBurn) XXX_Marshal 

func (m *MsgDepositForBurn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgDepositForBurn) XXX_Merge 

func (m *MsgDepositForBurn) XXX_Merge(src proto.Message)

func (*MsgDepositForBurn) XXX_Size 

func (m *MsgDepositForBurn) XXX_Size() int

func (*MsgDepositForBurn) XXX_Unmarshal 

func (m *MsgDepositForBurn) XXX_Unmarshal(b []byte) error

type MsgDepositForBurnResponse 

type MsgDepositForBurnResponse struct {
	Nonce uint64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

func (*MsgDepositForBurnResponse) Descriptor 

func (*MsgDepositForBurnResponse) Descriptor() ([]byte, []int)

func (*MsgDepositForBurnResponse) GetNonce 

func (m *MsgDepositForBurnResponse) GetNonce() uint64

func (*MsgDepositForBurnResponse) Marshal 

func (m *MsgDepositForBurnResponse) Marshal() (dAtA []byte, err error)

func (*MsgDepositForBurnResponse) MarshalTo 

func (m *MsgDepositForBurnResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgDepositForBurnResponse) MarshalToSizedBuffer 

func (m *MsgDepositForBurnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgDepositForBurnResponse) ProtoMessage 

func (*MsgDepositForBurnResponse) ProtoMessage()

func (*MsgDepositForBurnResponse) Reset 

func (m *MsgDepositForBurnResponse) Reset()

func (*MsgDepositForBurnResponse) Size 

func (m *MsgDepositForBurnResponse) Size() (n int)

func (*MsgDepositForBurnResponse) String 

func (m *MsgDepositForBurnResponse) String() string

func (*MsgDepositForBurnResponse) Unmarshal 

func (m *MsgDepositForBurnResponse) Unmarshal(dAtA []byte) error

func (*MsgDepositForBurnResponse) XXX_DiscardUnknown 

func (m *MsgDepositForBurnResponse) XXX_DiscardUnknown()

func (*MsgDepositForBurnResponse) XXX_Marshal 

func (m *MsgDepositForBurnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgDepositForBurnResponse) XXX_Merge 

func (m *MsgDepositForBurnResponse) XXX_Merge(src proto.Message)

func (*MsgDepositForBurnResponse) XXX_Size 

func (m *MsgDepositForBurnResponse) XXX_Size() int

func (*MsgDepositForBurnResponse) XXX_Unmarshal 

func (m *MsgDepositForBurnResponse) XXX_Unmarshal(b []byte) error

type MsgDepositForBurnWithCaller 

type MsgDepositForBurnWithCaller struct {
	From              string                `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Amount            cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
	DestinationDomain uint32                `protobuf:"varint,3,opt,name=destination_domain,json=destinationDomain,proto3" json:"destination_domain,omitempty"`
	MintRecipient     []byte                `protobuf:"bytes,4,opt,name=mint_recipient,json=mintRecipient,proto3" json:"mint_recipient,omitempty"`
	BurnToken         string                `protobuf:"bytes,5,opt,name=burn_token,json=burnToken,proto3" json:"burn_token,omitempty"`
	DestinationCaller []byte                `protobuf:"bytes,6,opt,name=destination_caller,json=destinationCaller,proto3" json:"destination_caller,omitempty"`
}

func NewMsgDepositForBurnWithCaller 

func NewMsgDepositForBurnWithCaller(from string, amount math.Int, destinationDomain uint32, mintRecipient []byte, burnToken string, destinationCaller []byte) *MsgDepositForBurnWithCaller

func (*MsgDepositForBurnWithCaller) Descriptor 

func (*MsgDepositForBurnWithCaller) Descriptor() ([]byte, []int)

func (*MsgDepositForBurnWithCaller) GetBurnToken 

func (m *MsgDepositForBurnWithCaller) GetBurnToken() string

func (*MsgDepositForBurnWithCaller) GetDestinationCaller 

func (m *MsgDepositForBurnWithCaller) GetDestinationCaller() []byte

func (*MsgDepositForBurnWithCaller) GetDestinationDomain 

func (m *MsgDepositForBurnWithCaller) GetDestinationDomain() uint32

func (*MsgDepositForBurnWithCaller) GetFrom 

func (m *MsgDepositForBurnWithCaller) GetFrom() string

func (*MsgDepositForBurnWithCaller) GetMintRecipient 

func (m *MsgDepositForBurnWithCaller) GetMintRecipient() []byte

func (*MsgDepositForBurnWithCaller) GetSignBytes 

func (msg *MsgDepositForBurnWithCaller) GetSignBytes() []byte

func (*MsgDepositForBurnWithCaller) GetSigners 

func (msg *MsgDepositForBurnWithCaller) GetSigners() []sdk.AccAddress

func (*MsgDepositForBurnWithCaller) Marshal 

func (m *MsgDepositForBurnWithCaller) Marshal() (dAtA []byte, err error)

func (*MsgDepositForBurnWithCaller) MarshalTo 

func (m *MsgDepositForBurnWithCaller) MarshalTo(dAtA []byte) (int, error)

func (*MsgDepositForBurnWithCaller) MarshalToSizedBuffer 

func (m *MsgDepositForBurnWithCaller) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgDepositForBurnWithCaller) ProtoMessage 

func (*MsgDepositForBurnWithCaller) ProtoMessage()

func (*MsgDepositForBurnWithCaller) Reset 

func (m *MsgDepositForBurnWithCaller) Reset()

func (*MsgDepositForBurnWithCaller) Route 

func (msg *MsgDepositForBurnWithCaller) Route() string

func (*MsgDepositForBurnWithCaller) Size 

func (m *MsgDepositForBurnWithCaller) Size() (n int)

func (*MsgDepositForBurnWithCaller) String 

func (m *MsgDepositForBurnWithCaller) String() string

func (*MsgDepositForBurnWithCaller) Type 

func (msg *MsgDepositForBurnWithCaller) Type() string

func (*MsgDepositForBurnWithCaller) Unmarshal 

func (m *MsgDepositForBurnWithCaller) Unmarshal(dAtA []byte) error

func (*MsgDepositForBurnWithCaller) ValidateBasic 

func (msg *MsgDepositForBurnWithCaller) ValidateBasic() error

func (*MsgDepositForBurnWithCaller) XXX_DiscardUnknown 

func (m *MsgDepositForBurnWithCaller) XXX_DiscardUnknown()

func (*MsgDepositForBurnWithCaller) XXX_Marshal 

func (m *MsgDepositForBurnWithCaller) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgDepositForBurnWithCaller) XXX_Merge 

func (m *MsgDepositForBurnWithCaller) XXX_Merge(src proto.Message)

func (*MsgDepositForBurnWithCaller) XXX_Size 

func (m *MsgDepositForBurnWithCaller) XXX_Size() int

func (*MsgDepositForBurnWithCaller) XXX_Unmarshal 

func (m *MsgDepositForBurnWithCaller) XXX_Unmarshal(b []byte) error

type MsgDepositForBurnWithCallerResponse 

type MsgDepositForBurnWithCallerResponse struct {
	Nonce uint64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

func (*MsgDepositForBurnWithCallerResponse) Descriptor 

func (*MsgDepositForBurnWithCallerResponse) Descriptor() ([]byte, []int)

func (*MsgDepositForBurnWithCallerResponse) GetNonce 

func (m *MsgDepositForBurnWithCallerResponse) GetNonce() uint64

func (*MsgDepositForBurnWithCallerResponse) Marshal 

func (m *MsgDepositForBurnWithCallerResponse) Marshal() (dAtA []byte, err error)

func (*MsgDepositForBurnWithCallerResponse) MarshalTo 

func (m *MsgDepositForBurnWithCallerResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgDepositForBurnWithCallerResponse) MarshalToSizedBuffer 

func (m *MsgDepositForBurnWithCallerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgDepositForBurnWithCallerResponse) ProtoMessage 

func (*MsgDepositForBurnWithCallerResponse) ProtoMessage()

func (*MsgDepositForBurnWithCallerResponse) Reset 

func (m *MsgDepositForBurnWithCallerResponse) Reset()

func (*MsgDepositForBurnWithCallerResponse) Size 

func (m *MsgDepositForBurnWithCallerResponse) Size() (n int)

func (*MsgDepositForBurnWithCallerResponse) String 

func (m *MsgDepositForBurnWithCallerResponse) String() string

func (*MsgDepositForBurnWithCallerResponse) Unmarshal 

func (m *MsgDepositForBurnWithCallerResponse) Unmarshal(dAtA []byte) error

func (*MsgDepositForBurnWithCallerResponse) XXX_DiscardUnknown 

func (m *MsgDepositForBurnWithCallerResponse) XXX_DiscardUnknown()

func (*MsgDepositForBurnWithCallerResponse) XXX_Marshal 

func (m *MsgDepositForBurnWithCallerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgDepositForBurnWithCallerResponse) XXX_Merge 

func (m *MsgDepositForBurnWithCallerResponse) XXX_Merge(src proto.Message)

func (*MsgDepositForBurnWithCallerResponse) XXX_Size 

func (m *MsgDepositForBurnWithCallerResponse) XXX_Size() int

func (*MsgDepositForBurnWithCallerResponse) XXX_Unmarshal 

func (m *MsgDepositForBurnWithCallerResponse) XXX_Unmarshal(b []byte) error

type MsgDisableAttester 

type MsgDisableAttester struct {
	From     string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Attester string `protobuf:"bytes,2,opt,name=attester,proto3" json:"attester,omitempty"`
}

func NewMsgDisableAttester 

func NewMsgDisableAttester(from string, attester string) *MsgDisableAttester

func (*MsgDisableAttester) Descriptor 

func (*MsgDisableAttester) Descriptor() ([]byte, []int)

func (*MsgDisableAttester) GetAttester 

func (m *MsgDisableAttester) GetAttester() string

func (*MsgDisableAttester) GetFrom 

func (m *MsgDisableAttester) GetFrom() string

func (*MsgDisableAttester) GetSignBytes 

func (msg *MsgDisableAttester) GetSignBytes() []byte

func (*MsgDisableAttester) GetSigners 

func (msg *MsgDisableAttester) GetSigners() []sdk.AccAddress

func (*MsgDisableAttester) Marshal 

func (m *MsgDisableAttester) Marshal() (dAtA []byte, err error)

func (*MsgDisableAttester) MarshalTo 

func (m *MsgDisableAttester) MarshalTo(dAtA []byte) (int, error)

func (*MsgDisableAttester) MarshalToSizedBuffer 

func (m *MsgDisableAttester) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgDisableAttester) ProtoMessage 

func (*MsgDisableAttester) ProtoMessage()

func (*MsgDisableAttester) Reset 

func (m *MsgDisableAttester) Reset()

func (*MsgDisableAttester) Route 

func (msg *MsgDisableAttester) Route() string

func (*MsgDisableAttester) Size 

func (m *MsgDisableAttester) Size() (n int)

func (*MsgDisableAttester) String 

func (m *MsgDisableAttester) String() string

func (*MsgDisableAttester) Type 

func (msg *MsgDisableAttester) Type() string

func (*MsgDisableAttester) Unmarshal 

func (m *MsgDisableAttester) Unmarshal(dAtA []byte) error

func (*MsgDisableAttester) ValidateBasic 

func (msg *MsgDisableAttester) ValidateBasic() error

func (*MsgDisableAttester) XXX_DiscardUnknown 

func (m *MsgDisableAttester) XXX_DiscardUnknown()

func (*MsgDisableAttester) XXX_Marshal 

func (m *MsgDisableAttester) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgDisableAttester) XXX_Merge 

func (m *MsgDisableAttester) XXX_Merge(src proto.Message)

func (*MsgDisableAttester) XXX_Size 

func (m *MsgDisableAttester) XXX_Size() int

func (*MsgDisableAttester) XXX_Unmarshal 

func (m *MsgDisableAttester) XXX_Unmarshal(b []byte) error

type MsgDisableAttesterResponse 

type MsgDisableAttesterResponse struct {
}

func (*MsgDisableAttesterResponse) Descriptor 

func (*MsgDisableAttesterResponse) Descriptor() ([]byte, []int)

func (*MsgDisableAttesterResponse) Marshal 

func (m *MsgDisableAttesterResponse) Marshal() (dAtA []byte, err error)

func (*MsgDisableAttesterResponse) MarshalTo 

func (m *MsgDisableAttesterResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgDisableAttesterResponse) MarshalToSizedBuffer 

func (m *MsgDisableAttesterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgDisableAttesterResponse) ProtoMessage 

func (*MsgDisableAttesterResponse) ProtoMessage()

func (*MsgDisableAttesterResponse) Reset 

func (m *MsgDisableAttesterResponse) Reset()

func (*MsgDisableAttesterResponse) Size 

func (m *MsgDisableAttesterResponse) Size() (n int)

func (*MsgDisableAttesterResponse) String 

func (m *MsgDisableAttesterResponse) String() string

func (*MsgDisableAttesterResponse) Unmarshal 

func (m *MsgDisableAttesterResponse) Unmarshal(dAtA []byte) error

func (*MsgDisableAttesterResponse) XXX_DiscardUnknown 

func (m *MsgDisableAttesterResponse) XXX_DiscardUnknown()

func (*MsgDisableAttesterResponse) XXX_Marshal 

func (m *MsgDisableAttesterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgDisableAttesterResponse) XXX_Merge 

func (m *MsgDisableAttesterResponse) XXX_Merge(src proto.Message)

func (*MsgDisableAttesterResponse) XXX_Size 

func (m *MsgDisableAttesterResponse) XXX_Size() int

func (*MsgDisableAttesterResponse) XXX_Unmarshal 

func (m *MsgDisableAttesterResponse) XXX_Unmarshal(b []byte) error

type MsgEnableAttester 

type MsgEnableAttester struct {
	From     string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Attester string `protobuf:"bytes,2,opt,name=attester,proto3" json:"attester,omitempty"`
}

func NewMsgEnableAttester 

func NewMsgEnableAttester(from string, attester string) *MsgEnableAttester

func (*MsgEnableAttester) Descriptor 

func (*MsgEnableAttester) Descriptor() ([]byte, []int)

func (*MsgEnableAttester) GetAttester 

func (m *MsgEnableAttester) GetAttester() string

func (*MsgEnableAttester) GetFrom 

func (m *MsgEnableAttester) GetFrom() string

func (*MsgEnableAttester) GetSignBytes 

func (msg *MsgEnableAttester) GetSignBytes() []byte

func (*MsgEnableAttester) GetSigners 

func (msg *MsgEnableAttester) GetSigners() []sdk.AccAddress

func (*MsgEnableAttester) Marshal 

func (m *MsgEnableAttester) Marshal() (dAtA []byte, err error)

func (*MsgEnableAttester) MarshalTo 

func (m *MsgEnableAttester) MarshalTo(dAtA []byte) (int, error)

func (*MsgEnableAttester) MarshalToSizedBuffer 

func (m *MsgEnableAttester) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgEnableAttester) ProtoMessage 

func (*MsgEnableAttester) ProtoMessage()

func (*MsgEnableAttester) Reset 

func (m *MsgEnableAttester) Reset()

func (*MsgEnableAttester) Route 

func (msg *MsgEnableAttester) Route() string

func (*MsgEnableAttester) Size 

func (m *MsgEnableAttester) Size() (n int)

func (*MsgEnableAttester) String 

func (m *MsgEnableAttester) String() string

func (*MsgEnableAttester) Type 

func (msg *MsgEnableAttester) Type() string

func (*MsgEnableAttester) Unmarshal 

func (m *MsgEnableAttester) Unmarshal(dAtA []byte) error

func (*MsgEnableAttester) ValidateBasic 

func (msg *MsgEnableAttester) ValidateBasic() error

func (*MsgEnableAttester) XXX_DiscardUnknown 

func (m *MsgEnableAttester) XXX_DiscardUnknown()

func (*MsgEnableAttester) XXX_Marshal 

func (m *MsgEnableAttester) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgEnableAttester) XXX_Merge 

func (m *MsgEnableAttester) XXX_Merge(src proto.Message)

func (*MsgEnableAttester) XXX_Size 

func (m *MsgEnableAttester) XXX_Size() int

func (*MsgEnableAttester) XXX_Unmarshal 

func (m *MsgEnableAttester) XXX_Unmarshal(b []byte) error

type MsgEnableAttesterResponse 

type MsgEnableAttesterResponse struct {
}

func (*MsgEnableAttesterResponse) Descriptor 

func (*MsgEnableAttesterResponse) Descriptor() ([]byte, []int)

func (*MsgEnableAttesterResponse) Marshal 

func (m *MsgEnableAttesterResponse) Marshal() (dAtA []byte, err error)

func (*MsgEnableAttesterResponse) MarshalTo 

func (m *MsgEnableAttesterResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgEnableAttesterResponse) MarshalToSizedBuffer 

func (m *MsgEnableAttesterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgEnableAttesterResponse) ProtoMessage 

func (*MsgEnableAttesterResponse) ProtoMessage()

func (*MsgEnableAttesterResponse) Reset 

func (m *MsgEnableAttesterResponse) Reset()

func (*MsgEnableAttesterResponse) Size 

func (m *MsgEnableAttesterResponse) Size() (n int)

func (*MsgEnableAttesterResponse) String 

func (m *MsgEnableAttesterResponse) String() string

func (*MsgEnableAttesterResponse) Unmarshal 

func (m *MsgEnableAttesterResponse) Unmarshal(dAtA []byte) error

func (*MsgEnableAttesterResponse) XXX_DiscardUnknown 

func (m *MsgEnableAttesterResponse) XXX_DiscardUnknown()

func (*MsgEnableAttesterResponse) XXX_Marshal 

func (m *MsgEnableAttesterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgEnableAttesterResponse) XXX_Merge 

func (m *MsgEnableAttesterResponse) XXX_Merge(src proto.Message)

func (*MsgEnableAttesterResponse) XXX_Size 

func (m *MsgEnableAttesterResponse) XXX_Size() int

func (*MsgEnableAttesterResponse) XXX_Unmarshal 

func (m *MsgEnableAttesterResponse) XXX_Unmarshal(b []byte) error

type MsgLinkTokenPair 

type MsgLinkTokenPair struct {
	From         string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	RemoteDomain uint32 `protobuf:"varint,2,opt,name=remote_domain,json=remoteDomain,proto3" json:"remote_domain,omitempty"`
	RemoteToken  []byte `protobuf:"bytes,3,opt,name=remote_token,json=remoteToken,proto3" json:"remote_token,omitempty"`
	LocalToken   string `protobuf:"bytes,4,opt,name=local_token,json=localToken,proto3" json:"local_token,omitempty"`
}

func NewMsgLinkTokenPair 

func NewMsgLinkTokenPair(from string, localToken string, remoteToken []byte, remoteDomain uint32) *MsgLinkTokenPair

func (*MsgLinkTokenPair) Descriptor 

func (*MsgLinkTokenPair) Descriptor() ([]byte, []int)

func (*MsgLinkTokenPair) GetFrom 

func (m *MsgLinkTokenPair) GetFrom() string

func (*MsgLinkTokenPair) GetLocalToken 

func (m *MsgLinkTokenPair) GetLocalToken() string

func (*MsgLinkTokenPair) GetRemoteDomain 

func (m *MsgLinkTokenPair) GetRemoteDomain() uint32

func (*MsgLinkTokenPair) GetRemoteToken 

func (m *MsgLinkTokenPair) GetRemoteToken() []byte

func (*MsgLinkTokenPair) GetSignBytes 

func (msg *MsgLinkTokenPair) GetSignBytes() []byte

func (*MsgLinkTokenPair) GetSigners 

func (msg *MsgLinkTokenPair) GetSigners() []sdk.AccAddress

func (*MsgLinkTokenPair) Marshal 

func (m *MsgLinkTokenPair) Marshal() (dAtA []byte, err error)

func (*MsgLinkTokenPair) MarshalTo 

func (m *MsgLinkTokenPair) MarshalTo(dAtA []byte) (int, error)

func (*MsgLinkTokenPair) MarshalToSizedBuffer 

func (m *MsgLinkTokenPair) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgLinkTokenPair) ProtoMessage 

func (*MsgLinkTokenPair) ProtoMessage()

func (*MsgLinkTokenPair) Reset 

func (m *MsgLinkTokenPair) Reset()

func (*MsgLinkTokenPair) Route 

func (msg *MsgLinkTokenPair) Route() string

func (*MsgLinkTokenPair) Size 

func (m *MsgLinkTokenPair) Size() (n int)

func (*MsgLinkTokenPair) String 

func (m *MsgLinkTokenPair) String() string

func (*MsgLinkTokenPair) Type 

func (msg *MsgLinkTokenPair) Type() string

func (*MsgLinkTokenPair) Unmarshal 

func (m *MsgLinkTokenPair) Unmarshal(dAtA []byte) error

func (*MsgLinkTokenPair) ValidateBasic 

func (msg *MsgLinkTokenPair) ValidateBasic() error

func (*MsgLinkTokenPair) XXX_DiscardUnknown 

func (m *MsgLinkTokenPair) XXX_DiscardUnknown()

func (*MsgLinkTokenPair) XXX_Marshal 

func (m *MsgLinkTokenPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgLinkTokenPair) XXX_Merge 

func (m *MsgLinkTokenPair) XXX_Merge(src proto.Message)

func (*MsgLinkTokenPair) XXX_Size 

func (m *MsgLinkTokenPair) XXX_Size() int

func (*MsgLinkTokenPair) XXX_Unmarshal 

func (m *MsgLinkTokenPair) XXX_Unmarshal(b []byte) error

type MsgLinkTokenPairResponse 

type MsgLinkTokenPairResponse struct {
}

func (*MsgLinkTokenPairResponse) Descriptor 

func (*MsgLinkTokenPairResponse) Descriptor() ([]byte, []int)

func (*MsgLinkTokenPairResponse) Marshal 

func (m *MsgLinkTokenPairResponse) Marshal() (dAtA []byte, err error)

func (*MsgLinkTokenPairResponse) MarshalTo 

func (m *MsgLinkTokenPairResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgLinkTokenPairResponse) MarshalToSizedBuffer 

func (m *MsgLinkTokenPairResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgLinkTokenPairResponse) ProtoMessage 

func (*MsgLinkTokenPairResponse) ProtoMessage()

func (*MsgLinkTokenPairResponse) Reset 

func (m *MsgLinkTokenPairResponse) Reset()

func (*MsgLinkTokenPairResponse) Size 

func (m *MsgLinkTokenPairResponse) Size() (n int)

func (*MsgLinkTokenPairResponse) String 

func (m *MsgLinkTokenPairResponse) String() string

func (*MsgLinkTokenPairResponse) Unmarshal 

func (m *MsgLinkTokenPairResponse) Unmarshal(dAtA []byte) error

func (*MsgLinkTokenPairResponse) XXX_DiscardUnknown 

func (m *MsgLinkTokenPairResponse) XXX_DiscardUnknown()

func (*MsgLinkTokenPairResponse) XXX_Marshal 

func (m *MsgLinkTokenPairResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgLinkTokenPairResponse) XXX_Merge 

func (m *MsgLinkTokenPairResponse) XXX_Merge(src proto.Message)

func (*MsgLinkTokenPairResponse) XXX_Size 

func (m *MsgLinkTokenPairResponse) XXX_Size() int

func (*MsgLinkTokenPairResponse) XXX_Unmarshal 

func (m *MsgLinkTokenPairResponse) XXX_Unmarshal(b []byte) error

type MsgPauseBurningAndMinting 

type MsgPauseBurningAndMinting struct {
	From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
}

func NewMsgPauseBurningAndMinting 

func NewMsgPauseBurningAndMinting(from string) *MsgPauseBurningAndMinting

func (*MsgPauseBurningAndMinting) Descriptor 

func (*MsgPauseBurningAndMinting) Descriptor() ([]byte, []int)

func (*MsgPauseBurningAndMinting) GetFrom 

func (m *MsgPauseBurningAndMinting) GetFrom() string

func (*MsgPauseBurningAndMinting) GetSignBytes 

func (msg *MsgPauseBurningAndMinting) GetSignBytes() []byte

func (*MsgPauseBurningAndMinting) GetSigners 

func (msg *MsgPauseBurningAndMinting) GetSigners() []sdk.AccAddress

func (*MsgPauseBurningAndMinting) Marshal 

func (m *MsgPauseBurningAndMinting) Marshal() (dAtA []byte, err error)

func (*MsgPauseBurningAndMinting) MarshalTo 

func (m *MsgPauseBurningAndMinting) MarshalTo(dAtA []byte) (int, error)

func (*MsgPauseBurningAndMinting) MarshalToSizedBuffer 

func (m *MsgPauseBurningAndMinting) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgPauseBurningAndMinting) ProtoMessage 

func (*MsgPauseBurningAndMinting) ProtoMessage()

func (*MsgPauseBurningAndMinting) Reset 

func (m *MsgPauseBurningAndMinting) Reset()

func (*MsgPauseBurningAndMinting) Route 

func (msg *MsgPauseBurningAndMinting) Route() string

func (*MsgPauseBurningAndMinting) Size 

func (m *MsgPauseBurningAndMinting) Size() (n int)

func (*MsgPauseBurningAndMinting) String 

func (m *MsgPauseBurningAndMinting) String() string

func (*MsgPauseBurningAndMinting) Type 

func (msg *MsgPauseBurningAndMinting) Type() string

func (*MsgPauseBurningAndMinting) Unmarshal 

func (m *MsgPauseBurningAndMinting) Unmarshal(dAtA []byte) error

func (*MsgPauseBurningAndMinting) ValidateBasic 

func (msg *MsgPauseBurningAndMinting) ValidateBasic() error

func (*MsgPauseBurningAndMinting) XXX_DiscardUnknown 

func (m *MsgPauseBurningAndMinting) XXX_DiscardUnknown()

func (*MsgPauseBurningAndMinting) XXX_Marshal 

func (m *MsgPauseBurningAndMinting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgPauseBurningAndMinting) XXX_Merge 

func (m *MsgPauseBurningAndMinting) XXX_Merge(src proto.Message)

func (*MsgPauseBurningAndMinting) XXX_Size 

func (m *MsgPauseBurningAndMinting) XXX_Size() int

func (*MsgPauseBurningAndMinting) XXX_Unmarshal 

func (m *MsgPauseBurningAndMinting) XXX_Unmarshal(b []byte) error

type MsgPauseBurningAndMintingResponse 

type MsgPauseBurningAndMintingResponse struct {
}

func (*MsgPauseBurningAndMintingResponse) Descriptor 

func (*MsgPauseBurningAndMintingResponse) Descriptor() ([]byte, []int)

func (*MsgPauseBurningAndMintingResponse) Marshal 

func (m *MsgPauseBurningAndMintingResponse) Marshal() (dAtA []byte, err error)

func (*MsgPauseBurningAndMintingResponse) MarshalTo 

func (m *MsgPauseBurningAndMintingResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgPauseBurningAndMintingResponse) MarshalToSizedBuffer 

func (m *MsgPauseBurningAndMintingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgPauseBurningAndMintingResponse) ProtoMessage 

func (*MsgPauseBurningAndMintingResponse) ProtoMessage()

func (*MsgPauseBurningAndMintingResponse) Reset 

func (m *MsgPauseBurningAndMintingResponse) Reset()

func (*MsgPauseBurningAndMintingResponse) Size 

func (m *MsgPauseBurningAndMintingResponse) Size() (n int)

func (*MsgPauseBurningAndMintingResponse) String 

func (m *MsgPauseBurningAndMintingResponse) String() string

func (*MsgPauseBurningAndMintingResponse) Unmarshal 

func (m *MsgPauseBurningAndMintingResponse) Unmarshal(dAtA []byte) error

func (*MsgPauseBurningAndMintingResponse) XXX_DiscardUnknown 

func (m *MsgPauseBurningAndMintingResponse) XXX_DiscardUnknown()

func (*MsgPauseBurningAndMintingResponse) XXX_Marshal 

func (m *MsgPauseBurningAndMintingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgPauseBurningAndMintingResponse) XXX_Merge 

func (m *MsgPauseBurningAndMintingResponse) XXX_Merge(src proto.Message)

func (*MsgPauseBurningAndMintingResponse) XXX_Size 

func (m *MsgPauseBurningAndMintingResponse) XXX_Size() int

func (*MsgPauseBurningAndMintingResponse) XXX_Unmarshal 

func (m *MsgPauseBurningAndMintingResponse) XXX_Unmarshal(b []byte) error

type MsgPauseSendingAndReceivingMessages 

type MsgPauseSendingAndReceivingMessages struct {
	From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
}

func NewMsgPauseSendingAndReceivingMessages 

func NewMsgPauseSendingAndReceivingMessages(from string) *MsgPauseSendingAndReceivingMessages

func (*MsgPauseSendingAndReceivingMessages) Descriptor 

func (*MsgPauseSendingAndReceivingMessages) Descriptor() ([]byte, []int)

func (*MsgPauseSendingAndReceivingMessages) GetFrom 

func (m *MsgPauseSendingAndReceivingMessages) GetFrom() string

func (*MsgPauseSendingAndReceivingMessages) GetSignBytes 

func (msg *MsgPauseSendingAndReceivingMessages) GetSignBytes() []byte

func (*MsgPauseSendingAndReceivingMessages) GetSigners 

func (msg *MsgPauseSendingAndReceivingMessages) GetSigners() []sdk.AccAddress

func (*MsgPauseSendingAndReceivingMessages) Marshal 

func (m *MsgPauseSendingAndReceivingMessages) Marshal() (dAtA []byte, err error)

func (*MsgPauseSendingAndReceivingMessages) MarshalTo 

func (m *MsgPauseSendingAndReceivingMessages) MarshalTo(dAtA []byte) (int, error)

func (*MsgPauseSendingAndReceivingMessages) MarshalToSizedBuffer 

func (m *MsgPauseSendingAndReceivingMessages) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgPauseSendingAndReceivingMessages) ProtoMessage 

func (*MsgPauseSendingAndReceivingMessages) ProtoMessage()

func (*MsgPauseSendingAndReceivingMessages) Reset 

func (m *MsgPauseSendingAndReceivingMessages) Reset()

func (*MsgPauseSendingAndReceivingMessages) Route 

func (msg *MsgPauseSendingAndReceivingMessages) Route() string

func (*MsgPauseSendingAndReceivingMessages) Size 

func (m *MsgPauseSendingAndReceivingMessages) Size() (n int)

func (*MsgPauseSendingAndReceivingMessages) String 

func (m *MsgPauseSendingAndReceivingMessages) String() string

func (*MsgPauseSendingAndReceivingMessages) Type 

func (msg *MsgPauseSendingAndReceivingMessages) Type() string

func (*MsgPauseSendingAndReceivingMessages) Unmarshal 

func (m *MsgPauseSendingAndReceivingMessages) Unmarshal(dAtA []byte) error

func (*MsgPauseSendingAndReceivingMessages) ValidateBasic 

func (msg *MsgPauseSendingAndReceivingMessages) ValidateBasic() error

func (*MsgPauseSendingAndReceivingMessages) XXX_DiscardUnknown 

func (m *MsgPauseSendingAndReceivingMessages) XXX_DiscardUnknown()

func (*MsgPauseSendingAndReceivingMessages) XXX_Marshal 

func (m *MsgPauseSendingAndReceivingMessages) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgPauseSendingAndReceivingMessages) XXX_Merge 

func (m *MsgPauseSendingAndReceivingMessages) XXX_Merge(src proto.Message)

func (*MsgPauseSendingAndReceivingMessages) XXX_Size 

func (m *MsgPauseSendingAndReceivingMessages) XXX_Size() int

func (*MsgPauseSendingAndReceivingMessages) XXX_Unmarshal 

func (m *MsgPauseSendingAndReceivingMessages) XXX_Unmarshal(b []byte) error

type MsgPauseSendingAndReceivingMessagesResponse 

type MsgPauseSendingAndReceivingMessagesResponse struct {
}

func (*MsgPauseSendingAndReceivingMessagesResponse) Descriptor 

func (*MsgPauseSendingAndReceivingMessagesResponse) Descriptor() ([]byte, []int)

func (*MsgPauseSendingAndReceivingMessagesResponse) Marshal 

func (m *MsgPauseSendingAndReceivingMessagesResponse) Marshal() (dAtA []byte, err error)

func (*MsgPauseSendingAndReceivingMessagesResponse) MarshalTo 

func (m *MsgPauseSendingAndReceivingMessagesResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgPauseSendingAndReceivingMessagesResponse) MarshalToSizedBuffer 

func (m *MsgPauseSendingAndReceivingMessagesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgPauseSendingAndReceivingMessagesResponse) ProtoMessage 

func (*MsgPauseSendingAndReceivingMessagesResponse) ProtoMessage()

func (*MsgPauseSendingAndReceivingMessagesResponse) Reset 

func (m *MsgPauseSendingAndReceivingMessagesResponse) Reset()

func (*MsgPauseSendingAndReceivingMessagesResponse) Size 

func (m *MsgPauseSendingAndReceivingMessagesResponse) Size() (n int)

func (*MsgPauseSendingAndReceivingMessagesResponse) String 

func (m *MsgPauseSendingAndReceivingMessagesResponse) String() string

func (*MsgPauseSendingAndReceivingMessagesResponse) Unmarshal 

func (m *MsgPauseSendingAndReceivingMessagesResponse) Unmarshal(dAtA []byte) error

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_DiscardUnknown 

func (m *MsgPauseSendingAndReceivingMessagesResponse) XXX_DiscardUnknown()

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_Marshal 

func (m *MsgPauseSendingAndReceivingMessagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_Merge 

func (m *MsgPauseSendingAndReceivingMessagesResponse) XXX_Merge(src proto.Message)

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_Size 

func (m *MsgPauseSendingAndReceivingMessagesResponse) XXX_Size() int

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_Unmarshal 

func (m *MsgPauseSendingAndReceivingMessagesResponse) XXX_Unmarshal(b []byte) error

type MsgReceiveMessage 

type MsgReceiveMessage struct {
	From        string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Message     []byte `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Attestation []byte `protobuf:"bytes,3,opt,name=attestation,proto3" json:"attestation,omitempty"`
}

func NewMsgReceiveMessage 

func NewMsgReceiveMessage(from string, message []byte, attestation []byte) *MsgReceiveMessage

func (*MsgReceiveMessage) Descriptor 

func (*MsgReceiveMessage) Descriptor() ([]byte, []int)

func (*MsgReceiveMessage) GetAttestation 

func (m *MsgReceiveMessage) GetAttestation() []byte

func (*MsgReceiveMessage) GetFrom 

func (m *MsgReceiveMessage) GetFrom() string

func (*MsgReceiveMessage) GetMessage 

func (m *MsgReceiveMessage) GetMessage() []byte

func (*MsgReceiveMessage) GetSignBytes 

func (msg *MsgReceiveMessage) GetSignBytes() []byte

func (*MsgReceiveMessage) GetSigners 

func (msg *MsgReceiveMessage) GetSigners() []sdk.AccAddress

func (*MsgReceiveMessage) Marshal 

func (m *MsgReceiveMessage) Marshal() (dAtA []byte, err error)

func (*MsgReceiveMessage) MarshalTo 

func (m *MsgReceiveMessage) MarshalTo(dAtA []byte) (int, error)

func (*MsgReceiveMessage) MarshalToSizedBuffer 

func (m *MsgReceiveMessage) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgReceiveMessage) ProtoMessage 

func (*MsgReceiveMessage) ProtoMessage()

func (*MsgReceiveMessage) Reset 

func (m *MsgReceiveMessage) Reset()

func (*MsgReceiveMessage) Route 

func (msg *MsgReceiveMessage) Route() string

func (*MsgReceiveMessage) Size 

func (m *MsgReceiveMessage) Size() (n int)

func (*MsgReceiveMessage) String 

func (m *MsgReceiveMessage) String() string

func (*MsgReceiveMessage) Type 

func (msg *MsgReceiveMessage) Type() string

func (*MsgReceiveMessage) Unmarshal 

func (m *MsgReceiveMessage) Unmarshal(dAtA []byte) error

func (*MsgReceiveMessage) ValidateBasic 

func (msg *MsgReceiveMessage) ValidateBasic() error

func (*MsgReceiveMessage) XXX_DiscardUnknown 

func (m *MsgReceiveMessage) XXX_DiscardUnknown()

func (*MsgReceiveMessage) XXX_Marshal 

func (m *MsgReceiveMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgReceiveMessage) XXX_Merge 

func (m *MsgReceiveMessage) XXX_Merge(src proto.Message)

func (*MsgReceiveMessage) XXX_Size 

func (m *MsgReceiveMessage) XXX_Size() int

func (*MsgReceiveMessage) XXX_Unmarshal 

func (m *MsgReceiveMessage) XXX_Unmarshal(b []byte) error

type MsgReceiveMessageResponse 

type MsgReceiveMessageResponse struct {
	Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
}

func (*MsgReceiveMessageResponse) Descriptor 

func (*MsgReceiveMessageResponse) Descriptor() ([]byte, []int)

func (*MsgReceiveMessageResponse) GetSuccess 

func (m *MsgReceiveMessageResponse) GetSuccess() bool

func (*MsgReceiveMessageResponse) Marshal 

func (m *MsgReceiveMessageResponse) Marshal() (dAtA []byte, err error)

func (*MsgReceiveMessageResponse) MarshalTo 

func (m *MsgReceiveMessageResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgReceiveMessageResponse) MarshalToSizedBuffer 

func (m *MsgReceiveMessageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgReceiveMessageResponse) ProtoMessage 

func (*MsgReceiveMessageResponse) ProtoMessage()

func (*MsgReceiveMessageResponse) Reset 

func (m *MsgReceiveMessageResponse) Reset()

func (*MsgReceiveMessageResponse) Size 

func (m *MsgReceiveMessageResponse) Size() (n int)

func (*MsgReceiveMessageResponse) String 

func (m *MsgReceiveMessageResponse) String() string

func (*MsgReceiveMessageResponse) Unmarshal 

func (m *MsgReceiveMessageResponse) Unmarshal(dAtA []byte) error

func (*MsgReceiveMessageResponse) XXX_DiscardUnknown 

func (m *MsgReceiveMessageResponse) XXX_DiscardUnknown()

func (*MsgReceiveMessageResponse) XXX_Marshal 

func (m *MsgReceiveMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgReceiveMessageResponse) XXX_Merge 

func (m *MsgReceiveMessageResponse) XXX_Merge(src proto.Message)

func (*MsgReceiveMessageResponse) XXX_Size 

func (m *MsgReceiveMessageResponse) XXX_Size() int

func (*MsgReceiveMessageResponse) XXX_Unmarshal 

func (m *MsgReceiveMessageResponse) XXX_Unmarshal(b []byte) error

type MsgRemoveRemoteTokenMessenger 

type MsgRemoveRemoteTokenMessenger struct {
	From     string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	DomainId uint32 `protobuf:"varint,2,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
}

func NewMsgRemoveRemoteTokenMessenger 

func NewMsgRemoveRemoteTokenMessenger(from string, domainId uint32) *MsgRemoveRemoteTokenMessenger

func (*MsgRemoveRemoteTokenMessenger) Descriptor 

func (*MsgRemoveRemoteTokenMessenger) Descriptor() ([]byte, []int)

func (*MsgRemoveRemoteTokenMessenger) GetDomainId 

func (m *MsgRemoveRemoteTokenMessenger) GetDomainId() uint32

func (*MsgRemoveRemoteTokenMessenger) GetFrom 

func (m *MsgRemoveRemoteTokenMessenger) GetFrom() string

func (*MsgRemoveRemoteTokenMessenger) GetSignBytes 

func (msg *MsgRemoveRemoteTokenMessenger) GetSignBytes() []byte

func (*MsgRemoveRemoteTokenMessenger) GetSigners 

func (msg *MsgRemoveRemoteTokenMessenger) GetSigners() []sdk.AccAddress

func (*MsgRemoveRemoteTokenMessenger) Marshal 

func (m *MsgRemoveRemoteTokenMessenger) Marshal() (dAtA []byte, err error)

func (*MsgRemoveRemoteTokenMessenger) MarshalTo 

func (m *MsgRemoveRemoteTokenMessenger) MarshalTo(dAtA []byte) (int, error)

func (*MsgRemoveRemoteTokenMessenger) MarshalToSizedBuffer 

func (m *MsgRemoveRemoteTokenMessenger) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgRemoveRemoteTokenMessenger) ProtoMessage 

func (*MsgRemoveRemoteTokenMessenger) ProtoMessage()

func (*MsgRemoveRemoteTokenMessenger) Reset 

func (m *MsgRemoveRemoteTokenMessenger) Reset()

func (*MsgRemoveRemoteTokenMessenger) Route 

func (msg *MsgRemoveRemoteTokenMessenger) Route() string

func (*MsgRemoveRemoteTokenMessenger) Size 

func (m *MsgRemoveRemoteTokenMessenger) Size() (n int)

func (*MsgRemoveRemoteTokenMessenger) String 

func (m *MsgRemoveRemoteTokenMessenger) String() string

func (*MsgRemoveRemoteTokenMessenger) Type 

func (msg *MsgRemoveRemoteTokenMessenger) Type() string

func (*MsgRemoveRemoteTokenMessenger) Unmarshal 

func (m *MsgRemoveRemoteTokenMessenger) Unmarshal(dAtA []byte) error

func (*MsgRemoveRemoteTokenMessenger) ValidateBasic 

func (msg *MsgRemoveRemoteTokenMessenger) ValidateBasic() error

func (*MsgRemoveRemoteTokenMessenger) XXX_DiscardUnknown 

func (m *MsgRemoveRemoteTokenMessenger) XXX_DiscardUnknown()

func (*MsgRemoveRemoteTokenMessenger) XXX_Marshal 

func (m *MsgRemoveRemoteTokenMessenger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgRemoveRemoteTokenMessenger) XXX_Merge 

func (m *MsgRemoveRemoteTokenMessenger) XXX_Merge(src proto.Message)

func (*MsgRemoveRemoteTokenMessenger) XXX_Size 

func (m *MsgRemoveRemoteTokenMessenger) XXX_Size() int

func (*MsgRemoveRemoteTokenMessenger) XXX_Unmarshal 

func (m *MsgRemoveRemoteTokenMessenger) XXX_Unmarshal(b []byte) error

type MsgRemoveRemoteTokenMessengerResponse 

type MsgRemoveRemoteTokenMessengerResponse struct {
}

func (*MsgRemoveRemoteTokenMessengerResponse) Descriptor 

func (*MsgRemoveRemoteTokenMessengerResponse) Descriptor() ([]byte, []int)

func (*MsgRemoveRemoteTokenMessengerResponse) Marshal 

func (m *MsgRemoveRemoteTokenMessengerResponse) Marshal() (dAtA []byte, err error)

func (*MsgRemoveRemoteTokenMessengerResponse) MarshalTo 

func (m *MsgRemoveRemoteTokenMessengerResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgRemoveRemoteTokenMessengerResponse) MarshalToSizedBuffer 

func (m *MsgRemoveRemoteTokenMessengerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgRemoveRemoteTokenMessengerResponse) ProtoMessage 

func (*MsgRemoveRemoteTokenMessengerResponse) ProtoMessage()

func (*MsgRemoveRemoteTokenMessengerResponse) Reset 

func (m *MsgRemoveRemoteTokenMessengerResponse) Reset()

func (*MsgRemoveRemoteTokenMessengerResponse) Size 

func (m *MsgRemoveRemoteTokenMessengerResponse) Size() (n int)

func (*MsgRemoveRemoteTokenMessengerResponse) String 

func (m *MsgRemoveRemoteTokenMessengerResponse) String() string

func (*MsgRemoveRemoteTokenMessengerResponse) Unmarshal 

func (m *MsgRemoveRemoteTokenMessengerResponse) Unmarshal(dAtA []byte) error

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_DiscardUnknown 

func (m *MsgRemoveRemoteTokenMessengerResponse) XXX_DiscardUnknown()

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_Marshal 

func (m *MsgRemoveRemoteTokenMessengerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_Merge 

func (m *MsgRemoveRemoteTokenMessengerResponse) XXX_Merge(src proto.Message)

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_Size 

func (m *MsgRemoveRemoteTokenMessengerResponse) XXX_Size() int

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_Unmarshal 

func (m *MsgRemoveRemoteTokenMessengerResponse) XXX_Unmarshal(b []byte) error

type MsgReplaceDepositForBurn 

type MsgReplaceDepositForBurn struct {
	From                 string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	OriginalMessage      []byte `protobuf:"bytes,2,opt,name=original_message,json=originalMessage,proto3" json:"original_message,omitempty"`
	OriginalAttestation  []byte `protobuf:"bytes,3,opt,name=original_attestation,json=originalAttestation,proto3" json:"original_attestation,omitempty"`
	NewDestinationCaller []byte `protobuf:"bytes,4,opt,name=new_destination_caller,json=newDestinationCaller,proto3" json:"new_destination_caller,omitempty"`
	NewMintRecipient     []byte `protobuf:"bytes,5,opt,name=new_mint_recipient,json=newMintRecipient,proto3" json:"new_mint_recipient,omitempty"`
}

func NewMsgReplaceDepositForBurn 

func NewMsgReplaceDepositForBurn(from string, originalMessage []byte, originalAttestation []byte, newDestinationCaller []byte, newMintRecipient []byte) *MsgReplaceDepositForBurn

func (*MsgReplaceDepositForBurn) Descriptor 

func (*MsgReplaceDepositForBurn) Descriptor() ([]byte, []int)

func (*MsgReplaceDepositForBurn) GetFrom 

func (m *MsgReplaceDepositForBurn) GetFrom() string

func (*MsgReplaceDepositForBurn) GetNewDestinationCaller 

func (m *MsgReplaceDepositForBurn) GetNewDestinationCaller() []byte

func (*MsgReplaceDepositForBurn) GetNewMintRecipient 

func (m *MsgReplaceDepositForBurn) GetNewMintRecipient() []byte

func (*MsgReplaceDepositForBurn) GetOriginalAttestation 

func (m *MsgReplaceDepositForBurn) GetOriginalAttestation() []byte

func (*MsgReplaceDepositForBurn) GetOriginalMessage 

func (m *MsgReplaceDepositForBurn) GetOriginalMessage() []byte

func (*MsgReplaceDepositForBurn) GetSignBytes 

func (msg *MsgReplaceDepositForBurn) GetSignBytes() []byte

func (*MsgReplaceDepositForBurn) GetSigners 

func (msg *MsgReplaceDepositForBurn) GetSigners() []sdk.AccAddress

func (*MsgReplaceDepositForBurn) Marshal 

func (m *MsgReplaceDepositForBurn) Marshal() (dAtA []byte, err error)

func (*MsgReplaceDepositForBurn) MarshalTo 

func (m *MsgReplaceDepositForBurn) MarshalTo(dAtA []byte) (int, error)

func (*MsgReplaceDepositForBurn) MarshalToSizedBuffer 

func (m *MsgReplaceDepositForBurn) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgReplaceDepositForBurn) ProtoMessage 

func (*MsgReplaceDepositForBurn) ProtoMessage()

func (*MsgReplaceDepositForBurn) Reset 

func (m *MsgReplaceDepositForBurn) Reset()

func (*MsgReplaceDepositForBurn) Route 

func (msg *MsgReplaceDepositForBurn) Route() string

func (*MsgReplaceDepositForBurn) Size 

func (m *MsgReplaceDepositForBurn) Size() (n int)

func (*MsgReplaceDepositForBurn) String 

func (m *MsgReplaceDepositForBurn) String() string

func (*MsgReplaceDepositForBurn) Type 

func (msg *MsgReplaceDepositForBurn) Type() string

func (*MsgReplaceDepositForBurn) Unmarshal 

func (m *MsgReplaceDepositForBurn) Unmarshal(dAtA []byte) error

func (*MsgReplaceDepositForBurn) ValidateBasic 

func (msg *MsgReplaceDepositForBurn) ValidateBasic() error

func (*MsgReplaceDepositForBurn) XXX_DiscardUnknown 

func (m *MsgReplaceDepositForBurn) XXX_DiscardUnknown()

func (*MsgReplaceDepositForBurn) XXX_Marshal 

func (m *MsgReplaceDepositForBurn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgReplaceDepositForBurn) XXX_Merge 

func (m *MsgReplaceDepositForBurn) XXX_Merge(src proto.Message)

func (*MsgReplaceDepositForBurn) XXX_Size 

func (m *MsgReplaceDepositForBurn) XXX_Size() int

func (*MsgReplaceDepositForBurn) XXX_Unmarshal 

func (m *MsgReplaceDepositForBurn) XXX_Unmarshal(b []byte) error

type MsgReplaceDepositForBurnResponse 

type MsgReplaceDepositForBurnResponse struct {
}

func (*MsgReplaceDepositForBurnResponse) Descriptor 

func (*MsgReplaceDepositForBurnResponse) Descriptor() ([]byte, []int)

func (*MsgReplaceDepositForBurnResponse) Marshal 

func (m *MsgReplaceDepositForBurnResponse) Marshal() (dAtA []byte, err error)

func (*MsgReplaceDepositForBurnResponse) MarshalTo 

func (m *MsgReplaceDepositForBurnResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgReplaceDepositForBurnResponse) MarshalToSizedBuffer 

func (m *MsgReplaceDepositForBurnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgReplaceDepositForBurnResponse) ProtoMessage 

func (*MsgReplaceDepositForBurnResponse) ProtoMessage()

func (*MsgReplaceDepositForBurnResponse) Reset 

func (m *MsgReplaceDepositForBurnResponse) Reset()

func (*MsgReplaceDepositForBurnResponse) Size 

func (m *MsgReplaceDepositForBurnResponse) Size() (n int)

func (*MsgReplaceDepositForBurnResponse) String 

func (m *MsgReplaceDepositForBurnResponse) String() string

func (*MsgReplaceDepositForBurnResponse) Unmarshal 

func (m *MsgReplaceDepositForBurnResponse) Unmarshal(dAtA []byte) error

func (*MsgReplaceDepositForBurnResponse) XXX_DiscardUnknown 

func (m *MsgReplaceDepositForBurnResponse) XXX_DiscardUnknown()

func (*MsgReplaceDepositForBurnResponse) XXX_Marshal 

func (m *MsgReplaceDepositForBurnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgReplaceDepositForBurnResponse) XXX_Merge 

func (m *MsgReplaceDepositForBurnResponse) XXX_Merge(src proto.Message)

func (*MsgReplaceDepositForBurnResponse) XXX_Size 

func (m *MsgReplaceDepositForBurnResponse) XXX_Size() int

func (*MsgReplaceDepositForBurnResponse) XXX_Unmarshal 

func (m *MsgReplaceDepositForBurnResponse) XXX_Unmarshal(b []byte) error

type MsgReplaceMessage 

type MsgReplaceMessage struct {
	From                 string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	OriginalMessage      []byte `protobuf:"bytes,2,opt,name=original_message,json=originalMessage,proto3" json:"original_message,omitempty"`
	OriginalAttestation  []byte `protobuf:"bytes,3,opt,name=original_attestation,json=originalAttestation,proto3" json:"original_attestation,omitempty"`
	NewMessageBody       []byte `protobuf:"bytes,4,opt,name=new_message_body,json=newMessageBody,proto3" json:"new_message_body,omitempty"`
	NewDestinationCaller []byte `protobuf:"bytes,5,opt,name=new_destination_caller,json=newDestinationCaller,proto3" json:"new_destination_caller,omitempty"`
}

func NewMsgReplaceMessage 

func NewMsgReplaceMessage(from string, originalMessage []byte, originalAttestation []byte, newMessageBody []byte, newDestinationCaller []byte) *MsgReplaceMessage

func (*MsgReplaceMessage) Descriptor 

func (*MsgReplaceMessage) Descriptor() ([]byte, []int)

func (*MsgReplaceMessage) GetFrom 

func (m *MsgReplaceMessage) GetFrom() string

func (*MsgReplaceMessage) GetNewDestinationCaller 

func (m *MsgReplaceMessage) GetNewDestinationCaller() []byte

func (*MsgReplaceMessage) GetNewMessageBody 

func (m *MsgReplaceMessage) GetNewMessageBody() []byte

func (*MsgReplaceMessage) GetOriginalAttestation 

func (m *MsgReplaceMessage) GetOriginalAttestation() []byte

func (*MsgReplaceMessage) GetOriginalMessage 

func (m *MsgReplaceMessage) GetOriginalMessage() []byte

func (*MsgReplaceMessage) GetSignBytes 

func (msg *MsgReplaceMessage) GetSignBytes() []byte

func (*MsgReplaceMessage) GetSigners 

func (msg *MsgReplaceMessage) GetSigners() []sdk.AccAddress

func (*MsgReplaceMessage) Marshal 

func (m *MsgReplaceMessage) Marshal() (dAtA []byte, err error)

func (*MsgReplaceMessage) MarshalTo 

func (m *MsgReplaceMessage) MarshalTo(dAtA []byte) (int, error)

func (*MsgReplaceMessage) MarshalToSizedBuffer 

func (m *MsgReplaceMessage) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgReplaceMessage) ProtoMessage 

func (*MsgReplaceMessage) ProtoMessage()

func (*MsgReplaceMessage) Reset 

func (m *MsgReplaceMessage) Reset()

func (*MsgReplaceMessage) Route 

func (msg *MsgReplaceMessage) Route() string

func (*MsgReplaceMessage) Size 

func (m *MsgReplaceMessage) Size() (n int)

func (*MsgReplaceMessage) String 

func (m *MsgReplaceMessage) String() string

func (*MsgReplaceMessage) Type 

func (msg *MsgReplaceMessage) Type() string

func (*MsgReplaceMessage) Unmarshal 

func (m *MsgReplaceMessage) Unmarshal(dAtA []byte) error

func (*MsgReplaceMessage) ValidateBasic 

func (msg *MsgReplaceMessage) ValidateBasic() error

func (*MsgReplaceMessage) XXX_DiscardUnknown 

func (m *MsgReplaceMessage) XXX_DiscardUnknown()

func (*MsgReplaceMessage) XXX_Marshal 

func (m *MsgReplaceMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgReplaceMessage) XXX_Merge 

func (m *MsgReplaceMessage) XXX_Merge(src proto.Message)

func (*MsgReplaceMessage) XXX_Size 

func (m *MsgReplaceMessage) XXX_Size() int

func (*MsgReplaceMessage) XXX_Unmarshal 

func (m *MsgReplaceMessage) XXX_Unmarshal(b []byte) error

type MsgReplaceMessageResponse 

type MsgReplaceMessageResponse struct {
}

func (*MsgReplaceMessageResponse) Descriptor 

func (*MsgReplaceMessageResponse) Descriptor() ([]byte, []int)

func (*MsgReplaceMessageResponse) Marshal 

func (m *MsgReplaceMessageResponse) Marshal() (dAtA []byte, err error)

func (*MsgReplaceMessageResponse) MarshalTo 

func (m *MsgReplaceMessageResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgReplaceMessageResponse) MarshalToSizedBuffer 

func (m *MsgReplaceMessageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgReplaceMessageResponse) ProtoMessage 

func (*MsgReplaceMessageResponse) ProtoMessage()

func (*MsgReplaceMessageResponse) Reset 

func (m *MsgReplaceMessageResponse) Reset()

func (*MsgReplaceMessageResponse) Size 

func (m *MsgReplaceMessageResponse) Size() (n int)

func (*MsgReplaceMessageResponse) String 

func (m *MsgReplaceMessageResponse) String() string

func (*MsgReplaceMessageResponse) Unmarshal 

func (m *MsgReplaceMessageResponse) Unmarshal(dAtA []byte) error

func (*MsgReplaceMessageResponse) XXX_DiscardUnknown 

func (m *MsgReplaceMessageResponse) XXX_DiscardUnknown()

func (*MsgReplaceMessageResponse) XXX_Marshal 

func (m *MsgReplaceMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgReplaceMessageResponse) XXX_Merge 

func (m *MsgReplaceMessageResponse) XXX_Merge(src proto.Message)

func (*MsgReplaceMessageResponse) XXX_Size 

func (m *MsgReplaceMessageResponse) XXX_Size() int

func (*MsgReplaceMessageResponse) XXX_Unmarshal 

func (m *MsgReplaceMessageResponse) XXX_Unmarshal(b []byte) error

type MsgSendMessage 

type MsgSendMessage struct {
	From              string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	DestinationDomain uint32 `protobuf:"varint,2,opt,name=destination_domain,json=destinationDomain,proto3" json:"destination_domain,omitempty"`
	Recipient         []byte `protobuf:"bytes,3,opt,name=recipient,proto3" json:"recipient,omitempty"`
	MessageBody       []byte `protobuf:"bytes,4,opt,name=message_body,json=messageBody,proto3" json:"message_body,omitempty"`
}

func NewMsgSendMessage 

func NewMsgSendMessage(from string, destinationDomain uint32, recipient []byte, messageBody []byte) *MsgSendMessage

func (*MsgSendMessage) Descriptor 

func (*MsgSendMessage) Descriptor() ([]byte, []int)

func (*MsgSendMessage) GetDestinationDomain 

func (m *MsgSendMessage) GetDestinationDomain() uint32

func (*MsgSendMessage) GetFrom 

func (m *MsgSendMessage) GetFrom() string

func (*MsgSendMessage) GetMessageBody 

func (m *MsgSendMessage) GetMessageBody() []byte

func (*MsgSendMessage) GetRecipient 

func (m *MsgSendMessage) GetRecipient() []byte

func (*MsgSendMessage) GetSignBytes 

func (msg *MsgSendMessage) GetSignBytes() []byte

func (*MsgSendMessage) GetSigners 

func (msg *MsgSendMessage) GetSigners() []sdk.AccAddress

func (*MsgSendMessage) Marshal 

func (m *MsgSendMessage) Marshal() (dAtA []byte, err error)

func (*MsgSendMessage) MarshalTo 

func (m *MsgSendMessage) MarshalTo(dAtA []byte) (int, error)

func (*MsgSendMessage) MarshalToSizedBuffer 

func (m *MsgSendMessage) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgSendMessage) ProtoMessage 

func (*MsgSendMessage) ProtoMessage()

func (*MsgSendMessage) Reset 

func (m *MsgSendMessage) Reset()

func (*MsgSendMessage) Route 

func (msg *MsgSendMessage) Route() string

func (*MsgSendMessage) Size 

func (m *MsgSendMessage) Size() (n int)

func (*MsgSendMessage) String 

func (m *MsgSendMessage) String() string

func (*MsgSendMessage) Type 

func (msg *MsgSendMessage) Type() string

func (*MsgSendMessage) Unmarshal 

func (m *MsgSendMessage) Unmarshal(dAtA []byte) error

func (*MsgSendMessage) ValidateBasic 

func (msg *MsgSendMessage) ValidateBasic() error

func (*MsgSendMessage) XXX_DiscardUnknown 

func (m *MsgSendMessage) XXX_DiscardUnknown()

func (*MsgSendMessage) XXX_Marshal 

func (m *MsgSendMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgSendMessage) XXX_Merge 

func (m *MsgSendMessage) XXX_Merge(src proto.Message)

func (*MsgSendMessage) XXX_Size 

func (m *MsgSendMessage) XXX_Size() int

func (*MsgSendMessage) XXX_Unmarshal 

func (m *MsgSendMessage) XXX_Unmarshal(b []byte) error

type MsgSendMessageResponse 

type MsgSendMessageResponse struct {
	Nonce uint64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

func (*MsgSendMessageResponse) Descriptor 

func (*MsgSendMessageResponse) Descriptor() ([]byte, []int)

func (*MsgSendMessageResponse) GetNonce 

func (m *MsgSendMessageResponse) GetNonce() uint64

func (*MsgSendMessageResponse) Marshal 

func (m *MsgSendMessageResponse) Marshal() (dAtA []byte, err error)

func (*MsgSendMessageResponse) MarshalTo 

func (m *MsgSendMessageResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgSendMessageResponse) MarshalToSizedBuffer 

func (m *MsgSendMessageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgSendMessageResponse) ProtoMessage 

func (*MsgSendMessageResponse) ProtoMessage()

func (*MsgSendMessageResponse) Reset 

func (m *MsgSendMessageResponse) Reset()

func (*MsgSendMessageResponse) Size 

func (m *MsgSendMessageResponse) Size() (n int)

func (*MsgSendMessageResponse) String 

func (m *MsgSendMessageResponse) String() string

func (*MsgSendMessageResponse) Unmarshal 

func (m *MsgSendMessageResponse) Unmarshal(dAtA []byte) error

func (*MsgSendMessageResponse) XXX_DiscardUnknown 

func (m *MsgSendMessageResponse) XXX_DiscardUnknown()

func (*MsgSendMessageResponse) XXX_Marshal 

func (m *MsgSendMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgSendMessageResponse) XXX_Merge 

func (m *MsgSendMessageResponse) XXX_Merge(src proto.Message)

func (*MsgSendMessageResponse) XXX_Size 

func (m *MsgSendMessageResponse) XXX_Size() int

func (*MsgSendMessageResponse) XXX_Unmarshal 

func (m *MsgSendMessageResponse) XXX_Unmarshal(b []byte) error

type MsgSendMessageWithCaller 

type MsgSendMessageWithCaller struct {
	From              string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	DestinationDomain uint32 `protobuf:"varint,2,opt,name=destination_domain,json=destinationDomain,proto3" json:"destination_domain,omitempty"`
	Recipient         []byte `protobuf:"bytes,3,opt,name=recipient,proto3" json:"recipient,omitempty"`
	MessageBody       []byte `protobuf:"bytes,4,opt,name=message_body,json=messageBody,proto3" json:"message_body,omitempty"`
	DestinationCaller []byte `protobuf:"bytes,5,opt,name=destination_caller,json=destinationCaller,proto3" json:"destination_caller,omitempty"`
}

func NewMsgSendMessageWithCaller 

func NewMsgSendMessageWithCaller(from string, destinationDomain uint32, recipient []byte, messageBody []byte, destinationCaller []byte) *MsgSendMessageWithCaller

func (*MsgSendMessageWithCaller) Descriptor 

func (*MsgSendMessageWithCaller) Descriptor() ([]byte, []int)

func (*MsgSendMessageWithCaller) GetDestinationCaller 

func (m *MsgSendMessageWithCaller) GetDestinationCaller() []byte

func (*MsgSendMessageWithCaller) GetDestinationDomain 

func (m *MsgSendMessageWithCaller) GetDestinationDomain() uint32

func (*MsgSendMessageWithCaller) GetFrom 

func (m *MsgSendMessageWithCaller) GetFrom() string

func (*MsgSendMessageWithCaller) GetMessageBody 

func (m *MsgSendMessageWithCaller) GetMessageBody() []byte

func (*MsgSendMessageWithCaller) GetRecipient 

func (m *MsgSendMessageWithCaller) GetRecipient() []byte

func (*MsgSendMessageWithCaller) GetSignBytes 

func (msg *MsgSendMessageWithCaller) GetSignBytes() []byte

func (*MsgSendMessageWithCaller) GetSigners 

func (msg *MsgSendMessageWithCaller) GetSigners() []sdk.AccAddress

func (*MsgSendMessageWithCaller) Marshal 

func (m *MsgSendMessageWithCaller) Marshal() (dAtA []byte, err error)

func (*MsgSendMessageWithCaller) MarshalTo 

func (m *MsgSendMessageWithCaller) MarshalTo(dAtA []byte) (int, error)

func (*MsgSendMessageWithCaller) MarshalToSizedBuffer 

func (m *MsgSendMessageWithCaller) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgSendMessageWithCaller) ProtoMessage 

func (*MsgSendMessageWithCaller) ProtoMessage()

func (*MsgSendMessageWithCaller) Reset 

func (m *MsgSendMessageWithCaller) Reset()

func (*MsgSendMessageWithCaller) Route 

func (msg *MsgSendMessageWithCaller) Route() string

func (*MsgSendMessageWithCaller) Size 

func (m *MsgSendMessageWithCaller) Size() (n int)

func (*MsgSendMessageWithCaller) String 

func (m *MsgSendMessageWithCaller) String() string

func (*MsgSendMessageWithCaller) Type 

func (msg *MsgSendMessageWithCaller) Type() string

func (*MsgSendMessageWithCaller) Unmarshal 

func (m *MsgSendMessageWithCaller) Unmarshal(dAtA []byte) error

func (*MsgSendMessageWithCaller) ValidateBasic 

func (msg *MsgSendMessageWithCaller) ValidateBasic() error

func (*MsgSendMessageWithCaller) XXX_DiscardUnknown 

func (m *MsgSendMessageWithCaller) XXX_DiscardUnknown()

func (*MsgSendMessageWithCaller) XXX_Marshal 

func (m *MsgSendMessageWithCaller) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgSendMessageWithCaller) XXX_Merge 

func (m *MsgSendMessageWithCaller) XXX_Merge(src proto.Message)

func (*MsgSendMessageWithCaller) XXX_Size 

func (m *MsgSendMessageWithCaller) XXX_Size() int

func (*MsgSendMessageWithCaller) XXX_Unmarshal 

func (m *MsgSendMessageWithCaller) XXX_Unmarshal(b []byte) error

type MsgSendMessageWithCallerResponse 

type MsgSendMessageWithCallerResponse struct {
	Nonce uint64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

func (*MsgSendMessageWithCallerResponse) Descriptor 

func (*MsgSendMessageWithCallerResponse) Descriptor() ([]byte, []int)

func (*MsgSendMessageWithCallerResponse) GetNonce 

func (m *MsgSendMessageWithCallerResponse) GetNonce() uint64

func (*MsgSendMessageWithCallerResponse) Marshal 

func (m *MsgSendMessageWithCallerResponse) Marshal() (dAtA []byte, err error)

func (*MsgSendMessageWithCallerResponse) MarshalTo 

func (m *MsgSendMessageWithCallerResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgSendMessageWithCallerResponse) MarshalToSizedBuffer 

func (m *MsgSendMessageWithCallerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgSendMessageWithCallerResponse) ProtoMessage 

func (*MsgSendMessageWithCallerResponse) ProtoMessage()

func (*MsgSendMessageWithCallerResponse) Reset 

func (m *MsgSendMessageWithCallerResponse) Reset()

func (*MsgSendMessageWithCallerResponse) Size 

func (m *MsgSendMessageWithCallerResponse) Size() (n int)

func (*MsgSendMessageWithCallerResponse) String 

func (m *MsgSendMessageWithCallerResponse) String() string

func (*MsgSendMessageWithCallerResponse) Unmarshal 

func (m *MsgSendMessageWithCallerResponse) Unmarshal(dAtA []byte) error

func (*MsgSendMessageWithCallerResponse) XXX_DiscardUnknown 

func (m *MsgSendMessageWithCallerResponse) XXX_DiscardUnknown()

func (*MsgSendMessageWithCallerResponse) XXX_Marshal 

func (m *MsgSendMessageWithCallerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgSendMessageWithCallerResponse) XXX_Merge 

func (m *MsgSendMessageWithCallerResponse) XXX_Merge(src proto.Message)

func (*MsgSendMessageWithCallerResponse) XXX_Size 

func (m *MsgSendMessageWithCallerResponse) XXX_Size() int

func (*MsgSendMessageWithCallerResponse) XXX_Unmarshal 

func (m *MsgSendMessageWithCallerResponse) XXX_Unmarshal(b []byte) error

type MsgServer 

type MsgServer interface {
	AcceptOwner(context.Context, *MsgAcceptOwner) (*MsgAcceptOwnerResponse, error)
	AddRemoteTokenMessenger(context.Context, *MsgAddRemoteTokenMessenger) (*MsgAddRemoteTokenMessengerResponse, error)
	DepositForBurn(context.Context, *MsgDepositForBurn) (*MsgDepositForBurnResponse, error)
	DepositForBurnWithCaller(context.Context, *MsgDepositForBurnWithCaller) (*MsgDepositForBurnWithCallerResponse, error)
	DisableAttester(context.Context, *MsgDisableAttester) (*MsgDisableAttesterResponse, error)
	EnableAttester(context.Context, *MsgEnableAttester) (*MsgEnableAttesterResponse, error)
	LinkTokenPair(context.Context, *MsgLinkTokenPair) (*MsgLinkTokenPairResponse, error)
	PauseBurningAndMinting(context.Context, *MsgPauseBurningAndMinting) (*MsgPauseBurningAndMintingResponse, error)
	PauseSendingAndReceivingMessages(context.Context, *MsgPauseSendingAndReceivingMessages) (*MsgPauseSendingAndReceivingMessagesResponse, error)
	ReceiveMessage(context.Context, *MsgReceiveMessage) (*MsgReceiveMessageResponse, error)
	RemoveRemoteTokenMessenger(context.Context, *MsgRemoveRemoteTokenMessenger) (*MsgRemoveRemoteTokenMessengerResponse, error)
	ReplaceDepositForBurn(context.Context, *MsgReplaceDepositForBurn) (*MsgReplaceDepositForBurnResponse, error)
	ReplaceMessage(context.Context, *MsgReplaceMessage) (*MsgReplaceMessageResponse, error)
	SendMessage(context.Context, *MsgSendMessage) (*MsgSendMessageResponse, error)
	SendMessageWithCaller(context.Context, *MsgSendMessageWithCaller) (*MsgSendMessageWithCallerResponse, error)
	UnlinkTokenPair(context.Context, *MsgUnlinkTokenPair) (*MsgUnlinkTokenPairResponse, error)
	UnpauseBurningAndMinting(context.Context, *MsgUnpauseBurningAndMinting) (*MsgUnpauseBurningAndMintingResponse, error)
	UnpauseSendingAndReceivingMessages(context.Context, *MsgUnpauseSendingAndReceivingMessages) (*MsgUnpauseSendingAndReceivingMessagesResponse, error)
	UpdateOwner(context.Context, *MsgUpdateOwner) (*MsgUpdateOwnerResponse, error)
	UpdateAttesterManager(context.Context, *MsgUpdateAttesterManager) (*MsgUpdateAttesterManagerResponse, error)
	UpdateTokenController(context.Context, *MsgUpdateTokenController) (*MsgUpdateTokenControllerResponse, error)
	UpdatePauser(context.Context, *MsgUpdatePauser) (*MsgUpdatePauserResponse, error)
	UpdateMaxMessageBodySize(context.Context, *MsgUpdateMaxMessageBodySize) (*MsgUpdateMaxMessageBodySizeResponse, error)
	SetMaxBurnAmountPerMessage(context.Context, *MsgSetMaxBurnAmountPerMessage) (*MsgSetMaxBurnAmountPerMessageResponse, error)
	UpdateSignatureThreshold(context.Context, *MsgUpdateSignatureThreshold) (*MsgUpdateSignatureThresholdResponse, error)
}

MsgServer is the server API for Msg service.

type MsgSetMaxBurnAmountPerMessage 

type MsgSetMaxBurnAmountPerMessage struct {
	From       string                `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	LocalToken string                `protobuf:"bytes,2,opt,name=local_token,json=localToken,proto3" json:"local_token,omitempty"`
	Amount     cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

func NewMsgSetMaxBurnAmountPerMessage 

func NewMsgSetMaxBurnAmountPerMessage(from string, localToken string, amount math.Int) *MsgSetMaxBurnAmountPerMessage

func (*MsgSetMaxBurnAmountPerMessage) Descriptor 

func (*MsgSetMaxBurnAmountPerMessage) Descriptor() ([]byte, []int)

func (*MsgSetMaxBurnAmountPerMessage) GetFrom 

func (m *MsgSetMaxBurnAmountPerMessage) GetFrom() string

func (*MsgSetMaxBurnAmountPerMessage) GetLocalToken 

func (m *MsgSetMaxBurnAmountPerMessage) GetLocalToken() string

func (*MsgSetMaxBurnAmountPerMessage) GetSignBytes 

func (msg *MsgSetMaxBurnAmountPerMessage) GetSignBytes() []byte

func (*MsgSetMaxBurnAmountPerMessage) GetSigners 

func (msg *MsgSetMaxBurnAmountPerMessage) GetSigners() []sdk.AccAddress

func (*MsgSetMaxBurnAmountPerMessage) Marshal 

func (m *MsgSetMaxBurnAmountPerMessage) Marshal() (dAtA []byte, err error)

func (*MsgSetMaxBurnAmountPerMessage) MarshalTo 

func (m *MsgSetMaxBurnAmountPerMessage) MarshalTo(dAtA []byte) (int, error)

func (*MsgSetMaxBurnAmountPerMessage) MarshalToSizedBuffer 

func (m *MsgSetMaxBurnAmountPerMessage) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgSetMaxBurnAmountPerMessage) ProtoMessage 

func (*MsgSetMaxBurnAmountPerMessage) ProtoMessage()

func (*MsgSetMaxBurnAmountPerMessage) Reset 

func (m *MsgSetMaxBurnAmountPerMessage) Reset()

func (*MsgSetMaxBurnAmountPerMessage) Route 

func (msg *MsgSetMaxBurnAmountPerMessage) Route() string

func (*MsgSetMaxBurnAmountPerMessage) Size 

func (m *MsgSetMaxBurnAmountPerMessage) Size() (n int)

func (*MsgSetMaxBurnAmountPerMessage) String 

func (m *MsgSetMaxBurnAmountPerMessage) String() string

func (*MsgSetMaxBurnAmountPerMessage) Type 

func (msg *MsgSetMaxBurnAmountPerMessage) Type() string

func (*MsgSetMaxBurnAmountPerMessage) Unmarshal 

func (m *MsgSetMaxBurnAmountPerMessage) Unmarshal(dAtA []byte) error

func (*MsgSetMaxBurnAmountPerMessage) ValidateBasic 

func (msg *MsgSetMaxBurnAmountPerMessage) ValidateBasic() error

func (*MsgSetMaxBurnAmountPerMessage) XXX_DiscardUnknown 

func (m *MsgSetMaxBurnAmountPerMessage) XXX_DiscardUnknown()

func (*MsgSetMaxBurnAmountPerMessage) XXX_Marshal 

func (m *MsgSetMaxBurnAmountPerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgSetMaxBurnAmountPerMessage) XXX_Merge 

func (m *MsgSetMaxBurnAmountPerMessage) XXX_Merge(src proto.Message)

func (*MsgSetMaxBurnAmountPerMessage) XXX_Size 

func (m *MsgSetMaxBurnAmountPerMessage) XXX_Size() int

func (*MsgSetMaxBurnAmountPerMessage) XXX_Unmarshal 

func (m *MsgSetMaxBurnAmountPerMessage) XXX_Unmarshal(b []byte) error

type MsgSetMaxBurnAmountPerMessageResponse 

type MsgSetMaxBurnAmountPerMessageResponse struct {
}

func (*MsgSetMaxBurnAmountPerMessageResponse) Descriptor 

func (*MsgSetMaxBurnAmountPerMessageResponse) Descriptor() ([]byte, []int)

func (*MsgSetMaxBurnAmountPerMessageResponse) Marshal 

func (m *MsgSetMaxBurnAmountPerMessageResponse) Marshal() (dAtA []byte, err error)

func (*MsgSetMaxBurnAmountPerMessageResponse) MarshalTo 

func (m *MsgSetMaxBurnAmountPerMessageResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgSetMaxBurnAmountPerMessageResponse) MarshalToSizedBuffer 

func (m *MsgSetMaxBurnAmountPerMessageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgSetMaxBurnAmountPerMessageResponse) ProtoMessage 

func (*MsgSetMaxBurnAmountPerMessageResponse) ProtoMessage()

func (*MsgSetMaxBurnAmountPerMessageResponse) Reset 

func (m *MsgSetMaxBurnAmountPerMessageResponse) Reset()

func (*MsgSetMaxBurnAmountPerMessageResponse) Size 

func (m *MsgSetMaxBurnAmountPerMessageResponse) Size() (n int)

func (*MsgSetMaxBurnAmountPerMessageResponse) String 

func (m *MsgSetMaxBurnAmountPerMessageResponse) String() string

func (*MsgSetMaxBurnAmountPerMessageResponse) Unmarshal 

func (m *MsgSetMaxBurnAmountPerMessageResponse) Unmarshal(dAtA []byte) error

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_DiscardUnknown 

func (m *MsgSetMaxBurnAmountPerMessageResponse) XXX_DiscardUnknown()

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_Marshal 

func (m *MsgSetMaxBurnAmountPerMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_Merge 

func (m *MsgSetMaxBurnAmountPerMessageResponse) XXX_Merge(src proto.Message)

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_Size 

func (m *MsgSetMaxBurnAmountPerMessageResponse) XXX_Size() int

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_Unmarshal 

func (m *MsgSetMaxBurnAmountPerMessageResponse) XXX_Unmarshal(b []byte) error

type MsgUnlinkTokenPair 

type MsgUnlinkTokenPair struct {
	From         string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	RemoteDomain uint32 `protobuf:"varint,2,opt,name=remote_domain,json=remoteDomain,proto3" json:"remote_domain,omitempty"`
	RemoteToken  []byte `protobuf:"bytes,3,opt,name=remote_token,json=remoteToken,proto3" json:"remote_token,omitempty"`
	LocalToken   string `protobuf:"bytes,4,opt,name=local_token,json=localToken,proto3" json:"local_token,omitempty"`
}

func NewMsgUnlinkTokenPair 

func NewMsgUnlinkTokenPair(from string, localToken string, remoteToken []byte, remoteDomain uint32) *MsgUnlinkTokenPair

func (*MsgUnlinkTokenPair) Descriptor 

func (*MsgUnlinkTokenPair) Descriptor() ([]byte, []int)

func (*MsgUnlinkTokenPair) GetFrom 

func (m *MsgUnlinkTokenPair) GetFrom() string

func (*MsgUnlinkTokenPair) GetLocalToken 

func (m *MsgUnlinkTokenPair) GetLocalToken() string

func (*MsgUnlinkTokenPair) GetRemoteDomain 

func (m *MsgUnlinkTokenPair) GetRemoteDomain() uint32

func (*MsgUnlinkTokenPair) GetRemoteToken 

func (m *MsgUnlinkTokenPair) GetRemoteToken() []byte

func (*MsgUnlinkTokenPair) GetSignBytes 

func (msg *MsgUnlinkTokenPair) GetSignBytes() []byte

func (*MsgUnlinkTokenPair) GetSigners 

func (msg *MsgUnlinkTokenPair) GetSigners() []sdk.AccAddress

func (*MsgUnlinkTokenPair) Marshal 

func (m *MsgUnlinkTokenPair) Marshal() (dAtA []byte, err error)

func (*MsgUnlinkTokenPair) MarshalTo 

func (m *MsgUnlinkTokenPair) MarshalTo(dAtA []byte) (int, error)

func (*MsgUnlinkTokenPair) MarshalToSizedBuffer 

func (m *MsgUnlinkTokenPair) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUnlinkTokenPair) ProtoMessage 

func (*MsgUnlinkTokenPair) ProtoMessage()

func (*MsgUnlinkTokenPair) Reset 

func (m *MsgUnlinkTokenPair) Reset()

func (*MsgUnlinkTokenPair) Route 

func (msg *MsgUnlinkTokenPair) Route() string

func (*MsgUnlinkTokenPair) Size 

func (m *MsgUnlinkTokenPair) Size() (n int)

func (*MsgUnlinkTokenPair) String 

func (m *MsgUnlinkTokenPair) String() string

func (*MsgUnlinkTokenPair) Type 

func (msg *MsgUnlinkTokenPair) Type() string

func (*MsgUnlinkTokenPair) Unmarshal 

func (m *MsgUnlinkTokenPair) Unmarshal(dAtA []byte) error

func (*MsgUnlinkTokenPair) ValidateBasic 

func (msg *MsgUnlinkTokenPair) ValidateBasic() error

func (*MsgUnlinkTokenPair) XXX_DiscardUnknown 

func (m *MsgUnlinkTokenPair) XXX_DiscardUnknown()

func (*MsgUnlinkTokenPair) XXX_Marshal 

func (m *MsgUnlinkTokenPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUnlinkTokenPair) XXX_Merge 

func (m *MsgUnlinkTokenPair) XXX_Merge(src proto.Message)

func (*MsgUnlinkTokenPair) XXX_Size 

func (m *MsgUnlinkTokenPair) XXX_Size() int

func (*MsgUnlinkTokenPair) XXX_Unmarshal 

func (m *MsgUnlinkTokenPair) XXX_Unmarshal(b []byte) error

type MsgUnlinkTokenPairResponse 

type MsgUnlinkTokenPairResponse struct {
}

func (*MsgUnlinkTokenPairResponse) Descriptor 

func (*MsgUnlinkTokenPairResponse) Descriptor() ([]byte, []int)

func (*MsgUnlinkTokenPairResponse) Marshal 

func (m *MsgUnlinkTokenPairResponse) Marshal() (dAtA []byte, err error)

func (*MsgUnlinkTokenPairResponse) MarshalTo 

func (m *MsgUnlinkTokenPairResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUnlinkTokenPairResponse) MarshalToSizedBuffer 

func (m *MsgUnlinkTokenPairResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUnlinkTokenPairResponse) ProtoMessage 

func (*MsgUnlinkTokenPairResponse) ProtoMessage()

func (*MsgUnlinkTokenPairResponse) Reset 

func (m *MsgUnlinkTokenPairResponse) Reset()

func (*MsgUnlinkTokenPairResponse) Size 

func (m *MsgUnlinkTokenPairResponse) Size() (n int)

func (*MsgUnlinkTokenPairResponse) String 

func (m *MsgUnlinkTokenPairResponse) String() string

func (*MsgUnlinkTokenPairResponse) Unmarshal 

func (m *MsgUnlinkTokenPairResponse) Unmarshal(dAtA []byte) error

func (*MsgUnlinkTokenPairResponse) XXX_DiscardUnknown 

func (m *MsgUnlinkTokenPairResponse) XXX_DiscardUnknown()

func (*MsgUnlinkTokenPairResponse) XXX_Marshal 

func (m *MsgUnlinkTokenPairResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUnlinkTokenPairResponse) XXX_Merge 

func (m *MsgUnlinkTokenPairResponse) XXX_Merge(src proto.Message)

func (*MsgUnlinkTokenPairResponse) XXX_Size 

func (m *MsgUnlinkTokenPairResponse) XXX_Size() int

func (*MsgUnlinkTokenPairResponse) XXX_Unmarshal 

func (m *MsgUnlinkTokenPairResponse) XXX_Unmarshal(b []byte) error

type MsgUnpauseBurningAndMinting 

type MsgUnpauseBurningAndMinting struct {
	From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
}

func NewMsgUnpauseBurningAndMinting 

func NewMsgUnpauseBurningAndMinting(from string) *MsgUnpauseBurningAndMinting

func (*MsgUnpauseBurningAndMinting) Descriptor 

func (*MsgUnpauseBurningAndMinting) Descriptor() ([]byte, []int)

func (*MsgUnpauseBurningAndMinting) GetFrom 

func (m *MsgUnpauseBurningAndMinting) GetFrom() string

func (*MsgUnpauseBurningAndMinting) GetSignBytes 

func (msg *MsgUnpauseBurningAndMinting) GetSignBytes() []byte

func (*MsgUnpauseBurningAndMinting) GetSigners 

func (msg *MsgUnpauseBurningAndMinting) GetSigners() []sdk.AccAddress

func (*MsgUnpauseBurningAndMinting) Marshal 

func (m *MsgUnpauseBurningAndMinting) Marshal() (dAtA []byte, err error)

func (*MsgUnpauseBurningAndMinting) MarshalTo 

func (m *MsgUnpauseBurningAndMinting) MarshalTo(dAtA []byte) (int, error)

func (*MsgUnpauseBurningAndMinting) MarshalToSizedBuffer 

func (m *MsgUnpauseBurningAndMinting) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUnpauseBurningAndMinting) ProtoMessage 

func (*MsgUnpauseBurningAndMinting) ProtoMessage()

func (*MsgUnpauseBurningAndMinting) Reset 

func (m *MsgUnpauseBurningAndMinting) Reset()

func (*MsgUnpauseBurningAndMinting) Route 

func (msg *MsgUnpauseBurningAndMinting) Route() string

func (*MsgUnpauseBurningAndMinting) Size 

func (m *MsgUnpauseBurningAndMinting) Size() (n int)

func (*MsgUnpauseBurningAndMinting) String 

func (m *MsgUnpauseBurningAndMinting) String() string

func (*MsgUnpauseBurningAndMinting) Type 

func (msg *MsgUnpauseBurningAndMinting) Type() string

func (*MsgUnpauseBurningAndMinting) Unmarshal 

func (m *MsgUnpauseBurningAndMinting) Unmarshal(dAtA []byte) error

func (*MsgUnpauseBurningAndMinting) ValidateBasic 

func (msg *MsgUnpauseBurningAndMinting) ValidateBasic() error

func (*MsgUnpauseBurningAndMinting) XXX_DiscardUnknown 

func (m *MsgUnpauseBurningAndMinting) XXX_DiscardUnknown()

func (*MsgUnpauseBurningAndMinting) XXX_Marshal 

func (m *MsgUnpauseBurningAndMinting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUnpauseBurningAndMinting) XXX_Merge 

func (m *MsgUnpauseBurningAndMinting) XXX_Merge(src proto.Message)

func (*MsgUnpauseBurningAndMinting) XXX_Size 

func (m *MsgUnpauseBurningAndMinting) XXX_Size() int

func (*MsgUnpauseBurningAndMinting) XXX_Unmarshal 

func (m *MsgUnpauseBurningAndMinting) XXX_Unmarshal(b []byte) error

type MsgUnpauseBurningAndMintingResponse 

type MsgUnpauseBurningAndMintingResponse struct {
}

func (*MsgUnpauseBurningAndMintingResponse) Descriptor 

func (*MsgUnpauseBurningAndMintingResponse) Descriptor() ([]byte, []int)

func (*MsgUnpauseBurningAndMintingResponse) Marshal 

func (m *MsgUnpauseBurningAndMintingResponse) Marshal() (dAtA []byte, err error)

func (*MsgUnpauseBurningAndMintingResponse) MarshalTo 

func (m *MsgUnpauseBurningAndMintingResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUnpauseBurningAndMintingResponse) MarshalToSizedBuffer 

func (m *MsgUnpauseBurningAndMintingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUnpauseBurningAndMintingResponse) ProtoMessage 

func (*MsgUnpauseBurningAndMintingResponse) ProtoMessage()

func (*MsgUnpauseBurningAndMintingResponse) Reset 

func (m *MsgUnpauseBurningAndMintingResponse) Reset()

func (*MsgUnpauseBurningAndMintingResponse) Size 

func (m *MsgUnpauseBurningAndMintingResponse) Size() (n int)

func (*MsgUnpauseBurningAndMintingResponse) String 

func (m *MsgUnpauseBurningAndMintingResponse) String() string

func (*MsgUnpauseBurningAndMintingResponse) Unmarshal 

func (m *MsgUnpauseBurningAndMintingResponse) Unmarshal(dAtA []byte) error

func (*MsgUnpauseBurningAndMintingResponse) XXX_DiscardUnknown 

func (m *MsgUnpauseBurningAndMintingResponse) XXX_DiscardUnknown()

func (*MsgUnpauseBurningAndMintingResponse) XXX_Marshal 

func (m *MsgUnpauseBurningAndMintingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUnpauseBurningAndMintingResponse) XXX_Merge 

func (m *MsgUnpauseBurningAndMintingResponse) XXX_Merge(src proto.Message)

func (*MsgUnpauseBurningAndMintingResponse) XXX_Size 

func (m *MsgUnpauseBurningAndMintingResponse) XXX_Size() int

func (*MsgUnpauseBurningAndMintingResponse) XXX_Unmarshal 

func (m *MsgUnpauseBurningAndMintingResponse) XXX_Unmarshal(b []byte) error

type MsgUnpauseSendingAndReceivingMessages 

type MsgUnpauseSendingAndReceivingMessages struct {
	From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
}

func NewMsgUnpauseSendingAndReceivingMessages 

func NewMsgUnpauseSendingAndReceivingMessages(from string) *MsgUnpauseSendingAndReceivingMessages

func (*MsgUnpauseSendingAndReceivingMessages) Descriptor 

func (*MsgUnpauseSendingAndReceivingMessages) Descriptor() ([]byte, []int)

func (*MsgUnpauseSendingAndReceivingMessages) GetFrom 

func (m *MsgUnpauseSendingAndReceivingMessages) GetFrom() string

func (*MsgUnpauseSendingAndReceivingMessages) GetSignBytes 

func (msg *MsgUnpauseSendingAndReceivingMessages) GetSignBytes() []byte

func (*MsgUnpauseSendingAndReceivingMessages) GetSigners 

func (msg *MsgUnpauseSendingAndReceivingMessages) GetSigners() []sdk.AccAddress

func (*MsgUnpauseSendingAndReceivingMessages) Marshal 

func (m *MsgUnpauseSendingAndReceivingMessages) Marshal() (dAtA []byte, err error)

func (*MsgUnpauseSendingAndReceivingMessages) MarshalTo 

func (m *MsgUnpauseSendingAndReceivingMessages) MarshalTo(dAtA []byte) (int, error)

func (*MsgUnpauseSendingAndReceivingMessages) MarshalToSizedBuffer 

func (m *MsgUnpauseSendingAndReceivingMessages) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUnpauseSendingAndReceivingMessages) ProtoMessage 

func (*MsgUnpauseSendingAndReceivingMessages) ProtoMessage()

func (*MsgUnpauseSendingAndReceivingMessages) Reset 

func (m *MsgUnpauseSendingAndReceivingMessages) Reset()

func (*MsgUnpauseSendingAndReceivingMessages) Route 

func (msg *MsgUnpauseSendingAndReceivingMessages) Route() string

func (*MsgUnpauseSendingAndReceivingMessages) Size 

func (m *MsgUnpauseSendingAndReceivingMessages) Size() (n int)

func (*MsgUnpauseSendingAndReceivingMessages) String 

func (m *MsgUnpauseSendingAndReceivingMessages) String() string

func (*MsgUnpauseSendingAndReceivingMessages) Type 

func (msg *MsgUnpauseSendingAndReceivingMessages) Type() string

func (*MsgUnpauseSendingAndReceivingMessages) Unmarshal 

func (m *MsgUnpauseSendingAndReceivingMessages) Unmarshal(dAtA []byte) error

func (*MsgUnpauseSendingAndReceivingMessages) ValidateBasic 

func (msg *MsgUnpauseSendingAndReceivingMessages) ValidateBasic() error

func (*MsgUnpauseSendingAndReceivingMessages) XXX_DiscardUnknown 

func (m *MsgUnpauseSendingAndReceivingMessages) XXX_DiscardUnknown()

func (*MsgUnpauseSendingAndReceivingMessages) XXX_Marshal 

func (m *MsgUnpauseSendingAndReceivingMessages) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUnpauseSendingAndReceivingMessages) XXX_Merge 

func (m *MsgUnpauseSendingAndReceivingMessages) XXX_Merge(src proto.Message)

func (*MsgUnpauseSendingAndReceivingMessages) XXX_Size 

func (m *MsgUnpauseSendingAndReceivingMessages) XXX_Size() int

func (*MsgUnpauseSendingAndReceivingMessages) XXX_Unmarshal 

func (m *MsgUnpauseSendingAndReceivingMessages) XXX_Unmarshal(b []byte) error

type MsgUnpauseSendingAndReceivingMessagesResponse 

type MsgUnpauseSendingAndReceivingMessagesResponse struct {
}

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Descriptor 

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Descriptor() ([]byte, []int)

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Marshal 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) Marshal() (dAtA []byte, err error)

func (*MsgUnpauseSendingAndReceivingMessagesResponse) MarshalTo 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUnpauseSendingAndReceivingMessagesResponse) MarshalToSizedBuffer 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUnpauseSendingAndReceivingMessagesResponse) ProtoMessage 

func (*MsgUnpauseSendingAndReceivingMessagesResponse) ProtoMessage()

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Reset 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) Reset()

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Size 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) Size() (n int)

func (*MsgUnpauseSendingAndReceivingMessagesResponse) String 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) String() string

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Unmarshal 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) Unmarshal(dAtA []byte) error

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_DiscardUnknown 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) XXX_DiscardUnknown()

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Marshal 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Merge 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Merge(src proto.Message)

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Size 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Size() int

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Unmarshal 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateAttesterManager 

type MsgUpdateAttesterManager struct {
	From               string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	NewAttesterManager string `protobuf:"bytes,2,opt,name=new_attester_manager,json=newAttesterManager,proto3" json:"new_attester_manager,omitempty"`
}

func NewMsgUpdateAttesterManager 

func NewMsgUpdateAttesterManager(from string, newAttesterManager string) *MsgUpdateAttesterManager

func (*MsgUpdateAttesterManager) Descriptor 

func (*MsgUpdateAttesterManager) Descriptor() ([]byte, []int)

func (*MsgUpdateAttesterManager) GetFrom 

func (m *MsgUpdateAttesterManager) GetFrom() string

func (*MsgUpdateAttesterManager) GetNewAttesterManager 

func (m *MsgUpdateAttesterManager) GetNewAttesterManager() string

func (*MsgUpdateAttesterManager) GetSignBytes 

func (msg *MsgUpdateAttesterManager) GetSignBytes() []byte

func (*MsgUpdateAttesterManager) GetSigners 

func (msg *MsgUpdateAttesterManager) GetSigners() []sdk.AccAddress

func (*MsgUpdateAttesterManager) Marshal 

func (m *MsgUpdateAttesterManager) Marshal() (dAtA []byte, err error)

func (*MsgUpdateAttesterManager) MarshalTo 

func (m *MsgUpdateAttesterManager) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateAttesterManager) MarshalToSizedBuffer 

func (m *MsgUpdateAttesterManager) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateAttesterManager) ProtoMessage 

func (*MsgUpdateAttesterManager) ProtoMessage()

func (*MsgUpdateAttesterManager) Reset 

func (m *MsgUpdateAttesterManager) Reset()

func (*MsgUpdateAttesterManager) Route 

func (msg *MsgUpdateAttesterManager) Route() string

func (*MsgUpdateAttesterManager) Size 

func (m *MsgUpdateAttesterManager) Size() (n int)

func (*MsgUpdateAttesterManager) String 

func (m *MsgUpdateAttesterManager) String() string

func (*MsgUpdateAttesterManager) Type 

func (msg *MsgUpdateAttesterManager) Type() string

func (*MsgUpdateAttesterManager) Unmarshal 

func (m *MsgUpdateAttesterManager) Unmarshal(dAtA []byte) error

func (*MsgUpdateAttesterManager) ValidateBasic 

func (msg *MsgUpdateAttesterManager) ValidateBasic() error

func (*MsgUpdateAttesterManager) XXX_DiscardUnknown 

func (m *MsgUpdateAttesterManager) XXX_DiscardUnknown()

func (*MsgUpdateAttesterManager) XXX_Marshal 

func (m *MsgUpdateAttesterManager) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateAttesterManager) XXX_Merge 

func (m *MsgUpdateAttesterManager) XXX_Merge(src proto.Message)

func (*MsgUpdateAttesterManager) XXX_Size 

func (m *MsgUpdateAttesterManager) XXX_Size() int

func (*MsgUpdateAttesterManager) XXX_Unmarshal 

func (m *MsgUpdateAttesterManager) XXX_Unmarshal(b []byte) error

type MsgUpdateAttesterManagerResponse 

type MsgUpdateAttesterManagerResponse struct {
}

func (*MsgUpdateAttesterManagerResponse) Descriptor 

func (*MsgUpdateAttesterManagerResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateAttesterManagerResponse) Marshal 

func (m *MsgUpdateAttesterManagerResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateAttesterManagerResponse) MarshalTo 

func (m *MsgUpdateAttesterManagerResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateAttesterManagerResponse) MarshalToSizedBuffer 

func (m *MsgUpdateAttesterManagerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateAttesterManagerResponse) ProtoMessage 

func (*MsgUpdateAttesterManagerResponse) ProtoMessage()

func (*MsgUpdateAttesterManagerResponse) Reset 

func (m *MsgUpdateAttesterManagerResponse) Reset()

func (*MsgUpdateAttesterManagerResponse) Size 

func (m *MsgUpdateAttesterManagerResponse) Size() (n int)

func (*MsgUpdateAttesterManagerResponse) String 

func (m *MsgUpdateAttesterManagerResponse) String() string

func (*MsgUpdateAttesterManagerResponse) Unmarshal 

func (m *MsgUpdateAttesterManagerResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateAttesterManagerResponse) XXX_DiscardUnknown 

func (m *MsgUpdateAttesterManagerResponse) XXX_DiscardUnknown()

func (*MsgUpdateAttesterManagerResponse) XXX_Marshal 

func (m *MsgUpdateAttesterManagerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateAttesterManagerResponse) XXX_Merge 

func (m *MsgUpdateAttesterManagerResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateAttesterManagerResponse) XXX_Size 

func (m *MsgUpdateAttesterManagerResponse) XXX_Size() int

func (*MsgUpdateAttesterManagerResponse) XXX_Unmarshal 

func (m *MsgUpdateAttesterManagerResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateMaxMessageBodySize 

type MsgUpdateMaxMessageBodySize struct {
	From        string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	MessageSize uint64 `protobuf:"varint,2,opt,name=message_size,json=messageSize,proto3" json:"message_size,omitempty"`
}

func NewMsgUpdateMaxMessageBodySize 

func NewMsgUpdateMaxMessageBodySize(from string, messageSize uint64) *MsgUpdateMaxMessageBodySize

func (*MsgUpdateMaxMessageBodySize) Descriptor 

func (*MsgUpdateMaxMessageBodySize) Descriptor() ([]byte, []int)

func (*MsgUpdateMaxMessageBodySize) GetFrom 

func (m *MsgUpdateMaxMessageBodySize) GetFrom() string

func (*MsgUpdateMaxMessageBodySize) GetMessageSize 

func (m *MsgUpdateMaxMessageBodySize) GetMessageSize() uint64

func (*MsgUpdateMaxMessageBodySize) GetSignBytes 

func (msg *MsgUpdateMaxMessageBodySize) GetSignBytes() []byte

func (*MsgUpdateMaxMessageBodySize) GetSigners 

func (msg *MsgUpdateMaxMessageBodySize) GetSigners() []sdk.AccAddress

func (*MsgUpdateMaxMessageBodySize) Marshal 

func (m *MsgUpdateMaxMessageBodySize) Marshal() (dAtA []byte, err error)

func (*MsgUpdateMaxMessageBodySize) MarshalTo 

func (m *MsgUpdateMaxMessageBodySize) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateMaxMessageBodySize) MarshalToSizedBuffer 

func (m *MsgUpdateMaxMessageBodySize) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateMaxMessageBodySize) ProtoMessage 

func (*MsgUpdateMaxMessageBodySize) ProtoMessage()

func (*MsgUpdateMaxMessageBodySize) Reset 

func (m *MsgUpdateMaxMessageBodySize) Reset()

func (*MsgUpdateMaxMessageBodySize) Route 

func (msg *MsgUpdateMaxMessageBodySize) Route() string

func (*MsgUpdateMaxMessageBodySize) Size 

func (m *MsgUpdateMaxMessageBodySize) Size() (n int)

func (*MsgUpdateMaxMessageBodySize) String 

func (m *MsgUpdateMaxMessageBodySize) String() string

func (*MsgUpdateMaxMessageBodySize) Type 

func (msg *MsgUpdateMaxMessageBodySize) Type() string

func (*MsgUpdateMaxMessageBodySize) Unmarshal 

func (m *MsgUpdateMaxMessageBodySize) Unmarshal(dAtA []byte) error

func (*MsgUpdateMaxMessageBodySize) ValidateBasic 

func (msg *MsgUpdateMaxMessageBodySize) ValidateBasic() error

func (*MsgUpdateMaxMessageBodySize) XXX_DiscardUnknown 

func (m *MsgUpdateMaxMessageBodySize) XXX_DiscardUnknown()

func (*MsgUpdateMaxMessageBodySize) XXX_Marshal 

func (m *MsgUpdateMaxMessageBodySize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateMaxMessageBodySize) XXX_Merge 

func (m *MsgUpdateMaxMessageBodySize) XXX_Merge(src proto.Message)

func (*MsgUpdateMaxMessageBodySize) XXX_Size 

func (m *MsgUpdateMaxMessageBodySize) XXX_Size() int

func (*MsgUpdateMaxMessageBodySize) XXX_Unmarshal 

func (m *MsgUpdateMaxMessageBodySize) XXX_Unmarshal(b []byte) error

type MsgUpdateMaxMessageBodySizeResponse 

type MsgUpdateMaxMessageBodySizeResponse struct {
}

func (*MsgUpdateMaxMessageBodySizeResponse) Descriptor 

func (*MsgUpdateMaxMessageBodySizeResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateMaxMessageBodySizeResponse) Marshal 

func (m *MsgUpdateMaxMessageBodySizeResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateMaxMessageBodySizeResponse) MarshalTo 

func (m *MsgUpdateMaxMessageBodySizeResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateMaxMessageBodySizeResponse) MarshalToSizedBuffer 

func (m *MsgUpdateMaxMessageBodySizeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateMaxMessageBodySizeResponse) ProtoMessage 

func (*MsgUpdateMaxMessageBodySizeResponse) ProtoMessage()

func (*MsgUpdateMaxMessageBodySizeResponse) Reset 

func (m *MsgUpdateMaxMessageBodySizeResponse) Reset()

func (*MsgUpdateMaxMessageBodySizeResponse) Size 

func (m *MsgUpdateMaxMessageBodySizeResponse) Size() (n int)

func (*MsgUpdateMaxMessageBodySizeResponse) String 

func (m *MsgUpdateMaxMessageBodySizeResponse) String() string

func (*MsgUpdateMaxMessageBodySizeResponse) Unmarshal 

func (m *MsgUpdateMaxMessageBodySizeResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_DiscardUnknown 

func (m *MsgUpdateMaxMessageBodySizeResponse) XXX_DiscardUnknown()

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_Marshal 

func (m *MsgUpdateMaxMessageBodySizeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_Merge 

func (m *MsgUpdateMaxMessageBodySizeResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_Size 

func (m *MsgUpdateMaxMessageBodySizeResponse) XXX_Size() int

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_Unmarshal 

func (m *MsgUpdateMaxMessageBodySizeResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateOwner 

type MsgUpdateOwner struct {
	From     string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	NewOwner string `protobuf:"bytes,2,opt,name=new_owner,json=newOwner,proto3" json:"new_owner,omitempty"`
}

TODO add comments

func NewMsgUpdateOwner 

func NewMsgUpdateOwner(from string, newOwner string) *MsgUpdateOwner

func (*MsgUpdateOwner) Descriptor 

func (*MsgUpdateOwner) Descriptor() ([]byte, []int)

func (*MsgUpdateOwner) GetFrom 

func (m *MsgUpdateOwner) GetFrom() string

func (*MsgUpdateOwner) GetNewOwner 

func (m *MsgUpdateOwner) GetNewOwner() string

func (*MsgUpdateOwner) GetSignBytes 

func (msg *MsgUpdateOwner) GetSignBytes() []byte

func (*MsgUpdateOwner) GetSigners 

func (msg *MsgUpdateOwner) GetSigners() []sdk.AccAddress

func (*MsgUpdateOwner) Marshal 

func (m *MsgUpdateOwner) Marshal() (dAtA []byte, err error)

func (*MsgUpdateOwner) MarshalTo 

func (m *MsgUpdateOwner) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateOwner) MarshalToSizedBuffer 

func (m *MsgUpdateOwner) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateOwner) ProtoMessage 

func (*MsgUpdateOwner) ProtoMessage()

func (*MsgUpdateOwner) Reset 

func (m *MsgUpdateOwner) Reset()

func (*MsgUpdateOwner) Route 

func (msg *MsgUpdateOwner) Route() string

func (*MsgUpdateOwner) Size 

func (m *MsgUpdateOwner) Size() (n int)

func (*MsgUpdateOwner) String 

func (m *MsgUpdateOwner) String() string

func (*MsgUpdateOwner) Type 

func (msg *MsgUpdateOwner) Type() string

func (*MsgUpdateOwner) Unmarshal 

func (m *MsgUpdateOwner) Unmarshal(dAtA []byte) error

func (*MsgUpdateOwner) ValidateBasic 

func (msg *MsgUpdateOwner) ValidateBasic() error

func (*MsgUpdateOwner) XXX_DiscardUnknown 

func (m *MsgUpdateOwner) XXX_DiscardUnknown()

func (*MsgUpdateOwner) XXX_Marshal 

func (m *MsgUpdateOwner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateOwner) XXX_Merge 

func (m *MsgUpdateOwner) XXX_Merge(src proto.Message)

func (*MsgUpdateOwner) XXX_Size 

func (m *MsgUpdateOwner) XXX_Size() int

func (*MsgUpdateOwner) XXX_Unmarshal 

func (m *MsgUpdateOwner) XXX_Unmarshal(b []byte) error

type MsgUpdateOwnerResponse 

type MsgUpdateOwnerResponse struct {
}

func (*MsgUpdateOwnerResponse) Descriptor 

func (*MsgUpdateOwnerResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateOwnerResponse) Marshal 

func (m *MsgUpdateOwnerResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateOwnerResponse) MarshalTo 

func (m *MsgUpdateOwnerResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateOwnerResponse) MarshalToSizedBuffer 

func (m *MsgUpdateOwnerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateOwnerResponse) ProtoMessage 

func (*MsgUpdateOwnerResponse) ProtoMessage()

func (*MsgUpdateOwnerResponse) Reset 

func (m *MsgUpdateOwnerResponse) Reset()

func (*MsgUpdateOwnerResponse) Size 

func (m *MsgUpdateOwnerResponse) Size() (n int)

func (*MsgUpdateOwnerResponse) String 

func (m *MsgUpdateOwnerResponse) String() string

func (*MsgUpdateOwnerResponse) Unmarshal 

func (m *MsgUpdateOwnerResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateOwnerResponse) XXX_DiscardUnknown 

func (m *MsgUpdateOwnerResponse) XXX_DiscardUnknown()

func (*MsgUpdateOwnerResponse) XXX_Marshal 

func (m *MsgUpdateOwnerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateOwnerResponse) XXX_Merge 

func (m *MsgUpdateOwnerResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateOwnerResponse) XXX_Size 

func (m *MsgUpdateOwnerResponse) XXX_Size() int

func (*MsgUpdateOwnerResponse) XXX_Unmarshal 

func (m *MsgUpdateOwnerResponse) XXX_Unmarshal(b []byte) error

type MsgUpdatePauser 

type MsgUpdatePauser struct {
	From      string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	NewPauser string `protobuf:"bytes,2,opt,name=new_pauser,json=newPauser,proto3" json:"new_pauser,omitempty"`
}

func NewMsgUpdatePauser 

func NewMsgUpdatePauser(from string, newPauser string) *MsgUpdatePauser

func (*MsgUpdatePauser) Descriptor 

func (*MsgUpdatePauser) Descriptor() ([]byte, []int)

func (*MsgUpdatePauser) GetFrom 

func (m *MsgUpdatePauser) GetFrom() string

func (*MsgUpdatePauser) GetNewPauser 

func (m *MsgUpdatePauser) GetNewPauser() string

func (*MsgUpdatePauser) GetSignBytes 

func (msg *MsgUpdatePauser) GetSignBytes() []byte

func (*MsgUpdatePauser) GetSigners 

func (msg *MsgUpdatePauser) GetSigners() []sdk.AccAddress

func (*MsgUpdatePauser) Marshal 

func (m *MsgUpdatePauser) Marshal() (dAtA []byte, err error)

func (*MsgUpdatePauser) MarshalTo 

func (m *MsgUpdatePauser) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdatePauser) MarshalToSizedBuffer 

func (m *MsgUpdatePauser) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdatePauser) ProtoMessage 

func (*MsgUpdatePauser) ProtoMessage()

func (*MsgUpdatePauser) Reset 

func (m *MsgUpdatePauser) Reset()

func (*MsgUpdatePauser) Route 

func (msg *MsgUpdatePauser) Route() string

func (*MsgUpdatePauser) Size 

func (m *MsgUpdatePauser) Size() (n int)

func (*MsgUpdatePauser) String 

func (m *MsgUpdatePauser) String() string

func (*MsgUpdatePauser) Type 

func (msg *MsgUpdatePauser) Type() string

func (*MsgUpdatePauser) Unmarshal 

func (m *MsgUpdatePauser) Unmarshal(dAtA []byte) error

func (*MsgUpdatePauser) ValidateBasic 

func (msg *MsgUpdatePauser) ValidateBasic() error

func (*MsgUpdatePauser) XXX_DiscardUnknown 

func (m *MsgUpdatePauser) XXX_DiscardUnknown()

func (*MsgUpdatePauser) XXX_Marshal 

func (m *MsgUpdatePauser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdatePauser) XXX_Merge 

func (m *MsgUpdatePauser) XXX_Merge(src proto.Message)

func (*MsgUpdatePauser) XXX_Size 

func (m *MsgUpdatePauser) XXX_Size() int

func (*MsgUpdatePauser) XXX_Unmarshal 

func (m *MsgUpdatePauser) XXX_Unmarshal(b []byte) error

type MsgUpdatePauserResponse 

type MsgUpdatePauserResponse struct {
}

func (*MsgUpdatePauserResponse) Descriptor 

func (*MsgUpdatePauserResponse) Descriptor() ([]byte, []int)

func (*MsgUpdatePauserResponse) Marshal 

func (m *MsgUpdatePauserResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdatePauserResponse) MarshalTo 

func (m *MsgUpdatePauserResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdatePauserResponse) MarshalToSizedBuffer 

func (m *MsgUpdatePauserResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdatePauserResponse) ProtoMessage 

func (*MsgUpdatePauserResponse) ProtoMessage()

func (*MsgUpdatePauserResponse) Reset 

func (m *MsgUpdatePauserResponse) Reset()

func (*MsgUpdatePauserResponse) Size 

func (m *MsgUpdatePauserResponse) Size() (n int)

func (*MsgUpdatePauserResponse) String 

func (m *MsgUpdatePauserResponse) String() string

func (*MsgUpdatePauserResponse) Unmarshal 

func (m *MsgUpdatePauserResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdatePauserResponse) XXX_DiscardUnknown 

func (m *MsgUpdatePauserResponse) XXX_DiscardUnknown()

func (*MsgUpdatePauserResponse) XXX_Marshal 

func (m *MsgUpdatePauserResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdatePauserResponse) XXX_Merge 

func (m *MsgUpdatePauserResponse) XXX_Merge(src proto.Message)

func (*MsgUpdatePauserResponse) XXX_Size 

func (m *MsgUpdatePauserResponse) XXX_Size() int

func (*MsgUpdatePauserResponse) XXX_Unmarshal 

func (m *MsgUpdatePauserResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateSignatureThreshold 

type MsgUpdateSignatureThreshold struct {
	From   string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Amount uint32 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
}

func NewMsgUpdateSignatureThreshold 

func NewMsgUpdateSignatureThreshold(from string, amount uint32) *MsgUpdateSignatureThreshold

func (*MsgUpdateSignatureThreshold) Descriptor 

func (*MsgUpdateSignatureThreshold) Descriptor() ([]byte, []int)

func (*MsgUpdateSignatureThreshold) GetAmount 

func (m *MsgUpdateSignatureThreshold) GetAmount() uint32

func (*MsgUpdateSignatureThreshold) GetFrom 

func (m *MsgUpdateSignatureThreshold) GetFrom() string

func (*MsgUpdateSignatureThreshold) GetSignBytes 

func (msg *MsgUpdateSignatureThreshold) GetSignBytes() []byte

func (*MsgUpdateSignatureThreshold) GetSigners 

func (msg *MsgUpdateSignatureThreshold) GetSigners() []sdk.AccAddress

func (*MsgUpdateSignatureThreshold) Marshal 

func (m *MsgUpdateSignatureThreshold) Marshal() (dAtA []byte, err error)

func (*MsgUpdateSignatureThreshold) MarshalTo 

func (m *MsgUpdateSignatureThreshold) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateSignatureThreshold) MarshalToSizedBuffer 

func (m *MsgUpdateSignatureThreshold) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateSignatureThreshold) ProtoMessage 

func (*MsgUpdateSignatureThreshold) ProtoMessage()

func (*MsgUpdateSignatureThreshold) Reset 

func (m *MsgUpdateSignatureThreshold) Reset()

func (*MsgUpdateSignatureThreshold) Route 

func (msg *MsgUpdateSignatureThreshold) Route() string

func (*MsgUpdateSignatureThreshold) Size 

func (m *MsgUpdateSignatureThreshold) Size() (n int)

func (*MsgUpdateSignatureThreshold) String 

func (m *MsgUpdateSignatureThreshold) String() string

func (*MsgUpdateSignatureThreshold) Type 

func (msg *MsgUpdateSignatureThreshold) Type() string

func (*MsgUpdateSignatureThreshold) Unmarshal 

func (m *MsgUpdateSignatureThreshold) Unmarshal(dAtA []byte) error

func (*MsgUpdateSignatureThreshold) ValidateBasic 

func (msg *MsgUpdateSignatureThreshold) ValidateBasic() error

func (*MsgUpdateSignatureThreshold) XXX_DiscardUnknown 

func (m *MsgUpdateSignatureThreshold) XXX_DiscardUnknown()

func (*MsgUpdateSignatureThreshold) XXX_Marshal 

func (m *MsgUpdateSignatureThreshold) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateSignatureThreshold) XXX_Merge 

func (m *MsgUpdateSignatureThreshold) XXX_Merge(src proto.Message)

func (*MsgUpdateSignatureThreshold) XXX_Size 

func (m *MsgUpdateSignatureThreshold) XXX_Size() int

func (*MsgUpdateSignatureThreshold) XXX_Unmarshal 

func (m *MsgUpdateSignatureThreshold) XXX_Unmarshal(b []byte) error

type MsgUpdateSignatureThresholdResponse 

type MsgUpdateSignatureThresholdResponse struct {
}

func (*MsgUpdateSignatureThresholdResponse) Descriptor 

func (*MsgUpdateSignatureThresholdResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateSignatureThresholdResponse) Marshal 

func (m *MsgUpdateSignatureThresholdResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateSignatureThresholdResponse) MarshalTo 

func (m *MsgUpdateSignatureThresholdResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateSignatureThresholdResponse) MarshalToSizedBuffer 

func (m *MsgUpdateSignatureThresholdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateSignatureThresholdResponse) ProtoMessage 

func (*MsgUpdateSignatureThresholdResponse) ProtoMessage()

func (*MsgUpdateSignatureThresholdResponse) Reset 

func (m *MsgUpdateSignatureThresholdResponse) Reset()

func (*MsgUpdateSignatureThresholdResponse) Size 

func (m *MsgUpdateSignatureThresholdResponse) Size() (n int)

func (*MsgUpdateSignatureThresholdResponse) String 

func (m *MsgUpdateSignatureThresholdResponse) String() string

func (*MsgUpdateSignatureThresholdResponse) Unmarshal 

func (m *MsgUpdateSignatureThresholdResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateSignatureThresholdResponse) XXX_DiscardUnknown 

func (m *MsgUpdateSignatureThresholdResponse) XXX_DiscardUnknown()

func (*MsgUpdateSignatureThresholdResponse) XXX_Marshal 

func (m *MsgUpdateSignatureThresholdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateSignatureThresholdResponse) XXX_Merge 

func (m *MsgUpdateSignatureThresholdResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateSignatureThresholdResponse) XXX_Size 

func (m *MsgUpdateSignatureThresholdResponse) XXX_Size() int

func (*MsgUpdateSignatureThresholdResponse) XXX_Unmarshal 

func (m *MsgUpdateSignatureThresholdResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateTokenController 

type MsgUpdateTokenController struct {
	From               string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	NewTokenController string `protobuf:"bytes,2,opt,name=new_token_controller,json=newTokenController,proto3" json:"new_token_controller,omitempty"`
}

func NewMsgUpdateTokenController 

func NewMsgUpdateTokenController(from string, newTokenController string) *MsgUpdateTokenController

func (*MsgUpdateTokenController) Descriptor 

func (*MsgUpdateTokenController) Descriptor() ([]byte, []int)

func (*MsgUpdateTokenController) GetFrom 

func (m *MsgUpdateTokenController) GetFrom() string

func (*MsgUpdateTokenController) GetNewTokenController 

func (m *MsgUpdateTokenController) GetNewTokenController() string

func (*MsgUpdateTokenController) GetSignBytes 

func (msg *MsgUpdateTokenController) GetSignBytes() []byte

func (*MsgUpdateTokenController) GetSigners 

func (msg *MsgUpdateTokenController) GetSigners() []sdk.AccAddress

func (*MsgUpdateTokenController) Marshal 

func (m *MsgUpdateTokenController) Marshal() (dAtA []byte, err error)

func (*MsgUpdateTokenController) MarshalTo 

func (m *MsgUpdateTokenController) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateTokenController) MarshalToSizedBuffer 

func (m *MsgUpdateTokenController) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateTokenController) ProtoMessage 

func (*MsgUpdateTokenController) ProtoMessage()

func (*MsgUpdateTokenController) Reset 

func (m *MsgUpdateTokenController) Reset()

func (*MsgUpdateTokenController) Route 

func (msg *MsgUpdateTokenController) Route() string

func (*MsgUpdateTokenController) Size 

func (m *MsgUpdateTokenController) Size() (n int)

func (*MsgUpdateTokenController) String 

func (m *MsgUpdateTokenController) String() string

func (*MsgUpdateTokenController) Type 

func (msg *MsgUpdateTokenController) Type() string

func (*MsgUpdateTokenController) Unmarshal 

func (m *MsgUpdateTokenController) Unmarshal(dAtA []byte) error

func (*MsgUpdateTokenController) ValidateBasic 

func (msg *MsgUpdateTokenController) ValidateBasic() error

func (*MsgUpdateTokenController) XXX_DiscardUnknown 

func (m *MsgUpdateTokenController) XXX_DiscardUnknown()

func (*MsgUpdateTokenController) XXX_Marshal 

func (m *MsgUpdateTokenController) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateTokenController) XXX_Merge 

func (m *MsgUpdateTokenController) XXX_Merge(src proto.Message)

func (*MsgUpdateTokenController) XXX_Size 

func (m *MsgUpdateTokenController) XXX_Size() int

func (*MsgUpdateTokenController) XXX_Unmarshal 

func (m *MsgUpdateTokenController) XXX_Unmarshal(b []byte) error

type MsgUpdateTokenControllerResponse 

type MsgUpdateTokenControllerResponse struct {
}

func (*MsgUpdateTokenControllerResponse) Descriptor 

func (*MsgUpdateTokenControllerResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateTokenControllerResponse) Marshal 

func (m *MsgUpdateTokenControllerResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateTokenControllerResponse) MarshalTo 

func (m *MsgUpdateTokenControllerResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateTokenControllerResponse) MarshalToSizedBuffer 

func (m *MsgUpdateTokenControllerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateTokenControllerResponse) ProtoMessage 

func (*MsgUpdateTokenControllerResponse) ProtoMessage()

func (*MsgUpdateTokenControllerResponse) Reset 

func (m *MsgUpdateTokenControllerResponse) Reset()

func (*MsgUpdateTokenControllerResponse) Size 

func (m *MsgUpdateTokenControllerResponse) Size() (n int)

func (*MsgUpdateTokenControllerResponse) String 

func (m *MsgUpdateTokenControllerResponse) String() string

func (*MsgUpdateTokenControllerResponse) Unmarshal 

func (m *MsgUpdateTokenControllerResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateTokenControllerResponse) XXX_DiscardUnknown 

func (m *MsgUpdateTokenControllerResponse) XXX_DiscardUnknown()

func (*MsgUpdateTokenControllerResponse) XXX_Marshal 

func (m *MsgUpdateTokenControllerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateTokenControllerResponse) XXX_Merge 

func (m *MsgUpdateTokenControllerResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateTokenControllerResponse) XXX_Size 

func (m *MsgUpdateTokenControllerResponse) XXX_Size() int

func (*MsgUpdateTokenControllerResponse) XXX_Unmarshal 

func (m *MsgUpdateTokenControllerResponse) XXX_Unmarshal(b []byte) error

type Nonce 

type Nonce struct {
	SourceDomain uint32 `protobuf:"varint,1,opt,name=source_domain,json=sourceDomain,proto3" json:"source_domain,omitempty"`
	Nonce        uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

* The Nonce type functions both to mark receipt of received messages and a counter for sending messages @param source_domain the domain id, used to mark used nonces for received messages @param nonce the nonce number

func (*Nonce) Descriptor 

func (*Nonce) Descriptor() ([]byte, []int)

func (*Nonce) GetNonce 

func (m *Nonce) GetNonce() uint64

func (*Nonce) GetSourceDomain 

func (m *Nonce) GetSourceDomain() uint32

func (*Nonce) Marshal 

func (m *Nonce) Marshal() (dAtA []byte, err error)

func (*Nonce) MarshalTo 

func (m *Nonce) MarshalTo(dAtA []byte) (int, error)

func (*Nonce) MarshalToSizedBuffer 

func (m *Nonce) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Nonce) ProtoMessage 

func (*Nonce) ProtoMessage()

func (*Nonce) Reset 

func (m *Nonce) Reset()

func (*Nonce) Size 

func (m *Nonce) Size() (n int)

func (*Nonce) String 

func (m *Nonce) String() string

func (*Nonce) Unmarshal 

func (m *Nonce) Unmarshal(dAtA []byte) error

func (*Nonce) XXX_DiscardUnknown 

func (m *Nonce) XXX_DiscardUnknown()

func (*Nonce) XXX_Marshal 

func (m *Nonce) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Nonce) XXX_Merge 

func (m *Nonce) XXX_Merge(src proto.Message)

func (*Nonce) XXX_Size 

func (m *Nonce) XXX_Size() int

func (*Nonce) XXX_Unmarshal 

func (m *Nonce) XXX_Unmarshal(b []byte) error

type OwnerUpdated 

type OwnerUpdated struct {
	PreviousOwner string `protobuf:"bytes,1,opt,name=previous_owner,json=previousOwner,proto3" json:"previous_owner,omitempty"`
	NewOwner      string `protobuf:"bytes,2,opt,name=new_owner,json=newOwner,proto3" json:"new_owner,omitempty"`
}

* Emitted when owner address is updated @param previous_owner representing the address of the previous owner @param new_owner representing the address of the new owner

func (*OwnerUpdated) Descriptor 

func (*OwnerUpdated) Descriptor() ([]byte, []int)

func (*OwnerUpdated) GetNewOwner 

func (m *OwnerUpdated) GetNewOwner() string

func (*OwnerUpdated) GetPreviousOwner 

func (m *OwnerUpdated) GetPreviousOwner() string

func (*OwnerUpdated) Marshal 

func (m *OwnerUpdated) Marshal() (dAtA []byte, err error)

func (*OwnerUpdated) MarshalTo 

func (m *OwnerUpdated) MarshalTo(dAtA []byte) (int, error)

func (*OwnerUpdated) MarshalToSizedBuffer 

func (m *OwnerUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*OwnerUpdated) ProtoMessage 

func (*OwnerUpdated) ProtoMessage()

func (*OwnerUpdated) Reset 

func (m *OwnerUpdated) Reset()

func (*OwnerUpdated) Size 

func (m *OwnerUpdated) Size() (n int)

func (*OwnerUpdated) String 

func (m *OwnerUpdated) String() string

func (*OwnerUpdated) Unmarshal 

func (m *OwnerUpdated) Unmarshal(dAtA []byte) error

func (*OwnerUpdated) XXX_DiscardUnknown 

func (m *OwnerUpdated) XXX_DiscardUnknown()

func (*OwnerUpdated) XXX_Marshal 

func (m *OwnerUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OwnerUpdated) XXX_Merge 

func (m *OwnerUpdated) XXX_Merge(src proto.Message)

func (*OwnerUpdated) XXX_Size 

func (m *OwnerUpdated) XXX_Size() int

func (*OwnerUpdated) XXX_Unmarshal 

func (m *OwnerUpdated) XXX_Unmarshal(b []byte) error

type OwnershipTransferStarted 

type OwnershipTransferStarted struct {
	PreviousOwner string `protobuf:"bytes,1,opt,name=previous_owner,json=previousOwner,proto3" json:"previous_owner,omitempty"`
	NewOwner      string `protobuf:"bytes,2,opt,name=new_owner,json=newOwner,proto3" json:"new_owner,omitempty"`
}

* Emitted when starting the two stage transfer ownership process @param previousOwner representing the address of the previous owner @param newOwner representing the address of the new owner

func (*OwnershipTransferStarted) Descriptor 

func (*OwnershipTransferStarted) Descriptor() ([]byte, []int)

func (*OwnershipTransferStarted) GetNewOwner 

func (m *OwnershipTransferStarted) GetNewOwner() string

func (*OwnershipTransferStarted) GetPreviousOwner 

func (m *OwnershipTransferStarted) GetPreviousOwner() string

func (*OwnershipTransferStarted) Marshal 

func (m *OwnershipTransferStarted) Marshal() (dAtA []byte, err error)

func (*OwnershipTransferStarted) MarshalTo 

func (m *OwnershipTransferStarted) MarshalTo(dAtA []byte) (int, error)

func (*OwnershipTransferStarted) MarshalToSizedBuffer 

func (m *OwnershipTransferStarted) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*OwnershipTransferStarted) ProtoMessage 

func (*OwnershipTransferStarted) ProtoMessage()

func (*OwnershipTransferStarted) Reset 

func (m *OwnershipTransferStarted) Reset()

func (*OwnershipTransferStarted) Size 

func (m *OwnershipTransferStarted) Size() (n int)

func (*OwnershipTransferStarted) String 

func (m *OwnershipTransferStarted) String() string

func (*OwnershipTransferStarted) Unmarshal 

func (m *OwnershipTransferStarted) Unmarshal(dAtA []byte) error

func (*OwnershipTransferStarted) XXX_DiscardUnknown 

func (m *OwnershipTransferStarted) XXX_DiscardUnknown()

func (*OwnershipTransferStarted) XXX_Marshal 

func (m *OwnershipTransferStarted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OwnershipTransferStarted) XXX_Merge 

func (m *OwnershipTransferStarted) XXX_Merge(src proto.Message)

func (*OwnershipTransferStarted) XXX_Size 

func (m *OwnershipTransferStarted) XXX_Size() int

func (*OwnershipTransferStarted) XXX_Unmarshal 

func (m *OwnershipTransferStarted) XXX_Unmarshal(b []byte) error

type Params 

type Params struct {
}

* Params defines the parameters for the module.

func DefaultParams 

func DefaultParams() Params

DefaultParams returns a default set of parameters

func NewParams 

func NewParams() Params

NewParams creates a new Params instance

func (*Params) Descriptor 

func (*Params) Descriptor() ([]byte, []int)

func (*Params) Marshal 

func (m *Params) Marshal() (dAtA []byte, err error)

func (*Params) MarshalTo 

func (m *Params) MarshalTo(dAtA []byte) (int, error)

func (*Params) MarshalToSizedBuffer 

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Params) ParamSetPairs 

func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs

ParamSetPairs get the params.ParamSet

func (*Params) ProtoMessage 

func (*Params) ProtoMessage()

func (*Params) Reset 

func (m *Params) Reset()

func (*Params) Size 

func (m *Params) Size() (n int)

func (Params) String 

func (p Params) String() string

String implements the Stringer interface.

func (*Params) Unmarshal 

func (m *Params) Unmarshal(dAtA []byte) error

func (Params) Validate 

func (p Params) Validate() error

Validate validates the set of params

func (*Params) XXX_DiscardUnknown 

func (m *Params) XXX_DiscardUnknown()

func (*Params) XXX_Marshal 

func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Params) XXX_Merge 

func (m *Params) XXX_Merge(src proto.Message)

func (*Params) XXX_Size 

func (m *Params) XXX_Size() int

func (*Params) XXX_Unmarshal 

func (m *Params) XXX_Unmarshal(b []byte) error

type PauserUpdated 

type PauserUpdated struct {
	PreviousPauser string `protobuf:"bytes,1,opt,name=previous_pauser,json=previousPauser,proto3" json:"previous_pauser,omitempty"`
	NewPauser      string `protobuf:"bytes,2,opt,name=new_pauser,json=newPauser,proto3" json:"new_pauser,omitempty"`
}

* Emitted when pauser address is updated @param previous_pauser representing the address of the previous pauser @param new_pauser representing the address of the new pauser

func (*PauserUpdated) Descriptor 

func (*PauserUpdated) Descriptor() ([]byte, []int)

func (*PauserUpdated) GetNewPauser 

func (m *PauserUpdated) GetNewPauser() string

func (*PauserUpdated) GetPreviousPauser 

func (m *PauserUpdated) GetPreviousPauser() string

func (*PauserUpdated) Marshal 

func (m *PauserUpdated) Marshal() (dAtA []byte, err error)

func (*PauserUpdated) MarshalTo 

func (m *PauserUpdated) MarshalTo(dAtA []byte) (int, error)

func (*PauserUpdated) MarshalToSizedBuffer 

func (m *PauserUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*PauserUpdated) ProtoMessage 

func (*PauserUpdated) ProtoMessage()

func (*PauserUpdated) Reset 

func (m *PauserUpdated) Reset()

func (*PauserUpdated) Size 

func (m *PauserUpdated) Size() (n int)

func (*PauserUpdated) String 

func (m *PauserUpdated) String() string

func (*PauserUpdated) Unmarshal 

func (m *PauserUpdated) Unmarshal(dAtA []byte) error

func (*PauserUpdated) XXX_DiscardUnknown 

func (m *PauserUpdated) XXX_DiscardUnknown()

func (*PauserUpdated) XXX_Marshal 

func (m *PauserUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*PauserUpdated) XXX_Merge 

func (m *PauserUpdated) XXX_Merge(src proto.Message)

func (*PauserUpdated) XXX_Size 

func (m *PauserUpdated) XXX_Size() int

func (*PauserUpdated) XXX_Unmarshal 

func (m *PauserUpdated) XXX_Unmarshal(b []byte) error

type PerMessageBurnLimit 

type PerMessageBurnLimit struct {
	Denom  string                `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	Amount cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

* PerMessageBurnLimit is the maximum amount of a certain denom that can be burned in an single burn @param denom the denom @param amount the amount that can be burned (in microunits). An amount of 1000000 uusdc is equivalent to 1USDC

func (*PerMessageBurnLimit) Descriptor 

func (*PerMessageBurnLimit) Descriptor() ([]byte, []int)

func (*PerMessageBurnLimit) GetDenom 

func (m *PerMessageBurnLimit) GetDenom() string

func (*PerMessageBurnLimit) Marshal 

func (m *PerMessageBurnLimit) Marshal() (dAtA []byte, err error)

func (*PerMessageBurnLimit) MarshalTo 

func (m *PerMessageBurnLimit) MarshalTo(dAtA []byte) (int, error)

func (*PerMessageBurnLimit) MarshalToSizedBuffer 

func (m *PerMessageBurnLimit) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*PerMessageBurnLimit) ProtoMessage 

func (*PerMessageBurnLimit) ProtoMessage()

func (*PerMessageBurnLimit) Reset 

func (m *PerMessageBurnLimit) Reset()

func (*PerMessageBurnLimit) Size 

func (m *PerMessageBurnLimit) Size() (n int)

func (*PerMessageBurnLimit) String 

func (m *PerMessageBurnLimit) String() string

func (*PerMessageBurnLimit) Unmarshal 

func (m *PerMessageBurnLimit) Unmarshal(dAtA []byte) error

func (*PerMessageBurnLimit) XXX_DiscardUnknown 

func (m *PerMessageBurnLimit) XXX_DiscardUnknown()

func (*PerMessageBurnLimit) XXX_Marshal 

func (m *PerMessageBurnLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*PerMessageBurnLimit) XXX_Merge 

func (m *PerMessageBurnLimit) XXX_Merge(src proto.Message)

func (*PerMessageBurnLimit) XXX_Size 

func (m *PerMessageBurnLimit) XXX_Size() int

func (*PerMessageBurnLimit) XXX_Unmarshal 

func (m *PerMessageBurnLimit) XXX_Unmarshal(b []byte) error

type QueryAllAttestersRequest 

type QueryAllAttestersRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryAllAttestersRequest is the request type for the Query/Attesters RPC method.

func (*QueryAllAttestersRequest) Descriptor 

func (*QueryAllAttestersRequest) Descriptor() ([]byte, []int)

func (*QueryAllAttestersRequest) GetPagination 

func (m *QueryAllAttestersRequest) GetPagination() *query.PageRequest

func (*QueryAllAttestersRequest) Marshal 

func (m *QueryAllAttestersRequest) Marshal() (dAtA []byte, err error)

func (*QueryAllAttestersRequest) MarshalTo 

func (m *QueryAllAttestersRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryAllAttestersRequest) MarshalToSizedBuffer 

func (m *QueryAllAttestersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryAllAttestersRequest) ProtoMessage 

func (*QueryAllAttestersRequest) ProtoMessage()

func (*QueryAllAttestersRequest) Reset 

func (m *QueryAllAttestersRequest) Reset()

func (*QueryAllAttestersRequest) Size 

func (m *QueryAllAttestersRequest) Size() (n int)

func (*QueryAllAttestersRequest) String 

func (m *QueryAllAttestersRequest) String() string

func (*QueryAllAttestersRequest) Unmarshal 

func (m *QueryAllAttestersRequest) Unmarshal(dAtA []byte) error

func (*QueryAllAttestersRequest) XXX_DiscardUnknown 

func (m *QueryAllAttestersRequest) XXX_DiscardUnknown()

func (*QueryAllAttestersRequest) XXX_Marshal 

func (m *QueryAllAttestersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryAllAttestersRequest) XXX_Merge 

func (m *QueryAllAttestersRequest) XXX_Merge(src proto.Message)

func (*QueryAllAttestersRequest) XXX_Size 

func (m *QueryAllAttestersRequest) XXX_Size() int

func (*QueryAllAttestersRequest) XXX_Unmarshal 

func (m *QueryAllAttestersRequest) XXX_Unmarshal(b []byte) error

type QueryAllAttestersResponse 

type QueryAllAttestersResponse struct {
	Attesters  []Attester          `protobuf:"bytes,1,rep,name=attesters,proto3" json:"attesters"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryAllAttestersResponse is the response type for the Query/Attesters RPC method.

func (*QueryAllAttestersResponse) Descriptor 

func (*QueryAllAttestersResponse) Descriptor() ([]byte, []int)

func (*QueryAllAttestersResponse) GetAttesters 

func (m *QueryAllAttestersResponse) GetAttesters() []Attester

func (*QueryAllAttestersResponse) GetPagination 

func (m *QueryAllAttestersResponse) GetPagination() *query.PageResponse

func (*QueryAllAttestersResponse) Marshal 

func (m *QueryAllAttestersResponse) Marshal() (dAtA []byte, err error)

func (*QueryAllAttestersResponse) MarshalTo 

func (m *QueryAllAttestersResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryAllAttestersResponse) MarshalToSizedBuffer 

func (m *QueryAllAttestersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryAllAttestersResponse) ProtoMessage 

func (*QueryAllAttestersResponse) ProtoMessage()

func (*QueryAllAttestersResponse) Reset 

func (m *QueryAllAttestersResponse) Reset()

func (*QueryAllAttestersResponse) Size 

func (m *QueryAllAttestersResponse) Size() (n int)

func (*QueryAllAttestersResponse) String 

func (m *QueryAllAttestersResponse) String() string

func (*QueryAllAttestersResponse) Unmarshal 

func (m *QueryAllAttestersResponse) Unmarshal(dAtA []byte) error

func (*QueryAllAttestersResponse) XXX_DiscardUnknown 

func (m *QueryAllAttestersResponse) XXX_DiscardUnknown()

func (*QueryAllAttestersResponse) XXX_Marshal 

func (m *QueryAllAttestersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryAllAttestersResponse) XXX_Merge 

func (m *QueryAllAttestersResponse) XXX_Merge(src proto.Message)

func (*QueryAllAttestersResponse) XXX_Size 

func (m *QueryAllAttestersResponse) XXX_Size() int

func (*QueryAllAttestersResponse) XXX_Unmarshal 

func (m *QueryAllAttestersResponse) XXX_Unmarshal(b []byte) error

type QueryAllPerMessageBurnLimitsRequest 

type QueryAllPerMessageBurnLimitsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryAllPerMessageBurnLimitsRequest is the response type for the Query/PerMessageBurnLimit RPC method.

func (*QueryAllPerMessageBurnLimitsRequest) Descriptor 

func (*QueryAllPerMessageBurnLimitsRequest) Descriptor() ([]byte, []int)

func (*QueryAllPerMessageBurnLimitsRequest) GetPagination 

func (m *QueryAllPerMessageBurnLimitsRequest) GetPagination() *query.PageRequest

func (*QueryAllPerMessageBurnLimitsRequest) Marshal 

func (m *QueryAllPerMessageBurnLimitsRequest) Marshal() (dAtA []byte, err error)

func (*QueryAllPerMessageBurnLimitsRequest) MarshalTo 

func (m *QueryAllPerMessageBurnLimitsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryAllPerMessageBurnLimitsRequest) MarshalToSizedBuffer 

func (m *QueryAllPerMessageBurnLimitsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryAllPerMessageBurnLimitsRequest) ProtoMessage 

func (*QueryAllPerMessageBurnLimitsRequest) ProtoMessage()

func (*QueryAllPerMessageBurnLimitsRequest) Reset 

func (m *QueryAllPerMessageBurnLimitsRequest) Reset()

func (*QueryAllPerMessageBurnLimitsRequest) Size 

func (m *QueryAllPerMessageBurnLimitsRequest) Size() (n int)

func (*QueryAllPerMessageBurnLimitsRequest) String 

func (m *QueryAllPerMessageBurnLimitsRequest) String() string

func (*QueryAllPerMessageBurnLimitsRequest) Unmarshal 

func (m *QueryAllPerMessageBurnLimitsRequest) Unmarshal(dAtA []byte) error

func (*QueryAllPerMessageBurnLimitsRequest) XXX_DiscardUnknown 

func (m *QueryAllPerMessageBurnLimitsRequest) XXX_DiscardUnknown()

func (*QueryAllPerMessageBurnLimitsRequest) XXX_Marshal 

func (m *QueryAllPerMessageBurnLimitsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryAllPerMessageBurnLimitsRequest) XXX_Merge 

func (m *QueryAllPerMessageBurnLimitsRequest) XXX_Merge(src proto.Message)

func (*QueryAllPerMessageBurnLimitsRequest) XXX_Size 

func (m *QueryAllPerMessageBurnLimitsRequest) XXX_Size() int

func (*QueryAllPerMessageBurnLimitsRequest) XXX_Unmarshal 

func (m *QueryAllPerMessageBurnLimitsRequest) XXX_Unmarshal(b []byte) error

type QueryAllPerMessageBurnLimitsResponse 

type QueryAllPerMessageBurnLimitsResponse struct {
	BurnLimits []PerMessageBurnLimit `protobuf:"bytes,1,rep,name=burn_limits,json=burnLimits,proto3" json:"burn_limits"`
	Pagination *query.PageResponse   `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryAllPerMessageBurnLimitsRequest is the response type for the Query/PerMessageBurnLimit RPC method.

func (*QueryAllPerMessageBurnLimitsResponse) Descriptor 

func (*QueryAllPerMessageBurnLimitsResponse) Descriptor() ([]byte, []int)

func (*QueryAllPerMessageBurnLimitsResponse) GetBurnLimits 

func (m *QueryAllPerMessageBurnLimitsResponse) GetBurnLimits() []PerMessageBurnLimit

func (*QueryAllPerMessageBurnLimitsResponse) GetPagination 

func (m *QueryAllPerMessageBurnLimitsResponse) GetPagination() *query.PageResponse

func (*QueryAllPerMessageBurnLimitsResponse) Marshal 

func (m *QueryAllPerMessageBurnLimitsResponse) Marshal() (dAtA []byte, err error)

func (*QueryAllPerMessageBurnLimitsResponse) MarshalTo 

func (m *QueryAllPerMessageBurnLimitsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryAllPerMessageBurnLimitsResponse) MarshalToSizedBuffer 

func (m *QueryAllPerMessageBurnLimitsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryAllPerMessageBurnLimitsResponse) ProtoMessage 

func (*QueryAllPerMessageBurnLimitsResponse) ProtoMessage()

func (*QueryAllPerMessageBurnLimitsResponse) Reset 

func (m *QueryAllPerMessageBurnLimitsResponse) Reset()

func (*QueryAllPerMessageBurnLimitsResponse) Size 

func (m *QueryAllPerMessageBurnLimitsResponse) Size() (n int)

func (*QueryAllPerMessageBurnLimitsResponse) String 

func (m *QueryAllPerMessageBurnLimitsResponse) String() string

func (*QueryAllPerMessageBurnLimitsResponse) Unmarshal 

func (m *QueryAllPerMessageBurnLimitsResponse) Unmarshal(dAtA []byte) error

func (*QueryAllPerMessageBurnLimitsResponse) XXX_DiscardUnknown 

func (m *QueryAllPerMessageBurnLimitsResponse) XXX_DiscardUnknown()

func (*QueryAllPerMessageBurnLimitsResponse) XXX_Marshal 

func (m *QueryAllPerMessageBurnLimitsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryAllPerMessageBurnLimitsResponse) XXX_Merge 

func (m *QueryAllPerMessageBurnLimitsResponse) XXX_Merge(src proto.Message)

func (*QueryAllPerMessageBurnLimitsResponse) XXX_Size 

func (m *QueryAllPerMessageBurnLimitsResponse) XXX_Size() int

func (*QueryAllPerMessageBurnLimitsResponse) XXX_Unmarshal 

func (m *QueryAllPerMessageBurnLimitsResponse) XXX_Unmarshal(b []byte) error

type QueryAllTokenPairsRequest 

type QueryAllTokenPairsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryAllTokenPairsRequest is the request type for the Query/TokenPairs RPC method.

func (*QueryAllTokenPairsRequest) Descriptor 

func (*QueryAllTokenPairsRequest) Descriptor() ([]byte, []int)

func (*QueryAllTokenPairsRequest) GetPagination 

func (m *QueryAllTokenPairsRequest) GetPagination() *query.PageRequest

func (*QueryAllTokenPairsRequest) Marshal 

func (m *QueryAllTokenPairsRequest) Marshal() (dAtA []byte, err error)

func (*QueryAllTokenPairsRequest) MarshalTo 

func (m *QueryAllTokenPairsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryAllTokenPairsRequest) MarshalToSizedBuffer 

func (m *QueryAllTokenPairsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryAllTokenPairsRequest) ProtoMessage 

func (*QueryAllTokenPairsRequest) ProtoMessage()

func (*QueryAllTokenPairsRequest) Reset 

func (m *QueryAllTokenPairsRequest) Reset()

func (*QueryAllTokenPairsRequest) Size 

func (m *QueryAllTokenPairsRequest) Size() (n int)

func (*QueryAllTokenPairsRequest) String 

func (m *QueryAllTokenPairsRequest) String() string

func (*QueryAllTokenPairsRequest) Unmarshal 

func (m *QueryAllTokenPairsRequest) Unmarshal(dAtA []byte) error

func (*QueryAllTokenPairsRequest) XXX_DiscardUnknown 

func (m *QueryAllTokenPairsRequest) XXX_DiscardUnknown()

func (*QueryAllTokenPairsRequest) XXX_Marshal 

func (m *QueryAllTokenPairsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryAllTokenPairsRequest) XXX_Merge 

func (m *QueryAllTokenPairsRequest) XXX_Merge(src proto.Message)

func (*QueryAllTokenPairsRequest) XXX_Size 

func (m *QueryAllTokenPairsRequest) XXX_Size() int

func (*QueryAllTokenPairsRequest) XXX_Unmarshal 

func (m *QueryAllTokenPairsRequest) XXX_Unmarshal(b []byte) error

type QueryAllTokenPairsResponse 

type QueryAllTokenPairsResponse struct {
	TokenPairs []TokenPair         `protobuf:"bytes,1,rep,name=token_pairs,json=tokenPairs,proto3" json:"token_pairs"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryAllTokenPairsResponse is the response type for the Query/TokenPairs RPC method.

func (*QueryAllTokenPairsResponse) Descriptor 

func (*QueryAllTokenPairsResponse) Descriptor() ([]byte, []int)

func (*QueryAllTokenPairsResponse) GetPagination 

func (m *QueryAllTokenPairsResponse) GetPagination() *query.PageResponse

func (*QueryAllTokenPairsResponse) GetTokenPairs 

func (m *QueryAllTokenPairsResponse) GetTokenPairs() []TokenPair

func (*QueryAllTokenPairsResponse) Marshal 

func (m *QueryAllTokenPairsResponse) Marshal() (dAtA []byte, err error)

func (*QueryAllTokenPairsResponse) MarshalTo 

func (m *QueryAllTokenPairsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryAllTokenPairsResponse) MarshalToSizedBuffer 

func (m *QueryAllTokenPairsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryAllTokenPairsResponse) ProtoMessage 

func (*QueryAllTokenPairsResponse) ProtoMessage()

func (*QueryAllTokenPairsResponse) Reset 

func (m *QueryAllTokenPairsResponse) Reset()

func (*QueryAllTokenPairsResponse) Size 

func (m *QueryAllTokenPairsResponse) Size() (n int)

func (*QueryAllTokenPairsResponse) String 

func (m *QueryAllTokenPairsResponse) String() string

func (*QueryAllTokenPairsResponse) Unmarshal 

func (m *QueryAllTokenPairsResponse) Unmarshal(dAtA []byte) error

func (*QueryAllTokenPairsResponse) XXX_DiscardUnknown 

func (m *QueryAllTokenPairsResponse) XXX_DiscardUnknown()

func (*QueryAllTokenPairsResponse) XXX_Marshal 

func (m *QueryAllTokenPairsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryAllTokenPairsResponse) XXX_Merge 

func (m *QueryAllTokenPairsResponse) XXX_Merge(src proto.Message)

func (*QueryAllTokenPairsResponse) XXX_Size 

func (m *QueryAllTokenPairsResponse) XXX_Size() int

func (*QueryAllTokenPairsResponse) XXX_Unmarshal 

func (m *QueryAllTokenPairsResponse) XXX_Unmarshal(b []byte) error

type QueryAllUsedNoncesRequest 

type QueryAllUsedNoncesRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryAllUsedNonceRequest is the request type for the Query/UsedNonces RPC method.

func (*QueryAllUsedNoncesRequest) Descriptor 

func (*QueryAllUsedNoncesRequest) Descriptor() ([]byte, []int)

func (*QueryAllUsedNoncesRequest) GetPagination 

func (m *QueryAllUsedNoncesRequest) GetPagination() *query.PageRequest

func (*QueryAllUsedNoncesRequest) Marshal 

func (m *QueryAllUsedNoncesRequest) Marshal() (dAtA []byte, err error)

func (*QueryAllUsedNoncesRequest) MarshalTo 

func (m *QueryAllUsedNoncesRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryAllUsedNoncesRequest) MarshalToSizedBuffer 

func (m *QueryAllUsedNoncesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryAllUsedNoncesRequest) ProtoMessage 

func (*QueryAllUsedNoncesRequest) ProtoMessage()

func (*QueryAllUsedNoncesRequest) Reset 

func (m *QueryAllUsedNoncesRequest) Reset()

func (*QueryAllUsedNoncesRequest) Size 

func (m *QueryAllUsedNoncesRequest) Size() (n int)

func (*QueryAllUsedNoncesRequest) String 

func (m *QueryAllUsedNoncesRequest) String() string

func (*QueryAllUsedNoncesRequest) Unmarshal 

func (m *QueryAllUsedNoncesRequest) Unmarshal(dAtA []byte) error

func (*QueryAllUsedNoncesRequest) XXX_DiscardUnknown 

func (m *QueryAllUsedNoncesRequest) XXX_DiscardUnknown()

func (*QueryAllUsedNoncesRequest) XXX_Marshal 

func (m *QueryAllUsedNoncesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryAllUsedNoncesRequest) XXX_Merge 

func (m *QueryAllUsedNoncesRequest) XXX_Merge(src proto.Message)

func (*QueryAllUsedNoncesRequest) XXX_Size 

func (m *QueryAllUsedNoncesRequest) XXX_Size() int

func (*QueryAllUsedNoncesRequest) XXX_Unmarshal 

func (m *QueryAllUsedNoncesRequest) XXX_Unmarshal(b []byte) error

type QueryAllUsedNoncesResponse 

type QueryAllUsedNoncesResponse struct {
	UsedNonces []Nonce             `protobuf:"bytes,1,rep,name=used_nonces,json=usedNonces,proto3" json:"used_nonces"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryAllUsedNonceResponse is the response type for the Query/UsedNonces RPC method.

func (*QueryAllUsedNoncesResponse) Descriptor 

func (*QueryAllUsedNoncesResponse) Descriptor() ([]byte, []int)

func (*QueryAllUsedNoncesResponse) GetPagination 

func (m *QueryAllUsedNoncesResponse) GetPagination() *query.PageResponse

func (*QueryAllUsedNoncesResponse) GetUsedNonces 

func (m *QueryAllUsedNoncesResponse) GetUsedNonces() []Nonce

func (*QueryAllUsedNoncesResponse) Marshal 

func (m *QueryAllUsedNoncesResponse) Marshal() (dAtA []byte, err error)

func (*QueryAllUsedNoncesResponse) MarshalTo 

func (m *QueryAllUsedNoncesResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryAllUsedNoncesResponse) MarshalToSizedBuffer 

func (m *QueryAllUsedNoncesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryAllUsedNoncesResponse) ProtoMessage 

func (*QueryAllUsedNoncesResponse) ProtoMessage()

func (*QueryAllUsedNoncesResponse) Reset 

func (m *QueryAllUsedNoncesResponse) Reset()

func (*QueryAllUsedNoncesResponse) Size 

func (m *QueryAllUsedNoncesResponse) Size() (n int)

func (*QueryAllUsedNoncesResponse) String 

func (m *QueryAllUsedNoncesResponse) String() string

func (*QueryAllUsedNoncesResponse) Unmarshal 

func (m *QueryAllUsedNoncesResponse) Unmarshal(dAtA []byte) error

func (*QueryAllUsedNoncesResponse) XXX_DiscardUnknown 

func (m *QueryAllUsedNoncesResponse) XXX_DiscardUnknown()

func (*QueryAllUsedNoncesResponse) XXX_Marshal 

func (m *QueryAllUsedNoncesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryAllUsedNoncesResponse) XXX_Merge 

func (m *QueryAllUsedNoncesResponse) XXX_Merge(src proto.Message)

func (*QueryAllUsedNoncesResponse) XXX_Size 

func (m *QueryAllUsedNoncesResponse) XXX_Size() int

func (*QueryAllUsedNoncesResponse) XXX_Unmarshal 

func (m *QueryAllUsedNoncesResponse) XXX_Unmarshal(b []byte) error

type QueryBurnMessageVersionRequest 

type QueryBurnMessageVersionRequest struct {
}

QueryBurnMessageVersionRequest is the request type for the Query/BurnMessageVersion RPC method.

func (*QueryBurnMessageVersionRequest) Descriptor 

func (*QueryBurnMessageVersionRequest) Descriptor() ([]byte, []int)

func (*QueryBurnMessageVersionRequest) Marshal 

func (m *QueryBurnMessageVersionRequest) Marshal() (dAtA []byte, err error)

func (*QueryBurnMessageVersionRequest) MarshalTo 

func (m *QueryBurnMessageVersionRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryBurnMessageVersionRequest) MarshalToSizedBuffer 

func (m *QueryBurnMessageVersionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryBurnMessageVersionRequest) ProtoMessage 

func (*QueryBurnMessageVersionRequest) ProtoMessage()

func (*QueryBurnMessageVersionRequest) Reset 

func (m *QueryBurnMessageVersionRequest) Reset()

func (*QueryBurnMessageVersionRequest) Size 

func (m *QueryBurnMessageVersionRequest) Size() (n int)

func (*QueryBurnMessageVersionRequest) String 

func (m *QueryBurnMessageVersionRequest) String() string

func (*QueryBurnMessageVersionRequest) Unmarshal 

func (m *QueryBurnMessageVersionRequest) Unmarshal(dAtA []byte) error

func (*QueryBurnMessageVersionRequest) XXX_DiscardUnknown 

func (m *QueryBurnMessageVersionRequest) XXX_DiscardUnknown()

func (*QueryBurnMessageVersionRequest) XXX_Marshal 

func (m *QueryBurnMessageVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryBurnMessageVersionRequest) XXX_Merge 

func (m *QueryBurnMessageVersionRequest) XXX_Merge(src proto.Message)

func (*QueryBurnMessageVersionRequest) XXX_Size 

func (m *QueryBurnMessageVersionRequest) XXX_Size() int

func (*QueryBurnMessageVersionRequest) XXX_Unmarshal 

func (m *QueryBurnMessageVersionRequest) XXX_Unmarshal(b []byte) error

type QueryBurnMessageVersionResponse 

type QueryBurnMessageVersionResponse struct {
	// version is the burn message version of the local domain.
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
}

QueryBurnMessageVersionResponse is the response type for the Query/BurnMessageVersion RPC method.

func (*QueryBurnMessageVersionResponse) Descriptor 

func (*QueryBurnMessageVersionResponse) Descriptor() ([]byte, []int)

func (*QueryBurnMessageVersionResponse) GetVersion 

func (m *QueryBurnMessageVersionResponse) GetVersion() uint32

func (*QueryBurnMessageVersionResponse) Marshal 

func (m *QueryBurnMessageVersionResponse) Marshal() (dAtA []byte, err error)

func (*QueryBurnMessageVersionResponse) MarshalTo 

func (m *QueryBurnMessageVersionResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryBurnMessageVersionResponse) MarshalToSizedBuffer 

func (m *QueryBurnMessageVersionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryBurnMessageVersionResponse) ProtoMessage 

func (*QueryBurnMessageVersionResponse) ProtoMessage()

func (*QueryBurnMessageVersionResponse) Reset 

func (m *QueryBurnMessageVersionResponse) Reset()

func (*QueryBurnMessageVersionResponse) Size 

func (m *QueryBurnMessageVersionResponse) Size() (n int)

func (*QueryBurnMessageVersionResponse) String 

func (m *QueryBurnMessageVersionResponse) String() string

func (*QueryBurnMessageVersionResponse) Unmarshal 

func (m *QueryBurnMessageVersionResponse) Unmarshal(dAtA []byte) error

func (*QueryBurnMessageVersionResponse) XXX_DiscardUnknown 

func (m *QueryBurnMessageVersionResponse) XXX_DiscardUnknown()

func (*QueryBurnMessageVersionResponse) XXX_Marshal 

func (m *QueryBurnMessageVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryBurnMessageVersionResponse) XXX_Merge 

func (m *QueryBurnMessageVersionResponse) XXX_Merge(src proto.Message)

func (*QueryBurnMessageVersionResponse) XXX_Size 

func (m *QueryBurnMessageVersionResponse) XXX_Size() int

func (*QueryBurnMessageVersionResponse) XXX_Unmarshal 

func (m *QueryBurnMessageVersionResponse) XXX_Unmarshal(b []byte) error

type QueryClient 

type QueryClient interface {
	Roles(ctx context.Context, in *QueryRolesRequest, opts ...grpc.CallOption) (*QueryRolesResponse, error)
	// Queries an Attester by index
	Attester(ctx context.Context, in *QueryGetAttesterRequest, opts ...grpc.CallOption) (*QueryGetAttesterResponse, error)
	// Queries a list of Attesters
	Attesters(ctx context.Context, in *QueryAllAttestersRequest, opts ...grpc.CallOption) (*QueryAllAttestersResponse, error)
	// Queries a PerMessageBurnLimit by index
	PerMessageBurnLimit(ctx context.Context, in *QueryGetPerMessageBurnLimitRequest, opts ...grpc.CallOption) (*QueryGetPerMessageBurnLimitResponse, error)
	// Queries a list of PerMessageBurnLimits
	PerMessageBurnLimits(ctx context.Context, in *QueryAllPerMessageBurnLimitsRequest, opts ...grpc.CallOption) (*QueryAllPerMessageBurnLimitsResponse, error)
	// Queries BurningAndMintingPaused
	BurningAndMintingPaused(ctx context.Context, in *QueryGetBurningAndMintingPausedRequest, opts ...grpc.CallOption) (*QueryGetBurningAndMintingPausedResponse, error)
	// Queries SendingAndReceivingPaused
	SendingAndReceivingMessagesPaused(ctx context.Context, in *QueryGetSendingAndReceivingMessagesPausedRequest, opts ...grpc.CallOption) (*QueryGetSendingAndReceivingMessagesPausedResponse, error)
	// Queries the MaxMessageBodySize
	MaxMessageBodySize(ctx context.Context, in *QueryGetMaxMessageBodySizeRequest, opts ...grpc.CallOption) (*QueryGetMaxMessageBodySizeResponse, error)
	// Queries the NextAvailableNonce
	NextAvailableNonce(ctx context.Context, in *QueryGetNextAvailableNonceRequest, opts ...grpc.CallOption) (*QueryGetNextAvailableNonceResponse, error)
	// Queries the SignatureThreshold
	SignatureThreshold(ctx context.Context, in *QueryGetSignatureThresholdRequest, opts ...grpc.CallOption) (*QueryGetSignatureThresholdResponse, error)
	// Queries a TokenPair by index
	TokenPair(ctx context.Context, in *QueryGetTokenPairRequest, opts ...grpc.CallOption) (*QueryGetTokenPairResponse, error)
	// Queries a list of TokenPair
	TokenPairs(ctx context.Context, in *QueryAllTokenPairsRequest, opts ...grpc.CallOption) (*QueryAllTokenPairsResponse, error)
	// Queries a UsedNonce by index
	UsedNonce(ctx context.Context, in *QueryGetUsedNonceRequest, opts ...grpc.CallOption) (*QueryGetUsedNonceResponse, error)
	// Queries a list of UsedNonces
	UsedNonces(ctx context.Context, in *QueryAllUsedNoncesRequest, opts ...grpc.CallOption) (*QueryAllUsedNoncesResponse, error)
	// Query the RemoteTokenMessenger of a specific domain.
	RemoteTokenMessenger(ctx context.Context, in *QueryRemoteTokenMessengerRequest, opts ...grpc.CallOption) (*QueryRemoteTokenMessengerResponse, error)
	// Query all RemoteTokenMessenger's.
	RemoteTokenMessengers(ctx context.Context, in *QueryRemoteTokenMessengersRequest, opts ...grpc.CallOption) (*QueryRemoteTokenMessengersResponse, error)
	BurnMessageVersion(ctx context.Context, in *QueryBurnMessageVersionRequest, opts ...grpc.CallOption) (*QueryBurnMessageVersionResponse, error)
	LocalMessageVersion(ctx context.Context, in *QueryLocalMessageVersionRequest, opts ...grpc.CallOption) (*QueryLocalMessageVersionResponse, error)
	LocalDomain(ctx context.Context, in *QueryLocalDomainRequest, opts ...grpc.CallOption) (*QueryLocalDomainResponse, error)
}

QueryClient is the client API for Query service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewQueryClient 

func NewQueryClient(cc grpc1.ClientConn) QueryClient

type QueryGetAttesterRequest 

type QueryGetAttesterRequest struct {
	Attester string `protobuf:"bytes,1,opt,name=attester,proto3" json:"attester,omitempty"`
}

QueryAttestersRequest is the request type for the Query/Attester RPC method.

func (*QueryGetAttesterRequest) Descriptor 

func (*QueryGetAttesterRequest) Descriptor() ([]byte, []int)

func (*QueryGetAttesterRequest) GetAttester 

func (m *QueryGetAttesterRequest) GetAttester() string

func (*QueryGetAttesterRequest) Marshal 

func (m *QueryGetAttesterRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetAttesterRequest) MarshalTo 

func (m *QueryGetAttesterRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetAttesterRequest) MarshalToSizedBuffer 

func (m *QueryGetAttesterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetAttesterRequest) ProtoMessage 

func (*QueryGetAttesterRequest) ProtoMessage()

func (*QueryGetAttesterRequest) Reset 

func (m *QueryGetAttesterRequest) Reset()

func (*QueryGetAttesterRequest) Size 

func (m *QueryGetAttesterRequest) Size() (n int)

func (*QueryGetAttesterRequest) String 

func (m *QueryGetAttesterRequest) String() string

func (*QueryGetAttesterRequest) Unmarshal 

func (m *QueryGetAttesterRequest) Unmarshal(dAtA []byte) error

func (*QueryGetAttesterRequest) XXX_DiscardUnknown 

func (m *QueryGetAttesterRequest) XXX_DiscardUnknown()

func (*QueryGetAttesterRequest) XXX_Marshal 

func (m *QueryGetAttesterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetAttesterRequest) XXX_Merge 

func (m *QueryGetAttesterRequest) XXX_Merge(src proto.Message)

func (*QueryGetAttesterRequest) XXX_Size 

func (m *QueryGetAttesterRequest) XXX_Size() int

func (*QueryGetAttesterRequest) XXX_Unmarshal 

func (m *QueryGetAttesterRequest) XXX_Unmarshal(b []byte) error

type QueryGetAttesterResponse 

type QueryGetAttesterResponse struct {
	Attester Attester `protobuf:"bytes,1,opt,name=attester,proto3" json:"attester"`
}

QueryAttestersResponse is the response type for the Query/Attester RPC method.

func (*QueryGetAttesterResponse) Descriptor 

func (*QueryGetAttesterResponse) Descriptor() ([]byte, []int)

func (*QueryGetAttesterResponse) GetAttester 

func (m *QueryGetAttesterResponse) GetAttester() Attester

func (*QueryGetAttesterResponse) Marshal 

func (m *QueryGetAttesterResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetAttesterResponse) MarshalTo 

func (m *QueryGetAttesterResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetAttesterResponse) MarshalToSizedBuffer 

func (m *QueryGetAttesterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetAttesterResponse) ProtoMessage 

func (*QueryGetAttesterResponse) ProtoMessage()

func (*QueryGetAttesterResponse) Reset 

func (m *QueryGetAttesterResponse) Reset()

func (*QueryGetAttesterResponse) Size 

func (m *QueryGetAttesterResponse) Size() (n int)

func (*QueryGetAttesterResponse) String 

func (m *QueryGetAttesterResponse) String() string

func (*QueryGetAttesterResponse) Unmarshal 

func (m *QueryGetAttesterResponse) Unmarshal(dAtA []byte) error

func (*QueryGetAttesterResponse) XXX_DiscardUnknown 

func (m *QueryGetAttesterResponse) XXX_DiscardUnknown()

func (*QueryGetAttesterResponse) XXX_Marshal 

func (m *QueryGetAttesterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetAttesterResponse) XXX_Merge 

func (m *QueryGetAttesterResponse) XXX_Merge(src proto.Message)

func (*QueryGetAttesterResponse) XXX_Size 

func (m *QueryGetAttesterResponse) XXX_Size() int

func (*QueryGetAttesterResponse) XXX_Unmarshal 

func (m *QueryGetAttesterResponse) XXX_Unmarshal(b []byte) error

type QueryGetBurningAndMintingPausedRequest 

type QueryGetBurningAndMintingPausedRequest struct {
}

QueryBurningAndMintingPausedRequest is the request type for the Query/BurningAndMintingPaused RPC method.

func (*QueryGetBurningAndMintingPausedRequest) Descriptor 

func (*QueryGetBurningAndMintingPausedRequest) Descriptor() ([]byte, []int)

func (*QueryGetBurningAndMintingPausedRequest) Marshal 

func (m *QueryGetBurningAndMintingPausedRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetBurningAndMintingPausedRequest) MarshalTo 

func (m *QueryGetBurningAndMintingPausedRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetBurningAndMintingPausedRequest) MarshalToSizedBuffer 

func (m *QueryGetBurningAndMintingPausedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetBurningAndMintingPausedRequest) ProtoMessage 

func (*QueryGetBurningAndMintingPausedRequest) ProtoMessage()

func (*QueryGetBurningAndMintingPausedRequest) Reset 

func (m *QueryGetBurningAndMintingPausedRequest) Reset()

func (*QueryGetBurningAndMintingPausedRequest) Size 

func (m *QueryGetBurningAndMintingPausedRequest) Size() (n int)

func (*QueryGetBurningAndMintingPausedRequest) String 

func (m *QueryGetBurningAndMintingPausedRequest) String() string

func (*QueryGetBurningAndMintingPausedRequest) Unmarshal 

func (m *QueryGetBurningAndMintingPausedRequest) Unmarshal(dAtA []byte) error

func (*QueryGetBurningAndMintingPausedRequest) XXX_DiscardUnknown 

func (m *QueryGetBurningAndMintingPausedRequest) XXX_DiscardUnknown()

func (*QueryGetBurningAndMintingPausedRequest) XXX_Marshal 

func (m *QueryGetBurningAndMintingPausedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetBurningAndMintingPausedRequest) XXX_Merge 

func (m *QueryGetBurningAndMintingPausedRequest) XXX_Merge(src proto.Message)

func (*QueryGetBurningAndMintingPausedRequest) XXX_Size 

func (m *QueryGetBurningAndMintingPausedRequest) XXX_Size() int

func (*QueryGetBurningAndMintingPausedRequest) XXX_Unmarshal 

func (m *QueryGetBurningAndMintingPausedRequest) XXX_Unmarshal(b []byte) error

type QueryGetBurningAndMintingPausedResponse 

type QueryGetBurningAndMintingPausedResponse struct {
	Paused BurningAndMintingPaused `protobuf:"bytes,1,opt,name=paused,proto3" json:"paused"`
}

QueryBurningAndMintingPausedResponse is the response type for the Query/BurningAndMintingPaused RPC method.

func (*QueryGetBurningAndMintingPausedResponse) Descriptor 

func (*QueryGetBurningAndMintingPausedResponse) Descriptor() ([]byte, []int)

func (*QueryGetBurningAndMintingPausedResponse) GetPaused 

func (m *QueryGetBurningAndMintingPausedResponse) GetPaused() BurningAndMintingPaused

func (*QueryGetBurningAndMintingPausedResponse) Marshal 

func (m *QueryGetBurningAndMintingPausedResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetBurningAndMintingPausedResponse) MarshalTo 

func (m *QueryGetBurningAndMintingPausedResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetBurningAndMintingPausedResponse) MarshalToSizedBuffer 

func (m *QueryGetBurningAndMintingPausedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetBurningAndMintingPausedResponse) ProtoMessage 

func (*QueryGetBurningAndMintingPausedResponse) ProtoMessage()

func (*QueryGetBurningAndMintingPausedResponse) Reset 

func (m *QueryGetBurningAndMintingPausedResponse) Reset()

func (*QueryGetBurningAndMintingPausedResponse) Size 

func (m *QueryGetBurningAndMintingPausedResponse) Size() (n int)

func (*QueryGetBurningAndMintingPausedResponse) String 

func (m *QueryGetBurningAndMintingPausedResponse) String() string

func (*QueryGetBurningAndMintingPausedResponse) Unmarshal 

func (m *QueryGetBurningAndMintingPausedResponse) Unmarshal(dAtA []byte) error

func (*QueryGetBurningAndMintingPausedResponse) XXX_DiscardUnknown 

func (m *QueryGetBurningAndMintingPausedResponse) XXX_DiscardUnknown()

func (*QueryGetBurningAndMintingPausedResponse) XXX_Marshal 

func (m *QueryGetBurningAndMintingPausedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetBurningAndMintingPausedResponse) XXX_Merge 

func (m *QueryGetBurningAndMintingPausedResponse) XXX_Merge(src proto.Message)

func (*QueryGetBurningAndMintingPausedResponse) XXX_Size 

func (m *QueryGetBurningAndMintingPausedResponse) XXX_Size() int

func (*QueryGetBurningAndMintingPausedResponse) XXX_Unmarshal 

func (m *QueryGetBurningAndMintingPausedResponse) XXX_Unmarshal(b []byte) error

type QueryGetMaxMessageBodySizeRequest 

type QueryGetMaxMessageBodySizeRequest struct {
}

QueryMaxMessageBodySizeRequest is the request type for the Query/MaxMessageBodySize RPC method.

func (*QueryGetMaxMessageBodySizeRequest) Descriptor 

func (*QueryGetMaxMessageBodySizeRequest) Descriptor() ([]byte, []int)

func (*QueryGetMaxMessageBodySizeRequest) Marshal 

func (m *QueryGetMaxMessageBodySizeRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetMaxMessageBodySizeRequest) MarshalTo 

func (m *QueryGetMaxMessageBodySizeRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetMaxMessageBodySizeRequest) MarshalToSizedBuffer 

func (m *QueryGetMaxMessageBodySizeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetMaxMessageBodySizeRequest) ProtoMessage 

func (*QueryGetMaxMessageBodySizeRequest) ProtoMessage()

func (*QueryGetMaxMessageBodySizeRequest) Reset 

func (m *QueryGetMaxMessageBodySizeRequest) Reset()

func (*QueryGetMaxMessageBodySizeRequest) Size 

func (m *QueryGetMaxMessageBodySizeRequest) Size() (n int)

func (*QueryGetMaxMessageBodySizeRequest) String 

func (m *QueryGetMaxMessageBodySizeRequest) String() string

func (*QueryGetMaxMessageBodySizeRequest) Unmarshal 

func (m *QueryGetMaxMessageBodySizeRequest) Unmarshal(dAtA []byte) error

func (*QueryGetMaxMessageBodySizeRequest) XXX_DiscardUnknown 

func (m *QueryGetMaxMessageBodySizeRequest) XXX_DiscardUnknown()

func (*QueryGetMaxMessageBodySizeRequest) XXX_Marshal 

func (m *QueryGetMaxMessageBodySizeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetMaxMessageBodySizeRequest) XXX_Merge 

func (m *QueryGetMaxMessageBodySizeRequest) XXX_Merge(src proto.Message)

func (*QueryGetMaxMessageBodySizeRequest) XXX_Size 

func (m *QueryGetMaxMessageBodySizeRequest) XXX_Size() int

func (*QueryGetMaxMessageBodySizeRequest) XXX_Unmarshal 

func (m *QueryGetMaxMessageBodySizeRequest) XXX_Unmarshal(b []byte) error

type QueryGetMaxMessageBodySizeResponse 

type QueryGetMaxMessageBodySizeResponse struct {
	Amount MaxMessageBodySize `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount"`
}

QueryMaxMessageBodySizeResponse is the response type for the Query/MaxMessageBodySize RPC method.

func (*QueryGetMaxMessageBodySizeResponse) Descriptor 

func (*QueryGetMaxMessageBodySizeResponse) Descriptor() ([]byte, []int)

func (*QueryGetMaxMessageBodySizeResponse) GetAmount 

func (m *QueryGetMaxMessageBodySizeResponse) GetAmount() MaxMessageBodySize

func (*QueryGetMaxMessageBodySizeResponse) Marshal 

func (m *QueryGetMaxMessageBodySizeResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetMaxMessageBodySizeResponse) MarshalTo 

func (m *QueryGetMaxMessageBodySizeResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetMaxMessageBodySizeResponse) MarshalToSizedBuffer 

func (m *QueryGetMaxMessageBodySizeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetMaxMessageBodySizeResponse) ProtoMessage 

func (*QueryGetMaxMessageBodySizeResponse) ProtoMessage()

func (*QueryGetMaxMessageBodySizeResponse) Reset 

func (m *QueryGetMaxMessageBodySizeResponse) Reset()

func (*QueryGetMaxMessageBodySizeResponse) Size 

func (m *QueryGetMaxMessageBodySizeResponse) Size() (n int)

func (*QueryGetMaxMessageBodySizeResponse) String 

func (m *QueryGetMaxMessageBodySizeResponse) String() string

func (*QueryGetMaxMessageBodySizeResponse) Unmarshal 

func (m *QueryGetMaxMessageBodySizeResponse) Unmarshal(dAtA []byte) error

func (*QueryGetMaxMessageBodySizeResponse) XXX_DiscardUnknown 

func (m *QueryGetMaxMessageBodySizeResponse) XXX_DiscardUnknown()

func (*QueryGetMaxMessageBodySizeResponse) XXX_Marshal 

func (m *QueryGetMaxMessageBodySizeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetMaxMessageBodySizeResponse) XXX_Merge 

func (m *QueryGetMaxMessageBodySizeResponse) XXX_Merge(src proto.Message)

func (*QueryGetMaxMessageBodySizeResponse) XXX_Size 

func (m *QueryGetMaxMessageBodySizeResponse) XXX_Size() int

func (*QueryGetMaxMessageBodySizeResponse) XXX_Unmarshal 

func (m *QueryGetMaxMessageBodySizeResponse) XXX_Unmarshal(b []byte) error

type QueryGetNextAvailableNonceRequest 

type QueryGetNextAvailableNonceRequest struct {
}

QueryGetNextAvailableNonceRequest is the request type for the Query/NextAvailableNonce RPC method.

func (*QueryGetNextAvailableNonceRequest) Descriptor 

func (*QueryGetNextAvailableNonceRequest) Descriptor() ([]byte, []int)

func (*QueryGetNextAvailableNonceRequest) Marshal 

func (m *QueryGetNextAvailableNonceRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetNextAvailableNonceRequest) MarshalTo 

func (m *QueryGetNextAvailableNonceRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetNextAvailableNonceRequest) MarshalToSizedBuffer 

func (m *QueryGetNextAvailableNonceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetNextAvailableNonceRequest) ProtoMessage 

func (*QueryGetNextAvailableNonceRequest) ProtoMessage()

func (*QueryGetNextAvailableNonceRequest) Reset 

func (m *QueryGetNextAvailableNonceRequest) Reset()

func (*QueryGetNextAvailableNonceRequest) Size 

func (m *QueryGetNextAvailableNonceRequest) Size() (n int)

func (*QueryGetNextAvailableNonceRequest) String 

func (m *QueryGetNextAvailableNonceRequest) String() string

func (*QueryGetNextAvailableNonceRequest) Unmarshal 

func (m *QueryGetNextAvailableNonceRequest) Unmarshal(dAtA []byte) error

func (*QueryGetNextAvailableNonceRequest) XXX_DiscardUnknown 

func (m *QueryGetNextAvailableNonceRequest) XXX_DiscardUnknown()

func (*QueryGetNextAvailableNonceRequest) XXX_Marshal 

func (m *QueryGetNextAvailableNonceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetNextAvailableNonceRequest) XXX_Merge 

func (m *QueryGetNextAvailableNonceRequest) XXX_Merge(src proto.Message)

func (*QueryGetNextAvailableNonceRequest) XXX_Size 

func (m *QueryGetNextAvailableNonceRequest) XXX_Size() int

func (*QueryGetNextAvailableNonceRequest) XXX_Unmarshal 

func (m *QueryGetNextAvailableNonceRequest) XXX_Unmarshal(b []byte) error

type QueryGetNextAvailableNonceResponse 

type QueryGetNextAvailableNonceResponse struct {
	Nonce Nonce `protobuf:"bytes,1,opt,name=nonce,proto3" json:"nonce"`
}

Query QueryGetNextAvailableNonceResponse is the response type for the Query/NextAvailableNonce RPC method.

func (*QueryGetNextAvailableNonceResponse) Descriptor 

func (*QueryGetNextAvailableNonceResponse) Descriptor() ([]byte, []int)

func (*QueryGetNextAvailableNonceResponse) GetNonce 

func (m *QueryGetNextAvailableNonceResponse) GetNonce() Nonce

func (*QueryGetNextAvailableNonceResponse) Marshal 

func (m *QueryGetNextAvailableNonceResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetNextAvailableNonceResponse) MarshalTo 

func (m *QueryGetNextAvailableNonceResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetNextAvailableNonceResponse) MarshalToSizedBuffer 

func (m *QueryGetNextAvailableNonceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetNextAvailableNonceResponse) ProtoMessage 

func (*QueryGetNextAvailableNonceResponse) ProtoMessage()

func (*QueryGetNextAvailableNonceResponse) Reset 

func (m *QueryGetNextAvailableNonceResponse) Reset()

func (*QueryGetNextAvailableNonceResponse) Size 

func (m *QueryGetNextAvailableNonceResponse) Size() (n int)

func (*QueryGetNextAvailableNonceResponse) String 

func (m *QueryGetNextAvailableNonceResponse) String() string

func (*QueryGetNextAvailableNonceResponse) Unmarshal 

func (m *QueryGetNextAvailableNonceResponse) Unmarshal(dAtA []byte) error

func (*QueryGetNextAvailableNonceResponse) XXX_DiscardUnknown 

func (m *QueryGetNextAvailableNonceResponse) XXX_DiscardUnknown()

func (*QueryGetNextAvailableNonceResponse) XXX_Marshal 

func (m *QueryGetNextAvailableNonceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetNextAvailableNonceResponse) XXX_Merge 

func (m *QueryGetNextAvailableNonceResponse) XXX_Merge(src proto.Message)

func (*QueryGetNextAvailableNonceResponse) XXX_Size 

func (m *QueryGetNextAvailableNonceResponse) XXX_Size() int

func (*QueryGetNextAvailableNonceResponse) XXX_Unmarshal 

func (m *QueryGetNextAvailableNonceResponse) XXX_Unmarshal(b []byte) error

type QueryGetPerMessageBurnLimitRequest 

type QueryGetPerMessageBurnLimitRequest struct {
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

QueryPerMessageBurnLimitRequest is the request type for the Query/PerMessageBurnLimit RPC method.

func (*QueryGetPerMessageBurnLimitRequest) Descriptor 

func (*QueryGetPerMessageBurnLimitRequest) Descriptor() ([]byte, []int)

func (*QueryGetPerMessageBurnLimitRequest) GetDenom 

func (m *QueryGetPerMessageBurnLimitRequest) GetDenom() string

func (*QueryGetPerMessageBurnLimitRequest) Marshal 

func (m *QueryGetPerMessageBurnLimitRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetPerMessageBurnLimitRequest) MarshalTo 

func (m *QueryGetPerMessageBurnLimitRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetPerMessageBurnLimitRequest) MarshalToSizedBuffer 

func (m *QueryGetPerMessageBurnLimitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetPerMessageBurnLimitRequest) ProtoMessage 

func (*QueryGetPerMessageBurnLimitRequest) ProtoMessage()

func (*QueryGetPerMessageBurnLimitRequest) Reset 

func (m *QueryGetPerMessageBurnLimitRequest) Reset()

func (*QueryGetPerMessageBurnLimitRequest) Size 

func (m *QueryGetPerMessageBurnLimitRequest) Size() (n int)

func (*QueryGetPerMessageBurnLimitRequest) String 

func (m *QueryGetPerMessageBurnLimitRequest) String() string

func (*QueryGetPerMessageBurnLimitRequest) Unmarshal 

func (m *QueryGetPerMessageBurnLimitRequest) Unmarshal(dAtA []byte) error

func (*QueryGetPerMessageBurnLimitRequest) XXX_DiscardUnknown 

func (m *QueryGetPerMessageBurnLimitRequest) XXX_DiscardUnknown()

func (*QueryGetPerMessageBurnLimitRequest) XXX_Marshal 

func (m *QueryGetPerMessageBurnLimitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetPerMessageBurnLimitRequest) XXX_Merge 

func (m *QueryGetPerMessageBurnLimitRequest) XXX_Merge(src proto.Message)

func (*QueryGetPerMessageBurnLimitRequest) XXX_Size 

func (m *QueryGetPerMessageBurnLimitRequest) XXX_Size() int

func (*QueryGetPerMessageBurnLimitRequest) XXX_Unmarshal 

func (m *QueryGetPerMessageBurnLimitRequest) XXX_Unmarshal(b []byte) error

type QueryGetPerMessageBurnLimitResponse 

type QueryGetPerMessageBurnLimitResponse struct {
	BurnLimit PerMessageBurnLimit `protobuf:"bytes,1,opt,name=burn_limit,json=burnLimit,proto3" json:"burn_limit"`
}

QueryPerMessageBurnLimitResponse is the response type for the Query/PerMessageBurnLimit RPC method.

func (*QueryGetPerMessageBurnLimitResponse) Descriptor 

func (*QueryGetPerMessageBurnLimitResponse) Descriptor() ([]byte, []int)

func (*QueryGetPerMessageBurnLimitResponse) GetBurnLimit 

func (m *QueryGetPerMessageBurnLimitResponse) GetBurnLimit() PerMessageBurnLimit

func (*QueryGetPerMessageBurnLimitResponse) Marshal 

func (m *QueryGetPerMessageBurnLimitResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetPerMessageBurnLimitResponse) MarshalTo 

func (m *QueryGetPerMessageBurnLimitResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetPerMessageBurnLimitResponse) MarshalToSizedBuffer 

func (m *QueryGetPerMessageBurnLimitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetPerMessageBurnLimitResponse) ProtoMessage 

func (*QueryGetPerMessageBurnLimitResponse) ProtoMessage()

func (*QueryGetPerMessageBurnLimitResponse) Reset 

func (m *QueryGetPerMessageBurnLimitResponse) Reset()

func (*QueryGetPerMessageBurnLimitResponse) Size 

func (m *QueryGetPerMessageBurnLimitResponse) Size() (n int)

func (*QueryGetPerMessageBurnLimitResponse) String 

func (m *QueryGetPerMessageBurnLimitResponse) String() string

func (*QueryGetPerMessageBurnLimitResponse) Unmarshal 

func (m *QueryGetPerMessageBurnLimitResponse) Unmarshal(dAtA []byte) error

func (*QueryGetPerMessageBurnLimitResponse) XXX_DiscardUnknown 

func (m *QueryGetPerMessageBurnLimitResponse) XXX_DiscardUnknown()

func (*QueryGetPerMessageBurnLimitResponse) XXX_Marshal 

func (m *QueryGetPerMessageBurnLimitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetPerMessageBurnLimitResponse) XXX_Merge 

func (m *QueryGetPerMessageBurnLimitResponse) XXX_Merge(src proto.Message)

func (*QueryGetPerMessageBurnLimitResponse) XXX_Size 

func (m *QueryGetPerMessageBurnLimitResponse) XXX_Size() int

func (*QueryGetPerMessageBurnLimitResponse) XXX_Unmarshal 

func (m *QueryGetPerMessageBurnLimitResponse) XXX_Unmarshal(b []byte) error

type QueryGetSendingAndReceivingMessagesPausedRequest 

type QueryGetSendingAndReceivingMessagesPausedRequest struct {
}

QuerySendingAndReceivingPausedRequest is the request type for the Query/SendingAndReceivingPaused RPC method.

func (*QueryGetSendingAndReceivingMessagesPausedRequest) Descriptor 

func (*QueryGetSendingAndReceivingMessagesPausedRequest) Descriptor() ([]byte, []int)

func (*QueryGetSendingAndReceivingMessagesPausedRequest) Marshal 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetSendingAndReceivingMessagesPausedRequest) MarshalTo 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetSendingAndReceivingMessagesPausedRequest) MarshalToSizedBuffer 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetSendingAndReceivingMessagesPausedRequest) ProtoMessage 

func (*QueryGetSendingAndReceivingMessagesPausedRequest) ProtoMessage()

func (*QueryGetSendingAndReceivingMessagesPausedRequest) Reset 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) Reset()

func (*QueryGetSendingAndReceivingMessagesPausedRequest) Size 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) Size() (n int)

func (*QueryGetSendingAndReceivingMessagesPausedRequest) String 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) String() string

func (*QueryGetSendingAndReceivingMessagesPausedRequest) Unmarshal 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) Unmarshal(dAtA []byte) error

func (*QueryGetSendingAndReceivingMessagesPausedRequest) XXX_DiscardUnknown 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) XXX_DiscardUnknown()

func (*QueryGetSendingAndReceivingMessagesPausedRequest) XXX_Marshal 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetSendingAndReceivingMessagesPausedRequest) XXX_Merge 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) XXX_Merge(src proto.Message)

func (*QueryGetSendingAndReceivingMessagesPausedRequest) XXX_Size 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) XXX_Size() int

func (*QueryGetSendingAndReceivingMessagesPausedRequest) XXX_Unmarshal 

func (m *QueryGetSendingAndReceivingMessagesPausedRequest) XXX_Unmarshal(b []byte) error

type QueryGetSendingAndReceivingMessagesPausedResponse 

type QueryGetSendingAndReceivingMessagesPausedResponse struct {
	Paused SendingAndReceivingMessagesPaused `protobuf:"bytes,1,opt,name=paused,proto3" json:"paused"`
}

QuerySendingAndReceivingPausedResponse is the response type for the Query/SendingAndReceivingPaused RPC method.

func (*QueryGetSendingAndReceivingMessagesPausedResponse) Descriptor 

func (*QueryGetSendingAndReceivingMessagesPausedResponse) Descriptor() ([]byte, []int)

func (*QueryGetSendingAndReceivingMessagesPausedResponse) GetPaused 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) GetPaused() SendingAndReceivingMessagesPaused

func (*QueryGetSendingAndReceivingMessagesPausedResponse) Marshal 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetSendingAndReceivingMessagesPausedResponse) MarshalTo 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetSendingAndReceivingMessagesPausedResponse) MarshalToSizedBuffer 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetSendingAndReceivingMessagesPausedResponse) ProtoMessage 

func (*QueryGetSendingAndReceivingMessagesPausedResponse) ProtoMessage()

func (*QueryGetSendingAndReceivingMessagesPausedResponse) Reset 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) Reset()

func (*QueryGetSendingAndReceivingMessagesPausedResponse) Size 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) Size() (n int)

func (*QueryGetSendingAndReceivingMessagesPausedResponse) String 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) String() string

func (*QueryGetSendingAndReceivingMessagesPausedResponse) Unmarshal 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) Unmarshal(dAtA []byte) error

func (*QueryGetSendingAndReceivingMessagesPausedResponse) XXX_DiscardUnknown 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) XXX_DiscardUnknown()

func (*QueryGetSendingAndReceivingMessagesPausedResponse) XXX_Marshal 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetSendingAndReceivingMessagesPausedResponse) XXX_Merge 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) XXX_Merge(src proto.Message)

func (*QueryGetSendingAndReceivingMessagesPausedResponse) XXX_Size 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) XXX_Size() int

func (*QueryGetSendingAndReceivingMessagesPausedResponse) XXX_Unmarshal 

func (m *QueryGetSendingAndReceivingMessagesPausedResponse) XXX_Unmarshal(b []byte) error

type QueryGetSignatureThresholdRequest 

type QueryGetSignatureThresholdRequest struct {
}

QuerySignatureThresholdRequest is the request type for the Query/SignatureThreshold RPC method.

func (*QueryGetSignatureThresholdRequest) Descriptor 

func (*QueryGetSignatureThresholdRequest) Descriptor() ([]byte, []int)

func (*QueryGetSignatureThresholdRequest) Marshal 

func (m *QueryGetSignatureThresholdRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetSignatureThresholdRequest) MarshalTo 

func (m *QueryGetSignatureThresholdRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetSignatureThresholdRequest) MarshalToSizedBuffer 

func (m *QueryGetSignatureThresholdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetSignatureThresholdRequest) ProtoMessage 

func (*QueryGetSignatureThresholdRequest) ProtoMessage()

func (*QueryGetSignatureThresholdRequest) Reset 

func (m *QueryGetSignatureThresholdRequest) Reset()

func (*QueryGetSignatureThresholdRequest) Size 

func (m *QueryGetSignatureThresholdRequest) Size() (n int)

func (*QueryGetSignatureThresholdRequest) String 

func (m *QueryGetSignatureThresholdRequest) String() string

func (*QueryGetSignatureThresholdRequest) Unmarshal 

func (m *QueryGetSignatureThresholdRequest) Unmarshal(dAtA []byte) error

func (*QueryGetSignatureThresholdRequest) XXX_DiscardUnknown 

func (m *QueryGetSignatureThresholdRequest) XXX_DiscardUnknown()

func (*QueryGetSignatureThresholdRequest) XXX_Marshal 

func (m *QueryGetSignatureThresholdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetSignatureThresholdRequest) XXX_Merge 

func (m *QueryGetSignatureThresholdRequest) XXX_Merge(src proto.Message)

func (*QueryGetSignatureThresholdRequest) XXX_Size 

func (m *QueryGetSignatureThresholdRequest) XXX_Size() int

func (*QueryGetSignatureThresholdRequest) XXX_Unmarshal 

func (m *QueryGetSignatureThresholdRequest) XXX_Unmarshal(b []byte) error

type QueryGetSignatureThresholdResponse 

type QueryGetSignatureThresholdResponse struct {
	Amount SignatureThreshold `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount"`
}

QuerySignatureThresholdResponse is the response type for the Query/SignatureThreshold RPC method.

func (*QueryGetSignatureThresholdResponse) Descriptor 

func (*QueryGetSignatureThresholdResponse) Descriptor() ([]byte, []int)

func (*QueryGetSignatureThresholdResponse) GetAmount 

func (m *QueryGetSignatureThresholdResponse) GetAmount() SignatureThreshold

func (*QueryGetSignatureThresholdResponse) Marshal 

func (m *QueryGetSignatureThresholdResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetSignatureThresholdResponse) MarshalTo 

func (m *QueryGetSignatureThresholdResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetSignatureThresholdResponse) MarshalToSizedBuffer 

func (m *QueryGetSignatureThresholdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetSignatureThresholdResponse) ProtoMessage 

func (*QueryGetSignatureThresholdResponse) ProtoMessage()

func (*QueryGetSignatureThresholdResponse) Reset 

func (m *QueryGetSignatureThresholdResponse) Reset()

func (*QueryGetSignatureThresholdResponse) Size 

func (m *QueryGetSignatureThresholdResponse) Size() (n int)

func (*QueryGetSignatureThresholdResponse) String 

func (m *QueryGetSignatureThresholdResponse) String() string

func (*QueryGetSignatureThresholdResponse) Unmarshal 

func (m *QueryGetSignatureThresholdResponse) Unmarshal(dAtA []byte) error

func (*QueryGetSignatureThresholdResponse) XXX_DiscardUnknown 

func (m *QueryGetSignatureThresholdResponse) XXX_DiscardUnknown()

func (*QueryGetSignatureThresholdResponse) XXX_Marshal 

func (m *QueryGetSignatureThresholdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetSignatureThresholdResponse) XXX_Merge 

func (m *QueryGetSignatureThresholdResponse) XXX_Merge(src proto.Message)

func (*QueryGetSignatureThresholdResponse) XXX_Size 

func (m *QueryGetSignatureThresholdResponse) XXX_Size() int

func (*QueryGetSignatureThresholdResponse) XXX_Unmarshal 

func (m *QueryGetSignatureThresholdResponse) XXX_Unmarshal(b []byte) error

type QueryGetTokenPairRequest 

type QueryGetTokenPairRequest struct {
	RemoteDomain uint32 `protobuf:"varint,1,opt,name=remote_domain,json=remoteDomain,proto3" json:"remote_domain,omitempty"`
	RemoteToken  string `protobuf:"bytes,2,opt,name=remote_token,json=remoteToken,proto3" json:"remote_token,omitempty"`
}

QueryGetTokenPairRequest is the request type for the Query/TokenPair RPC method.

func (*QueryGetTokenPairRequest) Descriptor 

func (*QueryGetTokenPairRequest) Descriptor() ([]byte, []int)

func (*QueryGetTokenPairRequest) GetRemoteDomain 

func (m *QueryGetTokenPairRequest) GetRemoteDomain() uint32

func (*QueryGetTokenPairRequest) GetRemoteToken 

func (m *QueryGetTokenPairRequest) GetRemoteToken() string

func (*QueryGetTokenPairRequest) Marshal 

func (m *QueryGetTokenPairRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetTokenPairRequest) MarshalTo 

func (m *QueryGetTokenPairRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetTokenPairRequest) MarshalToSizedBuffer 

func (m *QueryGetTokenPairRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetTokenPairRequest) ProtoMessage 

func (*QueryGetTokenPairRequest) ProtoMessage()

func (*QueryGetTokenPairRequest) Reset 

func (m *QueryGetTokenPairRequest) Reset()

func (*QueryGetTokenPairRequest) Size 

func (m *QueryGetTokenPairRequest) Size() (n int)

func (*QueryGetTokenPairRequest) String 

func (m *QueryGetTokenPairRequest) String() string

func (*QueryGetTokenPairRequest) Unmarshal 

func (m *QueryGetTokenPairRequest) Unmarshal(dAtA []byte) error

func (*QueryGetTokenPairRequest) XXX_DiscardUnknown 

func (m *QueryGetTokenPairRequest) XXX_DiscardUnknown()

func (*QueryGetTokenPairRequest) XXX_Marshal 

func (m *QueryGetTokenPairRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetTokenPairRequest) XXX_Merge 

func (m *QueryGetTokenPairRequest) XXX_Merge(src proto.Message)

func (*QueryGetTokenPairRequest) XXX_Size 

func (m *QueryGetTokenPairRequest) XXX_Size() int

func (*QueryGetTokenPairRequest) XXX_Unmarshal 

func (m *QueryGetTokenPairRequest) XXX_Unmarshal(b []byte) error

type QueryGetTokenPairResponse 

type QueryGetTokenPairResponse struct {
	Pair TokenPair `protobuf:"bytes,1,opt,name=pair,proto3" json:"pair"`
}

QueryGetTokenPairResponse is the response type for the Query/TokenPair RPC method.

func (*QueryGetTokenPairResponse) Descriptor 

func (*QueryGetTokenPairResponse) Descriptor() ([]byte, []int)

func (*QueryGetTokenPairResponse) GetPair 

func (m *QueryGetTokenPairResponse) GetPair() TokenPair

func (*QueryGetTokenPairResponse) Marshal 

func (m *QueryGetTokenPairResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetTokenPairResponse) MarshalTo 

func (m *QueryGetTokenPairResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetTokenPairResponse) MarshalToSizedBuffer 

func (m *QueryGetTokenPairResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetTokenPairResponse) ProtoMessage 

func (*QueryGetTokenPairResponse) ProtoMessage()

func (*QueryGetTokenPairResponse) Reset 

func (m *QueryGetTokenPairResponse) Reset()

func (*QueryGetTokenPairResponse) Size 

func (m *QueryGetTokenPairResponse) Size() (n int)

func (*QueryGetTokenPairResponse) String 

func (m *QueryGetTokenPairResponse) String() string

func (*QueryGetTokenPairResponse) Unmarshal 

func (m *QueryGetTokenPairResponse) Unmarshal(dAtA []byte) error

func (*QueryGetTokenPairResponse) XXX_DiscardUnknown 

func (m *QueryGetTokenPairResponse) XXX_DiscardUnknown()

func (*QueryGetTokenPairResponse) XXX_Marshal 

func (m *QueryGetTokenPairResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetTokenPairResponse) XXX_Merge 

func (m *QueryGetTokenPairResponse) XXX_Merge(src proto.Message)

func (*QueryGetTokenPairResponse) XXX_Size 

func (m *QueryGetTokenPairResponse) XXX_Size() int

func (*QueryGetTokenPairResponse) XXX_Unmarshal 

func (m *QueryGetTokenPairResponse) XXX_Unmarshal(b []byte) error

type QueryGetUsedNonceRequest 

type QueryGetUsedNonceRequest struct {
	SourceDomain uint32 `protobuf:"varint,1,opt,name=source_domain,json=sourceDomain,proto3" json:"source_domain,omitempty"`
	Nonce        uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

QueryGetUsedNonceRequest is the request type for the Query/UsedNonce RPC method.

func (*QueryGetUsedNonceRequest) Descriptor 

func (*QueryGetUsedNonceRequest) Descriptor() ([]byte, []int)

func (*QueryGetUsedNonceRequest) GetNonce 

func (m *QueryGetUsedNonceRequest) GetNonce() uint64

func (*QueryGetUsedNonceRequest) GetSourceDomain 

func (m *QueryGetUsedNonceRequest) GetSourceDomain() uint32

func (*QueryGetUsedNonceRequest) Marshal 

func (m *QueryGetUsedNonceRequest) Marshal() (dAtA []byte, err error)

func (*QueryGetUsedNonceRequest) MarshalTo 

func (m *QueryGetUsedNonceRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetUsedNonceRequest) MarshalToSizedBuffer 

func (m *QueryGetUsedNonceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetUsedNonceRequest) ProtoMessage 

func (*QueryGetUsedNonceRequest) ProtoMessage()

func (*QueryGetUsedNonceRequest) Reset 

func (m *QueryGetUsedNonceRequest) Reset()

func (*QueryGetUsedNonceRequest) Size 

func (m *QueryGetUsedNonceRequest) Size() (n int)

func (*QueryGetUsedNonceRequest) String 

func (m *QueryGetUsedNonceRequest) String() string

func (*QueryGetUsedNonceRequest) Unmarshal 

func (m *QueryGetUsedNonceRequest) Unmarshal(dAtA []byte) error

func (*QueryGetUsedNonceRequest) XXX_DiscardUnknown 

func (m *QueryGetUsedNonceRequest) XXX_DiscardUnknown()

func (*QueryGetUsedNonceRequest) XXX_Marshal 

func (m *QueryGetUsedNonceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetUsedNonceRequest) XXX_Merge 

func (m *QueryGetUsedNonceRequest) XXX_Merge(src proto.Message)

func (*QueryGetUsedNonceRequest) XXX_Size 

func (m *QueryGetUsedNonceRequest) XXX_Size() int

func (*QueryGetUsedNonceRequest) XXX_Unmarshal 

func (m *QueryGetUsedNonceRequest) XXX_Unmarshal(b []byte) error

type QueryGetUsedNonceResponse 

type QueryGetUsedNonceResponse struct {
	Nonce Nonce `protobuf:"bytes,1,opt,name=nonce,proto3" json:"nonce"`
}

QueryGetUsedNonceResponse is the response type for the Query/UsedNonce RPC method.

func (*QueryGetUsedNonceResponse) Descriptor 

func (*QueryGetUsedNonceResponse) Descriptor() ([]byte, []int)

func (*QueryGetUsedNonceResponse) GetNonce 

func (m *QueryGetUsedNonceResponse) GetNonce() Nonce

func (*QueryGetUsedNonceResponse) Marshal 

func (m *QueryGetUsedNonceResponse) Marshal() (dAtA []byte, err error)

func (*QueryGetUsedNonceResponse) MarshalTo 

func (m *QueryGetUsedNonceResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGetUsedNonceResponse) MarshalToSizedBuffer 

func (m *QueryGetUsedNonceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGetUsedNonceResponse) ProtoMessage 

func (*QueryGetUsedNonceResponse) ProtoMessage()

func (*QueryGetUsedNonceResponse) Reset 

func (m *QueryGetUsedNonceResponse) Reset()

func (*QueryGetUsedNonceResponse) Size 

func (m *QueryGetUsedNonceResponse) Size() (n int)

func (*QueryGetUsedNonceResponse) String 

func (m *QueryGetUsedNonceResponse) String() string

func (*QueryGetUsedNonceResponse) Unmarshal 

func (m *QueryGetUsedNonceResponse) Unmarshal(dAtA []byte) error

func (*QueryGetUsedNonceResponse) XXX_DiscardUnknown 

func (m *QueryGetUsedNonceResponse) XXX_DiscardUnknown()

func (*QueryGetUsedNonceResponse) XXX_Marshal 

func (m *QueryGetUsedNonceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGetUsedNonceResponse) XXX_Merge 

func (m *QueryGetUsedNonceResponse) XXX_Merge(src proto.Message)

func (*QueryGetUsedNonceResponse) XXX_Size 

func (m *QueryGetUsedNonceResponse) XXX_Size() int

func (*QueryGetUsedNonceResponse) XXX_Unmarshal 

func (m *QueryGetUsedNonceResponse) XXX_Unmarshal(b []byte) error

type QueryLocalDomainRequest 

type QueryLocalDomainRequest struct {
}

QueryLocalDomainRequest is the request type for the Query/LocalDomain RPC method.

func (*QueryLocalDomainRequest) Descriptor 

func (*QueryLocalDomainRequest) Descriptor() ([]byte, []int)

func (*QueryLocalDomainRequest) Marshal 

func (m *QueryLocalDomainRequest) Marshal() (dAtA []byte, err error)

func (*QueryLocalDomainRequest) MarshalTo 

func (m *QueryLocalDomainRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryLocalDomainRequest) MarshalToSizedBuffer 

func (m *QueryLocalDomainRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryLocalDomainRequest) ProtoMessage 

func (*QueryLocalDomainRequest) ProtoMessage()

func (*QueryLocalDomainRequest) Reset 

func (m *QueryLocalDomainRequest) Reset()

func (*QueryLocalDomainRequest) Size 

func (m *QueryLocalDomainRequest) Size() (n int)

func (*QueryLocalDomainRequest) String 

func (m *QueryLocalDomainRequest) String() string

func (*QueryLocalDomainRequest) Unmarshal 

func (m *QueryLocalDomainRequest) Unmarshal(dAtA []byte) error

func (*QueryLocalDomainRequest) XXX_DiscardUnknown 

func (m *QueryLocalDomainRequest) XXX_DiscardUnknown()

func (*QueryLocalDomainRequest) XXX_Marshal 

func (m *QueryLocalDomainRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryLocalDomainRequest) XXX_Merge 

func (m *QueryLocalDomainRequest) XXX_Merge(src proto.Message)

func (*QueryLocalDomainRequest) XXX_Size 

func (m *QueryLocalDomainRequest) XXX_Size() int

func (*QueryLocalDomainRequest) XXX_Unmarshal 

func (m *QueryLocalDomainRequest) XXX_Unmarshal(b []byte) error

type QueryLocalDomainResponse 

type QueryLocalDomainResponse struct {
	// domain_id is the id of the local domain.
	DomainId uint32 `protobuf:"varint,1,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
}

QueryLocalDomainResponse is the response type for the Query/LocalDomain RPC method.

func (*QueryLocalDomainResponse) Descriptor 

func (*QueryLocalDomainResponse) Descriptor() ([]byte, []int)

func (*QueryLocalDomainResponse) GetDomainId 

func (m *QueryLocalDomainResponse) GetDomainId() uint32

func (*QueryLocalDomainResponse) Marshal 

func (m *QueryLocalDomainResponse) Marshal() (dAtA []byte, err error)

func (*QueryLocalDomainResponse) MarshalTo 

func (m *QueryLocalDomainResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryLocalDomainResponse) MarshalToSizedBuffer 

func (m *QueryLocalDomainResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryLocalDomainResponse) ProtoMessage 

func (*QueryLocalDomainResponse) ProtoMessage()

func (*QueryLocalDomainResponse) Reset 

func (m *QueryLocalDomainResponse) Reset()

func (*QueryLocalDomainResponse) Size 

func (m *QueryLocalDomainResponse) Size() (n int)

func (*QueryLocalDomainResponse) String 

func (m *QueryLocalDomainResponse) String() string

func (*QueryLocalDomainResponse) Unmarshal 

func (m *QueryLocalDomainResponse) Unmarshal(dAtA []byte) error

func (*QueryLocalDomainResponse) XXX_DiscardUnknown 

func (m *QueryLocalDomainResponse) XXX_DiscardUnknown()

func (*QueryLocalDomainResponse) XXX_Marshal 

func (m *QueryLocalDomainResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryLocalDomainResponse) XXX_Merge 

func (m *QueryLocalDomainResponse) XXX_Merge(src proto.Message)

func (*QueryLocalDomainResponse) XXX_Size 

func (m *QueryLocalDomainResponse) XXX_Size() int

func (*QueryLocalDomainResponse) XXX_Unmarshal 

func (m *QueryLocalDomainResponse) XXX_Unmarshal(b []byte) error

type QueryLocalMessageVersionRequest 

type QueryLocalMessageVersionRequest struct {
}

QueryLocalMessageVersionRequest is the request type for the Query/LocalMessageVersion RPC method.

func (*QueryLocalMessageVersionRequest) Descriptor 

func (*QueryLocalMessageVersionRequest) Descriptor() ([]byte, []int)

func (*QueryLocalMessageVersionRequest) Marshal 

func (m *QueryLocalMessageVersionRequest) Marshal() (dAtA []byte, err error)

func (*QueryLocalMessageVersionRequest) MarshalTo 

func (m *QueryLocalMessageVersionRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryLocalMessageVersionRequest) MarshalToSizedBuffer 

func (m *QueryLocalMessageVersionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryLocalMessageVersionRequest) ProtoMessage 

func (*QueryLocalMessageVersionRequest) ProtoMessage()

func (*QueryLocalMessageVersionRequest) Reset 

func (m *QueryLocalMessageVersionRequest) Reset()

func (*QueryLocalMessageVersionRequest) Size 

func (m *QueryLocalMessageVersionRequest) Size() (n int)

func (*QueryLocalMessageVersionRequest) String 

func (m *QueryLocalMessageVersionRequest) String() string

func (*QueryLocalMessageVersionRequest) Unmarshal 

func (m *QueryLocalMessageVersionRequest) Unmarshal(dAtA []byte) error

func (*QueryLocalMessageVersionRequest) XXX_DiscardUnknown 

func (m *QueryLocalMessageVersionRequest) XXX_DiscardUnknown()

func (*QueryLocalMessageVersionRequest) XXX_Marshal 

func (m *QueryLocalMessageVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryLocalMessageVersionRequest) XXX_Merge 

func (m *QueryLocalMessageVersionRequest) XXX_Merge(src proto.Message)

func (*QueryLocalMessageVersionRequest) XXX_Size 

func (m *QueryLocalMessageVersionRequest) XXX_Size() int

func (*QueryLocalMessageVersionRequest) XXX_Unmarshal 

func (m *QueryLocalMessageVersionRequest) XXX_Unmarshal(b []byte) error

type QueryLocalMessageVersionResponse 

type QueryLocalMessageVersionResponse struct {
	// version is the message version of the local domain.
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
}

QueryLocalMessageVersionResponse is the response type for the Query/LocalMessageVersion RPC method.

func (*QueryLocalMessageVersionResponse) Descriptor 

func (*QueryLocalMessageVersionResponse) Descriptor() ([]byte, []int)

func (*QueryLocalMessageVersionResponse) GetVersion 

func (m *QueryLocalMessageVersionResponse) GetVersion() uint32

func (*QueryLocalMessageVersionResponse) Marshal 

func (m *QueryLocalMessageVersionResponse) Marshal() (dAtA []byte, err error)

func (*QueryLocalMessageVersionResponse) MarshalTo 

func (m *QueryLocalMessageVersionResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryLocalMessageVersionResponse) MarshalToSizedBuffer 

func (m *QueryLocalMessageVersionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryLocalMessageVersionResponse) ProtoMessage 

func (*QueryLocalMessageVersionResponse) ProtoMessage()

func (*QueryLocalMessageVersionResponse) Reset 

func (m *QueryLocalMessageVersionResponse) Reset()

func (*QueryLocalMessageVersionResponse) Size 

func (m *QueryLocalMessageVersionResponse) Size() (n int)

func (*QueryLocalMessageVersionResponse) String 

func (m *QueryLocalMessageVersionResponse) String() string

func (*QueryLocalMessageVersionResponse) Unmarshal 

func (m *QueryLocalMessageVersionResponse) Unmarshal(dAtA []byte) error

func (*QueryLocalMessageVersionResponse) XXX_DiscardUnknown 

func (m *QueryLocalMessageVersionResponse) XXX_DiscardUnknown()

func (*QueryLocalMessageVersionResponse) XXX_Marshal 

func (m *QueryLocalMessageVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryLocalMessageVersionResponse) XXX_Merge 

func (m *QueryLocalMessageVersionResponse) XXX_Merge(src proto.Message)

func (*QueryLocalMessageVersionResponse) XXX_Size 

func (m *QueryLocalMessageVersionResponse) XXX_Size() int

func (*QueryLocalMessageVersionResponse) XXX_Unmarshal 

func (m *QueryLocalMessageVersionResponse) XXX_Unmarshal(b []byte) error

type QueryParamsRequest 

type QueryParamsRequest struct {
}

QueryParamsRequest is the request type for the Query/Params RPC method.

func (*QueryParamsRequest) Descriptor 

func (*QueryParamsRequest) Descriptor() ([]byte, []int)

func (*QueryParamsRequest) Marshal 

func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error)

func (*QueryParamsRequest) MarshalTo 

func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryParamsRequest) MarshalToSizedBuffer 

func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryParamsRequest) ProtoMessage 

func (*QueryParamsRequest) ProtoMessage()

func (*QueryParamsRequest) Reset 

func (m *QueryParamsRequest) Reset()

func (*QueryParamsRequest) Size 

func (m *QueryParamsRequest) Size() (n int)

func (*QueryParamsRequest) String 

func (m *QueryParamsRequest) String() string

func (*QueryParamsRequest) Unmarshal 

func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error

func (*QueryParamsRequest) XXX_DiscardUnknown 

func (m *QueryParamsRequest) XXX_DiscardUnknown()

func (*QueryParamsRequest) XXX_Marshal 

func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryParamsRequest) XXX_Merge 

func (m *QueryParamsRequest) XXX_Merge(src proto.Message)

func (*QueryParamsRequest) XXX_Size 

func (m *QueryParamsRequest) XXX_Size() int

func (*QueryParamsRequest) XXX_Unmarshal 

func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error

type QueryParamsResponse 

type QueryParamsResponse struct {
	// params holds all the parameters of this module.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

QueryParamsResponse is the response type for the Query/Params RPC method.

func (*QueryParamsResponse) Descriptor 

func (*QueryParamsResponse) Descriptor() ([]byte, []int)

func (*QueryParamsResponse) GetParams 

func (m *QueryParamsResponse) GetParams() Params

func (*QueryParamsResponse) Marshal 

func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error)

func (*QueryParamsResponse) MarshalTo 

func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryParamsResponse) MarshalToSizedBuffer 

func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryParamsResponse) ProtoMessage 

func (*QueryParamsResponse) ProtoMessage()

func (*QueryParamsResponse) Reset 

func (m *QueryParamsResponse) Reset()

func (*QueryParamsResponse) Size 

func (m *QueryParamsResponse) Size() (n int)

func (*QueryParamsResponse) String 

func (m *QueryParamsResponse) String() string

func (*QueryParamsResponse) Unmarshal 

func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error

func (*QueryParamsResponse) XXX_DiscardUnknown 

func (m *QueryParamsResponse) XXX_DiscardUnknown()

func (*QueryParamsResponse) XXX_Marshal 

func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryParamsResponse) XXX_Merge 

func (m *QueryParamsResponse) XXX_Merge(src proto.Message)

func (*QueryParamsResponse) XXX_Size 

func (m *QueryParamsResponse) XXX_Size() int

func (*QueryParamsResponse) XXX_Unmarshal 

func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error

type QueryRemoteTokenMessengerRequest 

type QueryRemoteTokenMessengerRequest struct {
	DomainId uint32 `protobuf:"varint,1,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
}

QueryRemoteTokenMessengerRequest is the request type for the Query/RemoteTokenMessenger RPC method.

func (*QueryRemoteTokenMessengerRequest) Descriptor 

func (*QueryRemoteTokenMessengerRequest) Descriptor() ([]byte, []int)

func (*QueryRemoteTokenMessengerRequest) GetDomainId 

func (m *QueryRemoteTokenMessengerRequest) GetDomainId() uint32

func (*QueryRemoteTokenMessengerRequest) Marshal 

func (m *QueryRemoteTokenMessengerRequest) Marshal() (dAtA []byte, err error)

func (*QueryRemoteTokenMessengerRequest) MarshalTo 

func (m *QueryRemoteTokenMessengerRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryRemoteTokenMessengerRequest) MarshalToSizedBuffer 

func (m *QueryRemoteTokenMessengerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryRemoteTokenMessengerRequest) ProtoMessage 

func (*QueryRemoteTokenMessengerRequest) ProtoMessage()

func (*QueryRemoteTokenMessengerRequest) Reset 

func (m *QueryRemoteTokenMessengerRequest) Reset()

func (*QueryRemoteTokenMessengerRequest) Size 

func (m *QueryRemoteTokenMessengerRequest) Size() (n int)

func (*QueryRemoteTokenMessengerRequest) String 

func (m *QueryRemoteTokenMessengerRequest) String() string

func (*QueryRemoteTokenMessengerRequest) Unmarshal 

func (m *QueryRemoteTokenMessengerRequest) Unmarshal(dAtA []byte) error

func (*QueryRemoteTokenMessengerRequest) XXX_DiscardUnknown 

func (m *QueryRemoteTokenMessengerRequest) XXX_DiscardUnknown()

func (*QueryRemoteTokenMessengerRequest) XXX_Marshal 

func (m *QueryRemoteTokenMessengerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryRemoteTokenMessengerRequest) XXX_Merge 

func (m *QueryRemoteTokenMessengerRequest) XXX_Merge(src proto.Message)

func (*QueryRemoteTokenMessengerRequest) XXX_Size 

func (m *QueryRemoteTokenMessengerRequest) XXX_Size() int

func (*QueryRemoteTokenMessengerRequest) XXX_Unmarshal 

func (m *QueryRemoteTokenMessengerRequest) XXX_Unmarshal(b []byte) error

type QueryRemoteTokenMessengerResponse 

type QueryRemoteTokenMessengerResponse struct {
	RemoteTokenMessenger RemoteTokenMessenger `protobuf:"bytes,1,opt,name=remote_token_messenger,json=remoteTokenMessenger,proto3" json:"remote_token_messenger"`
}

QueryRemoteTokenMessengerResponse is the response type for the Query/RemoteTokenMessenger RPC method.

func (*QueryRemoteTokenMessengerResponse) Descriptor 

func (*QueryRemoteTokenMessengerResponse) Descriptor() ([]byte, []int)

func (*QueryRemoteTokenMessengerResponse) GetRemoteTokenMessenger 

func (m *QueryRemoteTokenMessengerResponse) GetRemoteTokenMessenger() RemoteTokenMessenger

func (*QueryRemoteTokenMessengerResponse) Marshal 

func (m *QueryRemoteTokenMessengerResponse) Marshal() (dAtA []byte, err error)

func (*QueryRemoteTokenMessengerResponse) MarshalTo 

func (m *QueryRemoteTokenMessengerResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryRemoteTokenMessengerResponse) MarshalToSizedBuffer 

func (m *QueryRemoteTokenMessengerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryRemoteTokenMessengerResponse) ProtoMessage 

func (*QueryRemoteTokenMessengerResponse) ProtoMessage()

func (*QueryRemoteTokenMessengerResponse) Reset 

func (m *QueryRemoteTokenMessengerResponse) Reset()

func (*QueryRemoteTokenMessengerResponse) Size 

func (m *QueryRemoteTokenMessengerResponse) Size() (n int)

func (*QueryRemoteTokenMessengerResponse) String 

func (m *QueryRemoteTokenMessengerResponse) String() string

func (*QueryRemoteTokenMessengerResponse) Unmarshal 

func (m *QueryRemoteTokenMessengerResponse) Unmarshal(dAtA []byte) error

func (*QueryRemoteTokenMessengerResponse) XXX_DiscardUnknown 

func (m *QueryRemoteTokenMessengerResponse) XXX_DiscardUnknown()

func (*QueryRemoteTokenMessengerResponse) XXX_Marshal 

func (m *QueryRemoteTokenMessengerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryRemoteTokenMessengerResponse) XXX_Merge 

func (m *QueryRemoteTokenMessengerResponse) XXX_Merge(src proto.Message)

func (*QueryRemoteTokenMessengerResponse) XXX_Size 

func (m *QueryRemoteTokenMessengerResponse) XXX_Size() int

func (*QueryRemoteTokenMessengerResponse) XXX_Unmarshal 

func (m *QueryRemoteTokenMessengerResponse) XXX_Unmarshal(b []byte) error

type QueryRemoteTokenMessengersRequest 

type QueryRemoteTokenMessengersRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryRemoteTokenMessengersRequest is the request type for the Query/RemoteTokenMessengers RPC method.

func (*QueryRemoteTokenMessengersRequest) Descriptor 

func (*QueryRemoteTokenMessengersRequest) Descriptor() ([]byte, []int)

func (*QueryRemoteTokenMessengersRequest) GetPagination 

func (m *QueryRemoteTokenMessengersRequest) GetPagination() *query.PageRequest

func (*QueryRemoteTokenMessengersRequest) Marshal 

func (m *QueryRemoteTokenMessengersRequest) Marshal() (dAtA []byte, err error)

func (*QueryRemoteTokenMessengersRequest) MarshalTo 

func (m *QueryRemoteTokenMessengersRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryRemoteTokenMessengersRequest) MarshalToSizedBuffer 

func (m *QueryRemoteTokenMessengersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryRemoteTokenMessengersRequest) ProtoMessage 

func (*QueryRemoteTokenMessengersRequest) ProtoMessage()

func (*QueryRemoteTokenMessengersRequest) Reset 

func (m *QueryRemoteTokenMessengersRequest) Reset()

func (*QueryRemoteTokenMessengersRequest) Size 

func (m *QueryRemoteTokenMessengersRequest) Size() (n int)

func (*QueryRemoteTokenMessengersRequest) String 

func (m *QueryRemoteTokenMessengersRequest) String() string

func (*QueryRemoteTokenMessengersRequest) Unmarshal 

func (m *QueryRemoteTokenMessengersRequest) Unmarshal(dAtA []byte) error

func (*QueryRemoteTokenMessengersRequest) XXX_DiscardUnknown 

func (m *QueryRemoteTokenMessengersRequest) XXX_DiscardUnknown()

func (*QueryRemoteTokenMessengersRequest) XXX_Marshal 

func (m *QueryRemoteTokenMessengersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryRemoteTokenMessengersRequest) XXX_Merge 

func (m *QueryRemoteTokenMessengersRequest) XXX_Merge(src proto.Message)

func (*QueryRemoteTokenMessengersRequest) XXX_Size 

func (m *QueryRemoteTokenMessengersRequest) XXX_Size() int

func (*QueryRemoteTokenMessengersRequest) XXX_Unmarshal 

func (m *QueryRemoteTokenMessengersRequest) XXX_Unmarshal(b []byte) error

type QueryRemoteTokenMessengersResponse 

type QueryRemoteTokenMessengersResponse struct {
	RemoteTokenMessengers []RemoteTokenMessenger `protobuf:"bytes,1,rep,name=remote_token_messengers,json=remoteTokenMessengers,proto3" json:"remote_token_messengers"`
	Pagination            *query.PageResponse    `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryRemoteTokenMessengersResponse is the response type for the Query/RemoteTokenMessengers RPC method.

func (*QueryRemoteTokenMessengersResponse) Descriptor 

func (*QueryRemoteTokenMessengersResponse) Descriptor() ([]byte, []int)

func (*QueryRemoteTokenMessengersResponse) GetPagination 

func (m *QueryRemoteTokenMessengersResponse) GetPagination() *query.PageResponse

func (*QueryRemoteTokenMessengersResponse) GetRemoteTokenMessengers 

func (m *QueryRemoteTokenMessengersResponse) GetRemoteTokenMessengers() []RemoteTokenMessenger

func (*QueryRemoteTokenMessengersResponse) Marshal 

func (m *QueryRemoteTokenMessengersResponse) Marshal() (dAtA []byte, err error)

func (*QueryRemoteTokenMessengersResponse) MarshalTo 

func (m *QueryRemoteTokenMessengersResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryRemoteTokenMessengersResponse) MarshalToSizedBuffer 

func (m *QueryRemoteTokenMessengersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryRemoteTokenMessengersResponse) ProtoMessage 

func (*QueryRemoteTokenMessengersResponse) ProtoMessage()

func (*QueryRemoteTokenMessengersResponse) Reset 

func (m *QueryRemoteTokenMessengersResponse) Reset()

func (*QueryRemoteTokenMessengersResponse) Size 

func (m *QueryRemoteTokenMessengersResponse) Size() (n int)

func (*QueryRemoteTokenMessengersResponse) String 

func (m *QueryRemoteTokenMessengersResponse) String() string

func (*QueryRemoteTokenMessengersResponse) Unmarshal 

func (m *QueryRemoteTokenMessengersResponse) Unmarshal(dAtA []byte) error

func (*QueryRemoteTokenMessengersResponse) XXX_DiscardUnknown 

func (m *QueryRemoteTokenMessengersResponse) XXX_DiscardUnknown()

func (*QueryRemoteTokenMessengersResponse) XXX_Marshal 

func (m *QueryRemoteTokenMessengersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryRemoteTokenMessengersResponse) XXX_Merge 

func (m *QueryRemoteTokenMessengersResponse) XXX_Merge(src proto.Message)

func (*QueryRemoteTokenMessengersResponse) XXX_Size 

func (m *QueryRemoteTokenMessengersResponse) XXX_Size() int

func (*QueryRemoteTokenMessengersResponse) XXX_Unmarshal 

func (m *QueryRemoteTokenMessengersResponse) XXX_Unmarshal(b []byte) error

type QueryRolesRequest 

type QueryRolesRequest struct {
}

QueryRolesRequest is the request type for the Query/Roles RPC method.

func (*QueryRolesRequest) Descriptor 

func (*QueryRolesRequest) Descriptor() ([]byte, []int)

func (*QueryRolesRequest) Marshal 

func (m *QueryRolesRequest) Marshal() (dAtA []byte, err error)

func (*QueryRolesRequest) MarshalTo 

func (m *QueryRolesRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryRolesRequest) MarshalToSizedBuffer 

func (m *QueryRolesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryRolesRequest) ProtoMessage 

func (*QueryRolesRequest) ProtoMessage()

func (*QueryRolesRequest) Reset 

func (m *QueryRolesRequest) Reset()

func (*QueryRolesRequest) Size 

func (m *QueryRolesRequest) Size() (n int)

func (*QueryRolesRequest) String 

func (m *QueryRolesRequest) String() string

func (*QueryRolesRequest) Unmarshal 

func (m *QueryRolesRequest) Unmarshal(dAtA []byte) error

func (*QueryRolesRequest) XXX_DiscardUnknown 

func (m *QueryRolesRequest) XXX_DiscardUnknown()

func (*QueryRolesRequest) XXX_Marshal 

func (m *QueryRolesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryRolesRequest) XXX_Merge 

func (m *QueryRolesRequest) XXX_Merge(src proto.Message)

func (*QueryRolesRequest) XXX_Size 

func (m *QueryRolesRequest) XXX_Size() int

func (*QueryRolesRequest) XXX_Unmarshal 

func (m *QueryRolesRequest) XXX_Unmarshal(b []byte) error

type QueryRolesResponse 

type QueryRolesResponse struct {
	Owner           string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	AttesterManager string `protobuf:"bytes,2,opt,name=attester_manager,json=attesterManager,proto3" json:"attester_manager,omitempty"`
	Pauser          string `protobuf:"bytes,3,opt,name=pauser,proto3" json:"pauser,omitempty"`
	TokenController string `protobuf:"bytes,4,opt,name=token_controller,json=tokenController,proto3" json:"token_controller,omitempty"`
}

QueryRolesResponse is the response type for the Query/Roles RPC method.

func (*QueryRolesResponse) Descriptor 

func (*QueryRolesResponse) Descriptor() ([]byte, []int)

func (*QueryRolesResponse) GetAttesterManager 

func (m *QueryRolesResponse) GetAttesterManager() string

func (*QueryRolesResponse) GetOwner 

func (m *QueryRolesResponse) GetOwner() string

func (*QueryRolesResponse) GetPauser 

func (m *QueryRolesResponse) GetPauser() string

func (*QueryRolesResponse) GetTokenController 

func (m *QueryRolesResponse) GetTokenController() string

func (*QueryRolesResponse) Marshal 

func (m *QueryRolesResponse) Marshal() (dAtA []byte, err error)

func (*QueryRolesResponse) MarshalTo 

func (m *QueryRolesResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryRolesResponse) MarshalToSizedBuffer 

func (m *QueryRolesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryRolesResponse) ProtoMessage 

func (*QueryRolesResponse) ProtoMessage()

func (*QueryRolesResponse) Reset 

func (m *QueryRolesResponse) Reset()

func (*QueryRolesResponse) Size 

func (m *QueryRolesResponse) Size() (n int)

func (*QueryRolesResponse) String 

func (m *QueryRolesResponse) String() string

func (*QueryRolesResponse) Unmarshal 

func (m *QueryRolesResponse) Unmarshal(dAtA []byte) error

func (*QueryRolesResponse) XXX_DiscardUnknown 

func (m *QueryRolesResponse) XXX_DiscardUnknown()

func (*QueryRolesResponse) XXX_Marshal 

func (m *QueryRolesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryRolesResponse) XXX_Merge 

func (m *QueryRolesResponse) XXX_Merge(src proto.Message)

func (*QueryRolesResponse) XXX_Size 

func (m *QueryRolesResponse) XXX_Size() int

func (*QueryRolesResponse) XXX_Unmarshal 

func (m *QueryRolesResponse) XXX_Unmarshal(b []byte) error

type QueryServer 

type QueryServer interface {
	Roles(context.Context, *QueryRolesRequest) (*QueryRolesResponse, error)
	// Queries an Attester by index
	Attester(context.Context, *QueryGetAttesterRequest) (*QueryGetAttesterResponse, error)
	// Queries a list of Attesters
	Attesters(context.Context, *QueryAllAttestersRequest) (*QueryAllAttestersResponse, error)
	// Queries a PerMessageBurnLimit by index
	PerMessageBurnLimit(context.Context, *QueryGetPerMessageBurnLimitRequest) (*QueryGetPerMessageBurnLimitResponse, error)
	// Queries a list of PerMessageBurnLimits
	PerMessageBurnLimits(context.Context, *QueryAllPerMessageBurnLimitsRequest) (*QueryAllPerMessageBurnLimitsResponse, error)
	// Queries BurningAndMintingPaused
	BurningAndMintingPaused(context.Context, *QueryGetBurningAndMintingPausedRequest) (*QueryGetBurningAndMintingPausedResponse, error)
	// Queries SendingAndReceivingPaused
	SendingAndReceivingMessagesPaused(context.Context, *QueryGetSendingAndReceivingMessagesPausedRequest) (*QueryGetSendingAndReceivingMessagesPausedResponse, error)
	// Queries the MaxMessageBodySize
	MaxMessageBodySize(context.Context, *QueryGetMaxMessageBodySizeRequest) (*QueryGetMaxMessageBodySizeResponse, error)
	// Queries the NextAvailableNonce
	NextAvailableNonce(context.Context, *QueryGetNextAvailableNonceRequest) (*QueryGetNextAvailableNonceResponse, error)
	// Queries the SignatureThreshold
	SignatureThreshold(context.Context, *QueryGetSignatureThresholdRequest) (*QueryGetSignatureThresholdResponse, error)
	// Queries a TokenPair by index
	TokenPair(context.Context, *QueryGetTokenPairRequest) (*QueryGetTokenPairResponse, error)
	// Queries a list of TokenPair
	TokenPairs(context.Context, *QueryAllTokenPairsRequest) (*QueryAllTokenPairsResponse, error)
	// Queries a UsedNonce by index
	UsedNonce(context.Context, *QueryGetUsedNonceRequest) (*QueryGetUsedNonceResponse, error)
	// Queries a list of UsedNonces
	UsedNonces(context.Context, *QueryAllUsedNoncesRequest) (*QueryAllUsedNoncesResponse, error)
	// Query the RemoteTokenMessenger of a specific domain.
	RemoteTokenMessenger(context.Context, *QueryRemoteTokenMessengerRequest) (*QueryRemoteTokenMessengerResponse, error)
	// Query all RemoteTokenMessenger's.
	RemoteTokenMessengers(context.Context, *QueryRemoteTokenMessengersRequest) (*QueryRemoteTokenMessengersResponse, error)
	BurnMessageVersion(context.Context, *QueryBurnMessageVersionRequest) (*QueryBurnMessageVersionResponse, error)
	LocalMessageVersion(context.Context, *QueryLocalMessageVersionRequest) (*QueryLocalMessageVersionResponse, error)
	LocalDomain(context.Context, *QueryLocalDomainRequest) (*QueryLocalDomainResponse, error)
}

QueryServer is the server API for Query service.

type RemoteTokenMessenger 

type RemoteTokenMessenger struct {
	DomainId uint32 `protobuf:"varint,1,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
	Address  []byte `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

* @param domain_id @param address

func (*RemoteTokenMessenger) Descriptor 

func (*RemoteTokenMessenger) Descriptor() ([]byte, []int)

func (*RemoteTokenMessenger) GetAddress 

func (m *RemoteTokenMessenger) GetAddress() []byte

func (*RemoteTokenMessenger) GetDomainId 

func (m *RemoteTokenMessenger) GetDomainId() uint32

func (*RemoteTokenMessenger) Marshal 

func (m *RemoteTokenMessenger) Marshal() (dAtA []byte, err error)

func (*RemoteTokenMessenger) MarshalTo 

func (m *RemoteTokenMessenger) MarshalTo(dAtA []byte) (int, error)

func (*RemoteTokenMessenger) MarshalToSizedBuffer 

func (m *RemoteTokenMessenger) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*RemoteTokenMessenger) ProtoMessage 

func (*RemoteTokenMessenger) ProtoMessage()

func (*RemoteTokenMessenger) Reset 

func (m *RemoteTokenMessenger) Reset()

func (*RemoteTokenMessenger) Size 

func (m *RemoteTokenMessenger) Size() (n int)

func (*RemoteTokenMessenger) String 

func (m *RemoteTokenMessenger) String() string

func (*RemoteTokenMessenger) Unmarshal 

func (m *RemoteTokenMessenger) Unmarshal(dAtA []byte) error

func (*RemoteTokenMessenger) XXX_DiscardUnknown 

func (m *RemoteTokenMessenger) XXX_DiscardUnknown()

func (*RemoteTokenMessenger) XXX_Marshal 

func (m *RemoteTokenMessenger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RemoteTokenMessenger) XXX_Merge 

func (m *RemoteTokenMessenger) XXX_Merge(src proto.Message)

func (*RemoteTokenMessenger) XXX_Size 

func (m *RemoteTokenMessenger) XXX_Size() int

func (*RemoteTokenMessenger) XXX_Unmarshal 

func (m *RemoteTokenMessenger) XXX_Unmarshal(b []byte) error

type RemoteTokenMessengerAdded 

type RemoteTokenMessengerAdded struct {
	Domain               uint32 `protobuf:"varint,1,opt,name=domain,proto3" json:"domain,omitempty"`
	RemoteTokenMessenger []byte `protobuf:"bytes,2,opt,name=remote_token_messenger,json=remoteTokenMessenger,proto3" json:"remote_token_messenger,omitempty"`
}

* Emitted when a RemoteTokenMessenger is added @param domain remote domain @param remote_token_messenger RemoteTokenMessenger on domain

func (*RemoteTokenMessengerAdded) Descriptor 

func (*RemoteTokenMessengerAdded) Descriptor() ([]byte, []int)

func (*RemoteTokenMessengerAdded) GetDomain 

func (m *RemoteTokenMessengerAdded) GetDomain() uint32

func (*RemoteTokenMessengerAdded) GetRemoteTokenMessenger 

func (m *RemoteTokenMessengerAdded) GetRemoteTokenMessenger() []byte

func (*RemoteTokenMessengerAdded) Marshal 

func (m *RemoteTokenMessengerAdded) Marshal() (dAtA []byte, err error)

func (*RemoteTokenMessengerAdded) MarshalTo 

func (m *RemoteTokenMessengerAdded) MarshalTo(dAtA []byte) (int, error)

func (*RemoteTokenMessengerAdded) MarshalToSizedBuffer 

func (m *RemoteTokenMessengerAdded) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*RemoteTokenMessengerAdded) ProtoMessage 

func (*RemoteTokenMessengerAdded) ProtoMessage()

func (*RemoteTokenMessengerAdded) Reset 

func (m *RemoteTokenMessengerAdded) Reset()

func (*RemoteTokenMessengerAdded) Size 

func (m *RemoteTokenMessengerAdded) Size() (n int)

func (*RemoteTokenMessengerAdded) String 

func (m *RemoteTokenMessengerAdded) String() string

func (*RemoteTokenMessengerAdded) Unmarshal 

func (m *RemoteTokenMessengerAdded) Unmarshal(dAtA []byte) error

func (*RemoteTokenMessengerAdded) XXX_DiscardUnknown 

func (m *RemoteTokenMessengerAdded) XXX_DiscardUnknown()

func (*RemoteTokenMessengerAdded) XXX_Marshal 

func (m *RemoteTokenMessengerAdded) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RemoteTokenMessengerAdded) XXX_Merge 

func (m *RemoteTokenMessengerAdded) XXX_Merge(src proto.Message)

func (*RemoteTokenMessengerAdded) XXX_Size 

func (m *RemoteTokenMessengerAdded) XXX_Size() int

func (*RemoteTokenMessengerAdded) XXX_Unmarshal 

func (m *RemoteTokenMessengerAdded) XXX_Unmarshal(b []byte) error

type RemoteTokenMessengerRemoved 

type RemoteTokenMessengerRemoved struct {
	Domain               uint32 `protobuf:"varint,1,opt,name=domain,proto3" json:"domain,omitempty"`
	RemoteTokenMessenger []byte `protobuf:"bytes,2,opt,name=remote_token_messenger,json=remoteTokenMessenger,proto3" json:"remote_token_messenger,omitempty"`
}

* Emitted when a RemoteTokenMessenger is removed @param domain remote domain @param remote_token_messenger RemoteTokenMessenger on domain

func (*RemoteTokenMessengerRemoved) Descriptor 

func (*RemoteTokenMessengerRemoved) Descriptor() ([]byte, []int)

func (*RemoteTokenMessengerRemoved) GetDomain 

func (m *RemoteTokenMessengerRemoved) GetDomain() uint32

func (*RemoteTokenMessengerRemoved) GetRemoteTokenMessenger 

func (m *RemoteTokenMessengerRemoved) GetRemoteTokenMessenger() []byte

func (*RemoteTokenMessengerRemoved) Marshal 

func (m *RemoteTokenMessengerRemoved) Marshal() (dAtA []byte, err error)

func (*RemoteTokenMessengerRemoved) MarshalTo 

func (m *RemoteTokenMessengerRemoved) MarshalTo(dAtA []byte) (int, error)

func (*RemoteTokenMessengerRemoved) MarshalToSizedBuffer 

func (m *RemoteTokenMessengerRemoved) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*RemoteTokenMessengerRemoved) ProtoMessage 

func (*RemoteTokenMessengerRemoved) ProtoMessage()

func (*RemoteTokenMessengerRemoved) Reset 

func (m *RemoteTokenMessengerRemoved) Reset()

func (*RemoteTokenMessengerRemoved) Size 

func (m *RemoteTokenMessengerRemoved) Size() (n int)

func (*RemoteTokenMessengerRemoved) String 

func (m *RemoteTokenMessengerRemoved) String() string

func (*RemoteTokenMessengerRemoved) Unmarshal 

func (m *RemoteTokenMessengerRemoved) Unmarshal(dAtA []byte) error

func (*RemoteTokenMessengerRemoved) XXX_DiscardUnknown 

func (m *RemoteTokenMessengerRemoved) XXX_DiscardUnknown()

func (*RemoteTokenMessengerRemoved) XXX_Marshal 

func (m *RemoteTokenMessengerRemoved) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RemoteTokenMessengerRemoved) XXX_Merge 

func (m *RemoteTokenMessengerRemoved) XXX_Merge(src proto.Message)

func (*RemoteTokenMessengerRemoved) XXX_Size 

func (m *RemoteTokenMessengerRemoved) XXX_Size() int

func (*RemoteTokenMessengerRemoved) XXX_Unmarshal 

func (m *RemoteTokenMessengerRemoved) XXX_Unmarshal(b []byte) error

type SendingAndReceivingMessagesPaused 

type SendingAndReceivingMessagesPaused struct {
	Paused bool `protobuf:"varint,1,opt,name=paused,proto3" json:"paused,omitempty"`
}

* Message format for SendingAndReceivingMessagesPaused @param paused true if paused, false if not paused

func (*SendingAndReceivingMessagesPaused) Descriptor 

func (*SendingAndReceivingMessagesPaused) Descriptor() ([]byte, []int)

func (*SendingAndReceivingMessagesPaused) GetPaused 

func (m *SendingAndReceivingMessagesPaused) GetPaused() bool

func (*SendingAndReceivingMessagesPaused) Marshal 

func (m *SendingAndReceivingMessagesPaused) Marshal() (dAtA []byte, err error)

func (*SendingAndReceivingMessagesPaused) MarshalTo 

func (m *SendingAndReceivingMessagesPaused) MarshalTo(dAtA []byte) (int, error)

func (*SendingAndReceivingMessagesPaused) MarshalToSizedBuffer 

func (m *SendingAndReceivingMessagesPaused) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*SendingAndReceivingMessagesPaused) ProtoMessage 

func (*SendingAndReceivingMessagesPaused) ProtoMessage()

func (*SendingAndReceivingMessagesPaused) Reset 

func (m *SendingAndReceivingMessagesPaused) Reset()

func (*SendingAndReceivingMessagesPaused) Size 

func (m *SendingAndReceivingMessagesPaused) Size() (n int)

func (*SendingAndReceivingMessagesPaused) String 

func (m *SendingAndReceivingMessagesPaused) String() string

func (*SendingAndReceivingMessagesPaused) Unmarshal 

func (m *SendingAndReceivingMessagesPaused) Unmarshal(dAtA []byte) error

func (*SendingAndReceivingMessagesPaused) XXX_DiscardUnknown 

func (m *SendingAndReceivingMessagesPaused) XXX_DiscardUnknown()

func (*SendingAndReceivingMessagesPaused) XXX_Marshal 

func (m *SendingAndReceivingMessagesPaused) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SendingAndReceivingMessagesPaused) XXX_Merge 

func (m *SendingAndReceivingMessagesPaused) XXX_Merge(src proto.Message)

func (*SendingAndReceivingMessagesPaused) XXX_Size 

func (m *SendingAndReceivingMessagesPaused) XXX_Size() int

func (*SendingAndReceivingMessagesPaused) XXX_Unmarshal 

func (m *SendingAndReceivingMessagesPaused) XXX_Unmarshal(b []byte) error

type SendingAndReceivingPausedEvent 

type SendingAndReceivingPausedEvent struct {
}

* Emitted when sending and receiving messages is paused

func (*SendingAndReceivingPausedEvent) Descriptor 

func (*SendingAndReceivingPausedEvent) Descriptor() ([]byte, []int)

func (*SendingAndReceivingPausedEvent) Marshal 

func (m *SendingAndReceivingPausedEvent) Marshal() (dAtA []byte, err error)

func (*SendingAndReceivingPausedEvent) MarshalTo 

func (m *SendingAndReceivingPausedEvent) MarshalTo(dAtA []byte) (int, error)

func (*SendingAndReceivingPausedEvent) MarshalToSizedBuffer 

func (m *SendingAndReceivingPausedEvent) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*SendingAndReceivingPausedEvent) ProtoMessage 

func (*SendingAndReceivingPausedEvent) ProtoMessage()

func (*SendingAndReceivingPausedEvent) Reset 

func (m *SendingAndReceivingPausedEvent) Reset()

func (*SendingAndReceivingPausedEvent) Size 

func (m *SendingAndReceivingPausedEvent) Size() (n int)

func (*SendingAndReceivingPausedEvent) String 

func (m *SendingAndReceivingPausedEvent) String() string

func (*SendingAndReceivingPausedEvent) Unmarshal 

func (m *SendingAndReceivingPausedEvent) Unmarshal(dAtA []byte) error

func (*SendingAndReceivingPausedEvent) XXX_DiscardUnknown 

func (m *SendingAndReceivingPausedEvent) XXX_DiscardUnknown()

func (*SendingAndReceivingPausedEvent) XXX_Marshal 

func (m *SendingAndReceivingPausedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SendingAndReceivingPausedEvent) XXX_Merge 

func (m *SendingAndReceivingPausedEvent) XXX_Merge(src proto.Message)

func (*SendingAndReceivingPausedEvent) XXX_Size 

func (m *SendingAndReceivingPausedEvent) XXX_Size() int

func (*SendingAndReceivingPausedEvent) XXX_Unmarshal 

func (m *SendingAndReceivingPausedEvent) XXX_Unmarshal(b []byte) error

type SendingAndReceivingUnpausedEvent 

type SendingAndReceivingUnpausedEvent struct {
}

* Emitted when sending and receiving messages is paused

func (*SendingAndReceivingUnpausedEvent) Descriptor 

func (*SendingAndReceivingUnpausedEvent) Descriptor() ([]byte, []int)

func (*SendingAndReceivingUnpausedEvent) Marshal 

func (m *SendingAndReceivingUnpausedEvent) Marshal() (dAtA []byte, err error)

func (*SendingAndReceivingUnpausedEvent) MarshalTo 

func (m *SendingAndReceivingUnpausedEvent) MarshalTo(dAtA []byte) (int, error)

func (*SendingAndReceivingUnpausedEvent) MarshalToSizedBuffer 

func (m *SendingAndReceivingUnpausedEvent) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*SendingAndReceivingUnpausedEvent) ProtoMessage 

func (*SendingAndReceivingUnpausedEvent) ProtoMessage()

func (*SendingAndReceivingUnpausedEvent) Reset 

func (m *SendingAndReceivingUnpausedEvent) Reset()

func (*SendingAndReceivingUnpausedEvent) Size 

func (m *SendingAndReceivingUnpausedEvent) Size() (n int)

func (*SendingAndReceivingUnpausedEvent) String 

func (m *SendingAndReceivingUnpausedEvent) String() string

func (*SendingAndReceivingUnpausedEvent) Unmarshal 

func (m *SendingAndReceivingUnpausedEvent) Unmarshal(dAtA []byte) error

func (*SendingAndReceivingUnpausedEvent) XXX_DiscardUnknown 

func (m *SendingAndReceivingUnpausedEvent) XXX_DiscardUnknown()

func (*SendingAndReceivingUnpausedEvent) XXX_Marshal 

func (m *SendingAndReceivingUnpausedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SendingAndReceivingUnpausedEvent) XXX_Merge 

func (m *SendingAndReceivingUnpausedEvent) XXX_Merge(src proto.Message)

func (*SendingAndReceivingUnpausedEvent) XXX_Size 

func (m *SendingAndReceivingUnpausedEvent) XXX_Size() int

func (*SendingAndReceivingUnpausedEvent) XXX_Unmarshal 

func (m *SendingAndReceivingUnpausedEvent) XXX_Unmarshal(b []byte) error

type SetBurnLimitPerMessage 

type SetBurnLimitPerMessage struct {
	Token               string                `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	BurnLimitPerMessage cosmossdk_io_math.Int `` /* 145-byte string literal not displayed */
}

* Emitted when max burn amount per message is updated @param local_token @param old_amount old max burn amount @param new_amount new max burn amount

func (*SetBurnLimitPerMessage) Descriptor 

func (*SetBurnLimitPerMessage) Descriptor() ([]byte, []int)

func (*SetBurnLimitPerMessage) GetToken 

func (m *SetBurnLimitPerMessage) GetToken() string

func (*SetBurnLimitPerMessage) Marshal 

func (m *SetBurnLimitPerMessage) Marshal() (dAtA []byte, err error)

func (*SetBurnLimitPerMessage) MarshalTo 

func (m *SetBurnLimitPerMessage) MarshalTo(dAtA []byte) (int, error)

func (*SetBurnLimitPerMessage) MarshalToSizedBuffer 

func (m *SetBurnLimitPerMessage) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*SetBurnLimitPerMessage) ProtoMessage 

func (*SetBurnLimitPerMessage) ProtoMessage()

func (*SetBurnLimitPerMessage) Reset 

func (m *SetBurnLimitPerMessage) Reset()

func (*SetBurnLimitPerMessage) Size 

func (m *SetBurnLimitPerMessage) Size() (n int)

func (*SetBurnLimitPerMessage) String 

func (m *SetBurnLimitPerMessage) String() string

func (*SetBurnLimitPerMessage) Unmarshal 

func (m *SetBurnLimitPerMessage) Unmarshal(dAtA []byte) error

func (*SetBurnLimitPerMessage) XXX_DiscardUnknown 

func (m *SetBurnLimitPerMessage) XXX_DiscardUnknown()

func (*SetBurnLimitPerMessage) XXX_Marshal 

func (m *SetBurnLimitPerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetBurnLimitPerMessage) XXX_Merge 

func (m *SetBurnLimitPerMessage) XXX_Merge(src proto.Message)

func (*SetBurnLimitPerMessage) XXX_Size 

func (m *SetBurnLimitPerMessage) XXX_Size() int

func (*SetBurnLimitPerMessage) XXX_Unmarshal 

func (m *SetBurnLimitPerMessage) XXX_Unmarshal(b []byte) error

type SignatureThreshold 

type SignatureThreshold struct {
	Amount uint32 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
}

* SignatureThreshold is the minimum amount of signatures required to attest to a message (the 'm' in a m/n multisig) @param amount the number of signatures required

func (*SignatureThreshold) Descriptor 

func (*SignatureThreshold) Descriptor() ([]byte, []int)

func (*SignatureThreshold) GetAmount 

func (m *SignatureThreshold) GetAmount() uint32

func (*SignatureThreshold) Marshal 

func (m *SignatureThreshold) Marshal() (dAtA []byte, err error)

func (*SignatureThreshold) MarshalTo 

func (m *SignatureThreshold) MarshalTo(dAtA []byte) (int, error)

func (*SignatureThreshold) MarshalToSizedBuffer 

func (m *SignatureThreshold) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*SignatureThreshold) ProtoMessage 

func (*SignatureThreshold) ProtoMessage()

func (*SignatureThreshold) Reset 

func (m *SignatureThreshold) Reset()

func (*SignatureThreshold) Size 

func (m *SignatureThreshold) Size() (n int)

func (*SignatureThreshold) String 

func (m *SignatureThreshold) String() string

func (*SignatureThreshold) Unmarshal 

func (m *SignatureThreshold) Unmarshal(dAtA []byte) error

func (*SignatureThreshold) XXX_DiscardUnknown 

func (m *SignatureThreshold) XXX_DiscardUnknown()

func (*SignatureThreshold) XXX_Marshal 

func (m *SignatureThreshold) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SignatureThreshold) XXX_Merge 

func (m *SignatureThreshold) XXX_Merge(src proto.Message)

func (*SignatureThreshold) XXX_Size 

func (m *SignatureThreshold) XXX_Size() int

func (*SignatureThreshold) XXX_Unmarshal 

func (m *SignatureThreshold) XXX_Unmarshal(b []byte) error

type SignatureThresholdUpdated 

type SignatureThresholdUpdated struct {
	OldSignatureThreshold uint64 `` /* 127-byte string literal not displayed */
	NewSignatureThreshold uint64 `` /* 127-byte string literal not displayed */
}

* Emitted when threshold number of attestations (m in m/n multisig) is updated @param old_signature_threshold old signature threshold @param new_signature_threshold new signature threshold

func (*SignatureThresholdUpdated) Descriptor 

func (*SignatureThresholdUpdated) Descriptor() ([]byte, []int)

func (*SignatureThresholdUpdated) GetNewSignatureThreshold 

func (m *SignatureThresholdUpdated) GetNewSignatureThreshold() uint64

func (*SignatureThresholdUpdated) GetOldSignatureThreshold 

func (m *SignatureThresholdUpdated) GetOldSignatureThreshold() uint64

func (*SignatureThresholdUpdated) Marshal 

func (m *SignatureThresholdUpdated) Marshal() (dAtA []byte, err error)

func (*SignatureThresholdUpdated) MarshalTo 

func (m *SignatureThresholdUpdated) MarshalTo(dAtA []byte) (int, error)

func (*SignatureThresholdUpdated) MarshalToSizedBuffer 

func (m *SignatureThresholdUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*SignatureThresholdUpdated) ProtoMessage 

func (*SignatureThresholdUpdated) ProtoMessage()

func (*SignatureThresholdUpdated) Reset 

func (m *SignatureThresholdUpdated) Reset()

func (*SignatureThresholdUpdated) Size 

func (m *SignatureThresholdUpdated) Size() (n int)

func (*SignatureThresholdUpdated) String 

func (m *SignatureThresholdUpdated) String() string

func (*SignatureThresholdUpdated) Unmarshal 

func (m *SignatureThresholdUpdated) Unmarshal(dAtA []byte) error

func (*SignatureThresholdUpdated) XXX_DiscardUnknown 

func (m *SignatureThresholdUpdated) XXX_DiscardUnknown()

func (*SignatureThresholdUpdated) XXX_Marshal 

func (m *SignatureThresholdUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SignatureThresholdUpdated) XXX_Merge 

func (m *SignatureThresholdUpdated) XXX_Merge(src proto.Message)

func (*SignatureThresholdUpdated) XXX_Size 

func (m *SignatureThresholdUpdated) XXX_Size() int

func (*SignatureThresholdUpdated) XXX_Unmarshal 

func (m *SignatureThresholdUpdated) XXX_Unmarshal(b []byte) error

type TokenControllerUpdated 

type TokenControllerUpdated struct {
	PreviousTokenController string `` /* 132-byte string literal not displayed */
	NewTokenController      string `protobuf:"bytes,2,opt,name=new_token_controller,json=newTokenController,proto3" json:"new_token_controller,omitempty"`
}

* Emitted when token controller address is updated @param previous_token_controller representing the address of the previous token controller @param new_token_controller representing the address of the new token controller

func (*TokenControllerUpdated) Descriptor 

func (*TokenControllerUpdated) Descriptor() ([]byte, []int)

func (*TokenControllerUpdated) GetNewTokenController 

func (m *TokenControllerUpdated) GetNewTokenController() string

func (*TokenControllerUpdated) GetPreviousTokenController 

func (m *TokenControllerUpdated) GetPreviousTokenController() string

func (*TokenControllerUpdated) Marshal 

func (m *TokenControllerUpdated) Marshal() (dAtA []byte, err error)

func (*TokenControllerUpdated) MarshalTo 

func (m *TokenControllerUpdated) MarshalTo(dAtA []byte) (int, error)

func (*TokenControllerUpdated) MarshalToSizedBuffer 

func (m *TokenControllerUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*TokenControllerUpdated) ProtoMessage 

func (*TokenControllerUpdated) ProtoMessage()

func (*TokenControllerUpdated) Reset 

func (m *TokenControllerUpdated) Reset()

func (*TokenControllerUpdated) Size 

func (m *TokenControllerUpdated) Size() (n int)

func (*TokenControllerUpdated) String 

func (m *TokenControllerUpdated) String() string

func (*TokenControllerUpdated) Unmarshal 

func (m *TokenControllerUpdated) Unmarshal(dAtA []byte) error

func (*TokenControllerUpdated) XXX_DiscardUnknown 

func (m *TokenControllerUpdated) XXX_DiscardUnknown()

func (*TokenControllerUpdated) XXX_Marshal 

func (m *TokenControllerUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TokenControllerUpdated) XXX_Merge 

func (m *TokenControllerUpdated) XXX_Merge(src proto.Message)

func (*TokenControllerUpdated) XXX_Size 

func (m *TokenControllerUpdated) XXX_Size() int

func (*TokenControllerUpdated) XXX_Unmarshal 

func (m *TokenControllerUpdated) XXX_Unmarshal(b []byte) error

type TokenPair 

type TokenPair struct {
	RemoteDomain uint32 `protobuf:"varint,1,opt,name=remote_domain,json=remoteDomain,proto3" json:"remote_domain,omitempty"`
	RemoteToken  []byte `protobuf:"bytes,2,opt,name=remote_token,json=remoteToken,proto3" json:"remote_token,omitempty"`
	LocalToken   string `protobuf:"bytes,3,opt,name=local_token,json=localToken,proto3" json:"local_token,omitempty"`
}

* TokenPair is used to look up the Noble token (i.e. "uusdc") from a remote domain token address Multiple remote_domain + remote_token pairs can map to the same local_token

@param remote_domain the remote domain_id corresponding to the token @param remote_token the remote token address @param local_token the corresponding Noble token denom in uunits

func (*TokenPair) Descriptor 

func (*TokenPair) Descriptor() ([]byte, []int)

func (*TokenPair) GetLocalToken 

func (m *TokenPair) GetLocalToken() string

func (*TokenPair) GetRemoteDomain 

func (m *TokenPair) GetRemoteDomain() uint32

func (*TokenPair) GetRemoteToken 

func (m *TokenPair) GetRemoteToken() []byte

func (*TokenPair) Marshal 

func (m *TokenPair) Marshal() (dAtA []byte, err error)

func (*TokenPair) MarshalTo 

func (m *TokenPair) MarshalTo(dAtA []byte) (int, error)

func (*TokenPair) MarshalToSizedBuffer 

func (m *TokenPair) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*TokenPair) ProtoMessage 

func (*TokenPair) ProtoMessage()

func (*TokenPair) Reset 

func (m *TokenPair) Reset()

func (*TokenPair) Size 

func (m *TokenPair) Size() (n int)

func (*TokenPair) String 

func (m *TokenPair) String() string

func (*TokenPair) Unmarshal 

func (m *TokenPair) Unmarshal(dAtA []byte) error

func (*TokenPair) XXX_DiscardUnknown 

func (m *TokenPair) XXX_DiscardUnknown()

func (*TokenPair) XXX_Marshal 

func (m *TokenPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TokenPair) XXX_Merge 

func (m *TokenPair) XXX_Merge(src proto.Message)

func (*TokenPair) XXX_Size 

func (m *TokenPair) XXX_Size() int

func (*TokenPair) XXX_Unmarshal 

func (m *TokenPair) XXX_Unmarshal(b []byte) error

type TokenPairLinked 

type TokenPairLinked struct {
	LocalToken   string `protobuf:"bytes,1,opt,name=local_token,json=localToken,proto3" json:"local_token,omitempty"`
	RemoteDomain uint32 `protobuf:"varint,2,opt,name=remote_domain,json=remoteDomain,proto3" json:"remote_domain,omitempty"`
	RemoteToken  []byte `protobuf:"bytes,3,opt,name=remote_token,json=remoteToken,proto3" json:"remote_token,omitempty"`
}

* Emitted when a token pair is linked @param local_token local token to support @param remote_domain remote domain @param remote_token token on `remoteDomain` corresponding to `localToken`

func (*TokenPairLinked) Descriptor 

func (*TokenPairLinked) Descriptor() ([]byte, []int)

func (*TokenPairLinked) GetLocalToken 

func (m *TokenPairLinked) GetLocalToken() string

func (*TokenPairLinked) GetRemoteDomain 

func (m *TokenPairLinked) GetRemoteDomain() uint32

func (*TokenPairLinked) GetRemoteToken 

func (m *TokenPairLinked) GetRemoteToken() []byte

func (*TokenPairLinked) Marshal 

func (m *TokenPairLinked) Marshal() (dAtA []byte, err error)

func (*TokenPairLinked) MarshalTo 

func (m *TokenPairLinked) MarshalTo(dAtA []byte) (int, error)

func (*TokenPairLinked) MarshalToSizedBuffer 

func (m *TokenPairLinked) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*TokenPairLinked) ProtoMessage 

func (*TokenPairLinked) ProtoMessage()

func (*TokenPairLinked) Reset 

func (m *TokenPairLinked) Reset()

func (*TokenPairLinked) Size 

func (m *TokenPairLinked) Size() (n int)

func (*TokenPairLinked) String 

func (m *TokenPairLinked) String() string

func (*TokenPairLinked) Unmarshal 

func (m *TokenPairLinked) Unmarshal(dAtA []byte) error

func (*TokenPairLinked) XXX_DiscardUnknown 

func (m *TokenPairLinked) XXX_DiscardUnknown()

func (*TokenPairLinked) XXX_Marshal 

func (m *TokenPairLinked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TokenPairLinked) XXX_Merge 

func (m *TokenPairLinked) XXX_Merge(src proto.Message)

func (*TokenPairLinked) XXX_Size 

func (m *TokenPairLinked) XXX_Size() int

func (*TokenPairLinked) XXX_Unmarshal 

func (m *TokenPairLinked) XXX_Unmarshal(b []byte) error

type TokenPairUnlinked 

type TokenPairUnlinked struct {
	LocalToken   string `protobuf:"bytes,1,opt,name=local_token,json=localToken,proto3" json:"local_token,omitempty"`
	RemoteDomain uint32 `protobuf:"varint,2,opt,name=remote_domain,json=remoteDomain,proto3" json:"remote_domain,omitempty"`
	RemoteToken  []byte `protobuf:"bytes,3,opt,name=remote_token,json=remoteToken,proto3" json:"remote_token,omitempty"`
}

* Emitted when a token pair is unlinked @param local_token local token address @param remote_domain remote domain @param remote_token token on `remoteDomain` unlinked from `localToken`

func (*TokenPairUnlinked) Descriptor 

func (*TokenPairUnlinked) Descriptor() ([]byte, []int)

func (*TokenPairUnlinked) GetLocalToken 

func (m *TokenPairUnlinked) GetLocalToken() string

func (*TokenPairUnlinked) GetRemoteDomain 

func (m *TokenPairUnlinked) GetRemoteDomain() uint32

func (*TokenPairUnlinked) GetRemoteToken 

func (m *TokenPairUnlinked) GetRemoteToken() []byte

func (*TokenPairUnlinked) Marshal 

func (m *TokenPairUnlinked) Marshal() (dAtA []byte, err error)

func (*TokenPairUnlinked) MarshalTo 

func (m *TokenPairUnlinked) MarshalTo(dAtA []byte) (int, error)

func (*TokenPairUnlinked) MarshalToSizedBuffer 

func (m *TokenPairUnlinked) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*TokenPairUnlinked) ProtoMessage 

func (*TokenPairUnlinked) ProtoMessage()

func (*TokenPairUnlinked) Reset 

func (m *TokenPairUnlinked) Reset()

func (*TokenPairUnlinked) Size 

func (m *TokenPairUnlinked) Size() (n int)

func (*TokenPairUnlinked) String 

func (m *TokenPairUnlinked) String() string

func (*TokenPairUnlinked) Unmarshal 

func (m *TokenPairUnlinked) Unmarshal(dAtA []byte) error

func (*TokenPairUnlinked) XXX_DiscardUnknown 

func (m *TokenPairUnlinked) XXX_DiscardUnknown()

func (*TokenPairUnlinked) XXX_Marshal 

func (m *TokenPairUnlinked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TokenPairUnlinked) XXX_Merge 

func (m *TokenPairUnlinked) XXX_Merge(src proto.Message)

func (*TokenPairUnlinked) XXX_Size 

func (m *TokenPairUnlinked) XXX_Size() int

func (*TokenPairUnlinked) XXX_Unmarshal 

func (m *TokenPairUnlinked) XXX_Unmarshal(b []byte) error

type UnimplementedMsgServer 

type UnimplementedMsgServer struct {
}

UnimplementedMsgServer can be embedded to have forward compatible implementations.

func (*UnimplementedMsgServer) AcceptOwner 

func (*UnimplementedMsgServer) AcceptOwner(ctx context.Context, req *MsgAcceptOwner) (*MsgAcceptOwnerResponse, error)

func (*UnimplementedMsgServer) AddRemoteTokenMessenger 

func (*UnimplementedMsgServer) AddRemoteTokenMessenger(ctx context.Context, req *MsgAddRemoteTokenMessenger) (*MsgAddRemoteTokenMessengerResponse, error)

func (*UnimplementedMsgServer) DepositForBurn 

func (*UnimplementedMsgServer) DepositForBurn(ctx context.Context, req *MsgDepositForBurn) (*MsgDepositForBurnResponse, error)

func (*UnimplementedMsgServer) DepositForBurnWithCaller 

func (*UnimplementedMsgServer) DepositForBurnWithCaller(ctx context.Context, req *MsgDepositForBurnWithCaller) (*MsgDepositForBurnWithCallerResponse, error)

func (*UnimplementedMsgServer) DisableAttester 

func (*UnimplementedMsgServer) DisableAttester(ctx context.Context, req *MsgDisableAttester) (*MsgDisableAttesterResponse, error)

func (*UnimplementedMsgServer) EnableAttester 

func (*UnimplementedMsgServer) EnableAttester(ctx context.Context, req *MsgEnableAttester) (*MsgEnableAttesterResponse, error)

func (*UnimplementedMsgServer) LinkTokenPair 

func (*UnimplementedMsgServer) LinkTokenPair(ctx context.Context, req *MsgLinkTokenPair) (*MsgLinkTokenPairResponse, error)

func (*UnimplementedMsgServer) PauseBurningAndMinting 

func (*UnimplementedMsgServer) PauseBurningAndMinting(ctx context.Context, req *MsgPauseBurningAndMinting) (*MsgPauseBurningAndMintingResponse, error)

func (*UnimplementedMsgServer) PauseSendingAndReceivingMessages 

func (*UnimplementedMsgServer) PauseSendingAndReceivingMessages(ctx context.Context, req *MsgPauseSendingAndReceivingMessages) (*MsgPauseSendingAndReceivingMessagesResponse, error)

func (*UnimplementedMsgServer) ReceiveMessage 

func (*UnimplementedMsgServer) ReceiveMessage(ctx context.Context, req *MsgReceiveMessage) (*MsgReceiveMessageResponse, error)

func (*UnimplementedMsgServer) RemoveRemoteTokenMessenger 

func (*UnimplementedMsgServer) RemoveRemoteTokenMessenger(ctx context.Context, req *MsgRemoveRemoteTokenMessenger) (*MsgRemoveRemoteTokenMessengerResponse, error)

func (*UnimplementedMsgServer) ReplaceDepositForBurn 

func (*UnimplementedMsgServer) ReplaceDepositForBurn(ctx context.Context, req *MsgReplaceDepositForBurn) (*MsgReplaceDepositForBurnResponse, error)

func (*UnimplementedMsgServer) ReplaceMessage 

func (*UnimplementedMsgServer) ReplaceMessage(ctx context.Context, req *MsgReplaceMessage) (*MsgReplaceMessageResponse, error)

func (*UnimplementedMsgServer) SendMessage 

func (*UnimplementedMsgServer) SendMessage(ctx context.Context, req *MsgSendMessage) (*MsgSendMessageResponse, error)

func (*UnimplementedMsgServer) SendMessageWithCaller 

func (*UnimplementedMsgServer) SendMessageWithCaller(ctx context.Context, req *MsgSendMessageWithCaller) (*MsgSendMessageWithCallerResponse, error)

func (*UnimplementedMsgServer) SetMaxBurnAmountPerMessage 

func (*UnimplementedMsgServer) SetMaxBurnAmountPerMessage(ctx context.Context, req *MsgSetMaxBurnAmountPerMessage) (*MsgSetMaxBurnAmountPerMessageResponse, error)

func (*UnimplementedMsgServer) UnlinkTokenPair 

func (*UnimplementedMsgServer) UnlinkTokenPair(ctx context.Context, req *MsgUnlinkTokenPair) (*MsgUnlinkTokenPairResponse, error)

func (*UnimplementedMsgServer) UnpauseBurningAndMinting 

func (*UnimplementedMsgServer) UnpauseBurningAndMinting(ctx context.Context, req *MsgUnpauseBurningAndMinting) (*MsgUnpauseBurningAndMintingResponse, error)

func (*UnimplementedMsgServer) UnpauseSendingAndReceivingMessages 

func (*UnimplementedMsgServer) UnpauseSendingAndReceivingMessages(ctx context.Context, req *MsgUnpauseSendingAndReceivingMessages) (*MsgUnpauseSendingAndReceivingMessagesResponse, error)

func (*UnimplementedMsgServer) UpdateAttesterManager 

func (*UnimplementedMsgServer) UpdateAttesterManager(ctx context.Context, req *MsgUpdateAttesterManager) (*MsgUpdateAttesterManagerResponse, error)

func (*UnimplementedMsgServer) UpdateMaxMessageBodySize 

func (*UnimplementedMsgServer) UpdateMaxMessageBodySize(ctx context.Context, req *MsgUpdateMaxMessageBodySize) (*MsgUpdateMaxMessageBodySizeResponse, error)

func (*UnimplementedMsgServer) UpdateOwner 

func (*UnimplementedMsgServer) UpdateOwner(ctx context.Context, req *MsgUpdateOwner) (*MsgUpdateOwnerResponse, error)

func (*UnimplementedMsgServer) UpdatePauser 

func (*UnimplementedMsgServer) UpdatePauser(ctx context.Context, req *MsgUpdatePauser) (*MsgUpdatePauserResponse, error)

func (*UnimplementedMsgServer) UpdateSignatureThreshold 

func (*UnimplementedMsgServer) UpdateSignatureThreshold(ctx context.Context, req *MsgUpdateSignatureThreshold) (*MsgUpdateSignatureThresholdResponse, error)

func (*UnimplementedMsgServer) UpdateTokenController 

func (*UnimplementedMsgServer) UpdateTokenController(ctx context.Context, req *MsgUpdateTokenController) (*MsgUpdateTokenControllerResponse, error)

type UnimplementedQueryServer 

type UnimplementedQueryServer struct {
}

UnimplementedQueryServer can be embedded to have forward compatible implementations.

func (*UnimplementedQueryServer) Attester 

func (*UnimplementedQueryServer) Attester(ctx context.Context, req *QueryGetAttesterRequest) (*QueryGetAttesterResponse, error)

func (*UnimplementedQueryServer) Attesters 

func (*UnimplementedQueryServer) Attesters(ctx context.Context, req *QueryAllAttestersRequest) (*QueryAllAttestersResponse, error)

func (*UnimplementedQueryServer) BurnMessageVersion 

func (*UnimplementedQueryServer) BurnMessageVersion(ctx context.Context, req *QueryBurnMessageVersionRequest) (*QueryBurnMessageVersionResponse, error)

func (*UnimplementedQueryServer) BurningAndMintingPaused 

func (*UnimplementedQueryServer) BurningAndMintingPaused(ctx context.Context, req *QueryGetBurningAndMintingPausedRequest) (*QueryGetBurningAndMintingPausedResponse, error)

func (*UnimplementedQueryServer) LocalDomain 

func (*UnimplementedQueryServer) LocalDomain(ctx context.Context, req *QueryLocalDomainRequest) (*QueryLocalDomainResponse, error)

func (*UnimplementedQueryServer) LocalMessageVersion 

func (*UnimplementedQueryServer) LocalMessageVersion(ctx context.Context, req *QueryLocalMessageVersionRequest) (*QueryLocalMessageVersionResponse, error)

func (*UnimplementedQueryServer) MaxMessageBodySize 

func (*UnimplementedQueryServer) MaxMessageBodySize(ctx context.Context, req *QueryGetMaxMessageBodySizeRequest) (*QueryGetMaxMessageBodySizeResponse, error)

func (*UnimplementedQueryServer) NextAvailableNonce 

func (*UnimplementedQueryServer) NextAvailableNonce(ctx context.Context, req *QueryGetNextAvailableNonceRequest) (*QueryGetNextAvailableNonceResponse, error)

func (*UnimplementedQueryServer) PerMessageBurnLimit 

func (*UnimplementedQueryServer) PerMessageBurnLimit(ctx context.Context, req *QueryGetPerMessageBurnLimitRequest) (*QueryGetPerMessageBurnLimitResponse, error)

func (*UnimplementedQueryServer) PerMessageBurnLimits 

func (*UnimplementedQueryServer) PerMessageBurnLimits(ctx context.Context, req *QueryAllPerMessageBurnLimitsRequest) (*QueryAllPerMessageBurnLimitsResponse, error)

func (*UnimplementedQueryServer) RemoteTokenMessenger 

func (*UnimplementedQueryServer) RemoteTokenMessenger(ctx context.Context, req *QueryRemoteTokenMessengerRequest) (*QueryRemoteTokenMessengerResponse, error)

func (*UnimplementedQueryServer) RemoteTokenMessengers 

func (*UnimplementedQueryServer) RemoteTokenMessengers(ctx context.Context, req *QueryRemoteTokenMessengersRequest) (*QueryRemoteTokenMessengersResponse, error)

func (*UnimplementedQueryServer) Roles 

func (*UnimplementedQueryServer) Roles(ctx context.Context, req *QueryRolesRequest) (*QueryRolesResponse, error)

func (*UnimplementedQueryServer) SendingAndReceivingMessagesPaused 

func (*UnimplementedQueryServer) SendingAndReceivingMessagesPaused(ctx context.Context, req *QueryGetSendingAndReceivingMessagesPausedRequest) (*QueryGetSendingAndReceivingMessagesPausedResponse, error)

func (*UnimplementedQueryServer) SignatureThreshold 

func (*UnimplementedQueryServer) SignatureThreshold(ctx context.Context, req *QueryGetSignatureThresholdRequest) (*QueryGetSignatureThresholdResponse, error)

func (*UnimplementedQueryServer) TokenPair 

func (*UnimplementedQueryServer) TokenPair(ctx context.Context, req *QueryGetTokenPairRequest) (*QueryGetTokenPairResponse, error)

func (*UnimplementedQueryServer) TokenPairs 

func (*UnimplementedQueryServer) TokenPairs(ctx context.Context, req *QueryAllTokenPairsRequest) (*QueryAllTokenPairsResponse, error)

func (*UnimplementedQueryServer) UsedNonce 

func (*UnimplementedQueryServer) UsedNonce(ctx context.Context, req *QueryGetUsedNonceRequest) (*QueryGetUsedNonceResponse, error)

func (*UnimplementedQueryServer) UsedNonces 

func (*UnimplementedQueryServer) UsedNonces(ctx context.Context, req *QueryAllUsedNoncesRequest) (*QueryAllUsedNoncesResponse, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.