116 lines
2.8 KiB
Go
116 lines
2.8 KiB
Go
package core
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
|
|
"github.com/CityOfZion/neo-go/pkg/core/storage"
|
|
"github.com/CityOfZion/neo-go/pkg/util"
|
|
)
|
|
|
|
// SpentCoins is mapping between transactions and their spent
|
|
// coin state.
|
|
type SpentCoins map[util.Uint256]*SpentCoinState
|
|
|
|
func (s SpentCoins) getAndUpdate(store storage.Store, hash util.Uint256) (*SpentCoinState, error) {
|
|
if spent, ok := s[hash]; ok {
|
|
return spent, nil
|
|
}
|
|
|
|
spent := &SpentCoinState{}
|
|
key := storage.AppendPrefix(storage.STSpentCoin, hash.BytesReverse())
|
|
if b, err := store.Get(key); err == nil {
|
|
if err := spent.DecodeBinary(bytes.NewReader(b)); err != nil {
|
|
return nil, fmt.Errorf("failed to decode (UnspentCoinState): %s", err)
|
|
}
|
|
} else {
|
|
spent = &SpentCoinState{
|
|
items: make(map[uint16]uint32),
|
|
}
|
|
}
|
|
|
|
s[hash] = spent
|
|
return spent, nil
|
|
}
|
|
|
|
func (s SpentCoins) commit(b storage.Batch) error {
|
|
buf := new(bytes.Buffer)
|
|
for hash, state := range s {
|
|
if err := state.EncodeBinary(buf); err != nil {
|
|
return err
|
|
}
|
|
key := storage.AppendPrefix(storage.STSpentCoin, hash.BytesReverse())
|
|
b.Put(key, buf.Bytes())
|
|
buf.Reset()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SpentCoinState represents the state of a spent coin.
|
|
type SpentCoinState struct {
|
|
txHash util.Uint256
|
|
txHeight uint32
|
|
|
|
// A mapping between the index of the prevIndex and block height.
|
|
items map[uint16]uint32
|
|
}
|
|
|
|
// NewSpentCoinState returns a new SpentCoinState object.
|
|
func NewSpentCoinState(hash util.Uint256, height uint32) *SpentCoinState {
|
|
return &SpentCoinState{
|
|
txHash: hash,
|
|
txHeight: height,
|
|
items: make(map[uint16]uint32),
|
|
}
|
|
}
|
|
|
|
// DecodeBinary implements the Payload interface.
|
|
func (s *SpentCoinState) DecodeBinary(r io.Reader) error {
|
|
if err := binary.Read(r, binary.LittleEndian, &s.txHash); err != nil {
|
|
return err
|
|
}
|
|
if err := binary.Read(r, binary.LittleEndian, &s.txHeight); err != nil {
|
|
return err
|
|
}
|
|
|
|
s.items = make(map[uint16]uint32)
|
|
lenItems := util.ReadVarUint(r)
|
|
for i := 0; i < int(lenItems); i++ {
|
|
var (
|
|
key uint16
|
|
value uint32
|
|
)
|
|
if err := binary.Read(r, binary.LittleEndian, &key); err != nil {
|
|
return err
|
|
}
|
|
if err := binary.Read(r, binary.LittleEndian, &value); err != nil {
|
|
return err
|
|
}
|
|
s.items[key] = value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// EncodeBinary implements the Payload interface.
|
|
func (s *SpentCoinState) EncodeBinary(w io.Writer) error {
|
|
if err := binary.Write(w, binary.LittleEndian, s.txHash); err != nil {
|
|
return err
|
|
}
|
|
if err := binary.Write(w, binary.LittleEndian, s.txHeight); err != nil {
|
|
return err
|
|
}
|
|
if err := util.WriteVarUint(w, uint64(len(s.items))); err != nil {
|
|
return err
|
|
}
|
|
for k, v := range s.items {
|
|
if err := binary.Write(w, binary.LittleEndian, k); err != nil {
|
|
return err
|
|
}
|
|
if err := binary.Write(w, binary.LittleEndian, v); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|