tapyrus 0.1.0

data/lib/tapyrus/validation.rb

@@ -0,0 +1,115 @@
+module Tapyrus
+
+  class Validation
+
+    # check transaction validation
+    def check_tx(tx, state)
+      # Basic checks that don't depend on any context
+      if tx.inputs.empty?
+        return state.DoS(10, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vin-empty')
+      end
+
+      if tx.outputs.empty?
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-empty')
+      end
+
+      # Size limits (this doesn't take the witness into account, as that hasn't been checked for malleability)
+      if tx.serialize_old_format.bytesize * Tapyrus::WITNESS_SCALE_FACTOR > Tapyrus::MAX_BLOCK_WEIGHT
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-oversize')
+      end
+
+      # Check for negative or overflow output values
+      amount = 0
+      tx.outputs.each do |o|
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-negative') if o.value < 0
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-toolarge') if MAX_MONEY < o.value
+        amount += o.value
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-toolarge') if MAX_MONEY < amount
+      end
+
+      # Check for duplicate inputs - note that this check is slow so we skip it in CheckBlock
+      out_points = tx.inputs.map{|i|i.out_point.to_payload}
+      unless out_points.size == out_points.uniq.size
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-inputs-duplicate')
+      end
+
+      if tx.coinbase_tx?
+        if tx.inputs[0].script_sig.size < 2 || tx.inputs[0].script_sig.size > 100
+          return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-cb-length')
+        end
+      else
+        tx.inputs.each do |i|
+          if i.out_point.nil? || !i.out_point.valid?
+            return state.DoS(10, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-prevout-null')
+          end
+        end
+      end
+      true
+    end
+
+    # check proof of work
+    def check_block_header(header, state)
+      header.block_hash
+      header.bits
+
+    end
+
+    def check_block(block, state)
+      # check block header
+      return false unless check_block_header(block.header, state)
+
+      # check merkle root
+
+      # size limits
+
+      # first tx is coinbase?
+
+      # check tx count
+
+      # check sigop count
+    end
+
+  end
+
+  class ValidationState
+
+    MODE = {valid: 0, invlid: 1, error: 2}
+
+    attr_accessor :mode
+    attr_accessor :n_dos
+    attr_accessor :reject_reason
+    attr_accessor :reject_code
+    attr_accessor :corruption_possible
+    attr_accessor :debug_message
+
+    def initialize
+      @mode = MODE[:valid]
+      @n_dos = 0
+      @reject_code = 0
+      @corruption_possible = false
+    end
+
+    def DoS(level, ret: false, reject_code: 0, reject_reason: '', corruption_in: false, debug_message: '')
+      @reject_code = reject_code
+      @reject_reason = reject_reason
+      @corruption_possible = corruption_in
+      @debug_message = debug_message
+      return ret if mode == MODE[:error]
+      @n_dos += level
+      @mode = MODE[:invalid]
+      ret
+    end
+
+    def valid?
+      mode == MODE[:valid]
+    end
+
+    def invalid?
+      mode == MODE[:invalid]
+    end
+
+    def error?
+      mode == MODE[:error]
+    end
+  end
+end

data/lib/tapyrus/version.rb

@@ -0,0 +1,3 @@
+module Tapyrus
+  VERSION = "0.1.0"
+end

data/lib/tapyrus/wallet/account.rb

@@ -0,0 +1,151 @@
+module Tapyrus
+  module Wallet
+
+    # the account in BIP-44
+    class Account
+
+      PURPOSE_TYPE = {legacy: 44, nested_witness: 49, native_segwit: 84}
+
+      attr_reader :purpose # either 44 or 49 or 84
+      attr_reader :index # BIP-44 index
+      attr_reader :name # account name
+      attr_reader :account_key # account xpub key Tapyrus::ExtPubkey
+      attr_accessor :receive_depth # receive address depth(address index)
+      attr_accessor :change_depth # change address depth(address index)
+      attr_accessor :lookahead
+      attr_accessor :wallet
+
+      def initialize(account_key, purpose = PURPOSE_TYPE[:native_segwit], index = 0, name = '')
+        validate_params!(account_key, purpose, index)
+        @purpose = purpose
+        @index = index
+        @name = name
+        @receive_depth = 0
+        @change_depth = 0
+        @lookahead = 10
+        @account_key = account_key
+      end
+
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        account_key = Tapyrus::ExtPubkey.parse_from_payload(buf.read(78))
+        payload = buf.read
+        name, payload = Tapyrus.unpack_var_string(payload)
+        name = name.force_encoding('utf-8')
+        purpose, index, receive_depth, change_depth, lookahead = payload.unpack('I*')
+        a = Account.new(account_key, purpose, index, name)
+        a.receive_depth = receive_depth
+        a.change_depth = change_depth
+        a.lookahead = lookahead
+        a
+      end
+
+      def to_payload
+        payload = account_key.to_payload
+        payload << Tapyrus.pack_var_string(name.unpack('H*').first.htb)
+        payload << [purpose, index, receive_depth, change_depth, lookahead].pack('I*')
+        payload
+      end
+
+      # whether support witness
+      def witness?
+        [PURPOSE_TYPE[:nested_witness], PURPOSE_TYPE[:native_segwit]].include?(purpose)
+      end
+
+      # create new receive key
+      # @return [Tapyrus::ExtPubkey]
+      def create_receive
+        @receive_depth += 1
+        save
+        save_key(0, @receive_depth, derive_key(0, @receive_depth))
+      end
+
+      # create new change key
+      # @return [Tapyrus::ExtPubkey]
+      def create_change
+        @change_depth += 1
+        save
+        save_key(1, @change_depth, derive_key(1, @change_depth))
+      end
+
+      # save this account payload to database.
+      def save
+        wallet.db.save_account(self)
+        save_key(0, receive_depth, derive_key(0, receive_depth)) if receive_depth.zero?
+        save_key(1, change_depth, derive_key(1, change_depth)) if change_depth.zero?
+      end
+
+      # @param purpose 0:recieve, 1:change
+      # @param index receive_depth or change_depth
+      # @param key the key to be saved
+      def save_key(purpose, index, key)
+        wallet.db.save_key(self, purpose, index, key)
+      end
+
+      # get the list of derived keys for receive key.
+      # @return [Array[Tapyrus::ExtPubkey]]
+      def derived_receive_keys
+        (receive_depth + 1).times.map{|i|derive_key(0,i)}
+      end
+
+      # get the list of derived keys for change key.
+      # @return [Array[Tapyrus::ExtPubkey]]
+      def derived_change_keys
+        (change_depth + 1).times.map{|i|derive_key(1,i)}
+      end
+
+      # get account type label.
+      def type
+        case purpose
+          when PURPOSE_TYPE[:legacy]
+            'pubkeyhash'
+          when PURPOSE_TYPE[:nested_witness]
+            'p2wpkh-p2sh'
+          when PURPOSE_TYPE[:native_segwit]
+            'p2wpkh'
+          else
+            'unknown'
+        end
+      end
+
+      # account derivation path
+      def path
+        "m/#{purpose}'/#{Tapyrus.chain_params.bip44_coin_type}'/#{index}'"
+      end
+
+      def watch_only
+        false # TODO implements import watch only address.
+      end
+
+      # get data elements tobe monitored with Bloom Filter.
+      # @return [Array[String]]
+      def watch_targets
+        wallet.db.get_keys(self).map { |key| Tapyrus.hash160(key) }
+      end
+
+      def to_h
+        {
+            name: name, type: type, index: index, receive_depth: receive_depth, change_depth: change_depth,
+            look_ahead: lookahead, receive_address: derive_key(0, receive_depth).addr,
+            change_address: derive_key(1, change_depth).addr,
+            account_key: account_key.to_base58, path: path, watch_only: watch_only
+        }
+      end
+
+      private
+
+      def derive_key(branch, address_index)
+        account_key.derive(branch).derive(address_index)
+      end
+
+      def validate_params!(account_key, purpose, index)
+        raise 'account_key must be an instance of Tapyrus::ExtPubkey.' unless account_key.is_a?(Tapyrus::ExtPubkey)
+        raise 'Account key and index does not match.' unless account_key.number == (index + Tapyrus::HARDENED_THRESHOLD)
+        version_bytes = Tapyrus::ExtPubkey.version_from_purpose(purpose + Tapyrus::HARDENED_THRESHOLD)
+        raise 'The purpose and the account key do not match.' unless account_key.version == version_bytes
+      end
+
+    end
+
+  end
+end

data/lib/tapyrus/wallet/base.rb

@@ -0,0 +1,162 @@
+require 'leveldb-native'
+
+module Tapyrus
+  module Wallet
+
+    class Base
+
+      attr_accessor :wallet_id
+      attr_reader :db
+      attr_reader :path
+
+      VERSION = 1
+
+      # get wallet dir path
+      def self.default_path_prefix
+        "#{Tapyrus.base_dir}/db/wallet/"
+      end
+
+      # Create new wallet. If wallet already exist, throw error.
+      # The wallet generates a seed using SecureRandom and store to db at initialization.
+      # @param [String] wallet_id new wallet id.
+      # @param [String] path_prefix wallet file path prefix.
+      # @return [Tapyrus::Wallet::Base] the wallet
+      def self.create(wallet_id = 1, path_prefix = default_path_prefix)
+        raise ArgumentError, "wallet_id : #{wallet_id} already exist." if self.exist?(wallet_id, path_prefix)
+        w = self.new(wallet_id, path_prefix)
+        # generate seed
+        raise RuntimeError, 'the seed already exist.' if w.db.registered_master?
+        master = Tapyrus::Wallet::MasterKey.generate
+        w.db.register_master_key(master)
+        w.create_account('Default')
+        w
+      end
+
+      # load wallet with specified +wallet_id+
+      # @return [Tapyrus::Wallet::Base] the wallet
+      def self.load(wallet_id, path_prefix = default_path_prefix)
+        raise ArgumentError, "wallet_id : #{wallet_id} dose not exist." unless self.exist?(wallet_id, path_prefix)
+        self.new(wallet_id, path_prefix)
+      end
+
+      # get wallets path
+      # @return [Array] Array of paths for each wallet dir.
+      def self.wallet_paths(path_prefix = default_path_prefix)
+        Dir.glob("#{path_prefix}wallet*/").sort
+      end
+
+      # get current wallet
+      def self.current_wallet(path_prefix = default_path_prefix)
+        path = wallet_paths(path_prefix).first # TODO default wallet selection
+        return nil unless path
+        path.slice!(path_prefix + 'wallet')
+        path.slice!('/')
+        self.load(path.to_i, path_prefix)
+      end
+
+      # get account list based on BIP-44
+      def accounts(purpose = nil)
+        list = []
+        db.accounts.each do |raw|
+          a = Account.parse_from_payload(raw)
+          next if purpose && purpose != a.purpose
+          a.wallet = self
+          list << a
+        end
+        list
+      end
+
+      # create new account
+      # @param [Integer] purpose BIP44's purpose.
+      # @param [String] name a account name.
+      # @return [Tapyrus::Wallet::Account]
+      def create_account(purpose = Account::PURPOSE_TYPE[:native_segwit], name)
+        raise ArgumentError.new('Account already exists.') if find_account(name, purpose)
+        index = accounts.size
+        path = "m/#{purpose}'/#{Tapyrus.chain_params.bip44_coin_type}'/#{index}'"
+        account_key = master_key.derive(path).ext_pubkey
+        account = Account.new(account_key, purpose, index, name)
+        account.wallet = self
+        account.save
+        account
+      end
+
+      # get wallet balance.
+      # @param [Tapyrus::Wallet::Account] account a account in the wallet.
+      def get_balance(account)
+        # TODO get from utxo db.
+        0.00000000
+      end
+
+      # create new tapyrus address for receiving payments.
+      # @param [String] account_name an account name.
+      # @return [String] generated address.
+      def generate_new_address(account_name)
+        account = find_account(account_name)
+        raise ArgumentError.new('Account does not exist.') unless account
+        account.create_receive.addr
+      end
+
+      # get wallet version.
+      def version
+        db.version
+      end
+
+      # close database wallet
+      def close
+        db.close
+      end
+
+      # get master key
+      # @return [Tapyrus::Wallet::MasterKey]
+      def master_key
+        db.master_key
+      end
+
+      # encrypt wallet
+      # @param [String] passphrase the wallet passphrase
+      def encrypt(passphrase)
+        master_key.encrypt(passphrase)
+        db.register_master_key(master_key)
+      end
+
+      # decrypt wallet
+      # @param [String] passphrase the wallet passphrase
+      def decrypt(passphrase)
+
+      end
+
+      # wallet information
+      def to_h
+        a = accounts.map(&:to_h)
+        { wallet_id: wallet_id, version: version, account_depth: a.size, accounts: a, master: {encrypted: master_key.encrypted} }
+      end
+
+      # get data elements tobe monitored with Bloom Filter.
+      # @return [Array[String]]
+      def watch_targets
+        accounts.map(&:watch_targets).flatten
+      end
+
+      private
+
+      def initialize(wallet_id, path_prefix)
+        @path = "#{path_prefix}wallet#{wallet_id}/"
+        @db = Tapyrus::Wallet::DB.new(@path)
+        @wallet_id = wallet_id
+      end
+
+      def self.exist?(wallet_id, path_prefix)
+        path = "#{path_prefix}wallet#{wallet_id}"
+        Dir.exist?(path)
+      end
+
+      # find account using +account_name+
+      def find_account(account_name, purpose = nil)
+        accounts(purpose).find{|a| a.name == account_name}
+      end
+
+    end
+
+  end
+end

data/lib/tapyrus/wallet/db.rb

@@ -0,0 +1,81 @@
+module Tapyrus
+  module Wallet
+
+    class DB
+
+      KEY_PREFIX = {
+          account: 'a',       # key: account index, value: Account raw data.
+          master: 'm',        # value: wallet seed.
+          version: 'v',       # value: wallet version
+          key: 'k',           # key: path to the key, value: public key
+      }
+
+      attr_reader :level_db
+      attr_accessor :master_key
+
+      def initialize(path = "#{Tapyrus.base_dir}/db/wallet")
+        FileUtils.mkdir_p(path)
+        @level_db = ::LevelDBNative::DB.new(path)
+      end
+
+      # close database
+      def close
+        level_db.close
+      end
+
+      # get accounts raw data.
+      def accounts
+        from = KEY_PREFIX[:account] + '00000000'
+        to = KEY_PREFIX[:account] + 'ffffffff'
+        level_db.each(from: from, to: to).map { |k, v| v}
+      end
+
+      def save_account(account)
+        level_db.batch do
+          id = [account.purpose, account.index].pack('I*').bth
+          key = KEY_PREFIX[:account] + id
+          level_db.put(key, account.to_payload)
+        end
+      end
+
+      def save_key(account, purpose, index, key)
+        pubkey = key.pub
+        id = [account.purpose, account.index, purpose, index].pack('I*').bth
+        k = KEY_PREFIX[:key] + id
+        level_db.put(k, pubkey)
+        key
+      end
+
+      def get_keys(account)
+        id = [account.purpose, account.index].pack('I*').bth
+        from = KEY_PREFIX[:key] + id + '00000000'
+        to = KEY_PREFIX[:key] + id + 'ffffffff'
+        level_db.each(from: from, to: to).map { |k, v| v}
+      end
+
+      # get master_key
+      def master_key
+        @master_key ||= Tapyrus::Wallet::MasterKey.parse_from_payload(level_db.get(KEY_PREFIX[:master]))
+      end
+
+      # save seed
+      # @param [Tapyrus::Wallet::MasterKey] master a master key.
+      def register_master_key(master)
+        level_db.put(KEY_PREFIX[:master], master.to_payload)
+        level_db.put(KEY_PREFIX[:version], Tapyrus::Wallet::Base::VERSION.to_s)
+        @master_key = master
+      end
+
+      # whether master key registered.
+      def registered_master?
+        !level_db.get(KEY_PREFIX[:master]).nil?
+      end
+
+      # wallet version
+      def version
+        level_db.get(KEY_PREFIX[:version]).to_i
+      end
+
+    end
+  end
+end

data/lib/tapyrus/wallet/master_key.rb

@@ -0,0 +1,110 @@
+module Tapyrus
+  module Wallet
+
+    # HD Wallet master seed
+    class MasterKey
+      extend Tapyrus::Util
+      include Tapyrus::Util
+      include Tapyrus::KeyPath
+
+      attr_reader :seed
+      attr_accessor :salt
+      attr_accessor :encrypted
+      attr_accessor :mnemonic # ephemeral data existing only at initialization
+
+      def initialize(seed, salt: '', encrypted: false, mnemonic: nil)
+        @mnemonic = mnemonic
+        @seed = seed
+        @encrypted = encrypted
+        @salt = salt
+      end
+
+      # generate new master key.
+      # @return Tapyrus::Wallet::MasterKey
+      def self.generate
+        entropy = SecureRandom.hex(32)
+        mnemonic = Tapyrus::Mnemonic.new('english')
+        self.recover_from_words(mnemonic.to_mnemonic(entropy))
+      end
+
+      # recover master key from mnemonic word list.
+      # @param [Array] words the mnemonic word list.
+      # @return Tapyrus::Wallet::MasterKey
+      def self.recover_from_words(words)
+        mnemonic = Tapyrus::Mnemonic.new('english')
+        seed = mnemonic.to_seed(words)
+        self.new(seed, mnemonic: words)
+      end
+
+      # parse master key raw data
+      # @param [String] payload raw data
+      # @return [Tapyrus::Wallet::MasterKey]
+      def self.parse_from_payload(payload)
+        flag, payload = unpack_var_int(payload)
+        raise 'encrypted flag is invalid.' unless [0, 1].include?(flag)
+        salt, payload = unpack_var_string(payload)
+        salt = '' unless salt
+        seed, payload = unpack_var_string(payload)
+        self.new(seed.bth, salt: salt.bth, encrypted: flag == 1)
+      end
+
+      # generate payload with following format
+      # [encrypted(false:0, true:1)][salt(var str)][seed(var str)]
+      def to_payload
+        flg = encrypted ? 1 : 0
+        pack_var_int(flg) << [salt, seed].map{|v|pack_var_string(v.htb)}.join
+      end
+
+      # get master key
+      # @return [Tapyrus::ExtKey] the master key
+      def key
+        raise 'seed is encrypted. please decrypt the seed.' if encrypted
+        Tapyrus::ExtKey.generate_master(seed)
+      end
+
+      # derive child key using derivation path.
+      # @return [Tapyrus::ExtKey]
+      def derive(path)
+        derived_key = key
+        parse_key_path(path).each{|num| derived_key = derived_key.derive(num)}
+        derived_key
+      end
+
+      # encrypt seed
+      def encrypt(passphrase)
+        raise 'The wallet is already encrypted.' if encrypted
+        @salt = SecureRandom.hex(16)
+        enc = OpenSSL::Cipher.new('AES-256-CBC')
+        enc.encrypt
+        enc.key, enc.iv = key_iv(enc, passphrase)
+        encrypted_data = ''
+        encrypted_data << enc.update(seed)
+        encrypted_data << enc.final
+        @seed = encrypted_data
+        @encrypted = true
+      end
+
+      # decrypt seed
+      def decrypt(passphrase)
+        raise 'The wallet is not encrypted.' unless encrypted
+        dec = OpenSSL::Cipher.new('AES-256-CBC')
+        dec.decrypt
+        dec.key, dec.iv = key_iv(dec, passphrase)
+        decrypted_data = ''
+        decrypted_data << dec.update(seed)
+        decrypted_data << dec.final
+        @seed = decrypted_data
+        @encrypted = false
+        @salt = ''
+      end
+
+      private
+
+      def key_iv(enc, passphrase)
+        key_iv = OpenSSL::PKCS5.pbkdf2_hmac_sha1(passphrase, salt, 2000, enc.key_len + enc.iv_len)
+        [key_iv[0, enc.key_len], key_iv[enc.key_len, enc.iv_len]]
+      end
+
+    end
+  end
+end

data/lib/tapyrus/wallet.rb

@@ -0,0 +1,8 @@
+module Tapyrus
+  module Wallet
+    autoload :Base, 'tapyrus/wallet/base'
+    autoload :Account, 'tapyrus/wallet/account'
+    autoload :DB, 'tapyrus/wallet/db'
+    autoload :MasterKey, 'tapyrus/wallet/master_key'
+  end
+end