Merge pull request #54 from ava-labs/remove-pow

Remove POW [Part 1]

Author: patrick-ogrady

chain/base_tx.go

@@ -4,57 +4,69 @@
 package chain
 
 import (
-	"bytes"
-
 	"github.com/ava-labs/avalanchego/ids"
-	"github.com/ava-labs/avalanchego/utils/crypto"
-
-	"github.com/ava-labs/quarkvm/parser"
 )
 
-var emptyPublicKeyBytes [crypto.SECP256K1RPKLen]byte
-
 type BaseTx struct {
-	Sender   [crypto.SECP256K1RPKLen]byte `serialize:"true" json:"sender"`
-	Graffiti uint64                       `serialize:"true" json:"graffiti"`
-	BlockID  ids.ID                       `serialize:"true" json:"blockId"`
+	// BlkID is the ID of a block in the [lookbackWindow].
+	BlkID ids.ID `serialize:"true" json:"blockId"`
 
 	// Prefix is the namespace for the "PrefixInfo"
 	// whose owner can write and read value for the
 	// specific key space.
 	// The prefix must not have the delimiter '/' as suffix.
 	// Otherwise, the verification will fail.
-	Prefix []byte `serialize:"true" json:"prefix"`
+
+	// TODO: change to string
+	// TODO: move to each tx
+	Pfx []byte `serialize:"true" json:"prefix"`
+
+	// Magic is a value defined in genesis to protect against replay attacks on
+	// different VMs.
+	Mgc uint64 `serialize:"true" json:"magic"`
+
+	// Price is the value per unit to spend on this transaction.
+	Prce uint64 `serialize:"true" json:"fee"`
 }
 
-func (b *BaseTx) SetBlockID(blockID ids.ID) {
-	b.BlockID = blockID
+func (b *BaseTx) BlockID() ids.ID {
+	return b.BlkID
 }
 
-func (b *BaseTx) SetGraffiti(graffiti uint64) {
-	b.Graffiti = graffiti
+func (b *BaseTx) SetBlockID(bid ids.ID) {
+	b.BlkID = bid
 }
 
-func (b *BaseTx) GetBlockID() ids.ID {
-	return b.BlockID
+func (b *BaseTx) Prefix() []byte {
+	return b.Pfx
 }
 
-func (b *BaseTx) GetSender() [crypto.SECP256K1RPKLen]byte {
-	return b.Sender
+func (b *BaseTx) Magic() uint64 {
+	return b.Mgc
 }
 
-func (b *BaseTx) ExecuteBase() error {
-	if err := parser.CheckPrefix(b.Prefix); err != nil {
-		return err
-	}
+func (b *BaseTx) SetMagic(magic uint64) {
+	b.Mgc = magic
+}
 
-	if bytes.Equal(b.Sender[:], emptyPublicKeyBytes[:]) {
-		return ErrInvalidSender
-	}
+func (b *BaseTx) Price() uint64 {
+	return b.Prce
+}
 
-	if b.BlockID == ids.Empty {
+func (b *BaseTx) SetPrice(price uint64) {
+	b.Prce = price
+}
+
+func (b *BaseTx) ExecuteBase(g *Genesis) error {
+	if b.BlkID == ids.Empty {
 		return ErrInvalidBlockID
 	}
+	if g.Magic != b.Mgc {
+		return ErrInvalidMagic
+	}
+	if b.Prce < g.MinPrice {
+		return ErrInvalidPrice
+	}
 	return nil
 }
 
@@ -67,16 +79,14 @@ func (b *BaseTx) LoadUnits(g *Genesis) uint64 {
 }
 
 func (b *BaseTx) Copy() *BaseTx {
-	sender := [crypto.SECP256K1RPKLen]byte{}
-	copy(sender[:], b.Sender[:])
 	blockID := ids.ID{}
-	copy(blockID[:], b.BlockID[:])
-	prefix := make([]byte, len(b.Prefix))
-	copy(prefix, b.Prefix)
+	copy(blockID[:], b.BlkID[:])
+	prefix := make([]byte, len(b.Pfx))
+	copy(prefix, b.Pfx)
 	return &BaseTx{
-		Sender:   sender,
-		BlockID:  blockID,
-		Graffiti: b.Graffiti,
-		Prefix:   prefix,
+		BlkID: blockID,
+		Pfx:   prefix,
+		Mgc:   b.Mgc,
+		Prce:  b.Prce,
 	}
 }

chain/base_tx_test.go

@@ -16,60 +16,58 @@ import (
 func TestBaseTx(t *testing.T) {
 	t.Parallel()
 
-	priv, err := f.NewPrivateKey()
-	if err != nil {
-		t.Fatal(err)
-	}
-	sender, err := FormatPK(priv.PublicKey())
-	if err != nil {
-		t.Fatal(err)
-	}
-
 	tt := []struct {
-		tx  *BaseTx
-		err error
+		tx        *BaseTx
+		baseTxErr error
+		prefixErr error
 	}{
 		{
-			tx:  &BaseTx{Sender: sender, Prefix: []byte("foo"), BlockID: ids.GenerateTestID()},
-			err: nil,
+			tx: &BaseTx{Pfx: []byte("foo"), BlkID: ids.GenerateTestID(), Prce: 1},
 		},
 		{
-			tx:  &BaseTx{Prefix: []byte("foo"), BlockID: ids.GenerateTestID()},
-			err: ErrInvalidSender,
+			tx:        &BaseTx{Pfx: []byte("foo"), BlkID: ids.GenerateTestID()},
+			baseTxErr: ErrInvalidPrice,
 		},
 		{
-			tx:  &BaseTx{Sender: sender, Prefix: []byte("fo/a")},
-			err: parser.ErrInvalidDelimiter,
+			tx:        &BaseTx{Pfx: []byte("fo/a"), BlkID: ids.GenerateTestID()},
+			prefixErr: parser.ErrInvalidDelimiter,
 		},
 		{
-			tx:  &BaseTx{Sender: sender, Prefix: []byte("foo/")},
-			err: parser.ErrInvalidDelimiter,
+			tx:        &BaseTx{Pfx: []byte("foo/"), BlkID: ids.GenerateTestID()},
+			prefixErr: parser.ErrInvalidDelimiter,
 		},
 		{
-			tx:  &BaseTx{Sender: sender, Prefix: []byte("foo")},
-			err: ErrInvalidBlockID,
+			tx:        &BaseTx{Pfx: []byte("foo")},
+			baseTxErr: ErrInvalidBlockID,
 		},
 		{
 			tx: &BaseTx{
-				Sender:  sender,
-				BlockID: ids.GenerateTestID(),
-				Prefix:  nil,
+				BlkID: ids.GenerateTestID(),
+				Pfx:   nil,
 			},
-			err: parser.ErrPrefixEmpty,
+			prefixErr: parser.ErrPrefixEmpty,
 		},
 		{
 			tx: &BaseTx{
-				Sender:  sender,
-				BlockID: ids.GenerateTestID(),
-				Prefix:  bytes.Repeat([]byte{'a'}, parser.MaxPrefixSize+1),
+				BlkID: ids.GenerateTestID(),
+				Pfx:   bytes.Repeat([]byte{'a'}, parser.MaxPrefixSize+1),
 			},
-			err: parser.ErrPrefixTooBig,
+			prefixErr: parser.ErrPrefixTooBig,
 		},
 	}
+	g := DefaultGenesis()
 	for i, tv := range tt {
-		err := tv.tx.ExecuteBase()
-		if !errors.Is(err, tv.err) {
-			t.Fatalf("#%d: tx.Execute err expected %v, got %v", i, tv.err, err)
+		err := tv.tx.ExecuteBase(g)
+		if tv.baseTxErr != nil && !errors.Is(err, tv.baseTxErr) {
+			t.Fatalf("#%d: tx.Execute err expected %v, got %v", i, tv.baseTxErr, err)
+		}
+		if tv.prefixErr == nil {
+			continue
+		}
+		tx := &ClaimTx{BaseTx: tv.tx}
+		err = tx.Execute(&TransactionContext{Genesis: g})
+		if !errors.Is(err, tv.prefixErr) {
+			t.Fatalf("#%d: tx.Execute err expected %v, got %v", i, tv.prefixErr, err)
 		}
 	}
 }

chain/block.go

@@ -12,21 +12,21 @@ import (
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/snow/choices"
 	"github.com/ava-labs/avalanchego/snow/consensus/snowman"
+	"github.com/ava-labs/avalanchego/utils/hashing"
 	log "github.com/inconshreveable/log15"
-	"golang.org/x/crypto/sha3"
 )
 
 const futureBound = 10 * time.Second
 
 var _ snowman.Block = &StatelessBlock{}
 
 type StatefulBlock struct {
-	Prnt       ids.ID         `serialize:"true" json:"parent"`
-	Tmstmp     int64          `serialize:"true" json:"timestamp"`
-	Hght       uint64         `serialize:"true" json:"height"`
-	Difficulty uint64         `serialize:"true" json:"difficulty"` // difficulty per unit
-	Cost       uint64         `serialize:"true" json:"cost"`
-	Txs        []*Transaction `serialize:"true" json:"txs"`
+	Prnt   ids.ID         `serialize:"true" json:"parent"`
+	Tmstmp int64          `serialize:"true" json:"timestamp"`
+	Hght   uint64         `serialize:"true" json:"height"`
+	Price  uint64         `serialize:"true" json:"price"`
+	Cost   uint64         `serialize:"true" json:"cost"`
+	Txs    []*Transaction `serialize:"true" json:"txs"`
 
 	Beneficiary []byte `serialize:"true" json:"beneficiary"` // prefix to reward
 }
@@ -53,7 +53,7 @@ func NewBlock(vm VM, parent snowman.Block, tmstp int64, beneficiary []byte, cont
 			Tmstmp:      tmstp,
 			Prnt:        parent.ID(),
 			Hght:        parent.Height() + 1,
-			Difficulty:  context.NextDifficulty,
+			Price:       context.NextPrice,
 			Cost:        context.NextCost,
 			Beneficiary: beneficiary,
 		},
@@ -94,8 +94,7 @@ func ParseStatefulBlock(
 		st:            status,
 		vm:            vm,
 	}
-	h := sha3.Sum256(b.bytes)
-	id, err := ids.ToID(h[:])
+	id, err := ids.ToID(hashing.ComputeHash256(b.bytes))
 	if err != nil {
 		return nil, err
 	}
@@ -116,8 +115,7 @@ func (b *StatelessBlock) init() error {
 	}
 	b.bytes = bytes
 
-	h := sha3.Sum256(b.bytes)
-	id, err := ids.ToID(h[:])
+	id, err := ids.ToID(hashing.ComputeHash256(b.bytes))
 	if err != nil {
 		return err
 	}
@@ -162,8 +160,8 @@ func (b *StatelessBlock) verify() (*StatelessBlock, *versiondb.Database, error)
 	if b.Cost != context.NextCost {
 		return nil, nil, ErrInvalidCost
 	}
-	if b.Difficulty != context.NextDifficulty {
-		return nil, nil, ErrInvalidDifficulty
+	if b.Price != context.NextPrice {
+		return nil, nil, ErrInvalidPrice
 	}
 
 	parentState, err := parent.onAccept()
@@ -182,19 +180,20 @@ func (b *StatelessBlock) verify() (*StatelessBlock, *versiondb.Database, error)
 	}
 
 	// Process new transactions
-	log.Debug("build context", "height", b.Hght, "difficulty", b.Difficulty, "cost", b.Cost)
-	surplusWork := uint64(0)
+	log.Debug("build context", "height", b.Hght, "price", b.Price, "cost", b.Cost)
+	surplusFee := uint64(0)
 	for _, tx := range b.Txs {
 		if err := tx.Execute(g, onAcceptDB, b.Tmstmp, context); err != nil {
 			return nil, nil, err
 		}
-		surplusWork += (tx.Difficulty() - b.Difficulty) * tx.FeeUnits(g)
+		surplusFee += (tx.Price() - b.Price) * tx.FeeUnits(g)
 	}
-	// Ensure enough work is performed to compensate for block production speed
-	requiredSurplus := b.Difficulty * b.Cost
-	if surplusWork < requiredSurplus {
-		return nil, nil, fmt.Errorf("%w: required=%d found=%d", ErrInsufficientSurplus, requiredSurplus, surplusWork)
+	// Ensure enough fee is paid to compensate for block production speed
+	requiredSurplus := b.Price * b.Cost
+	if surplusFee < requiredSurplus {
+		return nil, nil, fmt.Errorf("%w: required=%d found=%d", ErrInsufficientSurplus, requiredSurplus, surplusFee)
 	}
+	// TODO: send non-surplus fee to a random prefix owner
 	return parent, onAcceptDB, nil
 }