Add TransactionOutput

Author: stringintech

TODO.md

@@ -1,25 +1,10 @@
 # Bitcoin Kernel Go Wrapper - TODO
 
-This document lists the remaining C API functions and data structures from `bitcoinkernel.h` that haven't been wrapped yet in the Go kernel package.
-
-## Current Status
-
-✅ **Implemented:**
-- Chain parameters and context management
-- Block and block index operations
-- Chainstate manager functionality
-- Basic logging support
-
-❌ **Missing:**
-- Transaction processing pipeline
-- Script validation system
-- Block undo data handling
-- Complete callback system integration
+This document lists the remaining C API functions and data structures from [`bitcoinkernel.h`](./depend/bitcoin/src/kernel/bitcoinkernel.h) that haven't been wrapped yet in the Go kernel package.
 
 ## Missing Data Structures
 
 ### Core Transaction Types
-- **`kernel_TransactionOutput`** - Transaction output operations
 - **`kernel_BlockPointer`** - Non-owned block pointers (from callbacks)
 - **`kernel_BlockUndo`** - Block undo data operations
 
@@ -28,12 +13,6 @@ This document lists the remaining C API functions and data structures from `bitc
 ### Script Operations
 - [ ] `kernel_verify_script()` - **Script verification (IMPORTANT!)**
 
-### Transaction Output Operations
-- [ ] `kernel_transaction_output_create()` - Create transaction output
-- [ ] `kernel_transaction_output_destroy()` - Cleanup transaction output
-- [ ] `kernel_copy_script_pubkey_from_output()` - Extract script from output
-- [ ] `kernel_get_transaction_output_amount()` - Get output amount
-
 ### Block Operations (Additional)
 - [ ] `kernel_block_pointer_get_hash()` - Get hash from block pointer
 - [ ] `kernel_copy_block_pointer_data()` - Copy data from block pointer  

kernel/errors.go

@@ -25,4 +25,7 @@ var (
 	ErrInvalidScriptPubkeyData          = errors.New("invalid script pubkey data")
 	ErrInvalidScriptPubkey              = errors.New("invalid script pubkey")
 	ErrScriptPubkeyDataCopy             = errors.New("failed to copy script pubkey data")
+	ErrTransactionOutputCreation        = errors.New("failed to create transaction output")
+	ErrInvalidTransactionOutput         = errors.New("invalid transaction output")
+	ErrScriptPubkeyCopyFromOutput       = errors.New("failed to copy script pubkey from output")
 )

kernel/transaction_output.go

@@ -0,0 +1,65 @@
+package kernel
+
+/*
+#include "kernel/bitcoinkernel.h"
+*/
+import "C"
+import (
+	"runtime"
+)
+
+// TransactionOutput wraps the C kernel_TransactionOutput
+type TransactionOutput struct {
+	ptr *C.kernel_TransactionOutput
+}
+
+func NewTransactionOutput(scriptPubkey *ScriptPubkey, amount int64) (*TransactionOutput, error) {
+	if scriptPubkey == nil || scriptPubkey.ptr == nil {
+		return nil, ErrInvalidScriptPubkey
+	}
+
+	ptr := C.kernel_transaction_output_create(scriptPubkey.ptr, C.int64_t(amount))
+	if ptr == nil {
+		return nil, ErrTransactionOutputCreation
+	}
+
+	output := &TransactionOutput{ptr: ptr}
+	runtime.SetFinalizer(output, (*TransactionOutput).destroy)
+	return output, nil
+}
+
+// ScriptPubkey returns a copy of the script pubkey from this transaction output
+func (t *TransactionOutput) ScriptPubkey() (*ScriptPubkey, error) {
+	if t.ptr == nil {
+		return nil, ErrInvalidTransactionOutput
+	}
+
+	ptr := C.kernel_copy_script_pubkey_from_output(t.ptr)
+	if ptr == nil {
+		return nil, ErrScriptPubkeyCopyFromOutput
+	}
+
+	scriptPubkey := &ScriptPubkey{ptr: ptr}
+	runtime.SetFinalizer(scriptPubkey, (*ScriptPubkey).destroy)
+	return scriptPubkey, nil
+}
+
+func (t *TransactionOutput) Amount() int64 {
+	if t.ptr == nil {
+		return 0
+	}
+
+	return int64(C.kernel_get_transaction_output_amount(t.ptr))
+}
+
+func (t *TransactionOutput) destroy() {
+	if t.ptr != nil {
+		C.kernel_transaction_output_destroy(t.ptr)
+		t.ptr = nil
+	}
+}
+
+func (t *TransactionOutput) Destroy() {
+	runtime.SetFinalizer(t, nil)
+	t.destroy()
+}

kernel/transaction_output_test.go

@@ -0,0 +1,80 @@
+package kernel
+
+import (
+	"encoding/hex"
+	"errors"
+	"testing"
+)
+
+func TestInvalidTransactionOutput(t *testing.T) {
+	_, err := NewTransactionOutput(nil, 1000)
+	if !errors.Is(err, ErrInvalidScriptPubkey) {
+		t.Errorf("Expected ErrInvalidScriptPubkey, got %v", err)
+	}
+
+	_, err = NewTransactionOutput(&ScriptPubkey{ptr: nil}, 1000)
+	if !errors.Is(err, ErrInvalidScriptPubkey) {
+		t.Errorf("Expected ErrInvalidScriptPubkey, got %v", err)
+	}
+}
+
+func TestTransactionOutputCreation(t *testing.T) {
+	scriptHex := "76a914389ffce9cd9ae88dcc0631e88a821ffdbe9bfe26158088ac"
+	scriptBytes, err := hex.DecodeString(scriptHex)
+	if err != nil {
+		t.Fatalf("Failed to decode script hex: %v", err)
+	}
+
+	scriptPubkey, err := NewScriptPubkeyFromRaw(scriptBytes)
+	if err != nil {
+		t.Fatalf("Failed to create script pubkey: %v", err)
+	}
+	defer scriptPubkey.Destroy()
+
+	amount := int64(5000000000)
+	output, err := NewTransactionOutput(scriptPubkey, amount)
+	if err != nil {
+		t.Fatalf("NewTransactionOutput() error = %v", err)
+	}
+	defer output.Destroy()
+
+	gotAmount := output.Amount()
+	if gotAmount != amount {
+		t.Errorf("Expected amount %d, got %d", amount, gotAmount)
+	}
+
+	// Test getting script pubkey
+	gotScript, err := output.ScriptPubkey()
+	if err != nil {
+		t.Fatalf("TransactionOutput.ScriptPubkey() error = %v", err)
+	}
+	defer gotScript.Destroy()
+
+	scriptData, err := gotScript.Data()
+	if err != nil {
+		t.Fatalf("ScriptPubkey.Data() error = %v", err)
+	}
+
+	if len(scriptData) != len(scriptBytes) {
+		t.Errorf("Expected script length %d, got %d", len(scriptBytes), len(scriptData))
+	}
+
+	scriptHexGot := hex.EncodeToString(scriptData)
+	if scriptHexGot != scriptHex {
+		t.Errorf("Expected script hex: %s, got %s", scriptHex, scriptHexGot)
+	}
+}
+
+func TestTransactionOutputNilOperations(t *testing.T) {
+	output := &TransactionOutput{ptr: nil}
+
+	amount := output.Amount()
+	if amount != 0 {
+		t.Errorf("Expected amount 0 for nil ptr, got %d", amount)
+	}
+
+	_, err := output.ScriptPubkey()
+	if !errors.Is(err, ErrInvalidTransactionOutput) {
+		t.Errorf("Expected ErrInvalidTransactionOutput, got %v", err)
+	}
+}