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

[NOD-28] Move subnetwork consts to subnetworkid package (#197)

Browse Source 
* [NOD-28] Move SubnetworkID constants to subnetworkid package

* [NOD-28] change subnetwork id constants to pointers
This commit is contained in:
Ori Newman 2019-03-10 12:27:06 +02:00 committed by Svarog
parent aa46c167c8
commit 1e447432a7
40 changed files with 185 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
addrmgr/addrmanager.go
View File

@ -710,8 +710,8 @@ func (a *AddrManager) NeedMoreAddresses() bool {
defer a.mtx.Unlock()
allAddrs := a.numAddresses(a.localSubnetworkID)
if !a.localSubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
allAddrs += a.numAddresses(&wire.SubnetworkIDSupportsAll)
if !a.localSubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
allAddrs += a.numAddresses(subnetworkid.SubnetworkIDSupportsAll)
}
return allAddrs < needAddressThreshold
}

28
addrmgr/addrmanager_test.go
View File

@ -105,7 +105,7 @@ func lookupFunc(host string) ([]net.IP, error) {
}
func TestStartStop(t *testing.T) {
n := addrmgr.New("teststartstop", lookupFunc, &wire.SubnetworkIDSupportsAll)
n := addrmgr.New("teststartstop", lookupFunc, subnetworkid.SubnetworkIDSupportsAll)
n.Start()
err := n.Stop()
if err != nil {
@ -138,9 +138,9 @@ func TestAddAddressByIP(t *testing.T) {
},
}
amgr := addrmgr.New("testaddressbyip", nil, &wire.SubnetworkIDSupportsAll)
amgr := addrmgr.New("testaddressbyip", nil, subnetworkid.SubnetworkIDSupportsAll)
for i, test := range tests {
err := amgr.AddAddressByIP(test.addrIP, &wire.SubnetworkIDSupportsAll)
err := amgr.AddAddressByIP(test.addrIP, subnetworkid.SubnetworkIDSupportsAll)
if test.err != nil && err == nil {
t.Errorf("TestGood test %d failed expected an error and got none", i)
continue
@ -194,7 +194,7 @@ func TestAddLocalAddress(t *testing.T) {
true,
},
}
amgr := addrmgr.New("testaddlocaladdress", nil, &wire.SubnetworkIDSupportsAll)
amgr := addrmgr.New("testaddlocaladdress", nil, subnetworkid.SubnetworkIDSupportsAll)
for x, test := range tests {
result := amgr.AddLocalAddress(&test.address, test.priority)
if result == nil && !test.valid {
@ -211,10 +211,10 @@ func TestAddLocalAddress(t *testing.T) {
}
func TestAttempt(t *testing.T) {
n := addrmgr.New("testattempt", lookupFunc, &wire.SubnetworkIDSupportsAll)
n := addrmgr.New("testattempt", lookupFunc, subnetworkid.SubnetworkIDSupportsAll)
// Add a new address and get it
err := n.AddAddressByIP(someIP+":8333", &wire.SubnetworkIDSupportsAll)
err := n.AddAddressByIP(someIP+":8333", subnetworkid.SubnetworkIDSupportsAll)
if err != nil {
t.Fatalf("Adding address failed: %v", err)
}
@ -233,10 +233,10 @@ func TestAttempt(t *testing.T) {
}
func TestConnected(t *testing.T) {
n := addrmgr.New("testconnected", lookupFunc, &wire.SubnetworkIDSupportsAll)
n := addrmgr.New("testconnected", lookupFunc, subnetworkid.SubnetworkIDSupportsAll)
// Add a new address and get it
err := n.AddAddressByIP(someIP+":8333", &wire.SubnetworkIDSupportsAll)
err := n.AddAddressByIP(someIP+":8333", subnetworkid.SubnetworkIDSupportsAll)
if err != nil {
t.Fatalf("Adding address failed: %v", err)
}
@ -253,7 +253,7 @@ func TestConnected(t *testing.T) {
}
func TestNeedMoreAddresses(t *testing.T) {
n := addrmgr.New("testneedmoreaddresses", lookupFunc, &wire.SubnetworkIDSupportsAll)
n := addrmgr.New("testneedmoreaddresses", lookupFunc, subnetworkid.SubnetworkIDSupportsAll)
addrsToAdd := 1500
b := n.NeedMoreAddresses()
if !b {
@ -272,7 +272,7 @@ func TestNeedMoreAddresses(t *testing.T) {
srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
n.AddAddresses(addrs, srcAddr, &wire.SubnetworkIDSupportsAll)
n.AddAddresses(addrs, srcAddr, subnetworkid.SubnetworkIDSupportsAll)
numAddrs := n.TotalNumAddresses()
if numAddrs > addrsToAdd {
t.Errorf("Number of addresses is too many %d vs %d", numAddrs, addrsToAdd)
@ -285,7 +285,7 @@ func TestNeedMoreAddresses(t *testing.T) {
}
func TestGood(t *testing.T) {
n := addrmgr.New("testgood", lookupFunc, &wire.SubnetworkIDSupportsAll)
n := addrmgr.New("testgood", lookupFunc, subnetworkid.SubnetworkIDSupportsAll)
addrsToAdd := 64 * 64
addrs := make([]*wire.NetAddress, addrsToAdd)
subnetworkCount := 32
@ -306,7 +306,7 @@ func TestGood(t *testing.T) {
srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
n.AddAddresses(addrs, srcAddr, &wire.SubnetworkIDSupportsAll)
n.AddAddresses(addrs, srcAddr, subnetworkid.SubnetworkIDSupportsAll)
for i, addr := range addrs {
n.Good(addr, subnetworkIDs[i%subnetworkCount])
}
@ -355,7 +355,7 @@ func TestGetAddress(t *testing.T) {
n.Good(ka.NetAddress(), actualSubnetworkID)
ka = n.GetAddress()
if ka != nil {
t.Errorf("Didn't expect to get an address because there shouldn't be any address from subnetwork ID %s or %s", localSubnetworkID, wire.SubnetworkIDSupportsAll)
t.Errorf("Didn't expect to get an address because there shouldn't be any address from subnetwork ID %s or %s", localSubnetworkID, subnetworkid.SubnetworkIDSupportsAll)
}
// Checks that the total number of addresses incremented although the new address is not full node or a partial node of the same subnetwork as the local node.
@ -451,7 +451,7 @@ func TestGetBestLocalAddress(t *testing.T) {
*/
}
amgr := addrmgr.New("testgetbestlocaladdress", nil, &wire.SubnetworkIDSupportsAll)
amgr := addrmgr.New("testgetbestlocaladdress", nil, subnetworkid.SubnetworkIDSupportsAll)
// Test against default when there's no address
for x, test := range tests {

5
blockdag/accept_test.go
View File

@ -5,19 +5,18 @@ import (
"strings"
"testing"
"github.com/daglabs/btcd/wire"
"bou.ke/monkey"
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/database"
"github.com/daglabs/btcd/util"
"github.com/daglabs/btcd/util/subnetworkid"
)
func TestMaybeAcceptBlockErrors(t *testing.T) {
// Create a new database and DAG instance to run tests against.
dag, teardownFunc, err := DAGSetup("TestMaybeAcceptBlockErrors", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("TestMaybeAcceptBlockErrors: Failed to setup DAG instance: %v", err)

4
blockdag/blockindex_test.go
View File

@ -2,7 +2,6 @@ package blockdag
import (
"errors"
"github.com/daglabs/btcd/wire"
"strings"
"testing"
"time"
@ -10,6 +9,7 @@ import (
"bou.ke/monkey"
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/database"
"github.com/daglabs/btcd/util/subnetworkid"
)
func TestAncestorErrors(t *testing.T) {
@ -25,7 +25,7 @@ func TestFlushToDBErrors(t *testing.T) {
// Create a new database and DAG instance to run tests against.
dag, teardownFunc, err := DAGSetup("TestFlushToDBErrors", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("TestFlushToDBErrors: Failed to setup DAG instance: %s", err)

2
blockdag/dag.go
View File

@ -611,7 +611,7 @@ func (dag *BlockDAG) validateGasLimit(block *util.Block) error {
msgTx := tx.MsgTx()
// In DAGCoin and Registry sub-networks all txs must have Gas = 0, and that is validated in checkTransactionSanity
// Therefore - no need to check them here.
if msgTx.SubnetworkID != wire.SubnetworkIDNative && msgTx.SubnetworkID != wire.SubnetworkIDRegistry {
if !msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) && !msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) {
gasUsageInSubnetwork := gasUsageInAllSubnetworks[msgTx.SubnetworkID]
gasUsageInSubnetwork += msgTx.Gas
if gasUsageInSubnetwork < gasUsageInAllSubnetworks[msgTx.SubnetworkID] { // protect from overflows

33
blockdag/dag_test.go
View File

@ -21,6 +21,7 @@ import (
"github.com/daglabs/btcd/dagconfig/daghash"
"github.com/daglabs/btcd/txscript"
"github.com/daglabs/btcd/util"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/util/txsort"
"github.com/daglabs/btcd/wire"
)
@ -46,7 +47,7 @@ func TestBlockCount(t *testing.T) {
// Create a new database and DAG instance to run tests against.
dag, teardownFunc, err := DAGSetup("TestBlockCount", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup DAG instance: %v", err)
@ -96,7 +97,7 @@ func TestHaveBlock(t *testing.T) {
// Create a new database and DAG instance to run tests against.
dag, teardownFunc, err := DAGSetup("haveblock", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup DAG instance: %v", err)
@ -826,7 +827,7 @@ func testErrorThroughPatching(t *testing.T, expectedErrorMessage string, targetF
// Create a new database and dag instance to run tests against.
dag, teardownFunc, err := DAGSetup("testErrorThroughPatching", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup dag instance: %v", err)
@ -868,7 +869,7 @@ func TestValidateFeeTransaction(t *testing.T) {
params.K = 1
dag, teardownFunc, err := DAGSetup("TestValidateFeeTransaction", Config{
DAGParams: &params,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup DAG instance: %v", err)
@ -939,7 +940,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{ // Extra Fee Transaction
TxIn: []*wire.TxIn{
@ -951,7 +952,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
}
buildBlock("blockWithExtraFeeTx", []daghash.Hash{dag.genesis.hash}, blockWithExtraFeeTxTransactions, ErrMultipleFeeTransactions)
@ -969,7 +970,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
}
block1 := buildBlock("block1", []daghash.Hash{dag.genesis.hash}, block1Txs, 0)
@ -988,7 +989,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
}
block1A := buildBlock("block1A", []daghash.Hash{dag.genesis.hash}, block1ATxs, 0)
@ -1011,7 +1012,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
TxIn: []*wire.TxIn{
@ -1029,7 +1030,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Value: 1,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
}
block1AChild := buildBlock("block1AChild", []daghash.Hash{block1A.BlockHash()}, block1AChildTxs, 0)
@ -1048,7 +1049,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
}
block2 := buildBlock("block2", []daghash.Hash{block1.BlockHash()}, block2Txs, 0)
@ -1067,7 +1068,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
}
block3 := buildBlock("block3", []daghash.Hash{block2.BlockHash()}, block3Txs, 0)
@ -1091,7 +1092,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
TxIn: []*wire.TxIn{
@ -1109,7 +1110,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Value: 1,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
}
block4 := buildBlock("block4", []daghash.Hash{block3.BlockHash()}, block4Txs, 0)
@ -1132,7 +1133,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Sequence: wire.MaxTxInSequenceNum,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
TxIn: []*wire.TxIn{
@ -1150,7 +1151,7 @@ func TestValidateFeeTransaction(t *testing.T) {
Value: 1,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
}
block4A := buildBlock("block4A", []daghash.Hash{block3.BlockHash()}, block4ATxs, 0)

5
blockdag/example_test.go
View File

@ -10,13 +10,12 @@ import (
"os"
"path/filepath"
"github.com/daglabs/btcd/wire"
"github.com/daglabs/btcd/blockdag"
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/database"
_ "github.com/daglabs/btcd/database/ffldb"
"github.com/daglabs/btcd/util"
"github.com/daglabs/btcd/util/subnetworkid"
)
// This example demonstrates how to create a new chain instance and use
@ -51,7 +50,7 @@ func ExampleBlockDAG_ProcessBlock() {
DB: db,
DAGParams: &dagconfig.MainNetParams,
TimeSource: blockdag.NewMedianTime(),
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
fmt.Printf("Failed to create chain instance: %v\n", err)

8
blockdag/external_dag_test.go
View File

@ -39,7 +39,7 @@ func TestFinality(t *testing.T) {
params.K = 1
dag, teardownFunc, err := blockdag.DAGSetup("TestFinality", blockdag.Config{
DAGParams: &params,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup DAG instance: %v", err)
@ -148,7 +148,7 @@ func TestSubnetworkRegistry(t *testing.T) {
params.BlockRewardMaturity = 1
dag, teardownFunc, err := blockdag.DAGSetup("TestSubnetworkRegistry", blockdag.Config{
DAGParams: &params,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup DAG instance: %v", err)
@ -175,7 +175,7 @@ func TestChainedTransactions(t *testing.T) {
// Create a new database and dag instance to run tests against.
dag, teardownFunc, err := blockdag.DAGSetup("TestChainedTransactions", blockdag.Config{
DAGParams: &params,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup dag instance: %v", err)
@ -270,7 +270,7 @@ func TestGasLimit(t *testing.T) {
params.BlockRewardMaturity = 1
dag, teardownFunc, err := blockdag.DAGSetup("TestSubnetworkRegistry", blockdag.Config{
DAGParams: &params,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup DAG instance: %v", err)

3
blockdag/fullblocktests/params.go
View File

@ -11,6 +11,7 @@ import (
"time"
"github.com/daglabs/btcd/util/hdkeychain"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/dagconfig/daghash"
@ -96,7 +97,7 @@ var (
"4c702b6bf11d5fac"),
}},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
}},
}
)

3
blockdag/indexers/txindex_test.go
View File

@ -10,6 +10,7 @@ import (
"github.com/daglabs/btcd/dagconfig/daghash"
"github.com/daglabs/btcd/mining"
"github.com/daglabs/btcd/util"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/wire"
)
@ -42,7 +43,7 @@ func TestTxIndexConnectBlock(t *testing.T) {
config := blockdag.Config{
IndexManager: indexManager,
DAGParams: &params,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
}
dag, teardown, err := blockdag.DAGSetup("TestTxIndexConnectBlock", config)

4
blockdag/notifications_test.go
View File

@ -5,10 +5,10 @@
package blockdag
import (
"github.com/daglabs/btcd/wire"
"testing"
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/util/subnetworkid"
)
// TestNotifications ensures that notification callbacks are fired on events.
@ -21,7 +21,7 @@ func TestNotifications(t *testing.T) {
// Create a new database and dag instance to run tests against.
dag, teardownFunc, err := DAGSetup("notifications", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Fatalf("Failed to setup dag instance: %v", err)

4
blockdag/subnetworks.go
View File

@ -37,7 +37,7 @@ func registerSubnetworks(dbTx database.Tx, txsAcceptanceData MultiblockTxsAccept
}
tx := txData.Tx.MsgTx()
if tx.SubnetworkID == wire.SubnetworkIDRegistry {
if tx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) {
err := validateSubnetworkRegistryTransaction(tx)
if err != nil {
return err
@ -45,7 +45,7 @@ func registerSubnetworks(dbTx database.Tx, txsAcceptanceData MultiblockTxsAccept
validSubnetworkRegistryTxs = append(validSubnetworkRegistryTxs, tx)
}
if subnetworkid.Less(&wire.SubnetworkIDRegistry, &tx.SubnetworkID) {
if subnetworkid.Less(subnetworkid.SubnetworkIDRegistry, &tx.SubnetworkID) {
// Transactions are ordered by subnetwork, so we can safely assume
// that the rest of the transactions will not be subnetwork registry
// transactions.

4
blockdag/test_utils.go
View File

@ -89,7 +89,7 @@ func DAGSetup(dbName string, config Config) (*BlockDAG, func(), error) {
}
if config.SubnetworkID == nil {
config.SubnetworkID = &wire.SubnetworkIDSupportsAll
config.SubnetworkID = subnetworkid.SubnetworkIDSupportsAll
}
config.TimeSource = NewMedianTime()
@ -136,7 +136,7 @@ func createTxForTest(numInputs uint32, numOutputs uint32, outputValue uint64, su
tx.Gas = subnetworkData.Gas
tx.Payload = subnetworkData.Payload
} else {
tx.SubnetworkID = wire.SubnetworkIDNative
tx.SubnetworkID = *subnetworkid.SubnetworkIDNative
tx.Gas = 0
tx.Payload = []byte{}
}

12
blockdag/validate.go
View File

@ -237,22 +237,22 @@ func CheckTransactionSanity(tx *util.Tx, subnetworkID *subnetworkid.SubnetworkID
}
// Transactions in native and subnetwork registry subnetworks must have Gas = 0
if (msgTx.SubnetworkID == wire.SubnetworkIDNative ||
msgTx.SubnetworkID == wire.SubnetworkIDRegistry) &&
if (msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) ||
msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry)) &&
msgTx.Gas > 0 {
return ruleError(ErrInvalidGas, "transaction in the native or "+
"registry subnetworks has gas > 0 ")
}
if msgTx.SubnetworkID == wire.SubnetworkIDNative &&
if msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) &&
len(msgTx.Payload) > 0 {
return ruleError(ErrInvalidPayload,
"transaction in the native subnetwork includes a payload")
}
if msgTx.SubnetworkID == wire.SubnetworkIDRegistry &&
if msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) &&
len(msgTx.Payload) != 8 {
return ruleError(ErrInvalidPayload,
@ -262,8 +262,8 @@ func CheckTransactionSanity(tx *util.Tx, subnetworkID *subnetworkid.SubnetworkID
// If we are a partial node, only transactions on the Registry subnetwork
// or our own subnetwork may have a payload
isLocalNodeFull := subnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll)
shouldTxBeFull := msgTx.SubnetworkID.IsEqual(&wire.SubnetworkIDRegistry) ||
isLocalNodeFull := subnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll)
shouldTxBeFull := msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) ||
msgTx.SubnetworkID.IsEqual(subnetworkID)
if !isLocalNodeFull && !shouldTxBeFull && len(msgTx.Payload) > 0 {
return ruleError(ErrInvalidPayload,

58
blockdag/validate_test.go
View File

@ -70,7 +70,7 @@ func TestCheckConnectBlockTemplate(t *testing.T) {
// Create a new database and chain instance to run tests against.
dag, teardownFunc, err := DAGSetup("checkconnectblocktemplate", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Errorf("Failed to setup dag instance: %v", err)
@ -155,7 +155,7 @@ func TestCheckBlockSanity(t *testing.T) {
// Create a new database and dag instance to run tests against.
dag, teardownFunc, err := DAGSetup("TestCheckBlockSanity", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
t.Errorf("Failed to setup dag instance: %v", err)
@ -254,7 +254,7 @@ func TestCheckBlockSanity(t *testing.T) {
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -324,7 +324,7 @@ func TestCheckBlockSanity(t *testing.T) {
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -393,7 +393,7 @@ func TestCheckBlockSanity(t *testing.T) {
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -450,7 +450,7 @@ func TestCheckBlockSanity(t *testing.T) {
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
},
}
@ -650,43 +650,43 @@ func TestCheckTransactionSanity(t *testing.T) {
extraModificationsFunc func(*wire.MsgTx)
expectedErr error
}{
{"good one", 1, 1, 1, wire.SubnetworkIDNative, nil, nil, nil},
{"no inputs", 0, 1, 1, wire.SubnetworkIDNative, nil, nil, ruleError(ErrNoTxInputs, "")},
{"no outputs", 1, 0, 1, wire.SubnetworkIDNative, nil, nil, nil},
{"too big", 100000, 1, 1, wire.SubnetworkIDNative, nil, nil, ruleError(ErrTxTooBig, "")},
{"good one", 1, 1, 1, *subnetworkid.SubnetworkIDNative, nil, nil, nil},
{"no inputs", 0, 1, 1, *subnetworkid.SubnetworkIDNative, nil, nil, ruleError(ErrNoTxInputs, "")},
{"no outputs", 1, 0, 1, *subnetworkid.SubnetworkIDNative, nil, nil, nil},
{"too big", 100000, 1, 1, *subnetworkid.SubnetworkIDNative, nil, nil, ruleError(ErrTxTooBig, "")},
{"too much satoshi in one output", 1, 1, util.MaxSatoshi + 1,
wire.SubnetworkIDNative,
*subnetworkid.SubnetworkIDNative,
nil,
nil,
ruleError(ErrBadTxOutValue, "")},
{"too much satoshi in total outputs", 1, 2, util.MaxSatoshi - 1,
wire.SubnetworkIDNative,
*subnetworkid.SubnetworkIDNative,
nil,
nil,
ruleError(ErrBadTxOutValue, "")},
{"duplicate inputs", 2, 1, 1,
wire.SubnetworkIDNative,
*subnetworkid.SubnetworkIDNative,
nil,
func(tx *wire.MsgTx) { tx.TxIn[1].PreviousOutPoint.Index = 0 },
ruleError(ErrDuplicateTxInputs, "")},
{"non-zero gas in DAGCoin", 1, 1, 0,
wire.SubnetworkIDNative,
&txSubnetworkData{wire.SubnetworkIDNative, 1, []byte{}},
*subnetworkid.SubnetworkIDNative,
&txSubnetworkData{*subnetworkid.SubnetworkIDNative, 1, []byte{}},
nil,
ruleError(ErrInvalidGas, "")},
{"non-zero gas in subnetwork registry", 1, 1, 0,
wire.SubnetworkIDNative,
&txSubnetworkData{wire.SubnetworkIDNative, 1, []byte{}},
*subnetworkid.SubnetworkIDNative,
&txSubnetworkData{*subnetworkid.SubnetworkIDNative, 1, []byte{}},
nil,
ruleError(ErrInvalidGas, "")},
{"non-zero payload in DAGCoin", 1, 1, 0,
wire.SubnetworkIDNative,
&txSubnetworkData{wire.SubnetworkIDNative, 0, []byte{1}},
*subnetworkid.SubnetworkIDNative,
&txSubnetworkData{*subnetworkid.SubnetworkIDNative, 0, []byte{1}},
nil,
ruleError(ErrInvalidPayload, "")},
{"payload in subnetwork registry isn't 8 bytes", 1, 1, 0,
wire.SubnetworkIDNative,
&txSubnetworkData{wire.SubnetworkIDNative, 0, []byte{1, 2, 3, 4, 5, 6, 7}},
*subnetworkid.SubnetworkIDNative,
&txSubnetworkData{*subnetworkid.SubnetworkIDNative, 0, []byte{1, 2, 3, 4, 5, 6, 7}},
nil,
ruleError(ErrInvalidPayload, "")},
{"payload in other subnetwork isn't 0 bytes", 1, 1, 0,
@ -772,7 +772,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -802,7 +802,7 @@ var Block100000 = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -872,7 +872,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -941,7 +941,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -998,7 +998,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
},
}
@ -1094,7 +1094,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -1233,7 +1233,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -1290,7 +1290,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
},
}

5
btcjson/dagsvrwsntfns_test.go
View File

@ -15,7 +15,6 @@ import (
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/btcjson"
"github.com/daglabs/btcd/wire"
)
// TestDAGSvrWsNtfns tests all of the dag server websocket-specific
@ -196,7 +195,7 @@ func TestDAGSvrWsNtfns(t *testing.T) {
TxID: "123",
Version: 1,
LockTime: 4294967295,
Subnetwork: wire.SubnetworkIDNative.String(),
Subnetwork: subnetworkid.SubnetworkIDNative.String(),
Vin: nil,
Vout: nil,
Confirmations: 0,
@ -210,7 +209,7 @@ func TestDAGSvrWsNtfns(t *testing.T) {
TxID: "123",
Version: 1,
LockTime: 4294967295,
Subnetwork: wire.SubnetworkIDNative.String(),
Subnetwork: subnetworkid.SubnetworkIDNative.String(),
Vin: nil,
Vout: nil,
Confirmations: 0,

4
config/config.go
View File

@ -759,11 +759,11 @@ func loadConfig() (*Config, []string, error) {
return nil, nil, err
}
} else {
cfg.SubnetworkID = &wire.SubnetworkIDSupportsAll
cfg.SubnetworkID = subnetworkid.SubnetworkIDSupportsAll
}
// Check that 'generate' and 'subnetwork' flags do not conflict
if cfg.Generate && *cfg.SubnetworkID != wire.SubnetworkIDSupportsAll {
if cfg.Generate && cfg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
str := "%s: both generate flag and subnetwork filtering are set "
err := fmt.Errorf(str, funcName)
fmt.Fprintln(os.Stderr, err)

5
config/config_test.go
View File

@ -9,7 +9,6 @@ import (
"testing"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/wire"
)
var (
@ -77,7 +76,7 @@ func TestCreateDefaultConfigFile(t *testing.T) {
// TestConstants makes sure that all constants hard-coded into the help text were not modified.
func TestConstants(t *testing.T) {
zero := subnetworkid.SubnetworkID{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
if wire.SubnetworkIDSupportsAll != zero {
t.Errorf("wire.SubnetworkIDSupportsAll value was changed from 0, therefore you probably need to update the help text for SubnetworkID")
if *subnetworkid.SubnetworkIDSupportsAll != zero {
t.Errorf("subnetworkid.SubnetworkIDSupportsAll value was changed from 0, therefore you probably need to update the help text for SubnetworkID")
}
}

2
connmgr/seed.go
View File

@ -49,7 +49,7 @@ func SeedFromDNS(dagParams *dagconfig.Params, reqServices wire.ServiceFlag, subn
host = fmt.Sprintf("%c%x.%s", ServiceFlagPrefixChar, uint64(reqServices), dnsseed.Host)
}
if !subnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !subnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
host = fmt.Sprintf("%c%s.%s", SubnetworkIDPrefixChar, subnetworkID, host)
}

3
dagconfig/genesis.go
View File

@ -9,6 +9,7 @@ import (
"time"
"github.com/daglabs/btcd/dagconfig/daghash"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/wire"
)
@ -38,7 +39,7 @@ var genesisCoinbaseTx = wire.MsgTx{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
}
// genesisHash is the hash of the first block in the block chain for the main

2
database/testdata/generator.go vendored
View File

@ -143,7 +143,7 @@ var genesisCoinbaseTx = wire.MsgTx{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: subnetworkid.SubnetworkIDNative,
}
var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.

5
mempool/mempool.go
View File

@ -21,6 +21,7 @@ import (
"github.com/daglabs/btcd/mining"
"github.com/daglabs/btcd/txscript"
"github.com/daglabs/btcd/util"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/wire"
)
@ -751,9 +752,9 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// Check that transaction does not overuse GAS
msgTx := tx.MsgTx()
if msgTx.SubnetworkID == wire.SubnetworkIDSupportsAll {
if msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
return nil, nil, txRuleError(wire.RejectInvalid, "SubnetworkIDSupportsAll is not permited in transaction")
} else if msgTx.SubnetworkID != wire.SubnetworkIDNative {
} else if !msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
gasLimit, err := mp.cfg.DAG.SubnetworkStore.GasLimit(&msgTx.SubnetworkID)
if err != nil {
return nil, nil, err

14
mempool/mempool_test.go
View File

@ -213,7 +213,7 @@ func (p *poolHarness) CreateSignedTxForSubnetwork(inputs []spendableOutpoint, nu
// total input amount. All outputs will be to the payment script associated
// with the harness and all inputs are assumed to do the same.
func (p *poolHarness) CreateSignedTx(inputs []spendableOutpoint, numOutputs uint32) (*util.Tx, error) {
return p.CreateSignedTxForSubnetwork(inputs, numOutputs, &wire.SubnetworkIDNative, 0)
return p.CreateSignedTxForSubnetwork(inputs, numOutputs, subnetworkid.SubnetworkIDNative, 0)
}
// CreateTxChain creates a chain of zero-fee transactions (each subsequent
@ -286,7 +286,7 @@ func newPoolHarness(dagParams *dagconfig.Params, numOutputs uint32, dbName strin
// Create a new database and chain instance to run tests against.
dag, teardownFunc, err := blockdag.DAGSetup(dbName, blockdag.Config{
DAGParams: dagParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
})
if err != nil {
return nil, nil, nil, fmt.Errorf("Failed to setup DAG instance: %v", err)
@ -626,7 +626,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: p2shPKScript,
}},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
})
harness.txPool.mpUTXOSet.AddTx(p2shTx.MsgTx(), curHeight+1)
@ -642,7 +642,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: dummyPkScript,
}},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
})
_, err = harness.txPool.ProcessTransaction(nonStdSigScriptTx, true, false, 0)
if err == nil {
@ -687,7 +687,7 @@ func TestProcessTransaction(t *testing.T) {
}},
TxOut: []*wire.TxOut{},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
})
_, err = harness.txPool.ProcessTransaction(noOutsTx, true, false, 0)
if err != nil {
@ -759,7 +759,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: dummyPkScript,
}},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
})
_, err = harness.txPool.ProcessTransaction(tx, true, false, 0)
fmt.Println(err)
@ -1841,7 +1841,7 @@ var dummyBlock = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
},
}

2
mining/mining.go
View File

@ -494,7 +494,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
prioItem := heap.Pop(priorityQueue).(*txPrioItem)
tx := prioItem.tx
if tx.MsgTx().SubnetworkID != wire.SubnetworkIDNative && tx.MsgTx().SubnetworkID != wire.SubnetworkIDRegistry {
if !tx.MsgTx().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) && !tx.MsgTx().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) {
subnetworkID := tx.MsgTx().SubnetworkID
gasUsage, ok := gasUsageMap[subnetworkID]
if !ok {

5
peer/example_test.go
View File

@ -11,6 +11,7 @@ import (
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/peer"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/wire"
)
@ -23,7 +24,7 @@ func mockRemotePeer() error {
UserAgentName: "peer", // User agent name to advertise.
UserAgentVersion: "1.0.0", // User agent version to advertise.
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
}
// Accept connections on the simnet port.
@ -78,7 +79,7 @@ func Example_newOutboundPeer() {
verack <- struct{}{}
},
},
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
}
p, err := peer.NewOutboundPeer(peerCfg, "127.0.0.1:18555")
if err != nil {

4
peer/peer.go
View File

@ -1045,8 +1045,8 @@ func (p *Peer) handleRemoteVersionMsg(msg *wire.MsgVersion) error {
// Disconnect if:
// - we are a full node and the outbound connection we've initiated is a partial node
// - the remote node is partial and our subnetwork doesn't match their subnetwork
isLocalNodeFull := p.cfg.SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll)
isRemoteNodeFull := msg.SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll)
isLocalNodeFull := p.cfg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll)
isRemoteNodeFull := msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll)
if (isLocalNodeFull && !isRemoteNodeFull && !p.inbound) ||
(!isLocalNodeFull && !isRemoteNodeFull && !msg.SubnetworkID.IsEqual(p.cfg.SubnetworkID)) {

13
peer/peer_test.go
View File

@ -16,6 +16,7 @@ import (
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/dagconfig/daghash"
"github.com/daglabs/btcd/peer"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/wire"
)
@ -229,7 +230,7 @@ func TestPeerConnection(t *testing.T) {
DAGParams: &dagconfig.MainNetParams,
ProtocolVersion: wire.ProtocolVersion, // Configure with older version
Services: 0,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
}
peer2Cfg := &peer.Config{
Listeners: peer1Cfg.Listeners,
@ -239,7 +240,7 @@ func TestPeerConnection(t *testing.T) {
DAGParams: &dagconfig.MainNetParams,
ProtocolVersion: wire.ProtocolVersion + 1,
Services: wire.SFNodeNetwork,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
}
wantStats1 := peerStats{
@ -441,7 +442,7 @@ func TestPeerListeners(t *testing.T) {
UserAgentComments: []string{"comment"},
DAGParams: &dagconfig.MainNetParams,
Services: wire.SFNodeBloom,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
}
inConn, outConn := pipe(
&conn{raddr: "10.0.0.1:8333"},
@ -612,7 +613,7 @@ func TestOutboundPeer(t *testing.T) {
UserAgentComments: []string{"comment"},
DAGParams: &dagconfig.MainNetParams,
Services: 0,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
}
r, w := io.Pipe()
@ -753,7 +754,7 @@ func TestUnsupportedVersionPeer(t *testing.T) {
UserAgentComments: []string{"comment"},
DAGParams: &dagconfig.MainNetParams,
Services: 0,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
SubnetworkID: subnetworkid.SubnetworkIDSupportsAll,
}
localNA := wire.NewNetAddressIPPort(
@ -810,7 +811,7 @@ func TestUnsupportedVersionPeer(t *testing.T) {
}
// Remote peer writes version message advertising invalid protocol version 0
invalidVersionMsg := wire.NewMsgVersion(remoteNA, localNA, 0, 0, &wire.SubnetworkIDSupportsAll)
invalidVersionMsg := wire.NewMsgVersion(remoteNA, localNA, 0, 0, subnetworkid.SubnetworkIDSupportsAll)
invalidVersionMsg.ProtocolVersion = 0
_, err = wire.WriteMessageN(

18
server/p2p/p2p.go
View File

@ -426,8 +426,8 @@ func (sp *Peer) OnVersion(_ *peer.Peer, msg *wire.MsgVersion) {
if addrManager.NeedMoreAddresses() {
sp.QueueMessage(wire.NewMsgGetAddr(sp.SubnetworkID()), nil)
if !sp.SubnetworkID().IsEqual(&wire.SubnetworkIDSupportsAll) {
sp.QueueMessage(wire.NewMsgGetAddr(&wire.SubnetworkIDSupportsAll), nil)
if !sp.SubnetworkID().IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
sp.QueueMessage(wire.NewMsgGetAddr(subnetworkid.SubnetworkIDSupportsAll), nil)
}
}
@ -1122,9 +1122,9 @@ func (sp *Peer) OnAddr(_ *peer.Peer, msg *wire.MsgAddr) {
return
}
if msg.SubnetworkID == nil || (!msg.SubnetworkID.IsEqual(config.MainConfig().SubnetworkID) && !msg.SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll)) {
if msg.SubnetworkID == nil || (!msg.SubnetworkID.IsEqual(config.MainConfig().SubnetworkID) && !msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll)) {
peerLog.Errorf("Only %s and %s subnetwork IDs are allowed in [%s] command, but got subnetwork ID %s from %s",
wire.SubnetworkIDSupportsAll, config.MainConfig().SubnetworkID, msg.Command(), msg.SubnetworkID, sp.Peer)
subnetworkid.SubnetworkIDSupportsAll, config.MainConfig().SubnetworkID, msg.Command(), msg.SubnetworkID, sp.Peer)
sp.Disconnect()
return
}
@ -1284,8 +1284,8 @@ func (s *Server) pushBlockMsg(sp *Peer, hash *daghash.Hash, doneChan chan<- stru
// the block to a partial block.
nodeSubnetworkID := s.DAG.SubnetworkID()
peerSubnetworkID := sp.Peer.SubnetworkID()
isNodeFull := nodeSubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll)
isPeerFull := peerSubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll)
isNodeFull := nodeSubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll)
isPeerFull := peerSubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll)
if isNodeFull && !isPeerFull {
msgBlock.ConvertToPartial(peerSubnetworkID)
}
@ -1908,7 +1908,7 @@ func (s *Server) peerHandler() {
if !config.MainConfig().DisableDNSSeed {
seedFromSubNetwork := func(subnetworkID *subnetworkid.SubnetworkID) {
connmgr.SeedFromDNS(config.ActiveNetParams(), defaultRequiredServices,
&wire.SubnetworkIDSupportsAll, serverutils.BTCDLookup, func(addrs []*wire.NetAddress) {
subnetworkid.SubnetworkIDSupportsAll, serverutils.BTCDLookup, func(addrs []*wire.NetAddress) {
// Bitcoind uses a lookup of the dns seeder here. Since seeder returns
// IPs of nodes and not its own IP, we can not know real IP of
// source. So we'll take first returned address as source.
@ -1917,9 +1917,9 @@ func (s *Server) peerHandler() {
}
// Add full nodes discovered through DNS to the address manager.
seedFromSubNetwork(&wire.SubnetworkIDSupportsAll)
seedFromSubNetwork(subnetworkid.SubnetworkIDSupportsAll)
if !config.MainConfig().SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !config.MainConfig().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
// Node is partial - fetch nodes with same subnetwork
seedFromSubNetwork(config.MainConfig().SubnetworkID)
}

14
server/rpc/rpcserver.go
View File

@ -894,7 +894,7 @@ func handleGenerate(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
}
}
if !config.MainConfig().SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !config.MainConfig().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
Message: "`generate` is not supported on partial nodes.",
@ -1123,8 +1123,8 @@ func handleGetBlock(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
}
nodeSubnetworkID := config.MainConfig().SubnetworkID
if !requestSubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !nodeSubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !requestSubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
if !nodeSubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
if !nodeSubnetworkID.IsEqual(requestSubnetworkID) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
@ -2271,7 +2271,7 @@ func handleGetGenerate(s *Server, cmd interface{}, closeChan <-chan struct{}) (i
// handleGetHashesPerSec implements the getHashesPerSec command.
func handleGetHashesPerSec(s *Server, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {
if !config.MainConfig().SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !config.MainConfig().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
Message: "`getHashesPerSec` is not supported on partial nodes.",
@ -2360,7 +2360,7 @@ func handleGetMempoolInfo(s *Server, cmd interface{}, closeChan <-chan struct{})
// handleGetMiningInfo implements the getMiningInfo command. We only return the
// fields that are not related to wallet functionality.
func handleGetMiningInfo(s *Server, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {
if !config.MainConfig().SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !config.MainConfig().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
Message: "`getMiningInfo` is not supported on partial nodes.",
@ -2422,7 +2422,7 @@ func handleGetNetTotals(s *Server, cmd interface{}, closeChan <-chan struct{}) (
// This command had been (possibly temporarily) dropped.
// Originally it relied on height, which no longer makes sense.
func handleGetNetworkHashPS(s *Server, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {
if !config.MainConfig().SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !config.MainConfig().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
Message: "`getNetworkHashPS` is not supported on partial nodes.",
@ -3327,7 +3327,7 @@ func handleSendRawTransaction(s *Server, cmd interface{}, closeChan <-chan struc
// handleSetGenerate implements the setGenerate command.
func handleSetGenerate(s *Server, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {
if !config.MainConfig().SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
if !config.MainConfig().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
Message: "`setGenerate` is not supported on partial nodes.",

4
server/rpc/rpcwebsocket.go
View File

@ -1928,12 +1928,12 @@ func handleNotifyNewTransactions(wsc *wsClient, icmd interface{}) (interface{},
if isVerbose {
nodeSubnetworkID := wsc.server.cfg.DAG.SubnetworkID()
if nodeSubnetworkID.IsEqual(&wire.SubnetworkIDNative) && subnetworkID != nil {
if nodeSubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) && subnetworkID != nil {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidParameter,
Message: "Subnetwork switch is disabled when node is in Native subnetwork",
}
} else if !nodeSubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll) {
} else if !nodeSubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
if subnetworkID == nil {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidParameter,

9
util/block_test.go
View File

@ -14,6 +14,7 @@ import (
"github.com/daglabs/btcd/dagconfig/daghash"
"github.com/daglabs/btcd/util"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/wire"
"github.com/davecgh/go-spew/spew"
)
@ -362,7 +363,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -432,7 +433,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -501,7 +502,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
{
Version: 1,
@ -558,7 +559,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
},
}

11
util/subnetworkid/subnetworkid.go
View File

@ -27,6 +27,17 @@ var ErrIDStrSize = fmt.Errorf("max ID string length is %d bytes", MaxStringSize)
// typically represents ripmed160(sha256(data)).
type SubnetworkID [IDLength]byte
var (
// SubnetworkIDSupportsAll is the subnetwork ID that is used to signal to peers that you support all subnetworks
SubnetworkIDSupportsAll = &SubnetworkID{}
// SubnetworkIDNative is the default subnetwork ID which is used for transactions without related payload data
SubnetworkIDNative = &SubnetworkID{1}
// SubnetworkIDRegistry is the subnetwork ID which is used for adding new sub networks to the registry
SubnetworkIDRegistry = &SubnetworkID{2}
)
// String returns the SubnetworkID as the hexadecimal string of the byte-reversed
// hash.
func (id SubnetworkID) String() string {

2
util/testtools/testtools.go
View File

@ -64,7 +64,7 @@ func RegisterSubnetworkForTest(dag *blockdag.BlockDAG, params *dagconfig.Params,
PkScript: blockdag.OpTrueScript,
Value: fundsBlockCbTx.TxOut[0].Value,
})
registryTx.SubnetworkID = wire.SubnetworkIDRegistry
registryTx.SubnetworkID = *subnetworkid.SubnetworkIDRegistry
registryTx.Payload = make([]byte, 8)
binary.LittleEndian.PutUint64(registryTx.Payload, gasLimit)

3
wire/message_test.go
View File

@ -14,6 +14,7 @@ import (
"time"
"github.com/daglabs/btcd/dagconfig/daghash"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/davecgh/go-spew/spew"
)
@ -46,7 +47,7 @@ func TestMessage(t *testing.T) {
addrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8333}
me := NewNetAddress(addrMe, SFNodeNetwork)
me.Timestamp = time.Time{} // Version message has zero value timestamp.
msgVersion := NewMsgVersion(me, you, 123123, 0, &SubnetworkIDSupportsAll)
msgVersion := NewMsgVersion(me, you, 123123, 0, subnetworkid.SubnetworkIDSupportsAll)
msgVerack := NewMsgVerAck()
msgGetAddr := NewMsgGetAddr(nil)

3
wire/msgaddr_test.go
View File

@ -12,6 +12,7 @@ import (
"testing"
"time"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/davecgh/go-spew/spew"
)
@ -116,7 +117,7 @@ func TestAddrWire(t *testing.T) {
}
// Address message with multiple addresses and subnetworkID.
multiAddrSubnet := NewMsgAddr(&SubnetworkIDNative)
multiAddrSubnet := NewMsgAddr(subnetworkid.SubnetworkIDNative)
multiAddrSubnet.AddAddresses(na, na2)
multiAddrSubnetEncoded := []byte{
0x00, // All subnetworks

6
wire/msgblock_test.go
View File

@ -95,12 +95,12 @@ func TestConvertToPartial(t *testing.T) {
expectedPayloadLength int
}{
{
subnetworkID: SubnetworkIDNative,
subnetworkID: *subnetworkid.SubnetworkIDNative,
payload: []byte{},
expectedPayloadLength: 0,
},
{
subnetworkID: SubnetworkIDRegistry,
subnetworkID: *subnetworkid.SubnetworkIDRegistry,
payload: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08},
expectedPayloadLength: 0,
},
@ -538,7 +538,7 @@ var blockOne = MsgBlock{
},
},
LockTime: 0,
SubnetworkID: SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
},
},
}

3
wire/msggetaddr_test.go
View File

@ -9,6 +9,7 @@ import (
"reflect"
"testing"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/davecgh/go-spew/spew"
)
@ -45,7 +46,7 @@ func TestGetAddrWire(t *testing.T) {
}
// With specific subnetwork
msgGetAddrSubnet := NewMsgGetAddr(&SubnetworkIDNative)
msgGetAddrSubnet := NewMsgGetAddr(subnetworkid.SubnetworkIDNative)
msgGetAddrSubnetEncoded := []byte{
0x00, // All subnetworks
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Subnetwork ID

29
wire/msgtx.go
View File

@ -110,17 +110,6 @@ const (
txEncodingExcludeSignatureScript
)
var (
// SubnetworkIDSupportsAll is the subnetwork ID that is used to signal to peers that you support all subnetworks
SubnetworkIDSupportsAll = subnetworkid.SubnetworkID{}
// SubnetworkIDNative is the default subnetwork ID which is used for transactions without related payload data
SubnetworkIDNative = subnetworkid.SubnetworkID{1}
// SubnetworkIDRegistry is the subnetwork ID which is used for adding new sub networks to the registry
SubnetworkIDRegistry = subnetworkid.SubnetworkID{2}
)
// scriptFreeList defines a free list of byte slices (up to the maximum number
// defined by the freeListMaxItems constant) that have a cap according to the
// freeListMaxScriptSize constant. It is used to provide temporary buffers for
@ -543,12 +532,12 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
return err
}
if msg.SubnetworkID == SubnetworkIDSupportsAll {
if msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) {
str := fmt.Sprintf("%s is a reserved sub network and cannot be used as part of a transaction", msg.SubnetworkID)
return messageError("MsgTx.BtcDecode", str)
}
if msg.SubnetworkID != SubnetworkIDNative {
if !msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
msg.Gas, err = binarySerializer.Uint64(r, littleEndian)
if err != nil {
returnScriptBuffers()
@ -684,8 +673,8 @@ func (msg *MsgTx) encode(w io.Writer, pver uint32, encodingFlags txEncoding) err
return err
}
if msg.SubnetworkID != SubnetworkIDNative {
if msg.SubnetworkID == SubnetworkIDRegistry && msg.Gas != 0 {
if !msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
if msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) && msg.Gas != 0 {
str := fmt.Sprintf("Transactions from subnetwork %s should have 0 gas", msg.SubnetworkID)
return messageError("MsgTx.BtcEncode", str)
}
@ -754,7 +743,7 @@ func (msg *MsgTx) serializeSize(encodingFlags txEncoding) int {
n := 32 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
VarIntSerializeSize(uint64(len(msg.TxOut)))
if msg.SubnetworkID != SubnetworkIDNative {
if !msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
// Gas 8 bytes
n += 8
@ -836,8 +825,8 @@ func (msg *MsgTx) PkScriptLocs() []int {
// 2. The native subnetwork
// 3. The transaction's subnetwork
func (msg *MsgTx) IsSubnetworkCompatible(subnetworkID *subnetworkid.SubnetworkID) bool {
return subnetworkID.IsEqual(&SubnetworkIDSupportsAll) ||
subnetworkID.IsEqual(&SubnetworkIDNative) ||
return subnetworkID.IsEqual(subnetworkid.SubnetworkIDSupportsAll) ||
subnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) ||
subnetworkID.IsEqual(&msg.SubnetworkID)
}
@ -851,13 +840,13 @@ func NewMsgTx(version int32) *MsgTx {
Version: version,
TxIn: make([]*TxIn, 0, defaultTxInOutAlloc),
TxOut: make([]*TxOut, 0, defaultTxInOutAlloc),
SubnetworkID: SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
}
}
func newRegistryMsgTx(version int32, gasLimit uint64) *MsgTx {
tx := NewMsgTx(version)
tx.SubnetworkID = SubnetworkIDRegistry
tx.SubnetworkID = *subnetworkid.SubnetworkIDRegistry
tx.Payload = make([]byte, 8)
binary.LittleEndian.PutUint64(tx.Payload, gasLimit)
return tx

16
wire/msgtx_test.go
View File

@ -588,12 +588,12 @@ func TestTxSerializeErrors(t *testing.T) {
}
registryTx := NewMsgTx(1)
registryTx.SubnetworkID = SubnetworkIDRegistry
registryTx.SubnetworkID = *subnetworkid.SubnetworkIDRegistry
registryTx.Gas = 1
w := bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
err := registryTx.Serialize(w)
str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubnetworkIDRegistry)
str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", subnetworkid.SubnetworkIDRegistry)
expectedErr := messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -604,7 +604,7 @@ func TestTxSerializeErrors(t *testing.T) {
w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
err = nativeTx.Serialize(w)
str = fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubnetworkIDNative)
str = fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", subnetworkid.SubnetworkIDNative)
expectedErr = messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -615,7 +615,7 @@ func TestTxSerializeErrors(t *testing.T) {
w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
err = nativeTx.Serialize(w)
str = fmt.Sprintf("Transactions from subnetwork %v should have <nil> payload", SubnetworkIDNative)
str = fmt.Sprintf("Transactions from subnetwork %v should have <nil> payload", subnetworkid.SubnetworkIDNative)
expectedErr = messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -638,7 +638,7 @@ func TestTxSerializeErrors(t *testing.T) {
var tx MsgTx
err = tx.Deserialize(r)
str = fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", SubnetworkIDSupportsAll)
str = fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", subnetworkid.SubnetworkIDSupportsAll)
expectedErr = messageError("MsgTx.BtcDecode", str)
if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -776,12 +776,12 @@ func TestIsSubnetworkCompatible(t *testing.T) {
}{
{
name: "SupportsAll subnetwork",
subnetworkID: &SubnetworkIDSupportsAll,
subnetworkID: subnetworkid.SubnetworkIDSupportsAll,
expectedResult: true,
},
{
name: "Native subnetwork",
subnetworkID: &SubnetworkIDNative,
subnetworkID: subnetworkid.SubnetworkIDNative,
expectedResult: true,
},
{
@ -924,7 +924,7 @@ var multiTx = &MsgTx{
},
},
LockTime: 0,
SubnetworkID: SubnetworkIDNative,
SubnetworkID: *subnetworkid.SubnetworkIDNative,
}
// multiTxEncoded is the wire encoded bytes for multiTx using protocol version

3
wire/msgversion_test.go
View File

@ -13,6 +13,7 @@ import (
"testing"
"time"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/davecgh/go-spew/spew"
)
@ -32,7 +33,7 @@ func TestVersion(t *testing.T) {
}
// Ensure we get the correct data back out.
msg := NewMsgVersion(me, you, nonce, lastBlock, &SubnetworkIDSupportsAll)
msg := NewMsgVersion(me, you, nonce, lastBlock, subnetworkid.SubnetworkIDSupportsAll)
if msg.ProtocolVersion != int32(pver) {
t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
msg.ProtocolVersion, pver)