Mirroristas/kaspad
2
0
Fork 0
mirror of https://github.com/kaspanet/kaspad.git synced 2025-06-06 22:26:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

[NOD-1583] Split consensusserialization to consensushashing and serialization

Browse Source
This commit is contained in:
Mike Zak 2020-12-02 13:01:55 +02:00 committed by Svarog
parent ab3c81c552
commit 9866abb75a
55 changed files with 242 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/appmessage/p2p_msgblockheader.go
View File

@ -7,7 +7,7 @@ package appmessage
import (
"math"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/util/mstime"
@ -73,7 +73,7 @@ func (h *MsgBlockHeader) NumParentBlocks() byte {
// BlockHash computes the block identifier hash for the given block header.
func (h *MsgBlockHeader) BlockHash() *externalapi.DomainHash {
return consensusserialization.HeaderHash(BlockHeaderToDomainBlockHeader(h))
return consensushashing.HeaderHash(BlockHeaderToDomainBlockHeader(h))
}
// IsGenesis returns true iff this block is a genesis block

6
app/appmessage/p2p_msgtx.go
View File

@ -10,7 +10,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
@ -162,12 +162,12 @@ func (msg *MsgTx) IsCoinBase() bool {
// TxHash generates the Hash for the transaction.
func (msg *MsgTx) TxHash() *externalapi.DomainHash {
return consensusserialization.TransactionHash(MsgTxToDomainTransaction(msg))
return consensushashing.TransactionHash(MsgTxToDomainTransaction(msg))
}
// TxID generates the Hash for the transaction without the signature script, gas and payload fields.
func (msg *MsgTx) TxID() *externalapi.DomainTransactionID {
return consensusserialization.TransactionID(MsgTxToDomainTransaction(msg))
return consensushashing.TransactionID(MsgTxToDomainTransaction(msg))
}
// Copy creates a deep copy of a transaction so that the original does not get

13
app/protocol/flowcontext/blocks.go
View File

@ -1,13 +1,14 @@
package flowcontext
import (
"sync/atomic"
"github.com/kaspanet/kaspad/app/protocol/blocklogger"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/pkg/errors"
"sync/atomic"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
@ -17,7 +18,7 @@ import (
// relays newly unorphaned transactions and possibly rebroadcast
// manually added transactions when not in IBD.
func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
hash := consensusserialization.BlockHash(block)
hash := consensushashing.BlockHash(block)
log.Debugf("OnNewBlock start for block %s", hash)
defer log.Debugf("OnNewBlock end for block %s", hash)
unorphanedBlocks, err := f.UnorphanBlocks(block)
@ -63,7 +64,7 @@ func (f *FlowContext) broadcastTransactionsAfterBlockAdded(
txIDsToBroadcast := make([]*externalapi.DomainTransactionID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
for i, tx := range transactionsAcceptedToMempool {
txIDsToBroadcast[i] = consensusserialization.TransactionID(tx)
txIDsToBroadcast[i] = consensushashing.TransactionID(tx)
}
offset := len(transactionsAcceptedToMempool)
for i, txID := range txIDsToRebroadcast {
@ -91,7 +92,7 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
err := f.Domain().Consensus().ValidateAndInsertBlock(block)
if err != nil {
if errors.As(err, &ruleerrors.RuleError{}) {
log.Infof("Validation failed for block %s: %s", consensusserialization.BlockHash(block), err)
log.Infof("Validation failed for block %s: %s", consensushashing.BlockHash(block), err)
return nil
}
return err
@ -100,5 +101,5 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
if err != nil {
return err
}
return f.Broadcast(appmessage.NewMsgInvBlock(consensusserialization.BlockHash(block)))
return f.Broadcast(appmessage.NewMsgInvBlock(consensushashing.BlockHash(block)))
}

6
app/protocol/flowcontext/orphans.go
View File

@ -3,7 +3,7 @@ package flowcontext
import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/pkg/errors"
)
@ -12,7 +12,7 @@ func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
f.orphansMutex.Lock()
defer f.orphansMutex.Unlock()
orphanHash := consensusserialization.BlockHash(orphanBlock)
orphanHash := consensushashing.BlockHash(orphanBlock)
f.orphans[*orphanHash] = orphanBlock
log.Infof("Received a block with missing parents, adding to orphan pool: %s", orphanHash)
@ -34,7 +34,7 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*ext
// Find all the children of rootBlock among the orphans
// and add them to the process queue
rootBlockHash := consensusserialization.BlockHash(rootBlock)
rootBlockHash := consensushashing.BlockHash(rootBlock)
processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
var unorphanedBlocks []*externalapi.DomainBlock

8
app/protocol/flowcontext/transactions.go
View File

@ -6,7 +6,7 @@ import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
)
// AddTransaction adds transaction to the mempool and propagates it.
@ -19,7 +19,7 @@ func (f *FlowContext) AddTransaction(tx *externalapi.DomainTransaction) error {
return err
}
transactionID := consensusserialization.TransactionID(tx)
transactionID := consensushashing.TransactionID(tx)
f.transactionsToRebroadcast[*transactionID] = tx
inv := appmessage.NewMsgInvTransaction([]*externalapi.DomainTransactionID{transactionID})
return f.Broadcast(inv)
@ -32,7 +32,7 @@ func (f *FlowContext) updateTransactionsToRebroadcast(block *externalapi.DomainB
// anymore, although they are not included in the UTXO set.
// This is probably ok, since red blocks are quite rare.
for _, tx := range block.Transactions {
delete(f.transactionsToRebroadcast, *consensusserialization.TransactionID(tx))
delete(f.transactionsToRebroadcast, *consensushashing.TransactionID(tx))
}
}
@ -48,7 +48,7 @@ func (f *FlowContext) txIDsToRebroadcast() []*externalapi.DomainTransactionID {
txIDs := make([]*externalapi.DomainTransactionID, len(f.transactionsToRebroadcast))
i := 0
for _, tx := range f.transactionsToRebroadcast {
txIDs[i] = consensusserialization.TransactionID(tx)
txIDs[i] = consensushashing.TransactionID(tx)
i++
}
return txIDs

6
app/protocol/flows/blockrelay/handle_relay_invs.go
View File

@ -9,7 +9,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/blocks"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/infrastructure/logger"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@ -174,7 +174,7 @@ func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) err
}
block := appmessage.MsgBlockToDomainBlock(msgBlock)
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
log.Criticalf("got block %s", blockHash)
if *blockHash != *expectedHash {
@ -213,7 +213,7 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
}
func (flow *handleRelayInvsFlow) processAndRelayBlock(requestQueue *hashesQueueSet, requestedBlocksSet map[externalapi.DomainHash]struct{}, block *externalapi.DomainBlock) error {
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
log.Debugf("processAndRelayBlock start for block %s", blockHash)
defer log.Debugf("processAndRelayBlock end for block %s", blockHash)

4
app/protocol/flows/handshake/sendversion.go
View File

@ -4,7 +4,7 @@ import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/app/protocol/common"
peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/infrastructure/logger"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
"github.com/kaspanet/kaspad/version"
@ -56,7 +56,7 @@ func (flow *sendVersionFlow) start() error {
if err != nil {
return err
}
selectedTipHash := consensusserialization.BlockHash(virtualSelectedParent)
selectedTipHash := consensushashing.BlockHash(virtualSelectedParent)
subnetworkID := flow.Config().SubnetworkID
// Version message.

8
app/protocol/flows/ibd/ibd.go
View File

@ -8,7 +8,7 @@ import (
"github.com/kaspanet/kaspad/domain"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/infrastructure/config"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
"github.com/pkg/errors"
@ -143,7 +143,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies() error {
}
block := appmessage.MsgBlockToDomainBlock(msgIBDBlock.MsgBlock)
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
if *expectedHash != *blockHash {
return protocolerrors.Errorf(true, "expected block %s but got %s", expectedHash, blockHash)
}
@ -179,7 +179,7 @@ func (flow *handleIBDFlow) fetchMissingUTXOSet(ibdRootHash *externalapi.DomainHa
err = flow.Domain().Consensus().ValidateAndInsertBlock(block)
if err != nil {
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "got invalid block %s during IBD", blockHash)
}
@ -333,7 +333,7 @@ func (flow *handleIBDFlow) processHeader(msgBlockHeader *appmessage.MsgBlockHead
Transactions: nil,
}
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockHash)
if err != nil {
return err

4
app/protocol/flows/ibd/selectedtip/handle_request_selected_tip.go
View File

@ -3,7 +3,7 @@ package selectedtip
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/domain"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
"github.com/pkg/errors"
)
@ -61,6 +61,6 @@ func (flow *handleRequestSelectedTipFlow) sendSelectedTipHash() error {
if err != nil {
return err
}
msgSelectedTip := appmessage.NewMsgSelectedTip(consensusserialization.BlockHash(virtualSelectedParent))
msgSelectedTip := appmessage.NewMsgSelectedTip(consensushashing.BlockHash(virtualSelectedParent))
return flow.outgoingRoute.Enqueue(msgSelectedTip)
}

4
app/protocol/flows/relaytransactions/handle_relayed_transactions.go
View File

@ -6,7 +6,7 @@ import (
"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
"github.com/kaspanet/kaspad/domain"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@ -167,7 +167,7 @@ func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransact
continue
}
tx := appmessage.MsgTxToDomainTransaction(msgTx)
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
if txID != expectedID {
return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
expectedID, txID)

13
app/rpc/rpccontext/verbosedata.go
View File

@ -3,10 +3,11 @@ package rpccontext
import (
"encoding/hex"
"fmt"
"github.com/kaspanet/kaspad/domain/consensus/utils/blocks"
"math/big"
"strconv"
"github.com/kaspanet/kaspad/domain/consensus/utils/blocks"
"github.com/kaspanet/kaspad/domain/consensus/utils/estimatedsize"
"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
@ -14,7 +15,7 @@ import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/dagconfig"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/pointers"
@ -23,7 +24,7 @@ import (
// BuildBlockVerboseData builds a BlockVerboseData from the given block.
// This method must be called with the DAG lock held for reads
func (ctx *Context) BuildBlockVerboseData(block *externalapi.DomainBlock, includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
hash := consensusserialization.BlockHash(block)
hash := consensushashing.BlockHash(block)
blockHeader := block.Header
blueScore, err := blocks.ExtractBlueScore(block)
@ -48,14 +49,14 @@ func (ctx *Context) BuildBlockVerboseData(block *externalapi.DomainBlock, includ
txIDs := make([]string, len(block.Transactions))
for i, tx := range block.Transactions {
txIDs[i] = consensusserialization.TransactionID(tx).String()
txIDs[i] = consensushashing.TransactionID(tx).String()
}
result.TxIDs = txIDs
if includeTransactionVerboseData {
transactionVerboseData := make([]*appmessage.TransactionVerboseData, len(block.Transactions))
for i, tx := range block.Transactions {
txID := consensusserialization.TransactionID(tx).String()
txID := consensushashing.TransactionID(tx).String()
data, err := ctx.BuildTransactionVerboseData(tx, txID, blockHeader, hash.String())
if err != nil {
return nil, err
@ -100,7 +101,7 @@ func (ctx *Context) BuildTransactionVerboseData(tx *externalapi.DomainTransactio
txReply := &appmessage.TransactionVerboseData{
TxID: txID,
Hash: consensusserialization.TransactionHash(tx).String(),
Hash: consensushashing.TransactionHash(tx).String(),
Size: estimatedsize.TransactionEstimatedSerializedSize(tx),
TransactionVerboseInputs: ctx.buildTransactionVerboseInputs(tx),
TransactionVerboseOutputs: ctx.buildTransactionVerboseOutputs(tx, nil),

4
app/rpc/rpchandlers/get_selected_tip_hash.go
View File

@ -3,7 +3,7 @@ package rpchandlers
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/app/rpc/rpccontext"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
)
@ -15,7 +15,7 @@ func HandleGetSelectedTipHash(context *rpccontext.Context, _ *router.Router, _ a
}
response := appmessage.NewGetSelectedTipHashResponseMessage(
consensusserialization.BlockHash(selectedTip).String())
consensushashing.BlockHash(selectedTip).String())
return response, nil
}

4
app/rpc/rpchandlers/submit_block.go
View File

@ -3,7 +3,7 @@ package rpchandlers
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/app/rpc/rpccontext"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
)
@ -21,7 +21,7 @@ func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request ap
return errorMessage, nil
}
log.Infof("Accepted block %s via submitBlock", consensusserialization.BlockHash(domainBlock))
log.Infof("Accepted block %s via submitBlock", consensushashing.BlockHash(domainBlock))
response := appmessage.NewSubmitBlockResponseMessage()
return response, nil

4
app/rpc/rpchandlers/submit_transaction.go
View File

@ -3,7 +3,7 @@ package rpchandlers
import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/app/rpc/rpccontext"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
"github.com/pkg/errors"
@ -14,7 +14,7 @@ func HandleSubmitTransaction(context *rpccontext.Context, _ *router.Router, requ
submitTransactionRequest := request.(*appmessage.SubmitTransactionRequestMessage)
domainTransaction := appmessage.MsgTxToDomainTransaction(submitTransactionRequest.Transaction)
transactionID := consensusserialization.TransactionID(domainTransaction)
transactionID := consensushashing.TransactionID(domainTransaction)
err := context.ProtocolManager.AddTransaction(domainTransaction)
if err != nil {
if !errors.As(err, &mempool.RuleError{}) {

6
cmd/kaspaminer/mineloop.go
View File

@ -9,7 +9,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@ -95,7 +95,7 @@ func mineNextBlock(client *minerClient, miningAddr util.Address, foundBlock chan
}
func handleFoundBlock(client *minerClient, block *externalapi.DomainBlock) error {
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
log.Infof("Found block %s with parents %s. Submitting to %s", blockHash, block.Header.ParentHashes, client.Address())
err := client.SubmitBlock(block)
@ -114,7 +114,7 @@ func solveBlock(block *externalapi.DomainBlock, stopChan chan struct{}, foundBlo
return
default:
block.Header.Nonce = i
hash := consensusserialization.BlockHash(block)
hash := consensushashing.BlockHash(block)
atomic.AddUint64(&hashesTried, 1)
if hashes.ToBig(hash).Cmp(targetDifficulty) <= 0 {
foundBlock <- block

6
domain/consensus/consensus_test.go
View File

@ -5,7 +5,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
"github.com/kaspanet/kaspad/domain/dagconfig"
"github.com/pkg/errors"
@ -31,7 +31,7 @@ func TestConsensus_GetBlockInfo(t *testing.T) {
t.Fatalf("Expected block to be invalid with err: %v, instead found: %v", ruleerrors.ErrTimeTooOld, err)
}
info, err := consensus.GetBlockInfo(consensusserialization.BlockHash(invalidBlock))
info, err := consensus.GetBlockInfo(consensushashing.BlockHash(invalidBlock))
if err != nil {
t.Fatalf("Failed to get block info: %v", err)
}
@ -57,7 +57,7 @@ func TestConsensus_GetBlockInfo(t *testing.T) {
t.Fatalf("consensus.ValidateAndInsertBlock with a block straight from consensus.BuildBlock should not fail: %v", err)
}
info, err = consensus.GetBlockInfo(consensusserialization.BlockHash(validBlock))
info, err = consensus.GetBlockInfo(consensushashing.BlockHash(validBlock))
if err != nil {
t.Fatalf("Failed to get block info: %v", err)
}

54
domain/consensus/finality_test.go
View File

@ -5,7 +5,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/model/testapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
"github.com/kaspanet/kaspad/domain/dagconfig"
"github.com/pkg/errors"
@ -49,7 +49,7 @@ func TestFinality(t *testing.T) {
if err != nil {
t.Fatalf("TestFinality: Failed to process Block #%d: %v", i, err)
}
mainChainTipHash = consensusserialization.BlockHash(mainChainTip)
mainChainTipHash = consensushashing.BlockHash(mainChainTip)
blockInfo, err := consensus.GetBlockInfo(mainChainTipHash)
if err != nil {
@ -69,7 +69,7 @@ func TestFinality(t *testing.T) {
if err != nil {
t.Fatalf("TestFinality: Failed to process sidechain Block #%d: %v", i, err)
}
sideChainTipHash = consensusserialization.BlockHash(sideChainTip)
sideChainTipHash = consensushashing.BlockHash(sideChainTip)
blockInfo, err := consensus.GetBlockInfo(sideChainTipHash)
if err != nil {
@ -89,7 +89,7 @@ func TestFinality(t *testing.T) {
if err != nil {
t.Fatalf("TestFinality: Failed to process sidechain Block #%d: %v", i, err)
}
sideChainTipHash = consensusserialization.BlockHash(sideChainTip)
sideChainTipHash = consensushashing.BlockHash(sideChainTip)
}
// Make sure that now the sideChainTip is valid and selectedTip
@ -107,7 +107,7 @@ func TestFinality(t *testing.T) {
if err != nil {
t.Fatalf("TestFinality: Failed getting virtual selectedParent: %v", err)
}
if *consensusserialization.BlockHash(selectedTip) != *sideChainTipHash {
if *consensushashing.BlockHash(selectedTip) != *sideChainTipHash {
t.Fatalf("Overtaking block in side-chain is not selectedTip")
}
@ -117,7 +117,7 @@ func TestFinality(t *testing.T) {
if err != nil {
t.Fatalf("TestFinality: Failed to process sidechain Block #%d: %v", i, err)
}
mainChainTipHash = consensusserialization.BlockHash(mainChainTip)
mainChainTipHash = consensushashing.BlockHash(mainChainTip)
}
virtualFinality, err := consensus.ConsensusStateManager().VirtualFinalityPoint()
@ -137,7 +137,7 @@ func TestFinality(t *testing.T) {
if err != nil {
t.Fatalf("TestFinality: Failed to process sidechain Block #%d: %v", i, err)
}
sideChainTipHash = consensusserialization.BlockHash(sideChainTip)
sideChainTipHash = consensushashing.BlockHash(sideChainTip)
}
// Check that sideChainTip hash higher blue score than the selected parent
@ -145,7 +145,7 @@ func TestFinality(t *testing.T) {
if err != nil {
t.Fatalf("TestFinality: Failed getting virtual selectedParent: %v", err)
}
selectedTipGhostDagData, err := consensus.GHOSTDAGDataStore().Get(consensus.DatabaseContext(), consensusserialization.BlockHash(selectedTip))
selectedTipGhostDagData, err := consensus.GHOSTDAGDataStore().Get(consensus.DatabaseContext(), consensushashing.BlockHash(selectedTip))
if err != nil {
t.Fatalf("TestFinality: Failed getting the ghost dag data of the selected tip: %v", err)
}
@ -222,7 +222,7 @@ func TestBoundedMergeDepth(t *testing.T) {
}
getStatus := func(consensus testapi.TestConsensus, block *externalapi.DomainBlock) externalapi.BlockStatus {
blockInfo, err := consensus.GetBlockInfo(consensusserialization.BlockHash(block))
blockInfo, err := consensus.GetBlockInfo(consensushashing.BlockHash(block))
if err != nil {
t.Fatalf("TestBoundedMergeDepth: Failed to get block info: %v", err)
} else if !blockInfo.Exists {
@ -248,21 +248,21 @@ func TestBoundedMergeDepth(t *testing.T) {
// Create a chain
selectedChain := make([]*externalapi.DomainBlock, 0, finalityInterval+1)
parent := consensusserialization.BlockHash(block1)
parent := consensushashing.BlockHash(block1)
// Make sure this is always bigger than `blocksChain2` so it will stay the selected chain
for i := 0; i < finalityInterval+2; i++ {
block := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{parent})
selectedChain = append(selectedChain, block)
parent = consensusserialization.BlockHash(block)
parent = consensushashing.BlockHash(block)
}
// Create another chain
blocksChain2 := make([]*externalapi.DomainBlock, 0, finalityInterval+1)
parent = consensusserialization.BlockHash(block1)
parent = consensushashing.BlockHash(block1)
for i := 0; i < finalityInterval+1; i++ {
block := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{parent})
blocksChain2 = append(blocksChain2, block)
parent = consensusserialization.BlockHash(block)
parent = consensushashing.BlockHash(block)
}
// Teardown and assign nil to make sure we use the right DAG from here on.
@ -284,20 +284,20 @@ func TestBoundedMergeDepth(t *testing.T) {
}
// submit a block pointing at tip(chain1) and on first block in chain2 directly
mergeDepthViolatingBlockBottom, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensusserialization.BlockHash(blocksChain2[0]), consensusserialization.BlockHash(selectedChain[len(selectedChain)-1])})
mergeDepthViolatingBlockBottom, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[0]), consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
if !isViolatingMergeDepth {
t.Fatalf("TestBoundedMergeDepth: Expected mergeDepthViolatingBlockBottom to violate merge depth")
}
// submit a block pointing at tip(chain1) and tip(chain2) should also obviously violate merge depth (this points at first block in chain2 indirectly)
mergeDepthViolatingTop, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensusserialization.BlockHash(blocksChain2[len(blocksChain2)-1]), consensusserialization.BlockHash(selectedChain[len(selectedChain)-1])})
mergeDepthViolatingTop, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[len(blocksChain2)-1]), consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
if !isViolatingMergeDepth {
t.Fatalf("TestBoundedMergeDepth: Expected mergeDepthViolatingTop to violate merge depth")
}
// the location of the parents in the slices need to be both `-X` so the `selectedChain` one will have higher blueScore (it's a chain longer by 1)
kosherizingBlock, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensusserialization.BlockHash(blocksChain2[len(blocksChain2)-3]), consensusserialization.BlockHash(selectedChain[len(selectedChain)-3])})
kosherizingBlockHash := consensusserialization.BlockHash(kosherizingBlock)
kosherizingBlock, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[len(blocksChain2)-3]), consensushashing.BlockHash(selectedChain[len(selectedChain)-3])})
kosherizingBlockHash := consensushashing.BlockHash(kosherizingBlock)
if isViolatingMergeDepth {
t.Fatalf("TestBoundedMergeDepth: Expected blueKosherizingBlock to not violate merge depth")
}
@ -318,7 +318,7 @@ func TestBoundedMergeDepth(t *testing.T) {
t.Fatalf("TestBoundedMergeDepth: Expected kosherizingBlock to be blue by the virtual")
}
pointAtBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{kosherizingBlockHash, consensusserialization.BlockHash(selectedChain[len(selectedChain)-1])})
pointAtBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{kosherizingBlockHash, consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
if isViolatingMergeDepth {
t.Fatalf("TestBoundedMergeDepth: Expected selectedTip to not violate merge depth")
@ -329,16 +329,16 @@ func TestBoundedMergeDepth(t *testing.T) {
t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
}
if *consensusserialization.BlockHash(virtualSelectedParent) != *consensusserialization.BlockHash(pointAtBlueKosherizing) {
t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensusserialization.BlockHash(pointAtBlueKosherizing), consensusserialization.BlockHash(virtualSelectedParent))
if *consensushashing.BlockHash(virtualSelectedParent) != *consensushashing.BlockHash(pointAtBlueKosherizing) {
t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensushashing.BlockHash(pointAtBlueKosherizing), consensushashing.BlockHash(virtualSelectedParent))
}
// Now let's make the kosherizing block red and try to merge again
tip := consensusserialization.BlockHash(selectedChain[len(selectedChain)-1])
tip := consensushashing.BlockHash(selectedChain[len(selectedChain)-1])
// we use k-1 because `kosherizingBlock` points at tip-2, so 2+k-1 = k+1 anticone.
for i := 0; i < int(params.K)-1; i++ {
block := buildAndInsertBlock(consensusReal, []*externalapi.DomainHash{tip})
tip = consensusserialization.BlockHash(block)
tip = consensushashing.BlockHash(block)
}
virtualSelectedParent, err = consensusReal.GetVirtualSelectedParent()
@ -346,8 +346,8 @@ func TestBoundedMergeDepth(t *testing.T) {
t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
}
if *consensusserialization.BlockHash(virtualSelectedParent) != *tip {
t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", tip, consensusserialization.BlockHash(virtualSelectedParent))
if *consensushashing.BlockHash(virtualSelectedParent) != *tip {
t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", tip, consensushashing.BlockHash(virtualSelectedParent))
}
virtualGhotDagData, err = consensusReal.GHOSTDAGDataStore().Get(consensusReal.DatabaseContext(), model.VirtualBlockHash)
@ -372,7 +372,7 @@ func TestBoundedMergeDepth(t *testing.T) {
}
// Now `pointAtBlueKosherizing` itself is actually still blue, so we can still point at that even though we can't point at kosherizing directly anymore
transitiveBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensusserialization.BlockHash(pointAtBlueKosherizing), tip})
transitiveBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(pointAtBlueKosherizing), tip})
if isViolatingMergeDepth {
t.Fatalf("TestBoundedMergeDepth: Expected transitiveBlueKosherizing to not violate merge depth")
}
@ -382,8 +382,8 @@ func TestBoundedMergeDepth(t *testing.T) {
t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
}
if *consensusserialization.BlockHash(virtualSelectedParent) != *consensusserialization.BlockHash(transitiveBlueKosherizing) {
t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensusserialization.BlockHash(transitiveBlueKosherizing), consensusserialization.BlockHash(virtualSelectedParent))
if *consensushashing.BlockHash(virtualSelectedParent) != *consensushashing.BlockHash(transitiveBlueKosherizing) {
t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensushashing.BlockHash(transitiveBlueKosherizing), consensushashing.BlockHash(virtualSelectedParent))
}
// Lets validate the status of all the interesting blocks

2
domain/consensus/model/externalapi/transaction.go
View File

@ -19,7 +19,7 @@ type DomainTransaction struct {
Mass uint64
// ID is a field that is used to cache the transaction ID.
// Always use consensusserialization.TransactionID instead of accessing this field directly
// Always use consensushashing.TransactionID instead of accessing this field directly
ID *DomainTransactionID
}

6
domain/consensus/processes/blockbuilder/block_builder.go
View File

@ -5,7 +5,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/kaspanet/kaspad/domain/consensus/utils/merkle"
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
@ -193,8 +193,8 @@ func (bb *blockBuilder) calculateAcceptedIDMerkleRoot(acceptanceData model.Accep
}
}
sort.Slice(acceptedTransactions, func(i, j int) bool {
acceptedTransactionIID := consensusserialization.TransactionID(acceptedTransactions[i])
acceptedTransactionJID := consensusserialization.TransactionID(acceptedTransactions[j])
acceptedTransactionIID := consensushashing.TransactionID(acceptedTransactions[i])
acceptedTransactionJID := consensushashing.TransactionID(acceptedTransactions[j])
return transactionid.Less(acceptedTransactionIID, acceptedTransactionJID)
})

13
domain/consensus/processes/blockprocessor/validateandinsertblock.go
View File

@ -2,16 +2,17 @@ package blockprocessor
import (
"fmt"
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/infrastructure/logger"
"github.com/pkg/errors"
)
func (bp *blockProcessor) validateAndInsertBlock(block *externalapi.DomainBlock) error {
hash := consensusserialization.HeaderHash(block.Header)
hash := consensushashing.HeaderHash(block.Header)
log.Debugf("Validating block %s", hash)
syncInfo, err := bp.syncManager.GetSyncInfo()
@ -222,7 +223,7 @@ func (bp *blockProcessor) checkBlockStatus(hash *externalapi.DomainHash, mode *e
}
func (bp *blockProcessor) validateBlock(block *externalapi.DomainBlock, mode *externalapi.SyncInfo) error {
blockHash := consensusserialization.HeaderHash(block.Header)
blockHash := consensushashing.HeaderHash(block.Header)
hasHeader, err := bp.hasHeader(blockHash)
if err != nil {
return err
@ -251,7 +252,7 @@ func (bp *blockProcessor) validateBlock(block *externalapi.DomainBlock, mode *ex
if err != nil {
if errors.As(err, &ruleerrors.RuleError{}) {
bp.discardAllChanges()
hash := consensusserialization.BlockHash(block)
hash := consensushashing.BlockHash(block)
bp.blockStatusStore.Stage(hash, externalapi.StatusInvalid)
commitErr := bp.commitAllChanges()
if commitErr != nil {
@ -264,7 +265,7 @@ func (bp *blockProcessor) validateBlock(block *externalapi.DomainBlock, mode *ex
}
func (bp *blockProcessor) validatePreProofOfWork(block *externalapi.DomainBlock) error {
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
hasHeader, err := bp.hasHeader(blockHash)
if err != nil {
@ -283,7 +284,7 @@ func (bp *blockProcessor) validatePreProofOfWork(block *externalapi.DomainBlock)
}
func (bp *blockProcessor) validatePostProofOfWork(block *externalapi.DomainBlock, mode *externalapi.SyncInfo) error {
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
if mode.State != externalapi.SyncStateHeadersFirst {
bp.blockStore.Stage(blockHash, block)

7
domain/consensus/processes/blockvalidator/block_body_in_context.go
View File

@ -1,12 +1,13 @@
package blockvalidator
import (
"math"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
"github.com/pkg/errors"
"math"
)
// ValidateBodyInContext validates block bodies in the context of the current
@ -39,7 +40,7 @@ func (v *blockValidator) checkBlockTransactionsFinalized(blockHash *externalapi.
// Ensure all transactions in the block are finalized.
for _, tx := range block.Transactions {
if !v.isFinalizedTransaction(tx, ghostdagData.BlueScore, blockTime) {
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
return errors.Wrapf(ruleerrors.ErrUnfinalizedTx, "block contains unfinalized "+
"transaction %s", txID)
}

12
domain/consensus/processes/blockvalidator/block_body_in_isolation.go
View File

@ -4,7 +4,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/coinbase"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/kaspanet/kaspad/domain/consensus/utils/estimatedsize"
"github.com/kaspanet/kaspad/domain/consensus/utils/merkle"
@ -132,7 +132,7 @@ func (v *blockValidator) checkTransactionsInIsolation(block *externalapi.DomainB
err := v.transactionValidator.ValidateTransactionInIsolation(tx)
if err != nil {
return errors.Wrapf(err, "transaction %s failed isolation "+
"check", consensusserialization.TransactionID(tx))
"check", consensushashing.TransactionID(tx))
}
}
@ -152,7 +152,7 @@ func (v *blockValidator) checkBlockHashMerkleRoot(block *externalapi.DomainBlock
func (v *blockValidator) checkBlockDuplicateTransactions(block *externalapi.DomainBlock) error {
existingTxIDs := make(map[externalapi.DomainTransactionID]struct{})
for _, tx := range block.Transactions {
id := consensusserialization.TransactionID(tx)
id := consensushashing.TransactionID(tx)
if _, exists := existingTxIDs[*id]; exists {
return errors.Wrapf(ruleerrors.ErrDuplicateTx, "block contains duplicate "+
"transaction %s", id)
@ -166,7 +166,7 @@ func (v *blockValidator) checkBlockDoubleSpends(block *externalapi.DomainBlock)
usedOutpoints := make(map[externalapi.DomainOutpoint]*externalapi.DomainTransactionID)
for _, tx := range block.Transactions {
for _, input := range tx.Inputs {
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
if spendingTxID, exists := usedOutpoints[input.PreviousOutpoint]; exists {
return errors.Wrapf(ruleerrors.ErrDoubleSpendInSameBlock, "transaction %s spends "+
"outpoint %s that was already spent by "+
@ -184,14 +184,14 @@ func (v *blockValidator) checkBlockHasNoChainedTransactions(block *externalapi.D
transactions := block.Transactions
transactionsSet := make(map[externalapi.DomainTransactionID]struct{}, len(transactions))
for _, transaction := range transactions {
txID := consensusserialization.TransactionID(transaction)
txID := consensushashing.TransactionID(transaction)
transactionsSet[*txID] = struct{}{}
}
for _, transaction := range transactions {
for i, transactionInput := range transaction.Inputs {
if _, ok := transactionsSet[transactionInput.PreviousOutpoint.TransactionID]; ok {
txID := consensusserialization.TransactionID(transaction)
txID := consensushashing.TransactionID(transaction)
return errors.Wrapf(ruleerrors.ErrChainedTransactions, "block contains chained "+
"transactions: Input %d of transaction %s spend "+
"an output of transaction %s", i, txID, transactionInput.PreviousOutpoint.TransactionID)

13
domain/consensus/processes/blockvalidator/block_body_in_isolation_test.go
View File

@ -1,16 +1,17 @@
package blockvalidator_test
import (
"math"
"testing"
"github.com/kaspanet/kaspad/domain/consensus"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
"github.com/kaspanet/kaspad/domain/dagconfig"
"github.com/pkg/errors"
"math"
"testing"
)
func TestChainedTransactions(t *testing.T) {
@ -86,7 +87,7 @@ func TestCheckBlockSanity(t *testing.T) {
t.Fatalf("Error setting up consensus: %+v", err)
}
defer teardown()
blockHash := consensusserialization.BlockHash(&exampleValidBlock)
blockHash := consensushashing.BlockHash(&exampleValidBlock)
if len(exampleValidBlock.Transactions) < 3 {
t.Fatalf("Too few transactions in block, expect at least 3, got %v", len(exampleValidBlock.Transactions))
}
@ -99,7 +100,7 @@ func TestCheckBlockSanity(t *testing.T) {
}
// Test with block with wrong transactions sorting order
blockHash = consensusserialization.BlockHash(&blockWithWrongTxOrder)
blockHash = consensushashing.BlockHash(&blockWithWrongTxOrder)
consensus.BlockStore().Stage(blockHash, &blockWithWrongTxOrder)
err = consensus.BlockValidator().ValidateBodyInIsolation(blockHash)
if !errors.Is(err, ruleerrors.ErrTransactionsNotSorted) {
@ -108,7 +109,7 @@ func TestCheckBlockSanity(t *testing.T) {
// Test a block with invalid parents order
// We no longer require blocks to have ordered parents
blockHash = consensusserialization.BlockHash(&unOrderedParentsBlock)
blockHash = consensushashing.BlockHash(&unOrderedParentsBlock)
consensus.BlockStore().Stage(blockHash, &unOrderedParentsBlock)
err = consensus.BlockValidator().ValidateBodyInIsolation(blockHash)
if err != nil {

4
domain/consensus/processes/blockvalidator/block_header_in_context.go
View File

@ -3,7 +3,7 @@ package blockvalidator
import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/pkg/errors"
)
@ -96,7 +96,7 @@ func (v *blockValidator) validateMedianTime(header *externalapi.DomainBlockHeade
// Ensure the timestamp for the block header is not before the
// median time of the last several blocks (medianTimeBlocks).
hash := consensusserialization.HeaderHash(header)
hash := consensushashing.HeaderHash(header)
pastMedianTime, err := v.pastMedianTimeManager.PastMedianTime(hash)
if err != nil {
return err

4
domain/consensus/processes/blockvalidator/block_header_in_context_test.go
View File

@ -8,7 +8,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
"github.com/kaspanet/kaspad/domain/dagconfig"
)
@ -34,7 +34,7 @@ func TestValidateMedianTime(t *testing.T) {
t.Fatalf("expected error %s but got %+v", expectedErr, err)
}
return block, consensusserialization.BlockHash(block)
return block, consensushashing.BlockHash(block)
}
pastMedianTime := func(parents ...*externalapi.DomainHash) int64 {

4
domain/consensus/processes/blockvalidator/block_header_in_isolation.go
View File

@ -3,7 +3,7 @@ package blockvalidator
import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/pkg/errors"
)
@ -25,7 +25,7 @@ func (v *blockValidator) ValidateHeaderInIsolation(blockHash *externalapi.Domain
}
func (v *blockValidator) checkParentsLimit(header *externalapi.DomainBlockHeader) error {
hash := consensusserialization.HeaderHash(header)
hash := consensushashing.HeaderHash(header)
if len(header.ParentHashes) == 0 && *hash != *v.genesisHash {
return errors.Wrapf(ruleerrors.ErrNoParents, "block has no parents")
}

4
domain/consensus/processes/blockvalidator/proof_of_work.go
View File

@ -3,7 +3,7 @@ package blockvalidator
import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
"github.com/kaspanet/kaspad/util"
"github.com/pkg/errors"
@ -93,7 +93,7 @@ func (v *blockValidator) checkProofOfWork(header *externalapi.DomainBlockHeader)
// to avoid proof of work checks is set.
if !v.skipPoW {
// The block hash must be less than the claimed target.
hash := consensusserialization.HeaderHash(header)
hash := consensushashing.HeaderHash(header)
hashNum := hashes.ToBig(hash)
if hashNum.Cmp(target) > 0 {
return errors.Wrapf(ruleerrors.ErrUnexpectedDifficulty, "block hash of %064x is higher than "+

10
domain/consensus/processes/consensusstatemanager/calculate_past_utxo.go
View File

@ -1,7 +1,7 @@
package consensusstatemanager
import (
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/kaspanet/kaspad/domain/consensus/utils/multiset"
"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
@ -132,7 +132,7 @@ func (csm *consensusStateManager) applyBlueBlocks(blockHash *externalapi.DomainH
accumulatedMass := uint64(0)
for i, blueBlock := range blueBlocks {
blueBlockHash := consensusserialization.BlockHash(blueBlock)
blueBlockHash := consensushashing.BlockHash(blueBlock)
log.Tracef("Applying blue block %s", blueBlockHash)
blockAcceptanceData := &model.BlockAcceptanceData{
TransactionAcceptanceData: make([]*model.TransactionAcceptanceData, len(blueBlock.Transactions)),
@ -143,7 +143,7 @@ func (csm *consensusStateManager) applyBlueBlocks(blockHash *externalapi.DomainH
for j, transaction := range blueBlock.Transactions {
var isAccepted bool
transactionID := consensusserialization.TransactionID(transaction)
transactionID := consensushashing.TransactionID(transaction)
log.Tracef("Attempting to accept transaction %s in block %s",
transactionID, blueBlockHash)
@ -172,7 +172,7 @@ func (csm *consensusStateManager) maybeAcceptTransaction(transaction *externalap
accumulatedMassBefore uint64, selectedParentPastMedianTime int64, blockBlueScore uint64) (
isAccepted bool, accumulatedMassAfter uint64, err error) {
transactionID := consensusserialization.TransactionID(transaction)
transactionID := consensushashing.TransactionID(transaction)
log.Tracef("maybeAcceptTransaction start for transaction %s in block %s", transactionID, blockHash)
defer log.Tracef("maybeAcceptTransaction end for transaction %s in block %s", transactionID, blockHash)
@ -232,7 +232,7 @@ func (csm *consensusStateManager) checkTransactionMass(
transaction *externalapi.DomainTransaction, accumulatedMassBefore uint64) (
isAccepted bool, accumulatedMassAfter uint64) {
transactionID := consensusserialization.TransactionID(transaction)
transactionID := consensushashing.TransactionID(transaction)
log.Tracef("checkTransactionMass start for transaction %s", transactionID)
defer log.Tracef("checkTransactionMass end for transaction %s", transactionID)

11
domain/consensus/processes/consensusstatemanager/multisets.go
View File

@ -3,8 +3,9 @@ package consensusstatemanager
import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/multiset"
"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
"github.com/kaspanet/kaspad/domain/consensus/utils/utxoserialization"
)
@ -29,7 +30,7 @@ func (csm *consensusStateManager) calculateMultiset(
for _, blockAcceptanceData := range acceptanceData {
for i, transactionAcceptanceData := range blockAcceptanceData.TransactionAcceptanceData {
transaction := transactionAcceptanceData.Transaction
transactionID := consensusserialization.TransactionID(transaction)
transactionID := consensushashing.TransactionID(transaction)
if !transactionAcceptanceData.IsAccepted {
log.Tracef("Skipping transaction %s because it was not accepted", transactionID)
continue
@ -53,7 +54,7 @@ func (csm *consensusStateManager) calculateMultiset(
func addTransactionToMultiset(multiset model.Multiset, transaction *externalapi.DomainTransaction,
blockBlueScore uint64, isCoinbase bool) error {
transactionID := consensusserialization.TransactionID(transaction)
transactionID := consensushashing.TransactionID(transaction)
log.Tracef("addTransactionToMultiset start for transaction %s", transactionID)
defer log.Tracef("addTransactionToMultiset end for transaction %s", transactionID)
@ -90,7 +91,7 @@ func addTransactionToMultiset(multiset model.Multiset, transaction *externalapi.
func addUTXOToMultiset(multiset model.Multiset, entry *externalapi.UTXOEntry,
outpoint *externalapi.DomainOutpoint) error {
serializedUTXO, err := consensusserialization.SerializeUTXO(entry, outpoint)
serializedUTXO, err := utxo.SerializeUTXO(entry, outpoint)
if err != nil {
return err
}
@ -102,7 +103,7 @@ func addUTXOToMultiset(multiset model.Multiset, entry *externalapi.UTXOEntry,
func removeUTXOFromMultiset(multiset model.Multiset, entry *externalapi.UTXOEntry,
outpoint *externalapi.DomainOutpoint) error {
serializedUTXO, err := consensusserialization.SerializeUTXO(entry, outpoint)
serializedUTXO, err := utxo.SerializeUTXO(entry, outpoint)
if err != nil {
return err
}

4
domain/consensus/processes/consensusstatemanager/populate_tx_with_utxo_entries.go
View File

@ -4,7 +4,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/utxo/utxoalgebra"
)
@ -19,7 +19,7 @@ func (csm *consensusStateManager) PopulateTransactionWithUTXOEntries(transaction
func (csm *consensusStateManager) populateTransactionWithUTXOEntriesFromVirtualOrDiff(
transaction *externalapi.DomainTransaction, utxoDiff *model.UTXODiff) error {
transactionID := consensusserialization.TransactionID(transaction)
transactionID := consensushashing.TransactionID(transaction)
log.Tracef("populateTransactionWithUTXOEntriesFromVirtualOrDiff start for transaction %s", transactionID)
defer log.Tracef("populateTransactionWithUTXOEntriesFromVirtualOrDiff end for transaction %s", transactionID)

6
domain/consensus/processes/consensusstatemanager/resolve_block_status_test.go
View File

@ -6,7 +6,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@ -54,8 +54,8 @@ func TestDoubleSpends(t *testing.T) {
t.Fatalf("Error creating spendingTransaction2: %+v", err)
}
spendingTransaction2.Outputs[0].Value-- // tweak the value to create a different ID
spendingTransaction1ID := consensusserialization.TransactionID(spendingTransaction1)
spendingTransaction2ID := consensusserialization.TransactionID(spendingTransaction2)
spendingTransaction1ID := consensushashing.TransactionID(spendingTransaction1)
spendingTransaction2ID := consensushashing.TransactionID(spendingTransaction2)
if *spendingTransaction1ID == *spendingTransaction2ID {
t.Fatalf("spendingTransaction1 and spendingTransaction2 ids are equal")
}

7
domain/consensus/processes/consensusstatemanager/set_pruning_utxo_set.go
View File

@ -5,7 +5,8 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/serialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
"github.com/kaspanet/kaspad/domain/consensus/utils/utxoserialization"
"github.com/kaspanet/kaspad/infrastructure/logger"
"github.com/pkg/errors"
@ -130,9 +131,9 @@ func (p protoUTXOSetIterator) Next() bool {
}
func (p protoUTXOSetIterator) Get() (outpoint *externalapi.DomainOutpoint, utxoEntry *externalapi.UTXOEntry, err error) {
entry, outpoint, err := consensusserialization.DeserializeUTXO(p.utxoSet.Utxos[p.index].EntryOutpointPair)
entry, outpoint, err := utxo.DeserializeUTXO(p.utxoSet.Utxos[p.index].EntryOutpointPair)
if err != nil {
if consensusserialization.IsMalformedError(err) {
if serialization.IsMalformedError(err) {
return nil, nil, errors.Wrap(ruleerrors.ErrMalformedUTXO, "malformed utxo")
}
return nil, nil, err

16
domain/consensus/processes/consensusstatemanager/verify_and_build_utxo.go
View File

@ -8,7 +8,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/utils/coinbase"
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/merkle"
@ -40,7 +40,7 @@ func (csm *consensusStateManager) verifyUTXO(block *externalapi.DomainBlock, blo
coinbaseTransaction := block.Transactions[0]
log.Tracef("Validating coinbase transaction %s for block %s",
consensusserialization.TransactionID(coinbaseTransaction), blockHash)
consensushashing.TransactionID(coinbaseTransaction), blockHash)
err = csm.validateCoinbaseTransaction(blockHash, coinbaseTransaction)
if err != nil {
return err
@ -70,7 +70,7 @@ func (csm *consensusStateManager) validateBlockTransactionsAgainstPastUTXO(block
log.Tracef("The past median time of %s is %d", blockHash, selectedParentMedianTime)
for i, transaction := range block.Transactions {
transactionID := consensusserialization.TransactionID(transaction)
transactionID := consensushashing.TransactionID(transaction)
log.Tracef("Validating transaction %s in block %s against "+
"the block's past UTXO", transactionID, blockHash)
if i == transactionhelper.CoinbaseTransactionIndex {
@ -143,8 +143,8 @@ func calculateAcceptedIDMerkleRoot(multiblockAcceptanceData model.AcceptanceData
}
sort.Slice(acceptedTransactions, func(i, j int) bool {
return transactionid.Less(
consensusserialization.TransactionID(acceptedTransactions[i]),
consensusserialization.TransactionID(acceptedTransactions[j]))
consensushashing.TransactionID(acceptedTransactions[i]),
consensushashing.TransactionID(acceptedTransactions[j]))
})
return merkle.CalculateIDMerkleRoot(acceptedTransactions)
@ -156,7 +156,7 @@ func (csm *consensusStateManager) validateCoinbaseTransaction(blockHash *externa
defer log.Tracef("validateCoinbaseTransaction end for block %s", blockHash)
log.Tracef("Extracting coinbase data for coinbase transaction %s in block %s",
consensusserialization.TransactionID(coinbaseTransaction), blockHash)
consensushashing.TransactionID(coinbaseTransaction), blockHash)
_, coinbaseData, err := coinbase.ExtractCoinbaseDataAndBlueScore(coinbaseTransaction)
if err != nil {
return err
@ -168,8 +168,8 @@ func (csm *consensusStateManager) validateCoinbaseTransaction(blockHash *externa
return err
}
coinbaseTransactionHash := consensusserialization.TransactionHash(coinbaseTransaction)
expectedCoinbaseTransactionHash := consensusserialization.TransactionHash(expectedCoinbaseTransaction)
coinbaseTransactionHash := consensushashing.TransactionHash(coinbaseTransaction)
expectedCoinbaseTransactionHash := consensushashing.TransactionHash(expectedCoinbaseTransaction)
log.Tracef("given coinbase hash: %s, expected coinbase hash: %s",
coinbaseTransactionHash, expectedCoinbaseTransactionHash)

4
domain/consensus/processes/pastmediantimemanager/pastmediantimemanager_test.go
View File

@ -5,7 +5,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
"github.com/kaspanet/kaspad/domain/dagconfig"
)
@ -36,7 +36,7 @@ func TestPastMedianTime(t *testing.T) {
t.Fatalf("ValidateAndInsertBlock: %+v", err)
}
blockHashes[i] = consensusserialization.BlockHash(block)
blockHashes[i] = consensushashing.BlockHash(block)
}
tests := []struct {

4
domain/consensus/ruleerrors/rule_error.go
View File

@ -4,7 +4,7 @@ import (
"fmt"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/pkg/errors"
)
@ -311,7 +311,7 @@ type InvalidTransaction struct {
}
func (invalid InvalidTransaction) String() string {
return fmt.Sprintf("(%v: %s)", consensusserialization.TransactionID(invalid.Transaction), invalid.err)
return fmt.Sprintf("(%v: %s)", consensushashing.TransactionID(invalid.Transaction), invalid.err)
}
// ErrInvalidTransactionsInNewBlock indicates that some transactions in a new block are invalid

4
domain/consensus/test_consensus.go
View File

@ -4,7 +4,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/model/testapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
)
type testConsensus struct {
@ -44,7 +44,7 @@ func (tc *testConsensus) AddBlock(parentHashes []*externalapi.DomainHash, coinba
return nil, err
}
return consensusserialization.BlockHash(block), nil
return consensushashing.BlockHash(block), nil
}
func (tc *testConsensus) DiscardAllStores() {

10
domain/consensus/utils/consensusserialization/block.go → domain/consensus/utils/consensushashing/block.go
View File

@ -1,8 +1,10 @@
package consensusserialization
package consensushashing
import (
"io"
"github.com/kaspanet/kaspad/domain/consensus/utils/serialization"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
"github.com/pkg/errors"
@ -33,14 +35,14 @@ func serializeHeader(w io.Writer, header *externalapi.DomainBlockHeader) error {
timestamp := header.TimeInMilliseconds
numParents := len(header.ParentHashes)
if err := writeElements(w, header.Version, uint64(numParents)); err != nil {
if err := serialization.WriteElements(w, header.Version, uint64(numParents)); err != nil {
return err
}
for _, hash := range header.ParentHashes {
if err := WriteElement(w, hash); err != nil {
if err := serialization.WriteElement(w, hash); err != nil {
return err
}
}
return writeElements(w, &header.HashMerkleRoot, &header.AcceptedIDMerkleRoot, &header.UTXOCommitment, timestamp,
return serialization.WriteElements(w, &header.HashMerkleRoot, &header.AcceptedIDMerkleRoot, &header.UTXOCommitment, timestamp,
header.Bits, header.Nonce)
}

15
domain/consensus/utils/consensusserialization/transaction.go → domain/consensus/utils/consensushashing/transaction.go
View File

@ -1,8 +1,10 @@
package consensusserialization
package consensushashing
import (
"io"
"github.com/kaspanet/kaspad/domain/consensus/utils/serialization"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionhelper"
@ -39,7 +41,7 @@ func TransactionHashForSigning(tx *externalapi.DomainTransaction, hashType uint3
panic(errors.Wrap(err, "TransactionHashForSigning() failed. this should never fail for structurally-valid transactions"))
}
err = WriteElement(writer, hashType)
err = serialization.WriteElement(writer, hashType)
if err != nil {
panic(errors.Wrap(err, "this should never happen. SHA256's digest should never return an error"))
}
@ -65,7 +67,6 @@ func TransactionHash(tx *externalapi.DomainTransaction) *externalapi.DomainHash
// TransactionID generates the Hash for the transaction without the signature script and payload field.
func TransactionID(tx *externalapi.DomainTransaction) *externalapi.DomainTransactionID {
// If transaction ID is already cached, return it
if tx.ID != nil {
return tx.ID
@ -98,7 +99,7 @@ func serializeTransaction(w io.Writer, tx *externalapi.DomainTransaction, encodi
}
count := uint64(len(tx.Inputs))
err = WriteElement(w, count)
err = serialization.WriteElement(w, count)
if err != nil {
return err
}
@ -111,7 +112,7 @@ func serializeTransaction(w io.Writer, tx *externalapi.DomainTransaction, encodi
}
count = uint64(len(tx.Outputs))
err = WriteElement(w, count)
err = serialization.WriteElement(w, count)
if err != nil {
return err
}
@ -138,7 +139,7 @@ func serializeTransaction(w io.Writer, tx *externalapi.DomainTransaction, encodi
return err
}
err = WriteElement(w, &tx.PayloadHash)
err = serialization.WriteElement(w, &tx.PayloadHash)
if err != nil {
return err
}
@ -189,7 +190,7 @@ func writeOutpoint(w io.Writer, outpoint *externalapi.DomainOutpoint) error {
func writeVarBytes(w io.Writer, data []byte) error {
dataLength := uint64(len(data))
err := WriteElement(w, dataLength)
err := serialization.WriteElement(w, dataLength)
if err != nil {
return err
}

6
domain/consensus/utils/merkle/merkle.go
View File

@ -4,7 +4,7 @@ import (
"math"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
"github.com/pkg/errors"
)
@ -48,7 +48,7 @@ func hashMerkleBranches(left, right *externalapi.DomainHash) *externalapi.Domain
func CalculateHashMerkleRoot(transactions []*externalapi.DomainTransaction) *externalapi.DomainHash {
txHashes := make([]*externalapi.DomainHash, len(transactions))
for i, tx := range transactions {
txHashes[i] = consensusserialization.TransactionHash(tx)
txHashes[i] = consensushashing.TransactionHash(tx)
}
return merkleRoot(txHashes)
}
@ -62,7 +62,7 @@ func CalculateIDMerkleRoot(transactions []*externalapi.DomainTransaction) *exter
txIDs := make([]*externalapi.DomainHash, len(transactions))
for i, tx := range transactions {
txIDs[i] = (*externalapi.DomainHash)(consensusserialization.TransactionID(tx))
txIDs[i] = (*externalapi.DomainHash)(consensushashing.TransactionID(tx))
}
return merkleRoot(txIDs)
}

4
domain/consensus/utils/mining/solve.go
View File

@ -5,7 +5,7 @@ import (
"math/rand"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
utilsMath "github.com/kaspanet/kaspad/domain/consensus/utils/math"
"github.com/pkg/errors"
@ -17,7 +17,7 @@ func SolveBlock(block *externalapi.DomainBlock, rd *rand.Rand) {
for i := rd.Uint64(); i < math.MaxUint64; i++ {
block.Header.Nonce = i
hash := consensusserialization.BlockHash(block)
hash := consensushashing.BlockHash(block)
if hashes.ToBig(hash).Cmp(targetDifficulty) <= 0 {
return
}

18
domain/consensus/utils/consensusserialization/common.go → domain/consensus/utils/serialization/common.go
View File

@ -1,4 +1,4 @@
package consensusserialization
package serialization
import (
"io"
@ -97,9 +97,9 @@ func WriteElement(w io.Writer, element interface{}) error {
return errors.Wrapf(errNoEncodingForType, "couldn't find a way to write type %T", element)
}
// writeElements writes multiple items to w. It is equivalent to multiple
// WriteElements writes multiple items to w. It is equivalent to multiple
// calls to writeElement.
func writeElements(w io.Writer, elements ...interface{}) error {
func WriteElements(w io.Writer, elements ...interface{}) error {
for _, element := range elements {
err := WriteElement(w, element)
if err != nil {
@ -109,9 +109,9 @@ func writeElements(w io.Writer, elements ...interface{}) error {
return nil
}
// readElement reads the next sequence of bytes from r using little endian
// ReadElement reads the next sequence of bytes from r using little endian
// depending on the concrete type of element pointed to.
func readElement(r io.Reader, element interface{}) error {
func ReadElement(r io.Reader, element interface{}) error {
// Attempt to read the element based on the concrete type via fast
// type assertions first.
switch e := element.(type) {
@ -174,11 +174,11 @@ func readElement(r io.Reader, element interface{}) error {
return errors.Wrapf(errNoEncodingForType, "couldn't find a way to read type %T", element)
}
// readElements reads multiple items from r. It is equivalent to multiple
// calls to readElement.
func readElements(r io.Reader, elements ...interface{}) error {
// ReadElements reads multiple items from r. It is equivalent to multiple
// calls to ReadElement.
func ReadElements(r io.Reader, elements ...interface{}) error {
for _, element := range elements {
err := readElement(r, element)
err := ReadElement(r, element)
if err != nil {
return err
}

4
domain/consensus/utils/testutils/create_transaction.go
View File

@ -2,7 +2,7 @@ package testutils
import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
)
@ -19,7 +19,7 @@ func CreateTransaction(txToSpend *externalapi.DomainTransaction) (*externalapi.D
}
input := &externalapi.DomainTransactionInput{
PreviousOutpoint: externalapi.DomainOutpoint{
TransactionID: *consensusserialization.TransactionID(txToSpend),
TransactionID: *consensushashing.TransactionID(txToSpend),
Index: 0,
},
SignatureScript: signatureScript,

4
domain/consensus/utils/txscript/reference_test.go
View File

@ -15,7 +15,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/infrastructure/logger"
@ -231,7 +231,7 @@ func createSpendingTx(sigScript, scriptPubKey []byte) *externalapi.DomainTransac
}
outpoint = externalapi.DomainOutpoint{
TransactionID: *consensusserialization.TransactionID(coinbaseTx),
TransactionID: *consensushashing.TransactionID(coinbaseTx),
Index: 0,
}
input = &externalapi.DomainTransactionInput{

4
domain/consensus/utils/txscript/script.go
View File

@ -9,7 +9,7 @@ import (
"fmt"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/pkg/errors"
)
@ -361,7 +361,7 @@ func calcSignatureHash(script []parsedOpcode, hashType SigHashType, tx *external
// The final hash is the double sha256 of both the serialized modified
// transaction and the hash type (encoded as a 4-byte little-endian
// value) appended.
return consensusserialization.TransactionHashForSigning(&txCopy, uint32(hashType)), nil
return consensushashing.TransactionHashForSigning(&txCopy, uint32(hashType)), nil
}
// asSmallInt returns the passed opcode, which must be true according to

19
domain/consensus/utils/consensusserialization/utxo.go → domain/consensus/utils/utxo/serialization.go
View File

@ -1,10 +1,13 @@
package consensusserialization
package utxo
import (
"bytes"
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
"io"
"github.com/kaspanet/kaspad/domain/consensus/utils/serialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@ -51,7 +54,7 @@ func serializeOutpoint(w io.Writer, outpoint *externalapi.DomainOutpoint) error
return err
}
err = WriteElement(w, outpoint.Index)
err = serialization.WriteElement(w, outpoint.Index)
if err != nil {
return errors.WithStack(err)
}
@ -78,7 +81,7 @@ func deserializeOutpoint(r io.Reader) (*externalapi.DomainOutpoint, error) {
}
var index uint32
err = readElement(r, &index)
err = serialization.ReadElement(r, &index)
if err != nil {
return nil, err
}
@ -90,13 +93,13 @@ func deserializeOutpoint(r io.Reader) (*externalapi.DomainOutpoint, error) {
}
func serializeUTXOEntry(w io.Writer, entry *externalapi.UTXOEntry) error {
err := writeElements(w, entry.BlockBlueScore, entry.Amount, entry.IsCoinbase)
err := serialization.WriteElements(w, entry.BlockBlueScore, entry.Amount, entry.IsCoinbase)
if err != nil {
return err
}
count := uint64(len(entry.ScriptPublicKey))
err = WriteElement(w, count)
err = serialization.WriteElement(w, count)
if err != nil {
return err
}
@ -111,13 +114,13 @@ func serializeUTXOEntry(w io.Writer, entry *externalapi.UTXOEntry) error {
func deserializeUTXOEntry(r io.Reader) (*externalapi.UTXOEntry, error) {
entry := &externalapi.UTXOEntry{}
err := readElements(r, entry.BlockBlueScore, entry.Amount, entry.IsCoinbase)
err := serialization.ReadElements(r, entry.BlockBlueScore, entry.Amount, entry.IsCoinbase)
if err != nil {
return nil, err
}
count := uint64(len(entry.ScriptPublicKey))
err = readElement(r, count)
err = serialization.ReadElement(r, count)
if err != nil {
return nil, err
}

2
domain/consensus/utils/consensusserialization/utxo_test.go → domain/consensus/utils/utxo/serialization_test.go
View File

@ -1,4 +1,4 @@
package consensusserialization
package utxo
import (
"encoding/hex"

4
domain/consensus/utils/utxo/utxoalgebra/diff_helpers.go
View File

@ -3,7 +3,7 @@ package utxoalgebra
import (
"reflect"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionhelper"
@ -22,7 +22,7 @@ func DiffAddTransaction(utxoDiff *model.UTXODiff, transaction *externalapi.Domai
}
isCoinbase := transactionhelper.IsCoinBase(transaction)
transactionID := *consensusserialization.TransactionID(transaction)
transactionID := *consensushashing.TransactionID(transaction)
for i, output := range transaction.Outputs {
outpoint := &externalapi.DomainOutpoint{
TransactionID: transactionID,

4
domain/consensus/utils/utxoserialization/utxo.go
View File

@ -2,7 +2,7 @@ package utxoserialization
import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
)
// ReadOnlyUTXOSetToProtoUTXOSet converts ReadOnlyUTXOSetIterator to ProtoUTXOSet
@ -17,7 +17,7 @@ func ReadOnlyUTXOSetToProtoUTXOSet(iter model.ReadOnlyUTXOSetIterator) (*ProtoUT
return nil, err
}
serializedUTXOBytes, err := consensusserialization.SerializeUTXO(entry, outpoint)
serializedUTXOBytes, err := utxo.SerializeUTXO(entry, outpoint)
if err != nil {
return nil, err
}

10
domain/dagconfig/genesis_test.go
View File

@ -7,14 +7,14 @@ package dagconfig
import (
"testing"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
)
// TestGenesisBlock tests the genesis block of the main network for validity by
// checking the encoded hash.
func TestGenesisBlock(t *testing.T) {
// Check hash of the block against expected hash.
hash := consensusserialization.BlockHash(MainnetParams.GenesisBlock)
hash := consensushashing.BlockHash(MainnetParams.GenesisBlock)
if *MainnetParams.GenesisHash != *hash {
t.Fatalf("TestGenesisBlock: Genesis block hash does "+
"not appear valid - got %v, want %v", hash, MainnetParams.GenesisHash)
@ -25,7 +25,7 @@ func TestGenesisBlock(t *testing.T) {
// validity by checking the hash.
func TestTestnetGenesisBlock(t *testing.T) {
// Check hash of the block against expected hash.
hash := consensusserialization.BlockHash(TestnetParams.GenesisBlock)
hash := consensushashing.BlockHash(TestnetParams.GenesisBlock)
if *TestnetParams.GenesisHash != *hash {
t.Fatalf("TestTestnetGenesisBlock: Genesis block hash does "+
"not appear valid - got %v, want %v", hash,
@ -37,7 +37,7 @@ func TestTestnetGenesisBlock(t *testing.T) {
// for validity by checking the hash.
func TestSimnetGenesisBlock(t *testing.T) {
// Check hash of the block against expected hash.
hash := consensusserialization.BlockHash(SimnetParams.GenesisBlock)
hash := consensushashing.BlockHash(SimnetParams.GenesisBlock)
if *SimnetParams.GenesisHash != *hash {
t.Fatalf("TestSimnetGenesisBlock: Genesis block hash does "+
"not appear valid - got %v, want %v", hash,
@ -49,7 +49,7 @@ func TestSimnetGenesisBlock(t *testing.T) {
// for validity by checking the encoded hash.
func TestDevnetGenesisBlock(t *testing.T) {
// Check hash of the block against expected hash.
hash := consensusserialization.BlockHash(DevnetParams.GenesisBlock)
hash := consensushashing.BlockHash(DevnetParams.GenesisBlock)
if *DevnetParams.GenesisHash != *hash {
t.Fatalf("TestDevnetGenesisBlock: Genesis block hash does "+
"not appear valid - got %v, want %v", hash,

13
domain/miningmanager/blocktemplatebuilder/txselection.go
View File

@ -1,12 +1,13 @@
package blocktemplatebuilder
import (
consensusexternalapi "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
"math"
"math/rand"
"sort"
consensusexternalapi "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
)
const (
@ -103,7 +104,7 @@ func (btb *blockTemplateBuilder) selectTransactions(candidateTxs []*candidateTx)
if txsForBlockTemplate.totalMass+selectedTx.Mass < txsForBlockTemplate.totalMass ||
txsForBlockTemplate.totalMass+selectedTx.Mass > btb.policy.BlockMaxMass {
log.Tracef("Tx %s would exceed the max block mass. "+
"As such, stopping.", consensusserialization.TransactionID(tx))
"As such, stopping.", consensushashing.TransactionID(tx))
break
}
@ -121,7 +122,7 @@ func (btb *blockTemplateBuilder) selectTransactions(candidateTxs []*candidateTx)
log.Tracef("Tx %s would exceed the gas limit in "+
"subnetwork %s. Removing all remaining txs from this "+
"subnetwork.",
consensusserialization.TransactionID(tx), subnetworkID)
consensushashing.TransactionID(tx), subnetworkID)
for _, candidateTx := range candidateTxs {
// candidateTxs are ordered by subnetwork, so we can safely assume
// that transactions after subnetworkID will not be relevant.
@ -146,7 +147,7 @@ func (btb *blockTemplateBuilder) selectTransactions(candidateTxs []*candidateTx)
txsForBlockTemplate.totalFees += selectedTx.Fee
log.Tracef("Adding tx %s (feePerMegaGram %d)",
consensusserialization.TransactionID(tx), selectedTx.Fee*1e6/selectedTx.Mass)
consensushashing.TransactionID(tx), selectedTx.Fee*1e6/selectedTx.Mass)
markCandidateTxForDeletion(selectedTx)
}

40
domain/miningmanager/mempool/mempool.go
View File

@ -16,7 +16,7 @@ import (
consensusexternalapi "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/estimatedsize"
miningmanagermodel "github.com/kaspanet/kaspad/domain/miningmanager/model"
"github.com/kaspanet/kaspad/infrastructure/logger"
@ -148,7 +148,7 @@ type orphanTx struct {
// This function MUST be called with the mempool lock held (for writes).
func (mp *mempool) removeOrphan(tx *consensusexternalapi.DomainTransaction, removeRedeemers bool) {
// Nothing to do if passed tx is not an orphan.
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
otx, exists := mp.orphans[*txID]
if !exists {
return
@ -249,7 +249,7 @@ func (mp *mempool) addOrphan(tx *consensusexternalapi.DomainTransaction) {
// This will periodically remove any expired orphans and evict a random
// orphan if space is still needed.
mp.limitNumOrphans()
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
mp.orphans[*txID] = &orphanTx{
tx: tx,
expiration: mstime.Now().Add(orphanTTL),
@ -262,7 +262,7 @@ func (mp *mempool) addOrphan(tx *consensusexternalapi.DomainTransaction) {
mp.orphansByPrev[txIn.PreviousOutpoint][*txID] = tx
}
log.Debugf("Stored orphan transaction %s (total: %d)", consensusserialization.TransactionID(tx),
log.Debugf("Stored orphan transaction %s (total: %d)", consensushashing.TransactionID(tx),
len(mp.orphans))
}
@ -358,7 +358,7 @@ func (mp *mempool) haveTransaction(txID *consensusexternalapi.DomainTransactionI
// This function MUST be called with the mempool lock held (for writes).
func (mp *mempool) removeBlockTransactionsFromPool(txs []*consensusexternalapi.DomainTransaction) error {
for _, tx := range txs[transactionhelper.CoinbaseTransactionIndex+1:] {
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
if _, exists := mp.fetchTxDesc(txID); !exists {
continue
@ -378,7 +378,7 @@ func (mp *mempool) removeBlockTransactionsFromPool(txs []*consensusexternalapi.D
//
// This function MUST be called with the mempool lock held (for writes).
func (mp *mempool) removeTransactionAndItsChainedTransactions(tx *consensusexternalapi.DomainTransaction) error {
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
// Remove any transactions which rely on this one.
for i := uint32(0); i < uint32(len(tx.Outputs)); i++ {
prevOut := consensusexternalapi.DomainOutpoint{TransactionID: *txID, Index: i}
@ -412,7 +412,7 @@ func (mp *mempool) cleanTransactionFromSets(tx *consensusexternalapi.DomainTrans
return err
}
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
delete(mp.pool, *txID)
delete(mp.chainedTransactions, *txID)
@ -425,7 +425,7 @@ func (mp *mempool) cleanTransactionFromSets(tx *consensusexternalapi.DomainTrans
// This function MUST be called with the mempool lock held (for writes).
func (mp *mempool) updateBlockTransactionChainedTransactions(tx *consensusexternalapi.DomainTransaction) {
prevOut := consensusexternalapi.DomainOutpoint{TransactionID: *consensusserialization.TransactionID(tx)}
prevOut := consensusexternalapi.DomainOutpoint{TransactionID: *consensushashing.TransactionID(tx)}
for txOutIdx := range tx.Outputs {
// Skip to the next available output if there are none.
prevOut.Index = uint32(txOutIdx)
@ -439,7 +439,7 @@ func (mp *mempool) updateBlockTransactionChainedTransactions(tx *consensusextern
if txDesc.depCount == 0 {
// Transaction may be already removed by recursive calls, if removeRedeemers is true.
// So avoid moving it into main pool
txDescID := consensusserialization.TransactionID(txDesc.DomainTransaction)
txDescID := consensushashing.TransactionID(txDesc.DomainTransaction)
if _, ok := mp.chainedTransactions[*txDescID]; ok {
delete(mp.chainedTransactions, *txDescID)
mp.pool[*txDescID] = txDesc
@ -453,7 +453,7 @@ func (mp *mempool) updateBlockTransactionChainedTransactions(tx *consensusextern
//
// This function MUST be called with the mempool lock held (for writes).
func (mp *mempool) removeChainTransaction(tx *consensusexternalapi.DomainTransaction) {
delete(mp.chainedTransactions, *consensusserialization.TransactionID(tx))
delete(mp.chainedTransactions, *consensushashing.TransactionID(tx))
for _, txIn := range tx.Inputs {
delete(mp.chainedTransactionByPreviousOutpoint, txIn.PreviousOutpoint)
}
@ -467,10 +467,10 @@ func (mp *mempool) removeChainTransaction(tx *consensusexternalapi.DomainTransac
//
// This function MUST be called with the mempool lock held (for writes).
func (mp *mempool) removeDoubleSpends(tx *consensusexternalapi.DomainTransaction) error {
txID := *consensusserialization.TransactionID(tx)
txID := *consensushashing.TransactionID(tx)
for _, txIn := range tx.Inputs {
if txRedeemer, ok := mp.mempoolUTXOSet.poolTransactionBySpendingOutpoint(txIn.PreviousOutpoint); ok {
if !(*consensusserialization.TransactionID(txRedeemer) == txID) {
if !(*consensushashing.TransactionID(txRedeemer) == txID) {
err := mp.removeTransactionAndItsChainedTransactions(txRedeemer)
if err != nil {
return err
@ -493,7 +493,7 @@ func (mp *mempool) addTransaction(tx *consensusexternalapi.DomainTransaction, ma
DomainTransaction: tx,
depCount: len(parentsInPool),
}
txID := *consensusserialization.TransactionID(tx)
txID := *consensushashing.TransactionID(tx)
if len(parentsInPool) == 0 {
mp.pool[txID] = txDescriptor
@ -523,7 +523,7 @@ func (mp *mempool) checkPoolDoubleSpend(tx *consensusexternalapi.DomainTransacti
if txR, exists := mp.mempoolUTXOSet.poolTransactionBySpendingOutpoint(txIn.PreviousOutpoint); exists {
str := fmt.Sprintf("output %s already spent by "+
"transaction %s in the memory pool",
txIn.PreviousOutpoint, consensusserialization.TransactionID(txR))
txIn.PreviousOutpoint, consensushashing.TransactionID(txR))
return txRuleError(RejectDuplicate, str)
}
}
@ -557,7 +557,7 @@ func (mp *mempool) fetchTxDesc(txID *consensusexternalapi.DomainTransactionID) (
func (mp *mempool) maybeAcceptTransaction(tx *consensusexternalapi.DomainTransaction, rejectDupOrphans bool) (
[]*consensusexternalapi.DomainOutpoint, *txDescriptor, error) {
txID := consensusserialization.TransactionID(tx)
txID := consensushashing.TransactionID(tx)
// Don't accept the transaction if it already exists in the pool. This
// applies to orphan transactions as well when the reject duplicate
@ -687,7 +687,7 @@ func (mp *mempool) processOrphans(acceptedTx *consensusexternalapi.DomainTransac
firstElement := processList.Remove(processList.Front())
processItem := firstElement.(*consensusexternalapi.DomainTransaction)
prevOut := consensusexternalapi.DomainOutpoint{TransactionID: *consensusserialization.TransactionID(processItem)}
prevOut := consensusexternalapi.DomainOutpoint{TransactionID: *consensushashing.TransactionID(processItem)}
for txOutIdx := range processItem.Outputs {
// Look up all orphans that redeem the output that is
// now available. This will typically only be one, but
@ -767,7 +767,7 @@ func (mp *mempool) processOrphans(acceptedTx *consensusexternalapi.DomainTransac
//
// This function is safe for concurrent access.
func (mp *mempool) ValidateAndInsertTransaction(tx *consensusexternalapi.DomainTransaction, allowOrphan bool) error {
log.Tracef("Processing transaction %s", consensusserialization.TransactionID(tx))
log.Tracef("Processing transaction %s", consensushashing.TransactionID(tx))
// Protect concurrent access.
mp.mtx.Lock()
@ -809,7 +809,7 @@ func (mp *mempool) ValidateAndInsertTransaction(tx *consensusexternalapi.DomainT
// which is not really always the case.
str := fmt.Sprintf("orphan transaction %s references "+
"outputs of unknown or fully-spent "+
"transaction %s", consensusserialization.TransactionID(tx), missingParents[0])
"transaction %s", consensushashing.TransactionID(tx), missingParents[0])
return txRuleError(RejectDuplicate, str)
}
@ -878,7 +878,7 @@ func (mp *mempool) HandleNewBlockTransactions(txs []*consensusexternalapi.Domain
for _, tx := range txs[transactionhelper.CoinbaseTransactionIndex+1:] {
err := mp.removeDoubleSpends(tx)
if err != nil {
log.Infof("Failed removing tx from mempool: %s, '%s'", consensusserialization.TransactionID(tx), err)
log.Infof("Failed removing tx from mempool: %s, '%s'", consensushashing.TransactionID(tx), err)
}
mp.removeOrphan(tx, false)
acceptedOrphans := mp.processOrphans(tx)
@ -898,7 +898,7 @@ func (mp *mempool) RemoveTransactions(txs []*consensusexternalapi.DomainTransact
for _, tx := range txs {
err := mp.removeDoubleSpends(tx)
if err != nil {
log.Infof("Failed removing tx from mempool: %s, '%s'", consensusserialization.TransactionID(tx), err)
log.Infof("Failed removing tx from mempool: %s, '%s'", consensushashing.TransactionID(tx), err)
}
mp.removeOrphan(tx, true)
}

10
domain/miningmanager/mempool/mempool_utxoset.go
View File

@ -4,7 +4,7 @@ import (
"math"
consensusexternalapi "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/pkg/errors"
)
@ -42,7 +42,7 @@ func (mpus *mempoolUTXOSet) checkExists(tx *consensusexternalapi.DomainTransacti
}
// Check if it creates an already existing UTXO
outpoint := consensusexternalapi.DomainOutpoint{TransactionID: *consensusserialization.TransactionID(tx)}
outpoint := consensusexternalapi.DomainOutpoint{TransactionID: *consensushashing.TransactionID(tx)}
for i := range tx.Outputs {
outpoint.Index = uint32(i)
if _, exists := mpus.poolUnspentOutputs[outpoint]; exists {
@ -57,13 +57,13 @@ func (mpus *mempoolUTXOSet) checkExists(tx *consensusexternalapi.DomainTransacti
func (mpus *mempoolUTXOSet) addTx(tx *consensusexternalapi.DomainTransaction) error {
for _, txIn := range tx.Inputs {
if existingTx, exists := mpus.transactionByPreviousOutpoint[txIn.PreviousOutpoint]; exists {
return errors.Errorf("outpoint %s is already used by %s", txIn.PreviousOutpoint, consensusserialization.TransactionID(existingTx))
return errors.Errorf("outpoint %s is already used by %s", txIn.PreviousOutpoint, consensushashing.TransactionID(existingTx))
}
mpus.transactionByPreviousOutpoint[txIn.PreviousOutpoint] = tx
}
for i, txOut := range tx.Outputs {
outpoint := consensusexternalapi.DomainOutpoint{TransactionID: *consensusserialization.TransactionID(tx), Index: uint32(i)}
outpoint := consensusexternalapi.DomainOutpoint{TransactionID: *consensushashing.TransactionID(tx), Index: uint32(i)}
if _, exists := mpus.poolUnspentOutputs[outpoint]; exists {
return errors.Errorf("outpoint %s already exists", outpoint)
}
@ -87,7 +87,7 @@ func (mpus *mempoolUTXOSet) removeTx(tx *consensusexternalapi.DomainTransaction)
delete(mpus.transactionByPreviousOutpoint, txIn.PreviousOutpoint)
}
outpoint := consensusexternalapi.DomainOutpoint{TransactionID: *consensusserialization.TransactionID(tx)}
outpoint := consensusexternalapi.DomainOutpoint{TransactionID: *consensushashing.TransactionID(tx)}
for i := range tx.Outputs {
outpoint.Index = uint32(i)
if _, exists := mpus.poolUnspentOutputs[outpoint]; !exists {

6
testing/integration/basic_sync_test.go
View File

@ -4,7 +4,7 @@ import (
"testing"
"time"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/app/appmessage"
)
@ -37,7 +37,7 @@ func TestIntegrationBasicSync(t *testing.T) {
t.Fatalf("Timeout waiting for block added notification on node directly connected to miner")
}
blockHash := consensusserialization.BlockHash(block)
blockHash := consensushashing.BlockHash(block)
if *header.BlockHash() != *blockHash {
t.Errorf("Expected block with hash '%s', but got '%s'", blockHash, header.BlockHash())
}
@ -48,7 +48,7 @@ func TestIntegrationBasicSync(t *testing.T) {
t.Fatalf("Timeout waiting for block added notification on node indirectly connected to miner")
}
blockHash = consensusserialization.BlockHash(block)
blockHash = consensushashing.BlockHash(block)
if *header.BlockHash() != *blockHash {
t.Errorf("Expected block with hash '%s', but got '%s'", blockHash, header.BlockHash())
}

4
testing/integration/mining_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
"github.com/kaspanet/kaspad/util"
@ -18,7 +18,7 @@ func solveBlock(block *externalapi.DomainBlock) *externalapi.DomainBlock {
initialNonce := rand.Uint64()
for i := initialNonce; i != initialNonce-1; i++ {
block.Header.Nonce = i
hash := consensusserialization.BlockHash(block)
hash := consensushashing.BlockHash(block)
if hashes.ToBig(hash).Cmp(targetDifficulty) <= 0 {
return block
}

4
testing/integration/tx_relay_test.go
View File

@ -9,7 +9,7 @@ import (
"github.com/kaspanet/go-secp256k1"
"github.com/kaspanet/kaspad/app/appmessage"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionhelper"
"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
@ -86,7 +86,7 @@ func waitForPayeeToReceiveBlock(t *testing.T, payeeBlockAddedChan chan *appmessa
func generateTx(t *testing.T, firstBlockCoinbase *externalapi.DomainTransaction, payer, payee *appHarness) *appmessage.MsgTx {
txIns := make([]*appmessage.TxIn, 1)
txIns[0] = appmessage.NewTxIn(appmessage.NewOutpoint(consensusserialization.TransactionID(firstBlockCoinbase), 0), []byte{})
txIns[0] = appmessage.NewTxIn(appmessage.NewOutpoint(consensushashing.TransactionID(firstBlockCoinbase), 0), []byte{})
payeeAddress, err := util.DecodeAddress(payee.miningAddress, util.Bech32PrefixKaspaSim)
if err != nil {