Add Context, ContextOptions, and ChainParameters

stringintech · stringintech · commit 49eb8ae8028e · 2025-06-22T13:46:56.000+03:30
diff --git a/kernel/chain_parameters.go b/kernel/chain_parameters.go
@@ -0,0 +1,63 @@
+package kernel
+
+/*
+#include "kernel/bitcoinkernel.h"
+*/
+import "C"
+import "runtime"
+
+// ChainType represents the Bitcoin network type
+type ChainType int
+
+const (
+	ChainTypeMainnet ChainType = iota
+	ChainTypeTestnet
+	ChainTypeTestnet4
+	ChainTypeSignet
+	ChainTypeRegtest
+)
+
+// ChainParameters wraps the C kernel_ChainParameters
+type ChainParameters struct {
+	ptr *C.kernel_ChainParameters
+}
+
+func NewChainParameters(chainType ChainType) (*ChainParameters, error) {
+	var cChainType C.kernel_ChainType
+
+	switch chainType {
+	case ChainTypeMainnet:
+		cChainType = C.kernel_CHAIN_TYPE_MAINNET
+	case ChainTypeTestnet:
+		cChainType = C.kernel_CHAIN_TYPE_TESTNET
+	case ChainTypeTestnet4:
+		cChainType = C.kernel_CHAIN_TYPE_TESTNET_4
+	case ChainTypeSignet:
+		cChainType = C.kernel_CHAIN_TYPE_SIGNET
+	case ChainTypeRegtest:
+		cChainType = C.kernel_CHAIN_TYPE_REGTEST
+	default:
+		return nil, ErrInvalidChainType
+	}
+
+	ptr := C.kernel_chain_parameters_create(cChainType)
+	if ptr == nil {
+		return nil, ErrChainParametersCreation
+	}
+
+	cp := &ChainParameters{ptr: ptr}
+	runtime.SetFinalizer(cp, (*ChainParameters).destroy)
+	return cp, nil
+}
+
+func (cp *ChainParameters) destroy() {
+	if cp.ptr != nil {
+		C.kernel_chain_parameters_destroy(cp.ptr)
+		cp.ptr = nil
+	}
+}
+
+func (cp *ChainParameters) Destroy() {
+	runtime.SetFinalizer(cp, nil)
+	cp.destroy()
+}
diff --git a/kernel/chain_parameters_test.go b/kernel/chain_parameters_test.go
@@ -0,0 +1,81 @@
+package kernel
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestNewChainParameters(t *testing.T) {
+	tests := []struct {
+		name      string
+		chainType ChainType
+		wantErr   bool
+		errType   error
+	}{
+		{
+			name:      "Mainnet chain parameters",
+			chainType: ChainTypeMainnet,
+			wantErr:   false,
+		},
+		{
+			name:      "Testnet chain parameters",
+			chainType: ChainTypeTestnet,
+			wantErr:   false,
+		},
+		{
+			name:      "Testnet4 chain parameters",
+			chainType: ChainTypeTestnet4,
+			wantErr:   false,
+		},
+		{
+			name:      "Signet chain parameters",
+			chainType: ChainTypeSignet,
+			wantErr:   false,
+		},
+		{
+			name:      "Regtest chain parameters",
+			chainType: ChainTypeRegtest,
+			wantErr:   false,
+		},
+		{
+			name:      "Invalid chain type",
+			chainType: ChainType(999),
+			wantErr:   true,
+			errType:   ErrInvalidChainType,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cp, err := NewChainParameters(tt.chainType)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("NewChainParameters() error = nil, wantErr %v", tt.wantErr)
+					return
+				}
+				if tt.errType != nil && !errors.Is(err, tt.errType) {
+					t.Errorf("NewChainParameters() error = %v, want %v", err, tt.errType)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("NewChainParameters() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if cp == nil {
+				t.Error("NewChainParameters() returned nil ChainParameters")
+				return
+			}
+
+			if cp.ptr == nil {
+				t.Error("ChainParameters has nil pointer")
+			}
+
+			// Clean up
+			cp.Destroy()
+		})
+	}
+}
diff --git a/kernel/context.go b/kernel/context.go
@@ -0,0 +1,78 @@
+package kernel
+
+/*
+#include "kernel/bitcoinkernel.h"
+*/
+import "C"
+import (
+	"errors"
+	"runtime"
+)
+
+// Context wraps the C kernel_Context
+// Once other validation objects are instantiated from it, the context needs to be kept in
+// memory for the duration of their lifetimes.
+//
+// A constructed context can be safely used from multiple threads.
+type Context struct {
+	ptr *C.kernel_Context
+}
+
+// NewContext creates a new kernel context with the specified options.
+// Kernel copies all necessary data from the options during context creation,
+// so the caller can safely free the options object after this call returns.
+func NewContext(options *ContextOptions) (*Context, error) {
+	if options == nil {
+		return nil, errors.New("context options cannot be nil")
+	}
+
+	ptr := C.kernel_context_create(options.ptr)
+	if ptr == nil {
+		return nil, ErrContextCreation
+	}
+
+	ctx := &Context{ptr: ptr}
+	runtime.SetFinalizer(ctx, (*Context).destroy)
+	return ctx, nil
+}
+
+// NewDefaultContext creates a new kernel context with default mainnet parameters.
+// The defer statements are safe here because the Kernel copies all necessary
+// data during context creation, so the caller can safely free the options and
+// parameters objects immediately after the context is created.
+func NewDefaultContext() (*Context, error) {
+	opts, err := NewContextOptions()
+	if err != nil {
+		return nil, err
+	}
+	defer opts.Destroy()
+
+	params, err := NewChainParameters(ChainTypeMainnet)
+	if err != nil {
+		return nil, err
+	}
+	defer params.Destroy()
+
+	opts.SetChainParams(params)
+	return NewContext(opts)
+}
+
+// Interrupt can be used to halt long-running validation functions
+func (ctx *Context) Interrupt() bool {
+	if ctx.ptr == nil {
+		return false
+	}
+	return bool(C.kernel_context_interrupt(ctx.ptr))
+}
+
+func (ctx *Context) destroy() {
+	if ctx.ptr != nil {
+		C.kernel_context_destroy(ctx.ptr)
+		ctx.ptr = nil
+	}
+}
+
+func (ctx *Context) Destroy() {
+	runtime.SetFinalizer(ctx, nil)
+	ctx.destroy()
+}
diff --git a/kernel/context_options.go b/kernel/context_options.go
@@ -0,0 +1,50 @@
+package kernel
+
+/*
+#include "kernel/bitcoinkernel.h"
+*/
+import "C"
+import (
+	"runtime"
+)
+
+// ContextOptions wraps the C kernel_ContextOptions
+type ContextOptions struct {
+	ptr *C.kernel_ContextOptions
+}
+
+func NewContextOptions() (*ContextOptions, error) {
+	ptr := C.kernel_context_options_create()
+	if ptr == nil {
+		return nil, ErrContextOptionsCreation
+	}
+
+	opts := &ContextOptions{ptr: ptr}
+	runtime.SetFinalizer(opts, (*ContextOptions).destroy)
+	return opts, nil
+}
+
+// SetChainParams sets the chain parameters for these context options.
+// Kernel makes a copy of the chain parameters, so the caller can
+// safely free the chainParams object after this call returns.
+func (opts *ContextOptions) SetChainParams(chainParams *ChainParameters) {
+	if opts.ptr == nil {
+		panic("ContextOptions pointer is nil")
+	}
+	if chainParams.ptr == nil {
+		panic("ChainParameters pointer is nil")
+	}
+	C.kernel_context_options_set_chainparams(opts.ptr, chainParams.ptr)
+}
+
+func (opts *ContextOptions) destroy() {
+	if opts.ptr != nil {
+		C.kernel_context_options_destroy(opts.ptr)
+		opts.ptr = nil
+	}
+}
+
+func (opts *ContextOptions) Destroy() {
+	runtime.SetFinalizer(opts, nil)
+	opts.destroy()
+}
diff --git a/kernel/context_test.go b/kernel/context_test.go
@@ -0,0 +1,118 @@
+package kernel
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestNewContext(t *testing.T) {
+	tests := []struct {
+		name        string
+		setupOption func() *ContextOptions
+		wantErr     bool
+		errType     error
+	}{
+		{
+			name: "Valid context options",
+			setupOption: func() *ContextOptions {
+				opts, err := NewContextOptions()
+				if err != nil {
+					t.Fatalf("Failed to create context options: %v", err)
+				}
+				params, err := NewChainParameters(ChainTypeMainnet)
+				if err != nil {
+					t.Fatalf("Failed to create chain parameters: %v", err)
+				}
+				defer params.Destroy()
+				opts.SetChainParams(params)
+				return opts
+			},
+			wantErr: false,
+		},
+		{
+			name: "Nil context options",
+			setupOption: func() *ContextOptions {
+				return nil
+			},
+			wantErr: true,
+			errType: errors.New("context options cannot be nil"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			opts := tt.setupOption()
+			if opts != nil {
+				defer opts.Destroy()
+			}
+
+			ctx, err := NewContext(opts)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("NewContext() error = nil, wantErr %v", tt.wantErr)
+					return
+				}
+				if tt.errType != nil && err.Error() != tt.errType.Error() {
+					t.Errorf("NewContext() error = %v, want %v", err, tt.errType)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("NewContext() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if ctx == nil {
+				t.Error("NewContext() returned nil Context")
+				return
+			}
+
+			if ctx.ptr == nil {
+				t.Error("Context has nil pointer")
+			}
+
+			// Clean up
+			ctx.Destroy()
+		})
+	}
+}
+
+func TestNewDefaultContext(t *testing.T) {
+	ctx, err := NewDefaultContext()
+
+	if err != nil {
+		t.Errorf("NewDefaultContext() error = %v, want nil", err)
+		return
+	}
+
+	if ctx == nil {
+		t.Error("NewDefaultContext() returned nil Context")
+		return
+	}
+
+	if ctx.ptr == nil {
+		t.Error("Context has nil pointer")
+	}
+}
+
+func TestContextInterrupt(t *testing.T) {
+	ctx, err := NewDefaultContext()
+	if err != nil {
+		t.Fatalf("Failed to create default context: %v", err)
+	}
+	defer ctx.Destroy()
+
+	// Test interrupt on valid context
+	result := ctx.Interrupt()
+	// Result can be true or false, both could be valid
+	t.Logf("Context interrupt result: %v", result)
+
+	// Destroy and test interrupt on destroyed context
+	ctx.Destroy()
+	result = ctx.Interrupt()
+	if result {
+		t.Error("Interrupt() should return false after context is destroyed")
+	}
+}
diff --git a/kernel/errors.go b/kernel/errors.go
diff --git a/kernel/kernel.go b/kernel/kernel.go
