ed4478bc72
Move self-contained pieces into their own package. This spells out the depedencies and the context each sub-package focuses on. Not the final structure as it's WIP. Just tying the knots while climbing up the rope.
326 lines
7 KiB
Go
326 lines
7 KiB
Go
package claimnode
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"fmt"
|
|
"math"
|
|
"strconv"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
|
|
"github.com/lbryio/claimtrie/claim"
|
|
"github.com/lbryio/claimtrie/memento"
|
|
)
|
|
|
|
var dbg bool
|
|
|
|
// Node ...
|
|
type Node struct {
|
|
memento.Memento
|
|
|
|
height claim.Height
|
|
bestClaims map[claim.Height]*claim.Claim
|
|
claims map[wire.OutPoint]*claim.Claim
|
|
supports map[wire.OutPoint]*claim.Support
|
|
}
|
|
|
|
// NewNode ...
|
|
func NewNode() *Node {
|
|
return &Node{
|
|
Memento: memento.Memento{},
|
|
bestClaims: map[claim.Height]*claim.Claim{0: nil},
|
|
claims: map[wire.OutPoint]*claim.Claim{},
|
|
supports: map[wire.OutPoint]*claim.Support{},
|
|
}
|
|
}
|
|
|
|
// Height ...
|
|
func (n *Node) Height() claim.Height {
|
|
return n.height
|
|
}
|
|
|
|
// BestClaim ...
|
|
func (n *Node) BestClaim() *claim.Claim {
|
|
var latest claim.Height
|
|
for k := range n.bestClaims {
|
|
if k > latest {
|
|
latest = k
|
|
}
|
|
}
|
|
return n.bestClaims[latest]
|
|
}
|
|
|
|
// Tookover ...
|
|
func (n *Node) Tookover() claim.Height {
|
|
var latest claim.Height
|
|
for k := range n.bestClaims {
|
|
if k > latest {
|
|
latest = k
|
|
}
|
|
}
|
|
return latest
|
|
}
|
|
|
|
// IncrementBlock ...
|
|
func (n *Node) IncrementBlock(h claim.Height) error {
|
|
if h < 0 {
|
|
return ErrInvalidHeight
|
|
}
|
|
for i := claim.Height(0); i < h; i++ {
|
|
n.height++
|
|
n.processBlock()
|
|
n.Commit()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DecrementBlock ...
|
|
func (n *Node) DecrementBlock(h claim.Height) error {
|
|
if h < 0 {
|
|
return ErrInvalidHeight
|
|
}
|
|
for i := claim.Height(0); i < h; i++ {
|
|
n.height--
|
|
n.Rollback()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AddClaim ...
|
|
func (n *Node) AddClaim(op wire.OutPoint, amt claim.Amount) (*claim.Claim, error) {
|
|
c := &claim.Claim{
|
|
OutPoint: op,
|
|
ID: claim.NewID(op),
|
|
Amt: amt,
|
|
Accepted: n.height + 1,
|
|
ActiveAt: n.height + 1,
|
|
}
|
|
if n.BestClaim() != nil {
|
|
c.ActiveAt = calActiveHeight(c.Accepted, c.Accepted, n.Tookover())
|
|
}
|
|
|
|
n.Execute(cmdAddClaim{node: n, claim: c})
|
|
return c, nil
|
|
}
|
|
|
|
// RemoveClaim ...
|
|
func (n *Node) RemoveClaim(op wire.OutPoint) error {
|
|
c, ok := n.claims[op]
|
|
if !ok {
|
|
return ErrNotFound
|
|
}
|
|
n.Execute(cmdRemoveClaim{node: n, claim: c})
|
|
|
|
if n.BestClaim() != c {
|
|
return nil
|
|
}
|
|
n.Execute(updateNodeBestClaim{node: n, height: n.Tookover(), old: c, new: nil})
|
|
n.updateActiveHeights()
|
|
return nil
|
|
}
|
|
|
|
// AddSupport ...
|
|
func (n *Node) AddSupport(op wire.OutPoint, amt claim.Amount, supported claim.ID) (*claim.Support, error) {
|
|
s := &claim.Support{
|
|
OutPoint: op,
|
|
Amt: amt,
|
|
SupportedID: supported,
|
|
Accepted: n.height + 1,
|
|
ActiveAt: n.height + 1,
|
|
}
|
|
if n.BestClaim() == nil || n.BestClaim().OutPoint != op {
|
|
s.ActiveAt = calActiveHeight(s.Accepted, s.Accepted, n.Tookover())
|
|
}
|
|
|
|
for _, c := range n.claims {
|
|
if c.ID != supported {
|
|
continue
|
|
}
|
|
n.Execute(cmdAddSupport{node: n, support: s})
|
|
return s, nil
|
|
}
|
|
|
|
// Is supporting an non-existing Claim aceepted?
|
|
return nil, ErrNotFound
|
|
}
|
|
|
|
// RemoveSupport ...
|
|
func (n *Node) RemoveSupport(op wire.OutPoint) error {
|
|
s, ok := n.supports[op]
|
|
if !ok {
|
|
return ErrNotFound
|
|
}
|
|
n.Execute(cmdRemoveSupport{node: n, support: s})
|
|
return nil
|
|
}
|
|
|
|
// FindNextUpdateHeights ...
|
|
func (n *Node) FindNextUpdateHeights() claim.Height {
|
|
next := claim.Height(math.MaxInt64)
|
|
for _, v := range n.claims {
|
|
if v.ActiveAt > n.height && v.ActiveAt < next {
|
|
next = v.ActiveAt
|
|
}
|
|
}
|
|
for _, v := range n.supports {
|
|
if v.ActiveAt > n.height && v.ActiveAt < next {
|
|
next = v.ActiveAt
|
|
}
|
|
}
|
|
if next == claim.Height(math.MaxInt64) {
|
|
return n.height
|
|
}
|
|
return next
|
|
}
|
|
|
|
// Hash calculates the Hash value based on the OutPoint and at which height it tookover.
|
|
func (n *Node) Hash() chainhash.Hash {
|
|
if n.BestClaim() == nil {
|
|
return chainhash.Hash{}
|
|
}
|
|
return calNodeHash(n.BestClaim().OutPoint, n.Tookover())
|
|
}
|
|
|
|
// MarshalJSON customizes JSON marshaling of the Node.
|
|
func (n *Node) MarshalJSON() ([]byte, error) {
|
|
c := make([]*claim.Claim, 0, len(n.claims))
|
|
for _, v := range n.claims {
|
|
c = append(c, v)
|
|
}
|
|
s := make([]*claim.Support, 0, len(n.supports))
|
|
for _, v := range n.supports {
|
|
s = append(s, v)
|
|
}
|
|
return json.Marshal(&struct {
|
|
Height claim.Height
|
|
Hash string
|
|
Tookover claim.Height
|
|
BestClaim *claim.Claim
|
|
Claims []*claim.Claim
|
|
Supports []*claim.Support
|
|
}{
|
|
Height: n.height,
|
|
Hash: n.Hash().String(),
|
|
Tookover: n.Tookover(),
|
|
BestClaim: n.BestClaim(),
|
|
Claims: c,
|
|
Supports: s,
|
|
})
|
|
}
|
|
|
|
// String implements Stringer interface.
|
|
func (n *Node) String() string {
|
|
if dbg {
|
|
w := bytes.NewBuffer(nil)
|
|
fmt.Fprintf(w, "H: %2d BestClaims: ", n.height)
|
|
for k, v := range n.bestClaims {
|
|
if v == nil {
|
|
fmt.Fprintf(w, "{%d, nil}, ", k)
|
|
continue
|
|
}
|
|
fmt.Fprintf(w, "{%d, %d}, ", k, v.Index)
|
|
}
|
|
fmt.Fprintf(w, "\n")
|
|
for _, v := range n.claims {
|
|
fmt.Fprintf(w, "\n %v", v)
|
|
if v == n.BestClaim() {
|
|
fmt.Fprintf(w, " <B> ")
|
|
}
|
|
}
|
|
for _, v := range n.supports {
|
|
fmt.Fprintf(w, "\n %v", v)
|
|
}
|
|
fmt.Fprintf(w, "\n")
|
|
return w.String()
|
|
|
|
}
|
|
b, err := json.MarshalIndent(n, "", " ")
|
|
if err != nil {
|
|
panic("can't marshal Node")
|
|
}
|
|
return string(b)
|
|
}
|
|
func (n *Node) updateEffectiveAmounts() {
|
|
for _, c := range n.claims {
|
|
c.EffAmt = c.Amt
|
|
if c.ActiveAt > n.height {
|
|
c.EffAmt = 0
|
|
continue
|
|
}
|
|
for _, s := range n.supports {
|
|
if s.ActiveAt > n.height || s.SupportedID != c.ID {
|
|
continue
|
|
}
|
|
c.EffAmt += s.Amt
|
|
}
|
|
}
|
|
}
|
|
|
|
func (n *Node) updateActiveHeights() {
|
|
for _, v := range n.claims {
|
|
if old, new := v.ActiveAt, calActiveHeight(v.Accepted, n.height, n.height); old != new {
|
|
n.Execute(cmdUpdateClaimActiveHeight{claim: v, old: old, new: new})
|
|
}
|
|
}
|
|
for _, v := range n.supports {
|
|
if old, new := v.ActiveAt, calActiveHeight(v.Accepted, n.height, n.height); old != new {
|
|
n.Execute(cmdUpdateSupportActiveHeight{support: v, old: old, new: new})
|
|
}
|
|
}
|
|
}
|
|
func (n *Node) processBlock() {
|
|
for {
|
|
candidate := findCandiadte(n)
|
|
if n.BestClaim() == candidate {
|
|
return
|
|
}
|
|
n.Execute(updateNodeBestClaim{node: n, height: n.height, old: n.bestClaims[n.height], new: candidate})
|
|
n.updateActiveHeights()
|
|
}
|
|
}
|
|
|
|
func findCandiadte(n *Node) *claim.Claim {
|
|
n.updateEffectiveAmounts()
|
|
var candidate *claim.Claim
|
|
for _, v := range n.claims {
|
|
if v.ActiveAt > n.height {
|
|
continue
|
|
}
|
|
if candidate == nil || v.EffAmt > candidate.EffAmt {
|
|
candidate = v
|
|
}
|
|
}
|
|
return candidate
|
|
}
|
|
|
|
func calNodeHash(op wire.OutPoint, tookover claim.Height) chainhash.Hash {
|
|
txHash := chainhash.DoubleHashH(op.Hash[:])
|
|
|
|
nOut := []byte(strconv.Itoa(int(op.Index)))
|
|
nOutHash := chainhash.DoubleHashH(nOut)
|
|
|
|
buf := make([]byte, 8)
|
|
binary.BigEndian.PutUint64(buf, uint64(tookover))
|
|
heightHash := chainhash.DoubleHashH(buf)
|
|
|
|
h := make([]byte, 0, sha256.Size*3)
|
|
h = append(h, txHash[:]...)
|
|
h = append(h, nOutHash[:]...)
|
|
h = append(h, heightHash[:]...)
|
|
|
|
return chainhash.DoubleHashH(h)
|
|
}
|
|
|
|
var proportionalDelayFactor = claim.Height(32)
|
|
|
|
func calActiveHeight(Accepted, curr, tookover claim.Height) claim.Height {
|
|
delay := (curr - tookover) / proportionalDelayFactor
|
|
if delay > 4032 {
|
|
delay = 4032
|
|
}
|
|
return Accepted + delay
|
|
}
|