diff --git a/go.mod b/go.mod
index 0d6f461262c8db03d1bdbfef0c4e0480726e0e9a..ff040d9c87ed2b4d4e83cc2c1ded44e1bb68adb3 100644
--- a/go.mod
+++ b/go.mod
@@ -10,7 +10,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-20200325224052-ac4d38108211
+ github.com/iotaledger/hive.go v0.0.0-20200326163241-4aa5b4d3b5b0
github.com/iotaledger/iota.go v1.0.0-beta.14
github.com/labstack/echo v3.3.10+incompatible
github.com/labstack/gommon v0.3.0 // indirect
diff --git a/go.sum b/go.sum
index 16b57bbd2bc00f47c4b440ce912a0d3fc7a62326..3e63ee7518856c67e74c80c29e9eb774ee43215e 100644
--- a/go.sum
+++ b/go.sum
@@ -134,6 +134,14 @@ github.com/iotaledger/hive.go v0.0.0-20200325224052-ac4d38108211 h1:ckZnjlKHCqgs
github.com/iotaledger/hive.go v0.0.0-20200325224052-ac4d38108211/go.mod h1:EfH+ZcYGFJzzoFpO7NHGi2k7+Xc84ASyp1EwjhI3eJc=
github.com/iotaledger/hive.go v0.0.0-20200326125723-9ba81bd19b75 h1:oZdDKfciKDJm/txN1/Ax61CCuFyOc7Y7mpMCrrgCVwo=
github.com/iotaledger/hive.go v0.0.0-20200326125723-9ba81bd19b75/go.mod h1:EfH+ZcYGFJzzoFpO7NHGi2k7+Xc84ASyp1EwjhI3eJc=
+github.com/iotaledger/hive.go v0.0.0-20200326133753-889dd6edb2ee h1:/PPAbuLfHtBQhV7n9sFh+wVKTvPH7pX6pCCFixq8LXw=
+github.com/iotaledger/hive.go v0.0.0-20200326133753-889dd6edb2ee/go.mod h1:EfH+ZcYGFJzzoFpO7NHGi2k7+Xc84ASyp1EwjhI3eJc=
+github.com/iotaledger/hive.go v0.0.0-20200326142220-1a50b54482ba h1:h6ilKICR660XPJDKazAcr9BDsKE4D0RveH59McjhIL0=
+github.com/iotaledger/hive.go v0.0.0-20200326142220-1a50b54482ba/go.mod h1:EfH+ZcYGFJzzoFpO7NHGi2k7+Xc84ASyp1EwjhI3eJc=
+github.com/iotaledger/hive.go v0.0.0-20200326161423-f9e74839ddef h1:TbOHnWsk2sKDc4z92mMXMZL2FCFpexOjLTxrnyi8Nc0=
+github.com/iotaledger/hive.go v0.0.0-20200326161423-f9e74839ddef/go.mod h1:4sloxRutRhCuXgAgtOu1ZxVM95Na+ovK9MRDEQGZlzw=
+github.com/iotaledger/hive.go v0.0.0-20200326163241-4aa5b4d3b5b0 h1:ADYgndjbLPrCxxoCfHItxb6RjB3dzFxHlQ+mrqk16g8=
+github.com/iotaledger/hive.go v0.0.0-20200326163241-4aa5b4d3b5b0/go.mod h1:4sloxRutRhCuXgAgtOu1ZxVM95Na+ovK9MRDEQGZlzw=
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=
diff --git a/packages/binary/tangle/model/message/id.go b/packages/binary/messagelayer/message/id.go
similarity index 100%
rename from packages/binary/tangle/model/message/id.go
rename to packages/binary/messagelayer/message/id.go
diff --git a/packages/binary/tangle/model/message/transaction.go b/packages/binary/messagelayer/message/message.go
similarity index 55%
rename from packages/binary/tangle/model/message/transaction.go
rename to packages/binary/messagelayer/message/message.go
index 5b9f6785c7124e9d7200ae752f9234b16d4a8793..7bd44f50b29f3dedbfc792ca7fd62f58d696ae39 100644
--- a/packages/binary/tangle/model/message/transaction.go
+++ b/packages/binary/messagelayer/message/message.go
@@ -5,19 +5,20 @@ import (
"time"
"github.com/iotaledger/hive.go/marshalutil"
+ "github.com/iotaledger/hive.go/objectstorage"
"github.com/iotaledger/hive.go/stringify"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
-
- "github.com/iotaledger/hive.go/objectstorage"
"github.com/mr-tron/base58"
"golang.org/x/crypto/blake2b"
)
-type Transaction struct {
+// region Message //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+type Message struct {
// base functionality of StorableObject
objectstorage.StorableObjectFlags
@@ -44,8 +45,8 @@ type Transaction struct {
}
// New creates a new transaction with the details provided by the issuer.
-func New(trunkTransactionId Id, branchTransactionId Id, issuerKeyPair ed25119.KeyPair, issuingTime time.Time, sequenceNumber uint64, payload payload.Payload) (result *Transaction) {
- return &Transaction{
+func New(trunkTransactionId Id, branchTransactionId Id, issuerKeyPair ed25119.KeyPair, issuingTime time.Time, sequenceNumber uint64, payload payload.Payload) (result *Message) {
+ return &Message{
trunkTransactionId: trunkTransactionId,
branchTransactionId: branchTransactionId,
issuerPublicKey: issuerKeyPair.PublicKey,
@@ -57,67 +58,69 @@ func New(trunkTransactionId Id, branchTransactionId Id, issuerKeyPair ed25119.Ke
}
}
-// Get's called when we restore a transaction from storage. The bytes and the content will be unmarshaled by an external
-// caller (the objectStorage factory).
-func StorableObjectFromKey(id []byte) (result objectstorage.StorableObject, err error) {
- var transactionId Id
- copy(transactionId[:], id)
-
- result = &Transaction{
- id: &transactionId,
- }
+func FromBytes(bytes []byte, optionalTargetObject ...*Message) (result *Message, err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(bytes)
+ result, err = Parse(marshalUtil, optionalTargetObject...)
+ consumedBytes = marshalUtil.ReadOffset()
return
}
-func FromBytes(bytes []byte, optionalTargetObject ...*Transaction) (result *Transaction, err error, consumedBytes int) {
+func Parse(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Message) (result *Message, err error) {
// determine the target object that will hold the unmarshaled information
switch len(optionalTargetObject) {
case 0:
- result = &Transaction{}
+ result = &Message{}
case 1:
result = optionalTargetObject[0]
default:
- panic("too many arguments in call to FromBytes")
+ panic("too many arguments in call to Parse")
}
- // initialize helper
- marshalUtil := marshalutil.New(bytes)
+ if parsedObject, parseErr := marshalUtil.Parse(func(data []byte) (interface{}, error, int) {
+ return StorableObjectFromKey(data)
+ }); parseErr != nil {
+ err = parseErr
- // parse information
- if result.trunkTransactionId, err = ParseId(marshalUtil); err != nil {
- return
- }
- if result.branchTransactionId, err = ParseId(marshalUtil); err != nil {
- return
- }
- if result.issuerPublicKey, err = ed25119.ParsePublicKey(marshalUtil); err != nil {
return
+ } else {
+ result = parsedObject.(*Message)
}
- if result.issuingTime, err = marshalUtil.ReadTime(); err != nil {
+ if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+ parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
+
return
- }
- if result.sequenceNumber, err = marshalUtil.ReadUint64(); err != nil {
+ }); err != nil {
return
}
- if result.payload, err = payload.Parse(marshalUtil); err != nil {
- return
+
+ return
+}
+
+// Get's called when we restore a transaction from storage. The bytes and the content will be unmarshaled by an external
+// caller (the objectStorage factory).
+func StorableObjectFromKey(key []byte, optionalTargetObject ...*Message) (result objectstorage.StorableObject, err error, consumedBytes int) {
+ // determine the target object that will hold the unmarshaled information
+ switch len(optionalTargetObject) {
+ case 0:
+ result = &Message{}
+ case 1:
+ result = optionalTargetObject[0]
+ default:
+ panic("too many arguments in call to StorableObjectFromKey")
}
- if result.signature, err = ed25119.ParseSignature(marshalUtil); err != nil {
+
+ marshalUtil := marshalutil.New(key)
+ *result.(*Message).id, err = ParseId(marshalUtil)
+ if err != nil {
return
}
-
- // return the number of bytes we processed
consumedBytes = marshalUtil.ReadOffset()
- // store marshaled version
- result.bytes = make([]byte, consumedBytes)
- copy(result.bytes, bytes)
-
return
}
-func (transaction *Transaction) VerifySignature() (result bool) {
+func (transaction *Message) VerifySignature() (result bool) {
transactionBytes := transaction.Bytes()
transaction.signatureMutex.RLock()
@@ -127,7 +130,7 @@ func (transaction *Transaction) VerifySignature() (result bool) {
return
}
-func (transaction *Transaction) GetId() (result Id) {
+func (transaction *Message) GetId() (result Id) {
transaction.idMutex.RLock()
if transaction.id == nil {
transaction.idMutex.RUnlock()
@@ -150,29 +153,29 @@ func (transaction *Transaction) GetId() (result Id) {
return
}
-func (transaction *Transaction) GetTrunkTransactionId() Id {
+func (transaction *Message) GetTrunkTransactionId() Id {
return transaction.trunkTransactionId
}
-func (transaction *Transaction) GetBranchTransactionId() Id {
+func (transaction *Message) GetBranchTransactionId() Id {
return transaction.branchTransactionId
}
// IssuingTime returns the time when the transaction was created.
-func (transaction *Transaction) IssuingTime() time.Time {
+func (transaction *Message) IssuingTime() time.Time {
return transaction.issuingTime
}
// SequenceNumber returns the sequence number of this transaction.
-func (transaction *Transaction) SequenceNumber() uint64 {
+func (transaction *Message) SequenceNumber() uint64 {
return transaction.sequenceNumber
}
-func (transaction *Transaction) GetPayload() payload.Payload {
+func (transaction *Message) GetPayload() payload.Payload {
return transaction.payload
}
-func (transaction *Transaction) GetPayloadId() (result payload.Id) {
+func (transaction *Message) GetPayloadId() (result payload.Id) {
transaction.payloadIdMutex.RLock()
if transaction.payloadId == nil {
transaction.payloadIdMutex.RUnlock()
@@ -195,7 +198,7 @@ func (transaction *Transaction) GetPayloadId() (result payload.Id) {
return
}
-func (transaction *Transaction) calculateTransactionId() Id {
+func (transaction *Message) calculateTransactionId() Id {
payloadId := transaction.GetPayloadId()
hashBase := make([]byte, IdLength+IdLength+payload.IdLength)
@@ -213,13 +216,13 @@ func (transaction *Transaction) calculateTransactionId() Id {
return blake2b.Sum512(hashBase)
}
-func (transaction *Transaction) calculatePayloadId() payload.Id {
+func (transaction *Message) calculatePayloadId() payload.Id {
bytes := transaction.Bytes()
return blake2b.Sum512(bytes[2*IdLength:])
}
-func (transaction *Transaction) Bytes() []byte {
+func (transaction *Message) Bytes() []byte {
transaction.bytesMutex.RLock()
if transaction.bytes != nil {
defer transaction.bytesMutex.RUnlock()
@@ -248,34 +251,95 @@ func (transaction *Transaction) Bytes() []byte {
return marshalUtil.Bytes()
}
-// Since transactions are immutable and do not get changed after being created, we cache the result of the marshaling.
-func (transaction *Transaction) ObjectStorageValue() []byte {
- return transaction.Bytes()
-}
+func (transaction *Message) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ // initialize helper
+ marshalUtil := marshalutil.New(data)
+
+ // parse information
+ if transaction.trunkTransactionId, err = ParseId(marshalUtil); err != nil {
+ return
+ }
+ if transaction.branchTransactionId, err = ParseId(marshalUtil); err != nil {
+ return
+ }
+ if transaction.issuerPublicKey, err = ed25119.ParsePublicKey(marshalUtil); err != nil {
+ return
+ }
+ if transaction.issuingTime, err = marshalUtil.ReadTime(); err != nil {
+ return
+ }
+ if transaction.sequenceNumber, err = marshalUtil.ReadUint64(); err != nil {
+ return
+ }
+ if transaction.payload, err = payload.Parse(marshalUtil); err != nil {
+ return
+ }
+ if transaction.signature, err = ed25119.ParseSignature(marshalUtil); err != nil {
+ return
+ }
+
+ // return the number of bytes we processed
+ consumedBytes = marshalUtil.ReadOffset()
-func (transaction *Transaction) UnmarshalObjectStorageValue(data []byte) (err error) {
- _, err, _ = FromBytes(data, transaction)
+ // store marshaled version
+ transaction.bytes = make([]byte, consumedBytes)
+ copy(transaction.bytes, data)
return
}
-func (transaction *Transaction) ObjectStorageKey() []byte {
- transactionId := transaction.GetId()
+func (transaction *Message) ObjectStorageKey() []byte {
+ return transaction.GetId().Bytes()
+}
- return transactionId[:]
+// Since transactions are immutable and do not get changed after being created, we cache the result of the marshaling.
+func (transaction *Message) ObjectStorageValue() []byte {
+ return transaction.Bytes()
}
-func (transaction *Transaction) Update(other objectstorage.StorableObject) {
+func (transaction *Message) Update(other objectstorage.StorableObject) {
panic("transactions should never be overwritten and only stored once to optimize IO")
}
-func (transaction *Transaction) String() string {
+func (transaction *Message) String() string {
transactionId := transaction.GetId()
- return stringify.Struct("Transaction",
+ return stringify.Struct("Message",
stringify.StructField("id", base58.Encode(transactionId[:])),
stringify.StructField("trunkTransactionId", base58.Encode(transaction.trunkTransactionId[:])),
stringify.StructField("trunkTransactionId", base58.Encode(transaction.branchTransactionId[:])),
stringify.StructField("payload", transaction.payload),
)
}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region CachedMessage ////////////////////////////////////////////////////////////////////////////////////////////////
+
+type CachedMessage struct {
+ objectstorage.CachedObject
+}
+
+func (cachedMessage *CachedMessage) Retain() *CachedMessage {
+ return &CachedMessage{cachedMessage.CachedObject.Retain()}
+}
+
+func (cachedMessage *CachedMessage) Consume(consumer func(transaction *Message)) bool {
+ return cachedMessage.CachedObject.Consume(func(object objectstorage.StorableObject) {
+ consumer(object.(*Message))
+ })
+}
+
+func (cachedMessage *CachedMessage) Unwrap() *Message {
+ if untypedTransaction := cachedMessage.Get(); untypedTransaction == nil {
+ return nil
+ } else {
+ if typeCastedTransaction := untypedTransaction.(*Message); typeCastedTransaction == nil || typeCastedTransaction.IsDeleted() {
+ return nil
+ } else {
+ return typeCastedTransaction
+ }
+ }
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/binary/tangle/model/message/payload/data/data.go b/packages/binary/messagelayer/payload/data.go
similarity index 64%
rename from packages/binary/tangle/model/message/payload/data/data.go
rename to packages/binary/messagelayer/payload/data.go
index 2be4b5db174ae77b06a2d422dfb6760ae5e5edf1..1325ed35a21d69784b4a134dac6d0dec92370b2f 100644
--- a/packages/binary/tangle/model/message/payload/data/data.go
+++ b/packages/binary/messagelayer/payload/data.go
@@ -1,27 +1,33 @@
-package data
+package payload
import (
"github.com/iotaledger/hive.go/marshalutil"
"github.com/iotaledger/hive.go/stringify"
-
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
)
+var DataType = Type(0)
+
type Data struct {
- payloadType payload.Type
+ payloadType Type
data []byte
}
-var Type = payload.Type(0)
-
-func New(data []byte) *Data {
+func NewData(data []byte) *Data {
return &Data{
- payloadType: Type,
+ payloadType: DataType,
data: data,
}
}
-func FromBytes(bytes []byte, optionalTargetObject ...*Data) (result *Data, err error, consumedBytes int) {
+func DataFromBytes(bytes []byte, optionalTargetObject ...*Data) (result *Data, err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(bytes)
+ result, err = ParseData(marshalUtil, optionalTargetObject...)
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func ParseData(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Data) (result *Data, err error) {
// determine the target object that will hold the unmarshaled information
switch len(optionalTargetObject) {
case 0:
@@ -29,13 +35,10 @@ func FromBytes(bytes []byte, optionalTargetObject ...*Data) (result *Data, err e
case 1:
result = optionalTargetObject[0]
default:
- panic("too many arguments in call to FromBytes")
+ panic("too many arguments in call to ParseData")
}
- // initialize helper
- marshalUtil := marshalutil.New(bytes)
-
- // read data
+ // parse information
result.payloadType, err = marshalUtil.ReadUint32()
if err != nil {
return
@@ -49,17 +52,14 @@ func FromBytes(bytes []byte, optionalTargetObject ...*Data) (result *Data, err e
return
}
- // return the number of bytes we processed
- consumedBytes = marshalUtil.ReadOffset()
-
return
}
-func (dataPayload *Data) Type() payload.Type {
+func (dataPayload *Data) Type() Type {
return dataPayload.payloadType
}
-func (dataPayload *Data) GetData() []byte {
+func (dataPayload *Data) Data() []byte {
return dataPayload.data
}
@@ -78,19 +78,19 @@ func (dataPayload *Data) Bytes() []byte {
}
func (dataPayload *Data) Unmarshal(data []byte) (err error) {
- _, err, _ = FromBytes(data, dataPayload)
+ _, err, _ = DataFromBytes(data, dataPayload)
return
}
func (dataPayload *Data) String() string {
return stringify.Struct("Data",
- stringify.StructField("data", string(dataPayload.GetData())),
+ stringify.StructField("data", string(dataPayload.Data())),
)
}
-func GenericPayloadUnmarshalerFactory(payloadType payload.Type) payload.Unmarshaler {
- return func(data []byte) (payload payload.Payload, err error) {
+func GenericPayloadUnmarshalerFactory(payloadType Type) Unmarshaler {
+ return func(data []byte) (payload Payload, err error) {
payload = &Data{
payloadType: payloadType,
}
diff --git a/packages/binary/tangle/model/message/payload/id.go b/packages/binary/messagelayer/payload/id.go
similarity index 100%
rename from packages/binary/tangle/model/message/payload/id.go
rename to packages/binary/messagelayer/payload/id.go
diff --git a/packages/binary/tangle/model/message/payload/payload.go b/packages/binary/messagelayer/payload/payload.go
similarity index 89%
rename from packages/binary/tangle/model/message/payload/payload.go
rename to packages/binary/messagelayer/payload/payload.go
index 5510738465f479f462fa5b1db3a999fed438b9da..97faf1711fc77b6e82babb5d9aebb5ac5578c739 100644
--- a/packages/binary/tangle/model/message/payload/payload.go
+++ b/packages/binary/messagelayer/payload/payload.go
@@ -4,6 +4,12 @@ import (
"github.com/iotaledger/hive.go/marshalutil"
)
+func init() {
+ SetGenericUnmarshalerFactory(GenericPayloadUnmarshalerFactory)
+
+ RegisterType(DataType, GenericPayloadUnmarshalerFactory(DataType))
+}
+
type Payload interface {
Type() Type
Bytes() []byte
diff --git a/packages/binary/tangle/model/message/payload/type.go b/packages/binary/messagelayer/payload/type.go
similarity index 100%
rename from packages/binary/tangle/model/message/payload/type.go
rename to packages/binary/messagelayer/payload/type.go
diff --git a/packages/binary/tangle/model/message/payload/type_register.go b/packages/binary/messagelayer/payload/type_register.go
similarity index 100%
rename from packages/binary/tangle/model/message/payload/type_register.go
rename to packages/binary/messagelayer/payload/type_register.go
diff --git a/packages/binary/messagelayer/tangle/approver.go b/packages/binary/messagelayer/tangle/approver.go
new file mode 100644
index 0000000000000000000000000000000000000000..9c638ed1a6da843b5cc4f6f1d2bb077d0f0452ae
--- /dev/null
+++ b/packages/binary/messagelayer/tangle/approver.go
@@ -0,0 +1,164 @@
+package tangle
+
+import (
+ "github.com/iotaledger/hive.go/marshalutil"
+ "github.com/iotaledger/hive.go/objectstorage"
+ "github.com/iotaledger/hive.go/stringify"
+
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+)
+
+// region Approver /////////////////////////////////////////////////////////////////////////////////////////////////////
+
+type Approver struct {
+ objectstorage.StorableObjectFlags
+
+ referencedMessageId message.Id
+ approvingMessageId message.Id
+}
+
+func NewApprover(referencedTransaction message.Id, approvingTransaction message.Id) *Approver {
+ approver := &Approver{
+ referencedMessageId: referencedTransaction,
+ approvingMessageId: approvingTransaction,
+ }
+
+ return approver
+}
+
+func ApproverFromBytes(bytes []byte, optionalTargetObject ...*Approver) (result *Approver, err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(bytes)
+ result, err = ParseApprover(marshalUtil, optionalTargetObject...)
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func ParseApprover(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Approver) (result *Approver, err error) {
+ if parsedObject, parseErr := marshalUtil.Parse(func(data []byte) (interface{}, error, int) {
+ return ApproverFromStorageKey(data, optionalTargetObject...)
+ }); parseErr != nil {
+ err = parseErr
+
+ return
+ } else {
+ result = parsedObject.(*Approver)
+ }
+
+ if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+ parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
+
+ return
+ }); err != nil {
+ return
+ }
+
+ return
+}
+
+func ApproverFromStorageKey(key []byte, optionalTargetObject ...*Approver) (result objectstorage.StorableObject, err error, consumedBytes int) {
+ // determine the target object that will hold the unmarshaled information
+ switch len(optionalTargetObject) {
+ case 0:
+ result = &Approver{}
+ case 1:
+ result = optionalTargetObject[0]
+ default:
+ panic("too many arguments in call to ApproverFromStorageKey")
+ }
+
+ // parse the properties that are stored in the key
+ marshalUtil := marshalutil.New(key)
+ result.(*Approver).referencedMessageId, err = message.ParseId(marshalUtil)
+ if err != nil {
+ return
+ }
+ result.(*Approver).approvingMessageId, err = message.ParseId(marshalUtil)
+ if err != nil {
+ return
+ }
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func (approver *Approver) ReferencedMessageId() message.Id {
+ return approver.approvingMessageId
+}
+
+func (approver *Approver) ApprovingMessageId() message.Id {
+ return approver.approvingMessageId
+}
+
+func (approver *Approver) Bytes() []byte {
+ return approver.ObjectStorageKey()
+}
+
+func (approver *Approver) String() string {
+ return stringify.Struct("Approver",
+ stringify.StructField("referencedMessageId", approver.ReferencedMessageId()),
+ stringify.StructField("approvingMessageId", approver.ApprovingMessageId()),
+ )
+}
+
+func (approver *Approver) ObjectStorageKey() []byte {
+ return marshalutil.New().
+ WriteBytes(approver.referencedMessageId.Bytes()).
+ WriteBytes(approver.approvingMessageId.Bytes()).
+ Bytes()
+}
+
+func (approver *Approver) ObjectStorageValue() (result []byte) {
+ return
+}
+
+func (approver *Approver) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ return
+}
+
+func (approver *Approver) Update(other objectstorage.StorableObject) {
+ panic("approvers should never be overwritten and only stored once to optimize IO")
+}
+
+// interface contract (allow the compiler to check if the implementation has all of the required methods).
+var _ objectstorage.StorableObject = &Approver{}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region CachedApprover ///////////////////////////////////////////////////////////////////////////////////////////////
+
+type CachedApprover struct {
+ objectstorage.CachedObject
+}
+
+func (cachedApprover *CachedApprover) Unwrap() *Approver {
+ if untypedObject := cachedApprover.Get(); untypedObject == nil {
+ return nil
+ } else {
+ if typedObject := untypedObject.(*Approver); typedObject == nil || typedObject.IsDeleted() {
+ return nil
+ } else {
+ return typedObject
+ }
+ }
+}
+
+func (cachedApprover *CachedApprover) Consume(consumer func(approver *Approver)) (consumed bool) {
+ return cachedApprover.CachedObject.Consume(func(object objectstorage.StorableObject) {
+ consumer(object.(*Approver))
+ })
+}
+
+type CachedApprovers []*CachedApprover
+
+func (cachedApprovers CachedApprovers) Consume(consumer func(approver *Approver)) (consumed bool) {
+ for _, cachedApprover := range cachedApprovers {
+ consumed = cachedApprover.Consume(func(approver *Approver) {
+ consumer(approver)
+ }) || consumed
+ }
+
+ return
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/binary/tangle/events.go b/packages/binary/messagelayer/tangle/events.go
similarity index 74%
rename from packages/binary/tangle/events.go
rename to packages/binary/messagelayer/tangle/events.go
index ec056169f8f0ceddaaf3a3d4b344218973da00cc..4c0a6c5490fa3bf3209c0b9522e701d8efd545ed 100644
--- a/packages/binary/tangle/events.go
+++ b/packages/binary/messagelayer/tangle/events.go
@@ -3,8 +3,7 @@ package tangle
import (
"github.com/iotaledger/hive.go/events"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
)
type Events struct {
@@ -33,8 +32,8 @@ func transactionIdEvent(handler interface{}, params ...interface{}) {
}
func cachedTransactionEvent(handler interface{}, params ...interface{}) {
- handler.(func(*message.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(
- params[0].(*message.CachedTransaction).Retain(),
- params[1].(*transactionmetadata.CachedTransactionMetadata).Retain(),
+ handler.(func(*message.CachedMessage, *CachedMessageMetadata))(
+ params[0].(*message.CachedMessage).Retain(),
+ params[1].(*CachedMessageMetadata).Retain(),
)
}
diff --git a/packages/binary/messagelayer/tangle/messagemetadata.go b/packages/binary/messagelayer/tangle/messagemetadata.go
new file mode 100644
index 0000000000000000000000000000000000000000..4fd028f1ed18709b38f7f2e807e89c47ffcee879
--- /dev/null
+++ b/packages/binary/messagelayer/tangle/messagemetadata.go
@@ -0,0 +1,171 @@
+package tangle
+
+import (
+ "sync"
+ "time"
+
+ "github.com/iotaledger/hive.go/marshalutil"
+ "github.com/iotaledger/hive.go/objectstorage"
+
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+)
+
+type MessageMetadata struct {
+ objectstorage.StorableObjectFlags
+
+ transactionId message.Id
+ receivedTime time.Time
+ solid bool
+ solidificationTime time.Time
+
+ solidMutex sync.RWMutex
+ solidificationTimeMutex sync.RWMutex
+}
+
+func NewMessageMetadata(transactionId message.Id) *MessageMetadata {
+ return &MessageMetadata{
+ transactionId: transactionId,
+ receivedTime: time.Now(),
+ }
+}
+
+func MessageMetadataFromBytes(bytes []byte) (result *MessageMetadata, err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(bytes)
+ result, err = ParseMessageMetadata(marshalUtil)
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func ParseMessageMetadata(marshalUtil *marshalutil.MarshalUtil) (result *MessageMetadata, err error) {
+ if parsedObject, parseErr := marshalUtil.Parse(func(data []byte) (interface{}, error, int) {
+ return MessageMetadataFromStorageKey(data)
+ }); parseErr != nil {
+ err = parseErr
+
+ return
+ } else {
+ result = parsedObject.(*MessageMetadata)
+ }
+
+ if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+ parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
+
+ return
+ }); err != nil {
+ return
+ }
+
+ return
+}
+
+func MessageMetadataFromStorageKey(key []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
+ result = &MessageMetadata{}
+
+ marshalUtil := marshalutil.New(key)
+ result.(*MessageMetadata).transactionId, err = message.ParseId(marshalUtil)
+ if err != nil {
+ return
+ }
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func (messageMetadata *MessageMetadata) IsSolid() (result bool) {
+ messageMetadata.solidMutex.RLock()
+ result = messageMetadata.solid
+ messageMetadata.solidMutex.RUnlock()
+
+ return
+}
+
+func (messageMetadata *MessageMetadata) SetSolid(solid bool) (modified bool) {
+ messageMetadata.solidMutex.RLock()
+ if messageMetadata.solid != solid {
+ messageMetadata.solidMutex.RUnlock()
+
+ messageMetadata.solidMutex.Lock()
+ if messageMetadata.solid != solid {
+ messageMetadata.solid = solid
+ if solid {
+ messageMetadata.solidificationTimeMutex.Lock()
+ messageMetadata.solidificationTime = time.Now()
+ messageMetadata.solidificationTimeMutex.Unlock()
+ }
+
+ messageMetadata.SetModified()
+
+ modified = true
+ }
+ messageMetadata.solidMutex.Unlock()
+
+ } else {
+ messageMetadata.solidMutex.RUnlock()
+ }
+
+ return
+}
+
+func (messageMetadata *MessageMetadata) SoldificationTime() time.Time {
+ messageMetadata.solidificationTimeMutex.RLock()
+ defer messageMetadata.solidificationTimeMutex.RUnlock()
+
+ return messageMetadata.solidificationTime
+}
+
+func (messageMetadata *MessageMetadata) ObjectStorageKey() []byte {
+ return messageMetadata.transactionId.Bytes()
+}
+
+func (messageMetadata *MessageMetadata) ObjectStorageValue() []byte {
+ return marshalutil.New().
+ WriteTime(messageMetadata.receivedTime).
+ WriteTime(messageMetadata.solidificationTime).
+ WriteBool(messageMetadata.solid).
+ Bytes()
+}
+
+func (messageMetadata *MessageMetadata) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(data)
+
+ if messageMetadata.receivedTime, err = marshalUtil.ReadTime(); err != nil {
+ return
+ }
+ if messageMetadata.solidificationTime, err = marshalUtil.ReadTime(); err != nil {
+ return
+ }
+ if messageMetadata.solid, err = marshalUtil.ReadBool(); err != nil {
+ return
+ }
+
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func (messageMetadata *MessageMetadata) Update(other objectstorage.StorableObject) {
+ panic("updates disabled")
+}
+
+var _ objectstorage.StorableObject = &MessageMetadata{}
+
+type CachedMessageMetadata struct {
+ objectstorage.CachedObject
+}
+
+func (cachedMessageMetadata *CachedMessageMetadata) Retain() *CachedMessageMetadata {
+ return &CachedMessageMetadata{cachedMessageMetadata.CachedObject.Retain()}
+}
+
+func (cachedMessageMetadata *CachedMessageMetadata) Unwrap() *MessageMetadata {
+ if untypedObject := cachedMessageMetadata.Get(); untypedObject == nil {
+ return nil
+ } else {
+ if typedObject := untypedObject.(*MessageMetadata); typedObject == nil || typedObject.IsDeleted() {
+ return nil
+ } else {
+ return typedObject
+ }
+ }
+}
diff --git a/packages/binary/messagelayer/tangle/missingmessage.go b/packages/binary/messagelayer/tangle/missingmessage.go
new file mode 100644
index 0000000000000000000000000000000000000000..e05d11f047ff21258bea8a55ebdee012dcc6b633
--- /dev/null
+++ b/packages/binary/messagelayer/tangle/missingmessage.go
@@ -0,0 +1,82 @@
+package tangle
+
+import (
+ "time"
+
+ "github.com/iotaledger/hive.go/marshalutil"
+ "github.com/iotaledger/hive.go/objectstorage"
+
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+)
+
+type MissingMessage struct {
+ objectstorage.StorableObjectFlags
+
+ transactionId message.Id
+ missingSince time.Time
+}
+
+func NewMissingMessage(transactionId message.Id) *MissingMessage {
+ return &MissingMessage{
+ transactionId: transactionId,
+ missingSince: time.Now(),
+ }
+}
+
+func MissingMessageFromStorageKey(key []byte, optionalTargetObject ...*MissingMessage) (result objectstorage.StorableObject, err error, consumedBytes int) {
+ // determine the target object that will hold the unmarshaled information
+ switch len(optionalTargetObject) {
+ case 0:
+ result = &Approver{}
+ case 1:
+ result = optionalTargetObject[0]
+ default:
+ panic("too many arguments in call to MissingMessageFromStorageKey")
+ }
+
+ // parse the properties that are stored in the key
+ marshalUtil := marshalutil.New(key)
+ result.(*MissingMessage).transactionId, err = message.ParseId(marshalUtil)
+ if err != nil {
+ return
+ }
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func (missingMessage *MissingMessage) GetTransactionId() message.Id {
+ return missingMessage.transactionId
+}
+
+func (missingMessage *MissingMessage) GetMissingSince() time.Time {
+ return missingMessage.missingSince
+}
+
+func (missingMessage *MissingMessage) Update(other objectstorage.StorableObject) {
+ panic("missing transactions should never be overwritten and only stored once to optimize IO")
+}
+
+func (missingMessage *MissingMessage) ObjectStorageKey() []byte {
+ return missingMessage.transactionId[:]
+}
+
+func (missingMessage *MissingMessage) ObjectStorageValue() (result []byte) {
+ result, err := missingMessage.missingSince.MarshalBinary()
+ if err != nil {
+ panic(err)
+ }
+
+ return
+}
+
+func (missingMessage *MissingMessage) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(data)
+ missingMessage.missingSince, err = marshalUtil.ReadTime()
+ if err != nil {
+ return
+ }
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
diff --git a/packages/binary/tangle/tangle.go b/packages/binary/messagelayer/tangle/tangle.go
similarity index 55%
rename from packages/binary/tangle/tangle.go
rename to packages/binary/messagelayer/tangle/tangle.go
index 3ed82777a4e82e9e070c53185f5de4b853b9e59f..8dc9477f6362012cd685baff7b7a497be17dd234 100644
--- a/packages/binary/tangle/tangle.go
+++ b/packages/binary/messagelayer/tangle/tangle.go
@@ -7,11 +7,8 @@ import (
"github.com/dgraph-io/badger/v2"
"github.com/iotaledger/hive.go/types"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
"github.com/iotaledger/goshimmer/packages/binary/storageprefix"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/approver"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/missingtransaction"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
"github.com/iotaledger/hive.go/async"
"github.com/iotaledger/hive.go/objectstorage"
@@ -25,26 +22,38 @@ const (
type Tangle struct {
storageId []byte
- transactionStorage *objectstorage.ObjectStorage
- transactionMetadataStorage *objectstorage.ObjectStorage
- approverStorage *objectstorage.ObjectStorage
- missingTransactionsStorage *objectstorage.ObjectStorage
+ messageStorage *objectstorage.ObjectStorage
+ messageMetadataStorage *objectstorage.ObjectStorage
+ approverStorage *objectstorage.ObjectStorage
+ missingMessageStorage *objectstorage.ObjectStorage
Events Events
- storeTransactionsWorkerPool async.WorkerPool
- solidifierWorkerPool async.WorkerPool
- cleanupWorkerPool async.WorkerPool
+ storeMessageWorkerPool async.WorkerPool
+ solidifierWorkerPool async.WorkerPool
+ cleanupWorkerPool async.WorkerPool
+}
+
+func messageFactory(key []byte) (objectstorage.StorableObject, error, int) {
+ return message.StorableObjectFromKey(key)
+}
+
+func approverFactory(key []byte) (objectstorage.StorableObject, error, int) {
+ return ApproverFromStorageKey(key)
+}
+
+func missingMessageFactory(key []byte) (objectstorage.StorableObject, error, int) {
+ return MissingMessageFromStorageKey(key)
}
// Constructor for the tangle.
func New(badgerInstance *badger.DB, storageId []byte) (result *Tangle) {
result = &Tangle{
- storageId: storageId,
- transactionStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleTransaction...), message.StorableObjectFromKey, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
- transactionMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleTransactionMetadata...), transactionmetadata.StorableObjectFromKey, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
- approverStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleApprovers...), approver.StorableObjectFromKey, objectstorage.CacheTime(10*time.Second), objectstorage.PartitionKey(message.IdLength, message.IdLength), objectstorage.LeakDetectionEnabled(false)),
- missingTransactionsStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleMissingTransaction...), missingtransaction.StorableObjectFromKey, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
+ storageId: storageId,
+ messageStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0Message...), messageFactory, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
+ messageMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0MessageMetadata...), MessageMetadataFromStorageKey, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
+ approverStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0Approvers...), approverFactory, objectstorage.CacheTime(10*time.Second), objectstorage.PartitionKey(message.IdLength, message.IdLength), objectstorage.LeakDetectionEnabled(false)),
+ missingMessageStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0MissingMessage...), missingMessageFactory, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
Events: *newEvents(),
}
@@ -55,30 +64,30 @@ func New(badgerInstance *badger.DB, storageId []byte) (result *Tangle) {
}
// Returns the storage id of this tangle (can be used to create ontologies that follow the storage of the main tangle).
-func (tangle *Tangle) GetStorageId() []byte {
+func (tangle *Tangle) StorageId() []byte {
return tangle.storageId
}
// Attaches a new transaction to the tangle.
-func (tangle *Tangle) AttachTransaction(transaction *message.Transaction) {
- tangle.storeTransactionsWorkerPool.Submit(func() { tangle.storeTransactionWorker(transaction) })
+func (tangle *Tangle) AttachMessage(transaction *message.Message) {
+ tangle.storeMessageWorkerPool.Submit(func() { tangle.storeMessageWorker(transaction) })
}
// Retrieves a transaction from the tangle.
-func (tangle *Tangle) GetTransaction(transactionId message.Id) *message.CachedTransaction {
- return &message.CachedTransaction{CachedObject: tangle.transactionStorage.Load(transactionId[:])}
+func (tangle *Tangle) Message(transactionId message.Id) *message.CachedMessage {
+ return &message.CachedMessage{CachedObject: tangle.messageStorage.Load(transactionId[:])}
}
// Retrieves the metadata of a transaction from the tangle.
-func (tangle *Tangle) GetTransactionMetadata(transactionId message.Id) *transactionmetadata.CachedTransactionMetadata {
- return &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Load(transactionId[:])}
+func (tangle *Tangle) MessageMetadata(transactionId message.Id) *CachedMessageMetadata {
+ return &CachedMessageMetadata{CachedObject: tangle.messageMetadataStorage.Load(transactionId[:])}
}
-// GetApprovers retrieves the approvers of a transaction from the tangle.
-func (tangle *Tangle) GetApprovers(transactionId message.Id) approver.CachedApprovers {
- approvers := make(approver.CachedApprovers, 0)
+// Approvers retrieves the approvers of a transaction from the tangle.
+func (tangle *Tangle) Approvers(transactionId message.Id) CachedApprovers {
+ approvers := make(CachedApprovers, 0)
tangle.approverStorage.ForEach(func(key []byte, cachedObject objectstorage.CachedObject) bool {
- approvers = append(approvers, &approver.CachedApprover{CachedObject: cachedObject})
+ approvers = append(approvers, &CachedApprover{CachedObject: cachedObject})
return true
}, transactionId[:])
@@ -87,33 +96,33 @@ func (tangle *Tangle) GetApprovers(transactionId message.Id) approver.CachedAppr
}
// Deletes a transaction from the tangle (i.e. for local snapshots)
-func (tangle *Tangle) DeleteTransaction(transactionId message.Id) {
- tangle.GetTransaction(transactionId).Consume(func(currentTransaction *message.Transaction) {
+func (tangle *Tangle) DeleteMessage(messageId message.Id) {
+ tangle.Message(messageId).Consume(func(currentTransaction *message.Message) {
trunkTransactionId := currentTransaction.GetTrunkTransactionId()
- tangle.deleteApprover(trunkTransactionId, transactionId)
+ tangle.deleteApprover(trunkTransactionId, messageId)
branchTransactionId := currentTransaction.GetBranchTransactionId()
if branchTransactionId != trunkTransactionId {
- tangle.deleteApprover(branchTransactionId, transactionId)
+ tangle.deleteApprover(branchTransactionId, messageId)
}
- tangle.transactionMetadataStorage.Delete(transactionId[:])
- tangle.transactionStorage.Delete(transactionId[:])
+ tangle.messageMetadataStorage.Delete(messageId[:])
+ tangle.messageStorage.Delete(messageId[:])
- tangle.Events.TransactionRemoved.Trigger(transactionId)
+ tangle.Events.TransactionRemoved.Trigger(messageId)
})
}
// Marks the tangle as stopped, so it will not accept any new transactions (waits for all backgroundTasks to finish.
func (tangle *Tangle) Shutdown() *Tangle {
- tangle.storeTransactionsWorkerPool.ShutdownGracefully()
+ tangle.storeMessageWorkerPool.ShutdownGracefully()
tangle.solidifierWorkerPool.ShutdownGracefully()
tangle.cleanupWorkerPool.ShutdownGracefully()
- tangle.transactionStorage.Shutdown()
- tangle.transactionMetadataStorage.Shutdown()
+ tangle.messageStorage.Shutdown()
+ tangle.messageMetadataStorage.Shutdown()
tangle.approverStorage.Shutdown()
- tangle.missingTransactionsStorage.Shutdown()
+ tangle.missingMessageStorage.Shutdown()
return tangle
}
@@ -121,10 +130,10 @@ func (tangle *Tangle) Shutdown() *Tangle {
// Resets the database and deletes all objects (good for testing or "node resets").
func (tangle *Tangle) Prune() error {
for _, storage := range []*objectstorage.ObjectStorage{
- tangle.transactionStorage,
- tangle.transactionMetadataStorage,
+ tangle.messageStorage,
+ tangle.messageMetadataStorage,
tangle.approverStorage,
- tangle.missingTransactionsStorage,
+ tangle.missingMessageStorage,
} {
if err := storage.Prune(); err != nil {
return err
@@ -135,55 +144,55 @@ func (tangle *Tangle) Prune() error {
}
// Worker that stores the transactions and calls the corresponding storage events"
-func (tangle *Tangle) storeTransactionWorker(tx *message.Transaction) {
+func (tangle *Tangle) storeMessageWorker(tx *message.Message) {
// store transaction
- var cachedTransaction *message.CachedTransaction
- if _tmp, transactionIsNew := tangle.transactionStorage.StoreIfAbsent(tx); !transactionIsNew {
+ var cachedTransaction *message.CachedMessage
+ if _tmp, transactionIsNew := tangle.messageStorage.StoreIfAbsent(tx); !transactionIsNew {
return
} else {
- cachedTransaction = &message.CachedTransaction{CachedObject: _tmp}
+ cachedTransaction = &message.CachedMessage{CachedObject: _tmp}
}
// store transaction metadata
transactionId := tx.GetId()
- cachedTransactionMetadata := &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Store(transactionmetadata.New(transactionId))}
+ cachedTransactionMetadata := &CachedMessageMetadata{CachedObject: tangle.messageMetadataStorage.Store(NewMessageMetadata(transactionId))}
// store trunk approver
trunkTransactionID := tx.GetTrunkTransactionId()
- tangle.approverStorage.Store(approver.New(trunkTransactionID, transactionId)).Release()
+ tangle.approverStorage.Store(NewApprover(trunkTransactionID, transactionId)).Release()
// store branch approver
if branchTransactionID := tx.GetBranchTransactionId(); branchTransactionID != trunkTransactionID {
- tangle.approverStorage.Store(approver.New(branchTransactionID, transactionId)).Release()
+ tangle.approverStorage.Store(NewApprover(branchTransactionID, transactionId)).Release()
}
// trigger events
- if tangle.missingTransactionsStorage.DeleteIfPresent(transactionId[:]) {
+ if tangle.missingMessageStorage.DeleteIfPresent(transactionId[:]) {
tangle.Events.MissingTransactionReceived.Trigger(cachedTransaction, cachedTransactionMetadata)
}
tangle.Events.TransactionAttached.Trigger(cachedTransaction, cachedTransactionMetadata)
// check solidity
tangle.solidifierWorkerPool.Submit(func() {
- tangle.solidifyTransactionWorker(cachedTransaction, cachedTransactionMetadata)
+ tangle.solidifyMessageWorker(cachedTransaction, cachedTransactionMetadata)
})
}
// Worker that solidifies the transactions (recursively from past to present).
-func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+func (tangle *Tangle) solidifyMessageWorker(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *CachedMessageMetadata) {
isTransactionMarkedAsSolid := func(transactionId message.Id) bool {
if transactionId == message.EmptyId {
return true
}
- transactionMetadataCached := tangle.GetTransactionMetadata(transactionId)
+ transactionMetadataCached := tangle.MessageMetadata(transactionId)
if transactionMetadata := transactionMetadataCached.Unwrap(); transactionMetadata == nil {
transactionMetadataCached.Release()
// if transaction is missing and was not reported as missing, yet
- if cachedMissingTransaction, missingTransactionStored := tangle.missingTransactionsStorage.StoreIfAbsent(missingtransaction.New(transactionId)); missingTransactionStored {
+ if cachedMissingTransaction, missingTransactionStored := tangle.missingMessageStorage.StoreIfAbsent(NewMissingMessage(transactionId)); missingTransactionStored {
cachedMissingTransaction.Consume(func(object objectstorage.StorableObject) {
- tangle.monitorMissingTransactionWorker(object.(*missingtransaction.MissingTransaction).GetTransactionId())
+ tangle.monitorMissingMessageWorker(object.(*MissingMessage).GetTransactionId())
})
}
@@ -198,7 +207,7 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.Cache
return true
}
- isTransactionSolid := func(transaction *message.Transaction, transactionMetadata *transactionmetadata.TransactionMetadata) bool {
+ isTransactionSolid := func(transaction *message.Message, transactionMetadata *MessageMetadata) bool {
if transaction == nil || transaction.IsDeleted() {
return false
}
@@ -214,13 +223,13 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.Cache
return isTransactionMarkedAsSolid(transaction.GetTrunkTransactionId()) && isTransactionMarkedAsSolid(transaction.GetBranchTransactionId())
}
- popElementsFromStack := func(stack *list.List) (*message.CachedTransaction, *transactionmetadata.CachedTransactionMetadata) {
+ popElementsFromStack := func(stack *list.List) (*message.CachedMessage, *CachedMessageMetadata) {
currentSolidificationEntry := stack.Front()
currentCachedTransaction := currentSolidificationEntry.Value.([2]interface{})[0]
currentCachedTransactionMetadata := currentSolidificationEntry.Value.([2]interface{})[1]
stack.Remove(currentSolidificationEntry)
- return currentCachedTransaction.(*message.CachedTransaction), currentCachedTransactionMetadata.(*transactionmetadata.CachedTransactionMetadata)
+ return currentCachedTransaction.(*message.CachedMessage), currentCachedTransactionMetadata.(*CachedMessageMetadata)
}
// initialize the stack
@@ -244,12 +253,12 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.Cache
if isTransactionSolid(currentTransaction, currentTransactionMetadata) && currentTransactionMetadata.SetSolid(true) {
tangle.Events.TransactionSolid.Trigger(currentCachedTransaction, currentCachedTransactionMetadata)
- tangle.GetApprovers(currentTransaction.GetId()).Consume(func(approver *approver.Approver) {
- approverTransactionId := approver.GetApprovingTransactionId()
+ tangle.Approvers(currentTransaction.GetId()).Consume(func(approver *Approver) {
+ approverTransactionId := approver.ReferencedMessageId()
solidificationStack.PushBack([2]interface{}{
- tangle.GetTransaction(approverTransactionId),
- tangle.GetTransactionMetadata(approverTransactionId),
+ tangle.Message(approverTransactionId),
+ tangle.MessageMetadata(approverTransactionId),
})
})
}
@@ -261,12 +270,12 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.Cache
}
// Worker that Monitors the missing transactions (by scheduling regular checks).
-func (tangle *Tangle) monitorMissingTransactionWorker(transactionId message.Id) {
+func (tangle *Tangle) monitorMissingMessageWorker(transactionId message.Id) {
var scheduleNextMissingCheck func(transactionId message.Id)
scheduleNextMissingCheck = func(transactionId message.Id) {
time.AfterFunc(MISSING_CHECK_INTERVAL, func() {
- tangle.missingTransactionsStorage.Load(transactionId[:]).Consume(func(object objectstorage.StorableObject) {
- missingTransaction := object.(*missingtransaction.MissingTransaction)
+ tangle.missingMessageStorage.Load(transactionId[:]).Consume(func(object objectstorage.StorableObject) {
+ missingTransaction := object.(*MissingMessage)
if time.Since(missingTransaction.GetMissingSince()) >= MAX_MISSING_TIME_BEFORE_CLEANUP {
tangle.cleanupWorkerPool.Submit(func() {
@@ -308,10 +317,10 @@ func (tangle *Tangle) deleteSubtangle(transactionId message.Id) {
currentTransactionId := currentStackEntry.Value.(message.Id)
cleanupStack.Remove(currentStackEntry)
- tangle.DeleteTransaction(currentTransactionId)
+ tangle.DeleteMessage(currentTransactionId)
- tangle.GetApprovers(currentTransactionId).Consume(func(approver *approver.Approver) {
- approverId := approver.GetApprovingTransactionId()
+ tangle.Approvers(currentTransactionId).Consume(func(approver *Approver) {
+ approverId := approver.ReferencedMessageId()
if _, transactionProcessed := processedTransactions[approverId]; !transactionProcessed {
cleanupStack.PushBack(approverId)
diff --git a/packages/binary/tangle/tangle_test.go b/packages/binary/messagelayer/tangle/tangle_test.go
similarity index 52%
rename from packages/binary/tangle/tangle_test.go
rename to packages/binary/messagelayer/tangle/tangle_test.go
index 9cf607e6dcec5c78cf853c5f4ccaf0865b9cbabf..40a263f6d0c33f2b7b463bb3a2e7eeb7796364ee 100644
--- a/packages/binary/tangle/tangle_test.go
+++ b/packages/binary/messagelayer/tangle/tangle_test.go
@@ -10,10 +10,9 @@ import (
"github.com/iotaledger/hive.go/events"
"github.com/stretchr/testify/require"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
"github.com/iotaledger/goshimmer/packages/database"
"github.com/iotaledger/goshimmer/plugins/config"
)
@@ -34,16 +33,16 @@ func BenchmarkTangle_AttachTransaction(b *testing.B) {
testIdentity := ed25119.GenerateKeyPair()
- transactionBytes := make([]*message.Transaction, b.N)
+ transactionBytes := make([]*message.Message, b.N)
for i := 0; i < b.N; i++ {
- transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, testIdentity, time.Now(), 0, data.New([]byte("some data")))
+ transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, testIdentity, time.Now(), 0, payload.NewData([]byte("some data")))
transactionBytes[i].Bytes()
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
- tangle.AttachTransaction(transactionBytes[i])
+ tangle.AttachMessage(transactionBytes[i])
}
tangle.Shutdown()
@@ -56,49 +55,49 @@ func TestTangle_AttachTransaction(t *testing.T) {
// use the tempdir for the database
config.Node.Set(database.CFG_DIRECTORY, dir)
- tangle := New(database.GetBadgerInstance(), []byte("TEST_BINARY_TANGLE"))
- if err := tangle.Prune(); err != nil {
+ messageTangle := New(database.GetBadgerInstance(), []byte("TEST_BINARY_TANGLE"))
+ if err := messageTangle.Prune(); err != nil {
t.Error(err)
return
}
- tangle.Events.TransactionAttached.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+ messageTangle.Events.TransactionAttached.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *CachedMessageMetadata) {
cachedTransactionMetadata.Release()
- cachedTransaction.Consume(func(transaction *message.Transaction) {
+ cachedTransaction.Consume(func(transaction *message.Message) {
fmt.Println("ATTACHED:", transaction.GetId())
})
}))
- tangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+ messageTangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *CachedMessageMetadata) {
cachedTransactionMetadata.Release()
- cachedTransaction.Consume(func(transaction *message.Transaction) {
+ cachedTransaction.Consume(func(transaction *message.Message) {
fmt.Println("SOLID:", transaction.GetId())
})
}))
- tangle.Events.TransactionUnsolidifiable.Attach(events.NewClosure(func(transactionId message.Id) {
+ messageTangle.Events.TransactionUnsolidifiable.Attach(events.NewClosure(func(transactionId message.Id) {
fmt.Println("UNSOLIDIFIABLE:", transactionId)
}))
- tangle.Events.TransactionMissing.Attach(events.NewClosure(func(transactionId message.Id) {
+ messageTangle.Events.TransactionMissing.Attach(events.NewClosure(func(transactionId message.Id) {
fmt.Println("MISSING:", transactionId)
}))
- tangle.Events.TransactionRemoved.Attach(events.NewClosure(func(transactionId message.Id) {
+ messageTangle.Events.TransactionRemoved.Attach(events.NewClosure(func(transactionId message.Id) {
fmt.Println("REMOVED:", transactionId)
}))
- newTransaction1 := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some data")))
- newTransaction2 := message.New(newTransaction1.GetId(), newTransaction1.GetId(), ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some other data")))
+ newTransaction1 := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("some data")))
+ newTransaction2 := message.New(newTransaction1.GetId(), newTransaction1.GetId(), ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("some other data")))
- tangle.AttachTransaction(newTransaction2)
+ messageTangle.AttachMessage(newTransaction2)
time.Sleep(7 * time.Second)
- tangle.AttachTransaction(newTransaction1)
+ messageTangle.AttachMessage(newTransaction1)
- tangle.Shutdown()
+ messageTangle.Shutdown()
}
diff --git a/packages/binary/tangle/model/message/test/transaction_test.go b/packages/binary/messagelayer/test/transaction_test.go
similarity index 78%
rename from packages/binary/tangle/model/message/test/transaction_test.go
rename to packages/binary/messagelayer/test/transaction_test.go
index be5a61ffe8d24cb5c5ccfedeeecae19325cd6ca7..6881c27c4cef5b400452a8e726254cc447d8fcb9 100644
--- a/packages/binary/tangle/model/message/test/transaction_test.go
+++ b/packages/binary/messagelayer/test/transaction_test.go
@@ -10,9 +10,9 @@ import (
"github.com/panjf2000/ants/v2"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
)
func BenchmarkVerifyDataTransactions(b *testing.B) {
@@ -21,7 +21,7 @@ func BenchmarkVerifyDataTransactions(b *testing.B) {
transactions := make([][]byte, b.N)
for i := 0; i < b.N; i++ {
- tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some data")))
+ tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("some data")))
transactions[i] = tx.Bytes()
}
@@ -45,9 +45,9 @@ func BenchmarkVerifyDataTransactions(b *testing.B) {
func BenchmarkVerifySignature(b *testing.B) {
pool, _ := ants.NewPool(80, ants.WithNonblocking(false))
- transactions := make([]*message.Transaction, b.N)
+ transactions := make([]*message.Message, b.N)
for i := 0; i < b.N; i++ {
- transactions[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("test")))
+ transactions[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("test")))
transactions[i].Bytes()
}
diff --git a/packages/binary/tangle/tipselector/events.go b/packages/binary/messagelayer/tipselector/events.go
similarity index 81%
rename from packages/binary/tangle/tipselector/events.go
rename to packages/binary/messagelayer/tipselector/events.go
index 21f6276eda365408bae0bb38f0b71d7a891fcb0a..432f2914018bbdfdeec89238c2195b4d31c7ee9f 100644
--- a/packages/binary/tangle/tipselector/events.go
+++ b/packages/binary/messagelayer/tipselector/events.go
@@ -1,8 +1,9 @@
package tipselector
import (
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
"github.com/iotaledger/hive.go/events"
+
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
)
type Events struct {
diff --git a/packages/binary/tangle/tipselector/tipselector.go b/packages/binary/messagelayer/tipselector/tipselector.go
similarity index 92%
rename from packages/binary/tangle/tipselector/tipselector.go
rename to packages/binary/messagelayer/tipselector/tipselector.go
index f98d1f50eb3b09e739333c03dc434a084ab36a21..84e447d8661d165f0a0b390937e44ae9274d65fe 100644
--- a/packages/binary/tangle/tipselector/tipselector.go
+++ b/packages/binary/messagelayer/tipselector/tipselector.go
@@ -1,9 +1,10 @@
package tipselector
import (
- "github.com/iotaledger/goshimmer/packages/binary/datastructure"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
"github.com/iotaledger/hive.go/events"
+
+ "github.com/iotaledger/goshimmer/packages/binary/datastructure"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
)
type TipSelector struct {
@@ -21,7 +22,7 @@ func New() *TipSelector {
}
}
-func (tipSelector *TipSelector) AddTip(transaction *message.Transaction) {
+func (tipSelector *TipSelector) AddTip(transaction *message.Message) {
transactionId := transaction.GetId()
if tipSelector.tips.Set(transactionId, transactionId) {
tipSelector.Events.TipAdded.Trigger(transactionId)
diff --git a/packages/binary/tangle/tipselector/tipselector_test.go b/packages/binary/messagelayer/tipselector/tipselector_test.go
similarity index 80%
rename from packages/binary/tangle/tipselector/tipselector_test.go
rename to packages/binary/messagelayer/tipselector/tipselector_test.go
index f089f29d993401ab1d3d98b906b7e74e853671f2..9adda6fc1b80ec2bc03418636e0b6730e0a873ca 100644
--- a/packages/binary/tangle/tipselector/tipselector_test.go
+++ b/packages/binary/messagelayer/tipselector/tipselector_test.go
@@ -6,9 +6,9 @@ import (
"github.com/stretchr/testify/assert"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
)
func Test(t *testing.T) {
@@ -21,7 +21,7 @@ func Test(t *testing.T) {
assert.Equal(t, message.EmptyId, branch1)
// create a transaction and attach it
- transaction1 := message.New(trunk1, branch1, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("testtransaction")))
+ transaction1 := message.New(trunk1, branch1, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("testtransaction")))
tipSelector.AddTip(transaction1)
// check if the tip shows up in the tip count
@@ -33,7 +33,7 @@ func Test(t *testing.T) {
assert.Equal(t, transaction1.GetId(), branch2)
// create a 2nd transaction and attach it
- transaction2 := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("testtransaction")))
+ transaction2 := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("testtransaction")))
tipSelector.AddTip(transaction2)
// check if the tip shows up in the tip count
@@ -41,7 +41,7 @@ func Test(t *testing.T) {
// attach a transaction to our two tips
trunk3, branch3 := tipSelector.GetTips()
- transaction3 := message.New(trunk3, branch3, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("testtransaction")))
+ transaction3 := message.New(trunk3, branch3, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("testtransaction")))
tipSelector.AddTip(transaction3)
// check if the tip shows replaces the current tips
diff --git a/packages/binary/tangle/transactionparser/builtinfilters/recently_seen_bytes_filter.go b/packages/binary/messagelayer/transactionparser/builtinfilters/recently_seen_bytes_filter.go
similarity index 100%
rename from packages/binary/tangle/transactionparser/builtinfilters/recently_seen_bytes_filter.go
rename to packages/binary/messagelayer/transactionparser/builtinfilters/recently_seen_bytes_filter.go
diff --git a/packages/binary/tangle/transactionparser/builtinfilters/transaction_signature_filter.go b/packages/binary/messagelayer/transactionparser/builtinfilters/transaction_signature_filter.go
similarity index 74%
rename from packages/binary/tangle/transactionparser/builtinfilters/transaction_signature_filter.go
rename to packages/binary/messagelayer/transactionparser/builtinfilters/transaction_signature_filter.go
index f6d64f3eb25ae0b828b2195540f5235912111295..347c7c31dd34a0df8baf169bac65f3f6af03669b 100644
--- a/packages/binary/tangle/transactionparser/builtinfilters/transaction_signature_filter.go
+++ b/packages/binary/messagelayer/transactionparser/builtinfilters/transaction_signature_filter.go
@@ -7,14 +7,14 @@ import (
"github.com/iotaledger/hive.go/async"
"github.com/iotaledger/hive.go/autopeering/peer"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
)
var ErrInvalidSignature = fmt.Errorf("invalid signature")
type TransactionSignatureFilter struct {
- onAcceptCallback func(tx *message.Transaction, peer *peer.Peer)
- onRejectCallback func(tx *message.Transaction, err error, peer *peer.Peer)
+ onAcceptCallback func(tx *message.Message, peer *peer.Peer)
+ onRejectCallback func(tx *message.Message, err error, peer *peer.Peer)
workerPool async.WorkerPool
onAcceptCallbackMutex sync.RWMutex
@@ -27,7 +27,7 @@ func NewTransactionSignatureFilter() (result *TransactionSignatureFilter) {
return
}
-func (filter *TransactionSignatureFilter) Filter(tx *message.Transaction, peer *peer.Peer) {
+func (filter *TransactionSignatureFilter) Filter(tx *message.Message, peer *peer.Peer) {
filter.workerPool.Submit(func() {
if tx.VerifySignature() {
filter.getAcceptCallback()(tx, peer)
@@ -37,13 +37,13 @@ func (filter *TransactionSignatureFilter) Filter(tx *message.Transaction, peer *
})
}
-func (filter *TransactionSignatureFilter) OnAccept(callback func(tx *message.Transaction, peer *peer.Peer)) {
+func (filter *TransactionSignatureFilter) OnAccept(callback func(tx *message.Message, peer *peer.Peer)) {
filter.onAcceptCallbackMutex.Lock()
filter.onAcceptCallback = callback
filter.onAcceptCallbackMutex.Unlock()
}
-func (filter *TransactionSignatureFilter) OnReject(callback func(tx *message.Transaction, err error, peer *peer.Peer)) {
+func (filter *TransactionSignatureFilter) OnReject(callback func(tx *message.Message, err error, peer *peer.Peer)) {
filter.onRejectCallbackMutex.Lock()
filter.onRejectCallback = callback
filter.onRejectCallbackMutex.Unlock()
@@ -53,7 +53,7 @@ func (filter *TransactionSignatureFilter) Shutdown() {
filter.workerPool.ShutdownGracefully()
}
-func (filter *TransactionSignatureFilter) getAcceptCallback() (result func(tx *message.Transaction, peer *peer.Peer)) {
+func (filter *TransactionSignatureFilter) getAcceptCallback() (result func(tx *message.Message, peer *peer.Peer)) {
filter.onAcceptCallbackMutex.RLock()
result = filter.onAcceptCallback
filter.onAcceptCallbackMutex.RUnlock()
@@ -61,7 +61,7 @@ func (filter *TransactionSignatureFilter) getAcceptCallback() (result func(tx *m
return
}
-func (filter *TransactionSignatureFilter) getRejectCallback() (result func(tx *message.Transaction, err error, peer *peer.Peer)) {
+func (filter *TransactionSignatureFilter) getRejectCallback() (result func(tx *message.Message, err error, peer *peer.Peer)) {
filter.onRejectCallbackMutex.RLock()
result = filter.onRejectCallback
filter.onRejectCallbackMutex.RUnlock()
diff --git a/packages/binary/tangle/transactionparser/bytes_filter.go b/packages/binary/messagelayer/transactionparser/bytes_filter.go
similarity index 100%
rename from packages/binary/tangle/transactionparser/bytes_filter.go
rename to packages/binary/messagelayer/transactionparser/bytes_filter.go
diff --git a/packages/binary/tangle/transactionparser/events.go b/packages/binary/messagelayer/transactionparser/events.go
similarity index 100%
rename from packages/binary/tangle/transactionparser/events.go
rename to packages/binary/messagelayer/transactionparser/events.go
diff --git a/packages/binary/messagelayer/transactionparser/transaction_filter.go b/packages/binary/messagelayer/transactionparser/transaction_filter.go
new file mode 100644
index 0000000000000000000000000000000000000000..0cb631ae596c4d41ef44d5252bc47a265974f599
--- /dev/null
+++ b/packages/binary/messagelayer/transactionparser/transaction_filter.go
@@ -0,0 +1,14 @@
+package transactionparser
+
+import (
+ "github.com/iotaledger/hive.go/autopeering/peer"
+
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+)
+
+type TransactionFilter interface {
+ Filter(tx *message.Message, peer *peer.Peer)
+ OnAccept(callback func(tx *message.Message, peer *peer.Peer))
+ OnReject(callback func(tx *message.Message, err error, peer *peer.Peer))
+ Shutdown()
+}
diff --git a/packages/binary/tangle/transactionparser/transactionparser.go b/packages/binary/messagelayer/transactionparser/transactionparser.go
similarity index 90%
rename from packages/binary/tangle/transactionparser/transactionparser.go
rename to packages/binary/messagelayer/transactionparser/transactionparser.go
index d684efc3283a5c58a168c11cc0be8dbe1c42fdda..6e54add7ea0c3dcafa1474550b7fc2a66aef3a3e 100644
--- a/packages/binary/tangle/transactionparser/transactionparser.go
+++ b/packages/binary/messagelayer/transactionparser/transactionparser.go
@@ -3,11 +3,10 @@ package transactionparser
import (
"sync"
- "github.com/iotaledger/hive.go/autopeering/peer"
-
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/transactionparser/builtinfilters"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/transactionparser/builtinfilters"
+ "github.com/iotaledger/hive.go/autopeering/peer"
"github.com/iotaledger/hive.go/events"
"github.com/iotaledger/hive.go/typeutils"
)
@@ -33,10 +32,10 @@ func New() (result *TransactionParser) {
handler.(func([]byte, error, *peer.Peer))(params[0].([]byte), params[1].(error), params[2].(*peer.Peer))
}),
TransactionParsed: events.NewEvent(func(handler interface{}, params ...interface{}) {
- handler.(func(*message.Transaction, *peer.Peer))(params[0].(*message.Transaction), params[1].(*peer.Peer))
+ handler.(func(*message.Message, *peer.Peer))(params[0].(*message.Message), params[1].(*peer.Peer))
}),
TransactionRejected: events.NewEvent(func(handler interface{}, params ...interface{}) {
- handler.(func(*message.Transaction, error, *peer.Peer))(params[0].(*message.Transaction), params[1].(error), params[2].(*peer.Peer))
+ handler.(func(*message.Message, error, *peer.Peer))(params[0].(*message.Message), params[1].(error), params[2].(*peer.Peer))
}),
},
}
@@ -121,13 +120,13 @@ func (transactionParser *TransactionParser) setupTransactionsFilterDataFlow() {
numberOfTransactionFilters := len(transactionParser.transactionFilters)
for i := 0; i < numberOfTransactionFilters; i++ {
if i == numberOfTransactionFilters-1 {
- transactionParser.transactionFilters[i].OnAccept(func(tx *message.Transaction, peer *peer.Peer) {
+ transactionParser.transactionFilters[i].OnAccept(func(tx *message.Message, peer *peer.Peer) {
transactionParser.Events.TransactionParsed.Trigger(tx, peer)
})
} else {
transactionParser.transactionFilters[i].OnAccept(transactionParser.transactionFilters[i+1].Filter)
}
- transactionParser.transactionFilters[i].OnReject(func(tx *message.Transaction, err error, peer *peer.Peer) {
+ transactionParser.transactionFilters[i].OnReject(func(tx *message.Message, err error, peer *peer.Peer) {
transactionParser.Events.TransactionRejected.Trigger(tx, err, peer)
})
}
diff --git a/packages/binary/tangle/transactionparser/transactionparser_test.go b/packages/binary/messagelayer/transactionparser/transactionparser_test.go
similarity index 72%
rename from packages/binary/tangle/transactionparser/transactionparser_test.go
rename to packages/binary/messagelayer/transactionparser/transactionparser_test.go
index 9a5f64138ab321ef06f4c9844e1f137d0b0d6bc0..eb0c4af49c72b093f45a739f19f24d3e9bdb2d95 100644
--- a/packages/binary/tangle/transactionparser/transactionparser_test.go
+++ b/packages/binary/messagelayer/transactionparser/transactionparser_test.go
@@ -8,13 +8,13 @@ import (
"github.com/iotaledger/hive.go/events"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
)
func BenchmarkTransactionParser_ParseBytesSame(b *testing.B) {
- txBytes := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("Test"))).Bytes()
+ txBytes := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("Test"))).Bytes()
txParser := New()
b.ResetTimer()
@@ -29,7 +29,7 @@ func BenchmarkTransactionParser_ParseBytesSame(b *testing.B) {
func BenchmarkTransactionParser_ParseBytesDifferent(b *testing.B) {
transactionBytes := make([][]byte, b.N)
for i := 0; i < b.N; i++ {
- transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("Test"+strconv.Itoa(i)))).Bytes()
+ transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("Test"+strconv.Itoa(i)))).Bytes()
}
txParser := New()
@@ -44,12 +44,12 @@ func BenchmarkTransactionParser_ParseBytesDifferent(b *testing.B) {
}
func TestTransactionParser_ParseTransaction(t *testing.T) {
- tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("Test")))
+ tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("Test")))
txParser := New()
txParser.Parse(tx.Bytes(), nil)
- txParser.Events.TransactionParsed.Attach(events.NewClosure(func(tx *message.Transaction) {
+ txParser.Events.TransactionParsed.Attach(events.NewClosure(func(tx *message.Message) {
fmt.Println("PARSED!!!")
}))
diff --git a/packages/binary/tangle/transactionrequester/constants.go b/packages/binary/messagelayer/transactionrequester/constants.go
similarity index 100%
rename from packages/binary/tangle/transactionrequester/constants.go
rename to packages/binary/messagelayer/transactionrequester/constants.go
diff --git a/packages/binary/tangle/transactionrequester/events.go b/packages/binary/messagelayer/transactionrequester/events.go
similarity index 100%
rename from packages/binary/tangle/transactionrequester/events.go
rename to packages/binary/messagelayer/transactionrequester/events.go
diff --git a/packages/binary/tangle/transactionrequester/options.go b/packages/binary/messagelayer/transactionrequester/options.go
similarity index 100%
rename from packages/binary/tangle/transactionrequester/options.go
rename to packages/binary/messagelayer/transactionrequester/options.go
diff --git a/packages/binary/tangle/transactionrequester/transactionrequester.go b/packages/binary/messagelayer/transactionrequester/transactionrequester.go
similarity index 96%
rename from packages/binary/tangle/transactionrequester/transactionrequester.go
rename to packages/binary/messagelayer/transactionrequester/transactionrequester.go
index 2016298c71b42658d3b832c2040285118de61175..a81993a83c048ac90cefd8a107e77bffca06cf11 100644
--- a/packages/binary/tangle/transactionrequester/transactionrequester.go
+++ b/packages/binary/messagelayer/transactionrequester/transactionrequester.go
@@ -7,7 +7,7 @@ import (
"github.com/iotaledger/hive.go/async"
"github.com/iotaledger/hive.go/events"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
)
type TransactionRequester struct {
diff --git a/packages/binary/spammer/spammer.go b/packages/binary/spammer/spammer.go
index ea0efc5ac16b3f4ca84dcf3f4740ca7cec0a3f26..d8adc712e62fa8957f524f75f367b230bda94db4 100644
--- a/packages/binary/spammer/spammer.go
+++ b/packages/binary/spammer/spammer.go
@@ -6,11 +6,11 @@ import (
"github.com/iotaledger/hive.go/types"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/tipselector"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/transactionparser"
"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/tipselector"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/transactionparser"
)
type Spammer struct {
@@ -53,7 +53,7 @@ func (spammer *Spammer) run(tps int, processId int64) {
trunkTransactionId, branchTransactionId := spammer.tipSelector.GetTips()
spammer.transactionParser.Parse(
- message.New(trunkTransactionId, branchTransactionId, spammingIdentity, time.Now(), 0, data.New([]byte("SPAM"))).Bytes(),
+ message.New(trunkTransactionId, branchTransactionId, spammingIdentity, time.Now(), 0, payload.NewData([]byte("SPAM"))).Bytes(),
nil,
)
@@ -83,7 +83,7 @@ func (spammer *Spammer) sendBurst(transactions int, processId int64) {
return
}
- spamTransaction := message.New(previousTransactionId, previousTransactionId, spammingIdentity, time.Now(), 0, data.New([]byte("SPAM")))
+ spamTransaction := message.New(previousTransactionId, previousTransactionId, spammingIdentity, time.Now(), 0, payload.NewData([]byte("SPAM")))
previousTransactionId = spamTransaction.GetId()
burstBuffer[i] = spamTransaction.Bytes()
}
diff --git a/packages/binary/storageprefix/storageprefix.go b/packages/binary/storageprefix/storageprefix.go
index 0c960b0ac2102861550b75f15b0f84c86393497e..efafc56ee9dd4aeefa34fe8db69ee583f8170ec3 100644
--- a/packages/binary/storageprefix/storageprefix.go
+++ b/packages/binary/storageprefix/storageprefix.go
@@ -3,10 +3,10 @@ package storageprefix
var (
MainNet = []byte{0}
- TangleTransaction = []byte{1}
- TangleTransactionMetadata = []byte{2}
- TangleApprovers = []byte{3}
- TangleMissingTransaction = []byte{4}
+ Layer0Message = []byte{1}
+ Layer0MessageMetadata = []byte{2}
+ Layer0Approvers = []byte{3}
+ Layer0MissingMessage = []byte{4}
ValueTransferPayload = []byte{5}
ValueTransferPayloadMetadata = []byte{6}
diff --git a/packages/binary/tangle/model/approver/approver.go b/packages/binary/tangle/model/approver/approver.go
deleted file mode 100644
index b6545c6c4a65fb2ea821d9b33322def2f267e6e3..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/approver/approver.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package approver
-
-import (
- "github.com/iotaledger/hive.go/objectstorage"
-
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-)
-
-type Approver struct {
- objectstorage.StorableObjectFlags
-
- storageKey []byte
- referencedTransaction message.Id
- approvingTransaction message.Id
-}
-
-func New(referencedTransaction message.Id, approvingTransaction message.Id) *Approver {
- approver := &Approver{
- storageKey: make([]byte, message.IdLength+message.IdLength),
- referencedTransaction: referencedTransaction,
- approvingTransaction: approvingTransaction,
- }
-
- copy(approver.storageKey[:message.IdLength], referencedTransaction[:])
- copy(approver.storageKey[message.IdLength:], approvingTransaction[:])
-
- return approver
-}
-
-func StorableObjectFromKey(id []byte) (result objectstorage.StorableObject, err error) {
- approver := &Approver{
- storageKey: make([]byte, message.IdLength+message.IdLength),
- }
- copy(approver.referencedTransaction[:], id[:message.IdLength])
- copy(approver.approvingTransaction[:], id[message.IdLength:])
- copy(approver.storageKey, id)
-
- return approver, nil
-}
-
-func (approver *Approver) ObjectStorageKey() []byte {
- return approver.storageKey
-}
-
-func (approver *Approver) GetApprovingTransactionId() message.Id {
- return approver.approvingTransaction
-}
-
-func (approver *Approver) Update(other objectstorage.StorableObject) {
- panic("approvers should never be overwritten and only stored once to optimize IO")
-}
-
-func (approver *Approver) ObjectStorageValue() (result []byte) {
- return
-}
-
-func (approver *Approver) UnmarshalObjectStorageValue(data []byte) (err error) {
- return
-}
diff --git a/packages/binary/tangle/model/approver/cached_approver.go b/packages/binary/tangle/model/approver/cached_approver.go
deleted file mode 100644
index 68fe1bcba8559b730f5fad4e2d2d7fbdbea405a4..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/approver/cached_approver.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package approver
-
-import (
- "github.com/iotaledger/hive.go/objectstorage"
-)
-
-type CachedApprover struct {
- objectstorage.CachedObject
-}
-
-func (cachedApprover *CachedApprover) Unwrap() *Approver {
- if untypedObject := cachedApprover.Get(); untypedObject == nil {
- return nil
- } else {
- if typedObject := untypedObject.(*Approver); typedObject == nil || typedObject.IsDeleted() {
- return nil
- } else {
- return typedObject
- }
- }
-}
-
-type CachedApprovers []*CachedApprover
-
-func (cachedApprovers CachedApprovers) Consume(consumer func(approver *Approver)) (consumed bool) {
- for _, cachedApprover := range cachedApprovers {
- consumed = cachedApprover.Consume(func(object objectstorage.StorableObject) {
- consumer(object.(*Approver))
- }) || consumed
- }
-
- return
-}
diff --git a/packages/binary/tangle/model/message/cached_transaction.go b/packages/binary/tangle/model/message/cached_transaction.go
deleted file mode 100644
index 8657ecb87618a106654fbba2acb861594406eb35..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/message/cached_transaction.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package message
-
-import (
- "github.com/iotaledger/hive.go/objectstorage"
-)
-
-type CachedTransaction struct {
- objectstorage.CachedObject
-}
-
-func (cachedTransaction *CachedTransaction) Retain() *CachedTransaction {
- return &CachedTransaction{cachedTransaction.CachedObject.Retain()}
-}
-
-func (cachedTransaction *CachedTransaction) Consume(consumer func(transaction *Transaction)) bool {
- return cachedTransaction.CachedObject.Consume(func(object objectstorage.StorableObject) {
- consumer(object.(*Transaction))
- })
-}
-
-func (cachedTransaction *CachedTransaction) Unwrap() *Transaction {
- if untypedTransaction := cachedTransaction.Get(); untypedTransaction == nil {
- return nil
- } else {
- if typeCastedTransaction := untypedTransaction.(*Transaction); typeCastedTransaction == nil || typeCastedTransaction.IsDeleted() {
- return nil
- } else {
- return typeCastedTransaction
- }
- }
-}
diff --git a/packages/binary/tangle/model/message/init.go b/packages/binary/tangle/model/message/init.go
deleted file mode 100644
index 15999765139b3e31a3828cb69e25b93d9c2c24eb..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/message/init.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package message
-
-import (
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
-)
-
-func init() {
- payload.SetGenericUnmarshalerFactory(data.GenericPayloadUnmarshalerFactory)
-}
diff --git a/packages/binary/tangle/model/message/payload/data/init.go b/packages/binary/tangle/model/message/payload/data/init.go
deleted file mode 100644
index f1ae7c9d143c2115e60d3d082c22584d56b170da..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/message/payload/data/init.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package data
-
-import (
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
-)
-
-func init() {
- payload.RegisterType(Type, GenericPayloadUnmarshalerFactory(Type))
-}
diff --git a/packages/binary/tangle/model/missingtransaction/cached_missingtransaction.go b/packages/binary/tangle/model/missingtransaction/cached_missingtransaction.go
deleted file mode 100644
index f50f532127ba98e5f9baaaa5bd1095ba0c9d4216..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/missingtransaction/cached_missingtransaction.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package missingtransaction
-
-import (
- "github.com/iotaledger/hive.go/objectstorage"
-)
-
-type CachedMissingTransaction struct {
- objectstorage.CachedObject
-}
-
-func (cachedObject *CachedMissingTransaction) Unwrap() *MissingTransaction {
- if untypedObject := cachedObject.Get(); untypedObject == nil {
- return nil
- } else {
- if typedObject := untypedObject.(*MissingTransaction); typedObject == nil || typedObject.IsDeleted() {
- return nil
- } else {
- return typedObject
- }
- }
-}
diff --git a/packages/binary/tangle/model/missingtransaction/missingtransaction.go b/packages/binary/tangle/model/missingtransaction/missingtransaction.go
deleted file mode 100644
index a4fc5871dd3b93ee3a122da968c045050b742949..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/missingtransaction/missingtransaction.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package missingtransaction
-
-import (
- "time"
-
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/hive.go/objectstorage"
-)
-
-type MissingTransaction struct {
- objectstorage.StorableObjectFlags
-
- transactionId message.Id
- missingSince time.Time
-}
-
-func New(transactionId message.Id) *MissingTransaction {
- return &MissingTransaction{
- transactionId: transactionId,
- missingSince: time.Now(),
- }
-}
-
-func StorableObjectFromKey(key []byte) (objectstorage.StorableObject, error) {
- result := &MissingTransaction{}
- copy(result.transactionId[:], key)
-
- return result, nil
-}
-
-func (missingTransaction *MissingTransaction) GetTransactionId() message.Id {
- return missingTransaction.transactionId
-}
-
-func (missingTransaction *MissingTransaction) GetMissingSince() time.Time {
- return missingTransaction.missingSince
-}
-
-func (missingTransaction *MissingTransaction) Update(other objectstorage.StorableObject) {
- panic("missing transactions should never be overwritten and only stored once to optimize IO")
-}
-
-func (missingTransaction *MissingTransaction) ObjectStorageKey() []byte {
- return missingTransaction.transactionId[:]
-}
-
-func (missingTransaction *MissingTransaction) ObjectStorageValue() (result []byte) {
- result, err := missingTransaction.missingSince.MarshalBinary()
- if err != nil {
- panic(err)
- }
-
- return
-}
-
-func (missingTransaction *MissingTransaction) UnmarshalObjectStorageValue(data []byte) (err error) {
- return missingTransaction.missingSince.UnmarshalBinary(data)
-}
diff --git a/packages/binary/tangle/model/transactionmetadata/cached_transactionmetadata.go b/packages/binary/tangle/model/transactionmetadata/cached_transactionmetadata.go
deleted file mode 100644
index c8db28e1b0f455adb506ff40b5996fbab8801bcb..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/transactionmetadata/cached_transactionmetadata.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package transactionmetadata
-
-import (
- "github.com/iotaledger/hive.go/objectstorage"
-)
-
-type CachedTransactionMetadata struct {
- objectstorage.CachedObject
-}
-
-func (cachedObject *CachedTransactionMetadata) Retain() *CachedTransactionMetadata {
- return &CachedTransactionMetadata{cachedObject.CachedObject.Retain()}
-}
-
-func (cachedObject *CachedTransactionMetadata) Unwrap() *TransactionMetadata {
- if untypedObject := cachedObject.Get(); untypedObject == nil {
- return nil
- } else {
- if typedObject := untypedObject.(*TransactionMetadata); typedObject == nil || typedObject.IsDeleted() {
- return nil
- } else {
- return typedObject
- }
- }
-}
diff --git a/packages/binary/tangle/model/transactionmetadata/proto.go b/packages/binary/tangle/model/transactionmetadata/proto.go
deleted file mode 100644
index 652cb7d48f6a027ca9104ade946c2483f7626510..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/transactionmetadata/proto.go
+++ /dev/null
@@ -1,51 +0,0 @@
-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 ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/binary/tangle/model/transactionmetadata/transactionmetadata.go b/packages/binary/tangle/model/transactionmetadata/transactionmetadata.go
deleted file mode 100644
index 74e222bbcdfb8face95c981dcfbd0bb75c2cd697..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/model/transactionmetadata/transactionmetadata.go
+++ /dev/null
@@ -1,109 +0,0 @@
-package transactionmetadata
-
-import (
- "sync"
- "time"
-
- "github.com/iotaledger/hive.go/objectstorage"
-
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-)
-
-type TransactionMetadata struct {
- objectstorage.StorableObjectFlags
-
- transactionId message.Id
- receivedTime time.Time
- solid bool
- solidificationTime time.Time
-
- solidMutex sync.RWMutex
- solidificationTimeMutex sync.RWMutex
-}
-
-func New(transactionId message.Id) *TransactionMetadata {
- return &TransactionMetadata{
- transactionId: transactionId,
- receivedTime: time.Now(),
- }
-}
-
-func StorableObjectFromKey(id []byte) (objectstorage.StorableObject, error) {
- result := &TransactionMetadata{}
- copy(result.transactionId[:], id)
-
- return result, nil
-}
-
-func (transactionMetadata *TransactionMetadata) IsSolid() (result bool) {
- transactionMetadata.solidMutex.RLock()
- result = transactionMetadata.solid
- transactionMetadata.solidMutex.RUnlock()
-
- return
-}
-
-func (transactionMetadata *TransactionMetadata) SetSolid(solid bool) (modified bool) {
- transactionMetadata.solidMutex.RLock()
- if transactionMetadata.solid != solid {
- transactionMetadata.solidMutex.RUnlock()
-
- transactionMetadata.solidMutex.Lock()
- if transactionMetadata.solid != solid {
- transactionMetadata.solid = solid
- if solid {
- transactionMetadata.solidificationTimeMutex.Lock()
- transactionMetadata.solidificationTime = time.Now()
- transactionMetadata.solidificationTimeMutex.Unlock()
- }
-
- transactionMetadata.SetModified()
-
- modified = true
- }
- transactionMetadata.solidMutex.Unlock()
-
- } else {
- transactionMetadata.solidMutex.RUnlock()
- }
-
- return
-}
-
-func (transactionMetadata *TransactionMetadata) GetSoldificationTime() time.Time {
- transactionMetadata.solidificationTimeMutex.RLock()
- defer transactionMetadata.solidificationTimeMutex.RUnlock()
-
- return transactionMetadata.solidificationTime
-}
-
-func (transactionMetadata *TransactionMetadata) ObjectStorageKey() []byte {
- return transactionMetadata.transactionId[:]
-}
-
-func (transactionMetadata *TransactionMetadata) Update(other objectstorage.StorableObject) {
-
-}
-
-func (transactionMetadata *TransactionMetadata) ObjectStorageValue() []byte {
- return (&Proto{
- receivedTime: transactionMetadata.receivedTime,
- solidificationTime: transactionMetadata.solidificationTime,
- solid: transactionMetadata.solid,
- }).ToBytes()
-}
-
-func (transactionMetadata *TransactionMetadata) UnmarshalObjectStorageValue(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
-}
-
-var _ objectstorage.StorableObject = &TransactionMetadata{}
diff --git a/packages/binary/tangle/transactionparser/transaction_filter.go b/packages/binary/tangle/transactionparser/transaction_filter.go
deleted file mode 100644
index c13d94ec4d85c133e7967efd00bad62e19a21faa..0000000000000000000000000000000000000000
--- a/packages/binary/tangle/transactionparser/transaction_filter.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package transactionparser
-
-import (
- "github.com/iotaledger/hive.go/autopeering/peer"
-
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-)
-
-type TransactionFilter interface {
- Filter(tx *message.Transaction, peer *peer.Peer)
- OnAccept(callback func(tx *message.Transaction, peer *peer.Peer))
- OnReject(callback func(tx *message.Transaction, err error, peer *peer.Peer))
- Shutdown()
-}
diff --git a/packages/binary/valuetransfer/payload/payload.go b/packages/binary/valuetransfer/payload/payload.go
index c9e6ff69f4fe5b0ede1bf6e1af2b6e14f5de565c..d41e143931d8d5d1ee98b578b7413f124e4a8315 100644
--- a/packages/binary/valuetransfer/payload/payload.go
+++ b/packages/binary/valuetransfer/payload/payload.go
@@ -8,22 +8,21 @@ import (
"github.com/iotaledger/hive.go/stringify"
"golang.org/x/crypto/blake2b"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/transaction"
)
type Payload struct {
objectstorage.StorableObjectFlags
- trunkPayloadId Id
- branchPayloadId Id
- transaction *transaction.Transaction
-
id *Id
idMutex sync.RWMutex
- bytes []byte
- bytesMutex sync.RWMutex
+ trunkPayloadId Id
+ branchPayloadId Id
+ transaction *transaction.Transaction
+ bytes []byte
+ bytesMutex sync.RWMutex
}
func New(trunkPayloadId, branchPayloadId Id, valueTransfer *transaction.Transaction) *Payload {
@@ -34,20 +33,34 @@ func New(trunkPayloadId, branchPayloadId Id, valueTransfer *transaction.Transact
}
}
-func StorableObjectFromKey(key []byte) (objectstorage.StorableObject, error) {
- id, err, _ := IdFromBytes(key)
- if err != nil {
- return nil, err
+// FromBytes parses the marshaled version of a Payload into an object.
+// It either returns a new Payload or fills an optionally provided Payload with the parsed information.
+func FromBytes(bytes []byte, optionalTargetObject ...*Payload) (result *Payload, err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(bytes)
+ result, err = Parse(marshalUtil, optionalTargetObject...)
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func StorableObjectFromKey(key []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
+ result = &Payload{}
+
+ // parse the properties that are stored in the key
+ marshalUtil := marshalutil.New(key)
+ if payloadId, idErr := ParseId(marshalUtil); idErr != nil {
+ err = idErr
+
+ return
+ } else {
+ result.(*Payload).id = &payloadId
}
+ consumedBytes = marshalUtil.ReadOffset()
- return &Payload{
- id: &id,
- }, nil
+ return
}
-// FromBytes parses the marshaled version of a Payload into an object.
-// It either returns a new Payload or fills an optionally provided Payload with the parsed information.
-func FromBytes(bytes []byte, optionalTargetObject ...*Payload) (result *Payload, err error, consumedBytes int) {
+func Parse(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Payload) (result *Payload, err error) {
// determine the target object that will hold the unmarshaled information
switch len(optionalTargetObject) {
case 0:
@@ -55,49 +68,17 @@ func FromBytes(bytes []byte, optionalTargetObject ...*Payload) (result *Payload,
case 1:
result = optionalTargetObject[0]
default:
- panic("too many arguments in call to OutputFromBytes")
+ panic("too many arguments in call to Parse")
}
- // initialize helper
- marshalUtil := marshalutil.New(bytes)
+ if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+ parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
- // read information that are required to identify the payload from the outside
- _, err = marshalUtil.ReadUint32()
- if err != nil {
return
- }
- _, err = marshalUtil.ReadUint32()
- if err != nil {
+ }); err != nil {
return
}
- // parse trunk payload id
- parsedTrunkPayloadId, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return IdFromBytes(data) })
- if err != nil {
- return
- }
- result.trunkPayloadId = parsedTrunkPayloadId.(Id)
-
- // parse branch payload id
- parsedBranchPayloadId, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return IdFromBytes(data) })
- if err != nil {
- return
- }
- result.branchPayloadId = parsedBranchPayloadId.(Id)
-
- // parse transfer
- parsedTransfer, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return transaction.FromBytes(data) })
- if err != nil {
- return
- }
- result.transaction = parsedTransfer.(*transaction.Transaction)
-
- // return the number of bytes we processed
- consumedBytes = marshalUtil.ReadOffset()
-
- // store bytes, so we don't have to marshal manually
- result.bytes = bytes[:consumedBytes]
-
return
}
@@ -207,22 +188,49 @@ func (payload *Payload) ObjectStorageValue() []byte {
return payload.Bytes()
}
-func (payload *Payload) UnmarshalObjectStorageValue(data []byte) (err error) {
- _, err, _ = FromBytes(data, payload)
+func (payload *Payload) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(data)
+
+ // read information that are required to identify the payload from the outside
+ _, err = marshalUtil.ReadUint32()
+ if err != nil {
+ return
+ }
+ _, err = marshalUtil.ReadUint32()
+ if err != nil {
+ return
+ }
+
+ // parse trunk payload id
+ if payload.trunkPayloadId, err = ParseId(marshalUtil); err != nil {
+ return
+ }
+ if payload.branchPayloadId, err = ParseId(marshalUtil); err != nil {
+ return
+ }
+ if payload.transaction, err = transaction.Parse(marshalUtil); err != nil {
+ return
+ }
+
+ // return the number of bytes we processed
+ consumedBytes = marshalUtil.ReadOffset()
+
+ // store bytes, so we don't have to marshal manually
+ payload.bytes = make([]byte, consumedBytes)
+ copy(payload.bytes, data[:consumedBytes])
return
}
func (payload *Payload) Unmarshal(data []byte) (err error) {
- _, err, _ = FromBytes(data, payload)
+ _, err, _ = FromBytes(data)
return
}
func init() {
payload.RegisterType(Type, func(data []byte) (payload payload.Payload, err error) {
- payload = &Payload{}
- err = payload.Unmarshal(data)
+ payload, err, _ = FromBytes(data)
return
})
diff --git a/packages/binary/valuetransfer/payload/payload_test.go b/packages/binary/valuetransfer/payload/payload_test.go
index 0dc219378c233b2cc8daeec57eebca4e7fa313b8..fc7b762aee51d6a3b414546d1835f4aac6d36f8c 100644
--- a/packages/binary/valuetransfer/payload/payload_test.go
+++ b/packages/binary/valuetransfer/payload/payload_test.go
@@ -7,8 +7,8 @@ import (
"github.com/stretchr/testify/assert"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/address"
"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/address/signaturescheme"
"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/balance"
diff --git a/packages/binary/valuetransfer/tangle/attachment.go b/packages/binary/valuetransfer/tangle/attachment.go
index 372d91eb8d03b78e75e92f213958be9eef7a7787..c7dcd5527dd54681e18f64806059aa3263bf4d43 100644
--- a/packages/binary/valuetransfer/tangle/attachment.go
+++ b/packages/binary/valuetransfer/tangle/attachment.go
@@ -71,13 +71,13 @@ func ParseAttachment(marshalUtil *marshalutil.MarshalUtil) (*Attachment, error)
// AttachmentFromStorageKey gets called when we restore an Attachment from the storage - it parses the key bytes and
// returns the new object.
-func AttachmentFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error) {
+func AttachmentFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error, int) {
result, err, _ := AttachmentFromBytes(keyBytes)
if err != nil {
- return nil, err
+ return nil, err, 0
}
- return result, nil
+ return result, nil, 0
}
// TransactionId returns the transaction id of this Attachment.
@@ -116,7 +116,7 @@ func (attachment *Attachment) ObjectStorageValue() (data []byte) {
// UnmarshalObjectStorageValue unmarshals the "content part" of an Attachment from a sequence of bytes. Since all of the information
// for this object are stored in its key, this method does nothing and is only required to conform with the interface.
-func (attachment *Attachment) UnmarshalObjectStorageValue(data []byte) (err error) {
+func (attachment *Attachment) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
return
}
diff --git a/packages/binary/valuetransfer/tangle/consumer.go b/packages/binary/valuetransfer/tangle/consumer.go
index e0a41212672f16dcc9e4a3f5bcf4f617d88eca92..9dadca65db17677ba70df2aed239817319aa32e5 100644
--- a/packages/binary/valuetransfer/tangle/consumer.go
+++ b/packages/binary/valuetransfer/tangle/consumer.go
@@ -115,7 +115,7 @@ func (consumer *Consumer) ObjectStorageValue() (data []byte) {
// UnmarshalObjectStorageValue unmarshals the "content part" of a Consumer from a sequence of bytes. Since all of the information
// for this object are stored in its key, this method does nothing and is only required to conform with the interface.
-func (consumer *Consumer) UnmarshalObjectStorageValue(data []byte) (err error) {
+func (consumer *Consumer) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
return
}
diff --git a/packages/binary/valuetransfer/tangle/missingoutput.go b/packages/binary/valuetransfer/tangle/missingoutput.go
index 628d4a68e0aa57b59f9fc173be9bf44175400112..6e5e05d5a67aa6724cf52a2d96b0a3a1f6aa1c6f 100644
--- a/packages/binary/valuetransfer/tangle/missingoutput.go
+++ b/packages/binary/valuetransfer/tangle/missingoutput.go
@@ -53,7 +53,7 @@ func MissingOutputFromBytes(bytes []byte, optionalTargetObject ...*MissingOutput
// MissingOutputFromStorageKey gets called when we restore a MissingOutput from the storage. The content will be
// unmarshaled by an external caller using the binary.ObjectStorageValue interface.
-func MissingOutputFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error) {
+func MissingOutputFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error, int) {
outputId, err, _ := transaction.OutputIdFromBytes(keyBytes)
if err != nil {
panic(err)
@@ -61,7 +61,7 @@ func MissingOutputFromStorageKey(keyBytes []byte) (objectstorage.StorableObject,
return &MissingOutput{
outputId: outputId,
- }, nil
+ }, nil, transaction.OutputIdLength
}
// Id returns the id of the Output that is missing.
@@ -97,8 +97,8 @@ func (missingOutput *MissingOutput) ObjectStorageValue() []byte {
// UnmarshalObjectStorageValue restores the values of a MissingOutput from a sequence of bytes using the encoding.BinaryUnmarshaler
// interface.
-func (missingOutput *MissingOutput) UnmarshalObjectStorageValue(data []byte) (err error) {
- _, err, _ = MissingOutputFromBytes(data, missingOutput)
+func (missingOutput *MissingOutput) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ _, err, consumedBytes = MissingOutputFromBytes(data, missingOutput)
return
}
diff --git a/packages/binary/valuetransfer/tangle/missingpayload.go b/packages/binary/valuetransfer/tangle/missingpayload.go
index 527147538538686db202c6a3bc07d9ccd3ad0196..395365a2c6d4705bf670707001b5d23c3c659fb7 100644
--- a/packages/binary/valuetransfer/tangle/missingpayload.go
+++ b/packages/binary/valuetransfer/tangle/missingpayload.go
@@ -54,8 +54,8 @@ func MissingPayloadFromBytes(bytes []byte, optionalTargetObject ...*MissingPaylo
// MissingPayloadFromStorageKey gets called when we restore an entry for a missing value transfer payload from the storage. The bytes and
// the content will be unmarshaled by an external caller using the binary.ObjectStorageValue interface.
-func MissingPayloadFromStorageKey([]byte) (objectstorage.StorableObject, error) {
- return &MissingPayload{}, nil
+func MissingPayloadFromStorageKey([]byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
+ return
}
// GetId returns the payload id, that is missing.
@@ -96,8 +96,8 @@ func (missingPayload *MissingPayload) ObjectStorageValue() (data []byte) {
}
// UnmarshalObjectStorageValue is required to match the encoding.BinaryUnmarshaler interface.
-func (missingPayload *MissingPayload) UnmarshalObjectStorageValue(data []byte) (err error) {
- _, err, _ = MissingPayloadFromBytes(data, missingPayload)
+func (missingPayload *MissingPayload) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ _, err, consumedBytes = MissingPayloadFromBytes(data, missingPayload)
return
}
diff --git a/packages/binary/valuetransfer/tangle/payloadapprover.go b/packages/binary/valuetransfer/tangle/payloadapprover.go
index f0b34f1d413b739d683d1ddd9af34f1439d5e8f8..4664cb16a3aa51a8d600be49b73b03d7490401a0 100644
--- a/packages/binary/valuetransfer/tangle/payloadapprover.go
+++ b/packages/binary/valuetransfer/tangle/payloadapprover.go
@@ -34,25 +34,27 @@ func NewPayloadApprover(referencedPayload payload.Id, approvingPayload payload.I
// PayloadApproverFromStorageKey get's called when we restore transaction metadata from the storage.
// In contrast to other database models, it unmarshals the information from the key and does not use the UnmarshalObjectStorageValue
// method.
-func PayloadApproverFromStorageKey(idBytes []byte) (objectstorage.StorableObject, error) {
+func PayloadApproverFromStorageKey(idBytes []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
marshalUtil := marshalutil.New(idBytes)
referencedPayloadId, err := payload.ParseId(marshalUtil)
if err != nil {
- return nil, err
+ return
}
approvingPayloadId, err := payload.ParseId(marshalUtil)
if err != nil {
- return nil, err
+ return
}
- result := &PayloadApprover{
+ result = &PayloadApprover{
referencedPayloadId: referencedPayloadId,
approvingPayloadId: approvingPayloadId,
storageKey: marshalUtil.Bytes(true),
}
- return result, nil
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
}
// GetApprovingPayloadId returns the id of the approving payload.
@@ -74,8 +76,8 @@ func (payloadApprover *PayloadApprover) ObjectStorageValue() (data []byte) {
// UnmarshalObjectStorageValue is implemented to conform with the StorableObject interface, but it does not really do
// anything, since all of the information about an approver are stored in the "key".
-func (payloadApprover *PayloadApprover) UnmarshalObjectStorageValue(data []byte) error {
- return nil
+func (payloadApprover *PayloadApprover) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ return
}
// Update is disabled and panics if it ever gets called - updates are supposed to happen through the setters.
diff --git a/packages/binary/valuetransfer/tangle/payloadmetadata.go b/packages/binary/valuetransfer/tangle/payloadmetadata.go
index a73dec84367a85686d38cfa2c122ccfe43cbb197..4308e595612350142b745f365c96441ccc710bd3 100644
--- a/packages/binary/valuetransfer/tangle/payloadmetadata.go
+++ b/packages/binary/valuetransfer/tangle/payloadmetadata.go
@@ -62,15 +62,16 @@ func PayloadMetadataFromBytes(bytes []byte, optionalTargetObject ...*PayloadMeta
// PayloadMetadataFromStorageKey gets called when we restore transaction metadata from the storage. The bytes and the content will be
// unmarshaled by an external caller using the binary.ObjectStorageValue interface.
-func PayloadMetadataFromStorageKey(id []byte) (objectstorage.StorableObject, error) {
- result := &PayloadMetadata{}
+func PayloadMetadataFromStorageKey(id []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
+ result = &PayloadMetadata{}
- var err error
- if result.payloadId, err = payload.ParseId(marshalutil.New(id)); err != nil {
- return nil, err
+ marshalUtil := marshalutil.New(id)
+ if result.(*PayloadMetadata).payloadId, err = payload.ParseId(marshalUtil); err != nil {
+ return
}
+ consumedBytes = marshalUtil.ReadOffset()
- return result, nil
+ return
}
// ParsePayloadMetadata is a wrapper for simplified unmarshaling in a byte stream using the marshalUtil package.
@@ -125,7 +126,7 @@ func (payloadMetadata *PayloadMetadata) SetSolid(solid bool) (modified bool) {
return
}
-// GetSoldificationTime returns the time when the payload was marked to be solid.
+// SoldificationTime returns the time when the payload was marked to be solid.
func (payloadMetadata *PayloadMetadata) GetSoldificationTime() time.Time {
payloadMetadata.solidificationTimeMutex.RLock()
defer payloadMetadata.solidificationTimeMutex.RUnlock()
@@ -171,8 +172,8 @@ func (payloadMetadata *PayloadMetadata) ObjectStorageValue() []byte {
}
// UnmarshalObjectStorageValue is required to match the encoding.BinaryUnmarshaler interface.
-func (payloadMetadata *PayloadMetadata) UnmarshalObjectStorageValue(data []byte) (err error) {
- _, err, _ = PayloadMetadataFromBytes(data, payloadMetadata)
+func (payloadMetadata *PayloadMetadata) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ _, err, consumedBytes = PayloadMetadataFromBytes(data, payloadMetadata)
return
}
diff --git a/packages/binary/valuetransfer/tangle/tangle.go b/packages/binary/valuetransfer/tangle/tangle.go
index bea66a480481a8ac931c68b0c4b2e58b9de15274..01b00b5050ab4c3a8561f7b626a4f636b3d19282 100644
--- a/packages/binary/valuetransfer/tangle/tangle.go
+++ b/packages/binary/valuetransfer/tangle/tangle.go
@@ -46,7 +46,7 @@ func New(badgerInstance *badger.DB, storageId []byte) (result *Tangle) {
approverStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.ValueTransferApprover...), PayloadApproverFromStorageKey, objectstorage.CacheTime(time.Second), objectstorage.PartitionKey(payload.IdLength, payload.IdLength), objectstorage.KeysOnly(true)),
// transaction related storage
- transactionOutputMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleApprovers...), transaction.OutputFromStorageKey, objectstorage.CacheTime(time.Second)),
+ transactionOutputMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0Approvers...), transaction.OutputFromStorageKey, objectstorage.CacheTime(time.Second)),
missingOutputStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.ValueTransferMissingPayload...), MissingOutputFromStorageKey, objectstorage.CacheTime(time.Second)),
consumerStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.ValueTransferConsumer...), transaction.OutputFromStorageKey, objectstorage.CacheTime(time.Second)),
diff --git a/packages/binary/valuetransfer/tangle/transactionmetadata.go b/packages/binary/valuetransfer/tangle/transactionmetadata.go
index a920bce1c806b8f5ed2de036bb62e89853e8d7c9..98a36a7420195b7625f21ce93a3594c6b438eb6e 100644
--- a/packages/binary/valuetransfer/tangle/transactionmetadata.go
+++ b/packages/binary/valuetransfer/tangle/transactionmetadata.go
@@ -171,8 +171,8 @@ func (transactionMetadata *TransactionMetadata) ObjectStorageValue() []byte {
// UnmarshalObjectStorageValue restores the values of a TransactionMetadata object from a sequence of bytes and matches the
// encoding.BinaryUnmarshaler interface.
-func (transactionMetadata *TransactionMetadata) UnmarshalObjectStorageValue(data []byte) (err error) {
- _, err, _ = TransactionMetadataFromBytes(data, transactionMetadata)
+func (transactionMetadata *TransactionMetadata) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ _, err, consumedBytes = TransactionMetadataFromBytes(data, transactionMetadata)
return
}
diff --git a/packages/binary/valuetransfer/tangle/transactionoutputmetadata.go b/packages/binary/valuetransfer/tangle/transactionoutputmetadata.go
index 75ebbb5aff9efb1b6d0904164316785d9eafa474..a4c7e97684cdb1cd3defa5fcf04622f059869f5d 100644
--- a/packages/binary/valuetransfer/tangle/transactionoutputmetadata.go
+++ b/packages/binary/valuetransfer/tangle/transactionoutputmetadata.go
@@ -165,8 +165,8 @@ func (transactionOutputMetadata *TransactionOutputMetadata) ObjectStorageValue()
// UnmarshalObjectStorageValue restores the values of a TransactionOutputMetadata object from a sequence of bytes and matches the
// encoding.BinaryUnmarshaler interface.
-func (transactionOutputMetadata *TransactionOutputMetadata) UnmarshalObjectStorageValue(data []byte) (err error) {
- _, err, _ = TransactionOutputMetadataFromBytes(data, transactionOutputMetadata)
+func (transactionOutputMetadata *TransactionOutputMetadata) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ _, err, consumedBytes = TransactionOutputMetadataFromBytes(data, transactionOutputMetadata)
return
}
diff --git a/packages/binary/valuetransfer/transaction/output.go b/packages/binary/valuetransfer/transaction/output.go
index 270e73fcf940c55fdd632c6370673f3a52df33a3..a5d0aab1908952bc29b8634f666c083579504fce 100644
--- a/packages/binary/valuetransfer/transaction/output.go
+++ b/packages/binary/valuetransfer/transaction/output.go
@@ -83,10 +83,10 @@ func OutputFromBytes(bytes []byte, optionalTargetObject ...*Output) (result *Out
// OutputFromStorageKey get's called when we restore a Output from the storage.
// In contrast to other database models, it unmarshals some information from the key so we simply store the key before
// it gets handed over to UnmarshalObjectStorageValue (by the ObjectStorage).
-func OutputFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error) {
+func OutputFromStorageKey(keyBytes []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
return &Output{
storageKey: keyBytes[:OutputIdLength],
- }, nil
+ }, nil, OutputIdLength
}
// Address returns the address that this output belongs to.
@@ -120,7 +120,7 @@ func (output *Output) ObjectStorageValue() (data []byte) {
balanceCount := len(output.balances)
// initialize helper
- marshalUtil := marshalutil.New(4 + balanceCount*balance.Length)
+ marshalUtil := marshalutil.New(marshalutil.BOOL_SIZE + marshalutil.TIME_SIZE + marshalutil.UINT32_SIZE + balanceCount*balance.Length)
marshalUtil.WriteBool(output.solid)
marshalUtil.WriteTime(output.solidSince)
marshalUtil.WriteUint32(uint32(balanceCount))
@@ -133,8 +133,8 @@ func (output *Output) ObjectStorageValue() (data []byte) {
// UnmarshalObjectStorageValue restores a Output from a serialized version in the ObjectStorage with parts of the object
// being stored in its key rather than the content of the database to reduce storage requirements.
-func (output *Output) UnmarshalObjectStorageValue(data []byte) (err error) {
- _, err, _ = OutputFromBytes(marshalutil.New(output.storageKey).WriteBytes(data).Bytes(), output)
+func (output *Output) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+ _, err, consumedBytes = OutputFromBytes(marshalutil.New(output.storageKey).WriteBytes(data).Bytes(), output)
return
}
diff --git a/packages/binary/valuetransfer/transaction/transaction.go b/packages/binary/valuetransfer/transaction/transaction.go
index 20e1c2a440c9d849691317c810f4dc2414a59762..0d685c6055cddad72ce21c3897e35c4302744a0a 100644
--- a/packages/binary/valuetransfer/transaction/transaction.go
+++ b/packages/binary/valuetransfer/transaction/transaction.go
@@ -45,6 +45,14 @@ func New(inputs *Inputs, outputs *Outputs) *Transaction {
}
func FromBytes(bytes []byte, optionalTargetObject ...*Transaction) (result *Transaction, err error, consumedBytes int) {
+ marshalUtil := marshalutil.New(bytes)
+ result, err = Parse(marshalUtil, optionalTargetObject...)
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+func FromStorageKey(key []byte, optionalTargetObject ...*Transaction) (result objectstorage.StorableObject, err error, consumedBytes int) {
// determine the target object that will hold the unmarshaled information
switch len(optionalTargetObject) {
case 0:
@@ -52,63 +60,41 @@ func FromBytes(bytes []byte, optionalTargetObject ...*Transaction) (result *Tran
case 1:
result = optionalTargetObject[0]
default:
- panic("too many arguments in call to OutputFromBytes")
+ panic("too many arguments in call to FromStorageKey")
}
- // initialize helper
- marshalUtil := marshalutil.New(bytes)
-
- // unmarshal inputs
- parsedInputs, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return InputsFromBytes(data) })
+ marshalUtil := marshalutil.New(key)
+ id, err := ParseId(marshalUtil)
if err != nil {
return
}
- result.inputs = parsedInputs.(*Inputs)
+ result.(*Transaction).id = &id
- // unmarshal outputs
- parsedOutputs, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return OutputsFromBytes(data) })
- if err != nil {
- return
+ return
+}
+
+func Parse(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Transaction) (result *Transaction, err error) {
+ // determine the target object that will hold the unmarshaled information
+ switch len(optionalTargetObject) {
+ case 0:
+ result = &Transaction{}
+ case 1:
+ result = optionalTargetObject[0]
+ default:
+ panic("too many arguments in call to Parse")
}
- result.outputs = parsedOutputs.(*Outputs)
- // store essence bytes
- essenceBytesCount := marshalUtil.ReadOffset()
- result.essenceBytes = make([]byte, essenceBytesCount)
- copy(result.essenceBytes, bytes[:essenceBytesCount])
+ if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+ parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
- // unmarshal outputs
- parsedSignatures, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return SignaturesFromBytes(data) })
- if err != nil {
+ return
+ }); err != nil {
return
}
- result.signatures = parsedSignatures.(*Signatures)
-
- // store signature bytes
- signatureBytesCount := marshalUtil.ReadOffset() - essenceBytesCount
- result.signatureBytes = make([]byte, signatureBytesCount)
- copy(result.signatureBytes, bytes[essenceBytesCount:essenceBytesCount+signatureBytesCount])
-
- // return the number of bytes we processed
- consumedBytes = essenceBytesCount + signatureBytesCount
-
- // store bytes, so we don't have to marshal manually
- result.bytes = bytes[:consumedBytes]
return
}
-func FromStorage(key []byte) *Transaction {
- id, err, _ := IdFromBytes(key)
- if err != nil {
- panic(err)
- }
-
- return &Transaction{
- id: &id,
- }
-}
-
func (transaction *Transaction) Id() Id {
// acquire lock for reading id
transaction.idMutex.RLock()
@@ -281,9 +267,7 @@ func (transaction *Transaction) String() string {
var _ objectstorage.StorableObject = &Transaction{}
func (transaction *Transaction) ObjectStorageKey() []byte {
- id := transaction.Id()
-
- return id[:]
+ return transaction.Id().Bytes()
}
func (transaction *Transaction) Update(other objectstorage.StorableObject) {
@@ -295,8 +279,46 @@ func (transaction *Transaction) ObjectStorageValue() []byte {
return transaction.Bytes()
}
-func (transaction *Transaction) UnmarshalObjectStorageValue(bytes []byte) (err error) {
- _, err, _ = FromBytes(bytes, transaction)
+func (transaction *Transaction) UnmarshalObjectStorageValue(bytes []byte) (err error, consumedBytes int) {
+ // initialize helper
+ marshalUtil := marshalutil.New(bytes)
+
+ // unmarshal inputs
+ parsedInputs, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return InputsFromBytes(data) })
+ if err != nil {
+ return
+ }
+ transaction.inputs = parsedInputs.(*Inputs)
+
+ // unmarshal outputs
+ parsedOutputs, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return OutputsFromBytes(data) })
+ if err != nil {
+ return
+ }
+ transaction.outputs = parsedOutputs.(*Outputs)
+
+ // store essence bytes
+ essenceBytesCount := marshalUtil.ReadOffset()
+ transaction.essenceBytes = make([]byte, essenceBytesCount)
+ copy(transaction.essenceBytes, bytes[:essenceBytesCount])
+
+ // unmarshal outputs
+ parsedSignatures, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return SignaturesFromBytes(data) })
+ if err != nil {
+ return
+ }
+ transaction.signatures = parsedSignatures.(*Signatures)
+
+ // store signature bytes
+ signatureBytesCount := marshalUtil.ReadOffset() - essenceBytesCount
+ transaction.signatureBytes = make([]byte, signatureBytesCount)
+ copy(transaction.signatureBytes, bytes[essenceBytesCount:essenceBytesCount+signatureBytesCount])
+
+ // return the number of bytes we processed
+ consumedBytes = essenceBytesCount + signatureBytesCount
+
+ // store bytes, so we don't have to marshal manually
+ transaction.bytes = bytes[:consumedBytes]
return
}
diff --git a/packages/gossip/manager.go b/packages/gossip/manager.go
index d3d6ccba7be2b5275b2bfde6b7f8250c0b0f6ba0..b8b676a91b5c4ff10c70fdd98675fd440b50f0ad 100644
--- a/packages/gossip/manager.go
+++ b/packages/gossip/manager.go
@@ -6,7 +6,7 @@ import (
"net"
"sync"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
"github.com/golang/protobuf/proto"
pb "github.com/iotaledger/goshimmer/packages/gossip/proto"
@@ -238,7 +238,7 @@ func (m *Manager) handlePacket(data []byte, p *peer.Peer) error {
switch pb.MType(data[0]) {
- // Incoming Transaction
+ // Incoming Message
case pb.MTransaction:
msg := new(pb.Transaction)
if err := proto.Unmarshal(data[1:], msg); err != nil {
@@ -247,7 +247,7 @@ func (m *Manager) handlePacket(data []byte, p *peer.Peer) error {
m.log.Debugw("received message", "type", "TRANSACTION", "id", p.ID())
Events.TransactionReceived.Trigger(&TransactionReceivedEvent{Data: msg.GetData(), Peer: p})
- // Incoming Transaction request
+ // Incoming Message request
case pb.MTransactionRequest:
msg := new(pb.TransactionRequest)
diff --git a/packages/gossip/manager_test.go b/packages/gossip/manager_test.go
index 220f55134afb7dffb6c5d7eff0a5ac800af5ccca..ab0e5b8288c01fe4ac2348abfdfdcb9ea1d09c32 100644
--- a/packages/gossip/manager_test.go
+++ b/packages/gossip/manager_test.go
@@ -7,9 +7,6 @@ import (
"time"
"github.com/golang/protobuf/proto"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- pb "github.com/iotaledger/goshimmer/packages/gossip/proto"
- "github.com/iotaledger/goshimmer/packages/gossip/server"
"github.com/iotaledger/hive.go/autopeering/peer"
"github.com/iotaledger/hive.go/autopeering/peer/service"
"github.com/iotaledger/hive.go/database/mapdb"
@@ -18,6 +15,10 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
+
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ pb "github.com/iotaledger/goshimmer/packages/gossip/proto"
+ "github.com/iotaledger/goshimmer/packages/gossip/server"
)
const graceTime = 10 * time.Millisecond
diff --git a/pluginmgr/core/plugins.go b/pluginmgr/core/plugins.go
index c7faaaf75c525471eb3df8a5847cba45c66aa455..8453fb5e43da50ac3a5aab550daea470bce30def 100644
--- a/pluginmgr/core/plugins.go
+++ b/pluginmgr/core/plugins.go
@@ -9,9 +9,9 @@ import (
"github.com/iotaledger/goshimmer/plugins/gossip"
"github.com/iotaledger/goshimmer/plugins/gracefulshutdown"
"github.com/iotaledger/goshimmer/plugins/logger"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
"github.com/iotaledger/goshimmer/plugins/metrics"
"github.com/iotaledger/goshimmer/plugins/portcheck"
- "github.com/iotaledger/goshimmer/plugins/tangle"
"github.com/iotaledger/hive.go/node"
)
@@ -23,7 +23,7 @@ var PLUGINS = node.Plugins(
portcheck.PLUGIN,
database.PLUGIN,
autopeering.PLUGIN,
- tangle.PLUGIN,
+ messagelayer.PLUGIN,
gossip.PLUGIN,
gracefulshutdown.PLUGIN,
metrics.PLUGIN,
diff --git a/plugins/gossip/gossip.go b/plugins/gossip/gossip.go
index d611032d64f0dc8890189f819f27cefb9ab0c330..4d71f3a459fc7260bfd0b44dc97d086e9acc28dd 100644
--- a/plugins/gossip/gossip.go
+++ b/plugins/gossip/gossip.go
@@ -9,12 +9,12 @@ import (
"github.com/iotaledger/hive.go/logger"
"github.com/iotaledger/hive.go/netutil"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
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/config"
- "github.com/iotaledger/goshimmer/plugins/tangle"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
)
var (
@@ -71,13 +71,13 @@ func start(shutdownSignal <-chan struct{}) {
log.Info("Stopping " + name + " ...")
}
-func getTransaction(transactionId message.Id) (bytes []byte, err error) {
- log.Debugw("get tx from db", "id", transactionId.String())
+func getTransaction(messageId message.Id) (bytes []byte, err error) {
+ log.Debugw("get tx from db", "id", messageId.String())
- if !tangle.Instance.GetTransaction(transactionId).Consume(func(transaction *message.Transaction) {
- bytes = transaction.Bytes()
+ if !messagelayer.Tangle.Message(messageId).Consume(func(message *message.Message) {
+ bytes = message.Bytes()
}) {
- err = fmt.Errorf("transaction not found: hash=%s", transactionId)
+ err = fmt.Errorf("transaction not found: hash=%s", messageId)
}
return
diff --git a/plugins/gossip/plugin.go b/plugins/gossip/plugin.go
index ceca12f9e3a1e12300f408d8e2595b25aaa8eaf2..37c4f064fcbe33abfe1d33c6ef194f60dc8ef1ca 100644
--- a/plugins/gossip/plugin.go
+++ b/plugins/gossip/plugin.go
@@ -8,11 +8,11 @@ import (
"github.com/iotaledger/hive.go/logger"
"github.com/iotaledger/hive.go/node"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/tangle"
"github.com/iotaledger/goshimmer/packages/gossip"
"github.com/iotaledger/goshimmer/packages/shutdown"
- "github.com/iotaledger/goshimmer/plugins/tangle"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
)
const name = "Gossip" // name of the plugin
@@ -73,20 +73,20 @@ func configureEvents() {
// configure flow of incoming transactions
gossip.Events.TransactionReceived.Attach(events.NewClosure(func(event *gossip.TransactionReceivedEvent) {
- tangle.TransactionParser.Parse(event.Data, event.Peer)
+ messagelayer.TransactionParser.Parse(event.Data, event.Peer)
}))
// configure flow of outgoing transactions (gossip on solidification)
- tangle.Instance.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, transactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+ messagelayer.Tangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, transactionMetadata *tangle.CachedMessageMetadata) {
transactionMetadata.Release()
- cachedTransaction.Consume(func(transaction *message.Transaction) {
+ cachedTransaction.Consume(func(transaction *message.Message) {
mgr.SendTransaction(transaction.Bytes())
})
}))
// request missing transactions
- tangle.TransactionRequester.Events.SendRequest.Attach(events.NewClosure(func(transactionId message.Id) {
+ messagelayer.TransactionRequester.Events.SendRequest.Attach(events.NewClosure(func(transactionId message.Id) {
mgr.RequestTransaction(transactionId[:])
}))
}
diff --git a/plugins/graph/plugin.go b/plugins/graph/plugin.go
index c1aedcb1988e963fb74c31d51fc944632f2ba2a9..f71c4ad692e396df2b610e87d1ddbdab51a0c3ee 100644
--- a/plugins/graph/plugin.go
+++ b/plugins/graph/plugin.go
@@ -6,7 +6,7 @@ import (
"time"
"github.com/iotaledger/goshimmer/plugins/config"
- "github.com/iotaledger/goshimmer/plugins/tangle"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
"golang.org/x/net/context"
@@ -102,10 +102,10 @@ func run(*node.Plugin) {
daemon.BackgroundWorker("Graph[NewTxWorker]", func(shutdownSignal <-chan struct{}) {
log.Info("Starting Graph[NewTxWorker] ... done")
- tangle.Instance.Events.TransactionAttached.Attach(notifyNewTx)
+ messagelayer.Tangle.Events.TransactionAttached.Attach(notifyNewTx)
newTxWorkerPool.Start()
<-shutdownSignal
- tangle.Instance.Events.TransactionAttached.Detach(notifyNewTx)
+ messagelayer.Tangle.Events.TransactionAttached.Detach(notifyNewTx)
newTxWorkerPool.Stop()
log.Info("Stopping Graph[NewTxWorker] ... done")
}, shutdown.ShutdownPriorityGraph)
diff --git a/plugins/tangle/plugin.go b/plugins/messagelayer/plugin.go
similarity index 54%
rename from plugins/tangle/plugin.go
rename to plugins/messagelayer/plugin.go
index 0b3f156dc0d154a602a032cd5ddd4c1e89b41449..51efe3915a27e85c37a1ca23b914fb45a127590d 100644
--- a/plugins/tangle/plugin.go
+++ b/plugins/messagelayer/plugin.go
@@ -1,15 +1,14 @@
-package tangle
+package messagelayer
import (
"github.com/iotaledger/hive.go/autopeering/peer"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/tangle"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/tipselector"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/transactionparser"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/transactionrequester"
"github.com/iotaledger/goshimmer/packages/binary/storageprefix"
- "github.com/iotaledger/goshimmer/packages/binary/tangle"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/tipselector"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/transactionparser"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/transactionrequester"
"github.com/iotaledger/goshimmer/packages/database"
"github.com/iotaledger/goshimmer/packages/shutdown"
@@ -27,7 +26,7 @@ var TransactionRequester *transactionrequester.TransactionRequester
var TipSelector *tipselector.TipSelector
-var Instance *tangle.Tangle
+var Tangle *tangle.Tangle
var log *logger.Logger
@@ -38,27 +37,27 @@ func configure(*node.Plugin) {
TransactionParser = transactionparser.New()
TransactionRequester = transactionrequester.New()
TipSelector = tipselector.New()
- Instance = tangle.New(database.GetBadgerInstance(), storageprefix.MainNet)
+ Tangle = tangle.New(database.GetBadgerInstance(), storageprefix.MainNet)
// setup TransactionParser
- TransactionParser.Events.TransactionParsed.Attach(events.NewClosure(func(transaction *message.Transaction, peer *peer.Peer) {
+ TransactionParser.Events.TransactionParsed.Attach(events.NewClosure(func(transaction *message.Message, peer *peer.Peer) {
// TODO: ADD PEER
- Instance.AttachTransaction(transaction)
+ Tangle.AttachMessage(transaction)
}))
// setup TransactionRequester
- Instance.Events.TransactionMissing.Attach(events.NewClosure(TransactionRequester.ScheduleRequest))
- Instance.Events.MissingTransactionReceived.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+ Tangle.Events.TransactionMissing.Attach(events.NewClosure(TransactionRequester.ScheduleRequest))
+ Tangle.Events.MissingTransactionReceived.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *tangle.CachedMessageMetadata) {
cachedTransactionMetadata.Release()
- cachedTransaction.Consume(func(transaction *message.Transaction) {
+ cachedTransaction.Consume(func(transaction *message.Message) {
TransactionRequester.StopRequest(transaction.GetId())
})
}))
// setup TipSelector
- Instance.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+ Tangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *tangle.CachedMessageMetadata) {
cachedTransactionMetadata.Release()
cachedTransaction.Consume(TipSelector.AddTip)
@@ -70,6 +69,6 @@ func run(*node.Plugin) {
<-shutdownSignal
TransactionParser.Shutdown()
- Instance.Shutdown()
+ Tangle.Shutdown()
}, shutdown.ShutdownPriorityTangle)
}
diff --git a/plugins/metrics/plugin.go b/plugins/metrics/plugin.go
index 501e05f9a2c41e36ac6838321afc629205dd0e4d..a07160af3d5e560cbfe12139151ed87decad0512 100644
--- a/plugins/metrics/plugin.go
+++ b/plugins/metrics/plugin.go
@@ -8,17 +8,17 @@ import (
"github.com/iotaledger/hive.go/node"
"github.com/iotaledger/hive.go/timeutil"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/tangle"
"github.com/iotaledger/goshimmer/packages/shutdown"
- "github.com/iotaledger/goshimmer/plugins/tangle"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
)
var PLUGIN = node.NewPlugin("Metrics", node.Enabled, configure, run)
func configure(plugin *node.Plugin) {
// increase received TPS counter whenever we receive a new transaction
- tangle.Instance.Events.TransactionAttached.Attach(events.NewClosure(func(transaction *message.CachedTransaction, metadata *transactionmetadata.CachedTransactionMetadata) {
+ messagelayer.Tangle.Events.TransactionAttached.Attach(events.NewClosure(func(transaction *message.CachedMessage, metadata *tangle.CachedMessageMetadata) {
transaction.Release()
metadata.Release()
diff --git a/plugins/spa/explorer_routes.go b/plugins/spa/explorer_routes.go
index 7be338682180c3a68c11ce67f55b7b995c312537..448a57e922624640529ca1d7edbb95073ff643ce 100644
--- a/plugins/spa/explorer_routes.go
+++ b/plugins/spa/explorer_routes.go
@@ -4,8 +4,8 @@ import (
"net/http"
"sync"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/plugins/tangle"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
"github.com/labstack/echo"
"github.com/pkg/errors"
@@ -23,10 +23,10 @@ type ExplorerTx struct {
MWM int `json:"mwm"`
}
-func createExplorerTx(tx *message.Transaction) (*ExplorerTx, error) {
+func createExplorerTx(tx *message.Message) (*ExplorerTx, error) {
transactionId := tx.GetId()
- txMetadata := tangle.Instance.GetTransactionMetadata(transactionId)
+ txMetadata := messagelayer.Tangle.GetTransactionMetadata(transactionId)
t := &ExplorerTx{
Hash: transactionId.String(),
@@ -116,7 +116,7 @@ func setupExplorerRoutes(routeGroup *echo.Group) {
}
func findTransaction(transactionId message.Id) (explorerTx *ExplorerTx, err error) {
- if !tangle.Instance.GetTransaction(transactionId).Consume(func(transaction *message.Transaction) {
+ if !messagelayer.Tangle.GetTransaction(transactionId).Consume(func(transaction *message.Message) {
explorerTx, err = createExplorerTx(transaction)
}) {
err = errors.Wrapf(ErrNotFound, "tx hash: %s", transactionId.String())
diff --git a/plugins/spa/livefeed.go b/plugins/spa/livefeed.go
index adea985e1823779f4956d5ff7b08227cdd2dee7c..34851c6f03a583705c3cb6bd82e4fd12ea444a65 100644
--- a/plugins/spa/livefeed.go
+++ b/plugins/spa/livefeed.go
@@ -7,10 +7,10 @@ import (
"github.com/iotaledger/hive.go/events"
"github.com/iotaledger/hive.go/workerpool"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/tangle"
"github.com/iotaledger/goshimmer/packages/shutdown"
- "github.com/iotaledger/goshimmer/plugins/tangle"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
)
var liveFeedWorkerCount = 1
@@ -19,7 +19,7 @@ var liveFeedWorkerPool *workerpool.WorkerPool
func configureLiveFeed() {
liveFeedWorkerPool = workerpool.New(func(task workerpool.Task) {
- task.Param(0).(*message.CachedTransaction).Consume(func(transaction *message.Transaction) {
+ task.Param(0).(*message.CachedMessage).Consume(func(transaction *message.Message) {
sendToAllWSClient(&msg{MsgTypeTx, &tx{transaction.GetId().String(), 0}})
})
@@ -29,7 +29,7 @@ func configureLiveFeed() {
func runLiveFeed() {
newTxRateLimiter := time.NewTicker(time.Second / 10)
- notifyNewTx := events.NewClosure(func(tx *message.CachedTransaction, metadata *transactionmetadata.CachedTransactionMetadata) {
+ notifyNewTx := events.NewClosure(func(tx *message.CachedMessage, metadata *tangle.CachedMessageMetadata) {
metadata.Release()
select {
@@ -41,11 +41,11 @@ func runLiveFeed() {
})
daemon.BackgroundWorker("SPA[TxUpdater]", func(shutdownSignal <-chan struct{}) {
- tangle.Instance.Events.TransactionAttached.Attach(notifyNewTx)
+ messagelayer.Tangle.Events.TransactionAttached.Attach(notifyNewTx)
liveFeedWorkerPool.Start()
<-shutdownSignal
log.Info("Stopping SPA[TxUpdater] ...")
- tangle.Instance.Events.TransactionAttached.Detach(notifyNewTx)
+ messagelayer.Tangle.Events.TransactionAttached.Detach(notifyNewTx)
newTxRateLimiter.Stop()
liveFeedWorkerPool.Stop()
log.Info("Stopping SPA[TxUpdater] ... done")
diff --git a/plugins/webapi/gtta/plugin.go b/plugins/webapi/gtta/plugin.go
index ebebea7b8acf07d9f3d1af755c218c2c55e57644..6ecd48a8f756956a22dbdb6028917c7271b34e5d 100644
--- a/plugins/webapi/gtta/plugin.go
+++ b/plugins/webapi/gtta/plugin.go
@@ -3,11 +3,12 @@ package gtta
import (
"net/http"
- "github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
- "github.com/iotaledger/goshimmer/plugins/tangle"
- "github.com/iotaledger/goshimmer/plugins/webapi"
"github.com/iotaledger/hive.go/node"
"github.com/labstack/echo"
+
+ "github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
+ "github.com/iotaledger/goshimmer/plugins/webapi"
)
var PLUGIN = node.NewPlugin("WebAPI GTTA Endpoint", node.Disabled, func(plugin *node.Plugin) {
@@ -15,7 +16,7 @@ var PLUGIN = node.NewPlugin("WebAPI GTTA Endpoint", node.Disabled, func(plugin *
})
func Handler(c echo.Context) error {
- trunkTransactionId, branchTransactionId := tangle.TipSelector.GetTips()
+ trunkTransactionId, branchTransactionId := messagelayer.TipSelector.GetTips()
return c.JSON(http.StatusOK, Response{
TrunkTransaction: trunkTransactionId,
diff --git a/plugins/webapi/spammer/plugin.go b/plugins/webapi/spammer/plugin.go
index 0b827a85c9b82b59053b043948dff098bb1d8300..12de5fd2e719266902cd17374d4c086edae9ebd6 100644
--- a/plugins/webapi/spammer/plugin.go
+++ b/plugins/webapi/spammer/plugin.go
@@ -5,7 +5,7 @@ import (
"github.com/iotaledger/goshimmer/packages/binary/spammer"
"github.com/iotaledger/goshimmer/packages/shutdown"
- "github.com/iotaledger/goshimmer/plugins/tangle"
+ "github.com/iotaledger/goshimmer/plugins/messagelayer"
"github.com/iotaledger/goshimmer/plugins/webapi"
"github.com/iotaledger/hive.go/node"
@@ -16,7 +16,7 @@ var transactionSpammer *spammer.Spammer
var PLUGIN = node.NewPlugin("Spammer", node.Disabled, configure, run)
func configure(plugin *node.Plugin) {
- transactionSpammer = spammer.New(tangle.TransactionParser, tangle.TipSelector)
+ transactionSpammer = spammer.New(messagelayer.TransactionParser, messagelayer.TipSelector)
webapi.Server.GET("spammer", handleRequest)
}