bitcoinkernel 0.1.0

data/lib/bitcoinkernel/chain.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Represents the active blockchain.
+  # This is a view into the chainstate manager's active chain.
+  #
+  # Note: This class does not inherit from FFI::AutoPointer because:
+  # - There is no btck_chain_destroy function in the library
+  # - The pointer is not owned; it points to internal data of ChainstateManager
+  # - The lifetime depends on the parent ChainstateManager
+  class Chain
+    # @param [FFI::Pointer] ptr Pointer to btck_Chain
+    # @param [Boolean] owned Whether this object owns the pointer.
+    #   Chain pointers from ChainstateManager are NOT owned.
+    def initialize(ptr, owned: false)
+      @ptr = ptr
+      @owned = owned
+    end
+
+    # Get the height of the chain tip.
+    # @return [Integer]
+    def height
+      BitcoinKernel.btck_chain_get_height(@ptr)
+    end
+
+    # Get the block tree entry at the specified height.
+    # @param [Integer] block_height The height to query
+    # @return [BlockTreeEntry, nil] The block tree entry, or nil if height is out of bounds
+    def entry_at(block_height)
+      ptr = BitcoinKernel.btck_chain_get_by_height(@ptr, block_height)
+      return nil if ptr.null?
+      BlockTreeEntry.new(ptr, owned: false)
+    end
+
+    # Check if the chain contains a block tree entry.
+    # @param [BlockTreeEntry] entry The entry to check
+    # @return [Boolean]
+    def contains?(entry)
+      BitcoinKernel.btck_chain_contains(@ptr, entry.to_ptr) == 1
+    end
+
+    # Get the underlying pointer for FFI calls.
+    # @return [FFI::Pointer]
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/bitcoinkernel/chain_parameters.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Represents chain parameters for a specific network.
+  class ChainParameters < FFI::AutoPointer
+    # Create chain parameters for the specified network.
+    # @param [Integer] chain_type One of ChainType constants (MAINNET, TESTNET, etc.)
+    # @return [ChainParameters]
+    def self.create(chain_type = ChainType::MAINNET)
+      ptr = BitcoinKernel.btck_chain_parameters_create(chain_type)
+      raise Error, "Failed to create chain parameters" if ptr.null?
+      new(ptr)
+    end
+
+    # Create chain parameters for mainnet.
+    # @return [ChainParameters]
+    def self.mainnet
+      create(ChainType::MAINNET)
+    end
+
+    # Create chain parameters for testnet.
+    # @return [ChainParameters]
+    def self.testnet
+      create(ChainType::TESTNET)
+    end
+
+    # Create chain parameters for testnet4.
+    # @return [ChainParameters]
+    def self.testnet4
+      create(ChainType::TESTNET_4)
+    end
+
+    # Create chain parameters for signet.
+    # @return [ChainParameters]
+    def self.signet
+      create(ChainType::SIGNET)
+    end
+
+    # Create chain parameters for regtest.
+    # @return [ChainParameters]
+    def self.regtest
+      create(ChainType::REGTEST)
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_chain_parameters_destroy(ptr)
+    end
+  end
+end

data/lib/bitcoinkernel/chainstate_manager.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Manages chainstate and block validation.
+  class ChainstateManager < FFI::AutoPointer
+    # Create a chainstate manager.
+    # @param [ChainstateManagerOptions] options Options for the chainstate manager
+    # @return [ChainstateManager]
+    def self.create(options)
+      ptr = BitcoinKernel.btck_chainstate_manager_create(options)
+      raise Error, "Failed to create chainstate manager" if ptr.null?
+      new(ptr)
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_chainstate_manager_destroy(ptr)
+    end
+
+    # Process and validate a block.
+    # @param [Block] block The block to process
+    # @return [Boolean] true if processing was successful (not indicative of validity)
+    def process_block(block)
+      new_block_ptr = FFI::MemoryPointer.new(:int)
+      result = BitcoinKernel.btck_chainstate_manager_process_block(self, block, new_block_ptr)
+      result == 0
+    end
+
+    # Get the currently active chain.
+    # @return [Chain]
+    def active_chain
+      ptr = BitcoinKernel.btck_chainstate_manager_get_active_chain(self)
+      raise Error, "Failed to get active chain" if ptr.null?
+      Chain.new(ptr, owned: false)
+    end
+
+    # Get a block tree entry by its hash.
+    # @param [BlockHash] block_hash The block hash to look up
+    # @return [BlockTreeEntry, nil] The block tree entry, or nil if not found
+    def block_tree_entry_by_hash(block_hash)
+      ptr = BitcoinKernel.btck_chainstate_manager_get_block_tree_entry_by_hash(self, block_hash)
+      return nil if ptr.null?
+      BlockTreeEntry.new(ptr, owned: false)
+    end
+
+    # Read a block from disk by its block tree entry.
+    # @param [BlockTreeEntry] entry The block tree entry
+    # @return [Block]
+    def read_block(entry)
+      ptr = BitcoinKernel.btck_block_read(self, entry.to_ptr)
+      raise Error, "Failed to read block" if ptr.null?
+      Block.new(ptr)
+    end
+  end
+end

data/lib/bitcoinkernel/chainstate_manager_options.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Options for creating a ChainstateManager.
+  class ChainstateManagerOptions < FFI::AutoPointer
+    # Create chainstate manager options.
+    # @param [Context] context The kernel context
+    # @param [String] data_directory Path to the chainstate data directory
+    # @param [String] blocks_directory Path to the blocks directory
+    # @return [ChainstateManagerOptions]
+    def self.create(context:, data_directory:, blocks_directory:)
+      ptr = BitcoinKernel.btck_chainstate_manager_options_create(
+        context,
+        data_directory, data_directory.bytesize,
+        blocks_directory, blocks_directory.bytesize
+      )
+      raise Error, "Failed to create chainstate manager options" if ptr.null?
+      new(ptr)
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_chainstate_manager_options_destroy(ptr)
+    end
+
+    # Set the number of worker threads for validation.
+    # @param [Integer] num Number of worker threads (0-15)
+    # @return [self]
+    def set_worker_threads(num)
+      BitcoinKernel.btck_chainstate_manager_options_set_worker_threads_num(self, num)
+      self
+    end
+
+    # Set wipe database options for reindexing.
+    # @param [Boolean] wipe_block_tree_db Wipe block tree db (should only be true if wipe_chainstate_db is also true)
+    # @param [Boolean] wipe_chainstate_db Wipe chainstate db
+    # @return [Boolean] true if successful
+    def set_wipe_dbs(wipe_block_tree_db:, wipe_chainstate_db:)
+      result = BitcoinKernel.btck_chainstate_manager_options_set_wipe_dbs(
+        self,
+        wipe_block_tree_db ? 1 : 0,
+        wipe_chainstate_db ? 1 : 0
+      )
+      result == 0
+    end
+
+    # Set block tree db to be in memory.
+    # @param [Boolean] in_memory Whether to use in-memory database
+    # @return [self]
+    def set_block_tree_db_in_memory(in_memory = true)
+      BitcoinKernel.btck_chainstate_manager_options_update_block_tree_db_in_memory(self, in_memory ? 1 : 0)
+      self
+    end
+
+    # Set chainstate db to be in memory.
+    # @param [Boolean] in_memory Whether to use in-memory database
+    # @return [self]
+    def set_chainstate_db_in_memory(in_memory = true)
+      BitcoinKernel.btck_chainstate_manager_options_update_chainstate_db_in_memory(self, in_memory ? 1 : 0)
+      self
+    end
+  end
+end

data/lib/bitcoinkernel/context.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Represents the kernel context.
+  class Context < FFI::AutoPointer
+    # Create a new context with the given options.
+    # @param [ContextOptions, nil] options Context options (nil for defaults)
+    # @return [Context]
+    def self.create(options = nil)
+      opts_ptr = options&.to_ptr
+      ptr = BitcoinKernel.btck_context_create(opts_ptr)
+      raise Error, "Failed to create context" if ptr.null?
+      new(ptr)
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_context_destroy(ptr)
+    end
+
+    # Interrupt the context.
+    # @return [Boolean] true if interrupt was successful
+    def interrupt
+      BitcoinKernel.btck_context_interrupt(self) == 0
+    end
+  end
+end

data/lib/bitcoinkernel/context_options.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Options for creating a Context.
+  class ContextOptions < FFI::AutoPointer
+    # Create new context options.
+    # @return [ContextOptions]
+    def self.create
+      ptr = BitcoinKernel.btck_context_options_create
+      raise Error, "Failed to create context options" if ptr.null?
+      new(ptr)
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_context_options_destroy(ptr)
+    end
+
+    # Set chain parameters for this context.
+    # @param [ChainParameters] chain_params Chain parameters to use
+    # @return [self]
+    def set_chainparams(chain_params)
+      BitcoinKernel.btck_context_options_set_chainparams(self, chain_params)
+      self
+    end
+
+    # Set validation interface callbacks for this context.
+    # @param [ValidationInterface] validation_interface The validation interface with callbacks
+    # @return [self]
+    def set_validation_interface(validation_interface)
+      # Store reference to prevent garbage collection of callbacks
+      @validation_interface = validation_interface
+      callbacks = validation_interface.to_ffi_callbacks
+      BitcoinKernel.btck_context_options_set_validation_interface(self, callbacks)
+      self
+    end
+  end
+end

data/lib/bitcoinkernel/logging.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Logging configuration for Bitcoin Kernel.
+  module Logging
+    # Logging options struct for FFI
+    class Options < FFI::Struct
+      layout :log_timestamps, :int,
+             :log_time_micros, :int,
+             :log_threadnames, :int,
+             :log_sourcelocations, :int,
+             :always_print_category_levels, :int
+    end
+
+    # Log categories
+    module Category
+      ALL = 0
+      BENCH = 1
+      BLOCKSTORAGE = 2
+      COINDB = 3
+      LEVELDB = 4
+      MEMPOOL = 5
+      PRUNE = 6
+      RAND = 7
+      REINDEX = 8
+      VALIDATION = 9
+      KERNEL = 10
+    end
+
+    # Log levels
+    module Level
+      TRACE = 0
+      DEBUG = 1
+      INFO = 2
+    end
+
+    # Permanently disable kernel logging output for this process.
+    # Once called, logging cannot be re-enabled.
+    # This function should only be called once and is not thread-safe.
+    def self.disable
+      BitcoinKernel.btck_logging_disable
+    end
+
+    # Set logging format options.
+    # @param [Hash] opts Logging options
+    # @option opts [Boolean] :timestamps Prepend timestamp to log messages
+    # @option opts [Boolean] :time_micros Log timestamps in microsecond precision
+    # @option opts [Boolean] :threadnames Prepend thread name to log messages
+    # @option opts [Boolean] :sourcelocations Prepend source location to log messages
+    # @option opts [Boolean] :category_levels Prepend log category and level to log messages
+    def self.set_options(timestamps: false, time_micros: false, threadnames: false,
+                         sourcelocations: false, category_levels: false)
+      opts = Options.new
+      opts[:log_timestamps] = timestamps ? 1 : 0
+      opts[:log_time_micros] = time_micros ? 1 : 0
+      opts[:log_threadnames] = threadnames ? 1 : 0
+      opts[:log_sourcelocations] = sourcelocations ? 1 : 0
+      opts[:always_print_category_levels] = category_levels ? 1 : 0
+      BitcoinKernel.btck_logging_set_options(opts)
+    end
+
+    # Set log level for a specific category.
+    # @param [Integer] category One of Category constants
+    # @param [Integer] level One of Level constants
+    def self.set_level(category, level)
+      BitcoinKernel.btck_logging_set_level_category(category, level)
+    end
+
+    # Enable a log category.
+    # @param [Integer] category One of Category constants (use Category::ALL to enable all)
+    def self.enable_category(category)
+      BitcoinKernel.btck_logging_enable_category(category)
+    end
+
+    # Disable a log category.
+    # @param [Integer] category One of Category constants (use Category::ALL to disable all)
+    def self.disable_category(category)
+      BitcoinKernel.btck_logging_disable_category(category)
+    end
+  end
+end

data/lib/bitcoinkernel/script_pubkey.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Represents a script pubkey.
+  class ScriptPubkey < FFI::AutoPointer
+    include Serializable
+    serialize_with :btck_script_pubkey_to_bytes
+
+    # Create a ScriptPubkey from raw bytes.
+    # @param [String] script Raw script bytes (binary string)
+    # @return [ScriptPubkey]
+    def self.from_raw(script)
+      raw_ptr = FFI::MemoryPointer.new(:uint8, script.bytesize)
+      raw_ptr.put_bytes(0, script)
+      ptr = BitcoinKernel.btck_script_pubkey_create(raw_ptr, script.bytesize)
+      raise Error, "Failed to create script pubkey" if ptr.null?
+      new(ptr)
+    end
+
+    # @param [FFI::Pointer] ptr Pointer to btck_ScriptPubkey
+    # @param [Boolean] owned Whether this object owns the pointer.
+    #   When obtained via TransactionOutput#script_pubkey, the pointer is NOT owned
+    #   and depends on the lifetime of the parent TransactionOutput.
+    #   In that case, owned should be false to prevent double-free.
+    def initialize(ptr, owned: true)
+      super(ptr)
+      self.autorelease = owned
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_script_pubkey_destroy(ptr)
+    end
+
+    # Compare two script pubkeys for equality by their serialized bytes.
+    # @param [ScriptPubkey] other The other script pubkey to compare
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(ScriptPubkey)
+      to_bytes == other.to_bytes
+    end
+
+    # Verify that the script is correctly spent by a transaction input.
+    # @param [Integer] amount Amount in satoshis
+    # @param [Transaction] tx Transaction spending this script
+    # @param [Integer] input_index Index of the input spending this script
+    # @param [Array<TransactionOutput>] spent_outputs All spent outputs (required for taproot)
+    # @param [Integer] flags Script verification flags (default: ScriptFlags::ALL)
+    # @return [Boolean] true if verification succeeded
+    def verify(amount:, tx:, input_index:, spent_outputs: [], flags: ScriptFlags::ALL)
+      status_ptr = FFI::MemoryPointer.new(:uint8)
+
+      # Create precomputed transaction data
+      precomputed_ptr = nil
+      unless spent_outputs.empty?
+        outputs_ptr = FFI::MemoryPointer.new(:pointer, spent_outputs.size)
+        spent_outputs.each_with_index do |out, i|
+          outputs_ptr.put_pointer(i * FFI::Pointer.size, out)
+        end
+        precomputed_ptr = BitcoinKernel.btck_precomputed_transaction_data_create(
+          tx, outputs_ptr, spent_outputs.size
+        )
+      end
+
+      begin
+        result = BitcoinKernel.btck_script_pubkey_verify(
+          self, amount, tx, precomputed_ptr, input_index, flags, status_ptr
+        )
+        result == 1
+      ensure
+        BitcoinKernel.btck_precomputed_transaction_data_destroy(precomputed_ptr) if precomputed_ptr
+      end
+    end
+  end
+end

data/lib/bitcoinkernel/serializable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Mixin for classes that can be serialized to bytes.
+  # Include this module and call `serialize_with` to define the to_bytes method.
+  #
+  # @example
+  #   class Block < FFI::AutoPointer
+  #     include Serializable
+  #     serialize_with :btck_block_to_bytes
+  #   end
+  module Serializable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Define a to_bytes method using the specified FFI serialization function.
+      # @param ffi_method [Symbol] The FFI function name for serialization
+      def serialize_with(ffi_method)
+        define_method(:to_bytes) do
+          buffer = []
+          callback = proc do |bytes_ptr, size, _userdata|
+            buffer << bytes_ptr.read_bytes(size)
+            0
+          end
+          BitcoinKernel.send(ffi_method, self, callback, nil)
+          buffer.join.b
+        end
+      end
+    end
+  end
+end

data/lib/bitcoinkernel/transaction.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Represents a Bitcoin transaction.
+  class Transaction < FFI::AutoPointer
+    include Serializable
+    serialize_with :btck_transaction_to_bytes
+
+    # Create a Transaction from raw serialized data.
+    # @param [String] raw_tx Serialized transaction data (binary string)
+    # @return [Transaction]
+    def self.from_raw(raw_tx)
+      raw_ptr = FFI::MemoryPointer.new(:uint8, raw_tx.bytesize)
+      raw_ptr.put_bytes(0, raw_tx)
+      ptr = BitcoinKernel.btck_transaction_create(raw_ptr, raw_tx.bytesize)
+      raise Error, "Failed to create transaction from raw data" if ptr.null?
+      new(ptr)
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_transaction_destroy(ptr)
+    end
+
+    # Create a copy of this transaction.
+    # @return [Transaction] A new Transaction instance with copied data
+    def copy
+      copied_ptr = BitcoinKernel.btck_transaction_copy(self)
+      raise Error, "Failed to copy transaction" if copied_ptr.null?
+      Transaction.new(copied_ptr)
+    end
+
+    # Compare two transactions for equality by their txid.
+    # @param [Transaction] other The other transaction to compare
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(Transaction)
+      txid == other.txid
+    end
+
+    # Number of inputs in the transaction.
+    # @return [Integer]
+    def input_count
+      BitcoinKernel.btck_transaction_count_inputs(self)
+    end
+
+    # Number of outputs in the transaction.
+    # @return [Integer]
+    def output_count
+      BitcoinKernel.btck_transaction_count_outputs(self)
+    end
+
+    # Get output at specified index.
+    # @param [Integer] index Output index
+    # @return [TransactionOutput]
+    def output_at(index)
+      out_ptr = BitcoinKernel.btck_transaction_get_output_at(self, index)
+      raise Error, "Output not found at index #{index}" if out_ptr.null?
+      TransactionOutput.new(out_ptr, owned: false)
+    end
+
+    # Get all outputs.
+    # @return [Array<TransactionOutput>]
+    def outputs
+      output_count.times.map { |i| output_at(i) }
+    end
+
+    # Get input at specified index.
+    # @param [Integer] index Input index
+    # @return [TransactionInput]
+    def input_at(index)
+      in_ptr = BitcoinKernel.btck_transaction_get_input_at(self, index)
+      raise Error, "Input not found at index #{index}" if in_ptr.null?
+      TransactionInput.new(in_ptr, owned: false)
+    end
+
+    # Get all inputs.
+    # @return [Array<TransactionInput>]
+    def inputs
+      input_count.times.map { |i| input_at(i) }
+    end
+
+    # Get the txid.
+    # @return [Txid]
+    def txid
+      ptr = BitcoinKernel.btck_transaction_get_txid(self)
+      raise Error, "Failed to get txid" if ptr.null?
+      Txid.new(ptr, owned: false)
+    end
+  end
+end

data/lib/bitcoinkernel/transaction_input.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Represents a transaction input.
+  class TransactionInput < FFI::AutoPointer
+    # @param [FFI::Pointer] ptr Pointer to btck_TransactionInput
+    # @param [Boolean] owned Whether this object owns the pointer.
+    #   When obtained via Transaction#input_at, the pointer is NOT owned
+    #   and depends on the lifetime of the parent Transaction.
+    #   In that case, owned should be false to prevent double-free.
+    def initialize(ptr, owned: true)
+      super(ptr)
+      self.autorelease = owned
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_transaction_input_destroy(ptr)
+    end
+
+    # Get the outpoint (previous transaction output being spent).
+    # @return [TransactionOutPoint]
+    def out_point
+      out_point_ptr = BitcoinKernel.btck_transaction_input_get_out_point(self)
+      raise Error, "Failed to get out point" if out_point_ptr.null?
+      TransactionOutPoint.new(out_point_ptr, owned: false)
+    end
+  end
+end

data/lib/bitcoinkernel/transaction_out_point.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Represents a transaction outpoint (reference to a previous output).
+  class TransactionOutPoint < FFI::AutoPointer
+    # @param [FFI::Pointer] ptr Pointer to btck_TransactionOutPoint
+    # @param [Boolean] owned Whether this object owns the pointer.
+    #   When obtained via TransactionInput#out_point, the pointer is NOT owned
+    #   and depends on the lifetime of the parent TransactionInput.
+    #   In that case, owned should be false to prevent double-free.
+    def initialize(ptr, owned: true)
+      super(ptr)
+      self.autorelease = owned
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_transaction_out_point_destroy(ptr)
+    end
+
+    # Get the index of the output in the previous transaction.
+    # @return [Integer]
+    def index
+      BitcoinKernel.btck_transaction_out_point_get_index(self)
+    end
+
+    # Get the txid of the previous transaction.
+    # @return [Txid]
+    def txid
+      ptr = BitcoinKernel.btck_transaction_out_point_get_txid(self)
+      raise Error, "Failed to get txid" if ptr.null?
+      Txid.new(ptr, owned: false)
+    end
+
+    # Compare two transaction outpoints for equality by txid and index.
+    # @param [TransactionOutPoint] other The other outpoint to compare
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(TransactionOutPoint)
+      txid == other.txid && index == other.index
+    end
+  end
+end

data/lib/bitcoinkernel/transaction_output.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BitcoinKernel
+  # Represents a transaction output.
+  class TransactionOutput < FFI::AutoPointer
+    # @param [FFI::Pointer] ptr Pointer to btck_TransactionOutput
+    # @param [Boolean] owned Whether this object owns the pointer.
+    #   When obtained via Transaction#output_at, the pointer is NOT owned
+    #   and depends on the lifetime of the parent Transaction.
+    #   In that case, owned should be false to prevent double-free.
+    #   If you need to keep the TransactionOutput longer than the Transaction,
+    #   use btck_transaction_output_copy to create an owned copy.
+    def initialize(ptr, owned: true)
+      super(ptr)
+      self.autorelease = owned
+    end
+
+    def self.release(ptr)
+      BitcoinKernel.btck_transaction_output_destroy(ptr)
+    end
+
+    # Get the output amount in satoshis.
+    # @return [Integer]
+    def amount
+      BitcoinKernel.btck_transaction_output_get_amount(self)
+    end
+
+    # Get the script pubkey.
+    # @return [ScriptPubkey]
+    def script_pubkey
+      spk_ptr = BitcoinKernel.btck_transaction_output_get_script_pubkey(self)
+      raise Error, "Failed to get script pubkey" if spk_ptr.null?
+      ScriptPubkey.new(spk_ptr, owned: false)
+    end
+
+    # Compare two transaction outputs for equality by amount and script pubkey.
+    # @param [TransactionOutput] other The other output to compare
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(TransactionOutput)
+      amount == other.amount && script_pubkey == other.script_pubkey
+    end
+  end
+end