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

Merge remote-tracking branch 'origin/v0.6.1-dev'

Browse Source
This commit is contained in:
Yuval Shaul 2020-08-12 10:48:51 +03:00
commit aac173ed72
191 changed files with 1502 additions and 1779 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
addressmanager/addressmanager.go
View File

@ -23,8 +23,8 @@ import (
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
// AddressKey represents a "string" key in the form of ip:port for IPv4 addresses
@ -92,7 +92,7 @@ type PeersStateForSerialization struct {
}
type localAddress struct {
netAddress *wire.NetAddress
netAddress *domainmessage.NetAddress
score AddressPriority
}
@ -208,7 +208,7 @@ func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext) *Address
// updateAddress is a helper function to either update an address already known
// to the address manager, or to add the address if not already known.
func (am *AddressManager) updateAddress(netAddress, sourceAddress *wire.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
func (am *AddressManager) updateAddress(netAddress, sourceAddress *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
// Filter out non-routable addresses. Note that non-routable
// also includes invalid and local addresses.
if !am.IsRoutable(netAddress) {
@ -371,7 +371,7 @@ func (am *AddressManager) pickTried(subnetworkID *subnetworkid.SubnetworkID, buc
return oldest, oldestIndex
}
func (am *AddressManager) newAddressBucketIndex(netAddress, srcAddress *wire.NetAddress) int {
func (am *AddressManager) newAddressBucketIndex(netAddress, srcAddress *domainmessage.NetAddress) int {
// doublesha256(key + sourcegroup + int64(doublesha256(key + group + sourcegroup))%bucket_per_source_group) % num_new_buckets
data1 := []byte{}
@ -392,7 +392,7 @@ func (am *AddressManager) newAddressBucketIndex(netAddress, srcAddress *wire.Net
return int(binary.LittleEndian.Uint64(hash2) % NewBucketCount)
}
func (am *AddressManager) triedAddressBucketIndex(netAddress *wire.NetAddress) int {
func (am *AddressManager) triedAddressBucketIndex(netAddress *domainmessage.NetAddress) int {
// doublesha256(key + group + truncate_to_64bits(doublesha256(key)) % buckets_per_group) % num_buckets
data1 := []byte{}
data1 = append(data1, am.key[:]...)
@ -705,8 +705,8 @@ func (am *AddressManager) deserializePeersState(serializedPeerState []byte) erro
return nil
}
// DeserializeNetAddress converts a given address string to a *wire.NetAddress
func (am *AddressManager) DeserializeNetAddress(addressKey AddressKey) (*wire.NetAddress, error) {
// DeserializeNetAddress converts a given address string to a *domainmessage.NetAddress
func (am *AddressManager) DeserializeNetAddress(addressKey AddressKey) (*domainmessage.NetAddress, error) {
host, portString, err := net.SplitHostPort(string(addressKey))
if err != nil {
return nil, err
@ -716,7 +716,7 @@ func (am *AddressManager) DeserializeNetAddress(addressKey AddressKey) (*wire.Ne
return nil, err
}
return am.HostToNetAddress(host, uint16(port), wire.SFNodeNetwork)
return am.HostToNetAddress(host, uint16(port), domainmessage.SFNodeNetwork)
}
// Start begins the core address handler which manages a pool of known
@ -758,7 +758,7 @@ func (am *AddressManager) Stop() error {
// AddAddresses adds new addresses to the address manager. It enforces a max
// number of addresses and silently ignores duplicate addresses. It is
// safe for concurrent access.
func (am *AddressManager) AddAddresses(addresses []*wire.NetAddress, sourceAddress *wire.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
func (am *AddressManager) AddAddresses(addresses []*domainmessage.NetAddress, sourceAddress *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
am.mutex.Lock()
defer am.mutex.Unlock()
@ -770,7 +770,7 @@ func (am *AddressManager) AddAddresses(addresses []*wire.NetAddress, sourceAddre
// AddAddress adds a new address to the address manager. It enforces a max
// number of addresses and silently ignores duplicate addresses. It is
// safe for concurrent access.
func (am *AddressManager) AddAddress(address, sourceAddress *wire.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
func (am *AddressManager) AddAddress(address, sourceAddress *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
am.mutex.Lock()
defer am.mutex.Unlock()
@ -778,14 +778,14 @@ func (am *AddressManager) AddAddress(address, sourceAddress *wire.NetAddress, su
}
// AddAddressByIP adds an address where we are given an ip:port and not a
// wire.NetAddress.
// domainmessage.NetAddress.
func (am *AddressManager) AddAddressByIP(addressIP string, subnetworkID *subnetworkid.SubnetworkID) error {
// Split IP and port
ipString, portString, err := net.SplitHostPort(addressIP)
if err != nil {
return err
}
// Put it in wire.Netaddress
// Put it in domainmessage.Netaddress
ip := net.ParseIP(ipString)
if ip == nil {
return errors.Errorf("invalid ip %s", ipString)
@ -794,7 +794,7 @@ func (am *AddressManager) AddAddressByIP(addressIP string, subnetworkID *subnetw
if err != nil {
return errors.Errorf("invalid port %s: %s", portString, err)
}
netAddress := wire.NewNetAddressIPPort(ip, uint16(port), 0)
netAddress := domainmessage.NewNetAddressIPPort(ip, uint16(port), 0)
am.AddAddress(netAddress, netAddress, subnetworkID) // XXX use correct src address
return nil
}
@ -843,7 +843,7 @@ func (am *AddressManager) NeedMoreAddresses() bool {
// AddressCache returns the current address cache. It must be treated as
// read-only (but since it is a copy now, this is not as dangerous).
func (am *AddressManager) AddressCache(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) []*wire.NetAddress {
func (am *AddressManager) AddressCache(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) []*domainmessage.NetAddress {
am.mutex.Lock()
defer am.mutex.Unlock()
@ -851,7 +851,7 @@ func (am *AddressManager) AddressCache(includeAllSubnetworks bool, subnetworkID
return nil
}
allAddresses := []*wire.NetAddress{}
allAddresses := []*domainmessage.NetAddress{}
// Iteration order is undefined here, but we randomise it anyway.
for _, v := range am.addressIndex {
if includeAllSubnetworks || v.SubnetworkID().IsEqual(subnetworkID) {
@ -907,7 +907,7 @@ func (am *AddressManager) reset() {
// HostToNetAddress returns a netaddress given a host address. If
// the host is not an IP address it will be resolved.
func (am *AddressManager) HostToNetAddress(host string, port uint16, services wire.ServiceFlag) (*wire.NetAddress, error) {
func (am *AddressManager) HostToNetAddress(host string, port uint16, services domainmessage.ServiceFlag) (*domainmessage.NetAddress, error) {
ip := net.ParseIP(host)
if ip == nil {
ips, err := am.lookupFunc(host)
@ -920,12 +920,12 @@ func (am *AddressManager) HostToNetAddress(host string, port uint16, services wi
ip = ips[0]
}
return wire.NewNetAddressIPPort(ip, port, services), nil
return domainmessage.NewNetAddressIPPort(ip, port, services), nil
}
// NetAddressKey returns a key in the form of ip:port for IPv4 addresses
// or [ip]:port for IPv6 addresses for use as keys in maps.
func NetAddressKey(netAddress *wire.NetAddress) AddressKey {
func NetAddressKey(netAddress *domainmessage.NetAddress) AddressKey {
port := strconv.FormatUint(uint64(netAddress.Port), 10)
return AddressKey(net.JoinHostPort(netAddress.IP.String(), port))
@ -1031,13 +1031,13 @@ func (tb *triedAddressBucketArray) name() string {
return "tried"
}
func (am *AddressManager) knownAddress(address *wire.NetAddress) *KnownAddress {
func (am *AddressManager) knownAddress(address *domainmessage.NetAddress) *KnownAddress {
return am.addressIndex[NetAddressKey(address)]
}
// Attempt increases the given address' attempt counter and updates
// the last attempt time.
func (am *AddressManager) Attempt(address *wire.NetAddress) {
func (am *AddressManager) Attempt(address *domainmessage.NetAddress) {
am.mutex.Lock()
defer am.mutex.Unlock()
@ -1055,7 +1055,7 @@ func (am *AddressManager) Attempt(address *wire.NetAddress) {
// Connected Marks the given address as currently connected and working at the
// current time. The address must already be known to AddressManager else it will
// be ignored.
func (am *AddressManager) Connected(address *wire.NetAddress) {
func (am *AddressManager) Connected(address *domainmessage.NetAddress) {
am.mutex.Lock()
defer am.mutex.Unlock()
@ -1078,7 +1078,7 @@ func (am *AddressManager) Connected(address *wire.NetAddress) {
// Good marks the given address as good. To be called after a successful
// connection and version exchange. If the address is unknown to the address
// manager it will be ignored.
func (am *AddressManager) Good(address *wire.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
func (am *AddressManager) Good(address *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
am.mutex.Lock()
defer am.mutex.Unlock()
@ -1254,7 +1254,7 @@ func (am *AddressManager) incrementTriedAddressCount(subnetworkID *subnetworkid.
// AddLocalAddress adds netAddress to the list of known local addresses to advertise
// with the given priority.
func (am *AddressManager) AddLocalAddress(netAddress *wire.NetAddress, priority AddressPriority) error {
func (am *AddressManager) AddLocalAddress(netAddress *domainmessage.NetAddress, priority AddressPriority) error {
if !am.IsRoutable(netAddress) {
return errors.Errorf("address %s is not routable", netAddress.IP)
}
@ -1279,7 +1279,7 @@ func (am *AddressManager) AddLocalAddress(netAddress *wire.NetAddress, priority
// getReachabilityFrom returns the relative reachability of the provided local
// address to the provided remote address.
func (am *AddressManager) getReachabilityFrom(localAddress, remoteAddress *wire.NetAddress) int {
func (am *AddressManager) getReachabilityFrom(localAddress, remoteAddress *domainmessage.NetAddress) int {
const (
Unreachable = 0
Default = iota
@ -1346,13 +1346,13 @@ func (am *AddressManager) getReachabilityFrom(localAddress, remoteAddress *wire.
// GetBestLocalAddress returns the most appropriate local address to use
// for the given remote address.
func (am *AddressManager) GetBestLocalAddress(remoteAddress *wire.NetAddress) *wire.NetAddress {
func (am *AddressManager) GetBestLocalAddress(remoteAddress *domainmessage.NetAddress) *domainmessage.NetAddress {
am.localAddressesLock.Lock()
defer am.localAddressesLock.Unlock()
bestReach := 0
var bestScore AddressPriority
var bestAddress *wire.NetAddress
var bestAddress *domainmessage.NetAddress
for _, localAddress := range am.localAddresses {
reach := am.getReachabilityFrom(localAddress.netAddress, remoteAddress)
if reach > bestReach ||
@ -1376,24 +1376,24 @@ func (am *AddressManager) GetBestLocalAddress(remoteAddress *wire.NetAddress) *w
} else {
ip = net.IPv4zero
}
services := wire.SFNodeNetwork | wire.SFNodeBloom
bestAddress = wire.NewNetAddressIPPort(ip, 0, services)
services := domainmessage.SFNodeNetwork | domainmessage.SFNodeBloom
bestAddress = domainmessage.NewNetAddressIPPort(ip, 0, services)
}
return bestAddress
}
// Ban marks the given address as banned
func (am *AddressManager) Ban(address *wire.NetAddress) error {
func (am *AddressManager) Ban(address *domainmessage.NetAddress) error {
return am.setBanned(address, true, mstime.Now())
}
// Unban marks the given address as not banned
func (am *AddressManager) Unban(address *wire.NetAddress) error {
func (am *AddressManager) Unban(address *domainmessage.NetAddress) error {
return am.setBanned(address, false, mstime.Time{})
}
func (am *AddressManager) setBanned(address *wire.NetAddress, isBanned bool, bannedTime mstime.Time) error {
func (am *AddressManager) setBanned(address *domainmessage.NetAddress, isBanned bool, bannedTime mstime.Time) error {
am.localAddressesLock.Lock()
defer am.localAddressesLock.Unlock()
@ -1408,7 +1408,7 @@ func (am *AddressManager) setBanned(address *wire.NetAddress, isBanned bool, ban
}
// IsBanned returns whether the given address is banned
func (am *AddressManager) IsBanned(address *wire.NetAddress) (bool, error) {
func (am *AddressManager) IsBanned(address *domainmessage.NetAddress) (bool, error) {
am.localAddressesLock.Lock()
defer am.localAddressesLock.Unlock()

86
addressmanager/addressmanager_test.go
View File

@ -19,13 +19,13 @@ import (
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
// naTest is used to describe a test to be performed against the NetAddressKey
// method.
type naTest struct {
in wire.NetAddress
in domainmessage.NetAddress
want AddressKey
}
@ -99,7 +99,7 @@ func addNaTests() {
func addNaTest(ip string, port uint16, want AddressKey) {
nip := net.ParseIP(ip)
na := *wire.NewNetAddressIPPort(nip, port, wire.SFNodeNetwork)
na := *domainmessage.NewNetAddressIPPort(nip, port, domainmessage.SFNodeNetwork)
test := naTest{na, want}
naTests = append(naTests, test)
}
@ -194,37 +194,37 @@ func TestAddAddressByIP(t *testing.T) {
func TestAddLocalAddress(t *testing.T) {
var tests = []struct {
address wire.NetAddress
address domainmessage.NetAddress
priority AddressPriority
valid bool
}{
{
wire.NetAddress{IP: net.ParseIP("192.168.0.100")},
domainmessage.NetAddress{IP: net.ParseIP("192.168.0.100")},
InterfacePrio,
false,
},
{
wire.NetAddress{IP: net.ParseIP("204.124.1.1")},
domainmessage.NetAddress{IP: net.ParseIP("204.124.1.1")},
InterfacePrio,
true,
},
{
wire.NetAddress{IP: net.ParseIP("204.124.1.1")},
domainmessage.NetAddress{IP: net.ParseIP("204.124.1.1")},
BoundPrio,
true,
},
{
wire.NetAddress{IP: net.ParseIP("::1")},
domainmessage.NetAddress{IP: net.ParseIP("::1")},
InterfacePrio,
false,
},
{
wire.NetAddress{IP: net.ParseIP("fe80::1")},
domainmessage.NetAddress{IP: net.ParseIP("fe80::1")},
InterfacePrio,
false,
},
{
wire.NetAddress{IP: net.ParseIP("2620:100::1")},
domainmessage.NetAddress{IP: net.ParseIP("2620:100::1")},
InterfacePrio,
true,
},
@ -298,7 +298,7 @@ func TestNeedMoreAddresses(t *testing.T) {
if !b {
t.Errorf("Expected that we need more addresses")
}
addrs := make([]*wire.NetAddress, addrsToAdd)
addrs := make([]*domainmessage.NetAddress, addrsToAdd)
var err error
for i := 0; i < addrsToAdd; i++ {
@ -309,7 +309,7 @@ func TestNeedMoreAddresses(t *testing.T) {
}
}
srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
srcAddr := domainmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
amgr.AddAddresses(addrs, srcAddr, nil)
numAddrs := amgr.TotalNumAddresses()
@ -327,7 +327,7 @@ func TestGood(t *testing.T) {
amgr, teardown := newAddrManagerForTest(t, "TestGood", nil)
defer teardown()
addrsToAdd := 64 * 64
addrs := make([]*wire.NetAddress, addrsToAdd)
addrs := make([]*domainmessage.NetAddress, addrsToAdd)
subnetworkCount := 32
subnetworkIDs := make([]*subnetworkid.SubnetworkID, subnetworkCount)
@ -344,7 +344,7 @@ func TestGood(t *testing.T) {
subnetworkIDs[i] = &subnetworkid.SubnetworkID{0xff - byte(i)}
}
srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
srcAddr := domainmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
amgr.AddAddresses(addrs, srcAddr, nil)
for i, addr := range addrs {
@ -374,9 +374,9 @@ func TestGood(t *testing.T) {
func TestGoodChangeSubnetworkID(t *testing.T) {
amgr, teardown := newAddrManagerForTest(t, "TestGoodChangeSubnetworkID", nil)
defer teardown()
addr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
addr := domainmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
addrKey := NetAddressKey(addr)
srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
srcAddr := domainmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
oldSubnetwork := subnetworkid.SubnetworkIDNative
amgr.AddAddress(addr, srcAddr, oldSubnetwork)
@ -515,7 +515,7 @@ func TestGetAddress(t *testing.T) {
}
func TestGetBestLocalAddress(t *testing.T) {
localAddrs := []wire.NetAddress{
localAddrs := []domainmessage.NetAddress{
{IP: net.ParseIP("192.168.0.100")},
{IP: net.ParseIP("::1")},
{IP: net.ParseIP("fe80::1")},
@ -523,43 +523,43 @@ func TestGetBestLocalAddress(t *testing.T) {
}
var tests = []struct {
remoteAddr wire.NetAddress
want0 wire.NetAddress
want1 wire.NetAddress
want2 wire.NetAddress
want3 wire.NetAddress
remoteAddr domainmessage.NetAddress
want0 domainmessage.NetAddress
want1 domainmessage.NetAddress
want2 domainmessage.NetAddress
want3 domainmessage.NetAddress
}{
{
// Remote connection from public IPv4
wire.NetAddress{IP: net.ParseIP("204.124.8.1")},
wire.NetAddress{IP: net.IPv4zero},
wire.NetAddress{IP: net.IPv4zero},
wire.NetAddress{IP: net.ParseIP("204.124.8.100")},
wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
domainmessage.NetAddress{IP: net.ParseIP("204.124.8.1")},
domainmessage.NetAddress{IP: net.IPv4zero},
domainmessage.NetAddress{IP: net.IPv4zero},
domainmessage.NetAddress{IP: net.ParseIP("204.124.8.100")},
domainmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
},
{
// Remote connection from private IPv4
wire.NetAddress{IP: net.ParseIP("172.16.0.254")},
wire.NetAddress{IP: net.IPv4zero},
wire.NetAddress{IP: net.IPv4zero},
wire.NetAddress{IP: net.IPv4zero},
wire.NetAddress{IP: net.IPv4zero},
domainmessage.NetAddress{IP: net.ParseIP("172.16.0.254")},
domainmessage.NetAddress{IP: net.IPv4zero},
domainmessage.NetAddress{IP: net.IPv4zero},
domainmessage.NetAddress{IP: net.IPv4zero},
domainmessage.NetAddress{IP: net.IPv4zero},
},
{
// Remote connection from public IPv6
wire.NetAddress{IP: net.ParseIP("2602:100:abcd::102")},
wire.NetAddress{IP: net.IPv6zero},
wire.NetAddress{IP: net.ParseIP("2001:470::1")},
wire.NetAddress{IP: net.ParseIP("2001:470::1")},
wire.NetAddress{IP: net.ParseIP("2001:470::1")},
domainmessage.NetAddress{IP: net.ParseIP("2602:100:abcd::102")},
domainmessage.NetAddress{IP: net.IPv6zero},
domainmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
domainmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
domainmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
},
/* XXX
{
// Remote connection from Tor
wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43::100")},
wire.NetAddress{IP: net.IPv4zero},
wire.NetAddress{IP: net.ParseIP("204.124.8.100")},
wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
domainmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43::100")},
domainmessage.NetAddress{IP: net.IPv4zero},
domainmessage.NetAddress{IP: net.ParseIP("204.124.8.100")},
domainmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
},
*/
}
@ -592,7 +592,7 @@ func TestGetBestLocalAddress(t *testing.T) {
}
// Add a public IP to the list of local addresses.
localAddr := wire.NetAddress{IP: net.ParseIP("204.124.8.100")}
localAddr := domainmessage.NetAddress{IP: net.ParseIP("204.124.8.100")}
amgr.AddLocalAddress(&localAddr, InterfacePrio)
// Test against want2
@ -606,7 +606,7 @@ func TestGetBestLocalAddress(t *testing.T) {
}
/*
// Add a Tor generated IP address
localAddr = wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")}
localAddr = domainmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")}
amgr.AddLocalAddress(&localAddr, ManualPrio)
// Test against want3
for x, test := range tests {

4
addressmanager/internal_test.go
View File

@ -5,8 +5,8 @@
package addressmanager
import (
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/mstime"
"github.com/kaspanet/kaspad/wire"
)
func TstKnownAddressIsBad(ka *KnownAddress) bool {
@ -17,7 +17,7 @@ func TstKnownAddressChance(ka *KnownAddress) float64 {
return ka.chance()
}
func TstNewKnownAddress(na *wire.NetAddress, attempts int,
func TstNewKnownAddress(na *domainmessage.NetAddress, attempts int,
lastattempt, lastsuccess mstime.Time, tried bool, refs int) *KnownAddress {
return &KnownAddress{netAddress: na, attempts: attempts, lastAttempt: lastattempt,
lastSuccess: lastsuccess, tried: tried, referenceCount: refs}

10
addressmanager/knownaddress.go
View File

@ -10,14 +10,14 @@ import (
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
// KnownAddress tracks information about a known network address that is used
// to determine how viable an address is.
type KnownAddress struct {
netAddress *wire.NetAddress
sourceAddress *wire.NetAddress
netAddress *domainmessage.NetAddress
sourceAddress *domainmessage.NetAddress
attempts int
lastAttempt mstime.Time
lastSuccess mstime.Time
@ -28,9 +28,9 @@ type KnownAddress struct {
bannedTime mstime.Time
}
// NetAddress returns the underlying wire.NetAddress associated with the
// NetAddress returns the underlying domainmessage.NetAddress associated with the
// known address.
func (ka *KnownAddress) NetAddress() *wire.NetAddress {
func (ka *KnownAddress) NetAddress() *domainmessage.NetAddress {
return ka.netAddress
}

20
addressmanager/knownaddress_test.go
View File

@ -11,7 +11,7 @@ import (
"time"
"github.com/kaspanet/kaspad/addressmanager"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
func TestChance(t *testing.T) {
@ -22,27 +22,27 @@ func TestChance(t *testing.T) {
}{
{
//Test normal case
addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
addressmanager.TstNewKnownAddress(&domainmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
0, mstime.Now().Add(-30*time.Minute), mstime.Now(), false, 0),
1.0,
}, {
//Test case in which lastseen < 0
addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(20 * time.Second)},
addressmanager.TstNewKnownAddress(&domainmessage.NetAddress{Timestamp: now.Add(20 * time.Second)},
0, mstime.Now().Add(-30*time.Minute), mstime.Now(), false, 0),
1.0,
}, {
//Test case in which lastAttempt < 0
addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
addressmanager.TstNewKnownAddress(&domainmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
0, mstime.Now().Add(30*time.Minute), mstime.Now(), false, 0),
1.0 * .01,
}, {
//Test case in which lastAttempt < ten minutes
addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
addressmanager.TstNewKnownAddress(&domainmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
0, mstime.Now().Add(-5*time.Minute), mstime.Now(), false, 0),
1.0 * .01,
}, {
//Test case with several failed attempts.
addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
addressmanager.TstNewKnownAddress(&domainmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
2, mstime.Now().Add(-30*time.Minute), mstime.Now(), false, 0),
1 / 1.5 / 1.5,
},
@ -66,10 +66,10 @@ func TestIsBad(t *testing.T) {
hoursOld := now.Add(-5 * time.Hour)
zeroTime := mstime.Time{}
futureNa := &wire.NetAddress{Timestamp: future}
minutesOldNa := &wire.NetAddress{Timestamp: minutesOld}
monthOldNa := &wire.NetAddress{Timestamp: monthOld}
currentNa := &wire.NetAddress{Timestamp: secondsOld}
futureNa := &domainmessage.NetAddress{Timestamp: future}
minutesOldNa := &domainmessage.NetAddress{Timestamp: minutesOld}
monthOldNa := &domainmessage.NetAddress{Timestamp: monthOld}
currentNa := &domainmessage.NetAddress{Timestamp: secondsOld}
//Test addresses that have been tried in the last minute.
if addressmanager.TstKnownAddressIsBad(addressmanager.TstNewKnownAddress(futureNa, 3, secondsOld, zeroTime, false, 0)) {

38
addressmanager/network.go
View File

@ -7,7 +7,7 @@ package addressmanager
import (
"net"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
var (
@ -86,19 +86,19 @@ func ipNet(ip string, ones, bits int) net.IPNet {
}
// IsIPv4 returns whether or not the given address is an IPv4 address.
func IsIPv4(na *wire.NetAddress) bool {
func IsIPv4(na *domainmessage.NetAddress) bool {
return na.IP.To4() != nil
}
// IsLocal returns whether or not the given address is a local address.
func IsLocal(na *wire.NetAddress) bool {
func IsLocal(na *domainmessage.NetAddress) bool {
return na.IP.IsLoopback() || zero4Net.Contains(na.IP)
}
// IsRFC1918 returns whether or not the passed address is part of the IPv4
// private network address space as defined by RFC1918 (10.0.0.0/8,
// 172.16.0.0/12, or 192.168.0.0/16).
func IsRFC1918(na *wire.NetAddress) bool {
func IsRFC1918(na *domainmessage.NetAddress) bool {
for _, rfc := range rfc1918Nets {
if rfc.Contains(na.IP) {
return true
@ -109,56 +109,56 @@ func IsRFC1918(na *wire.NetAddress) bool {
// IsRFC2544 returns whether or not the passed address is part of the IPv4
// address space as defined by RFC2544 (198.18.0.0/15)
func IsRFC2544(na *wire.NetAddress) bool {
func IsRFC2544(na *domainmessage.NetAddress) bool {
return rfc2544Net.Contains(na.IP)
}
// IsRFC3849 returns whether or not the passed address is part of the IPv6
// documentation range as defined by RFC3849 (2001:DB8::/32).
func IsRFC3849(na *wire.NetAddress) bool {
func IsRFC3849(na *domainmessage.NetAddress) bool {
return rfc3849Net.Contains(na.IP)
}
// IsRFC3927 returns whether or not the passed address is part of the IPv4
// autoconfiguration range as defined by RFC3927 (169.254.0.0/16).
func IsRFC3927(na *wire.NetAddress) bool {
func IsRFC3927(na *domainmessage.NetAddress) bool {
return rfc3927Net.Contains(na.IP)
}
// IsRFC3964 returns whether or not the passed address is part of the IPv6 to
// IPv4 encapsulation range as defined by RFC3964 (2002::/16).
func IsRFC3964(na *wire.NetAddress) bool {
func IsRFC3964(na *domainmessage.NetAddress) bool {
return rfc3964Net.Contains(na.IP)
}
// IsRFC4193 returns whether or not the passed address is part of the IPv6
// unique local range as defined by RFC4193 (FC00::/7).
func IsRFC4193(na *wire.NetAddress) bool {
func IsRFC4193(na *domainmessage.NetAddress) bool {
return rfc4193Net.Contains(na.IP)
}
// IsRFC4380 returns whether or not the passed address is part of the IPv6
// teredo tunneling over UDP range as defined by RFC4380 (2001::/32).
func IsRFC4380(na *wire.NetAddress) bool {
func IsRFC4380(na *domainmessage.NetAddress) bool {
return rfc4380Net.Contains(na.IP)
}
// IsRFC4843 returns whether or not the passed address is part of the IPv6
// ORCHID range as defined by RFC4843 (2001:10::/28).
func IsRFC4843(na *wire.NetAddress) bool {
func IsRFC4843(na *domainmessage.NetAddress) bool {
return rfc4843Net.Contains(na.IP)
}
// IsRFC4862 returns whether or not the passed address is part of the IPv6
// stateless address autoconfiguration range as defined by RFC4862 (FE80::/64).
func IsRFC4862(na *wire.NetAddress) bool {
func IsRFC4862(na *domainmessage.NetAddress) bool {
return rfc4862Net.Contains(na.IP)
}
// IsRFC5737 returns whether or not the passed address is part of the IPv4
// documentation address space as defined by RFC5737 (192.0.2.0/24,
// 198.51.100.0/24, 203.0.113.0/24)
func IsRFC5737(na *wire.NetAddress) bool {
func IsRFC5737(na *domainmessage.NetAddress) bool {
for _, rfc := range rfc5737Net {
if rfc.Contains(na.IP) {
return true
@ -170,19 +170,19 @@ func IsRFC5737(na *wire.NetAddress) bool {
// IsRFC6052 returns whether or not the passed address is part of the IPv6
// well-known prefix range as defined by RFC6052 (64:FF9B::/96).
func IsRFC6052(na *wire.NetAddress) bool {
func IsRFC6052(na *domainmessage.NetAddress) bool {
return rfc6052Net.Contains(na.IP)
}
// IsRFC6145 returns whether or not the passed address is part of the IPv6 to
// IPv4 translated address range as defined by RFC6145 (::FFFF:0:0:0/96).
func IsRFC6145(na *wire.NetAddress) bool {
func IsRFC6145(na *domainmessage.NetAddress) bool {
return rfc6145Net.Contains(na.IP)
}
// IsRFC6598 returns whether or not the passed address is part of the IPv4
// shared address space specified by RFC6598 (100.64.0.0/10)
func IsRFC6598(na *wire.NetAddress) bool {
func IsRFC6598(na *domainmessage.NetAddress) bool {
return rfc6598Net.Contains(na.IP)
}
@ -190,7 +190,7 @@ func IsRFC6598(na *wire.NetAddress) bool {
// considered invalid under the following circumstances:
// IPv4: It is either a zero or all bits set address.
// IPv6: It is either a zero or RFC3849 documentation address.
func IsValid(na *wire.NetAddress) bool {
func IsValid(na *domainmessage.NetAddress) bool {
// IsUnspecified returns if address is 0, so only all bits set, and
// RFC3849 need to be explicitly checked.
return na.IP != nil && !(na.IP.IsUnspecified() ||
@ -200,7 +200,7 @@ func IsValid(na *wire.NetAddress) bool {
// IsRoutable returns whether or not the passed address is routable over
// the public internet. This is true as long as the address is valid and is not
// in any reserved ranges.
func (am *AddressManager) IsRoutable(na *wire.NetAddress) bool {
func (am *AddressManager) IsRoutable(na *domainmessage.NetAddress) bool {
if am.cfg.NetParams().AcceptUnroutable {
return !IsLocal(na)
}
@ -215,7 +215,7 @@ func (am *AddressManager) IsRoutable(na *wire.NetAddress) bool {
// of. This is the /16 for IPv4, the /32 (/36 for he.net) for IPv6, the string
// "local" for a local address, and the string "unroutable" for an unroutable
// address.
func (am *AddressManager) GroupKey(na *wire.NetAddress) string {
func (am *AddressManager) GroupKey(na *domainmessage.NetAddress) string {
if IsLocal(na) {
return "local"
}

8
addressmanager/network_test.go
View File

@ -8,7 +8,7 @@ import (
"net"
"testing"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
// TestIPTypes ensures the various functions which determine the type of an IP
@ -17,7 +17,7 @@ func TestIPTypes(t *testing.T) {
amgr, teardown := newAddrManagerForTest(t, "TestAddAddressByIP", nil)
defer teardown()
type ipTest struct {
in wire.NetAddress
in domainmessage.NetAddress
rfc1918 bool
rfc2544 bool
rfc3849 bool
@ -40,7 +40,7 @@ func TestIPTypes(t *testing.T) {
rfc4193, rfc4380, rfc4843, rfc4862, rfc5737, rfc6052, rfc6145, rfc6598,
local, valid, routable bool) ipTest {
nip := net.ParseIP(ip)
na := *wire.NewNetAddressIPPort(nip, 16111, wire.SFNodeNetwork)
na := *domainmessage.NewNetAddressIPPort(nip, 16111, domainmessage.SFNodeNetwork)
test := ipTest{na, rfc1918, rfc2544, rfc3849, rfc3927, rfc3964, rfc4193, rfc4380,
rfc4843, rfc4862, rfc5737, rfc6052, rfc6145, rfc6598, local, valid, routable}
return test
@ -196,7 +196,7 @@ func TestGroupKey(t *testing.T) {
for i, test := range tests {
nip := net.ParseIP(test.ip)
na := *wire.NewNetAddressIPPort(nip, 8333, wire.SFNodeNetwork)
na := *domainmessage.NewNetAddressIPPort(nip, 8333, domainmessage.SFNodeNetwork)
if key := amgr.GroupKey(&na); key != test.expected {
t.Errorf("TestGroupKey #%d (%s): unexpected group key "+
"- got '%s', want '%s'", i, test.name,

7
app/app.go
View File

@ -14,6 +14,7 @@ import (
"github.com/kaspanet/kaspad/connmanager"
"github.com/kaspanet/kaspad/dbaccess"
"github.com/kaspanet/kaspad/dnsseed"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/mempool"
"github.com/kaspanet/kaspad/mining"
"github.com/kaspanet/kaspad/netadapter"
@ -23,7 +24,6 @@ import (
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/panics"
"github.com/kaspanet/kaspad/wire"
)
// App is a wrapper for all the kaspad services
@ -138,8 +138,8 @@ func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrup
func (a *App) maybeSeedFromDNS() {
if !a.cfg.DisableDNSSeed {
dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, wire.SFNodeNetwork, false, nil,
a.cfg.Lookup, func(addresses []*wire.NetAddress) {
dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, domainmessage.SFNodeNetwork, false, nil,
a.cfg.Lookup, func(addresses []*domainmessage.NetAddress) {
// Kaspad uses a lookup of the dns seeder here. Since seeder returns
// IPs of nodes and not its own IP, we can not know real IP of
// source. So we'll take first returned address as source.
@ -168,6 +168,7 @@ func setupIndexes(cfg *config.Config) (blockdag.IndexManager, *indexers.Acceptan
var acceptanceIndex *indexers.AcceptanceIndex
if cfg.AcceptanceIndex {
log.Info("acceptance index is enabled")
acceptanceIndex = indexers.NewAcceptanceIndex()
indexes = append(indexes, acceptanceIndex)
}

8
blockdag/blocknode.go
View File

@ -12,8 +12,8 @@ import (
"github.com/kaspanet/kaspad/util/mstime"
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
// blockStatus is a bit field representing the validation state of the block.
@ -106,7 +106,7 @@ type blockNode struct {
// anticone of its selected parent (parent with highest blue score).
// selectedParentAnticone is used to update reachability data we store for future reachability queries.
// This function is NOT safe for concurrent access.
func (dag *BlockDAG) newBlockNode(blockHeader *wire.BlockHeader, parents blockSet) (node *blockNode, selectedParentAnticone []*blockNode) {
func (dag *BlockDAG) newBlockNode(blockHeader *domainmessage.BlockHeader, parents blockSet) (node *blockNode, selectedParentAnticone []*blockNode) {
node = &blockNode{
parents: parents,
children: make(blockSet),
@ -160,9 +160,9 @@ func (node *blockNode) less(other *blockNode) bool {
// Header constructs a block header from the node and returns it.
//
// This function is safe for concurrent access.
func (node *blockNode) Header() *wire.BlockHeader {
func (node *blockNode) Header() *domainmessage.BlockHeader {
// No lock is needed because all accessed fields are immutable.
return &wire.BlockHeader{
return &domainmessage.BlockHeader{
Version: node.version,
ParentHashes: node.ParentHashes(),
HashMerkleRoot: node.hashMerkleRoot,

12
blockdag/coinbase.go
View File

@ -7,12 +7,12 @@ import (
"io"
"github.com/kaspanet/kaspad/dbaccess"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/coinbasepayload"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/util/txsort"
"github.com/kaspanet/kaspad/wire"
"github.com/pkg/errors"
)
@ -124,8 +124,8 @@ func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceD
return nil, err
}
txIns := []*wire.TxIn{}
txOuts := []*wire.TxOut{}
txIns := []*domainmessage.TxIn{}
txOuts := []*domainmessage.TxOut{}
for _, blue := range node.blues {
txOut, err := coinbaseOutputForBlueBlock(dag, blue, txsAcceptanceData, bluesFeeData)
@ -140,7 +140,7 @@ func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceD
if err != nil {
return nil, err
}
coinbaseTx := wire.NewSubnetworkMsgTx(wire.TxVersion, txIns, txOuts, subnetworkid.SubnetworkIDCoinbase, 0, payload)
coinbaseTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, txIns, txOuts, subnetworkid.SubnetworkIDCoinbase, 0, payload)
sortedCoinbaseTx := txsort.Sort(coinbaseTx)
return util.NewTx(sortedCoinbaseTx), nil
}
@ -148,7 +148,7 @@ func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceD
// coinbaseOutputForBlueBlock calculates the output that should go into the coinbase transaction of blueBlock
// If blueBlock gets no fee - returns nil for txOut
func coinbaseOutputForBlueBlock(dag *BlockDAG, blueBlock *blockNode,
txsAcceptanceData MultiBlockTxsAcceptanceData, feeData map[daghash.Hash]compactFeeData) (*wire.TxOut, error) {
txsAcceptanceData MultiBlockTxsAcceptanceData, feeData map[daghash.Hash]compactFeeData) (*domainmessage.TxOut, error) {
blockTxsAcceptanceData, ok := txsAcceptanceData.FindAcceptanceData(blueBlock.hash)
if !ok {
@ -190,7 +190,7 @@ func coinbaseOutputForBlueBlock(dag *BlockDAG, blueBlock *blockNode,
return nil, err
}
txOut := &wire.TxOut{
txOut := &domainmessage.TxOut{
Value: totalReward,
ScriptPubKey: scriptPubKey,
}

10
blockdag/common_test.go
View File

@ -18,9 +18,9 @@ import (
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
// loadUTXOSet returns a utxo view loaded from a file.
@ -78,7 +78,7 @@ func loadUTXOSet(filename string) (UTXOSet, error) {
if err != nil {
return nil, err
}
utxoSet.utxoCollection[wire.Outpoint{TxID: txID, Index: index}] = entry
utxoSet.utxoCollection[domainmessage.Outpoint{TxID: txID, Index: index}] = entry
}
return utxoSet, nil
@ -120,7 +120,7 @@ func newTestDAG(params *dagconfig.Params) *BlockDAG {
// provided fields populated and fake values for the other fields.
func newTestNode(dag *BlockDAG, parents blockSet, blockVersion int32, bits uint32, timestamp mstime.Time) *blockNode {
// Make up a header and create a block node from it.
header := &wire.BlockHeader{
header := &domainmessage.BlockHeader{
Version: blockVersion,
ParentHashes: parents.hashes(),
Bits: bits,
@ -168,7 +168,7 @@ func checkRuleError(gotErr, wantErr error) error {
return nil
}
func prepareAndProcessBlockByParentMsgBlocks(t *testing.T, dag *BlockDAG, parents ...*wire.MsgBlock) *wire.MsgBlock {
func prepareAndProcessBlockByParentMsgBlocks(t *testing.T, dag *BlockDAG, parents ...*domainmessage.MsgBlock) *domainmessage.MsgBlock {
parentHashes := make([]*daghash.Hash, len(parents))
for i, parent := range parents {
parentHashes[i] = parent.BlockHash()
@ -176,7 +176,7 @@ func prepareAndProcessBlockByParentMsgBlocks(t *testing.T, dag *BlockDAG, parent
return PrepareAndProcessBlockForTest(t, dag, parentHashes, nil)
}
func nodeByMsgBlock(t *testing.T, dag *BlockDAG, block *wire.MsgBlock) *blockNode {
func nodeByMsgBlock(t *testing.T, dag *BlockDAG, block *domainmessage.MsgBlock) *blockNode {
node, ok := dag.index.LookupNode(block.BlockHash())
if !ok {
t.Fatalf("couldn't find block node with hash %s", block.BlockHash())

50
blockdag/dag.go
View File

@ -21,10 +21,10 @@ import (
"github.com/kaspanet/go-secp256k1"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
const (
@ -513,14 +513,14 @@ func (dag *BlockDAG) calcSequenceLock(node *blockNode, utxoSet UTXOSet, tx *util
// mask in order to obtain the time lock delta required before
// this input can be spent.
sequenceNum := txIn.Sequence
relativeLock := int64(sequenceNum & wire.SequenceLockTimeMask)
relativeLock := int64(sequenceNum & domainmessage.SequenceLockTimeMask)
switch {
// Relative time locks are disabled for this input, so we can
// skip any further calculation.
case sequenceNum&wire.SequenceLockTimeDisabled == wire.SequenceLockTimeDisabled:
case sequenceNum&domainmessage.SequenceLockTimeDisabled == domainmessage.SequenceLockTimeDisabled:
continue
case sequenceNum&wire.SequenceLockTimeIsSeconds == wire.SequenceLockTimeIsSeconds:
case sequenceNum&domainmessage.SequenceLockTimeIsSeconds == domainmessage.SequenceLockTimeIsSeconds:
// This input requires a relative time lock expressed
// in seconds before it can be spent. Therefore, we
// need to query for the block prior to the one in
@ -534,11 +534,11 @@ func (dag *BlockDAG) calcSequenceLock(node *blockNode, utxoSet UTXOSet, tx *util
medianTime := blockNode.PastMedianTime(dag)
// Time based relative time-locks have a time granularity of
// wire.SequenceLockTimeGranularity, so we shift left by this
// domainmessage.SequenceLockTimeGranularity, so we shift left by this
// amount to convert to the proper relative time-lock. We also
// subtract one from the relative lock to maintain the original
// lockTime semantics.
timeLockMilliseconds := (relativeLock << wire.SequenceLockTimeGranularity) - 1
timeLockMilliseconds := (relativeLock << domainmessage.SequenceLockTimeGranularity) - 1
timeLock := medianTime.UnixMilliseconds() + timeLockMilliseconds
if timeLock > sequenceLock.Milliseconds {
sequenceLock.Milliseconds = timeLock
@ -572,8 +572,8 @@ func LockTimeToSequence(isMilliseconds bool, locktime uint64) uint64 {
// shift the locktime over by 19 since the time granularity is in
// 524288-millisecond intervals (2^19). This results in a max lock-time of
// 34,359,214,080 seconds, or 1.1 years.
return wire.SequenceLockTimeIsSeconds |
locktime>>wire.SequenceLockTimeGranularity
return domainmessage.SequenceLockTimeIsSeconds |
locktime>>domainmessage.SequenceLockTimeGranularity
}
// addBlock handles adding the passed block to the DAG.
@ -755,7 +755,7 @@ func (node *blockNode) selectedParentMultiset(dag *BlockDAG) (*secp256k1.MultiSe
return ms, nil
}
func addTxToMultiset(ms *secp256k1.MultiSet, tx *wire.MsgTx, pastUTXO UTXOSet, blockBlueScore uint64) (*secp256k1.MultiSet, error) {
func addTxToMultiset(ms *secp256k1.MultiSet, tx *domainmessage.MsgTx, pastUTXO UTXOSet, blockBlueScore uint64) (*secp256k1.MultiSet, error) {
for _, txIn := range tx.TxIn {
entry, ok := pastUTXO.Get(txIn.PreviousOutpoint)
if !ok {
@ -771,7 +771,7 @@ func addTxToMultiset(ms *secp256k1.MultiSet, tx *wire.MsgTx, pastUTXO UTXOSet, b
isCoinbase := tx.IsCoinBase()
for i, txOut := range tx.TxOut {
outpoint := *wire.NewOutpoint(tx.TxID(), uint32(i))
outpoint := *domainmessage.NewOutpoint(tx.TxID(), uint32(i))
entry := NewUTXOEntry(txOut, isCoinbase, blockBlueScore)
var err error
@ -1485,7 +1485,7 @@ func (dag *BlockDAG) selectedTip() *blockNode {
// It will return nil if there is no tip.
//
// This function is safe for concurrent access.
func (dag *BlockDAG) SelectedTipHeader() *wire.BlockHeader {
func (dag *BlockDAG) SelectedTipHeader() *domainmessage.BlockHeader {
selectedTip := dag.selectedTip()
if selectedTip == nil {
return nil
@ -1522,7 +1522,7 @@ func (dag *BlockDAG) CalcPastMedianTime() mstime.Time {
//
// This function is safe for concurrent access. However, the returned entry (if
// any) is NOT.
func (dag *BlockDAG) GetUTXOEntry(outpoint wire.Outpoint) (*UTXOEntry, bool) {
func (dag *BlockDAG) GetUTXOEntry(outpoint domainmessage.Outpoint) (*UTXOEntry, bool) {
return dag.virtual.utxoSet.get(outpoint)
}
@ -1582,7 +1582,7 @@ func (dag *BlockDAG) BlockConfirmationsByHashNoLock(hash *daghash.Hash) (uint64,
// in the DAG's UTXO set.
//
// This function is safe for concurrent access.
func (dag *BlockDAG) UTXOConfirmations(outpoint *wire.Outpoint) (uint64, bool) {
func (dag *BlockDAG) UTXOConfirmations(outpoint *domainmessage.Outpoint) (uint64, bool) {
dag.dagLock.RLock()
defer dag.dagLock.RUnlock()
@ -1784,11 +1784,11 @@ func (dag *BlockDAG) CurrentBits() uint32 {
// HeaderByHash returns the block header identified by the given hash or an
// error if it doesn't exist.
func (dag *BlockDAG) HeaderByHash(hash *daghash.Hash) (*wire.BlockHeader, error) {
func (dag *BlockDAG) HeaderByHash(hash *daghash.Hash) (*domainmessage.BlockHeader, error) {
node, ok := dag.index.LookupNode(hash)
if !ok {
err := errors.Errorf("block %s is not known", hash)
return &wire.BlockHeader{}, err
return &domainmessage.BlockHeader{}, err
}
return node.Header(), nil
@ -1851,14 +1851,14 @@ func (dag *BlockDAG) antiPastHashesBetween(lowHash, highHash *daghash.Hash, maxH
func (dag *BlockDAG) antiPastBetween(lowHash, highHash *daghash.Hash, maxEntries uint64) ([]*blockNode, error) {
lowNode, ok := dag.index.LookupNode(lowHash)
if !ok {
return nil, errors.Errorf("Couldn't find low hash %s", lowHash)
return nil, errors.Wrapf(ErrInvalidParameter, "couldn't find low hash %s", lowHash)
}
highNode, ok := dag.index.LookupNode(highHash)
if !ok {
return nil, errors.Errorf("Couldn't find high hash %s", highHash)
return nil, errors.Wrapf(ErrInvalidParameter, "couldn't find high hash %s", highHash)
}
if lowNode.blueScore >= highNode.blueScore {
return nil, errors.Errorf("Low hash blueScore >= high hash blueScore (%d >= %d)",
return nil, errors.Wrapf(ErrInvalidParameter, "low hash blueScore >= high hash blueScore (%d >= %d)",
lowNode.blueScore, highNode.blueScore)
}
@ -1937,20 +1937,20 @@ func (dag *BlockDAG) AntiPastHashesBetween(lowHash, highHash *daghash.Hash, maxH
// max number of block headers.
//
// This function MUST be called with the DAG state lock held (for reads).
func (dag *BlockDAG) antiPastHeadersBetween(lowHash, highHash *daghash.Hash, maxHeaders uint64) ([]*wire.BlockHeader, error) {
func (dag *BlockDAG) antiPastHeadersBetween(lowHash, highHash *daghash.Hash, maxHeaders uint64) ([]*domainmessage.BlockHeader, error) {
nodes, err := dag.antiPastBetween(lowHash, highHash, maxHeaders)
if err != nil {
return nil, err
}
headers := make([]*wire.BlockHeader, len(nodes))
headers := make([]*domainmessage.BlockHeader, len(nodes))
for i, node := range nodes {
headers[i] = node.Header()
}
return headers, nil
}
// GetTopHeaders returns the top wire.MaxBlockHeadersPerMsg block headers ordered by blue score.
func (dag *BlockDAG) GetTopHeaders(highHash *daghash.Hash, maxHeaders uint64) ([]*wire.BlockHeader, error) {
// GetTopHeaders returns the top domainmessage.MaxBlockHeadersPerMsg block headers ordered by blue score.
func (dag *BlockDAG) GetTopHeaders(highHash *daghash.Hash, maxHeaders uint64) ([]*domainmessage.BlockHeader, error) {
highNode := &dag.virtual.blockNode
if highHash != nil {
var ok bool
@ -1959,7 +1959,7 @@ func (dag *BlockDAG) GetTopHeaders(highHash *daghash.Hash, maxHeaders uint64) ([
return nil, errors.Errorf("Couldn't find the high hash %s in the dag", highHash)
}
}
headers := make([]*wire.BlockHeader, 0, highNode.blueScore)
headers := make([]*domainmessage.BlockHeader, 0, highNode.blueScore)
queue := newDownHeap()
queue.pushSet(highNode.parents)
@ -1997,10 +1997,10 @@ func (dag *BlockDAG) RUnlock() {
// AntiPastHeadersBetween returns the headers of the blocks between the
// lowHash's antiPast and highHash's antiPast, or up to
// wire.MaxBlockHeadersPerMsg block headers.
// domainmessage.MaxBlockHeadersPerMsg block headers.
//
// This function is safe for concurrent access.
func (dag *BlockDAG) AntiPastHeadersBetween(lowHash, highHash *daghash.Hash, maxHeaders uint64) ([]*wire.BlockHeader, error) {
func (dag *BlockDAG) AntiPastHeadersBetween(lowHash, highHash *daghash.Hash, maxHeaders uint64) ([]*domainmessage.BlockHeader, error) {
dag.dagLock.RLock()
defer dag.dagLock.RUnlock()
headers, err := dag.antiPastHeadersBetween(lowHash, highHash, maxHeaders)

104
blockdag/dag_test.go
View File

@ -18,11 +18,11 @@ import (
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/wire"
)
func TestBlockCount(t *testing.T) {
@ -255,7 +255,7 @@ func TestCalcSequenceLock(t *testing.T) {
// Create a utxo view with a fake utxo for the inputs used in the
// transactions created below. This utxo is added such that it has an
// age of 4 blocks.
msgTx := wire.NewNativeMsgTx(wire.TxVersion, nil, []*wire.TxOut{{ScriptPubKey: nil, Value: 10}})
msgTx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, nil, []*domainmessage.TxOut{{ScriptPubKey: nil, Value: 10}})
targetTx := util.NewTx(msgTx)
utxoSet := NewFullUTXOSet()
blueScore := uint64(numBlocksToGenerate) - 4
@ -270,7 +270,7 @@ func TestCalcSequenceLock(t *testing.T) {
// that the sequence lock heights are always calculated from the same
// point of view that they were originally calculated from for a given
// utxo. That is to say, the height prior to it.
utxo := wire.Outpoint{
utxo := domainmessage.Outpoint{
TxID: *targetTx.ID(),
Index: 0,
}
@ -290,8 +290,8 @@ func TestCalcSequenceLock(t *testing.T) {
// Add an additional transaction which will serve as our unconfirmed
// output.
unConfTx := wire.NewNativeMsgTx(wire.TxVersion, nil, []*wire.TxOut{{ScriptPubKey: nil, Value: 5}})
unConfUtxo := wire.Outpoint{
unConfTx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, nil, []*domainmessage.TxOut{{ScriptPubKey: nil, Value: 5}})
unConfUtxo := domainmessage.Outpoint{
TxID: *unConfTx.TxID(),
Index: 0,
}
@ -303,7 +303,7 @@ func TestCalcSequenceLock(t *testing.T) {
tests := []struct {
name string
tx *wire.MsgTx
tx *domainmessage.MsgTx
utxoSet UTXOSet
mempool bool
want *SequenceLock
@ -313,7 +313,7 @@ func TestCalcSequenceLock(t *testing.T) {
// should be disabled.
{
name: "single input, max sequence number",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: wire.MaxTxInSequenceNum}}, nil),
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: utxo, Sequence: domainmessage.MaxTxInSequenceNum}}, nil),
utxoSet: utxoSet,
want: &SequenceLock{
Milliseconds: -1,
@ -328,7 +328,7 @@ func TestCalcSequenceLock(t *testing.T) {
// the targeted block.
{
name: "single input, milliseconds lock time below time granularity",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 2)}}, nil),
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 2)}}, nil),
utxoSet: utxoSet,
want: &SequenceLock{
Milliseconds: medianTime - 1,
@ -340,7 +340,7 @@ func TestCalcSequenceLock(t *testing.T) {
// milliseconds after the median past time of the DAG.
{
name: "single input, 1048575 milliseconds after median time",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
utxoSet: utxoSet,
want: &SequenceLock{
Milliseconds: medianTime + 1048575,
@ -355,8 +355,8 @@ func TestCalcSequenceLock(t *testing.T) {
// latest lock that isn't disabled.
{
name: "multiple varied inputs",
tx: wire.NewNativeMsgTx(1,
[]*wire.TxIn{{
tx: domainmessage.NewNativeMsgTx(1,
[]*domainmessage.TxIn{{
PreviousOutpoint: utxo,
Sequence: LockTimeToSequence(true, 2621440),
}, {
@ -365,12 +365,12 @@ func TestCalcSequenceLock(t *testing.T) {
}, {
PreviousOutpoint: utxo,
Sequence: LockTimeToSequence(false, 5) |
wire.SequenceLockTimeDisabled,
domainmessage.SequenceLockTimeDisabled,
}},
nil),
utxoSet: utxoSet,
want: &SequenceLock{
Milliseconds: medianTime + (5 << wire.SequenceLockTimeGranularity) - 1,
Milliseconds: medianTime + (5 << domainmessage.SequenceLockTimeGranularity) - 1,
BlockBlueScore: int64(prevUtxoBlueScore) + 3,
},
},
@ -380,7 +380,7 @@ func TestCalcSequenceLock(t *testing.T) {
// height of 2 meaning it can be included at height 3.
{
name: "single input, lock-time in blocks",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(false, 3)}}, nil),
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(false, 3)}}, nil),
utxoSet: utxoSet,
want: &SequenceLock{
Milliseconds: -1,
@ -392,7 +392,7 @@ func TestCalcSequenceLock(t *testing.T) {
// be the time further in the future.
{
name: "two inputs, lock-times in seconds",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{
PreviousOutpoint: utxo,
Sequence: LockTimeToSequence(true, 5242880),
}, {
@ -401,7 +401,7 @@ func TestCalcSequenceLock(t *testing.T) {
}}, nil),
utxoSet: utxoSet,
want: &SequenceLock{
Milliseconds: medianTime + (10 << wire.SequenceLockTimeGranularity) - 1,
Milliseconds: medianTime + (10 << domainmessage.SequenceLockTimeGranularity) - 1,
BlockBlueScore: -1,
},
},
@ -411,8 +411,8 @@ func TestCalcSequenceLock(t *testing.T) {
// indicating it can be included at height 11.
{
name: "two inputs, lock-times in blocks",
tx: wire.NewNativeMsgTx(1,
[]*wire.TxIn{{
tx: domainmessage.NewNativeMsgTx(1,
[]*domainmessage.TxIn{{
PreviousOutpoint: utxo,
Sequence: LockTimeToSequence(false, 1),
}, {
@ -431,8 +431,8 @@ func TestCalcSequenceLock(t *testing.T) {
// further into the future for both inputs should be chosen.
{
name: "four inputs, two lock-times in time, two lock-times in blocks",
tx: wire.NewNativeMsgTx(1,
[]*wire.TxIn{{
tx: domainmessage.NewNativeMsgTx(1,
[]*domainmessage.TxIn{{
PreviousOutpoint: utxo,
Sequence: LockTimeToSequence(true, 2621440),
}, {
@ -448,7 +448,7 @@ func TestCalcSequenceLock(t *testing.T) {
nil),
utxoSet: utxoSet,
want: &SequenceLock{
Milliseconds: medianTime + (13 << wire.SequenceLockTimeGranularity) - 1,
Milliseconds: medianTime + (13 << domainmessage.SequenceLockTimeGranularity) - 1,
BlockBlueScore: int64(prevUtxoBlueScore) + 8,
},
},
@ -460,7 +460,7 @@ func TestCalcSequenceLock(t *testing.T) {
// after that.
{
name: "single input, unconfirmed, lock-time in blocks",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(false, 2)}}, nil),
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(false, 2)}}, nil),
utxoSet: utxoSet,
mempool: true,
want: &SequenceLock{
@ -473,7 +473,7 @@ func TestCalcSequenceLock(t *testing.T) {
// MTP of the *next* block.
{
name: "single input, unconfirmed, lock-time in milliseoncds",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
utxoSet: utxoSet,
mempool: true,
want: &SequenceLock{
@ -701,7 +701,7 @@ func TestConfirmations(t *testing.T) {
}
// Add a chain of blocks
chainBlocks := make([]*wire.MsgBlock, 5)
chainBlocks := make([]*domainmessage.MsgBlock, 5)
chainBlocks[0] = dag.Params.GenesisBlock
for i := uint32(1); i < 5; i++ {
chainBlocks[i] = prepareAndProcessBlockByParentMsgBlocks(t, dag, chainBlocks[i-1])
@ -721,7 +721,7 @@ func TestConfirmations(t *testing.T) {
}
}
branchingBlocks := make([]*wire.MsgBlock, 2)
branchingBlocks := make([]*domainmessage.MsgBlock, 2)
// Add two branching blocks
branchingBlocks[0] = prepareAndProcessBlockByParentMsgBlocks(t, dag, chainBlocks[1])
branchingBlocks[1] = prepareAndProcessBlockByParentMsgBlocks(t, dag, branchingBlocks[0])
@ -794,7 +794,7 @@ func TestAcceptingBlock(t *testing.T) {
defer teardownFunc()
dag.TestSetCoinbaseMaturity(0)
acceptingBlockByMsgBlock := func(block *wire.MsgBlock) (*blockNode, error) {
acceptingBlockByMsgBlock := func(block *domainmessage.MsgBlock) (*blockNode, error) {
node := nodeByMsgBlock(t, dag, block)
return dag.acceptingBlock(node)
}
@ -810,7 +810,7 @@ func TestAcceptingBlock(t *testing.T) {
}
numChainBlocks := uint32(10)
chainBlocks := make([]*wire.MsgBlock, numChainBlocks)
chainBlocks := make([]*domainmessage.MsgBlock, numChainBlocks)
chainBlocks[0] = dag.Params.GenesisBlock
for i := uint32(1); i <= numChainBlocks-1; i++ {
chainBlocks[i] = prepareAndProcessBlockByParentMsgBlocks(t, dag, chainBlocks[i-1])
@ -1030,11 +1030,11 @@ func TestDAGIndexFailedStatus(t *testing.T) {
}
defer teardownFunc()
invalidCbTx := wire.NewSubnetworkMsgTx(wire.TxVersion, []*wire.TxIn{}, []*wire.TxOut{}, subnetworkid.SubnetworkIDCoinbase, 0, []byte{})
invalidCbTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{}, []*domainmessage.TxOut{}, subnetworkid.SubnetworkIDCoinbase, 0, []byte{})
txs := []*util.Tx{util.NewTx(invalidCbTx)}
hashMerkleRoot := BuildHashMerkleTreeStore(txs).Root()
invalidMsgBlock := wire.NewMsgBlock(
wire.NewBlockHeader(
invalidMsgBlock := domainmessage.NewMsgBlock(
domainmessage.NewBlockHeader(
1,
[]*daghash.Hash{params.GenesisHash}, hashMerkleRoot,
&daghash.Hash{},
@ -1066,8 +1066,8 @@ func TestDAGIndexFailedStatus(t *testing.T) {
t.Fatalf("invalidBlockNode status to have %b flags raised (got: %b)", statusValidateFailed, invalidBlockNode.status)
}
invalidMsgBlockChild := wire.NewMsgBlock(
wire.NewBlockHeader(1, []*daghash.Hash{
invalidMsgBlockChild := domainmessage.NewMsgBlock(
domainmessage.NewBlockHeader(1, []*daghash.Hash{
invalidBlock.Hash(),
}, hashMerkleRoot, &daghash.Hash{}, &daghash.Hash{}, dag.genesis.bits, 0),
)
@ -1095,8 +1095,8 @@ func TestDAGIndexFailedStatus(t *testing.T) {
t.Fatalf("invalidBlockNode status to have %b flags raised (got %b)", statusInvalidAncestor, invalidBlockChildNode.status)
}
invalidMsgBlockGrandChild := wire.NewMsgBlock(
wire.NewBlockHeader(1, []*daghash.Hash{
invalidMsgBlockGrandChild := domainmessage.NewMsgBlock(
domainmessage.NewBlockHeader(1, []*daghash.Hash{
invalidBlockChild.Hash(),
}, hashMerkleRoot, &daghash.Hash{}, &daghash.Hash{}, dag.genesis.bits, 0),
)
@ -1139,7 +1139,7 @@ func TestIsDAGCurrentMaxDiff(t *testing.T) {
}
}
func testProcessBlockRuleError(t *testing.T, dag *BlockDAG, block *wire.MsgBlock, expectedRuleErr error) {
func testProcessBlockRuleError(t *testing.T, dag *BlockDAG, block *domainmessage.MsgBlock, expectedRuleErr error) {
isOrphan, isDelayed, err := dag.ProcessBlock(util.NewBlock(block), BFNoPoWCheck)
err = checkRuleError(err, expectedRuleErr)
@ -1175,24 +1175,24 @@ func TestDoubleSpends(t *testing.T) {
if err != nil {
t.Fatalf("Failed to build signature script: %s", err)
}
txIn := &wire.TxIn{
PreviousOutpoint: wire.Outpoint{TxID: *cbTx.TxID(), Index: 0},
txIn := &domainmessage.TxIn{
PreviousOutpoint: domainmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
SignatureScript: signatureScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}
txOut := &wire.TxOut{
txOut := &domainmessage.TxOut{
ScriptPubKey: OpTrueScript,
Value: uint64(1),
}
tx1 := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn}, []*wire.TxOut{txOut})
tx1 := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut})
doubleSpendTxOut := &wire.TxOut{
doubleSpendTxOut := &domainmessage.TxOut{
ScriptPubKey: OpTrueScript,
Value: uint64(2),
}
doubleSpendTx1 := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn}, []*wire.TxOut{doubleSpendTxOut})
doubleSpendTx1 := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{doubleSpendTxOut})
blockWithTx1 := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{fundingBlock.BlockHash()}, []*wire.MsgTx{tx1})
blockWithTx1 := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{fundingBlock.BlockHash()}, []*domainmessage.MsgTx{tx1})
// Check that a block will be rejected if it has a transaction that already exists in its past.
anotherBlockWithTx1, err := PrepareBlockForTest(dag, []*daghash.Hash{blockWithTx1.BlockHash()}, nil)
@ -1227,7 +1227,7 @@ func TestDoubleSpends(t *testing.T) {
testProcessBlockRuleError(t, dag, blockWithDoubleSpendForTx1, ruleError(ErrMissingTxOut, ""))
blockInAnticoneOfBlockWithTx1, err := PrepareBlockForTest(dag, []*daghash.Hash{fundingBlock.BlockHash()}, []*wire.MsgTx{doubleSpendTx1})
blockInAnticoneOfBlockWithTx1, err := PrepareBlockForTest(dag, []*daghash.Hash{fundingBlock.BlockHash()}, []*domainmessage.MsgTx{doubleSpendTx1})
if err != nil {
t.Fatalf("PrepareBlockForTest: %v", err)
}
@ -1282,7 +1282,7 @@ func TestUTXOCommitment(t *testing.T) {
resetExtraNonceForTest()
createTx := func(txToSpend *wire.MsgTx) *wire.MsgTx {
createTx := func(txToSpend *domainmessage.MsgTx) *domainmessage.MsgTx {
scriptPubKey, err := txscript.PayToScriptHashScript(OpTrueScript)
if err != nil {
t.Fatalf("TestUTXOCommitment: failed to build script pub key: %s", err)
@ -1291,16 +1291,16 @@ func TestUTXOCommitment(t *testing.T) {
if err != nil {
t.Fatalf("TestUTXOCommitment: failed to build signature script: %s", err)
}
txIn := &wire.TxIn{
PreviousOutpoint: wire.Outpoint{TxID: *txToSpend.TxID(), Index: 0},
txIn := &domainmessage.TxIn{
PreviousOutpoint: domainmessage.Outpoint{TxID: *txToSpend.TxID(), Index: 0},
SignatureScript: signatureScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}
txOut := &wire.TxOut{
txOut := &domainmessage.TxOut{
ScriptPubKey: scriptPubKey,
Value: uint64(1),
}
return wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn}, []*wire.TxOut{txOut})
return domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut})
}
// Build the following DAG:
@ -1316,12 +1316,12 @@ func TestUTXOCommitment(t *testing.T) {
// Block C:
txSpendBlockACoinbase := createTx(blockA.Transactions[0])
blockCTxs := []*wire.MsgTx{txSpendBlockACoinbase}
blockCTxs := []*domainmessage.MsgTx{txSpendBlockACoinbase}
blockC := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{blockA.BlockHash()}, blockCTxs)
// Block D:
txSpendTxInBlockC := createTx(txSpendBlockACoinbase)
blockDTxs := []*wire.MsgTx{txSpendTxInBlockC}
blockDTxs := []*domainmessage.MsgTx{txSpendTxInBlockC}
blockD := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{blockB.BlockHash(), blockC.BlockHash()}, blockDTxs)
// Get the pastUTXO of blockD

22
blockdag/dagio.go
View File

@ -15,11 +15,11 @@ import (
"github.com/kaspanet/kaspad/dbaccess"
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/binaryserializer"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/wire"
)
var (
@ -49,7 +49,7 @@ func IsNotInDAGErr(err error) bool {
// keys will be iterated in an ascending order by the outpoint index.
var outpointIndexByteOrder = binary.BigEndian
func serializeOutpoint(w io.Writer, outpoint *wire.Outpoint) error {
func serializeOutpoint(w io.Writer, outpoint *domainmessage.Outpoint) error {
_, err := w.Write(outpoint.TxID[:])
if err != nil {
return err
@ -61,10 +61,10 @@ func serializeOutpoint(w io.Writer, outpoint *wire.Outpoint) error {
var outpointSerializeSize = daghash.TxIDSize + 4
// deserializeOutpoint decodes an outpoint from the passed serialized byte
// slice into a new wire.Outpoint using a format that is suitable for long-
// slice into a new domainmessage.Outpoint using a format that is suitable for long-
// term storage. This format is described in detail above.
func deserializeOutpoint(r io.Reader) (*wire.Outpoint, error) {
outpoint := &wire.Outpoint{}
func deserializeOutpoint(r io.Reader) (*domainmessage.Outpoint, error) {
outpoint := &domainmessage.Outpoint{}
_, err := r.Read(outpoint.TxID[:])
if err != nil {
return nil, err
@ -410,7 +410,7 @@ func (dag *BlockDAG) processUnprocessedBlockNodes(unprocessedBlockNodes []*block
func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
buffer := bytes.NewReader(blockRow)
var header wire.BlockHeader
var header domainmessage.BlockHeader
err := header.Deserialize(buffer)
if err != nil {
return nil, err
@ -464,7 +464,7 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
return nil, err
}
bluesCount, err := wire.ReadVarInt(buffer)
bluesCount, err := domainmessage.ReadVarInt(buffer)
if err != nil {
return nil, err
}
@ -483,7 +483,7 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
}
}
bluesAnticoneSizesLen, err := wire.ReadVarInt(buffer)
bluesAnticoneSizesLen, err := domainmessage.ReadVarInt(buffer)
if err != nil {
return nil, err
}
@ -527,7 +527,7 @@ func storeBlock(dbContext *dbaccess.TxContext, block *util.Block) error {
}
func serializeBlockNode(node *blockNode) ([]byte, error) {
w := bytes.NewBuffer(make([]byte, 0, wire.MaxBlockHeaderPayload+1))
w := bytes.NewBuffer(make([]byte, 0, domainmessage.MaxBlockHeaderPayload+1))
header := node.Header()
err := header.Serialize(w)
if err != nil {
@ -554,7 +554,7 @@ func serializeBlockNode(node *blockNode) ([]byte, error) {
return nil, err
}
err = wire.WriteVarInt(w, uint64(len(node.blues)))
err = domainmessage.WriteVarInt(w, uint64(len(node.blues)))
if err != nil {
return nil, err
}
@ -566,7 +566,7 @@ func serializeBlockNode(node *blockNode) ([]byte, error) {
}
}
err = wire.WriteVarInt(w, uint64(len(node.bluesAnticoneSizes)))
err = domainmessage.WriteVarInt(w, uint64(len(node.bluesAnticoneSizes)))
if err != nil {
return nil, err
}

4
blockdag/error.go
View File

@ -287,3 +287,7 @@ func (e RuleError) Error() string {
func ruleError(c ErrorCode, desc string) error {
return errors.WithStack(RuleError{ErrorCode: c, Description: desc})
}
// ErrInvalidParameter signifies that an invalid parameter has been
// supplied to one of the BlockDAG functions.
var ErrInvalidParameter = errors.New("invalid parameter")

108
blockdag/external_dag_test.go
View File

@ -15,10 +15,10 @@ import (
"github.com/kaspanet/kaspad/blockdag"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/mining"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/wire"
)
// TestFinality checks that the finality mechanism works as expected.
@ -125,7 +125,7 @@ func TestFinality(t *testing.T) {
t.Errorf("NextBlockCoinbaseTransaction: %s", err)
}
merkleRoot := blockdag.BuildHashMerkleTreeStore([]*util.Tx{fakeCoinbaseTx}).Root()
beforeFinalityBlock := wire.NewMsgBlock(&wire.BlockHeader{
beforeFinalityBlock := domainmessage.NewMsgBlock(&domainmessage.BlockHeader{
Version: 0x10000000,
ParentHashes: []*daghash.Hash{genesis.Hash()},
HashMerkleRoot: merkleRoot,
@ -164,7 +164,7 @@ func TestFinality(t *testing.T) {
}
// TestFinalityInterval tests that the finality interval is
// smaller then wire.MaxInvPerMsg, so when a peer receives
// smaller then domainmessage.MaxInvPerMsg, so when a peer receives
// a getblocks message it should always be able to send
// all the necessary invs.
func TestFinalityInterval(t *testing.T) {
@ -185,8 +185,8 @@ func TestFinalityInterval(t *testing.T) {
}
defer teardownFunc()
if dag.FinalityInterval() > wire.MaxInvPerMsg {
t.Errorf("FinalityInterval in %s should be lower or equal to wire.MaxInvPerMsg", params.Name)
if dag.FinalityInterval() > domainmessage.MaxInvPerMsg {
t.Errorf("FinalityInterval in %s should be lower or equal to domainmessage.MaxInvPerMsg", params.Name)
}
}()
}
@ -253,34 +253,34 @@ func TestChainedTransactions(t *testing.T) {
if err != nil {
t.Fatalf("Failed to build signature script: %s", err)
}
txIn := &wire.TxIn{
PreviousOutpoint: wire.Outpoint{TxID: *cbTx.TxID(), Index: 0},
txIn := &domainmessage.TxIn{
PreviousOutpoint: domainmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
SignatureScript: signatureScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}
txOut := &wire.TxOut{
txOut := &domainmessage.TxOut{
ScriptPubKey: blockdag.OpTrueScript,
Value: uint64(1),
}
tx := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn}, []*wire.TxOut{txOut})
tx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut})
chainedTxIn := &wire.TxIn{
PreviousOutpoint: wire.Outpoint{TxID: *tx.TxID(), Index: 0},
chainedTxIn := &domainmessage.TxIn{
PreviousOutpoint: domainmessage.Outpoint{TxID: *tx.TxID(), Index: 0},
SignatureScript: signatureScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}
scriptPubKey, err := txscript.PayToScriptHashScript(blockdag.OpTrueScript)
if err != nil {
t.Fatalf("Failed to build public key script: %s", err)
}
chainedTxOut := &wire.TxOut{
chainedTxOut := &domainmessage.TxOut{
ScriptPubKey: scriptPubKey,
Value: uint64(1),
}
chainedTx := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{chainedTxIn}, []*wire.TxOut{chainedTxOut})
chainedTx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{chainedTxIn}, []*domainmessage.TxOut{chainedTxOut})
block2, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*wire.MsgTx{tx}, false)
block2, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*domainmessage.MsgTx{tx}, false)
if err != nil {
t.Fatalf("PrepareBlockForTest: %v", err)
}
@ -315,18 +315,18 @@ func TestChainedTransactions(t *testing.T) {
t.Errorf("ProcessBlock: block2 got unexpectedly orphaned")
}
nonChainedTxIn := &wire.TxIn{
PreviousOutpoint: wire.Outpoint{TxID: *cbTx.TxID(), Index: 0},
nonChainedTxIn := &domainmessage.TxIn{
PreviousOutpoint: domainmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
SignatureScript: signatureScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}
nonChainedTxOut := &wire.TxOut{
nonChainedTxOut := &domainmessage.TxOut{
ScriptPubKey: scriptPubKey,
Value: uint64(1),
}
nonChainedTx := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{nonChainedTxIn}, []*wire.TxOut{nonChainedTxOut})
nonChainedTx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{nonChainedTxIn}, []*domainmessage.TxOut{nonChainedTxOut})
block3, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*wire.MsgTx{nonChainedTx}, false)
block3, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*domainmessage.MsgTx{nonChainedTx}, false)
if err != nil {
t.Fatalf("PrepareBlockForTest: %v", err)
}
@ -363,23 +363,23 @@ func TestOrderInDiffFromAcceptanceData(t *testing.T) {
createBlock := func(previousBlock *util.Block) *util.Block {
// Prepare a transaction that spends the previous block's coinbase transaction
var txs []*wire.MsgTx
var txs []*domainmessage.MsgTx
if !previousBlock.IsGenesis() {
previousCoinbaseTx := previousBlock.MsgBlock().Transactions[0]
signatureScript, err := txscript.PayToScriptHashSignatureScript(blockdag.OpTrueScript, nil)
if err != nil {
t.Fatalf("TestOrderInDiffFromAcceptanceData: Failed to build signature script: %s", err)
}
txIn := &wire.TxIn{
PreviousOutpoint: wire.Outpoint{TxID: *previousCoinbaseTx.TxID(), Index: 0},
txIn := &domainmessage.TxIn{
PreviousOutpoint: domainmessage.Outpoint{TxID: *previousCoinbaseTx.TxID(), Index: 0},
SignatureScript: signatureScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}
txOut := &wire.TxOut{
txOut := &domainmessage.TxOut{
ScriptPubKey: blockdag.OpTrueScript,
Value: uint64(1),
}
txs = append(txs, wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn}, []*wire.TxOut{txOut}))
txs = append(txs, domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut}))
}
// Create the block
@ -438,7 +438,7 @@ func TestGasLimit(t *testing.T) {
t.Fatalf("could not register network: %s", err)
}
cbTxs := []*wire.MsgTx{}
cbTxs := []*domainmessage.MsgTx{}
for i := 0; i < 4; i++ {
fundsBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), nil, false)
if err != nil {
@ -469,30 +469,30 @@ func TestGasLimit(t *testing.T) {
t.Fatalf("Failed to build public key script: %s", err)
}
tx1In := &wire.TxIn{
PreviousOutpoint: *wire.NewOutpoint(cbTxs[0].TxID(), 0),
Sequence: wire.MaxTxInSequenceNum,
tx1In := &domainmessage.TxIn{
PreviousOutpoint: *domainmessage.NewOutpoint(cbTxs[0].TxID(), 0),
Sequence: domainmessage.MaxTxInSequenceNum,
SignatureScript: signatureScript,
}
tx1Out := &wire.TxOut{
tx1Out := &domainmessage.TxOut{
Value: cbTxs[0].TxOut[0].Value,
ScriptPubKey: scriptPubKey,
}
tx1 := wire.NewSubnetworkMsgTx(wire.TxVersion, []*wire.TxIn{tx1In}, []*wire.TxOut{tx1Out}, subnetworkID, 10000, []byte{})
tx1 := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{tx1In}, []*domainmessage.TxOut{tx1Out}, subnetworkID, 10000, []byte{})
tx2In := &wire.TxIn{
PreviousOutpoint: *wire.NewOutpoint(cbTxs[1].TxID(), 0),
Sequence: wire.MaxTxInSequenceNum,
tx2In := &domainmessage.TxIn{
PreviousOutpoint: *domainmessage.NewOutpoint(cbTxs[1].TxID(), 0),
Sequence: domainmessage.MaxTxInSequenceNum,
SignatureScript: signatureScript,
}
tx2Out := &wire.TxOut{
tx2Out := &domainmessage.TxOut{
Value: cbTxs[1].TxOut[0].Value,
ScriptPubKey: scriptPubKey,
}
tx2 := wire.NewSubnetworkMsgTx(wire.TxVersion, []*wire.TxIn{tx2In}, []*wire.TxOut{tx2Out}, subnetworkID, 10000, []byte{})
tx2 := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{tx2In}, []*domainmessage.TxOut{tx2Out}, subnetworkID, 10000, []byte{})
// Here we check that we can't process a block that has transactions that exceed the gas limit
overLimitBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*wire.MsgTx{tx1, tx2}, true)
overLimitBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*domainmessage.MsgTx{tx1, tx2}, true)
if err != nil {
t.Fatalf("PrepareBlockForTest: %v", err)
}
@ -514,20 +514,20 @@ func TestGasLimit(t *testing.T) {
t.Fatalf("ProcessBlock: overLimitBlock got unexpectedly orphan")
}
overflowGasTxIn := &wire.TxIn{
PreviousOutpoint: *wire.NewOutpoint(cbTxs[2].TxID(), 0),
Sequence: wire.MaxTxInSequenceNum,
overflowGasTxIn := &domainmessage.TxIn{
PreviousOutpoint: *domainmessage.NewOutpoint(cbTxs[2].TxID(), 0),
Sequence: domainmessage.MaxTxInSequenceNum,
SignatureScript: signatureScript,
}
overflowGasTxOut := &wire.TxOut{
overflowGasTxOut := &domainmessage.TxOut{
Value: cbTxs[2].TxOut[0].Value,
ScriptPubKey: scriptPubKey,
}
overflowGasTx := wire.NewSubnetworkMsgTx(wire.TxVersion, []*wire.TxIn{overflowGasTxIn}, []*wire.TxOut{overflowGasTxOut},
overflowGasTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{overflowGasTxIn}, []*domainmessage.TxOut{overflowGasTxOut},
subnetworkID, math.MaxUint64, []byte{})
// Here we check that we can't process a block that its transactions' gas overflows uint64
overflowGasBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*wire.MsgTx{tx1, overflowGasTx}, true)
overflowGasBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*domainmessage.MsgTx{tx1, overflowGasTx}, true)
if err != nil {
t.Fatalf("PrepareBlockForTest: %v", err)
}
@ -549,19 +549,19 @@ func TestGasLimit(t *testing.T) {
}
nonExistentSubnetwork := &subnetworkid.SubnetworkID{123}
nonExistentSubnetworkTxIn := &wire.TxIn{
PreviousOutpoint: *wire.NewOutpoint(cbTxs[3].TxID(), 0),
Sequence: wire.MaxTxInSequenceNum,
nonExistentSubnetworkTxIn := &domainmessage.TxIn{
PreviousOutpoint: *domainmessage.NewOutpoint(cbTxs[3].TxID(), 0),
Sequence: domainmessage.MaxTxInSequenceNum,
SignatureScript: signatureScript,
}
nonExistentSubnetworkTxOut := &wire.TxOut{
nonExistentSubnetworkTxOut := &domainmessage.TxOut{
Value: cbTxs[3].TxOut[0].Value,
ScriptPubKey: scriptPubKey,
}
nonExistentSubnetworkTx := wire.NewSubnetworkMsgTx(wire.TxVersion, []*wire.TxIn{nonExistentSubnetworkTxIn},
[]*wire.TxOut{nonExistentSubnetworkTxOut}, nonExistentSubnetwork, 1, []byte{})
nonExistentSubnetworkTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{nonExistentSubnetworkTxIn},
[]*domainmessage.TxOut{nonExistentSubnetworkTxOut}, nonExistentSubnetwork, 1, []byte{})
nonExistentSubnetworkBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*wire.MsgTx{nonExistentSubnetworkTx, overflowGasTx}, true)
nonExistentSubnetworkBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*domainmessage.MsgTx{nonExistentSubnetworkTx, overflowGasTx}, true)
if err != nil {
t.Fatalf("PrepareBlockForTest: %v", err)
}
@ -582,7 +582,7 @@ func TestGasLimit(t *testing.T) {
}
// Here we check that we can process a block with a transaction that doesn't exceed the gas limit
validBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*wire.MsgTx{tx1}, true)
validBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*domainmessage.MsgTx{tx1}, true)
if err != nil {
t.Fatalf("PrepareBlockForTest: %v", err)
}

4
blockdag/indexers/acceptanceindex.go
View File

@ -6,9 +6,9 @@ import (
"github.com/kaspanet/kaspad/blockdag"
"github.com/kaspanet/kaspad/dbaccess"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
// AcceptanceIndex implements a txAcceptanceData by block hash index. That is to say,
@ -113,7 +113,7 @@ func (idx *AcceptanceIndex) TxsAcceptanceData(blockHash *daghash.Hash) (blockdag
}
type serializableTxAcceptanceData struct {
MsgTx wire.MsgTx
MsgTx domainmessage.MsgTx
IsAccepted bool
}

14
blockdag/indexers/acceptanceindex_test.go
View File

@ -12,28 +12,28 @@ import (
"github.com/kaspanet/kaspad/blockdag"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/dbaccess"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
"github.com/pkg/errors"
)
func TestAcceptanceIndexSerializationAndDeserialization(t *testing.T) {
// Create test data
hash, _ := daghash.NewHashFromStr("1111111111111111111111111111111111111111111111111111111111111111")
txIn1 := &wire.TxIn{SignatureScript: []byte{1}, PreviousOutpoint: wire.Outpoint{Index: 1}, Sequence: 0}
txIn2 := &wire.TxIn{SignatureScript: []byte{2}, PreviousOutpoint: wire.Outpoint{Index: 2}, Sequence: 0}
txOut1 := &wire.TxOut{ScriptPubKey: []byte{1}, Value: 10}
txOut2 := &wire.TxOut{ScriptPubKey: []byte{2}, Value: 20}
txIn1 := &domainmessage.TxIn{SignatureScript: []byte{1}, PreviousOutpoint: domainmessage.Outpoint{Index: 1}, Sequence: 0}
txIn2 := &domainmessage.TxIn{SignatureScript: []byte{2}, PreviousOutpoint: domainmessage.Outpoint{Index: 2}, Sequence: 0}
txOut1 := &domainmessage.TxOut{ScriptPubKey: []byte{1}, Value: 10}
txOut2 := &domainmessage.TxOut{ScriptPubKey: []byte{2}, Value: 20}
blockTxsAcceptanceData := blockdag.BlockTxsAcceptanceData{
BlockHash: *hash,
TxAcceptanceData: []blockdag.TxAcceptanceData{
{
Tx: util.NewTx(wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn1}, []*wire.TxOut{txOut1})),
Tx: util.NewTx(domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn1}, []*domainmessage.TxOut{txOut1})),
IsAccepted: true,
},
{
Tx: util.NewTx(wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn2}, []*wire.TxOut{txOut2})),
Tx: util.NewTx(domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn2}, []*domainmessage.TxOut{txOut2})),
IsAccepted: false,
},
},

8
blockdag/mining.go
View File

@ -6,11 +6,11 @@ import (
"time"
"github.com/kaspanet/go-secp256k1"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/mstime"
"github.com/kaspanet/kaspad/wire"
)
// BlockForMining returns a block with the given transactions
@ -18,7 +18,7 @@ import (
// all aspects except proof of work.
//
// This function MUST be called with the DAG state lock held (for reads).
func (dag *BlockDAG) BlockForMining(transactions []*util.Tx) (*wire.MsgBlock, error) {
func (dag *BlockDAG) BlockForMining(transactions []*util.Tx) (*domainmessage.MsgBlock, error) {
blockTimestamp := dag.NextBlockTime()
requiredDifficulty := dag.NextRequiredDifficulty(blockTimestamp)
@ -35,7 +35,7 @@ func (dag *BlockDAG) BlockForMining(transactions []*util.Tx) (*wire.MsgBlock, er
if err != nil {
return nil, err
}
var msgBlock wire.MsgBlock
var msgBlock domainmessage.MsgBlock
for _, tx := range transactions {
msgBlock.AddTransaction(tx.MsgTx())
}
@ -45,7 +45,7 @@ func (dag *BlockDAG) BlockForMining(transactions []*util.Tx) (*wire.MsgBlock, er
return nil, err
}
msgBlock.Header = wire.BlockHeader{
msgBlock.Header = domainmessage.BlockHeader{
Version: nextBlockVersion,
ParentHashes: dag.TipHashes(),
HashMerkleRoot: hashMerkleTree.Root(),

30
blockdag/reachabilitystore.go
View File

@ -4,8 +4,8 @@ import (
"bytes"
"github.com/kaspanet/kaspad/database"
"github.com/kaspanet/kaspad/dbaccess"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
"github.com/pkg/errors"
"io"
)
@ -225,20 +225,20 @@ func (store *reachabilityStore) serializeTreeNode(w io.Writer, treeNode *reachab
if treeNode.parent != nil {
parentHash = treeNode.parent.blockNode.hash
}
err = wire.WriteElement(w, parentHash)
err = domainmessage.WriteElement(w, parentHash)
if err != nil {
return err
}
// Serialize the amount of children
err = wire.WriteVarInt(w, uint64(len(treeNode.children)))
err = domainmessage.WriteVarInt(w, uint64(len(treeNode.children)))
if err != nil {
return err
}
// Serialize the children
for _, child := range treeNode.children {
err = wire.WriteElement(w, child.blockNode.hash)
err = domainmessage.WriteElement(w, child.blockNode.hash)
if err != nil {
return err
}
@ -249,13 +249,13 @@ func (store *reachabilityStore) serializeTreeNode(w io.Writer, treeNode *reachab
func (store *reachabilityStore) serializeReachabilityInterval(w io.Writer, interval *reachabilityInterval) error {
// Serialize start
err := wire.WriteElement(w, interval.start)
err := domainmessage.WriteElement(w, interval.start)
if err != nil {
return err
}
// Serialize end
err = wire.WriteElement(w, interval.end)
err = domainmessage.WriteElement(w, interval.end)
if err != nil {
return err
}
@ -265,14 +265,14 @@ func (store *reachabilityStore) serializeReachabilityInterval(w io.Writer, inter
func (store *reachabilityStore) serializeFutureCoveringSet(w io.Writer, futureCoveringSet futureCoveringTreeNodeSet) error {
// Serialize the set size
err := wire.WriteVarInt(w, uint64(len(futureCoveringSet)))
err := domainmessage.WriteVarInt(w, uint64(len(futureCoveringSet)))
if err != nil {
return err
}
// Serialize each node in the set
for _, node := range futureCoveringSet {
err = wire.WriteElement(w, node.blockNode.hash)
err = domainmessage.WriteElement(w, node.blockNode.hash)
if err != nil {
return err
}
@ -312,7 +312,7 @@ func (store *reachabilityStore) deserializeTreeNode(r io.Reader, destination *re
// Deserialize the parent
// If this is the zero hash, this node is the genesis and as such doesn't have a parent
parentHash := &daghash.Hash{}
err = wire.ReadElement(r, parentHash)
err = domainmessage.ReadElement(r, parentHash)
if err != nil {
return err
}
@ -325,7 +325,7 @@ func (store *reachabilityStore) deserializeTreeNode(r io.Reader, destination *re
}
// Deserialize the amount of children
childCount, err := wire.ReadVarInt(r)
childCount, err := domainmessage.ReadVarInt(r)
if err != nil {
return err
}
@ -334,7 +334,7 @@ func (store *reachabilityStore) deserializeTreeNode(r io.Reader, destination *re
children := make([]*reachabilityTreeNode, childCount)
for i := uint64(0); i < childCount; i++ {
childHash := &daghash.Hash{}
err = wire.ReadElement(r, childHash)
err = domainmessage.ReadElement(r, childHash)
if err != nil {
return err
}
@ -354,7 +354,7 @@ func (store *reachabilityStore) deserializeReachabilityInterval(r io.Reader) (*r
// Deserialize start
start := uint64(0)
err := wire.ReadElement(r, &start)
err := domainmessage.ReadElement(r, &start)
if err != nil {
return nil, err
}
@ -362,7 +362,7 @@ func (store *reachabilityStore) deserializeReachabilityInterval(r io.Reader) (*r
// Deserialize end
end := uint64(0)
err = wire.ReadElement(r, &end)
err = domainmessage.ReadElement(r, &end)
if err != nil {
return nil, err
}
@ -373,7 +373,7 @@ func (store *reachabilityStore) deserializeReachabilityInterval(r io.Reader) (*r
func (store *reachabilityStore) deserializeFutureCoveringSet(r io.Reader, destination *reachabilityData) error {
// Deserialize the set size
setSize, err := wire.ReadVarInt(r)
setSize, err := domainmessage.ReadVarInt(r)
if err != nil {
return err
}
@ -382,7 +382,7 @@ func (store *reachabilityStore) deserializeFutureCoveringSet(r io.Reader, destin
futureCoveringSet := make(futureCoveringTreeNodeSet, setSize)
for i := uint64(0); i < setSize; i++ {
blockHash := &daghash.Hash{}
err = wire.ReadElement(r, blockHash)
err = domainmessage.ReadElement(r, blockHash)
if err != nil {
return err
}

4
blockdag/scriptval.go
View File

@ -9,15 +9,15 @@ import (
"runtime"
"time"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/wire"
)
// txValidateItem holds a transaction along with which input to validate.
type txValidateItem struct {
txInIndex int
txIn *wire.TxIn
txIn *domainmessage.TxIn
tx *util.Tx
}

12
blockdag/subnetworks.go
View File

@ -10,8 +10,8 @@ import (
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/wire"
)
// registerSubnetworks scans a list of transactions, singles out
@ -19,7 +19,7 @@ import (
// subnetwork based on it.
// This function returns an error if one or more transactions are invalid
func registerSubnetworks(dbContext dbaccess.Context, txs []*util.Tx) error {
subnetworkRegistryTxs := make([]*wire.MsgTx, 0)
subnetworkRegistryTxs := make([]*domainmessage.MsgTx, 0)
for _, tx := range txs {
msgTx := tx.MsgTx()
@ -60,7 +60,7 @@ func registerSubnetworks(dbContext dbaccess.Context, txs []*util.Tx) error {
// 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 *domainmessage.MsgTx) error {
if len(tx.Payload) != 8 {
return ruleError(ErrSubnetworkRegistry, fmt.Sprintf("validation failed: subnetwork registry"+
"tx '%s' has an invalid payload", tx.TxHash()))
@ -70,7 +70,7 @@ func validateSubnetworkRegistryTransaction(tx *wire.MsgTx) error {
}
// TxToSubnetworkID creates a subnetwork ID from a subnetwork registry transaction
func TxToSubnetworkID(tx *wire.MsgTx) (*subnetworkid.SubnetworkID, error) {
func TxToSubnetworkID(tx *domainmessage.MsgTx) (*subnetworkid.SubnetworkID, error) {
txHash := tx.TxHash()
return subnetworkid.New(util.Hash160(txHash[:]))
}
@ -114,14 +114,14 @@ type subnetwork struct {
gasLimit uint64
}
func newSubnetwork(tx *wire.MsgTx) *subnetwork {
func newSubnetwork(tx *domainmessage.MsgTx) *subnetwork {
return &subnetwork{
gasLimit: ExtractGasLimit(tx),
}
}
// ExtractGasLimit extracts the gas limit from the transaction payload
func ExtractGasLimit(tx *wire.MsgTx) uint64 {
func ExtractGasLimit(tx *domainmessage.MsgTx) uint64 {
return binary.LittleEndian.Uint64(tx.Payload[:8])
}

26
blockdag/test_utils.go
View File

@ -22,9 +22,9 @@ import (
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
// FileExists returns whether or not the named file or directory exists.
@ -121,30 +121,30 @@ type txSubnetworkData struct {
Payload []byte
}
func createTxForTest(numInputs uint32, numOutputs uint32, outputValue uint64, subnetworkData *txSubnetworkData) *wire.MsgTx {
txIns := []*wire.TxIn{}
txOuts := []*wire.TxOut{}
func createTxForTest(numInputs uint32, numOutputs uint32, outputValue uint64, subnetworkData *txSubnetworkData) *domainmessage.MsgTx {
txIns := []*domainmessage.TxIn{}
txOuts := []*domainmessage.TxOut{}
for i := uint32(0); i < numInputs; i++ {
txIns = append(txIns, &wire.TxIn{
PreviousOutpoint: *wire.NewOutpoint(&daghash.TxID{}, i),
txIns = append(txIns, &domainmessage.TxIn{
PreviousOutpoint: *domainmessage.NewOutpoint(&daghash.TxID{}, i),
SignatureScript: []byte{},
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
})
}
for i := uint32(0); i < numOutputs; i++ {
txOuts = append(txOuts, &wire.TxOut{
txOuts = append(txOuts, &domainmessage.TxOut{
ScriptPubKey: OpTrueScript,
Value: outputValue,
})
}
if subnetworkData != nil {
return wire.NewSubnetworkMsgTx(wire.TxVersion, txIns, txOuts, subnetworkData.subnetworkID, subnetworkData.Gas, subnetworkData.Payload)
return domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, txIns, txOuts, subnetworkData.subnetworkID, subnetworkData.Gas, subnetworkData.Payload)
}
return wire.NewNativeMsgTx(wire.TxVersion, txIns, txOuts)
return domainmessage.NewNativeMsgTx(domainmessage.TxVersion, txIns, txOuts)
}
// VirtualForTest is an exported version for virtualBlock, so that it can be returned by exported test_util methods
@ -186,7 +186,7 @@ func GetVirtualFromParentsForTest(dag *BlockDAG, parentHashes []*daghash.Hash) (
// LoadBlocks reads files containing kaspa gzipped block data from disk
// and returns them as an array of util.Block.
func LoadBlocks(filename string) (blocks []*util.Block, err error) {
var network = wire.Mainnet
var network = domainmessage.Mainnet
var dr io.Reader
var fi io.ReadCloser
@ -244,7 +244,7 @@ func opTrueAddress(prefix util.Bech32Prefix) (util.Address, error) {
}
// PrepareBlockForTest generates a block with the proper merkle roots, coinbase transaction etc. This function is used for test purposes only
func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*wire.MsgTx) (*wire.MsgBlock, error) {
func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*domainmessage.MsgTx) (*domainmessage.MsgBlock, error) {
newVirtual, err := GetVirtualFromParentsForTest(dag, parentHashes)
if err != nil {
return nil, err
@ -297,7 +297,7 @@ func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactio
// PrepareAndProcessBlockForTest prepares a block that points to the given parent
// hashes and process it.
func PrepareAndProcessBlockForTest(t *testing.T, dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*wire.MsgTx) *wire.MsgBlock {
func PrepareAndProcessBlockForTest(t *testing.T, dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*domainmessage.MsgTx) *domainmessage.MsgBlock {
daghash.Sort(parentHashes)
block, err := PrepareBlockForTest(dag, parentHashes, transactions)
if err != nil {

6
blockdag/utxo_ecmh.go
View File

@ -3,10 +3,10 @@ package blockdag
import (
"bytes"
"github.com/kaspanet/go-secp256k1"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
func addUTXOToMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *wire.Outpoint) (*secp256k1.MultiSet, error) {
func addUTXOToMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *domainmessage.Outpoint) (*secp256k1.MultiSet, error) {
w := &bytes.Buffer{}
err := serializeUTXO(w, entry, outpoint)
if err != nil {
@ -16,7 +16,7 @@ func addUTXOToMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *wire.
return ms, nil
}
func removeUTXOFromMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *wire.Outpoint) (*secp256k1.MultiSet, error) {
func removeUTXOFromMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *domainmessage.Outpoint) (*secp256k1.MultiSet, error) {
w := &bytes.Buffer{}
err := serializeUTXO(w, entry, outpoint)
if err != nil {

6
blockdag/utxodiffstore_test.go
View File

@ -6,8 +6,8 @@ import (
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/dbaccess"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
func TestUTXODiffStore(t *testing.T) {
@ -42,8 +42,8 @@ func TestUTXODiffStore(t *testing.T) {
// Add node's diff data to the utxoDiffStore and check if it's checked correctly.
node := createNode()
diff := NewUTXODiff()
diff.toAdd.add(wire.Outpoint{TxID: daghash.TxID{0x01}, Index: 0}, &UTXOEntry{amount: 1, scriptPubKey: []byte{0x01}})
diff.toRemove.add(wire.Outpoint{TxID: daghash.TxID{0x02}, Index: 0}, &UTXOEntry{amount: 2, scriptPubKey: []byte{0x02}})
diff.toAdd.add(domainmessage.Outpoint{TxID: daghash.TxID{0x01}, Index: 0}, &UTXOEntry{amount: 1, scriptPubKey: []byte{0x01}})
diff.toRemove.add(domainmessage.Outpoint{TxID: daghash.TxID{0x02}, Index: 0}, &UTXOEntry{amount: 2, scriptPubKey: []byte{0x02}})
if err := dag.utxoDiffStore.setBlockDiff(node, diff); err != nil {
t.Fatalf("setBlockDiff: unexpected error: %s", err)
}

24
blockdag/utxoio.go
View File

@ -2,9 +2,9 @@ package blockdag
import (
"bytes"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/binaryserializer"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
"github.com/pkg/errors"
"io"
)
@ -17,12 +17,12 @@ import (
// diff | UTXODiff | The diff data's diff
func serializeBlockUTXODiffData(w io.Writer, diffData *blockUTXODiffData) error {
hasDiffChild := diffData.diffChild != nil
err := wire.WriteElement(w, hasDiffChild)
err := domainmessage.WriteElement(w, hasDiffChild)
if err != nil {
return err
}
if hasDiffChild {
err := wire.WriteElement(w, diffData.diffChild.hash)
err := domainmessage.WriteElement(w, diffData.diffChild.hash)
if err != nil {
return err
}
@ -41,14 +41,14 @@ func (diffStore *utxoDiffStore) deserializeBlockUTXODiffData(serializedDiffData
r := bytes.NewBuffer(serializedDiffData)
var hasDiffChild bool
err := wire.ReadElement(r, &hasDiffChild)
err := domainmessage.ReadElement(r, &hasDiffChild)
if err != nil {
return nil, err
}
if hasDiffChild {
hash := &daghash.Hash{}
err := wire.ReadElement(r, hash)
err := domainmessage.ReadElement(r, hash)
if err != nil {
return nil, err
}
@ -86,7 +86,7 @@ func deserializeUTXODiff(r io.Reader) (*UTXODiff, error) {
}
func deserializeUTXOCollection(r io.Reader) (utxoCollection, error) {
count, err := wire.ReadVarInt(r)
count, err := domainmessage.ReadVarInt(r)
if err != nil {
return nil, err
}
@ -101,7 +101,7 @@ func deserializeUTXOCollection(r io.Reader) (utxoCollection, error) {
return collection, nil
}
func deserializeUTXO(r io.Reader) (*UTXOEntry, *wire.Outpoint, error) {
func deserializeUTXO(r io.Reader) (*UTXOEntry, *domainmessage.Outpoint, error) {
outpoint, err := deserializeOutpoint(r)
if err != nil {
return nil, nil, err
@ -134,7 +134,7 @@ func serializeUTXODiff(w io.Writer, diff *UTXODiff) error {
// the utxo entries and serializing them and their corresponding outpoint
// prefixed by a varint that indicates their size.
func serializeUTXOCollection(w io.Writer, collection utxoCollection) error {
err := wire.WriteVarInt(w, uint64(len(collection)))
err := domainmessage.WriteVarInt(w, uint64(len(collection)))
if err != nil {
return err
}
@ -148,7 +148,7 @@ func serializeUTXOCollection(w io.Writer, collection utxoCollection) error {
}
// serializeUTXO serializes a utxo entry-outpoint pair
func serializeUTXO(w io.Writer, entry *UTXOEntry, outpoint *wire.Outpoint) error {
func serializeUTXO(w io.Writer, entry *UTXOEntry, outpoint *domainmessage.Outpoint) error {
err := serializeOutpoint(w, outpoint)
if err != nil {
return err
@ -163,7 +163,7 @@ func serializeUTXO(w io.Writer, entry *UTXOEntry, outpoint *wire.Outpoint) error
// p2pkhUTXOEntrySerializeSize is the serialized size for a P2PKH UTXO entry.
// 8 bytes (header code) + 8 bytes (amount) + varint for script pub key length of 25 (for P2PKH) + 25 bytes for P2PKH script.
var p2pkhUTXOEntrySerializeSize = 8 + 8 + wire.VarIntSerializeSize(25) + 25
var p2pkhUTXOEntrySerializeSize = 8 + 8 + domainmessage.VarIntSerializeSize(25) + 25
// serializeUTXOEntry encodes the entry to the given io.Writer and use compression if useCompression is true.
// The compression format is described in detail above.
@ -185,7 +185,7 @@ func serializeUTXOEntry(w io.Writer, entry *UTXOEntry) error {
return err
}
err = wire.WriteVarInt(w, uint64(len(entry.ScriptPubKey())))
err = domainmessage.WriteVarInt(w, uint64(len(entry.ScriptPubKey())))
if err != nil {
return err
}
@ -225,7 +225,7 @@ func deserializeUTXOEntry(r io.Reader) (*UTXOEntry, error) {
return nil, err
}
scriptPubKeyLen, err := wire.ReadVarInt(r)
scriptPubKeyLen, err := domainmessage.ReadVarInt(r)
if err != nil {
return nil, err
}

46
blockdag/utxoset.go
View File

@ -9,7 +9,7 @@ import (
"github.com/pkg/errors"
"github.com/kaspanet/go-secp256k1"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
const (
@ -78,7 +78,7 @@ const (
)
// NewUTXOEntry creates a new utxoEntry representing the given txOut
func NewUTXOEntry(txOut *wire.TxOut, isCoinbase bool, blockBlueScore uint64) *UTXOEntry {
func NewUTXOEntry(txOut *domainmessage.TxOut, isCoinbase bool, blockBlueScore uint64) *UTXOEntry {
entry := &UTXOEntry{
amount: txOut.Value,
scriptPubKey: txOut.ScriptPubKey,
@ -93,7 +93,7 @@ func NewUTXOEntry(txOut *wire.TxOut, isCoinbase bool, blockBlueScore uint64) *UT
}
// utxoCollection represents a set of UTXOs indexed by their outpoints
type utxoCollection map[wire.Outpoint]*UTXOEntry
type utxoCollection map[domainmessage.Outpoint]*UTXOEntry
func (uc utxoCollection) String() string {
utxoStrings := make([]string, len(uc))
@ -112,31 +112,31 @@ func (uc utxoCollection) String() string {
}
// add adds a new UTXO entry to this collection
func (uc utxoCollection) add(outpoint wire.Outpoint, entry *UTXOEntry) {
func (uc utxoCollection) add(outpoint domainmessage.Outpoint, entry *UTXOEntry) {
uc[outpoint] = entry
}
// remove removes a UTXO entry from this collection if it exists
func (uc utxoCollection) remove(outpoint wire.Outpoint) {
func (uc utxoCollection) remove(outpoint domainmessage.Outpoint) {
delete(uc, outpoint)
}
// get returns the UTXOEntry represented by provided outpoint,
// and a boolean value indicating if said UTXOEntry is in the set or not
func (uc utxoCollection) get(outpoint wire.Outpoint) (*UTXOEntry, bool) {
func (uc utxoCollection) get(outpoint domainmessage.Outpoint) (*UTXOEntry, bool) {
entry, ok := uc[outpoint]
return entry, ok
}
// contains returns a boolean value indicating whether a UTXO entry is in the set
func (uc utxoCollection) contains(outpoint wire.Outpoint) bool {
func (uc utxoCollection) contains(outpoint domainmessage.Outpoint) bool {
_, ok := uc[outpoint]
return ok
}
// containsWithBlueScore returns a boolean value indicating whether a UTXOEntry
// is in the set and its blue score is equal to the given blue score.
func (uc utxoCollection) containsWithBlueScore(outpoint wire.Outpoint, blueScore uint64) bool {
func (uc utxoCollection) containsWithBlueScore(outpoint domainmessage.Outpoint, blueScore uint64) bool {
entry, ok := uc.get(outpoint)
return ok && entry.blockBlueScore == blueScore
}
@ -353,7 +353,7 @@ func (d *UTXODiff) clone() *UTXODiff {
//
// If d.useMultiset is true, this function MUST be
// called with the DAG lock held.
func (d *UTXODiff) AddEntry(outpoint wire.Outpoint, entry *UTXOEntry) error {
func (d *UTXODiff) AddEntry(outpoint domainmessage.Outpoint, entry *UTXOEntry) error {
if d.toRemove.containsWithBlueScore(outpoint, entry.blockBlueScore) {
d.toRemove.remove(outpoint)
} else if _, exists := d.toAdd[outpoint]; exists {
@ -368,7 +368,7 @@ func (d *UTXODiff) AddEntry(outpoint wire.Outpoint, entry *UTXOEntry) error {
//
// If d.useMultiset is true, this function MUST be
// called with the DAG lock held.
func (d *UTXODiff) RemoveEntry(outpoint wire.Outpoint, entry *UTXOEntry) error {
func (d *UTXODiff) RemoveEntry(outpoint domainmessage.Outpoint, entry *UTXOEntry) error {
if d.toAdd.containsWithBlueScore(outpoint, entry.blockBlueScore) {
d.toAdd.remove(outpoint)
} else if _, exists := d.toRemove[outpoint]; exists {
@ -399,9 +399,9 @@ type UTXOSet interface {
fmt.Stringer
diffFrom(other UTXOSet) (*UTXODiff, error)
WithDiff(utxoDiff *UTXODiff) (UTXOSet, error)
AddTx(tx *wire.MsgTx, blockBlueScore uint64) (ok bool, err error)
AddTx(tx *domainmessage.MsgTx, blockBlueScore uint64) (ok bool, err error)
clone() UTXOSet
Get(outpoint wire.Outpoint) (*UTXOEntry, bool)
Get(outpoint domainmessage.Outpoint) (*UTXOEntry, bool)
}
// FullUTXOSet represents a full list of transaction outputs and their values
@ -456,7 +456,7 @@ func (fus *FullUTXOSet) WithDiff(other *UTXODiff) (UTXOSet, error) {
// necessarily means there's an error).
//
// This function MUST be called with the DAG lock held.
func (fus *FullUTXOSet) AddTx(tx *wire.MsgTx, blueScore uint64) (isAccepted bool, err error) {
func (fus *FullUTXOSet) AddTx(tx *domainmessage.MsgTx, blueScore uint64) (isAccepted bool, err error) {
if !fus.containsInputs(tx) {
return false, nil
}
@ -467,7 +467,7 @@ func (fus *FullUTXOSet) AddTx(tx *wire.MsgTx, blueScore uint64) (isAccepted bool
isCoinbase := tx.IsCoinBase()
for i, txOut := range tx.TxOut {
outpoint := *wire.NewOutpoint(tx.TxID(), uint32(i))
outpoint := *domainmessage.NewOutpoint(tx.TxID(), uint32(i))
entry := NewUTXOEntry(txOut, isCoinbase, blueScore)
fus.add(outpoint, entry)
}
@ -475,9 +475,9 @@ func (fus *FullUTXOSet) AddTx(tx *wire.MsgTx, blueScore uint64) (isAccepted bool
return true, nil
}
func (fus *FullUTXOSet) containsInputs(tx *wire.MsgTx) bool {
func (fus *FullUTXOSet) containsInputs(tx *domainmessage.MsgTx) bool {
for _, txIn := range tx.TxIn {
outpoint := *wire.NewOutpoint(&txIn.PreviousOutpoint.TxID, txIn.PreviousOutpoint.Index)
outpoint := *domainmessage.NewOutpoint(&txIn.PreviousOutpoint.TxID, txIn.PreviousOutpoint.Index)
if !fus.contains(outpoint) {
return false
}
@ -492,7 +492,7 @@ func (fus *FullUTXOSet) clone() UTXOSet {
}
// Get returns the UTXOEntry associated with the given Outpoint, and a boolean indicating if such entry was found
func (fus *FullUTXOSet) Get(outpoint wire.Outpoint) (*UTXOEntry, bool) {
func (fus *FullUTXOSet) Get(outpoint domainmessage.Outpoint) (*UTXOEntry, bool) {
utxoEntry, ok := fus.utxoCollection[outpoint]
return utxoEntry, ok
}
@ -540,7 +540,7 @@ func (dus *DiffUTXOSet) WithDiff(other *UTXODiff) (UTXOSet, error) {
//
// If dus.UTXODiff.useMultiset is true, this function MUST be
// called with the DAG lock held.
func (dus *DiffUTXOSet) AddTx(tx *wire.MsgTx, blockBlueScore uint64) (bool, error) {
func (dus *DiffUTXOSet) AddTx(tx *domainmessage.MsgTx, blockBlueScore uint64) (bool, error) {
if !dus.containsInputs(tx) {
return false, nil
}
@ -553,7 +553,7 @@ func (dus *DiffUTXOSet) AddTx(tx *wire.MsgTx, blockBlueScore uint64) (bool, erro
return true, nil
}
func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockBlueScore uint64) error {
func (dus *DiffUTXOSet) appendTx(tx *domainmessage.MsgTx, blockBlueScore uint64) error {
for _, txIn := range tx.TxIn {
entry, ok := dus.Get(txIn.PreviousOutpoint)
if !ok {
@ -567,7 +567,7 @@ func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockBlueScore uint64) error {
isCoinbase := tx.IsCoinBase()
for i, txOut := range tx.TxOut {
outpoint := *wire.NewOutpoint(tx.TxID(), uint32(i))
outpoint := *domainmessage.NewOutpoint(tx.TxID(), uint32(i))
entry := NewUTXOEntry(txOut, isCoinbase, blockBlueScore)
err := dus.UTXODiff.AddEntry(outpoint, entry)
@ -578,9 +578,9 @@ func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockBlueScore uint64) error {
return nil
}
func (dus *DiffUTXOSet) containsInputs(tx *wire.MsgTx) bool {
func (dus *DiffUTXOSet) containsInputs(tx *domainmessage.MsgTx) bool {
for _, txIn := range tx.TxIn {
outpoint := *wire.NewOutpoint(&txIn.PreviousOutpoint.TxID, txIn.PreviousOutpoint.Index)
outpoint := *domainmessage.NewOutpoint(&txIn.PreviousOutpoint.TxID, txIn.PreviousOutpoint.Index)
isInBase := dus.base.contains(outpoint)
isInDiffToAdd := dus.UTXODiff.toAdd.contains(outpoint)
isInDiffToRemove := dus.UTXODiff.toRemove.contains(outpoint)
@ -626,7 +626,7 @@ func (dus *DiffUTXOSet) cloneWithoutBase() UTXOSet {
// Get returns the UTXOEntry associated with provided outpoint in this UTXOSet.
// Returns false in second output if this UTXOEntry was not found
func (dus *DiffUTXOSet) Get(outpoint wire.Outpoint) (*UTXOEntry, bool) {
func (dus *DiffUTXOSet) Get(outpoint domainmessage.Outpoint) (*UTXOEntry, bool) {
if toRemoveEntry, ok := dus.UTXODiff.toRemove.get(outpoint); ok {
// An exception is made for entries with unequal blue scores
// These are just "updates" to accepted blue score

90
blockdag/utxoset_test.go
View File

@ -6,18 +6,18 @@ import (
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
// TestUTXOCollection makes sure that utxoCollection cloning and string representations work as expected.
func TestUTXOCollection(t *testing.T) {
txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outpoint0 := *wire.NewOutpoint(txID0, 0)
outpoint1 := *wire.NewOutpoint(txID1, 0)
utxoEntry0 := NewUTXOEntry(&wire.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
utxoEntry1 := NewUTXOEntry(&wire.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
outpoint1 := *domainmessage.NewOutpoint(txID1, 0)
utxoEntry0 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
utxoEntry1 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
// For each of the following test cases, we will:
// .String() the given collection and compare it to expectedStringWithMultiset
@ -73,10 +73,10 @@ func TestUTXOCollection(t *testing.T) {
func TestUTXODiff(t *testing.T) {
txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outpoint0 := *wire.NewOutpoint(txID0, 0)
outpoint1 := *wire.NewOutpoint(txID1, 0)
utxoEntry0 := NewUTXOEntry(&wire.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
utxoEntry1 := NewUTXOEntry(&wire.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
outpoint1 := *domainmessage.NewOutpoint(txID1, 0)
utxoEntry0 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
utxoEntry1 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
// Test utxoDiff creation
@ -119,9 +119,9 @@ func TestUTXODiff(t *testing.T) {
// Each test case represents a cell in the two tables outlined in the documentation for utxoDiff.
func TestUTXODiffRules(t *testing.T) {
txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
outpoint0 := *wire.NewOutpoint(txID0, 0)
utxoEntry1 := NewUTXOEntry(&wire.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 10)
utxoEntry2 := NewUTXOEntry(&wire.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 20)
outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
utxoEntry1 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 10)
utxoEntry2 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 20)
// For each of the following test cases, we will:
// this.diffFrom(other) and compare it to expectedDiffFromResult
@ -630,10 +630,10 @@ func (dus *DiffUTXOSet) equal(other *DiffUTXOSet) bool {
func TestFullUTXOSet(t *testing.T) {
txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outpoint0 := *wire.NewOutpoint(txID0, 0)
outpoint1 := *wire.NewOutpoint(txID1, 0)
txOut0 := &wire.TxOut{ScriptPubKey: []byte{}, Value: 10}
txOut1 := &wire.TxOut{ScriptPubKey: []byte{}, Value: 20}
outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
outpoint1 := *domainmessage.NewOutpoint(txID1, 0)
txOut0 := &domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}
txOut1 := &domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}
utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
utxoEntry1 := NewUTXOEntry(txOut1, false, 1)
diff := &UTXODiff{
@ -661,8 +661,8 @@ func TestFullUTXOSet(t *testing.T) {
}
// Test fullUTXOSet addTx
txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutpoint: wire.Outpoint{TxID: *txID0, Index: 0}, Sequence: 0}
transaction0 := wire.NewNativeMsgTx(1, []*wire.TxIn{txIn0}, []*wire.TxOut{txOut0})
txIn0 := &domainmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: domainmessage.Outpoint{TxID: *txID0, Index: 0}, Sequence: 0}
transaction0 := domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{txIn0}, []*domainmessage.TxOut{txOut0})
if isAccepted, err := emptySet.AddTx(transaction0, 0); err != nil {
t.Errorf("AddTx unexpectedly failed: %s", err)
} else if isAccepted {
@ -694,10 +694,10 @@ func TestFullUTXOSet(t *testing.T) {
func TestDiffUTXOSet(t *testing.T) {
txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outpoint0 := *wire.NewOutpoint(txID0, 0)
outpoint1 := *wire.NewOutpoint(txID1, 0)
txOut0 := &wire.TxOut{ScriptPubKey: []byte{}, Value: 10}
txOut1 := &wire.TxOut{ScriptPubKey: []byte{}, Value: 20}
outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
outpoint1 := *domainmessage.NewOutpoint(txID1, 0)
txOut0 := &domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}
txOut1 := &domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}
utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
utxoEntry1 := NewUTXOEntry(txOut1, false, 1)
diff := &UTXODiff{
@ -946,29 +946,29 @@ func TestUTXOSetDiffRules(t *testing.T) {
// TestDiffUTXOSet_addTx makes sure that diffUTXOSet addTx works as expected
func TestDiffUTXOSet_addTx(t *testing.T) {
txOut0 := &wire.TxOut{ScriptPubKey: []byte{0}, Value: 10}
txOut0 := &domainmessage.TxOut{ScriptPubKey: []byte{0}, Value: 10}
utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
coinbaseTX := wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, []*wire.TxOut{txOut0}, subnetworkid.SubnetworkIDCoinbase, 0, nil)
coinbaseTX := domainmessage.NewSubnetworkMsgTx(1, []*domainmessage.TxIn{}, []*domainmessage.TxOut{txOut0}, subnetworkid.SubnetworkIDCoinbase, 0, nil)
// transaction1 spends coinbaseTX
id1 := coinbaseTX.TxID()
outpoint1 := *wire.NewOutpoint(id1, 0)
txIn1 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutpoint: outpoint1, Sequence: 0}
txOut1 := &wire.TxOut{ScriptPubKey: []byte{1}, Value: 20}
outpoint1 := *domainmessage.NewOutpoint(id1, 0)
txIn1 := &domainmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: outpoint1, Sequence: 0}
txOut1 := &domainmessage.TxOut{ScriptPubKey: []byte{1}, Value: 20}
utxoEntry1 := NewUTXOEntry(txOut1, false, 1)
transaction1 := wire.NewNativeMsgTx(1, []*wire.TxIn{txIn1}, []*wire.TxOut{txOut1})
transaction1 := domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{txIn1}, []*domainmessage.TxOut{txOut1})
// transaction2 spends transaction1
id2 := transaction1.TxID()
outpoint2 := *wire.NewOutpoint(id2, 0)
txIn2 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutpoint: outpoint2, Sequence: 0}
txOut2 := &wire.TxOut{ScriptPubKey: []byte{2}, Value: 30}
outpoint2 := *domainmessage.NewOutpoint(id2, 0)
txIn2 := &domainmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: outpoint2, Sequence: 0}
txOut2 := &domainmessage.TxOut{ScriptPubKey: []byte{2}, Value: 30}
utxoEntry2 := NewUTXOEntry(txOut2, false, 2)
transaction2 := wire.NewNativeMsgTx(1, []*wire.TxIn{txIn2}, []*wire.TxOut{txOut2})
transaction2 := domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{txIn2}, []*domainmessage.TxOut{txOut2})
// outpoint3 is the outpoint for transaction2
id3 := transaction2.TxID()
outpoint3 := *wire.NewOutpoint(id3, 0)
outpoint3 := *domainmessage.NewOutpoint(id3, 0)
// For each of the following test cases, we will:
// 1. startSet.addTx() all the transactions in toAdd, in order, with the initial block height startHeight
@ -977,14 +977,14 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
name string
startSet *DiffUTXOSet
startHeight uint64
toAdd []*wire.MsgTx
toAdd []*domainmessage.MsgTx
expectedSet *DiffUTXOSet
}{
{
name: "add coinbase transaction to empty set",
startSet: NewDiffUTXOSet(NewFullUTXOSet(), NewUTXODiff()),
startHeight: 0,
toAdd: []*wire.MsgTx{coinbaseTX},
toAdd: []*domainmessage.MsgTx{coinbaseTX},
expectedSet: &DiffUTXOSet{
base: &FullUTXOSet{utxoCollection: utxoCollection{}},
UTXODiff: &UTXODiff{
@ -997,7 +997,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
name: "add regular transaction to empty set",
startSet: NewDiffUTXOSet(NewFullUTXOSet(), NewUTXODiff()),
startHeight: 0,
toAdd: []*wire.MsgTx{transaction1},
toAdd: []*domainmessage.MsgTx{transaction1},
expectedSet: &DiffUTXOSet{
base: &FullUTXOSet{utxoCollection: utxoCollection{}},
UTXODiff: &UTXODiff{
@ -1016,7 +1016,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
},
},
startHeight: 1,
toAdd: []*wire.MsgTx{transaction1},
toAdd: []*domainmessage.MsgTx{transaction1},
expectedSet: &DiffUTXOSet{
base: &FullUTXOSet{utxoCollection: utxoCollection{outpoint1: utxoEntry0}},
UTXODiff: &UTXODiff{
@ -1035,7 +1035,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
},
},
startHeight: 1,
toAdd: []*wire.MsgTx{transaction1},
toAdd: []*domainmessage.MsgTx{transaction1},
expectedSet: &DiffUTXOSet{
base: NewFullUTXOSet(),
UTXODiff: &UTXODiff{
@ -1054,7 +1054,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
},
},
startHeight: 1,
toAdd: []*wire.MsgTx{transaction1},
toAdd: []*domainmessage.MsgTx{transaction1},
expectedSet: &DiffUTXOSet{
base: NewFullUTXOSet(),
UTXODiff: &UTXODiff{
@ -1073,7 +1073,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
},
},
startHeight: 1,
toAdd: []*wire.MsgTx{transaction1, transaction2},
toAdd: []*domainmessage.MsgTx{transaction1, transaction2},
expectedSet: &DiffUTXOSet{
base: &FullUTXOSet{utxoCollection: utxoCollection{outpoint1: utxoEntry0}},
UTXODiff: &UTXODiff{
@ -1125,16 +1125,16 @@ func (dus *DiffUTXOSet) collection() (utxoCollection, error) {
func TestUTXOSetAddEntry(t *testing.T) {
txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outpoint0 := wire.NewOutpoint(txID0, 0)
outpoint1 := wire.NewOutpoint(txID1, 0)
utxoEntry0 := NewUTXOEntry(&wire.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
utxoEntry1 := NewUTXOEntry(&wire.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
outpoint0 := domainmessage.NewOutpoint(txID0, 0)
outpoint1 := domainmessage.NewOutpoint(txID1, 0)
utxoEntry0 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
utxoEntry1 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
utxoDiff := NewUTXODiff()
tests := []struct {
name string
outpointToAdd *wire.Outpoint
outpointToAdd *domainmessage.Outpoint
utxoEntryToAdd *UTXOEntry
expectedUTXODiff *UTXODiff
expectedError string

38
blockdag/validate.go
View File

@ -14,11 +14,11 @@ import (
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/wire"
)
const (
@ -46,7 +46,7 @@ const (
// isNullOutpoint determines whether or not a previous transaction outpoint
// is set.
func isNullOutpoint(outpoint *wire.Outpoint) bool {
func isNullOutpoint(outpoint *domainmessage.Outpoint) bool {
if outpoint.Index == math.MaxUint32 && outpoint.TxID == daghash.ZeroTxID {
return true
}
@ -171,7 +171,7 @@ func CheckTransactionSanity(tx *util.Tx, subnetworkID *subnetworkid.SubnetworkID
}
// Check for duplicate transaction inputs.
existingTxOut := make(map[wire.Outpoint]struct{})
existingTxOut := make(map[domainmessage.Outpoint]struct{})
for _, txIn := range msgTx.TxIn {
if _, exists := existingTxOut[txIn.PreviousOutpoint]; exists {
return ruleError(ErrDuplicateTxInputs, "transaction "+
@ -255,7 +255,7 @@ func CheckTransactionSanity(tx *util.Tx, subnetworkID *subnetworkid.SubnetworkID
// The flags modify the behavior of this function as follows:
// - BFNoPoWCheck: The check to ensure the block hash is less than the target
// difficulty is not performed.
func (dag *BlockDAG) checkProofOfWork(header *wire.BlockHeader, flags BehaviorFlags) error {
func (dag *BlockDAG) checkProofOfWork(header *domainmessage.BlockHeader, flags BehaviorFlags) error {
// The target difficulty must be larger than zero.
target := util.CompactToBig(header.Bits)
if target.Sign() <= 0 {
@ -295,9 +295,9 @@ func ValidateTxMass(tx *util.Tx, utxoSet UTXOSet) error {
if err != nil {
return err
}
if txMass > wire.MaxMassPerBlock {
if txMass > domainmessage.MaxMassPerBlock {
str := fmt.Sprintf("tx %s has mass %d, which is above the "+
"allowed limit of %d", tx.ID(), txMass, wire.MaxMassPerBlock)
"allowed limit of %d", tx.ID(), txMass, domainmessage.MaxMassPerBlock)
return ruleError(ErrTxMassTooHigh, str)
}
return nil
@ -321,9 +321,9 @@ func CalcBlockMass(pastUTXO UTXOSet, transactions []*util.Tx) (uint64, error) {
// We could potentially overflow the accumulator so check for
// overflow as well.
if totalMass < txMass || totalMass > wire.MaxMassPerBlock {
if totalMass < txMass || totalMass > domainmessage.MaxMassPerBlock {
str := fmt.Sprintf("block has total mass %d, which is "+
"above the allowed limit of %d", totalMass, wire.MaxMassPerBlock)
"above the allowed limit of %d", totalMass, domainmessage.MaxMassPerBlock)
return 0, ruleError(ErrBlockMassTooHigh, str)
}
}
@ -426,7 +426,7 @@ func (dag *BlockDAG) checkBlockHeaderSanity(block *util.Block, flags BehaviorFla
}
//checkBlockParentsOrder ensures that the block's parents are ordered by hash
func checkBlockParentsOrder(header *wire.BlockHeader) error {
func checkBlockParentsOrder(header *domainmessage.BlockHeader) error {
sortedHashes := make([]*daghash.Hash, header.NumParentBlocks())
for i, hash := range header.ParentHashes {
sortedHashes[i] = hash
@ -512,9 +512,9 @@ func (dag *BlockDAG) checkBlockContainsLessThanMaxBlockMassTransactions(block *u
// else it is certainly over the block mass limit.
transactions := block.Transactions()
numTx := len(transactions)
if numTx > wire.MaxMassPerBlock {
if numTx > domainmessage.MaxMassPerBlock {
str := fmt.Sprintf("block contains too many transactions - "+
"got %d, max %d", numTx, wire.MaxMassPerBlock)
"got %d, max %d", numTx, domainmessage.MaxMassPerBlock)
return ruleError(ErrBlockMassTooHigh, str)
}
return nil
@ -608,7 +608,7 @@ func (dag *BlockDAG) checkBlockDuplicateTransactions(block *util.Block) error {
}
func (dag *BlockDAG) checkBlockDoubleSpends(block *util.Block) error {
usedOutpoints := make(map[wire.Outpoint]*daghash.TxID)
usedOutpoints := make(map[domainmessage.Outpoint]*daghash.TxID)
transactions := block.Transactions()
for _, tx := range transactions {
for _, txIn := range tx.MsgTx().TxIn {
@ -631,7 +631,7 @@ func (dag *BlockDAG) checkBlockDoubleSpends(block *util.Block) error {
// - BFFastAdd: No checks are performed.
//
// This function MUST be called with the dag state lock held (for writes).
func (dag *BlockDAG) checkBlockHeaderContext(header *wire.BlockHeader, bluestParent *blockNode, fastAdd bool) error {
func (dag *BlockDAG) checkBlockHeaderContext(header *domainmessage.BlockHeader, bluestParent *blockNode, fastAdd bool) error {
if !fastAdd {
if err := dag.validateDifficulty(header, bluestParent); err != nil {
return err
@ -644,7 +644,7 @@ func (dag *BlockDAG) checkBlockHeaderContext(header *wire.BlockHeader, bluestPar
return nil
}
func validateMedianTime(dag *BlockDAG, header *wire.BlockHeader, bluestParent *blockNode) error {
func validateMedianTime(dag *BlockDAG, header *domainmessage.BlockHeader, bluestParent *blockNode) error {
if !header.IsGenesis() {
// Ensure the timestamp for the block header is not before the
// median time of the last several blocks (medianTimeBlocks).
@ -658,7 +658,7 @@ func validateMedianTime(dag *BlockDAG, header *wire.BlockHeader, bluestParent *b
return nil
}
func (dag *BlockDAG) validateDifficulty(header *wire.BlockHeader, bluestParent *blockNode) error {
func (dag *BlockDAG) validateDifficulty(header *domainmessage.BlockHeader, bluestParent *blockNode) error {
// Ensure the difficulty specified in the block header matches
// the calculated difficulty based on the previous block and
// difficulty retarget rules.
@ -674,7 +674,7 @@ func (dag *BlockDAG) validateDifficulty(header *wire.BlockHeader, bluestParent *
}
// validateParents validates that no parent is an ancestor of another parent, and no parent is finalized
func (dag *BlockDAG) validateParents(blockHeader *wire.BlockHeader, parents blockSet) error {
func (dag *BlockDAG) validateParents(blockHeader *domainmessage.BlockHeader, parents blockSet) error {
for parentA := range parents {
// isFinalized might be false-negative because node finality status is
// updated in a separate goroutine. This is why later the block is
@ -765,9 +765,9 @@ func (dag *BlockDAG) validateAllTxsFinalized(block *util.Block, node *blockNode,
func ensureNoDuplicateTx(utxoSet UTXOSet, transactions []*util.Tx) error {
// Fetch utxos for all of the transaction ouputs in this block.
// Typically, there will not be any utxos for any of the outputs.
fetchSet := make(map[wire.Outpoint]struct{})
fetchSet := make(map[domainmessage.Outpoint]struct{})
for _, tx := range transactions {
prevOut := wire.Outpoint{TxID: *tx.ID()}
prevOut := domainmessage.Outpoint{TxID: *tx.ID()}
for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx)
fetchSet[prevOut] = struct{}{}
@ -874,7 +874,7 @@ func CheckTransactionInputsAndCalulateFee(tx *util.Tx, txBlueScore uint64, utxoS
return txFeeInSompi, nil
}
func validateCoinbaseMaturity(dagParams *dagconfig.Params, entry *UTXOEntry, txBlueScore uint64, txIn *wire.TxIn) error {
func validateCoinbaseMaturity(dagParams *dagconfig.Params, entry *UTXOEntry, txBlueScore uint64, txIn *domainmessage.TxIn) error {
// Ensure the transaction is not spending coins which have not
// yet reached the required coinbase maturity.
if entry.IsCoinbase() {

114
blockdag/validate_test.go
View File

@ -15,10 +15,10 @@ import (
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/wire"
)
// TestSequenceLocksActive tests the SequenceLockActive function to ensure it
@ -196,8 +196,8 @@ func TestCheckBlockSanity(t *testing.T) {
t.Errorf("CheckBlockSanity: unexpected return %s delay", delay)
}
var invalidParentsOrderBlock = wire.MsgBlock{
Header: wire.BlockHeader{
var invalidParentsOrderBlock = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 0x10000000,
ParentHashes: []*daghash.Hash{
{
@ -235,12 +235,12 @@ func TestCheckBlockSanity(t *testing.T) {
Bits: 0x207fffff,
Nonce: 0x1,
},
Transactions: []*wire.MsgTx{
Transactions: []*domainmessage.MsgTx{
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID{},
Index: 0xffffffff,
},
@ -252,7 +252,7 @@ func TestCheckBlockSanity(t *testing.T) {
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0x12a05f200, // 5000000000
ScriptPubKey: []byte{
@ -265,9 +265,9 @@ func TestCheckBlockSanity(t *testing.T) {
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
@ -302,7 +302,7 @@ func TestCheckBlockSanity(t *testing.T) {
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0x2123e300, // 556000000
ScriptPubKey: []byte{
@ -335,9 +335,9 @@ func TestCheckBlockSanity(t *testing.T) {
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
@ -371,7 +371,7 @@ func TestCheckBlockSanity(t *testing.T) {
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0xf4240, // 1000000
ScriptPubKey: []byte{
@ -404,9 +404,9 @@ func TestCheckBlockSanity(t *testing.T) {
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
@ -441,7 +441,7 @@ func TestCheckBlockSanity(t *testing.T) {
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0xf4240, // 1000000
ScriptPubKey: []byte{
@ -563,7 +563,7 @@ func TestValidateParents(t *testing.T) {
bNode := nodeByMsgBlock(t, dag, b)
cNode := nodeByMsgBlock(t, dag, c)
fakeBlockHeader := &wire.BlockHeader{
fakeBlockHeader := &domainmessage.BlockHeader{
HashMerkleRoot: &daghash.ZeroHash,
AcceptedIDMerkleRoot: &daghash.ZeroHash,
UTXOCommitment: &daghash.ZeroHash,
@ -596,7 +596,7 @@ func TestCheckTransactionSanity(t *testing.T) {
outputValue uint64
nodeSubnetworkID subnetworkid.SubnetworkID
txSubnetworkData *txSubnetworkData
extraModificationsFunc func(*wire.MsgTx)
extraModificationsFunc func(*domainmessage.MsgTx)
expectedErr error
}{
{"good one", 1, 1, 1, *subnetworkid.SubnetworkIDNative, nil, nil, nil},
@ -615,7 +615,7 @@ func TestCheckTransactionSanity(t *testing.T) {
{"duplicate inputs", 2, 1, 1,
*subnetworkid.SubnetworkIDNative,
nil,
func(tx *wire.MsgTx) { tx.TxIn[1].PreviousOutpoint.Index = 0 },
func(tx *domainmessage.MsgTx) { tx.TxIn[1].PreviousOutpoint.Index = 0 },
ruleError(ErrDuplicateTxInputs, "")},
{"1 input coinbase",
1,
@ -669,14 +669,14 @@ func TestCheckTransactionSanity(t *testing.T) {
{"invalid payload hash", 1, 1, 0,
subnetworkid.SubnetworkID{123},
&txSubnetworkData{&subnetworkid.SubnetworkID{123}, 0, []byte{1}},
func(tx *wire.MsgTx) {
func(tx *domainmessage.MsgTx) {
tx.PayloadHash = &daghash.Hash{}
},
ruleError(ErrInvalidPayloadHash, "")},
{"invalid payload hash in native subnetwork", 1, 1, 0,
*subnetworkid.SubnetworkIDNative,
nil,
func(tx *wire.MsgTx) {
func(tx *domainmessage.MsgTx) {
tx.PayloadHash = daghash.DoubleHashP(tx.Payload)
},
ruleError(ErrInvalidPayloadHash, "")},
@ -699,8 +699,8 @@ func TestCheckTransactionSanity(t *testing.T) {
// Block100000 defines block 100,000 of the block DAG. It is used to
// test Block operations.
var Block100000 = wire.MsgBlock{
Header: wire.BlockHeader{
var Block100000 = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 0x10000000,
ParentHashes: []*daghash.Hash{
{
@ -733,12 +733,12 @@ var Block100000 = wire.MsgBlock{
Bits: 0x207fffff,
Nonce: 1,
},
Transactions: []*wire.MsgTx{
Transactions: []*domainmessage.MsgTx{
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID{
0x9b, 0x22, 0x59, 0x44, 0x66, 0xf0, 0xbe, 0x50,
0x7c, 0x1c, 0x8a, 0xf6, 0x06, 0x27, 0xe6, 0x33,
@ -751,7 +751,7 @@ var Block100000 = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0x12a05f200, // 5000000000
ScriptPubKey: []byte{
@ -773,9 +773,9 @@ var Block100000 = wire.MsgBlock{
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID{
0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95,
0xd9, 0xc6, 0x41, 0xf3, 0xb8, 0xee, 0xc2, 0xf3,
@ -787,7 +787,7 @@ var Block100000 = wire.MsgBlock{
Sequence: math.MaxUint64,
},
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID{
0x4b, 0xb0, 0x75, 0x35, 0xdf, 0xd5, 0x8e, 0x0b,
0x3c, 0xd6, 0x4f, 0xd7, 0x15, 0x52, 0x80, 0x87,
@ -803,9 +803,9 @@ var Block100000 = wire.MsgBlock{
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
@ -840,7 +840,7 @@ var Block100000 = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0x2123e300, // 556000000
ScriptPubKey: []byte{
@ -873,9 +873,9 @@ var Block100000 = wire.MsgBlock{
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
@ -909,7 +909,7 @@ var Block100000 = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0xf4240, // 1000000
ScriptPubKey: []byte{
@ -942,9 +942,9 @@ var Block100000 = wire.MsgBlock{
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
@ -979,7 +979,7 @@ var Block100000 = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0xf4240, // 1000000
ScriptPubKey: []byte{
@ -1001,8 +1001,8 @@ var Block100000 = wire.MsgBlock{
}
// BlockWithWrongTxOrder defines invalid block 100,000 of the block DAG.
var BlockWithWrongTxOrder = wire.MsgBlock{
Header: wire.BlockHeader{
var BlockWithWrongTxOrder = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 1,
ParentHashes: []*daghash.Hash{
{
@ -1040,12 +1040,12 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
Bits: 0x207fffff,
Nonce: 1,
},
Transactions: []*wire.MsgTx{
Transactions: []*domainmessage.MsgTx{
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID{
0x9b, 0x22, 0x59, 0x44, 0x66, 0xf0, 0xbe, 0x50,
0x7c, 0x1c, 0x8a, 0xf6, 0x06, 0x27, 0xe6, 0x33,
@ -1058,7 +1058,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0x12a05f200, // 5000000000
ScriptPubKey: []byte{
@ -1080,9 +1080,9 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID{
0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95,
0xd9, 0xc6, 0x41, 0xf3, 0xb8, 0xee, 0xc2, 0xf3,
@ -1094,7 +1094,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
Sequence: math.MaxUint64,
},
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID{
0x4b, 0xb0, 0x75, 0x35, 0xdf, 0xd5, 0x8e, 0x0b,
0x3c, 0xd6, 0x4f, 0xd7, 0x15, 0x52, 0x80, 0x87,
@ -1110,9 +1110,9 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
@ -1147,7 +1147,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0x2123e300, // 556000000
ScriptPubKey: []byte{
@ -1182,9 +1182,9 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
@ -1218,7 +1218,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0xf4240, // 1000000
ScriptPubKey: []byte{
@ -1251,9 +1251,9 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
},
{
Version: 1,
TxIn: []*wire.TxIn{
TxIn: []*domainmessage.TxIn{
{
PreviousOutpoint: wire.Outpoint{
PreviousOutpoint: domainmessage.Outpoint{
TxID: daghash.TxID([32]byte{
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
@ -1288,7 +1288,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
Sequence: math.MaxUint64,
},
},
TxOut: []*wire.TxOut{
TxOut: []*domainmessage.TxOut{
{
Value: 0xf4240, // 1000000
ScriptPubKey: []byte{

6
cmd/addblock/import.go
View File

@ -14,8 +14,8 @@ import (
"time"
"github.com/kaspanet/kaspad/blockdag"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/wire"
)
// importResults houses the stats and result as an import operation.
@ -68,10 +68,10 @@ func (bi *blockImporter) readBlock() ([]byte, error) {
if err := binary.Read(bi.r, binary.LittleEndian, &blockLen); err != nil {
return nil, err
}
if blockLen > wire.MaxMessagePayload {
if blockLen > domainmessage.MaxMessagePayload {
return nil, errors.Errorf("block payload of %d bytes is larger "+
"than the max allowed %d bytes", blockLen,
wire.MaxMessagePayload)
domainmessage.MaxMessagePayload)
}
serializedBlock := make([]byte, blockLen)

4
cmd/kaspaminer/client.go
View File

@ -1,9 +1,9 @@
package main
import (
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/rpc/client"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/wire"
"github.com/pkg/errors"
"io/ioutil"
"time"
@ -19,7 +19,7 @@ func newMinerClient(connCfg *client.ConnConfig) (*minerClient, error) {
onBlockAdded: make(chan struct{}, 1),
}
notificationHandlers := &client.NotificationHandlers{
OnFilteredBlockAdded: func(_ uint64, header *wire.BlockHeader,
OnFilteredBlockAdded: func(_ uint64, header *domainmessage.BlockHeader,
txs []*util.Tx) {
minerClient.onBlockAdded <- struct{}{}
},

10
cmd/txsigner/txsigner.go
View File

@ -5,9 +5,9 @@ import (
"encoding/hex"
"fmt"
"github.com/kaspanet/go-secp256k1"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/wire"
"github.com/pkg/errors"
"os"
)
@ -58,12 +58,12 @@ func parsePrivateKey(privateKeyHex string) (*secp256k1.PrivateKey, error) {
return secp256k1.DeserializePrivateKeyFromSlice(privateKeyBytes)
}
func parseTransaction(transactionHex string) (*wire.MsgTx, error) {
func parseTransaction(transactionHex string) (*domainmessage.MsgTx, error) {
serializedTx, err := hex.DecodeString(transactionHex)
if err != nil {
return nil, errors.Wrap(err, "couldn't decode transaction hex")
}
var transaction wire.MsgTx
var transaction domainmessage.MsgTx
err = transaction.Deserialize(bytes.NewReader(serializedTx))
return &transaction, err
}
@ -81,7 +81,7 @@ func createScriptPubKey(publicKey *secp256k1.SchnorrPublicKey) ([]byte, error) {
return scriptPubKey, err
}
func signTransaction(transaction *wire.MsgTx, privateKey *secp256k1.PrivateKey, scriptPubKey []byte) error {
func signTransaction(transaction *domainmessage.MsgTx, privateKey *secp256k1.PrivateKey, scriptPubKey []byte) error {
for i, transactionInput := range transaction.TxIn {
signatureScript, err := txscript.SignatureScript(transaction, i, scriptPubKey, txscript.SigHashAll, privateKey, true)
if err != nil {
@ -92,7 +92,7 @@ func signTransaction(transaction *wire.MsgTx, privateKey *secp256k1.PrivateKey,
return nil
}
func serializeTransaction(transaction *wire.MsgTx) (string, error) {
func serializeTransaction(transaction *domainmessage.MsgTx) (string, error) {
buf := bytes.NewBuffer(make([]byte, 0, transaction.SerializeSize()))
err := transaction.Serialize(buf)
serializedTransaction := hex.EncodeToString(buf.Bytes())

52
dagconfig/genesis.go
View File

@ -5,13 +5,13 @@
package dagconfig
import (
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/mstime"
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/wire"
)
var genesisTxOuts = []*wire.TxOut{}
var genesisTxOuts = []*domainmessage.TxOut{}
var genesisTxPayload = []byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
@ -23,7 +23,7 @@ var genesisTxPayload = []byte{
// genesisCoinbaseTx is the coinbase transaction for the genesis blocks for
// the main network.
var genesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, genesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, genesisTxPayload)
var genesisCoinbaseTx = domainmessage.NewSubnetworkMsgTx(1, []*domainmessage.TxIn{}, genesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, genesisTxPayload)
// genesisHash is the hash of the first block in the block DAG for the main
// network (genesis block).
@ -45,8 +45,8 @@ var genesisMerkleRoot = daghash.Hash{
// genesisBlock defines the genesis block of the block DAG which serves as the
// public transaction ledger for the main network.
var genesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
var genesisBlock = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 0x10000000,
ParentHashes: []*daghash.Hash{},
HashMerkleRoot: &genesisMerkleRoot,
@ -56,10 +56,10 @@ var genesisBlock = wire.MsgBlock{
Bits: 0x207fffff,
Nonce: 0x1,
},
Transactions: []*wire.MsgTx{genesisCoinbaseTx},
Transactions: []*domainmessage.MsgTx{genesisCoinbaseTx},
}
var devnetGenesisTxOuts = []*wire.TxOut{}
var devnetGenesisTxOuts = []*domainmessage.TxOut{}
var devnetGenesisTxPayload = []byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
@ -72,7 +72,7 @@ var devnetGenesisTxPayload = []byte{
// devnetGenesisCoinbaseTx is the coinbase transaction for the genesis blocks for
// the development network.
var devnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, devnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, devnetGenesisTxPayload)
var devnetGenesisCoinbaseTx = domainmessage.NewSubnetworkMsgTx(1, []*domainmessage.TxIn{}, devnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, devnetGenesisTxPayload)
// devGenesisHash is the hash of the first block in the block DAG for the development
// network (genesis block).
@ -94,8 +94,8 @@ var devnetGenesisMerkleRoot = daghash.Hash{
// devnetGenesisBlock defines the genesis block of the block DAG which serves as the
// public transaction ledger for the development network.
var devnetGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
var devnetGenesisBlock = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 0x10000000,
ParentHashes: []*daghash.Hash{},
HashMerkleRoot: &devnetGenesisMerkleRoot,
@ -105,10 +105,10 @@ var devnetGenesisBlock = wire.MsgBlock{
Bits: 0x1e7fffff,
Nonce: 0x10bb,
},
Transactions: []*wire.MsgTx{devnetGenesisCoinbaseTx},
Transactions: []*domainmessage.MsgTx{devnetGenesisCoinbaseTx},
}
var regtestGenesisTxOuts = []*wire.TxOut{}
var regtestGenesisTxOuts = []*domainmessage.TxOut{}
var regtestGenesisTxPayload = []byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
@ -121,7 +121,7 @@ var regtestGenesisTxPayload = []byte{
// regtestGenesisCoinbaseTx is the coinbase transaction for
// the genesis blocks for the regtest network.
var regtestGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, regtestGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, regtestGenesisTxPayload)
var regtestGenesisCoinbaseTx = domainmessage.NewSubnetworkMsgTx(1, []*domainmessage.TxIn{}, regtestGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, regtestGenesisTxPayload)
// devGenesisHash is the hash of the first block in the block DAG for the development
// network (genesis block).
@ -143,8 +143,8 @@ var regtestGenesisMerkleRoot = daghash.Hash{
// regtestGenesisBlock defines the genesis block of the block DAG which serves as the
// public transaction ledger for the development network.
var regtestGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
var regtestGenesisBlock = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 0x10000000,
ParentHashes: []*daghash.Hash{},
HashMerkleRoot: &regtestGenesisMerkleRoot,
@ -154,10 +154,10 @@ var regtestGenesisBlock = wire.MsgBlock{
Bits: 0x207fffff,
Nonce: 0x0,
},
Transactions: []*wire.MsgTx{regtestGenesisCoinbaseTx},
Transactions: []*domainmessage.MsgTx{regtestGenesisCoinbaseTx},
}
var simnetGenesisTxOuts = []*wire.TxOut{}
var simnetGenesisTxOuts = []*domainmessage.TxOut{}
var simnetGenesisTxPayload = []byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
@ -169,7 +169,7 @@ var simnetGenesisTxPayload = []byte{
}
// simnetGenesisCoinbaseTx is the coinbase transaction for the simnet genesis block.
var simnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, simnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, simnetGenesisTxPayload)
var simnetGenesisCoinbaseTx = domainmessage.NewSubnetworkMsgTx(1, []*domainmessage.TxIn{}, simnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, simnetGenesisTxPayload)
// simnetGenesisHash is the hash of the first block in the block DAG for
// the simnet (genesis block).
@ -191,8 +191,8 @@ var simnetGenesisMerkleRoot = daghash.Hash{
// simnetGenesisBlock defines the genesis block of the block DAG which serves as the
// public transaction ledger for the development network.
var simnetGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
var simnetGenesisBlock = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 0x10000000,
ParentHashes: []*daghash.Hash{},
HashMerkleRoot: &simnetGenesisMerkleRoot,
@ -202,10 +202,10 @@ var simnetGenesisBlock = wire.MsgBlock{
Bits: 0x207fffff,
Nonce: 0x0,
},
Transactions: []*wire.MsgTx{simnetGenesisCoinbaseTx},
Transactions: []*domainmessage.MsgTx{simnetGenesisCoinbaseTx},
}
var testnetGenesisTxOuts = []*wire.TxOut{}
var testnetGenesisTxOuts = []*domainmessage.TxOut{}
var testnetGenesisTxPayload = []byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
@ -215,7 +215,7 @@ var testnetGenesisTxPayload = []byte{
}
// testnetGenesisCoinbaseTx is the coinbase transaction for the testnet genesis block.
var testnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, testnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, testnetGenesisTxPayload)
var testnetGenesisCoinbaseTx = domainmessage.NewSubnetworkMsgTx(1, []*domainmessage.TxIn{}, testnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, testnetGenesisTxPayload)
// testnetGenesisHash is the hash of the first block in the block DAG for the test
// network (genesis block).
@ -237,8 +237,8 @@ var testnetGenesisMerkleRoot = daghash.Hash{
// testnetGenesisBlock defines the genesis block of the block DAG which serves as the
// public transaction ledger for testnet.
var testnetGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
var testnetGenesisBlock = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 0x10000000,
ParentHashes: []*daghash.Hash{},
HashMerkleRoot: &testnetGenesisMerkleRoot,
@ -248,5 +248,5 @@ var testnetGenesisBlock = wire.MsgBlock{
Bits: 0x1e7fffff,
Nonce: 0x162ca,
},
Transactions: []*wire.MsgTx{testnetGenesisCoinbaseTx},
Transactions: []*domainmessage.MsgTx{testnetGenesisCoinbaseTx},
}

10
dagconfig/genesis_test.go
View File

@ -145,7 +145,7 @@ func TestDevnetGenesisBlock(t *testing.T) {
}
}
// genesisBlockBytes are the wire encoded bytes for the genesis block of the
// genesisBlockBytes are the encoded bytes for the genesis block of the
// main network as of protocol version 1.
var genesisBlockBytes = []byte{
0x00, 0x00, 0x00, 0x10, 0x00, 0xca, 0x85, 0x56, 0x27, 0xc7, 0x6a, 0xb5, 0x7a, 0x26, 0x1d, 0x63,
@ -165,7 +165,7 @@ var genesisBlockBytes = []byte{
0x30, 0xcd, 0x5a, 0x4b, 0x87,
}
// regtestGenesisBlockBytes are the wire encoded bytes for the genesis block of
// regtestGenesisBlockBytes are the encoded bytes for the genesis block of
// the regression test network as of protocol version 1.
var regtestGenesisBlockBytes = []byte{
0x00, 0x00, 0x00, 0x10, 0x00, 0x1e, 0x08, 0xae, 0x1f, 0x43, 0xf5, 0xfc, 0x24, 0xe6, 0xec, 0x54,
@ -186,7 +186,7 @@ var regtestGenesisBlockBytes = []byte{
0x73, 0x74,
}
// testnetGenesisBlockBytes are the wire encoded bytes for the genesis block of
// testnetGenesisBlockBytes are the encoded bytes for the genesis block of
// the test network as of protocol version 1.
var testnetGenesisBlockBytes = []byte{
0x00, 0x00, 0x00, 0x10, 0x00, 0xa0, 0xa1, 0x3d, 0xfd, 0x86, 0x41, 0x35, 0xc8, 0xbd, 0xbb, 0xe6,
@ -205,7 +205,7 @@ var testnetGenesisBlockBytes = []byte{
0x61, 0x73, 0x70, 0x61, 0x2d, 0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74,
}
// simnetGenesisBlockBytes are the wire encoded bytes for the genesis block of
// simnetGenesisBlockBytes are the encoded bytes for the genesis block of
// the simulation test network as of protocol version 1.
var simnetGenesisBlockBytes = []byte{
0x00, 0x00, 0x00, 0x10, 0x00, 0x47, 0x52, 0xc7, 0x23, 0x70, 0x4d, 0x89, 0x17, 0xbd, 0x44, 0x26,
@ -226,7 +226,7 @@ var simnetGenesisBlockBytes = []byte{
0x74,
}
// devnetGenesisBlockBytes are the wire encoded bytes for the genesis block of
// devnetGenesisBlockBytes are the encoded bytes for the genesis block of
// the development network as of protocol version 1.
var devnetGenesisBlockBytes = []byte{
0x00, 0x00, 0x00, 0x10, 0x00, 0x68, 0x60, 0xe7, 0x77, 0x47, 0x74, 0x7f, 0xd5, 0x55, 0x58, 0x8a,

18
dagconfig/params.go
View File

@ -14,8 +14,8 @@ import (
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
// These variables are the DAG proof-of-work limit parameters for each default
@ -101,7 +101,7 @@ type Params struct {
Name string
// Net defines the magic bytes used to identify the network.
Net wire.KaspaNet
Net domainmessage.KaspaNet
// RPCPort defines the rpc server port
RPCPort string
@ -114,7 +114,7 @@ type Params struct {
DNSSeeds []string
// GenesisBlock defines the first block of the DAG.
GenesisBlock *wire.MsgBlock
GenesisBlock *domainmessage.MsgBlock
// GenesisHash is the starting block hash.
GenesisHash *daghash.Hash
@ -190,7 +190,7 @@ func (p *Params) NormalizeRPCServerAddress(addr string) (string, error) {
var MainnetParams = Params{
K: ghostdagK,
Name: "mainnet",
Net: wire.Mainnet,
Net: domainmessage.Mainnet,
RPCPort: "16110",
DefaultPort: "16111",
DNSSeeds: []string{"dnsseed.kas.pa"},
@ -243,7 +243,7 @@ var MainnetParams = Params{
var RegressionNetParams = Params{
K: ghostdagK,
Name: "regtest",
Net: wire.Regtest,
Net: domainmessage.Regtest,
RPCPort: "16210",
DefaultPort: "16211",
DNSSeeds: []string{},
@ -294,7 +294,7 @@ var RegressionNetParams = Params{
var TestnetParams = Params{
K: ghostdagK,
Name: "testnet",
Net: wire.Testnet,
Net: domainmessage.Testnet,
RPCPort: "16210",
DefaultPort: "16211",
DNSSeeds: []string{"testnet-dnsseed.kas.pa"},
@ -351,7 +351,7 @@ var TestnetParams = Params{
var SimnetParams = Params{
K: ghostdagK,
Name: "simnet",
Net: wire.Simnet,
Net: domainmessage.Simnet,
RPCPort: "16510",
DefaultPort: "16511",
DNSSeeds: []string{}, // NOTE: There must NOT be any seeds.
@ -400,7 +400,7 @@ var SimnetParams = Params{
var DevnetParams = Params{
K: ghostdagK,
Name: "devnet",
Net: wire.Devnet,
Net: domainmessage.Devnet,
RPCPort: "16610",
DefaultPort: "16611",
DNSSeeds: []string{}, // NOTE: There must NOT be any seeds.
@ -455,7 +455,7 @@ var (
)
var (
registeredNets = make(map[wire.KaspaNet]struct{})
registeredNets = make(map[domainmessage.KaspaNet]struct{})
)
// Register registers the network parameters for a Kaspa network. This may

12
dnsseed/seed.go
View File

@ -16,7 +16,7 @@ import (
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
const (
@ -34,13 +34,13 @@ const (
// OnSeed is the signature of the callback function which is invoked when DNS
// seeding is successful.
type OnSeed func(addrs []*wire.NetAddress)
type OnSeed func(addrs []*domainmessage.NetAddress)
// LookupFunc is the signature of the DNS lookup function.
type LookupFunc func(string) ([]net.IP, error)
// SeedFromDNS uses DNS seeding to populate the address manager with peers.
func SeedFromDNS(dagParams *dagconfig.Params, customSeed string, reqServices wire.ServiceFlag, includeAllSubnetworks bool,
func SeedFromDNS(dagParams *dagconfig.Params, customSeed string, reqServices domainmessage.ServiceFlag, includeAllSubnetworks bool,
subnetworkID *subnetworkid.SubnetworkID, lookupFn LookupFunc, seedFn OnSeed) {
var dnsSeeds []string
@ -52,7 +52,7 @@ func SeedFromDNS(dagParams *dagconfig.Params, customSeed string, reqServices wir
for _, dnsseed := range dnsSeeds {
var host string
if reqServices == wire.SFNodeNetwork {
if reqServices == domainmessage.SFNodeNetwork {
host = dnsseed
} else {
host = fmt.Sprintf("%c%x.%s", ServiceFlagPrefixChar, uint64(reqServices), dnsseed)
@ -81,11 +81,11 @@ func SeedFromDNS(dagParams *dagconfig.Params, customSeed string, reqServices wir
if numPeers == 0 {
return
}
addresses := make([]*wire.NetAddress, len(seedPeers))
addresses := make([]*domainmessage.NetAddress, len(seedPeers))
// if this errors then we have *real* problems
intPort, _ := strconv.Atoi(dagParams.DefaultPort)
for i, peer := range seedPeers {
addresses[i] = wire.NewNetAddressTimestamp(
addresses[i] = domainmessage.NewNetAddressTimestamp(
// seed with addresses from a time randomly selected
// between 3 and 7 days ago.
mstime.Now().Add(-1*time.Second*time.Duration(secondsIn3Days+

2
wire/README.md → domainmessage/README.md
View File

@ -36,7 +36,7 @@ to a remote node running a kaspa peer. Example syntax is:
// Reads and validates the next kaspa message from conn using the
// protocol version pver and the kaspa network kaspanet. The returns
// are a wire.Message, a []byte which contains the unmarshalled
// are a domainmessage.Message, a []byte which contains the unmarshalled
// raw payload, and a possible error.
msg, rawPayload, err := wire.ReadMessage(conn, pver, kaspanet)
if err != nil {

2
wire/bench_test.go → domainmessage/bench_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"

14
wire/blockheader.go → domainmessage/blockheader.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"
@ -82,7 +82,7 @@ func (h *BlockHeader) IsGenesis() bool {
// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
// This is part of the Message interface implementation.
// See Deserialize for decoding block headers stored to disk, such as in a
// database, as opposed to decoding block headers from the wire.
// database, as opposed to decoding block headers from the domainmessage.
func (h *BlockHeader) KaspaDecode(r io.Reader, pver uint32) error {
return readBlockHeader(r, pver, h)
}
@ -90,7 +90,7 @@ func (h *BlockHeader) KaspaDecode(r io.Reader, pver uint32) error {
// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
// This is part of the Message interface implementation.
// See Serialize for encoding block headers to be stored to disk, such as in a
// database, as opposed to encoding block headers for the wire.
// database, as opposed to encoding block headers for the domainmessage.
func (h *BlockHeader) KaspaEncode(w io.Writer, pver uint32) error {
return writeBlockHeader(w, pver, h)
}
@ -99,7 +99,7 @@ func (h *BlockHeader) KaspaEncode(w io.Writer, pver uint32) error {
// that is suitable for long-term storage such as a database while respecting
// the Version field.
func (h *BlockHeader) Deserialize(r io.Reader) error {
// At the current time, there is no difference between the wire encoding
// At the current time, there is no difference between the domainmessage encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of readBlockHeader.
return readBlockHeader(r, 0, h)
@ -109,7 +109,7 @@ func (h *BlockHeader) Deserialize(r io.Reader) error {
// that is suitable for long-term storage such as a database while respecting
// the Version field.
func (h *BlockHeader) Serialize(w io.Writer) error {
// At the current time, there is no difference between the wire encoding
// At the current time, there is no difference between the domainmessage encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of writeBlockHeader.
return writeBlockHeader(w, 0, h)
@ -143,7 +143,7 @@ func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot
// readBlockHeader reads a kaspa block header from r. See Deserialize for
// decoding block headers stored to disk, such as in a database, as opposed to
// decoding from the wire.
// decoding from the domainmessage.
func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
var numParentBlocks byte
err := readElements(r, &bh.Version, &numParentBlocks)
@ -169,7 +169,7 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
// writeBlockHeader writes a kaspa block header to w. See Serialize for
// encoding block headers to be stored to disk, such as in a database, as
// opposed to encoding for the wire.
// opposed to encoding for the domainmessage.
func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
timestamp := bh.Timestamp.UnixMilliseconds()
if err := writeElements(w, bh.Version, bh.NumParentBlocks()); err != nil {

18
wire/blockheader_test.go → domainmessage/blockheader_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"
@ -47,9 +47,9 @@ func TestBlockHeader(t *testing.T) {
}
}
// TestBlockHeaderWire tests the BlockHeader wire encode and decode for various
// TestBlockHeaderEncoding tests the BlockHeader domainmessage encode and decode for various
// protocol versions.
func TestBlockHeaderWire(t *testing.T) {
func TestBlockHeaderEncoding(t *testing.T) {
nonce := uint64(123123) // 0x000000000001e0f3
pver := ProtocolVersion
@ -66,7 +66,7 @@ func TestBlockHeaderWire(t *testing.T) {
Nonce: nonce,
}
// baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr.
// baseBlockHdrEncoded is the domainmessage encoded bytes of baseBlockHdr.
baseBlockHdrEncoded := []byte{
0x01, 0x00, 0x00, 0x00, // Version 1
0x02, // NumParentBlocks
@ -98,8 +98,8 @@ func TestBlockHeaderWire(t *testing.T) {
tests := []struct {
in *BlockHeader // Data to encode
out *BlockHeader // Expected decoded data
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded data
pver uint32 // Protocol version for domainmessage encoding
}{
// Latest protocol version.
{
@ -112,7 +112,7 @@ func TestBlockHeaderWire(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
var buf bytes.Buffer
err := writeBlockHeader(&buf, test.pver, test.in)
if err != nil {
@ -137,7 +137,7 @@ func TestBlockHeaderWire(t *testing.T) {
continue
}
// Decode the block header from wire format.
// Decode the block header from domainmessage format.
var bh BlockHeader
rbuf := bytes.NewReader(test.buf)
err = readBlockHeader(rbuf, test.pver, &bh)
@ -182,7 +182,7 @@ func TestBlockHeaderSerialize(t *testing.T) {
Nonce: nonce,
}
// baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr.
// baseBlockHdrEncoded is the domainmessage encoded bytes of baseBlockHdr.
baseBlockHdrEncoded := []byte{
0x01, 0x00, 0x00, 0x00, // Version 1
0x02, // NumParentBlocks

20
wire/common.go → domainmessage/common.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"encoding/binary"
@ -20,6 +20,9 @@ import (
// MaxVarIntPayload is the maximum payload size for a variable length integer.
const MaxVarIntPayload = 9
// MaxInvPerMsg is the maximum number of inventory vectors that can be in any type of kaspa inv message.
const MaxInvPerMsg = 1 << 17
var (
// littleEndian is a convenience variable since binary.LittleEndian is
// quite long.
@ -160,14 +163,6 @@ func ReadElement(r io.Reader, element interface{}) error {
*e = ServiceFlag(rv)
return nil
case *InvType:
rv, err := binaryserializer.Uint32(r, littleEndian)
if err != nil {
return err
}
*e = InvType(rv)
return nil
case *KaspaNet:
rv, err := binaryserializer.Uint32(r, littleEndian)
if err != nil {
@ -292,13 +287,6 @@ func WriteElement(w io.Writer, element interface{}) error {
}
return nil
case InvType:
err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
if err != nil {
return err
}
return nil
case KaspaNet:
err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
if err != nil {

111
wire/common_test.go → domainmessage/common_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"
@ -57,13 +57,13 @@ var exampleUTXOCommitment = &daghash.Hash{
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
}
// TestElementWire tests wire encode and decode for various element types. This
// TestElementEncoding tests domainmessage encode and decode for various element types. This
// is mainly to test the "fast" paths in readElement and writeElement which use
// type assertions to avoid reflection when possible.
func TestElementWire(t *testing.T) {
func TestElementEncoding(t *testing.T) {
tests := []struct {
in interface{} // Value to encode
buf []byte // Wire encoding
buf []byte // Encoded value
}{
{int32(1), []byte{0x01, 0x00, 0x00, 0x00}},
{uint32(256), []byte{0x00, 0x01, 0x00, 0x00}},
@ -121,10 +121,6 @@ func TestElementWire(t *testing.T) {
ServiceFlag(SFNodeNetwork),
[]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
},
{
InvType(InvTypeTx),
[]byte{0x01, 0x00, 0x00, 0x00},
},
{
KaspaNet(Mainnet),
[]byte{0x1d, 0xf7, 0xdc, 0x3d},
@ -133,7 +129,7 @@ func TestElementWire(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Write to wire format.
// Write to domainmessage format.
var buf bytes.Buffer
err := WriteElement(&buf, test.in)
if err != nil {
@ -146,7 +142,7 @@ func TestElementWire(t *testing.T) {
continue
}
// Read from wire format.
// Read from domainmessage format.
rbuf := bytes.NewReader(test.buf)
val := test.in
if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
@ -169,9 +165,9 @@ func TestElementWire(t *testing.T) {
}
}
// TestElementWireErrors performs negative tests against wire encode and decode
// TestElementEncodingErrors performs negative tests against domainmessage encode and decode
// of various element types to confirm error paths work correctly.
func TestElementWireErrors(t *testing.T) {
func TestElementEncodingErrors(t *testing.T) {
type writeElementReflect int32
tests := []struct {
@ -206,7 +202,6 @@ func TestElementWireErrors(t *testing.T) {
0, io.ErrShortWrite, io.EOF,
},
{ServiceFlag(SFNodeNetwork), 0, io.ErrShortWrite, io.EOF},
{InvType(InvTypeTx), 0, io.ErrShortWrite, io.EOF},
{KaspaNet(Mainnet), 0, io.ErrShortWrite, io.EOF},
// Type with no supported encoding.
{writeElementReflect(0), 0, errNoEncodingForType, errNoEncodingForType},
@ -214,7 +209,7 @@ func TestElementWireErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
w := newFixedWriter(test.max)
err := WriteElement(w, test.in)
if !errors.Is(err, test.writeErr) {
@ -223,7 +218,7 @@ func TestElementWireErrors(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
r := newFixedReader(test.max, nil)
val := test.in
if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
@ -238,11 +233,11 @@ func TestElementWireErrors(t *testing.T) {
}
}
// TestVarIntWire tests wire encode and decode for variable length integers.
func TestVarIntWire(t *testing.T) {
// TestVarIntEncoding tests domainmessage encode and decode for variable length integers.
func TestVarIntEncoding(t *testing.T) {
tests := []struct {
value uint64 // Value to encode
buf []byte // Wire encoding
buf []byte // Encoded value
}{
// Latest protocol version.
// Single byte
@ -271,7 +266,7 @@ func TestVarIntWire(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
buf := &bytes.Buffer{}
err := WriteVarInt(buf, test.value)
if err != nil {
@ -284,7 +279,7 @@ func TestVarIntWire(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
rbuf := bytes.NewReader(test.buf)
val, err := ReadVarInt(rbuf)
if err != nil {
@ -299,12 +294,12 @@ func TestVarIntWire(t *testing.T) {
}
}
// TestVarIntWireErrors performs negative tests against wire encode and decode
// TestVarIntEncodingErrors performs negative tests against domainmessage encode and decode
// of variable length integers to confirm error paths work correctly.
func TestVarIntWireErrors(t *testing.T) {
func TestVarIntEncodingErrors(t *testing.T) {
tests := []struct {
in uint64 // Value to encode
buf []byte // Wire encoding
buf []byte // Encoded value
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
@ -324,7 +319,7 @@ func TestVarIntWireErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
w := newFixedWriter(test.max)
err := WriteVarInt(w, test.in)
if !errors.Is(err, test.writeErr) {
@ -333,7 +328,7 @@ func TestVarIntWireErrors(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
r := newFixedReader(test.max, test.buf)
_, err = ReadVarInt(r)
if !errors.Is(err, test.readErr) {
@ -352,7 +347,7 @@ func TestVarIntNonCanonical(t *testing.T) {
tests := []struct {
name string // Test name for easier identification
in []byte // Value to decode
pver uint32 // Protocol version for wire encoding
pver uint32 // Protocol version for domainmessage encoding
}{
{
"0 encoded with 3 bytes", []byte{0xfd, 0x00, 0x00},
@ -384,7 +379,7 @@ func TestVarIntNonCanonical(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Decode from wire format.
// Decode from domainmessage format.
rbuf := bytes.NewReader(test.in)
val, err := ReadVarInt(rbuf)
if msgErr := &(MessageError{}); !errors.As(err, &msgErr) {
@ -400,7 +395,7 @@ func TestVarIntNonCanonical(t *testing.T) {
}
}
// TestVarIntWire tests the serialize size for variable length integers.
// TestVarIntEncoding tests the serialize size for variable length integers.
func TestVarIntSerializeSize(t *testing.T) {
tests := []struct {
val uint64 // Value to get the serialized size for
@ -435,8 +430,8 @@ func TestVarIntSerializeSize(t *testing.T) {
}
}
// TestVarStringWire tests wire encode and decode for variable length strings.
func TestVarStringWire(t *testing.T) {
// TestVarStringEncoding tests domainmessage encode and decode for variable length strings.
func TestVarStringEncoding(t *testing.T) {
pver := ProtocolVersion
// str256 is a string that takes a 2-byte varint to encode.
@ -445,8 +440,8 @@ func TestVarStringWire(t *testing.T) {
tests := []struct {
in string // String to encode
out string // String to decoded value
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
}{
// Latest protocol version.
// Empty string
@ -459,7 +454,7 @@ func TestVarStringWire(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
var buf bytes.Buffer
err := WriteVarString(&buf, test.in)
if err != nil {
@ -472,7 +467,7 @@ func TestVarStringWire(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
rbuf := bytes.NewReader(test.buf)
val, err := ReadVarString(rbuf, test.pver)
if err != nil {
@ -487,9 +482,9 @@ func TestVarStringWire(t *testing.T) {
}
}
// TestVarStringWireErrors performs negative tests against wire encode and
// TestVarStringEncodingErrors performs negative tests against domainmessage encode and
// decode of variable length strings to confirm error paths work correctly.
func TestVarStringWireErrors(t *testing.T) {
func TestVarStringEncodingErrors(t *testing.T) {
pver := ProtocolVersion
// str256 is a string that takes a 2-byte varint to encode.
@ -497,8 +492,8 @@ func TestVarStringWireErrors(t *testing.T) {
tests := []struct {
in string // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
@ -514,7 +509,7 @@ func TestVarStringWireErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
w := newFixedWriter(test.max)
err := WriteVarString(w, test.in)
if !errors.Is(err, test.writeErr) {
@ -523,7 +518,7 @@ func TestVarStringWireErrors(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
r := newFixedReader(test.max, test.buf)
_, err = ReadVarString(r, test.pver)
if !errors.Is(err, test.readErr) {
@ -542,8 +537,8 @@ func TestVarStringOverflowErrors(t *testing.T) {
pver := ProtocolVersion
tests := []struct {
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
err error // Expected error
}{
{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
@ -554,7 +549,7 @@ func TestVarStringOverflowErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Decode from wire format.
// Decode from domainmessage format.
rbuf := bytes.NewReader(test.buf)
_, err := ReadVarString(rbuf, test.pver)
if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@ -566,8 +561,8 @@ func TestVarStringOverflowErrors(t *testing.T) {
}
// TestVarBytesWire tests wire encode and decode for variable length byte array.
func TestVarBytesWire(t *testing.T) {
// TestVarBytesEncoding tests domainmessage encode and decode for variable length byte array.
func TestVarBytesEncoding(t *testing.T) {
pver := ProtocolVersion
// bytes256 is a byte array that takes a 2-byte varint to encode.
@ -575,8 +570,8 @@ func TestVarBytesWire(t *testing.T) {
tests := []struct {
in []byte // Byte Array to write
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
}{
// Latest protocol version.
// Empty byte array
@ -589,7 +584,7 @@ func TestVarBytesWire(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
var buf bytes.Buffer
err := WriteVarBytes(&buf, test.pver, test.in)
if err != nil {
@ -602,7 +597,7 @@ func TestVarBytesWire(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
rbuf := bytes.NewReader(test.buf)
val, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
"test payload")
@ -618,9 +613,9 @@ func TestVarBytesWire(t *testing.T) {
}
}
// TestVarBytesWireErrors performs negative tests against wire encode and
// TestVarBytesEncodingErrors performs negative tests against domainmessage encode and
// decode of variable length byte arrays to confirm error paths work correctly.
func TestVarBytesWireErrors(t *testing.T) {
func TestVarBytesEncodingErrors(t *testing.T) {
pver := ProtocolVersion
// bytes256 is a byte array that takes a 2-byte varint to encode.
@ -628,8 +623,8 @@ func TestVarBytesWireErrors(t *testing.T) {
tests := []struct {
in []byte // Byte Array to write
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
@ -645,7 +640,7 @@ func TestVarBytesWireErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
w := newFixedWriter(test.max)
err := WriteVarBytes(w, test.pver, test.in)
if !errors.Is(err, test.writeErr) {
@ -654,7 +649,7 @@ func TestVarBytesWireErrors(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
r := newFixedReader(test.max, test.buf)
_, err = ReadVarBytes(r, test.pver, MaxMessagePayload,
"test payload")
@ -674,8 +669,8 @@ func TestVarBytesOverflowErrors(t *testing.T) {
pver := ProtocolVersion
tests := []struct {
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
err error // Expected error
}{
{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
@ -686,7 +681,7 @@ func TestVarBytesOverflowErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Decode from wire format.
// Decode from domainmessage format.
rbuf := bytes.NewReader(test.buf)
_, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
"test payload")

38
wire/doc.go → domainmessage/doc.go
View File

@ -1,8 +1,8 @@
/*
Package wire implements the kaspa wire protocol.
Package domainmessage implements the kaspa domainmessage protocol.
At a high level, this package provides support for marshalling and unmarshalling
supported kaspa messages to and from the wire. This package does not deal
supported kaspa messages to and from the domainmessage. This package does not deal
with the specifics of message handling such as what to do when a message is
received. This provides the caller with a high level of flexibility.
@ -19,7 +19,7 @@ Message which allows messages of any type to be read, written, or passed around
through channels, functions, etc. In addition, concrete implementations of most
of the currently supported kaspa messages are provided. For these supported
messages, all of the details of marshalling and unmarshalling to and from the
wire using kaspa encoding are handled so the caller doesn't have to concern
domainmessage using kaspa encoding are handled so the caller doesn't have to concern
themselves with the specifics.
Message Interaction
@ -55,7 +55,7 @@ Protocol Version
The protocol version should be negotiated with the remote peer at a higher
level than this package via the version (MsgVersion) message exchange, however,
this package provides the wire.ProtocolVersion constant which indicates the
this package provides the domainmessage.ProtocolVersion constant which indicates the
latest protocol version this package supports and is typically the value to use
for all outbound connections before a potentially lower protocol version is
negotiated.
@ -66,11 +66,11 @@ The kaspa network is a magic number which is used to identify the start of a
message and which kaspa network the message applies to. This package provides
the following constants:
wire.Mainnet
wire.Testnet (Test network)
wire.Regtest (Regression test network)
wire.Simnet (Simulation test network)
wire.Devnet (Development network)
domainmessage.Mainnet
domainmessage.Testnet (Test network)
domainmessage.Regtest (Regression test network)
domainmessage.Simnet (Simulation test network)
domainmessage.Devnet (Development network)
Determining Message Type
@ -82,43 +82,43 @@ switch or type assertion. An example of a type switch follows:
// Assumes msg is already a valid concrete message such as one created
// via NewMsgVersion or read via ReadMessage.
switch msg := msg.(type) {
case *wire.MsgVersion:
case *domainmessage.MsgVersion:
// The message is a pointer to a MsgVersion struct.
fmt.Printf("Protocol version: %d", msg.ProtocolVersion)
case *wire.MsgBlock:
case *domainmessage.MsgBlock:
// The message is a pointer to a MsgBlock struct.
fmt.Printf("Number of tx in block: %d", msg.Header.TxnCount)
}
Reading Messages
In order to unmarshall kaspa messages from the wire, use the ReadMessage
In order to unmarshall kaspa messages from the domainmessage, use the ReadMessage
function. It accepts any io.Reader, but typically this will be a net.Conn to
a remote node running a kaspa peer. Example syntax is:
// Reads and validates the next kaspa message from conn using the
// protocol version pver and the kaspa network kaspaNet. The returns
// are a wire.Message, a []byte which contains the unmarshalled
// are a domainmessage.Message, a []byte which contains the unmarshalled
// raw payload, and a possible error.
msg, rawPayload, err := wire.ReadMessage(conn, pver, kaspaNet)
msg, rawPayload, err := domainmessage.ReadMessage(conn, pver, kaspaNet)
if err != nil {
// Log and handle the error
}
Writing Messages
In order to marshall kaspa messages to the wire, use the WriteMessage
In order to marshall kaspa messages to the domainmessage, use the WriteMessage
function. It accepts any io.Writer, but typically this will be a net.Conn to
a remote node running a kaspa peer. Example syntax to request addresses
from a remote peer is:
// Create a new getaddr kaspa message.
msg := wire.NewMsgRequestAddresses()
msg := domainmessage.NewMsgRequestAddresses()
// Writes a kaspa message msg to conn using the protocol version
// pver, and the kaspa network kaspaNet. The return is a possible
// error.
err := wire.WriteMessage(conn, msg, pver, kaspaNet)
err := domainmessage.WriteMessage(conn, msg, pver, kaspaNet)
if err != nil {
// Log and handle the error
}
@ -127,8 +127,8 @@ Errors
Errors returned by this package are either the raw errors provided by underlying
calls to read/write from streams such as io.EOF, io.ErrUnexpectedEOF, and
io.ErrShortWrite, or of type wire.MessageError. This allows the caller to
io.ErrShortWrite, or of type domainmessage.MessageError. This allows the caller to
differentiate between general IO errors and malformed messages through type
assertions.
*/
package wire
package domainmessage

2
wire/error.go → domainmessage/error.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"fmt"

6
wire/fakemessage_test.go → domainmessage/fakemessage_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import "io"
@ -15,7 +15,7 @@ type fakeMessage struct {
forceLenErr bool
}
// KaspaDecode doesn't do anything. It just satisfies the wire.Message
// KaspaDecode doesn't do anything. It just satisfies the domainmessage.Message
// interface.
func (msg *fakeMessage) KaspaDecode(r io.Reader, pver uint32) error {
return nil
@ -23,7 +23,7 @@ func (msg *fakeMessage) KaspaDecode(r io.Reader, pver uint32) error {
// KaspaEncode writes the payload field of the fake message or forces an error
// if the forceEncodeErr flag of the fake message is set. It also satisfies the
// wire.Message interface.
// domainmessage.Message interface.
func (msg *fakeMessage) KaspaEncode(w io.Writer, pver uint32) error {
if msg.forceEncodeErr {
err := &MessageError{

2
wire/fixedIO_test.go → domainmessage/fixedIO_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"

2
wire/message.go → domainmessage/message.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"fmt"

2
wire/msgaddresses.go → domainmessage/msgaddresses.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"fmt"

2
wire/msgaddresses_test.go → domainmessage/msgaddresses_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"net"

20
wire/msgblock.go → domainmessage/msgblock.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"
@ -59,7 +59,7 @@ func (msg *MsgBlock) ClearTransactions() {
// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
// This is part of the Message interface implementation.
// See Deserialize for decoding blocks stored to disk, such as in a database, as
// opposed to decoding blocks from the wire.
// opposed to decoding blocks from the domainmessage.
func (msg *MsgBlock) KaspaDecode(r io.Reader, pver uint32) error {
err := readBlockHeader(r, pver, &msg.Header)
if err != nil {
@ -96,14 +96,14 @@ func (msg *MsgBlock) KaspaDecode(r io.Reader, pver uint32) error {
// Deserialize decodes a block from r into the receiver using a format that is
// suitable for long-term storage such as a database while respecting the
// Version field in the block. This function differs from KaspaDecode in that
// KaspaDecode decodes from the kaspa wire protocol as it was sent across the
// network. The wire encoding can technically differ depending on the protocol
// KaspaDecode decodes from the kaspa domainmessage protocol as it was sent across the
// network. The domainmessage encoding can technically differ depending on the protocol
// version and doesn't even really need to match the format of a stored block at
// all. As of the time this comment was written, the encoded block is the same
// in both instances, but there is a distinct difference and separating the two
// allows the API to be flexible enough to deal with changes.
func (msg *MsgBlock) Deserialize(r io.Reader) error {
// At the current time, there is no difference between the wire encoding
// At the current time, there is no difference between the domainmessage encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of KaspaDecode.
return msg.KaspaDecode(r, 0)
@ -116,9 +116,9 @@ func (msg *MsgBlock) Deserialize(r io.Reader) error {
func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
fullLen := r.Len()
// At the current time, there is no difference between the wire encoding
// At the current time, there is no difference between the domainmessage encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of existing wire protocol functions.
// a result, make use of existing domainmessage protocol functions.
err := readBlockHeader(r, 0, &msg.Header)
if err != nil {
return nil, err
@ -159,7 +159,7 @@ func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
// This is part of the Message interface implementation.
// See Serialize for encoding blocks to be stored to disk, such as in a
// database, as opposed to encoding blocks for the wire.
// database, as opposed to encoding blocks for the domainmessage.
func (msg *MsgBlock) KaspaEncode(w io.Writer, pver uint32) error {
err := writeBlockHeader(w, pver, &msg.Header)
if err != nil {
@ -184,14 +184,14 @@ func (msg *MsgBlock) KaspaEncode(w io.Writer, pver uint32) error {
// Serialize encodes the block to w using a format that suitable for long-term
// storage such as a database while respecting the Version field in the block.
// This function differs from KaspaEncode in that KaspaEncode encodes the block to
// the kaspa wire protocol in order to be sent across the network. The wire
// the kaspa domainmessage protocol in order to be sent across the network. The domainmessage
// encoding can technically differ depending on the protocol version and doesn't
// even really need to match the format of a stored block at all. As of the
// time this comment was written, the encoded block is the same in both
// instances, but there is a distinct difference and separating the two allows
// the API to be flexible enough to deal with changes.
func (msg *MsgBlock) Serialize(w io.Writer) error {
// At the current time, there is no difference between the wire encoding
// At the current time, there is no difference between the domainmessage encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of KaspaEncode.
return msg.KaspaEncode(w, 0)

38
wire/msgblock_test.go → domainmessage/msgblock_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"
@ -144,15 +144,15 @@ func TestConvertToPartial(t *testing.T) {
}
}
// TestBlockWire tests the MsgBlock wire encode and decode for various numbers
// TestBlockEncoding tests the MsgBlock domainmessage encode and decode for various numbers
// of transaction inputs and outputs and protocol versions.
func TestBlockWire(t *testing.T) {
func TestBlockEncoding(t *testing.T) {
tests := []struct {
in *MsgBlock // Message to encode
out *MsgBlock // Expected decoded message
buf []byte // Wire encoding
buf []byte // Encoded value
txLocs []TxLoc // Expected transaction locations
pver uint32 // Protocol version for wire encoding
pver uint32 // Protocol version for domainmessage encoding
}{
// Latest protocol version.
{
@ -166,7 +166,7 @@ func TestBlockWire(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode the message to wire format.
// Encode the message to domainmessage format.
var buf bytes.Buffer
err := test.in.KaspaEncode(&buf, test.pver)
if err != nil {
@ -179,7 +179,7 @@ func TestBlockWire(t *testing.T) {
continue
}
// Decode the message from wire format.
// Decode the message from domainmessage format.
var msg MsgBlock
rbuf := bytes.NewReader(test.buf)
err = msg.KaspaDecode(rbuf, test.pver)
@ -195,15 +195,15 @@ func TestBlockWire(t *testing.T) {
}
}
// TestBlockWireErrors performs negative tests against wire encode and decode
// TestBlockEncodingErrors performs negative tests against domainmessage encode and decode
// of MsgBlock to confirm error paths work correctly.
func TestBlockWireErrors(t *testing.T) {
func TestBlockEncodingErrors(t *testing.T) {
pver := ProtocolVersion
tests := []struct {
in *MsgBlock // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
@ -236,7 +236,7 @@ func TestBlockWireErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
w := newFixedWriter(test.max)
err := test.in.KaspaEncode(w, test.pver)
if !errors.Is(err, test.writeErr) {
@ -245,7 +245,7 @@ func TestBlockWireErrors(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
var msg MsgBlock
r := newFixedReader(test.max, test.buf)
err = msg.KaspaDecode(r, test.pver)
@ -324,7 +324,7 @@ func TestBlockSerialize(t *testing.T) {
}
}
// TestBlockSerializeErrors performs negative tests against wire encode and
// TestBlockSerializeErrors performs negative tests against domainmessage encode and
// decode of MsgBlock to confirm error paths work correctly.
func TestBlockSerializeErrors(t *testing.T) {
tests := []struct {
@ -400,8 +400,8 @@ func TestBlockOverflowErrors(t *testing.T) {
pver := ProtocolVersion
tests := []struct {
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
err error // Expected error
}{
// Block that claims to have ~uint64(0) transactions.
@ -440,7 +440,7 @@ func TestBlockOverflowErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Decode from wire format.
// Decode from domainmessage format.
var msg MsgBlock
r := bytes.NewReader(test.buf)
err := msg.KaspaDecode(r, test.pver)
@ -450,7 +450,7 @@ func TestBlockOverflowErrors(t *testing.T) {
continue
}
// Deserialize from wire format.
// Deserialize from domainmessage format.
r = bytes.NewReader(test.buf)
err = msg.Deserialize(r)
if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@ -459,7 +459,7 @@ func TestBlockOverflowErrors(t *testing.T) {
continue
}
// Deserialize with transaction location info from wire format.
// Deserialize with transaction location info from domainmessage format.
br := bytes.NewBuffer(test.buf)
_, err = msg.DeserializeTxLoc(br)
if reflect.TypeOf(err) != reflect.TypeOf(test.err) {

2
wire/msgblocklocator.go → domainmessage/msgblocklocator.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msgblocklocator_test.go → domainmessage/msgblocklocator_test.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"testing"

2
wire/msgdoneibdblocks.go → domainmessage/msgdoneibdblocks.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
// MsgDoneIBDBlocks implements the Message interface and represents a kaspa
// DoneIBDBlocks message. It is used to notify the IBD syncing peer that the

2
wire/msgibdblock.go → domainmessage/msgibdblock.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
// MsgIBDBlock implements the Message interface and represents a kaspa
// ibdblock message. It is used to deliver block and transaction information in

14
wire/msgibdblock_test.go → domainmessage/msgibdblock_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"
@ -65,15 +65,15 @@ func TestIBDBlock(t *testing.T) {
}
}
// TestIBDBlockWire tests the MsgIBDBlock wire encode and decode for various numbers
// TestIBDBlockEncoding tests the MsgIBDBlock domainmessage encode and decode for various numbers
// of transaction inputs and outputs and protocol versions.
func TestIBDBlockWire(t *testing.T) {
func TestIBDBlockEncoding(t *testing.T) {
tests := []struct {
in *MsgIBDBlock // Message to encode
out *MsgIBDBlock // Expected decoded message
buf []byte // Wire encoding
buf []byte // Encoded value
txLocs []TxLoc // Expected transaction locations
pver uint32 // Protocol version for wire encoding
pver uint32 // Protocol version for domainmessage encoding
}{
// Latest protocol version.
{
@ -87,7 +87,7 @@ func TestIBDBlockWire(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode the message to wire format.
// Encode the message to domainmessage format.
var buf bytes.Buffer
err := test.in.KaspaEncode(&buf, test.pver)
if err != nil {
@ -100,7 +100,7 @@ func TestIBDBlockWire(t *testing.T) {
continue
}
// Decode the message from wire format.
// Decode the message from domainmessage format.
var msg MsgIBDBlock
msg.MsgBlock = new(MsgBlock)
rbuf := bytes.NewReader(test.buf)

2
wire/msginvrelayblock.go → domainmessage/msginvrelayblock.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msginvtransaction.go → domainmessage/msginvtransaction.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msgping.go → domainmessage/msgping.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
// MsgPing implements the Message interface and represents a kaspa ping
// message.

2
wire/msgping_test.go → domainmessage/msgping_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"testing"

2
wire/msgpong.go → domainmessage/msgpong.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
// MsgPong implements the Message interface and represents a kaspa pong
// message which is used primarily to confirm that a connection is still valid

2
wire/msgpong_test.go → domainmessage/msgpong_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"testing"

2
wire/msgrequestaddresses.go → domainmessage/msgrequestaddresses.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/subnetworkid"

2
wire/msgrequestaddresses_test.go → domainmessage/msgrequestaddresses_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"testing"

2
wire/msgrequestblocklocator.go → domainmessage/msgrequestblocklocator.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msgrequestblocklocator_test.go → domainmessage/msgrequestblocklocator_test.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"testing"

2
wire/msgrequestibdblocks.go → domainmessage/msgrequestibdblocks.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msgrequestibdblocks_test.go → domainmessage/msgrequestibdblocks_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"testing"

2
wire/msgrequestnextibdblocks.go → domainmessage/msgrequestnextibdblocks.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
// MsgRequestNextIBDBlocks implements the Message interface and represents a kaspa
// RequestNextIBDBlocks message. It is used to notify the IBD syncer peer to send

2
wire/msgrequestrelayblocks.go → domainmessage/msgrequestrelayblocks.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msgrequestselectedtip.go → domainmessage/msgrequestselectedtip.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
// MsgRequestSelectedTip implements the Message interface and represents a kaspa
// RequestSelectedTip message. It is used to request the selected tip of another peer.

2
wire/msgrequestselectedtip_test.go → domainmessage/msgrequestselectedtip_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"testing"

2
wire/msgrequesttransactions.go → domainmessage/msgrequesttransactions.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msgselectedtip.go → domainmessage/msgselectedtip.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msgselectedtip_test.go → domainmessage/msgselectedtip_test.go
View File

@ -1,4 +1,4 @@
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

2
wire/msgtransactionnotfound.go → domainmessage/msgtransactionnotfound.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/daghash"

22
wire/msgtx.go → domainmessage/msgtx.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"
@ -84,7 +84,7 @@ const (
minTxPayload = 10
// freeListMaxScriptSize is the size of each buffer in the free list
// that is used for deserializing scripts from the wire before they are
// that is used for deserializing scripts from the domainmessage before they are
// concatenated into a single contiguous buffers. This value was chosen
// because it is slightly more than twice the size of the vast majority
// of all "standard" scripts. Larger scripts are still deserialized
@ -401,7 +401,7 @@ func (msg *MsgTx) Copy() *MsgTx {
// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
// This is part of the Message interface implementation.
// See Deserialize for decoding transactions stored to disk, such as in a
// database, as opposed to decoding transactions from the wire.
// database, as opposed to decoding transactions from the domainmessage.
func (msg *MsgTx) KaspaDecode(r io.Reader, pver uint32) error {
version, err := binaryserializer.Uint32(r, littleEndian)
if err != nil {
@ -591,15 +591,15 @@ func (msg *MsgTx) KaspaDecode(r io.Reader, pver uint32) error {
// Deserialize decodes a transaction from r into the receiver using a format
// that is suitable for long-term storage such as a database while respecting
// the Version field in the transaction. This function differs from KaspaDecode
// in that KaspaDecode decodes from the kaspa wire protocol as it was sent
// across the network. The wire encoding can technically differ depending on
// in that KaspaDecode decodes from the kaspa domainmessage protocol as it was sent
// across the network. The domainmessage encoding can technically differ depending on
// the protocol version and doesn't even really need to match the format of a
// stored transaction at all. As of the time this comment was written, the
// encoded transaction is the same in both instances, but there is a distinct
// difference and separating the two allows the API to be flexible enough to
// deal with changes.
func (msg *MsgTx) Deserialize(r io.Reader) error {
// At the current time, there is no difference between the wire encoding
// At the current time, there is no difference between the domainmessage encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of KaspaDecode.
return msg.KaspaDecode(r, 0)
@ -608,7 +608,7 @@ func (msg *MsgTx) Deserialize(r io.Reader) error {
// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
// This is part of the Message interface implementation.
// See Serialize for encoding transactions to be stored to disk, such as in a
// database, as opposed to encoding transactions for the wire.
// database, as opposed to encoding transactions for the domainmessage.
func (msg *MsgTx) KaspaEncode(w io.Writer, pver uint32) error {
return msg.encode(w, pver, txEncodingFull)
}
@ -697,22 +697,22 @@ func (msg *MsgTx) encode(w io.Writer, pver uint32, encodingFlags txEncoding) err
// Serialize encodes the transaction to w using a format that suitable for
// long-term storage such as a database while respecting the Version field in
// the transaction. This function differs from KaspaEncode in that KaspaEncode
// encodes the transaction to the kaspa wire protocol in order to be sent
// across the network. The wire encoding can technically differ depending on
// encodes the transaction to the kaspa domainmessage protocol in order to be sent
// across the network. The domainmessage encoding can technically differ depending on
// the protocol version and doesn't even really need to match the format of a
// stored transaction at all. As of the time this comment was written, the
// encoded transaction is the same in both instances, but there is a distinct
// difference and separating the two allows the API to be flexible enough to
// deal with changes.
func (msg *MsgTx) Serialize(w io.Writer) error {
// At the current time, there is no difference between the wire encoding
// At the current time, there is no difference between the domainmessage encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of KaspaEncode.
return msg.KaspaEncode(w, 0)
}
func (msg *MsgTx) serialize(w io.Writer, encodingFlags txEncoding) error {
// At the current time, there is no difference between the wire encoding
// At the current time, there is no difference between the domainmessage encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of `encode`.
return msg.encode(w, 0, encodingFlags)

38
wire/msgtx_test.go → domainmessage/msgtx_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"bytes"
@ -253,9 +253,9 @@ func TestTxHashAndID(t *testing.T) {
}
}
// TestTxWire tests the MsgTx wire encode and decode for various numbers
// TestTxEncoding tests the MsgTx domainmessage encode and decode for various numbers
// of transaction inputs and outputs and protocol versions.
func TestTxWire(t *testing.T) {
func TestTxEncoding(t *testing.T) {
// Empty tx message.
noTx := NewNativeMsgTx(1, nil, nil)
noTxEncoded := []byte{
@ -271,8 +271,8 @@ func TestTxWire(t *testing.T) {
tests := []struct {
in *MsgTx // Message to encode
out *MsgTx // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
}{
// Latest protocol version with no transactions.
{
@ -293,7 +293,7 @@ func TestTxWire(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode the message to wire format.
// Encode the message to domainmessage format.
var buf bytes.Buffer
err := test.in.KaspaEncode(&buf, test.pver)
if err != nil {
@ -306,7 +306,7 @@ func TestTxWire(t *testing.T) {
continue
}
// Decode the message from wire format.
// Decode the message from domainmessage format.
var msg MsgTx
rbuf := bytes.NewReader(test.buf)
err = msg.KaspaDecode(rbuf, test.pver)
@ -322,15 +322,15 @@ func TestTxWire(t *testing.T) {
}
}
// TestTxWireErrors performs negative tests against wire encode and decode
// TestTxEncodingErrors performs negative tests against domainmessage encode and decode
// of MsgTx to confirm error paths work correctly.
func TestTxWireErrors(t *testing.T) {
func TestTxEncodingErrors(t *testing.T) {
pver := ProtocolVersion
tests := []struct {
in *MsgTx // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
@ -363,7 +363,7 @@ func TestTxWireErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
// Encode to domainmessage format.
w := newFixedWriter(test.max)
err := test.in.KaspaEncode(w, test.pver)
if !errors.Is(err, test.writeErr) {
@ -372,7 +372,7 @@ func TestTxWireErrors(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
var msg MsgTx
r := newFixedReader(test.max, test.buf)
err = msg.KaspaDecode(r, test.pver)
@ -528,7 +528,7 @@ func TestTxSerialize(t *testing.T) {
}
}
// TestTxSerializeErrors performs negative tests against wire encode and decode
// TestTxSerializeErrors performs negative tests against domainmessage encode and decode
// of MsgTx to confirm error paths work correctly.
func TestTxSerializeErrors(t *testing.T) {
tests := []struct {
@ -628,8 +628,8 @@ func TestTxOverflowErrors(t *testing.T) {
txVer := uint32(1)
tests := []struct {
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
buf []byte // Encoded value
pver uint32 // Protocol version for domainmessage encoding
version uint32 // Transaction version
err error // Expected error
}{
@ -691,7 +691,7 @@ func TestTxOverflowErrors(t *testing.T) {
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Decode from wire format.
// Decode from domainmessage format.
var msg MsgTx
r := bytes.NewReader(test.buf)
err := msg.KaspaDecode(r, test.pver)
@ -701,7 +701,7 @@ func TestTxOverflowErrors(t *testing.T) {
continue
}
// Decode from wire format.
// Decode from domainmessage format.
r = bytes.NewReader(test.buf)
err = msg.Deserialize(r)
if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@ -891,7 +891,7 @@ var multiTxOuts = []*TxOut{
}
var multiTx = NewNativeMsgTx(1, multiTxIns, multiTxOuts)
// multiTxEncoded is the wire encoded bytes for multiTx using protocol version
// multiTxEncoded is the domainmessage encoded bytes for multiTx using protocol version
// 60002 and is used in the various tests.
var multiTxEncoded = []byte{
0x01, 0x00, 0x00, 0x00, // Version

2
wire/msgverack.go → domainmessage/msgverack.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
// MsgVerAck defines a kaspa verack message which is used for a peer to
// acknowledge a version message (MsgVersion) after it has used the information

2
wire/msgverack_test.go → domainmessage/msgverack_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"testing"

8
wire/msgversion.go → domainmessage/msgversion.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"fmt"
@ -20,7 +20,7 @@ import (
// version message (MsgVersion).
const MaxUserAgentLen = 256
// DefaultUserAgent for wire in the stack
// DefaultUserAgent for domainmessage in the stack
var DefaultUserAgent = fmt.Sprintf("/kaspad:%s/", version.Version())
// MsgVersion implements the Message interface and represents a kaspa version
@ -37,7 +37,7 @@ type MsgVersion struct {
// Bitfield which identifies the enabled services.
Services ServiceFlag
// Time the message was generated. This is encoded as an int64 on the wire.
// Time the message was generated. This is encoded as an int64 on the domainmessage.
Timestamp mstime.Time
// Address of the local peer.
@ -47,7 +47,7 @@ type MsgVersion struct {
ID *id.ID
// The user agent that generated messsage. This is a encoded as a varString
// on the wire. This has a max length of MaxUserAgentLen.
// on the domainmessage. This has a max length of MaxUserAgentLen.
UserAgent string
// The selected tip hash of the generator of the version message.

2
wire/msgversion_test.go → domainmessage/msgversion_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"github.com/davecgh/go-spew/spew"

4
wire/netaddress.go → domainmessage/netaddress.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"github.com/kaspanet/kaspad/util/mstime"
@ -21,7 +21,7 @@ type NetAddress struct {
// IP address of the peer.
IP net.IP
// Port the peer is using. This is encoded in big endian on the wire
// Port the peer is using. This is encoded in big endian on the domainmessage
// which differs from most everything else.
Port uint16
}

2
wire/netaddress_test.go → domainmessage/netaddress_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"net"

2
wire/protocol.go → domainmessage/protocol.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import (
"fmt"

2
wire/protocol_test.go → domainmessage/protocol_test.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
package domainmessage
import "testing"

0
wire/testdata/megatx.bin.bz2 → domainmessage/testdata/megatx.bin.bz2 vendored
View File

4
integration/64_incoming_connections_test.go
View File

@ -8,7 +8,7 @@ import (
"github.com/kaspanet/kaspad/util/locks"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
func Test64IncomingConnections(t *testing.T) {
@ -42,7 +42,7 @@ func Test64IncomingConnections(t *testing.T) {
}
blockAdded := false
bully.rpcClient.onBlockAdded = func(header *wire.BlockHeader) {
bully.rpcClient.onBlockAdded = func(header *domainmessage.BlockHeader) {
if blockAdded {
t.Fatalf("Single bully reported block added twice")
}

12
integration/basic_sync_test.go
View File

@ -4,7 +4,7 @@ import (
"testing"
"time"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
func TestIntegrationBasicSync(t *testing.T) {
@ -16,19 +16,19 @@ func TestIntegrationBasicSync(t *testing.T) {
connect(t, appHarness1, appHarness2)
connect(t, appHarness2, appHarness3)
app2OnBlockAddedChan := make(chan *wire.BlockHeader)
setOnBlockAddedHandler(t, appHarness2, func(header *wire.BlockHeader) {
app2OnBlockAddedChan := make(chan *domainmessage.BlockHeader)
setOnBlockAddedHandler(t, appHarness2, func(header *domainmessage.BlockHeader) {
app2OnBlockAddedChan <- header
})
app3OnBlockAddedChan := make(chan *wire.BlockHeader)
setOnBlockAddedHandler(t, appHarness3, func(header *wire.BlockHeader) {
app3OnBlockAddedChan := make(chan *domainmessage.BlockHeader)
setOnBlockAddedHandler(t, appHarness3, func(header *domainmessage.BlockHeader) {
app3OnBlockAddedChan <- header
})
block := mineNextBlock(t, appHarness1)
var header *wire.BlockHeader
var header *domainmessage.BlockHeader
select {
case header = <-app2OnBlockAddedChan:
case <-time.After(defaultTimeout):

4
integration/ibd_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/kaspanet/kaspad/util/locks"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
func TestIBD(t *testing.T) {
@ -23,7 +23,7 @@ func TestIBD(t *testing.T) {
blockAddedWG := sync.WaitGroup{}
blockAddedWG.Add(numBlocks)
receivedBlocks := 0
setOnBlockAddedHandler(t, syncee, func(header *wire.BlockHeader) {
setOnBlockAddedHandler(t, syncee, func(header *domainmessage.BlockHeader) {
receivedBlocks++
blockAddedWG.Done()
})

4
integration/mining_test.go
View File

@ -6,12 +6,12 @@ import (
clientpkg "github.com/kaspanet/kaspad/rpc/client"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
func solveBlock(block *util.Block) *wire.MsgBlock {
func solveBlock(block *util.Block) *domainmessage.MsgBlock {
msgBlock := block.MsgBlock()
targetDifficulty := util.CompactToBig(msgBlock.Header.Bits)
initialNonce := rand.Uint64()

4
integration/notifications_test.go
View File

@ -3,10 +3,10 @@ package integration
import (
"testing"
"github.com/kaspanet/kaspad/wire"
"github.com/kaspanet/kaspad/domainmessage"
)
func setOnBlockAddedHandler(t *testing.T, harness *appHarness, handler func(header *wire.BlockHeader)) {
func setOnBlockAddedHandler(t *testing.T, harness *appHarness, handler func(header *domainmessage.BlockHeader)) {
err := harness.rpcClient.NotifyBlocks()
if err != nil {
t.Fatalf("Error from NotifyBlocks: %s", err)

6
integration/rpc_test.go
View File

@ -1,21 +1,21 @@
package integration
import (
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/wire"
rpcclient "github.com/kaspanet/kaspad/rpc/client"
)
type rpcClient struct {
*rpcclient.Client
onBlockAdded func(*wire.BlockHeader)
onBlockAdded func(*domainmessage.BlockHeader)
}
func newRPCClient(rpcAddress string) (*rpcClient, error) {
client := &rpcClient{}
notificationHandlers := &rpcclient.NotificationHandlers{
OnFilteredBlockAdded: func(height uint64, header *wire.BlockHeader, txs []*util.Tx) {
OnFilteredBlockAdded: func(height uint64, header *domainmessage.BlockHeader, txs []*util.Tx) {
if client.onBlockAdded != nil {
client.onBlockAdded(header)
}

18
integration/tx_relay_test.go
View File

@ -7,9 +7,9 @@ import (
"time"
"github.com/kaspanet/go-secp256k1"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/wire"
)
func TestTxRelay(t *testing.T) {
@ -21,8 +21,8 @@ func TestTxRelay(t *testing.T) {
connect(t, payer, mediator)
connect(t, mediator, payee)
payeeBlockAddedChan := make(chan *wire.BlockHeader)
setOnBlockAddedHandler(t, payee, func(header *wire.BlockHeader) {
payeeBlockAddedChan := make(chan *domainmessage.BlockHeader)
setOnBlockAddedHandler(t, payee, func(header *domainmessage.BlockHeader) {
payeeBlockAddedChan <- header
})
// skip the first block because it's paying to genesis script
@ -70,7 +70,7 @@ func TestTxRelay(t *testing.T) {
}
}
func waitForPayeeToReceiveBlock(t *testing.T, payeeBlockAddedChan chan *wire.BlockHeader) {
func waitForPayeeToReceiveBlock(t *testing.T, payeeBlockAddedChan chan *domainmessage.BlockHeader) {
select {
case <-payeeBlockAddedChan:
case <-time.After(defaultTimeout):
@ -78,9 +78,9 @@ func waitForPayeeToReceiveBlock(t *testing.T, payeeBlockAddedChan chan *wire.Blo
}
}
func generateTx(t *testing.T, firstBlockCoinbase *wire.MsgTx, payer, payee *appHarness) *wire.MsgTx {
txIns := make([]*wire.TxIn, 1)
txIns[0] = wire.NewTxIn(wire.NewOutpoint(firstBlockCoinbase.TxID(), 0), []byte{})
func generateTx(t *testing.T, firstBlockCoinbase *domainmessage.MsgTx, payer, payee *appHarness) *domainmessage.MsgTx {
txIns := make([]*domainmessage.TxIn, 1)
txIns[0] = domainmessage.NewTxIn(domainmessage.NewOutpoint(firstBlockCoinbase.TxID(), 0), []byte{})
payeeAddress, err := util.DecodeAddress(payee.miningAddress, util.Bech32PrefixKaspaSim)
if err != nil {
@ -91,11 +91,11 @@ func generateTx(t *testing.T, firstBlockCoinbase *wire.MsgTx, payer, payee *appH
t.Fatalf("Error generating script: %+v", err)
}
txOuts := []*wire.TxOut{wire.NewTxOut(firstBlockCoinbase.TxOut[0].Value-1, toScript)}
txOuts := []*domainmessage.TxOut{domainmessage.NewTxOut(firstBlockCoinbase.TxOut[0].Value-1, toScript)}
fromScript := firstBlockCoinbase.TxOut[0].ScriptPubKey
tx := wire.NewNativeMsgTx(wire.TxVersion, txIns, txOuts)
tx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, txIns, txOuts)
privateKeyBytes, err := hex.DecodeString(payer.miningAddressPrivateKey)
if err != nil {

2
mempool/error.go
View File

@ -150,7 +150,7 @@ func extractRejectCode(err error) (RejectCode, bool) {
}
// ErrToRejectErr examines the underlying type of the error and returns a reject
// code and string appropriate to be sent in a wire.MsgReject message.
// code and string appropriate to be sent in a domainmessage.MsgReject message.
func ErrToRejectErr(err error) (RejectCode, string) {
// Return the reject code along with the error text if it can be
// extracted from the error.

36
mempool/mempool.go
View File

@ -15,13 +15,13 @@ import (
"github.com/pkg/errors"
"github.com/kaspanet/kaspad/blockdag"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/logger"
"github.com/kaspanet/kaspad/mining"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/subnetworkid"
"github.com/kaspanet/kaspad/wire"
)
const (
@ -129,10 +129,10 @@ type TxPool struct {
cfg Config
pool map[daghash.TxID]*TxDesc
depends map[daghash.TxID]*TxDesc
dependsByPrev map[wire.Outpoint]map[daghash.TxID]*TxDesc
dependsByPrev map[domainmessage.Outpoint]map[daghash.TxID]*TxDesc
orphans map[daghash.TxID]*orphanTx
orphansByPrev map[wire.Outpoint]map[daghash.TxID]*util.Tx
outpoints map[wire.Outpoint]*util.Tx
orphansByPrev map[domainmessage.Outpoint]map[daghash.TxID]*util.Tx
outpoints map[domainmessage.Outpoint]*util.Tx
// nextExpireScan is the time after which the orphan pool will be
// scanned in order to evict orphans. This is NOT a hard deadline as
@ -174,7 +174,7 @@ func (mp *TxPool) removeOrphan(tx *util.Tx, removeRedeemers bool) {
// Remove any orphans that redeem outputs from this one if requested.
if removeRedeemers {
prevOut := wire.Outpoint{TxID: *txID}
prevOut := domainmessage.Outpoint{TxID: *txID}
for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx)
for _, orphan := range mp.orphansByPrev[prevOut] {
@ -479,7 +479,7 @@ func (mp *TxPool) removeTransaction(tx *util.Tx, removeDependants bool, restoreI
if removeDependants {
// Remove any transactions which rely on this one.
for i := uint32(0); i < uint32(len(tx.MsgTx().TxOut)); i++ {
prevOut := wire.Outpoint{TxID: *txID, Index: i}
prevOut := domainmessage.Outpoint{TxID: *txID, Index: i}
if txRedeemer, exists := mp.outpoints[prevOut]; exists {
err := mp.removeTransaction(txRedeemer, true, false)
if err != nil {
@ -541,7 +541,7 @@ func (mp *TxPool) removeTransactionWithDiff(tx *util.Tx, diff *blockdag.UTXODiff
// removeTransactionUTXOEntriesFromDiff removes tx's UTXOEntries from the diff
func (mp *TxPool) removeTransactionUTXOEntriesFromDiff(tx *util.Tx, diff *blockdag.UTXODiff) error {
for idx := range tx.MsgTx().TxOut {
outpoint := *wire.NewOutpoint(tx.ID(), uint32(idx))
outpoint := *domainmessage.NewOutpoint(tx.ID(), uint32(idx))
entry, exists := mp.mpUTXOSet.Get(outpoint)
if exists {
err := diff.RemoveEntry(outpoint, entry)
@ -583,7 +583,7 @@ func (mp *TxPool) markTransactionOutputsUnspent(tx *util.Tx, diff *blockdag.UTXO
// processRemovedTransactionDependencies processes the dependencies of a
// transaction tx that was just now removed from the mempool
func (mp *TxPool) processRemovedTransactionDependencies(tx *util.Tx) {
prevOut := wire.Outpoint{TxID: *tx.ID()}
prevOut := domainmessage.Outpoint{TxID: *tx.ID()}
for txOutIdx := range tx.MsgTx().TxOut {
// Skip to the next available output if there are none.
prevOut.Index = uint32(txOutIdx)
@ -664,7 +664,7 @@ func (mp *TxPool) removeDoubleSpends(tx *util.Tx) error {
// helper for maybeAcceptTransaction.
//
// This function MUST be called with the mempool lock held (for writes).
func (mp *TxPool) addTransaction(tx *util.Tx, fee uint64, parentsInPool []*wire.Outpoint) (*TxDesc, error) {
func (mp *TxPool) addTransaction(tx *util.Tx, fee uint64, parentsInPool []*domainmessage.Outpoint) (*TxDesc, error) {
// Add the transaction to the pool and mark the referenced outpoints
// as spent by the pool.
mass, err := blockdag.CalcTxMassFromUTXOSet(tx, mp.mpUTXOSet)
@ -728,7 +728,7 @@ func (mp *TxPool) checkPoolDoubleSpend(tx *util.Tx) error {
// CheckSpend checks whether the passed outpoint is already spent by a
// transaction in the mempool. If that's the case the spending transaction will
// be returned, if not nil will be returned.
func (mp *TxPool) CheckSpend(op wire.Outpoint) *util.Tx {
func (mp *TxPool) CheckSpend(op domainmessage.Outpoint) *util.Tx {
mp.mtx.RLock()
defer mp.mtx.RUnlock()
txR := mp.outpoints[op]
@ -783,9 +783,9 @@ func (mp *TxPool) FetchTransaction(txID *daghash.TxID) (*util.Tx, bool) {
// checkTransactionMassSanity checks that a transaction must not exceed the maximum allowed block mass when serialized.
func checkTransactionMassSanity(tx *util.Tx) error {
serializedTxSize := tx.MsgTx().SerializeSize()
if serializedTxSize*blockdag.MassPerTxByte > wire.MaxMassPerTx {
if serializedTxSize*blockdag.MassPerTxByte > domainmessage.MaxMassPerTx {
str := fmt.Sprintf("serialized transaction is too big - got "+
"%d, max %d", serializedTxSize, wire.MaxMassPerBlock)
"%d, max %d", serializedTxSize, domainmessage.MaxMassPerBlock)
return txRuleError(RejectInvalid, str)
}
return nil
@ -912,7 +912,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, rejectDupOrphans bool) ([]
// Don't allow the transaction if it exists in the DAG and is
// not already fully spent.
prevOut := wire.Outpoint{TxID: *txID}
prevOut := domainmessage.Outpoint{TxID: *txID}
for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx)
_, ok := mp.mpUTXOSet.Get(prevOut)
@ -927,7 +927,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, rejectDupOrphans bool) ([]
// is not handled by this function, and the caller should use
// maybeAddOrphan if this behavior is desired.
var missingParents []*daghash.TxID
var parentsInPool []*wire.Outpoint
var parentsInPool []*domainmessage.Outpoint
for _, txIn := range tx.MsgTx().TxIn {
if _, ok := mp.mpUTXOSet.Get(txIn.PreviousOutpoint); !ok {
// Must make a copy of the hash here since the iterator
@ -1075,7 +1075,7 @@ func (mp *TxPool) processOrphans(acceptedTx *util.Tx) []*TxDesc {
firstElement := processList.Remove(processList.Front())
processItem := firstElement.(*util.Tx)
prevOut := wire.Outpoint{TxID: *processItem.ID()}
prevOut := domainmessage.Outpoint{TxID: *processItem.ID()}
for txOutIdx := range processItem.MsgTx().TxOut {
// Look up all orphans that redeem the output that is
// now available. This will typically only be one, but
@ -1392,11 +1392,11 @@ func New(cfg *Config) *TxPool {
cfg: *cfg,
pool: make(map[daghash.TxID]*TxDesc),
depends: make(map[daghash.TxID]*TxDesc),
dependsByPrev: make(map[wire.Outpoint]map[daghash.TxID]*TxDesc),
dependsByPrev: make(map[domainmessage.Outpoint]map[daghash.TxID]*TxDesc),
orphans: make(map[daghash.TxID]*orphanTx),
orphansByPrev: make(map[wire.Outpoint]map[daghash.TxID]*util.Tx),
orphansByPrev: make(map[domainmessage.Outpoint]map[daghash.TxID]*util.Tx),
nextExpireScan: mstime.Now().Add(orphanExpireScanInterval),
outpoints: make(map[wire.Outpoint]*util.Tx),
outpoints: make(map[domainmessage.Outpoint]*util.Tx),
mpUTXOSet: mpUTXO,
}
}

126
mempool/mempool_test.go
View File

@ -22,11 +22,11 @@ import (
"github.com/kaspanet/kaspad/blockdag"
"github.com/kaspanet/kaspad/dagconfig"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/mining"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/wire"
)
// fakeDAG is used by the pool harness to provide generated test utxos and
@ -82,7 +82,7 @@ func calcSequenceLock(tx *util.Tx,
// spendableOutpoint is a convenience type that houses a particular utxo and the
// amount associated with it.
type spendableOutpoint struct {
outpoint wire.Outpoint
outpoint domainmessage.Outpoint
amount util.Amount
}
@ -91,7 +91,7 @@ type spendableOutpoint struct {
// transactions.
func txOutToSpendableOutpoint(tx *util.Tx, outputNum uint32) spendableOutpoint {
return spendableOutpoint{
outpoint: wire.Outpoint{TxID: *tx.ID(), Index: outputNum},
outpoint: domainmessage.Outpoint{TxID: *tx.ID(), Index: outputNum},
amount: util.Amount(tx.MsgTx().TxOut[outputNum].Value),
}
}
@ -125,16 +125,16 @@ func (p *poolHarness) CreateCoinbaseTx(blueScore uint64, numOutputs uint32) (*ut
return nil, err
}
txIns := []*wire.TxIn{{
txIns := []*domainmessage.TxIn{{
// Coinbase transactions have no inputs, so previous outpoint is
// zero hash and max index.
PreviousOutpoint: *wire.NewOutpoint(&daghash.TxID{},
wire.MaxPrevOutIndex),
PreviousOutpoint: *domainmessage.NewOutpoint(&daghash.TxID{},
domainmessage.MaxPrevOutIndex),
SignatureScript: coinbaseScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}}
txOuts := []*wire.TxOut{}
txOuts := []*domainmessage.TxOut{}
totalInput := blockdag.CalcBlockSubsidy(blueScore, p.dagParams)
amountPerOutput := totalInput / uint64(numOutputs)
remainder := totalInput - amountPerOutput*uint64(numOutputs)
@ -145,13 +145,13 @@ func (p *poolHarness) CreateCoinbaseTx(blueScore uint64, numOutputs uint32) (*ut
if i == numOutputs-1 {
amount = amountPerOutput + remainder
}
txOuts = append(txOuts, &wire.TxOut{
txOuts = append(txOuts, &domainmessage.TxOut{
ScriptPubKey: p.payScript,
Value: amount,
})
}
return util.NewTx(wire.NewNativeMsgTx(wire.TxVersion, txIns, txOuts)), nil
return util.NewTx(domainmessage.NewNativeMsgTx(domainmessage.TxVersion, txIns, txOuts)), nil
}
// CreateSignedTxForSubnetwork creates a new signed transaction that consumes the provided
@ -169,16 +169,16 @@ func (p *poolHarness) CreateSignedTxForSubnetwork(inputs []spendableOutpoint, nu
amountPerOutput := uint64(totalInput) / uint64(numOutputs)
remainder := uint64(totalInput) - amountPerOutput*uint64(numOutputs)
var txIns []*wire.TxIn
var txIns []*domainmessage.TxIn
for _, input := range inputs {
txIns = append(txIns, &wire.TxIn{
txIns = append(txIns, &domainmessage.TxIn{
PreviousOutpoint: input.outpoint,
SignatureScript: p.signatureScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
})
}
var txOuts []*wire.TxOut
var txOuts []*domainmessage.TxOut
for i := uint32(0); i < numOutputs; i++ {
// Ensure the final output accounts for any remainder that might
// be left from splitting the input amount.
@ -186,13 +186,13 @@ func (p *poolHarness) CreateSignedTxForSubnetwork(inputs []spendableOutpoint, nu
if i == numOutputs-1 {
amount = amountPerOutput + remainder
}
txOuts = append(txOuts, &wire.TxOut{
txOuts = append(txOuts, &domainmessage.TxOut{
ScriptPubKey: p.payScript,
Value: amount,
})
}
tx := wire.NewSubnetworkMsgTx(wire.TxVersion, txIns, txOuts, subnetworkID, gas, []byte{})
tx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, txIns, txOuts, subnetworkID, gas, []byte{})
// Sign the new transaction.
for i := range tx.TxIn {
@ -224,21 +224,21 @@ func (p *poolHarness) CreateTxChain(firstOutput spendableOutpoint, numTxns uint3
// associated with the harness.
spendableAmount = spendableAmount - txRelayFeeForTest
txIn := &wire.TxIn{
txIn := &domainmessage.TxIn{
PreviousOutpoint: prevOutpoint,
SignatureScript: p.signatureScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}
txOut := &wire.TxOut{
txOut := &domainmessage.TxOut{
ScriptPubKey: p.payScript,
Value: uint64(spendableAmount),
}
tx := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn}, []*wire.TxOut{txOut})
tx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut})
txChain = append(txChain, util.NewTx(tx))
// Next transaction uses outputs from this one.
prevOutpoint = wire.Outpoint{TxID: *tx.TxID(), Index: 0}
prevOutpoint = domainmessage.Outpoint{TxID: *tx.TxID(), Index: 0}
}
return txChain, nil
@ -246,12 +246,12 @@ func (p *poolHarness) CreateTxChain(firstOutput spendableOutpoint, numTxns uint3
func (tc *testContext) mineTransactions(transactions []*util.Tx, numberOfBlocks uint64) []spendableOutpoint {
var outpoints []spendableOutpoint
msgTxs := make([]*wire.MsgTx, len(transactions))
msgTxs := make([]*domainmessage.MsgTx, len(transactions))
for i, tx := range transactions {
msgTxs[i] = tx.MsgTx()
}
for i := uint64(0); i < numberOfBlocks; i++ {
var blockTxs []*wire.MsgTx
var blockTxs []*domainmessage.MsgTx
if i == 0 {
blockTxs = msgTxs
}
@ -292,7 +292,7 @@ func (tc *testContext) mineTransactions(transactions []*util.Tx, numberOfBlocks
for i, txOut := range coinbaseTx.TxOut {
outpoints = append(outpoints, spendableOutpoint{
outpoint: *wire.NewOutpoint(coinbaseTx.TxID(), uint32(i)),
outpoint: *domainmessage.NewOutpoint(coinbaseTx.TxID(), uint32(i)),
amount: util.Amount(txOut.Value),
})
}
@ -455,21 +455,21 @@ func testPoolMembership(tc *testContext, tx *util.Tx, inOrphanPool, inTxPool boo
}
func (p *poolHarness) createTx(outpoint spendableOutpoint, fee uint64, numOutputs int64) (*util.Tx, error) {
txIns := []*wire.TxIn{{
txIns := []*domainmessage.TxIn{{
PreviousOutpoint: outpoint.outpoint,
SignatureScript: nil,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}}
var txOuts []*wire.TxOut
var txOuts []*domainmessage.TxOut
amountPerOutput := (uint64(outpoint.amount) - fee) / uint64(numOutputs)
for i := int64(0); i < numOutputs; i++ {
txOuts = append(txOuts, &wire.TxOut{
txOuts = append(txOuts, &domainmessage.TxOut{
ScriptPubKey: p.payScript,
Value: amountPerOutput,
})
}
tx := wire.NewNativeMsgTx(wire.TxVersion, txIns, txOuts)
tx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, txIns, txOuts)
// Sign the new transaction.
tx.TxIn[0].SignatureScript = p.signatureScript
@ -506,7 +506,7 @@ func TestProcessTransaction(t *testing.T) {
orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{}, Index: 1},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{}, Index: 1},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -574,7 +574,7 @@ func TestProcessTransaction(t *testing.T) {
if err != nil {
t.Fatalf("Unexpected error from harness.createTx: %s", err)
}
nonStdTx.MsgTx().Version = wire.TxVersion + 1
nonStdTx.MsgTx().Version = domainmessage.TxVersion + 1
_, err = harness.txPool.ProcessTransaction(nonStdTx, true, 0)
if err == nil {
t.Errorf("ProcessTransaction: expected an error, not nil")
@ -641,7 +641,7 @@ func TestProcessTransaction(t *testing.T) {
if err != nil {
t.Fatalf("NewShaHashFromStr: unexpected error: %v", err)
}
dummyPrevOut := wire.Outpoint{TxID: *dummyPrevOutTxID, Index: 1}
dummyPrevOut := domainmessage.Outpoint{TxID: *dummyPrevOutTxID, Index: 1}
dummySigScript := bytes.Repeat([]byte{0x00}, 65)
addrHash := [20]byte{0x01}
@ -654,23 +654,23 @@ func TestProcessTransaction(t *testing.T) {
if err != nil {
t.Fatalf("PayToAddrScript: unexpected error: %v", err)
}
p2shTx := util.NewTx(wire.NewNativeMsgTx(1, nil, []*wire.TxOut{{Value: 5000000000, ScriptPubKey: p2shScriptPubKey}}))
p2shTx := util.NewTx(domainmessage.NewNativeMsgTx(1, nil, []*domainmessage.TxOut{{Value: 5000000000, ScriptPubKey: p2shScriptPubKey}}))
if isAccepted, err := harness.txPool.mpUTXOSet.AddTx(p2shTx.MsgTx(), currentBlueScore+1); err != nil {
t.Fatalf("AddTx unexpectedly failed. Error: %s", err)
} else if !isAccepted {
t.Fatalf("AddTx unexpectedly didn't add tx %s", p2shTx.ID())
}
txIns := []*wire.TxIn{{
PreviousOutpoint: wire.Outpoint{TxID: *p2shTx.ID(), Index: 0},
txIns := []*domainmessage.TxIn{{
PreviousOutpoint: domainmessage.Outpoint{TxID: *p2shTx.ID(), Index: 0},
SignatureScript: wrappedP2SHNonStdSigScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}}
txOuts := []*wire.TxOut{{
txOuts := []*domainmessage.TxOut{{
Value: 5000000000,
ScriptPubKey: dummyScriptPubKey,
}}
nonStdSigScriptTx := util.NewTx(wire.NewNativeMsgTx(1, txIns, txOuts))
nonStdSigScriptTx := util.NewTx(domainmessage.NewNativeMsgTx(1, txIns, txOuts))
_, err = harness.txPool.ProcessTransaction(nonStdSigScriptTx, true, 0)
if err == nil {
t.Errorf("ProcessTransaction: expected an error, not nil")
@ -688,10 +688,10 @@ func TestProcessTransaction(t *testing.T) {
}
// Checks that a transaction with no outputs will not get rejected
noOutsTx := util.NewTx(wire.NewNativeMsgTx(1, []*wire.TxIn{{
noOutsTx := util.NewTx(domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{
PreviousOutpoint: dummyPrevOut,
SignatureScript: dummySigScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}},
nil))
_, err = harness.txPool.ProcessTransaction(noOutsTx, true, 0)
@ -738,16 +738,16 @@ func TestProcessTransaction(t *testing.T) {
t.Errorf("Unexpected error code. Expected %v but got %v", RejectInsufficientFee, code)
}
txIns = []*wire.TxIn{{
txIns = []*domainmessage.TxIn{{
PreviousOutpoint: spendableOuts[5].outpoint,
SignatureScript: []byte{02, 01}, // Unparsable script
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}}
txOuts = []*wire.TxOut{{
txOuts = []*domainmessage.TxOut{{
Value: 1,
ScriptPubKey: dummyScriptPubKey,
}}
tx = util.NewTx(wire.NewNativeMsgTx(1, txIns, txOuts))
tx = util.NewTx(domainmessage.NewNativeMsgTx(1, txIns, txOuts))
_, err = harness.txPool.ProcessTransaction(tx, true, 0)
fmt.Println(err)
if err == nil {
@ -826,7 +826,7 @@ func TestDoubleSpendsFromDAG(t *testing.T) {
}
dag := harness.txPool.cfg.DAG
blockdag.PrepareAndProcessBlockForTest(t, dag, dag.TipHashes(), []*wire.MsgTx{tx.MsgTx()})
blockdag.PrepareAndProcessBlockForTest(t, dag, dag.TipHashes(), []*domainmessage.MsgTx{tx.MsgTx()})
// Check that a transaction that double spends the DAG UTXO set is orphaned.
doubleSpendTx, err := harness.createTx(spendableOuts[0], uint64(txRelayFeeForTest), 2)
@ -875,7 +875,7 @@ func TestFetchTransaction(t *testing.T) {
orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{1}, Index: 1},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{1}, Index: 1},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1035,7 +1035,7 @@ func TestOrphanExpiration(t *testing.T) {
expiredTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{}, Index: 0},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{}, Index: 0},
}}, 1)
if err != nil {
t.Fatalf("Unexpected error on harness.CreateSignedTx: %s", err)
@ -1049,7 +1049,7 @@ func TestOrphanExpiration(t *testing.T) {
tx1, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{1}, Index: 0},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{1}, Index: 0},
}}, 1)
if err != nil {
t.Fatalf("Unexpected error on harness.CreateSignedTx: %s", err)
@ -1069,7 +1069,7 @@ func TestOrphanExpiration(t *testing.T) {
tx2, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{2}, Index: 0},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{2}, Index: 0},
}}, 1)
if err != nil {
t.Fatalf("Unexpected error on harness.CreateSignedTx: %s", err)
@ -1098,7 +1098,7 @@ func TestMaxOrphanTxSize(t *testing.T) {
tx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{}, Index: 0},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{}, Index: 0},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1227,7 +1227,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
orphanedTx1, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{1}, Index: 1},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{1}, Index: 1},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1235,7 +1235,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
harness.txPool.ProcessTransaction(orphanedTx1, true, 1)
orphanedTx2, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{2}, Index: 2},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{2}, Index: 2},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1243,7 +1243,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
harness.txPool.ProcessTransaction(orphanedTx2, true, 1)
orphanedTx3, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{3}, Index: 3},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{3}, Index: 3},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1252,7 +1252,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
orphanedTx4, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{4}, Index: 4},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{4}, Index: 4},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1312,7 +1312,7 @@ func TestBasicOrphanRemoval(t *testing.T) {
// and ensure the state of all other orphans are unaffected.
nonChainedOrphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outpoint: wire.Outpoint{TxID: daghash.TxID{}, Index: 0},
outpoint: domainmessage.Outpoint{TxID: daghash.TxID{}, Index: 0},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1536,7 +1536,7 @@ func TestCheckSpend(t *testing.T) {
// Now all but the last tx should be spent by the next.
for i := 0; i < len(chainedTxns)-1; i++ {
op = wire.Outpoint{
op = domainmessage.Outpoint{
TxID: *chainedTxns[i].ID(),
Index: 0,
}
@ -1549,7 +1549,7 @@ func TestCheckSpend(t *testing.T) {
}
// The last tx should have no spend.
op = wire.Outpoint{
op = domainmessage.Outpoint{
TxID: *chainedTxns[txChainLength-1].ID(),
Index: 0,
}
@ -1681,7 +1681,7 @@ func TestHandleNewBlock(t *testing.T) {
orphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(2500000000 - txRelayFeeForTest),
outpoint: wire.Outpoint{TxID: *txID, Index: 0},
outpoint: domainmessage.Outpoint{TxID: *txID, Index: 0},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1757,8 +1757,8 @@ func TestHandleNewBlock(t *testing.T) {
}
// dummyBlock defines a block on the block DAG. It is used to test block operations.
var dummyBlock = wire.MsgBlock{
Header: wire.BlockHeader{
var dummyBlock = domainmessage.MsgBlock{
Header: domainmessage.BlockHeader{
Version: 1,
ParentHashes: []*daghash.Hash{
{
@ -1783,11 +1783,11 @@ var dummyBlock = wire.MsgBlock{
Bits: 0x1e00ffff, // 503382015
Nonce: 0x000ae53f, // 714047
},
Transactions: []*wire.MsgTx{
Transactions: []*domainmessage.MsgTx{
{
Version: 1,
TxIn: []*wire.TxIn{},
TxOut: []*wire.TxOut{
TxIn: []*domainmessage.TxIn{},
TxOut: []*domainmessage.TxOut{
{
Value: 0x12a05f200, // 5000000000
ScriptPubKey: []byte{

4
mempool/policy.go
View File

@ -9,9 +9,9 @@ import (
"github.com/kaspanet/kaspad/util/mstime"
"github.com/kaspanet/kaspad/blockdag"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/wire"
)
const (
@ -118,7 +118,7 @@ func checkInputsStandard(tx *util.Tx, utxoSet blockdag.UTXOSet) error {
// Dust is defined in terms of the minimum transaction relay fee. In
// particular, if the cost to the network to spend coins is more than 1/3 of the
// minimum transaction relay fee, it is considered dust.
func isDust(txOut *wire.TxOut, minRelayTxFee util.Amount) bool {
func isDust(txOut *domainmessage.TxOut, minRelayTxFee util.Amount) bool {
// Unspendable outputs are considered dust.
if txscript.IsUnspendable(txOut.ScriptPubKey) {
return true

56
mempool/policy_test.go
View File

@ -6,11 +6,11 @@ package mempool
import (
"bytes"
"github.com/kaspanet/kaspad/domainmessage"
"github.com/kaspanet/kaspad/txscript"
"github.com/kaspanet/kaspad/util"
"github.com/kaspanet/kaspad/util/daghash"
"github.com/kaspanet/kaspad/util/mstime"
"github.com/kaspanet/kaspad/wire"
"github.com/pkg/errors"
"testing"
)
@ -102,47 +102,47 @@ func TestDust(t *testing.T) {
tests := []struct {
name string // test description
txOut wire.TxOut
txOut domainmessage.TxOut
relayFee util.Amount // minimum relay transaction fee.
isDust bool
}{
{
// Any value is allowed with a zero relay fee.
"zero value with zero relay fee",
wire.TxOut{Value: 0, ScriptPubKey: scriptPubKey},
domainmessage.TxOut{Value: 0, ScriptPubKey: scriptPubKey},
0,
false,
},
{
// Zero value is dust with any relay fee"
"zero value with very small tx fee",
wire.TxOut{Value: 0, ScriptPubKey: scriptPubKey},
domainmessage.TxOut{Value: 0, ScriptPubKey: scriptPubKey},
1,
true,
},
{
"38 byte public key script with value 584",
wire.TxOut{Value: 584, ScriptPubKey: scriptPubKey},
domainmessage.TxOut{Value: 584, ScriptPubKey: scriptPubKey},
1000,
true,
},
{
"38 byte public key script with value 585",
wire.TxOut{Value: 585, ScriptPubKey: scriptPubKey},
domainmessage.TxOut{Value: 585, ScriptPubKey: scriptPubKey},
1000,
false,
},
{
// Maximum allowed value is never dust.
"max sompi amount is never dust",
wire.TxOut{Value: util.MaxSompi, ScriptPubKey: scriptPubKey},
domainmessage.TxOut{Value: util.MaxSompi, ScriptPubKey: scriptPubKey},
util.MaxSompi,
false,
},
{
// Maximum int64 value causes overflow.
"maximum int64 value",
wire.TxOut{Value: 1<<63 - 1, ScriptPubKey: scriptPubKey},
domainmessage.TxOut{Value: 1<<63 - 1, ScriptPubKey: scriptPubKey},
1<<63 - 1,
true,
},
@ -150,7 +150,7 @@ func TestDust(t *testing.T) {
// Unspendable scriptPubKey due to an invalid public key
// script.
"unspendable scriptPubKey",
wire.TxOut{Value: 5000, ScriptPubKey: []byte{0x01}},
domainmessage.TxOut{Value: 5000, ScriptPubKey: []byte{0x01}},
0, // no relay fee
true,
},
@ -172,12 +172,12 @@ func TestCheckTransactionStandard(t *testing.T) {
if err != nil {
t.Fatalf("NewShaHashFromStr: unexpected error: %v", err)
}
dummyPrevOut := wire.Outpoint{TxID: *prevOutTxID, Index: 1}
dummyPrevOut := domainmessage.Outpoint{TxID: *prevOutTxID, Index: 1}
dummySigScript := bytes.Repeat([]byte{0x00}, 65)
dummyTxIn := wire.TxIn{
dummyTxIn := domainmessage.TxIn{
PreviousOutpoint: dummyPrevOut,
SignatureScript: dummySigScript,
Sequence: wire.MaxTxInSequenceNum,
Sequence: domainmessage.MaxTxInSequenceNum,
}
addrHash := [20]byte{0x01}
addr, err := util.NewAddressPubKeyHash(addrHash[:], util.Bech32PrefixKaspaTest)
@ -188,45 +188,45 @@ func TestCheckTransactionStandard(t *testing.T) {
if err != nil {
t.Fatalf("PayToAddrScript: unexpected error: %v", err)
}
dummyTxOut := wire.TxOut{
dummyTxOut := domainmessage.TxOut{
Value: 100000000, // 1 KAS
ScriptPubKey: dummyScriptPubKey,
}
tests := []struct {
name string
tx *wire.MsgTx
tx *domainmessage.MsgTx
height uint64
isStandard bool
code RejectCode
}{
{
name: "Typical pay-to-pubkey-hash transaction",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{&dummyTxIn}, []*wire.TxOut{&dummyTxOut}),
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{&dummyTxIn}, []*domainmessage.TxOut{&dummyTxOut}),
height: 300000,
isStandard: true,
},
{
name: "Transaction version too high",
tx: wire.NewNativeMsgTx(wire.TxVersion+1, []*wire.TxIn{&dummyTxIn}, []*wire.TxOut{&dummyTxOut}),
tx: domainmessage.NewNativeMsgTx(domainmessage.TxVersion+1, []*domainmessage.TxIn{&dummyTxIn}, []*domainmessage.TxOut{&dummyTxOut}),
height: 300000,
isStandard: false,
code: RejectNonstandard,
},
{
name: "Transaction is not finalized",
tx: wire.NewNativeMsgTxWithLocktime(1, []*wire.TxIn{{
tx: domainmessage.NewNativeMsgTxWithLocktime(1, []*domainmessage.TxIn{{
PreviousOutpoint: dummyPrevOut,
SignatureScript: dummySigScript,
Sequence: 0,
}}, []*wire.TxOut{&dummyTxOut}, 300001),
}}, []*domainmessage.TxOut{&dummyTxOut}, 300001),
height: 300000,
isStandard: false,
code: RejectNonstandard,
},
{
name: "Transaction size is too large",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{&dummyTxIn}, []*wire.TxOut{{
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{&dummyTxIn}, []*domainmessage.TxOut{{
Value: 0,
ScriptPubKey: bytes.Repeat([]byte{0x00},
MaxStandardTxSize+1),
@ -237,31 +237,31 @@ func TestCheckTransactionStandard(t *testing.T) {
},
{
name: "Signature script size is too large",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{
PreviousOutpoint: dummyPrevOut,
SignatureScript: bytes.Repeat([]byte{0x00},
maxStandardSigScriptSize+1),
Sequence: wire.MaxTxInSequenceNum,
}}, []*wire.TxOut{&dummyTxOut}),
Sequence: domainmessage.MaxTxInSequenceNum,
}}, []*domainmessage.TxOut{&dummyTxOut}),
height: 300000,
isStandard: false,
code: RejectNonstandard,
},
{
name: "Signature script that does more than push data",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{
PreviousOutpoint: dummyPrevOut,
SignatureScript: []byte{
txscript.OpCheckSigVerify},
Sequence: wire.MaxTxInSequenceNum,
}}, []*wire.TxOut{&dummyTxOut}),
Sequence: domainmessage.MaxTxInSequenceNum,
}}, []*domainmessage.TxOut{&dummyTxOut}),
height: 300000,
isStandard: false,
code: RejectNonstandard,
},
{
name: "Valid but non standard public key script",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{&dummyTxIn}, []*wire.TxOut{{
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{&dummyTxIn}, []*domainmessage.TxOut{{
Value: 100000000,
ScriptPubKey: []byte{txscript.OpTrue},
}}),
@ -271,7 +271,7 @@ func TestCheckTransactionStandard(t *testing.T) {
},
{
name: "Dust output",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{&dummyTxIn}, []*wire.TxOut{{
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{&dummyTxIn}, []*domainmessage.TxOut{{
Value: 0,
ScriptPubKey: dummyScriptPubKey,
}}),
@ -281,7 +281,7 @@ func TestCheckTransactionStandard(t *testing.T) {
},
{
name: "Nulldata transaction",
tx: wire.NewNativeMsgTx(1, []*wire.TxIn{&dummyTxIn}, []*wire.TxOut{{
tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{&dummyTxIn}, []*domainmessage.TxOut{{
Value: 0,
ScriptPubKey: []byte{txscript.OpReturn},
}}),

Some files were not shown because too many files have changed in this diff Show More