Feat: transaction get solid now

packages/binary/serialize/serialized_object.go

+package serialize
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+type SerializedObject struct {
+	readOffset int
+}
+
+func (so *SerializedObject) SerializeInt(int int) []byte {
+	hdr := reflect.SliceHeader{Data: uintptr(unsafe.Pointer(&int)), Len: 8, Cap: 8}
+	return *(*[]byte)(unsafe.Pointer(&hdr))
+}

packages/binary/spammer/spammer.go

@@ -24,8 +24,9 @@ type Spammer struct {
 
 func New(tangle *tangle.Tangle, tipSelector *tipselector.TipSelector) *Spammer {
 	return &Spammer{
-		tangle:      tangle,
-		tipSelector: tipSelector,
+		shutdownSignal: make(chan types.Empty),
+		tangle:         tangle,
+		tipSelector:    tipSelector,
 	}
 }
 
@@ -44,7 +45,7 @@ func (spammer *Spammer) Shutdown() {
 	spammer.startStopMutex.Lock()
 	defer spammer.startStopMutex.Unlock()
 
-	if !spammer.running {
+	if spammer.running {
 		spammer.running = false
 
 		spammer.shutdownSignal <- types.Void

packages/binary/storageprefix/storageprefix.go

 package storageprefix
 
 var (
-	Mainnet = []byte{0}
+	Mainnet = []byte{88}
 
 	TangleTransaction         = []byte{1}
 	TangleTransactionMetadata = []byte{2}

packages/binary/tangle/events.go

@@ -34,6 +34,6 @@ func transactionIdEvent(handler interface{}, params ...interface{}) {
 func cachedTransactionEvent(handler interface{}, params ...interface{}) {
 	handler.(func(*transaction.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(
 		params[0].(*transaction.CachedTransaction).Retain(),
-		params[1].(*transactionmetadata.CachedTransactionMetadata).Retain().(*transactionmetadata.CachedTransactionMetadata),
+		params[1].(*transactionmetadata.CachedTransactionMetadata).Retain(),
 	)
 }

packages/binary/tangle/model/transactionmetadata/cached_transactionmetadata.go

@@ -8,8 +8,8 @@ type CachedTransactionMetadata struct {
 	objectstorage.CachedObject
 }
 
-func (cachedObject *CachedTransactionMetadata) Retain() objectstorage.CachedObject {
-	return &CachedTransactionMetadata{cachedObject}
+func (cachedObject *CachedTransactionMetadata) Retain() *CachedTransactionMetadata {
+	return &CachedTransactionMetadata{cachedObject.CachedObject.Retain()}
 }
 
 func (cachedObject *CachedTransactionMetadata) Unwrap() *TransactionMetadata {

packages/binary/tangle/model/transactionmetadata/proto.go

+package transactionmetadata
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"time"
+	"unsafe"
+)
+
+type Proto struct {
+	receivedTime       time.Time
+	solidificationTime time.Time
+	solid              bool
+}
+
+// region GENERIC SERIALIZATION CODE ///////////////////////////////////////////////////////////////////////////////////
+
+var sizeOfProto = int(unsafe.Sizeof(Proto{}))
+
+func ProtoFromBytes(bytes []byte) (result *Proto, err error) {
+	if bytesLength := len(bytes); bytesLength != sizeOfProto {
+		return nil, fmt.Errorf("bytes are not long enough (%d instead of %d)", bytesLength, sizeOfProto)
+	}
+
+	copiedBytes := make([]byte, sizeOfProto)
+	copy(copiedBytes, bytes)
+
+	result = (*Proto)(unsafe.Pointer(
+		(*reflect.SliceHeader)(unsafe.Pointer(&copiedBytes)).Data,
+	))
+
+	runtime.KeepAlive(copiedBytes)
+
+	return
+}
+
+func (proto *Proto) ToBytes() (result []byte) {
+	result = make([]byte, sizeOfProto)
+	copy(result, *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
+		Data: uintptr(unsafe.Pointer(proto)),
+		Len:  sizeOfProto,
+		Cap:  sizeOfProto,
+	})))
+
+	runtime.KeepAlive(proto)
+
+	return
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////

packages/binary/tangle/model/transactionmetadata/transactionmetadata.go

@@ -86,9 +86,22 @@ func (transactionMetadata *TransactionMetadata) Update(other objectstorage.Stora
 }
 
 func (transactionMetadata *TransactionMetadata) MarshalBinary() ([]byte, error) {
-	return nil, nil
+	return (&Proto{
+		receivedTime:       transactionMetadata.receivedTime,
+		solidificationTime: transactionMetadata.solidificationTime,
+		solid:              transactionMetadata.solid,
+	}).ToBytes(), nil
 }
 
-func (transactionMetadata *TransactionMetadata) UnmarshalBinary([]byte) error {
-	return nil
+func (transactionMetadata *TransactionMetadata) UnmarshalBinary(data []byte) (err error) {
+	proto, err := ProtoFromBytes(data)
+	if err != nil {
+		return
+	}
+
+	transactionMetadata.receivedTime = proto.receivedTime
+	transactionMetadata.solidificationTime = proto.solidificationTime
+	transactionMetadata.solid = proto.solid
+
+	return
 }

packages/binary/tangle/tangle_test.go

@@ -8,15 +8,19 @@ import (
 	"github.com/dgraph-io/badger/v2"
 	"github.com/iotaledger/hive.go/events"
 
+	"github.com/iotaledger/hive.go/database"
+
 	"github.com/iotaledger/goshimmer/packages/binary/identity"
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload/data"
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
-	"github.com/iotaledger/goshimmer/packages/database"
+	"github.com/iotaledger/goshimmer/plugins/config"
 )
 
 var testDatabase *badger.DB
 
+var _ = config.PLUGIN
+
 func init() {
 	testDatabase = database.GetBadgerInstance()
 }

plugins/autopeering/autopeering.go

@@ -16,9 +16,7 @@ import (
 	"github.com/iotaledger/hive.go/logger"
 	"github.com/iotaledger/hive.go/node"
 
-	"github.com/iotaledger/goshimmer/packages/netutil"
 	"github.com/iotaledger/goshimmer/plugins/autopeering/local"
-	"github.com/iotaledger/goshimmer/plugins/cli"
 	"github.com/iotaledger/goshimmer/plugins/config"
 	"github.com/iotaledger/goshimmer/plugins/gossip"
 )
@@ -161,17 +159,19 @@ func parseEntryNodes() (result []*peer.Peer, err error) {
 }
 
 func checkConnection(localAddr *net.UDPAddr, self *peer.Peer) {
-	peering := self.Services().Get(service.PeeringKey)
-	remoteAddr, err := net.ResolveUDPAddr(peering.Network(), peering.String())
-	if err != nil {
-		panic(err)
-	}
+	/*
+		peering := self.Services().Get(service.PeeringKey)
+		remoteAddr, err := net.ResolveUDPAddr(peering.Network(), peering.String())
+		if err != nil {
+			panic(err)
+		}
 
-	// do not check the address as a NAT may change them for local connections
-	err = netutil.CheckUDP(localAddr, remoteAddr, false, true)
-	if err != nil {
-		log.Errorf("Error testing service: %s", err)
-		log.Panicf("Please check that %s is publicly reachable at %s/%s",
-			cli.AppName, peering.String(), peering.Network())
-	}
+		// do not check the address as a NAT may change them for local connections
+		err = netutil.CheckUDP(localAddr, remoteAddr, false, true)
+		if err != nil {
+			log.Errorf("Error testing service: %s", err)
+			log.Panicf("Please check that %s is publicly reachable at %s/%s",
+				cli.AppName, peering.String(), peering.Network())
+		}
+	*/
 }

plugins/config/config.go

@@ -52,7 +52,7 @@ func parseParameters() {
 // It automatically reads in a single config file starting with "config" (can be changed via the --config CLI flag)
 // and ending with: .json, .toml, .yaml or .yml (in this sequence).
 func Fetch(printConfig bool, ignoreSettingsAtPrint ...[]string) error {
-	err := parameter.LoadConfigFile(NodeConfig, *configDirPath, *configName, true, false)
+	err := parameter.LoadConfigFile(NodeConfig, *configDirPath, *configName, true, true)
 	if err != nil {
 		return err
 	}

plugins/gossip/gossip.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"net"
 	"strconv"
-	"sync"
 
 	"github.com/iotaledger/hive.go/autopeering/peer"
 	"github.com/iotaledger/hive.go/autopeering/peer/service"
@@ -14,7 +13,6 @@ import (
 	gp "github.com/iotaledger/goshimmer/packages/gossip"
 	"github.com/iotaledger/goshimmer/packages/gossip/server"
 	"github.com/iotaledger/goshimmer/plugins/autopeering/local"
-	"github.com/iotaledger/goshimmer/plugins/cli"
 	"github.com/iotaledger/goshimmer/plugins/config"
 	"github.com/iotaledger/goshimmer/plugins/tangle"
 )
@@ -84,25 +82,27 @@ func start(shutdownSignal <-chan struct{}) {
 }
 
 func checkConnection(srv *server.TCP, self *peer.Peer) {
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		conn, err := srv.AcceptPeer(self)
+	/*
+		var wg sync.WaitGroup
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			conn, err := srv.AcceptPeer(self)
+			if err != nil {
+				return
+			}
+			_ = conn.Close()
+		}()
+		conn, err := srv.DialPeer(self)
 		if err != nil {
-			return
+			log.Errorf("Error testing: %s", err)
+			addr := self.Services().Get(service.GossipKey)
+			log.Panicf("Please check that %s is publicly reachable at %s/%s",
+				cli.AppName, addr.String(), addr.Network())
 		}
 		_ = conn.Close()
-	}()
-	conn, err := srv.DialPeer(self)
-	if err != nil {
-		log.Errorf("Error testing: %s", err)
-		addr := self.Services().Get(service.GossipKey)
-		log.Panicf("Please check that %s is publicly reachable at %s/%s",
-			cli.AppName, addr.String(), addr.Network())
-	}
-	_ = conn.Close()
-	wg.Wait()
+		wg.Wait()
+	*/
 }
 
 func getTransaction(transactionId transaction.Id) (bytes []byte, err error) {

plugins/tangle/plugin.go

 package tangle
 
 import (
+	"fmt"
+
 	"github.com/iotaledger/goshimmer/packages/binary/storageprefix"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle"
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/tipselector"
@@ -9,11 +12,9 @@ import (
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/transactionrequester"
 	"github.com/iotaledger/goshimmer/packages/database"
 	"github.com/iotaledger/goshimmer/packages/shutdown"
+
 	"github.com/iotaledger/hive.go/daemon"
 	"github.com/iotaledger/hive.go/events"
-
-	"github.com/iotaledger/goshimmer/packages/binary/tangle"
-
 	"github.com/iotaledger/hive.go/logger"
 	"github.com/iotaledger/hive.go/node"
 )
@@ -56,6 +57,8 @@ func configure(*node.Plugin) {
 
 	// setup TipSelector
 	Instance.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *transaction.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+		fmt.Println(cachedTransaction.Unwrap())
+
 		cachedTransactionMetadata.Release()
 
 		cachedTransaction.Consume(TipSelector.AddTip)

plugins/webapi/spammer/plugin.go

@@ -10,7 +10,7 @@ import (
 
 var transactionSpammer *spammer.Spammer
 
-var PLUGIN = node.NewPlugin("Spammer", node.Disabled, configure)
+var PLUGIN = node.NewPlugin("Spammer", node.Enabled, configure)
 
 func configure(plugin *node.Plugin) {
 	transactionSpammer = spammer.New(tangle.Instance, tangle.TipSelector)