forked from TrueCloudLab/neoneo-go
143 lines
3.1 KiB
Go
143 lines
3.1 KiB
Go
package database
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"fmt"
|
|
|
|
"github.com/CityOfZion/neo-go/pkg/wire/payload"
|
|
"github.com/CityOfZion/neo-go/pkg/wire/payload/transaction"
|
|
"github.com/CityOfZion/neo-go/pkg/wire/util"
|
|
"github.com/syndtr/goleveldb/leveldb"
|
|
"github.com/syndtr/goleveldb/leveldb/errors"
|
|
)
|
|
|
|
type LDB struct {
|
|
db *leveldb.DB
|
|
path string
|
|
}
|
|
|
|
type Database interface {
|
|
Has(key []byte) (bool, error)
|
|
Put(key []byte, value []byte) error
|
|
Get(key []byte) ([]byte, error)
|
|
Delete(key []byte) error
|
|
Close() error
|
|
}
|
|
|
|
var (
|
|
// TX, HEADER AND UTXO are the prefixes for the db
|
|
TX = []byte("TX")
|
|
HEADER = []byte("HEADER")
|
|
LATESTHEADER = []byte("LH")
|
|
UTXO = []byte("UTXO")
|
|
)
|
|
|
|
func New(path string) *LDB {
|
|
db, err := leveldb.OpenFile(path, nil)
|
|
|
|
if _, corrupted := err.(*errors.ErrCorrupted); corrupted {
|
|
db, err = leveldb.RecoverFile(path, nil)
|
|
}
|
|
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
return &LDB{
|
|
db,
|
|
path,
|
|
}
|
|
}
|
|
|
|
func (l *LDB) Has(key []byte) (bool, error) {
|
|
return l.db.Has(key, nil)
|
|
}
|
|
|
|
func (l *LDB) Put(key []byte, value []byte) error {
|
|
return l.db.Put(key, value, nil)
|
|
}
|
|
func (l *LDB) Get(key []byte) ([]byte, error) {
|
|
return l.db.Get(key, nil)
|
|
}
|
|
func (l *LDB) Delete(key []byte) error {
|
|
return l.db.Delete(key, nil)
|
|
}
|
|
func (l *LDB) Close() error {
|
|
return l.db.Close()
|
|
}
|
|
|
|
func (l *LDB) AddHeader(header *payload.BlockBase) error {
|
|
|
|
table := NewTable(l, HEADER)
|
|
|
|
byt, err := header.Bytes()
|
|
if err != nil {
|
|
fmt.Println("Could not Get bytes from decoded BlockBase")
|
|
return nil
|
|
}
|
|
|
|
fmt.Println("Adding Header, This should be batched!!!!")
|
|
|
|
// This is the main mapping
|
|
//Key: HEADER+BLOCKHASH Value: contents of blockhash
|
|
key := header.Hash.Bytes()
|
|
err = table.Put(key, byt)
|
|
if err != nil {
|
|
fmt.Println("Error trying to add the original mapping into the DB for Header. Mapping is [Header]+[Hash]")
|
|
return err
|
|
}
|
|
|
|
// This is the secondary mapping
|
|
// Key: HEADER + BLOCKHEIGHT Value: blockhash
|
|
|
|
bh := uint32ToBytes(header.Index)
|
|
key = []byte(bh)
|
|
err = table.Put(key, header.Hash.Bytes())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// This is the third mapping
|
|
// WARNING: This assumes that headers are adding in order.
|
|
return table.Put(LATESTHEADER, header.Hash.Bytes())
|
|
}
|
|
|
|
func (l *LDB) AddTransactions(blockhash util.Uint256, txs []transaction.Transactioner) error {
|
|
|
|
// SHOULD BE DONE IN BATCH!!!!
|
|
for i, tx := range txs {
|
|
buf := new(bytes.Buffer)
|
|
fmt.Println(tx.ID())
|
|
tx.Encode(buf)
|
|
txByt := buf.Bytes()
|
|
txhash, err := tx.ID()
|
|
if err != nil {
|
|
fmt.Println("Error adding transaction with bytes", txByt)
|
|
return err
|
|
}
|
|
// This is the original mapping
|
|
// Key: [TX] + TXHASH
|
|
key := append(TX, txhash.Bytes()...)
|
|
l.Put(key, txByt)
|
|
|
|
// This is the index
|
|
// Key: [TX] + BLOCKHASH + I <- i is the incrementer from the for loop
|
|
//Value : TXHASH
|
|
key = append(TX, blockhash.Bytes()...)
|
|
key = append(key, uint32ToBytes(uint32(i))...)
|
|
|
|
err = l.Put(key, txhash.Bytes())
|
|
if err != nil {
|
|
fmt.Println("Error could not add tx index into db")
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// BigEndian
|
|
func uint32ToBytes(h uint32) []byte {
|
|
a := make([]byte, 4)
|
|
binary.BigEndian.PutUint32(a, h)
|
|
return a
|
|
}
|