Add encode/decode keystone

database/tbcd/database.go

@@ -21,6 +21,7 @@ import (
 	"github.com/syndtr/goleveldb/leveldb"
 
 	"github.com/hemilabs/heminetwork/database"
+	"github.com/hemilabs/heminetwork/hemi"
 )
 
 type InsertType int
@@ -125,8 +126,8 @@ type Database interface {
 }
 
 type Keystone struct {
-	BlockHash           chainhash.Hash // Block that contains abbreviated keystone
-	AbbreviatedKeystone []byte         // Abbreviated keystone
+	BlockHash           chainhash.Hash                 // Block that contains abbreviated keystone
+	AbbreviatedKeystone [hemi.L2KeystoneAbrevSize]byte // Abbreviated keystone
 }
 
 // XXX there exist various types in this file that need to be reevaluated.

database/tbcd/level/level.go

@@ -296,11 +296,7 @@ func (l *ldb) BlockKeystoneByL2KeystoneAbrevHash(ctx context.Context, abrevhash
 		return nil, fmt.Errorf("l2 keystone get: %w", err)
 	}
 
-	ks := tbcd.Keystone{
-		BlockHash:           chainhash.Hash(eks[:32]),
-		AbbreviatedKeystone: eks[32:],
-	}
-
+	ks := decodeKeystone(eks)
 	return &ks, nil
 }
 
@@ -1729,6 +1725,32 @@ func (l *ldb) BlockTxUpdate(ctx context.Context, direction int, txs map[tbcd.TxK
 	return nil
 }
 
+// encodeKeystone encodes a database keystone as
+// [blockhash,abbreviated keystone] or [32+76] bytes. The abbreviated keystone
+// hash is the leveldb table key.
+func encodeKeystone(ks tbcd.Keystone) (eks [chainhash.HashSize + hemi.L2KeystoneAbrevSize]byte) {
+	copy(eks[0:32], ks.BlockHash[:])
+	copy(eks[32:], ks.AbbreviatedKeystone[:])
+	return
+}
+
+func encodeKeystoneToSlice(ks tbcd.Keystone) []byte {
+	eks := encodeKeystone(ks)
+	return eks[:]
+}
+
+// decodeKeystone reverse the process of encodeKeystone.
+func decodeKeystone(eks []byte) (ks tbcd.Keystone) {
+	bh, err := chainhash.NewHash(eks[0:32])
+	if err != nil {
+		panic(err) // Can't happen
+	}
+	ks.BlockHash = *bh
+	// copy the values to prevent slicing reentrancy problems.
+	copy(ks.AbbreviatedKeystone[:], eks[32:])
+	return ks
+}
+
 func (l *ldb) BlockKeystoneUpdate(ctx context.Context, direction int, keystones map[chainhash.Hash]tbcd.Keystone) error {
 	log.Tracef("BlockKeystoneUpdate")
 	defer log.Tracef("BlockKeystoneUpdate exit")
@@ -1748,17 +1770,15 @@ func (l *ldb) BlockKeystoneUpdate(ctx context.Context, direction int, keystones
 	for k, v := range keystones {
 		switch direction {
 		case -1:
-			foundKeystone, err := kssTx.Get(k[:], nil)
+			eks, err := kssTx.Get(k[:], nil)
 			if err != nil {
 				continue
 			}
-			fbh, err := chainhash.NewHash(foundKeystone[0:32])
-			if err != nil {
-				return err // XXX really can't happen
-			}
+			ks := decodeKeystone(eks)
 			// Only delete keystone if it is in the previously found block.
-			if fbh.IsEqual(&v.BlockHash) {
+			if ks.BlockHash.IsEqual(&v.BlockHash) {
 				kssBatch.Delete(k[:])
+			} else {
 			}
 		case 1:
 			has, err := kssTx.Has(k[:], nil)
@@ -1769,10 +1789,7 @@ func (l *ldb) BlockKeystoneUpdate(ctx context.Context, direction int, keystones
 				// Only store unknown keystones
 				continue
 			}
-			var value [chainhash.HashSize + hemi.L2KeystoneAbrevSize]byte
-			copy(value[0:32], v.BlockHash[:])
-			copy(value[32:], v.AbbreviatedKeystone)
-			kssBatch.Put(k[:], value[:])
+			kssBatch.Put(k[:], encodeKeystoneToSlice(v))
 		}
 	}
 

service/tbc/crawler.go

@@ -1241,7 +1241,7 @@ func processKeystones(blockHash *chainhash.Hash, txs []*btcutil.Tx, kssCache map
 			abvKss := aPoPTx.L2Keystone.Serialize()
 			kssCache[*aPoPTx.L2Keystone.Hash()] = tbcd.Keystone{
 				BlockHash:           *blockHash,
-				AbbreviatedKeystone: abvKss[:],
+				AbbreviatedKeystone: abvKss,
 			}
 		}
 	}

service/tbc/rpc_test.go

@@ -1594,7 +1594,7 @@ func TestL2BlockByAbrevHash(t *testing.T) {
 
 			kssCache[*hemi.L2KeystoneAbbreviate(l2Keystone).Hash()] = tbcd.Keystone{
 				BlockHash:           btcBlockHash,
-				AbbreviatedKeystone: abrvKss[:],
+				AbbreviatedKeystone: abrvKss,
 			}
 
 			if err := s.db.BlockKeystoneUpdate(ctx, 1, kssCache); err != nil {

service/tbc/tbcfork_test.go

@@ -865,7 +865,7 @@ func (b *btcNode) mine(name string, from *chainhash.Hash, payToAddress btcutil.A
 		abrvKs := hemi.L2KeystoneAbbreviate(l2Keystone).Serialize()
 		blk.kss[*hemi.L2KeystoneAbbreviate(l2Keystone).Hash()] = tbcd.Keystone{
 			BlockHash:           *blk.Hash(),
-			AbbreviatedKeystone: abrvKs[:],
+			AbbreviatedKeystone: abrvKs,
 		}
 	}