Mirroristas/kaspad
2
0
Fork 0
mirror of https://github.com/kaspanet/kaspad.git synced 2025-03-30 15:08:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add nil checks for protowire (#1570)

Browse Source 
* Handle errors in p2p handshake better

* Add a new errNil in protowire

* Add nil checks for all protowire.toAppMessage() functions for the p2p

* Add nil checks for all protowire.toAppMessage() functions for the RPC

* Add nil check for protwire KaspadMessage

Co-authored-by: Svarog <feanorr@gmail.com>
This commit is contained in:
Elichai Turkel 2021-03-02 19:14:31 +02:00 committed by GitHub
parent 1548ed9629
commit 7829a9fd76
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
67 changed files with 1889 additions and 611 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
app/protocol/protocol.go
View File

@ -59,8 +59,20 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
peer, err := handshake.HandleHandshake(m.context, netConnection, receiveVersionRoute,
sendVersionRoute, router.OutgoingRoute())
if err != nil {
m.handleError(err, netConnection, router.OutgoingRoute())
// non-blocking read from channel
select {
case innerError := <-errChan:
if errors.Is(err, routerpkg.ErrRouteClosed) {
m.handleError(innerError, netConnection, router.OutgoingRoute())
} else {
log.Errorf("Peer %s sent invalid message: %s", netConnection, innerError)
m.handleError(err, netConnection, router.OutgoingRoute())
}
default:
m.handleError(err, netConnection, router.OutgoingRoute())
}
return
}
defer m.context.RemoveFromPeers(peer)

56
infrastructure/network/netadapter/server/grpcserver/protowire/common.go
View File

@ -12,7 +12,12 @@ import (
"github.com/pkg/errors"
)
var errorNil = errors.New("a required field is nil")
func (x *Hash) toDomain() (*externalapi.DomainHash, error) {
if x == nil {
return nil, errors.Wrap(errorNil, "Hash is nil")
}
return externalapi.NewDomainHashFromByteSlice(x.Bytes)
}
@ -43,6 +48,9 @@ func domainHashesToProto(hashes []*externalapi.DomainHash) []*Hash {
}
func (x *TransactionId) toDomain() (*externalapi.DomainTransactionID, error) {
if x == nil {
return nil, errors.Wrap(errorNil, "TransactionId is nil")
}
return transactionid.FromBytes(x.Bytes)
}
@ -74,7 +82,7 @@ func wireTransactionIDsToProto(ids []*externalapi.DomainTransactionID) []*Transa
func (x *SubnetworkId) toDomain() (*externalapi.DomainSubnetworkID, error) {
if x == nil {
return nil, nil
return nil, errors.Wrap(errorNil, "SubnetworkId is nil")
}
return subnetworks.FromBytes(x.Bytes)
}
@ -89,6 +97,9 @@ func domainSubnetworkIDToProto(id *externalapi.DomainSubnetworkID) *SubnetworkId
}
func (x *NetAddress) toAppMessage() (*appmessage.NetAddress, error) {
if x == nil {
return nil, errors.Wrap(errorNil, "NetAddress is nil")
}
if x.Port > math.MaxUint16 {
return nil, errors.Errorf("port number is larger than %d", math.MaxUint16)
}
@ -108,3 +119,46 @@ func appMessageNetAddressToProto(address *appmessage.NetAddress) *NetAddress {
Port: uint32(address.Port),
}
}
func (x *Outpoint) toAppMessage() (*appmessage.Outpoint, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "Outpoint is nil")
}
transactionID, err := x.TransactionId.toDomain()
if err != nil {
return nil, err
}
return &appmessage.Outpoint{
TxID: *transactionID,
Index: x.Index,
}, nil
}
func (x *UtxoEntry) toAppMessage() (*appmessage.UTXOEntry, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "UtxoEntry is nil")
}
scriptPublicKey, err := x.ScriptPublicKey.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.UTXOEntry{
Amount: x.Amount,
ScriptPublicKey: scriptPublicKey,
BlockBlueScore: x.BlockBlueScore,
IsCoinbase: x.IsCoinbase,
}, nil
}
func (x *ScriptPublicKey) toAppMessage() (*externalapi.ScriptPublicKey, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "ScriptPublicKey is nil")
}
if x.Version > math.MaxUint16 {
return nil, errors.Errorf("ScriptPublicKey version is bigger then uint16.")
}
return &externalapi.ScriptPublicKey{
Script: x.Script,
Version: uint16(x.Version),
}, nil
}

31
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_addresses.go
View File

@ -6,23 +6,36 @@ import (
)
func (x *KaspadMessage_Addresses) toAppMessage() (appmessage.Message, error) {
protoAddresses := x.Addresses
if len(x.Addresses.AddressList) > appmessage.MaxAddressesPerMsg {
return nil, errors.Errorf("too many addresses for message "+
"[count %d, max %d]", len(x.Addresses.AddressList), appmessage.MaxAddressesPerMsg)
if x == nil {
return nil, errors.Wrap(errorNil, "KaspadMessage_Addresses is nil")
}
addressList, err := x.Addresses.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.MsgAddresses{
AddressList: addressList,
}, nil
}
func (x *AddressesMessage) toAppMessage() ([]*appmessage.NetAddress, error) {
if x == nil {
return nil, errors.Wrap(errorNil, "AddressesMessage is nil")
}
addressList := make([]*appmessage.NetAddress, len(protoAddresses.AddressList))
for i, address := range protoAddresses.AddressList {
if len(x.AddressList) > appmessage.MaxAddressesPerMsg {
return nil, errors.Errorf("too many addresses for message "+
"[count %d, max %d]", len(x.AddressList), appmessage.MaxAddressesPerMsg)
}
addressList := make([]*appmessage.NetAddress, len(x.AddressList))
for i, address := range x.AddressList {
var err error
addressList[i], err = address.toAppMessage()
if err != nil {
return nil, err
}
}
return &appmessage.MsgAddresses{
AddressList: addressList,
}, nil
return addressList, nil
}
func (x *KaspadMessage_Addresses) fromAppMessage(msgAddresses *appmessage.MsgAddresses) error {

16
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_block.go
View File

@ -6,6 +6,9 @@ import (
)
func (x *KaspadMessage_Block) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrap(errorNil, "KaspadMessage_Block is nil")
}
return x.Block.toAppMessage()
}
@ -15,21 +18,14 @@ func (x *KaspadMessage_Block) fromAppMessage(msgBlock *appmessage.MsgBlock) erro
}
func (x *BlockMessage) toAppMessage() (*appmessage.MsgBlock, error) {
if x == nil {
return nil, errors.Wrap(errorNil, "BlockMessage is nil")
}
if len(x.Transactions) > appmessage.MaxTxPerBlock {
return nil, errors.Errorf("too many transactions to fit into a block "+
"[count %d, max %d]", len(x.Transactions), appmessage.MaxTxPerBlock)
}
protoBlockHeader := x.Header
if protoBlockHeader == nil {
return nil, errors.New("block header field cannot be nil")
}
if len(protoBlockHeader.ParentHashes) > appmessage.MaxBlockParents {
return nil, errors.Errorf("block header has %d parents, but the maximum allowed amount "+
"is %d", len(protoBlockHeader.ParentHashes), appmessage.MaxBlockParents)
}
header, err := x.Header.toAppMessage()
if err != nil {
return nil, err

29
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_block_headers.go
View File

@ -1,10 +1,29 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_BlockHeaders) toAppMessage() (appmessage.Message, error) {
blockHeaders := make([]*appmessage.MsgBlockHeader, len(x.BlockHeaders.BlockHeaders))
for i, blockHeader := range x.BlockHeaders.BlockHeaders {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_BlockHeaders is nil")
}
blockHeaders, err := x.BlockHeaders.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.BlockHeadersMessage{
BlockHeaders: blockHeaders,
}, nil
}
func (x *BlockHeadersMessage) toAppMessage() ([]*appmessage.MsgBlockHeader, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "BlockHeadersMessage is nil")
}
blockHeaders := make([]*appmessage.MsgBlockHeader, len(x.BlockHeaders))
for i, blockHeader := range x.BlockHeaders {
var err error
blockHeaders[i], err = blockHeader.toAppMessage()
if err != nil {
@ -12,9 +31,7 @@ func (x *KaspadMessage_BlockHeaders) toAppMessage() (appmessage.Message, error)
}
}
return &appmessage.BlockHeadersMessage{
BlockHeaders: blockHeaders,
}, nil
return blockHeaders, nil
}
func (x *KaspadMessage_BlockHeaders) fromAppMessage(blockHeadersMessage *appmessage.BlockHeadersMessage) error {

19
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_block_locator.go
View File

@ -2,21 +2,32 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/pkg/errors"
)
func (x *KaspadMessage_BlockLocator) toAppMessage() (appmessage.Message, error) {
if len(x.BlockLocator.Hashes) > appmessage.MaxBlockLocatorsPerMsg {
return nil, errors.Errorf("too many block locator hashes for message "+
"[count %d, max %d]", len(x.BlockLocator.Hashes), appmessage.MaxBlockLocatorsPerMsg)
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_BlockLocator is nil")
}
hashes, err := protoHashesToDomain(x.BlockLocator.Hashes)
hashes, err := x.BlockLocator.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.MsgBlockLocator{BlockLocatorHashes: hashes}, nil
}
func (x *BlockLocatorMessage) toAppMessage() ([]*externalapi.DomainHash, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "BlockLocatorMessage is nil")
}
if len(x.Hashes) > appmessage.MaxBlockLocatorsPerMsg {
return nil, errors.Errorf("too many block locator hashes for message "+
"[count %d, max %d]", len(x.Hashes), appmessage.MaxBlockLocatorsPerMsg)
}
return protoHashesToDomain(x.Hashes)
}
func (x *KaspadMessage_BlockLocator) fromAppMessage(msgBlockLocator *appmessage.MsgBlockLocator) error {
if len(msgBlockLocator.BlockLocatorHashes) > appmessage.MaxBlockLocatorsPerMsg {
return errors.Errorf("too many block locator hashes for message "+

8
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_done_ibd_blocks.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_DoneHeaders) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_DoneHeaders is nil")
}
return &appmessage.MsgDoneHeaders{}, nil
}

8
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_done_pruning_point_utxo_set_chunks.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_DonePruningPointUtxoSetChunks) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_DonePruningPointUtxoSetChunks is nil")
}
return &appmessage.MsgDonePruningPointUTXOSetChunks{}, nil
}

6
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_header.go
View File

@ -8,6 +8,9 @@ import (
)
func (x *BlockHeaderMessage) toAppMessage() (*appmessage.MsgBlockHeader, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "BlockHeaderMessage is nil")
}
if len(x.ParentHashes) > appmessage.MaxBlockParents {
return nil, errors.Errorf("block header has %d parents, but the maximum allowed amount "+
"is %d", len(x.ParentHashes), appmessage.MaxBlockParents)
@ -17,17 +20,14 @@ func (x *BlockHeaderMessage) toAppMessage() (*appmessage.MsgBlockHeader, error)
if err != nil {
return nil, err
}
hashMerkleRoot, err := x.HashMerkleRoot.toDomain()
if err != nil {
return nil, err
}
acceptedIDMerkleRoot, err := x.AcceptedIdMerkleRoot.toDomain()
if err != nil {
return nil, err
}
utxoCommitment, err := x.UtxoCommitment.toDomain()
if err != nil {
return nil, err

8
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_ibd_block.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_IbdBlock) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_IbdBlock is nil")
}
msgBlock, err := x.IbdBlock.toAppMessage()
if err != nil {
return nil, err

15
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_ibd_block_locator.go
View File

@ -2,14 +2,25 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_IbdBlockLocator) toAppMessage() (appmessage.Message, error) {
targetHash, err := x.IbdBlockLocator.TargetHash.toDomain()
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_IbdBlockLocator is nil")
}
return x.IbdBlockLocator.toAppMessage()
}
func (x *IbdBlockLocatorMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "IbdBlockLocatorMessage is nil")
}
targetHash, err := x.TargetHash.toDomain()
if err != nil {
return nil, err
}
blockLocatorHash, err := protoHashesToDomain(x.IbdBlockLocator.BlockLocatorHashes)
blockLocatorHash, err := protoHashesToDomain(x.BlockLocatorHashes)
if err != nil {
return nil, err
}

18
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_ibd_block_locator_highest_hash.go
View File

@ -1,9 +1,22 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_IbdBlockLocatorHighestHash) toAppMessage() (appmessage.Message, error) {
highestHash, err := x.IbdBlockLocatorHighestHash.HighestHash.toDomain()
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_IbdBlockLocatorHighestHash is nil")
}
return x.IbdBlockLocatorHighestHash.toAppMessgage()
}
func (x *IbdBlockLocatorHighestHashMessage) toAppMessgage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "IbdBlockLocatorHighestHashMessage is nil")
}
highestHash, err := x.HighestHash.toDomain()
if err != nil {
return nil, err
}
@ -11,6 +24,7 @@ func (x *KaspadMessage_IbdBlockLocatorHighestHash) toAppMessage() (appmessage.Me
return &appmessage.MsgIBDBlockLocatorHighestHash{
HighestHash: highestHash,
}, nil
}
func (x *KaspadMessage_IbdBlockLocatorHighestHash) fromAppMessage(message *appmessage.MsgIBDBlockLocatorHighestHash) error {

8
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_ibd_block_locator_highest_hash_not_found.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_IbdBlockLocatorHighestHashNotFound) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_IbdBlockLocatorHighestHashNotFound is nil")
}
return &appmessage.MsgIBDBlockLocatorHighestHashNotFound{}, nil
}

18
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_inv_relay_block.go
View File

@ -1,14 +1,28 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_InvRelayBlock) toAppMessage() (appmessage.Message, error) {
hash, err := x.InvRelayBlock.Hash.toDomain()
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_InvRelayBlock is nil")
}
return x.InvRelayBlock.toAppMessage()
}
func (x *InvRelayBlockMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "InvRelayBlockMessage is nil")
}
hash, err := x.Hash.toDomain()
if err != nil {
return nil, err
}
return &appmessage.MsgInvRelayBlock{Hash: hash}, nil
}
func (x *KaspadMessage_InvRelayBlock) fromAppMessage(msgInvRelayBlock *appmessage.MsgInvRelayBlock) error {

17
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_inv_transactions.go
View File

@ -6,16 +6,27 @@ import (
)
func (x *KaspadMessage_InvTransactions) toAppMessage() (appmessage.Message, error) {
if len(x.InvTransactions.Ids) > appmessage.MaxInvPerTxInvMsg {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_InvTransactions is nil")
}
return x.InvTransactions.toAppMessage()
}
func (x *InvTransactionsMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "InvTransactionsMessage is nil")
}
if len(x.Ids) > appmessage.MaxInvPerTxInvMsg {
return nil, errors.Errorf("too many hashes for message "+
"[count %d, max %d]", len(x.InvTransactions.Ids), appmessage.MaxInvPerTxInvMsg)
"[count %d, max %d]", len(x.Ids), appmessage.MaxInvPerTxInvMsg)
}
ids, err := protoTransactionIDsToDomain(x.InvTransactions.Ids)
ids, err := protoTransactionIDsToDomain(x.Ids)
if err != nil {
return nil, err
}
return &appmessage.MsgInvTransaction{TxIDs: ids}, nil
}
func (x *KaspadMessage_InvTransactions) fromAppMessage(msgInvTransaction *appmessage.MsgInvTransaction) error {

13
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_ping.go
View File

@ -2,11 +2,22 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_Ping) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_Ping is nil")
}
return x.Ping.toAppMessage()
}
func (x *PingMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "PingMessage is nil")
}
return &appmessage.MsgPing{
Nonce: x.Ping.Nonce,
Nonce: x.Nonce,
}, nil
}

13
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_pong.go
View File

@ -2,11 +2,22 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_Pong) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_Pong is nil")
}
return x.Pong.toAppMessage()
}
func (x *PongMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "PongMessage is nil")
}
return &appmessage.MsgPong{
Nonce: x.Pong.Nonce,
Nonce: x.Nonce,
}, nil
}

19
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_pruning_point_hash.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_PruningPointHash) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_PruningPointHash is nil")
}
hash, err := x.PruningPointHash.Hash.toDomain()
if err != nil {
return nil, err
@ -11,6 +17,17 @@ func (x *KaspadMessage_PruningPointHash) toAppMessage() (appmessage.Message, err
return &appmessage.MsgPruningPointHashMessage{Hash: hash}, nil
}
func (x *PruningPointHashMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "PruningPointHashMessage is nil")
}
hash, err := x.Hash.toDomain()
if err != nil {
return nil, err
}
return &appmessage.MsgPruningPointHashMessage{Hash: hash}, nil
}
func (x *KaspadMessage_PruningPointHash) fromAppMessage(msgPruningPointHash *appmessage.MsgPruningPointHashMessage) error {
x.PruningPointHash = &PruningPointHashMessage{
Hash: domainHashToProto(msgPruningPointHash.Hash),

47
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_pruning_point_utxo_set_chunk.go
View File

@ -2,45 +2,44 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/pkg/errors"
"math"
)
func (x *KaspadMessage_PruningPointUtxoSetChunk) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_PruningPointUtxoSetChunk is nil")
}
outpointAndUTXOEntryPairs := make([]*appmessage.OutpointAndUTXOEntryPair, len(x.PruningPointUtxoSetChunk.OutpointAndUtxoEntryPairs))
for i, outpointAndUTXOEntryPair := range x.PruningPointUtxoSetChunk.OutpointAndUtxoEntryPairs {
transactionID, err := outpointAndUTXOEntryPair.Outpoint.TransactionId.toDomain()
outpointEntryPairAppMessage, err := outpointAndUTXOEntryPair.toAppMessage()
if err != nil {
return nil, err
}
outpoint := &appmessage.Outpoint{
TxID: *transactionID,
Index: outpointAndUTXOEntryPair.Outpoint.Index,
}
if outpointAndUTXOEntryPair.UtxoEntry.ScriptPublicKey.Version > math.MaxUint16 {
return nil, errors.Errorf("ScriptPublicKey version is bigger then uint16.")
}
scriptPublicKey := &externalapi.ScriptPublicKey{
Script: outpointAndUTXOEntryPair.UtxoEntry.ScriptPublicKey.Script,
Version: uint16(outpointAndUTXOEntryPair.UtxoEntry.ScriptPublicKey.Version),
}
utxoEntry := &appmessage.UTXOEntry{
Amount: outpointAndUTXOEntryPair.UtxoEntry.Amount,
ScriptPublicKey: scriptPublicKey,
BlockBlueScore: outpointAndUTXOEntryPair.UtxoEntry.BlockBlueScore,
IsCoinbase: outpointAndUTXOEntryPair.UtxoEntry.IsCoinbase,
}
outpointAndUTXOEntryPairs[i] = &appmessage.OutpointAndUTXOEntryPair{
Outpoint: outpoint,
UTXOEntry: utxoEntry,
}
outpointAndUTXOEntryPairs[i] = outpointEntryPairAppMessage
}
return &appmessage.MsgPruningPointUTXOSetChunk{
OutpointAndUTXOEntryPairs: outpointAndUTXOEntryPairs,
}, nil
}
func (x *OutpointAndUtxoEntryPair) toAppMessage() (*appmessage.OutpointAndUTXOEntryPair, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "OutpointAndUtxoEntryPair is nil")
}
outpoint, err := x.Outpoint.toAppMessage()
if err != nil {
return nil, err
}
utxoEntry, err := x.UtxoEntry.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.OutpointAndUTXOEntryPair{
Outpoint: outpoint,
UTXOEntry: utxoEntry,
}, nil
}
func (x *KaspadMessage_PruningPointUtxoSetChunk) fromAppMessage(message *appmessage.MsgPruningPointUTXOSetChunk) error {
outpointAndUTXOEntryPairs := make([]*OutpointAndUtxoEntryPair, len(message.OutpointAndUTXOEntryPairs))
for i, outpointAndUTXOEntryPair := range message.OutpointAndUTXOEntryPairs {

13
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_reject.go
View File

@ -2,11 +2,22 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_Reject) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_Reject is nil")
}
return x.Reject.toAppMessage()
}
func (x *RejectMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RejectMessage is nil")
}
return &appmessage.MsgReject{
Reason: x.Reject.Reason,
Reason: x.Reason,
}, nil
}

20
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_addresses.go
View File

@ -2,19 +2,31 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_RequestAddresses) toAppMessage() (appmessage.Message, error) {
protoGetAddresses := x.RequestAddresses
subnetworkID, err := protoGetAddresses.SubnetworkId.toDomain()
if err != nil {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestAddresses is nil")
}
return x.RequestAddresses.toAppMessage()
}
func (x *RequestAddressesMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RequestAddressesMessage is nil")
}
subnetworkID, err := x.SubnetworkId.toDomain()
// Full kaspa nodes set SubnetworkId==nil
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.MsgRequestAddresses{
IncludeAllSubnetworks: protoGetAddresses.IncludeAllSubnetworks,
IncludeAllSubnetworks: x.IncludeAllSubnetworks,
SubnetworkID: subnetworkID,
}, nil
}
func (x *KaspadMessage_RequestAddresses) fromAppMessage(msgGetAddresses *appmessage.MsgRequestAddresses) error {

22
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_block_locator.go
View File

@ -1,14 +1,27 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_RequestBlockLocator) toAppMessage() (appmessage.Message, error) {
lowHash, err := x.RequestBlockLocator.LowHash.toDomain()
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestBlockLocator is nil")
}
return x.RequestBlockLocator.toAppMessage()
}
func (x *RequestBlockLocatorMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RequestBlockLocatorMessage is nil")
}
lowHash, err := x.LowHash.toDomain()
if err != nil {
return nil, err
}
highHash, err := x.RequestBlockLocator.HighHash.toDomain()
highHash, err := x.HighHash.toDomain()
if err != nil {
return nil, err
}
@ -16,8 +29,9 @@ func (x *KaspadMessage_RequestBlockLocator) toAppMessage() (appmessage.Message,
return &appmessage.MsgRequestBlockLocator{
LowHash: lowHash,
HighHash: highHash,
Limit: x.RequestBlockLocator.Limit,
Limit: x.Limit,
}, nil
}
func (x *KaspadMessage_RequestBlockLocator) fromAppMessage(msgGetBlockLocator *appmessage.MsgRequestBlockLocator) error {

28
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_headers.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_RequestHeaders) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestBlockLocator is nil")
}
lowHash, err := x.RequestHeaders.LowHash.toDomain()
if err != nil {
return nil, err
@ -18,6 +24,26 @@ func (x *KaspadMessage_RequestHeaders) toAppMessage() (appmessage.Message, error
HighHash: highHash,
}, nil
}
func (x *RequestHeadersMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RequestHeadersMessage is nil")
}
lowHash, err := x.LowHash.toDomain()
if err != nil {
return nil, err
}
highHash, err := x.HighHash.toDomain()
if err != nil {
return nil, err
}
return &appmessage.MsgRequestHeaders{
LowHash: lowHash,
HighHash: highHash,
}, nil
}
func (x *KaspadMessage_RequestHeaders) fromAppMessage(msgRequestHeaders *appmessage.MsgRequestHeaders) error {
x.RequestHeaders = &RequestHeadersMessage{

13
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_ibd_blocks.go
View File

@ -2,10 +2,21 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_RequestIBDBlocks) toAppMessage() (appmessage.Message, error) {
hashes, err := protoHashesToDomain(x.RequestIBDBlocks.Hashes)
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestIBDBlocks is nil")
}
return x.RequestIBDBlocks.toAppMessage()
}
func (x *RequestIBDBlocksMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RequestIBDBlocksMessage is nil")
}
hashes, err := protoHashesToDomain(x.Hashes)
if err != nil {
return nil, err
}

8
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_next_headers.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_RequestNextHeaders) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestNextHeaders is nil")
}
return &appmessage.MsgRequestNextHeaders{}, nil
}

8
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_next_pruning_point_utxo_set_chunk.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_RequestNextPruningPointUtxoSetChunk) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestNextPruningPointUtxoSetChunk is nil")
}
return &appmessage.MsgRequestNextPruningPointUTXOSetChunk{}, nil
}

8
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_pruning_point_hash.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_RequestPruningPointHash) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestPruningPointHash is nil")
}
return &appmessage.MsgRequestPruningPointHashMessage{}, nil
}

17
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_pruning_point_utxo_set_and_block.go
View File

@ -1,9 +1,22 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_RequestPruningPointUTXOSetAndBlock) toAppMessage() (appmessage.Message, error) {
pruningPointHash, err := x.RequestPruningPointUTXOSetAndBlock.PruningPointHash.toDomain()
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestPruningPointUTXOSetAndBlock is nil")
}
return x.RequestPruningPointUTXOSetAndBlock.toAppMessage()
}
func (x *RequestPruningPointUTXOSetAndBlockMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RequestPruningPointUTXOSetAndBlockMessage is nil")
}
pruningPointHash, err := x.PruningPointHash.toDomain()
if err != nil {
return nil, err
}

19
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_relay_blocks.go
View File

@ -6,15 +6,26 @@ import (
)
func (x *KaspadMessage_RequestRelayBlocks) toAppMessage() (appmessage.Message, error) {
if len(x.RequestRelayBlocks.Hashes) > appmessage.MaxRequestRelayBlocksHashes {
return nil, errors.Errorf("too many hashes for message "+
"[count %d, max %d]", len(x.RequestRelayBlocks.Hashes), appmessage.MaxRequestRelayBlocksHashes)
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestRelayBlocks is nil")
}
hashes, err := protoHashesToDomain(x.RequestRelayBlocks.Hashes)
return x.RequestRelayBlocks.toAppMessage()
}
func (x *RequestRelayBlocksMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RequestRelayBlocksMessage is nil")
}
if len(x.Hashes) > appmessage.MaxRequestRelayBlocksHashes {
return nil, errors.Errorf("too many hashes for message "+
"[count %d, max %d]", len(x.Hashes), appmessage.MaxRequestRelayBlocksHashes)
}
hashes, err := protoHashesToDomain(x.Hashes)
if err != nil {
return nil, err
}
return &appmessage.MsgRequestRelayBlocks{Hashes: hashes}, nil
}
func (x *KaspadMessage_RequestRelayBlocks) fromAppMessage(msgGetRelayBlocks *appmessage.MsgRequestRelayBlocks) error {

17
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_request_transactions.go
View File

@ -6,12 +6,21 @@ import (
)
func (x *KaspadMessage_RequestTransactions) toAppMessage() (appmessage.Message, error) {
if len(x.RequestTransactions.Ids) > appmessage.MaxInvPerRequestTransactionsMsg {
return nil, errors.Errorf("too many hashes for message "+
"[count %d, max %d]", len(x.RequestTransactions.Ids), appmessage.MaxInvPerRequestTransactionsMsg)
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_RequestTransactions is nil")
}
return x.RequestTransactions.toAppMessage()
}
ids, err := protoTransactionIDsToDomain(x.RequestTransactions.Ids)
func (x *RequestTransactionsMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RequestTransactionsMessage is nil")
}
if len(x.Ids) > appmessage.MaxInvPerRequestTransactionsMsg {
return nil, errors.Errorf("too many hashes for message "+
"[count %d, max %d]", len(x.Ids), appmessage.MaxInvPerRequestTransactionsMsg)
}
ids, err := protoTransactionIDsToDomain(x.Ids)
if err != nil {
return nil, err
}

51
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_transaction.go
View File

@ -8,6 +8,9 @@ import (
)
func (x *KaspadMessage_Transaction) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_Transaction is nil")
}
return x.Transaction.toAppMessage()
}
@ -18,30 +21,25 @@ func (x *KaspadMessage_Transaction) fromAppMessage(msgTx *appmessage.MsgTx) erro
}
func (x *TransactionMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "TransactionMessage is nil")
}
inputs := make([]*appmessage.TxIn, len(x.Inputs))
for i, protoInput := range x.Inputs {
prevTxID, err := protoInput.PreviousOutpoint.TransactionId.toDomain()
input, err := protoInput.toAppMessage()
if err != nil {
return nil, err
}
outpoint := appmessage.NewOutpoint(prevTxID, protoInput.PreviousOutpoint.Index)
inputs[i] = appmessage.NewTxIn(outpoint, protoInput.SignatureScript, protoInput.Sequence)
inputs[i] = input
}
outputs := make([]*appmessage.TxOut, len(x.Outputs))
for i, protoOutput := range x.Outputs {
if protoOutput.ScriptPublicKey.Version > math.MaxUint16 {
return nil, errors.Errorf("The version on ScriptPublicKey is bigger then uint16.")
output, err := protoOutput.toAppMessage()
if err != nil {
return nil, err
}
outputs[i] = &appmessage.TxOut{
Value: protoOutput.Value,
ScriptPubKey: &externalapi.ScriptPublicKey{protoOutput.ScriptPublicKey.Script, uint16(protoOutput.ScriptPublicKey.Version)},
}
}
if x.SubnetworkId == nil {
return nil, errors.New("transaction subnetwork field cannot be nil")
outputs[i] = output
}
subnetworkID, err := x.SubnetworkId.toDomain()
@ -71,6 +69,31 @@ func (x *TransactionMessage) toAppMessage() (appmessage.Message, error) {
}, nil
}
func (x *TransactionInput) toAppMessage() (*appmessage.TxIn, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "TransactionInput is nil")
}
outpoint, err := x.PreviousOutpoint.toAppMessage()
if err != nil {
return nil, err
}
return appmessage.NewTxIn(outpoint, x.SignatureScript, x.Sequence), nil
}
func (x *TransactionOutput) toAppMessage() (*appmessage.TxOut, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "TransactionOutput is nil")
}
scriptPublicKey, err := x.ScriptPublicKey.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.TxOut{
Value: x.Value,
ScriptPubKey: scriptPublicKey,
}, nil
}
func (x *TransactionMessage) fromAppMessage(msgTx *appmessage.MsgTx) {
protoInputs := make([]*TransactionInput, len(msgTx.TxIn))
for i, input := range msgTx.TxIn {

13
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_transaction_not_found.go
View File

@ -2,10 +2,21 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_TransactionNotFound) toAppMessage() (appmessage.Message, error) {
id, err := x.TransactionNotFound.Id.toDomain()
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_TransactionNotFound is nil")
}
return x.TransactionNotFound.toAppMessage()
}
func (x *TransactionNotFoundMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "TransactionNotFoundMessage is nil")
}
id, err := x.Id.toDomain()
if err != nil {
return nil, err
}

8
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_verack.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_Verack) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_Verack is nil")
}
return &appmessage.MsgVerAck{}, nil
}

44
infrastructure/network/netadapter/server/grpcserver/protowire/p2p_version.go
View File

@ -4,38 +4,46 @@ import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
"github.com/kaspanet/kaspad/util/mstime"
"github.com/pkg/errors"
)
func (x *KaspadMessage_Version) toAppMessage() (appmessage.Message, error) {
// Address is optional for non-listening nodes
var address *appmessage.NetAddress
if x.Version.Address != nil {
var err error
address, err = x.Version.Address.toAppMessage()
if err != nil {
return nil, err
}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_Version is nil")
}
return x.Version.toAppMessage()
}
subnetworkID, err := x.Version.SubnetworkId.toDomain()
if err != nil {
func (x *VersionMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "VersionMessage is nil")
}
address, err := x.Address.toAppMessage()
// Address is optional for non-listening nodes
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
err = appmessage.ValidateUserAgent(x.Version.UserAgent)
subnetworkID, err := x.SubnetworkId.toDomain()
// Full kaspa nodes set SubnetworkId==nil
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
err = appmessage.ValidateUserAgent(x.UserAgent)
if err != nil {
return nil, err
}
return &appmessage.MsgVersion{
ProtocolVersion: x.Version.ProtocolVersion,
Network: x.Version.Network,
Services: appmessage.ServiceFlag(x.Version.Services),
Timestamp: mstime.UnixMilliseconds(x.Version.Timestamp),
ProtocolVersion: x.ProtocolVersion,
Network: x.Network,
Services: appmessage.ServiceFlag(x.Services),
Timestamp: mstime.UnixMilliseconds(x.Timestamp),
Address: address,
ID: id.FromBytes(x.Version.Id),
UserAgent: x.Version.UserAgent,
DisableRelayTx: x.Version.DisableRelayTx,
ID: id.FromBytes(x.Id),
UserAgent: x.UserAgent,
DisableRelayTx: x.DisableRelayTx,
SubnetworkID: subnetworkID,
}, nil
}

46
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_add_peer.go
View File

@ -1,12 +1,15 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_AddPeerRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.AddPeerRequestMessage{
Address: x.AddPeerRequest.Address,
IsPermanent: x.AddPeerRequest.IsPermanent,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_AddPeerRequest is nil")
}
return x.AddPeerRequest.toAppMessage()
}
func (x *KaspadMessage_AddPeerRequest) fromAppMessage(message *appmessage.AddPeerRequestMessage) error {
@ -17,16 +20,23 @@ func (x *KaspadMessage_AddPeerRequest) fromAppMessage(message *appmessage.AddPee
return nil
}
func (x *KaspadMessage_AddPeerResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.AddPeerResponse.Error != nil {
err = &appmessage.RPCError{Message: x.AddPeerResponse.Error.Message}
func (x *AddPeerRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "AddPeerRequestMessage is nil")
}
return &appmessage.AddPeerResponseMessage{
Error: err,
return &appmessage.AddPeerRequestMessage{
Address: x.Address,
IsPermanent: x.IsPermanent,
}, nil
}
func (x *KaspadMessage_AddPeerResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_AddPeerResponse is nil")
}
return x.AddPeerResponse.toAppMessage()
}
func (x *KaspadMessage_AddPeerResponse) fromAppMessage(message *appmessage.AddPeerResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -37,3 +47,17 @@ func (x *KaspadMessage_AddPeerResponse) fromAppMessage(message *appmessage.AddPe
}
return nil
}
func (x *AddPeerResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "AddPeerResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.AddPeerResponseMessage{
Error: rpcErr,
}, nil
}

32
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_ban.go
View File

@ -2,11 +2,22 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_BanRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_BanRequest is nil")
}
return x.BanRequest.toAppMessage()
}
func (x *BanRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "BanRequestMessage is nil")
}
return &appmessage.BanRequestMessage{
IP: x.BanRequest.Ip,
IP: x.Ip,
}, nil
}
@ -16,12 +27,23 @@ func (x *KaspadMessage_BanRequest) fromAppMessage(message *appmessage.BanRequest
}
func (x *KaspadMessage_BanResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.BanResponse.Error != nil {
err = &appmessage.RPCError{Message: x.BanResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_BanResponse is nil")
}
return x.BanResponse.toAppMessage()
}
func (x *BanResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "BanResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.BanResponseMessage{
Error: err,
Error: rpcErr,
}, nil
}

13
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_error.go Normal file
View File

@ -0,0 +1,13 @@
package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *RPCError) toAppMessage() (*appmessage.RPCError, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RPCError is nil")
}
return &appmessage.RPCError{Message: x.Message}, nil
}

129
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_block.go
View File

@ -8,9 +8,19 @@ import (
)
func (x *KaspadMessage_GetBlockRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlockRequest is nil")
}
return x.GetBlockRequest.toAppMessage()
}
func (x *GetBlockRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetBlockRequestMessage is nil")
}
return &appmessage.GetBlockRequestMessage{
Hash: x.GetBlockRequest.Hash,
IncludeTransactionVerboseData: x.GetBlockRequest.IncludeTransactionVerboseData,
Hash: x.Hash,
IncludeTransactionVerboseData: x.IncludeTransactionVerboseData,
}, nil
}
@ -23,21 +33,35 @@ func (x *KaspadMessage_GetBlockRequest) fromAppMessage(message *appmessage.GetBl
}
func (x *KaspadMessage_GetBlockResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetBlockResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetBlockResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlockResponse is nil")
}
return x.GetBlockResponse.toAppMessage()
}
func (x *GetBlockResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetBlockResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
var blockVerboseData *appmessage.BlockVerboseData
if x.GetBlockResponse.BlockVerboseData != nil {
appBlockVerboseData, err := x.GetBlockResponse.BlockVerboseData.toAppMessage()
// Return verbose data only if there's no error
if rpcErr != nil && x.BlockVerboseData != nil {
return nil, errors.New("GetBlockResponseMessage contains both an error and a response")
}
if rpcErr == nil {
blockVerboseData, err = x.BlockVerboseData.toAppMessage()
if err != nil {
return nil, err
}
blockVerboseData = appBlockVerboseData
}
return &appmessage.GetBlockResponseMessage{
BlockVerboseData: blockVerboseData,
Error: err,
Error: rpcErr,
}, nil
}
@ -63,6 +87,9 @@ func (x *KaspadMessage_GetBlockResponse) fromAppMessage(message *appmessage.GetB
}
func (x *BlockVerboseData) toAppMessage() (*appmessage.BlockVerboseData, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "BlockVerboseData is nil")
}
transactionVerboseData := make([]*appmessage.TransactionVerboseData, len(x.TransactionVerboseData))
for i, transactionVerboseDatum := range x.TransactionVerboseData {
appTransactionVerboseDatum, err := transactionVerboseDatum.toAppMessage()
@ -130,32 +157,24 @@ func (x *BlockVerboseData) fromAppMessage(message *appmessage.BlockVerboseData)
}
func (x *TransactionVerboseData) toAppMessage() (*appmessage.TransactionVerboseData, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "TransactionVerboseData is nil")
}
inputs := make([]*appmessage.TransactionVerboseInput, len(x.TransactionVerboseInputs))
for j, item := range x.TransactionVerboseInputs {
scriptSig := &appmessage.ScriptSig{
Asm: item.ScriptSig.Asm,
Hex: item.ScriptSig.Hex,
}
inputs[j] = &appmessage.TransactionVerboseInput{
TxID: item.TxId,
OutputIndex: item.OutputIndex,
ScriptSig: scriptSig,
Sequence: item.Sequence,
input, err := item.toAppMessage()
if err != nil {
return nil, err
}
inputs[j] = input
}
outputs := make([]*appmessage.TransactionVerboseOutput, len(x.TransactionVerboseOutputs))
for j, item := range x.TransactionVerboseOutputs {
scriptPubKey := &appmessage.ScriptPubKeyResult{
Hex: item.ScriptPublicKey.Hex,
Type: item.ScriptPublicKey.Type,
Address: item.ScriptPublicKey.Address,
Version: uint16(item.ScriptPublicKey.Version),
}
outputs[j] = &appmessage.TransactionVerboseOutput{
Value: item.Value,
Index: item.Index,
ScriptPubKey: scriptPubKey,
output, err := item.toAppMessage()
if err != nil {
return nil, err
}
outputs[j] = output
}
if x.Version > math.MaxUint16 {
return nil, errors.Errorf("Invalid transaction version - bigger then uint16")
@ -224,3 +243,57 @@ func (x *TransactionVerboseData) fromAppMessage(message *appmessage.TransactionV
}
return nil
}
func (x *TransactionVerboseInput) toAppMessage() (*appmessage.TransactionVerboseInput, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "TransactionVerboseInput is nil")
}
scriptSig, err := x.ScriptSig.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.TransactionVerboseInput{
TxID: x.TxId,
OutputIndex: x.OutputIndex,
ScriptSig: scriptSig,
Sequence: x.Sequence,
}, nil
}
func (x *TransactionVerboseOutput) toAppMessage() (*appmessage.TransactionVerboseOutput, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "TransactionVerboseOutput is nil")
}
scriptPubKey, err := x.ScriptPublicKey.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.TransactionVerboseOutput{
Value: x.Value,
Index: x.Index,
ScriptPubKey: scriptPubKey,
}, nil
}
func (x *ScriptSig) toAppMessage() (*appmessage.ScriptSig, error) {
if x == nil {
return nil, errors.Wrap(errorNil, "ScriptSig is nil")
}
return &appmessage.ScriptSig{
Asm: x.Asm,
Hex: x.Hex,
}, nil
}
func (x *ScriptPublicKeyResult) toAppMessage() (*appmessage.ScriptPubKeyResult, error) {
if x == nil {
return nil, errors.Wrap(errorNil, "ScriptPublicKeyResult is nil")
}
return &appmessage.ScriptPubKeyResult{
Hex: x.Hex,
Type: x.Type,
Address: x.Address,
Version: uint16(x.Version),
}, nil
}

38
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_block_count.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetBlockCountRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlockCountRequest is nil")
}
return &appmessage.GetBlockCountRequestMessage{}, nil
}
@ -12,15 +18,10 @@ func (x *KaspadMessage_GetBlockCountRequest) fromAppMessage(_ *appmessage.GetBlo
}
func (x *KaspadMessage_GetBlockCountResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetBlockCountResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetBlockCountResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlockCountResponse is nil")
}
return &appmessage.GetBlockCountResponseMessage{
BlockCount: x.GetBlockCountResponse.BlockCount,
HeaderCount: x.GetBlockCountResponse.HeaderCount,
Error: err,
}, nil
return x.GetBlockCountResponse.toAppMessage()
}
func (x *KaspadMessage_GetBlockCountResponse) fromAppMessage(message *appmessage.GetBlockCountResponseMessage) error {
@ -35,3 +36,22 @@ func (x *KaspadMessage_GetBlockCountResponse) fromAppMessage(message *appmessage
}
return nil
}
func (x *GetBlockCountResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetBlockCountResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && (x.BlockCount != 0 || x.HeaderCount != 0) {
return nil, errors.New("GetBlockCountResponseMessage contains both an error and a response")
}
return &appmessage.GetBlockCountResponseMessage{
BlockCount: x.BlockCount,
HeaderCount: x.HeaderCount,
Error: rpcErr,
}, nil
}

42
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_block_dag_info.go
View File

@ -2,9 +2,13 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetBlockDagInfoRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlockDagInfoRequest is nil")
}
return &appmessage.GetBlockDAGInfoRequestMessage{}, nil
}
@ -14,20 +18,34 @@ func (x *KaspadMessage_GetBlockDagInfoRequest) fromAppMessage(_ *appmessage.GetB
}
func (x *KaspadMessage_GetBlockDagInfoResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetBlockDagInfoResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetBlockDagInfoResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlockDagInfoResponse is nil")
}
return x.GetBlockDagInfoResponse.toAppMessage()
}
func (x *GetBlockDagInfoResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetBlockDagInfoResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && (x.NetworkName != "" || x.BlockCount != 0 || x.HeaderCount != 0 || len(x.TipHashes) != 0 || len(x.VirtualParentHashes) != 0 || x.Difficulty != 0 || x.PastMedianTime != 0 || x.PruningPointHash != "") {
return nil, errors.New("GetBlockDagInfoResponseMessage contains both an error and a response")
}
return &appmessage.GetBlockDAGInfoResponseMessage{
NetworkName: x.GetBlockDagInfoResponse.NetworkName,
BlockCount: x.GetBlockDagInfoResponse.BlockCount,
HeaderCount: x.GetBlockDagInfoResponse.HeaderCount,
TipHashes: x.GetBlockDagInfoResponse.TipHashes,
VirtualParentHashes: x.GetBlockDagInfoResponse.VirtualParentHashes,
Difficulty: x.GetBlockDagInfoResponse.Difficulty,
PastMedianTime: x.GetBlockDagInfoResponse.PastMedianTime,
PruningPointHash: x.GetBlockDagInfoResponse.PruningPointHash,
Error: err,
NetworkName: x.NetworkName,
BlockCount: x.BlockCount,
HeaderCount: x.HeaderCount,
TipHashes: x.TipHashes,
VirtualParentHashes: x.VirtualParentHashes,
Difficulty: x.Difficulty,
PastMedianTime: x.PastMedianTime,
PruningPointHash: x.PruningPointHash,
Error: rpcErr,
}, nil
}

37
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_block_template.go
View File

@ -2,12 +2,14 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetBlockTemplateRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetBlockTemplateRequestMessage{
PayAddress: x.GetBlockTemplateRequest.PayAddress,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlockTemplateRequest is nil")
}
return x.GetBlockTemplateRequest.toAppMessage()
}
func (x *KaspadMessage_GetBlockTemplateRequest) fromAppMessage(message *appmessage.GetBlockTemplateRequestMessage) error {
@ -17,12 +19,20 @@ func (x *KaspadMessage_GetBlockTemplateRequest) fromAppMessage(message *appmessa
return nil
}
func (x *KaspadMessage_GetBlockTemplateResponse) toAppMessage() (appmessage.Message, error) {
msgBlock, err := x.GetBlockTemplateResponse.BlockMessage.toAppMessage()
if err != nil {
return nil, err
func (x *GetBlockTemplateRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetBlockTemplateRequestMessage is nil")
}
return appmessage.NewGetBlockTemplateResponseMessage(msgBlock, x.GetBlockTemplateResponse.IsSynced), nil
return &appmessage.GetBlockTemplateRequestMessage{
PayAddress: x.PayAddress,
}, nil
}
func (x *KaspadMessage_GetBlockTemplateResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlockTemplateResponse is nil")
}
return x.GetBlockTemplateResponse.toAppMessage()
}
func (x *KaspadMessage_GetBlockTemplateResponse) fromAppMessage(message *appmessage.GetBlockTemplateResponseMessage) error {
@ -32,3 +42,14 @@ func (x *KaspadMessage_GetBlockTemplateResponse) fromAppMessage(message *appmess
}
return x.GetBlockTemplateResponse.BlockMessage.fromAppMessage(message.MsgBlock)
}
func (x *GetBlockTemplateResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetBlockTemplateResponseMessage is nil")
}
msgBlock, err := x.BlockMessage.toAppMessage()
if err != nil {
return nil, err
}
return appmessage.NewGetBlockTemplateResponseMessage(msgBlock, x.IsSynced), nil
}

74
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_blocks.go
View File

@ -1,13 +1,15 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetBlocksRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetBlocksRequestMessage{
LowHash: x.GetBlocksRequest.LowHash,
IncludeBlockVerboseData: x.GetBlocksRequest.IncludeBlockVerboseData,
IncludeTransactionVerboseData: x.GetBlocksRequest.IncludeTransactionVerboseData,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlocksRequest is nil")
}
return x.GetBlocksRequest.toAppMessage()
}
func (x *KaspadMessage_GetBlocksRequest) fromAppMessage(message *appmessage.GetBlocksRequestMessage) error {
@ -19,27 +21,22 @@ func (x *KaspadMessage_GetBlocksRequest) fromAppMessage(message *appmessage.GetB
return nil
}
func (x *KaspadMessage_GetBlocksResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetBlocksResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetBlocksResponse.Error.Message}
}
appMessage := &appmessage.GetBlocksResponseMessage{
BlockHashes: x.GetBlocksResponse.BlockHashes,
Error: err,
}
if x.GetBlocksResponse.BlockVerboseData != nil {
appMessage.BlockVerboseData = make([]*appmessage.BlockVerboseData, len(x.GetBlocksResponse.BlockVerboseData))
for i, blockVerboseDatum := range x.GetBlocksResponse.BlockVerboseData {
appBlockVerboseDatum, err := blockVerboseDatum.toAppMessage()
if err != nil {
return nil, err
}
appMessage.BlockVerboseData[i] = appBlockVerboseDatum
}
func (x *GetBlocksRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetBlocksRequestMessage is nil")
}
return &appmessage.GetBlocksRequestMessage{
LowHash: x.LowHash,
IncludeBlockVerboseData: x.IncludeBlockVerboseData,
IncludeTransactionVerboseData: x.IncludeTransactionVerboseData,
}, nil
}
return appMessage, nil
func (x *KaspadMessage_GetBlocksResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetBlocksResponse is nil")
}
return x.GetBlocksResponse.toAppMessage()
}
func (x *KaspadMessage_GetBlocksResponse) fromAppMessage(message *appmessage.GetBlocksResponseMessage) error {
@ -64,3 +61,30 @@ func (x *KaspadMessage_GetBlocksResponse) fromAppMessage(message *appmessage.Get
}
return nil
}
func (x *GetBlocksResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetBlocksResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
// Return verbose data only if there's no error
if rpcErr != nil && len(x.BlockVerboseData) != 0 {
return nil, errors.New("GetBlocksResponseMessage contains both an error and a response")
}
blocksVerboseData := make([]*appmessage.BlockVerboseData, len(x.BlockVerboseData))
for i, blockVerboseDatum := range x.BlockVerboseData {
appBlockVerboseDatum, err := blockVerboseDatum.toAppMessage()
if err != nil {
return nil, err
}
blocksVerboseData[i] = appBlockVerboseDatum
}
return &appmessage.GetBlocksResponseMessage{
BlockVerboseData: blocksVerboseData,
Error: rpcErr,
}, nil
}

70
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_connected_peer_info.go
View File

@ -2,6 +2,7 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetConnectedPeerInfoRequest) toAppMessage() (appmessage.Message, error) {
@ -13,28 +14,10 @@ func (x *KaspadMessage_GetConnectedPeerInfoRequest) fromAppMessage(_ *appmessage
}
func (x *KaspadMessage_GetConnectedPeerInfoResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetConnectedPeerInfoResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetConnectedPeerInfoResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetConnectedPeerInfoResponse is nil")
}
infos := make([]*appmessage.GetConnectedPeerInfoMessage, len(x.GetConnectedPeerInfoResponse.Infos))
for i, info := range x.GetConnectedPeerInfoResponse.Infos {
infos[i] = &appmessage.GetConnectedPeerInfoMessage{
ID: info.Id,
Address: info.Address,
LastPingDuration: info.LastPingDuration,
IsOutbound: info.IsOutbound,
TimeOffset: info.TimeOffset,
UserAgent: info.UserAgent,
AdvertisedProtocolVersion: info.AdvertisedProtocolVersion,
TimeConnected: info.TimeOffset,
IsIBDPeer: info.IsIbdPeer,
}
}
return &appmessage.GetConnectedPeerInfoResponseMessage{
Infos: infos,
Error: err,
}, nil
return x.GetConnectedPeerInfoResponse.toAppMessage()
}
func (x *KaspadMessage_GetConnectedPeerInfoResponse) fromAppMessage(message *appmessage.GetConnectedPeerInfoResponseMessage) error {
@ -62,3 +45,48 @@ func (x *KaspadMessage_GetConnectedPeerInfoResponse) fromAppMessage(message *app
}
return nil
}
func (x *GetConnectedPeerInfoResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetConnectedPeerInfoResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
// Return verbose data only if there's no error
if rpcErr != nil && len(x.Infos) != 0 {
return nil, errors.New("GetConnectedPeerInfoResponseMessage contains both an error and a response")
}
infos := make([]*appmessage.GetConnectedPeerInfoMessage, len(x.Infos))
for i, info := range x.Infos {
appInfo, err := info.toAppMessage()
if err != nil {
return nil, err
}
infos[i] = appInfo
}
return &appmessage.GetConnectedPeerInfoResponseMessage{
Infos: infos,
Error: rpcErr,
}, nil
}
func (x *GetConnectedPeerInfoMessage) toAppMessage() (*appmessage.GetConnectedPeerInfoMessage, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetConnectedPeerInfoMessage is nil")
}
return &appmessage.GetConnectedPeerInfoMessage{
ID: x.Id,
Address: x.Address,
LastPingDuration: x.LastPingDuration,
IsOutbound: x.IsOutbound,
TimeOffset: x.TimeOffset,
UserAgent: x.UserAgent,
AdvertisedProtocolVersion: x.AdvertisedProtocolVersion,
TimeConnected: x.TimeOffset,
IsIBDPeer: x.IsIbdPeer,
}, nil
}

35
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_current_network.go
View File

@ -1,6 +1,9 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetCurrentNetworkRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetCurrentNetworkRequestMessage{}, nil
@ -11,14 +14,10 @@ func (x *KaspadMessage_GetCurrentNetworkRequest) fromAppMessage(_ *appmessage.Ge
}
func (x *KaspadMessage_GetCurrentNetworkResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetCurrentNetworkResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetCurrentNetworkResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetCurrentNetworkResponse is nil")
}
return &appmessage.GetCurrentNetworkResponseMessage{
CurrentNetwork: x.GetCurrentNetworkResponse.CurrentNetwork,
Error: err,
}, nil
return x.toAppMessage()
}
func (x *KaspadMessage_GetCurrentNetworkResponse) fromAppMessage(message *appmessage.GetCurrentNetworkResponseMessage) error {
@ -32,3 +31,23 @@ func (x *KaspadMessage_GetCurrentNetworkResponse) fromAppMessage(message *appmes
}
return nil
}
func (x *GetCurrentNetworkResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetCurrentNetworkResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && len(x.CurrentNetwork) != 0 {
return nil, errors.New("GetCurrentNetworkResponseMessage contains both an error and a response")
}
return &appmessage.GetCurrentNetworkResponseMessage{
CurrentNetwork: x.CurrentNetwork,
Error: rpcErr,
}, nil
}

51
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_headers.go
View File

@ -2,14 +2,14 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetHeadersRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetHeadersRequestMessage{
StartHash: x.GetHeadersRequest.StartHash,
Limit: x.GetHeadersRequest.Limit,
IsAscending: x.GetHeadersRequest.IsAscending,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetHeadersRequest is nil")
}
return x.GetHeadersRequest.toAppMessage()
}
func (x *KaspadMessage_GetHeadersRequest) fromAppMessage(message *appmessage.GetHeadersRequestMessage) error {
@ -21,17 +21,24 @@ func (x *KaspadMessage_GetHeadersRequest) fromAppMessage(message *appmessage.Get
return nil
}
func (x *KaspadMessage_GetHeadersResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetHeadersResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetHeadersResponse.Error.Message}
func (x *GetHeadersRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetHeadersRequestMessage is nil")
}
return &appmessage.GetHeadersResponseMessage{
Headers: x.GetHeadersResponse.Headers,
Error: err,
return &appmessage.GetHeadersRequestMessage{
StartHash: x.StartHash,
Limit: x.Limit,
IsAscending: x.IsAscending,
}, nil
}
func (x *KaspadMessage_GetHeadersResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetHeadersResponse is nil")
}
return x.GetHeadersResponse.toAppMessage()
}
func (x *KaspadMessage_GetHeadersResponse) fromAppMessage(message *appmessage.GetHeadersResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -43,3 +50,23 @@ func (x *KaspadMessage_GetHeadersResponse) fromAppMessage(message *appmessage.Ge
}
return nil
}
func (x *GetHeadersResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetHeadersResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && len(x.Headers) != 0 {
return nil, errors.New("GetHeadersResponseMessage contains both an error and a response")
}
return &appmessage.GetHeadersResponseMessage{
Headers: x.Headers,
Error: rpcErr,
}, nil
}

31
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_info.go
View File

@ -2,6 +2,7 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetInfoRequest) toAppMessage() (appmessage.Message, error) {
@ -14,14 +15,10 @@ func (x *KaspadMessage_GetInfoRequest) fromAppMessage(_ *appmessage.GetInfoReque
}
func (x *KaspadMessage_GetInfoResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetInfoResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetInfoResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetInfoResponse is nil")
}
return &appmessage.GetInfoResponseMessage{
P2PID: x.GetInfoResponse.P2PId,
Error: err,
}, nil
return x.GetInfoResponse.toAppMessage()
}
func (x *KaspadMessage_GetInfoResponse) fromAppMessage(message *appmessage.GetInfoResponseMessage) error {
@ -35,3 +32,23 @@ func (x *KaspadMessage_GetInfoResponse) fromAppMessage(message *appmessage.GetIn
}
return nil
}
func (x *GetInfoResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetInfoResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && len(x.P2PId) != 0 {
return nil, errors.New("GetInfoResponseMessage contains both an error and a response")
}
return &appmessage.GetInfoResponseMessage{
P2PID: x.P2PId,
Error: rpcErr,
}, nil
}

53
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_mempool_entries.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetMempoolEntriesRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetMempoolEntriesRequest is nil")
}
return &appmessage.GetMempoolEntriesRequestMessage{}, nil
}
@ -12,22 +18,10 @@ func (x *KaspadMessage_GetMempoolEntriesRequest) fromAppMessage(_ *appmessage.Ge
}
func (x *KaspadMessage_GetMempoolEntriesResponse) toAppMessage() (appmessage.Message, error) {
var rpcErr *appmessage.RPCError
if x.GetMempoolEntriesResponse.Error != nil {
rpcErr = &appmessage.RPCError{Message: x.GetMempoolEntriesResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetMempoolEntriesResponse is nil")
}
entries := make([]*appmessage.MempoolEntry, len(x.GetMempoolEntriesResponse.Entries))
for i, entry := range x.GetMempoolEntriesResponse.Entries {
var err error
entries[i], err = entry.toAppMessage()
if err != nil {
return nil, err
}
}
return &appmessage.GetMempoolEntriesResponseMessage{
Entries: entries,
Error: rpcErr,
}, nil
return x.GetMempoolEntriesResponse.toAppMessage()
}
func (x *KaspadMessage_GetMempoolEntriesResponse) fromAppMessage(message *appmessage.GetMempoolEntriesResponseMessage) error {
@ -49,3 +43,30 @@ func (x *KaspadMessage_GetMempoolEntriesResponse) fromAppMessage(message *appmes
}
return nil
}
func (x *GetMempoolEntriesResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetMempoolEntriesResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && len(x.Entries) != 0 {
return nil, errors.New("GetMempoolEntriesResponseMessage contains both an error and a response")
}
entries := make([]*appmessage.MempoolEntry, len(x.Entries))
for i, entry := range x.Entries {
entries[i], err = entry.toAppMessage()
if err != nil {
return nil, err
}
}
return &appmessage.GetMempoolEntriesResponseMessage{
Entries: entries,
Error: rpcErr,
}, nil
}

74
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_mempool_entry.go
View File

@ -2,12 +2,14 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetMempoolEntryRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetMempoolEntryRequestMessage{
TxID: x.GetMempoolEntryRequest.TxId,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetMempoolEntryRequest is nil")
}
return x.GetMempoolEntryRequest.toAppMessage()
}
func (x *KaspadMessage_GetMempoolEntryRequest) fromAppMessage(message *appmessage.GetMempoolEntryRequestMessage) error {
@ -17,25 +19,22 @@ func (x *KaspadMessage_GetMempoolEntryRequest) fromAppMessage(message *appmessag
return nil
}
func (x *KaspadMessage_GetMempoolEntryResponse) toAppMessage() (appmessage.Message, error) {
var rpcErr *appmessage.RPCError
if x.GetMempoolEntryResponse.Error != nil {
rpcErr = &appmessage.RPCError{Message: x.GetMempoolEntryResponse.Error.Message}
func (x *GetMempoolEntryRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetMempoolEntryRequestMessage is nil")
}
var entry *appmessage.MempoolEntry
if x.GetMempoolEntryResponse.Entry != nil {
var err error
entry, err = x.GetMempoolEntryResponse.Entry.toAppMessage()
if err != nil {
return nil, err
}
}
return &appmessage.GetMempoolEntryResponseMessage{
Entry: entry,
Error: rpcErr,
return &appmessage.GetMempoolEntryRequestMessage{
TxID: x.TxId,
}, nil
}
func (x *KaspadMessage_GetMempoolEntryResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetMempoolEntryResponse is nil")
}
return x.GetMempoolEntryResponse.toAppMessage()
}
func (x *KaspadMessage_GetMempoolEntryResponse) fromAppMessage(message *appmessage.GetMempoolEntryResponseMessage) error {
var rpcErr *RPCError
if message.Error != nil {
@ -55,14 +54,39 @@ func (x *KaspadMessage_GetMempoolEntryResponse) fromAppMessage(message *appmessa
return nil
}
func (x *GetMempoolEntryResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetMempoolEntryResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
entry, err := x.Entry.toAppMessage()
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && entry != nil {
return nil, errors.New("GetMempoolEntryResponseMessage contains both an error and a response")
}
return &appmessage.GetMempoolEntryResponseMessage{
Entry: entry,
Error: rpcErr,
}, nil
}
func (x *MempoolEntry) toAppMessage() (*appmessage.MempoolEntry, error) {
var txVerboseData *appmessage.TransactionVerboseData
if x.TransactionVerboseData != nil {
var err error
txVerboseData, err = x.TransactionVerboseData.toAppMessage()
if err != nil {
return nil, err
}
if x == nil {
return nil, errors.Wrapf(errorNil, "MempoolEntry is nil")
}
txVerboseData, err := x.TransactionVerboseData.toAppMessage()
// TransactionVerboseData is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.MempoolEntry{
Fee: x.Fee,

71
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_peer_addresses.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetPeerAddressesRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetPeerAddressesRequest is nil")
}
return &appmessage.GetPeerAddressesRequestMessage{}, nil
}
@ -11,23 +17,10 @@ func (x *KaspadMessage_GetPeerAddressesRequest) fromAppMessage(_ *appmessage.Get
}
func (x *KaspadMessage_GetPeerAddressesResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetPeerAddressesResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetPeerAddressesResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetPeerAddressesResponse is nil")
}
addresses := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(x.GetPeerAddressesResponse.Addresses))
for i, address := range x.GetPeerAddressesResponse.Addresses {
addresses[i] = &appmessage.GetPeerAddressesKnownAddressMessage{Addr: address.Addr}
}
bannedAddresses := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(x.GetPeerAddressesResponse.BannedAddresses))
for i, address := range x.GetPeerAddressesResponse.BannedAddresses {
bannedAddresses[i] = &appmessage.GetPeerAddressesKnownAddressMessage{Addr: address.Addr}
}
return &appmessage.GetPeerAddressesResponseMessage{
Addresses: addresses,
BannedAddresses: bannedAddresses,
Error: err,
}, nil
return x.GetPeerAddressesResponse.toAppMessage()
}
func (x *KaspadMessage_GetPeerAddressesResponse) fromAppMessage(message *appmessage.GetPeerAddressesResponseMessage) error {
@ -50,3 +43,47 @@ func (x *KaspadMessage_GetPeerAddressesResponse) fromAppMessage(message *appmess
}
return nil
}
func (x *GetPeerAddressesResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetPeerAddressesResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
addresses := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(x.Addresses))
for i, address := range x.Addresses {
appAddress, err := address.toAppMessage()
if err != nil {
return nil, err
}
addresses[i] = appAddress
}
bannedAddresses := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(x.BannedAddresses))
for i, address := range x.BannedAddresses {
bannedAddress, err := address.toAppMessage()
if err != nil {
return nil, err
}
bannedAddresses[i] = bannedAddress
}
if rpcErr != nil && (len(addresses) != 0 || len(bannedAddresses) != 0) {
return nil, errors.New("GetPeerAddressesResponseMessage contains both an error and a response")
}
return &appmessage.GetPeerAddressesResponseMessage{
Addresses: addresses,
BannedAddresses: bannedAddresses,
Error: rpcErr,
}, nil
}
func (x *GetPeerAddressesKnownAddressMessage) toAppMessage() (*appmessage.GetPeerAddressesKnownAddressMessage, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetPeerAddressesKnownAddressMessage is nil")
}
return &appmessage.GetPeerAddressesKnownAddressMessage{Addr: x.Addr}, nil
}

35
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_selected_tip_hash.go
View File

@ -1,6 +1,9 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetSelectedTipHashRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetSelectedTipHashRequestMessage{}, nil
@ -11,14 +14,10 @@ func (x *KaspadMessage_GetSelectedTipHashRequest) fromAppMessage(_ *appmessage.G
}
func (x *KaspadMessage_GetSelectedTipHashResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetSelectedTipHashResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetSelectedTipHashResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetSelectedTipHashResponse is nil")
}
return &appmessage.GetSelectedTipHashResponseMessage{
SelectedTipHash: x.GetSelectedTipHashResponse.SelectedTipHash,
Error: err,
}, nil
return x.GetSelectedTipHashResponse.toAppMessage()
}
func (x *KaspadMessage_GetSelectedTipHashResponse) fromAppMessage(message *appmessage.GetSelectedTipHashResponseMessage) error {
@ -32,3 +31,23 @@ func (x *KaspadMessage_GetSelectedTipHashResponse) fromAppMessage(message *appme
}
return nil
}
func (x *GetSelectedTipHashResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetSelectedTipHashResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && len(x.SelectedTipHash) != 0 {
return nil, errors.New("GetSelectedTipHashResponseMessage contains both an error and a response")
}
return &appmessage.GetSelectedTipHashResponseMessage{
SelectedTipHash: x.SelectedTipHash,
Error: rpcErr,
}, nil
}

51
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_subnetwork.go
View File

@ -1,11 +1,15 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetSubnetworkRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetSubnetworkRequestMessage{
SubnetworkID: x.GetSubnetworkRequest.SubnetworkId,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetSubnetworkRequest is nil")
}
return x.GetSubnetworkRequest.toAppMessage()
}
func (x *KaspadMessage_GetSubnetworkRequest) fromAppMessage(message *appmessage.GetSubnetworkRequestMessage) error {
@ -15,17 +19,22 @@ func (x *KaspadMessage_GetSubnetworkRequest) fromAppMessage(message *appmessage.
return nil
}
func (x *KaspadMessage_GetSubnetworkResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetSubnetworkResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetSubnetworkResponse.Error.Message}
func (x *GetSubnetworkRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetSubnetworkRequestMessage is nil")
}
return &appmessage.GetSubnetworkResponseMessage{
GasLimit: x.GetSubnetworkResponse.GasLimit,
Error: err,
return &appmessage.GetSubnetworkRequestMessage{
SubnetworkID: x.SubnetworkId,
}, nil
}
func (x *KaspadMessage_GetSubnetworkResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetSubnetworkResponse is nil")
}
return x.GetSubnetworkResponse.toAppMessage()
}
func (x *KaspadMessage_GetSubnetworkResponse) fromAppMessage(message *appmessage.GetSubnetworkResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -37,3 +46,23 @@ func (x *KaspadMessage_GetSubnetworkResponse) fromAppMessage(message *appmessage
}
return nil
}
func (x *GetSubnetworkResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetSubnetworkResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && x.GasLimit != 0 {
return nil, errors.New("GetSubnetworkResponseMessage contains both an error and a response")
}
return &appmessage.GetSubnetworkResponseMessage{
GasLimit: x.GasLimit,
Error: rpcErr,
}, nil
}

68
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_utxos_by_addresses.go
View File

@ -1,11 +1,15 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetUtxosByAddressesRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetUTXOsByAddressesRequestMessage{
Addresses: x.GetUtxosByAddressesRequest.Addresses,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetUtxosByAddressesRequest is nil")
}
return x.GetUtxosByAddressesRequest.toAppMessage()
}
func (x *KaspadMessage_GetUtxosByAddressesRequest) fromAppMessage(message *appmessage.GetUTXOsByAddressesRequestMessage) error {
@ -15,25 +19,22 @@ func (x *KaspadMessage_GetUtxosByAddressesRequest) fromAppMessage(message *appme
return nil
}
func (x *KaspadMessage_GetUtxosByAddressesResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetUtxosByAddressesResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetUtxosByAddressesResponse.Error.Message}
func (x *GetUtxosByAddressesRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetUtxosByAddressesRequestMessage is nil")
}
entries := make([]*appmessage.UTXOsByAddressesEntry, len(x.GetUtxosByAddressesResponse.Entries))
for i, entry := range x.GetUtxosByAddressesResponse.Entries {
entryAsAppMessage, err := entry.toAppMessage()
if err != nil {
return nil, err
}
entries[i] = entryAsAppMessage
}
return &appmessage.GetUTXOsByAddressesResponseMessage{
Entries: entries,
Error: err,
return &appmessage.GetUTXOsByAddressesRequestMessage{
Addresses: x.Addresses,
}, nil
}
func (x *KaspadMessage_GetUtxosByAddressesResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetUtxosByAddressesResponseMessage is nil")
}
return x.GetUtxosByAddressesResponse.toAppMessage()
}
func (x *KaspadMessage_GetUtxosByAddressesResponse) fromAppMessage(message *appmessage.GetUTXOsByAddressesResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -50,3 +51,32 @@ func (x *KaspadMessage_GetUtxosByAddressesResponse) fromAppMessage(message *appm
}
return nil
}
func (x *GetUtxosByAddressesResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetUtxosByAddressesResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && len(x.Entries) != 0 {
return nil, errors.New("GetUtxosByAddressesResponseMessage contains both an error and a response")
}
entries := make([]*appmessage.UTXOsByAddressesEntry, len(x.Entries))
for i, entry := range x.Entries {
entryAsAppMessage, err := entry.toAppMessage()
if err != nil {
return nil, err
}
entries[i] = entryAsAppMessage
}
return &appmessage.GetUTXOsByAddressesResponseMessage{
Entries: entries,
Error: rpcErr,
}, nil
}

34
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_virtual_selected_parent_blue_score.go
View File

@ -2,9 +2,13 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetVirtualSelectedParentBlueScoreRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetVirtualSelectedParentBlueScoreRequest is nil")
}
return &appmessage.GetVirtualSelectedParentBlueScoreRequestMessage{}, nil
}
@ -14,14 +18,10 @@ func (x *KaspadMessage_GetVirtualSelectedParentBlueScoreRequest) fromAppMessage(
}
func (x *KaspadMessage_GetVirtualSelectedParentBlueScoreResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetVirtualSelectedParentBlueScoreResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetVirtualSelectedParentBlueScoreResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetVirtualSelectedParentBlueScoreResponse is nil")
}
return &appmessage.GetVirtualSelectedParentBlueScoreResponseMessage{
BlueScore: x.GetVirtualSelectedParentBlueScoreResponse.BlueScore,
Error: err,
}, nil
return x.GetVirtualSelectedParentBlueScoreResponse.toAppMessage()
}
func (x *KaspadMessage_GetVirtualSelectedParentBlueScoreResponse) fromAppMessage(message *appmessage.GetVirtualSelectedParentBlueScoreResponseMessage) error {
@ -35,3 +35,23 @@ func (x *KaspadMessage_GetVirtualSelectedParentBlueScoreResponse) fromAppMessage
}
return nil
}
func (x *GetVirtualSelectedParentBlueScoreResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetVirtualSelectedParentBlueScoreResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && x.BlueScore != 0 {
return nil, errors.New("GetVirtualSelectedParentBlueScoreResponseMessage contains both an error and a response")
}
return &appmessage.GetVirtualSelectedParentBlueScoreResponseMessage{
BlueScore: x.BlueScore,
Error: rpcErr,
}, nil
}

69
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_virtual_selected_parent_chain_from_block.go
View File

@ -1,11 +1,15 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_GetVirtualSelectedParentChainFromBlockRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.GetVirtualSelectedParentChainFromBlockRequestMessage{
StartHash: x.GetVirtualSelectedParentChainFromBlockRequest.StartHash,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetVirtualSelectedParentChainFromBlockRequest is nil")
}
return x.GetVirtualSelectedParentChainFromBlockRequest.toAppMessage()
}
func (x *KaspadMessage_GetVirtualSelectedParentChainFromBlockRequest) fromAppMessage(message *appmessage.GetVirtualSelectedParentChainFromBlockRequestMessage) error {
@ -15,26 +19,22 @@ func (x *KaspadMessage_GetVirtualSelectedParentChainFromBlockRequest) fromAppMes
return nil
}
func (x *KaspadMessage_GetVirtualSelectedParentChainFromBlockResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.GetVirtualSelectedParentChainFromBlockResponse.Error != nil {
err = &appmessage.RPCError{Message: x.GetVirtualSelectedParentChainFromBlockResponse.Error.Message}
func (x *GetVirtualSelectedParentChainFromBlockRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetVirtualSelectedParentChainFromBlockRequestMessage is nil")
}
addedChainBlocks := make([]*appmessage.ChainBlock, len(x.GetVirtualSelectedParentChainFromBlockResponse.AddedChainBlocks))
for i, addedChainBlock := range x.GetVirtualSelectedParentChainFromBlockResponse.AddedChainBlocks {
appAddedChainBlock, err := addedChainBlock.toAppMessage()
if err != nil {
return nil, err
}
addedChainBlocks[i] = appAddedChainBlock
}
return &appmessage.GetVirtualSelectedParentChainFromBlockResponseMessage{
RemovedChainBlockHashes: x.GetVirtualSelectedParentChainFromBlockResponse.RemovedChainBlockHashes,
AddedChainBlocks: addedChainBlocks,
Error: err,
return &appmessage.GetVirtualSelectedParentChainFromBlockRequestMessage{
StartHash: x.StartHash,
}, nil
}
func (x *KaspadMessage_GetVirtualSelectedParentChainFromBlockResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_GetVirtualSelectedParentChainFromBlockResponse is nil")
}
return x.GetVirtualSelectedParentChainFromBlockResponse.toAppMessage()
}
func (x *KaspadMessage_GetVirtualSelectedParentChainFromBlockResponse) fromAppMessage(message *appmessage.GetVirtualSelectedParentChainFromBlockResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -56,3 +56,32 @@ func (x *KaspadMessage_GetVirtualSelectedParentChainFromBlockResponse) fromAppMe
}
return nil
}
func (x *GetVirtualSelectedParentChainFromBlockResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "GetVirtualSelectedParentChainFromBlockResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
if rpcErr != nil && (len(x.AddedChainBlocks) != 0 || len(x.RemovedChainBlockHashes) != 0) {
return nil, errors.New("GetVirtualSelectedParentChainFromBlockResponseMessage contains both an error and a response")
}
addedChainBlocks := make([]*appmessage.ChainBlock, len(x.AddedChainBlocks))
for i, addedChainBlock := range x.AddedChainBlocks {
appAddedChainBlock, err := addedChainBlock.toAppMessage()
if err != nil {
return nil, err
}
addedChainBlocks[i] = appAddedChainBlock
}
return &appmessage.GetVirtualSelectedParentChainFromBlockResponseMessage{
RemovedChainBlockHashes: x.RemovedChainBlockHashes,
AddedChainBlocks: addedChainBlocks,
Error: rpcErr,
}, nil
}

58
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_notify_block_added.go
View File

@ -1,6 +1,9 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_NotifyBlockAddedRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.NotifyBlockAddedRequestMessage{}, nil
@ -12,13 +15,10 @@ func (x *KaspadMessage_NotifyBlockAddedRequest) fromAppMessage(_ *appmessage.Not
}
func (x *KaspadMessage_NotifyBlockAddedResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.NotifyBlockAddedResponse.Error != nil {
err = &appmessage.RPCError{Message: x.NotifyBlockAddedResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyBlockAddedResponse is nil")
}
return &appmessage.NotifyBlockAddedResponseMessage{
Error: err,
}, nil
return x.NotifyBlockAddedResponse.toAppMessage()
}
func (x *KaspadMessage_NotifyBlockAddedResponse) fromAppMessage(message *appmessage.NotifyBlockAddedResponseMessage) error {
@ -32,21 +32,27 @@ func (x *KaspadMessage_NotifyBlockAddedResponse) fromAppMessage(message *appmess
return nil
}
func (x *KaspadMessage_BlockAddedNotification) toAppMessage() (appmessage.Message, error) {
block, err := x.BlockAddedNotification.Block.toAppMessage()
if err != nil {
func (x *NotifyBlockAddedResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "NotifyBlockAddedResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
blockVerboseData, err := x.BlockAddedNotification.BlockVerboseData.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.BlockAddedNotificationMessage{
Block: block,
BlockVerboseData: blockVerboseData,
return &appmessage.NotifyBlockAddedResponseMessage{
Error: rpcErr,
}, nil
}
func (x *KaspadMessage_BlockAddedNotification) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_BlockAddedNotification is nil")
}
return x.BlockAddedNotification.toAppMessage()
}
func (x *KaspadMessage_BlockAddedNotification) fromAppMessage(message *appmessage.BlockAddedNotificationMessage) error {
blockMessage := &BlockMessage{}
err := blockMessage.fromAppMessage(message.Block)
@ -64,3 +70,21 @@ func (x *KaspadMessage_BlockAddedNotification) fromAppMessage(message *appmessag
}
return nil
}
func (x *BlockAddedNotificationMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "BlockAddedNotificationMessage is nil")
}
block, err := x.Block.toAppMessage()
if err != nil {
return nil, err
}
blockVerboseData, err := x.BlockVerboseData.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.BlockAddedNotificationMessage{
Block: block,
BlockVerboseData: blockVerboseData,
}, nil
}

60
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_notify_finality_conflicts.go
View File

@ -1,6 +1,9 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_NotifyFinalityConflictsRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.NotifyFinalityConflictsRequestMessage{}, nil
@ -12,13 +15,10 @@ func (x *KaspadMessage_NotifyFinalityConflictsRequest) fromAppMessage(_ *appmess
}
func (x *KaspadMessage_NotifyFinalityConflictsResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.NotifyFinalityConflictsResponse.Error != nil {
err = &appmessage.RPCError{Message: x.NotifyFinalityConflictsResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyFinalityConflictsResponse is nil")
}
return &appmessage.NotifyFinalityConflictsResponseMessage{
Error: err,
}, nil
return x.NotifyFinalityConflictsResponse.toAppMessage()
}
func (x *KaspadMessage_NotifyFinalityConflictsResponse) fromAppMessage(message *appmessage.NotifyFinalityConflictsResponseMessage) error {
@ -32,12 +32,27 @@ func (x *KaspadMessage_NotifyFinalityConflictsResponse) fromAppMessage(message *
return nil
}
func (x *KaspadMessage_FinalityConflictNotification) toAppMessage() (appmessage.Message, error) {
return &appmessage.FinalityConflictNotificationMessage{
ViolatingBlockHash: x.FinalityConflictNotification.ViolatingBlockHash,
func (x *NotifyFinalityConflictsResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "NotifyFinalityConflictsResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.NotifyFinalityConflictsResponseMessage{
Error: rpcErr,
}, nil
}
func (x *KaspadMessage_FinalityConflictNotification) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_FinalityConflictNotification is nil")
}
return x.FinalityConflictNotification.toAppMessage()
}
func (x *KaspadMessage_FinalityConflictNotification) fromAppMessage(message *appmessage.FinalityConflictNotificationMessage) error {
x.FinalityConflictNotification = &FinalityConflictNotificationMessage{
ViolatingBlockHash: message.ViolatingBlockHash,
@ -45,15 +60,34 @@ func (x *KaspadMessage_FinalityConflictNotification) fromAppMessage(message *app
return nil
}
func (x *KaspadMessage_FinalityConflictResolvedNotification) toAppMessage() (appmessage.Message, error) {
return &appmessage.FinalityConflictResolvedNotificationMessage{
FinalityBlockHash: x.FinalityConflictResolvedNotification.FinalityBlockHash,
func (x *FinalityConflictNotificationMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "FinalityConflictNotificationMessage is nil")
}
return &appmessage.FinalityConflictNotificationMessage{
ViolatingBlockHash: x.ViolatingBlockHash,
}, nil
}
func (x *KaspadMessage_FinalityConflictResolvedNotification) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_FinalityConflictResolvedNotification is nil")
}
return x.FinalityConflictResolvedNotification.toAppMessage()
}
func (x *KaspadMessage_FinalityConflictResolvedNotification) fromAppMessage(message *appmessage.FinalityConflictResolvedNotificationMessage) error {
x.FinalityConflictResolvedNotification = &FinalityConflictResolvedNotificationMessage{
FinalityBlockHash: message.FinalityBlockHash,
}
return nil
}
func (x *FinalityConflictResolvedNotificationMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "FinalityConflictResolvedNotificationMessage is nil")
}
return &appmessage.FinalityConflictResolvedNotificationMessage{
FinalityBlockHash: x.FinalityBlockHash,
}, nil
}

60
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_notify_pruning_point_utxo_set_override.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_NotifyPruningPointUTXOSetOverrideRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyPruningPointUTXOSetOverrideRequest is nil")
}
return &appmessage.NotifyPruningPointUTXOSetOverrideRequestMessage{}, nil
}
@ -12,13 +18,10 @@ func (x *KaspadMessage_NotifyPruningPointUTXOSetOverrideRequest) fromAppMessage(
}
func (x *KaspadMessage_NotifyPruningPointUTXOSetOverrideResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.NotifyPruningPointUTXOSetOverrideResponse.Error != nil {
err = &appmessage.RPCError{Message: x.NotifyPruningPointUTXOSetOverrideResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyPruningPointUTXOSetOverrideResponse is nil")
}
return &appmessage.NotifyPruningPointUTXOSetOverrideResponseMessage{
Error: err,
}, nil
return x.NotifyPruningPointUTXOSetOverrideResponse.toAppMessage()
}
func (x *KaspadMessage_NotifyPruningPointUTXOSetOverrideResponse) fromAppMessage(message *appmessage.NotifyPruningPointUTXOSetOverrideResponseMessage) error {
@ -32,7 +35,24 @@ func (x *KaspadMessage_NotifyPruningPointUTXOSetOverrideResponse) fromAppMessage
return nil
}
func (x *NotifyPruningPointUTXOSetOverrideResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "NotifyPruningPointUTXOSetOverrideResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.NotifyPruningPointUTXOSetOverrideResponseMessage{
Error: rpcErr,
}, nil
}
func (x *KaspadMessage_PruningPointUTXOSetOverrideNotification) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_PruningPointUTXOSetOverrideNotification is nil")
}
return &appmessage.PruningPointUTXOSetOverrideNotificationMessage{}, nil
}
@ -42,6 +62,9 @@ func (x *KaspadMessage_PruningPointUTXOSetOverrideNotification) fromAppMessage(_
}
func (x *KaspadMessage_StopNotifyingPruningPointUTXOSetOverrideRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_StopNotifyingPruningPointUTXOSetOverrideRequest is nil")
}
return &appmessage.StopNotifyingPruningPointUTXOSetOverrideRequestMessage{}, nil
}
@ -51,13 +74,10 @@ func (x *KaspadMessage_StopNotifyingPruningPointUTXOSetOverrideRequest) fromAppM
}
func (x *KaspadMessage_StopNotifyingPruningPointUTXOSetOverrideResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.StopNotifyingPruningPointUTXOSetOverrideResponse.Error != nil {
err = &appmessage.RPCError{Message: x.StopNotifyingPruningPointUTXOSetOverrideResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_StopNotifyingPruningPointUTXOSetOverrideResponse is nil")
}
return &appmessage.StopNotifyingPruningPointUTXOSetOverrideResponseMessage{
Error: err,
}, nil
return x.StopNotifyingPruningPointUTXOSetOverrideResponse.toAppMessage()
}
func (x *KaspadMessage_StopNotifyingPruningPointUTXOSetOverrideResponse) fromAppMessage(
@ -72,3 +92,17 @@ func (x *KaspadMessage_StopNotifyingPruningPointUTXOSetOverrideResponse) fromApp
}
return nil
}
func (x *StopNotifyingPruningPointUTXOSetOverrideResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "StopNotifyingPruningPointUTXOSetOverrideResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.StopNotifyingPruningPointUTXOSetOverrideResponseMessage{
Error: rpcErr,
}, nil
}

141
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_notify_utxos_changed.go
View File

@ -2,12 +2,14 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_NotifyUtxosChangedRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.NotifyUTXOsChangedRequestMessage{
Addresses: x.NotifyUtxosChangedRequest.Addresses,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyUtxosChangedRequest is nil")
}
return x.NotifyUtxosChangedRequest.toAppMessage()
}
func (x *KaspadMessage_NotifyUtxosChangedRequest) fromAppMessage(message *appmessage.NotifyUTXOsChangedRequestMessage) error {
@ -17,16 +19,22 @@ func (x *KaspadMessage_NotifyUtxosChangedRequest) fromAppMessage(message *appmes
return nil
}
func (x *KaspadMessage_NotifyUtxosChangedResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.NotifyUtxosChangedResponse.Error != nil {
err = &appmessage.RPCError{Message: x.NotifyUtxosChangedResponse.Error.Message}
func (x *NotifyUtxosChangedRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "NotifyUtxosChangedRequestMessage is nil")
}
return &appmessage.NotifyUTXOsChangedResponseMessage{
Error: err,
return &appmessage.NotifyUTXOsChangedRequestMessage{
Addresses: x.Addresses,
}, nil
}
func (x *KaspadMessage_NotifyUtxosChangedResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "NotifyUtxosChangedResponseMessage is nil")
}
return x.NotifyUtxosChangedResponse.toAppMessage()
}
func (x *KaspadMessage_NotifyUtxosChangedResponse) fromAppMessage(message *appmessage.NotifyUTXOsChangedResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -38,31 +46,27 @@ func (x *KaspadMessage_NotifyUtxosChangedResponse) fromAppMessage(message *appme
return nil
}
func (x *KaspadMessage_UtxosChangedNotification) toAppMessage() (appmessage.Message, error) {
added := make([]*appmessage.UTXOsByAddressesEntry, len(x.UtxosChangedNotification.Added))
for i, entry := range x.UtxosChangedNotification.Added {
entryAsAppMessage, err := entry.toAppMessage()
if err != nil {
return nil, err
}
added[i] = entryAsAppMessage
func (x *NotifyUtxosChangedResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "NotifyUtxosChangedResponseMessage is nil")
}
removed := make([]*appmessage.UTXOsByAddressesEntry, len(x.UtxosChangedNotification.Removed))
for i, entry := range x.UtxosChangedNotification.Removed {
entryAsAppMessage, err := entry.toAppMessage()
if err != nil {
return nil, err
}
removed[i] = entryAsAppMessage
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.UTXOsChangedNotificationMessage{
Added: added,
Removed: removed,
return &appmessage.NotifyUTXOsChangedResponseMessage{
Error: rpcErr,
}, nil
}
func (x *KaspadMessage_UtxosChangedNotification) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_UtxosChangedNotification is nil")
}
return x.UtxosChangedNotification.toAppMessage()
}
func (x *KaspadMessage_UtxosChangedNotification) fromAppMessage(message *appmessage.UTXOsChangedNotificationMessage) error {
added := make([]*UtxosByAddressesEntry, len(message.Added))
for i, entry := range message.Added {
@ -83,28 +87,55 @@ func (x *KaspadMessage_UtxosChangedNotification) fromAppMessage(message *appmess
return nil
}
func (x *UtxosByAddressesEntry) toAppMessage() (*appmessage.UTXOsByAddressesEntry, error) {
outpoint := &appmessage.RPCOutpoint{
TransactionID: x.Outpoint.TransactionId,
Index: x.Outpoint.Index,
func (x *UtxosChangedNotificationMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "UtxosChangedNotificationMessage is nil")
}
var utxoEntry *appmessage.RPCUTXOEntry
if x.UtxoEntry != nil {
scriptPubKey, err := ConvertFromAppMsgRPCScriptPubKeyToRPCScriptPubKey(x.UtxoEntry.ScriptPublicKey)
added := make([]*appmessage.UTXOsByAddressesEntry, len(x.Added))
for i, entry := range x.Added {
entryAsAppMessage, err := entry.toAppMessage()
if err != nil {
return nil, err
}
utxoEntry = &appmessage.RPCUTXOEntry{
Amount: x.UtxoEntry.Amount,
ScriptPublicKey: scriptPubKey,
BlockBlueScore: x.UtxoEntry.BlockBlueScore,
IsCoinbase: x.UtxoEntry.IsCoinbase,
// UTXOEntry is optional in other places, but here it's required.
if entryAsAppMessage.UTXOEntry == nil {
return nil, errors.Wrapf(errorNil, "UTXOEntry is nil in UTXOsByAddressesEntry.Added")
}
added[i] = entryAsAppMessage
}
removed := make([]*appmessage.UTXOsByAddressesEntry, len(x.Removed))
for i, entry := range x.Removed {
entryAsAppMessage, err := entry.toAppMessage()
if err != nil {
return nil, err
}
removed[i] = entryAsAppMessage
}
return &appmessage.UTXOsChangedNotificationMessage{
Added: added,
Removed: removed,
}, nil
}
func (x *UtxosByAddressesEntry) toAppMessage() (*appmessage.UTXOsByAddressesEntry, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "UtxosByAddressesEntry is nil")
}
outpoint, err := x.Outpoint.toAppMessage()
if err != nil {
return nil, err
}
entry, err := x.UtxoEntry.toAppMessage()
// entry is an optional field sometimes
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.UTXOsByAddressesEntry{
Address: x.Address,
Outpoint: outpoint,
UTXOEntry: utxoEntry,
UTXOEntry: entry,
}, nil
}
@ -128,3 +159,29 @@ func (x *UtxosByAddressesEntry) fromAppMessage(entry *appmessage.UTXOsByAddresse
UtxoEntry: utxoEntry,
}
}
func (x *RpcOutpoint) toAppMessage() (*appmessage.RPCOutpoint, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RpcOutpoint is nil")
}
return &appmessage.RPCOutpoint{
TransactionID: x.TransactionId,
Index: x.Index,
}, nil
}
func (x *RpcUtxoEntry) toAppMessage() (*appmessage.RPCUTXOEntry, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RpcUtxoEntry is nil")
}
scriptPubKey, err := x.ScriptPublicKey.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.RPCUTXOEntry{
Amount: x.Amount,
ScriptPublicKey: scriptPubKey,
BlockBlueScore: x.BlockBlueScore,
IsCoinbase: x.IsCoinbase,
}, nil
}

47
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_notify_virtual_selected_parent_blue_score_changed.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_NotifyVirtualSelectedParentBlueScoreChangedRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyVirtualSelectedParentBlueScoreChangedRequest is nil")
}
return &appmessage.NotifyVirtualSelectedParentBlueScoreChangedRequestMessage{}, nil
}
@ -12,13 +18,10 @@ func (x *KaspadMessage_NotifyVirtualSelectedParentBlueScoreChangedRequest) fromA
}
func (x *KaspadMessage_NotifyVirtualSelectedParentBlueScoreChangedResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.NotifyVirtualSelectedParentBlueScoreChangedResponse.Error != nil {
err = &appmessage.RPCError{Message: x.NotifyVirtualSelectedParentBlueScoreChangedResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyVirtualSelectedParentBlueScoreChangedResponse is nil")
}
return &appmessage.NotifyVirtualSelectedParentBlueScoreChangedResponseMessage{
Error: err,
}, nil
return x.NotifyVirtualSelectedParentBlueScoreChangedResponse.toAppMessage()
}
func (x *KaspadMessage_NotifyVirtualSelectedParentBlueScoreChangedResponse) fromAppMessage(message *appmessage.NotifyVirtualSelectedParentBlueScoreChangedResponseMessage) error {
@ -32,15 +35,39 @@ func (x *KaspadMessage_NotifyVirtualSelectedParentBlueScoreChangedResponse) from
return nil
}
func (x *KaspadMessage_VirtualSelectedParentBlueScoreChangedNotification) toAppMessage() (appmessage.Message, error) {
return &appmessage.VirtualSelectedParentBlueScoreChangedNotificationMessage{
VirtualSelectedParentBlueScore: x.VirtualSelectedParentBlueScoreChangedNotification.VirtualSelectedParentBlueScore,
func (x *NotifyVirtualSelectedParentBlueScoreChangedResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "NotifyVirtualSelectedParentBlueScoreChangedResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.NotifyVirtualSelectedParentBlueScoreChangedResponseMessage{
Error: rpcErr,
}, nil
}
func (x *KaspadMessage_VirtualSelectedParentBlueScoreChangedNotification) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_VirtualSelectedParentBlueScoreChangedNotification is nil")
}
return x.VirtualSelectedParentBlueScoreChangedNotification.toAppMessage()
}
func (x *KaspadMessage_VirtualSelectedParentBlueScoreChangedNotification) fromAppMessage(message *appmessage.VirtualSelectedParentBlueScoreChangedNotificationMessage) error {
x.VirtualSelectedParentBlueScoreChangedNotification = &VirtualSelectedParentBlueScoreChangedNotificationMessage{
VirtualSelectedParentBlueScore: message.VirtualSelectedParentBlueScore,
}
return nil
}
func (x *VirtualSelectedParentBlueScoreChangedNotificationMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "VirtualSelectedParentBlueScoreChangedNotificationMessage is nil")
}
return &appmessage.VirtualSelectedParentBlueScoreChangedNotificationMessage{
VirtualSelectedParentBlueScore: x.VirtualSelectedParentBlueScore,
}, nil
}

83
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_notify_virtual_selected_parent_chain_changed.go
View File

@ -1,8 +1,14 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_NotifyVirtualSelectedParentChainChangedRequest) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyVirtualSelectedParentChainChangedRequest is nil")
}
return &appmessage.NotifyVirtualSelectedParentChainChangedRequestMessage{}, nil
}
@ -12,13 +18,10 @@ func (x *KaspadMessage_NotifyVirtualSelectedParentChainChangedRequest) fromAppMe
}
func (x *KaspadMessage_NotifyVirtualSelectedParentChainChangedResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.NotifyVirtualSelectedParentChainChangedResponse.Error != nil {
err = &appmessage.RPCError{Message: x.NotifyVirtualSelectedParentChainChangedResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyVirtualSelectedParentChainChangedResponse is nil")
}
return &appmessage.NotifyVirtualSelectedParentChainChangedResponseMessage{
Error: err,
}, nil
return x.NotifyVirtualSelectedParentChainChangedResponse.toAppMessage()
}
func (x *KaspadMessage_NotifyVirtualSelectedParentChainChangedResponse) fromAppMessage(message *appmessage.NotifyVirtualSelectedParentChainChangedResponseMessage) error {
@ -32,21 +35,27 @@ func (x *KaspadMessage_NotifyVirtualSelectedParentChainChangedResponse) fromAppM
return nil
}
func (x *KaspadMessage_VirtualSelectedParentChainChangedNotification) toAppMessage() (appmessage.Message, error) {
addedChainBlocks := make([]*appmessage.ChainBlock, len(x.VirtualSelectedParentChainChangedNotification.AddedChainBlocks))
for i, addedChainBlock := range x.VirtualSelectedParentChainChangedNotification.AddedChainBlocks {
appAddedChainBlock, err := addedChainBlock.toAppMessage()
if err != nil {
return nil, err
}
addedChainBlocks[i] = appAddedChainBlock
func (x *NotifyVirtualSelectedParentChainChangedResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "NotifyVirtualSelectedParentChainChangedResponseMessage is nil")
}
return &appmessage.VirtualSelectedParentChainChangedNotificationMessage{
RemovedChainBlockHashes: x.VirtualSelectedParentChainChangedNotification.RemovedChainBlockHashes,
AddedChainBlocks: addedChainBlocks,
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.NotifyVirtualSelectedParentChainChangedResponseMessage{
Error: rpcErr,
}, nil
}
func (x *KaspadMessage_VirtualSelectedParentChainChangedNotification) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_VirtualSelectedParentChainChangedNotification is nil")
}
return x.VirtualSelectedParentChainChangedNotification.toAppMessage()
}
func (x *KaspadMessage_VirtualSelectedParentChainChangedNotification) fromAppMessage(message *appmessage.VirtualSelectedParentChainChangedNotificationMessage) error {
addedChainBlocks := make([]*ChainBlock, len(message.AddedChainBlocks))
for i, addedChainBlock := range message.AddedChainBlocks {
@ -64,13 +73,35 @@ func (x *KaspadMessage_VirtualSelectedParentChainChangedNotification) fromAppMes
return nil
}
func (x *VirtualSelectedParentChainChangedNotificationMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "VirtualSelectedParentChainChangedNotificationMessage is nil")
}
addedChainBlocks := make([]*appmessage.ChainBlock, len(x.AddedChainBlocks))
for i, addedChainBlock := range x.AddedChainBlocks {
appAddedChainBlock, err := addedChainBlock.toAppMessage()
if err != nil {
return nil, err
}
addedChainBlocks[i] = appAddedChainBlock
}
return &appmessage.VirtualSelectedParentChainChangedNotificationMessage{
RemovedChainBlockHashes: x.RemovedChainBlockHashes,
AddedChainBlocks: addedChainBlocks,
}, nil
}
func (x *ChainBlock) toAppMessage() (*appmessage.ChainBlock, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "ChainBlock is nil")
}
acceptedBlocks := make([]*appmessage.AcceptedBlock, len(x.AcceptedBlocks))
for j, acceptedBlock := range x.AcceptedBlocks {
acceptedBlocks[j] = &appmessage.AcceptedBlock{
Hash: acceptedBlock.Hash,
AcceptedTransactionIDs: acceptedBlock.AcceptedTransactionIds,
appAcceptedBlock, err := acceptedBlock.toAppMessage()
if err != nil {
return nil, err
}
acceptedBlocks[j] = appAcceptedBlock
}
return &appmessage.ChainBlock{
Hash: x.Hash,
@ -92,3 +123,13 @@ func (x *ChainBlock) fromAppMessage(message *appmessage.ChainBlock) error {
}
return nil
}
func (x *AcceptedBlock) toAppMessage() (*appmessage.AcceptedBlock, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "AcceptedBlock is nil")
}
return &appmessage.AcceptedBlock{
Hash: x.Hash,
AcceptedTransactionIDs: x.AcceptedTransactionIds,
}, nil
}

44
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_resolve_finality_conflict.go
View File

@ -1,11 +1,15 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_ResolveFinalityConflictRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.ResolveFinalityConflictRequestMessage{
FinalityBlockHash: x.ResolveFinalityConflictRequest.FinalityBlockHash,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_ResolveFinalityConflictRequest is nil")
}
return x.ResolveFinalityConflictRequest.toAppMessage()
}
func (x *KaspadMessage_ResolveFinalityConflictRequest) fromAppMessage(message *appmessage.ResolveFinalityConflictRequestMessage) error {
@ -15,16 +19,22 @@ func (x *KaspadMessage_ResolveFinalityConflictRequest) fromAppMessage(message *a
return nil
}
func (x *KaspadMessage_ResolveFinalityConflictResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.ResolveFinalityConflictResponse.Error != nil {
err = &appmessage.RPCError{Message: x.ResolveFinalityConflictResponse.Error.Message}
func (x *ResolveFinalityConflictRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "ResolveFinalityConflictRequestMessage is nil")
}
return &appmessage.ResolveFinalityConflictResponseMessage{
Error: err,
return &appmessage.ResolveFinalityConflictRequestMessage{
FinalityBlockHash: x.FinalityBlockHash,
}, nil
}
func (x *KaspadMessage_ResolveFinalityConflictResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_ResolveFinalityConflictResponse is nil")
}
return x.ResolveFinalityConflictResponse.toAppMessage()
}
func (x *KaspadMessage_ResolveFinalityConflictResponse) fromAppMessage(message *appmessage.ResolveFinalityConflictResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -35,3 +45,17 @@ func (x *KaspadMessage_ResolveFinalityConflictResponse) fromAppMessage(message *
}
return nil
}
func (x *ResolveFinalityConflictResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "ResolveFinalityConflictResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.ResolveFinalityConflictResponseMessage{
Error: rpcErr,
}, nil
}

28
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_shut_down.go
View File

@ -1,6 +1,9 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_ShutDownRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.ShutDownRequestMessage{}, nil
@ -12,13 +15,10 @@ func (x *KaspadMessage_ShutDownRequest) fromAppMessage(_ *appmessage.ShutDownReq
}
func (x *KaspadMessage_ShutDownResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.ShutDownResponse.Error != nil {
err = &appmessage.RPCError{Message: x.ShutDownResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_ShutDownResponse is nil")
}
return &appmessage.ShutDownResponseMessage{
Error: err,
}, nil
return x.ShutDownResponse.toAppMessage()
}
func (x *KaspadMessage_ShutDownResponse) fromAppMessage(message *appmessage.ShutDownResponseMessage) error {
@ -31,3 +31,17 @@ func (x *KaspadMessage_ShutDownResponse) fromAppMessage(message *appmessage.Shut
}
return nil
}
func (x *ShutDownResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "ShutDownResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.ShutDownResponseMessage{
Error: rpcErr,
}, nil
}

40
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_stop_notifying_utxos_changed.go
View File

@ -2,12 +2,14 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_StopNotifyingUtxosChangedRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.StopNotifyingUTXOsChangedRequestMessage{
Addresses: x.StopNotifyingUtxosChangedRequest.Addresses,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_StopNotifyingUtxosChangedRequest is nil")
}
return x.StopNotifyingUtxosChangedRequest.toAppMessage()
}
func (x *KaspadMessage_StopNotifyingUtxosChangedRequest) fromAppMessage(message *appmessage.StopNotifyingUTXOsChangedRequestMessage) error {
@ -17,16 +19,22 @@ func (x *KaspadMessage_StopNotifyingUtxosChangedRequest) fromAppMessage(message
return nil
}
func (x *KaspadMessage_StopNotifyingUtxosChangedResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.StopNotifyingUtxosChangedResponse.Error != nil {
err = &appmessage.RPCError{Message: x.StopNotifyingUtxosChangedResponse.Error.Message}
func (x *StopNotifyingUtxosChangedRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "StopNotifyingUtxosChangedRequestMessage is nil")
}
return &appmessage.StopNotifyingUTXOsChangedResponseMessage{
Error: err,
return &appmessage.StopNotifyingUTXOsChangedRequestMessage{
Addresses: x.Addresses,
}, nil
}
func (x *KaspadMessage_StopNotifyingUtxosChangedResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_StopNotifyingUtxosChangedResponse is nil")
}
return x.StopNotifyingUtxosChangedResponse.toAppMessage()
}
func (x *KaspadMessage_StopNotifyingUtxosChangedResponse) fromAppMessage(message *appmessage.StopNotifyingUTXOsChangedResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -37,3 +45,17 @@ func (x *KaspadMessage_StopNotifyingUtxosChangedResponse) fromAppMessage(message
}
return nil
}
func (x *StopNotifyingUtxosChangedResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "StopNotifyingUtxosChangedResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.StopNotifyingUTXOsChangedResponseMessage{
Error: rpcErr,
}, nil
}

52
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_submit_block.go
View File

@ -1,9 +1,27 @@
package protowire
import "github.com/kaspanet/kaspad/app/appmessage"
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_SubmitBlockRequest) toAppMessage() (appmessage.Message, error) {
blockAppMessage, err := x.SubmitBlockRequest.Block.toAppMessage()
if x == nil {
return nil, errors.Wrapf(errorNil, "SubmitBlockRequestMessage is nil")
}
return x.SubmitBlockRequest.toAppMessage()
}
func (x *KaspadMessage_SubmitBlockRequest) fromAppMessage(message *appmessage.SubmitBlockRequestMessage) error {
x.SubmitBlockRequest = &SubmitBlockRequestMessage{Block: &BlockMessage{}}
return x.SubmitBlockRequest.Block.fromAppMessage(message.Block)
}
func (x *SubmitBlockRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "SubmitBlockRequestMessage is nil")
}
blockAppMessage, err := x.Block.toAppMessage()
if err != nil {
return nil, err
}
@ -13,20 +31,11 @@ func (x *KaspadMessage_SubmitBlockRequest) toAppMessage() (appmessage.Message, e
}, nil
}
func (x *KaspadMessage_SubmitBlockRequest) fromAppMessage(message *appmessage.SubmitBlockRequestMessage) error {
x.SubmitBlockRequest = &SubmitBlockRequestMessage{Block: &BlockMessage{}}
return x.SubmitBlockRequest.Block.fromAppMessage(message.Block)
}
func (x *KaspadMessage_SubmitBlockResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.SubmitBlockResponse.Error != nil {
err = &appmessage.RPCError{Message: x.SubmitBlockResponse.Error.Message}
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_SubmitBlockResponse is nil")
}
return &appmessage.SubmitBlockResponseMessage{
RejectReason: appmessage.RejectReason(x.SubmitBlockResponse.RejectReason),
Error: err,
}, nil
return x.SubmitBlockResponse.toAppMessage()
}
func (x *KaspadMessage_SubmitBlockResponse) fromAppMessage(message *appmessage.SubmitBlockResponseMessage) error {
@ -40,3 +49,18 @@ func (x *KaspadMessage_SubmitBlockResponse) fromAppMessage(message *appmessage.S
}
return nil
}
func (x *SubmitBlockResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "SubmitBlockResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.SubmitBlockResponseMessage{
RejectReason: appmessage.RejectReason(x.RejectReason),
Error: rpcErr,
}, nil
}

139
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_submit_transaction.go
View File

@ -7,13 +7,10 @@ import (
)
func (x *KaspadMessage_SubmitTransactionRequest) toAppMessage() (appmessage.Message, error) {
rpcTransaction, err := x.SubmitTransactionRequest.Transaction.toAppMessage()
if err != nil {
return nil, err
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_SubmitTransactionRequest is nil")
}
return &appmessage.SubmitTransactionRequestMessage{
Transaction: rpcTransaction,
}, nil
return x.SubmitTransactionRequest.toAppMessage()
}
func (x *KaspadMessage_SubmitTransactionRequest) fromAppMessage(message *appmessage.SubmitTransactionRequestMessage) error {
@ -24,17 +21,26 @@ func (x *KaspadMessage_SubmitTransactionRequest) fromAppMessage(message *appmess
return nil
}
func (x *KaspadMessage_SubmitTransactionResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.SubmitTransactionResponse.Error != nil {
err = &appmessage.RPCError{Message: x.SubmitTransactionResponse.Error.Message}
func (x *SubmitTransactionRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "SubmitBlockRequestMessage is nil")
}
return &appmessage.SubmitTransactionResponseMessage{
TransactionID: x.SubmitTransactionResponse.TransactionId,
Error: err,
rpcTransaction, err := x.Transaction.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.SubmitTransactionRequestMessage{
Transaction: rpcTransaction,
}, nil
}
func (x *KaspadMessage_SubmitTransactionResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_SubmitTransactionResponse is nil")
}
return x.SubmitTransactionResponse.toAppMessage()
}
func (x *KaspadMessage_SubmitTransactionResponse) fromAppMessage(message *appmessage.SubmitTransactionResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -47,29 +53,40 @@ func (x *KaspadMessage_SubmitTransactionResponse) fromAppMessage(message *appmes
return nil
}
func (x *SubmitTransactionResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "SubmitTransactionResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.SubmitTransactionResponseMessage{
TransactionID: x.TransactionId,
Error: rpcErr,
}, nil
}
func (x *RpcTransaction) toAppMessage() (*appmessage.RPCTransaction, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RpcTransaction is nil")
}
inputs := make([]*appmessage.RPCTransactionInput, len(x.Inputs))
for i, input := range x.Inputs {
previousOutpoint := &appmessage.RPCOutpoint{
TransactionID: input.PreviousOutpoint.TransactionId,
Index: input.PreviousOutpoint.Index,
}
inputs[i] = &appmessage.RPCTransactionInput{
PreviousOutpoint: previousOutpoint,
SignatureScript: input.SignatureScript,
Sequence: input.Sequence,
}
}
outputs := make([]*appmessage.RPCTransactionOutput, len(x.Outputs))
for i, output := range x.Outputs {
scriptPubKey, err := ConvertFromAppMsgRPCScriptPubKeyToRPCScriptPubKey(output.ScriptPublicKey)
appInput, err := input.toAppMessage()
if err != nil {
return nil, err
}
outputs[i] = &appmessage.RPCTransactionOutput{
Amount: output.Amount,
ScriptPublicKey: scriptPubKey,
inputs[i] = appInput
}
outputs := make([]*appmessage.RPCTransactionOutput, len(x.Outputs))
for i, output := range x.Outputs {
appOutput, err := output.toAppMessage()
if err != nil {
return nil, err
}
outputs[i] = appOutput
}
if x.Version > math.MaxUint16 {
@ -88,22 +105,6 @@ func (x *RpcTransaction) toAppMessage() (*appmessage.RPCTransaction, error) {
}, nil
}
// ConvertFromAppMsgRPCScriptPubKeyToRPCScriptPubKey converts from RpcScriptPubKey to RPCScriptPublicKey.
func ConvertFromAppMsgRPCScriptPubKeyToRPCScriptPubKey(toConvert *RpcScriptPublicKey) (*appmessage.RPCScriptPublicKey, error) {
if toConvert.Version > math.MaxUint16 {
return nil, errors.Errorf("Invalid header version - bigger then uint16")
}
version := uint16(toConvert.Version)
script := toConvert.ScriptPublicKey
return &appmessage.RPCScriptPublicKey{Version: version,
Script: script}, nil
}
// ConvertFromRPCScriptPubKeyToAppMsgRPCScriptPubKey converts from RPCScriptPublicKey to RpcScriptPubKey.
func ConvertFromRPCScriptPubKeyToAppMsgRPCScriptPubKey(toConvert *appmessage.RPCScriptPublicKey) *RpcScriptPublicKey {
return &RpcScriptPublicKey{Version: uint32(toConvert.Version), ScriptPublicKey: toConvert.Script}
}
func (x *RpcTransaction) fromAppMessage(transaction *appmessage.RPCTransaction) {
inputs := make([]*RpcTransactionInput, len(transaction.Inputs))
for i, input := range transaction.Inputs {
@ -135,3 +136,51 @@ func (x *RpcTransaction) fromAppMessage(transaction *appmessage.RPCTransaction)
Payload: transaction.Payload,
}
}
func (x *RpcTransactionInput) toAppMessage() (*appmessage.RPCTransactionInput, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RpcTransactionInput is nil")
}
outpoint, err := x.PreviousOutpoint.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.RPCTransactionInput{
PreviousOutpoint: outpoint,
SignatureScript: x.SignatureScript,
Sequence: x.Sequence,
}, nil
}
func (x *RpcTransactionOutput) toAppMessage() (*appmessage.RPCTransactionOutput, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RpcTransactionOutput is nil")
}
scriptPubKey, err := x.ScriptPublicKey.toAppMessage()
if err != nil {
return nil, err
}
return &appmessage.RPCTransactionOutput{
Amount: x.Amount,
ScriptPublicKey: scriptPubKey,
}, nil
}
func (x *RpcScriptPublicKey) toAppMessage() (*appmessage.RPCScriptPublicKey, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "RpcScriptPublicKey is nil")
}
if x.Version > math.MaxUint16 {
return nil, errors.Errorf("Invalid header version - bigger then uint16")
}
return &appmessage.RPCScriptPublicKey{
Version: uint16(x.Version),
Script: x.ScriptPublicKey,
}, nil
}
// ConvertFromRPCScriptPubKeyToAppMsgRPCScriptPubKey converts from RPCScriptPublicKey to RpcScriptPubKey.
func ConvertFromRPCScriptPubKeyToAppMsgRPCScriptPubKey(toConvert *appmessage.RPCScriptPublicKey) *RpcScriptPublicKey {
return &RpcScriptPublicKey{Version: uint32(toConvert.Version), ScriptPublicKey: toConvert.Script}
}

40
infrastructure/network/netadapter/server/grpcserver/protowire/rpc_unban.go
View File

@ -2,12 +2,14 @@ package protowire
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/pkg/errors"
)
func (x *KaspadMessage_UnbanRequest) toAppMessage() (appmessage.Message, error) {
return &appmessage.UnbanRequestMessage{
IP: x.UnbanRequest.Ip,
}, nil
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_UnbanRequest is nil")
}
return x.UnbanRequest.toAppMessage()
}
func (x *KaspadMessage_UnbanRequest) fromAppMessage(message *appmessage.UnbanRequestMessage) error {
@ -15,16 +17,22 @@ func (x *KaspadMessage_UnbanRequest) fromAppMessage(message *appmessage.UnbanReq
return nil
}
func (x *KaspadMessage_UnbanResponse) toAppMessage() (appmessage.Message, error) {
var err *appmessage.RPCError
if x.UnbanResponse.Error != nil {
err = &appmessage.RPCError{Message: x.UnbanResponse.Error.Message}
func (x *UnbanRequestMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "UnbanRequestMessage is nil")
}
return &appmessage.UnbanResponseMessage{
Error: err,
return &appmessage.UnbanRequestMessage{
IP: x.Ip,
}, nil
}
func (x *KaspadMessage_UnbanResponse) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage_UnbanResponse is nil")
}
return x.UnbanResponse.toAppMessage()
}
func (x *KaspadMessage_UnbanResponse) fromAppMessage(message *appmessage.UnbanResponseMessage) error {
var err *RPCError
if message.Error != nil {
@ -35,3 +43,17 @@ func (x *KaspadMessage_UnbanResponse) fromAppMessage(message *appmessage.UnbanRe
}
return nil
}
func (x *UnbanResponseMessage) toAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "UnbanResponseMessage is nil")
}
rpcErr, err := x.Error.toAppMessage()
// Error is an optional field
if err != nil && !errors.Is(err, errorNil) {
return nil, err
}
return &appmessage.UnbanResponseMessage{
Error: rpcErr,
}, nil
}

3
infrastructure/network/netadapter/server/grpcserver/protowire/wire.go
View File

@ -11,6 +11,9 @@ type converter interface {
// ToAppMessage converts a KaspadMessage to its appmessage.Message representation
func (x *KaspadMessage) ToAppMessage() (appmessage.Message, error) {
if x == nil {
return nil, errors.Wrapf(errorNil, "KaspadMessage is nil")
}
converter, ok := x.Payload.(converter)
if !ok {
return nil, errors.Errorf("received invalid message")