cryptocoin 0.0.1b

data/lib/cryptocoin/script/op_code.rb

@@ -0,0 +1,59 @@
+require 'cryptocoin/script/op_code/constants'
+
+module Cryptocoin
+  class Script
+    # Taken from the Bitcoin official client
+    class OpCode
+      include Cryptocoin::Script::OpCode::Constants
+      def self.from_name(name)
+        c = Cryptocoin::Script::OpCode::Constants.const_get(name.upcase)
+        self.new([c].pack('C'))
+      rescue NameError 
+        false
+      end
+
+      def initialize(bin)
+        @bin = bin
+        @hex = bin.unpack('H*')[0].to_i(16)
+
+        if const_by_val(@hex) or @hex.between?(OP_PUSHDATA0, OP_PUSHDATA1)
+          @valid = true
+        else
+          @valid = false
+        end
+      end
+      
+      def name
+        # Return special case first 
+        return nil if !@valid
+        return 'OP_PUSHDATA0' if @hex.between?(OP_PUSHDATA0, OP_PUSHDATA1)
+        const_by_val(hex).to_s
+      end
+
+      def hex
+        @hex
+      end
+
+      def raw
+        @bin
+      end
+
+      def valid?
+        @valid
+      end
+
+      def disabled?
+        return nil if !@valid
+        [OP_CAT, OP_SUBSTR, OP_LEFT, OP_RIGHT, OP_INVERT, OP_AND, OP_OR, OP_XOR, OP_2MUL, OP_2DIV, OP_MUL, OP_DIV, OP_MOD, OP_LSHIFT, OP_RSHIFT].include?(@hex)
+      end
+
+      private
+
+      def const_by_val(val)
+        Cryptocoin::Script::OpCode::Constants.constants.find{ |name|
+          Cryptocoin::Script::OpCode::Constants.const_get(name) == val
+        }
+      end
+    end
+  end
+end

data/lib/cryptocoin/script.rb

@@ -0,0 +1,234 @@
+require 'cryptocoin/script/op_code'
+require 'cryptocoin/script/op_code/functions'
+
+module Cryptocoin
+  # Script, or as I prefer to stylize it, SCRIPT, is Satoshi's
+  # non-Turing complete scripting language for Bitcoin transactions
+  # It's similar to Forth and Postscript in that it's a stack based
+  # language, while missing certain features such as loops to prevent
+  # malicious code from being created within a transaction. 
+  #
+  # This is the parser for a SCRIPT directive
+  #
+  # My thinking behind the design of this parser is that, while it is
+  # tied to transactions usually, it can be used to parse general statements
+  # that a user inputs
+  class Script
+    include Cryptocoin::Script::OpCode::Constants
+    include Cryptocoin::Script::OpCode::Functions
+    
+    attr_accessor :stack
+    
+    # Create binary script from string
+    # Returns false if unable to create binary string
+    def self.from_s(str)
+      # split each value from str
+      # look up value in constants
+      # push data if pushdata instruction, noting that pushdata0 will need to read the binary size of the next string and then add the size plus the string
+      instructions = str.split(' ')
+      raw = ''
+      instructions.each_index do |i|
+        code = Cryptocoin::Script::OpCode.from_name(instructions[i].upcase)
+        return false if !code
+        case code.hex
+        when OP_PUSHDATA0
+          data = instructions.slice!(i+1)
+          data = [data].pack('H*')
+          raw += [data.bytesize].pack('C') + data
+        when OP_PUSHDATA1..OP_PUSHDATA4
+          # Crude implementation because it ignores what data says about the length
+          bytes = instructions.slice!(i+1)
+          data = instructions.slice!(i+1)
+          raw += code.raw + [bytes].pack('H*') + [data].pack('H*')
+        else
+          raw += code.raw
+        end
+      end
+      self.new(raw)
+    end
+    
+    # Validates that the script is okay within the ruleset of the
+    # Bitcoin protocol
+    def initialize(raw)
+      return false if raw.bytesize > 10000
+      @script = raw
+      @raw = raw
+      @transaction_valid = true
+      @valid = false
+      @subscript = false
+      @codeseparator = 0
+      @script_string = []
+      @stack = []
+    end
+        
+    # Sets the script as subscript and parses it to remove
+    # OP_CODESEPARATOR and the signature
+    def is_subscript!(signature)
+      @sub_sig = signature
+      @subscript = true
+    end
+    
+    def is_subscript?
+      @subscript
+    end
+    
+    # Sets the transaction so that it can be used if
+    # OP_CHECKSIG is called within directive
+    # +tx+ is the current transaction and +input+ is the 
+    # current input index
+    def set_transaction(tx, input)
+      @transaction = tx
+      @input_index = input
+    end
+
+    def raw
+      if is_subscript?
+        # Remove OP_CODESEPARTOR
+        parse(true)
+        # Remove signature
+        @raw = @raw.split(@sub_sig).join
+      end
+      @raw
+    end
+
+    def to_s
+      @script_string.join(' ')
+    end
+
+    # Parses directive according to current Bitcoin client rules
+    # Returns true if a valid script, returns valid is invalid
+    # The functions are also aware if it's subscript and don't
+    # parse as much (i.e. we don't actually check the validity) 
+    # if so.
+    def parse!(is_subscript=false)
+      opcode_count = 0
+      @alt_stack, @exec_stack = [], [] # These stacks are not carried over
+      seek = 0
+      @raw = ""
+      while seek < @script.length 
+        opcode_count+=1
+        _i = @script[seek]
+        seek += 1
+        opcode = Cryptocoin::Script::OpCode.new(_i)
+        return false if !opcode.valid?
+        return false if opcode_count > 201 and opcode.hex > OP_16
+        return false if opcode.disabled?
+        
+        if is_subscript
+          if !(opcode.hex == OP_CODESEPARATOR)
+            @raw += _i
+            @script_string.push(opcode.name)
+          end
+        else
+          @raw += _i
+          @script_string.push(opcode.name)
+        end
+                
+        if opcode.hex.between?(OP_PUSHDATA0, OP_PUSHDATA4)
+          @stack, @script_string, @raw, seek = op_pushdata(@stack, opcode, @script, @script_string, @raw, seek)
+        end
+        
+        if !is_subscript?
+          case opcode.hex
+          when OP_1NEGATE, OP_1, OP_2..OP_16
+            @stack = op_numeric(@stack, opcode)
+          when OP_NOP, OP_NOP1..OP_NOP10
+            op_nop
+          when OP_IF, OP_NOTIF
+            @stack, @exec_stack = op_if(@stack, @exec_stack, opcode)
+          when OP_ELSE
+            @exec_stack = op_else(@exec_stack)
+          when OP_ENDIF
+            exec_stack = op_endif(exec_stack)
+          when OP_RETURN
+            @transaction_valid = op_return
+          when OP_CODESEPARATOR
+            @codeseparator = op_codeseparator(seek)
+          when OP_VERIFY
+            @stack = op_verify(@stack)
+          when OP_TOALTSTACK
+            @stack, alt_stack = op_toaltstack(@stack, alt_stack)
+          when OP_FROMALTSTACK
+            @stack, alt_stack = op_fromaltstack(@stack, alt_stack)
+          when OP_2DROP
+            @stack = op_2drop(@stack)
+          when OP_2DUP
+            @stack = op_2dup(@stack)
+          when OP_3DUP
+            @stack = op_3dup(@stack)
+          when OP_2OVER
+            @stack = op_2over(@stack)
+          when OP_2ROT
+            @stack = op_2rot(@stack)
+          when OP_2SWAP
+            @stack = op_2swap(@stack)
+          when OP_IFDUP
+            @stack = op_ifdup(@stack)
+          when OP_DEPTH
+            @stack = op_depth(@stack)
+          when OP_DROP
+            @stack = op_drop(@stack)
+          when OP_DUP
+            @stack = op_dup(@stack)
+          when OP_NIP
+            @stack = op_nip(@stack)
+          when OP_OVER
+            @stack = op_over(@stack)
+          when OP_PICK, OP_ROLL
+            @stack = op_pick_or_roll(@stack, opcode)
+          when OP_ROT
+            @stack = op_rot(@stack)
+          when OP_SWAP
+            @stack = op_swap(@stack)
+          when OP_TUCK
+            @stack = op_tuck(@stack)
+          when OP_SIZE
+            @stack = op_size(@stack)
+          when OP_RETURN
+            @transaction_valid = op_return
+          when OP_EQUAL
+            @stack = op_equal(@stack)
+          when OP_1ADD, OP_1SUB, OP_NEGATE, OP_ABS, OP_NOT, OP_0NOTEQUAL
+            @stack = single_stack_arithmetic(@stack)
+          when OP_ADD, OP_SUB, OP_BOOLAND, OP_BOOLOR, OP_NUMEQUAL, OP_NUMEQUALVERIFY, OP_NUMNOTEQUAL, OP_LESSTHAN, OP_GREATERTHAN, OP_LESSTHANOREQUAL, OP_GREATERTHANOREQUAL, OP_MIN, OP_MAX
+            @stack = double_stack_arithmetic(@stack)
+          when OP_WITHIN
+            @stack = op_within(@stack)
+          when OP_RIPEMD160, OP_SHA256, OP_SHA1, OP_HASH160, OP_HASH256
+            @stack = digest(@stack)
+          when OP_CHECKSIG
+            raise ArgumentError, "Transaction and input are not set" if !@transaction
+            op_checksig(@stack, @script, @code_separator, @transaction)
+          when OP_CHECKSIGVERIFY
+            raise ArgumentError, "Transaction and input are not set" if !@transaction
+            @stack = op_checksig(@stack, @script, @code_separator, @transaction)
+            @stack = op_verify(@stack)
+          when OP_CHECKMULTISIG
+            raise ArgumentError, "Transaction and input are not set" if !@transaction
+            @stack = check_multisig(@stack, @script, code_separator, @transaction, opcode_count)
+          when OP_CHECKMULTISIGVERIFY
+            raise ArgumentError, "Transaction and input are not set" if !@transaction
+            @stack = check_multisig(@stack, @script, code_separator, @transaction, opcode_count)
+            @stack = op_verify(@stack)
+          end
+        end
+      end
+
+      # if top of stack is truthy, true
+      # else, false
+      if @stack.last != 0 && !@stack.empty?
+        @valid = true
+      else
+        @valid = false
+      end
+    end
+
+    def valid?
+      @valid
+    end
+    
+    def transaction_valid?
+      @transaction_valid
+    end
+  end
+end

data/lib/cryptocoin/structure/address.rb

@@ -0,0 +1,64 @@
+require 'cryptocoin/core_ext/string'
+
+module Cryptocoin
+  module Structure
+    # An address is just a specific way to represent a series of bytes within the network
+    class Address
+      attr_reader :network
+      # Creates a new Address structure from a given hash and network
+      # Will return false if the address is just 1 as this the representation of 0
+      def self.from_s(address_hash, network)
+        s = address_hash.from_base58.to_s(16)
+        '0'+s = s if s.bytesize.odd?
+        return false if s == '00'
+        
+        i = (address_hash.match(/^([1]+)/) ? $1 : '').size
+        self.new(['00'*i + s].pack('H*'), network)
+      end
+         
+      def initialize(address, network)
+        @address_raw = address
+        @network = network
+      end
+      
+      # Returns identifier for address type
+      # Current address types are p2sh and hash160
+      def type
+        return :p2sh if digest[0..1] == network.p2sh_version
+        return :hash160 if digest[0..1] == network.hash160_version
+        return :private_key if digest[0..1] == network.private_key_version
+        :unknown
+      end
+      
+      def to_s
+        digest.encode_to_base58
+      end
+      
+      def checksum
+        digest[-8..-1]
+      end
+      
+      def digest
+        @address_raw.unpack('H*')[0]
+      end
+      
+      def valid?
+        valid_checksum? and valid_network_version?
+      end
+      
+      private
+      
+      def valid_checksum?
+        if type == :private_key
+          Cryptocoin::Digest.new([digest[0..-9]].pack('H*'), :binary).double_sha256[0..7] == checksum
+        else
+          Cryptocoin::Digest.new([digest[0..-9]].pack('H*'), :binary).double_sha256[0..7] == checksum
+        end
+      end
+      
+      def valid_network_version?
+        type != :unknown
+      end
+    end
+  end
+end

data/lib/cryptocoin/structure/block.rb

@@ -0,0 +1,109 @@
+require 'cryptocoin/structure/transaction'
+require 'cryptocoin/protocol/var_len_int'
+require 'stringio'
+
+module Cryptocoin
+  module Structure
+    class Block
+      attr_reader :transactions_count, :transactions
+      def self.parse_from_raw(raw)
+        io = StringIO.new(raw)
+        self.parse_from_io(io)
+      end
+      
+      def self.parse_from_io(io, is_aux_pow=false)
+        # Save file for future use
+        # File.open('block.dat', 'w') do |f|
+        #   f.puts(io.read)
+        #   io.seek(0)
+        # end
+        txs = []
+        version_raw = io.read(4)
+        prev_block_raw = io.read(32)
+        merkle_root_raw = io.read(32)
+        timestamp_raw = io.read(4)
+        bits_raw = io.read(4)
+        nonce_raw = io.read(4)
+
+        if is_aux_pow 
+          # TODO: actually save this information
+          aux_coinbase_tx = Cryptocoin::Structure::Transaction.parse_from_io(io)
+          aux_block_hash = io.read(32)
+          aux_coinbase_branch = Cryptocoin::Structure::MerkleBranch.parse_from_io(io)
+          aux_blockchain_branch = Cryptocoin::Structure::MerkleBranch.parse_from_io(io)
+          aux_parent_block = io.read(80) #This is a block header, parse this later
+        end
+
+        tx_count = Cryptocoin::Protocol::VarLenInt.parse_from_io(io)
+        p "Transaction count: #{tx_count}, #{tx_count.to_i}"
+        tx_count.times do
+          txs.push(Cryptocoin::Structure::Transaction.parse_from_io(io))
+        end
+        self.new(version_raw, prev_block_raw, merkle_root_raw, timestamp_raw, bits_raw, nonce_raw, tx_count, txs)
+      end
+      
+      # txs is an array to keep consistent with the transaction model
+      def initialize(version_raw, prev_block_raw, merkle_root_raw, timestamp_raw, bits_raw, nonce_raw, tx_count, txs)
+        @version_raw = version_raw
+        @prev_block_raw = prev_block_raw
+        @merkle_root_raw = merkle_root_raw
+        @timestamp_raw = timestamp_raw
+        @bits_raw = bits_raw
+        @nonce_raw = nonce_raw
+        @transactions_count = tx_count
+        @transactions = txs
+      end
+
+      def head
+        @version_raw + @prev_block_raw + @merkle_root_raw + @timestamp_raw + @bits_raw + @nonce_raw
+      end
+
+      def body
+        @transactions_count.raw + @transactions.reduce { |tx, memo| memo += tx }
+      end
+      
+      def version
+        @version ||= @version_raw.unpack('L')[0]
+      end
+      
+      def previous_block_digest
+        @previous_block_digest ||= @prev_block_raw.reverse.unpack('H*')[0]
+      end
+      
+      def merkle_root_digest
+        @merkle_root_digest ||= @merkle_root_raw.reverse.unpack('H*')[0]
+      end
+      
+      def timestamp
+        @timestamp ||= @timestamp_raw.unpack('L')[0]
+      end
+      
+      def bits
+        @bits ||= @bits_raw.unpack('L')[0]
+      end
+      
+      def target
+        require 'openssl'
+        @bytes if @bytes
+
+        puts @bits_raw.unpack('H*')[0]
+
+        bytes = OpenSSL::BN.new(@bits_raw.unpack('H*')[0].reverse_every(2), 16).to_s(0).unpack('C*')
+        size = bytes.size - 4
+        nbits = size << 24
+        nbits |= (bytes[4] << 16) if size >= 1
+        nbits |= (bytes[5] <<  8) if size >= 2
+        nbits |= (bytes[6]      ) if size >= 3
+        @bytes = nbits
+      end
+      
+      def nonce
+        @nonce ||= @nonce_raw.unpack('L')[0]
+      end
+
+      def digest
+        @digest ||= Cryptocoin::Digest.new(self.head, :binary).double_sha256.reverse_every(2)
+      end
+    end
+  end
+end

data/lib/cryptocoin/structure/key_pair.rb

@@ -0,0 +1,57 @@
+require 'cryptocoin/core_ext/string'
+require 'cryptocoin/core_ext/integer'
+require 'cryptocoin/structure/address'
+
+module Cryptocoin
+  module Structure
+    class KeyPair
+      attr_reader :network, :public_key, :private_key
+      
+      def self.generate(network)
+        key = OpenSSL::PKey::EC.new("secp256k1").generate_key
+        new(key, network)
+      end
+      
+      def initialize(key_pair, network)
+        @network = network
+        
+        @public_key = PublicKey.new(key_pair.public_key, network)
+        @private_key = PrivateKey.new(key_pair.private_key, network)
+      end
+      
+      class PublicKey
+        def initialize(public_key, network)
+          @network = network
+          @public_key = public_key
+        end
+        
+        def to_s
+          @public_key.to_bn.to_i.to_s(16)
+        end
+        
+        def to_address
+          kh = @network.hash160_version + Cryptocoin::Digest.new(to_s, :string).hash160
+          checksum = Cryptocoin::Digest.new([kh].pack('H*'), :binary).double_sha256[0..7]
+          Cryptocoin::Structure::Address.from_s((kh + checksum).encode_to_base58, @network)
+        end
+      end
+      
+      class PrivateKey
+        def initialize(private_key, network)
+          @network = network
+          @private_key = private_key
+        end
+        
+        def to_s
+          @private_key.to_bn.to_i.to_s(16)
+        end
+        
+        def to_address 
+          kh =  @network.private_key_version + Cryptocoin::Digest.new(to_s, :string).double_sha256
+          checksum = Cryptocoin::Digest.new([kh].pack('H*'), :binary).double_sha256[0..7]
+          Cryptocoin::Structure::Address.from_s((kh + checksum).to_i(16).to_base58, @network)
+        end
+      end
+    end
+  end
+end

data/lib/cryptocoin/structure/merkle_branch.rb

@@ -0,0 +1,37 @@
+require 'cryptocoin/protocol/var_len_int'
+
+module Cryptocoin
+	module Structure
+    class MerkleBranch
+      def self.parse_from_io(io)
+        branch_length = Cryptocoin::Protocol::VarLenInt.parse_from_io(io)
+
+        branch_hashes = branch_length.times.map { |i|
+          io.read(32)
+        }
+
+        branch_side_mark = io.read(4)
+
+        self.new(branch_length, branch_hashes, branch_side_mark)
+      end
+
+      def initialize(branch_length, branch_hashes, branch_side_mark)
+        @branch_length_raw = branch_length
+        @branch_hashes_raw = branch_hashes
+        @branch_side_mark_raw = branch_side_mark
+      end
+
+      def branch_length
+        @branch_length ||= @branch_length_raw.to_i
+      end
+
+      def branch_hashes
+        @branch_hashes ||= @branch_hashes_raw.map { |branch_hash| branch_hash.reverse.unpack('H*')[0] }
+      end
+
+      def branch_side_mark
+        @branch_side_mark ||= @branch_side_mark_raw.unpack('l')[0]
+      end
+    end
+  end
+end

data/lib/cryptocoin/structure/transaction/input.rb

@@ -0,0 +1,80 @@
+require 'cryptocoin/protocol/var_len_int'
+
+module Cryptocoin
+  module Structure
+    class Transaction
+      class Input
+        attr_reader :index, :previous_output_hash, :previous_output_index, :script_sig_length, :script_sig, :sequence
+        
+        # Parses a raw binary transaction input
+        # Takes a raw transaction input and outputs a
+        # Crytocoin::Structure::Transaction::Input object
+        def self.parse_from_raw(i, raw)
+          c = 0
+          previous_output_hash_raw = raw[c..32]
+          previous_output_index_raw = raw[c+32..36]
+          sequence = raw[-5..-1]
+          c += 36
+          script_sig_length = Cryptocoin::Protocol::VarLenInt.parse_from_raw(raw[c..-1])
+          script_sig = raw[c+script_sig_length..-5]
+          self.new(previous_output_hash_raw, previous_output_index_raw, script_sig_length, script_sig, sequence, i)
+        end
+        
+        # Parses the top transaction input from io
+        # Returns a Cryptocoin::Structure::Transaction::Input object
+        def self.parse_from_io(i, io)
+          previous_output_hash_raw = io.read(32)
+          previous_output_index_raw = io.read(4)
+          script_sig_length = Cryptocoin::Protocol::VarLenInt.parse_from_io(io)
+          script_sig = io.read(script_sig_length.to_i)
+          sequence_raw = io.read(4)
+          self.new(previous_output_hash_raw, previous_output_index_raw, script_sig_length, script_sig, sequence_raw, i)
+        end
+        
+        # Creates a new transaction input from supplied arguments, then freezes itself
+        # Types: (str) previous_output_hash, (str) previous_output_index
+        # (Cryptocoin::Protocol::VarLenInt) sig_script_length, (str) script_sig
+        # (str) sequence, (int) index
+        def initialize(previous_output_hash, previous_output_index, script_sig_length, script_sig_raw, sequence, index)
+          @previous_output_hash_raw = previous_output_hash
+          @previous_output_index_raw = previous_output_index
+          @script_sig_length = script_sig_length
+          @script_sig_raw = script_sig_raw
+          @sequence_raw = sequence
+          @index = index
+        end
+        
+        def previous_output_hash
+          @previous_output_hash_raw.reverse.unpack('H*')[0]
+        end
+        
+        def previous_output_index
+          @previous_output_index_raw.unpack('V')[0]
+        end
+        
+        def script_sig
+          @script_sig ||= Cryptocoin::Script.new(@script_sig_raw)
+        end
+
+        def raw
+          @previous_output_hash_raw + @previous_output_index_raw + @script_sig_length.raw + @script_sig + @sequence
+        end
+        
+        def size
+          raw.bytesize
+        end
+        
+        # Provides a copy of the transaction in which you can set the raw binary values
+        def copy
+          r = self
+          ['previous_output_hash_raw', 'previous_output_index_raw', 'script_sig_length', 'script_sig', 'sequence_raw'].each do |i|
+            r.class.send(:define_method, "#{i}=") do |j|
+              instance_variable_set("@#{i}", j)
+            end
+          end
+          r
+        end
+      end
+    end
+  end
+end

data/lib/cryptocoin/structure/transaction/output.rb

@@ -0,0 +1,49 @@
+require 'cryptocoin/script'
+require 'cryptocoin/protocol/var_len_int'
+
+module Cryptocoin
+  module Structure
+    class Transaction
+      class Output
+        attr_reader :index, :value, :pk_script_length, :pk_script
+        
+        def self.parse_from_io(i, io)
+          value_raw = io.read(8)
+          puts "CURRENT IO POS: #{io.pos}"
+          pk_script_length = Cryptocoin::Protocol::VarLenInt.parse_from_io(io)
+          pk_script_raw = io.read(pk_script_length.to_i)
+          self.new(value_raw, pk_script_length, pk_script_raw, i)
+        end
+        
+        def initialize(value_raw, pk_scipt_length, pk_script_raw, i)
+          @value_raw = value_raw
+          @pk_script_length = pk_script_length
+          @pk_script_raw = pk_script_raw
+          @index = i
+        end
+        
+        def value
+          @value_raw.unpack('Q')[0]
+        end
+        
+        def pk_script
+          @pk_script ||= Cryptocoin::Script.new(@pk_script_raw)
+        end
+
+        def raw
+          @value_raw + @pk_script_length.raw + @pk_script
+        end
+        
+        def copy
+          r = self
+          ['value_raw', 'pk_script_length', 'pk_script_raw', 'index'].each do |i|
+            r.class.send(:define_method, "#{i}=") do |j|
+              instance_variable_set("@#{i}", j)
+            end
+          end
+          r
+        end
+      end
+    end
+  end
+end