types

package
v1.0.2 Latest Latest
Warning

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

 Go to latest Published: Sep 18, 2024 License: Apache-2.0 Imports: 36 Imported by: 0

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 TypeMsgRegisterAccount = "register_account"
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 added in v1.0.1 

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

func NewMsgAcceptOwner added in v1.0.1 

func NewMsgAcceptOwner(from string) *MsgAcceptOwner

func (*MsgAcceptOwner) Descriptor added in v1.0.1 

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

func (*MsgAcceptOwner) GetFrom added in v1.0.1 

func (m *MsgAcceptOwner) GetFrom() string

func (*MsgAcceptOwner) GetSignBytes added in v1.0.1 

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

func (*MsgAcceptOwner) GetSigners added in v1.0.1 

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

func (*MsgAcceptOwner) Marshal added in v1.0.1 

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

func (*MsgAcceptOwner) MarshalTo added in v1.0.1 

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

func (*MsgAcceptOwner) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgAcceptOwner) ProtoMessage added in v1.0.1 

func (*MsgAcceptOwner) ProtoMessage()

func (*MsgAcceptOwner) Reset added in v1.0.1 

func (m *MsgAcceptOwner) Reset()

func (*MsgAcceptOwner) Route added in v1.0.1 

func (msg *MsgAcceptOwner) Route() string

func (*MsgAcceptOwner) Size added in v1.0.1 

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

func (*MsgAcceptOwner) String added in v1.0.1 

func (m *MsgAcceptOwner) String() string

func (*MsgAcceptOwner) Type added in v1.0.1 

func (msg *MsgAcceptOwner) Type() string

func (*MsgAcceptOwner) Unmarshal added in v1.0.1 

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

func (*MsgAcceptOwner) ValidateBasic added in v1.0.1 

func (msg *MsgAcceptOwner) ValidateBasic() error

func (*MsgAcceptOwner) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgAcceptOwner) XXX_DiscardUnknown()

func (*MsgAcceptOwner) XXX_Marshal added in v1.0.1 

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

func (*MsgAcceptOwner) XXX_Merge added in v1.0.1 

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

func (*MsgAcceptOwner) XXX_Size added in v1.0.1 

func (m *MsgAcceptOwner) XXX_Size() int

func (*MsgAcceptOwner) XXX_Unmarshal added in v1.0.1 

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

type MsgAcceptOwnerResponse added in v1.0.1 

type MsgAcceptOwnerResponse struct {
}

func (*MsgAcceptOwnerResponse) Descriptor added in v1.0.1 

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

func (*MsgAcceptOwnerResponse) Marshal added in v1.0.1 

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

func (*MsgAcceptOwnerResponse) MarshalTo added in v1.0.1 

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

func (*MsgAcceptOwnerResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgAcceptOwnerResponse) ProtoMessage added in v1.0.1 

func (*MsgAcceptOwnerResponse) ProtoMessage()

func (*MsgAcceptOwnerResponse) Reset added in v1.0.1 

func (m *MsgAcceptOwnerResponse) Reset()

func (*MsgAcceptOwnerResponse) Size added in v1.0.1 

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

func (*MsgAcceptOwnerResponse) String added in v1.0.1 

func (m *MsgAcceptOwnerResponse) String() string

func (*MsgAcceptOwnerResponse) Unmarshal added in v1.0.1 

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

func (*MsgAcceptOwnerResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgAcceptOwnerResponse) XXX_DiscardUnknown()

func (*MsgAcceptOwnerResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgAcceptOwnerResponse) XXX_Merge added in v1.0.1 

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

func (*MsgAcceptOwnerResponse) XXX_Size added in v1.0.1 

func (m *MsgAcceptOwnerResponse) XXX_Size() int

func (*MsgAcceptOwnerResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgAddRemoteTokenMessenger added in v1.0.1 

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 added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) Descriptor added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) GetAddress added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) GetDomainId added in v1.0.1 

func (m *MsgAddRemoteTokenMessenger) GetDomainId() uint32

func (*MsgAddRemoteTokenMessenger) GetFrom added in v1.0.1 

func (m *MsgAddRemoteTokenMessenger) GetFrom() string

func (*MsgAddRemoteTokenMessenger) GetSignBytes added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) GetSigners added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) Marshal added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) MarshalTo added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) ProtoMessage added in v1.0.1 

func (*MsgAddRemoteTokenMessenger) ProtoMessage()

func (*MsgAddRemoteTokenMessenger) Reset added in v1.0.1 

func (m *MsgAddRemoteTokenMessenger) Reset()

func (*MsgAddRemoteTokenMessenger) Route added in v1.0.1 

func (msg *MsgAddRemoteTokenMessenger) Route() string

func (*MsgAddRemoteTokenMessenger) Size added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) String added in v1.0.1 

func (m *MsgAddRemoteTokenMessenger) String() string

func (*MsgAddRemoteTokenMessenger) Type added in v1.0.1 

func (msg *MsgAddRemoteTokenMessenger) Type() string

func (*MsgAddRemoteTokenMessenger) Unmarshal added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) ValidateBasic added in v1.0.1 

func (msg *MsgAddRemoteTokenMessenger) ValidateBasic() error

func (*MsgAddRemoteTokenMessenger) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgAddRemoteTokenMessenger) XXX_DiscardUnknown()

func (*MsgAddRemoteTokenMessenger) XXX_Marshal added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) XXX_Merge added in v1.0.1 

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

func (*MsgAddRemoteTokenMessenger) XXX_Size added in v1.0.1 

func (m *MsgAddRemoteTokenMessenger) XXX_Size() int

func (*MsgAddRemoteTokenMessenger) XXX_Unmarshal added in v1.0.1 

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

type MsgAddRemoteTokenMessengerResponse added in v1.0.1 

type MsgAddRemoteTokenMessengerResponse struct {
}

func (*MsgAddRemoteTokenMessengerResponse) Descriptor added in v1.0.1 

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

func (*MsgAddRemoteTokenMessengerResponse) Marshal added in v1.0.1 

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

func (*MsgAddRemoteTokenMessengerResponse) MarshalTo added in v1.0.1 

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

func (*MsgAddRemoteTokenMessengerResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgAddRemoteTokenMessengerResponse) ProtoMessage added in v1.0.1 

func (*MsgAddRemoteTokenMessengerResponse) ProtoMessage()

func (*MsgAddRemoteTokenMessengerResponse) Reset added in v1.0.1 

func (m *MsgAddRemoteTokenMessengerResponse) Reset()

func (*MsgAddRemoteTokenMessengerResponse) Size added in v1.0.1 

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

func (*MsgAddRemoteTokenMessengerResponse) String added in v1.0.1 

func (m *MsgAddRemoteTokenMessengerResponse) String() string

func (*MsgAddRemoteTokenMessengerResponse) Unmarshal added in v1.0.1 

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

func (*MsgAddRemoteTokenMessengerResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgAddRemoteTokenMessengerResponse) XXX_DiscardUnknown()

func (*MsgAddRemoteTokenMessengerResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgAddRemoteTokenMessengerResponse) XXX_Merge added in v1.0.1 

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

func (*MsgAddRemoteTokenMessengerResponse) XXX_Size added in v1.0.1 

func (m *MsgAddRemoteTokenMessengerResponse) XXX_Size() int

func (*MsgAddRemoteTokenMessengerResponse) XXX_Unmarshal added in v1.0.1 

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)
	RegisterAccount(ctx context.Context, in *MsgRegisterAccount, opts ...grpc.CallOption) (*MsgRegisterAccountResponse, 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 added in v1.0.1 

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 added in v1.0.1 

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

func (*MsgDepositForBurn) Descriptor added in v1.0.1 

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

func (*MsgDepositForBurn) GetBurnToken added in v1.0.1 

func (m *MsgDepositForBurn) GetBurnToken() string

func (*MsgDepositForBurn) GetDestinationDomain added in v1.0.1 

func (m *MsgDepositForBurn) GetDestinationDomain() uint32

func (*MsgDepositForBurn) GetFrom added in v1.0.1 

func (m *MsgDepositForBurn) GetFrom() string

func (*MsgDepositForBurn) GetMintRecipient added in v1.0.1 

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

func (*MsgDepositForBurn) GetSignBytes added in v1.0.1 

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

func (*MsgDepositForBurn) GetSigners added in v1.0.1 

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

func (*MsgDepositForBurn) Marshal added in v1.0.1 

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

func (*MsgDepositForBurn) MarshalTo added in v1.0.1 

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

func (*MsgDepositForBurn) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgDepositForBurn) ProtoMessage added in v1.0.1 

func (*MsgDepositForBurn) ProtoMessage()

func (*MsgDepositForBurn) Reset added in v1.0.1 

func (m *MsgDepositForBurn) Reset()

func (*MsgDepositForBurn) Route added in v1.0.1 

func (msg *MsgDepositForBurn) Route() string

func (*MsgDepositForBurn) Size added in v1.0.1 

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

func (*MsgDepositForBurn) String added in v1.0.1 

func (m *MsgDepositForBurn) String() string

func (*MsgDepositForBurn) Type added in v1.0.1 

func (msg *MsgDepositForBurn) Type() string

func (*MsgDepositForBurn) Unmarshal added in v1.0.1 

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

func (*MsgDepositForBurn) ValidateBasic added in v1.0.1 

func (msg *MsgDepositForBurn) ValidateBasic() error

func (*MsgDepositForBurn) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgDepositForBurn) XXX_DiscardUnknown()

func (*MsgDepositForBurn) XXX_Marshal added in v1.0.1 

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

func (*MsgDepositForBurn) XXX_Merge added in v1.0.1 

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

func (*MsgDepositForBurn) XXX_Size added in v1.0.1 

func (m *MsgDepositForBurn) XXX_Size() int

func (*MsgDepositForBurn) XXX_Unmarshal added in v1.0.1 

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

type MsgDepositForBurnResponse added in v1.0.1 

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

func (*MsgDepositForBurnResponse) Descriptor added in v1.0.1 

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

func (*MsgDepositForBurnResponse) GetNonce added in v1.0.1 

func (m *MsgDepositForBurnResponse) GetNonce() uint64

func (*MsgDepositForBurnResponse) Marshal added in v1.0.1 

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

func (*MsgDepositForBurnResponse) MarshalTo added in v1.0.1 

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

func (*MsgDepositForBurnResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgDepositForBurnResponse) ProtoMessage added in v1.0.1 

func (*MsgDepositForBurnResponse) ProtoMessage()

func (*MsgDepositForBurnResponse) Reset added in v1.0.1 

func (m *MsgDepositForBurnResponse) Reset()

func (*MsgDepositForBurnResponse) Size added in v1.0.1 

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

func (*MsgDepositForBurnResponse) String added in v1.0.1 

func (m *MsgDepositForBurnResponse) String() string

func (*MsgDepositForBurnResponse) Unmarshal added in v1.0.1 

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

func (*MsgDepositForBurnResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgDepositForBurnResponse) XXX_DiscardUnknown()

func (*MsgDepositForBurnResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgDepositForBurnResponse) XXX_Merge added in v1.0.1 

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

func (*MsgDepositForBurnResponse) XXX_Size added in v1.0.1 

func (m *MsgDepositForBurnResponse) XXX_Size() int

func (*MsgDepositForBurnResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgDepositForBurnWithCaller added in v1.0.1 

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 added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) Descriptor added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) GetBurnToken added in v1.0.1 

func (m *MsgDepositForBurnWithCaller) GetBurnToken() string

func (*MsgDepositForBurnWithCaller) GetDestinationCaller added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) GetDestinationDomain added in v1.0.1 

func (m *MsgDepositForBurnWithCaller) GetDestinationDomain() uint32

func (*MsgDepositForBurnWithCaller) GetFrom added in v1.0.1 

func (m *MsgDepositForBurnWithCaller) GetFrom() string

func (*MsgDepositForBurnWithCaller) GetMintRecipient added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) GetSignBytes added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) GetSigners added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) Marshal added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) MarshalTo added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) ProtoMessage added in v1.0.1 

func (*MsgDepositForBurnWithCaller) ProtoMessage()

func (*MsgDepositForBurnWithCaller) Reset added in v1.0.1 

func (m *MsgDepositForBurnWithCaller) Reset()

func (*MsgDepositForBurnWithCaller) Route added in v1.0.1 

func (msg *MsgDepositForBurnWithCaller) Route() string

func (*MsgDepositForBurnWithCaller) Size added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) String added in v1.0.1 

func (m *MsgDepositForBurnWithCaller) String() string

func (*MsgDepositForBurnWithCaller) Type added in v1.0.1 

func (msg *MsgDepositForBurnWithCaller) Type() string

func (*MsgDepositForBurnWithCaller) Unmarshal added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) ValidateBasic added in v1.0.1 

func (msg *MsgDepositForBurnWithCaller) ValidateBasic() error

func (*MsgDepositForBurnWithCaller) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgDepositForBurnWithCaller) XXX_DiscardUnknown()

func (*MsgDepositForBurnWithCaller) XXX_Marshal added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) XXX_Merge added in v1.0.1 

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

func (*MsgDepositForBurnWithCaller) XXX_Size added in v1.0.1 

func (m *MsgDepositForBurnWithCaller) XXX_Size() int

func (*MsgDepositForBurnWithCaller) XXX_Unmarshal added in v1.0.1 

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

type MsgDepositForBurnWithCallerResponse added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) Descriptor added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) GetNonce added in v1.0.1 

func (m *MsgDepositForBurnWithCallerResponse) GetNonce() uint64

func (*MsgDepositForBurnWithCallerResponse) Marshal added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) MarshalTo added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) ProtoMessage added in v1.0.1 

func (*MsgDepositForBurnWithCallerResponse) ProtoMessage()

func (*MsgDepositForBurnWithCallerResponse) Reset added in v1.0.1 

func (m *MsgDepositForBurnWithCallerResponse) Reset()

func (*MsgDepositForBurnWithCallerResponse) Size added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) String added in v1.0.1 

func (m *MsgDepositForBurnWithCallerResponse) String() string

func (*MsgDepositForBurnWithCallerResponse) Unmarshal added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgDepositForBurnWithCallerResponse) XXX_DiscardUnknown()

func (*MsgDepositForBurnWithCallerResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) XXX_Merge added in v1.0.1 

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

func (*MsgDepositForBurnWithCallerResponse) XXX_Size added in v1.0.1 

func (m *MsgDepositForBurnWithCallerResponse) XXX_Size() int

func (*MsgDepositForBurnWithCallerResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgDisableAttester added in v1.0.1 

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 added in v1.0.1 

func NewMsgDisableAttester(from string, attester string) *MsgDisableAttester

func (*MsgDisableAttester) Descriptor added in v1.0.1 

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

func (*MsgDisableAttester) GetAttester added in v1.0.1 

func (m *MsgDisableAttester) GetAttester() string

func (*MsgDisableAttester) GetFrom added in v1.0.1 

func (m *MsgDisableAttester) GetFrom() string

func (*MsgDisableAttester) GetSignBytes added in v1.0.1 

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

func (*MsgDisableAttester) GetSigners added in v1.0.1 

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

func (*MsgDisableAttester) Marshal added in v1.0.1 

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

func (*MsgDisableAttester) MarshalTo added in v1.0.1 

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

func (*MsgDisableAttester) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgDisableAttester) ProtoMessage added in v1.0.1 

func (*MsgDisableAttester) ProtoMessage()

func (*MsgDisableAttester) Reset added in v1.0.1 

func (m *MsgDisableAttester) Reset()

func (*MsgDisableAttester) Route added in v1.0.1 

func (msg *MsgDisableAttester) Route() string

func (*MsgDisableAttester) Size added in v1.0.1 

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

func (*MsgDisableAttester) String added in v1.0.1 

func (m *MsgDisableAttester) String() string

func (*MsgDisableAttester) Type added in v1.0.1 

func (msg *MsgDisableAttester) Type() string

func (*MsgDisableAttester) Unmarshal added in v1.0.1 

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

func (*MsgDisableAttester) ValidateBasic added in v1.0.1 

func (msg *MsgDisableAttester) ValidateBasic() error

func (*MsgDisableAttester) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgDisableAttester) XXX_DiscardUnknown()

func (*MsgDisableAttester) XXX_Marshal added in v1.0.1 

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

func (*MsgDisableAttester) XXX_Merge added in v1.0.1 

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

func (*MsgDisableAttester) XXX_Size added in v1.0.1 

func (m *MsgDisableAttester) XXX_Size() int

func (*MsgDisableAttester) XXX_Unmarshal added in v1.0.1 

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

type MsgDisableAttesterResponse added in v1.0.1 

type MsgDisableAttesterResponse struct {
}

func (*MsgDisableAttesterResponse) Descriptor added in v1.0.1 

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

func (*MsgDisableAttesterResponse) Marshal added in v1.0.1 

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

func (*MsgDisableAttesterResponse) MarshalTo added in v1.0.1 

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

func (*MsgDisableAttesterResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgDisableAttesterResponse) ProtoMessage added in v1.0.1 

func (*MsgDisableAttesterResponse) ProtoMessage()

func (*MsgDisableAttesterResponse) Reset added in v1.0.1 

func (m *MsgDisableAttesterResponse) Reset()

func (*MsgDisableAttesterResponse) Size added in v1.0.1 

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

func (*MsgDisableAttesterResponse) String added in v1.0.1 

func (m *MsgDisableAttesterResponse) String() string

func (*MsgDisableAttesterResponse) Unmarshal added in v1.0.1 

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

func (*MsgDisableAttesterResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgDisableAttesterResponse) XXX_DiscardUnknown()

func (*MsgDisableAttesterResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgDisableAttesterResponse) XXX_Merge added in v1.0.1 

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

func (*MsgDisableAttesterResponse) XXX_Size added in v1.0.1 

func (m *MsgDisableAttesterResponse) XXX_Size() int

func (*MsgDisableAttesterResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgEnableAttester added in v1.0.1 

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 added in v1.0.1 

func NewMsgEnableAttester(from string, attester string) *MsgEnableAttester

func (*MsgEnableAttester) Descriptor added in v1.0.1 

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

func (*MsgEnableAttester) GetAttester added in v1.0.1 

func (m *MsgEnableAttester) GetAttester() string

func (*MsgEnableAttester) GetFrom added in v1.0.1 

func (m *MsgEnableAttester) GetFrom() string

func (*MsgEnableAttester) GetSignBytes added in v1.0.1 

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

func (*MsgEnableAttester) GetSigners added in v1.0.1 

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

func (*MsgEnableAttester) Marshal added in v1.0.1 

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

func (*MsgEnableAttester) MarshalTo added in v1.0.1 

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

func (*MsgEnableAttester) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgEnableAttester) ProtoMessage added in v1.0.1 

func (*MsgEnableAttester) ProtoMessage()

func (*MsgEnableAttester) Reset added in v1.0.1 

func (m *MsgEnableAttester) Reset()

func (*MsgEnableAttester) Route added in v1.0.1 

func (msg *MsgEnableAttester) Route() string

func (*MsgEnableAttester) Size added in v1.0.1 

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

func (*MsgEnableAttester) String added in v1.0.1 

func (m *MsgEnableAttester) String() string

func (*MsgEnableAttester) Type added in v1.0.1 

func (msg *MsgEnableAttester) Type() string

func (*MsgEnableAttester) Unmarshal added in v1.0.1 

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

func (*MsgEnableAttester) ValidateBasic added in v1.0.1 

func (msg *MsgEnableAttester) ValidateBasic() error

func (*MsgEnableAttester) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgEnableAttester) XXX_DiscardUnknown()

func (*MsgEnableAttester) XXX_Marshal added in v1.0.1 

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

func (*MsgEnableAttester) XXX_Merge added in v1.0.1 

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

func (*MsgEnableAttester) XXX_Size added in v1.0.1 

func (m *MsgEnableAttester) XXX_Size() int

func (*MsgEnableAttester) XXX_Unmarshal added in v1.0.1 

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

type MsgEnableAttesterResponse added in v1.0.1 

type MsgEnableAttesterResponse struct {
}

func (*MsgEnableAttesterResponse) Descriptor added in v1.0.1 

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

func (*MsgEnableAttesterResponse) Marshal added in v1.0.1 

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

func (*MsgEnableAttesterResponse) MarshalTo added in v1.0.1 

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

func (*MsgEnableAttesterResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgEnableAttesterResponse) ProtoMessage added in v1.0.1 

func (*MsgEnableAttesterResponse) ProtoMessage()

func (*MsgEnableAttesterResponse) Reset added in v1.0.1 

func (m *MsgEnableAttesterResponse) Reset()

func (*MsgEnableAttesterResponse) Size added in v1.0.1 

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

func (*MsgEnableAttesterResponse) String added in v1.0.1 

func (m *MsgEnableAttesterResponse) String() string

func (*MsgEnableAttesterResponse) Unmarshal added in v1.0.1 

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

func (*MsgEnableAttesterResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgEnableAttesterResponse) XXX_DiscardUnknown()

func (*MsgEnableAttesterResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgEnableAttesterResponse) XXX_Merge added in v1.0.1 

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

func (*MsgEnableAttesterResponse) XXX_Size added in v1.0.1 

func (m *MsgEnableAttesterResponse) XXX_Size() int

func (*MsgEnableAttesterResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgLinkTokenPair added in v1.0.1 

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 added in v1.0.1 

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

func (*MsgLinkTokenPair) Descriptor added in v1.0.1 

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

func (*MsgLinkTokenPair) GetFrom added in v1.0.1 

func (m *MsgLinkTokenPair) GetFrom() string

func (*MsgLinkTokenPair) GetLocalToken added in v1.0.1 

func (m *MsgLinkTokenPair) GetLocalToken() string

func (*MsgLinkTokenPair) GetRemoteDomain added in v1.0.1 

func (m *MsgLinkTokenPair) GetRemoteDomain() uint32

func (*MsgLinkTokenPair) GetRemoteToken added in v1.0.1 

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

func (*MsgLinkTokenPair) GetSignBytes added in v1.0.1 

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

func (*MsgLinkTokenPair) GetSigners added in v1.0.1 

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

func (*MsgLinkTokenPair) Marshal added in v1.0.1 

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

func (*MsgLinkTokenPair) MarshalTo added in v1.0.1 

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

func (*MsgLinkTokenPair) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgLinkTokenPair) ProtoMessage added in v1.0.1 

func (*MsgLinkTokenPair) ProtoMessage()

func (*MsgLinkTokenPair) Reset added in v1.0.1 

func (m *MsgLinkTokenPair) Reset()

func (*MsgLinkTokenPair) Route added in v1.0.1 

func (msg *MsgLinkTokenPair) Route() string

func (*MsgLinkTokenPair) Size added in v1.0.1 

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

func (*MsgLinkTokenPair) String added in v1.0.1 

func (m *MsgLinkTokenPair) String() string

func (*MsgLinkTokenPair) Type added in v1.0.1 

func (msg *MsgLinkTokenPair) Type() string

func (*MsgLinkTokenPair) Unmarshal added in v1.0.1 

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

func (*MsgLinkTokenPair) ValidateBasic added in v1.0.1 

func (msg *MsgLinkTokenPair) ValidateBasic() error

func (*MsgLinkTokenPair) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgLinkTokenPair) XXX_DiscardUnknown()

func (*MsgLinkTokenPair) XXX_Marshal added in v1.0.1 

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

func (*MsgLinkTokenPair) XXX_Merge added in v1.0.1 

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

func (*MsgLinkTokenPair) XXX_Size added in v1.0.1 

func (m *MsgLinkTokenPair) XXX_Size() int

func (*MsgLinkTokenPair) XXX_Unmarshal added in v1.0.1 

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

type MsgLinkTokenPairResponse added in v1.0.1 

type MsgLinkTokenPairResponse struct {
}

func (*MsgLinkTokenPairResponse) Descriptor added in v1.0.1 

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

func (*MsgLinkTokenPairResponse) Marshal added in v1.0.1 

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

func (*MsgLinkTokenPairResponse) MarshalTo added in v1.0.1 

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

func (*MsgLinkTokenPairResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgLinkTokenPairResponse) ProtoMessage added in v1.0.1 

func (*MsgLinkTokenPairResponse) ProtoMessage()

func (*MsgLinkTokenPairResponse) Reset added in v1.0.1 

func (m *MsgLinkTokenPairResponse) Reset()

func (*MsgLinkTokenPairResponse) Size added in v1.0.1 

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

func (*MsgLinkTokenPairResponse) String added in v1.0.1 

func (m *MsgLinkTokenPairResponse) String() string

func (*MsgLinkTokenPairResponse) Unmarshal added in v1.0.1 

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

func (*MsgLinkTokenPairResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgLinkTokenPairResponse) XXX_DiscardUnknown()

func (*MsgLinkTokenPairResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgLinkTokenPairResponse) XXX_Merge added in v1.0.1 

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

func (*MsgLinkTokenPairResponse) XXX_Size added in v1.0.1 

func (m *MsgLinkTokenPairResponse) XXX_Size() int

func (*MsgLinkTokenPairResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgPauseBurningAndMinting added in v1.0.1 

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

func NewMsgPauseBurningAndMinting added in v1.0.1 

func NewMsgPauseBurningAndMinting(from string) *MsgPauseBurningAndMinting

func (*MsgPauseBurningAndMinting) Descriptor added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) GetFrom added in v1.0.1 

func (m *MsgPauseBurningAndMinting) GetFrom() string

func (*MsgPauseBurningAndMinting) GetSignBytes added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) GetSigners added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) Marshal added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) MarshalTo added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) ProtoMessage added in v1.0.1 

func (*MsgPauseBurningAndMinting) ProtoMessage()

func (*MsgPauseBurningAndMinting) Reset added in v1.0.1 

func (m *MsgPauseBurningAndMinting) Reset()

func (*MsgPauseBurningAndMinting) Route added in v1.0.1 

func (msg *MsgPauseBurningAndMinting) Route() string

func (*MsgPauseBurningAndMinting) Size added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) String added in v1.0.1 

func (m *MsgPauseBurningAndMinting) String() string

func (*MsgPauseBurningAndMinting) Type added in v1.0.1 

func (msg *MsgPauseBurningAndMinting) Type() string

func (*MsgPauseBurningAndMinting) Unmarshal added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) ValidateBasic added in v1.0.1 

func (msg *MsgPauseBurningAndMinting) ValidateBasic() error

func (*MsgPauseBurningAndMinting) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgPauseBurningAndMinting) XXX_DiscardUnknown()

func (*MsgPauseBurningAndMinting) XXX_Marshal added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) XXX_Merge added in v1.0.1 

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

func (*MsgPauseBurningAndMinting) XXX_Size added in v1.0.1 

func (m *MsgPauseBurningAndMinting) XXX_Size() int

func (*MsgPauseBurningAndMinting) XXX_Unmarshal added in v1.0.1 

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

type MsgPauseBurningAndMintingResponse added in v1.0.1 

type MsgPauseBurningAndMintingResponse struct {
}

func (*MsgPauseBurningAndMintingResponse) Descriptor added in v1.0.1 

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

func (*MsgPauseBurningAndMintingResponse) Marshal added in v1.0.1 

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

func (*MsgPauseBurningAndMintingResponse) MarshalTo added in v1.0.1 

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

func (*MsgPauseBurningAndMintingResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgPauseBurningAndMintingResponse) ProtoMessage added in v1.0.1 

func (*MsgPauseBurningAndMintingResponse) ProtoMessage()

func (*MsgPauseBurningAndMintingResponse) Reset added in v1.0.1 

func (m *MsgPauseBurningAndMintingResponse) Reset()

func (*MsgPauseBurningAndMintingResponse) Size added in v1.0.1 

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

func (*MsgPauseBurningAndMintingResponse) String added in v1.0.1 

func (m *MsgPauseBurningAndMintingResponse) String() string

func (*MsgPauseBurningAndMintingResponse) Unmarshal added in v1.0.1 

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

func (*MsgPauseBurningAndMintingResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgPauseBurningAndMintingResponse) XXX_DiscardUnknown()

func (*MsgPauseBurningAndMintingResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgPauseBurningAndMintingResponse) XXX_Merge added in v1.0.1 

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

func (*MsgPauseBurningAndMintingResponse) XXX_Size added in v1.0.1 

func (m *MsgPauseBurningAndMintingResponse) XXX_Size() int

func (*MsgPauseBurningAndMintingResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgPauseSendingAndReceivingMessages added in v1.0.1 

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

func NewMsgPauseSendingAndReceivingMessages added in v1.0.1 

func NewMsgPauseSendingAndReceivingMessages(from string) *MsgPauseSendingAndReceivingMessages

func (*MsgPauseSendingAndReceivingMessages) Descriptor added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) GetFrom added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessages) GetFrom() string

func (*MsgPauseSendingAndReceivingMessages) GetSignBytes added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) GetSigners added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) Marshal added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) MarshalTo added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) ProtoMessage added in v1.0.1 

func (*MsgPauseSendingAndReceivingMessages) ProtoMessage()

func (*MsgPauseSendingAndReceivingMessages) Reset added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessages) Reset()

func (*MsgPauseSendingAndReceivingMessages) Route added in v1.0.1 

func (msg *MsgPauseSendingAndReceivingMessages) Route() string

func (*MsgPauseSendingAndReceivingMessages) Size added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) String added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessages) String() string

func (*MsgPauseSendingAndReceivingMessages) Type added in v1.0.1 

func (msg *MsgPauseSendingAndReceivingMessages) Type() string

func (*MsgPauseSendingAndReceivingMessages) Unmarshal added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) ValidateBasic added in v1.0.1 

func (msg *MsgPauseSendingAndReceivingMessages) ValidateBasic() error

func (*MsgPauseSendingAndReceivingMessages) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessages) XXX_DiscardUnknown()

func (*MsgPauseSendingAndReceivingMessages) XXX_Marshal added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) XXX_Merge added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessages) XXX_Size added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessages) XXX_Size() int

func (*MsgPauseSendingAndReceivingMessages) XXX_Unmarshal added in v1.0.1 

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

type MsgPauseSendingAndReceivingMessagesResponse added in v1.0.1 

type MsgPauseSendingAndReceivingMessagesResponse struct {
}

func (*MsgPauseSendingAndReceivingMessagesResponse) Descriptor added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessagesResponse) Marshal added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessagesResponse) MarshalTo added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessagesResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessagesResponse) ProtoMessage added in v1.0.1 

func (*MsgPauseSendingAndReceivingMessagesResponse) ProtoMessage()

func (*MsgPauseSendingAndReceivingMessagesResponse) Reset added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessagesResponse) Reset()

func (*MsgPauseSendingAndReceivingMessagesResponse) Size added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessagesResponse) String added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessagesResponse) String() string

func (*MsgPauseSendingAndReceivingMessagesResponse) Unmarshal added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessagesResponse) XXX_DiscardUnknown()

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_Merge added in v1.0.1 

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

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_Size added in v1.0.1 

func (m *MsgPauseSendingAndReceivingMessagesResponse) XXX_Size() int

func (*MsgPauseSendingAndReceivingMessagesResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgReceiveMessage added in v1.0.1 

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 added in v1.0.1 

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

func (*MsgReceiveMessage) Descriptor added in v1.0.1 

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

func (*MsgReceiveMessage) GetAttestation added in v1.0.1 

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

func (*MsgReceiveMessage) GetFrom added in v1.0.1 

func (m *MsgReceiveMessage) GetFrom() string

func (*MsgReceiveMessage) GetMessage added in v1.0.1 

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

func (*MsgReceiveMessage) GetSignBytes added in v1.0.1 

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

func (*MsgReceiveMessage) GetSigners added in v1.0.1 

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

func (*MsgReceiveMessage) Marshal added in v1.0.1 

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

func (*MsgReceiveMessage) MarshalTo added in v1.0.1 

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

func (*MsgReceiveMessage) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgReceiveMessage) ProtoMessage added in v1.0.1 

func (*MsgReceiveMessage) ProtoMessage()

func (*MsgReceiveMessage) Reset added in v1.0.1 

func (m *MsgReceiveMessage) Reset()

func (*MsgReceiveMessage) Route added in v1.0.1 

func (msg *MsgReceiveMessage) Route() string

func (*MsgReceiveMessage) Size added in v1.0.1 

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

func (*MsgReceiveMessage) String added in v1.0.1 

func (m *MsgReceiveMessage) String() string

func (*MsgReceiveMessage) Type added in v1.0.1 

func (msg *MsgReceiveMessage) Type() string

func (*MsgReceiveMessage) Unmarshal added in v1.0.1 

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

func (*MsgReceiveMessage) ValidateBasic added in v1.0.1 

func (msg *MsgReceiveMessage) ValidateBasic() error

func (*MsgReceiveMessage) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgReceiveMessage) XXX_DiscardUnknown()

func (*MsgReceiveMessage) XXX_Marshal added in v1.0.1 

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

func (*MsgReceiveMessage) XXX_Merge added in v1.0.1 

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

func (*MsgReceiveMessage) XXX_Size added in v1.0.1 

func (m *MsgReceiveMessage) XXX_Size() int

func (*MsgReceiveMessage) XXX_Unmarshal added in v1.0.1 

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

type MsgReceiveMessageResponse added in v1.0.1 

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

func (*MsgReceiveMessageResponse) Descriptor added in v1.0.1 

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

func (*MsgReceiveMessageResponse) GetSuccess added in v1.0.1 

func (m *MsgReceiveMessageResponse) GetSuccess() bool

func (*MsgReceiveMessageResponse) Marshal added in v1.0.1 

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

func (*MsgReceiveMessageResponse) MarshalTo added in v1.0.1 

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

func (*MsgReceiveMessageResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgReceiveMessageResponse) ProtoMessage added in v1.0.1 

func (*MsgReceiveMessageResponse) ProtoMessage()

func (*MsgReceiveMessageResponse) Reset added in v1.0.1 

func (m *MsgReceiveMessageResponse) Reset()

func (*MsgReceiveMessageResponse) Size added in v1.0.1 

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

func (*MsgReceiveMessageResponse) String added in v1.0.1 

func (m *MsgReceiveMessageResponse) String() string

func (*MsgReceiveMessageResponse) Unmarshal added in v1.0.1 

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

func (*MsgReceiveMessageResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgReceiveMessageResponse) XXX_DiscardUnknown()

func (*MsgReceiveMessageResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgReceiveMessageResponse) XXX_Merge added in v1.0.1 

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

func (*MsgReceiveMessageResponse) XXX_Size added in v1.0.1 

func (m *MsgReceiveMessageResponse) XXX_Size() int

func (*MsgReceiveMessageResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgRegisterAccount added in v1.0.1 

type MsgRegisterAccount struct {
	Signer    string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
	Recipient string `protobuf:"bytes,2,opt,name=recipient,proto3" json:"recipient,omitempty"`
	Channel   string `protobuf:"bytes,3,opt,name=channel,proto3" json:"channel,omitempty"`
}

func NewMsgRegisterAccount added in v1.0.1 

func NewMsgRegisterAccount(signer string, recipient string, channel string) *MsgRegisterAccount

func (*MsgRegisterAccount) Descriptor added in v1.0.1 

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

func (*MsgRegisterAccount) GetChannel added in v1.0.1 

func (m *MsgRegisterAccount) GetChannel() string

func (*MsgRegisterAccount) GetRecipient added in v1.0.1 

func (m *MsgRegisterAccount) GetRecipient() string

func (*MsgRegisterAccount) GetSignBytes added in v1.0.1 

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

func (*MsgRegisterAccount) GetSigner added in v1.0.1 

func (m *MsgRegisterAccount) GetSigner() string

func (*MsgRegisterAccount) GetSigners added in v1.0.1 

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

func (*MsgRegisterAccount) Marshal added in v1.0.1 

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

func (*MsgRegisterAccount) MarshalTo added in v1.0.1 

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

func (*MsgRegisterAccount) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgRegisterAccount) ProtoMessage added in v1.0.1 

func (*MsgRegisterAccount) ProtoMessage()

func (*MsgRegisterAccount) Reset added in v1.0.1 

func (m *MsgRegisterAccount) Reset()

func (*MsgRegisterAccount) Route added in v1.0.1 

func (msg *MsgRegisterAccount) Route() string

func (*MsgRegisterAccount) Size added in v1.0.1 

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

func (*MsgRegisterAccount) String added in v1.0.1 

func (m *MsgRegisterAccount) String() string

func (*MsgRegisterAccount) Type added in v1.0.1 

func (msg *MsgRegisterAccount) Type() string

func (*MsgRegisterAccount) Unmarshal added in v1.0.1 

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

func (*MsgRegisterAccount) ValidateBasic added in v1.0.1 

func (msg *MsgRegisterAccount) ValidateBasic() error

func (*MsgRegisterAccount) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgRegisterAccount) XXX_DiscardUnknown()

func (*MsgRegisterAccount) XXX_Marshal added in v1.0.1 

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

func (*MsgRegisterAccount) XXX_Merge added in v1.0.1 

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

func (*MsgRegisterAccount) XXX_Size added in v1.0.1 

func (m *MsgRegisterAccount) XXX_Size() int

func (*MsgRegisterAccount) XXX_Unmarshal added in v1.0.1 

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

type MsgRegisterAccountResponse added in v1.0.1 

type MsgRegisterAccountResponse struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

func (*MsgRegisterAccountResponse) Descriptor added in v1.0.1 

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

func (*MsgRegisterAccountResponse) GetAddress added in v1.0.1 

func (m *MsgRegisterAccountResponse) GetAddress() string

func (*MsgRegisterAccountResponse) Marshal added in v1.0.1 

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

func (*MsgRegisterAccountResponse) MarshalTo added in v1.0.1 

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

func (*MsgRegisterAccountResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgRegisterAccountResponse) ProtoMessage added in v1.0.1 

func (*MsgRegisterAccountResponse) ProtoMessage()

func (*MsgRegisterAccountResponse) Reset added in v1.0.1 

func (m *MsgRegisterAccountResponse) Reset()

func (*MsgRegisterAccountResponse) Size added in v1.0.1 

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

func (*MsgRegisterAccountResponse) String added in v1.0.1 

func (m *MsgRegisterAccountResponse) String() string

func (*MsgRegisterAccountResponse) Unmarshal added in v1.0.1 

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

func (*MsgRegisterAccountResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgRegisterAccountResponse) XXX_DiscardUnknown()

func (*MsgRegisterAccountResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgRegisterAccountResponse) XXX_Merge added in v1.0.1 

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

func (*MsgRegisterAccountResponse) XXX_Size added in v1.0.1 

func (m *MsgRegisterAccountResponse) XXX_Size() int

func (*MsgRegisterAccountResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgRemoveRemoteTokenMessenger added in v1.0.1 

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 added in v1.0.1 

func NewMsgRemoveRemoteTokenMessenger(from string, domainId uint32) *MsgRemoveRemoteTokenMessenger

func (*MsgRemoveRemoteTokenMessenger) Descriptor added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) GetDomainId added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessenger) GetDomainId() uint32

func (*MsgRemoveRemoteTokenMessenger) GetFrom added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessenger) GetFrom() string

func (*MsgRemoveRemoteTokenMessenger) GetSignBytes added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) GetSigners added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) Marshal added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) MarshalTo added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) ProtoMessage added in v1.0.1 

func (*MsgRemoveRemoteTokenMessenger) ProtoMessage()

func (*MsgRemoveRemoteTokenMessenger) Reset added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessenger) Reset()

func (*MsgRemoveRemoteTokenMessenger) Route added in v1.0.1 

func (msg *MsgRemoveRemoteTokenMessenger) Route() string

func (*MsgRemoveRemoteTokenMessenger) Size added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) String added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessenger) String() string

func (*MsgRemoveRemoteTokenMessenger) Type added in v1.0.1 

func (msg *MsgRemoveRemoteTokenMessenger) Type() string

func (*MsgRemoveRemoteTokenMessenger) Unmarshal added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) ValidateBasic added in v1.0.1 

func (msg *MsgRemoveRemoteTokenMessenger) ValidateBasic() error

func (*MsgRemoveRemoteTokenMessenger) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessenger) XXX_DiscardUnknown()

func (*MsgRemoveRemoteTokenMessenger) XXX_Marshal added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) XXX_Merge added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessenger) XXX_Size added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessenger) XXX_Size() int

func (*MsgRemoveRemoteTokenMessenger) XXX_Unmarshal added in v1.0.1 

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

type MsgRemoveRemoteTokenMessengerResponse added in v1.0.1 

type MsgRemoveRemoteTokenMessengerResponse struct {
}

func (*MsgRemoveRemoteTokenMessengerResponse) Descriptor added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessengerResponse) Marshal added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessengerResponse) MarshalTo added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessengerResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessengerResponse) ProtoMessage added in v1.0.1 

func (*MsgRemoveRemoteTokenMessengerResponse) ProtoMessage()

func (*MsgRemoveRemoteTokenMessengerResponse) Reset added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessengerResponse) Reset()

func (*MsgRemoveRemoteTokenMessengerResponse) Size added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessengerResponse) String added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessengerResponse) String() string

func (*MsgRemoveRemoteTokenMessengerResponse) Unmarshal added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessengerResponse) XXX_DiscardUnknown()

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_Merge added in v1.0.1 

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

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_Size added in v1.0.1 

func (m *MsgRemoveRemoteTokenMessengerResponse) XXX_Size() int

func (*MsgRemoveRemoteTokenMessengerResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgReplaceDepositForBurn added in v1.0.1 

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 added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) Descriptor added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) GetFrom added in v1.0.1 

func (m *MsgReplaceDepositForBurn) GetFrom() string

func (*MsgReplaceDepositForBurn) GetNewDestinationCaller added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) GetNewMintRecipient added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) GetOriginalAttestation added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) GetOriginalMessage added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) GetSignBytes added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) GetSigners added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) Marshal added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) MarshalTo added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) ProtoMessage added in v1.0.1 

func (*MsgReplaceDepositForBurn) ProtoMessage()

func (*MsgReplaceDepositForBurn) Reset added in v1.0.1 

func (m *MsgReplaceDepositForBurn) Reset()

func (*MsgReplaceDepositForBurn) Route added in v1.0.1 

func (msg *MsgReplaceDepositForBurn) Route() string

func (*MsgReplaceDepositForBurn) Size added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) String added in v1.0.1 

func (m *MsgReplaceDepositForBurn) String() string

func (*MsgReplaceDepositForBurn) Type added in v1.0.1 

func (msg *MsgReplaceDepositForBurn) Type() string

func (*MsgReplaceDepositForBurn) Unmarshal added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) ValidateBasic added in v1.0.1 

func (msg *MsgReplaceDepositForBurn) ValidateBasic() error

func (*MsgReplaceDepositForBurn) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgReplaceDepositForBurn) XXX_DiscardUnknown()

func (*MsgReplaceDepositForBurn) XXX_Marshal added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) XXX_Merge added in v1.0.1 

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

func (*MsgReplaceDepositForBurn) XXX_Size added in v1.0.1 

func (m *MsgReplaceDepositForBurn) XXX_Size() int

func (*MsgReplaceDepositForBurn) XXX_Unmarshal added in v1.0.1 

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

type MsgReplaceDepositForBurnResponse added in v1.0.1 

type MsgReplaceDepositForBurnResponse struct {
}

func (*MsgReplaceDepositForBurnResponse) Descriptor added in v1.0.1 

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

func (*MsgReplaceDepositForBurnResponse) Marshal added in v1.0.1 

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

func (*MsgReplaceDepositForBurnResponse) MarshalTo added in v1.0.1 

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

func (*MsgReplaceDepositForBurnResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgReplaceDepositForBurnResponse) ProtoMessage added in v1.0.1 

func (*MsgReplaceDepositForBurnResponse) ProtoMessage()

func (*MsgReplaceDepositForBurnResponse) Reset added in v1.0.1 

func (m *MsgReplaceDepositForBurnResponse) Reset()

func (*MsgReplaceDepositForBurnResponse) Size added in v1.0.1 

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

func (*MsgReplaceDepositForBurnResponse) String added in v1.0.1 

func (m *MsgReplaceDepositForBurnResponse) String() string

func (*MsgReplaceDepositForBurnResponse) Unmarshal added in v1.0.1 

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

func (*MsgReplaceDepositForBurnResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgReplaceDepositForBurnResponse) XXX_DiscardUnknown()

func (*MsgReplaceDepositForBurnResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgReplaceDepositForBurnResponse) XXX_Merge added in v1.0.1 

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

func (*MsgReplaceDepositForBurnResponse) XXX_Size added in v1.0.1 

func (m *MsgReplaceDepositForBurnResponse) XXX_Size() int

func (*MsgReplaceDepositForBurnResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgReplaceMessage added in v1.0.1 

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 added in v1.0.1 

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

func (*MsgReplaceMessage) Descriptor added in v1.0.1 

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

func (*MsgReplaceMessage) GetFrom added in v1.0.1 

func (m *MsgReplaceMessage) GetFrom() string

func (*MsgReplaceMessage) GetNewDestinationCaller added in v1.0.1 

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

func (*MsgReplaceMessage) GetNewMessageBody added in v1.0.1 

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

func (*MsgReplaceMessage) GetOriginalAttestation added in v1.0.1 

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

func (*MsgReplaceMessage) GetOriginalMessage added in v1.0.1 

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

func (*MsgReplaceMessage) GetSignBytes added in v1.0.1 

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

func (*MsgReplaceMessage) GetSigners added in v1.0.1 

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

func (*MsgReplaceMessage) Marshal added in v1.0.1 

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

func (*MsgReplaceMessage) MarshalTo added in v1.0.1 

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

func (*MsgReplaceMessage) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgReplaceMessage) ProtoMessage added in v1.0.1 

func (*MsgReplaceMessage) ProtoMessage()

func (*MsgReplaceMessage) Reset added in v1.0.1 

func (m *MsgReplaceMessage) Reset()

func (*MsgReplaceMessage) Route added in v1.0.1 

func (msg *MsgReplaceMessage) Route() string

func (*MsgReplaceMessage) Size added in v1.0.1 

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

func (*MsgReplaceMessage) String added in v1.0.1 

func (m *MsgReplaceMessage) String() string

func (*MsgReplaceMessage) Type added in v1.0.1 

func (msg *MsgReplaceMessage) Type() string

func (*MsgReplaceMessage) Unmarshal added in v1.0.1 

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

func (*MsgReplaceMessage) ValidateBasic added in v1.0.1 

func (msg *MsgReplaceMessage) ValidateBasic() error

func (*MsgReplaceMessage) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgReplaceMessage) XXX_DiscardUnknown()

func (*MsgReplaceMessage) XXX_Marshal added in v1.0.1 

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

func (*MsgReplaceMessage) XXX_Merge added in v1.0.1 

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

func (*MsgReplaceMessage) XXX_Size added in v1.0.1 

func (m *MsgReplaceMessage) XXX_Size() int

func (*MsgReplaceMessage) XXX_Unmarshal added in v1.0.1 

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

type MsgReplaceMessageResponse added in v1.0.1 

type MsgReplaceMessageResponse struct {
}

func (*MsgReplaceMessageResponse) Descriptor added in v1.0.1 

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

func (*MsgReplaceMessageResponse) Marshal added in v1.0.1 

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

func (*MsgReplaceMessageResponse) MarshalTo added in v1.0.1 

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

func (*MsgReplaceMessageResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgReplaceMessageResponse) ProtoMessage added in v1.0.1 

func (*MsgReplaceMessageResponse) ProtoMessage()

func (*MsgReplaceMessageResponse) Reset added in v1.0.1 

func (m *MsgReplaceMessageResponse) Reset()

func (*MsgReplaceMessageResponse) Size added in v1.0.1 

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

func (*MsgReplaceMessageResponse) String added in v1.0.1 

func (m *MsgReplaceMessageResponse) String() string

func (*MsgReplaceMessageResponse) Unmarshal added in v1.0.1 

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

func (*MsgReplaceMessageResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgReplaceMessageResponse) XXX_DiscardUnknown()

func (*MsgReplaceMessageResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgReplaceMessageResponse) XXX_Merge added in v1.0.1 

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

func (*MsgReplaceMessageResponse) XXX_Size added in v1.0.1 

func (m *MsgReplaceMessageResponse) XXX_Size() int

func (*MsgReplaceMessageResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgSendMessage added in v1.0.1 

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 added in v1.0.1 

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

func (*MsgSendMessage) Descriptor added in v1.0.1 

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

func (*MsgSendMessage) GetDestinationDomain added in v1.0.1 

func (m *MsgSendMessage) GetDestinationDomain() uint32

func (*MsgSendMessage) GetFrom added in v1.0.1 

func (m *MsgSendMessage) GetFrom() string

func (*MsgSendMessage) GetMessageBody added in v1.0.1 

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

func (*MsgSendMessage) GetRecipient added in v1.0.1 

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

func (*MsgSendMessage) GetSignBytes added in v1.0.1 

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

func (*MsgSendMessage) GetSigners added in v1.0.1 

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

func (*MsgSendMessage) Marshal added in v1.0.1 

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

func (*MsgSendMessage) MarshalTo added in v1.0.1 

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

func (*MsgSendMessage) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgSendMessage) ProtoMessage added in v1.0.1 

func (*MsgSendMessage) ProtoMessage()

func (*MsgSendMessage) Reset added in v1.0.1 

func (m *MsgSendMessage) Reset()

func (*MsgSendMessage) Route added in v1.0.1 

func (msg *MsgSendMessage) Route() string

func (*MsgSendMessage) Size added in v1.0.1 

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

func (*MsgSendMessage) String added in v1.0.1 

func (m *MsgSendMessage) String() string

func (*MsgSendMessage) Type added in v1.0.1 

func (msg *MsgSendMessage) Type() string

func (*MsgSendMessage) Unmarshal added in v1.0.1 

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

func (*MsgSendMessage) ValidateBasic added in v1.0.1 

func (msg *MsgSendMessage) ValidateBasic() error

func (*MsgSendMessage) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgSendMessage) XXX_DiscardUnknown()

func (*MsgSendMessage) XXX_Marshal added in v1.0.1 

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

func (*MsgSendMessage) XXX_Merge added in v1.0.1 

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

func (*MsgSendMessage) XXX_Size added in v1.0.1 

func (m *MsgSendMessage) XXX_Size() int

func (*MsgSendMessage) XXX_Unmarshal added in v1.0.1 

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

type MsgSendMessageResponse added in v1.0.1 

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

func (*MsgSendMessageResponse) Descriptor added in v1.0.1 

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

func (*MsgSendMessageResponse) GetNonce added in v1.0.1 

func (m *MsgSendMessageResponse) GetNonce() uint64

func (*MsgSendMessageResponse) Marshal added in v1.0.1 

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

func (*MsgSendMessageResponse) MarshalTo added in v1.0.1 

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

func (*MsgSendMessageResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgSendMessageResponse) ProtoMessage added in v1.0.1 

func (*MsgSendMessageResponse) ProtoMessage()

func (*MsgSendMessageResponse) Reset added in v1.0.1 

func (m *MsgSendMessageResponse) Reset()

func (*MsgSendMessageResponse) Size added in v1.0.1 

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

func (*MsgSendMessageResponse) String added in v1.0.1 

func (m *MsgSendMessageResponse) String() string

func (*MsgSendMessageResponse) Unmarshal added in v1.0.1 

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

func (*MsgSendMessageResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgSendMessageResponse) XXX_DiscardUnknown()

func (*MsgSendMessageResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgSendMessageResponse) XXX_Merge added in v1.0.1 

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

func (*MsgSendMessageResponse) XXX_Size added in v1.0.1 

func (m *MsgSendMessageResponse) XXX_Size() int

func (*MsgSendMessageResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgSendMessageWithCaller added in v1.0.1 

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 added in v1.0.1 

func NewMsgSendMessageWithCaller(from string, destinationDomain uint32, recipient []byte, messageBody []byte, destinationCaller []byte) *MsgSendMessageWithCaller

func (*MsgSendMessageWithCaller) Descriptor added in v1.0.1 

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

func (*MsgSendMessageWithCaller) GetDestinationCaller added in v1.0.1 

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

func (*MsgSendMessageWithCaller) GetDestinationDomain added in v1.0.1 

func (m *MsgSendMessageWithCaller) GetDestinationDomain() uint32

func (*MsgSendMessageWithCaller) GetFrom added in v1.0.1 

func (m *MsgSendMessageWithCaller) GetFrom() string

func (*MsgSendMessageWithCaller) GetMessageBody added in v1.0.1 

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

func (*MsgSendMessageWithCaller) GetRecipient added in v1.0.1 

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

func (*MsgSendMessageWithCaller) GetSignBytes added in v1.0.1 

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

func (*MsgSendMessageWithCaller) GetSigners added in v1.0.1 

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

func (*MsgSendMessageWithCaller) Marshal added in v1.0.1 

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

func (*MsgSendMessageWithCaller) MarshalTo added in v1.0.1 

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

func (*MsgSendMessageWithCaller) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgSendMessageWithCaller) ProtoMessage added in v1.0.1 

func (*MsgSendMessageWithCaller) ProtoMessage()

func (*MsgSendMessageWithCaller) Reset added in v1.0.1 

func (m *MsgSendMessageWithCaller) Reset()

func (*MsgSendMessageWithCaller) Route added in v1.0.1 

func (msg *MsgSendMessageWithCaller) Route() string

func (*MsgSendMessageWithCaller) Size added in v1.0.1 

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

func (*MsgSendMessageWithCaller) String added in v1.0.1 

func (m *MsgSendMessageWithCaller) String() string

func (*MsgSendMessageWithCaller) Type added in v1.0.1 

func (msg *MsgSendMessageWithCaller) Type() string

func (*MsgSendMessageWithCaller) Unmarshal added in v1.0.1 

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

func (*MsgSendMessageWithCaller) ValidateBasic added in v1.0.1 

func (msg *MsgSendMessageWithCaller) ValidateBasic() error

func (*MsgSendMessageWithCaller) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgSendMessageWithCaller) XXX_DiscardUnknown()

func (*MsgSendMessageWithCaller) XXX_Marshal added in v1.0.1 

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

func (*MsgSendMessageWithCaller) XXX_Merge added in v1.0.1 

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

func (*MsgSendMessageWithCaller) XXX_Size added in v1.0.1 

func (m *MsgSendMessageWithCaller) XXX_Size() int

func (*MsgSendMessageWithCaller) XXX_Unmarshal added in v1.0.1 

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

type MsgSendMessageWithCallerResponse added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) Descriptor added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) GetNonce added in v1.0.1 

func (m *MsgSendMessageWithCallerResponse) GetNonce() uint64

func (*MsgSendMessageWithCallerResponse) Marshal added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) MarshalTo added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) ProtoMessage added in v1.0.1 

func (*MsgSendMessageWithCallerResponse) ProtoMessage()

func (*MsgSendMessageWithCallerResponse) Reset added in v1.0.1 

func (m *MsgSendMessageWithCallerResponse) Reset()

func (*MsgSendMessageWithCallerResponse) Size added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) String added in v1.0.1 

func (m *MsgSendMessageWithCallerResponse) String() string

func (*MsgSendMessageWithCallerResponse) Unmarshal added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgSendMessageWithCallerResponse) XXX_DiscardUnknown()

func (*MsgSendMessageWithCallerResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) XXX_Merge added in v1.0.1 

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

func (*MsgSendMessageWithCallerResponse) XXX_Size added in v1.0.1 

func (m *MsgSendMessageWithCallerResponse) XXX_Size() int

func (*MsgSendMessageWithCallerResponse) XXX_Unmarshal added in v1.0.1 

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)
	RegisterAccount(context.Context, *MsgRegisterAccount) (*MsgRegisterAccountResponse, error)
}

MsgServer is the server API for Msg service.

type MsgSetMaxBurnAmountPerMessage added in v1.0.1 

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 added in v1.0.1 

func NewMsgSetMaxBurnAmountPerMessage(from string, localToken string, amount math.Int) *MsgSetMaxBurnAmountPerMessage

func (*MsgSetMaxBurnAmountPerMessage) Descriptor added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) GetFrom added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessage) GetFrom() string

func (*MsgSetMaxBurnAmountPerMessage) GetLocalToken added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessage) GetLocalToken() string

func (*MsgSetMaxBurnAmountPerMessage) GetSignBytes added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) GetSigners added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) Marshal added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) MarshalTo added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) ProtoMessage added in v1.0.1 

func (*MsgSetMaxBurnAmountPerMessage) ProtoMessage()

func (*MsgSetMaxBurnAmountPerMessage) Reset added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessage) Reset()

func (*MsgSetMaxBurnAmountPerMessage) Route added in v1.0.1 

func (msg *MsgSetMaxBurnAmountPerMessage) Route() string

func (*MsgSetMaxBurnAmountPerMessage) Size added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) String added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessage) String() string

func (*MsgSetMaxBurnAmountPerMessage) Type added in v1.0.1 

func (msg *MsgSetMaxBurnAmountPerMessage) Type() string

func (*MsgSetMaxBurnAmountPerMessage) Unmarshal added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) ValidateBasic added in v1.0.1 

func (msg *MsgSetMaxBurnAmountPerMessage) ValidateBasic() error

func (*MsgSetMaxBurnAmountPerMessage) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessage) XXX_DiscardUnknown()

func (*MsgSetMaxBurnAmountPerMessage) XXX_Marshal added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) XXX_Merge added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessage) XXX_Size added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessage) XXX_Size() int

func (*MsgSetMaxBurnAmountPerMessage) XXX_Unmarshal added in v1.0.1 

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

type MsgSetMaxBurnAmountPerMessageResponse added in v1.0.1 

type MsgSetMaxBurnAmountPerMessageResponse struct {
}

func (*MsgSetMaxBurnAmountPerMessageResponse) Descriptor added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessageResponse) Marshal added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessageResponse) MarshalTo added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessageResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessageResponse) ProtoMessage added in v1.0.1 

func (*MsgSetMaxBurnAmountPerMessageResponse) ProtoMessage()

func (*MsgSetMaxBurnAmountPerMessageResponse) Reset added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessageResponse) Reset()

func (*MsgSetMaxBurnAmountPerMessageResponse) Size added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessageResponse) String added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessageResponse) String() string

func (*MsgSetMaxBurnAmountPerMessageResponse) Unmarshal added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessageResponse) XXX_DiscardUnknown()

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_Merge added in v1.0.1 

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

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_Size added in v1.0.1 

func (m *MsgSetMaxBurnAmountPerMessageResponse) XXX_Size() int

func (*MsgSetMaxBurnAmountPerMessageResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUnlinkTokenPair added in v1.0.1 

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 added in v1.0.1 

func NewMsgUnlinkTokenPair(from string, localToken string, remoteToken []byte, remoteDomain uint32) *MsgUnlinkTokenPair

func (*MsgUnlinkTokenPair) Descriptor added in v1.0.1 

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

func (*MsgUnlinkTokenPair) GetFrom added in v1.0.1 

func (m *MsgUnlinkTokenPair) GetFrom() string

func (*MsgUnlinkTokenPair) GetLocalToken added in v1.0.1 

func (m *MsgUnlinkTokenPair) GetLocalToken() string

func (*MsgUnlinkTokenPair) GetRemoteDomain added in v1.0.1 

func (m *MsgUnlinkTokenPair) GetRemoteDomain() uint32

func (*MsgUnlinkTokenPair) GetRemoteToken added in v1.0.1 

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

func (*MsgUnlinkTokenPair) GetSignBytes added in v1.0.1 

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

func (*MsgUnlinkTokenPair) GetSigners added in v1.0.1 

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

func (*MsgUnlinkTokenPair) Marshal added in v1.0.1 

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

func (*MsgUnlinkTokenPair) MarshalTo added in v1.0.1 

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

func (*MsgUnlinkTokenPair) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUnlinkTokenPair) ProtoMessage added in v1.0.1 

func (*MsgUnlinkTokenPair) ProtoMessage()

func (*MsgUnlinkTokenPair) Reset added in v1.0.1 

func (m *MsgUnlinkTokenPair) Reset()

func (*MsgUnlinkTokenPair) Route added in v1.0.1 

func (msg *MsgUnlinkTokenPair) Route() string

func (*MsgUnlinkTokenPair) Size added in v1.0.1 

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

func (*MsgUnlinkTokenPair) String added in v1.0.1 

func (m *MsgUnlinkTokenPair) String() string

func (*MsgUnlinkTokenPair) Type added in v1.0.1 

func (msg *MsgUnlinkTokenPair) Type() string

func (*MsgUnlinkTokenPair) Unmarshal added in v1.0.1 

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

func (*MsgUnlinkTokenPair) ValidateBasic added in v1.0.1 

func (msg *MsgUnlinkTokenPair) ValidateBasic() error

func (*MsgUnlinkTokenPair) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUnlinkTokenPair) XXX_DiscardUnknown()

func (*MsgUnlinkTokenPair) XXX_Marshal added in v1.0.1 

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

func (*MsgUnlinkTokenPair) XXX_Merge added in v1.0.1 

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

func (*MsgUnlinkTokenPair) XXX_Size added in v1.0.1 

func (m *MsgUnlinkTokenPair) XXX_Size() int

func (*MsgUnlinkTokenPair) XXX_Unmarshal added in v1.0.1 

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

type MsgUnlinkTokenPairResponse added in v1.0.1 

type MsgUnlinkTokenPairResponse struct {
}

func (*MsgUnlinkTokenPairResponse) Descriptor added in v1.0.1 

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

func (*MsgUnlinkTokenPairResponse) Marshal added in v1.0.1 

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

func (*MsgUnlinkTokenPairResponse) MarshalTo added in v1.0.1 

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

func (*MsgUnlinkTokenPairResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUnlinkTokenPairResponse) ProtoMessage added in v1.0.1 

func (*MsgUnlinkTokenPairResponse) ProtoMessage()

func (*MsgUnlinkTokenPairResponse) Reset added in v1.0.1 

func (m *MsgUnlinkTokenPairResponse) Reset()

func (*MsgUnlinkTokenPairResponse) Size added in v1.0.1 

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

func (*MsgUnlinkTokenPairResponse) String added in v1.0.1 

func (m *MsgUnlinkTokenPairResponse) String() string

func (*MsgUnlinkTokenPairResponse) Unmarshal added in v1.0.1 

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

func (*MsgUnlinkTokenPairResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUnlinkTokenPairResponse) XXX_DiscardUnknown()

func (*MsgUnlinkTokenPairResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUnlinkTokenPairResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUnlinkTokenPairResponse) XXX_Size added in v1.0.1 

func (m *MsgUnlinkTokenPairResponse) XXX_Size() int

func (*MsgUnlinkTokenPairResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUnpauseBurningAndMinting added in v1.0.1 

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

func NewMsgUnpauseBurningAndMinting added in v1.0.1 

func NewMsgUnpauseBurningAndMinting(from string) *MsgUnpauseBurningAndMinting

func (*MsgUnpauseBurningAndMinting) Descriptor added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) GetFrom added in v1.0.1 

func (m *MsgUnpauseBurningAndMinting) GetFrom() string

func (*MsgUnpauseBurningAndMinting) GetSignBytes added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) GetSigners added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) Marshal added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) MarshalTo added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) ProtoMessage added in v1.0.1 

func (*MsgUnpauseBurningAndMinting) ProtoMessage()

func (*MsgUnpauseBurningAndMinting) Reset added in v1.0.1 

func (m *MsgUnpauseBurningAndMinting) Reset()

func (*MsgUnpauseBurningAndMinting) Route added in v1.0.1 

func (msg *MsgUnpauseBurningAndMinting) Route() string

func (*MsgUnpauseBurningAndMinting) Size added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) String added in v1.0.1 

func (m *MsgUnpauseBurningAndMinting) String() string

func (*MsgUnpauseBurningAndMinting) Type added in v1.0.1 

func (msg *MsgUnpauseBurningAndMinting) Type() string

func (*MsgUnpauseBurningAndMinting) Unmarshal added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) ValidateBasic added in v1.0.1 

func (msg *MsgUnpauseBurningAndMinting) ValidateBasic() error

func (*MsgUnpauseBurningAndMinting) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUnpauseBurningAndMinting) XXX_DiscardUnknown()

func (*MsgUnpauseBurningAndMinting) XXX_Marshal added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) XXX_Merge added in v1.0.1 

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

func (*MsgUnpauseBurningAndMinting) XXX_Size added in v1.0.1 

func (m *MsgUnpauseBurningAndMinting) XXX_Size() int

func (*MsgUnpauseBurningAndMinting) XXX_Unmarshal added in v1.0.1 

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

type MsgUnpauseBurningAndMintingResponse added in v1.0.1 

type MsgUnpauseBurningAndMintingResponse struct {
}

func (*MsgUnpauseBurningAndMintingResponse) Descriptor added in v1.0.1 

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

func (*MsgUnpauseBurningAndMintingResponse) Marshal added in v1.0.1 

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

func (*MsgUnpauseBurningAndMintingResponse) MarshalTo added in v1.0.1 

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

func (*MsgUnpauseBurningAndMintingResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUnpauseBurningAndMintingResponse) ProtoMessage added in v1.0.1 

func (*MsgUnpauseBurningAndMintingResponse) ProtoMessage()

func (*MsgUnpauseBurningAndMintingResponse) Reset added in v1.0.1 

func (m *MsgUnpauseBurningAndMintingResponse) Reset()

func (*MsgUnpauseBurningAndMintingResponse) Size added in v1.0.1 

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

func (*MsgUnpauseBurningAndMintingResponse) String added in v1.0.1 

func (m *MsgUnpauseBurningAndMintingResponse) String() string

func (*MsgUnpauseBurningAndMintingResponse) Unmarshal added in v1.0.1 

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

func (*MsgUnpauseBurningAndMintingResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUnpauseBurningAndMintingResponse) XXX_DiscardUnknown()

func (*MsgUnpauseBurningAndMintingResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUnpauseBurningAndMintingResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUnpauseBurningAndMintingResponse) XXX_Size added in v1.0.1 

func (m *MsgUnpauseBurningAndMintingResponse) XXX_Size() int

func (*MsgUnpauseBurningAndMintingResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUnpauseSendingAndReceivingMessages added in v1.0.1 

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

func NewMsgUnpauseSendingAndReceivingMessages added in v1.0.1 

func NewMsgUnpauseSendingAndReceivingMessages(from string) *MsgUnpauseSendingAndReceivingMessages

func (*MsgUnpauseSendingAndReceivingMessages) Descriptor added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) GetFrom added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessages) GetFrom() string

func (*MsgUnpauseSendingAndReceivingMessages) GetSignBytes added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) GetSigners added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) Marshal added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) MarshalTo added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) ProtoMessage added in v1.0.1 

func (*MsgUnpauseSendingAndReceivingMessages) ProtoMessage()

func (*MsgUnpauseSendingAndReceivingMessages) Reset added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessages) Reset()

func (*MsgUnpauseSendingAndReceivingMessages) Route added in v1.0.1 

func (msg *MsgUnpauseSendingAndReceivingMessages) Route() string

func (*MsgUnpauseSendingAndReceivingMessages) Size added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) String added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessages) String() string

func (*MsgUnpauseSendingAndReceivingMessages) Type added in v1.0.1 

func (msg *MsgUnpauseSendingAndReceivingMessages) Type() string

func (*MsgUnpauseSendingAndReceivingMessages) Unmarshal added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) ValidateBasic added in v1.0.1 

func (msg *MsgUnpauseSendingAndReceivingMessages) ValidateBasic() error

func (*MsgUnpauseSendingAndReceivingMessages) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessages) XXX_DiscardUnknown()

func (*MsgUnpauseSendingAndReceivingMessages) XXX_Marshal added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) XXX_Merge added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessages) XXX_Size added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessages) XXX_Size() int

func (*MsgUnpauseSendingAndReceivingMessages) XXX_Unmarshal added in v1.0.1 

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

type MsgUnpauseSendingAndReceivingMessagesResponse added in v1.0.1 

type MsgUnpauseSendingAndReceivingMessagesResponse struct {
}

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Descriptor added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Marshal added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessagesResponse) MarshalTo added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessagesResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessagesResponse) ProtoMessage added in v1.0.1 

func (*MsgUnpauseSendingAndReceivingMessagesResponse) ProtoMessage()

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Reset added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) Reset()

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Size added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessagesResponse) String added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) String() string

func (*MsgUnpauseSendingAndReceivingMessagesResponse) Unmarshal added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) XXX_DiscardUnknown()

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Size added in v1.0.1 

func (m *MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Size() int

func (*MsgUnpauseSendingAndReceivingMessagesResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateAttesterManager added in v1.0.1 

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 added in v1.0.1 

func NewMsgUpdateAttesterManager(from string, newAttesterManager string) *MsgUpdateAttesterManager

func (*MsgUpdateAttesterManager) Descriptor added in v1.0.1 

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

func (*MsgUpdateAttesterManager) GetFrom added in v1.0.1 

func (m *MsgUpdateAttesterManager) GetFrom() string

func (*MsgUpdateAttesterManager) GetNewAttesterManager added in v1.0.1 

func (m *MsgUpdateAttesterManager) GetNewAttesterManager() string

func (*MsgUpdateAttesterManager) GetSignBytes added in v1.0.1 

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

func (*MsgUpdateAttesterManager) GetSigners added in v1.0.1 

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

func (*MsgUpdateAttesterManager) Marshal added in v1.0.1 

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

func (*MsgUpdateAttesterManager) MarshalTo added in v1.0.1 

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

func (*MsgUpdateAttesterManager) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateAttesterManager) ProtoMessage added in v1.0.1 

func (*MsgUpdateAttesterManager) ProtoMessage()

func (*MsgUpdateAttesterManager) Reset added in v1.0.1 

func (m *MsgUpdateAttesterManager) Reset()

func (*MsgUpdateAttesterManager) Route added in v1.0.1 

func (msg *MsgUpdateAttesterManager) Route() string

func (*MsgUpdateAttesterManager) Size added in v1.0.1 

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

func (*MsgUpdateAttesterManager) String added in v1.0.1 

func (m *MsgUpdateAttesterManager) String() string

func (*MsgUpdateAttesterManager) Type added in v1.0.1 

func (msg *MsgUpdateAttesterManager) Type() string

func (*MsgUpdateAttesterManager) Unmarshal added in v1.0.1 

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

func (*MsgUpdateAttesterManager) ValidateBasic added in v1.0.1 

func (msg *MsgUpdateAttesterManager) ValidateBasic() error

func (*MsgUpdateAttesterManager) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateAttesterManager) XXX_DiscardUnknown()

func (*MsgUpdateAttesterManager) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateAttesterManager) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateAttesterManager) XXX_Size added in v1.0.1 

func (m *MsgUpdateAttesterManager) XXX_Size() int

func (*MsgUpdateAttesterManager) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateAttesterManagerResponse added in v1.0.1 

type MsgUpdateAttesterManagerResponse struct {
}

func (*MsgUpdateAttesterManagerResponse) Descriptor added in v1.0.1 

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

func (*MsgUpdateAttesterManagerResponse) Marshal added in v1.0.1 

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

func (*MsgUpdateAttesterManagerResponse) MarshalTo added in v1.0.1 

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

func (*MsgUpdateAttesterManagerResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateAttesterManagerResponse) ProtoMessage added in v1.0.1 

func (*MsgUpdateAttesterManagerResponse) ProtoMessage()

func (*MsgUpdateAttesterManagerResponse) Reset added in v1.0.1 

func (m *MsgUpdateAttesterManagerResponse) Reset()

func (*MsgUpdateAttesterManagerResponse) Size added in v1.0.1 

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

func (*MsgUpdateAttesterManagerResponse) String added in v1.0.1 

func (m *MsgUpdateAttesterManagerResponse) String() string

func (*MsgUpdateAttesterManagerResponse) Unmarshal added in v1.0.1 

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

func (*MsgUpdateAttesterManagerResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateAttesterManagerResponse) XXX_DiscardUnknown()

func (*MsgUpdateAttesterManagerResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateAttesterManagerResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateAttesterManagerResponse) XXX_Size added in v1.0.1 

func (m *MsgUpdateAttesterManagerResponse) XXX_Size() int

func (*MsgUpdateAttesterManagerResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateMaxMessageBodySize added in v1.0.1 

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 added in v1.0.1 

func NewMsgUpdateMaxMessageBodySize(from string, messageSize uint64) *MsgUpdateMaxMessageBodySize

func (*MsgUpdateMaxMessageBodySize) Descriptor added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) GetFrom added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySize) GetFrom() string

func (*MsgUpdateMaxMessageBodySize) GetMessageSize added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySize) GetMessageSize() uint64

func (*MsgUpdateMaxMessageBodySize) GetSignBytes added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) GetSigners added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) Marshal added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) MarshalTo added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) ProtoMessage added in v1.0.1 

func (*MsgUpdateMaxMessageBodySize) ProtoMessage()

func (*MsgUpdateMaxMessageBodySize) Reset added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySize) Reset()

func (*MsgUpdateMaxMessageBodySize) Route added in v1.0.1 

func (msg *MsgUpdateMaxMessageBodySize) Route() string

func (*MsgUpdateMaxMessageBodySize) Size added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) String added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySize) String() string

func (*MsgUpdateMaxMessageBodySize) Type added in v1.0.1 

func (msg *MsgUpdateMaxMessageBodySize) Type() string

func (*MsgUpdateMaxMessageBodySize) Unmarshal added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) ValidateBasic added in v1.0.1 

func (msg *MsgUpdateMaxMessageBodySize) ValidateBasic() error

func (*MsgUpdateMaxMessageBodySize) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySize) XXX_DiscardUnknown()

func (*MsgUpdateMaxMessageBodySize) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySize) XXX_Size added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySize) XXX_Size() int

func (*MsgUpdateMaxMessageBodySize) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateMaxMessageBodySizeResponse added in v1.0.1 

type MsgUpdateMaxMessageBodySizeResponse struct {
}

func (*MsgUpdateMaxMessageBodySizeResponse) Descriptor added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySizeResponse) Marshal added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySizeResponse) MarshalTo added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySizeResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySizeResponse) ProtoMessage added in v1.0.1 

func (*MsgUpdateMaxMessageBodySizeResponse) ProtoMessage()

func (*MsgUpdateMaxMessageBodySizeResponse) Reset added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySizeResponse) Reset()

func (*MsgUpdateMaxMessageBodySizeResponse) Size added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySizeResponse) String added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySizeResponse) String() string

func (*MsgUpdateMaxMessageBodySizeResponse) Unmarshal added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySizeResponse) XXX_DiscardUnknown()

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_Size added in v1.0.1 

func (m *MsgUpdateMaxMessageBodySizeResponse) XXX_Size() int

func (*MsgUpdateMaxMessageBodySizeResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateOwner added in v1.0.1 

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 added in v1.0.1 

func NewMsgUpdateOwner(from string, newOwner string) *MsgUpdateOwner

func (*MsgUpdateOwner) Descriptor added in v1.0.1 

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

func (*MsgUpdateOwner) GetFrom added in v1.0.1 

func (m *MsgUpdateOwner) GetFrom() string

func (*MsgUpdateOwner) GetNewOwner added in v1.0.1 

func (m *MsgUpdateOwner) GetNewOwner() string

func (*MsgUpdateOwner) GetSignBytes added in v1.0.1 

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

func (*MsgUpdateOwner) GetSigners added in v1.0.1 

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

func (*MsgUpdateOwner) Marshal added in v1.0.1 

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

func (*MsgUpdateOwner) MarshalTo added in v1.0.1 

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

func (*MsgUpdateOwner) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateOwner) ProtoMessage added in v1.0.1 

func (*MsgUpdateOwner) ProtoMessage()

func (*MsgUpdateOwner) Reset added in v1.0.1 

func (m *MsgUpdateOwner) Reset()

func (*MsgUpdateOwner) Route added in v1.0.1 

func (msg *MsgUpdateOwner) Route() string

func (*MsgUpdateOwner) Size added in v1.0.1 

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

func (*MsgUpdateOwner) String added in v1.0.1 

func (m *MsgUpdateOwner) String() string

func (*MsgUpdateOwner) Type added in v1.0.1 

func (msg *MsgUpdateOwner) Type() string

func (*MsgUpdateOwner) Unmarshal added in v1.0.1 

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

func (*MsgUpdateOwner) ValidateBasic added in v1.0.1 

func (msg *MsgUpdateOwner) ValidateBasic() error

func (*MsgUpdateOwner) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateOwner) XXX_DiscardUnknown()

func (*MsgUpdateOwner) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateOwner) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateOwner) XXX_Size added in v1.0.1 

func (m *MsgUpdateOwner) XXX_Size() int

func (*MsgUpdateOwner) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateOwnerResponse added in v1.0.1 

type MsgUpdateOwnerResponse struct {
}

func (*MsgUpdateOwnerResponse) Descriptor added in v1.0.1 

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

func (*MsgUpdateOwnerResponse) Marshal added in v1.0.1 

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

func (*MsgUpdateOwnerResponse) MarshalTo added in v1.0.1 

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

func (*MsgUpdateOwnerResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateOwnerResponse) ProtoMessage added in v1.0.1 

func (*MsgUpdateOwnerResponse) ProtoMessage()

func (*MsgUpdateOwnerResponse) Reset added in v1.0.1 

func (m *MsgUpdateOwnerResponse) Reset()

func (*MsgUpdateOwnerResponse) Size added in v1.0.1 

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

func (*MsgUpdateOwnerResponse) String added in v1.0.1 

func (m *MsgUpdateOwnerResponse) String() string

func (*MsgUpdateOwnerResponse) Unmarshal added in v1.0.1 

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

func (*MsgUpdateOwnerResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateOwnerResponse) XXX_DiscardUnknown()

func (*MsgUpdateOwnerResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateOwnerResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateOwnerResponse) XXX_Size added in v1.0.1 

func (m *MsgUpdateOwnerResponse) XXX_Size() int

func (*MsgUpdateOwnerResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdatePauser added in v1.0.1 

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 added in v1.0.1 

func NewMsgUpdatePauser(from string, newPauser string) *MsgUpdatePauser

func (*MsgUpdatePauser) Descriptor added in v1.0.1 

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

func (*MsgUpdatePauser) GetFrom added in v1.0.1 

func (m *MsgUpdatePauser) GetFrom() string

func (*MsgUpdatePauser) GetNewPauser added in v1.0.1 

func (m *MsgUpdatePauser) GetNewPauser() string

func (*MsgUpdatePauser) GetSignBytes added in v1.0.1 

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

func (*MsgUpdatePauser) GetSigners added in v1.0.1 

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

func (*MsgUpdatePauser) Marshal added in v1.0.1 

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

func (*MsgUpdatePauser) MarshalTo added in v1.0.1 

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

func (*MsgUpdatePauser) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdatePauser) ProtoMessage added in v1.0.1 

func (*MsgUpdatePauser) ProtoMessage()

func (*MsgUpdatePauser) Reset added in v1.0.1 

func (m *MsgUpdatePauser) Reset()

func (*MsgUpdatePauser) Route added in v1.0.1 

func (msg *MsgUpdatePauser) Route() string

func (*MsgUpdatePauser) Size added in v1.0.1 

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

func (*MsgUpdatePauser) String added in v1.0.1 

func (m *MsgUpdatePauser) String() string

func (*MsgUpdatePauser) Type added in v1.0.1 

func (msg *MsgUpdatePauser) Type() string

func (*MsgUpdatePauser) Unmarshal added in v1.0.1 

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

func (*MsgUpdatePauser) ValidateBasic added in v1.0.1 

func (msg *MsgUpdatePauser) ValidateBasic() error

func (*MsgUpdatePauser) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdatePauser) XXX_DiscardUnknown()

func (*MsgUpdatePauser) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdatePauser) XXX_Merge added in v1.0.1 

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

func (*MsgUpdatePauser) XXX_Size added in v1.0.1 

func (m *MsgUpdatePauser) XXX_Size() int

func (*MsgUpdatePauser) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdatePauserResponse added in v1.0.1 

type MsgUpdatePauserResponse struct {
}

func (*MsgUpdatePauserResponse) Descriptor added in v1.0.1 

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

func (*MsgUpdatePauserResponse) Marshal added in v1.0.1 

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

func (*MsgUpdatePauserResponse) MarshalTo added in v1.0.1 

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

func (*MsgUpdatePauserResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdatePauserResponse) ProtoMessage added in v1.0.1 

func (*MsgUpdatePauserResponse) ProtoMessage()

func (*MsgUpdatePauserResponse) Reset added in v1.0.1 

func (m *MsgUpdatePauserResponse) Reset()

func (*MsgUpdatePauserResponse) Size added in v1.0.1 

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

func (*MsgUpdatePauserResponse) String added in v1.0.1 

func (m *MsgUpdatePauserResponse) String() string

func (*MsgUpdatePauserResponse) Unmarshal added in v1.0.1 

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

func (*MsgUpdatePauserResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdatePauserResponse) XXX_DiscardUnknown()

func (*MsgUpdatePauserResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdatePauserResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUpdatePauserResponse) XXX_Size added in v1.0.1 

func (m *MsgUpdatePauserResponse) XXX_Size() int

func (*MsgUpdatePauserResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateSignatureThreshold added in v1.0.1 

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 added in v1.0.1 

func NewMsgUpdateSignatureThreshold(from string, amount uint32) *MsgUpdateSignatureThreshold

func (*MsgUpdateSignatureThreshold) Descriptor added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) GetAmount added in v1.0.1 

func (m *MsgUpdateSignatureThreshold) GetAmount() uint32

func (*MsgUpdateSignatureThreshold) GetFrom added in v1.0.1 

func (m *MsgUpdateSignatureThreshold) GetFrom() string

func (*MsgUpdateSignatureThreshold) GetSignBytes added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) GetSigners added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) Marshal added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) MarshalTo added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) ProtoMessage added in v1.0.1 

func (*MsgUpdateSignatureThreshold) ProtoMessage()

func (*MsgUpdateSignatureThreshold) Reset added in v1.0.1 

func (m *MsgUpdateSignatureThreshold) Reset()

func (*MsgUpdateSignatureThreshold) Route added in v1.0.1 

func (msg *MsgUpdateSignatureThreshold) Route() string

func (*MsgUpdateSignatureThreshold) Size added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) String added in v1.0.1 

func (m *MsgUpdateSignatureThreshold) String() string

func (*MsgUpdateSignatureThreshold) Type added in v1.0.1 

func (msg *MsgUpdateSignatureThreshold) Type() string

func (*MsgUpdateSignatureThreshold) Unmarshal added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) ValidateBasic added in v1.0.1 

func (msg *MsgUpdateSignatureThreshold) ValidateBasic() error

func (*MsgUpdateSignatureThreshold) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateSignatureThreshold) XXX_DiscardUnknown()

func (*MsgUpdateSignatureThreshold) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateSignatureThreshold) XXX_Size added in v1.0.1 

func (m *MsgUpdateSignatureThreshold) XXX_Size() int

func (*MsgUpdateSignatureThreshold) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateSignatureThresholdResponse added in v1.0.1 

type MsgUpdateSignatureThresholdResponse struct {
}

func (*MsgUpdateSignatureThresholdResponse) Descriptor added in v1.0.1 

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

func (*MsgUpdateSignatureThresholdResponse) Marshal added in v1.0.1 

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

func (*MsgUpdateSignatureThresholdResponse) MarshalTo added in v1.0.1 

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

func (*MsgUpdateSignatureThresholdResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateSignatureThresholdResponse) ProtoMessage added in v1.0.1 

func (*MsgUpdateSignatureThresholdResponse) ProtoMessage()

func (*MsgUpdateSignatureThresholdResponse) Reset added in v1.0.1 

func (m *MsgUpdateSignatureThresholdResponse) Reset()

func (*MsgUpdateSignatureThresholdResponse) Size added in v1.0.1 

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

func (*MsgUpdateSignatureThresholdResponse) String added in v1.0.1 

func (m *MsgUpdateSignatureThresholdResponse) String() string

func (*MsgUpdateSignatureThresholdResponse) Unmarshal added in v1.0.1 

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

func (*MsgUpdateSignatureThresholdResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateSignatureThresholdResponse) XXX_DiscardUnknown()

func (*MsgUpdateSignatureThresholdResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateSignatureThresholdResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateSignatureThresholdResponse) XXX_Size added in v1.0.1 

func (m *MsgUpdateSignatureThresholdResponse) XXX_Size() int

func (*MsgUpdateSignatureThresholdResponse) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateTokenController added in v1.0.1 

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 added in v1.0.1 

func NewMsgUpdateTokenController(from string, newTokenController string) *MsgUpdateTokenController

func (*MsgUpdateTokenController) Descriptor added in v1.0.1 

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

func (*MsgUpdateTokenController) GetFrom added in v1.0.1 

func (m *MsgUpdateTokenController) GetFrom() string

func (*MsgUpdateTokenController) GetNewTokenController added in v1.0.1 

func (m *MsgUpdateTokenController) GetNewTokenController() string

func (*MsgUpdateTokenController) GetSignBytes added in v1.0.1 

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

func (*MsgUpdateTokenController) GetSigners added in v1.0.1 

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

func (*MsgUpdateTokenController) Marshal added in v1.0.1 

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

func (*MsgUpdateTokenController) MarshalTo added in v1.0.1 

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

func (*MsgUpdateTokenController) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateTokenController) ProtoMessage added in v1.0.1 

func (*MsgUpdateTokenController) ProtoMessage()

func (*MsgUpdateTokenController) Reset added in v1.0.1 

func (m *MsgUpdateTokenController) Reset()

func (*MsgUpdateTokenController) Route added in v1.0.1 

func (msg *MsgUpdateTokenController) Route() string

func (*MsgUpdateTokenController) Size added in v1.0.1 

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

func (*MsgUpdateTokenController) String added in v1.0.1 

func (m *MsgUpdateTokenController) String() string

func (*MsgUpdateTokenController) Type added in v1.0.1 

func (msg *MsgUpdateTokenController) Type() string

func (*MsgUpdateTokenController) Unmarshal added in v1.0.1 

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

func (*MsgUpdateTokenController) ValidateBasic added in v1.0.1 

func (msg *MsgUpdateTokenController) ValidateBasic() error

func (*MsgUpdateTokenController) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateTokenController) XXX_DiscardUnknown()

func (*MsgUpdateTokenController) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateTokenController) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateTokenController) XXX_Size added in v1.0.1 

func (m *MsgUpdateTokenController) XXX_Size() int

func (*MsgUpdateTokenController) XXX_Unmarshal added in v1.0.1 

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

type MsgUpdateTokenControllerResponse added in v1.0.1 

type MsgUpdateTokenControllerResponse struct {
}

func (*MsgUpdateTokenControllerResponse) Descriptor added in v1.0.1 

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

func (*MsgUpdateTokenControllerResponse) Marshal added in v1.0.1 

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

func (*MsgUpdateTokenControllerResponse) MarshalTo added in v1.0.1 

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

func (*MsgUpdateTokenControllerResponse) MarshalToSizedBuffer added in v1.0.1 

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

func (*MsgUpdateTokenControllerResponse) ProtoMessage added in v1.0.1 

func (*MsgUpdateTokenControllerResponse) ProtoMessage()

func (*MsgUpdateTokenControllerResponse) Reset added in v1.0.1 

func (m *MsgUpdateTokenControllerResponse) Reset()

func (*MsgUpdateTokenControllerResponse) Size added in v1.0.1 

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

func (*MsgUpdateTokenControllerResponse) String added in v1.0.1 

func (m *MsgUpdateTokenControllerResponse) String() string

func (*MsgUpdateTokenControllerResponse) Unmarshal added in v1.0.1 

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

func (*MsgUpdateTokenControllerResponse) XXX_DiscardUnknown added in v1.0.1 

func (m *MsgUpdateTokenControllerResponse) XXX_DiscardUnknown()

func (*MsgUpdateTokenControllerResponse) XXX_Marshal added in v1.0.1 

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

func (*MsgUpdateTokenControllerResponse) XXX_Merge added in v1.0.1 

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

func (*MsgUpdateTokenControllerResponse) XXX_Size added in v1.0.1 

func (m *MsgUpdateTokenControllerResponse) XXX_Size() int

func (*MsgUpdateTokenControllerResponse) XXX_Unmarshal added in v1.0.1 

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) RegisterAccount 

func (*UnimplementedMsgServer) RegisterAccount(ctx context.Context, req *MsgRegisterAccount) (*MsgRegisterAccountResponse, 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.