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

[DEV-347] Normalize the way 'subnetwork' is capitalized (#161)

Browse Source
This commit is contained in:
Svarog 2019-01-13 18:00:34 +02:00 committed by stasatdaglabs
parent 6b55950901
commit e3994cddac
24 changed files with 245 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
blockdag/dag.go
View File

@ -96,9 +96,9 @@ type BlockDAG struct {
// virtual tracks the current tips.
virtual *virtualBlock
// lastSubNetworkID holds the last registered sub-network ID in the DAG.
// Note that it is NOT the total amount of registered (or active) sub-networks.
lastSubNetworkID uint64
// 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
// protected by a combination of the chain lock and the orphan lock.
@ -567,10 +567,10 @@ func (dag *BlockDAG) connectBlock(node *blockNode, block *util.Block, fastAdd bo
return err
}
// Scan all accepted transactions and register any sub-network registry
// transaction. If any sub-network registry transaction is not well-formed,
// Scan all accepted transactions and register any subnetwork registry
// transaction. If any subnetwork registry transaction is not well-formed,
// fail the entire block.
err = registerSubNetworks(dbTx, acceptedTxsData)
err = registerSubnetworks(dbTx, acceptedTxsData)
if err != nil {
return err
}

32
blockdag/dagio.go
View File

@ -53,17 +53,17 @@ var (
// unspent transaction output set.
utxoSetBucketName = []byte("utxoset")
// pendingSubNetworksBucketName is the name of the db bucket used to store the
// pending sub-networks.
pendingSubNetworksBucketName = []byte("pendingsubnetworks")
// 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 sub-networks.
registeredSubNetworkTxsBucketName = []byte("registeredsubnetworktxs")
// 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
// sub-network registry.
subNetworksBucketName = []byte("subnetworks")
// subnetworksBucketName is the name of the db bucket used to store the
// subnetwork registry.
subnetworksBucketName = []byte("subnetworks")
// byteOrder is the preferred byte order used for serializing numeric
// fields for storage in the database.
@ -670,7 +670,7 @@ func dbFetchHeightByHash(dbTx database.Tx, hash *daghash.Hash) (int32, error) {
type dagState struct {
TipHashes []daghash.Hash
LastFinalityPoint daghash.Hash
LastSubNetworkID uint64
LastSubnetworkID uint64
}
// serializeDAGState returns the serialization of the DAG state.
@ -776,21 +776,21 @@ func (dag *BlockDAG) createDAGState() error {
return err
}
// Create the bucket that houses the pending sub-networks.
_, err = meta.CreateBucket(pendingSubNetworksBucketName)
// Create the bucket that houses the pending subnetworks.
_, err = meta.CreateBucket(pendingSubnetworksBucketName)
if err != nil {
return err
}
// Create the bucket that houses the registered sub-networks to
// Create the bucket that houses the registered subnetworks to
// their registry transactions index.
_, err = meta.CreateBucket(registeredSubNetworkTxsBucketName)
_, err = meta.CreateBucket(registeredSubnetworkTxsBucketName)
if err != nil {
return err
}
// Create the bucket that houses the registered sub-networks.
_, err = meta.CreateBucket(subNetworksBucketName)
// Create the bucket that houses the registered subnetworks.
_, err = meta.CreateBucket(subnetworksBucketName)
if err != nil {
return err
}

8
blockdag/dagio_test.go
View File

@ -547,18 +547,18 @@ func TestDAGStateSerialization(t *testing.T) {
state: &dagState{
TipHashes: []daghash.Hash{*newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")},
LastFinalityPoint: *newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"),
LastSubNetworkID: 123456,
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],\"LastSubnetworkID\":123456}"),
},
{
name: "block 1",
state: &dagState{
TipHashes: []daghash.Hash{*newHashFromStr("00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048")},
LastFinalityPoint: *newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"),
LastSubNetworkID: 684321,
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],\"LastSubnetworkID\":684321}"),
},
}

8
blockdag/error.go
View File

@ -213,20 +213,20 @@ const (
ErrFinality
// ErrTransactionsNotSorted indicates that transactions in block are not
// sorted by sub-network
// sorted by subnetwork
ErrTransactionsNotSorted
// ErrInvalidGas transaction wants to use more GAS than allowed
// by subnetwork
ErrInvalidGas
// ErrInvalidPayload transaction includes a payload in a sub-network that doesn't allow
// ErrInvalidPayload transaction includes a payload in a subnetwork that doesn't allow
// a Payload
ErrInvalidPayload
// ErrSubNetwork indicates that a block doesn't adhere to the sub-network
// ErrSubnetwork indicates that a block doesn't adhere to the subnetwork
// registry rules
ErrSubNetworkRegistry
ErrSubnetworkRegistry
)
// Map of ErrorCode values back to their constant names for pretty printing.

2
blockdag/fullblocktests/params.go
View File

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

16
blockdag/indexers/txindex_test.go
View File

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

116
blockdag/subnetworks.go
View File

@ -11,44 +11,44 @@ import (
"github.com/daglabs/btcd/wire"
)
// registerSubNetworks scans a list of accepted transactions, singles out
// sub-network registry transactions, validates them, and registers a new
// sub-network based on it.
// registerSubnetworks scans a list of accepted transactions, singles out
// subnetwork registry transactions, validates them, and registers a new
// subnetwork based on it.
// This function returns an error if one or more transactions are invalid
func registerSubNetworks(dbTx database.Tx, txs []*TxWithBlockHash) error {
validSubNetworkRegistryTxs := make([]*wire.MsgTx, 0)
func registerSubnetworks(dbTx database.Tx, txs []*TxWithBlockHash) error {
validSubnetworkRegistryTxs := make([]*wire.MsgTx, 0)
for _, txData := range txs {
tx := txData.Tx.MsgTx()
if tx.SubNetworkID == wire.SubNetworkRegistry {
err := validateSubNetworkRegistryTransaction(tx)
if tx.SubnetworkID == wire.SubnetworkRegistry {
err := validateSubnetworkRegistryTransaction(tx)
if err != nil {
return err
}
validSubNetworkRegistryTxs = append(validSubNetworkRegistryTxs, tx)
validSubnetworkRegistryTxs = append(validSubnetworkRegistryTxs, tx)
}
if subnetworkid.Less(&wire.SubNetworkRegistry, &tx.SubNetworkID) {
// Transactions are ordered by sub-network, so we can safely assume
// that the rest of the transactions will not be sub-network registry
if subnetworkid.Less(&wire.SubnetworkRegistry, &tx.SubnetworkID) {
// Transactions are ordered by subnetwork, so we can safely assume
// that the rest of the transactions will not be subnetwork registry
// transactions.
break
}
}
for _, registryTx := range validSubNetworkRegistryTxs {
subNetworkID, err := txToSubNetworkID(registryTx)
for _, registryTx := range validSubnetworkRegistryTxs {
subnetworkID, err := txToSubnetworkID(registryTx)
if err != nil {
return err
}
sNet, err := dbGetSubNetwork(dbTx, subNetworkID)
sNet, err := dbGetSubnetwork(dbTx, subnetworkID)
if err != nil {
return err
}
if sNet == nil {
createdSubNetwork := newSubNetwork(registryTx)
err := dbRegisterSubNetwork(dbTx, subNetworkID, createdSubNetwork)
createdSubnetwork := newSubnetwork(registryTx)
err := dbRegisterSubnetwork(dbTx, subnetworkID, createdSubnetwork)
if err != nil {
return fmt.Errorf("failed registering sub-network"+
return fmt.Errorf("failed registering subnetwork"+
"for tx '%s': %s", registryTx.TxHash(), err)
}
}
@ -57,125 +57,125 @@ func registerSubNetworks(dbTx database.Tx, txs []*TxWithBlockHash) error {
return nil
}
// validateSubNetworkRegistryTransaction makes sure that a given sub-network registry
// validateSubnetworkRegistryTransaction makes sure that a given subnetwork registry
// transaction is valid. Such a transaction is valid iff:
// - Its entire payload is a uint64 (8 bytes)
func validateSubNetworkRegistryTransaction(tx *wire.MsgTx) error {
func validateSubnetworkRegistryTransaction(tx *wire.MsgTx) error {
if len(tx.Payload) != 8 {
return ruleError(ErrSubNetworkRegistry, fmt.Sprintf("validation failed: subnetwork registry"+
return ruleError(ErrSubnetworkRegistry, fmt.Sprintf("validation failed: subnetwork registry"+
"tx '%s' has an invalid payload", tx.TxHash()))
}
return nil
}
// txToSubNetworkID creates a sub-network ID from a sub-network registry transaction
func txToSubNetworkID(tx *wire.MsgTx) (*subnetworkid.SubNetworkID, error) {
// txToSubnetworkID creates a subnetwork ID from a subnetwork registry transaction
func txToSubnetworkID(tx *wire.MsgTx) (*subnetworkid.SubnetworkID, error) {
txHash := tx.TxHash()
return subnetworkid.New(util.Hash160(txHash[:]))
}
// subNetwork returns a registered sub-network. If the sub-network does not exist
// subnetwork returns a registered subnetwork. If the subnetwork does not exist
// this method returns an error.
func (dag *BlockDAG) subNetwork(subNetworkID *subnetworkid.SubNetworkID) (*subNetwork, error) {
var sNet *subNetwork
func (dag *BlockDAG) subnetwork(subnetworkID *subnetworkid.SubnetworkID) (*subnetwork, error) {
var sNet *subnetwork
var err error
dbErr := dag.db.View(func(dbTx database.Tx) error {
sNet, err = dbGetSubNetwork(dbTx, subNetworkID)
sNet, err = dbGetSubnetwork(dbTx, subnetworkID)
return nil
})
if dbErr != nil {
return nil, fmt.Errorf("could not retrieve sub-network '%d': %s", subNetworkID, dbErr)
return nil, fmt.Errorf("could not retrieve subnetwork '%d': %s", subnetworkID, dbErr)
}
if err != nil {
return nil, fmt.Errorf("could not retrieve sub-network '%d': %s", subNetworkID, err)
return nil, fmt.Errorf("could not retrieve subnetwork '%d': %s", subnetworkID, err)
}
return sNet, nil
}
// GasLimit returns the gas limit of a registered sub-network. If the sub-network does not
// GasLimit returns the gas limit of a registered subnetwork. If the subnetwork does not
// exist this method returns an error.
func (dag *BlockDAG) GasLimit(subNetworkID *subnetworkid.SubNetworkID) (uint64, error) {
sNet, err := dag.subNetwork(subNetworkID)
func (dag *BlockDAG) GasLimit(subnetworkID *subnetworkid.SubnetworkID) (uint64, error) {
sNet, err := dag.subnetwork(subnetworkID)
if err != nil {
return 0, err
}
if sNet == nil {
return 0, fmt.Errorf("sub-network '%s' not found", subNetworkID)
return 0, fmt.Errorf("subnetwork '%s' not found", subnetworkID)
}
return sNet.gasLimit, nil
}
// dbRegisterSubNetwork stores mappings from ID of the sub-network to the sub-network data.
func dbRegisterSubNetwork(dbTx database.Tx, subNetworkID *subnetworkid.SubNetworkID, network *subNetwork) error {
// Serialize the sub-network
serializedSubNetwork, err := serializeSubNetwork(network)
// dbRegisterSubnetwork stores mappings from ID of the subnetwork to the subnetwork data.
func dbRegisterSubnetwork(dbTx database.Tx, subnetworkID *subnetworkid.SubnetworkID, network *subnetwork) error {
// Serialize the subnetwork
serializedSubnetwork, err := serializeSubnetwork(network)
if err != nil {
return fmt.Errorf("failed to serialize sub-netowrk '%s': %s", subNetworkID, err)
return fmt.Errorf("failed to serialize sub-netowrk '%s': %s", subnetworkID, err)
}
// Store the sub-network
subNetworksBucket := dbTx.Metadata().Bucket(subNetworksBucketName)
err = subNetworksBucket.Put(subNetworkID[:], serializedSubNetwork)
// Store the subnetwork
subnetworksBucket := dbTx.Metadata().Bucket(subnetworksBucketName)
err = subnetworksBucket.Put(subnetworkID[:], serializedSubnetwork)
if err != nil {
return fmt.Errorf("failed to write sub-netowrk '%s': %s", subNetworkID, err)
return fmt.Errorf("failed to write sub-netowrk '%s': %s", subnetworkID, err)
}
return nil
}
// dbGetSubNetwork returns the sub-network associated with subNetworkID or nil if the sub-network was not found.
func dbGetSubNetwork(dbTx database.Tx, subNetworkID *subnetworkid.SubNetworkID) (*subNetwork, error) {
bucket := dbTx.Metadata().Bucket(subNetworksBucketName)
serializedSubNetwork := bucket.Get(subNetworkID[:])
if serializedSubNetwork == nil {
// dbGetSubnetwork returns the subnetwork associated with subnetworkID or nil if the subnetwork was not found.
func dbGetSubnetwork(dbTx database.Tx, subnetworkID *subnetworkid.SubnetworkID) (*subnetwork, error) {
bucket := dbTx.Metadata().Bucket(subnetworksBucketName)
serializedSubnetwork := bucket.Get(subnetworkID[:])
if serializedSubnetwork == nil {
return nil, nil
}
return deserializeSubNetwork(serializedSubNetwork)
return deserializeSubnetwork(serializedSubnetwork)
}
type subNetwork struct {
type subnetwork struct {
gasLimit uint64
}
func newSubNetwork(tx *wire.MsgTx) *subNetwork {
func newSubnetwork(tx *wire.MsgTx) *subnetwork {
gasLimit := binary.LittleEndian.Uint64(tx.Payload[:8])
return &subNetwork{
return &subnetwork{
gasLimit: gasLimit,
}
}
// serializeSubNetwork serializes a subNetwork into the following binary format:
// serializeSubnetwork serializes a subnetwork into the following binary format:
// | gasLimit (8 bytes) |
func serializeSubNetwork(sNet *subNetwork) ([]byte, error) {
func serializeSubnetwork(sNet *subnetwork) ([]byte, error) {
serializedSNet := bytes.NewBuffer(make([]byte, 0, 8))
// Write the gas limit
err := binary.Write(serializedSNet, byteOrder, sNet.gasLimit)
if err != nil {
return nil, fmt.Errorf("failed to serialize sub-network: %s", err)
return nil, fmt.Errorf("failed to serialize subnetwork: %s", err)
}
return serializedSNet.Bytes(), nil
}
// deserializeSubNetwork deserializes a byte slice into a subNetwork.
// See serializeSubNetwork for the binary format.
func deserializeSubNetwork(serializedSNetBytes []byte) (*subNetwork, error) {
// deserializeSubnetwork deserializes a byte slice into a subnetwork.
// See serializeSubnetwork for the binary format.
func deserializeSubnetwork(serializedSNetBytes []byte) (*subnetwork, error) {
serializedSNet := bytes.NewBuffer(serializedSNetBytes)
// Read the gas limit
var gasLimit uint64
err := binary.Read(serializedSNet, byteOrder, &gasLimit)
if err != nil {
return nil, fmt.Errorf("failed to deserialize sub-network: %s", err)
return nil, fmt.Errorf("failed to deserialize subnetwork: %s", err)
}
return &subNetwork{
return &subnetwork{
gasLimit: gasLimit,
}, nil
}

24
blockdag/subnetworks_test.go
View File

@ -7,11 +7,11 @@ import (
"github.com/daglabs/btcd/dagconfig"
)
// TestSubNetworkRegistry tests the full sub-network registry flow
func TestSubNetworkRegistry(t *testing.T) {
// TestSubnetworkRegistry tests the full subnetwork registry flow
func TestSubnetworkRegistry(t *testing.T) {
params := dagconfig.SimNetParams
params.K = 1
dag, teardownFunc, err := DAGSetup("TestSubNetworkRegistry", Config{
dag, teardownFunc, err := DAGSetup("TestSubnetworkRegistry", Config{
DAGParams: &params,
})
if err != nil {
@ -20,11 +20,11 @@ func TestSubNetworkRegistry(t *testing.T) {
defer teardownFunc()
gasLimit := uint64(12345)
subNetworkID, err := RegisterSubNetworkForTest(dag, gasLimit)
subnetworkID, err := RegisterSubnetworkForTest(dag, gasLimit)
if err != nil {
t.Fatalf("could not register network: %s", err)
}
limit, err := dag.GasLimit(subNetworkID)
limit, err := dag.GasLimit(subnetworkID)
if err != nil {
t.Fatalf("could not retrieve gas limit: %s", err)
}
@ -33,22 +33,22 @@ func TestSubNetworkRegistry(t *testing.T) {
}
}
func TestSerializeSubNetwork(t *testing.T) {
sNet := &subNetwork{
func TestSerializeSubnetwork(t *testing.T) {
sNet := &subnetwork{
gasLimit: 1000,
}
serializedSNet, err := serializeSubNetwork(sNet)
serializedSNet, err := serializeSubnetwork(sNet)
if err != nil {
t.Fatalf("sub-network serialization unexpectedly failed: %s", err)
t.Fatalf("subnetwork serialization unexpectedly failed: %s", err)
}
deserializedSNet, err := deserializeSubNetwork(serializedSNet)
deserializedSNet, err := deserializeSubnetwork(serializedSNet)
if err != nil {
t.Fatalf("sub-network deserialization unexpectedly failed: %s", err)
t.Fatalf("subnetwork deserialization unexpectedly failed: %s", err)
}
if !reflect.DeepEqual(sNet, deserializedSNet) {
t.Errorf("original sub-network and deserialized sub-network are not equal")
t.Errorf("original subnetwork and deserialized subnetwork are not equal")
}
}

22
blockdag/test_utils.go
View File

@ -106,7 +106,7 @@ func DAGSetup(dbName string, config Config) (*BlockDAG, func(), error) {
var OpTrueScript = []byte{txscript.OpTrue}
type txSubnetworkData struct {
subnetworkID subnetworkid.SubNetworkID
subnetworkID subnetworkid.SubnetworkID
Gas uint64
Payload []byte
}
@ -129,11 +129,11 @@ func createTxForTest(numInputs uint32, numOutputs uint32, outputValue uint64, su
}
if subnetworkData != nil {
tx.SubNetworkID = subnetworkData.subnetworkID
tx.SubnetworkID = subnetworkData.subnetworkID
tx.Gas = subnetworkData.Gas
tx.Payload = subnetworkData.Payload
} else {
tx.SubNetworkID = wire.SubNetworkDAGCoin
tx.SubnetworkID = wire.SubnetworkDAGCoin
tx.Gas = 0
tx.Payload = []byte{}
}
@ -180,8 +180,8 @@ func createCoinbaseTxForTest(blockHeight int32, numOutputs uint32, extraNonce in
return tx, nil
}
// RegisterSubNetworkForTest is used to register network on DAG with specified gas limit
func RegisterSubNetworkForTest(dag *BlockDAG, gasLimit uint64) (*subnetworkid.SubNetworkID, error) {
// RegisterSubnetworkForTest is used to register network on DAG with specified gas limit
func RegisterSubnetworkForTest(dag *BlockDAG, gasLimit uint64) (*subnetworkid.SubnetworkID, error) {
blockTime := time.Unix(dag.selectedTip().timestamp, 0)
extraNonce := int64(0)
@ -227,9 +227,9 @@ func RegisterSubNetworkForTest(dag *BlockDAG, gasLimit uint64) (*subnetworkid.Su
currentNode := dag.selectedTip()
// Create a block with a valid sub-network registry transaction
// Create a block with a valid subnetwork registry transaction
registryTx := wire.NewMsgTx(wire.TxVersion)
registryTx.SubNetworkID = wire.SubNetworkRegistry
registryTx.SubnetworkID = wire.SubnetworkRegistry
registryTx.Payload = make([]byte, 8)
binary.LittleEndian.PutUint64(registryTx.Payload, gasLimit)
@ -243,10 +243,10 @@ func RegisterSubNetworkForTest(dag *BlockDAG, gasLimit uint64) (*subnetworkid.Su
return nil, fmt.Errorf("could not add registry block to DAG: %s", err)
}
// Build a sub-network ID from the registry transaction
subNetworkID, err := txToSubNetworkID(registryTx)
// Build a subnetwork ID from the registry transaction
subnetworkID, err := txToSubnetworkID(registryTx)
if err != nil {
return nil, fmt.Errorf("could not build sub-network ID: %s", err)
return nil, fmt.Errorf("could not build subnetwork ID: %s", err)
}
return subNetworkID, nil
return subnetworkID, nil
}

18
blockdag/validate.go
View File

@ -262,27 +262,27 @@ func CheckTransactionSanity(tx *util.Tx) error {
}
}
// Transactions in native and SubNetworkRegistry SubNetworks must have Gas = 0
if (msgTx.SubNetworkID == wire.SubNetworkDAGCoin ||
msgTx.SubNetworkID == wire.SubNetworkRegistry) &&
// Transactions in native and SubnetworkRegistry Subnetworks must have Gas = 0
if (msgTx.SubnetworkID == wire.SubnetworkDAGCoin ||
msgTx.SubnetworkID == wire.SubnetworkRegistry) &&
msgTx.Gas > 0 {
return ruleError(ErrInvalidGas, "transaction in the native or "+
"registry sub-networks has gas > 0 ")
"registry subnetworks has gas > 0 ")
}
if msgTx.SubNetworkID == wire.SubNetworkDAGCoin &&
if msgTx.SubnetworkID == wire.SubnetworkDAGCoin &&
len(msgTx.Payload) > 0 {
return ruleError(ErrInvalidPayload,
"transaction in the native sub-network includes a payload")
"transaction in the native subnetwork includes a payload")
}
if msgTx.SubNetworkID == wire.SubNetworkRegistry &&
if msgTx.SubnetworkID == wire.SubnetworkRegistry &&
len(msgTx.Payload) != 8 {
return ruleError(ErrInvalidPayload,
"transaction in the sub-network registry include a payload "+
"transaction in the subnetwork registry include a payload "+
"with length != 8 bytes")
}
@ -516,7 +516,7 @@ func checkBlockSanity(block *util.Block, powLimit *big.Int, timeSource MedianTim
"index %d", i+1)
return ruleError(ErrMultipleCoinbases, str)
}
if subnetworkid.Less(&tx.MsgTx().SubNetworkID, &transactions[i].MsgTx().SubNetworkID) {
if subnetworkid.Less(&tx.MsgTx().SubnetworkID, &transactions[i].MsgTx().SubnetworkID) {
return ruleError(ErrTransactionsNotSorted, "transactions must be sorted by subnetwork")
}
}

20
blockdag/validate_test.go
View File

@ -753,7 +753,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
{
Version: 1,
@ -822,7 +822,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
{
Version: 1,
@ -879,7 +879,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
},
}
@ -1015,7 +1015,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: subnetworkid.SubNetworkID{11},
SubnetworkID: subnetworkid.SubnetworkID{11},
},
{
Version: 1,
@ -1084,7 +1084,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
{
Version: 1,
@ -1141,7 +1141,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
},
}
@ -1166,16 +1166,16 @@ func TestCheckTransactionSanity(t *testing.T) {
func(tx *wire.MsgTx) { tx.TxIn[1].PreviousOutPoint.Index = 0 },
ruleError(ErrDuplicateTxInputs, "")},
{"non-zero gas in DAGCoin", 1, 1, 0,
&txSubnetworkData{wire.SubNetworkDAGCoin, 1, []byte{}},
&txSubnetworkData{wire.SubnetworkDAGCoin, 1, []byte{}},
nil, ruleError(ErrInvalidGas, "")},
{"non-zero gas in subnetwork registry", 1, 1, 0,
&txSubnetworkData{wire.SubNetworkRegistry, 1, []byte{}},
&txSubnetworkData{wire.SubnetworkRegistry, 1, []byte{}},
nil, ruleError(ErrInvalidGas, "")},
{"non-zero payload in DAGCoin", 1, 1, 0,
&txSubnetworkData{wire.SubNetworkDAGCoin, 0, []byte{1}},
&txSubnetworkData{wire.SubnetworkDAGCoin, 0, []byte{1}},
nil, ruleError(ErrInvalidPayload, "")},
{"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.SubnetworkRegistry, 0, []byte{1, 2, 3, 4, 5, 6, 7}},
nil, ruleError(ErrInvalidPayload, "")},
}

10
config/config.go
View File

@ -166,7 +166,7 @@ type configFlags struct {
DropAddrIndex bool `long:"dropaddrindex" description:"Deletes the address-based transaction index from the database on start up and then exits."`
RelayNonStd bool `long:"relaynonstd" description:"Relay non-standard transactions regardless of the default settings for the active network."`
RejectNonStd bool `long:"rejectnonstd" description:"Reject non-standard transactions regardless of the default settings for the active network."`
SubNetwork string `string:"subnetwork" description:"If subnetwork != 0, than node will request and process only payloads from specified subnetwork. And if subnetwork is 0, than payloads of all subnetworks are processed. Subnetworks 3 through 255 are reserved for future use and are currently not allowed."`
Subnetwork string `string:"subnetwork" description:"If subnetwork != 0, than node will request and process only payloads from specified subnetwork. And if subnetwork is 0, than payloads of all subnetworks are processed. Subnetworks 3 through 255 are reserved for future use and are currently not allowed."`
}
// Config defines the configuration options for btcd.
@ -181,7 +181,7 @@ type Config struct {
MiningAddrs []util.Address
MinRelayTxFee util.Amount
Whitelists []*net.IPNet
SubNetwork *subnetworkid.SubNetworkID
Subnetwork *subnetworkid.SubnetworkID
}
// serviceOptions defines the configuration options for the daemon as a service on
@ -753,15 +753,15 @@ func loadConfig() (*Config, []string, error) {
cfg.MiningAddrs = append(cfg.MiningAddrs, addr)
}
if cfg.configFlags.SubNetwork != "" {
cfg.SubNetwork, err = subnetworkid.NewFromStr(cfg.configFlags.SubNetwork)
if cfg.configFlags.Subnetwork != "" {
cfg.Subnetwork, err = subnetworkid.NewFromStr(cfg.configFlags.Subnetwork)
if err != nil {
return nil, nil, err
}
}
// Check that 'generate' and 'subnetwork' flags do not conflict
if cfg.Generate && *cfg.SubNetwork != wire.SubNetworkSupportsAll {
if cfg.Generate && *cfg.Subnetwork != wire.SubnetworkSupportsAll {
str := "%s: both generate flag and subnetwork filtering are set "
err := fmt.Errorf(str, funcName)
fmt.Fprintln(os.Stderr, err)

6
config/config_test.go
View File

@ -76,8 +76,8 @@ 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.SubNetworkSupportsAll != zero {
t.Errorf("wire.SubNetworkSupportsAll value was changed from 0, therefore you probably need to update the help text for SubNetwork")
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 {
t.Errorf("wire.SubnetworkSupportsAll value was changed from 0, therefore you probably need to update the help text for Subnetwork")
}
}

2
dagconfig/genesis.go
View File

@ -54,7 +54,7 @@ var genesisCoinbaseTx = wire.MsgTx{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
}
// 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.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
}
var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.

6
mempool/mempool.go
View File

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

24
mempool/mempool_test.go
View File

@ -156,11 +156,11 @@ func (p *poolHarness) CreateCoinbaseTx(blockHeight int32, numOutputs uint32) (*u
return util.NewTx(tx), nil
}
// CreateSignedTxForSubNetwork creates a new signed transaction that consumes the provided
// CreateSignedTxForSubnetwork creates a new signed transaction that consumes the provided
// inputs and generates the provided number of outputs by evenly splitting the
// 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) CreateSignedTxForSubNetwork(inputs []spendableOutpoint, numOutputs uint32, subNetworkID *subnetworkid.SubNetworkID, gas uint64) (*util.Tx, error) {
func (p *poolHarness) CreateSignedTxForSubnetwork(inputs []spendableOutpoint, numOutputs uint32, subnetworkID *subnetworkid.SubnetworkID, gas uint64) (*util.Tx, error) {
// Calculate the total input amount and split it amongst the requested
// number of outputs.
var totalInput util.Amount
@ -171,7 +171,7 @@ func (p *poolHarness) CreateSignedTxForSubNetwork(inputs []spendableOutpoint, nu
remainder := uint64(totalInput) - amountPerOutput*uint64(numOutputs)
tx := wire.NewMsgTx(wire.TxVersion)
tx.SubNetworkID = *subNetworkID
tx.SubnetworkID = *subnetworkID
tx.Gas = gas
for _, input := range inputs {
tx.AddTxIn(&wire.TxIn{
@ -211,7 +211,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.SubNetworkDAGCoin, 0)
return p.CreateSignedTxForSubnetwork(inputs, numOutputs, &wire.SubnetworkDAGCoin, 0)
}
// CreateTxChain creates a chain of zero-fee transactions (each subsequent
@ -610,7 +610,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: p2shPKScript,
}},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
})
harness.txPool.mpUTXOSet.AddTx(p2shTx.MsgTx(), curHeight+1)
@ -626,7 +626,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: dummyPkScript,
}},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
})
_, err = harness.txPool.ProcessTransaction(nonStdSigScriptTx, true, false, 0)
if err == nil {
@ -671,7 +671,7 @@ func TestProcessTransaction(t *testing.T) {
}},
TxOut: []*wire.TxOut{},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
})
_, err = harness.txPool.ProcessTransaction(noOutsTx, true, false, 0)
if err == nil {
@ -748,7 +748,7 @@ func TestProcessTransaction(t *testing.T) {
PkScript: dummyPkScript,
}},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
})
_, err = harness.txPool.ProcessTransaction(tx, true, false, 0)
fmt.Println(err)
@ -1830,7 +1830,7 @@ var dummyBlock = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
},
}
@ -1844,13 +1844,13 @@ func TestTransactionGas(t *testing.T) {
// tc := &testContext{t, harness}
const gasLimit = 10000
subNetworkID, err := blockdag.RegisterSubNetworkForTest(harness.txPool.cfg.DAG, gasLimit)
subnetworkID, err := blockdag.RegisterSubnetworkForTest(harness.txPool.cfg.DAG, gasLimit)
if err != nil {
t.Fatalf("unable to register network: %v", err)
}
// Create valid transaction
tx, err := harness.CreateSignedTxForSubNetwork(spendableOuts[:1], 1, subNetworkID, gasLimit)
tx, err := harness.CreateSignedTxForSubnetwork(spendableOuts[:1], 1, subnetworkID, gasLimit)
if err != nil {
t.Fatalf("unable to create transaction: %v", err)
}
@ -1860,7 +1860,7 @@ func TestTransactionGas(t *testing.T) {
}
// Create invalid transaction
tx, err = harness.CreateSignedTxForSubNetwork(spendableOuts[1:], 1, subNetworkID, gasLimit+1)
tx, err = harness.CreateSignedTxForSubnetwork(spendableOuts[1:], 1, subnetworkID, gasLimit+1)
if err != nil {
t.Fatalf("unable to create transaction: %v", err)
}

20
mining/mining.go
View File

@ -476,7 +476,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
totalFees := uint64(0)
// Create map of GAS usage per subnetwork
gasUsageMap := make(map[subnetworkid.SubNetworkID]uint64)
gasUsageMap := make(map[subnetworkid.SubnetworkID]uint64)
// Choose which transactions make it into the block.
for priorityQueue.Len() > 0 {
@ -485,24 +485,24 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
prioItem := heap.Pop(priorityQueue).(*txPrioItem)
tx := prioItem.tx
if tx.MsgTx().SubNetworkID != wire.SubNetworkDAGCoin {
subNetwork := tx.MsgTx().SubNetworkID
gasUsage, ok := gasUsageMap[subNetwork]
if tx.MsgTx().SubnetworkID != wire.SubnetworkDAGCoin {
subnetwork := tx.MsgTx().SubnetworkID
gasUsage, ok := gasUsageMap[subnetwork]
if !ok {
gasUsage = 0
}
gasLimit, err := g.dag.GasLimit(&subNetwork)
gasLimit, err := g.dag.GasLimit(&subnetwork)
if err != nil {
log.Errorf("Cannot get GAS limit for subNetwork %v", subNetwork)
log.Errorf("Cannot get GAS limit for subnetwork %v", subnetwork)
continue
}
txGas := tx.MsgTx().Gas
if gasLimit-gasUsage < txGas {
log.Tracef("Transaction %v (GAS=%v) ignored because gas overusage (GASUsage=%v) in subNetwork %v (GASLimit=%v)",
tx.MsgTx().TxHash, txGas, gasUsage, subNetwork, gasLimit)
log.Tracef("Transaction %v (GAS=%v) ignored because gas overusage (GASUsage=%v) in subnetwork %v (GASLimit=%v)",
tx.MsgTx().TxHash, txGas, gasUsage, subnetwork, gasLimit)
continue
}
gasUsageMap[subNetwork] = gasUsage + txGas
gasUsageMap[subnetwork] = gasUsage + txGas
}
// Enforce maximum block size. Also check for overflow.
@ -646,7 +646,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
// Sort transactions by subnetwork ID before building Merkle tree
sort.Slice(blockTxns, func(i, j int) bool {
return subnetworkid.Less(&blockTxns[i].MsgTx().SubNetworkID, &blockTxns[j].MsgTx().SubNetworkID)
return subnetworkid.Less(&blockTxns[i].MsgTx().SubnetworkID, &blockTxns[j].MsgTx().SubnetworkID)
})
// Create a new block ready to be solved.

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().Subnetwork.IsEqual(&wire.SubnetworkSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
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.
func handleGetHashesPerSec(s *Server, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {
if !config.MainConfig().SubNetwork.IsEqual(&wire.SubNetworkSupportsAll) {
if !config.MainConfig().Subnetwork.IsEqual(&wire.SubnetworkSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
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
// fields that are not related to wallet functionality.
func handleGetMiningInfo(s *Server, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {
if !config.MainConfig().SubNetwork.IsEqual(&wire.SubNetworkSupportsAll) {
if !config.MainConfig().Subnetwork.IsEqual(&wire.SubnetworkSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
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.
// Originally it relied on height, which no longer makes sense.
func handleGetNetworkHashPS(s *Server, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {
if !config.MainConfig().SubNetwork.IsEqual(&wire.SubNetworkSupportsAll) {
if !config.MainConfig().Subnetwork.IsEqual(&wire.SubnetworkSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
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.
func handleSetGenerate(s *Server, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {
if !config.MainConfig().SubNetwork.IsEqual(&wire.SubNetworkSupportsAll) {
if !config.MainConfig().Subnetwork.IsEqual(&wire.SubnetworkSupportsAll) {
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidRequest.Code,
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,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
{
Version: 1,
@ -432,7 +432,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
{
Version: 1,
@ -501,7 +501,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
{
Version: 1,
@ -558,7 +558,7 @@ var Block100000 = wire.MsgBlock{
},
},
LockTime: 0,
SubNetworkID: wire.SubNetworkDAGCoin,
SubnetworkID: wire.SubnetworkDAGCoin,
},
},
}

52
util/subnetworkid/subnetworkid.go
View File

@ -13,23 +13,23 @@ import (
"strings"
)
// IDLength of array used to store the sub-network ID. See SubNetworkID.
// IDLength of array used to store the subnetwork ID. See SubnetworkID.
const IDLength = 20
// MaxStringSize is the maximum length of a SubNetworkID string.
// MaxStringSize is the maximum length of a SubnetworkID string.
const MaxStringSize = IDLength * 2
// ErrIDStrSize describes an error that indicates the caller specified an ID
// string that has too many characters.
var ErrIDStrSize = fmt.Errorf("max ID string length is %v bytes", MaxStringSize)
// SubNetworkID is used in several of the bitcoin messages and common structures. It
// SubnetworkID is used in several of the bitcoin messages and common structures. It
// typically represents ripmed160(sha256(data)).
type SubNetworkID [IDLength]byte
type SubnetworkID [IDLength]byte
// String returns the SubNetworkID as the hexadecimal string of the byte-reversed
// String returns the SubnetworkID as the hexadecimal string of the byte-reversed
// hash.
func (id SubNetworkID) String() string {
func (id SubnetworkID) String() string {
for i := 0; i < IDLength/2; i++ {
id[i], id[IDLength-1-i] = id[IDLength-1-i], id[i]
}
@ -37,7 +37,7 @@ func (id SubNetworkID) String() string {
}
// Strings returns a slice of strings representing the IDs in the given slice of IDs
func Strings(ids []SubNetworkID) []string {
func Strings(ids []SubnetworkID) []string {
strings := make([]string, len(ids))
for i, id := range ids {
strings[i] = id.String()
@ -51,7 +51,7 @@ func Strings(ids []SubNetworkID) []string {
//
// NOTE: It is generally cheaper to just slice the ID directly thereby reusing
// the same bytes rather than calling this method.
func (id *SubNetworkID) CloneBytes() []byte {
func (id *SubnetworkID) CloneBytes() []byte {
newID := make([]byte, IDLength)
copy(newID, id[:])
@ -60,7 +60,7 @@ func (id *SubNetworkID) CloneBytes() []byte {
// SetBytes sets the bytes which represent the ID. An error is returned if
// the number of bytes passed in is not IDLength.
func (id *SubNetworkID) SetBytes(newID []byte) error {
func (id *SubnetworkID) SetBytes(newID []byte) error {
nhlen := len(newID)
if nhlen != IDLength {
return fmt.Errorf("invalid ID length of %v, want %v", nhlen,
@ -72,7 +72,7 @@ func (id *SubNetworkID) SetBytes(newID []byte) error {
}
// IsEqual returns true if target is the same as ID.
func (id *SubNetworkID) IsEqual(target *SubNetworkID) bool {
func (id *SubnetworkID) IsEqual(target *SubnetworkID) bool {
if id == nil && target == nil {
return true
}
@ -84,7 +84,7 @@ func (id *SubNetworkID) IsEqual(target *SubNetworkID) bool {
// AreEqual returns true if both slices contain the same IDs.
// Either slice must not contain duplicates.
func AreEqual(first []SubNetworkID, second []SubNetworkID) bool {
func AreEqual(first []SubnetworkID, second []SubnetworkID) bool {
if len(first) != len(second) {
return false
}
@ -100,8 +100,8 @@ func AreEqual(first []SubNetworkID, second []SubNetworkID) bool {
// New returns a new ID from a byte slice. An error is returned if
// the number of bytes passed in is not IDLength.
func New(newID []byte) (*SubNetworkID, error) {
var sh SubNetworkID
func New(newID []byte) (*SubnetworkID, error) {
var sh SubnetworkID
err := sh.SetBytes(newID)
if err != nil {
return nil, err
@ -109,11 +109,11 @@ func New(newID []byte) (*SubNetworkID, error) {
return &sh, err
}
// NewFromStr creates a SubNetworkID from a string. The string should be
// NewFromStr creates a SubnetworkID from a string. The string should be
// the hexadecimal string of a byte-reversed hash, but any missing characters
// result in zero padding at the end of the SubNetworkID.
func NewFromStr(id string) (*SubNetworkID, error) {
ret := new(SubNetworkID)
// result in zero padding at the end of the SubnetworkID.
func NewFromStr(id string) (*SubnetworkID, error) {
ret := new(SubnetworkID)
err := Decode(ret, id)
if err != nil {
return nil, err
@ -121,9 +121,9 @@ func NewFromStr(id string) (*SubNetworkID, error) {
return ret, nil
}
// Decode decodes the byte-reversed hexadecimal string encoding of a SubNetworkID to a
// Decode decodes the byte-reversed hexadecimal string encoding of a SubnetworkID to a
// destination.
func Decode(dst *SubNetworkID, src string) error {
func Decode(dst *SubnetworkID, src string) error {
// Return error if ID string is too long.
if len(src) > MaxStringSize {
return ErrIDStrSize
@ -141,7 +141,7 @@ func Decode(dst *SubNetworkID, src string) error {
}
// Hex decode the source bytes to a temporary destination.
var reversedHash SubNetworkID
var reversedHash SubnetworkID
_, err := hex.Decode(reversedHash[IDLength-hex.DecodedLen(len(srcBytes)):], srcBytes)
if err != nil {
return err
@ -156,9 +156,9 @@ func Decode(dst *SubNetworkID, src string) error {
return nil
}
// ToBig converts a SubNetworkID into a big.Int that can be used to
// ToBig converts a SubnetworkID into a big.Int that can be used to
// perform math comparisons.
func ToBig(id *SubNetworkID) *big.Int {
func ToBig(id *SubnetworkID) *big.Int {
// A Hash is in little-endian, but the big package wants the bytes in
// big-endian, so reverse them.
buf := *id
@ -176,22 +176,22 @@ func ToBig(id *SubNetworkID) *big.Int {
// 0 if id == target
// +1 if id > target
//
func (id *SubNetworkID) Cmp(target *SubNetworkID) int {
func (id *SubnetworkID) Cmp(target *SubnetworkID) int {
return ToBig(id).Cmp(ToBig(target))
}
// Less returns true iff id a is less than id b
func Less(a *SubNetworkID, b *SubNetworkID) bool {
func Less(a *SubnetworkID, b *SubnetworkID) bool {
return a.Cmp(b) < 0
}
// JoinIDsStrings joins all the stringified IDs separated by a separator
func JoinIDsStrings(ids []SubNetworkID, separator string) string {
func JoinIDsStrings(ids []SubnetworkID, separator string) string {
return strings.Join(Strings(ids), separator)
}
// Sort sorts a slice of ids
func Sort(ids []SubNetworkID) {
func Sort(ids []SubnetworkID) {
sort.Slice(ids, func(i, j int) bool {
return Less(&ids[i], &ids[j])
})

2
wire/msgblock_test.go
View File

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

42
wire/msgtx.go
View File

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

28
wire/msgtx_test.go
View File

@ -403,12 +403,12 @@ func TestTxSerialize(t *testing.T) {
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Payload / Gas limit
}
subNetworkTx := NewMsgTx(1)
subNetworkTx.SubNetworkID = subnetworkid.SubNetworkID{0xff}
subNetworkTx.Gas = 5
subNetworkTx.Payload = []byte{0, 1, 2}
subnetworkTx := NewMsgTx(1)
subnetworkTx.SubnetworkID = subnetworkid.SubnetworkID{0xff}
subnetworkTx.Gas = 5
subnetworkTx.Payload = []byte{0, 1, 2}
subNetworkTxEncoded := []byte{
subnetworkTxEncoded := []byte{
0x01, 0x00, 0x00, 0x00, // Version
0x00, // Varint for number of input transactions
0x00, // Varint for number of output transactions
@ -445,9 +445,9 @@ func TestTxSerialize(t *testing.T) {
// Sub Network Transaction.
{
subNetworkTx,
subNetworkTx,
subNetworkTxEncoded,
subnetworkTx,
subnetworkTx,
subnetworkTxEncoded,
nil,
},
@ -569,12 +569,12 @@ func TestTxSerializeErrors(t *testing.T) {
}
registryTx := NewMsgTx(1)
registryTx.SubNetworkID = SubNetworkRegistry
registryTx.SubnetworkID = SubnetworkRegistry
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", SubNetworkRegistry)
str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubnetworkRegistry)
expectedErr := messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -585,7 +585,7 @@ func TestTxSerializeErrors(t *testing.T) {
w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
err = dagCoinTx.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", SubnetworkDAGCoin)
expectedErr = messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -596,7 +596,7 @@ func TestTxSerializeErrors(t *testing.T) {
w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
err = dagCoinTx.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", SubnetworkDAGCoin)
expectedErr = messageError("MsgTx.BtcEncode", str)
if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -619,7 +619,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", SubNetworkSupportsAll)
str = fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", SubnetworkSupportsAll)
expectedErr = messageError("MsgTx.BtcDecode", str)
if err == nil || err.Error() != expectedErr.Error() {
t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
@ -870,7 +870,7 @@ var multiTx = &MsgTx{
},
},
LockTime: 0,
SubNetworkID: SubNetworkDAGCoin,
SubnetworkID: SubnetworkDAGCoin,
}
// multiTxEncoded is the wire encoded bytes for multiTx using protocol version