Develop.merge binary (#263)

* Feat: started to merge changes

* Refactor: moved parameter package to be a plugin (same with logger)

* Feat: first compiling version of new ontologoies merge

* Feat: ported additional plugins

* Feat: transaction get solid now

* Refactor: reverted some previous changes from debugging

* Feat: added a banner module for the cli interface

* Feat: added a plugin for the port checks

* Feat: fixed some bugs

* Refactor: reverted some changes

* Feat: reworked TransactionParser to use Errors

* Feat: TransactionParser uses Peer

* Feat: started to rework broadCastData webapi call

* Feat: refactored some plugins

* Fix: fixed test of tangle

* Refactor: changed tangle package in graph plugin

* Refactor: uncommented broken code

* Fix: fixed broken method signature in gossip test

* Feat: started adding value tangle

* Feat: adjusted to new hive.go

* Feat: upgraded hive.go

* Clean up PortCheck plugin and make it standalone #259 (#271)

Co-authored-by: Hans Moog <hm@mkjc.net>

Co-authored-by: Jonas Theis <mail@jonastheis.de>

go.mod

@@ -13,7 +13,7 @@ require (
 	github.com/googollee/go-engine.io v1.4.3-0.20190924125625-798118fc0dd2
 	github.com/googollee/go-socket.io v1.4.3-0.20191204093753-683f8725b6d0
 	github.com/gorilla/websocket v1.4.1
-	github.com/iotaledger/hive.go v0.0.0-20200219224037-2d5f5238c0de
+	github.com/iotaledger/hive.go v0.0.0-20200225104639-95ee10a0e675
 	github.com/iotaledger/iota.go v1.0.0-beta.14
 	github.com/kr/pretty v0.2.0 // indirect
 	github.com/kr/text v0.2.0 // indirect

go.sum

@@ -17,8 +17,10 @@ github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7 h1:uSoVVbwJiQipAclBb
 github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7/go.mod h1:6zEj6s6u/ghQa61ZWa/C2Aw3RkjiTBOix7dkqa1VLIs=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239 h1:kFOfPq6dUM1hTo4JG6LR5AXSUEsOjtdm0kw0FtQtMJA=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/beevik/ntp v0.2.0/go.mod h1:hIHWr+l3+/clUnF44zdK+CWW7fO8dR5cIylAQ76NRpg=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
@@ -57,11 +59,13 @@ github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/emirpasic/gods v1.12.0 h1:QAUIPSaCu4G+POclxeqb3F+WPpdKqFGlw36+yOzGlrg=
 github.com/emirpasic/gods v1.12.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
+github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BHsljHzVlRcyQhjrss6TZTdY2VfCqZPbv5k3iBFa2ZQ=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
+github.com/gliderlabs/ssh v0.2.2 h1:6zsha5zo/TWhRhwqCD3+EarCAgZ2yN28ipRnGPnwkI0=
 github.com/gliderlabs/ssh v0.2.2/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
@@ -98,6 +102,7 @@ github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
 github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
@@ -132,8 +137,8 @@ github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/iotaledger/hive.go v0.0.0-20200219224037-2d5f5238c0de h1:J9G9YWM5q7r3DObMIx/Qc8CUjrpD+c90EPVKjsBrR+E=
-github.com/iotaledger/hive.go v0.0.0-20200219224037-2d5f5238c0de/go.mod h1:wj3bFHlcX0NiEOWu5+WOg/MI/5N7PKCFnyaziaylB64=
+github.com/iotaledger/hive.go v0.0.0-20200225104639-95ee10a0e675 h1:rlN7zGXPTms6tg4OoD4rTbca71X/wffneMvScmrwMp8=
+github.com/iotaledger/hive.go v0.0.0-20200225104639-95ee10a0e675/go.mod h1:wj3bFHlcX0NiEOWu5+WOg/MI/5N7PKCFnyaziaylB64=
 github.com/iotaledger/iota.go v1.0.0-beta.9/go.mod h1:F6WBmYd98mVjAmmPVYhnxg8NNIWCjjH8VWT9qvv3Rc8=
 github.com/iotaledger/iota.go v1.0.0-beta.14 h1:Oeb28MfBuJEeXcGrLhTCJFtbsnc8y1u7xidsAmiOD5A=
 github.com/iotaledger/iota.go v1.0.0-beta.14/go.mod h1:F6WBmYd98mVjAmmPVYhnxg8NNIWCjjH8VWT9qvv3Rc8=
@@ -357,8 +362,6 @@ golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191119213627-4f8c1d86b1ba/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20191122220453-ac88ee75c92c/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d h1:9FCpayM9Egr1baVnV1SX0H87m+XB0B8S0hAMi99X/3U=
-golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200214034016-1d94cc7ab1c6 h1:Sy5bstxEqwwbYs6n0/pBuxKENqOeZUgD45Gp3Q3pqLg=
 golang.org/x/crypto v0.0.0-20200214034016-1d94cc7ab1c6/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -383,8 +386,6 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553 h1:efeOvDhwQ29Dj3SdAV/MJf8oukgn+8D8WgaCaRMchF8=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200202094626-16171245cfb2 h1:CCH4IOTTfewWjGOlSp+zGcjutRKlBEZQ6wTn8ozI/nI=
 golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -415,8 +416,6 @@ golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9 h1:1/DFK4b7JH8DmkqhUk48onnSfrPzImPoVxuomtbT2nk=
-golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4 h1:sfkvUWPNGwSV+8/fNqctR5lS2AqCSqYwXdrjCxp/dXo=
 golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

main.go

@@ -6,46 +6,46 @@ import (
 
 	"github.com/iotaledger/goshimmer/plugins/analysis"
 	"github.com/iotaledger/goshimmer/plugins/autopeering"
-	"github.com/iotaledger/goshimmer/plugins/bundleprocessor"
+	"github.com/iotaledger/goshimmer/plugins/banner"
 	"github.com/iotaledger/goshimmer/plugins/cli"
+	"github.com/iotaledger/goshimmer/plugins/config"
 	"github.com/iotaledger/goshimmer/plugins/gossip"
 	"github.com/iotaledger/goshimmer/plugins/gracefulshutdown"
-	"github.com/iotaledger/goshimmer/plugins/graph"
+	"github.com/iotaledger/goshimmer/plugins/logger"
 	"github.com/iotaledger/goshimmer/plugins/metrics"
+	"github.com/iotaledger/goshimmer/plugins/portcheck"
 	"github.com/iotaledger/goshimmer/plugins/remotelog"
 	"github.com/iotaledger/goshimmer/plugins/spa"
 	"github.com/iotaledger/goshimmer/plugins/tangle"
-	"github.com/iotaledger/goshimmer/plugins/tipselection"
 	"github.com/iotaledger/goshimmer/plugins/webapi"
 	webapi_broadcastData "github.com/iotaledger/goshimmer/plugins/webapi/broadcastData"
-	webapi_findTransactionHashes "github.com/iotaledger/goshimmer/plugins/webapi/findTransactionHashes"
-	webapi_getNeighbors "github.com/iotaledger/goshimmer/plugins/webapi/getNeighbors"
-	webapi_getTransactionObjectsByHash "github.com/iotaledger/goshimmer/plugins/webapi/getTransactionObjectsByHash"
-	webapi_getTransactionTrytesByHash "github.com/iotaledger/goshimmer/plugins/webapi/getTransactionTrytesByHash"
 	webapi_gtta "github.com/iotaledger/goshimmer/plugins/webapi/gtta"
 	webapi_spammer "github.com/iotaledger/goshimmer/plugins/webapi/spammer"
 	webapi_auth "github.com/iotaledger/goshimmer/plugins/webauth"
+
 	"github.com/iotaledger/hive.go/node"
 )
 
 func main() {
-	cli.PrintVersion()
-	cli.LoadConfig()
+	config.Init()
 
 	go http.ListenAndServe("localhost:6061", nil) // pprof Server for Debbuging Mutexes
 
 	node.Run(
 		node.Plugins(
+			banner.PLUGIN,
+			config.PLUGIN,
+			logger.PLUGIN,
 			cli.PLUGIN,
 			remotelog.PLUGIN,
+			portcheck.PLUGIN,
 
 			autopeering.PLUGIN,
-			gossip.PLUGIN,
 			tangle.PLUGIN,
-			bundleprocessor.PLUGIN,
-			analysis.PLUGIN,
+			gossip.PLUGIN,
 			gracefulshutdown.PLUGIN,
-			tipselection.PLUGIN,
+
+			analysis.PLUGIN,
 			metrics.PLUGIN,
 
 			webapi.PLUGIN,
@@ -53,14 +53,17 @@ func main() {
 			webapi_gtta.PLUGIN,
 			webapi_spammer.PLUGIN,
 			webapi_broadcastData.PLUGIN,
-			webapi_getTransactionTrytesByHash.PLUGIN,
-			webapi_getTransactionObjectsByHash.PLUGIN,
-			webapi_findTransactionHashes.PLUGIN,
-			webapi_getNeighbors.PLUGIN,
-			webapi_spammer.PLUGIN,
 
 			spa.PLUGIN,
-			graph.PLUGIN,
+
+			/*
+				webapi_getTransactionTrytesByHash.PLUGIN,
+				webapi_getTransactionObjectsByHash.PLUGIN,
+				webapi_findTransactionHashes.PLUGIN,
+				webapi_getNeighbors.PLUGIN,
+
+				//graph.PLUGIN,
+			*/
 		),
 	)
 }

packages/binary/datastructure/queue/queue.go

+package queue
+
+import (
+	"sync"
+)
+
+type Queue struct {
+	ringBuffer []interface{}
+	read       int
+	write      int
+	capacity   int
+	size       int
+	mutex      sync.Mutex
+}
+
+func New(capacity int) *Queue {
+	return &Queue{
+		ringBuffer: make([]interface{}, capacity),
+		capacity:   capacity,
+	}
+}
+
+func (queue *Queue) Size() int {
+	queue.mutex.Lock()
+	defer queue.mutex.Unlock()
+
+	return queue.size
+}
+
+func (queue *Queue) Capacity() int {
+	queue.mutex.Lock()
+	defer queue.mutex.Unlock()
+
+	return queue.capacity
+}
+
+func (queue *Queue) Offer(element interface{}) bool {
+	queue.mutex.Lock()
+	defer queue.mutex.Unlock()
+
+	if queue.size == queue.capacity {
+		return false
+	}
+
+	queue.ringBuffer[queue.write] = element
+	queue.write = (queue.write + 1) % queue.capacity
+	queue.size++
+
+	return true
+}
+
+func (queue *Queue) Poll() (element interface{}, success bool) {
+	queue.mutex.Lock()
+	defer queue.mutex.Unlock()
+
+	if success = queue.size != 0; !success {
+		return
+	}
+
+	element = queue.ringBuffer[queue.read]
+	queue.ringBuffer[queue.read] = nil
+	queue.read = (queue.read + 1) % queue.capacity
+	queue.size--
+
+	return
+}

packages/binary/datastructure/queue/queue_test.go

+package queue
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test(t *testing.T) {
+	queue := New(2)
+	assert.Equal(t, 0, queue.Size())
+	assert.Equal(t, 2, queue.Capacity())
+
+	assert.Equal(t, true, queue.Offer(1))
+	assert.Equal(t, 1, queue.Size())
+
+	assert.Equal(t, true, queue.Offer(2))
+	assert.Equal(t, 2, queue.Size())
+
+	assert.Equal(t, false, queue.Offer(3))
+
+	polledValue, ok := queue.Poll()
+	assert.Equal(t, true, ok)
+	assert.Equal(t, 1, polledValue)
+	assert.Equal(t, 1, queue.Size())
+
+	polledValue, ok = queue.Poll()
+	assert.Equal(t, true, ok)
+	assert.Equal(t, 2, polledValue)
+	assert.Equal(t, 0, queue.Size())
+
+	polledValue, ok = queue.Poll()
+	assert.Equal(t, false, ok)
+	assert.Equal(t, nil, polledValue)
+	assert.Equal(t, 0, queue.Size())
+
+	assert.Equal(t, true, queue.Offer(3))
+	assert.Equal(t, 1, queue.Size())
+
+	assert.Equal(t, true, queue.Offer(4))
+	assert.Equal(t, 2, queue.Size())
+}

packages/binary/datastructure/random_map.go

+package datastructure
+
+import (
+	"math/rand"
+	"sync"
+	"time"
+)
+
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
+type randomMapEntry struct {
+	key      interface{}
+	value    interface{}
+	keyIndex int
+}
+
+type RandomMap struct {
+	rawMap map[interface{}]*randomMapEntry
+	keys   []interface{}
+	size   int
+	mutex  sync.RWMutex
+}
+
+func NewRandomMap() *RandomMap {
+	return &RandomMap{
+		rawMap: make(map[interface{}]*randomMapEntry),
+		keys:   make([]interface{}, 0),
+	}
+}
+
+func (rmap *RandomMap) Set(key interface{}, value interface{}) (updated bool) {
+	rmap.mutex.Lock()
+
+	if entry, exists := rmap.rawMap[key]; exists {
+		if entry.value != value {
+			entry.value = value
+
+			updated = true
+		}
+	} else {
+		rmap.rawMap[key] = &randomMapEntry{
+			key:      key,
+			value:    value,
+			keyIndex: rmap.size,
+		}
+
+		updated = true
+
+		rmap.keys = append(rmap.keys, key)
+
+		rmap.size++
+	}
+
+	rmap.mutex.Unlock()
+
+	return
+}
+
+func (rmap *RandomMap) Get(key interface{}) (result interface{}, exists bool) {
+	rmap.mutex.RLock()
+
+	if entry, entryExists := rmap.rawMap[key]; entryExists {
+		result = entry.value
+		exists = entryExists
+	}
+
+	rmap.mutex.RUnlock()
+
+	return
+}
+
+func (rmap *RandomMap) Delete(key interface{}) (result interface{}, exists bool) {
+	rmap.mutex.RLock()
+
+	if _, entryExists := rmap.rawMap[key]; entryExists {
+		rmap.mutex.RUnlock()
+		rmap.mutex.Lock()
+
+		if entry, entryExists := rmap.rawMap[key]; entryExists {
+			delete(rmap.rawMap, key)
+
+			rmap.size--
+
+			if entry.keyIndex != rmap.size {
+				oldKey := entry.keyIndex
+				movedKey := rmap.keys[rmap.size]
+
+				rmap.rawMap[movedKey].keyIndex = oldKey
+
+				rmap.keys[oldKey] = movedKey
+			}
+
+			rmap.keys = rmap.keys[:rmap.size]
+
+			result = entry.value
+			exists = true
+		}
+
+		rmap.mutex.Unlock()
+	} else {
+		rmap.mutex.RUnlock()
+	}
+
+	return
+}
+
+func (rmap *RandomMap) Size() (result int) {
+	rmap.mutex.RLock()
+
+	result = rmap.size
+
+	rmap.mutex.RUnlock()
+
+	return
+}
+
+func (rmap *RandomMap) RandomEntry() (result interface{}) {
+	rmap.mutex.RLock()
+
+	if rmap.size >= 1 {
+		result = rmap.rawMap[rmap.keys[rand.Intn(rmap.size)]].value
+	}
+
+	rmap.mutex.RUnlock()
+
+	return
+}

packages/binary/marshalutil/marshalutil.bytes.go

+package marshalutil
+
+func (util *MarshalUtil) WriteBytes(bytes []byte) {
+	writeEndOffset := util.expandWriteCapacity(len(bytes))
+
+	copy(util.bytes[util.writeOffset:writeEndOffset], bytes)
+
+	util.WriteSeek(writeEndOffset)
+}
+
+func (util *MarshalUtil) ReadBytes(length int) ([]byte, error) {
+	readEndOffset, err := util.checkReadCapacity(length)
+	if err != nil {
+		return nil, err
+	}
+
+	defer util.ReadSeek(readEndOffset)
+
+	return util.bytes[util.readOffset:readEndOffset], nil
+}
+
+func (util *MarshalUtil) ReadRemainingBytes() []byte {
+	defer util.ReadSeek(util.size)
+
+	return util.bytes[util.readOffset:]
+}

packages/binary/marshalutil/marshalutil.go

+package marshalutil
+
+import (
+	"fmt"
+)
+
+type MarshalUtil struct {
+	bytes       []byte
+	readOffset  int
+	writeOffset int
+	size        int
+}
+
+func New(args ...interface{}) *MarshalUtil {
+	switch argsCount := len(args); argsCount {
+	case 0:
+		return &MarshalUtil{
+			bytes: make([]byte, 1024),
+			size:  0,
+		}
+	case 1:
+		switch param := args[0].(type) {
+		case int:
+			return &MarshalUtil{
+				bytes: make([]byte, param),
+				size:  param,
+			}
+		case []byte:
+			return &MarshalUtil{
+				bytes: param,
+				size:  len(param),
+			}
+		default:
+			panic(fmt.Errorf("illegal argument type %T in marshalutil.New(...)", param))
+		}
+	default:
+		panic(fmt.Errorf("illegal argument count %d in marshalutil.New(...)", argsCount))
+	}
+}
+
+func (util *MarshalUtil) WriteSeek(offset int) {
+	util.writeOffset = offset
+}
+
+func (util *MarshalUtil) ReadSeek(offset int) {
+	util.readOffset = offset
+}
+
+func (util *MarshalUtil) Bytes() []byte {
+	return util.bytes[:util.size]
+}
+
+func (util *MarshalUtil) checkReadCapacity(length int) (readEndOffset int, err error) {
+	readEndOffset = util.readOffset + length
+
+	if readEndOffset > util.size {
+		err = fmt.Errorf("tried to read %d bytes from %d bytes input", readEndOffset, util.size)
+	}
+
+	return
+}
+
+func (util *MarshalUtil) expandWriteCapacity(length int) (writeEndOffset int) {
+	writeEndOffset = util.writeOffset + length
+
+	if writeEndOffset > util.size {
+		extendedBytes := make([]byte, writeEndOffset-util.size)
+		util.bytes = append(util.bytes, extendedBytes...)
+		util.size = writeEndOffset
+	}
+
+	return
+}

packages/binary/marshalutil/marshalutil.int64.go

+package marshalutil
+
+import (
+	"encoding/binary"
+)
+
+const INT64_SIZE = 8
+
+func (util *MarshalUtil) WriteInt64(value int64) {
+	writeEndOffset := util.expandWriteCapacity(INT64_SIZE)
+
+	binary.LittleEndian.PutUint64(util.bytes[util.writeOffset:writeEndOffset], uint64(value))
+
+	util.WriteSeek(writeEndOffset)
+}
+
+func (util *MarshalUtil) ReadInt64() (int64, error) {
+	readEndOffset, err := util.checkReadCapacity(INT64_SIZE)
+	if err != nil {
+		return 0, err
+	}
+
+	defer util.ReadSeek(readEndOffset)
+
+	return int64(binary.LittleEndian.Uint64(util.bytes[util.readOffset:readEndOffset])), nil
+}

packages/binary/marshalutil/marshalutil.uint64.go

+package marshalutil
+
+import "encoding/binary"
+
+const UINT64_SIZE = 8
+
+func (util *MarshalUtil) WriteUint64(value uint64) {
+	writeEndOffset := util.expandWriteCapacity(UINT64_SIZE)
+
+	binary.LittleEndian.PutUint64(util.bytes[util.writeOffset:writeEndOffset], value)
+
+	util.WriteSeek(writeEndOffset)
+}
+
+func (util *MarshalUtil) ReadUint64() (uint64, error) {
+	readEndOffset, err := util.checkReadCapacity(UINT64_SIZE)
+	if err != nil {
+		return 0, err
+	}
+
+	defer util.ReadSeek(readEndOffset)
+
+	return binary.LittleEndian.Uint64(util.bytes[util.readOffset:readEndOffset]), nil
+}

packages/binary/marshalutil/marshalutil_test.go

+package marshalutil
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	util := New(1)
+
+	util.WriteBytes(make([]byte, UINT64_SIZE))
+	util.WriteInt64(-12)
+	util.WriteUint64(38)
+
+	fmt.Println(util.ReadBytes(UINT64_SIZE))
+	fmt.Println(util.ReadInt64())
+	fmt.Println(util.ReadUint64())
+	fmt.Println(util.ReadUint64())
+
+	fmt.Println(util)
+}

packages/binary/spammer/spammer.go

+package spammer
+
+import (
+	"fmt"
+	"sync/atomic"
+	"time"
+
+	"github.com/iotaledger/hive.go/types"
+
+	"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/tipselector"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/transactionparser"
+)
+
+type Spammer struct {
+	transactionParser *transactionparser.TransactionParser
+	tipSelector       *tipselector.TipSelector
+
+	processId      int64
+	shutdownSignal chan types.Empty
+}
+
+func New(transactionParser *transactionparser.TransactionParser, tipSelector *tipselector.TipSelector) *Spammer {
+	return &Spammer{
+		shutdownSignal:    make(chan types.Empty),
+		transactionParser: transactionParser,
+		tipSelector:       tipSelector,
+	}
+}
+
+func (spammer *Spammer) Start(tps int) {
+	go spammer.run(tps, atomic.AddInt64(&spammer.processId, 1))
+}
+
+func (spammer *Spammer) Burst(transactions int) {
+	go spammer.sendBurst(transactions, atomic.AddInt64(&spammer.processId, 1))
+}
+
+func (spammer *Spammer) Shutdown() {
+	atomic.AddInt64(&spammer.processId, 1)
+}
+
+func (spammer *Spammer) run(tps int, processId int64) {
+	fmt.Println(processId)
+	currentSentCounter := 0
+	start := time.Now()
+
+	for {
+		if atomic.LoadInt64(&spammer.processId) != processId {
+			return
+		}
+
+		trunkTransactionId, branchTransactionId := spammer.tipSelector.GetTips()
+		spammer.transactionParser.Parse(
+			transaction.New(trunkTransactionId, branchTransactionId, identity.Generate(), data.New([]byte("SPAM"))).GetBytes(),
+			nil,
+		)
+
+		currentSentCounter++
+
+		// rate limit to the specified TPS
+		if currentSentCounter >= tps {
+			duration := time.Since(start)
+			if duration < time.Second {
+				time.Sleep(time.Second - duration)
+			}
+
+			start = time.Now()
+			currentSentCounter = 0
+		}
+	}
+}
+
+func (spammer *Spammer) sendBurst(transactions int, processId int64) {
+	spammingIdentity := identity.Generate()
+
+	previousTransactionId := transaction.EmptyId
+
+	burstBuffer := make([][]byte, transactions)
+	for i := 0; i < transactions; i++ {
+		if atomic.LoadInt64(&spammer.processId) != processId {
+			return
+		}
+
+		spamTransaction := transaction.New(previousTransactionId, previousTransactionId, spammingIdentity, data.New([]byte("SPAM")))
+		previousTransactionId = spamTransaction.GetId()
+		burstBuffer[i] = spamTransaction.GetBytes()
+	}
+
+	for i := 0; i < transactions; i++ {
+		if atomic.LoadInt64(&spammer.processId) != processId {
+			return
+		}
+
+		spammer.transactionParser.Parse(burstBuffer[i], nil)
+	}
+}

packages/binary/storageprefix/storageprefix.go

 package storageprefix
 
 var (
-	TangleTransaction         = []byte{0}
-	TangleTransactionMetadata = []byte{1}
-	TangleApprovers           = []byte{2}
-	TangleMissingTransaction  = []byte{3}
+	MainNet = []byte{0}
 
-	ValueTangleTransferMetadata = []byte{4}
-	ValueTangleConsumers        = []byte{5}
-	ValueTangleMissingTransfers = []byte{6}
+	TangleTransaction         = []byte{1}
+	TangleTransactionMetadata = []byte{2}
+	TangleApprovers           = []byte{3}
+	TangleMissingTransaction  = []byte{4}
 
-	LedgerStateTransferOutput        = []byte{7}
-	LedgerStateTransferOutputBooking = []byte{8}
-	LedgerStateReality               = []byte{9}
-	LedgerStateConflictSet           = []byte{10}
+	ValueTangleTransferMetadata = []byte{5}
+	ValueTangleConsumers        = []byte{6}
+	ValueTangleMissingTransfers = []byte{7}
+
+	LedgerStateTransferOutput        = []byte{8}
+	LedgerStateTransferOutputBooking = []byte{9}
+	LedgerStateReality               = []byte{10}
+	LedgerStateConflictSet           = []byte{11}
 )

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/approver/cached_approver.go

@@ -24,9 +24,9 @@ type CachedApprovers []*CachedApprover
 
 func (cachedApprovers CachedApprovers) Consume(consumer func(approver *Approver)) (consumed bool) {
 	for _, cachedApprover := range cachedApprovers {
-		consumed = consumed || cachedApprover.Consume(func(object objectstorage.StorableObject) {
+		consumed = cachedApprover.Consume(func(object objectstorage.StorableObject) {
 			consumer(object.(*Approver))
-		})
+		}) || consumed
 	}
 
 	return

packages/binary/tangle/model/transaction/cached_transaction.go

@@ -12,7 +12,7 @@ func (cachedTransaction *CachedTransaction) Retain() *CachedTransaction {
 	return &CachedTransaction{cachedTransaction.CachedObject.Retain()}
 }
 
-func (cachedTransaction *CachedTransaction) Consume(consumer func(object *Transaction)) bool {
+func (cachedTransaction *CachedTransaction) Consume(consumer func(transaction *Transaction)) bool {
 	return cachedTransaction.CachedObject.Consume(func(object objectstorage.StorableObject) {
 		consumer(object.(*Transaction))
 	})

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
 }