tapyrus 0.1.0

data/lib/tapyrus/tx.rb

@@ -0,0 +1,347 @@
+# Porting part of the code from bitcoin-ruby. see the license.
+# https://github.com/lian/bitcoin-ruby/blob/master/COPYING
+
+module Tapyrus
+
+  # Transaction class
+  class Tx
+
+    MAX_STANDARD_VERSION = 2
+
+    # The maximum weight for transactions we're willing to relay/mine
+    MAX_STANDARD_TX_WEIGHT = 400000
+
+    MARKER = 0x00
+    FLAG = 0x01
+
+    attr_accessor :version
+    attr_accessor :marker
+    attr_accessor :flag
+    attr_reader :inputs
+    attr_reader :outputs
+    attr_accessor :lock_time
+
+    def initialize
+      @inputs = []
+      @outputs = []
+      @version = 1
+      @lock_time = 0
+    end
+
+    alias_method :in, :inputs
+    alias_method :out, :outputs
+
+    def self.parse_from_payload(payload, non_witness: false)
+      buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+      tx = new
+      tx.version = buf.read(4).unpack('V').first
+
+      in_count = Tapyrus.unpack_var_int_from_io(buf)
+      witness = false
+      if in_count.zero? && !non_witness
+        tx.marker = 0
+        tx.flag = buf.read(1).unpack('c').first
+        if tx.flag.zero?
+          buf.pos -= 1
+        else
+          in_count = Tapyrus.unpack_var_int_from_io(buf)
+          witness = true
+        end
+      end
+
+      in_count.times do
+        tx.inputs << TxIn.parse_from_payload(buf)
+      end
+
+      out_count = Tapyrus.unpack_var_int_from_io(buf)
+      out_count.times do
+        tx.outputs << TxOut.parse_from_payload(buf)
+      end
+
+      if witness
+        in_count.times do |i|
+          tx.inputs[i].script_witness = Tapyrus::ScriptWitness.parse_from_payload(buf)
+        end
+      end
+
+      tx.lock_time = buf.read(4).unpack('V').first
+
+      tx
+    end
+
+    def hash
+      to_payload.bth.to_i(16)
+    end
+
+    def tx_hash
+      Tapyrus.double_sha256(serialize_old_format).bth
+    end
+
+    def txid
+      buf = [version].pack('V')
+      buf << Tapyrus.pack_var_int(inputs.length) << inputs.map{|i|i.to_payload(use_malfix: true)}.join
+      buf << Tapyrus.pack_var_int(outputs.length) << outputs.map(&:to_payload).join
+      buf << [lock_time].pack('V')
+      Tapyrus.double_sha256(buf).reverse.bth
+    end
+
+    def witness_hash
+      Tapyrus.double_sha256(to_payload).bth
+    end
+
+    def wtxid
+      witness_hash.rhex
+    end
+
+    # get the witness commitment of coinbase tx.
+    # if this tx does not coinbase or not have commitment, return nil.
+    def witness_commitment
+      return nil unless coinbase_tx?
+      outputs.each do |output|
+        commitment = output.script_pubkey.witness_commitment
+        return commitment if commitment
+      end
+      nil
+    end
+
+    def to_payload
+      witness? ? serialize_witness_format : serialize_old_format
+    end
+
+    # convert tx to hex format.
+    # @return [String] tx with hex format.
+    def to_hex
+      to_payload.bth
+    end
+
+    def coinbase_tx?
+      inputs.length == 1 && inputs.first.coinbase?
+    end
+
+    def witness?
+      !inputs.find { |i| !i.script_witness.empty? }.nil?
+    end
+
+    def ==(other)
+      to_payload == other.to_payload
+    end
+
+    # serialize tx with old tx format
+    def serialize_old_format
+      buf = [version].pack('V')
+      buf << Tapyrus.pack_var_int(inputs.length) << inputs.map(&:to_payload).join
+      buf << Tapyrus.pack_var_int(outputs.length) << outputs.map(&:to_payload).join
+      buf << [lock_time].pack('V')
+      buf
+    end
+
+    # serialize tx with segwit tx format
+    # https://github.com/bitcoin/bips/blob/master/bip-0144.mediawiki
+    def serialize_witness_format
+      buf = [version, MARKER, FLAG].pack('Vcc')
+      buf << Tapyrus.pack_var_int(inputs.length) << inputs.map(&:to_payload).join
+      buf << Tapyrus.pack_var_int(outputs.length) << outputs.map(&:to_payload).join
+      buf << witness_payload << [lock_time].pack('V')
+      buf
+    end
+
+    def witness_payload
+      inputs.map { |i| i.script_witness.to_payload }.join
+    end
+
+    # check this tx is standard.
+    def standard?
+      return false if version > MAX_STANDARD_VERSION
+      return false if weight > MAX_STANDARD_TX_WEIGHT
+      inputs.each do |i|
+        # Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed keys (remember the 520 byte limit on redeemScript size).
+        # That works out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627
+        # bytes of scriptSig, which we round off to 1650 bytes for some minor future-proofing.
+        # That's also enough to spend a 20-of-20 CHECKMULTISIG scriptPubKey, though such a scriptPubKey is not considered standard.
+        return false if i.script_sig.size > 1650
+        return false unless i.script_sig.push_only?
+      end
+      data_count = 0
+      outputs.each do |o|
+        return false unless o.script_pubkey.standard?
+        data_count += 1 if o.script_pubkey.op_return?
+        # TODO add non P2SH multisig relay(permitbaremultisig)
+        return false if o.dust?
+      end
+      return false if data_count > 1
+      true
+    end
+
+    # The serialized transaction size
+    def size
+      to_payload.bytesize
+    end
+
+    # The virtual transaction size (differs from size for witness transactions)
+    def vsize
+      (weight.to_f / 4).ceil
+    end
+
+    # calculate tx weight
+    # weight = (legacy tx payload) * 3 + (witness tx payload)
+    def weight
+      if witness?
+        serialize_old_format.bytesize * (WITNESS_SCALE_FACTOR - 1) + serialize_witness_format.bytesize
+      else
+        serialize_old_format.bytesize * WITNESS_SCALE_FACTOR
+      end
+    end
+
+    # get signature hash
+    # @param [Integer] input_index input index.
+    # @param [Integer] hash_type signature hash type
+    # @param [Tapyrus::Script] output_script script pubkey or script code. if script pubkey is P2WSH, set witness script to this.
+    # @param [Integer] amount tapyrus 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)
+      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 || Tapyrus.chain_params.fork_chain?
+        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
+    end
+
+    # verify input signature.
+    # @param [Integer] input_index
+    # @param [Tapyrus::Script] script_pubkey the script pubkey for target input.
+    # @param [Integer] amount the amount of tapyrus, 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)
+      script_sig = inputs[input_index].script_sig
+      has_witness = inputs[input_index].has_witness?
+
+      if script_pubkey.p2sh?
+        flags << SCRIPT_VERIFY_P2SH
+        redeem_script = Script.parse_from_payload(script_sig.chunks.last)
+        script_pubkey = redeem_script if redeem_script.p2wpkh?
+      end
+
+      if has_witness || Tapyrus.chain_params.fork_chain?
+        verify_input_sig_for_witness(input_index, script_pubkey, amount, flags)
+      else
+        verify_input_sig_for_legacy(input_index, script_pubkey, flags)
+      end
+    end
+
+    def to_h
+      {
+          txid: txid, hash: witness_hash.rhex, version: version, size: size, vsize: vsize, locktime: lock_time,
+          vin: inputs.map(&:to_h), vout: outputs.map.with_index{|tx_out, index| tx_out.to_h.merge({n: index})}
+      }
+    end
+
+    # Verify transaction validity.
+    # @return [Boolean] whether this tx is valid or not.
+    def valid?
+      state = Tapyrus::ValidationState.new
+      validation = Tapyrus::Validation.new
+      validation.check_tx(self, state) && state.valid?
+    end
+
+    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(Tapyrus::Opcodes::OP_CODESEPARATOR))
+        else
+          case hash_type & 0x1f
+            when SIGHASH_TYPE[:none], SIGHASH_TYPE[:single]
+              i.to_payload(Tapyrus::Script.new, 0)
+            else
+              i.to_payload(Tapyrus::Script.new)
+          end
+        end
+      end
+
+      outs = outputs.map(&:to_payload)
+      out_size = Tapyrus.pack_var_int(outputs.size)
+
+      case hash_type & 0x1f
+        when SIGHASH_TYPE[:none]
+          outs = ''
+          out_size = Tapyrus.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 = Tapyrus.pack_var_int(index + 1)
+      end
+
+      if hash_type & SIGHASH_TYPE[:anyonecanpay] != 0
+        ins = [ins[index]]
+      end
+
+      buf = [[version].pack('V'), Tapyrus.pack_var_int(ins.size),
+          ins, out_size, outs, [lock_time, hash_type].pack('VV')].join
+
+      Tapyrus.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 = Tapyrus.double_sha256(inputs.map{|i|i.out_point.to_payload}.join)
+      hash_sequence = Tapyrus.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 = Tapyrus.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") : Tapyrus.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
+      hash_type |= (Tapyrus.chain_params.fork_id << 8) if Tapyrus.chain_params.fork_chain?
+      buf = [ [version].pack('V'), hash_prevouts, hash_sequence, outpoint,
+              script_code ,amount, nsequence, hash_outputs, [@lock_time, hash_type].pack('VV')].join
+      Tapyrus.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
+      checker = Tapyrus::TxChecker.new(tx: self, input_index: input_index)
+      interpreter = Tapyrus::ScriptInterpreter.new(checker: checker, flags: flags)
+
+      interpreter.verify_script(script_sig, script_pubkey)
+    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 = Tapyrus::TxChecker.new(tx: self, input_index: input_index, amount: amount)
+      interpreter = Tapyrus::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)
+    end
+
+  end
+
+end

data/lib/tapyrus/tx_in.rb

@@ -0,0 +1,89 @@
+# Porting part of the code from bitcoin-ruby. see the license.
+# https://github.com/lian/bitcoin-ruby/blob/master/COPYING
+
+module Tapyrus
+
+  # transaction input
+  class TxIn
+
+    attr_accessor :out_point
+    attr_accessor :script_sig
+    attr_accessor :sequence
+    attr_accessor :script_witness
+
+    # Setting nSequence to this value for every input in a transaction disables nLockTime.
+    SEQUENCE_FINAL = 0xffffffff
+
+    # If this flag set, TxIn#sequence is NOT interpreted as a relative lock-time.
+    SEQUENCE_LOCKTIME_DISABLE_FLAG = (1 << 31)
+
+    # If TxIn#sequence encodes a relative lock-time and this flag is set, the relative lock-time has units of 512 seconds,
+    # otherwise it specifies blocks with a granularity of 1.
+    SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22)
+
+    # If TxIn#sequence encodes a relative lock-time, this mask is applied to extract that lock-time from the sequence field.
+    SEQUENCE_LOCKTIME_MASK = 0x0000ffff
+
+    def initialize(out_point: nil, script_sig: Tapyrus::Script.new, script_witness: ScriptWitness.new, sequence: SEQUENCE_FINAL)
+      @out_point = out_point
+      @script_sig = script_sig
+      @script_witness = script_witness
+      @sequence = sequence
+    end
+
+    def self.parse_from_payload(payload)
+      buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+      i = new
+      hash, index = buf.read(36).unpack('a32V')
+      i.out_point = OutPoint.new(hash.bth, index)
+      sig_length = Tapyrus.unpack_var_int_from_io(buf)
+      sig = buf.read(sig_length)
+      if i.coinbase?
+        i.script_sig.chunks[0] = sig
+      else
+        i.script_sig = Script.parse_from_payload(sig)
+      end
+      i.sequence = buf.read(4).unpack('V').first
+      i
+    end
+
+    def coinbase?
+      out_point.coinbase?
+    end
+
+    def to_payload(script_sig = @script_sig, sequence = @sequence, use_malfix: false)
+      p = out_point.to_payload
+      unless use_malfix
+        p << Tapyrus.pack_var_int(script_sig.to_payload.bytesize)
+        p << script_sig.to_payload
+      end
+      p << [sequence].pack('V')
+      p
+    end
+
+    def has_witness?
+      !script_witness.empty?
+    end
+
+    def to_h
+      sig = script_sig.to_h
+      sig.delete(:type)
+      h = {txid: out_point.txid, vout: out_point.index,  script_sig: sig }
+      h[:txinwitness] = script_witness.stack.map(&:bth) if has_witness?
+      h[:sequence] = sequence
+      h
+    end
+
+    def ==(other)
+      to_payload == other.to_payload
+    end
+
+    # return previous output hash (not txid)
+    def prev_hash
+      return nil unless out_point
+      out_point.tx_hash
+    end
+
+  end
+
+end

data/lib/tapyrus/tx_out.rb

@@ -0,0 +1,74 @@
+# Porting part of the code from bitcoin-ruby. see the license.
+# https://github.com/lian/bitcoin-ruby/blob/master/COPYING
+
+module Tapyrus
+
+  # transaction output
+  class TxOut
+
+    include OpenAssets::MarkerOutput
+
+    attr_accessor :value
+    attr_accessor :script_pubkey
+
+    def initialize(value: 0, script_pubkey: nil)
+      @value = value
+      @script_pubkey = script_pubkey
+    end
+
+    def self.parse_from_payload(payload)
+      buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+      value = buf.read(8).unpack('q').first
+      script_size = Tapyrus.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') << Tapyrus.pack_var_int(s.length) << s
+    end
+
+    def to_empty_payload
+      'ffffffffffffffff00'.htb
+    end
+
+    # convert satoshi to btc
+    def value_to_btc
+      value / 100000000.0
+    end
+
+    def to_h
+      {value: value_to_btc, script_pubkey: script_pubkey.to_h}
+    end
+
+    def ==(other)
+      to_payload == other.to_payload
+    end
+
+    # Returns this output bytesize
+    # @return [Integer] bytesize
+    def size
+      to_payload.bytesize
+    end
+
+    # Whether this output is dust or not
+    # @return [Boolean]
+    def dust?
+      value < dust_threshold
+    end
+
+    private
+
+    def dust_threshold
+      return 0 if script_pubkey.unspendable?
+      n_size = size
+      n_size += script_pubkey.witness_program? ? (32 + 4 + 1 + (107 / Tapyrus::WITNESS_SCALE_FACTOR) + 4) : (32 + 4 + 1 + 107 + 4)
+      fee = n_size * Tapyrus.chain_params.dust_relay_fee / 1000
+      if fee == 0 && n_size != 0
+        fee = Tapyrus.chain_params.dust_relay_fee > 0 ? 1 : -1
+      end
+      fee
+    end
+  end
+
+end

data/lib/tapyrus/util.rb

@@ -0,0 +1,133 @@
+# Porting part of the code from bitcoin-ruby. see the license.
+# https://github.com/lian/bitcoin-ruby/blob/master/COPYING
+
+module Tapyrus
+
+  # tapyrus utility.
+  # following methods can be used as follows.
+  #     Tapyrus.pack_var_int(5)
+  module Util
+
+    def pack_var_string(payload)
+      pack_var_int(payload.bytesize) + payload
+    end
+
+    def unpack_var_string(payload)
+      size, payload = unpack_var_int(payload)
+      size > 0 ? payload.unpack("a#{size}a*") : [nil, payload]
+    end
+
+    def pack_var_int(i)
+      if i <  0xfd
+        [i].pack('C')
+      elsif i <= 0xffff
+        [0xfd, i].pack('Cv')
+      elsif i <= 0xffffffff
+        [0xfe, i].pack('CV')
+      elsif i <= 0xffffffffffffffff
+        [0xff, i].pack('CQ')
+      else
+        raise "int(#{i}) too large!"
+      end
+    end
+
+    # @return an integer for a valid payload, otherwise nil
+    def unpack_var_int(payload)
+      case payload.unpack('C').first
+      when 0xfd
+        payload.unpack('xva*')
+      when 0xfe
+        payload.unpack('xVa*')
+      when 0xff
+        payload.unpack('xQa*')
+      else
+        payload.unpack('Ca*')
+      end
+    end
+
+    # @return an integer for a valid payload, otherwise nil
+    def unpack_var_int_from_io(buf)
+      uchar = buf.read(1)&.unpack('C')&.first
+      case uchar
+      when 0xfd
+        buf.read(2)&.unpack('v')&.first
+      when 0xfe
+        buf.read(4)&.unpack('V')&.first
+      when 0xff
+        buf.read(8)&.unpack('Q')&.first
+      else
+        uchar
+      end
+    end
+
+    def pack_boolean(b)
+      b ? [0x01].pack('C') : [0x00].pack('C')
+    end
+
+    def unpack_boolean(payload)
+      data, payload = payload.unpack('Ca*')
+      [(data.zero? ? false : true), payload]
+    end
+
+    def sha256(payload)
+      Digest::SHA256.digest(payload)
+    end
+
+    def double_sha256(payload)
+      sha256(sha256(payload))
+    end
+
+    # 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
+    end
+
+    # padding zero to the left of binary string until bytesize.
+    # @param [String] binary string
+    # @param [Integer] bytesize total bytesize.
+    # @return [String] padded binary string.
+    def padding_zero(binary, bytesize)
+      return binary unless binary.bytesize < bytesize
+      ('00' * (bytesize - binary.bytesize)).htb + binary
+    end
+
+    # generate sha256-ripemd160 hash for value
+    def hash160(hex)
+      Digest::RMD160.hexdigest(Digest::SHA256.digest(hex.htb))
+    end
+
+    # encode Base58 check address.
+    # @param [String] hex the address payload.
+    # @param [String] addr_version the address version for P2PKH and P2SH.
+    # @return [String] Base58 check encoding address.
+    def encode_base58_address(hex, addr_version)
+      base = addr_version + hex
+      Base58.encode(base + calc_checksum(base))
+    end
+
+    # decode Base58 check encoding address.
+    # @param [String] addr address.
+    # @return [Array] hex and address version
+    def decode_base58_address(addr)
+      hex = Base58.decode(addr)
+      if hex.size == 50 && calc_checksum(hex[0...-8]) == hex[-8..-1]
+        raise 'Invalid version bytes.' unless [Tapyrus.chain_params.address_version, Tapyrus.chain_params.p2sh_version].include?(hex[0..1])
+        [hex[2...-8], hex[0..1]]
+      else
+        raise 'Invalid address.'
+      end
+    end
+
+    def calc_checksum(hex)
+      double_sha256(hex.htb).bth[0..7]
+    end
+
+    DIGEST_NAME_SHA256 = 'sha256'
+
+    def hmac_sha256(key, data)
+      OpenSSL::HMAC.digest(DIGEST_NAME_SHA256, key, data)
+    end
+
+  end
+
+end