Add writer helper, adapt to C API changes, and add new tests

Author: stringintech

README.md

@@ -101,7 +101,7 @@ The library uses structured error types for better error handling (see [errors.g
 
 ```go
 m := kernel.ChainstateManager{}
-blockIndex := m.GetBlockIndexFromGenesis() // panic: chainstateManager is not initialized
+chain, _ := m.GetActiveChain() // panic: chainstateManager is not initialized
 ```
 
 Always ensure objects are properly initialized (and not destroyed) before calling methods on them. Constructor functions like `NewChainstateManager()` return errors for validation, but method calls on receivers expect valid objects.

kernel/block.go

@@ -11,24 +11,24 @@ import (
 
 var _ cManagedResource = &Block{}
 
-// Block wraps the C kernel_Block
+// Block wraps the C btck_Block
 type Block struct {
-	ptr *C.kernel_Block
+	ptr *C.btck_Block
 }
 
 // NewBlockFromRaw creates a new block from raw serialized data
 func NewBlockFromRaw(rawBlock []byte) (*Block, error) {
 	if len(rawBlock) == 0 {
 		return nil, ErrEmptyBlockData
 	}
-	ptr := C.kernel_block_create((*C.uchar)(unsafe.Pointer(&rawBlock[0])), C.size_t(len(rawBlock)))
+	ptr := C.btck_block_create(unsafe.Pointer(&rawBlock[0]), C.size_t(len(rawBlock)))
 	if ptr == nil {
 		return nil, ErrKernelBlockCreate
 	}
 	return newBlockFromPtr(ptr), nil
 }
 
-func newBlockFromPtr(ptr *C.kernel_Block) *Block {
+func newBlockFromPtr(ptr *C.btck_Block) *Block {
 	block := &Block{ptr: ptr}
 	runtime.SetFinalizer(block, (*Block).destroy)
 	return block
@@ -37,7 +37,7 @@ func newBlockFromPtr(ptr *C.kernel_Block) *Block {
 func (b *Block) Hash() (*BlockHash, error) {
 	checkReady(b)
 
-	ptr := C.kernel_block_get_hash(b.ptr)
+	ptr := C.btck_block_get_hash(b.ptr)
 	if ptr == nil {
 		return nil, ErrKernelBlockGetHash
 	}
@@ -51,25 +51,49 @@ func (b *Block) Hash() (*BlockHash, error) {
 func (b *Block) Data() ([]byte, error) {
 	checkReady(b)
 
-	byteArray := C.kernel_block_copy_data(b.ptr)
-	if byteArray == nil {
-		return nil, ErrKernelCopyBlockData
+	// Use the callback helper to collect bytes from btck_block_to_bytes
+	return writeToBytes(func(writer C.btck_WriteBytes, userData unsafe.Pointer) C.int {
+		return C.btck_block_to_bytes(b.ptr, writer, userData)
+	})
+}
+
+// Copy creates a copy of the block
+func (b *Block) Copy() (*Block, error) {
+	checkReady(b)
+
+	ptr := C.btck_block_copy(b.ptr)
+	if ptr == nil {
+		return nil, ErrKernelBlockCopy
 	}
-	defer C.kernel_byte_array_destroy(byteArray)
 
-	size := int(byteArray.size)
-	if size == 0 {
-		return nil, nil
+	return newBlockFromPtr(ptr), nil
+}
+
+// CountTransactions returns the number of transactions in the block
+func (b *Block) CountTransactions() (uint64, error) {
+	checkReady(b)
+
+	count := C.btck_block_count_transactions(b.ptr)
+	return uint64(count), nil
+}
+
+// GetTransactionAt returns the transaction at the specified index.
+func (b *Block) GetTransactionAt(index uint64) (*Transaction, error) {
+	checkReady(b)
+
+	ptr := C.btck_block_get_transaction_at(b.ptr, C.uint64_t(index))
+	if ptr == nil {
+		return nil, ErrKernelBlockGetTransaction
 	}
 
-	// Copy the data to Go slice
-	data := C.GoBytes(unsafe.Pointer(byteArray.data), C.int(size))
-	return data, nil
+	transaction := &Transaction{ptr: ptr}
+	runtime.SetFinalizer(transaction, (*Transaction).destroy)
+	return transaction, nil
 }
 
 func (b *Block) destroy() {
 	if b.ptr != nil {
-		C.kernel_block_destroy(b.ptr)
+		C.btck_block_destroy(b.ptr)
 		b.ptr = nil
 	}
 }

kernel/block_hash.go

@@ -11,9 +11,9 @@ import (
 
 var _ cManagedResource = &BlockHash{}
 
-// BlockHash wraps the C kernel_BlockHash
+// BlockHash wraps the C btck_BlockHash
 type BlockHash struct {
-	ptr *C.kernel_BlockHash
+	ptr *C.btck_BlockHash
 }
 
 // Bytes returns the raw hash bytes
@@ -25,7 +25,7 @@ func (bh *BlockHash) Bytes() []byte {
 
 func (bh *BlockHash) destroy() {
 	if bh.ptr != nil {
-		C.kernel_block_hash_destroy(bh.ptr)
+		C.btck_block_hash_destroy(bh.ptr)
 		bh.ptr = nil
 	}
 }

kernel/block_index.go

@@ -0,0 +1,69 @@
+package kernel
+
+/*
+#include "kernel/bitcoinkernel.h"
+*/
+import "C"
+import (
+	"runtime"
+)
+
+var _ cManagedResource = &BlockSpentOutputs{}
+
+// BlockSpentOutputs wraps the C btck_BlockSpentOutputs
+type BlockSpentOutputs struct {
+	ptr *C.btck_BlockSpentOutputs
+}
+
+// Size returns the number of transaction spent outputs contained in block spent outputs
+func (bso *BlockSpentOutputs) Size() uint64 {
+	checkReady(bso)
+	return uint64(C.btck_block_spent_outputs_size(bso.ptr))
+}
+
+// GetTransactionSpentOutputsAt returns the transaction spent outputs at the specified index
+func (bso *BlockSpentOutputs) GetTransactionSpentOutputsAt(index uint64) (*TransactionSpentOutputs, error) {
+	checkReady(bso)
+	ptr := C.btck_block_spent_outputs_get_transaction_spent_outputs_at(bso.ptr, C.uint64_t(index))
+	if ptr == nil {
+		return nil, ErrBlockSpentOutputsGetTransactionSpentOutputsAt
+	}
+
+	txSpentOutputs := &TransactionSpentOutputs{ptr: ptr}
+	runtime.SetFinalizer(txSpentOutputs, (*TransactionSpentOutputs).destroy)
+	return txSpentOutputs, nil
+}
+
+// Copy creates a copy of the block spent outputs
+func (bso *BlockSpentOutputs) Copy() (*BlockSpentOutputs, error) {
+	checkReady(bso)
+
+	ptr := C.btck_block_spent_outputs_copy(bso.ptr)
+	if ptr == nil {
+		return nil, ErrKernelBlockSpentOutputsCopy
+	}
+
+	outputs := &BlockSpentOutputs{ptr: ptr}
+	runtime.SetFinalizer(outputs, (*BlockSpentOutputs).destroy)
+	return outputs, nil
+}
+
+func (bso *BlockSpentOutputs) destroy() {
+	if bso.ptr != nil {
+		C.btck_block_spent_outputs_destroy(bso.ptr)
+		bso.ptr = nil
+	}
+}
+
+func (bso *BlockSpentOutputs) Destroy() {
+	runtime.SetFinalizer(bso, nil)
+	bso.destroy()
+}
+
+func (bso *BlockSpentOutputs) isReady() bool {
+	return bso != nil && bso.ptr != nil
+}
+
+func (bso *BlockSpentOutputs) uninitializedError() error {
+	return ErrBlockSpentOutputsUninitialized
+}

kernel/block_spent_outputs.go

@@ -69,3 +69,82 @@ func TestBlockFromRaw(t *testing.T) {
 		t.Logf("Expected data hex: %s, got %s", genesisHex, hexStr)
 	}
 }
+
+func TestBlockCopy(t *testing.T) {
+	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 copying block
+	blockCopy, err := block.Copy()
+	if err != nil {
+		t.Fatalf("Block.Copy() error = %v", err)
+	}
+	if blockCopy == nil {
+		t.Fatal("Copied block is nil")
+	}
+	defer blockCopy.Destroy()
+
+	if blockCopy.ptr == nil {
+		t.Error("Copied block pointer is nil")
+	}
+}
+
+func TestBlockCountTransactions(t *testing.T) {
+	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 counting transactions (genesis block has 1 transaction)
+	txCount, err := block.CountTransactions()
+	if err != nil {
+		t.Fatalf("Block.CountTransactions() error = %v", err)
+	}
+	if txCount != 1 {
+		t.Errorf("Expected 1 transaction, got %d", txCount)
+	}
+}
+
+func TestBlockGetTransactionAt(t *testing.T) {
+	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 transaction at index 0
+	tx, err := block.GetTransactionAt(0)
+	if err != nil {
+		t.Fatalf("Block.GetTransactionAt(0) error = %v", err)
+	}
+	if tx == nil {
+		t.Fatal("Transaction is nil")
+	}
+	defer tx.Destroy()
+
+	if tx.ptr == nil {
+		t.Error("Transaction pointer is nil")
+	}
+}