btcruby 0.0.0 → 1.0.0

data/lib/btcruby/transaction_input.rb

@@ -0,0 +1,298 @@
+# Transaction input (aka "txin") represents a reference to another transaction's output.
+# Reference is defined by tx hash + tx output index.
+# Signature script is used to prove ownership of the corresponding tx output.
+# Sequence is used to require different signatures when tx is updated. It is only relevant when tx lock_time > 0.
+module BTC
+  class TransactionInput
+
+    INVALID_INDEX = 0xFFFFFFFF # aka "(unsigned int) -1" in BitcoinQT.
+    MAX_SEQUENCE  = 0xFFFFFFFF
+    ZERO_HASH256  = "\x00".b*32
+
+    # Hash of the previous transaction (raw binary hash)
+    attr_accessor :previous_hash
+
+    # ID of a previous transaction (reversed hash in hex)
+    attr_accessor :previous_id
+
+    # Index of the previous transaction's output (uint32_t).
+    attr_accessor :previous_index
+
+    # BTC::Script instance that proves ownership of the previous transaction output.
+    # We intentionally do not call it "script" to avoid accidental confusion with
+    # TransactionOutput#script.
+    attr_accessor :signature_script
+
+    # Binary String contained in signature script in coinbase input.
+    # Returns nil if it is not a coinbase input.
+    attr_accessor :coinbase_data
+
+    # Input sequence (uint32_t). Default is maximum value 0xFFFFFFFF.
+    # Sequence is used to update a timelocked tx stored in memory of the nodes. It is only relevant when tx lock_time > 0.
+    # Currently, for DoS and security reasons, nodes do not store timelocked transactions making the sequence number meaningless.
+    attr_accessor :sequence
+
+    # Binary representation of the input in wire format (aka payload).
+    attr_reader :data
+
+    # Dictionary representation of transaction ready to be encoded in JSON, PropertyList etc.
+    attr_reader :dictionary
+
+    # Optional reference to the owning transaction.
+    # It is set in `tx.add_input` and reset to nil in `tx.remove_all_inputs`.
+    # Default is nil.
+    attr_accessor :transaction
+    
+    # Optional index within owning transaction. 
+    # It is set in `tx.add_input` and reset to nil in `tx.remove_all_inputs`.
+    # Default is nil.
+    attr_accessor :index
+
+    # Optional attribute referencing an output that this input is spending.
+    attr_accessor :transaction_output
+
+    # Optional attribute containing a value in the corresponding output (in satoshis).
+    # Default is transaction_output.value or nil.
+    attr_accessor :value
+
+    # Initializes transaction input with its attributes. Every attribute has a valid default value.
+    def initialize(data: nil,
+                   stream: nil,
+                   dictionary: nil,
+                   previous_hash: ZERO_HASH256,
+                   previous_id: nil,
+                   previous_index: INVALID_INDEX,
+                   coinbase_data: nil,
+                   signature_script: BTC::Script.new,
+                   sequence: MAX_SEQUENCE,
+
+                   # optional attributes
+                   transaction: nil,
+                   transaction_output: nil,
+                   value: nil)
+      if stream || data
+        init_with_stream(stream || StringIO.new(data))
+      elsif dictionary
+        init_with_dictionary(dictionary)
+      else
+        @previous_hash    = previous_hash    || ZERO_HASH256
+        @previous_hash    = BTC.hash_from_id(previous_id) if previous_id
+        @previous_index   = previous_index   || INVALID_INDEX
+        @coinbase_data    = coinbase_data
+        @signature_script = signature_script || BTC::Script.new
+        @sequence         = sequence         || MAX_SEQUENCE
+      end
+
+      @transaction = transaction
+
+      @transaction_output = transaction_output
+      # Try to set outpoint data based on transaction output.
+      if @transaction_output
+        if @previous_hash == ZERO_HASH256
+          @previous_hash = @transaction_output.transaction_hash || ZERO_HASH256
+        end
+        if @previous_index == INVALID_INDEX
+          @previous_index = @transaction_output.index || INVALID_INDEX
+        end
+      end
+      @value = value
+    end
+
+    def init_with_stream(stream)
+      if stream.eof?
+        raise ArgumentError, "Can't parse transaction input from stream because it is already closed."
+      end
+
+      if !(@previous_hash = stream.read(32)) || @previous_hash.bytesize != 32
+        raise ArgumentError, "Failed to read 32-byte previous_hash from stream."
+      end
+
+      if !(@previous_index = BTC::WireFormat.read_uint32le(stream: stream).first)
+        raise ArgumentError, "Failed to read previous_index from stream."
+      end
+
+      is_coinbase = (@previous_hash == ZERO_HASH256 && @previous_index == INVALID_INDEX)
+
+      if !(scriptdata = BTC::WireFormat.read_string(stream: stream).first)
+        raise ArgumentError, "Failed to read signature_script data from stream."
+      end
+
+      @coinbase_data = nil
+      @signature_script = nil
+
+      if is_coinbase
+        @coinbase_data = scriptdata
+      else
+        @signature_script = BTC::Script.new(data: scriptdata)
+      end
+
+      if !(@sequence = BTC::WireFormat.read_uint32le(stream: stream).first)
+        raise ArgumentError, "Failed to read sequence from stream."
+      end
+    end
+
+    def init_with_dictionary(dict)
+      raise ArgumentError, "Dictionary is missing" if !dict
+
+      # Supports bitcoin-QT RPC format
+
+      if dict["prev_out"] && !dict["prev_out"].is_a?(Hash)
+        raise ArgumentError, "prev_out is not a dictionary."
+      end
+
+      prevhash = ZERO_HASH256
+      previndex = INVALID_INDEX
+      script = nil
+      seq = MAX_SEQUENCE
+
+      if dict["prev_out"]
+        if hashhex = dict["prev_out"]["hash"]
+          prevhash = BTC::Data.data_from_hex(hashhex)
+          if prevhash.bytesize != 32
+            raise ArgumentError, "prev_out.hash is not 32 bytes long."
+          end
+        end
+
+        if n = dict["prev_out"]["n"]
+          index = n.to_i
+          if index < 0 || index > 0xffffffff
+            raise ArgumentError, "prev_out.n is out of bounds (#{index})."
+          end
+          previndex = index
+        end
+      end
+
+      coinbase_data = nil
+      script = nil
+      if hex = dict["coinbase"]
+        coinbase_data = BTC::Data.data_from_hex(hex)
+      elsif dict["scriptSig"]
+        if dict["scriptSig"].is_a?(Hash)
+          if hex = dict["scriptSig"]["hex"]
+            script = BTC::Script.new(data: BTC::Data.data_from_hex(hex))
+          end
+        end
+      end
+
+      if dict["sequence"]
+        seq = dict["sequence"].to_i
+        if seq < 0 || seq > MAX_SEQUENCE
+          raise ArgumentError, "sequence is out of bounds (#{index})."
+        end
+      end
+
+      @previous_hash = prevhash
+      @previous_index = previndex,
+      @coinbase_data = coinbase_data
+      @signature_script = script
+      @sequence = seq
+    end
+
+    def self.with_data(data)
+      raise ArgumentError, "Use TransactionInput.new(data: ...) instead"
+    end
+
+    def self.with_stream(stream)
+      raise ArgumentError, "Use TransactionInput.new(stream: ...) instead"
+    end
+
+    def self.with_dictionary(dict)
+      raise ArgumentError, "Use TransactionInput.new(dictionary: ...) instead"
+    end
+
+    # Returns true if this input is a coinbase input.
+    def coinbase?
+      return self.previous_index == INVALID_INDEX && self.previous_hash == ZERO_HASH256
+    end
+
+    def previous_id
+      BTC.id_from_hash(self.previous_hash)
+    end
+
+    def previous_id=(txid)
+      self.previous_hash = BTC.hash_from_id(txid)
+    end
+
+    def value
+      return @value if @value
+      return @transaction_output.value if @transaction_output
+      return nil
+    end
+
+    def data
+      data = "".b
+      data << BTC::Data.ensure_binary_encoding(self.previous_hash)
+      data << BTC::WireFormat.encode_uint32le(self.previous_index)
+      if coinbase?
+        data << BTC::WireFormat.encode_string(self.coinbase_data)
+      else
+        data << BTC::WireFormat.encode_string(self.signature_script.data)
+      end
+      data << BTC::WireFormat.encode_uint32le(self.sequence)
+      data
+    end
+
+    def dictionary
+      dict = {}
+
+      dict["prev_out"] = {
+        "hash" => BTC::Data.hex_from_data(self.previous_hash),
+        "n"    => self.previous_index
+      }
+
+      if self.coinbase?
+        dict["coinbase"] = BTC::Data.hex_from_data(self.coinbase_data)
+      else
+        dict["scriptSig"] = {
+          "asm" => self.signature_script.to_s,
+          "hex" => BTC::Data.hex_from_data(self.signature_script.data)
+        }
+      end
+
+      dict["sequence"] = self.sequence
+
+      dict
+    end
+
+    def to_h
+      self.dictionary
+    end
+
+    def to_s
+      BTC::Data.hex_from_data(self.data)
+    end
+
+    def ==(other)
+      return true if super(other)
+      return true if self.data == other.data
+      return false
+    end
+
+    # Makes a deep copy of a transaction input
+    def dup
+      TransactionInput.new(previous_hash: @previous_hash.dup,
+                          previous_index: @previous_index,
+                        signature_script: @signature_script ? @signature_script.dup : nil,
+                           coinbase_data: @coinbase_data,
+                                sequence: @sequence,
+                             transaction: @transaction,
+                      transaction_output: @transaction_output, # not dup-ing txout because it's a transient object without #==
+                                   value: @value)
+    end
+
+    def inspect(style = :full)
+      if style == :full
+        %{#<#{self.class.name} prev:#{self.previous_id}[#{self.previous_index}]} +
+        %{ script:#{self.signature_script.to_s.inspect}} +
+        %{ seq:#{self.sequence}} +
+        %{>}
+      else
+        %{#<#{self.class.name} prev:#{self.previous_id[0,10]}[#{self.previous_index}]} +
+        %{ script:#{self.signature_script.to_s.inspect}} +
+        (self.sequence != MAX_SEQUENCE ? %{ seq:#{self.sequence}} : %{}) +
+        %{>}
+      end
+    end
+
+  end
+end

data/lib/btcruby/transaction_outpoint.rb

@@ -0,0 +1,30 @@
+module BTC
+  # Represents a reference to a previous transaction.
+  class TransactionOutpoint
+    attr_accessor :transaction_hash
+    attr_accessor :transaction_id
+    attr_accessor :index
+    
+    def initialize(transaction_hash: nil, transaction_id: nil, index: 0)
+      @transaction_hash = transaction_hash
+      self.transaction_id = transaction_id if transaction_id
+      @index = index
+    end
+    
+    def transaction_id=(txid)
+      self.transaction_hash = BTC.hash_from_id(txid)
+    end
+
+    def transaction_id
+      BTC.id_from_hash(self.transaction_hash)
+    end
+    
+    def outpoint_id
+      %{#{transaction_id}:#{index}}
+    end
+    
+    def to_s
+      outpoint_id
+    end
+  end
+end

data/lib/btcruby/transaction_output.rb

@@ -0,0 +1,315 @@
+# Transaction output (aka "tx out") is a value with rules attached in form of a script.
+# To spend money one need to choose a transaction output and provide an appropriate
+# input which makes the script execute with success.
+module BTC
+  class TransactionOutput
+
+    # Core attributes.
+
+    # Value of output in satoshis.
+    attr_accessor :value
+
+    # BTC::Script defining redemption rules for this output (aka scriptPubKey or pk_script)
+    attr_accessor :script
+
+
+    # Derived attributes.
+
+    # Serialized binary form of the output (payload)
+    attr_reader :data
+
+    # Dictionary representation of transaction ready to be encoded in JSON, PropertyList etc.
+    attr_reader :dictionary
+
+
+    # Optional attributes.
+
+    # These are not derived from tx data, but attached externally (e.g. via external APIs).
+    # 'index', 'confirmations' and 'transaction_hash' are optional attributes updated in certain context.
+    # E.g. when loading unspent outputs from Chain.com, all these attributes will be set.
+    # index and transaction_hash are kept up to date when output is added/removed from the transaction.
+
+    # Reference to the owning transaction. It is set on tx.add_output() and
+    # reset to nil on tx.remove_all_outputs. Default is nil.
+    attr_accessor :transaction
+
+    # Identifier of the transaction. Default is nil.
+    attr_accessor :transaction_hash
+
+    # Transaction ID. Always in sync with transaction_hash. Default is nil.
+    attr_accessor :transaction_id
+
+    # Index of this output in its transaction. Default is nil (unknown).
+    attr_accessor :index
+
+    # Binary hash of the block at which transaction was included.
+    # If not confirmed or not available, equals nil.
+    attr_accessor :block_hash
+    attr_accessor :block_id
+
+    # Height of the block at which transaction was included.
+    # If not confirmed equals -1.
+    # Note: `block_height` might not be provided by some APIs while `confirmations` may be.
+    # Default value is derived from `transaction` if possible or equals nil.
+    attr_accessor :block_height
+
+    # Time of the block at which tx was included (::Time instance or nil).
+    # Default value is derived from `transaction` if possible or equals nil.
+    attr_accessor :block_time
+
+    # Number of confirmations.
+    # Default value is derived from `transaction` if possible or equals nil.
+    attr_accessor :confirmations
+
+    # If available, returns whether this output is spent (true or false).
+    # Default is nil.
+    # See also `spent_confirmations`.
+    attr_accessor :spent
+
+    # If this transaction is spent, contains number of confirmations of the spending transaction.
+    # Returns nil if not available or output is not spent.
+    # Returns 0 if spending transaction is unconfirmed.
+    attr_accessor :spent_confirmations
+
+    def initialize(data: nil,
+                   stream: nil,
+                   dictionary: nil,
+                   value: 0,
+                   script: BTC::Script.new,
+
+                   # optional attributes
+                   transaction: nil,
+                   transaction_hash: nil,
+                   transaction_id: nil,
+                   index: nil,
+                   block_hash: nil,
+                   block_id: nil,
+                   block_height: nil,
+                   block_time: nil,
+                   confirmations: nil,
+                   spent: nil,
+                   spent_confirmations: nil)
+
+      if stream || data
+        init_with_stream(stream || StringIO.new(data))
+      elsif dictionary
+        init_with_dictionary(dictionary)
+      else
+        @value = value || 0
+        @script = script || BTC::Script.new
+      end
+
+      @transaction = transaction
+      @transaction_hash = transaction_hash
+      @transaction_hash = BTC.hash_from_id(transaction_id) if transaction_id
+      @index = index
+      @block_hash = block_hash
+      @block_hash = BTC.hash_from_id(block_id) if block_id
+      @block_height = block_height
+      @block_time = block_time
+      @confirmations = confirmations
+      @spent = spent
+      @spent_confirmations = spent_confirmations
+    end
+
+    def init_with_stream(stream)
+      if stream.eof?
+        raise ArgumentError, "Can't parse transaction output from stream because it is already closed."
+      end
+
+      # Read value
+      if !(@value = BTC::WireFormat.read_int64le(stream: stream).first)
+        raise ArgumentError, "Failed to read output value from stream."
+      end
+
+      # Read script
+      if !(scriptdata = BTC::WireFormat.read_string(stream: stream).first)
+        raise ArgumentError, "Failed to read output script data from stream."
+      end
+
+      @script = BTC::Script.new(data: scriptdata)
+    end
+
+    def init_with_dictionary(dict)
+      @value = 0
+      if amount_string = dict["value"]
+        @value = CurrencyFormatter.btc_long_formatter.number_from_string(amount_string)
+        if !@value
+          raise ArgumentError, "Failed to parse bitcoin amount from dictionary 'value': #{amount_string.inspect}"
+        end
+      end
+
+      @script = nil
+      if dict["scriptPubKey"] && dict["scriptPubKey"].is_a?(Hash)
+        if hex = dict["scriptPubKey"]["hex"]
+          @script = Script.new(data: BTC::Data.data_from_hex(hex))
+          if !@script
+            raise ArgumentError, "Failed to parse script from scriptPubKey.hex"
+          end
+        end
+      end
+    end
+
+    def self.with_data(data)
+      raise ArgumentError, "Use TransactionOutput.new(data: ...) instead"
+    end
+
+    def self.with_stream(stream)
+      raise ArgumentError, "Use TransactionOutput.new(stream: ...) instead"
+    end
+
+    def self.with_dictionary(dict)
+      raise ArgumentError, "Use TransactionOutput.new(dictionary: ...) instead"
+    end
+
+    def data
+      data = "".b
+      data << BTC::WireFormat.encode_int64le(self.value)
+      data << BTC::WireFormat.encode_string(self.script.data)
+      data
+    end
+
+    def dictionary
+      {
+        "value" => CurrencyFormatter.btc_long_formatter.string_from_number(self.value),
+        "scriptPubKey" => {
+          "asm" => self.script.to_s,
+          "hex" => BTC::Data.hex_from_data(self.script.data)
+        }
+      }
+    end
+
+    def transaction=(tx)
+      @transaction = tx
+      @transaction_hash = nil
+      @outpoint = nil
+    end
+
+    def index=(i)
+      @index = i
+      @outpoint = nil
+    end
+
+    def transaction_hash
+      return @transaction_hash             if @transaction_hash
+      return @transaction.transaction_hash if @transaction
+      return nil
+    end
+
+    def transaction_hash=(txhash)
+      @transaction_hash = txhash
+      @outpoint = nil
+    end
+
+    def transaction_id=(txid)
+      self.transaction_hash = BTC.hash_from_id(txid)
+    end
+
+    def transaction_id
+      BTC.id_from_hash(self.transaction_hash)
+    end
+
+    def outpoint
+      return @outpoint if @outpoint
+      if transaction_hash && index
+        @outpoint = TransactionOutpoint.new(transaction_hash: transaction_hash, index: index)
+      end
+      @outpoint
+    end
+
+    def outpoint_id
+      outpoint.outpoint_id
+    end
+
+    def block_id
+      BTC.id_from_hash(self.block_hash)
+    end
+
+    def block_id=(block_id)
+      self.block_hash = BTC.hash_from_id(block_id)
+    end
+
+    def block_hash
+      return @block_hash if @block_hash
+      return @transaction.block_hash if @transaction
+      return nil
+    end
+
+    def block_height
+      return @block_height if @block_height
+      return @transaction.block_height if @transaction
+      return nil
+    end
+
+    def block_time
+      return @block_time if @block_time
+      return @transaction.block_time if @transaction
+      return nil
+    end
+
+    def confirmations
+      return @confirmations if @confirmations
+      return @transaction.confirmations if @transaction
+      return nil
+    end
+
+    # Returns `true` if this transaction output contains an Open Assets marker.
+    # Does not perform expensive validation.
+    # Use this method to quickly filter out non-asset transactions.
+    def open_assets_marker?
+      self.script.open_assets_marker?
+    end
+
+    def dust?(relay_fee_rate = Transaction::DEFAULT_RELAY_FEE_RATE)
+      return self.value < self.dust_limit(relay_fee_rate)
+    end
+
+    def dust_limit(relay_fee_rate = Transaction::DEFAULT_RELAY_FEE_RATE)
+      # "Dust" is defined in terms of Transaction::DEFAULT_RELAY_FEE_RATE,
+      # which has units satoshis-per-kilobyte.
+      # If you'd pay more than 1/3 in fees
+      # to spend something, then we consider it dust.
+      # A typical txout is 34 bytes big, and will
+      # need a TransactionInput of at least 148 bytes to spend:
+      # so dust is a txout less than 546 satoshis (3*(34+148))
+      # with default relay_fee_rate.
+      size = self.data.bytesize + 148
+      return 3*Transaction.compute_fee(size, fee_rate: relay_fee_rate)
+    end
+
+    def to_h
+      self.dictionary
+    end
+
+    def to_s
+      BTC::Data.hex_from_data(self.data)
+    end
+
+    def ==(other)
+      return true if super(other)
+      return true if self.data == other.data
+      return false
+    end
+
+    # Makes a deep copy of a transaction output
+    def dup
+      TransactionOutput.new(value: @value,
+                            script: @script.dup,
+                            transaction: @transaction,
+                            transaction_hash: @transaction_hash,
+                            index: @index,
+                            block_hash: @block_hash,
+                            block_height: @block_height,
+                            block_time: @block_time,
+                            confirmations: @confirmations,
+                            spent: @spent,
+                            spent_confirmations: @spent_confirmations)
+    end
+
+    def inspect(style = :full)
+      %{#<#{self.class.name} value:#{CurrencyFormatter.btc_long_formatter.string_from_number(self.value)}} +
+      %{ script:#{self.script.to_s.inspect}>}
+    end
+
+  end
+end

data/lib/btcruby/version.rb

@@ -0,0 +1,3 @@
+module BTC
+  VERSION = "1.0.0".freeze
+end