mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-23 04:03:49 +00:00
209 lines
5.2 KiB
Go
209 lines
5.2 KiB
Go
package main
|
|
|
|
import (
|
|
_"fmt"
|
|
"time"
|
|
_"bytes"
|
|
_"encoding/hex"
|
|
)
|
|
|
|
type Block struct {
|
|
// The number of this block
|
|
number uint32
|
|
// Hash to the previous block
|
|
prevHash string
|
|
// Uncles of this block
|
|
uncles []*Block
|
|
coinbase string
|
|
// state xxx
|
|
state *Trie
|
|
difficulty uint32
|
|
// Creation time
|
|
time int64
|
|
nonce uint32
|
|
// List of transactions and/or contracts
|
|
transactions []*Transaction
|
|
|
|
extra string
|
|
}
|
|
|
|
// New block takes a raw encoded string
|
|
func NewBlock(raw []byte) *Block {
|
|
block := &Block{}
|
|
block.UnmarshalRlp(raw)
|
|
|
|
return block
|
|
}
|
|
|
|
// Creates a new block. This is currently for testing
|
|
func CreateTestBlock(/* TODO use raw data */transactions []*Transaction) *Block {
|
|
block := &Block{
|
|
// Slice of transactions to include in this block
|
|
transactions: transactions,
|
|
number: 1,
|
|
prevHash: "1234",
|
|
coinbase: "me",
|
|
difficulty: 10,
|
|
nonce: 0,
|
|
time: time.Now().Unix(),
|
|
}
|
|
|
|
return block
|
|
}
|
|
|
|
func CreateBlock(root string, num int, prevHash string, base string, difficulty int, nonce int, extra string, txes []*Transaction) *Block {
|
|
block := &Block{
|
|
// Slice of transactions to include in this block
|
|
transactions: txes,
|
|
number: uint32(num),
|
|
prevHash: prevHash,
|
|
coinbase: base,
|
|
difficulty: uint32(difficulty),
|
|
nonce: uint32(nonce),
|
|
time: time.Now().Unix(),
|
|
extra: extra,
|
|
}
|
|
block.state = NewTrie(Db, root)
|
|
|
|
for _, tx := range txes {
|
|
// Create contract if there's no recipient
|
|
if tx.recipient == "" {
|
|
addr := tx.Hash()
|
|
|
|
contract := NewContract(tx.value, []byte(""))
|
|
block.state.Update(string(addr), string(contract.MarshalRlp()))
|
|
for i, val := range tx.data {
|
|
contract.state.Update(string(Encode(uint32(i))), val)
|
|
}
|
|
block.UpdateContract(addr, contract)
|
|
}
|
|
}
|
|
|
|
return block
|
|
}
|
|
|
|
func (block *Block) GetContract(addr []byte) *Contract {
|
|
data := block.state.Get(string(addr))
|
|
contract := &Contract{}
|
|
contract.UnmarshalRlp([]byte(data))
|
|
|
|
return contract
|
|
}
|
|
|
|
func (block *Block) UpdateContract(addr []byte, contract *Contract) {
|
|
block.state.Update(string(addr), string(contract.MarshalRlp()))
|
|
}
|
|
|
|
func (block *Block) Update() {
|
|
}
|
|
|
|
// Returns a hash of the block
|
|
func (block *Block) Hash() []byte {
|
|
return Sha256Bin(block.MarshalRlp())
|
|
}
|
|
|
|
func (block *Block) MarshalRlp() []byte {
|
|
// Marshal the transactions of this block
|
|
encTx := make([]string, len(block.transactions))
|
|
for i, tx := range block.transactions {
|
|
// Cast it to a string (safe)
|
|
encTx[i] = string(tx.MarshalRlp())
|
|
}
|
|
|
|
/* I made up the block. It should probably contain different data or types. It sole purpose now is testing */
|
|
header := []interface{}{
|
|
block.number,
|
|
block.prevHash,
|
|
// Sha of uncles
|
|
"",
|
|
block.coinbase,
|
|
// root state
|
|
block.state.root,
|
|
// Sha of tx
|
|
string(Sha256Bin([]byte(Encode(encTx)))),
|
|
block.difficulty,
|
|
uint64(block.time),
|
|
block.nonce,
|
|
block.extra,
|
|
}
|
|
|
|
// TODO
|
|
uncles := []interface{}{}
|
|
// Encode a slice interface which contains the header and the list of transactions.
|
|
return Encode([]interface{}{header, encTx, uncles})
|
|
}
|
|
|
|
func (block *Block) UnmarshalRlp(data []byte) {
|
|
t, _ := Decode(data,0)
|
|
|
|
// interface slice assertion
|
|
if slice, ok := t.([]interface{}); ok {
|
|
// interface slice assertion
|
|
if header, ok := slice[0].([]interface{}); ok {
|
|
if number, ok := header[0].(uint8); ok {
|
|
block.number = uint32(number)
|
|
}
|
|
|
|
if prevHash, ok := header[1].([]uint8); ok {
|
|
block.prevHash = string(prevHash)
|
|
}
|
|
|
|
// sha of uncles is header[2]
|
|
|
|
if coinbase, ok := header[3].([]byte); ok {
|
|
block.coinbase = string(coinbase)
|
|
}
|
|
|
|
if state, ok := header[4].([]uint8); ok {
|
|
// XXX The database is currently a global variable defined in testing.go
|
|
// This will eventually go away and the database will grabbed from the public server
|
|
// interface
|
|
block.state = NewTrie(Db, string(state))
|
|
}
|
|
|
|
// sha is header[5]
|
|
|
|
// It's either 8bit or 64
|
|
if difficulty, ok := header[6].(uint8); ok {
|
|
block.difficulty = uint32(difficulty)
|
|
}
|
|
if difficulty, ok := header[6].(uint64); ok {
|
|
block.difficulty = uint32(difficulty)
|
|
}
|
|
|
|
// It's either 8bit or 64
|
|
if time, ok := header[7].(uint8); ok {
|
|
block.time = int64(time)
|
|
}
|
|
if time, ok := header[7].(uint64); ok {
|
|
block.time = int64(time)
|
|
}
|
|
|
|
if nonce, ok := header[8].(uint8); ok {
|
|
block.nonce = uint32(nonce)
|
|
}
|
|
|
|
if extra, ok := header[9].([]byte); ok {
|
|
block.extra = string(extra)
|
|
}
|
|
}
|
|
|
|
if txSlice, ok := slice[1].([]interface{}); ok {
|
|
// Create transaction slice equal to decoded tx interface slice
|
|
block.transactions = make([]*Transaction, len(txSlice))
|
|
|
|
// Unmarshal transactions
|
|
for i, tx := range txSlice {
|
|
if t, ok := tx.([]byte); ok {
|
|
tx := &Transaction{}
|
|
// Use the unmarshaled data to unmarshal the transaction
|
|
// t is still decoded.
|
|
tx.UnmarshalRlp(t)
|
|
|
|
block.transactions[i] = tx
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|