diff --git a/docs/ibc/proto-docs.md b/docs/ibc/proto-docs.md
index dacb89063dd..32546ed6568 100644
--- a/docs/ibc/proto-docs.md
+++ b/docs/ibc/proto-docs.md
@@ -307,27 +307,15 @@
- [DataType](#ibc.lightclients.solomachine.v1.DataType)
- [ibc/lightclients/solomachine/v2/solomachine.proto](#ibc/lightclients/solomachine/v2/solomachine.proto)
- - [ChannelStateData](#ibc.lightclients.solomachine.v2.ChannelStateData)
- [ClientState](#ibc.lightclients.solomachine.v2.ClientState)
- - [ClientStateData](#ibc.lightclients.solomachine.v2.ClientStateData)
- - [ConnectionStateData](#ibc.lightclients.solomachine.v2.ConnectionStateData)
- [ConsensusState](#ibc.lightclients.solomachine.v2.ConsensusState)
- - [ConsensusStateData](#ibc.lightclients.solomachine.v2.ConsensusStateData)
- [Header](#ibc.lightclients.solomachine.v2.Header)
- [HeaderData](#ibc.lightclients.solomachine.v2.HeaderData)
- [Misbehaviour](#ibc.lightclients.solomachine.v2.Misbehaviour)
- - [NextSequenceRecvData](#ibc.lightclients.solomachine.v2.NextSequenceRecvData)
- - [PacketAcknowledgementData](#ibc.lightclients.solomachine.v2.PacketAcknowledgementData)
- - [PacketCommitmentData](#ibc.lightclients.solomachine.v2.PacketCommitmentData)
- - [PacketReceiptAbsenceData](#ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData)
- - [SignBytes](#ibc.lightclients.solomachine.v2.SignBytes)
- [SignBytesV2](#ibc.lightclients.solomachine.v2.SignBytesV2)
- - [SignatureAndData](#ibc.lightclients.solomachine.v2.SignatureAndData)
- [SignatureAndDataV2](#ibc.lightclients.solomachine.v2.SignatureAndDataV2)
- [TimestampedSignatureData](#ibc.lightclients.solomachine.v2.TimestampedSignatureData)
- - [DataType](#ibc.lightclients.solomachine.v2.DataType)
-
- [ibc/lightclients/tendermint/v1/tendermint.proto](#ibc/lightclients/tendermint/v1/tendermint.proto)
- [ClientState](#ibc.lightclients.tendermint.v1.ClientState)
- [ConsensusState](#ibc.lightclients.tendermint.v1.ConsensusState)
@@ -4494,23 +4482,6 @@ to preserve uniqueness of different data sign byte encodings.
-
-
-### ChannelStateData
-ChannelStateData returns the SignBytes data for channel state
-verification.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `path` | [bytes](#bytes) | | |
-| `channel` | [ibc.core.channel.v1.Channel](#ibc.core.channel.v1.Channel) | | |
-
-
-
-
-
-
### ClientState
@@ -4530,39 +4501,6 @@ state and if the client is frozen.
-
-
-### ClientStateData
-ClientStateData returns the SignBytes data for client state verification.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `path` | [bytes](#bytes) | | |
-| `client_state` | [google.protobuf.Any](#google.protobuf.Any) | | |
-
-
-
-
-
-
-
-
-### ConnectionStateData
-ConnectionStateData returns the SignBytes data for connection state
-verification.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `path` | [bytes](#bytes) | | |
-| `connection` | [ibc.core.connection.v1.ConnectionEnd](#ibc.core.connection.v1.ConnectionEnd) | | |
-
-
-
-
-
-
### ConsensusState
@@ -4582,23 +4520,6 @@ consensus state.
-
-
-### ConsensusStateData
-ConsensusStateData returns the SignBytes data for consensus state
-verification.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `path` | [bytes](#bytes) | | |
-| `consensus_state` | [google.protobuf.Any](#google.protobuf.Any) | | |
-
-
-
-
-
-
### Header
@@ -4653,92 +4574,6 @@ of a sequence and two signatures over different messages at that sequence.
-
-
-### NextSequenceRecvData
-NextSequenceRecvData returns the SignBytes data for verification of the next
-sequence to be received.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `path` | [bytes](#bytes) | | |
-| `next_seq_recv` | [uint64](#uint64) | | |
-
-
-
-
-
-
-
-
-### PacketAcknowledgementData
-PacketAcknowledgementData returns the SignBytes data for acknowledgement
-verification.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `path` | [bytes](#bytes) | | |
-| `acknowledgement` | [bytes](#bytes) | | |
-
-
-
-
-
-
-
-
-### PacketCommitmentData
-PacketCommitmentData returns the SignBytes data for packet commitment
-verification.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `path` | [bytes](#bytes) | | |
-| `commitment` | [bytes](#bytes) | | |
-
-
-
-
-
-
-
-
-### PacketReceiptAbsenceData
-PacketReceiptAbsenceData returns the SignBytes data for
-packet receipt absence verification.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `path` | [bytes](#bytes) | | |
-
-
-
-
-
-
-
-
-### SignBytes
-SignBytes defines the signed bytes used for signature verification.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `sequence` | [uint64](#uint64) | | |
-| `timestamp` | [uint64](#uint64) | | |
-| `diversifier` | [string](#string) | | |
-| `data_type` | [DataType](#ibc.lightclients.solomachine.v2.DataType) | | type of the data used |
-| `data` | [bytes](#bytes) | | marshaled data |
-
-
-
-
-
-
### SignBytesV2
@@ -4758,25 +4593,6 @@ SignBytesV2 defines the signed bytes used for signature verification.
-
-
-### SignatureAndData
-SignatureAndData contains a signature and the data signed over to create that
-signature.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `signature` | [bytes](#bytes) | | |
-| `data_type` | [DataType](#ibc.lightclients.solomachine.v2.DataType) | | |
-| `data` | [bytes](#bytes) | | |
-| `timestamp` | [uint64](#uint64) | | |
-
-
-
-
-
-
### SignatureAndDataV2
@@ -4814,27 +4630,6 @@ signature.
-
-
-
-### DataType
-DataType defines the type of solo machine proof being created. This is done
-to preserve uniqueness of different data sign byte encodings.
-
-| Name | Number | Description |
-| ---- | ------ | ----------- |
-| DATA_TYPE_UNINITIALIZED_UNSPECIFIED | 0 | Default State |
-| DATA_TYPE_CLIENT_STATE | 1 | Data type for client state verification |
-| DATA_TYPE_CONSENSUS_STATE | 2 | Data type for consensus state verification |
-| DATA_TYPE_CONNECTION_STATE | 3 | Data type for connection state verification |
-| DATA_TYPE_CHANNEL_STATE | 4 | Data type for channel state verification |
-| DATA_TYPE_PACKET_COMMITMENT | 5 | Data type for packet commitment verification |
-| DATA_TYPE_PACKET_ACKNOWLEDGEMENT | 6 | Data type for packet acknowledgement verification |
-| DATA_TYPE_PACKET_RECEIPT_ABSENCE | 7 | Data type for packet receipt absence verification |
-| DATA_TYPE_NEXT_SEQUENCE_RECV | 8 | Data type for next sequence recv verification |
-| DATA_TYPE_HEADER | 9 | Data type for header verification |
-
-
diff --git a/modules/light-clients/06-solomachine/client_state.go b/modules/light-clients/06-solomachine/client_state.go
index 077155632a8..93e61b7c00a 100644
--- a/modules/light-clients/06-solomachine/client_state.go
+++ b/modules/light-clients/06-solomachine/client_state.go
@@ -105,329 +105,6 @@ func (cs ClientState) VerifyUpgradeAndUpdateState(
return sdkerrors.Wrap(clienttypes.ErrInvalidUpgradeClient, "cannot upgrade solomachine client")
}
-// VerifyClientState verifies a proof of the client state of the running chain
-// stored on the solo machine.
-func (cs *ClientState) VerifyClientState(
- store sdk.KVStore,
- cdc codec.BinaryCodec,
- height exported.Height,
- prefix exported.Prefix,
- counterpartyClientIdentifier string,
- proof []byte,
- clientState exported.ClientState,
-) error {
- // NOTE: the proof height sequence is incremented by one due to the connection handshake verification ordering
- height = clienttypes.NewHeight(height.GetRevisionNumber(), height.GetRevisionHeight()+1)
-
- publicKey, sigData, timestamp, sequence, err := produceVerificationArgs(cdc, cs, height, prefix, proof)
- if err != nil {
- return err
- }
-
- clientPrefixedPath := commitmenttypes.NewMerklePath(host.FullClientStatePath(counterpartyClientIdentifier))
- path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath)
- if err != nil {
- return err
- }
-
- signBz, err := ClientStateSignBytes(cdc, sequence, timestamp, cs.ConsensusState.Diversifier, path, clientState)
- if err != nil {
- return err
- }
-
- if err := VerifySignature(publicKey, signBz, sigData); err != nil {
- return err
- }
-
- cs.Sequence++
- cs.ConsensusState.Timestamp = timestamp
- setClientState(store, cdc, cs)
- return nil
-}
-
-// VerifyClientConsensusState verifies a proof of the consensus state of the
-// running chain stored on the solo machine.
-func (cs *ClientState) VerifyClientConsensusState(
- store sdk.KVStore,
- cdc codec.BinaryCodec,
- height exported.Height,
- counterpartyClientIdentifier string,
- consensusHeight exported.Height,
- prefix exported.Prefix,
- proof []byte,
- consensusState exported.ConsensusState,
-) error {
- // NOTE: the proof height sequence is incremented by two due to the connection handshake verification ordering
- height = clienttypes.NewHeight(height.GetRevisionNumber(), height.GetRevisionHeight()+2)
-
- publicKey, sigData, timestamp, sequence, err := produceVerificationArgs(cdc, cs, height, prefix, proof)
- if err != nil {
- return err
- }
-
- clientPrefixedPath := commitmenttypes.NewMerklePath(host.FullConsensusStatePath(counterpartyClientIdentifier, consensusHeight))
- path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath)
- if err != nil {
- return err
- }
-
- signBz, err := ConsensusStateSignBytes(cdc, sequence, timestamp, cs.ConsensusState.Diversifier, path, consensusState)
- if err != nil {
- return err
- }
-
- if err := VerifySignature(publicKey, signBz, sigData); err != nil {
- return err
- }
-
- cs.Sequence++
- cs.ConsensusState.Timestamp = timestamp
- setClientState(store, cdc, cs)
- return nil
-}
-
-// VerifyConnectionState verifies a proof of the connection state of the
-// specified connection end stored on the target machine.
-func (cs *ClientState) VerifyConnectionState(
- store sdk.KVStore,
- cdc codec.BinaryCodec,
- height exported.Height,
- prefix exported.Prefix,
- proof []byte,
- connectionID string,
- connectionEnd exported.ConnectionI,
-) error {
- publicKey, sigData, timestamp, sequence, err := produceVerificationArgs(cdc, cs, height, prefix, proof)
- if err != nil {
- return err
- }
-
- connectionPath := commitmenttypes.NewMerklePath(host.ConnectionPath(connectionID))
- path, err := commitmenttypes.ApplyPrefix(prefix, connectionPath)
- if err != nil {
- return err
- }
-
- signBz, err := ConnectionStateSignBytes(cdc, sequence, timestamp, cs.ConsensusState.Diversifier, path, connectionEnd)
- if err != nil {
- return err
- }
-
- if err := VerifySignature(publicKey, signBz, sigData); err != nil {
- return err
- }
-
- cs.Sequence++
- cs.ConsensusState.Timestamp = timestamp
- setClientState(store, cdc, cs)
- return nil
-}
-
-// VerifyChannelState verifies a proof of the channel state of the specified
-// channel end, under the specified port, stored on the target machine.
-func (cs *ClientState) VerifyChannelState(
- store sdk.KVStore,
- cdc codec.BinaryCodec,
- height exported.Height,
- prefix exported.Prefix,
- proof []byte,
- portID,
- channelID string,
- channel exported.ChannelI,
-) error {
- publicKey, sigData, timestamp, sequence, err := produceVerificationArgs(cdc, cs, height, prefix, proof)
- if err != nil {
- return err
- }
-
- channelPath := commitmenttypes.NewMerklePath(host.ChannelPath(portID, channelID))
- path, err := commitmenttypes.ApplyPrefix(prefix, channelPath)
- if err != nil {
- return err
- }
-
- signBz, err := ChannelStateSignBytes(cdc, sequence, timestamp, cs.ConsensusState.Diversifier, path, channel)
- if err != nil {
- return err
- }
-
- if err := VerifySignature(publicKey, signBz, sigData); err != nil {
- return err
- }
-
- cs.Sequence++
- cs.ConsensusState.Timestamp = timestamp
- setClientState(store, cdc, cs)
- return nil
-}
-
-// VerifyPacketCommitment verifies a proof of an outgoing packet commitment at
-// the specified port, specified channel, and specified sequence.
-func (cs *ClientState) VerifyPacketCommitment(
- ctx sdk.Context,
- store sdk.KVStore,
- cdc codec.BinaryCodec,
- height exported.Height,
- _ uint64,
- _ uint64,
- prefix exported.Prefix,
- proof []byte,
- portID,
- channelID string,
- packetSequence uint64,
- commitmentBytes []byte,
-) error {
- publicKey, sigData, timestamp, sequence, err := produceVerificationArgs(cdc, cs, height, prefix, proof)
- if err != nil {
- return err
- }
-
- commitmentPath := commitmenttypes.NewMerklePath(host.PacketCommitmentPath(portID, channelID, packetSequence))
- path, err := commitmenttypes.ApplyPrefix(prefix, commitmentPath)
- if err != nil {
- return err
- }
-
- signBz, err := PacketCommitmentSignBytes(cdc, sequence, timestamp, cs.ConsensusState.Diversifier, path, commitmentBytes)
- if err != nil {
- return err
- }
-
- if err := VerifySignature(publicKey, signBz, sigData); err != nil {
- return err
- }
-
- cs.Sequence++
- cs.ConsensusState.Timestamp = timestamp
- setClientState(store, cdc, cs)
- return nil
-}
-
-// VerifyPacketAcknowledgement verifies a proof of an incoming packet
-// acknowledgement at the specified port, specified channel, and specified sequence.
-func (cs *ClientState) VerifyPacketAcknowledgement(
- ctx sdk.Context,
- store sdk.KVStore,
- cdc codec.BinaryCodec,
- height exported.Height,
- _ uint64,
- _ uint64,
- prefix exported.Prefix,
- proof []byte,
- portID,
- channelID string,
- packetSequence uint64,
- acknowledgement []byte,
-) error {
- publicKey, sigData, timestamp, sequence, err := produceVerificationArgs(cdc, cs, height, prefix, proof)
- if err != nil {
- return err
- }
-
- ackPath := commitmenttypes.NewMerklePath(host.PacketAcknowledgementPath(portID, channelID, packetSequence))
- path, err := commitmenttypes.ApplyPrefix(prefix, ackPath)
- if err != nil {
- return err
- }
-
- signBz, err := PacketAcknowledgementSignBytes(cdc, sequence, timestamp, cs.ConsensusState.Diversifier, path, acknowledgement)
- if err != nil {
- return err
- }
-
- if err := VerifySignature(publicKey, signBz, sigData); err != nil {
- return err
- }
-
- cs.Sequence++
- cs.ConsensusState.Timestamp = timestamp
- setClientState(store, cdc, cs)
- return nil
-}
-
-// VerifyPacketReceiptAbsence verifies a proof of the absence of an
-// incoming packet receipt at the specified port, specified channel, and
-// specified sequence.
-func (cs *ClientState) VerifyPacketReceiptAbsence(
- ctx sdk.Context,
- store sdk.KVStore,
- cdc codec.BinaryCodec,
- height exported.Height,
- _ uint64,
- _ uint64,
- prefix exported.Prefix,
- proof []byte,
- portID,
- channelID string,
- packetSequence uint64,
-) error {
- publicKey, sigData, timestamp, sequence, err := produceVerificationArgs(cdc, cs, height, prefix, proof)
- if err != nil {
- return err
- }
-
- receiptPath := commitmenttypes.NewMerklePath(host.PacketReceiptPath(portID, channelID, packetSequence))
- path, err := commitmenttypes.ApplyPrefix(prefix, receiptPath)
- if err != nil {
- return err
- }
-
- signBz, err := PacketReceiptAbsenceSignBytes(cdc, sequence, timestamp, cs.ConsensusState.Diversifier, path)
- if err != nil {
- return err
- }
-
- if err := VerifySignature(publicKey, signBz, sigData); err != nil {
- return err
- }
-
- cs.Sequence++
- cs.ConsensusState.Timestamp = timestamp
- setClientState(store, cdc, cs)
- return nil
-}
-
-// VerifyNextSequenceRecv verifies a proof of the next sequence number to be
-// received of the specified channel at the specified port.
-func (cs *ClientState) VerifyNextSequenceRecv(
- ctx sdk.Context,
- store sdk.KVStore,
- cdc codec.BinaryCodec,
- height exported.Height,
- _ uint64,
- _ uint64,
- prefix exported.Prefix,
- proof []byte,
- portID,
- channelID string,
- nextSequenceRecv uint64,
-) error {
- publicKey, sigData, timestamp, sequence, err := produceVerificationArgs(cdc, cs, height, prefix, proof)
- if err != nil {
- return err
- }
-
- nextSequenceRecvPath := commitmenttypes.NewMerklePath(host.NextSequenceRecvPath(portID, channelID))
- path, err := commitmenttypes.ApplyPrefix(prefix, nextSequenceRecvPath)
- if err != nil {
- return err
- }
-
- signBz, err := NextSequenceRecvSignBytes(cdc, sequence, timestamp, cs.ConsensusState.Diversifier, path, nextSequenceRecv)
- if err != nil {
- return err
- }
-
- if err := VerifySignature(publicKey, signBz, sigData); err != nil {
- return err
- }
-
- cs.Sequence++
- cs.ConsensusState.Timestamp = timestamp
- setClientState(store, cdc, cs)
- return nil
-}
-
// VerifyMembership is a generic proof verification method which verifies a proof of the existence of a value at a given CommitmentPath at the specified height.
// The caller is expected to construct the full CommitmentPath from a CommitmentPrefix and a standardized path (as defined in ICS 24).
func (cs *ClientState) VerifyMembership(
@@ -530,6 +207,7 @@ func (cs *ClientState) VerifyNonMembership(
return nil
}
+// TODO: Remove function as no longer used
// produceVerificationArgs perfoms the basic checks on the arguments that are
// shared between the verification functions and returns the public key of the
// consensus state, the unmarshalled proof representing the signature and timestamp
diff --git a/modules/light-clients/06-solomachine/client_state_test.go b/modules/light-clients/06-solomachine/client_state_test.go
index 2beb48dbbf4..5ef1014af28 100644
--- a/modules/light-clients/06-solomachine/client_state_test.go
+++ b/modules/light-clients/06-solomachine/client_state_test.go
@@ -2,8 +2,6 @@ package solomachine_test
import (
clienttypes "github.com/cosmos/ibc-go/v3/modules/core/02-client/types"
- connectiontypes "github.com/cosmos/ibc-go/v3/modules/core/03-connection/types"
- channeltypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
commitmenttypes "github.com/cosmos/ibc-go/v3/modules/core/23-commitment/types"
"github.com/cosmos/ibc-go/v3/modules/core/exported"
solomachine "github.com/cosmos/ibc-go/v3/modules/light-clients/06-solomachine"
@@ -18,13 +16,6 @@ const (
testPortID = "testportid"
)
-var (
- prefix = &commitmenttypes.MerklePrefix{
- KeyPrefix: []byte("ibc"),
- }
- consensusHeight = clienttypes.ZeroHeight()
-)
-
func (suite *SoloMachineTestSuite) TestStatus() {
clientState := suite.solomachine.ClientState()
// solo machine discards arguments
@@ -563,708 +554,6 @@ func (suite *SoloMachineTestSuite) TestVerifyMembership() {
}
}
-func (suite *SoloMachineTestSuite) TestVerifyClientState() {
- // create client for tendermint so we can use client state for verification
- tmPath := ibctesting.NewPath(suite.chainA, suite.chainB)
- suite.coordinator.SetupClients(tmPath)
- clientState := suite.chainA.GetClientState(tmPath.EndpointA.ClientID)
- path := suite.solomachine.GetClientStatePath(counterpartyClientIdentifier)
-
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- value, err := solomachine.ClientStateSignBytes(suite.chainA.Codec, sm.Sequence, sm.Time, sm.Diversifier, path, clientState)
- suite.Require().NoError(err)
-
- sig := sm.GenerateSignature(value)
-
- signatureDoc := &solomachine.TimestampedSignatureData{
- SignatureData: sig,
- Timestamp: sm.Time,
- }
-
- proof, err := suite.chainA.Codec.Marshal(signatureDoc)
- suite.Require().NoError(err)
-
- testCases := []struct {
- name string
- clientState *solomachine.ClientState
- prefix exported.Prefix
- proof []byte
- expPass bool
- }{
- {
- "successful verification",
- sm.ClientState(),
- prefix,
- proof,
- true,
- },
- {
- "ApplyPrefix failed",
- sm.ClientState(),
- nil,
- proof,
- false,
- },
- {
- "consensus state in client state is nil",
- solomachine.NewClientState(1, nil, false),
- prefix,
- proof,
- false,
- },
- {
- "client state latest height is less than sequence",
- solomachine.NewClientState(sm.Sequence-1,
- &solomachine.ConsensusState{
- Timestamp: sm.Time,
- PublicKey: sm.ConsensusState().PublicKey,
- }, false),
- prefix,
- proof,
- false,
- },
- {
- "consensus state timestamp is greater than signature",
- solomachine.NewClientState(sm.Sequence,
- &solomachine.ConsensusState{
- Timestamp: sm.Time + 1,
- PublicKey: sm.ConsensusState().PublicKey,
- }, false),
- prefix,
- proof,
- false,
- },
-
- {
- "proof is nil",
- sm.ClientState(),
- prefix,
- nil,
- false,
- },
- {
- "proof verification failed",
- sm.ClientState(),
- prefix,
- suite.GetInvalidProof(),
- false,
- },
- }
-
- for _, tc := range testCases {
- tc := tc
-
- suite.Run(tc.name, func() {
-
- var expSeq uint64
- if tc.clientState.ConsensusState != nil {
- expSeq = tc.clientState.Sequence + 1
- }
-
- // NOTE: to replicate the ordering of connection handshake, we must decrement proof height by 1
- height := clienttypes.NewHeight(sm.GetHeight().GetRevisionNumber(), sm.GetHeight().GetRevisionHeight()-1)
-
- err := tc.clientState.VerifyClientState(
- suite.store, suite.chainA.Codec, height, tc.prefix, counterpartyClientIdentifier, tc.proof, clientState,
- )
-
- if tc.expPass {
- suite.Require().NoError(err)
- suite.Require().Equal(expSeq, tc.clientState.Sequence)
- suite.Require().Equal(expSeq, suite.GetSequenceFromStore(), "sequence not updated in the store (%d) on valid test case %s", suite.GetSequenceFromStore(), tc.name)
- } else {
- suite.Require().Error(err)
- }
- })
- }
- }
-}
-
-func (suite *SoloMachineTestSuite) TestVerifyClientConsensusState() {
- // create client for tendermint so we can use consensus state for verification
- tmPath := ibctesting.NewPath(suite.chainA, suite.chainB)
- suite.coordinator.SetupClients(tmPath)
- clientState := suite.chainA.GetClientState(tmPath.EndpointA.ClientID)
- consensusState, found := suite.chainA.GetConsensusState(tmPath.EndpointA.ClientID, clientState.GetLatestHeight())
- suite.Require().True(found)
-
- path := suite.solomachine.GetConsensusStatePath(counterpartyClientIdentifier, consensusHeight)
-
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- value, err := solomachine.ConsensusStateSignBytes(suite.chainA.Codec, sm.Sequence, sm.Time, sm.Diversifier, path, consensusState)
- suite.Require().NoError(err)
-
- sig := sm.GenerateSignature(value)
- signatureDoc := &solomachine.TimestampedSignatureData{
- SignatureData: sig,
- Timestamp: sm.Time,
- }
-
- proof, err := suite.chainA.Codec.Marshal(signatureDoc)
- suite.Require().NoError(err)
-
- testCases := []struct {
- name string
- clientState *solomachine.ClientState
- prefix exported.Prefix
- proof []byte
- expPass bool
- }{
- {
- "successful verification",
- sm.ClientState(),
- prefix,
- proof,
- true,
- },
- {
- "ApplyPrefix failed",
- sm.ClientState(),
- nil,
- proof,
- false,
- },
- {
- "consensus state in client state is nil",
- solomachine.NewClientState(1, nil, false),
- prefix,
- proof,
- false,
- },
- {
- "client state latest height is less than sequence",
- solomachine.NewClientState(sm.Sequence-1,
- &solomachine.ConsensusState{
- Timestamp: sm.Time,
- PublicKey: sm.ConsensusState().PublicKey,
- }, false),
- prefix,
- proof,
- false,
- },
- {
- "consensus state timestamp is greater than signature",
- solomachine.NewClientState(sm.Sequence,
- &solomachine.ConsensusState{
- Timestamp: sm.Time + 1,
- PublicKey: sm.ConsensusState().PublicKey,
- }, false),
- prefix,
- proof,
- false,
- },
-
- {
- "proof is nil",
- sm.ClientState(),
- prefix,
- nil,
- false,
- },
- {
- "proof verification failed",
- sm.ClientState(),
- prefix,
- suite.GetInvalidProof(),
- false,
- },
- }
-
- for _, tc := range testCases {
- tc := tc
-
- suite.Run(tc.name, func() {
-
- var expSeq uint64
- if tc.clientState.ConsensusState != nil {
- expSeq = tc.clientState.Sequence + 1
- }
-
- // NOTE: to replicate the ordering of connection handshake, we must decrement proof height by 1
- height := clienttypes.NewHeight(sm.GetHeight().GetRevisionNumber(), sm.GetHeight().GetRevisionHeight()-2)
-
- err := tc.clientState.VerifyClientConsensusState(
- suite.store, suite.chainA.Codec, height, counterpartyClientIdentifier, consensusHeight, tc.prefix, tc.proof, consensusState,
- )
-
- if tc.expPass {
- suite.Require().NoError(err)
- suite.Require().Equal(expSeq, tc.clientState.Sequence)
- suite.Require().Equal(expSeq, suite.GetSequenceFromStore(), "sequence not updated in the store (%d) on valid test case %s", suite.GetSequenceFromStore(), tc.name)
- } else {
- suite.Require().Error(err)
- }
- })
- }
- }
-}
-
-func (suite *SoloMachineTestSuite) TestVerifyConnectionState() {
- counterparty := connectiontypes.NewCounterparty("clientB", testConnectionID, *prefix)
- conn := connectiontypes.NewConnectionEnd(connectiontypes.OPEN, "clientA", counterparty, connectiontypes.ExportedVersionsToProto(connectiontypes.GetCompatibleVersions()), 0)
-
- path := suite.solomachine.GetConnectionStatePath(testConnectionID)
-
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- value, err := solomachine.ConnectionStateSignBytes(suite.chainA.Codec, sm.Sequence, sm.Time, sm.Diversifier, path, conn)
- suite.Require().NoError(err)
-
- sig := sm.GenerateSignature(value)
- signatureDoc := &solomachine.TimestampedSignatureData{
- SignatureData: sig,
- Timestamp: sm.Time,
- }
-
- proof, err := suite.chainA.Codec.Marshal(signatureDoc)
- suite.Require().NoError(err)
-
- testCases := []struct {
- name string
- clientState *solomachine.ClientState
- prefix exported.Prefix
- proof []byte
- expPass bool
- }{
- {
- "successful verification",
- sm.ClientState(),
- prefix,
- proof,
- true,
- },
- {
- "ApplyPrefix failed",
- sm.ClientState(),
- commitmenttypes.NewMerklePrefix([]byte{}),
- proof,
- false,
- },
- {
- "proof is nil",
- sm.ClientState(),
- prefix,
- nil,
- false,
- },
- {
- "proof verification failed",
- sm.ClientState(),
- prefix,
- suite.GetInvalidProof(),
- false,
- },
- }
-
- for i, tc := range testCases {
- tc := tc
-
- expSeq := tc.clientState.Sequence + 1
-
- err := tc.clientState.VerifyConnectionState(
- suite.store, suite.chainA.Codec, sm.GetHeight(), tc.prefix, tc.proof, testConnectionID, conn,
- )
-
- if tc.expPass {
- suite.Require().NoError(err, "valid test case %d failed: %s", i, tc.name)
- suite.Require().Equal(expSeq, tc.clientState.Sequence)
- suite.Require().Equal(expSeq, suite.GetSequenceFromStore(), "sequence not updated in the store (%d) on valid test case %d: %s", suite.GetSequenceFromStore(), i, tc.name)
- } else {
- suite.Require().Error(err, "invalid test case %d passed: %s", i, tc.name)
- }
- }
- }
-}
-
-func (suite *SoloMachineTestSuite) TestVerifyChannelState() {
- counterparty := channeltypes.NewCounterparty(testPortID, testChannelID)
- ch := channeltypes.NewChannel(channeltypes.OPEN, channeltypes.ORDERED, counterparty, []string{testConnectionID}, "1.0.0")
-
- path := suite.solomachine.GetChannelStatePath(testPortID, testChannelID)
-
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- value, err := solomachine.ChannelStateSignBytes(suite.chainA.Codec, sm.Sequence, sm.Time, sm.Diversifier, path, ch)
- suite.Require().NoError(err)
-
- sig := sm.GenerateSignature(value)
- signatureDoc := &solomachine.TimestampedSignatureData{
- SignatureData: sig,
- Timestamp: sm.Time,
- }
-
- proof, err := suite.chainA.Codec.Marshal(signatureDoc)
- suite.Require().NoError(err)
-
- testCases := []struct {
- name string
- clientState *solomachine.ClientState
- prefix exported.Prefix
- proof []byte
- expPass bool
- }{
- {
- "successful verification",
- sm.ClientState(),
- prefix,
- proof,
- true,
- },
- {
- "ApplyPrefix failed",
- sm.ClientState(),
- nil,
- proof,
- false,
- },
- {
- "proof is nil",
- sm.ClientState(),
- prefix,
- nil,
- false,
- },
- {
- "proof verification failed",
- sm.ClientState(),
- prefix,
- suite.GetInvalidProof(),
- false,
- },
- }
-
- for i, tc := range testCases {
- tc := tc
-
- expSeq := tc.clientState.Sequence + 1
-
- err := tc.clientState.VerifyChannelState(
- suite.store, suite.chainA.Codec, sm.GetHeight(), tc.prefix, tc.proof, testPortID, testChannelID, ch,
- )
-
- if tc.expPass {
- suite.Require().NoError(err, "valid test case %d failed: %s", i, tc.name)
- suite.Require().Equal(expSeq, tc.clientState.Sequence)
- suite.Require().Equal(expSeq, suite.GetSequenceFromStore(), "sequence not updated in the store (%d) on valid test case %d: %s", suite.GetSequenceFromStore(), i, tc.name)
- } else {
- suite.Require().Error(err, "invalid test case %d passed: %s", i, tc.name)
- }
- }
- }
-}
-
-func (suite *SoloMachineTestSuite) TestVerifyPacketCommitment() {
- commitmentBytes := []byte("COMMITMENT BYTES")
-
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- path := sm.GetPacketCommitmentPath(testPortID, testChannelID)
-
- value, err := solomachine.PacketCommitmentSignBytes(suite.chainA.Codec, sm.Sequence, sm.Time, sm.Diversifier, path, commitmentBytes)
- suite.Require().NoError(err)
-
- sig := sm.GenerateSignature(value)
- signatureDoc := &solomachine.TimestampedSignatureData{
- SignatureData: sig,
- Timestamp: sm.Time,
- }
-
- proof, err := suite.chainA.Codec.Marshal(signatureDoc)
- suite.Require().NoError(err)
-
- testCases := []struct {
- name string
- clientState *solomachine.ClientState
- prefix exported.Prefix
- proof []byte
- expPass bool
- }{
- {
- "successful verification",
- sm.ClientState(),
- prefix,
- proof,
- true,
- },
- {
- "ApplyPrefix failed",
- sm.ClientState(),
- commitmenttypes.NewMerklePrefix([]byte{}),
- proof,
- false,
- },
- {
- "proof is nil",
- sm.ClientState(),
- prefix,
- nil,
- false,
- },
- {
- "proof verification failed",
- sm.ClientState(),
- prefix,
- suite.GetInvalidProof(),
- false,
- },
- }
-
- for i, tc := range testCases {
- tc := tc
-
- expSeq := tc.clientState.Sequence + 1
- ctx := suite.chainA.GetContext()
-
- err := tc.clientState.VerifyPacketCommitment(
- ctx, suite.store, suite.chainA.Codec, sm.GetHeight(), 0, 0, tc.prefix, tc.proof, testPortID, testChannelID, sm.Sequence, commitmentBytes,
- )
-
- if tc.expPass {
- suite.Require().NoError(err, "valid test case %d failed: %s", i, tc.name)
- suite.Require().Equal(expSeq, suite.GetSequenceFromStore(), "sequence not updated in the store (%d) on valid test case %d: %s", suite.GetSequenceFromStore(), i, tc.name)
- } else {
- suite.Require().Error(err, "invalid test case %d passed: %s", i, tc.name)
- }
- }
- }
-}
-
-func (suite *SoloMachineTestSuite) TestVerifyPacketAcknowledgement() {
- ack := []byte("ACK")
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- path := sm.GetPacketAcknowledgementPath(testPortID, testChannelID)
-
- value, err := solomachine.PacketAcknowledgementSignBytes(suite.chainA.Codec, sm.Sequence, sm.Time, sm.Diversifier, path, ack)
- suite.Require().NoError(err)
-
- sig := sm.GenerateSignature(value)
- signatureDoc := &solomachine.TimestampedSignatureData{
- SignatureData: sig,
- Timestamp: sm.Time,
- }
-
- proof, err := suite.chainA.Codec.Marshal(signatureDoc)
- suite.Require().NoError(err)
-
- testCases := []struct {
- name string
- clientState *solomachine.ClientState
- prefix exported.Prefix
- proof []byte
- expPass bool
- }{
- {
- "successful verification",
- sm.ClientState(),
- prefix,
- proof,
- true,
- },
- {
- "ApplyPrefix failed",
- sm.ClientState(),
- commitmenttypes.NewMerklePrefix([]byte{}),
- proof,
- false,
- },
- {
- "proof is nil",
- sm.ClientState(),
- prefix,
- nil,
- false,
- },
- {
- "proof verification failed",
- sm.ClientState(),
- prefix,
- suite.GetInvalidProof(),
- false,
- },
- }
-
- for i, tc := range testCases {
- tc := tc
-
- expSeq := tc.clientState.Sequence + 1
- ctx := suite.chainA.GetContext()
-
- err := tc.clientState.VerifyPacketAcknowledgement(
- ctx, suite.store, suite.chainA.Codec, sm.GetHeight(), 0, 0, tc.prefix, tc.proof, testPortID, testChannelID, sm.Sequence, ack,
- )
-
- if tc.expPass {
- suite.Require().NoError(err, "valid test case %d failed: %s", i, tc.name)
- suite.Require().Equal(expSeq, suite.GetSequenceFromStore(), "sequence not updated in the store (%d) on valid test case %d: %s", suite.GetSequenceFromStore(), i, tc.name)
- } else {
- suite.Require().Error(err, "invalid test case %d passed: %s", i, tc.name)
- }
- }
- }
-}
-
-func (suite *SoloMachineTestSuite) TestVerifyPacketReceiptAbsence() {
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- // absence uses receipt path as well
- path := sm.GetPacketReceiptPath(testPortID, testChannelID)
-
- value, err := solomachine.PacketReceiptAbsenceSignBytes(suite.chainA.Codec, sm.Sequence, sm.Time, sm.Diversifier, path)
- suite.Require().NoError(err)
-
- sig := sm.GenerateSignature(value)
- signatureDoc := &solomachine.TimestampedSignatureData{
- SignatureData: sig,
- Timestamp: sm.Time,
- }
-
- proof, err := suite.chainA.Codec.Marshal(signatureDoc)
- suite.Require().NoError(err)
-
- testCases := []struct {
- name string
- clientState *solomachine.ClientState
- prefix exported.Prefix
- proof []byte
- expPass bool
- }{
- {
- "successful verification",
- sm.ClientState(),
- prefix,
- proof,
- true,
- },
- {
- "ApplyPrefix failed",
- sm.ClientState(),
- commitmenttypes.NewMerklePrefix([]byte{}),
- proof,
- false,
- },
- {
- "proof is nil",
- sm.ClientState(),
- prefix,
- nil,
- false,
- },
- {
- "proof verification failed",
- sm.ClientState(),
- prefix,
- suite.GetInvalidProof(),
- false,
- },
- }
-
- for i, tc := range testCases {
- tc := tc
-
- expSeq := tc.clientState.Sequence + 1
- ctx := suite.chainA.GetContext()
-
- err := tc.clientState.VerifyPacketReceiptAbsence(
- ctx, suite.store, suite.chainA.Codec, sm.GetHeight(), 0, 0, tc.prefix, tc.proof, testPortID, testChannelID, sm.Sequence,
- )
-
- if tc.expPass {
- suite.Require().NoError(err, "valid test case %d failed: %s", i, tc.name)
- suite.Require().Equal(expSeq, suite.GetSequenceFromStore(), "sequence not updated in the store (%d) on valid test case %d: %s", suite.GetSequenceFromStore(), i, tc.name)
- } else {
- suite.Require().Error(err, "invalid test case %d passed: %s", i, tc.name)
- }
- }
- }
-}
-
-func (suite *SoloMachineTestSuite) TestVerifyNextSeqRecv() {
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- nextSeqRecv := sm.Sequence + 1
- path := sm.GetNextSequenceRecvPath(testPortID, testChannelID)
-
- value, err := solomachine.NextSequenceRecvSignBytes(suite.chainA.Codec, sm.Sequence, sm.Time, sm.Diversifier, path, nextSeqRecv)
- suite.Require().NoError(err)
-
- sig := sm.GenerateSignature(value)
- signatureDoc := &solomachine.TimestampedSignatureData{
- SignatureData: sig,
- Timestamp: sm.Time,
- }
-
- proof, err := suite.chainA.Codec.Marshal(signatureDoc)
- suite.Require().NoError(err)
-
- testCases := []struct {
- name string
- clientState *solomachine.ClientState
- prefix exported.Prefix
- proof []byte
- expPass bool
- }{
- {
- "successful verification",
- sm.ClientState(),
- prefix,
- proof,
- true,
- },
- {
- "ApplyPrefix failed",
- sm.ClientState(),
- commitmenttypes.NewMerklePrefix([]byte{}),
- proof,
- false,
- },
- {
- "proof is nil",
- sm.ClientState(),
- prefix,
- nil,
- false,
- },
- {
- "proof verification failed",
- sm.ClientState(),
- prefix,
- suite.GetInvalidProof(),
- false,
- },
- }
-
- for i, tc := range testCases {
- tc := tc
-
- expSeq := tc.clientState.Sequence + 1
- ctx := suite.chainA.GetContext()
-
- err := tc.clientState.VerifyNextSequenceRecv(
- ctx, suite.store, suite.chainA.Codec, sm.GetHeight(), 0, 0, tc.prefix, tc.proof, testPortID, testChannelID, nextSeqRecv,
- )
-
- if tc.expPass {
- suite.Require().NoError(err, "valid test case %d failed: %s", i, tc.name)
- suite.Require().Equal(expSeq, tc.clientState.Sequence)
- suite.Require().Equal(expSeq, suite.GetSequenceFromStore(), "sequence not updated in the store (%d) on valid test case %d: %s", suite.GetSequenceFromStore(), i, tc.name)
- } else {
- suite.Require().Error(err, "invalid test case %d passed: %s", i, tc.name)
- }
- }
- }
-}
-
func (suite *SoloMachineTestSuite) TestGetTimestampAtHeight() {
tmPath := ibctesting.NewPath(suite.chainA, suite.chainB)
suite.coordinator.SetupClients(tmPath)
diff --git a/modules/light-clients/06-solomachine/codec.go b/modules/light-clients/06-solomachine/codec.go
index a857433ed56..ed040d7b2c2 100644
--- a/modules/light-clients/06-solomachine/codec.go
+++ b/modules/light-clients/06-solomachine/codec.go
@@ -6,7 +6,6 @@ import (
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/types/tx/signing"
- clienttypes "github.com/cosmos/ibc-go/v3/modules/core/02-client/types"
"github.com/cosmos/ibc-go/v3/modules/core/exported"
)
@@ -41,91 +40,3 @@ func UnmarshalSignatureData(cdc codec.BinaryCodec, data []byte) (signing.Signatu
return sigData, nil
}
-
-// UnmarshalDataByType attempts to unmarshal the data to the specified type. An error is
-// return if it fails.
-func UnmarshalDataByType(cdc codec.BinaryCodec, dataType DataType, data []byte) (Data, error) {
- if len(data) == 0 {
- return nil, sdkerrors.Wrap(ErrInvalidSignatureAndData, "data cannot be empty")
- }
-
- switch dataType {
- case UNSPECIFIED:
- return nil, sdkerrors.Wrap(ErrInvalidDataType, "data type cannot be UNSPECIFIED")
-
- case CLIENT:
- clientData := &ClientStateData{}
- if err := cdc.Unmarshal(data, clientData); err != nil {
- return nil, err
- }
-
- // unpack any
- if _, err := clienttypes.UnpackClientState(clientData.ClientState); err != nil {
- return nil, err
- }
- return clientData, nil
-
- case CONSENSUS:
- consensusData := &ConsensusStateData{}
- if err := cdc.Unmarshal(data, consensusData); err != nil {
- return nil, err
- }
-
- // unpack any
- if _, err := clienttypes.UnpackConsensusState(consensusData.ConsensusState); err != nil {
- return nil, err
- }
- return consensusData, nil
-
- case CONNECTION:
- connectionData := &ConnectionStateData{}
- if err := cdc.Unmarshal(data, connectionData); err != nil {
- return nil, err
- }
-
- return connectionData, nil
-
- case CHANNEL:
- channelData := &ChannelStateData{}
- if err := cdc.Unmarshal(data, channelData); err != nil {
- return nil, err
- }
-
- return channelData, nil
-
- case PACKETCOMMITMENT:
- commitmentData := &PacketCommitmentData{}
- if err := cdc.Unmarshal(data, commitmentData); err != nil {
- return nil, err
- }
-
- return commitmentData, nil
-
- case PACKETACKNOWLEDGEMENT:
- ackData := &PacketAcknowledgementData{}
- if err := cdc.Unmarshal(data, ackData); err != nil {
- return nil, err
- }
-
- return ackData, nil
-
- case PACKETRECEIPTABSENCE:
- receiptAbsenceData := &PacketReceiptAbsenceData{}
- if err := cdc.Unmarshal(data, receiptAbsenceData); err != nil {
- return nil, err
- }
-
- return receiptAbsenceData, nil
-
- case NEXTSEQUENCERECV:
- nextSeqRecvData := &NextSequenceRecvData{}
- if err := cdc.Unmarshal(data, nextSeqRecvData); err != nil {
- return nil, err
- }
-
- return nextSeqRecvData, nil
-
- default:
- return nil, sdkerrors.Wrapf(ErrInvalidDataType, "unsupported data type %T", dataType)
- }
-}
diff --git a/modules/light-clients/06-solomachine/codec_test.go b/modules/light-clients/06-solomachine/codec_test.go
deleted file mode 100644
index ff7d5084043..00000000000
--- a/modules/light-clients/06-solomachine/codec_test.go
+++ /dev/null
@@ -1,190 +0,0 @@
-package solomachine_test
-
-import (
- clienttypes "github.com/cosmos/ibc-go/v3/modules/core/02-client/types"
- connectiontypes "github.com/cosmos/ibc-go/v3/modules/core/03-connection/types"
- channeltypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
- solomachine "github.com/cosmos/ibc-go/v3/modules/light-clients/06-solomachine"
- ibctesting "github.com/cosmos/ibc-go/v3/testing"
-)
-
-func (suite SoloMachineTestSuite) TestUnmarshalDataByType() {
- var (
- data []byte
- err error
- )
-
- // test singlesig and multisig public keys
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
-
- cdc := suite.chainA.App.AppCodec()
- cases := []struct {
- name string
- dataType solomachine.DataType
- malleate func()
- expPass bool
- }{
- {
- "empty data", solomachine.CLIENT, func() {
- data = []byte{}
- }, false,
- },
- {
- "unspecified", solomachine.UNSPECIFIED, func() {
- path := sm.GetClientStatePath(counterpartyClientIdentifier)
- data, err = solomachine.ClientStateDataBytes(cdc, path, sm.ClientState())
- suite.Require().NoError(err)
- }, false,
- },
- {
- "client", solomachine.CLIENT, func() {
- path := sm.GetClientStatePath(counterpartyClientIdentifier)
- data, err = solomachine.ClientStateDataBytes(cdc, path, sm.ClientState())
- suite.Require().NoError(err)
- }, true,
- },
- {
- "bad client (provides consensus state data)", solomachine.CLIENT, func() {
- path := sm.GetConsensusStatePath(counterpartyClientIdentifier, clienttypes.NewHeight(0, 5))
- data, err = solomachine.ConsensusStateDataBytes(cdc, path, sm.ConsensusState())
- suite.Require().NoError(err)
- }, false,
- },
- {
- "consensus", solomachine.CONSENSUS, func() {
- path := sm.GetConsensusStatePath(counterpartyClientIdentifier, clienttypes.NewHeight(0, 5))
- data, err = solomachine.ConsensusStateDataBytes(cdc, path, sm.ConsensusState())
- suite.Require().NoError(err)
-
- }, true,
- },
- {
- "bad consensus (provides client state data)", solomachine.CONSENSUS, func() {
- path := sm.GetClientStatePath(counterpartyClientIdentifier)
- data, err = solomachine.ClientStateDataBytes(cdc, path, sm.ClientState())
- suite.Require().NoError(err)
- }, false,
- },
- {
- "connection", solomachine.CONNECTION, func() {
- counterparty := connectiontypes.NewCounterparty("clientB", testConnectionID, *prefix)
- conn := connectiontypes.NewConnectionEnd(connectiontypes.OPEN, "clientA", counterparty, connectiontypes.ExportedVersionsToProto(connectiontypes.GetCompatibleVersions()), 0)
- path := sm.GetConnectionStatePath("connectionID")
-
- data, err = solomachine.ConnectionStateDataBytes(cdc, path, conn)
- suite.Require().NoError(err)
-
- }, true,
- },
- {
- "bad connection (uses channel data)", solomachine.CONNECTION, func() {
- counterparty := channeltypes.NewCounterparty(testPortID, testChannelID)
- ch := channeltypes.NewChannel(channeltypes.OPEN, channeltypes.ORDERED, counterparty, []string{testConnectionID}, "1.0.0")
- path := sm.GetChannelStatePath("portID", "channelID")
-
- data, err = solomachine.ChannelStateDataBytes(cdc, path, ch)
- suite.Require().NoError(err)
- }, false,
- },
- {
- "channel", solomachine.CHANNEL, func() {
- counterparty := channeltypes.NewCounterparty(testPortID, testChannelID)
- ch := channeltypes.NewChannel(channeltypes.OPEN, channeltypes.ORDERED, counterparty, []string{testConnectionID}, "1.0.0")
- path := sm.GetChannelStatePath("portID", "channelID")
-
- data, err = solomachine.ChannelStateDataBytes(cdc, path, ch)
- suite.Require().NoError(err)
- }, true,
- },
- {
- "bad channel (uses connection data)", solomachine.CHANNEL, func() {
- counterparty := connectiontypes.NewCounterparty("clientB", testConnectionID, *prefix)
- conn := connectiontypes.NewConnectionEnd(connectiontypes.OPEN, "clientA", counterparty, connectiontypes.ExportedVersionsToProto(connectiontypes.GetCompatibleVersions()), 0)
- path := sm.GetConnectionStatePath("connectionID")
-
- data, err = solomachine.ConnectionStateDataBytes(cdc, path, conn)
- suite.Require().NoError(err)
-
- }, false,
- },
- {
- "packet commitment", solomachine.PACKETCOMMITMENT, func() {
- commitment := []byte("packet commitment")
- path := sm.GetPacketCommitmentPath("portID", "channelID")
-
- data, err = solomachine.PacketCommitmentDataBytes(cdc, path, commitment)
- suite.Require().NoError(err)
- }, true,
- },
- {
- "bad packet commitment (uses next seq recv)", solomachine.PACKETCOMMITMENT, func() {
- path := sm.GetNextSequenceRecvPath("portID", "channelID")
-
- data, err = solomachine.NextSequenceRecvDataBytes(cdc, path, 10)
- suite.Require().NoError(err)
- }, false,
- },
- {
- "packet acknowledgement", solomachine.PACKETACKNOWLEDGEMENT, func() {
- commitment := []byte("packet acknowledgement")
- path := sm.GetPacketAcknowledgementPath("portID", "channelID")
-
- data, err = solomachine.PacketAcknowledgementDataBytes(cdc, path, commitment)
- suite.Require().NoError(err)
- }, true,
- },
- {
- "bad packet acknowledgement (uses next sequence recv)", solomachine.PACKETACKNOWLEDGEMENT, func() {
- path := sm.GetNextSequenceRecvPath("portID", "channelID")
-
- data, err = solomachine.NextSequenceRecvDataBytes(cdc, path, 10)
- suite.Require().NoError(err)
- }, false,
- },
- {
- "packet acknowledgement absence", solomachine.PACKETRECEIPTABSENCE, func() {
- path := sm.GetPacketReceiptPath("portID", "channelID")
-
- data, err = solomachine.PacketReceiptAbsenceDataBytes(cdc, path)
- suite.Require().NoError(err)
- }, true,
- },
- {
- "next sequence recv", solomachine.NEXTSEQUENCERECV, func() {
- path := sm.GetNextSequenceRecvPath("portID", "channelID")
-
- data, err = solomachine.NextSequenceRecvDataBytes(cdc, path, 10)
- suite.Require().NoError(err)
- }, true,
- },
- {
- "bad next sequence recv (uses packet commitment)", solomachine.NEXTSEQUENCERECV, func() {
- commitment := []byte("packet commitment")
- path := sm.GetPacketCommitmentPath("portID", "channelID")
-
- data, err = solomachine.PacketCommitmentDataBytes(cdc, path, commitment)
- suite.Require().NoError(err)
- }, false,
- },
- }
-
- for _, tc := range cases {
- tc := tc
-
- suite.Run(tc.name, func() {
- tc.malleate()
-
- data, err := solomachine.UnmarshalDataByType(cdc, tc.dataType, data)
-
- if tc.expPass {
- suite.Require().NoError(err)
- suite.Require().NotNil(data)
- } else {
- suite.Require().Error(err)
- suite.Require().Nil(data)
- }
- })
- }
- }
-
-}
diff --git a/modules/light-clients/06-solomachine/errors.go b/modules/light-clients/06-solomachine/errors.go
index 73ca5999dbc..7f41349337d 100644
--- a/modules/light-clients/06-solomachine/errors.go
+++ b/modules/light-clients/06-solomachine/errors.go
@@ -14,5 +14,4 @@ var (
ErrInvalidSignatureAndData = sdkerrors.Register(SubModuleName, 4, "invalid signature and data")
ErrSignatureVerificationFailed = sdkerrors.Register(SubModuleName, 5, "signature verification failed")
ErrInvalidProof = sdkerrors.Register(SubModuleName, 6, "invalid solo machine proof")
- ErrInvalidDataType = sdkerrors.Register(SubModuleName, 7, "invalid data type")
)
diff --git a/modules/light-clients/06-solomachine/misbehaviour.go b/modules/light-clients/06-solomachine/misbehaviour.go
index e9e8bdd0803..1d1a5060a95 100644
--- a/modules/light-clients/06-solomachine/misbehaviour.go
+++ b/modules/light-clients/06-solomachine/misbehaviour.go
@@ -53,24 +53,6 @@ func (misbehaviour Misbehaviour) ValidateBasic() error {
return nil
}
-// ValidateBasic ensures that the signature and data fields are non-empty.
-func (sd SignatureAndData) ValidateBasic() error {
- if len(sd.Signature) == 0 {
- return sdkerrors.Wrap(ErrInvalidSignatureAndData, "signature cannot be empty")
- }
- if len(sd.Data) == 0 {
- return sdkerrors.Wrap(ErrInvalidSignatureAndData, "data for signature cannot be empty")
- }
- if sd.DataType == UNSPECIFIED {
- return sdkerrors.Wrap(ErrInvalidSignatureAndData, "data type cannot be UNSPECIFIED")
- }
- if sd.Timestamp == 0 {
- return sdkerrors.Wrap(ErrInvalidSignatureAndData, "timestamp cannot be 0")
- }
-
- return nil
-}
-
// ValidateBasic ensures that the signature and data fields are non-empty.
func (sd SignatureAndDataV2) ValidateBasic() error {
if len(sd.Signature) == 0 {
diff --git a/modules/light-clients/06-solomachine/proof.go b/modules/light-clients/06-solomachine/proof.go
index cdbd8f19983..386830340cf 100644
--- a/modules/light-clients/06-solomachine/proof.go
+++ b/modules/light-clients/06-solomachine/proof.go
@@ -1,17 +1,10 @@
package solomachine
import (
- "github.com/cosmos/cosmos-sdk/codec"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
"github.com/cosmos/cosmos-sdk/crypto/types/multisig"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/types/tx/signing"
-
- clienttypes "github.com/cosmos/ibc-go/v3/modules/core/02-client/types"
- connectiontypes "github.com/cosmos/ibc-go/v3/modules/core/03-connection/types"
- channeltypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
- commitmenttypes "github.com/cosmos/ibc-go/v3/modules/core/23-commitment/types"
- "github.com/cosmos/ibc-go/v3/modules/core/exported"
)
// VerifySignature verifies if the the provided public key generated the signature
@@ -48,429 +41,3 @@ func VerifySignature(pubKey cryptotypes.PubKey, signBytes []byte, sigData signin
return nil
}
-
-// MisbehaviourSignBytes returns the sign bytes for verification of misbehaviour.
-func MisbehaviourSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- dataType DataType,
- data []byte) ([]byte, error) {
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: dataType,
- Data: data,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// HeaderSignBytes returns the sign bytes for verification of misbehaviour.
-func HeaderSignBytes(
- cdc codec.BinaryCodec,
- header *Header,
-) ([]byte, error) {
- data := &HeaderData{
- NewPubKey: header.NewPublicKey,
- NewDiversifier: header.NewDiversifier,
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: header.Sequence,
- Timestamp: header.Timestamp,
- Diversifier: header.NewDiversifier,
- DataType: HEADER,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// ClientStateSignBytes returns the sign bytes for verification of the
-// client state.
-func ClientStateSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- path commitmenttypes.MerklePath,
- clientState exported.ClientState,
-) ([]byte, error) {
- dataBz, err := ClientStateDataBytes(cdc, path, clientState)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: CLIENT,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// ClientStateDataBytes returns the client state data bytes used in constructing
-// SignBytes.
-func ClientStateDataBytes(
- cdc codec.BinaryCodec,
- path commitmenttypes.MerklePath, // nolint: interfacer
- clientState exported.ClientState,
-) ([]byte, error) {
- any, err := clienttypes.PackClientState(clientState)
- if err != nil {
- return nil, err
- }
-
- data := &ClientStateData{
- Path: []byte(path.String()),
- ClientState: any,
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- return dataBz, nil
-}
-
-// ConsensusStateSignBytes returns the sign bytes for verification of the
-// consensus state.
-func ConsensusStateSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- path commitmenttypes.MerklePath,
- consensusState exported.ConsensusState,
-) ([]byte, error) {
- dataBz, err := ConsensusStateDataBytes(cdc, path, consensusState)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: CONSENSUS,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// ConsensusStateDataBytes returns the consensus state data bytes used in constructing
-// SignBytes.
-func ConsensusStateDataBytes(
- cdc codec.BinaryCodec,
- path commitmenttypes.MerklePath, // nolint: interfacer
- consensusState exported.ConsensusState,
-) ([]byte, error) {
- any, err := clienttypes.PackConsensusState(consensusState)
- if err != nil {
- return nil, err
- }
-
- data := &ConsensusStateData{
- Path: []byte(path.String()),
- ConsensusState: any,
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- return dataBz, nil
-}
-
-// ConnectionStateSignBytes returns the sign bytes for verification of the
-// connection state.
-func ConnectionStateSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- path commitmenttypes.MerklePath,
- connectionEnd exported.ConnectionI,
-) ([]byte, error) {
- dataBz, err := ConnectionStateDataBytes(cdc, path, connectionEnd)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: CONNECTION,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// ConnectionStateDataBytes returns the connection state data bytes used in constructing
-// SignBytes.
-func ConnectionStateDataBytes(
- cdc codec.BinaryCodec,
- path commitmenttypes.MerklePath, // nolint: interfacer
- connectionEnd exported.ConnectionI,
-) ([]byte, error) {
- connection, ok := connectionEnd.(connectiontypes.ConnectionEnd)
- if !ok {
- return nil, sdkerrors.Wrapf(
- connectiontypes.ErrInvalidConnection,
- "expected type %T, got %T", connectiontypes.ConnectionEnd{}, connectionEnd,
- )
- }
-
- data := &ConnectionStateData{
- Path: []byte(path.String()),
- Connection: &connection,
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- return dataBz, nil
-}
-
-// ChannelStateSignBytes returns the sign bytes for verification of the
-// channel state.
-func ChannelStateSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- path commitmenttypes.MerklePath,
- channelEnd exported.ChannelI,
-) ([]byte, error) {
- dataBz, err := ChannelStateDataBytes(cdc, path, channelEnd)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: CHANNEL,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// ChannelStateDataBytes returns the channel state data bytes used in constructing
-// SignBytes.
-func ChannelStateDataBytes(
- cdc codec.BinaryCodec,
- path commitmenttypes.MerklePath, // nolint: interfacer
- channelEnd exported.ChannelI,
-) ([]byte, error) {
- channel, ok := channelEnd.(channeltypes.Channel)
- if !ok {
- return nil, sdkerrors.Wrapf(
- channeltypes.ErrInvalidChannel,
- "expected channel type %T, got %T", channeltypes.Channel{}, channelEnd)
- }
-
- data := &ChannelStateData{
- Path: []byte(path.String()),
- Channel: &channel,
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- return dataBz, nil
-}
-
-// PacketCommitmentSignBytes returns the sign bytes for verification of the
-// packet commitment.
-func PacketCommitmentSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- path commitmenttypes.MerklePath,
- commitmentBytes []byte,
-) ([]byte, error) {
- dataBz, err := PacketCommitmentDataBytes(cdc, path, commitmentBytes)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: PACKETCOMMITMENT,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// PacketCommitmentDataBytes returns the packet commitment data bytes used in constructing
-// SignBytes.
-func PacketCommitmentDataBytes(
- cdc codec.BinaryCodec,
- path commitmenttypes.MerklePath, // nolint: interfacer
- commitmentBytes []byte,
-) ([]byte, error) {
- data := &PacketCommitmentData{
- Path: []byte(path.String()),
- Commitment: commitmentBytes,
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- return dataBz, nil
-}
-
-// PacketAcknowledgementSignBytes returns the sign bytes for verification of
-// the acknowledgement.
-func PacketAcknowledgementSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- path commitmenttypes.MerklePath,
- acknowledgement []byte,
-) ([]byte, error) {
- dataBz, err := PacketAcknowledgementDataBytes(cdc, path, acknowledgement)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: PACKETACKNOWLEDGEMENT,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// PacketAcknowledgementDataBytes returns the packet acknowledgement data bytes used in constructing
-// SignBytes.
-func PacketAcknowledgementDataBytes(
- cdc codec.BinaryCodec,
- path commitmenttypes.MerklePath, // nolint: interfacer
- acknowledgement []byte,
-) ([]byte, error) {
- data := &PacketAcknowledgementData{
- Path: []byte(path.String()),
- Acknowledgement: acknowledgement,
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- return dataBz, nil
-}
-
-// PacketReceiptAbsenceSignBytes returns the sign bytes for verification
-// of the absence of an receipt.
-func PacketReceiptAbsenceSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- path commitmenttypes.MerklePath,
-) ([]byte, error) {
- dataBz, err := PacketReceiptAbsenceDataBytes(cdc, path)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: PACKETRECEIPTABSENCE,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// PacketReceiptAbsenceDataBytes returns the packet receipt absence data bytes
-// used in constructing SignBytes.
-func PacketReceiptAbsenceDataBytes(
- cdc codec.BinaryCodec,
- path commitmenttypes.MerklePath, // nolint: interfacer
-) ([]byte, error) {
- data := &PacketReceiptAbsenceData{
- Path: []byte(path.String()),
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- return dataBz, nil
-}
-
-// NextSequenceRecvSignBytes returns the sign bytes for verification of the next
-// sequence to be received.
-func NextSequenceRecvSignBytes(
- cdc codec.BinaryCodec,
- sequence, timestamp uint64,
- diversifier string,
- path commitmenttypes.MerklePath,
- nextSequenceRecv uint64,
-) ([]byte, error) {
- dataBz, err := NextSequenceRecvDataBytes(cdc, path, nextSequenceRecv)
- if err != nil {
- return nil, err
- }
-
- signBytes := &SignBytes{
- Sequence: sequence,
- Timestamp: timestamp,
- Diversifier: diversifier,
- DataType: NEXTSEQUENCERECV,
- Data: dataBz,
- }
-
- return cdc.Marshal(signBytes)
-}
-
-// NextSequenceRecvDataBytes returns the next sequence recv data bytes used in constructing
-// SignBytes.
-func NextSequenceRecvDataBytes(
- cdc codec.BinaryCodec,
- path commitmenttypes.MerklePath, // nolint: interfacer
- nextSequenceRecv uint64,
-) ([]byte, error) {
- data := &NextSequenceRecvData{
- Path: []byte(path.String()),
- NextSeqRecv: nextSequenceRecv,
- }
-
- dataBz, err := cdc.Marshal(data)
- if err != nil {
- return nil, err
- }
-
- return dataBz, nil
-}
diff --git a/modules/light-clients/06-solomachine/proof_test.go b/modules/light-clients/06-solomachine/proof_test.go
index dd7bb52ec1e..0ea96ee4116 100644
--- a/modules/light-clients/06-solomachine/proof_test.go
+++ b/modules/light-clients/06-solomachine/proof_test.go
@@ -5,7 +5,6 @@ import (
"github.com/cosmos/cosmos-sdk/types/tx/signing"
solomachine "github.com/cosmos/ibc-go/v3/modules/light-clients/06-solomachine"
- ibctesting "github.com/cosmos/ibc-go/v3/testing"
)
func (suite *SoloMachineTestSuite) TestVerifySignature() {
@@ -66,37 +65,3 @@ func (suite *SoloMachineTestSuite) TestVerifySignature() {
})
}
}
-
-func (suite *SoloMachineTestSuite) TestClientStateSignBytes() {
- cdc := suite.chainA.App.AppCodec()
-
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
- // success
- path := sm.GetClientStatePath(counterpartyClientIdentifier)
- bz, err := solomachine.ClientStateSignBytes(cdc, sm.Sequence, sm.Time, sm.Diversifier, path, sm.ClientState())
- suite.Require().NoError(err)
- suite.Require().NotNil(bz)
-
- // nil client state
- bz, err = solomachine.ClientStateSignBytes(cdc, sm.Sequence, sm.Time, sm.Diversifier, path, nil)
- suite.Require().Error(err)
- suite.Require().Nil(bz)
- }
-}
-
-func (suite *SoloMachineTestSuite) TestConsensusStateSignBytes() {
- cdc := suite.chainA.App.AppCodec()
-
- for _, sm := range []*ibctesting.Solomachine{suite.solomachine, suite.solomachineMulti} {
- // success
- path := sm.GetConsensusStatePath(counterpartyClientIdentifier, consensusHeight)
- bz, err := solomachine.ConsensusStateSignBytes(cdc, sm.Sequence, sm.Time, sm.Diversifier, path, sm.ConsensusState())
- suite.Require().NoError(err)
- suite.Require().NotNil(bz)
-
- // nil consensus state
- bz, err = solomachine.ConsensusStateSignBytes(cdc, sm.Sequence, sm.Time, sm.Diversifier, path, nil)
- suite.Require().Error(err)
- suite.Require().Nil(bz)
- }
-}
diff --git a/modules/light-clients/06-solomachine/solomachine.go b/modules/light-clients/06-solomachine/solomachine.go
index e3d58781ea8..41511910bf4 100644
--- a/modules/light-clients/06-solomachine/solomachine.go
+++ b/modules/light-clients/06-solomachine/solomachine.go
@@ -3,8 +3,6 @@ package solomachine
import (
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
-
- "github.com/cosmos/ibc-go/v3/modules/core/exported"
)
// Interface implementation checks.
@@ -32,13 +30,3 @@ func (h Header) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
func (hd HeaderData) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
return unpacker.UnpackAny(hd.NewPubKey, new(cryptotypes.PubKey))
}
-
-// UnpackInterfaces implements the UnpackInterfaceMessages.UnpackInterfaces method
-func (csd ClientStateData) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
- return unpacker.UnpackAny(csd.ClientState, new(exported.ClientState))
-}
-
-// UnpackInterfaces implements the UnpackInterfaceMessages.UnpackInterfaces method
-func (csd ConsensusStateData) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
- return unpacker.UnpackAny(csd.ConsensusState, new(exported.ConsensusState))
-}
diff --git a/modules/light-clients/06-solomachine/solomachine.pb.go b/modules/light-clients/06-solomachine/solomachine.pb.go
index a43dac24b16..0ea56245a5e 100644
--- a/modules/light-clients/06-solomachine/solomachine.pb.go
+++ b/modules/light-clients/06-solomachine/solomachine.pb.go
@@ -6,8 +6,6 @@ package solomachine
import (
fmt "fmt"
types "github.com/cosmos/cosmos-sdk/codec/types"
- types1 "github.com/cosmos/ibc-go/v3/modules/core/03-connection/types"
- types2 "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
@@ -26,67 +24,6 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-// DataType defines the type of solo machine proof being created. This is done
-// to preserve uniqueness of different data sign byte encodings.
-type DataType int32
-
-const (
- // Default State
- UNSPECIFIED DataType = 0
- // Data type for client state verification
- CLIENT DataType = 1
- // Data type for consensus state verification
- CONSENSUS DataType = 2
- // Data type for connection state verification
- CONNECTION DataType = 3
- // Data type for channel state verification
- CHANNEL DataType = 4
- // Data type for packet commitment verification
- PACKETCOMMITMENT DataType = 5
- // Data type for packet acknowledgement verification
- PACKETACKNOWLEDGEMENT DataType = 6
- // Data type for packet receipt absence verification
- PACKETRECEIPTABSENCE DataType = 7
- // Data type for next sequence recv verification
- NEXTSEQUENCERECV DataType = 8
- // Data type for header verification
- HEADER DataType = 9
-)
-
-var DataType_name = map[int32]string{
- 0: "DATA_TYPE_UNINITIALIZED_UNSPECIFIED",
- 1: "DATA_TYPE_CLIENT_STATE",
- 2: "DATA_TYPE_CONSENSUS_STATE",
- 3: "DATA_TYPE_CONNECTION_STATE",
- 4: "DATA_TYPE_CHANNEL_STATE",
- 5: "DATA_TYPE_PACKET_COMMITMENT",
- 6: "DATA_TYPE_PACKET_ACKNOWLEDGEMENT",
- 7: "DATA_TYPE_PACKET_RECEIPT_ABSENCE",
- 8: "DATA_TYPE_NEXT_SEQUENCE_RECV",
- 9: "DATA_TYPE_HEADER",
-}
-
-var DataType_value = map[string]int32{
- "DATA_TYPE_UNINITIALIZED_UNSPECIFIED": 0,
- "DATA_TYPE_CLIENT_STATE": 1,
- "DATA_TYPE_CONSENSUS_STATE": 2,
- "DATA_TYPE_CONNECTION_STATE": 3,
- "DATA_TYPE_CHANNEL_STATE": 4,
- "DATA_TYPE_PACKET_COMMITMENT": 5,
- "DATA_TYPE_PACKET_ACKNOWLEDGEMENT": 6,
- "DATA_TYPE_PACKET_RECEIPT_ABSENCE": 7,
- "DATA_TYPE_NEXT_SEQUENCE_RECV": 8,
- "DATA_TYPE_HEADER": 9,
-}
-
-func (x DataType) String() string {
- return proto.EnumName(DataType_name, int32(x))
-}
-
-func (DataType) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{0}
-}
-
// ClientState defines a solo machine client that tracks the current consensus
// state and if the client is frozen.
type ClientState struct {
@@ -265,48 +202,6 @@ func (m *Misbehaviour) XXX_DiscardUnknown() {
var xxx_messageInfo_Misbehaviour proto.InternalMessageInfo
-// SignatureAndData contains a signature and the data signed over to create that
-// signature.
-type SignatureAndData struct {
- Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
- DataType DataType `protobuf:"varint,2,opt,name=data_type,json=dataType,proto3,enum=ibc.lightclients.solomachine.v2.DataType" json:"data_type,omitempty" yaml:"data_type"`
- Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
- Timestamp uint64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
-}
-
-func (m *SignatureAndData) Reset() { *m = SignatureAndData{} }
-func (m *SignatureAndData) String() string { return proto.CompactTextString(m) }
-func (*SignatureAndData) ProtoMessage() {}
-func (*SignatureAndData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{4}
-}
-func (m *SignatureAndData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *SignatureAndData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_SignatureAndData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *SignatureAndData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_SignatureAndData.Merge(m, src)
-}
-func (m *SignatureAndData) XXX_Size() int {
- return m.Size()
-}
-func (m *SignatureAndData) XXX_DiscardUnknown() {
- xxx_messageInfo_SignatureAndData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SignatureAndData proto.InternalMessageInfo
-
// SignatureAndDataV2 contains a signature and the data signed over to create that
// signature.
type SignatureAndDataV2 struct {
@@ -320,7 +215,7 @@ func (m *SignatureAndDataV2) Reset() { *m = SignatureAndDataV2{} }
func (m *SignatureAndDataV2) String() string { return proto.CompactTextString(m) }
func (*SignatureAndDataV2) ProtoMessage() {}
func (*SignatureAndDataV2) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{5}
+ return fileDescriptor_141333b361aae010, []int{4}
}
func (m *SignatureAndDataV2) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -360,7 +255,7 @@ func (m *TimestampedSignatureData) Reset() { *m = TimestampedSignatureDa
func (m *TimestampedSignatureData) String() string { return proto.CompactTextString(m) }
func (*TimestampedSignatureData) ProtoMessage() {}
func (*TimestampedSignatureData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{6}
+ return fileDescriptor_141333b361aae010, []int{5}
}
func (m *TimestampedSignatureData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -407,7 +302,7 @@ func (m *SignBytesV2) Reset() { *m = SignBytesV2{} }
func (m *SignBytesV2) String() string { return proto.CompactTextString(m) }
func (*SignBytesV2) ProtoMessage() {}
func (*SignBytesV2) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{7}
+ return fileDescriptor_141333b361aae010, []int{6}
}
func (m *SignBytesV2) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -436,50 +331,6 @@ func (m *SignBytesV2) XXX_DiscardUnknown() {
var xxx_messageInfo_SignBytesV2 proto.InternalMessageInfo
-// SignBytes defines the signed bytes used for signature verification.
-type SignBytes struct {
- Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
- Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
- Diversifier string `protobuf:"bytes,3,opt,name=diversifier,proto3" json:"diversifier,omitempty"`
- // type of the data used
- DataType DataType `protobuf:"varint,4,opt,name=data_type,json=dataType,proto3,enum=ibc.lightclients.solomachine.v2.DataType" json:"data_type,omitempty" yaml:"data_type"`
- // marshaled data
- Data []byte `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
-}
-
-func (m *SignBytes) Reset() { *m = SignBytes{} }
-func (m *SignBytes) String() string { return proto.CompactTextString(m) }
-func (*SignBytes) ProtoMessage() {}
-func (*SignBytes) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{8}
-}
-func (m *SignBytes) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *SignBytes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_SignBytes.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *SignBytes) XXX_Merge(src proto.Message) {
- xxx_messageInfo_SignBytes.Merge(m, src)
-}
-func (m *SignBytes) XXX_Size() int {
- return m.Size()
-}
-func (m *SignBytes) XXX_DiscardUnknown() {
- xxx_messageInfo_SignBytes.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SignBytes proto.InternalMessageInfo
-
// HeaderData returns the SignBytes data for update verification.
type HeaderData struct {
// header public key
@@ -492,7 +343,7 @@ func (m *HeaderData) Reset() { *m = HeaderData{} }
func (m *HeaderData) String() string { return proto.CompactTextString(m) }
func (*HeaderData) ProtoMessage() {}
func (*HeaderData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{9}
+ return fileDescriptor_141333b361aae010, []int{7}
}
func (m *HeaderData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -521,583 +372,166 @@ func (m *HeaderData) XXX_DiscardUnknown() {
var xxx_messageInfo_HeaderData proto.InternalMessageInfo
-// ClientStateData returns the SignBytes data for client state verification.
-type ClientStateData struct {
- Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
- ClientState *types.Any `protobuf:"bytes,2,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty" yaml:"client_state"`
+func init() {
+ proto.RegisterType((*ClientState)(nil), "ibc.lightclients.solomachine.v2.ClientState")
+ proto.RegisterType((*ConsensusState)(nil), "ibc.lightclients.solomachine.v2.ConsensusState")
+ proto.RegisterType((*Header)(nil), "ibc.lightclients.solomachine.v2.Header")
+ proto.RegisterType((*Misbehaviour)(nil), "ibc.lightclients.solomachine.v2.Misbehaviour")
+ proto.RegisterType((*SignatureAndDataV2)(nil), "ibc.lightclients.solomachine.v2.SignatureAndDataV2")
+ proto.RegisterType((*TimestampedSignatureData)(nil), "ibc.lightclients.solomachine.v2.TimestampedSignatureData")
+ proto.RegisterType((*SignBytesV2)(nil), "ibc.lightclients.solomachine.v2.SignBytesV2")
+ proto.RegisterType((*HeaderData)(nil), "ibc.lightclients.solomachine.v2.HeaderData")
}
-func (m *ClientStateData) Reset() { *m = ClientStateData{} }
-func (m *ClientStateData) String() string { return proto.CompactTextString(m) }
-func (*ClientStateData) ProtoMessage() {}
-func (*ClientStateData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{10}
-}
-func (m *ClientStateData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *ClientStateData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_ClientStateData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *ClientStateData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ClientStateData.Merge(m, src)
-}
-func (m *ClientStateData) XXX_Size() int {
- return m.Size()
-}
-func (m *ClientStateData) XXX_DiscardUnknown() {
- xxx_messageInfo_ClientStateData.DiscardUnknown(m)
+func init() {
+ proto.RegisterFile("ibc/lightclients/solomachine/v2/solomachine.proto", fileDescriptor_141333b361aae010)
}
-var xxx_messageInfo_ClientStateData proto.InternalMessageInfo
-
-// ConsensusStateData returns the SignBytes data for consensus state
-// verification.
-type ConsensusStateData struct {
- Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
- ConsensusState *types.Any `protobuf:"bytes,2,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty" yaml:"consensus_state"`
+var fileDescriptor_141333b361aae010 = []byte{
+ // 790 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x3d, 0x6f, 0xdb, 0x46,
+ 0x18, 0x16, 0x69, 0xda, 0x90, 0x4e, 0xaa, 0xdc, 0x12, 0xb2, 0x41, 0xab, 0x85, 0x28, 0x70, 0x28,
+ 0xbc, 0x98, 0xac, 0x25, 0xa0, 0x83, 0xbb, 0xd4, 0xb2, 0x51, 0xf4, 0xc3, 0x45, 0x0d, 0xfa, 0x63,
+ 0xe8, 0x42, 0x1c, 0xc9, 0x13, 0x75, 0x28, 0xc5, 0x53, 0x79, 0x47, 0x09, 0xca, 0x10, 0x04, 0x99,
+ 0x32, 0x66, 0xcb, 0x1a, 0x04, 0xc8, 0xef, 0xc8, 0x9a, 0x25, 0x80, 0xc7, 0x4c, 0x42, 0x60, 0xff,
+ 0x03, 0xfd, 0x82, 0x80, 0x47, 0x4a, 0x24, 0x65, 0xc7, 0x06, 0x92, 0x6c, 0x77, 0xef, 0xe7, 0xf3,
+ 0x3e, 0xf7, 0xbc, 0x24, 0xd8, 0xc7, 0xb6, 0x63, 0xf8, 0xd8, 0x1b, 0x30, 0xc7, 0xc7, 0x28, 0x60,
+ 0xd4, 0xa0, 0xc4, 0x27, 0x43, 0xe8, 0x0c, 0x70, 0x80, 0x8c, 0x71, 0x27, 0x7f, 0xd5, 0x47, 0x21,
+ 0x61, 0x44, 0x56, 0xb1, 0xed, 0xe8, 0xf9, 0x14, 0x3d, 0x1f, 0x33, 0xee, 0x34, 0x1b, 0x1e, 0xf1,
+ 0x08, 0x8f, 0x35, 0xe2, 0x53, 0x92, 0xd6, 0xdc, 0xf1, 0x08, 0xf1, 0x7c, 0x64, 0xf0, 0x9b, 0x1d,
+ 0xf5, 0x0d, 0x18, 0x4c, 0x13, 0x97, 0xf6, 0x46, 0x04, 0xd5, 0x23, 0x5e, 0xeb, 0x8c, 0x41, 0x86,
+ 0xe4, 0x26, 0x28, 0x53, 0xf4, 0x7f, 0x84, 0x02, 0x07, 0x29, 0x42, 0x5b, 0xd8, 0x95, 0xcc, 0xe5,
+ 0x5d, 0xde, 0x07, 0x15, 0x4c, 0xad, 0x7e, 0x48, 0x1e, 0xa1, 0x40, 0x11, 0xdb, 0xc2, 0x6e, 0xb9,
+ 0xd7, 0x98, 0xcf, 0xd4, 0x6f, 0xa7, 0x70, 0xe8, 0x1f, 0x68, 0x4b, 0x97, 0x66, 0x96, 0x31, 0xfd,
+ 0x8d, 0x1f, 0x65, 0x06, 0x36, 0x1d, 0x12, 0x50, 0x14, 0xd0, 0x88, 0x5a, 0x34, 0xee, 0xa0, 0xac,
+ 0xb5, 0x85, 0xdd, 0x6a, 0xc7, 0xd0, 0x1f, 0x18, 0x45, 0x3f, 0x5a, 0xe4, 0x71, 0x60, 0xbd, 0xe6,
+ 0x7c, 0xa6, 0x6e, 0x27, 0x9d, 0x56, 0x2a, 0x6a, 0x66, 0xdd, 0x29, 0xc4, 0xca, 0x08, 0x7c, 0x0f,
+ 0x7d, 0x9f, 0x4c, 0xac, 0x68, 0xe4, 0x42, 0x86, 0x2c, 0xd8, 0x67, 0x28, 0xb4, 0x46, 0x21, 0x19,
+ 0x11, 0x0a, 0x7d, 0x45, 0xe2, 0xd0, 0x7f, 0x9c, 0xcf, 0x54, 0x2d, 0x29, 0x78, 0x4f, 0xb0, 0x66,
+ 0x2a, 0xdc, 0x7b, 0xc1, 0x9d, 0x87, 0xb1, 0xef, 0x34, 0x75, 0x1d, 0x48, 0xcf, 0x5e, 0xaa, 0x25,
+ 0xed, 0x95, 0x00, 0xea, 0x45, 0xac, 0xf2, 0x9f, 0x00, 0x8c, 0x22, 0xdb, 0xc7, 0x8e, 0xf5, 0x1f,
+ 0x9a, 0x72, 0x1a, 0xab, 0x9d, 0x86, 0x9e, 0x3c, 0x82, 0xbe, 0x78, 0x04, 0xfd, 0x30, 0x98, 0xf6,
+ 0xb6, 0xe6, 0x33, 0xf5, 0xbb, 0x04, 0x44, 0x96, 0xa1, 0x99, 0x95, 0xe4, 0xf2, 0x17, 0x9a, 0xca,
+ 0x6d, 0x50, 0x75, 0xf1, 0x18, 0x85, 0x14, 0xf7, 0x31, 0x0a, 0x39, 0xed, 0x15, 0x33, 0x6f, 0x92,
+ 0x7f, 0x00, 0x15, 0x86, 0x87, 0x88, 0x32, 0x38, 0x1c, 0x71, 0x76, 0x25, 0x33, 0x33, 0xa4, 0x20,
+ 0x9f, 0x8a, 0x60, 0xe3, 0x77, 0x04, 0x5d, 0x14, 0xde, 0xfb, 0xc2, 0x85, 0x52, 0xe2, 0x4a, 0xa9,
+ 0xd8, 0x4b, 0xb1, 0x17, 0x40, 0x16, 0x85, 0xc9, 0x33, 0xd6, 0xcc, 0xcc, 0x20, 0x5f, 0x80, 0x7a,
+ 0x80, 0x26, 0x56, 0x6e, 0x70, 0xe9, 0x9e, 0xc1, 0x77, 0xe6, 0x33, 0x75, 0x2b, 0x19, 0xbc, 0x98,
+ 0xa5, 0x99, 0xb5, 0x00, 0x4d, 0x4e, 0x97, 0xf3, 0x1f, 0x81, 0xcd, 0x38, 0x20, 0xcf, 0xc1, 0x7a,
+ 0xcc, 0x41, 0x5e, 0x10, 0x2b, 0x01, 0x9a, 0x19, 0x23, 0x39, 0xce, 0x0c, 0x29, 0x09, 0xef, 0x44,
+ 0x50, 0xfb, 0x1b, 0x53, 0x1b, 0x0d, 0xe0, 0x18, 0x93, 0x28, 0x94, 0xbb, 0xa0, 0x92, 0x88, 0xcf,
+ 0xc2, 0x2e, 0xe7, 0xa2, 0xd2, 0xdb, 0xce, 0x04, 0xbd, 0x74, 0x69, 0x8a, 0x60, 0x96, 0x93, 0xdb,
+ 0x1f, 0x6e, 0x81, 0x3f, 0x71, 0x85, 0xbf, 0x10, 0x7c, 0xb3, 0x24, 0xc4, 0x22, 0xc1, 0x42, 0xec,
+ 0xdd, 0x07, 0xc5, 0x7e, 0xb6, 0xc8, 0x3a, 0x0c, 0xdc, 0x63, 0xc8, 0xe0, 0x65, 0xa7, 0xa7, 0xcc,
+ 0x67, 0x6a, 0x23, 0x41, 0x52, 0xa8, 0xa9, 0x99, 0xb5, 0xe5, 0xfd, 0x9f, 0x60, 0xa5, 0x27, 0x9b,
+ 0x90, 0x94, 0xf6, 0xaf, 0xd7, 0x93, 0x4d, 0x48, 0xbe, 0xe7, 0xf9, 0x84, 0xa4, 0x7c, 0x3e, 0x06,
+ 0xf2, 0xed, 0x1a, 0x45, 0x95, 0x08, 0xab, 0x2a, 0x91, 0x81, 0x34, 0x82, 0x6c, 0xc0, 0x99, 0xab,
+ 0x99, 0xfc, 0x1c, 0xdb, 0x5c, 0xc8, 0x60, 0x2a, 0x29, 0x7e, 0x2e, 0x2a, 0x51, 0xba, 0x5b, 0xd4,
+ 0x4f, 0x04, 0xa0, 0x9c, 0x2f, 0x6c, 0xc8, 0x5d, 0x62, 0x89, 0x81, 0xc8, 0xbf, 0x82, 0x7a, 0x36,
+ 0x02, 0x2f, 0xcf, 0xb1, 0xe4, 0x85, 0x57, 0xf4, 0x6b, 0x66, 0xc6, 0xe3, 0xf1, 0x2d, 0x08, 0xe2,
+ 0xdd, 0x10, 0x5e, 0x08, 0xa0, 0x1a, 0xf7, 0xed, 0x4d, 0x19, 0xa2, 0x97, 0x9d, 0x2f, 0x58, 0xae,
+ 0x95, 0x3d, 0x5f, 0xbb, 0xbd, 0xe7, 0x0b, 0xea, 0xa4, 0x3b, 0xa8, 0x5b, 0xcf, 0xa8, 0x4b, 0x91,
+ 0xbd, 0x16, 0x00, 0x48, 0x36, 0x9e, 0x0f, 0x73, 0x02, 0xaa, 0xe9, 0x9e, 0x3d, 0xf8, 0x4d, 0x8a,
+ 0x57, 0x40, 0x2e, 0xac, 0x66, 0xfa, 0x51, 0x4a, 0xf6, 0xf2, 0x13, 0x4b, 0x29, 0x7e, 0xde, 0x52,
+ 0xf6, 0xfa, 0x6f, 0xaf, 0x5b, 0xc2, 0xd5, 0x75, 0x4b, 0xf8, 0x70, 0xdd, 0x12, 0x9e, 0xdf, 0xb4,
+ 0x4a, 0x57, 0x37, 0xad, 0xd2, 0xfb, 0x9b, 0x56, 0xe9, 0xdf, 0x13, 0x0f, 0xb3, 0x41, 0x64, 0xeb,
+ 0x0e, 0x19, 0x1a, 0x0e, 0xa1, 0x43, 0x42, 0x0d, 0x6c, 0x3b, 0x7b, 0x1e, 0x31, 0xc6, 0x5d, 0x63,
+ 0x48, 0xdc, 0xc8, 0x47, 0x34, 0xf9, 0x7f, 0xee, 0x2d, 0x7e, 0xa0, 0x3f, 0xfd, 0xbc, 0x97, 0x13,
+ 0xf9, 0x2f, 0xb9, 0xb3, 0xbd, 0xc1, 0x67, 0xec, 0x7e, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x9b, 0xf7,
+ 0xe0, 0x5f, 0x76, 0x07, 0x00, 0x00,
}
-func (m *ConsensusStateData) Reset() { *m = ConsensusStateData{} }
-func (m *ConsensusStateData) String() string { return proto.CompactTextString(m) }
-func (*ConsensusStateData) ProtoMessage() {}
-func (*ConsensusStateData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{11}
-}
-func (m *ConsensusStateData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *ConsensusStateData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_ConsensusStateData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
+func (m *ClientState) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
}
-}
-func (m *ConsensusStateData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ConsensusStateData.Merge(m, src)
-}
-func (m *ConsensusStateData) XXX_Size() int {
- return m.Size()
-}
-func (m *ConsensusStateData) XXX_DiscardUnknown() {
- xxx_messageInfo_ConsensusStateData.DiscardUnknown(m)
+ return dAtA[:n], nil
}
-var xxx_messageInfo_ConsensusStateData proto.InternalMessageInfo
-
-// ConnectionStateData returns the SignBytes data for connection state
-// verification.
-type ConnectionStateData struct {
- Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
- Connection *types1.ConnectionEnd `protobuf:"bytes,2,opt,name=connection,proto3" json:"connection,omitempty"`
+func (m *ClientState) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ConnectionStateData) Reset() { *m = ConnectionStateData{} }
-func (m *ConnectionStateData) String() string { return proto.CompactTextString(m) }
-func (*ConnectionStateData) ProtoMessage() {}
-func (*ConnectionStateData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{12}
-}
-func (m *ConnectionStateData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *ConnectionStateData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_ConnectionStateData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
+func (m *ClientState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.AllowUpdateAfterProposal {
+ i--
+ if m.AllowUpdateAfterProposal {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
}
- return b[:n], nil
+ i--
+ dAtA[i] = 0x20
}
-}
-func (m *ConnectionStateData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ConnectionStateData.Merge(m, src)
-}
-func (m *ConnectionStateData) XXX_Size() int {
- return m.Size()
-}
-func (m *ConnectionStateData) XXX_DiscardUnknown() {
- xxx_messageInfo_ConnectionStateData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ConnectionStateData proto.InternalMessageInfo
-
-// ChannelStateData returns the SignBytes data for channel state
-// verification.
-type ChannelStateData struct {
- Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
- Channel *types2.Channel `protobuf:"bytes,2,opt,name=channel,proto3" json:"channel,omitempty"`
-}
-
-func (m *ChannelStateData) Reset() { *m = ChannelStateData{} }
-func (m *ChannelStateData) String() string { return proto.CompactTextString(m) }
-func (*ChannelStateData) ProtoMessage() {}
-func (*ChannelStateData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{13}
-}
-func (m *ChannelStateData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *ChannelStateData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_ChannelStateData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
+ if m.ConsensusState != nil {
+ {
+ size, err := m.ConsensusState.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintSolomachine(dAtA, i, uint64(size))
}
- return b[:n], nil
+ i--
+ dAtA[i] = 0x1a
}
-}
-func (m *ChannelStateData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ChannelStateData.Merge(m, src)
-}
-func (m *ChannelStateData) XXX_Size() int {
- return m.Size()
-}
-func (m *ChannelStateData) XXX_DiscardUnknown() {
- xxx_messageInfo_ChannelStateData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ChannelStateData proto.InternalMessageInfo
-
-// PacketCommitmentData returns the SignBytes data for packet commitment
-// verification.
-type PacketCommitmentData struct {
- Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
- Commitment []byte `protobuf:"bytes,2,opt,name=commitment,proto3" json:"commitment,omitempty"`
-}
-
-func (m *PacketCommitmentData) Reset() { *m = PacketCommitmentData{} }
-func (m *PacketCommitmentData) String() string { return proto.CompactTextString(m) }
-func (*PacketCommitmentData) ProtoMessage() {}
-func (*PacketCommitmentData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{14}
-}
-func (m *PacketCommitmentData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *PacketCommitmentData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_PacketCommitmentData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
+ if m.IsFrozen {
+ i--
+ if m.IsFrozen {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
}
- return b[:n], nil
+ i--
+ dAtA[i] = 0x10
}
-}
-func (m *PacketCommitmentData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PacketCommitmentData.Merge(m, src)
-}
-func (m *PacketCommitmentData) XXX_Size() int {
- return m.Size()
-}
-func (m *PacketCommitmentData) XXX_DiscardUnknown() {
- xxx_messageInfo_PacketCommitmentData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PacketCommitmentData proto.InternalMessageInfo
-
-func (m *PacketCommitmentData) GetPath() []byte {
- if m != nil {
- return m.Path
+ if m.Sequence != 0 {
+ i = encodeVarintSolomachine(dAtA, i, uint64(m.Sequence))
+ i--
+ dAtA[i] = 0x8
}
- return nil
+ return len(dAtA) - i, nil
}
-func (m *PacketCommitmentData) GetCommitment() []byte {
- if m != nil {
- return m.Commitment
+func (m *ConsensusState) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
}
- return nil
+ return dAtA[:n], nil
}
-// PacketAcknowledgementData returns the SignBytes data for acknowledgement
-// verification.
-type PacketAcknowledgementData struct {
- Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
- Acknowledgement []byte `protobuf:"bytes,2,opt,name=acknowledgement,proto3" json:"acknowledgement,omitempty"`
+func (m *ConsensusState) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *PacketAcknowledgementData) Reset() { *m = PacketAcknowledgementData{} }
-func (m *PacketAcknowledgementData) String() string { return proto.CompactTextString(m) }
-func (*PacketAcknowledgementData) ProtoMessage() {}
-func (*PacketAcknowledgementData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{15}
-}
-func (m *PacketAcknowledgementData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *PacketAcknowledgementData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_PacketAcknowledgementData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
+func (m *ConsensusState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Timestamp != 0 {
+ i = encodeVarintSolomachine(dAtA, i, uint64(m.Timestamp))
+ i--
+ dAtA[i] = 0x18
}
-}
-func (m *PacketAcknowledgementData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PacketAcknowledgementData.Merge(m, src)
-}
-func (m *PacketAcknowledgementData) XXX_Size() int {
- return m.Size()
-}
-func (m *PacketAcknowledgementData) XXX_DiscardUnknown() {
- xxx_messageInfo_PacketAcknowledgementData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PacketAcknowledgementData proto.InternalMessageInfo
-
-func (m *PacketAcknowledgementData) GetPath() []byte {
- if m != nil {
- return m.Path
- }
- return nil
-}
-
-func (m *PacketAcknowledgementData) GetAcknowledgement() []byte {
- if m != nil {
- return m.Acknowledgement
- }
- return nil
-}
-
-// PacketReceiptAbsenceData returns the SignBytes data for
-// packet receipt absence verification.
-type PacketReceiptAbsenceData struct {
- Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
-}
-
-func (m *PacketReceiptAbsenceData) Reset() { *m = PacketReceiptAbsenceData{} }
-func (m *PacketReceiptAbsenceData) String() string { return proto.CompactTextString(m) }
-func (*PacketReceiptAbsenceData) ProtoMessage() {}
-func (*PacketReceiptAbsenceData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{16}
-}
-func (m *PacketReceiptAbsenceData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *PacketReceiptAbsenceData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_PacketReceiptAbsenceData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *PacketReceiptAbsenceData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PacketReceiptAbsenceData.Merge(m, src)
-}
-func (m *PacketReceiptAbsenceData) XXX_Size() int {
- return m.Size()
-}
-func (m *PacketReceiptAbsenceData) XXX_DiscardUnknown() {
- xxx_messageInfo_PacketReceiptAbsenceData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PacketReceiptAbsenceData proto.InternalMessageInfo
-
-func (m *PacketReceiptAbsenceData) GetPath() []byte {
- if m != nil {
- return m.Path
- }
- return nil
-}
-
-// NextSequenceRecvData returns the SignBytes data for verification of the next
-// sequence to be received.
-type NextSequenceRecvData struct {
- Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
- NextSeqRecv uint64 `protobuf:"varint,2,opt,name=next_seq_recv,json=nextSeqRecv,proto3" json:"next_seq_recv,omitempty" yaml:"next_seq_recv"`
-}
-
-func (m *NextSequenceRecvData) Reset() { *m = NextSequenceRecvData{} }
-func (m *NextSequenceRecvData) String() string { return proto.CompactTextString(m) }
-func (*NextSequenceRecvData) ProtoMessage() {}
-func (*NextSequenceRecvData) Descriptor() ([]byte, []int) {
- return fileDescriptor_141333b361aae010, []int{17}
-}
-func (m *NextSequenceRecvData) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *NextSequenceRecvData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_NextSequenceRecvData.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *NextSequenceRecvData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NextSequenceRecvData.Merge(m, src)
-}
-func (m *NextSequenceRecvData) XXX_Size() int {
- return m.Size()
-}
-func (m *NextSequenceRecvData) XXX_DiscardUnknown() {
- xxx_messageInfo_NextSequenceRecvData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NextSequenceRecvData proto.InternalMessageInfo
-
-func (m *NextSequenceRecvData) GetPath() []byte {
- if m != nil {
- return m.Path
- }
- return nil
-}
-
-func (m *NextSequenceRecvData) GetNextSeqRecv() uint64 {
- if m != nil {
- return m.NextSeqRecv
- }
- return 0
-}
-
-func init() {
- proto.RegisterEnum("ibc.lightclients.solomachine.v2.DataType", DataType_name, DataType_value)
- proto.RegisterType((*ClientState)(nil), "ibc.lightclients.solomachine.v2.ClientState")
- proto.RegisterType((*ConsensusState)(nil), "ibc.lightclients.solomachine.v2.ConsensusState")
- proto.RegisterType((*Header)(nil), "ibc.lightclients.solomachine.v2.Header")
- proto.RegisterType((*Misbehaviour)(nil), "ibc.lightclients.solomachine.v2.Misbehaviour")
- proto.RegisterType((*SignatureAndData)(nil), "ibc.lightclients.solomachine.v2.SignatureAndData")
- proto.RegisterType((*SignatureAndDataV2)(nil), "ibc.lightclients.solomachine.v2.SignatureAndDataV2")
- proto.RegisterType((*TimestampedSignatureData)(nil), "ibc.lightclients.solomachine.v2.TimestampedSignatureData")
- proto.RegisterType((*SignBytesV2)(nil), "ibc.lightclients.solomachine.v2.SignBytesV2")
- proto.RegisterType((*SignBytes)(nil), "ibc.lightclients.solomachine.v2.SignBytes")
- proto.RegisterType((*HeaderData)(nil), "ibc.lightclients.solomachine.v2.HeaderData")
- proto.RegisterType((*ClientStateData)(nil), "ibc.lightclients.solomachine.v2.ClientStateData")
- proto.RegisterType((*ConsensusStateData)(nil), "ibc.lightclients.solomachine.v2.ConsensusStateData")
- proto.RegisterType((*ConnectionStateData)(nil), "ibc.lightclients.solomachine.v2.ConnectionStateData")
- proto.RegisterType((*ChannelStateData)(nil), "ibc.lightclients.solomachine.v2.ChannelStateData")
- proto.RegisterType((*PacketCommitmentData)(nil), "ibc.lightclients.solomachine.v2.PacketCommitmentData")
- proto.RegisterType((*PacketAcknowledgementData)(nil), "ibc.lightclients.solomachine.v2.PacketAcknowledgementData")
- proto.RegisterType((*PacketReceiptAbsenceData)(nil), "ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData")
- proto.RegisterType((*NextSequenceRecvData)(nil), "ibc.lightclients.solomachine.v2.NextSequenceRecvData")
-}
-
-func init() {
- proto.RegisterFile("ibc/lightclients/solomachine/v2/solomachine.proto", fileDescriptor_141333b361aae010)
-}
-
-var fileDescriptor_141333b361aae010 = []byte{
- // 1412 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xdf, 0x6f, 0xdb, 0xd4,
- 0x17, 0xaf, 0xb3, 0xac, 0x6b, 0x4e, 0xba, 0x36, 0x5f, 0x2f, 0xdb, 0x52, 0x6f, 0x4a, 0xfc, 0x35,
- 0x62, 0x14, 0xc4, 0x12, 0xda, 0x8a, 0x09, 0x0d, 0x04, 0x38, 0x8e, 0xc7, 0xb2, 0xb5, 0x6e, 0x70,
- 0xdc, 0xc1, 0x26, 0x24, 0xcb, 0x71, 0x6e, 0x53, 0x6b, 0x89, 0x6f, 0x16, 0x3b, 0xe9, 0x82, 0x04,
- 0x42, 0x3c, 0x8d, 0x88, 0x07, 0xde, 0x78, 0x8a, 0x84, 0x40, 0xfc, 0x1d, 0xbc, 0x21, 0x5e, 0x90,
- 0xf6, 0xc8, 0x53, 0x40, 0xdb, 0x7f, 0x90, 0xbf, 0x00, 0xd9, 0xf7, 0x26, 0xb6, 0xd3, 0x36, 0x15,
- 0x83, 0xbd, 0xdd, 0x7b, 0x7e, 0x7c, 0xce, 0xe7, 0x9e, 0x7b, 0x7c, 0xee, 0x31, 0x6c, 0x58, 0x35,
- 0xb3, 0xd0, 0xb4, 0x1a, 0x07, 0xae, 0xd9, 0xb4, 0x90, 0xed, 0x3a, 0x05, 0x07, 0x37, 0x71, 0xcb,
- 0x30, 0x0f, 0x2c, 0x1b, 0x15, 0x7a, 0x9b, 0xe1, 0x6d, 0xbe, 0xdd, 0xc1, 0x2e, 0x66, 0x73, 0x56,
- 0xcd, 0xcc, 0x87, 0x5d, 0xf2, 0x61, 0x9b, 0xde, 0x26, 0xf7, 0x9a, 0x87, 0x69, 0xe2, 0x0e, 0x2a,
- 0x98, 0xd8, 0xb6, 0x91, 0xe9, 0x5a, 0xd8, 0x2e, 0xf4, 0x36, 0x42, 0x3b, 0x82, 0xc4, 0xfd, 0x3f,
- 0x30, 0x3c, 0x30, 0x6c, 0x1b, 0x35, 0x7d, 0x2b, 0xb2, 0xa4, 0x26, 0xe9, 0x06, 0x6e, 0x60, 0x7f,
- 0x59, 0xf0, 0x56, 0x54, 0xba, 0xd6, 0xc0, 0xb8, 0xd1, 0x44, 0x05, 0x7f, 0x57, 0xeb, 0xee, 0x17,
- 0x0c, 0xbb, 0x4f, 0x54, 0xc2, 0x2f, 0x31, 0x48, 0x4a, 0x3e, 0xaf, 0xaa, 0x6b, 0xb8, 0x88, 0xe5,
- 0x60, 0xc9, 0x41, 0x8f, 0xba, 0xc8, 0x36, 0x51, 0x86, 0xe1, 0x99, 0xf5, 0xb8, 0x3a, 0xdd, 0xb3,
- 0x1b, 0x90, 0xb0, 0x1c, 0x7d, 0xbf, 0x83, 0x3f, 0x47, 0x76, 0x26, 0xc6, 0x33, 0xeb, 0x4b, 0xc5,
- 0xf4, 0x78, 0x94, 0x4b, 0xf5, 0x8d, 0x56, 0xf3, 0xa6, 0x30, 0x55, 0x09, 0xea, 0x92, 0xe5, 0xdc,
- 0xf2, 0x97, 0xac, 0x0b, 0xab, 0x26, 0xb6, 0x1d, 0x64, 0x3b, 0x5d, 0x47, 0x77, 0xbc, 0x08, 0x99,
- 0x33, 0x3c, 0xb3, 0x9e, 0xdc, 0x2c, 0xe4, 0x4f, 0x49, 0x4b, 0x5e, 0x9a, 0xf8, 0xf9, 0xc4, 0x8a,
- 0xdc, 0x78, 0x94, 0xbb, 0x44, 0x22, 0xcd, 0x20, 0x0a, 0xea, 0x8a, 0x19, 0xb1, 0x65, 0x11, 0x5c,
- 0x31, 0x9a, 0x4d, 0x7c, 0xa8, 0x77, 0xdb, 0x75, 0xc3, 0x45, 0xba, 0xb1, 0xef, 0xa2, 0x8e, 0xde,
- 0xee, 0xe0, 0x36, 0x76, 0x8c, 0x66, 0x26, 0xee, 0x53, 0xbf, 0x36, 0x1e, 0xe5, 0x04, 0x02, 0x38,
- 0xc7, 0x58, 0x50, 0x33, 0xbe, 0x76, 0xcf, 0x57, 0x8a, 0x9e, 0xae, 0x42, 0x55, 0x37, 0xe3, 0x4f,
- 0x7e, 0xc8, 0x2d, 0x08, 0x3f, 0x32, 0xb0, 0x12, 0xe5, 0xca, 0xde, 0x01, 0x68, 0x77, 0x6b, 0x4d,
- 0xcb, 0xd4, 0x1f, 0xa2, 0xbe, 0x9f, 0xc6, 0xe4, 0x66, 0x3a, 0x4f, 0x2e, 0x21, 0x3f, 0xb9, 0x84,
- 0xbc, 0x68, 0xf7, 0x8b, 0x17, 0xc7, 0xa3, 0xdc, 0xff, 0x08, 0x89, 0xc0, 0x43, 0x50, 0x13, 0x64,
- 0x73, 0x17, 0xf5, 0x59, 0x1e, 0x92, 0x75, 0xab, 0x87, 0x3a, 0x8e, 0xb5, 0x6f, 0xa1, 0x8e, 0x9f,
- 0xf6, 0x84, 0x1a, 0x16, 0xb1, 0x57, 0x21, 0xe1, 0x5a, 0x2d, 0xe4, 0xb8, 0x46, 0xab, 0xed, 0x67,
- 0x37, 0xae, 0x06, 0x02, 0x4a, 0xf2, 0xeb, 0x18, 0x2c, 0xde, 0x46, 0x46, 0x1d, 0x75, 0xe6, 0xde,
- 0x70, 0x04, 0x2a, 0x36, 0x03, 0xe5, 0x69, 0x1d, 0xab, 0x61, 0x1b, 0x6e, 0xb7, 0x43, 0xae, 0x71,
- 0x59, 0x0d, 0x04, 0xec, 0x1e, 0xac, 0xd8, 0xe8, 0x50, 0x0f, 0x1d, 0x3c, 0x3e, 0xe7, 0xe0, 0x6b,
- 0xe3, 0x51, 0xee, 0x22, 0x39, 0x78, 0xd4, 0x4b, 0x50, 0x97, 0x6d, 0x74, 0x58, 0x99, 0x9e, 0x5f,
- 0x82, 0x55, 0xcf, 0x20, 0x9c, 0x83, 0xb3, 0x5e, 0x0e, 0xc2, 0x05, 0x31, 0x63, 0x20, 0xa8, 0x1e,
- 0x93, 0x52, 0x20, 0xa0, 0x49, 0xf8, 0x3d, 0x06, 0xcb, 0x3b, 0x96, 0x53, 0x43, 0x07, 0x46, 0xcf,
- 0xc2, 0xdd, 0x0e, 0xbb, 0x05, 0x09, 0x52, 0x7c, 0xba, 0x55, 0xf7, 0x73, 0x91, 0x28, 0x5e, 0x0a,
- 0x0a, 0x7a, 0xaa, 0x12, 0x32, 0x8c, 0xba, 0x44, 0x76, 0xe5, 0x7a, 0x24, 0x7f, 0xb1, 0x99, 0xfc,
- 0x75, 0xe0, 0xfc, 0x34, 0x21, 0x3a, 0xb6, 0x27, 0xc5, 0xbe, 0x75, 0x6a, 0xb1, 0x57, 0x27, 0x5e,
- 0xa2, 0x5d, 0x2f, 0x19, 0xae, 0x71, 0x6f, 0xb3, 0x98, 0x19, 0x8f, 0x72, 0x69, 0xc2, 0x24, 0x82,
- 0x29, 0xa8, 0xcb, 0xd3, 0xfd, 0xae, 0x3d, 0x13, 0xd3, 0x3d, 0xc4, 0x34, 0xed, 0xff, 0x5d, 0x4c,
- 0xf7, 0x10, 0x87, 0x63, 0x6a, 0x87, 0x98, 0xe6, 0xf3, 0x57, 0x06, 0x52, 0xb3, 0x20, 0xd1, 0x22,
- 0x61, 0x66, 0x8b, 0xe4, 0x33, 0x48, 0xd4, 0x0d, 0xd7, 0xd0, 0xdd, 0x7e, 0x9b, 0x64, 0x6f, 0x65,
- 0xf3, 0xf5, 0x53, 0x89, 0x7a, 0xb8, 0x5a, 0xbf, 0x8d, 0xc2, 0xdd, 0x66, 0x8a, 0x22, 0xa8, 0x4b,
- 0x75, 0xaa, 0x67, 0x59, 0x88, 0x7b, 0x6b, 0x5a, 0x9b, 0xfe, 0x3a, 0x5a, 0xd2, 0xf1, 0xe3, 0xbf,
- 0x8e, 0x2f, 0x81, 0x3d, 0x9a, 0x8c, 0x53, 0x4e, 0xc2, 0x42, 0xbc, 0x6d, 0xb8, 0x07, 0xfe, 0x21,
- 0x96, 0x55, 0x7f, 0xfd, 0xc2, 0xf1, 0xbf, 0x62, 0x20, 0xa3, 0x4d, 0x64, 0xa8, 0x3e, 0xe5, 0xe2,
- 0x27, 0xf4, 0x43, 0x58, 0x09, 0xee, 0xc2, 0x87, 0xf7, 0xb9, 0x84, 0xbf, 0xa0, 0xa8, 0x5e, 0x50,
- 0x83, 0x82, 0x28, 0x1d, 0xa1, 0x10, 0x3b, 0x9e, 0xc2, 0xf7, 0x0c, 0x24, 0xbd, 0xb8, 0xc5, 0xbe,
- 0x8b, 0x9c, 0x7b, 0x9b, 0xff, 0xa2, 0x4b, 0xcc, 0x34, 0xac, 0x33, 0x47, 0x1b, 0xd6, 0x24, 0x75,
- 0xf1, 0x63, 0x52, 0x77, 0x36, 0x48, 0x1d, 0x65, 0xf6, 0x27, 0x03, 0x89, 0x29, 0xb3, 0x97, 0xca,
- 0x2b, 0x52, 0x9c, 0xf1, 0x97, 0x55, 0x9c, 0x47, 0x4f, 0xf8, 0x33, 0x03, 0x40, 0x9a, 0xb3, 0x7f,
- 0x5d, 0xdb, 0x90, 0xa4, 0x2d, 0xf1, 0xd4, 0xe7, 0xc3, 0xeb, 0x56, 0x6c, 0xa4, 0x8b, 0xd2, 0xf7,
- 0x83, 0xb4, 0xd0, 0x13, 0xfa, 0x67, 0xec, 0x05, 0xfb, 0xe7, 0x17, 0xb0, 0x1a, 0x1a, 0x15, 0x7c,
- 0xae, 0x93, 0xab, 0x64, 0x42, 0x57, 0x59, 0x81, 0x65, 0xda, 0x3a, 0xc9, 0x83, 0x1f, 0x9b, 0x73,
- 0x80, 0xcb, 0xe3, 0x51, 0xee, 0x42, 0xa4, 0xdd, 0xd2, 0x27, 0x3d, 0x69, 0x06, 0x91, 0x68, 0xf8,
- 0x6f, 0x18, 0x60, 0xa3, 0x0f, 0xed, 0x89, 0x14, 0xee, 0x1f, 0x1d, 0x3b, 0xe6, 0xb1, 0xf8, 0x07,
- 0xb3, 0x05, 0xe5, 0xd2, 0x83, 0x0b, 0xd2, 0x74, 0x3c, 0x9b, 0xcf, 0x45, 0x06, 0x08, 0x26, 0x39,
- 0x4a, 0xe3, 0x55, 0xbf, 0xac, 0xbc, 0x51, 0x2e, 0x1f, 0x9a, 0xf2, 0x7a, 0x1b, 0xf9, 0x00, 0x54,
- 0xb6, 0xeb, 0x6a, 0xc8, 0x91, 0xc6, 0xad, 0x43, 0x4a, 0x22, 0x03, 0xdf, 0xfc, 0xa0, 0x37, 0xe0,
- 0x1c, 0x1d, 0x0c, 0x69, 0xc4, 0xab, 0xa1, 0x88, 0x74, 0x62, 0xf4, 0xc2, 0x91, 0xa5, 0x3a, 0x31,
- 0xa6, 0x51, 0xee, 0x40, 0xba, 0x62, 0x98, 0x0f, 0x91, 0x2b, 0xe1, 0x56, 0xcb, 0x72, 0x5b, 0xc8,
- 0x76, 0x4f, 0x8c, 0x94, 0xf5, 0x8e, 0x37, 0xb1, 0xa2, 0xdd, 0x30, 0x24, 0x11, 0xee, 0xc3, 0x1a,
- 0xc1, 0x12, 0xcd, 0x87, 0x36, 0x3e, 0x6c, 0xa2, 0x7a, 0x03, 0xcd, 0x05, 0x5c, 0x87, 0x55, 0x23,
- 0x6a, 0x4a, 0x51, 0x67, 0xc5, 0x42, 0x1e, 0x32, 0x04, 0x5a, 0x45, 0x26, 0xb2, 0xda, 0xae, 0x58,
- 0x73, 0xbc, 0x3e, 0x70, 0x12, 0xb2, 0x70, 0x00, 0x69, 0x05, 0x3d, 0x76, 0xab, 0xb4, 0x5f, 0xa8,
- 0xc8, 0xec, 0x9d, 0xc8, 0xe2, 0x3d, 0x38, 0x6f, 0xa3, 0xc7, 0xae, 0xee, 0xa0, 0x47, 0x7a, 0x07,
- 0x99, 0x3d, 0xd2, 0x4f, 0xc2, 0x0f, 0x64, 0x44, 0x2d, 0xa8, 0x49, 0x9b, 0x40, 0x7b, 0xa8, 0x6f,
- 0x7c, 0x1b, 0x87, 0xa5, 0x49, 0x63, 0x60, 0xdf, 0x81, 0x57, 0x4a, 0xa2, 0x26, 0xea, 0xda, 0xfd,
- 0x8a, 0xac, 0xef, 0x29, 0x65, 0xa5, 0xac, 0x95, 0xc5, 0xed, 0xf2, 0x03, 0xb9, 0xa4, 0xef, 0x29,
- 0xd5, 0x8a, 0x2c, 0x95, 0x6f, 0x95, 0xe5, 0x52, 0x6a, 0x81, 0x5b, 0x1d, 0x0c, 0xf9, 0x64, 0x48,
- 0xc4, 0x5e, 0x83, 0x4b, 0x81, 0xa7, 0xb4, 0x5d, 0x96, 0x15, 0x4d, 0xaf, 0x6a, 0xa2, 0x26, 0xa7,
- 0x18, 0x0e, 0x06, 0x43, 0x7e, 0x91, 0xc8, 0xd8, 0x37, 0x61, 0x2d, 0x64, 0xb7, 0xab, 0x54, 0x65,
- 0xa5, 0xba, 0x57, 0xa5, 0xa6, 0x31, 0xee, 0xfc, 0x60, 0xc8, 0x27, 0xa6, 0x62, 0x36, 0x0f, 0x5c,
- 0xc4, 0x5a, 0x91, 0x25, 0xad, 0xbc, 0xab, 0x50, 0xf3, 0x33, 0xdc, 0xca, 0x60, 0xc8, 0x43, 0x20,
- 0x67, 0xd7, 0xe1, 0x72, 0xc8, 0xfe, 0xb6, 0xa8, 0x28, 0xf2, 0x36, 0x35, 0x8e, 0x73, 0xc9, 0xc1,
- 0x90, 0x3f, 0x47, 0x85, 0xec, 0xdb, 0x70, 0x25, 0xb0, 0xac, 0x88, 0xd2, 0x5d, 0x59, 0xd3, 0xa5,
- 0xdd, 0x9d, 0x9d, 0xb2, 0xb6, 0x23, 0x2b, 0x5a, 0xea, 0x2c, 0x97, 0x1e, 0x0c, 0xf9, 0x14, 0x51,
- 0x04, 0x72, 0xf6, 0x03, 0xe0, 0x8f, 0xb8, 0x89, 0xd2, 0x5d, 0x65, 0xf7, 0x93, 0x6d, 0xb9, 0xf4,
- 0x91, 0xec, 0xfb, 0x2e, 0x72, 0x6b, 0x83, 0x21, 0x7f, 0x91, 0x68, 0x67, 0x94, 0xec, 0xfb, 0xc7,
- 0x00, 0xa8, 0xb2, 0x24, 0x97, 0x2b, 0x9a, 0x2e, 0x16, 0xab, 0xb2, 0x22, 0xc9, 0xa9, 0x73, 0x5c,
- 0x66, 0x30, 0xe4, 0xd3, 0x44, 0x4b, 0x95, 0x54, 0xc7, 0xde, 0x80, 0xab, 0x81, 0xbf, 0x22, 0x7f,
- 0xaa, 0xe9, 0x55, 0xf9, 0xe3, 0x3d, 0x4f, 0xe5, 0xc1, 0xdc, 0x4b, 0x2d, 0x11, 0xe2, 0x9e, 0x66,
- 0xa2, 0xf0, 0xe4, 0x2c, 0x0f, 0xa9, 0xc0, 0xef, 0xb6, 0x2c, 0x96, 0x64, 0x35, 0x95, 0x20, 0x37,
- 0x43, 0x76, 0x5c, 0xfc, 0xc9, 0x4f, 0xd9, 0x85, 0xe2, 0xfe, 0x6f, 0xcf, 0xb2, 0xcc, 0xd3, 0x67,
- 0x59, 0xe6, 0xaf, 0x67, 0x59, 0xe6, 0xbb, 0xe7, 0xd9, 0x85, 0xa7, 0xcf, 0xb3, 0x0b, 0x7f, 0x3c,
- 0xcf, 0x2e, 0x3c, 0xd8, 0x6e, 0x58, 0xee, 0x41, 0xb7, 0x96, 0x37, 0x71, 0xab, 0x60, 0x62, 0xa7,
- 0x85, 0x9d, 0x82, 0x55, 0x33, 0xaf, 0x37, 0x70, 0xa1, 0xb7, 0x55, 0x68, 0xe1, 0x7a, 0xb7, 0x89,
- 0x1c, 0xf2, 0xbf, 0x79, 0x7d, 0xf2, 0xc3, 0xf9, 0xd6, 0x8d, 0xeb, 0xa1, 0x27, 0xe8, 0xdd, 0xd0,
- 0xba, 0xb6, 0xe8, 0x77, 0xb5, 0xad, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x52, 0x93, 0xd6, 0x8d,
- 0xa6, 0x0e, 0x00, 0x00,
-}
-
-func (m *ClientState) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *ClientState) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ClientState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if m.AllowUpdateAfterProposal {
- i--
- if m.AllowUpdateAfterProposal {
- dAtA[i] = 1
- } else {
- dAtA[i] = 0
- }
- i--
- dAtA[i] = 0x20
- }
- if m.ConsensusState != nil {
- {
- size, err := m.ConsensusState.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintSolomachine(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x1a
- }
- if m.IsFrozen {
- i--
- if m.IsFrozen {
- dAtA[i] = 1
- } else {
- dAtA[i] = 0
- }
- i--
- dAtA[i] = 0x10
- }
- if m.Sequence != 0 {
- i = encodeVarintSolomachine(dAtA, i, uint64(m.Sequence))
- i--
- dAtA[i] = 0x8
- }
- return len(dAtA) - i, nil
-}
-
-func (m *ConsensusState) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *ConsensusState) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ConsensusState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if m.Timestamp != 0 {
- i = encodeVarintSolomachine(dAtA, i, uint64(m.Timestamp))
- i--
- dAtA[i] = 0x18
- }
- if len(m.Diversifier) > 0 {
- i -= len(m.Diversifier)
- copy(dAtA[i:], m.Diversifier)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Diversifier)))
- i--
- dAtA[i] = 0x12
+ if len(m.Diversifier) > 0 {
+ i -= len(m.Diversifier)
+ copy(dAtA[i:], m.Diversifier)
+ i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Diversifier)))
+ i--
+ dAtA[i] = 0x12
}
if m.PublicKey != nil {
{
@@ -1232,53 +666,6 @@ func (m *Misbehaviour) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *SignatureAndData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *SignatureAndData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *SignatureAndData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if m.Timestamp != 0 {
- i = encodeVarintSolomachine(dAtA, i, uint64(m.Timestamp))
- i--
- dAtA[i] = 0x20
- }
- if len(m.Data) > 0 {
- i -= len(m.Data)
- copy(dAtA[i:], m.Data)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Data)))
- i--
- dAtA[i] = 0x1a
- }
- if m.DataType != 0 {
- i = encodeVarintSolomachine(dAtA, i, uint64(m.DataType))
- i--
- dAtA[i] = 0x10
- }
- if len(m.Signature) > 0 {
- i -= len(m.Signature)
- copy(dAtA[i:], m.Signature)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Signature)))
- i--
- dAtA[i] = 0xa
- }
- return len(dAtA) - i, nil
-}
-
func (m *SignatureAndDataV2) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@@ -1417,7 +804,7 @@ func (m *SignBytesV2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *SignBytes) Marshal() (dAtA []byte, err error) {
+func (m *HeaderData) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -1427,2035 +814,233 @@ func (m *SignBytes) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *SignBytes) MarshalTo(dAtA []byte) (int, error) {
+func (m *HeaderData) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *SignBytes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *HeaderData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Data) > 0 {
- i -= len(m.Data)
- copy(dAtA[i:], m.Data)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Data)))
- i--
- dAtA[i] = 0x2a
- }
- if m.DataType != 0 {
- i = encodeVarintSolomachine(dAtA, i, uint64(m.DataType))
- i--
- dAtA[i] = 0x20
- }
- if len(m.Diversifier) > 0 {
- i -= len(m.Diversifier)
- copy(dAtA[i:], m.Diversifier)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Diversifier)))
- i--
- dAtA[i] = 0x1a
- }
- if m.Timestamp != 0 {
- i = encodeVarintSolomachine(dAtA, i, uint64(m.Timestamp))
+ if len(m.NewDiversifier) > 0 {
+ i -= len(m.NewDiversifier)
+ copy(dAtA[i:], m.NewDiversifier)
+ i = encodeVarintSolomachine(dAtA, i, uint64(len(m.NewDiversifier)))
i--
- dAtA[i] = 0x10
+ dAtA[i] = 0x12
}
- if m.Sequence != 0 {
- i = encodeVarintSolomachine(dAtA, i, uint64(m.Sequence))
+ if m.NewPubKey != nil {
+ {
+ size, err := m.NewPubKey.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintSolomachine(dAtA, i, uint64(size))
+ }
i--
- dAtA[i] = 0x8
+ dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
-func (m *HeaderData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
+func encodeVarintSolomachine(dAtA []byte, offset int, v uint64) int {
+ offset -= sovSolomachine(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
}
- return dAtA[:n], nil
-}
-
-func (m *HeaderData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+ dAtA[offset] = uint8(v)
+ return base
}
-
-func (m *HeaderData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
+func (m *ClientState) Size() (n int) {
+ if m == nil {
+ return 0
+ }
var l int
_ = l
- if len(m.NewDiversifier) > 0 {
- i -= len(m.NewDiversifier)
- copy(dAtA[i:], m.NewDiversifier)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.NewDiversifier)))
- i--
- dAtA[i] = 0x12
- }
- if m.NewPubKey != nil {
- {
- size, err := m.NewPubKey.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintSolomachine(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0xa
+ if m.Sequence != 0 {
+ n += 1 + sovSolomachine(uint64(m.Sequence))
}
- return len(dAtA) - i, nil
-}
-
-func (m *ClientStateData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
+ if m.IsFrozen {
+ n += 2
}
- return dAtA[:n], nil
-}
-
-func (m *ClientStateData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ClientStateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if m.ClientState != nil {
- {
- size, err := m.ClientState.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintSolomachine(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x12
+ if m.ConsensusState != nil {
+ l = m.ConsensusState.Size()
+ n += 1 + l + sovSolomachine(uint64(l))
}
- if len(m.Path) > 0 {
- i -= len(m.Path)
- copy(dAtA[i:], m.Path)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Path)))
- i--
- dAtA[i] = 0xa
+ if m.AllowUpdateAfterProposal {
+ n += 2
}
- return len(dAtA) - i, nil
+ return n
}
-func (m *ConsensusStateData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
+func (m *ConsensusState) Size() (n int) {
+ if m == nil {
+ return 0
}
- return dAtA[:n], nil
-}
-
-func (m *ConsensusStateData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ConsensusStateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
var l int
_ = l
- if m.ConsensusState != nil {
- {
- size, err := m.ConsensusState.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintSolomachine(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x12
+ if m.PublicKey != nil {
+ l = m.PublicKey.Size()
+ n += 1 + l + sovSolomachine(uint64(l))
}
- if len(m.Path) > 0 {
- i -= len(m.Path)
- copy(dAtA[i:], m.Path)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Path)))
- i--
- dAtA[i] = 0xa
+ l = len(m.Diversifier)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
}
- return len(dAtA) - i, nil
-}
-
-func (m *ConnectionStateData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
+ if m.Timestamp != 0 {
+ n += 1 + sovSolomachine(uint64(m.Timestamp))
}
- return dAtA[:n], nil
-}
-
-func (m *ConnectionStateData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+ return n
}
-func (m *ConnectionStateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
+func (m *Header) Size() (n int) {
+ if m == nil {
+ return 0
+ }
var l int
_ = l
- if m.Connection != nil {
- {
- size, err := m.Connection.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintSolomachine(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x12
+ if m.Sequence != 0 {
+ n += 1 + sovSolomachine(uint64(m.Sequence))
}
- if len(m.Path) > 0 {
- i -= len(m.Path)
- copy(dAtA[i:], m.Path)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Path)))
- i--
- dAtA[i] = 0xa
+ if m.Timestamp != 0 {
+ n += 1 + sovSolomachine(uint64(m.Timestamp))
}
- return len(dAtA) - i, nil
-}
-
-func (m *ChannelStateData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
+ l = len(m.Signature)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
}
- return dAtA[:n], nil
-}
-
-func (m *ChannelStateData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ChannelStateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if m.Channel != nil {
- {
- size, err := m.Channel.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintSolomachine(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x12
+ if m.NewPublicKey != nil {
+ l = m.NewPublicKey.Size()
+ n += 1 + l + sovSolomachine(uint64(l))
}
- if len(m.Path) > 0 {
- i -= len(m.Path)
- copy(dAtA[i:], m.Path)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Path)))
- i--
- dAtA[i] = 0xa
+ l = len(m.NewDiversifier)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
}
- return len(dAtA) - i, nil
+ return n
}
-func (m *PacketCommitmentData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
+func (m *Misbehaviour) Size() (n int) {
+ if m == nil {
+ return 0
}
- return dAtA[:n], nil
-}
-
-func (m *PacketCommitmentData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PacketCommitmentData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
var l int
_ = l
- if len(m.Commitment) > 0 {
- i -= len(m.Commitment)
- copy(dAtA[i:], m.Commitment)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Commitment)))
- i--
- dAtA[i] = 0x12
- }
- if len(m.Path) > 0 {
- i -= len(m.Path)
- copy(dAtA[i:], m.Path)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Path)))
- i--
- dAtA[i] = 0xa
- }
- return len(dAtA) - i, nil
-}
-
-func (m *PacketAcknowledgementData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
+ l = len(m.ClientId)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
}
- return dAtA[:n], nil
-}
-
-func (m *PacketAcknowledgementData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PacketAcknowledgementData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if len(m.Acknowledgement) > 0 {
- i -= len(m.Acknowledgement)
- copy(dAtA[i:], m.Acknowledgement)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Acknowledgement)))
- i--
- dAtA[i] = 0x12
- }
- if len(m.Path) > 0 {
- i -= len(m.Path)
- copy(dAtA[i:], m.Path)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Path)))
- i--
- dAtA[i] = 0xa
- }
- return len(dAtA) - i, nil
-}
-
-func (m *PacketReceiptAbsenceData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *PacketReceiptAbsenceData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PacketReceiptAbsenceData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if len(m.Path) > 0 {
- i -= len(m.Path)
- copy(dAtA[i:], m.Path)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Path)))
- i--
- dAtA[i] = 0xa
- }
- return len(dAtA) - i, nil
-}
-
-func (m *NextSequenceRecvData) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *NextSequenceRecvData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *NextSequenceRecvData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if m.NextSeqRecv != 0 {
- i = encodeVarintSolomachine(dAtA, i, uint64(m.NextSeqRecv))
- i--
- dAtA[i] = 0x10
- }
- if len(m.Path) > 0 {
- i -= len(m.Path)
- copy(dAtA[i:], m.Path)
- i = encodeVarintSolomachine(dAtA, i, uint64(len(m.Path)))
- i--
- dAtA[i] = 0xa
- }
- return len(dAtA) - i, nil
-}
-
-func encodeVarintSolomachine(dAtA []byte, offset int, v uint64) int {
- offset -= sovSolomachine(v)
- base := offset
- for v >= 1<<7 {
- dAtA[offset] = uint8(v&0x7f | 0x80)
- v >>= 7
- offset++
- }
- dAtA[offset] = uint8(v)
- return base
-}
-func (m *ClientState) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if m.Sequence != 0 {
- n += 1 + sovSolomachine(uint64(m.Sequence))
- }
- if m.IsFrozen {
- n += 2
- }
- if m.ConsensusState != nil {
- l = m.ConsensusState.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.AllowUpdateAfterProposal {
- n += 2
- }
- return n
-}
-
-func (m *ConsensusState) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if m.PublicKey != nil {
- l = m.PublicKey.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.Diversifier)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.Timestamp != 0 {
- n += 1 + sovSolomachine(uint64(m.Timestamp))
- }
- return n
-}
-
-func (m *Header) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if m.Sequence != 0 {
- n += 1 + sovSolomachine(uint64(m.Sequence))
- }
- if m.Timestamp != 0 {
- n += 1 + sovSolomachine(uint64(m.Timestamp))
- }
- l = len(m.Signature)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.NewPublicKey != nil {
- l = m.NewPublicKey.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.NewDiversifier)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *Misbehaviour) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.ClientId)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.Sequence != 0 {
- n += 1 + sovSolomachine(uint64(m.Sequence))
- }
- if m.SignatureOne != nil {
- l = m.SignatureOne.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.SignatureTwo != nil {
- l = m.SignatureTwo.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *SignatureAndData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Signature)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.DataType != 0 {
- n += 1 + sovSolomachine(uint64(m.DataType))
- }
- l = len(m.Data)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.Timestamp != 0 {
- n += 1 + sovSolomachine(uint64(m.Timestamp))
- }
- return n
-}
-
-func (m *SignatureAndDataV2) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Signature)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.Data)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.Timestamp != 0 {
- n += 1 + sovSolomachine(uint64(m.Timestamp))
- }
- return n
-}
-
-func (m *TimestampedSignatureData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.SignatureData)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.Timestamp != 0 {
- n += 1 + sovSolomachine(uint64(m.Timestamp))
- }
- return n
-}
-
-func (m *SignBytesV2) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
if m.Sequence != 0 {
n += 1 + sovSolomachine(uint64(m.Sequence))
}
- if m.Timestamp != 0 {
- n += 1 + sovSolomachine(uint64(m.Timestamp))
- }
- l = len(m.Diversifier)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.Data)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *SignBytes) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if m.Sequence != 0 {
- n += 1 + sovSolomachine(uint64(m.Sequence))
- }
- if m.Timestamp != 0 {
- n += 1 + sovSolomachine(uint64(m.Timestamp))
- }
- l = len(m.Diversifier)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.DataType != 0 {
- n += 1 + sovSolomachine(uint64(m.DataType))
- }
- l = len(m.Data)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *HeaderData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if m.NewPubKey != nil {
- l = m.NewPubKey.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.NewDiversifier)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *ClientStateData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.ClientState != nil {
- l = m.ClientState.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *ConsensusStateData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.ConsensusState != nil {
- l = m.ConsensusState.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *ConnectionStateData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.Connection != nil {
- l = m.Connection.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *ChannelStateData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.Channel != nil {
- l = m.Channel.Size()
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *PacketCommitmentData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.Commitment)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *PacketAcknowledgementData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- l = len(m.Acknowledgement)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *PacketReceiptAbsenceData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- return n
-}
-
-func (m *NextSequenceRecvData) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- l = len(m.Path)
- if l > 0 {
- n += 1 + l + sovSolomachine(uint64(l))
- }
- if m.NextSeqRecv != 0 {
- n += 1 + sovSolomachine(uint64(m.NextSeqRecv))
- }
- return n
-}
-
-func sovSolomachine(x uint64) (n int) {
- return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozSolomachine(x uint64) (n int) {
- return sovSolomachine(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *ClientState) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: ClientState: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: ClientState: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
- }
- m.Sequence = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Sequence |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field IsFrozen", wireType)
- }
- var v int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- v |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- m.IsFrozen = bool(v != 0)
- case 3:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", wireType)
- }
- var msglen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- msglen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if msglen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- if m.ConsensusState == nil {
- m.ConsensusState = &ConsensusState{}
- }
- if err := m.ConsensusState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- case 4:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field AllowUpdateAfterProposal", wireType)
- }
- var v int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- v |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- m.AllowUpdateAfterProposal = bool(v != 0)
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *ConsensusState) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: ConsensusState: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: ConsensusState: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
- }
- var msglen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- msglen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if msglen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- if m.PublicKey == nil {
- m.PublicKey = &types.Any{}
- }
- if err := m.PublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- case 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Diversifier", wireType)
- }
- var stringLen uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- stringLen |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- intStringLen := int(stringLen)
- if intStringLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + intStringLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Diversifier = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
- case 3:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
- }
- m.Timestamp = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Timestamp |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *Header) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: Header: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
- }
- m.Sequence = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Sequence |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
- }
- m.Timestamp = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Timestamp |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 3:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
- if m.Signature == nil {
- m.Signature = []byte{}
- }
- iNdEx = postIndex
- case 4:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field NewPublicKey", wireType)
- }
- var msglen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- msglen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if msglen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- if m.NewPublicKey == nil {
- m.NewPublicKey = &types.Any{}
- }
- if err := m.NewPublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- case 5:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field NewDiversifier", wireType)
- }
- var stringLen uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- stringLen |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- intStringLen := int(stringLen)
- if intStringLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + intStringLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.NewDiversifier = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *Misbehaviour) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: Misbehaviour: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: Misbehaviour: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType)
- }
- var stringLen uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- stringLen |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- intStringLen := int(stringLen)
- if intStringLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + intStringLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.ClientId = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
- }
- m.Sequence = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Sequence |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 3:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field SignatureOne", wireType)
- }
- var msglen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- msglen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if msglen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- if m.SignatureOne == nil {
- m.SignatureOne = &SignatureAndDataV2{}
- }
- if err := m.SignatureOne.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- case 4:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field SignatureTwo", wireType)
- }
- var msglen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- msglen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if msglen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- if m.SignatureTwo == nil {
- m.SignatureTwo = &SignatureAndDataV2{}
- }
- if err := m.SignatureTwo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *SignatureAndData) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: SignatureAndData: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: SignatureAndData: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
- if m.Signature == nil {
- m.Signature = []byte{}
- }
- iNdEx = postIndex
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType)
- }
- m.DataType = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.DataType |= DataType(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 3:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
- if m.Data == nil {
- m.Data = []byte{}
- }
- iNdEx = postIndex
- case 4:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
- }
- m.Timestamp = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Timestamp |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *SignatureAndDataV2) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: SignatureAndDataV2: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: SignatureAndDataV2: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
- if m.Signature == nil {
- m.Signature = []byte{}
- }
- iNdEx = postIndex
- case 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Path = append(m.Path[:0], dAtA[iNdEx:postIndex]...)
- if m.Path == nil {
- m.Path = []byte{}
- }
- iNdEx = postIndex
- case 3:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
- if m.Data == nil {
- m.Data = []byte{}
- }
- iNdEx = postIndex
- case 4:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
- }
- m.Timestamp = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Timestamp |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *TimestampedSignatureData) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: TimestampedSignatureData: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: TimestampedSignatureData: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field SignatureData", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.SignatureData = append(m.SignatureData[:0], dAtA[iNdEx:postIndex]...)
- if m.SignatureData == nil {
- m.SignatureData = []byte{}
- }
- iNdEx = postIndex
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
- }
- m.Timestamp = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Timestamp |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *SignBytesV2) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: SignBytesV2: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: SignBytesV2: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
- }
- m.Sequence = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Sequence |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
- }
- m.Timestamp = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Timestamp |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 3:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Diversifier", wireType)
- }
- var stringLen uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- stringLen |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- intStringLen := int(stringLen)
- if intStringLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + intStringLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Diversifier = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
- case 4:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Path = append(m.Path[:0], dAtA[iNdEx:postIndex]...)
- if m.Path == nil {
- m.Path = []byte{}
- }
- iNdEx = postIndex
- case 5:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
- if m.Data == nil {
- m.Data = []byte{}
- }
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
+ if m.SignatureOne != nil {
+ l = m.SignatureOne.Size()
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ if m.SignatureTwo != nil {
+ l = m.SignatureTwo.Size()
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ return n
+}
- if iNdEx > l {
- return io.ErrUnexpectedEOF
+func (m *SignatureAndDataV2) Size() (n int) {
+ if m == nil {
+ return 0
}
- return nil
+ var l int
+ _ = l
+ l = len(m.Signature)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ l = len(m.Path)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ l = len(m.Data)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ if m.Timestamp != 0 {
+ n += 1 + sovSolomachine(uint64(m.Timestamp))
+ }
+ return n
+}
+
+func (m *TimestampedSignatureData) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.SignatureData)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ if m.Timestamp != 0 {
+ n += 1 + sovSolomachine(uint64(m.Timestamp))
+ }
+ return n
+}
+
+func (m *SignBytesV2) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Sequence != 0 {
+ n += 1 + sovSolomachine(uint64(m.Sequence))
+ }
+ if m.Timestamp != 0 {
+ n += 1 + sovSolomachine(uint64(m.Timestamp))
+ }
+ l = len(m.Diversifier)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ l = len(m.Path)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ l = len(m.Data)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ return n
+}
+
+func (m *HeaderData) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.NewPubKey != nil {
+ l = m.NewPubKey.Size()
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ l = len(m.NewDiversifier)
+ if l > 0 {
+ n += 1 + l + sovSolomachine(uint64(l))
+ }
+ return n
+}
+
+func sovSolomachine(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozSolomachine(x uint64) (n int) {
+ return sovSolomachine(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
-func (m *SignBytes) Unmarshal(dAtA []byte) error {
+func (m *ClientState) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -3478,10 +1063,10 @@ func (m *SignBytes) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: SignBytes: wiretype end group for non-group")
+ return fmt.Errorf("proto: ClientState: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: SignBytes: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: ClientState: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@@ -3505,9 +1090,9 @@ func (m *SignBytes) Unmarshal(dAtA []byte) error {
}
case 2:
if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field IsFrozen", wireType)
}
- m.Timestamp = 0
+ var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -3517,149 +1102,15 @@ func (m *SignBytes) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.Timestamp |= uint64(b&0x7F) << shift
+ v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
+ m.IsFrozen = bool(v != 0)
case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Diversifier", wireType)
- }
- var stringLen uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- stringLen |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- intStringLen := int(stringLen)
- if intStringLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + intStringLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Diversifier = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
- case 4:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType)
- }
- m.DataType = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.DataType |= DataType(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 5:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
- if m.Data == nil {
- m.Data = []byte{}
- }
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *HeaderData) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: HeaderData: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: HeaderData: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field NewPubKey", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -3686,18 +1137,18 @@ func (m *HeaderData) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.NewPubKey == nil {
- m.NewPubKey = &types.Any{}
+ if m.ConsensusState == nil {
+ m.ConsensusState = &ConsensusState{}
}
- if err := m.NewPubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.ConsensusState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field NewDiversifier", wireType)
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AllowUpdateAfterProposal", wireType)
}
- var stringLen uint64
+ var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -3707,24 +1158,12 @@ func (m *HeaderData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- stringLen |= uint64(b&0x7F) << shift
+ v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- intStringLen := int(stringLen)
- if intStringLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + intStringLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.NewDiversifier = string(dAtA[iNdEx:postIndex])
- iNdEx = postIndex
+ m.AllowUpdateAfterProposal = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipSolomachine(dAtA[iNdEx:])
@@ -3746,7 +1185,7 @@ func (m *HeaderData) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ClientStateData) Unmarshal(dAtA []byte) error {
+func (m *ConsensusState) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -3769,17 +1208,17 @@ func (m *ClientStateData) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: ClientStateData: wiretype end group for non-group")
+ return fmt.Errorf("proto: ConsensusState: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: ClientStateData: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: ConsensusState: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -3789,31 +1228,33 @@ func (m *ClientStateData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
+ if msglen < 0 {
return ErrInvalidLengthSolomachine
}
- postIndex := iNdEx + byteLen
+ postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSolomachine
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Path = append(m.Path[:0], dAtA[iNdEx:postIndex]...)
- if m.Path == nil {
- m.Path = []byte{}
+ if m.PublicKey == nil {
+ m.PublicKey = &types.Any{}
+ }
+ if err := m.PublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ClientState", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Diversifier", wireType)
}
- var msglen int
+ var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -3823,28 +1264,43 @@ func (m *ClientStateData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if msglen < 0 {
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
return ErrInvalidLengthSolomachine
}
- postIndex := iNdEx + msglen
+ postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSolomachine
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.ClientState == nil {
- m.ClientState = &types.Any{}
+ m.Diversifier = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
}
- if err := m.ClientState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ m.Timestamp = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Timestamp |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
}
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSolomachine(dAtA[iNdEx:])
@@ -3866,7 +1322,7 @@ func (m *ClientStateData) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ConsensusStateData) Unmarshal(dAtA []byte) error {
+func (m *Header) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -3889,15 +1345,53 @@ func (m *ConsensusStateData) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: ConsensusStateData: wiretype end group for non-group")
+ return fmt.Errorf("proto: Header: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: ConsensusStateData: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
+ }
+ m.Sequence = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Sequence |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+ }
+ m.Timestamp = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Timestamp |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@@ -3924,14 +1418,14 @@ func (m *ConsensusStateData) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Path = append(m.Path[:0], dAtA[iNdEx:postIndex]...)
- if m.Path == nil {
- m.Path = []byte{}
+ m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
+ if m.Signature == nil {
+ m.Signature = []byte{}
}
iNdEx = postIndex
- case 2:
+ case 4:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field NewPublicKey", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -3958,13 +1452,45 @@ func (m *ConsensusStateData) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.ConsensusState == nil {
- m.ConsensusState = &types.Any{}
+ if m.NewPublicKey == nil {
+ m.NewPublicKey = &types.Any{}
}
- if err := m.ConsensusState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.NewPublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NewDiversifier", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NewDiversifier = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSolomachine(dAtA[iNdEx:])
@@ -3986,7 +1512,7 @@ func (m *ConsensusStateData) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ConnectionStateData) Unmarshal(dAtA []byte) error {
+func (m *Misbehaviour) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4009,17 +1535,17 @@ func (m *ConnectionStateData) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: ConnectionStateData: wiretype end group for non-group")
+ return fmt.Errorf("proto: Misbehaviour: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: ConnectionStateData: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: Misbehaviour: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType)
}
- var byteLen int
+ var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -4029,31 +1555,29 @@ func (m *ConnectionStateData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
return ErrInvalidLengthSolomachine
}
- postIndex := iNdEx + byteLen
+ postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSolomachine
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Path = append(m.Path[:0], dAtA[iNdEx:postIndex]...)
- if m.Path == nil {
- m.Path = []byte{}
- }
+ m.ClientId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Connection", wireType)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
}
- var msglen int
+ m.Sequence = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -4063,83 +1587,16 @@ func (m *ConnectionStateData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.Sequence |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if msglen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- if m.Connection == nil {
- m.Connection = &types1.ConnectionEnd{}
- }
- if err := m.Connection.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipSolomachine(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthSolomachine
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *ChannelStateData) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowSolomachine
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: ChannelStateData: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: ChannelStateData: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field SignatureOne", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -4149,29 +1606,31 @@ func (m *ChannelStateData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
+ if msglen < 0 {
return ErrInvalidLengthSolomachine
}
- postIndex := iNdEx + byteLen
+ postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSolomachine
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Path = append(m.Path[:0], dAtA[iNdEx:postIndex]...)
- if m.Path == nil {
- m.Path = []byte{}
+ if m.SignatureOne == nil {
+ m.SignatureOne = &SignatureAndDataV2{}
+ }
+ if err := m.SignatureOne.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
iNdEx = postIndex
- case 2:
+ case 4:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Channel", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field SignatureTwo", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -4198,10 +1657,10 @@ func (m *ChannelStateData) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Channel == nil {
- m.Channel = &types2.Channel{}
+ if m.SignatureTwo == nil {
+ m.SignatureTwo = &SignatureAndDataV2{}
}
- if err := m.Channel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.SignatureTwo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -4226,7 +1685,7 @@ func (m *ChannelStateData) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *PacketCommitmentData) Unmarshal(dAtA []byte) error {
+func (m *SignatureAndDataV2) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4249,13 +1708,47 @@ func (m *PacketCommitmentData) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: PacketCommitmentData: wiretype end group for non-group")
+ return fmt.Errorf("proto: SignatureAndDataV2: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: PacketCommitmentData: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: SignatureAndDataV2: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
+ if m.Signature == nil {
+ m.Signature = []byte{}
+ }
+ iNdEx = postIndex
+ case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
}
@@ -4289,9 +1782,9 @@ func (m *PacketCommitmentData) Unmarshal(dAtA []byte) error {
m.Path = []byte{}
}
iNdEx = postIndex
- case 2:
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@@ -4318,11 +1811,30 @@ func (m *PacketCommitmentData) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Commitment = append(m.Commitment[:0], dAtA[iNdEx:postIndex]...)
- if m.Commitment == nil {
- m.Commitment = []byte{}
+ m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+ if m.Data == nil {
+ m.Data = []byte{}
}
iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+ }
+ m.Timestamp = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Timestamp |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
default:
iNdEx = preIndex
skippy, err := skipSolomachine(dAtA[iNdEx:])
@@ -4344,7 +1856,7 @@ func (m *PacketCommitmentData) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *PacketAcknowledgementData) Unmarshal(dAtA []byte) error {
+func (m *TimestampedSignatureData) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4367,15 +1879,15 @@ func (m *PacketAcknowledgementData) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: PacketAcknowledgementData: wiretype end group for non-group")
+ return fmt.Errorf("proto: TimestampedSignatureData: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: PacketAcknowledgementData: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: TimestampedSignatureData: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field SignatureData", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@@ -4402,16 +1914,16 @@ func (m *PacketAcknowledgementData) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Path = append(m.Path[:0], dAtA[iNdEx:postIndex]...)
- if m.Path == nil {
- m.Path = []byte{}
+ m.SignatureData = append(m.SignatureData[:0], dAtA[iNdEx:postIndex]...)
+ if m.SignatureData == nil {
+ m.SignatureData = []byte{}
}
iNdEx = postIndex
case 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Acknowledgement", wireType)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
}
- var byteLen int
+ m.Timestamp = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -4421,26 +1933,11 @@ func (m *PacketAcknowledgementData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ m.Timestamp |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
- return ErrInvalidLengthSolomachine
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthSolomachine
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Acknowledgement = append(m.Acknowledgement[:0], dAtA[iNdEx:postIndex]...)
- if m.Acknowledgement == nil {
- m.Acknowledgement = []byte{}
- }
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSolomachine(dAtA[iNdEx:])
@@ -4462,7 +1959,7 @@ func (m *PacketAcknowledgementData) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *PacketReceiptAbsenceData) Unmarshal(dAtA []byte) error {
+func (m *SignBytesV2) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4485,13 +1982,83 @@ func (m *PacketReceiptAbsenceData) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: PacketReceiptAbsenceData: wiretype end group for non-group")
+ return fmt.Errorf("proto: SignBytesV2: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: PacketReceiptAbsenceData: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: SignBytesV2: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
+ }
+ m.Sequence = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Sequence |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+ }
+ m.Timestamp = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Timestamp |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Diversifier", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Diversifier = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
}
@@ -4525,6 +2092,40 @@ func (m *PacketReceiptAbsenceData) Unmarshal(dAtA []byte) error {
m.Path = []byte{}
}
iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowSolomachine
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+ if m.Data == nil {
+ m.Data = []byte{}
+ }
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSolomachine(dAtA[iNdEx:])
@@ -4546,7 +2147,7 @@ func (m *PacketReceiptAbsenceData) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *NextSequenceRecvData) Unmarshal(dAtA []byte) error {
+func (m *HeaderData) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4569,17 +2170,17 @@ func (m *NextSequenceRecvData) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: NextSequenceRecvData: wiretype end group for non-group")
+ return fmt.Errorf("proto: HeaderData: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: NextSequenceRecvData: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: HeaderData: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field NewPubKey", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -4589,31 +2190,33 @@ func (m *NextSequenceRecvData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
+ if msglen < 0 {
return ErrInvalidLengthSolomachine
}
- postIndex := iNdEx + byteLen
+ postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSolomachine
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Path = append(m.Path[:0], dAtA[iNdEx:postIndex]...)
- if m.Path == nil {
- m.Path = []byte{}
+ if m.NewPubKey == nil {
+ m.NewPubKey = &types.Any{}
+ }
+ if err := m.NewPubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
iNdEx = postIndex
case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field NextSeqRecv", wireType)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NewDiversifier", wireType)
}
- m.NextSeqRecv = 0
+ var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSolomachine
@@ -4623,11 +2226,24 @@ func (m *NextSequenceRecvData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.NextSeqRecv |= uint64(b&0x7F) << shift
+ stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthSolomachine
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NewDiversifier = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSolomachine(dAtA[iNdEx:])
diff --git a/modules/light-clients/06-solomachine/update.go b/modules/light-clients/06-solomachine/update.go
index 1d903a6105a..f5a7c4c9a55 100644
--- a/modules/light-clients/06-solomachine/update.go
+++ b/modules/light-clients/06-solomachine/update.go
@@ -44,7 +44,25 @@ func (cs ClientState) verifyHeader(ctx sdk.Context, cdc codec.BinaryCodec, clien
}
// assert currently registered public key signed over the new public key with correct sequence
- data, err := HeaderSignBytes(cdc, header)
+ headerData := &HeaderData{
+ NewPubKey: header.NewPublicKey,
+ NewDiversifier: header.NewDiversifier,
+ }
+
+ dataBz, err := cdc.Marshal(headerData)
+ if err != nil {
+ return err
+ }
+
+ signBytes := &SignBytesV2{
+ Sequence: header.Sequence,
+ Timestamp: header.Timestamp,
+ Diversifier: header.NewDiversifier,
+ Path: []byte{},
+ Data: dataBz,
+ }
+
+ data, err := cdc.Marshal(signBytes)
if err != nil {
return err
}
diff --git a/modules/light-clients/06-solomachine/update_test.go b/modules/light-clients/06-solomachine/update_test.go
index 24dad99ab0b..282b7edb47f 100644
--- a/modules/light-clients/06-solomachine/update_test.go
+++ b/modules/light-clients/06-solomachine/update_test.go
@@ -101,11 +101,11 @@ func (suite *SoloMachineTestSuite) TestVerifyClientMessageHeader() {
suite.Require().NoError(err)
// generate invalid signature
- signBytes := &solomachine.SignBytes{
+ signBytes := &solomachine.SignBytesV2{
Sequence: cs.Sequence,
Timestamp: sm.Time,
Diversifier: sm.Diversifier,
- DataType: solomachine.CLIENT,
+ Path: []byte("invalid signature data"),
Data: dataBz,
}
@@ -258,11 +258,11 @@ func (suite *SoloMachineTestSuite) TestVerifyClientMessageMisbehaviour() {
m := sm.CreateMisbehaviour()
msg := []byte("DATA ONE")
- signBytes := &solomachine.SignBytes{
+ signBytes := &solomachine.SignBytesV2{
Sequence: sm.Sequence + 1,
Timestamp: sm.Time,
Diversifier: sm.Diversifier,
- DataType: solomachine.CLIENT,
+ Path: []byte("invalid signature data"),
Data: msg,
}
@@ -284,11 +284,11 @@ func (suite *SoloMachineTestSuite) TestVerifyClientMessageMisbehaviour() {
m := sm.CreateMisbehaviour()
msg := []byte("DATA TWO")
- signBytes := &solomachine.SignBytes{
+ signBytes := &solomachine.SignBytesV2{
Sequence: sm.Sequence + 1,
Timestamp: sm.Time,
Diversifier: sm.Diversifier,
- DataType: solomachine.CLIENT,
+ Path: []byte("invalid signature data"),
Data: msg,
}
@@ -341,11 +341,11 @@ func (suite *SoloMachineTestSuite) TestVerifyClientMessageMisbehaviour() {
// Signature One
msg := []byte("DATA ONE")
// sequence used is plus 1
- signBytes := &solomachine.SignBytes{
+ signBytes := &solomachine.SignBytesV2{
Sequence: sm.Sequence + 1,
Timestamp: sm.Time,
Diversifier: sm.Diversifier,
- DataType: solomachine.CLIENT,
+ Path: []byte("invalid signature data"),
Data: msg,
}
@@ -361,11 +361,11 @@ func (suite *SoloMachineTestSuite) TestVerifyClientMessageMisbehaviour() {
msg = []byte("DATA TWO")
// sequence used is minus 1
- signBytes = &solomachine.SignBytes{
+ signBytes = &solomachine.SignBytesV2{
Sequence: sm.Sequence - 1,
Timestamp: sm.Time,
Diversifier: sm.Diversifier,
- DataType: solomachine.CLIENT,
+ Path: []byte("invalid signature data"),
Data: msg,
}
data, err = suite.chainA.Codec.Marshal(signBytes)
diff --git a/proto/ibc/lightclients/solomachine/v2/solomachine.proto b/proto/ibc/lightclients/solomachine/v2/solomachine.proto
index a9e16f719fb..6c03acae18e 100644
--- a/proto/ibc/lightclients/solomachine/v2/solomachine.proto
+++ b/proto/ibc/lightclients/solomachine/v2/solomachine.proto
@@ -4,8 +4,6 @@ package ibc.lightclients.solomachine.v2;
option go_package = "github.com/cosmos/ibc-go/v3/modules/light-clients/06-solomachine;solomachine";
-import "ibc/core/connection/v1/connection.proto";
-import "ibc/core/channel/v1/channel.proto";
import "gogoproto/gogo.proto";
import "google/protobuf/any.proto";
@@ -60,16 +58,6 @@ message Misbehaviour {
SignatureAndDataV2 signature_two = 4 [(gogoproto.moretags) = "yaml:\"signature_two\""];
}
-// SignatureAndData contains a signature and the data signed over to create that
-// signature.
-message SignatureAndData {
- option (gogoproto.goproto_getters) = false;
- bytes signature = 1;
- DataType data_type = 2 [(gogoproto.moretags) = "yaml:\"data_type\""];
- bytes data = 3;
- uint64 timestamp = 4;
-}
-
// SignatureAndDataV2 contains a signature and the data signed over to create that
// signature.
message SignatureAndDataV2 {
@@ -104,46 +92,6 @@ message SignBytesV2 {
bytes data = 5;
}
-// SignBytes defines the signed bytes used for signature verification.
-message SignBytes {
- option (gogoproto.goproto_getters) = false;
-
- uint64 sequence = 1;
- uint64 timestamp = 2;
- string diversifier = 3;
- // type of the data used
- DataType data_type = 4 [(gogoproto.moretags) = "yaml:\"data_type\""];
- // marshaled data
- bytes data = 5;
-}
-
-// DataType defines the type of solo machine proof being created. This is done
-// to preserve uniqueness of different data sign byte encodings.
-enum DataType {
- option (gogoproto.goproto_enum_prefix) = false;
-
- // Default State
- DATA_TYPE_UNINITIALIZED_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "UNSPECIFIED"];
- // Data type for client state verification
- DATA_TYPE_CLIENT_STATE = 1 [(gogoproto.enumvalue_customname) = "CLIENT"];
- // Data type for consensus state verification
- DATA_TYPE_CONSENSUS_STATE = 2 [(gogoproto.enumvalue_customname) = "CONSENSUS"];
- // Data type for connection state verification
- DATA_TYPE_CONNECTION_STATE = 3 [(gogoproto.enumvalue_customname) = "CONNECTION"];
- // Data type for channel state verification
- DATA_TYPE_CHANNEL_STATE = 4 [(gogoproto.enumvalue_customname) = "CHANNEL"];
- // Data type for packet commitment verification
- DATA_TYPE_PACKET_COMMITMENT = 5 [(gogoproto.enumvalue_customname) = "PACKETCOMMITMENT"];
- // Data type for packet acknowledgement verification
- DATA_TYPE_PACKET_ACKNOWLEDGEMENT = 6 [(gogoproto.enumvalue_customname) = "PACKETACKNOWLEDGEMENT"];
- // Data type for packet receipt absence verification
- DATA_TYPE_PACKET_RECEIPT_ABSENCE = 7 [(gogoproto.enumvalue_customname) = "PACKETRECEIPTABSENCE"];
- // Data type for next sequence recv verification
- DATA_TYPE_NEXT_SEQUENCE_RECV = 8 [(gogoproto.enumvalue_customname) = "NEXTSEQUENCERECV"];
- // Data type for header verification
- DATA_TYPE_HEADER = 9 [(gogoproto.enumvalue_customname) = "HEADER"];
-}
-
// HeaderData returns the SignBytes data for update verification.
message HeaderData {
option (gogoproto.goproto_getters) = false;
@@ -153,65 +101,3 @@ message HeaderData {
// header diversifier
string new_diversifier = 2 [(gogoproto.moretags) = "yaml:\"new_diversifier\""];
}
-
-// ClientStateData returns the SignBytes data for client state verification.
-message ClientStateData {
- option (gogoproto.goproto_getters) = false;
-
- bytes path = 1;
- google.protobuf.Any client_state = 2 [(gogoproto.moretags) = "yaml:\"client_state\""];
-}
-
-// ConsensusStateData returns the SignBytes data for consensus state
-// verification.
-message ConsensusStateData {
- option (gogoproto.goproto_getters) = false;
-
- bytes path = 1;
- google.protobuf.Any consensus_state = 2 [(gogoproto.moretags) = "yaml:\"consensus_state\""];
-}
-
-// ConnectionStateData returns the SignBytes data for connection state
-// verification.
-message ConnectionStateData {
- option (gogoproto.goproto_getters) = false;
-
- bytes path = 1;
- ibc.core.connection.v1.ConnectionEnd connection = 2;
-}
-
-// ChannelStateData returns the SignBytes data for channel state
-// verification.
-message ChannelStateData {
- option (gogoproto.goproto_getters) = false;
-
- bytes path = 1;
- ibc.core.channel.v1.Channel channel = 2;
-}
-
-// PacketCommitmentData returns the SignBytes data for packet commitment
-// verification.
-message PacketCommitmentData {
- bytes path = 1;
- bytes commitment = 2;
-}
-
-// PacketAcknowledgementData returns the SignBytes data for acknowledgement
-// verification.
-message PacketAcknowledgementData {
- bytes path = 1;
- bytes acknowledgement = 2;
-}
-
-// PacketReceiptAbsenceData returns the SignBytes data for
-// packet receipt absence verification.
-message PacketReceiptAbsenceData {
- bytes path = 1;
-}
-
-// NextSequenceRecvData returns the SignBytes data for verification of the next
-// sequence to be received.
-message NextSequenceRecvData {
- bytes path = 1;
- uint64 next_seq_recv = 2 [(gogoproto.moretags) = "yaml:\"next_seq_recv\""];
-}
diff --git a/testing/solomachine.go b/testing/solomachine.go
index 785b1f7fe7b..ee54c64b1ba 100644
--- a/testing/solomachine.go
+++ b/testing/solomachine.go
@@ -122,11 +122,11 @@ func (solo *Solomachine) CreateHeader() *solomachinetypes.Header {
dataBz, err := solo.cdc.Marshal(data)
require.NoError(solo.t, err)
- signBytes := &solomachinetypes.SignBytes{
+ signBytes := &solomachinetypes.SignBytesV2{
Sequence: solo.Sequence,
Timestamp: solo.Time,
Diversifier: solo.Diversifier,
- DataType: solomachinetypes.HEADER,
+ Path: []byte{},
Data: dataBz,
}