Operation index for target and peers

Author: kfangw

lib/block/operation.go

@@ -27,15 +27,18 @@ type BlockOperation struct {
 
 	Type    operation.OperationType `json:"type"`
 	Source  string                  `json:"source"`
+	Target  string                  `json:"target"`
 	Body    []byte                  `json:"body"`
 	Height  uint64                  `json:"block_height"`
 	Index   uint64                  `json:"index"`
 	TxIndex uint64                  `json:"tx_index"`
 
-	// transaction will be used only for `Save` time.
+	// bellows will be used only for `Save` time.
 	transaction transaction.Transaction
+	operation   operation.Operation
 	isSaved     bool
 	order       *BlockOrder
+	linked      string
 }
 
 func NewBlockOperationKey(opHash, txHash string, index uint64) string {
@@ -53,6 +56,18 @@ func NewBlockOperationFromOperation(op operation.Operation, tx transaction.Trans
 
 	order := NewBlockOpOrder(blockHeight, txIndex, index)
 
+	target := ""
+	if pop, ok := op.B.(operation.Targetable); ok {
+		target = pop.TargetAddress()
+	}
+
+	linked := ""
+	if createAccount, ok := op.B.(*operation.CreateAccount); ok {
+		if createAccount.Linked != "" {
+			linked = createAccount.Linked
+		}
+	}
+
 	return BlockOperation{
 		Hash: NewBlockOperationKey(opHash, txHash, index),
 
@@ -61,16 +76,33 @@ func NewBlockOperationFromOperation(op operation.Operation, tx transaction.Trans
 
 		Type:    op.H.Type,
 		Source:  tx.B.Source,
+		Target:  target,
 		Body:    body,
 		Height:  blockHeight,
 		Index:   index,
 		TxIndex: txIndex,
 
 		transaction: tx,
+		operation:   op,
 		order:       order,
+		linked:      linked,
 	}, nil
 }
 
+func (bo *BlockOperation) hasTarget() bool {
+	if bo.Target != "" {
+		return true
+	}
+	return false
+}
+
+func (bo *BlockOperation) targetIsLinked() bool {
+	if bo.hasTarget() && bo.linked != "" {
+		return true
+	}
+	return false
+}
+
 func (bo *BlockOperation) Save(st *storage.LevelDBBackend) (err error) {
 	if bo.isSaved {
 		return errors.AlreadySaved
@@ -91,47 +123,62 @@ func (bo *BlockOperation) Save(st *storage.LevelDBBackend) (err error) {
 	if err = st.New(bo.NewBlockOperationTxHashKey(), bo.Hash); err != nil {
 		return
 	}
-	if err = st.New(bo.NewBlockOperationSourceKey(), bo.Hash); err != nil {
+
+	if err = st.New(bo.NewBlockOperationSourceKey(bo.Source), bo.Hash); err != nil {
 		return
 	}
-	if err = st.New(bo.NewBlockOperationSourceAndTypeKey(), bo.Hash); err != nil {
+	if err = st.New(bo.NewBlockOperationSourceAndTypeKey(bo.Source), bo.Hash); err != nil {
+		return
+	}
+	if err = st.New(bo.NewBlockOperationPeersKey(bo.Source), bo.Hash); err != nil {
+		return
+	}
+	if err = st.New(bo.NewBlockOperationPeersAndTypeKey(bo.Source), bo.Hash); err != nil {
 		return
 	}
 
-	var body operation.Body
-	var casted operation.CreateAccount
-	var ok bool
-
-	if bo.Type == operation.TypeCreateAccount {
-		if body, err = operation.UnmarshalBodyJSON(bo.Type, bo.Body); err != nil {
-			return err
+	if bo.hasTarget() {
+		if err = st.New(bo.NewBlockOperationTargetKey(bo.Target), bo.Hash); err != nil {
+			return
 		}
-		if casted, ok = body.(operation.CreateAccount); !ok {
-			return errors.TypeOperationBodyNotMatched
+		if err = st.New(bo.NewBlockOperationTargetAndTypeKey(bo.Target), bo.Hash); err != nil {
+			return
 		}
-		if casted.Linked != "" {
-			if err = st.New(GetBlockOperationCreateFrozenKey(casted.Target, bo.Height), bo.Hash); err != nil {
-				return err
-			}
-			if err = st.New(bo.NewBlockOperationFrozenLinkedKey(casted.Linked), bo.Hash); err != nil {
-				return err
-			}
+		if err = st.New(bo.NewBlockOperationPeersKey(bo.Target), bo.Hash); err != nil {
+			return
+		}
+		if err = st.New(bo.NewBlockOperationPeersAndTypeKey(bo.Target), bo.Hash); err != nil {
+			return
 		}
 	}
 
-	bo.isSaved = true
+	if bo.targetIsLinked() {
+		if err = st.New(GetBlockOperationCreateFrozenKey(bo.Target, bo.Height), bo.Hash); err != nil {
+			return err
+		}
+		if err = st.New(bo.NewBlockOperationFrozenLinkedKey(bo.linked), bo.Hash); err != nil {
+			return err
+		}
+	}
 
 	event := "saved"
-	event += " " + fmt.Sprintf("source-%s", bo.Source)
 	event += " " + fmt.Sprintf("hash-%s", bo.Hash)
 	event += " " + fmt.Sprintf("txhash-%s", bo.TxHash)
+	event += " " + fmt.Sprintf("source-%s", bo.Source)
 	event += " " + fmt.Sprintf("source-type-%s%s", bo.Source, bo.Type)
-	if casted.Linked != "" {
-		event += " frozen"
-		event += " " + fmt.Sprintf("linked-%s", casted.Linked)
+
+	if bo.hasTarget() {
+		event += " " + fmt.Sprintf("target-%s", bo.Target)
+		event += " " + fmt.Sprintf("target-type-%s%s", bo.Target, bo.Type)
+	}
+	if bo.targetIsLinked() {
+		event += " " + "frozen"
+		event += " " + fmt.Sprintf("linked-%s", bo.linked)
 	}
 	observer.BlockOperationObserver.Trigger(event, bo)
 
+	bo.isSaved = true
+
 	return nil
 }
 
@@ -140,6 +187,10 @@ func (bo BlockOperation) Serialize() (encoded []byte, err error) {
 	return
 }
 
+func (bo BlockOperation) BlockOrder() *BlockOrder {
+	return bo.order
+}
+
 func GetBlockOperationKey(hash string) string {
 	idx := storage.NewIndex()
 	idx.WritePrefix(common.BlockOperationPrefixHash, hash)
@@ -171,9 +222,33 @@ func GetBlockOperationKeyPrefixSource(source string) string {
 	return idx.String()
 }
 
+func GetBlockOperationKeyPrefixTarget(target string) string {
+	idx := storage.NewIndex()
+	idx.WritePrefix(common.BlockOperationPrefixTarget, target)
+	return idx.String()
+}
+
+func GetBlockOperationKeyPrefixPeers(addr string) string {
+	idx := storage.NewIndex()
+	idx.WritePrefix(common.BlockOperationPrefixPeers, addr)
+	return idx.String()
+}
+
 func GetBlockOperationKeyPrefixSourceAndType(source string, ty operation.OperationType) string {
 	idx := storage.NewIndex()
-	idx.WritePrefix(common.BlockOperationPrefixSource, source, string(ty))
+	idx.WritePrefix(common.BlockOperationPrefixTypeSource, string(ty), source)
+	return idx.String()
+}
+
+func GetBlockOperationKeyPrefixTargetAndType(target string, ty operation.OperationType) string {
+	idx := storage.NewIndex()
+	idx.WritePrefix(common.BlockOperationPrefixTypeTarget, string(ty), target)
+	return idx.String()
+}
+
+func GetBlockOperationKeyPrefixPeersAndType(addr string, ty operation.OperationType) string {
+	idx := storage.NewIndex()
+	idx.WritePrefix(common.BlockOperationPrefixTypePeers, string(ty), addr)
 	return idx.String()
 }
 
@@ -182,66 +257,55 @@ func (bo BlockOperation) NewBlockOperationTxHashKey() string {
 	idx.WritePrefix(GetBlockOperationKeyPrefixTxHash(bo.TxHash))
 	bo.order.Index(idx)
 	return idx.String()
-	/*
-		return fmt.Sprintf(
-			"%s%s%s%s",
-			GetBlockOperationKeyPrefixTxHash(bo.TxHash),
-			common.EncodeUint64ToByteSlice(bo.Height),
-			common.EncodeUint64ToByteSlice(bo.TxIndex),
-			common.EncodeUint64ToByteSlice(bo.Index),
-		)
-	*/
-}
-
-func (bo BlockOperation) NewBlockOperationSourceKey() string {
+}
+
+func (bo BlockOperation) NewBlockOperationSourceKey(source string) string {
+	idx := storage.NewIndex()
+	idx.WritePrefix(GetBlockOperationKeyPrefixSource(source))
+	bo.order.Index(idx)
+	return idx.String()
+}
+
+func (bo BlockOperation) NewBlockOperationTargetKey(target string) string {
+	idx := storage.NewIndex()
+	idx.WritePrefix(GetBlockOperationKeyPrefixTarget(target))
+	bo.order.Index(idx)
+	return idx.String()
+}
+
+func (bo BlockOperation) NewBlockOperationPeersKey(addr string) string {
 	idx := storage.NewIndex()
-	idx.WritePrefix(GetBlockOperationKeyPrefixSource(bo.Source))
+	idx.WritePrefix(GetBlockOperationKeyPrefixPeers(addr))
 	bo.order.Index(idx)
 	return idx.String()
-	/*
-		return fmt.Sprintf(
-			"%s%s%s%s",
-			GetBlockOperationKeyPrefixSource(bo.Source),
-			common.EncodeUint64ToByteSlice(bo.Height),
-			common.EncodeUint64ToByteSlice(bo.TxIndex),
-			common.EncodeUint64ToByteSlice(bo.Index),
-		)
-	*/
 }
 
 func (bo BlockOperation) NewBlockOperationFrozenLinkedKey(hash string) string {
 	idx := storage.NewIndex()
 	idx.WritePrefix(GetBlockOperationKeyPrefixFrozenLinked(hash))
 	bo.order.Index(idx)
 	return idx.String()
+}
 
-	/*
-		return fmt.Sprintf(
-			"%s%s",
-			GetBlockOperationKeyPrefixFrozenLinked(hash),
-			common.EncodeUint64ToByteSlice(bo.Height),
-		)
-	*/
+func (bo BlockOperation) NewBlockOperationSourceAndTypeKey(source string) string {
+	idx := storage.NewIndex()
+	idx.WritePrefix(GetBlockOperationKeyPrefixSourceAndType(source, bo.Type))
+	bo.order.Index(idx)
+	return idx.String()
 }
 
-func (bo BlockOperation) NewBlockOperationSourceAndTypeKey() string {
+func (bo BlockOperation) NewBlockOperationTargetAndTypeKey(target string) string {
 	idx := storage.NewIndex()
-	idx.WritePrefix(GetBlockOperationKeyPrefixSourceAndType(bo.Source, bo.Type))
+	idx.WritePrefix(GetBlockOperationKeyPrefixTargetAndType(target, bo.Type))
 	bo.order.Index(idx)
 	return idx.String()
-	/*
-		return fmt.Sprintf(
-			"%s%s%s%s",
-			GetBlockOperationKeyPrefixSourceAndType(bo.Source, bo.Type),
-			common.EncodeUint64ToByteSlice(bo.Height),
-			common.EncodeUint64ToByteSlice(bo.TxIndex),
-			common.EncodeUint64ToByteSlice(bo.Index),
-		)
-	*/
 }
 
-func (bo BlockOperation) BlockOrder() *BlockOrder {
-	return bo.order
+func (bo BlockOperation) NewBlockOperationPeersAndTypeKey(addr string) string {
+	idx := storage.NewIndex()
+	idx.WritePrefix(GetBlockOperationKeyPrefixPeersAndType(addr, bo.Type))
+	bo.order.Index(idx)
+	return idx.String()
 }
 
 func ExistsBlockOperation(st *storage.LevelDBBackend, hash string) (bool, error) {
@@ -296,6 +360,24 @@ func GetBlockOperationsByTxHash(st *storage.LevelDBBackend, txHash string, optio
 	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
 }
 
+// Find all operations which created frozen account.
+func GetBlockOperationsByFrozen(st *storage.LevelDBBackend, options storage.ListOptions) (
+	func() (BlockOperation, bool, []byte),
+	func(),
+) {
+	iterFunc, closeFunc := st.GetIterator(common.BlockOperationPrefixCreateFrozen, options)
+	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
+}
+
+// Find all operations which created frozen account and have the link of a general account's address.
+func GetBlockOperationsByLinked(st *storage.LevelDBBackend, hash string, options storage.ListOptions) (
+	func() (BlockOperation, bool, []byte),
+	func(),
+) {
+	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixFrozenLinked(hash), options)
+	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
+}
+
 func GetBlockOperationsBySource(st *storage.LevelDBBackend, source string, options storage.ListOptions) (
 	func() (BlockOperation, bool, []byte),
 	func(),
@@ -305,28 +387,44 @@ func GetBlockOperationsBySource(st *storage.LevelDBBackend, source string, optio
 	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
 }
 
-// Find all operations which created frozen account.
-func GetBlockOperationsByFrozen(st *storage.LevelDBBackend, options storage.ListOptions) (
+func GetBlockOperationsBySourceAndType(st *storage.LevelDBBackend, source string, ty operation.OperationType, options storage.ListOptions) (
 	func() (BlockOperation, bool, []byte),
 	func(),
 ) {
-	iterFunc, closeFunc := st.GetIterator(common.BlockOperationPrefixCreateFrozen, options)
+	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixSourceAndType(source, ty), options)
 	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
 }
 
-// Find all operations which created frozen account and have the link of a general account's address.
-func GetBlockOperationsByLinked(st *storage.LevelDBBackend, hash string, options storage.ListOptions) (
+func GetBlockOperationsByTarget(st *storage.LevelDBBackend, target string, options storage.ListOptions) (
 	func() (BlockOperation, bool, []byte),
 	func(),
 ) {
-	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixFrozenLinked(hash), options)
+	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixTarget(target), options)
+
 	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
 }
 
-func GetBlockOperationsBySourceAndType(st *storage.LevelDBBackend, source string, ty operation.OperationType, options storage.ListOptions) (
+func GetBlockOperationsByTargetAndType(st *storage.LevelDBBackend, target string, ty operation.OperationType, options storage.ListOptions) (
 	func() (BlockOperation, bool, []byte),
 	func(),
 ) {
-	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixSourceAndType(source, ty), options)
+	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixTargetAndType(target, ty), options)
+	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
+}
+
+func GetBlockOperationsByPeers(st *storage.LevelDBBackend, addr string, options storage.ListOptions) (
+	func() (BlockOperation, bool, []byte),
+	func(),
+) {
+	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixPeers(addr), options)
+
+	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
+}
+
+func GetBlockOperationsByPeersAndType(st *storage.LevelDBBackend, addr string, ty operation.OperationType, options storage.ListOptions) (
+	func() (BlockOperation, bool, []byte),
+	func(),
+) {
+	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixPeersAndType(addr, ty), options)
 	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
 }

lib/client/response.go

@@ -112,6 +112,7 @@ type Operation struct {
 	} `json:"_links"`
 	Hash   string      `json:"hash"`
 	Source string      `json:"source"`
+	Target string      `json:"target"`
 	Type   string      `json:"type"`
 	Body   interface{} `json:"body"`
 }