Refactor BlockHash wrapper based on kernelApi_66

Author: stringintech

kernel/block.go

@@ -37,7 +37,7 @@ func NewBlock(rawBlock []byte) (*Block, error) {
 }
 
 func (b *Block) Hash() *BlockHash {
-	return newBlockHash(C.btck_block_get_hash((*C.btck_Block)(b.ptr)))
+	return newBlockHash(C.btck_block_get_hash((*C.btck_Block)(b.ptr)), true)
 }
 
 // Bytes returns the consensus serialized block

kernel/block_hash.go

@@ -14,17 +14,32 @@ func (blockHashCFuncs) destroy(ptr unsafe.Pointer) {
 	C.btck_block_hash_destroy((*C.btck_BlockHash)(ptr))
 }
 
+func (blockHashCFuncs) copy(ptr unsafe.Pointer) unsafe.Pointer {
+	return unsafe.Pointer(C.btck_block_hash_copy((*C.btck_BlockHash)(ptr)))
+}
+
 type BlockHash struct {
-	*uniqueHandle
+	*handle
+}
+
+func newBlockHash(ptr *C.btck_BlockHash, fromOwned bool) *BlockHash {
+	h := newHandle(unsafe.Pointer(ptr), blockHashCFuncs{}, fromOwned)
+	return &BlockHash{handle: h}
 }
 
-func newBlockHash(ptr *C.btck_BlockHash) *BlockHash {
-	h := newUniqueHandle(unsafe.Pointer(ptr), blockHashCFuncs{})
-	return &BlockHash{uniqueHandle: h}
+// NewBlockHash creates a new BlockHash from raw 32-byte hash data
+func NewBlockHash(hashBytes [32]byte) *BlockHash {
+	ptr := C.btck_block_hash_create((*C.uchar)(unsafe.Pointer(&hashBytes[0])))
+	return newBlockHash(ptr, true)
 }
 
 // Bytes returns the raw hash bytes
-func (bh *BlockHash) Bytes() []byte {
-	// BlockHash is a 32-byte array in the C struct
-	return C.GoBytes(unsafe.Pointer(&(*C.btck_BlockHash)(bh.ptr).hash[0]), 32)
+func (bh *BlockHash) Bytes() [32]byte {
+	var output [32]C.uchar
+	C.btck_block_hash_to_bytes((*C.btck_BlockHash)(bh.ptr), &output[0])
+	return *(*[32]byte)(unsafe.Pointer(&output[0]))
+}
+
+func (bh *BlockHash) Copy() *BlockHash {
+	return newBlockHash((*C.btck_BlockHash)(bh.ptr), false)
 }

kernel/block_hash_test.go

@@ -0,0 +1,43 @@
+package kernel
+
+import (
+	"encoding/hex"
+	"testing"
+)
+
+func TestBlockHash(t *testing.T) {
+	genesisHex := "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000"
+	genesisBytes, err := hex.DecodeString(genesisHex)
+	if err != nil {
+		t.Fatalf("Failed to decode genesis hex: %v", err)
+	}
+
+	block, err := NewBlock(genesisBytes)
+	if err != nil {
+		t.Fatalf("NewBlock() error = %v", err)
+	}
+	defer block.Destroy()
+
+	hash := block.Hash()
+	defer hash.Destroy()
+
+	hashBytes := hash.Bytes()
+
+	newHash := NewBlockHash(hashBytes)
+	defer newHash.Destroy()
+
+	newHashBytes := newHash.Bytes()
+
+	if hashBytes != newHashBytes {
+		t.Errorf("Hash bytes differ: %x != %x", hashBytes, newHashBytes)
+	}
+
+	copiedHash := hash.Copy()
+	defer copiedHash.Destroy()
+
+	copiedHashBytes := copiedHash.Bytes()
+
+	if hashBytes != copiedHashBytes {
+		t.Errorf("Copied hash bytes differ: %x != %x", hashBytes, copiedHashBytes)
+	}
+}

kernel/block_test.go

@@ -32,14 +32,10 @@ func TestBlockFromRaw(t *testing.T) {
 	hash := block.Hash()
 	defer hash.Destroy()
 
-	hashBytes := hash.Bytes()
-	if len(hashBytes) != 32 {
-		t.Errorf("Expected hash length 32, got %d", len(hashBytes))
-	}
-
 	// Expected genesis block hash (reversed byte order for display)
 	expectedHash := "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
-	actualHashHex := hex.EncodeToString(reverseBytes(hashBytes))
+	hashBytes := hash.Bytes()
+	actualHashHex := hex.EncodeToString(reverseBytes(hashBytes[:]))
 	if actualHashHex != expectedHash {
 		t.Logf("Actual hash: %s", actualHashHex)
 		t.Logf("Expected hash: %s", expectedHash)

kernel/block_tree_entry.go

@@ -15,7 +15,7 @@ func (bi *BlockTreeEntry) Height() int32 {
 
 func (bi *BlockTreeEntry) Hash() *BlockHash {
 	ptr := C.btck_block_tree_entry_get_block_hash(bi.ptr)
-	return newBlockHash(check(ptr))
+	return newBlockHash(check(ptr), true)
 }
 
 func (bi *BlockTreeEntry) Previous() *BlockTreeEntry {

kernel/chain_test.go

@@ -16,36 +16,17 @@ func TestChain(t *testing.T) {
 
 	// Test GetGenesis
 	genesis := chain.GetGenesis()
-
 	height := genesis.Height()
 	if height != 0 {
 		t.Errorf("Expected genesis height 0, got %d", height)
 	}
 
-	genesisHash := genesis.Hash()
-	defer genesisHash.Destroy()
-
-	hashBytes := genesisHash.Bytes()
-	if len(hashBytes) != 32 {
-		t.Errorf("Expected hash length 32, got %d", len(hashBytes))
-	}
-
 	// Test GetTip
 	tip := chain.GetTip()
-
 	tipHeight := tip.Height()
 	if tipHeight <= 0 {
 		t.Errorf("Expected tip height > 0, got %d", tipHeight)
 	}
-
-	tipHash := tip.Hash()
-	defer tipHash.Destroy()
-
-	tipHashBytes := tipHash.Bytes()
-	if len(tipHashBytes) != 32 {
-		t.Errorf("Expected hash length 32, got %d", len(tipHashBytes))
-	}
-
 	if tip.Height() != suite.ImportedBlocksCount {
 		t.Errorf("Expected tip height %d, got %d", suite.ImportedBlocksCount, tip.Height())
 	}

kernel/chainstate_manager_test.go

@@ -69,7 +69,6 @@ func (s *ChainstateManagerTestSuite) TestReadBlock(t *testing.T) {
 
 	// Test reading genesis block
 	genesis := chain.GetGenesis()
-
 	genesisBlock, err := s.Manager.ReadBlock(genesis)
 	if err != nil {
 		t.Fatalf("ChainstateManager.ReadBlock() for genesis error = %v", err)
@@ -79,18 +78,8 @@ func (s *ChainstateManagerTestSuite) TestReadBlock(t *testing.T) {
 	}
 	defer genesisBlock.Destroy()
 
-	// Verify genesis block has expected properties
-	genesisHash := genesisBlock.Hash()
-	defer genesisHash.Destroy()
-
-	hashBytes := genesisHash.Bytes()
-	if len(hashBytes) != 32 {
-		t.Errorf("Expected hash length 32, got %d", len(hashBytes))
-	}
-
 	// Test reading tip block
 	tip := chain.GetTip()
-
 	tipBlock, err := s.Manager.ReadBlock(tip)
 	if err != nil {
 		t.Fatalf("ChainstateManager.ReadBlock() for tip error = %v", err)
@@ -99,15 +88,6 @@ func (s *ChainstateManagerTestSuite) TestReadBlock(t *testing.T) {
 		t.Fatal("Read tip block is nil")
 	}
 	defer tipBlock.Destroy()
-
-	// Verify tip block properties
-	tipHash := tipBlock.Hash()
-	defer tipHash.Destroy()
-
-	tipHashBytes := tipHash.Bytes()
-	if len(tipHashBytes) != 32 {
-		t.Errorf("Expected tip hash length 32, got %d", len(tipHashBytes))
-	}
 }
 
 func (s *ChainstateManagerTestSuite) TestGetBlockTreeEntryByHash(t *testing.T) {