Cleanup Progress

chain/block.go

@@ -181,7 +181,7 @@ func (b *StatelessBlock) verify() (*StatelessBlock, *versiondb.Database, error)
 	}
 	onAcceptDB := versiondb.New(parentState)
 
-	// Remove all expired prefixes
+	// Remove all expired spaces
 	if err := ExpireNext(onAcceptDB, parent.Tmstmp, b.Tmstmp, b.vm.IsBootstrapped()); err != nil {
 		return nil, nil, err
 	}

chain/builder.go

@@ -40,7 +40,7 @@ func BuildBlock(vm VM, preferred ids.ID) (snowman.Block, error) {
 	}
 	vdb := versiondb.New(parentDB)
 
-	// Remove all expired prefixes
+	// Remove all expired spaces
 	if err := ExpireNext(vdb, parent.Tmstmp, b.Tmstmp, true); err != nil {
 		return nil, err
 	}
@@ -79,7 +79,7 @@ func BuildBlock(vm VM, preferred ids.ID) (snowman.Block, error) {
 		if err := tvdb.Commit(); err != nil {
 			return nil, err
 		}
-		// Wait to add prefix until after verification
+		// Wait to add spaces until after verification
 		b.Txs = append(b.Txs, next)
 		units += nextLoad
 	}

chain/claim_tx.go

@@ -35,7 +35,7 @@ func (c *ClaimTx) Execute(t *TransactionContext) error {
 		return err
 	}
 
-	// Restrict address prefix to be owned by address
+	// Restrict address space to be owned by address
 	if len(c.Space) == hexAddressLen && strings.ToLower(t.Sender.Hex()) != c.Space {
 		return ErrAddressMismatch
 	}
@@ -55,7 +55,7 @@ func (c *ClaimTx) Execute(t *TransactionContext) error {
 		Created: t.BlockTime,
 		Updated: t.BlockTime,
 		Expiry:  t.BlockTime + t.Genesis.ClaimReward,
-		Units:   1,
+		Units:   t.Genesis.MinClaimFee,
 	}
 	if err := PutSpaceInfo(t.Database, []byte(c.Space), newInfo, 0); err != nil {
 		return err

chain/claim_tx_test.go

@@ -41,13 +41,13 @@ func TestClaimTx(t *testing.T) {
 		sender    common.Address
 		err       error
 	}{
-		{ // invalid claim, [42]byte prefix is reserved for pubkey
+		{ // invalid claim, [42]byte space is reserved for pubkey
 			tx:        &ClaimTx{BaseTx: &BaseTx{}, Space: strings.Repeat("a", hexAddressLen)},
 			blockTime: 1,
 			sender:    sender,
 			err:       ErrAddressMismatch,
 		},
-		{ // valid claim, [42]byte prefix is reserved for pubkey
+		{ // valid claim, [42]byte space is reserved for pubkey
 			tx:        &ClaimTx{BaseTx: &BaseTx{}, Space: strings.ToLower(sender.Hex())},
 			blockTime: 1,
 			sender:    sender,
@@ -86,7 +86,7 @@ func TestClaimTx(t *testing.T) {
 	}
 	for i, tv := range tt {
 		if i > 0 {
-			// Expire old prefixes between txs
+			// Expire old spaces between txs
 			if err := ExpireNext(db, tt[i-1].blockTime, tv.blockTime, true); err != nil {
 				t.Fatalf("#%d: ExpireNext errored %v", i, err)
 			}
@@ -107,10 +107,10 @@ func TestClaimTx(t *testing.T) {
 		}
 		info, exists, err := GetSpaceInfo(db, []byte(tv.tx.Space))
 		if err != nil {
-			t.Fatalf("#%d: failed to get prefix info %v", i, err)
+			t.Fatalf("#%d: failed to get space info %v", i, err)
 		}
 		if !exists {
-			t.Fatalf("#%d: failed to find prefix info", i)
+			t.Fatalf("#%d: failed to find space info", i)
 		}
 		if !bytes.Equal(info.Owner[:], tv.sender[:]) {
 			t.Fatalf("#%d: unexpected owner found (expected pub key %q)", i, string(sender[:]))
@@ -130,9 +130,9 @@ func TestClaimTx(t *testing.T) {
 	}
 	_, exists, err := GetSpaceInfo(db, []byte("foo"))
 	if err != nil {
-		t.Fatalf("failed to get prefix info %v", err)
+		t.Fatalf("failed to get space info %v", err)
 	}
 	if exists {
-		t.Fatal("prefix should not exist")
+		t.Fatal("space should not exist")
 	}
 }

chain/errors.go

@@ -18,7 +18,7 @@ var (
 	ErrNoTxs                  = errors.New("no transactions")
 	ErrInvalidCost            = errors.New("invalid block cost")
 	ErrInvalidPrice           = errors.New("invalid price")
-	ErrInsufficientSurplus    = errors.New("insufficient surplus difficulty")
+	ErrInsufficientSurplus    = errors.New("insufficient surplus fee")
 	ErrParentBlockNotVerified = errors.New("parent block not verified or accepted")
 
 	// Tx Correctness

chain/lifeline_tx.go

@@ -15,15 +15,15 @@ var _ UnsignedTransaction = &LifelineTx{}
 type LifelineTx struct {
 	*BaseTx `serialize:"true" json:"baseTx"`
 
-	// Space is the namespace for the "PrefixInfo"
+	// Space is the namespace for the "SpaceInfo"
 	// whose owner can write and read value for the
 	// specific key space.
+	//
 	// The space must be ^[a-z0-9]{1,256}$.
 	Space string `serialize:"true" json:"space"`
 
-	// Units is the additional fee the sender pays to extend the life of their
-	// space. The added expiry time is a function of:
-	// [Units] * [LifelineInterval].
+	// Units is the number of [ClaimReward] to extend
+	// the life of the [Space].
 	Units uint64 `serialize:"true" json:"units"`
 }
 

chain/lifeline_tx_test.go

@@ -32,7 +32,7 @@ func TestLifelineTx(t *testing.T) {
 		sender    common.Address
 		err       error
 	}{
-		{ // invalid when prefix info is missing
+		{ // invalid when space info is missing
 			utx:       &LifelineTx{BaseTx: &BaseTx{}, Space: "foo", Units: 1},
 			blockTime: 1,
 			sender:    sender,
@@ -50,7 +50,7 @@ func TestLifelineTx(t *testing.T) {
 			sender:    sender,
 			err:       ErrNonActionable,
 		},
-		{ // successful lifeline when prefix info and units is not missing
+		{ // successful lifeline when space info and units is not missing
 			utx:       &LifelineTx{BaseTx: &BaseTx{}, Space: "foo", Units: 1},
 			blockTime: 1,
 			sender:    sender,

chain/move_tx_test.go

@@ -55,14 +55,14 @@ func TestMoveTx(t *testing.T) {
 	}
 
 	// Items: transfer without balance, transfer with small balance, transfer some balance, transfer from
-	// account that now has balance, transfer prefix, transfer to self
+	// account that now has balance, transfer space, transfer to self
 	tt := []struct {
 		utx       UnsignedTransaction
 		blockTime uint64
 		sender    common.Address
 		err       error
 	}{
-		{ // invalid when prefix is not owned
+		{ // invalid when space is not owned
 			utx:       &MoveTx{BaseTx: &BaseTx{}, Space: "foo", To: sender3},
 			blockTime: 1,
 			sender:    sender,
@@ -80,13 +80,13 @@ func TestMoveTx(t *testing.T) {
 			sender:    sender,
 			err:       ErrNonActionable,
 		},
-		{ // successful prefix transfer
+		{ // successful space transfer
 			utx:       &MoveTx{BaseTx: &BaseTx{}, Space: "foo", To: sender3},
 			blockTime: 1,
 			sender:    sender,
 			err:       nil,
 		},
-		{ // prefix looking bad
+		{ // space looking bad
 			utx:       &MoveTx{BaseTx: &BaseTx{}, Space: "foo/", To: sender3},
 			blockTime: 1,
 			sender:    sender,

chain/set_tx_test.go

@@ -227,7 +227,7 @@ func TestSetTx(t *testing.T) {
 	}
 	for i, tv := range tt {
 		if i > 0 {
-			// Expire old prefixes between txs
+			// Expire old spaces between txs
 			if err := ExpireNext(db, tt[i-1].blockTime, tv.blockTime, true); err != nil {
 				t.Fatalf("#%d: ExpireNext errored %v", i, err)
 			}
@@ -261,10 +261,10 @@ func TestSetTx(t *testing.T) {
 		case *ClaimTx: // "ClaimTx.Execute" must persist "SpaceInfo"
 			info, exists, err := GetSpaceInfo(db, []byte(tp.Space))
 			if err != nil {
-				t.Fatalf("#%d: failed to get prefix info %v", i, err)
+				t.Fatalf("#%d: failed to get space info %v", i, err)
 			}
 			if !exists {
-				t.Fatalf("#%d: failed to find prefix info", i)
+				t.Fatalf("#%d: failed to find space info", i)
 			}
 			if !bytes.Equal(info.Owner[:], tv.sender[:]) {
 				t.Fatalf("#%d: unexpected owner found (expected pub key %q)", i, string(sender[:]))

chain/storage.go

@@ -22,7 +22,6 @@ import (
 	"github.com/ava-labs/spacesvm/parser"
 )
 
-// TODO: cleanup mapping diagram
 // 0x0/ (block hashes)
 // 0x1/ (tx hashes)
 //   -> [tx hash]=>nil
@@ -404,32 +403,32 @@ func ExpireNext(db database.Database, rparent int64, rcurrent int64, bootstrappe
 		}
 
 		// [space]
-		pfx := cursor.Value()
+		spc := cursor.Value()
 
 		// [infoPrefix] + [delimiter] + [space]
-		k := SpaceInfoKey(pfx)
+		k := SpaceInfoKey(spc)
 		if err := db.Delete(k); err != nil {
 			return err
 		}
-		expired, rpfx, err := extractSpecificTimeKey(curKey)
+		expired, rspc, err := extractSpecificTimeKey(curKey)
 		if err != nil {
 			return err
 		}
 
 		if bootstrapped {
 			// [pruningPrefix] + [delimiter] + [timestamp] + [delimiter] + [rawSpace]
-			k = PrefixPruningKey(expired, rpfx)
+			k = PrefixPruningKey(expired, rspc)
 			if err := db.Put(k, nil); err != nil {
 				return err
 			}
 		} else {
 			// If we are not yet bootstrapped, we should delete the dangling value keys
 			// immediately instead of clearing async.
-			if err := database.ClearPrefix(db, db, SpaceValueKey(rpfx, nil)); err != nil {
+			if err := database.ClearPrefix(db, db, SpaceValueKey(rspc, nil)); err != nil {
 				return err
 			}
 		}
-		log.Debug("space expired", "space", string(pfx))
+		log.Debug("space expired", "space", string(spc))
 	}
 	return nil
 }
@@ -449,18 +448,18 @@ func PruneNext(db database.Database, limit int) (removals int, err error) {
 		if bytes.Compare(curKey, endKey) > 0 { // curKey > endKey; end search
 			break
 		}
-		_, rpfx, err := extractSpecificTimeKey(curKey)
+		_, rspc, err := extractSpecificTimeKey(curKey)
 		if err != nil {
 			return removals, err
 		}
 		if err := db.Delete(curKey); err != nil {
 			return removals, err
 		}
 		// [keyPrefix] + [delimiter] + [rawSpace] + [delimiter] + [key]
-		if err := database.ClearPrefix(db, db, SpaceValueKey(rpfx, nil)); err != nil {
+		if err := database.ClearPrefix(db, db, SpaceValueKey(rspc, nil)); err != nil {
 			return removals, err
 		}
-		log.Debug("rspace pruned", "rspace", rpfx.Hex())
+		log.Debug("rspace pruned", "rspace", rspc.Hex())
 		removals++
 	}
 	return removals, nil

chain/storage_test.go

@@ -19,18 +19,18 @@ func TestSpaceValueKey(t *testing.T) {
 	t.Parallel()
 
 	tt := []struct {
-		rpfx     ids.ShortID
+		rspc     ids.ShortID
 		key      []byte
 		valueKey []byte
 	}{
 		{
-			rpfx:     ids.ShortID{0x1},
+			rspc:     ids.ShortID{0x1},
 			key:      []byte("hello"),
 			valueKey: append([]byte{keyPrefix}, []byte("/\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/hello")...), //nolint:lll
 		},
 	}
 	for i, tv := range tt {
-		vv := SpaceValueKey(tv.rpfx, tv.key)
+		vv := SpaceValueKey(tv.rspc, tv.key)
 		if !bytes.Equal(tv.valueKey, vv) {
 			t.Fatalf("#%d: value expected %q, got %q", i, tv.valueKey, vv)
 		}
@@ -41,16 +41,16 @@ func TestSpaceInfoKey(t *testing.T) {
 	t.Parallel()
 
 	tt := []struct {
-		pfx     []byte
+		spc     []byte
 		infoKey []byte
 	}{
 		{
-			pfx:     []byte("foo"),
+			spc:     []byte("foo"),
 			infoKey: append([]byte{infoPrefix}, []byte("/foo")...),
 		},
 	}
 	for i, tv := range tt {
-		vv := SpaceInfoKey(tv.pfx)
+		vv := SpaceInfoKey(tv.spc)
 		if !bytes.Equal(tv.infoKey, vv) {
 			t.Fatalf("#%d: value expected %q, got %q", i, tv.infoKey, vv)
 		}
@@ -105,55 +105,55 @@ func TestPutSpaceInfoAndKey(t *testing.T) {
 	db := memdb.New()
 	defer db.Close()
 
-	pfx := []byte("foo")
+	spc := []byte("foo")
 	k, v := []byte("k"), &ValueMeta{}
 
-	// expect failures for non-existing prefixInfo
-	if ok, err := HasSpace(db, pfx); ok || err != nil {
+	// expect failures for non-existing spaceInfo
+	if ok, err := HasSpace(db, spc); ok || err != nil {
 		t.Fatalf("unexpected ok %v, err %v", ok, err)
 	}
-	if ok, err := HasSpaceKey(db, pfx, k); ok || err != nil {
+	if ok, err := HasSpaceKey(db, spc, k); ok || err != nil {
 		t.Fatalf("unexpected ok %v, err %v", ok, err)
 	}
-	if err := PutSpaceKey(db, pfx, k, v); !errors.Is(err, ErrSpaceMissing) {
+	if err := PutSpaceKey(db, spc, k, v); !errors.Is(err, ErrSpaceMissing) {
 		t.Fatalf("unexpected error %v, expected %v", err, ErrSpaceMissing)
 	}
 
 	if err := PutSpaceInfo(
 		db,
-		pfx,
+		spc,
 		&SpaceInfo{
 			RawSpace: ids.ShortID{0x1},
 		},
 		0,
 	); err != nil {
 		t.Fatal(err)
 	}
-	if err := PutSpaceKey(db, pfx, k, v); err != nil {
+	if err := PutSpaceKey(db, spc, k, v); err != nil {
 		t.Fatalf("unexpected error %v", err)
 	}
 
-	// expect success for existing prefixInfo
-	if ok, err := HasSpace(db, pfx); !ok || err != nil {
+	// expect success for existing spaceInfo
+	if ok, err := HasSpace(db, spc); !ok || err != nil {
 		t.Fatalf("unexpected ok %v, err %v", ok, err)
 	}
-	if ok, err := HasSpaceKey(db, pfx, k); !ok || err != nil {
+	if ok, err := HasSpaceKey(db, spc, k); !ok || err != nil {
 		t.Fatalf("unexpected ok %v, err %v", ok, err)
 	}
 }
 
 func TestSpecificTimeKey(t *testing.T) {
-	rpfx0 := ids.ShortID{'k'}
-	k := PrefixExpiryKey(100, rpfx0)
-	ts, rpfx, err := extractSpecificTimeKey(k)
+	rspc0 := ids.ShortID{'k'}
+	k := PrefixExpiryKey(100, rspc0)
+	ts, rspc, err := extractSpecificTimeKey(k)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if ts != 100 {
 		t.Fatalf("unexpected timestamp %d, expected 100", ts)
 	}
-	if rpfx != rpfx0 {
-		t.Fatalf("unexpected rawPrefix %v, expected %v", rpfx, rpfx0)
+	if rspc != rspc0 {
+		t.Fatalf("unexpected rawSpace %v, expected %v", rspc, rspc0)
 	}
 
 	if _, _, err = extractSpecificTimeKey(k[:10]); !errors.Is(err, ErrInvalidKeyFormat) {
@@ -336,7 +336,7 @@ func TestGetAllValueMetas(t *testing.T) {
 	}
 	for i, tv := range tt {
 		if i > 0 {
-			// Expire old prefixes between txs
+			// Expire old spaces between txs
 			if err := ExpireNext(db, tt[i-1].blockTime, tv.blockTime, true); err != nil {
 				t.Fatalf("#%d: ExpireNext errored %v", i, err)
 			}

chain/transfer_tx_test.go

@@ -54,7 +54,7 @@ func TestTransferTx(t *testing.T) {
 	}
 
 	// Items: transfer without balance, transfer with small balance, transfer some balance, transfer from
-	// account that now has balance, transfer prefix, transfer to self
+	// account that now has balance, transfer space, transfer to self
 	tt := []struct {
 		utx       UnsignedTransaction
 		blockTime uint64