Feat: refactored alot :P

packages/binary/address/address.go

+package address
+
+import (
+	"crypto/rand"
+
+	"github.com/mr-tron/base58"
+)
+
+type Address [Length]byte
+
+func New(addressBytes []byte) (result Address) {
+	copy(result[:], addressBytes)
+
+	return
+}
+
+func FromBase58EncodedString(base58EncodedString string) (result Address) {
+	if addressBytes, err := base58.Decode(base58EncodedString); err != nil {
+		panic(err)
+	} else {
+		copy(result[:], addressBytes)
+	}
+
+	return
+}
+
+func Random() (result Address) {
+	addressBytes := make([]byte, Length)
+	if _, err := rand.Read(addressBytes); err != nil {
+		panic(err)
+	}
+
+	return New(addressBytes)
+}
+
+func (address *Address) UnmarshalBinary(data []byte) error {
+	copy(address[:], data[:Length])
+
+	return nil
+}
+
+func (address *Address) MarshalBinary() (bytes []byte, err error) {
+	bytes = append(bytes, address[:]...)
+
+	return
+}
+
+func (address Address) String() string {
+	return base58.Encode(address[:])
+}
+
+const Length = 32

packages/binary/tangle/tangle.go

 package tangle
 
 import (
-	"github.com/iotaledger/goshimmer/packages/binary/approvers"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/approvers"
 	"github.com/iotaledger/goshimmer/packages/binary/transaction"
 	"github.com/iotaledger/hive.go/objectstorage"
 )

packages/binary/transaction/id.go

 package transaction
 
-type Id [transactionIdLength]byte
+type Id [IdLength]byte
 
-const transactionIdLength = 64
+var EmptyId = Id{}
+
+const IdLength = 64

packages/binary/transaction/init.go

+package transaction
+
+import (
+	"github.com/iotaledger/goshimmer/packages/binary/transaction/payload"
+	"github.com/iotaledger/goshimmer/packages/binary/transaction/payload/data"
+)
+
+func init() {
+	payload.SetGenericUnmarshalerFactory(data.GenericPayloadUnmarshalerFactory)
+}

packages/binary/transaction/data_payload.go → packages/binary/transaction/payload/data/data.go

-package transaction
+package data
 
-type DataPayload struct {
-	payloadType PayloadType
+import (
+	"github.com/iotaledger/goshimmer/packages/binary/transaction/payload"
+)
+
+type Data struct {
+	payloadType payload.Type
 	data        []byte
 }
 
-var DataPayloadType = PayloadType(0)
+var Type = payload.Type(0)
 
-func NewDataPayload(data []byte) *DataPayload {
-	return &DataPayload{
-		payloadType: DataPayloadType,
+func New(data []byte) *Data {
+	return &Data{
+		payloadType: Type,
 		data:        data,
 	}
 }
 
-func (dataPayload *DataPayload) GetType() PayloadType {
+func (dataPayload *Data) GetType() payload.Type {
 	return dataPayload.payloadType
 }
 
-func (dataPayload *DataPayload) GetData() []byte {
+func (dataPayload *Data) GetData() []byte {
 	return dataPayload.data
 }
 
-func (dataPayload *DataPayload) UnmarshalBinary(data []byte) error {
+func (dataPayload *Data) UnmarshalBinary(data []byte) error {
 	dataPayload.data = make([]byte, len(data))
 	copy(dataPayload.data, data)
 
 	return nil
 }
 
-func (dataPayload *DataPayload) MarshalBinary() (data []byte, err error) {
+func (dataPayload *Data) MarshalBinary() (data []byte, err error) {
 	data = make([]byte, len(dataPayload.data))
 	copy(data, dataPayload.data)
 
 	return
 }
 
-func createGenericDataPayloadUnmarshaler(payloadType PayloadType) PayloadUnmarshaler {
-	return func(data []byte) (payload Payload, err error) {
-		payload = &DataPayload{
+func GenericPayloadUnmarshalerFactory(payloadType payload.Type) payload.Unmarshaler {
+	return func(data []byte) (payload payload.Payload, err error) {
+		payload = &Data{
 			payloadType: payloadType,
 		}
 		err = payload.UnmarshalBinary(data)

packages/binary/transaction/payload/data/init.go

+package data
+
+import (
+	"github.com/iotaledger/goshimmer/packages/binary/transaction/payload"
+)
+
+func init() {
+	payload.RegisterType(Type, GenericPayloadUnmarshalerFactory(Type))
+}

packages/binary/transaction/payload/id.go

+package payload
+
+type Id [IdLength]byte
+
+const IdLength = 64

packages/binary/transaction/payload.go → packages/binary/transaction/payload/payload.go

-package transaction
+package payload
 
 import (
 	"encoding"
@@ -8,5 +8,5 @@ type Payload interface {
 	encoding.BinaryMarshaler
 	encoding.BinaryUnmarshaler
 
-	GetType() PayloadType
+	GetType() Type
 }

packages/binary/transaction/payload/type.go

+package payload
+
+type Type = uint32

packages/binary/transaction/payload/type_register.go

+package payload
+
+import (
+	"sync"
+)
+
+type Unmarshaler func(data []byte) (Payload, error)
+
+var (
+	typeRegister              = make(map[Type]Unmarshaler)
+	typeRegisterMutex         sync.RWMutex
+	genericUnmarshalerFactory func(payloadType Type) Unmarshaler
+)
+
+func RegisterType(payloadType Type, unmarshaler Unmarshaler) {
+	typeRegisterMutex.Lock()
+	typeRegister[payloadType] = unmarshaler
+	typeRegisterMutex.Unlock()
+}
+
+func GetUnmarshaler(payloadType Type) Unmarshaler {
+	typeRegisterMutex.RLock()
+	if unmarshaler, exists := typeRegister[payloadType]; exists {
+		typeRegisterMutex.RUnlock()
+
+		return unmarshaler
+	} else {
+		typeRegisterMutex.RUnlock()
+
+		return genericUnmarshalerFactory(payloadType)
+	}
+}
+
+func SetGenericUnmarshalerFactory(unmarshalerFactory func(payloadType Type) Unmarshaler) {
+	genericUnmarshalerFactory = unmarshalerFactory
+}

packages/binary/transaction/payload/valuetransfer/value.go

+package valuetransfer
+
+import (
+	"github.com/iotaledger/goshimmer/packages/binary/address"
+	"github.com/iotaledger/goshimmer/packages/binary/transaction"
+	"github.com/iotaledger/goshimmer/packages/binary/transaction/payload"
+)
+
+type ValueTransfer struct{}
+
+var Type = payload.Type(1)
+
+func New() *ValueTransfer {
+	return &ValueTransfer{}
+}
+
+func (valueTransfer *ValueTransfer) AddInput(transaction transaction.Id, address address.Address) *ValueTransfer {
+	return valueTransfer
+}
+
+func (valueTransfer *ValueTransfer) GetType() payload.Type {
+	return Type
+}
+
+func (valueTransfer *ValueTransfer) MarshalBinary() (bytes []byte, err error) {
+	return
+}
+
+func (valueTransfer *ValueTransfer) UnmarshalBinary(bytes []byte) (err error) {
+	return
+}

packages/binary/transaction/payload_id.go

-package transaction
-
-type PayloadId [payloadIdLength]byte
-
-const payloadIdLength = 64

packages/binary/transaction/payload_type.go

-package transaction
-
-type PayloadType = uint32

packages/binary/transaction/payload_type_register.go

-package transaction
-
-import (
-	"sync"
-)
-
-type PayloadUnmarshaler func(data []byte) (Payload, error)
-
-var (
-	payloadTypeRegister      map[PayloadType]PayloadUnmarshaler
-	payloadTypeRegisterMutex sync.RWMutex
-)
-
-func RegisterPayloadType(payloadType PayloadType, unmarshaler PayloadUnmarshaler) {
-	payloadTypeRegisterMutex.Lock()
-	payloadTypeRegister[payloadType] = unmarshaler
-	payloadTypeRegisterMutex.Unlock()
-}
-
-func GetPayloadUnmarshaler(payloadType PayloadType) PayloadUnmarshaler {
-	payloadTypeRegisterMutex.RLock()
-	if unmarshaler, exists := payloadTypeRegister[payloadType]; exists {
-		payloadTypeRegisterMutex.RUnlock()
-
-		return unmarshaler
-	} else {
-		payloadTypeRegisterMutex.RUnlock()
-
-		return createGenericDataPayloadUnmarshaler(payloadType)
-	}
-}

packages/binary/transaction/test/transaction_test.go

+package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/iotaledger/goshimmer/packages/binary/transaction"
+
+	"github.com/iotaledger/goshimmer/packages/binary/address"
+	"github.com/iotaledger/goshimmer/packages/binary/identity"
+	"github.com/iotaledger/goshimmer/packages/binary/transaction/payload/data"
+	"github.com/iotaledger/goshimmer/packages/binary/transaction/payload/valuetransfer"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNew(t *testing.T) {
+	newTransaction1 := transaction.New(transaction.EmptyId, transaction.EmptyId, identity.Generate(), data.New([]byte("test")))
+	assert.Equal(t, newTransaction1.VerifySignature(), true)
+
+	valueTransfer := valuetransfer.New().AddInput(transaction.EmptyId, address.Random())
+
+	newValueTransaction1 := transaction.New(transaction.EmptyId, transaction.EmptyId, identity.Generate(), valueTransfer)
+	assert.Equal(t, newValueTransaction1.VerifySignature(), true)
+
+	newValueTransaction2, _ := transaction.FromBytes(newValueTransaction1.GetBytes())
+	assert.Equal(t, newValueTransaction2.VerifySignature(), true)
+
+	if newValueTransaction1.GetPayload().GetType() == valuetransfer.Type {
+		fmt.Println("VALUE TRANSFER TRANSACTION")
+	}
+
+	newTransaction2 := transaction.New(newTransaction1.GetId(), transaction.EmptyId, identity.Generate(), data.New([]byte("test1")))
+	assert.Equal(t, newTransaction2.VerifySignature(), true)
+
+	if newTransaction1.GetPayload().GetType() == data.Type {
+		fmt.Println("DATA TRANSACTION")
+	}
+
+	newTransaction3, _ := transaction.FromBytes(newTransaction2.GetBytes())
+	assert.Equal(t, newTransaction3.VerifySignature(), true)
+
+	fmt.Println(newTransaction1)
+	fmt.Println(newTransaction2)
+	fmt.Println(newTransaction3)
+
+	//fmt.Println(newValueTransaction1)
+	//fmt.Println(newValueTransaction2)
+}

packages/binary/transaction/transaction.go

@@ -5,6 +5,7 @@ import (
 	"sync"
 
 	"github.com/iotaledger/goshimmer/packages/binary/identity"
+	"github.com/iotaledger/goshimmer/packages/binary/transaction/payload"
 	"github.com/iotaledger/goshimmer/packages/stringify"
 
 	"github.com/iotaledger/hive.go/objectstorage"
@@ -22,7 +23,7 @@ type Transaction struct {
 	trunkTransactionId  Id
 	branchTransactionId Id
 	issuer              *identity.Identity
-	payload             Payload
+	payload             payload.Payload
 	bytes               []byte
 	bytesMutex          sync.RWMutex
 	signature           [identity.SignatureSize]byte
@@ -31,12 +32,12 @@ type Transaction struct {
 	// derived properties
 	id             *Id
 	idMutex        sync.RWMutex
-	payloadId      *PayloadId
+	payloadId      *payload.Id
 	payloadIdMutex sync.RWMutex
 }
 
 // Allows us to "issue" a transaction.
-func New(trunkTransactionId Id, branchTransactionId Id, issuer *identity.Identity, payload Payload) (result *Transaction) {
+func New(trunkTransactionId Id, branchTransactionId Id, issuer *identity.Identity, payload payload.Payload) (result *Transaction) {
 	return &Transaction{
 		trunkTransactionId:  trunkTransactionId,
 		branchTransactionId: branchTransactionId,
@@ -98,11 +99,11 @@ func (transaction *Transaction) GetId() (result Id) {
 	return
 }
 
-func (transaction *Transaction) GetPayload() Payload {
+func (transaction *Transaction) GetPayload() payload.Payload {
 	return transaction.payload
 }
 
-func (transaction *Transaction) GetPayloadId() (result PayloadId) {
+func (transaction *Transaction) GetPayloadId() (result payload.Id) {
 	transaction.payloadIdMutex.RLock()
 	if transaction.payloadId == nil {
 		transaction.payloadIdMutex.RUnlock()
@@ -136,14 +137,14 @@ func (transaction *Transaction) GetBytes() []byte {
 func (transaction *Transaction) calculateTransactionId() Id {
 	payloadId := transaction.GetPayloadId()
 
-	hashBase := make([]byte, transactionIdLength+transactionIdLength+payloadIdLength)
+	hashBase := make([]byte, IdLength+IdLength+payload.IdLength)
 	offset := 0
 
 	copy(hashBase[offset:], transaction.trunkTransactionId[:])
-	offset += transactionIdLength
+	offset += IdLength
 
 	copy(hashBase[offset:], transaction.branchTransactionId[:])
-	offset += transactionIdLength
+	offset += IdLength
 
 	copy(hashBase[offset:], payloadId[:])
 	// offset += payloadIdLength
@@ -151,10 +152,10 @@ func (transaction *Transaction) calculateTransactionId() Id {
 	return blake2b.Sum512(hashBase)
 }
 
-func (transaction *Transaction) calculatePayloadId() PayloadId {
+func (transaction *Transaction) calculatePayloadId() payload.Id {
 	bytes := transaction.GetBytes()
 
-	return blake2b.Sum512(bytes[2*transactionIdLength:])
+	return blake2b.Sum512(bytes[2*IdLength:])
 }
 
 // Since transactions are immutable and do not get changed after being created, we cache the result of the marshaling.
@@ -173,14 +174,14 @@ func (transaction *Transaction) MarshalBinary() (result []byte, err error) {
 			}
 			serializedPayloadLength := len(serializedPayload)
 
-			result = make([]byte, transactionIdLength+transactionIdLength+identity.PublicKeySize+4+serializedPayloadLength+identity.SignatureSize)
+			result = make([]byte, IdLength+IdLength+identity.PublicKeySize+4+serializedPayloadLength+identity.SignatureSize)
 			offset := 0
 
 			copy(result[offset:], transaction.trunkTransactionId[:])
-			offset += transactionIdLength
+			offset += IdLength
 
 			copy(result[offset:], transaction.branchTransactionId[:])
-			offset += transactionIdLength
+			offset += IdLength
 
 			copy(result[offset:], transaction.issuer.PublicKey)
 			offset += identity.PublicKeySize
@@ -217,10 +218,10 @@ func (transaction *Transaction) UnmarshalBinary(data []byte) (err error) {
 	offset := 0
 
 	copy(transaction.trunkTransactionId[:], data[offset:])
-	offset += transactionIdLength
+	offset += IdLength
 
 	copy(transaction.branchTransactionId[:], data[offset:])
-	offset += transactionIdLength
+	offset += IdLength
 
 	transaction.issuer = identity.New(data[offset : offset+identity.PublicKeySize])
 	offset += identity.PublicKeySize
@@ -228,7 +229,7 @@ func (transaction *Transaction) UnmarshalBinary(data []byte) (err error) {
 	payloadType := binary.LittleEndian.Uint32(data[offset:])
 	offset += 4
 
-	if transaction.payload, err = GetPayloadUnmarshaler(payloadType)(data[offset : len(data)-identity.SignatureSize]); err != nil {
+	if transaction.payload, err = payload.GetUnmarshaler(payloadType)(data[offset : len(data)-identity.SignatureSize]); err != nil {
 		return
 	}
 	offset += len(data) - identity.SignatureSize - offset

packages/binary/transaction/transaction_test.go

-package transaction
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/magiconair/properties/assert"
-
-	"github.com/iotaledger/goshimmer/packages/binary/identity"
-)
-
-func TestNew(t *testing.T) {
-	newTransaction1 := New(Id{}, Id{}, identity.Generate(), NewDataPayload([]byte("test")))
-	assert.Equal(t, newTransaction1.VerifySignature(), true)
-
-	newTransaction2 := New(newTransaction1.GetId(), Id{}, identity.Generate(), NewDataPayload([]byte("test1")))
-	assert.Equal(t, newTransaction2.VerifySignature(), true)
-
-	newTransaction3, _ := FromBytes(newTransaction2.GetBytes())
-	assert.Equal(t, newTransaction3.VerifySignature(), true)
-
-	fmt.Println(newTransaction1)
-	fmt.Println(newTransaction2)
-	fmt.Println(newTransaction3)
-}

packages/binary/transferoutput/reference.go

+package transferoutput