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

[DEV-353] Rename subnetwork to subnetworkID everywhere in the code except for the command line flag (#165)

Browse Source 
* [DEV-353] Renamed subnetwork -> subnetworkID.

* [DEV-353] Renamed dagcoin -> native.
This commit is contained in:
stasatdaglabs 2019-01-20 16:22:25 +02:00 committed by Evgeny Khirin
parent 10ee7df252
commit f00651c4e3
28 changed files with 115 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
blockdag/dag.go
View File

@ -96,10 +96,6 @@ type BlockDAG struct {
// virtual tracks the current tips. // virtual tracks the current tips.
virtual *virtualBlock virtual *virtualBlock
// lastSubnetworkID holds the last registered subnetwork ID in the DAG.
// Note that it is NOT the total amount of registered (or active) subnetworks.
lastSubnetworkID uint64
// These fields are related to handling of orphan blocks. They are // These fields are related to handling of orphan blocks. They are
// protected by a combination of the chain lock and the orphan lock. // protected by a combination of the chain lock and the orphan lock.
orphanLock sync.RWMutex orphanLock sync.RWMutex

22
blockdag/dagio.go
View File

@ -53,14 +53,6 @@ var (
// unspent transaction output set. // unspent transaction output set.
utxoSetBucketName = []byte("utxoset") utxoSetBucketName = []byte("utxoset")
// pendingSubnetworksBucketName is the name of the db bucket used to store the
// pending subnetworks.
pendingSubnetworksBucketName = []byte("pendingsubnetworks")
// registeredSubnetworkTxsBucketName is the name of the db bucket used to house
// the transactions that have been used to register subnetworks.
registeredSubnetworkTxsBucketName = []byte("registeredsubnetworktxs")
// subnetworksBucketName is the name of the db bucket used to store the // subnetworksBucketName is the name of the db bucket used to store the
// subnetwork registry. // subnetwork registry.
subnetworksBucketName = []byte("subnetworks") subnetworksBucketName = []byte("subnetworks")
@ -670,7 +662,6 @@ func dbFetchHeightByHash(dbTx database.Tx, hash *daghash.Hash) (int32, error) {
type dagState struct { type dagState struct {
TipHashes []daghash.Hash TipHashes []daghash.Hash
LastFinalityPoint daghash.Hash LastFinalityPoint daghash.Hash
LastSubnetworkID uint64
} }
// serializeDAGState returns the serialization of the DAG state. // serializeDAGState returns the serialization of the DAG state.
@ -776,19 +767,6 @@ func (dag *BlockDAG) createDAGState() error {
return err return err
} }
// Create the bucket that houses the pending subnetworks.
_, err = meta.CreateBucket(pendingSubnetworksBucketName)
if err != nil {
return err
}
// Create the bucket that houses the registered subnetworks to
// their registry transactions index.
_, err = meta.CreateBucket(registeredSubnetworkTxsBucketName)
if err != nil {
return err
}
// Create the bucket that houses the registered subnetworks. // Create the bucket that houses the registered subnetworks.
_, err = meta.CreateBucket(subnetworksBucketName) _, err = meta.CreateBucket(subnetworksBucketName)
if err != nil { if err != nil {

6
blockdag/dagio_test.go
View File

@ -547,18 +547,16 @@ func TestDAGStateSerialization(t *testing.T) {
state: &dagState{ state: &dagState{
TipHashes: []daghash.Hash{*newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")}, TipHashes: []daghash.Hash{*newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")},
LastFinalityPoint: *newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"), LastFinalityPoint: *newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"),
LastSubnetworkID: 123456,
}, },
serialized: []byte("{\"TipHashes\":[[111,226,140,10,182,241,179,114,193,166,162,70,174,99,247,79,147,30,131,101,225,90,8,156,104,214,25,0,0,0,0,0]],\"LastFinalityPoint\":[111,226,140,10,182,241,179,114,193,166,162,70,174,99,247,79,147,30,131,101,225,90,8,156,104,214,25,0,0,0,0,0],\"LastSubnetworkID\":123456}"), serialized: []byte("{\"TipHashes\":[[111,226,140,10,182,241,179,114,193,166,162,70,174,99,247,79,147,30,131,101,225,90,8,156,104,214,25,0,0,0,0,0]],\"LastFinalityPoint\":[111,226,140,10,182,241,179,114,193,166,162,70,174,99,247,79,147,30,131,101,225,90,8,156,104,214,25,0,0,0,0,0]}"),
}, },
{ {
name: "block 1", name: "block 1",
state: &dagState{ state: &dagState{
TipHashes: []daghash.Hash{*newHashFromStr("00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048")}, TipHashes: []daghash.Hash{*newHashFromStr("00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048")},
LastFinalityPoint: *newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"), LastFinalityPoint: *newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"),
LastSubnetworkID: 684321,
}, },
serialized: []byte("{\"TipHashes\":[[72,96,235,24,191,27,22,32,227,126,148,144,252,138,66,117,20,65,111,215,81,89,171,134,104,142,154,131,0,0,0,0]],\"LastFinalityPoint\":[111,226,140,10,182,241,179,114,193,166,162,70,174,99,247,79,147,30,131,101,225,90,8,156,104,214,25,0,0,0,0,0],\"LastSubnetworkID\":684321}"), serialized: []byte("{\"TipHashes\":[[72,96,235,24,191,27,22,32,227,126,148,144,252,138,66,117,20,65,111,215,81,89,171,134,104,142,154,131,0,0,0,0]],\"LastFinalityPoint\":[111,226,140,10,182,241,179,114,193,166,162,70,174,99,247,79,147,30,131,101,225,90,8,156,104,214,25,0,0,0,0,0]}"),
}, },
} }

2
blockdag/fullblocktests/params.go
View File

@ -84,7 +84,7 @@ var (
"4c702b6bf11d5fac"), "4c702b6bf11d5fac"),
}}, }},
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}}, }},
} }
) )

16
blockdag/indexers/txindex_test.go
View File

@ -151,7 +151,7 @@ var block1 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }
@ -205,7 +205,7 @@ var block2 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
@ -251,7 +251,7 @@ var block2 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }
@ -300,7 +300,7 @@ var block3Tx = &wire.MsgTx{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
} }
var block3 = wire.MsgBlock{ var block3 = wire.MsgBlock{
@ -352,7 +352,7 @@ var block3 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
block3Tx, block3Tx,
}, },
@ -407,7 +407,7 @@ var block3A = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
block3Tx, block3Tx,
}, },
@ -462,7 +462,7 @@ var block4 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }
@ -522,7 +522,7 @@ var block5 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }

4
blockdag/subnetworks.go
View File

@ -19,7 +19,7 @@ func registerSubnetworks(dbTx database.Tx, txs []*TxWithBlockHash) error {
validSubnetworkRegistryTxs := make([]*wire.MsgTx, 0) validSubnetworkRegistryTxs := make([]*wire.MsgTx, 0)
for _, txData := range txs { for _, txData := range txs {
tx := txData.Tx.MsgTx() tx := txData.Tx.MsgTx()
if tx.SubnetworkID == wire.SubnetworkRegistry { if tx.SubnetworkID == wire.SubnetworkIDRegistry {
err := validateSubnetworkRegistryTransaction(tx) err := validateSubnetworkRegistryTransaction(tx)
if err != nil { if err != nil {
return err return err
@ -27,7 +27,7 @@ func registerSubnetworks(dbTx database.Tx, txs []*TxWithBlockHash) error {
validSubnetworkRegistryTxs = append(validSubnetworkRegistryTxs, tx) validSubnetworkRegistryTxs = append(validSubnetworkRegistryTxs, tx)
} }
if subnetworkid.Less(&wire.SubnetworkRegistry, &tx.SubnetworkID) { if subnetworkid.Less(&wire.SubnetworkIDRegistry, &tx.SubnetworkID) {
// Transactions are ordered by subnetwork, so we can safely assume // Transactions are ordered by subnetwork, so we can safely assume
// that the rest of the transactions will not be subnetwork registry // that the rest of the transactions will not be subnetwork registry
// transactions. // transactions.

4
blockdag/test_utils.go
View File

@ -133,7 +133,7 @@ func createTxForTest(numInputs uint32, numOutputs uint32, outputValue uint64, su
tx.Gas = subnetworkData.Gas tx.Gas = subnetworkData.Gas
tx.Payload = subnetworkData.Payload tx.Payload = subnetworkData.Payload
} else { } else {
tx.SubnetworkID = wire.SubnetworkDAGCoin tx.SubnetworkID = wire.SubnetworkIDNative
tx.Gas = 0 tx.Gas = 0
tx.Payload = []byte{} tx.Payload = []byte{}
} }
@ -229,7 +229,7 @@ func RegisterSubnetworkForTest(dag *BlockDAG, gasLimit uint64) (*subnetworkid.Su
// Create a block with a valid subnetwork registry transaction // Create a block with a valid subnetwork registry transaction
registryTx := wire.NewMsgTx(wire.TxVersion) registryTx := wire.NewMsgTx(wire.TxVersion)
registryTx.SubnetworkID = wire.SubnetworkRegistry registryTx.SubnetworkID = wire.SubnetworkIDRegistry
registryTx.Payload = make([]byte, 8) registryTx.Payload = make([]byte, 8)
binary.LittleEndian.PutUint64(registryTx.Payload, gasLimit) binary.LittleEndian.PutUint64(registryTx.Payload, gasLimit)

10
blockdag/validate.go
View File

@ -262,23 +262,23 @@ func CheckTransactionSanity(tx *util.Tx) error {
} }
} }
// Transactions in native and SubnetworkRegistry Subnetworks must have Gas = 0 // Transactions in native and subnetwork registry subnetworks must have Gas = 0
if (msgTx.SubnetworkID == wire.SubnetworkDAGCoin || if (msgTx.SubnetworkID == wire.SubnetworkIDNative ||
msgTx.SubnetworkID == wire.SubnetworkRegistry) && msgTx.SubnetworkID == wire.SubnetworkIDRegistry) &&
msgTx.Gas > 0 { msgTx.Gas > 0 {
return ruleError(ErrInvalidGas, "transaction in the native or "+ return ruleError(ErrInvalidGas, "transaction in the native or "+
"registry subnetworks has gas > 0 ") "registry subnetworks has gas > 0 ")
} }
if msgTx.SubnetworkID == wire.SubnetworkDAGCoin && if msgTx.SubnetworkID == wire.SubnetworkIDNative &&
len(msgTx.Payload) > 0 { len(msgTx.Payload) > 0 {
return ruleError(ErrInvalidPayload, return ruleError(ErrInvalidPayload,
"transaction in the native subnetwork includes a payload") "transaction in the native subnetwork includes a payload")
} }
if msgTx.SubnetworkID == wire.SubnetworkRegistry && if msgTx.SubnetworkID == wire.SubnetworkIDRegistry &&
len(msgTx.Payload) != 8 { len(msgTx.Payload) != 8 {
return ruleError(ErrInvalidPayload, return ruleError(ErrInvalidPayload,

22
blockdag/validate_test.go
View File

@ -753,7 +753,7 @@ var Block100000 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
@ -822,7 +822,7 @@ var Block100000 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
@ -879,7 +879,7 @@ var Block100000 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }
@ -1084,7 +1084,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
@ -1141,7 +1141,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }
@ -1165,17 +1165,17 @@ func TestCheckTransactionSanity(t *testing.T) {
{"duplicate inputs", 2, 1, 1, nil, {"duplicate inputs", 2, 1, 1, nil,
func(tx *wire.MsgTx) { tx.TxIn[1].PreviousOutPoint.Index = 0 }, func(tx *wire.MsgTx) { tx.TxIn[1].PreviousOutPoint.Index = 0 },
ruleError(ErrDuplicateTxInputs, "")}, ruleError(ErrDuplicateTxInputs, "")},
{"non-zero gas in DAGCoin", 1, 1, 0, {"non-zero gas in native subnetwork", 1, 1, 0,
&txSubnetworkData{wire.SubnetworkDAGCoin, 1, []byte{}}, &txSubnetworkData{wire.SubnetworkIDNative, 1, []byte{}},
nil, ruleError(ErrInvalidGas, "")}, nil, ruleError(ErrInvalidGas, "")},
{"non-zero gas in subnetwork registry", 1, 1, 0, {"non-zero gas in subnetwork registry", 1, 1, 0,
&txSubnetworkData{wire.SubnetworkRegistry, 1, []byte{}}, &txSubnetworkData{wire.SubnetworkIDRegistry, 1, []byte{}},
nil, ruleError(ErrInvalidGas, "")}, nil, ruleError(ErrInvalidGas, "")},
{"non-zero payload in DAGCoin", 1, 1, 0, {"non-zero payload in native subnetwork", 1, 1, 0,
&txSubnetworkData{wire.SubnetworkDAGCoin, 0, []byte{1}}, &txSubnetworkData{wire.SubnetworkIDNative, 0, []byte{1}},
nil, ruleError(ErrInvalidPayload, "")}, nil, ruleError(ErrInvalidPayload, "")},
{"payload in subnetwork registry isn't 8 bytes", 1, 1, 0, {"payload in subnetwork registry isn't 8 bytes", 1, 1, 0,
&txSubnetworkData{wire.SubnetworkRegistry, 0, []byte{1, 2, 3, 4, 5, 6, 7}}, &txSubnetworkData{wire.SubnetworkIDRegistry, 0, []byte{1, 2, 3, 4, 5, 6, 7}},
nil, ruleError(ErrInvalidPayload, "")}, nil, ruleError(ErrInvalidPayload, "")},
} }

6
config/config.go
View File

@ -181,7 +181,7 @@ type Config struct {
MiningAddrs []util.Address MiningAddrs []util.Address
MinRelayTxFee util.Amount MinRelayTxFee util.Amount
Whitelists []*net.IPNet Whitelists []*net.IPNet
Subnetwork *subnetworkid.SubnetworkID SubnetworkID *subnetworkid.SubnetworkID
} }
// serviceOptions defines the configuration options for the daemon as a service on // serviceOptions defines the configuration options for the daemon as a service on
@ -754,14 +754,14 @@ func loadConfig() (*Config, []string, error) {
} }
if cfg.configFlags.Subnetwork != "" { if cfg.configFlags.Subnetwork != "" {
cfg.Subnetwork, err = subnetworkid.NewFromStr(cfg.configFlags.Subnetwork) cfg.SubnetworkID, err = subnetworkid.NewFromStr(cfg.configFlags.Subnetwork)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
} }
// Check that 'generate' and 'subnetwork' flags do not conflict // Check that 'generate' and 'subnetwork' flags do not conflict
if cfg.Generate && *cfg.Subnetwork != wire.SubnetworkSupportsAll { if cfg.Generate && *cfg.SubnetworkID != wire.SubnetworkIDSupportsAll {
str := "%s: both generate flag and subnetwork filtering are set " str := "%s: both generate flag and subnetwork filtering are set "
err := fmt.Errorf(str, funcName) err := fmt.Errorf(str, funcName)
fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, err)

4
config/config_test.go
View File

@ -77,7 +77,7 @@ func TestCreateDefaultConfigFile(t *testing.T) {
// TestConstants makes sure that all constants hard-coded into the help text were not modified. // TestConstants makes sure that all constants hard-coded into the help text were not modified.
func TestConstants(t *testing.T) { 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} 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.SubnetworkSupportsAll != zero { if wire.SubnetworkIDSupportsAll != zero {
t.Errorf("wire.SubnetworkSupportsAll value was changed from 0, therefore you probably need to update the help text for Subnetwork") t.Errorf("wire.SubnetworkIDSupportsAll value was changed from 0, therefore you probably need to update the help text for SubnetworkID")
} }
} }

2
dagconfig/genesis.go
View File

@ -54,7 +54,7 @@ var genesisCoinbaseTx = wire.MsgTx{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
} }
// genesisHash is the hash of the first block in the block chain for the main // 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, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
} }
var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy. var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.

6
mempool/mempool.go
View File

@ -659,9 +659,9 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// Check that transaction does not overuse GAS // Check that transaction does not overuse GAS
msgTx := tx.MsgTx() msgTx := tx.MsgTx()
if msgTx.SubnetworkID == wire.SubnetworkSupportsAll { if msgTx.SubnetworkID == wire.SubnetworkIDSupportsAll {
return nil, nil, txRuleError(wire.RejectInvalid, "Subnetwork 0 is not permited in transaction") return nil, nil, txRuleError(wire.RejectInvalid, "SubnetworkIDSupportsAll is not permited in transaction")
} else if msgTx.SubnetworkID != wire.SubnetworkDAGCoin { } else if msgTx.SubnetworkID != wire.SubnetworkIDNative {
gasLimit, err := mp.cfg.DAG.GasLimit(&msgTx.SubnetworkID) gasLimit, err := mp.cfg.DAG.GasLimit(&msgTx.SubnetworkID)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err

12
mempool/mempool_test.go
View File

@ -211,7 +211,7 @@ func (p *poolHarness) CreateSignedTxForSubnetwork(inputs []spendableOutpoint, nu
// total input amount. All outputs will be to the payment script associated // total input amount. All outputs will be to the payment script associated
// with the harness and all inputs are assumed to do the same. // with the harness and all inputs are assumed to do the same.
func (p *poolHarness) CreateSignedTx(inputs []spendableOutpoint, numOutputs uint32) (*util.Tx, error) { func (p *poolHarness) CreateSignedTx(inputs []spendableOutpoint, numOutputs uint32) (*util.Tx, error) {
return p.CreateSignedTxForSubnetwork(inputs, numOutputs, &wire.SubnetworkDAGCoin, 0) return p.CreateSignedTxForSubnetwork(inputs, numOutputs, &wire.SubnetworkIDNative, 0)
} }
// CreateTxChain creates a chain of zero-fee transactions (each subsequent // CreateTxChain creates a chain of zero-fee transactions (each subsequent
@ -610,7 +610,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: p2shPKScript, PkScript: p2shPKScript,
}}, }},
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}) })
harness.txPool.mpUTXOSet.AddTx(p2shTx.MsgTx(), curHeight+1) harness.txPool.mpUTXOSet.AddTx(p2shTx.MsgTx(), curHeight+1)
@ -626,7 +626,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: dummyPkScript, PkScript: dummyPkScript,
}}, }},
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}) })
_, err = harness.txPool.ProcessTransaction(nonStdSigScriptTx, true, false, 0) _, err = harness.txPool.ProcessTransaction(nonStdSigScriptTx, true, false, 0)
if err == nil { if err == nil {
@ -671,7 +671,7 @@ func TestProcessTransaction(t *testing.T) {
}}, }},
TxOut: []*wire.TxOut{}, TxOut: []*wire.TxOut{},
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}) })
_, err = harness.txPool.ProcessTransaction(noOutsTx, true, false, 0) _, err = harness.txPool.ProcessTransaction(noOutsTx, true, false, 0)
if err == nil { if err == nil {
@ -748,7 +748,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: dummyPkScript, PkScript: dummyPkScript,
}}, }},
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}) })
_, err = harness.txPool.ProcessTransaction(tx, true, false, 0) _, err = harness.txPool.ProcessTransaction(tx, true, false, 0)
fmt.Println(err) fmt.Println(err)
@ -1830,7 +1830,7 @@ var dummyBlock = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }

14
mining/mining.go
View File

@ -485,24 +485,24 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
prioItem := heap.Pop(priorityQueue).(*txPrioItem) prioItem := heap.Pop(priorityQueue).(*txPrioItem)
tx := prioItem.tx tx := prioItem.tx
if tx.MsgTx().SubnetworkID != wire.SubnetworkDAGCoin { if tx.MsgTx().SubnetworkID != wire.SubnetworkIDNative {
subnetwork := tx.MsgTx().SubnetworkID subnetworkID := tx.MsgTx().SubnetworkID
gasUsage, ok := gasUsageMap[subnetwork] gasUsage, ok := gasUsageMap[subnetworkID]
if !ok { if !ok {
gasUsage = 0 gasUsage = 0
} }
gasLimit, err := g.dag.GasLimit(&subnetwork) gasLimit, err := g.dag.GasLimit(&subnetworkID)
if err != nil { if err != nil {
log.Errorf("Cannot get GAS limit for subnetwork %v", subnetwork) log.Errorf("Cannot get GAS limit for subnetwork %v", subnetworkID)
continue continue
} }
txGas := tx.MsgTx().Gas txGas := tx.MsgTx().Gas
if gasLimit-gasUsage < txGas { if gasLimit-gasUsage < txGas {
log.Tracef("Transaction %v (GAS=%v) ignored because gas overusage (GASUsage=%v) in subnetwork %v (GASLimit=%v)", log.Tracef("Transaction %v (GAS=%v) ignored because gas overusage (GASUsage=%v) in subnetwork %v (GASLimit=%v)",
tx.MsgTx().TxHash, txGas, gasUsage, subnetwork, gasLimit) tx.MsgTx().TxHash, txGas, gasUsage, subnetworkID, gasLimit)
continue continue
} }
gasUsageMap[subnetwork] = gasUsage + txGas gasUsageMap[subnetworkID] = gasUsage + txGas
} }
// Enforce maximum block size. Also check for overflow. // Enforce maximum block size. Also check for overflow.

4
peer/example_test.go
View File

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

12
peer/peer.go
View File

@ -271,8 +271,8 @@ type Config struct {
// messages. // messages.
Listeners MessageListeners Listeners MessageListeners
// Subnetwork specifies which subnetwork the peer is associated with. // SubnetworkID specifies which subnetwork the peer is associated with.
Subnetwork *subnetworkid.SubnetworkID SubnetworkID *subnetworkid.SubnetworkID
} }
// minUint32 is a helper function to return the minimum of two uint32s. // minUint32 is a helper function to return the minimum of two uint32s.
@ -823,7 +823,7 @@ func (p *Peer) localVersionMsg() (*wire.MsgVersion, error) {
nonce := uint64(rand.Int63()) nonce := uint64(rand.Int63())
sentNonces.Add(nonce) sentNonces.Add(nonce)
subnetworkID := p.cfg.Subnetwork subnetworkID := p.cfg.SubnetworkID
// Version message. // Version message.
msg := wire.NewMsgVersion(ourNA, theirNA, nonce, blockNum, subnetworkID) msg := wire.NewMsgVersion(ourNA, theirNA, nonce, blockNum, subnetworkID)
@ -1045,10 +1045,10 @@ func (p *Peer) handleRemoteVersionMsg(msg *wire.MsgVersion) error {
// Disconnect if: // Disconnect if:
// - we are a full node and the outbound connection we've initiated is a partial node // - 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 // - the remote node is partial and our subnetwork doesn't match their subnetwork
isLocalNodeFull := p.cfg.Subnetwork.IsEqual(&wire.SubnetworkSupportsAll) isLocalNodeFull := p.cfg.SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll)
isRemoteNodeFull := msg.Subnetwork.IsEqual(&wire.SubnetworkSupportsAll) isRemoteNodeFull := msg.SubnetworkID.IsEqual(&wire.SubnetworkIDSupportsAll)
if (isLocalNodeFull && !isRemoteNodeFull && !p.inbound) || if (isLocalNodeFull && !isRemoteNodeFull && !p.inbound) ||
(!isRemoteNodeFull && !msg.Subnetwork.IsEqual(p.cfg.Subnetwork)) { (!isRemoteNodeFull && !msg.SubnetworkID.IsEqual(p.cfg.SubnetworkID)) {
return errors.New("incompatible subnetworks") return errors.New("incompatible subnetworks")
} }

12
peer/peer_test.go
View File

@ -229,7 +229,7 @@ func TestPeerConnection(t *testing.T) {
DAGParams: &dagconfig.MainNetParams, DAGParams: &dagconfig.MainNetParams,
ProtocolVersion: wire.RejectVersion, // Configure with older version ProtocolVersion: wire.RejectVersion, // Configure with older version
Services: 0, Services: 0,
Subnetwork: &wire.SubnetworkSupportsAll, SubnetworkID: &wire.SubnetworkIDSupportsAll,
} }
peer2Cfg := &peer.Config{ peer2Cfg := &peer.Config{
Listeners: peer1Cfg.Listeners, Listeners: peer1Cfg.Listeners,
@ -238,7 +238,7 @@ func TestPeerConnection(t *testing.T) {
UserAgentComments: []string{"comment"}, UserAgentComments: []string{"comment"},
DAGParams: &dagconfig.MainNetParams, DAGParams: &dagconfig.MainNetParams,
Services: wire.SFNodeNetwork, Services: wire.SFNodeNetwork,
Subnetwork: &wire.SubnetworkSupportsAll, SubnetworkID: &wire.SubnetworkIDSupportsAll,
} }
wantStats1 := peerStats{ wantStats1 := peerStats{
@ -440,7 +440,7 @@ func TestPeerListeners(t *testing.T) {
UserAgentComments: []string{"comment"}, UserAgentComments: []string{"comment"},
DAGParams: &dagconfig.MainNetParams, DAGParams: &dagconfig.MainNetParams,
Services: wire.SFNodeBloom, Services: wire.SFNodeBloom,
Subnetwork: &wire.SubnetworkSupportsAll, SubnetworkID: &wire.SubnetworkIDSupportsAll,
} }
inConn, outConn := pipe( inConn, outConn := pipe(
&conn{raddr: "10.0.0.1:8333"}, &conn{raddr: "10.0.0.1:8333"},
@ -611,7 +611,7 @@ func TestOutboundPeer(t *testing.T) {
UserAgentComments: []string{"comment"}, UserAgentComments: []string{"comment"},
DAGParams: &dagconfig.MainNetParams, DAGParams: &dagconfig.MainNetParams,
Services: 0, Services: 0,
Subnetwork: &wire.SubnetworkSupportsAll, SubnetworkID: &wire.SubnetworkIDSupportsAll,
} }
r, w := io.Pipe() r, w := io.Pipe()
@ -752,7 +752,7 @@ func TestUnsupportedVersionPeer(t *testing.T) {
UserAgentComments: []string{"comment"}, UserAgentComments: []string{"comment"},
DAGParams: &dagconfig.MainNetParams, DAGParams: &dagconfig.MainNetParams,
Services: 0, Services: 0,
Subnetwork: &wire.SubnetworkSupportsAll, SubnetworkID: &wire.SubnetworkIDSupportsAll,
} }
localNA := wire.NewNetAddressIPPort( localNA := wire.NewNetAddressIPPort(
@ -809,7 +809,7 @@ func TestUnsupportedVersionPeer(t *testing.T) {
} }
// Remote peer writes version message advertising invalid protocol version 1 // Remote peer writes version message advertising invalid protocol version 1
invalidVersionMsg := wire.NewMsgVersion(remoteNA, localNA, 0, 0, &wire.SubnetworkSupportsAll) invalidVersionMsg := wire.NewMsgVersion(remoteNA, localNA, 0, 0, &wire.SubnetworkIDSupportsAll)
invalidVersionMsg.ProtocolVersion = 1 invalidVersionMsg.ProtocolVersion = 1
_, err = wire.WriteMessageN( _, err = wire.WriteMessageN(

2
server/p2p/p2p.go
View File

@ -1816,7 +1816,7 @@ func newPeerConfig(sp *Peer) *peer.Config {
Services: sp.server.services, Services: sp.server.services,
DisableRelayTx: config.MainConfig().BlocksOnly, DisableRelayTx: config.MainConfig().BlocksOnly,
ProtocolVersion: peer.MaxProtocolVersion, ProtocolVersion: peer.MaxProtocolVersion,
Subnetwork: config.MainConfig().Subnetwork, SubnetworkID: config.MainConfig().SubnetworkID,
} }
} }

10
server/rpc/rpcserver.go
View File

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

8
util/block_test.go
View File

@ -362,7 +362,7 @@ var Block100000 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
@ -432,7 +432,7 @@ var Block100000 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
@ -501,7 +501,7 @@ var Block100000 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
@ -558,7 +558,7 @@ var Block100000 = wire.MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkDAGCoin, SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }

2
wire/message_test.go
View File

@ -46,7 +46,7 @@ func TestMessage(t *testing.T) {
addrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8333} addrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8333}
me := NewNetAddress(addrMe, SFNodeNetwork) me := NewNetAddress(addrMe, SFNodeNetwork)
me.Timestamp = time.Time{} // Version message has zero value timestamp. me.Timestamp = time.Time{} // Version message has zero value timestamp.
msgVersion := NewMsgVersion(me, you, 123123, 0, &SubnetworkSupportsAll) msgVersion := NewMsgVersion(me, you, 123123, 0, &SubnetworkIDSupportsAll)
msgVerack := NewMsgVerAck() msgVerack := NewMsgVerAck()
msgGetAddr := NewMsgGetAddr() msgGetAddr := NewMsgGetAddr()

2
wire/msgblock_test.go
View File

@ -533,7 +533,7 @@ var blockOne = MsgBlock{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: SubnetworkDAGCoin, SubnetworkID: SubnetworkIDNative,
}, },
}, },
} }

26
wire/msgtx.go
View File

@ -99,14 +99,14 @@ const (
) )
var ( var (
// SubnetworkSupportsAll is the subnetwork id that is used to signal to peers that you support all subnetworks // SubnetworkIDSupportsAll is the subnetwork ID that is used to signal to peers that you support all subnetworks
SubnetworkSupportsAll = subnetworkid.SubnetworkID{} SubnetworkIDSupportsAll = subnetworkid.SubnetworkID{}
// SubnetworkDAGCoin is the default subnetwork which is used for transactions without related payload data // SubnetworkIDNative is the default subnetwork ID which is used for transactions without related payload data
SubnetworkDAGCoin = subnetworkid.SubnetworkID{1} SubnetworkIDNative = subnetworkid.SubnetworkID{1}
// SubnetworkRegistry is the subnetwork which is used for adding new sub networks to the registry // SubnetworkIDRegistry is the subnetwork ID which is used for adding new sub networks to the registry
SubnetworkRegistry = subnetworkid.SubnetworkID{2} SubnetworkIDRegistry = subnetworkid.SubnetworkID{2}
) )
// scriptFreeList defines a free list of byte slices (up to the maximum number // scriptFreeList defines a free list of byte slices (up to the maximum number
@ -464,12 +464,12 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
return err return err
} }
if msg.SubnetworkID == SubnetworkSupportsAll { if msg.SubnetworkID == SubnetworkIDSupportsAll {
str := fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", msg.SubnetworkID) str := fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", msg.SubnetworkID)
return messageError("MsgTx.BtcDecode", str) return messageError("MsgTx.BtcDecode", str)
} }
if msg.SubnetworkID != SubnetworkDAGCoin { if msg.SubnetworkID != SubnetworkIDNative {
msg.Gas, err = binarySerializer.Uint64(r, littleEndian) msg.Gas, err = binarySerializer.Uint64(r, littleEndian)
if err != nil { if err != nil {
returnScriptBuffers() returnScriptBuffers()
@ -601,8 +601,8 @@ func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
return err return err
} }
if msg.SubnetworkID != SubnetworkDAGCoin { if msg.SubnetworkID != SubnetworkIDNative {
if msg.SubnetworkID == SubnetworkRegistry && msg.Gas != 0 { if msg.SubnetworkID == SubnetworkIDRegistry && msg.Gas != 0 {
str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", msg.SubnetworkID) str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", msg.SubnetworkID)
return messageError("MsgTx.BtcEncode", str) return messageError("MsgTx.BtcEncode", str)
} }
@ -657,7 +657,7 @@ func (msg *MsgTx) SerializeSize() int {
n := 32 + VarIntSerializeSize(uint64(len(msg.TxIn))) + n := 32 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
VarIntSerializeSize(uint64(len(msg.TxOut))) VarIntSerializeSize(uint64(len(msg.TxOut)))
if msg.SubnetworkID != SubnetworkDAGCoin { if msg.SubnetworkID != SubnetworkIDNative {
// Gas 8 bytes + Serialized varint size for the length of the payload // Gas 8 bytes + Serialized varint size for the length of the payload
n += 8 + VarIntSerializeSize(uint64(len(msg.Payload))) n += 8 + VarIntSerializeSize(uint64(len(msg.Payload)))
} }
@ -735,13 +735,13 @@ func NewMsgTx(version int32) *MsgTx {
Version: version, Version: version,
TxIn: make([]*TxIn, 0, defaultTxInOutAlloc), TxIn: make([]*TxIn, 0, defaultTxInOutAlloc),
TxOut: make([]*TxOut, 0, defaultTxInOutAlloc), TxOut: make([]*TxOut, 0, defaultTxInOutAlloc),
SubnetworkID: SubnetworkDAGCoin, SubnetworkID: SubnetworkIDNative,
} }
} }
func newRegistryMsgTx(version int32, gasLimit uint64) *MsgTx { func newRegistryMsgTx(version int32, gasLimit uint64) *MsgTx {
tx := NewMsgTx(version) tx := NewMsgTx(version)
tx.SubnetworkID = SubnetworkRegistry tx.SubnetworkID = SubnetworkIDRegistry
tx.Payload = make([]byte, 8) tx.Payload = make([]byte, 8)
binary.LittleEndian.PutUint64(tx.Payload, gasLimit) binary.LittleEndian.PutUint64(tx.Payload, gasLimit)
return tx return tx

24
wire/msgtx_test.go
View File

@ -569,34 +569,34 @@ func TestTxSerializeErrors(t *testing.T) {
} }
registryTx := NewMsgTx(1) registryTx := NewMsgTx(1)
registryTx.SubnetworkID = SubnetworkRegistry registryTx.SubnetworkID = SubnetworkIDRegistry
registryTx.Gas = 1 registryTx.Gas = 1
w := bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize())) w := bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
err := registryTx.Serialize(w) err := registryTx.Serialize(w)
str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubnetworkRegistry) str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubnetworkIDRegistry)
expectedErr := messageError("MsgTx.BtcEncode", str) expectedErr := messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() { if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err) t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
} }
dagCoinTx := NewMsgTx(1) nativeTx := NewMsgTx(1)
dagCoinTx.Gas = 1 nativeTx.Gas = 1
w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize())) w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
err = dagCoinTx.Serialize(w) err = nativeTx.Serialize(w)
str = fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubnetworkDAGCoin) str = fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubnetworkIDNative)
expectedErr = messageError("MsgTx.BtcEncode", str) expectedErr = messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() { if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err) t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
} }
dagCoinTx.Gas = 0 nativeTx.Gas = 0
dagCoinTx.Payload = []byte{1, 2, 3} nativeTx.Payload = []byte{1, 2, 3}
w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize())) w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
err = dagCoinTx.Serialize(w) err = nativeTx.Serialize(w)
str = fmt.Sprintf("Transactions from subnetwork %v should have <nil> payload", SubnetworkDAGCoin) str = fmt.Sprintf("Transactions from subnetwork %v should have <nil> payload", SubnetworkIDNative)
expectedErr = messageError("MsgTx.BtcEncode", str) expectedErr = messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() { if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err) t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -619,7 +619,7 @@ func TestTxSerializeErrors(t *testing.T) {
var tx MsgTx var tx MsgTx
err = tx.Deserialize(r) err = tx.Deserialize(r)
str = fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", SubnetworkSupportsAll) str = fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", SubnetworkIDSupportsAll)
expectedErr = messageError("MsgTx.BtcDecode", str) expectedErr = messageError("MsgTx.BtcDecode", str)
if err == nil || err.Error() != expectedErr.Error() { if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err) t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -870,7 +870,7 @@ var multiTx = &MsgTx{
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: SubnetworkDAGCoin, SubnetworkID: SubnetworkIDNative,
} }
// multiTxEncoded is the wire encoded bytes for multiTx using protocol version // multiTxEncoded is the wire encoded bytes for multiTx using protocol version

8
wire/msgversion.go
View File

@ -58,7 +58,7 @@ type MsgVersion struct {
DisableRelayTx bool DisableRelayTx bool
// The subnetwork of the generator of the version message. // The subnetwork of the generator of the version message.
Subnetwork subnetworkid.SubnetworkID SubnetworkID subnetworkid.SubnetworkID
} }
// HasService returns whether the specified service is supported by the peer // HasService returns whether the specified service is supported by the peer
@ -93,7 +93,7 @@ func (msg *MsgVersion) BtcDecode(r io.Reader, pver uint32) error {
return err return err
} }
err = readElement(buf, &msg.Subnetwork) err = readElement(buf, &msg.SubnetworkID)
if err != nil { if err != nil {
return err return err
} }
@ -170,7 +170,7 @@ func (msg *MsgVersion) BtcEncode(w io.Writer, pver uint32) error {
return err return err
} }
err = writeElement(w, msg.Subnetwork) err = writeElement(w, msg.SubnetworkID)
if err != nil { if err != nil {
return err return err
} }
@ -249,7 +249,7 @@ func NewMsgVersion(me *NetAddress, you *NetAddress, nonce uint64,
UserAgent: DefaultUserAgent, UserAgent: DefaultUserAgent,
LastBlock: lastBlock, LastBlock: lastBlock,
DisableRelayTx: false, DisableRelayTx: false,
Subnetwork: *subnetworkID, SubnetworkID: *subnetworkID,
} }
} }

8
wire/msgversion_test.go
View File

@ -32,7 +32,7 @@ func TestVersion(t *testing.T) {
} }
// Ensure we get the correct data back out. // Ensure we get the correct data back out.
msg := NewMsgVersion(me, you, nonce, lastBlock, &SubnetworkSupportsAll) msg := NewMsgVersion(me, you, nonce, lastBlock, &SubnetworkIDSupportsAll)
if msg.ProtocolVersion != int32(pver) { if msg.ProtocolVersion != int32(pver) {
t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v", t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
msg.ProtocolVersion, pver) msg.ProtocolVersion, pver)
@ -289,7 +289,7 @@ func TestVersionWireErrors(t *testing.T) {
{baseVersion, baseVersionEncoded, pver, 4, io.ErrShortWrite, io.EOF}, {baseVersion, baseVersionEncoded, pver, 4, io.ErrShortWrite, io.EOF},
// Force error in timestamp. // Force error in timestamp.
{baseVersion, baseVersionEncoded, pver, 12, io.ErrShortWrite, io.EOF}, {baseVersion, baseVersionEncoded, pver, 12, io.ErrShortWrite, io.EOF},
// Force error in subnetwork. // Force error in subnetworkID.
{baseVersion, baseVersionEncoded, pver, 20, io.ErrShortWrite, io.EOF}, {baseVersion, baseVersionEncoded, pver, 20, io.ErrShortWrite, io.EOF},
// Force error in remote address. // Force error in remote address.
{baseVersion, baseVersionEncoded, pver, 40, io.ErrShortWrite, io.EOF}, {baseVersion, baseVersionEncoded, pver, 40, io.ErrShortWrite, io.EOF},
@ -487,7 +487,7 @@ var baseVersionEncoded = []byte{
0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // 64-bit Timestamp 0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // 64-bit Timestamp
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, // Subnetwork SupportsAll 0x00, 0x00, 0x00, 0x00, // SubnetworkIDSupportsAll
// AddrYou -- No timestamp for NetAddress in version message // AddrYou -- No timestamp for NetAddress in version message
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -536,7 +536,7 @@ var baseVersionBIP0037Encoded = []byte{
0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // 64-bit Timestamp 0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // 64-bit Timestamp
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, // Subnetwork SupportsAll 0x00, 0x00, 0x00, 0x00, // SubnetworkIDSupportsAll
// AddrYou -- No timestamp for NetAddress in version message // AddrYou -- No timestamp for NetAddress in version message
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,