Skip to content
Snippets Groups Projects
Commit 33cb0e94 authored by Hans Moog's avatar Hans Moog
Browse files

Feat: added solidification login

parent 8ac150ef
No related branches found
No related tags found
No related merge requests found
Showing with 305 additions and 180 deletions
......@@ -15,7 +15,7 @@ require (
github.com/golang/protobuf v1.3.2 // indirect
github.com/google/open-location-code/go v0.0.0-20190903173953-119bc96a3a51
github.com/gorilla/websocket v1.4.1
github.com/iotaledger/hive.go v0.0.0-20200101211541-ea7950f4c2f2
github.com/iotaledger/hive.go v0.0.0-20200106003337-d78637b86bf2
github.com/iotaledger/iota.go v1.0.0-beta.9
github.com/kr/text v0.1.0
github.com/labstack/echo v3.3.10+incompatible
......
......@@ -101,6 +101,10 @@ github.com/iotaledger/hive.go v0.0.0-20200101185538-ae70241fee7f h1:vxfLVJOsHHEb
github.com/iotaledger/hive.go v0.0.0-20200101185538-ae70241fee7f/go.mod h1:vrZrvGaWT1o5kz3Jj2B/PcUtqsFzZnLWrO3zEsGSuwk=
github.com/iotaledger/hive.go v0.0.0-20200101211541-ea7950f4c2f2 h1:S84ohGcHKq6NFOY77HUXLvqYfOveJhzzphSeimTUtTw=
github.com/iotaledger/hive.go v0.0.0-20200101211541-ea7950f4c2f2/go.mod h1:vrZrvGaWT1o5kz3Jj2B/PcUtqsFzZnLWrO3zEsGSuwk=
github.com/iotaledger/hive.go v0.0.0-20200105155739-b36b4405762f h1:HqEFrjhbUB4uAOl9a9tTj78hYZ2bQLP9qLUlYwanPPY=
github.com/iotaledger/hive.go v0.0.0-20200105155739-b36b4405762f/go.mod h1:vrZrvGaWT1o5kz3Jj2B/PcUtqsFzZnLWrO3zEsGSuwk=
github.com/iotaledger/hive.go v0.0.0-20200106003337-d78637b86bf2 h1:HBQKEP6PnaEhG7j3HNjZTkpALvek8QYPeoJXyDzBDpo=
github.com/iotaledger/hive.go v0.0.0-20200106003337-d78637b86bf2/go.mod h1:vrZrvGaWT1o5kz3Jj2B/PcUtqsFzZnLWrO3zEsGSuwk=
github.com/iotaledger/iota.go v1.0.0-beta.9 h1:c654s9pkdhMBkABUvWg+6k91MEBbdtmZXP1xDfQpajg=
github.com/iotaledger/iota.go v1.0.0-beta.9/go.mod h1:F6WBmYd98mVjAmmPVYhnxg8NNIWCjjH8VWT9qvv3Rc8=
github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
......
package approvers
import (
"github.com/iotaledger/hive.go/objectstorage"
)
type CachedApprovers struct {
*objectstorage.CachedObject
}
func (cachedObject *CachedApprovers) Unwrap() *Approvers {
if untypedObject := cachedObject.Get(); untypedObject == nil {
return nil
} else {
if typedObject := untypedObject.(*Approvers); typedObject == nil || typedObject.IsDeleted() {
return nil
} else {
return typedObject
}
}
}
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
}
}
}
package missingtransaction
import (
"time"
"github.com/iotaledger/goshimmer/packages/binary/transaction"
"github.com/iotaledger/hive.go/objectstorage"
)
type MissingTransaction struct {
objectstorage.StorableObjectFlags
storageKey []byte
id transaction.Id
missingSince time.Time
}
func New(id transaction.Id) *MissingTransaction {
return &MissingTransaction{
storageKey: id[:],
id: id,
missingSince: time.Now(),
}
}
func FromStorage(key []byte) objectstorage.StorableObject {
result := &MissingTransaction{
storageKey: make([]byte, len(key)),
}
copy(result.storageKey, key)
return result
}
func (missingTransaction *MissingTransaction) GetId() transaction.Id {
return missingTransaction.id
}
func (missingTransaction *MissingTransaction) GetMissingSince() time.Time {
return missingTransaction.missingSince
}
func (missingTransaction *MissingTransaction) GetStorageKey() []byte {
return missingTransaction.storageKey
}
func (missingTransaction *MissingTransaction) Update(other objectstorage.StorableObject) {
panic("missing transactions should never be overwritten and only stored once to optimize IO")
}
func (missingTransaction *MissingTransaction) MarshalBinary() (result []byte, err error) {
return missingTransaction.missingSince.MarshalBinary()
}
func (missingTransaction *MissingTransaction) UnmarshalBinary(data []byte) (err error) {
copy(missingTransaction.id[:], missingTransaction.storageKey)
return missingTransaction.missingSince.UnmarshalBinary(data)
}
package tangle
import (
"container/list"
"github.com/iotaledger/goshimmer/packages/binary/tangle/approvers"
"github.com/iotaledger/goshimmer/packages/binary/transaction"
"github.com/iotaledger/goshimmer/packages/binary/transactionmetadata"
"github.com/iotaledger/hive.go/async"
"github.com/iotaledger/hive.go/objectstorage"
)
type solidifier struct {
tangle *Tangle
workerPool async.WorkerPool
}
func newSolidifier(tangle *Tangle) (result *solidifier) {
result = &solidifier{
tangle: tangle,
}
result.workerPool.Tune(1024)
return
}
func (solidifier *solidifier) Shutdown() {
solidifier.workerPool.ShutdownGracefully()
}
func (solidifier *solidifier) Solidify(cachedTransaction *objectstorage.CachedObject, cachedTransactionMetadata *objectstorage.CachedObject) {
solidifier.workerPool.Submit(func() { solidifier.solidify(cachedTransaction, cachedTransactionMetadata) })
}
func (solidifier *solidifier) solidify(cachedTransaction *objectstorage.CachedObject, cachedTransactionMetadata *objectstorage.CachedObject) {
// initialize the stack
solidificationStack := list.New()
solidificationStack.PushBack([2]*objectstorage.CachedObject{cachedTransaction, cachedTransactionMetadata})
// process transactions that are supposed to be checked for solidity recursively
for solidificationStack.Len() > 0 {
// pop first element from stack
currentSolidificationEntry := solidificationStack.Front()
currentCachedTransaction := currentSolidificationEntry.Value.([2]*objectstorage.CachedObject)[0]
currentCachedTransactionMetadata := currentSolidificationEntry.Value.([2]*objectstorage.CachedObject)[1]
solidificationStack.Remove(currentSolidificationEntry)
// retrieve transaction from cached result
var currentTransaction *transaction.Transaction
if _tmp := currentCachedTransaction.Get(); _tmp != nil {
currentTransaction = _tmp.(*transaction.Transaction)
} else {
currentCachedTransaction.Release()
currentCachedTransactionMetadata.Release()
continue
}
// retrieve metadata from cached result
var currentTransactionMetadata *transactionmetadata.TransactionMetadata
if _tmp := currentCachedTransactionMetadata.Get(); _tmp != nil {
currentTransactionMetadata = _tmp.(*transactionmetadata.TransactionMetadata)
} else {
currentCachedTransaction.Release()
currentCachedTransactionMetadata.Release()
continue
}
// if current transaction is solid and was not marked as solid before: mark as solid and propagate
if solidifier.isTransactionSolid(currentTransaction, currentTransactionMetadata) && currentTransactionMetadata.SetSolid(true) {
solidifier.tangle.Events.TransactionSolid.Trigger(currentCachedTransaction, currentCachedTransactionMetadata)
solidifier.tangle.GetApprovers(currentTransaction.GetId()).Consume(func(object objectstorage.StorableObject) {
for approverTransactionId := range object.(*approvers.Approvers).Get() {
solidificationStack.PushBack([2]*objectstorage.CachedObject{
solidifier.tangle.GetTransaction(approverTransactionId),
solidifier.tangle.GetTransactionMetadata(approverTransactionId),
})
}
})
}
// release cached results
currentCachedTransaction.Release()
currentCachedTransactionMetadata.Release()
}
}
func (solidifier *solidifier) isTransactionSolid(transaction *transaction.Transaction, transactionMetadata *transactionmetadata.TransactionMetadata) bool {
if transaction == nil || transaction.IsDeleted() {
return false
}
if transactionMetadata == nil || transactionMetadata.IsDeleted() {
return false
}
if transactionMetadata.IsSolid() {
return true
}
// 1. check tangle solidity
if solidifier.isTransactionSolidInTangle(transaction.GetTrunkTransactionId()) && solidifier.isTransactionSolidInTangle(transaction.GetBranchTransactionId()) {
// 2. check payload solidity
return true
}
return false
}
func (solidifier *solidifier) isTransactionSolidInTangle(transactionId transaction.Id) bool {
if transactionId != transaction.EmptyId {
cachedTransactionMetadata := solidifier.tangle.GetTransactionMetadata(transactionId)
if transactionMetadata := cachedTransactionMetadata.Get().(*transactionmetadata.TransactionMetadata); transactionMetadata == nil || transactionMetadata.IsDeleted() || !transactionMetadata.IsSolid() {
cachedTransactionMetadata.Release()
return false
}
cachedTransactionMetadata.Release()
}
return true
}
package tangle
import (
"container/list"
"fmt"
"github.com/iotaledger/goshimmer/packages/binary/tangle/approvers"
"github.com/iotaledger/goshimmer/packages/binary/tangle/missingtransaction"
"github.com/iotaledger/goshimmer/packages/binary/transaction"
"github.com/iotaledger/goshimmer/packages/binary/transactionmetadata"
"github.com/iotaledger/goshimmer/packages/storageprefix"
"github.com/iotaledger/goshimmer/packages/stringify"
"github.com/iotaledger/hive.go/async"
"github.com/iotaledger/hive.go/events"
"github.com/iotaledger/hive.go/objectstorage"
"github.com/pkg/errors"
)
type Tangle struct {
solidifier *solidifier
transactionStorage *objectstorage.ObjectStorage
transactionMetadataStorage *objectstorage.ObjectStorage
approversStorage *objectstorage.ObjectStorage
missingTransactionsStorage *objectstorage.ObjectStorage
Events tangleEvents
verifyTransactionsWorkerPool async.WorkerPool
storeTransactionsWorkerPool async.WorkerPool
storeTransactionsWorkerPool async.WorkerPool
solidifierWorkerPool async.WorkerPool
}
func New(storageId []byte) (result *Tangle) {
......@@ -29,25 +31,26 @@ func New(storageId []byte) (result *Tangle) {
transactionStorage: objectstorage.New(append(storageId, storageprefix.TangleTransaction...), transactionFactory),
transactionMetadataStorage: objectstorage.New(append(storageId, storageprefix.TangleTransactionMetadata...), transactionFactory),
approversStorage: objectstorage.New(append(storageId, storageprefix.TangleApprovers...), approversFactory),
missingTransactionsStorage: objectstorage.New(append(storageId, storageprefix.TangleTransaction...), missingtransaction.FromStorage),
Events: tangleEvents{
TransactionAttached: events.NewEvent(func(handler interface{}, params ...interface{}) {
cachedTransaction := params[0].(*objectstorage.CachedObject)
cachedTransactionMetadata := params[1].(*objectstorage.CachedObject)
cachedTransaction := params[0].(*transaction.CachedTransaction)
cachedTransactionMetadata := params[1].(*transactionmetadata.CachedTransactionMetadata)
cachedTransaction.RegisterConsumer()
cachedTransactionMetadata.RegisterConsumer()
handler.(func(*objectstorage.CachedObject, *objectstorage.CachedObject))(cachedTransaction, cachedTransactionMetadata)
handler.(func(*transaction.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(cachedTransaction, cachedTransactionMetadata)
}),
TransactionSolid: events.NewEvent(func(handler interface{}, params ...interface{}) {
cachedTransaction := params[0].(*objectstorage.CachedObject)
cachedTransactionMetadata := params[1].(*objectstorage.CachedObject)
cachedTransaction := params[0].(*transaction.CachedTransaction)
cachedTransactionMetadata := params[1].(*transactionmetadata.CachedTransactionMetadata)
cachedTransaction.RegisterConsumer()
cachedTransactionMetadata.RegisterConsumer()
handler.(func(*objectstorage.CachedObject, *objectstorage.CachedObject))(cachedTransaction, cachedTransactionMetadata)
handler.(func(*transaction.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(cachedTransaction, cachedTransactionMetadata)
}),
Error: events.NewEvent(func(handler interface{}, params ...interface{}) {
handler.(func(error))(params[0].(error))
......@@ -55,7 +58,7 @@ func New(storageId []byte) (result *Tangle) {
},
}
result.solidifier = newSolidifier(result)
result.solidifierWorkerPool.Tune(1024)
return
}
......@@ -77,60 +80,159 @@ func (tangle *Tangle) Prune() error {
}
func (tangle *Tangle) AttachTransaction(transaction *transaction.Transaction) {
tangle.verifyTransactionsWorkerPool.Submit(func() { tangle.verifyTransaction(transaction) })
tangle.storeTransactionsWorkerPool.Submit(func() { tangle.storeTransaction(transaction) })
}
func (tangle *Tangle) GetTransaction(transactionId transaction.Id) *objectstorage.CachedObject {
return tangle.transactionStorage.Load(transactionId[:])
func (tangle *Tangle) GetTransaction(transactionId transaction.Id) *transaction.CachedTransaction {
return &transaction.CachedTransaction{CachedObject: tangle.transactionStorage.Load(transactionId[:])}
}
func (tangle *Tangle) GetTransactionMetadata(transactionId transaction.Id) *objectstorage.CachedObject {
return tangle.transactionMetadataStorage.Load(transactionId[:])
func (tangle *Tangle) GetTransactionMetadata(transactionId transaction.Id) *transactionmetadata.CachedTransactionMetadata {
return &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Load(transactionId[:])}
}
func (tangle *Tangle) GetApprovers(transactionId transaction.Id) *objectstorage.CachedObject {
return tangle.approversStorage.Load(transactionId[:])
func (tangle *Tangle) GetApprovers(transactionId transaction.Id) *approvers.CachedApprovers {
return &approvers.CachedApprovers{CachedObject: tangle.approversStorage.Load(transactionId[:])}
}
func (tangle *Tangle) verifyTransaction(transaction *transaction.Transaction) {
if !transaction.VerifySignature() {
tangle.Events.Error.Trigger(errors.New("transaction with id " + stringify.Interface(transaction.GetId()) + " has an invalid signature"))
// Marks the tangle as stopped, so it will not accept any new transactions, and then waits for all backgroundTasks to
// finish.
func (tangle *Tangle) Shutdown() *Tangle {
tangle.storeTransactionsWorkerPool.ShutdownGracefully()
tangle.solidifierWorkerPool.ShutdownGracefully()
return tangle
}
func (tangle *Tangle) storeTransaction(tx *transaction.Transaction) {
cachedTransaction, transactionIsNew := tangle.transactionStorage.StoreIfAbsent(tx.GetStorageKey(), tx)
if !transactionIsNew {
return
}
tangle.storeTransactionsWorkerPool.Submit(func() { tangle.storeTransaction(transaction) })
cachedTransactionMetadata := tangle.createTransactionMetadata(tx)
tangle.addTransactionToApprovers(tx, tx.GetTrunkTransactionId())
tangle.addTransactionToApprovers(tx, tx.GetBranchTransactionId())
transactionId := tx.GetId()
if tangle.missingTransactionsStorage.DeleteIfPresent(transactionId[:]) {
fmt.Println("MISSING TRANSACTION RECEIVED")
}
tangle.solidifierWorkerPool.Submit(func() {
tangle.solidify(&transaction.CachedTransaction{CachedObject: cachedTransaction}, cachedTransactionMetadata)
})
}
func (tangle *Tangle) storeTransaction(transaction *transaction.Transaction) {
cachedTransaction, transactionIsNew := tangle.transactionStorage.StoreIfAbsent(transaction.GetStorageKey(), transaction)
if !transactionIsNew {
return
// Payloads can have different solidification rules and it might happen, that an external process needs to "manually
// trigger" the solidification checks of a transaction (to update it's solidification status).
func (tangle *Tangle) Solidify(transactionId transaction.Id) {
tangle.solidifierWorkerPool.Submit(func() {
tangle.solidify(tangle.GetTransaction(transactionId), tangle.GetTransactionMetadata(transactionId))
})
}
func (tangle *Tangle) solidify(cachedTransaction *transaction.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
popElementsFromStack := func(stack *list.List) (*transaction.CachedTransaction, *transactionmetadata.CachedTransactionMetadata) {
currentSolidificationEntry := stack.Front()
currentCachedTransaction := currentSolidificationEntry.Value.([2]interface{})[0]
currentCachedTransactionMetadata := currentSolidificationEntry.Value.([2]interface{})[1]
stack.Remove(currentSolidificationEntry)
return currentCachedTransaction.(*transaction.CachedTransaction), currentCachedTransactionMetadata.(*transactionmetadata.CachedTransactionMetadata)
}
// initialize the stack
solidificationStack := list.New()
solidificationStack.PushBack([2]interface{}{cachedTransaction, cachedTransactionMetadata})
// process transactions that are supposed to be checked for solidity recursively
for solidificationStack.Len() > 0 {
currentCachedTransaction, currentCachedTransactionMetadata := popElementsFromStack(solidificationStack)
currentTransaction := currentCachedTransaction.Unwrap()
currentTransactionMetadata := currentCachedTransactionMetadata.Unwrap()
if currentTransaction == nil || currentTransactionMetadata == nil {
currentCachedTransaction.Release()
currentCachedTransactionMetadata.Release()
continue
}
// if current transaction is solid and was not marked as solid before: mark as solid and propagate
if tangle.isTransactionSolid(currentTransaction, currentTransactionMetadata) && currentTransactionMetadata.SetSolid(true) {
tangle.Events.TransactionSolid.Trigger(currentCachedTransaction, currentCachedTransactionMetadata)
tangle.GetApprovers(currentTransaction.GetId()).Consume(func(object objectstorage.StorableObject) {
for approverTransactionId := range object.(*approvers.Approvers).Get() {
solidificationStack.PushBack([2]interface{}{
tangle.GetTransaction(approverTransactionId),
tangle.GetTransactionMetadata(approverTransactionId),
})
}
})
}
// release cached results
currentCachedTransaction.Release()
currentCachedTransactionMetadata.Release()
}
}
func (tangle *Tangle) isTransactionSolid(transaction *transaction.Transaction, transactionMetadata *transactionmetadata.TransactionMetadata) bool {
if transaction == nil || transaction.IsDeleted() {
return false
}
cachedTransactionMetadata := tangle.createTransactionMetadata(transaction)
if transactionMetadata == nil || transactionMetadata.IsDeleted() {
return false
}
tangle.addTransactionToApprovers(transaction, transaction.GetTrunkTransactionId())
tangle.addTransactionToApprovers(transaction, transaction.GetBranchTransactionId())
if transactionMetadata.IsSolid() {
return true
}
// 1. check tangle solidity
isTrunkSolid := tangle.isTransactionMarkedAsSolid(transaction.GetTrunkTransactionId())
isBranchSolid := tangle.isTransactionMarkedAsSolid(transaction.GetBranchTransactionId())
if isTrunkSolid && isBranchSolid {
// 2. check payload solidity
return true
}
tangle.solidifier.Solidify(cachedTransaction, cachedTransactionMetadata)
return false
}
// Marks the tangle as stopped, so it will not accept any new transactions, and then waits for all backgroundTasks to
// finish.
func (tangle *Tangle) Shutdown() *Tangle {
tangle.verifyTransactionsWorkerPool.ShutdownGracefully()
tangle.storeTransactionsWorkerPool.ShutdownGracefully()
func (tangle *Tangle) isTransactionMarkedAsSolid(transactionId transaction.Id) bool {
if transactionId == transaction.EmptyId {
return true
}
tangle.solidifier.Shutdown()
cachedTransactionMetadata := tangle.GetTransactionMetadata(transactionId)
if transactionMetadata := cachedTransactionMetadata.Unwrap(); transactionMetadata == nil {
cachedTransactionMetadata.Release()
return tangle
if _, missingTransactionStored := tangle.missingTransactionsStorage.StoreIfAbsent(transactionId[:], &missingtransaction.MissingTransaction{}); missingTransactionStored {
// Trigger
fmt.Println("MISSING TX EVENT")
}
// transaction is missing -> add to solidifier
return false
} else if !transactionMetadata.IsSolid() {
cachedTransactionMetadata.Release()
return false
}
cachedTransactionMetadata.Release()
return true
}
func (tangle *Tangle) createTransactionMetadata(transaction *transaction.Transaction) *objectstorage.CachedObject {
func (tangle *Tangle) createTransactionMetadata(transaction *transaction.Transaction) *transactionmetadata.CachedTransactionMetadata {
transactionMetadata := transactionmetadata.New(transaction.GetId())
return tangle.transactionMetadataStorage.Store(transactionMetadata)
return &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Store(transactionMetadata)}
}
func (tangle *Tangle) addTransactionToApprovers(transaction *transaction.Transaction, trunkTransactionId transaction.Id) {
......
......@@ -3,6 +3,7 @@ package tangle
import (
"fmt"
"testing"
"time"
"github.com/iotaledger/goshimmer/packages/binary/identity"
"github.com/iotaledger/goshimmer/packages/binary/transaction"
......@@ -48,11 +49,13 @@ func TestTangle_AttachTransaction(t *testing.T) {
}
newTransaction1 := transaction.New(transaction.EmptyId, transaction.EmptyId, identity.Generate(), data.New([]byte("some data")))
newTransaction2 := transaction.New(newTransaction1.GetId(), transaction.EmptyId, identity.Generate(), data.New([]byte("some other data")))
newTransaction2 := transaction.New(newTransaction1.GetId(), newTransaction1.GetId(), identity.Generate(), data.New([]byte("some other data")))
fmt.Println("ATTACH", newTransaction2.GetId())
tangle.AttachTransaction(newTransaction2)
time.Sleep(1 * time.Second)
fmt.Println("ATTACH", newTransaction1.GetId())
tangle.AttachTransaction(newTransaction1)
......
package transaction
import (
"github.com/iotaledger/hive.go/objectstorage"
)
type CachedTransaction struct {
*objectstorage.CachedObject
}
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
}
}
}
package transactionmetadata
import (
"github.com/iotaledger/hive.go/objectstorage"
)
type CachedTransactionMetadata struct {
*objectstorage.CachedObject
}
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
}
}
}
......@@ -9,7 +9,7 @@ import (
"github.com/iotaledger/hive.go/async"
)
type ValueTransactionSignatureFilter struct {
type ValueTransferSignatureFilter struct {
onAcceptCallback func(tx *transaction.Transaction)
onRejectCallback func(tx *transaction.Transaction)
workerPool async.WorkerPool
......@@ -18,13 +18,13 @@ type ValueTransactionSignatureFilter struct {
onRejectCallbackMutex sync.RWMutex
}
func NewValueTransactionSignatureFilter() (result *ValueTransactionSignatureFilter) {
result = &ValueTransactionSignatureFilter{}
func NewValueTransferSignatureFilter() (result *ValueTransferSignatureFilter) {
result = &ValueTransferSignatureFilter{}
return
}
func (filter *ValueTransactionSignatureFilter) Filter(tx *transaction.Transaction) {
func (filter *ValueTransferSignatureFilter) Filter(tx *transaction.Transaction) {
filter.workerPool.Submit(func() {
if payload := tx.GetPayload(); payload.GetType() == valuetransfer.Type {
if valueTransfer, ok := payload.(*valuetransfer.ValueTransfer); ok && valueTransfer.VerifySignatures() {
......@@ -38,23 +38,23 @@ func (filter *ValueTransactionSignatureFilter) Filter(tx *transaction.Transactio
})
}
func (filter *ValueTransactionSignatureFilter) OnAccept(callback func(tx *transaction.Transaction)) {
func (filter *ValueTransferSignatureFilter) OnAccept(callback func(tx *transaction.Transaction)) {
filter.onAcceptCallbackMutex.Lock()
filter.onAcceptCallback = callback
filter.onAcceptCallbackMutex.Unlock()
}
func (filter *ValueTransactionSignatureFilter) OnReject(callback func(tx *transaction.Transaction)) {
func (filter *ValueTransferSignatureFilter) OnReject(callback func(tx *transaction.Transaction)) {
filter.onRejectCallbackMutex.Lock()
filter.onRejectCallback = callback
filter.onRejectCallbackMutex.Unlock()
}
func (filter *ValueTransactionSignatureFilter) Shutdown() {
func (filter *ValueTransferSignatureFilter) Shutdown() {
filter.workerPool.ShutdownGracefully()
}
func (filter *ValueTransactionSignatureFilter) getAcceptCallback() (result func(tx *transaction.Transaction)) {
func (filter *ValueTransferSignatureFilter) getAcceptCallback() (result func(tx *transaction.Transaction)) {
filter.onAcceptCallbackMutex.RLock()
result = filter.onAcceptCallback
filter.onAcceptCallbackMutex.RUnlock()
......@@ -62,7 +62,7 @@ func (filter *ValueTransactionSignatureFilter) getAcceptCallback() (result func(
return
}
func (filter *ValueTransactionSignatureFilter) getRejectCallback() (result func(tx *transaction.Transaction)) {
func (filter *ValueTransferSignatureFilter) getRejectCallback() (result func(tx *transaction.Transaction)) {
filter.onRejectCallbackMutex.RLock()
result = filter.onRejectCallback
filter.onRejectCallbackMutex.RUnlock()
......
......@@ -43,7 +43,7 @@ func New() (result *TransactionParser) {
// add builtin filters
result.AddBytesFilter(builtinfilters.NewRecentlySeenBytesFilter())
result.AddTransactionsFilter(builtinfilters.NewTransactionSignatureFilter())
result.AddTransactionsFilter(builtinfilters.NewValueTransactionSignatureFilter())
result.AddTransactionsFilter(builtinfilters.NewValueTransferSignatureFilter())
return
}
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment