bitcoinrb 0.5.0 → 0.9.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,21 +33,21 @@ 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).unpack('V').first
+      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).unpack('c').first
+        tx.flag = buf.read(1).unpack1('c')
         if tx.flag.zero?
           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
 
-      tx.lock_time = buf.read(4).unpack('V').first
-
+      raise ArgumentError, 'Transaction has unexpected data.' if strict &&  (buf.pos + 4) != buf.length
+      tx.lock_time = buf.read(4).unpack1('V')
       tx
     end
 
@@ -188,22 +188,26 @@ module Bitcoin
     # @param [Integer] input_index input index.
     # @param [Integer] hash_type signature hash type
     # @param [Bitcoin::Script] output_script script pubkey or script code. if script pubkey is P2WSH, set witness script to this.
+    # @param [Hash] opts Data required for each sig version (amount and skip_separator_index params can also be set to this parameter)
     # @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.
-    def sighash_for_input(input_index, output_script, hash_type: SIGHASH_TYPE[:all],
-                          sig_version: :base, amount: nil, skip_separator_index: 0)
+    # @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, 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.' unless output_script
-      raise ArgumentError, 'unsupported sig version specified.' unless SIG_VERSION.include?(sig_version)
-
-      if sig_version == :witness_v0
-        raise ArgumentError, 'amount must be specified.' unless amount
-        sighash_for_witness(input_index, output_script, hash_type, amount, skip_separator_index)
-      else
-        sighash_for_legacy(input_index, output_script, hash_type)
-      end
+      raise ArgumentError, 'script_pubkey must be specified.' if [:base, :witness_v0].include?(sig_version) && output_script.nil?
+
+      opts[:amount] = amount if amount
+      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
 
     # verify input signature.
@@ -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
@@ -245,73 +251,6 @@ module Bitcoin
 
     private
 
-    # generate sighash with legacy format
-    def sighash_for_legacy(index, script_code, hash_type)
-      ins = inputs.map.with_index do |i, idx|
-        if idx == index
-          i.to_payload(script_code.delete_opcode(Bitcoin::Opcodes::OP_CODESEPARATOR))
-        else
-          case hash_type & 0x1f
-            when SIGHASH_TYPE[:none], SIGHASH_TYPE[:single]
-              i.to_payload(Bitcoin::Script.new, 0)
-            else
-              i.to_payload(Bitcoin::Script.new)
-          end
-        end
-      end
-
-      outs = outputs.map(&:to_payload)
-      out_size = Bitcoin.pack_var_int(outputs.size)
-
-      case hash_type & 0x1f
-        when SIGHASH_TYPE[:none]
-          outs = ''
-          out_size = Bitcoin.pack_var_int(0)
-        when SIGHASH_TYPE[:single]
-          return "\x01".ljust(32, "\x00") if index >= outputs.size
-          outs = outputs[0...(index + 1)].map.with_index { |o, idx| (idx == index) ? o.to_payload : o.to_empty_payload }.join
-          out_size = Bitcoin.pack_var_int(index + 1)
-      end
-
-      if hash_type & SIGHASH_TYPE[:anyonecanpay] != 0
-        ins = [ins[index]]
-      end
-
-      buf = [[version].pack('V'), Bitcoin.pack_var_int(ins.size),
-          ins, out_size, outs, [lock_time, hash_type].pack('VV')].join
-
-      Bitcoin.double_sha256(buf)
-    end
-
-    # generate sighash with BIP-143 format
-    # https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki
-    def sighash_for_witness(index, script_pubkey_or_script_code, hash_type, amount, skip_separator_index)
-      hash_prevouts = Bitcoin.double_sha256(inputs.map{|i|i.out_point.to_payload}.join)
-      hash_sequence = Bitcoin.double_sha256(inputs.map{|i|[i.sequence].pack('V')}.join)
-      outpoint = inputs[index].out_point.to_payload
-      amount = [amount].pack('Q')
-      nsequence = [inputs[index].sequence].pack('V')
-      hash_outputs = Bitcoin.double_sha256(outputs.map{|o|o.to_payload}.join)
-
-      script_code = script_pubkey_or_script_code.to_script_code(skip_separator_index)
-
-      case (hash_type & 0x1f)
-      when SIGHASH_TYPE[:single]
-        hash_outputs = index >= outputs.size ? "\x00".ljust(32, "\x00") : Bitcoin.double_sha256(outputs[index].to_payload)
-        hash_sequence = "\x00".ljust(32, "\x00")
-      when SIGHASH_TYPE[:none]
-        hash_sequence = hash_outputs = "\x00".ljust(32, "\x00")
-      end
-
-      if (hash_type & SIGHASH_TYPE[:anyonecanpay]) != 0
-        hash_prevouts = hash_sequence ="\x00".ljust(32, "\x00")
-      end
-
-      buf = [ [version].pack('V'), hash_prevouts, hash_sequence, outpoint,
-              script_code ,amount, nsequence, hash_outputs, [@lock_time, hash_type].pack('VV')].join
-      Bitcoin.double_sha256(buf)
-    end
-
     # verify input signature for legacy tx.
     def verify_input_sig_for_legacy(input_index, script_pubkey, flags)
       script_sig = inputs[input_index].script_sig
@@ -322,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/tx_in.rb

@@ -42,7 +42,7 @@ module Bitcoin
       else
         i.script_sig = Script.parse_from_payload(buf.read(sig_length))
       end
-      i.sequence = buf.read(4).unpack('V').first
+      i.sequence = buf.read(4).unpack1('V')
       i
     end
 

data/lib/bitcoin/tx_out.rb

@@ -18,14 +18,13 @@ module Bitcoin
 
     def self.parse_from_payload(payload)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
-      value = buf.read(8).unpack('q').first
+      value = buf.read(8).unpack1('q')
       script_size = Bitcoin.unpack_var_int_from_io(buf)
       new(value: value, script_pubkey: Script.parse_from_payload(buf.read(script_size)))
     end
 
     def to_payload
-      s = script_pubkey.to_payload
-      [value].pack('Q') << Bitcoin.pack_var_int(s.length) << s
+      [value].pack('Q') << script_pubkey.to_payload(true)
     end
 
     def to_empty_payload

data/lib/bitcoin/util.rb

@@ -33,7 +33,7 @@ module Bitcoin
 
     # @return an integer for a valid payload, otherwise nil
     def unpack_var_int(payload)
-      case payload.unpack('C').first
+      case payload.unpack1('C')
       when 0xfd
         payload.unpack('xva*')
       when 0xfe
@@ -47,14 +47,14 @@ module Bitcoin
 
     # @return an integer for a valid payload, otherwise nil
     def unpack_var_int_from_io(buf)
-      uchar = buf.read(1)&.unpack('C')&.first
+      uchar = buf.read(1)&.unpack1('C')
       case uchar
       when 0xfd
-        buf.read(2)&.unpack('v')&.first
+        buf.read(2)&.unpack1('v')
       when 0xfe
-        buf.read(4)&.unpack('V')&.first
+        buf.read(4)&.unpack1('V')
       when 0xff
-        buf.read(8)&.unpack('Q')&.first
+        buf.read(8)&.unpack1('Q')
       else
         uchar
       end
@@ -79,7 +79,7 @@ module Bitcoin
 
     # byte convert to the sequence of bits packed eight in a byte with the least significant bit first.
     def byte_to_bit(byte)
-      byte.unpack('b*').first
+      byte.unpack1('b*')
     end
 
     # padding zero to the left of binary string until bytesize.
@@ -96,6 +96,15 @@ module Bitcoin
       Digest::RMD160.hexdigest(Digest::SHA256.digest(hex.htb))
     end
 
+    # Generate tagged hash value.
+    # @param [String] tag tag value.
+    # @param [String] msg the message to be hashed.
+    # @return [String] the hash value with binary format.
+    def tagged_hash(tag, msg)
+      tag_hash = Digest::SHA256.digest(tag)
+      Digest::SHA256.digest(tag_hash + tag_hash + msg)
+    end
+
     # encode Base58 check address.
     # @param [String] hex the address payload.
     # @param [String] addr_version the address version for P2PKH and P2SH.

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.5.0"
+  VERSION = "0.9.0"
 end

data/lib/bitcoin/wallet/account.rb

@@ -43,7 +43,7 @@ module Bitcoin
 
       def to_payload
         payload = account_key.to_payload
-        payload << Bitcoin.pack_var_string(name.unpack('H*').first.htb)
+        payload << Bitcoin.pack_var_string(name.unpack1('H*').htb)
         payload << [purpose, index, receive_depth, change_depth, lookahead].pack('I*')
         payload
       end

data/lib/bitcoin.rb

@@ -3,7 +3,7 @@
 
 require 'bitcoin/version'
 require 'eventmachine'
-require 'ecdsa'
+require 'schnorr'
 require 'securerandom'
 require 'json'
 require 'bech32'
@@ -58,8 +58,13 @@ module Bitcoin
   autoload :Aezeed, 'bitcoin/aezeed'
   autoload :PaymentCode, 'bitcoin/payment_code'
   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'
 
   extend Util
 
@@ -67,7 +72,7 @@ module Bitcoin
 
   # set bitcoin network chain params
   def self.chain_params=(name)
-    raise "chain params for #{name} is not defined." unless %i(mainnet testnet regtest).include?(name.to_sym)
+    raise "chain params for #{name} is not defined." unless %i(mainnet testnet regtest signet).include?(name.to_sym)
     @current_chain = nil
     @chain_param = name.to_sym
   end
@@ -82,6 +87,8 @@ module Bitcoin
       @current_chain = Bitcoin::ChainParams.testnet
     when :regtest
       @current_chain = Bitcoin::ChainParams.regtest
+    when :signet
+      @current_chain = Bitcoin::ChainParams.signet
     end
     @current_chain
   end
@@ -108,7 +115,7 @@ module Bitcoin
   class ::String
     # binary convert to hex string
     def bth
-      unpack('H*').first
+      unpack1('H*')
     end
 
     # hex string convert to binary
@@ -128,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?
@@ -165,6 +165,27 @@ module Bitcoin
       self[offset..-1]
     end
 
+    def valid_pushdata_length?
+      buf = StringIO.new(self)
+      opcode = buf.read(1).ord
+      offset = 1
+      return false if buf.eof?
+      len = case opcode
+            when Bitcoin::Opcodes::OP_PUSHDATA1
+              offset += 1
+              buf.read(1).unpack1('C')
+            when Bitcoin::Opcodes::OP_PUSHDATA2
+              offset += 2
+              buf.read(2).unpack1('v')
+            when Bitcoin::Opcodes::OP_PUSHDATA4
+              offset += 4
+              buf.read(4).unpack1('V')
+            else
+              opcode
+            end
+      self.bytesize == len + offset
+    end
+
     # whether value is hex or not hex
     # @return [Boolean] return true if data is hex
     def valid_hex?
@@ -219,17 +240,4 @@ module Bitcoin
     end
   end
 
-  class ::ECDSA::Signature
-    # convert signature to der string.
-    def to_der
-      ECDSA::Format::SignatureDerString.encode(self)
-    end
-  end
-
-  class ::ECDSA::Point
-    def to_hex(compression = true)
-      ECDSA::Format::PointOctetString.encode(self, compression: compression).bth
-    end
-  end
-
 end