Adapt to C API changes

stringintech · stringintech · commit 2a7e97038e85 · 2025-07-20T00:13:08.000+03:30
diff --git a/Makefile b/Makefile
@@ -30,20 +30,25 @@ test:
 clean:
 	rm -rf depend/bitcoin/build
 	go clean ./...
+	go clean -testcache
 
 lint:
 	golangci-lint run ./...
 
 deps:
 	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
 
+update-kernel:
+	git subtree pull --prefix=depend/bitcoin https://github.com/TheCharlatan/bitcoin.git kernelApi --squash
+
 help:
 	@echo "Available targets:"
-	@echo "  all		- Build kernel library and run tests (default)"
-	@echo "  build-kernel	- Build Bitcoin kernel library"
-	@echo "  build		- Compile Go code"
-	@echo "  test        	- Run Go tests"
-	@echo "  clean       	- Clean build artifacts"
-	@echo "  lint        	- Lint Go code"
-	@echo "  deps        	- Install development dependencies"
-	@echo "  help        	- Show this help message"
+	@echo "  all			- Build kernel library and run tests (default)"
+	@echo "  build-kernel		- Build Bitcoin kernel library"
+	@echo "  build			- Compile Go code"
+	@echo "  test        		- Run Go tests"
+	@echo "  clean       		- Clean build artifacts"
+	@echo "  lint        		- Lint Go code"
+	@echo "  deps        		- Install development dependencies"
+	@echo "  update-kernel  	- Update Bitcoin dependency using git subtree"
+	@echo "  help        		- Show this help message"
diff --git a/kernel/block.go b/kernel/block.go
@@ -51,7 +51,7 @@ func (b *Block) Hash() (*BlockHash, error) {
 func (b *Block) Data() ([]byte, error) {
 	checkReady(b)
 
-	byteArray := C.kernel_copy_block_data(b.ptr)
+	byteArray := C.kernel_block_copy_data(b.ptr)
 	if byteArray == nil {
 		return nil, ErrKernelCopyBlockData
 	}
diff --git a/kernel/block_index.go b/kernel/block_index.go
@@ -36,7 +36,7 @@ func (bi *BlockIndex) Hash() (*BlockHash, error) {
 func (bi *BlockIndex) Previous() *BlockIndex {
 	checkReady(bi)
 
-	ptr := C.kernel_get_previous_block_index(bi.ptr)
+	ptr := C.kernel_block_index_get_previous(bi.ptr)
 	if ptr == nil {
 		return nil
 	}
diff --git a/kernel/block_undo.go b/kernel/block_undo.go
@@ -25,22 +25,22 @@ func (bu *BlockUndo) Size() uint64 {
 // contained in the transaction undo data at the specified index
 func (bu *BlockUndo) GetTransactionUndoSize(transactionUndoIndex uint64) uint64 {
 	checkReady(bu)
-	return uint64(C.kernel_get_transaction_undo_size(bu.ptr, C.uint64_t(transactionUndoIndex)))
+	return uint64(C.kernel_block_undo_get_transaction_undo_size(bu.ptr, C.uint64_t(transactionUndoIndex)))
 }
 
 // GetUndoOutputHeightByIndex returns the block height of the block that contains
 // the output at output_index within the transaction undo data at the provided index
 func (bu *BlockUndo) GetUndoOutputHeightByIndex(transactionUndoIndex, outputIndex uint64) uint32 {
 	checkReady(bu)
-	return uint32(C.kernel_get_undo_output_height_by_index(bu.ptr, C.uint64_t(transactionUndoIndex), C.uint64_t(outputIndex)))
+	return uint32(C.kernel_block_undo_get_transaction_output_height_by_index(bu.ptr, C.uint64_t(transactionUndoIndex), C.uint64_t(outputIndex)))
 }
 
 // GetUndoOutputByIndex returns a transaction output contained in the transaction
 // undo data at the specified indices
 func (bu *BlockUndo) GetUndoOutputByIndex(transactionUndoIndex, outputIndex uint64) (*TransactionOutput, error) {
 	checkReady(bu)
 
-	ptr := C.kernel_get_undo_output_by_index(bu.ptr, C.uint64_t(transactionUndoIndex), C.uint64_t(outputIndex))
+	ptr := C.kernel_block_undo_copy_transaction_output_by_index(bu.ptr, C.uint64_t(transactionUndoIndex), C.uint64_t(outputIndex))
 	if ptr == nil {
 		return nil, ErrKernelGetUndoOutputByIndex
 	}
diff --git a/kernel/block_validation_state.go b/kernel/block_validation_state.go
@@ -14,13 +14,13 @@ type BlockValidationState struct {
 
 func (bvs *BlockValidationState) ValidationMode() ValidationMode {
 	checkReady(bvs)
-	mode := C.kernel_get_validation_mode_from_block_validation_state(bvs.ptr)
+	mode := C.kernel_block_validation_state_get_validation_mode(bvs.ptr)
 	return ValidationMode(mode)
 }
 
 func (bvs *BlockValidationState) ValidationResult() BlockValidationResult {
 	checkReady(bvs)
-	result := C.kernel_get_block_validation_result_from_block_validation_state(bvs.ptr)
+	result := C.kernel_block_validation_state_get_block_validation_result(bvs.ptr)
 	return BlockValidationResult(result)
 }
 
diff --git a/kernel/chainstate_manager.go b/kernel/chainstate_manager.go
@@ -43,30 +43,30 @@ func NewChainstateManager(context *Context, options *ChainstateManagerOptions) (
 	return manager, nil
 }
 
-// ReadBlockFromDisk reads a block from disk using the provided block index
-func (cm *ChainstateManager) ReadBlockFromDisk(blockIndex *BlockIndex) (*Block, error) {
+// ReadBlock reads a block using the provided block index
+func (cm *ChainstateManager) ReadBlock(blockIndex *BlockIndex) (*Block, error) {
 	checkReady(cm)
 	if err := validateReady(blockIndex); err != nil {
 		return nil, err
 	}
 
-	ptr := C.kernel_read_block_from_disk(cm.context.ptr, cm.ptr, blockIndex.ptr)
+	ptr := C.kernel_block_read(cm.context.ptr, cm.ptr, blockIndex.ptr)
 	if ptr == nil {
-		return nil, ErrKernelChainstateManagerReadBlockFromDisk
+		return nil, ErrKernelChainstateManagerReadBlock
 	}
 	return newBlockFromPtr(ptr), nil
 }
 
-// ReadBlockUndoFromDisk reads block undo data from disk for a given block index
-func (cm *ChainstateManager) ReadBlockUndoFromDisk(blockIndex *BlockIndex) (*BlockUndo, error) {
+// ReadBlockUndo reads block undo data for a given block index
+func (cm *ChainstateManager) ReadBlockUndo(blockIndex *BlockIndex) (*BlockUndo, error) {
 	checkReady(cm)
 	if err := validateReady(blockIndex); err != nil {
 		return nil, err
 	}
 
-	ptr := C.kernel_read_block_undo_from_disk(cm.context.ptr, cm.ptr, blockIndex.ptr)
+	ptr := C.kernel_block_undo_read(cm.context.ptr, cm.ptr, blockIndex.ptr)
 	if ptr == nil {
-		return nil, ErrKernelChainstateManagerReadBlockUndoFromDisk
+		return nil, ErrKernelChainstateManagerReadBlockUndo
 	}
 
 	blockUndo := &BlockUndo{ptr: ptr}
@@ -95,11 +95,11 @@ func (cm *ChainstateManager) ProcessBlock(block *Block) (bool, bool, error) {
 	return bool(success), bool(newBlock), nil
 }
 
-// GetBlockIndexFromTip returns the block index of the current chain tip
-func (cm *ChainstateManager) GetBlockIndexFromTip() (*BlockIndex, error) {
+// GetBlockIndexTip returns the block index of the current chain tip
+func (cm *ChainstateManager) GetBlockIndexTip() (*BlockIndex, error) {
 	checkReady(cm)
 
-	ptr := C.kernel_get_block_index_from_tip(cm.context.ptr, cm.ptr)
+	ptr := C.kernel_block_index_get_tip(cm.context.ptr, cm.ptr)
 	if ptr == nil {
 		return nil, ErrBlockIndexUninitialized
 	}
@@ -109,11 +109,11 @@ func (cm *ChainstateManager) GetBlockIndexFromTip() (*BlockIndex, error) {
 	return blockIndex, nil
 }
 
-// GetBlockIndexFromGenesis returns the block index of the genesis block
-func (cm *ChainstateManager) GetBlockIndexFromGenesis() (*BlockIndex, error) {
+// GetBlockIndexGenesis returns the block index of the genesis block
+func (cm *ChainstateManager) GetBlockIndexGenesis() (*BlockIndex, error) {
 	checkReady(cm)
 
-	ptr := C.kernel_get_block_index_from_genesis(cm.context.ptr, cm.ptr)
+	ptr := C.kernel_block_index_get_genesis(cm.context.ptr, cm.ptr)
 	if ptr == nil {
 		return nil, ErrBlockIndexUninitialized
 	}
@@ -123,14 +123,14 @@ func (cm *ChainstateManager) GetBlockIndexFromGenesis() (*BlockIndex, error) {
 	return blockIndex, nil
 }
 
-// GetBlockIndexFromHash returns the block index for a given block hash
-func (cm *ChainstateManager) GetBlockIndexFromHash(blockHash *BlockHash) (*BlockIndex, error) {
+// GetBlockIndexByHash returns the block index for a given block hash
+func (cm *ChainstateManager) GetBlockIndexByHash(blockHash *BlockHash) (*BlockIndex, error) {
 	checkReady(cm)
 	if blockHash == nil || blockHash.ptr == nil {
 		return nil, ErrBlockHashUninitialized
 	}
 
-	ptr := C.kernel_get_block_index_from_hash(cm.context.ptr, cm.ptr, blockHash.ptr)
+	ptr := C.kernel_block_index_get_by_hash(cm.context.ptr, cm.ptr, blockHash.ptr)
 	if ptr == nil {
 		return nil, ErrBlockIndexUninitialized
 	}
@@ -140,11 +140,11 @@ func (cm *ChainstateManager) GetBlockIndexFromHash(blockHash *BlockHash) (*Block
 	return blockIndex, nil
 }
 
-// GetBlockIndexFromHeight returns the block index for a given height in the currently active chain
-func (cm *ChainstateManager) GetBlockIndexFromHeight(height int) (*BlockIndex, error) {
+// GetBlockIndexByHeight returns the block index for a given height in the currently active chain
+func (cm *ChainstateManager) GetBlockIndexByHeight(height int) (*BlockIndex, error) {
 	checkReady(cm)
 
-	ptr := C.kernel_get_block_index_from_height(cm.context.ptr, cm.ptr, C.int(height))
+	ptr := C.kernel_block_index_get_by_height(cm.context.ptr, cm.ptr, C.int(height))
 	if ptr == nil {
 		return nil, ErrBlockIndexUninitialized
 	}
@@ -161,7 +161,7 @@ func (cm *ChainstateManager) GetNextBlockIndex(blockIndex *BlockIndex) (*BlockIn
 		return nil, err
 	}
 
-	ptr := C.kernel_get_next_block_index(cm.context.ptr, cm.ptr, blockIndex.ptr)
+	ptr := C.kernel_block_index_get_next(cm.context.ptr, cm.ptr, blockIndex.ptr)
 	if ptr == nil {
 		return nil, nil // No next block (tip or invalid)
 	}
@@ -177,7 +177,7 @@ func (cm *ChainstateManager) ImportBlocks(blockFilePaths []string) error {
 
 	if len(blockFilePaths) == 0 {
 		// Import with no files triggers reindex if wipe options were set
-		success := C.kernel_import_blocks(cm.context.ptr, cm.ptr, nil, nil, 0)
+		success := C.kernel_chainstate_manager_import_blocks(cm.context.ptr, cm.ptr, nil, nil, 0)
 		if !success {
 			return ErrKernelImportBlocks
 		}
@@ -200,7 +200,7 @@ func (cm *ChainstateManager) ImportBlocks(blockFilePaths []string) error {
 		}
 	}()
 
-	success := C.kernel_import_blocks(
+	success := C.kernel_chainstate_manager_import_blocks(
 		cm.context.ptr,
 		cm.ptr,
 		(**C.char)(unsafe.Pointer(&cPaths[0])),
diff --git a/kernel/chainstate_manager_test.go b/kernel/chainstate_manager_test.go
@@ -22,9 +22,9 @@ func TestChainstateManager(t *testing.T) {
 }
 
 func (s *ChainstateManagerTestSuite) TestGenesis(t *testing.T) {
-	genesisIndex, err := s.Manager.GetBlockIndexFromGenesis()
+	genesisIndex, err := s.Manager.GetBlockIndexGenesis()
 	if err != nil {
-		t.Fatalf("GetBlockIndexFromGenesis() error = %v", err)
+		t.Fatalf("GetBlockIndexGenesis() error = %v", err)
 	}
 	defer genesisIndex.Destroy()
 
@@ -46,9 +46,9 @@ func (s *ChainstateManagerTestSuite) TestGenesis(t *testing.T) {
 }
 
 func (s *ChainstateManagerTestSuite) TestTip(t *testing.T) {
-	tipIndex, err := s.Manager.GetBlockIndexFromTip()
+	tipIndex, err := s.Manager.GetBlockIndexTip()
 	if err != nil {
-		t.Fatalf("GetBlockIndexFromTip() error = %v", err)
+		t.Fatalf("GetBlockIndexTip() error = %v", err)
 	}
 	defer tipIndex.Destroy()
 
@@ -74,15 +74,15 @@ func (s *ChainstateManagerTestSuite) TestTip(t *testing.T) {
 }
 
 func (s *ChainstateManagerTestSuite) TestBlockUndo(t *testing.T) {
-	blockIndex, err := s.Manager.GetBlockIndexFromHeight(202)
+	blockIndex, err := s.Manager.GetBlockIndexByHeight(202)
 	if err != nil {
-		t.Fatalf("GetBlockIndexFromHeight(202) error = %v", err)
+		t.Fatalf("GetBlockIndexByHeight(202) error = %v", err)
 	}
 	defer blockIndex.Destroy()
 
-	blockUndo, err := s.Manager.ReadBlockUndoFromDisk(blockIndex)
+	blockUndo, err := s.Manager.ReadBlockUndo(blockIndex)
 	if err != nil {
-		t.Fatalf("ReadBlockUndoFromDisk() error = %v", err)
+		t.Fatalf("ReadBlockUndo() error = %v", err)
 	}
 	defer blockUndo.Destroy()
 
diff --git a/kernel/errors.go b/kernel/errors.go
@@ -21,25 +21,25 @@ var (
 	ErrTransactionUninitialized              = &UninitializedError{ObjectName: "transaction"}
 	ErrLoggingConnectionUninitialized        = &UninitializedError{ObjectName: "loggingConnection"}
 
-	ErrKernelBlockCreate                            = &KernelError{Operation: "kernel_block_create"}
-	ErrKernelBlockGetHash                           = &KernelError{Operation: "kernel_block_get_hash"}
-	ErrKernelCopyBlockData                          = &KernelError{Operation: "kernel_copy_block_data"}
-	ErrKernelScriptPubkeyCreate                     = &KernelError{Operation: "kernel_script_pubkey_create"}
-	ErrKernelCopyScriptPubkeyData                   = &KernelError{Operation: "kernel_copy_script_pubkey_data"}
-	ErrKernelTransactionOutputCreate                = &KernelError{Operation: "kernel_transaction_output_create"}
-	ErrKernelCopyScriptPubkeyFromOutput             = &KernelError{Operation: "kernel_copy_script_pubkey_from_output"}
-	ErrKernelTransactionCreate                      = &KernelError{Operation: "kernel_transaction_create"}
-	ErrKernelLoggingConnectionCreate                = &KernelError{Operation: "kernel_logging_connection_create"}
-	ErrKernelGetUndoOutputByIndex                   = &KernelError{Operation: "kernel_get_undo_output_by_index"}
-	ErrKernelChainstateManagerCreate                = &KernelError{Operation: "kernel_chainstate_manager_create"}
-	ErrKernelChainstateManagerOptionsCreate         = &KernelError{Operation: "kernel_chainstate_manager_options_create"}
-	ErrKernelContextCreate                          = &KernelError{Operation: "kernel_context_create"}
-	ErrKernelChainstateManagerReadBlockFromDisk     = &KernelError{Operation: "kernel_read_block_from_disk"}
-	ErrKernelChainstateManagerReadBlockUndoFromDisk = &KernelError{Operation: "kernel_read_block_undo_from_disk"}
-	ErrKernelChainstateManagerProcessBlock          = &KernelError{Operation: "kernel_chainstate_manager_process_block"}
-	ErrKernelImportBlocks                           = &KernelError{Operation: "kernel_import_blocks"}
-	ErrKernelChainParametersCreate                  = &KernelError{Operation: "kernel_chain_parameters_create"}
-	ErrKernelContextOptionsCreate                   = &KernelError{Operation: "kernel_context_options_create"}
+	ErrKernelBlockCreate                    = &KernelError{Operation: "kernel_block_create"}
+	ErrKernelBlockGetHash                   = &KernelError{Operation: "kernel_block_get_hash"}
+	ErrKernelCopyBlockData                  = &KernelError{Operation: "kernel_block_copy_data"}
+	ErrKernelScriptPubkeyCreate             = &KernelError{Operation: "kernel_script_pubkey_create"}
+	ErrKernelCopyScriptPubkeyData           = &KernelError{Operation: "kernel_script_pubkey_copy_data"}
+	ErrKernelTransactionOutputCreate        = &KernelError{Operation: "kernel_transaction_output_create"}
+	ErrKernelCopyScriptPubkeyFromOutput     = &KernelError{Operation: "kernel_transaction_output_copy_script_pubkey"}
+	ErrKernelTransactionCreate              = &KernelError{Operation: "kernel_transaction_create"}
+	ErrKernelLoggingConnectionCreate        = &KernelError{Operation: "kernel_logging_connection_create"}
+	ErrKernelGetUndoOutputByIndex           = &KernelError{Operation: "kernel_block_undo_copy_transaction_output_by_index"}
+	ErrKernelChainstateManagerCreate        = &KernelError{Operation: "kernel_chainstate_manager_create"}
+	ErrKernelChainstateManagerOptionsCreate = &KernelError{Operation: "kernel_chainstate_manager_options_create"}
+	ErrKernelContextCreate                  = &KernelError{Operation: "kernel_context_create"}
+	ErrKernelChainstateManagerReadBlock     = &KernelError{Operation: "kernel_block_read"}
+	ErrKernelChainstateManagerReadBlockUndo = &KernelError{Operation: "kernel_block_undo_read"}
+	ErrKernelChainstateManagerProcessBlock  = &KernelError{Operation: "kernel_chainstate_manager_process_block"}
+	ErrKernelImportBlocks                   = &KernelError{Operation: "kernel_chainstate_manager_import_blocks"}
+	ErrKernelChainParametersCreate          = &KernelError{Operation: "kernel_chain_parameters_create"}
+	ErrKernelContextOptionsCreate           = &KernelError{Operation: "kernel_context_options_create"}
 
 	ErrScriptVerify                        = &KernelError{Operation: "kernel_verify_script"}
 	ErrScriptVerifyTxInputIndex            = &KernelError{Operation: "kernel_verify_script", Detail: "the provided input index is out of range of the actual number of inputs of the transaction"}
diff --git a/kernel/logging_connection.go b/kernel/logging_connection.go
@@ -109,7 +109,7 @@ func (lc *LoggingConnection) uninitializedError() error {
 // DisableLogging permanently disables the global internal logger.
 // This function should only be called once and is not thread-safe
 func DisableLogging() {
-	C.kernel_disable_logging()
+	C.kernel_logging_disable()
 }
 
 // Global mutex for thread-safe category management
@@ -119,21 +119,21 @@ var loggingMutex = sync.RWMutex{}
 func AddLogLevelCategory(category LogCategory, level LogLevel) {
 	loggingMutex.Lock()
 	defer loggingMutex.Unlock()
-	C.kernel_add_log_level_category(category.mustC(), level.mustC())
+	C.kernel_logging_set_level_category(category.mustC(), level.mustC())
 }
 
 // EnableLogCategory enables logging for a specific category or all categories
 func EnableLogCategory(category LogCategory) {
 	loggingMutex.Lock()
 	defer loggingMutex.Unlock()
-	C.kernel_enable_log_category(category.mustC())
+	C.kernel_logging_enable_category(category.mustC())
 }
 
 // DisableLogCategory disables logging for a specific category or all categories
 func DisableLogCategory(category LogCategory) {
 	loggingMutex.Lock()
 	defer loggingMutex.Unlock()
-	C.kernel_disable_log_category(category.mustC())
+	C.kernel_logging_disable_category(category.mustC())
 }
 
 // LogLevel represents the logging level
diff --git a/kernel/script_pubkey.go b/kernel/script_pubkey.go
@@ -35,7 +35,7 @@ func NewScriptPubkeyFromRaw(rawScriptPubkey []byte) (*ScriptPubkey, error) {
 func (s *ScriptPubkey) Data() ([]byte, error) {
 	checkReady(s)
 
-	byteArray := C.kernel_copy_script_pubkey_data(s.ptr)
+	byteArray := C.kernel_script_pubkey_copy_data(s.ptr)
 	if byteArray == nil {
 		return nil, ErrKernelCopyScriptPubkeyData
 	}
diff --git a/kernel/transaction_output.go b/kernel/transaction_output.go
@@ -34,7 +34,7 @@ func NewTransactionOutput(scriptPubkey *ScriptPubkey, amount int64) (*Transactio
 func (t *TransactionOutput) ScriptPubkey() (*ScriptPubkey, error) {
 	checkReady(t)
 
-	ptr := C.kernel_copy_script_pubkey_from_output(t.ptr)
+	ptr := C.kernel_transaction_output_copy_script_pubkey(t.ptr)
 	if ptr == nil {
 		return nil, ErrKernelCopyScriptPubkeyFromOutput
 	}
@@ -46,7 +46,7 @@ func (t *TransactionOutput) ScriptPubkey() (*ScriptPubkey, error) {
 
 func (t *TransactionOutput) Amount() int64 {
 	checkReady(t)
-	return int64(C.kernel_get_transaction_output_amount(t.ptr))
+	return int64(C.kernel_transaction_output_get_amount(t.ptr))
 }
 
 func (t *TransactionOutput) destroy() {
diff --git a/kernel/validation_interface_callbacks.go b/kernel/validation_interface_callbacks.go
@@ -55,7 +55,7 @@ func (bp *BlockPointer) CopyData() ([]byte, error) {
 		return nil, ErrBlockUninitialized
 	}
 
-	byteArray := C.kernel_copy_block_pointer_data(bp.ptr)
+	byteArray := C.kernel_block_pointer_copy_data(bp.ptr)
 	if byteArray == nil {
 		return nil, ErrKernelCopyBlockData
 	}

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ func (b Block) Hash() (BlockHash, error) {`
`51`	`51`	`func (b *Block) Data() ([]byte, error) {`
`52`	`52`	`checkReady(b)`
`53`	`53`
`54`		`- byteArray := C.kernel_copy_block_data(b.ptr)`
	`54`	`+ byteArray := C.kernel_block_copy_data(b.ptr)`
`55`	`55`	`if byteArray == nil {`
`56`	`56`	`return nil, ErrKernelCopyBlockData`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ func (bi BlockIndex) Hash() (BlockHash, error) {`
`36`	`36`	`func (bi BlockIndex) Previous() BlockIndex {`
`37`	`37`	`checkReady(bi)`
`38`	`38`
`39`		`- ptr := C.kernel_get_previous_block_index(bi.ptr)`
	`39`	`+ ptr := C.kernel_block_index_get_previous(bi.ptr)`
`40`	`40`	`if ptr == nil {`
`41`	`41`	`return nil`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,13 +14,13 @@ type BlockValidationState struct {`
`14`	`14`
`15`	`15`	`func (bvs *BlockValidationState) ValidationMode() ValidationMode {`
`16`	`16`	`checkReady(bvs)`
`17`		`- mode := C.kernel_get_validation_mode_from_block_validation_state(bvs.ptr)`
	`17`	`+ mode := C.kernel_block_validation_state_get_validation_mode(bvs.ptr)`
`18`	`18`	`return ValidationMode(mode)`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`func (bvs *BlockValidationState) ValidationResult() BlockValidationResult {`
`22`	`22`	`checkReady(bvs)`
`23`		`- result := C.kernel_get_block_validation_result_from_block_validation_state(bvs.ptr)`
	`23`	`+ result := C.kernel_block_validation_state_get_block_validation_result(bvs.ptr)`
`24`	`24`	`return BlockValidationResult(result)`
`25`	`25`	`}`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,9 @@ func TestChainstateManager(t *testing.T) {`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`func (s ChainstateManagerTestSuite) TestGenesis(t testing.T) {`
`25`		`- genesisIndex, err := s.Manager.GetBlockIndexFromGenesis()`
	`25`	`+ genesisIndex, err := s.Manager.GetBlockIndexGenesis()`
`26`	`26`	`if err != nil {`
`27`		`- t.Fatalf("GetBlockIndexFromGenesis() error = %v", err)`
	`27`	`+ t.Fatalf("GetBlockIndexGenesis() error = %v", err)`
`28`	`28`	`}`
`29`	`29`	`defer genesisIndex.Destroy()`
`30`	`30`
`@@ -46,9 +46,9 @@ func (s ChainstateManagerTestSuite) TestGenesis(t testing.T) {`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`func (s ChainstateManagerTestSuite) TestTip(t testing.T) {`
`49`		`- tipIndex, err := s.Manager.GetBlockIndexFromTip()`
	`49`	`+ tipIndex, err := s.Manager.GetBlockIndexTip()`
`50`	`50`	`if err != nil {`
`51`		`- t.Fatalf("GetBlockIndexFromTip() error = %v", err)`
	`51`	`+ t.Fatalf("GetBlockIndexTip() error = %v", err)`
`52`	`52`	`}`
`53`	`53`	`defer tipIndex.Destroy()`
`54`	`54`
`@@ -74,15 +74,15 @@ func (s ChainstateManagerTestSuite) TestTip(t testing.T) {`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`func (s ChainstateManagerTestSuite) TestBlockUndo(t testing.T) {`
`77`		`- blockIndex, err := s.Manager.GetBlockIndexFromHeight(202)`
	`77`	`+ blockIndex, err := s.Manager.GetBlockIndexByHeight(202)`
`78`	`78`	`if err != nil {`
`79`		`- t.Fatalf("GetBlockIndexFromHeight(202) error = %v", err)`
	`79`	`+ t.Fatalf("GetBlockIndexByHeight(202) error = %v", err)`
`80`	`80`	`}`
`81`	`81`	`defer blockIndex.Destroy()`
`82`	`82`
`83`		`- blockUndo, err := s.Manager.ReadBlockUndoFromDisk(blockIndex)`
	`83`	`+ blockUndo, err := s.Manager.ReadBlockUndo(blockIndex)`
`84`	`84`	`if err != nil {`
`85`		`- t.Fatalf("ReadBlockUndoFromDisk() error = %v", err)`
	`85`	`+ t.Fatalf("ReadBlockUndo() error = %v", err)`
`86`	`86`	`}`
`87`	`87`	`defer blockUndo.Destroy()`
`88`	`88`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ func NewScriptPubkeyFromRaw(rawScriptPubkey []byte) (*ScriptPubkey, error) {`
`35`	`35`	`func (s *ScriptPubkey) Data() ([]byte, error) {`
`36`	`36`	`checkReady(s)`
`37`	`37`
`38`		`- byteArray := C.kernel_copy_script_pubkey_data(s.ptr)`
	`38`	`+ byteArray := C.kernel_script_pubkey_copy_data(s.ptr)`
`39`	`39`	`if byteArray == nil {`
`40`	`40`	`return nil, ErrKernelCopyScriptPubkeyData`
`41`	`41`	`}`