Add Block and BlockHash

Author: stringintech

kernel/block.go

@@ -0,0 +1,80 @@
+package kernel
+
+/*
+#include "kernel/bitcoinkernel.h"
+*/
+import "C"
+import (
+	"runtime"
+	"unsafe"
+)
+
+// Block wraps the C kernel_Block
+type Block struct {
+	ptr *C.kernel_Block
+}
+
+// NewBlockFromRaw creates a new block from raw serialized data
+func NewBlockFromRaw(rawBlock []byte) (*Block, error) {
+	if len(rawBlock) == 0 {
+		return nil, ErrInvalidBlockData
+	}
+
+	ptr := C.kernel_block_create((*C.uchar)(unsafe.Pointer(&rawBlock[0])), C.size_t(len(rawBlock)))
+	if ptr == nil {
+		return nil, ErrBlockCreation
+	}
+
+	block := &Block{ptr: ptr}
+	runtime.SetFinalizer(block, (*Block).destroy)
+	return block, nil
+}
+
+func (b *Block) Hash() (*BlockHash, error) {
+	if b.ptr == nil {
+		return nil, ErrInvalidBlock
+	}
+
+	ptr := C.kernel_block_get_hash(b.ptr)
+	if ptr == nil {
+		return nil, ErrHashCalculation
+	}
+
+	hash := &BlockHash{ptr: ptr}
+	runtime.SetFinalizer(hash, (*BlockHash).destroy)
+	return hash, nil
+}
+
+// Data returns the serialized block data
+func (b *Block) Data() ([]byte, error) {
+	if b.ptr == nil {
+		return nil, ErrInvalidBlock
+	}
+
+	byteArray := C.kernel_copy_block_data(b.ptr)
+	if byteArray == nil {
+		return nil, ErrBlockDataCopy
+	}
+	defer C.kernel_byte_array_destroy(byteArray)
+
+	size := int(byteArray.size)
+	if size == 0 {
+		return nil, nil
+	}
+
+	// Copy the data to Go slice
+	data := C.GoBytes(unsafe.Pointer(byteArray.data), C.int(size))
+	return data, nil
+}
+
+func (b *Block) destroy() {
+	if b.ptr != nil {
+		C.kernel_block_destroy(b.ptr)
+		b.ptr = nil
+	}
+}
+
+func (b *Block) Destroy() {
+	runtime.SetFinalizer(b, nil)
+	b.destroy()
+}

kernel/block_hash.go

@@ -0,0 +1,36 @@
+package kernel
+
+/*
+#include "kernel/bitcoinkernel.h"
+*/
+import "C"
+import (
+	"runtime"
+	"unsafe"
+)
+
+// BlockHash wraps the C kernel_BlockHash
+type BlockHash struct {
+	ptr *C.kernel_BlockHash
+}
+
+func (bh *BlockHash) destroy() {
+	if bh.ptr != nil {
+		C.kernel_block_hash_destroy(bh.ptr)
+		bh.ptr = nil
+	}
+}
+
+func (bh *BlockHash) Destroy() {
+	runtime.SetFinalizer(bh, nil)
+	bh.destroy()
+}
+
+// Bytes returns the raw hash bytes
+func (bh *BlockHash) Bytes() []byte {
+	if bh.ptr == nil {
+		return nil
+	}
+	// BlockHash is a 32-byte array in the C struct
+	return C.GoBytes(unsafe.Pointer(&bh.ptr.hash[0]), 32)
+}

kernel/block_test.go

@@ -0,0 +1,71 @@
+package kernel
+
+import (
+	"encoding/hex"
+	"errors"
+	"testing"
+)
+
+func TestInvalidBlockData(t *testing.T) {
+	// Test with empty data
+	_, err := NewBlockFromRaw([]byte{})
+	if !errors.Is(err, ErrInvalidBlockData) {
+		t.Errorf("Expected ErrInvalidBlockData, got %v", err)
+	}
+
+	// Test with invalid data
+	_, err = NewBlockFromRaw([]byte{0x00, 0x01, 0x02})
+	if !errors.Is(err, ErrBlockCreation) {
+		t.Errorf("Expected ErrBlockCreation, got %v", err)
+	}
+}
+
+func TestBlockFromRaw(t *testing.T) {
+	// Complete Bitcoin mainnet genesis block (285 bytes)
+	genesisHex := "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000"
+	genesisBytes, err := hex.DecodeString(genesisHex)
+	if err != nil {
+		t.Fatalf("Failed to decode genesis hex: %v", err)
+	}
+
+	block, err := NewBlockFromRaw(genesisBytes)
+	if err != nil {
+		t.Fatalf("NewBlockFromRaw() error = %v", err)
+	}
+	defer block.Destroy()
+
+	// Test getting block hash
+	hash, err := block.Hash()
+	if err != nil {
+		t.Fatalf("Block.Hash() error = %v", err)
+	}
+	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))
+	if actualHashHex != expectedHash {
+		t.Logf("Actual hash: %s", actualHashHex)
+		t.Logf("Expected hash: %s", expectedHash)
+	}
+
+	// Test getting block data
+	data, err := block.Data()
+	if err != nil {
+		t.Fatalf("Block.Data() error = %v", err)
+	}
+
+	if len(data) != len(genesisBytes) {
+		t.Errorf("Expected data length %d, got %d", len(genesisBytes), len(data))
+	}
+
+	hexStr := hex.EncodeToString(data)
+	if hexStr != genesisHex {
+		t.Logf("Expected data hex: %s, got %s", genesisHex, hexStr)
+	}
+}

kernel/errors.go

@@ -7,4 +7,9 @@ var (
 	ErrContextOptionsCreation  = errors.New("failed to create context options")
 	ErrContextCreation         = errors.New("failed to create kernel context")
 	ErrInvalidChainType        = errors.New("invalid chain type")
+	ErrBlockCreation           = errors.New("failed to create block from raw data")
+	ErrInvalidBlockData        = errors.New("invalid block data")
+	ErrInvalidBlock            = errors.New("invalid block")
+	ErrHashCalculation         = errors.New("failed to calculate hash")
+	ErrBlockDataCopy           = errors.New("failed to copy block data")
 )

kernel/utils.go

@@ -0,0 +1,10 @@
+package kernel
+
+// ReverseBytes reverses bytes for display
+func ReverseBytes(data []byte) []byte {
+	result := make([]byte, len(data))
+	for i, b := range data {
+		result[len(data)-1-i] = b
+	}
+	return result
+}