bitcoinrb 0.6.0 → 1.0.0

data/lib/bitcoin/taproot/simple_builder.rb

@@ -0,0 +1,155 @@
+module Bitcoin
+  module Taproot
+
+    # Utility class to construct Taproot outputs from internal key and script tree.keyPathSpending
+    # SimpleBuilder builds a script tree that places all lock scripts, in the order they are added, as leaf nodes.
+    # It is not possible to specify the depth of the locking script or to insert any intermediate nodes.
+    class SimpleBuilder
+      include Bitcoin::Opcodes
+
+      attr_reader :internal_key # String with hex format
+      attr_reader :branches # List of branch that has two child leaves
+
+      # Initialize builder.
+      # @param [String] internal_key Internal public key with hex format.
+      # @param [Array[Bitcoin::Taproot::LeafNode]] leaves (Optional) Array of leaf nodes for each lock condition.
+      # @raise [Bitcoin::Taproot::Builder] +internal_pubkey+ dose not xonly public key or leaf in +leaves+ does not instance of Bitcoin::Taproot::LeafNode.
+      # @return [Bitcoin::Taproot::SimpleBuilder]
+      def initialize(internal_key, leaves = [])
+        raise Error, 'Internal public key must be 32 bytes' unless internal_key.htb.bytesize == 32
+        raise Error, 'leaf must be Bitcoin::Taproot::LeafNode object' if leaves.find{ |leaf| !leaf.is_a?(Bitcoin::Taproot::LeafNode)}
+
+        @leaves = leaves
+        @branches = leaves.each_slice(2).map.to_a
+        @internal_key = internal_key
+      end
+
+      # Add a leaf node to the end of the current branch.
+      # @param [Bitcoin::Taproot::LeafNode] leaf Leaf node to be added.
+      def add_leaf(leaf)
+        raise Error, 'leaf must be Bitcoin::Taproot::LeafNode object' unless leaf.is_a?(Bitcoin::Taproot::LeafNode)
+
+        if branches.last&.size == 1
+          branches.last << leaf
+        else
+          branches << [leaf]
+        end
+        self
+      end
+
+      # Add a pair of leaf nodes as a branch. If there is only one, add a branch with only one child.
+      # @param [Bitcoin::Taproot::LeafNode] leaf1 Leaf node to be added.
+      # @param [Bitcoin::Taproot::LeafNode] leaf2 Leaf node to be added.
+      def add_branch(leaf1, leaf2 = nil)
+        raise Error, 'leaf1 must be Bitcoin::Taproot::LeafNode object' unless leaf1.is_a?(Bitcoin::Taproot::LeafNode)
+        raise Error, 'leaf2 must be Bitcoin::Taproot::LeafNode object' if leaf2 && !leaf2.is_a?(Bitcoin::Taproot::LeafNode)
+
+        branches << (leaf2.nil? ? [leaf1] : [leaf1, leaf2])
+        self
+      end
+
+      # Build P2TR script.
+      # @return [Bitcoin::Script] P2TR script.
+      def build
+        q = tweak_public_key
+        Bitcoin::Script.new << OP_1 << q.xonly_pubkey
+      end
+
+      # Compute the tweaked public key.
+      # @return [Bitcoin::Key] the tweaked public key
+      def tweak_public_key
+        Taproot.tweak_public_key(Bitcoin::Key.from_xonly_pubkey(internal_key), merkle_root)
+      end
+
+      # Compute the secret key for a tweaked public key.
+      # @param [Bitcoin::Key] key key object contains private key.
+      # @return [Bitcoin::Key] secret key for a tweaked public key
+      def tweak_private_key(key)
+        raise Error, 'Requires private key' unless key.priv_key
+
+        Taproot.tweak_private_key(key, merkle_root)
+      end
+
+      # Generate control block needed to unlock with script-path.
+      # @param [Bitcoin::Taproot::LeafNode] leaf Leaf to use for unlocking.
+      # @return [String] control block with binary format.
+      def control_block(leaf)
+        path = inclusion_proof(leaf)
+        parity = tweak_public_key.to_point.has_even_y? ? 0 : 1
+        [parity + leaf.leaf_ver].pack("C") + internal_key.htb + path.join
+      end
+
+      # Generate inclusion proof for +leaf+.
+      # @param [Bitcoin::Taproot::LeafNode] leaf The leaf node in script tree.
+      # @return [Array[String]] Inclusion proof.
+      # @raise [Bitcoin::Taproot::Error] If the specified +leaf+ does not exist
+      def inclusion_proof(leaf)
+        proofs = []
+        target_branch = branches.find{|b| b.include?(leaf)}
+        raise Error 'Specified leaf does not exist' unless target_branch
+
+        # flatten each branch
+        proofs << hash_value(target_branch.find{|b| b != leaf}) if target_branch.size == 2
+        parent_hash = combine_hash(target_branch)
+        parents = branches.map {|pair| combine_hash(pair)}
+
+        until parents.size == 1
+          parents = parents.each_slice(2).map do |pair|
+            combined = combine_hash(pair)
+            unless pair.size == 1
+              if hash_value(pair[0]) == parent_hash
+                proofs << hash_value(pair[1])
+                parent_hash = combined
+              elsif hash_value(pair[1]) == parent_hash
+                proofs << hash_value(pair[0])
+                parent_hash = combined
+              end
+            end
+            combined
+          end
+        end
+        proofs
+      end
+
+      private
+
+      # Compute tweak from script tree.
+      # @return [String] tweak with binary format.
+      def tweak
+        Taproot.tweak(Bitcoin::Key.from_xonly_pubkey(internal_key), merkle_root)
+      end
+
+      # Calculate merkle root from branches.
+      # @return [String] merkle root with hex format.
+      def merkle_root
+        parents = branches.map {|pair| combine_hash(pair)}
+        if parents.empty?
+          parents = ['']
+        elsif parents.size == 1
+          parents = [combine_hash(parents)]
+        else
+          parents = parents.each_slice(2).map { |pair| combine_hash(pair) } until parents.size == 1
+        end
+        parents.first.bth
+      end
+
+      def combine_hash(pair)
+        if pair.size == 1
+          hash_value(pair[0])
+        else
+          hash1 = hash_value(pair[0])
+          hash2 = hash_value(pair[1])
+
+          # Lexicographically sort a and b's hash, and compute parent hash.
+          payload = hash1.bth < hash2.bth ? hash1 + hash2 : hash2 + hash1
+          Bitcoin.tagged_hash('TapBranch', payload)
+        end
+      end
+
+      def hash_value(leaf_or_branch)
+        leaf_or_branch.is_a?(LeafNode) ? leaf_or_branch.leaf_hash : leaf_or_branch
+      end
+    end
+  end
+
+end

data/lib/bitcoin/taproot.rb

@@ -0,0 +1,45 @@
+module Bitcoin
+  module Taproot
+
+    class Error < StandardError; end
+
+    autoload :LeafNode, 'bitcoin/taproot/leaf_node'
+    autoload :SimpleBuilder, 'bitcoin/taproot/simple_builder'
+
+    module_function
+
+    # Calculate tweak value from +internal_pubkey+ and +merkle_root+.
+    # @param [Bitcoin::Key] internal_key Internal key with hex format(x-only public key).
+    # @param [String] merkle_root Merkle root value of script tree with hex format.
+    # @return [String] teak value with binary format.
+    def tweak(internal_key, merkle_root)
+      raise Error, 'internal_key must be Bitcoin::Key object.' unless internal_key.is_a?(Bitcoin::Key)
+
+      merkle_root ||= ''
+      t = Bitcoin.tagged_hash('TapTweak', internal_key.xonly_pubkey.htb + merkle_root.htb)
+      raise Error, 'tweak value exceeds the curve order' if t.bti >= ECDSA::Group::Secp256k1.order
+
+      t
+    end
+
+    # Generate tweak public key form +internal_pubkey+ and +merkle_root+.
+    # @param [Bitcoin::Key] internal_key Internal key with hex format(x-only public key).
+    # @param [String] merkle_root Merkle root value of script tree with hex format.
+    # @return [Bitcoin::Key] Tweaked public key.
+    def tweak_public_key(internal_key, merkle_root)
+      t = tweak(internal_key, merkle_root)
+      key = Bitcoin::Key.new(priv_key: t.bth, key_type: Key::TYPES[:compressed])
+      Bitcoin::Key.from_point(key.to_point + internal_key.to_point)
+    end
+
+    # Generate tweak private key
+    #
+    def tweak_private_key(internal_private_key, merkle_root)
+      p = internal_private_key.to_point
+      private_key = p.has_even_y? ? internal_private_key.priv_key.to_i(16) :
+                      ECDSA::Group::Secp256k1.order - internal_private_key.priv_key.to_i(16)
+      t = tweak(internal_private_key, merkle_root)
+      Bitcoin::Key.new(priv_key: ((t.bti + private_key) % ECDSA::Group::Secp256k1.order).to_even_length_hex)
+    end
+  end
+end

data/lib/bitcoin/tx.rb

@@ -33,13 +33,13 @@ module Bitcoin
     alias_method :in, :inputs
     alias_method :out, :outputs
 
-    def self.parse_from_payload(payload, non_witness: false)
+    def self.parse_from_payload(payload, non_witness: false, strict: false)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
       tx = new
       tx.version = buf.read(4).unpack1('V')
 
       in_count = Bitcoin.unpack_var_int_from_io(buf)
-      witness = false
+      has_witness = false
       if in_count.zero? && !non_witness
         tx.marker = 0
         tx.flag = buf.read(1).unpack1('c')
@@ -47,7 +47,7 @@ module Bitcoin
           buf.pos -= 1
         else
           in_count = Bitcoin.unpack_var_int_from_io(buf)
-          witness = true
+          has_witness = true
         end
       end
 
@@ -60,14 +60,14 @@ module Bitcoin
         tx.outputs << TxOut.parse_from_payload(buf)
       end
 
-      if witness
+      if has_witness
         in_count.times do |i|
           tx.inputs[i].script_witness = Bitcoin::ScriptWitness.parse_from_payload(buf)
         end
       end
 
+      raise ArgumentError, 'Transaction has unexpected data.' if strict &&  (buf.pos + 4) != buf.length
       tx.lock_time = buf.read(4).unpack1('V')
-
       tx
     end
 
@@ -192,8 +192,10 @@ module Bitcoin
     # @param [Integer] amount bitcoin amount locked in input. required for witness input only.
     # @param [Integer] skip_separator_index If output_script is P2WSH and output_script contains any OP_CODESEPARATOR,
     # the script code needs  is the witnessScript but removing everything up to and including the last executed OP_CODESEPARATOR before the signature checking opcode being executed.
+    # @param [Array[Bitcoin::TxOut] prevouts Previous outputs referenced by all Tx inputs, required for taproot.
+    # @return [String] signature hash with binary format.
     def sighash_for_input(input_index, output_script = nil, opts: {}, hash_type: SIGHASH_TYPE[:all],
-                          sig_version: :base, amount: nil, skip_separator_index: 0)
+                          sig_version: :base, amount: nil, skip_separator_index: 0, prevouts: [])
       raise ArgumentError, 'input_index must be specified.' unless input_index
       raise ArgumentError, 'does not exist input corresponding to input_index.' if input_index >= inputs.size
       raise ArgumentError, 'script_pubkey must be specified.' if [:base, :witness_v0].include?(sig_version) && output_script.nil?
@@ -202,6 +204,8 @@ module Bitcoin
       opts[:skip_separator_index] = skip_separator_index
       opts[:sig_version] = sig_version
       opts[:script_code] = output_script
+      opts[:prevouts] = prevouts
+      opts[:last_code_separator_pos] ||= 0xffffffff
       sig_hash_gen = SigHashGenerator.load(sig_version)
       sig_hash_gen.generate(self, input_index, hash_type, opts)
     end
@@ -211,7 +215,9 @@ module Bitcoin
     # @param [Bitcoin::Script] script_pubkey the script pubkey for target input.
     # @param [Integer] amount the amount of bitcoin, require for witness program only.
     # @param [Array] flags the flags used when execute script interpreter.
-    def verify_input_sig(input_index, script_pubkey, amount: nil, flags: STANDARD_SCRIPT_VERIFY_FLAGS)
+    # @param [Array[Bitcoin::TxOut]] prevouts Previous outputs referenced by all Tx inputs, required for taproot.
+    # @return [Boolean] result
+    def verify_input_sig(input_index, script_pubkey, amount: nil, flags: STANDARD_SCRIPT_VERIFY_FLAGS, prevouts: [])
       script_sig = inputs[input_index].script_sig
       has_witness = inputs[input_index].has_witness?
 
@@ -222,7 +228,7 @@ module Bitcoin
       end
 
       if has_witness
-        verify_input_sig_for_witness(input_index, script_pubkey, amount, flags)
+        verify_input_sig_for_witness(input_index, script_pubkey, amount, flags, prevouts)
       else
         verify_input_sig_for_legacy(input_index, script_pubkey, flags)
       end
@@ -255,16 +261,11 @@ module Bitcoin
     end
 
     # verify input signature for witness tx.
-    def verify_input_sig_for_witness(input_index, script_pubkey, amount, flags)
-      flags |= SCRIPT_VERIFY_WITNESS
-      flags |= SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
-      checker = Bitcoin::TxChecker.new(tx: self, input_index: input_index, amount: amount)
+    def verify_input_sig_for_witness(input_index, script_pubkey, amount, flags, prevouts)
+      checker = Bitcoin::TxChecker.new(tx: self, input_index: input_index, amount: amount, prevouts: prevouts)
       interpreter = Bitcoin::ScriptInterpreter.new(checker: checker, flags: flags)
       i = inputs[input_index]
-
-      script_sig = i.script_sig
-      witness = i.script_witness
-      interpreter.verify_script(script_sig, script_pubkey, witness)
+      interpreter.verify_script(i.script_sig, script_pubkey, i.script_witness)
     end
 
   end

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.6.0"
+  VERSION = "1.0.0"
 end

data/lib/bitcoin.rb

@@ -60,6 +60,8 @@ module Bitcoin
   autoload :BIP85Entropy, 'bitcoin/bip85_entropy'
   autoload :Errors, 'bitcoin/errors'
   autoload :SigHashGenerator, 'bitcoin/sighash_generator'
+  autoload :MessageSign, 'bitcoin/message_sign'
+  autoload :Taproot, 'bitcoin/taproot'
 
   require_relative 'bitcoin/constants'
   require_relative 'bitcoin/ext/ecdsa'
@@ -133,14 +135,7 @@ module Bitcoin
 
     # get opcode
     def opcode
-      case encoding
-      when Encoding::ASCII_8BIT
-        each_byte.next
-      when Encoding::US_ASCII
-        ord
-      else
-        to_i
-      end
+      force_encoding(Encoding::ASCII_8BIT).ord
     end
 
     def opcode?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-20 00:00:00.000000000 Z
+date: 2021-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: daemon-spawn
   requirement: !ruby/object:Gem::Requirement
@@ -198,14 +198,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: base32
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.4
 - !ruby/object:Gem::Dependency
   name: leveldb-native
   requirement: !ruby/object:Gem::Requirement
@@ -290,6 +304,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.11.1
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.20.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.20.1
 description: The implementation of Bitcoin Protocol for Ruby.
 email:
 - azuchi@chaintope.com
@@ -299,11 +327,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- ".rspec_parallel"
 - ".ruby-gemset"
 - ".ruby-version"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -332,6 +361,7 @@ files:
 - lib/bitcoin/descriptor.rb
 - lib/bitcoin/errors.rb
 - lib/bitcoin/ext.rb
+- lib/bitcoin/ext/array_ext.rb
 - lib/bitcoin/ext/ecdsa.rb
 - lib/bitcoin/ext/json_parser.rb
 - lib/bitcoin/ext_key.rb
@@ -342,6 +372,7 @@ files:
 - lib/bitcoin/merkle_tree.rb
 - lib/bitcoin/message.rb
 - lib/bitcoin/message/addr.rb
+- lib/bitcoin/message/addr_v2.rb
 - lib/bitcoin/message/base.rb
 - lib/bitcoin/message/block.rb
 - lib/bitcoin/message/block_transaction_request.rb
@@ -379,11 +410,13 @@ files:
 - lib/bitcoin/message/pong.rb
 - lib/bitcoin/message/prefilled_tx.rb
 - lib/bitcoin/message/reject.rb
+- lib/bitcoin/message/send_addr_v2.rb
 - lib/bitcoin/message/send_cmpct.rb
 - lib/bitcoin/message/send_headers.rb
 - lib/bitcoin/message/tx.rb
 - lib/bitcoin/message/ver_ack.rb
 - lib/bitcoin/message/version.rb
+- lib/bitcoin/message_sign.rb
 - lib/bitcoin/mnemonic.rb
 - lib/bitcoin/mnemonic/wordlist/chinese_simplified.txt
 - lib/bitcoin/mnemonic/wordlist/chinese_traditional.txt
@@ -443,6 +476,9 @@ files:
 - lib/bitcoin/store/db/level_db.rb
 - lib/bitcoin/store/spv_chain.rb
 - lib/bitcoin/store/utxo_db.rb
+- lib/bitcoin/taproot.rb
+- lib/bitcoin/taproot/leaf_node.rb
+- lib/bitcoin/taproot/simple_builder.rb
 - lib/bitcoin/tx.rb
 - lib/bitcoin/tx_in.rb
 - lib/bitcoin/tx_out.rb
@@ -478,7 +514,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: The implementation of Bitcoin Protocol for Ruby.

data/.travis.yml

@@ -1,13 +0,0 @@
-language: ruby
-rvm:
-  - 2.4.10
-  - 2.5.8
-  - 2.6.6
-  - 2.7.2
-  - 3.0.0
-addons:
-  apt:
-    packages:
-      - libleveldb-dev
-script:
-  - bundle exec parallel_test spec/ -n 6 --type rspec