sibit 0.27.1 → 0.29.0

data/lib/sibit/bitcoin/script.rb

@@ -6,53 +6,51 @@
 require 'digest'
 require_relative 'base58'
 
-class Sibit
-  module Bitcoin
-    # Bitcoin Script parser.
-    #
-    # Parses standard P2PKH scripts to extract addresses.
-    #
-    # Author:: Yegor Bugayenko (yegor256@gmail.com)
-    # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
-    # License:: MIT
-    class Script
-      OP_DUP = 0x76
-      OP_HASH160 = 0xa9
-      OP_EQUALVERIFY = 0x88
-      OP_CHECKSIG = 0xac
-
-      def initialize(hex)
-        @bytes = [hex].pack('H*').bytes
-      end
-
-      def address
-        return p2pkh_address if p2pkh?
-        nil
-      end
-
-      def p2pkh?
-        @bytes.length == 25 &&
-          @bytes[0] == OP_DUP &&
-          @bytes[1] == OP_HASH160 &&
-          @bytes[2] == 20 &&
-          @bytes[23] == OP_EQUALVERIFY &&
-          @bytes[24] == OP_CHECKSIG
-      end
-
-      def hash160
-        return nil unless p2pkh?
-        @bytes[3, 20].pack('C*').unpack1('H*')
-      end
-
-      private
-
-      def p2pkh_address
-        h = hash160
-        return nil unless h
-        versioned = "00#{h}"
-        checksum = Base58.check(versioned)
-        Base58.encode(versioned + checksum)
-      end
+module Sibit::Bitcoin
+  # Bitcoin Script parser.
+  #
+  # Parses standard P2PKH scripts to extract addresses.
+  #
+  # Author:: Yegor Bugayenko (yegor256@gmail.com)
+  # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
+  # License:: MIT
+  class Script
+    OP_DUP = 0x76
+    OP_HASH160 = 0xa9
+    OP_EQUALVERIFY = 0x88
+    OP_CHECKSIG = 0xac
+
+    def initialize(hex)
+      @bytes = [hex].pack('H*').bytes
+    end
+
+    def address
+      return p2pkh_address if p2pkh?
+      nil
+    end
+
+    def p2pkh?
+      @bytes.length == 25 &&
+        @bytes[0] == OP_DUP &&
+        @bytes[1] == OP_HASH160 &&
+        @bytes[2] == 20 &&
+        @bytes[23] == OP_EQUALVERIFY &&
+        @bytes[24] == OP_CHECKSIG
+    end
+
+    def hash160
+      return nil unless p2pkh?
+      @bytes[3, 20].pack('C*').unpack1('H*')
+    end
+
+    private
+
+    def p2pkh_address
+      h = hash160
+      return nil unless h
+      versioned = "00#{h}"
+      checksum = Base58.check(versioned)
+      Base58.encode(versioned + checksum)
     end
   end
 end

data/lib/sibit/bitcoin/tx.rb

@@ -8,205 +8,203 @@ require_relative 'base58'
 require_relative 'key'
 require_relative 'script'
 
-class Sibit
-  module Bitcoin
-    # Bitcoin Transaction structure.
-    #
-    # Author:: Yegor Bugayenko (yegor256@gmail.com)
-    # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
-    # License:: MIT
-    class Tx
-      SIGHASH_ALL = 0x01
-      VERSION = 1
-      SEQUENCE = 0xffffffff
-
-      attr_reader :inputs, :outputs
-
-      def initialize
-        @inputs = []
-        @outputs = []
-      end
+module Sibit::Bitcoin
+  # Bitcoin Transaction structure.
+  #
+  # Author:: Yegor Bugayenko (yegor256@gmail.com)
+  # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
+  # License:: MIT
+  class Tx
+    SIGHASH_ALL = 0x01
+    VERSION = 1
+    SEQUENCE = 0xffffffff
+
+    attr_reader :inputs, :outputs
+
+    def initialize
+      @inputs = []
+      @outputs = []
+    end
 
-      def add_input(hash:, index:, script:, key:)
-        @inputs << Input.new(hash, index, script, key)
-      end
+    def add_input(hash:, index:, script:, key:)
+      @inputs << Input.new(hash, index, script, key)
+    end
 
-      def add_output(value, address)
-        @outputs << Output.new(value, address)
-      end
+    def add_output(value, address)
+      @outputs << Output.new(value, address)
+    end
 
-      def hash
-        Digest::SHA256.hexdigest(Digest::SHA256.digest(payload)).reverse.scan(/../).join
-      end
+    def hash
+      Digest::SHA256.hexdigest(Digest::SHA256.digest(payload)).reverse.scan(/../).join
+    end
 
-      def payload
-        sign_inputs
-        serialize
-      end
+    def payload
+      sign_inputs
+      serialize
+    end
 
-      def hex
-        payload.unpack1('H*')
-      end
+    def hex
+      payload.unpack1('H*')
+    end
 
-      def in
-        @inputs
-      end
+    def in
+      @inputs
+    end
 
-      def out
-        @outputs
-      end
+    def out
+      @outputs
+    end
 
-      private
+    private
 
-      def sign_inputs
-        @inputs.each_with_index do |input, idx|
-          sighash = signature_hash(idx)
-          sig = sign(input.key, sighash)
-          pubkey = [input.key.pub].pack('H*')
-          input.script_sig = der_sig(sig) + pubkey_script(pubkey)
-        end
+    def sign_inputs
+      @inputs.each_with_index do |input, idx|
+        sighash = signature_hash(idx)
+        sig = sign(input.key, sighash)
+        pubkey = [input.key.pub].pack('H*')
+        input.script_sig = der_sig(sig) + pubkey_script(pubkey)
       end
+    end
 
-      def signature_hash(idx)
-        tx_copy = serialize_for_signing(idx)
-        hash_type = [SIGHASH_ALL].pack('V')
-        Digest::SHA256.digest(Digest::SHA256.digest(tx_copy + hash_type))
-      end
+    def signature_hash(idx)
+      tx_copy = serialize_for_signing(idx)
+      hash_type = [SIGHASH_ALL].pack('V')
+      Digest::SHA256.digest(Digest::SHA256.digest(tx_copy + hash_type))
+    end
 
-      def sign(key, hash)
-        der = key.sign(hash)
-        repack(der)
-      end
+    def sign(key, hash)
+      der = key.sign(hash)
+      repack(der)
+    end
 
-      def repack(der)
-        return der if low_s?(der)
-        seq = OpenSSL::ASN1.decode(der)
-        r = seq.value[0].value.to_i
-        s = seq.value[1].value.to_i
-        order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
-        s = order - s if s > order / 2
-        OpenSSL::ASN1::Sequence.new(
-          [OpenSSL::ASN1::Integer.new(r), OpenSSL::ASN1::Integer.new(s)]
-        ).to_der
-      end
+    def repack(der)
+      return der if low_s?(der)
+      seq = OpenSSL::ASN1.decode(der)
+      r = seq.value[0].value.to_i
+      s = seq.value[1].value.to_i
+      order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+      s = order - s if s > order / 2
+      OpenSSL::ASN1::Sequence.new(
+        [OpenSSL::ASN1::Integer.new(r), OpenSSL::ASN1::Integer.new(s)]
+      ).to_der
+    end
 
-      def low_s?(der)
-        seq = OpenSSL::ASN1.decode(der)
-        s = seq.value[1].value.to_i
-        order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
-        s <= order / 2
-      end
+    def low_s?(der)
+      seq = OpenSSL::ASN1.decode(der)
+      s = seq.value[1].value.to_i
+      order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+      s <= order / 2
+    end
 
-      def der_sig(sig)
-        data = sig + [SIGHASH_ALL].pack('C')
-        [data.length].pack('C') + data
-      end
+    def der_sig(sig)
+      data = sig + [SIGHASH_ALL].pack('C')
+      [data.length].pack('C') + data
+    end
 
-      def pubkey_script(pubkey)
-        [pubkey.length].pack('C') + pubkey
-      end
+    def pubkey_script(pubkey)
+      [pubkey.length].pack('C') + pubkey
+    end
 
-      def serialize
-        result = [VERSION].pack('V')
-        result += varint(@inputs.length)
-        @inputs.each do |input|
-          result += [input.hash].pack('H*').reverse
-          result += [input.index].pack('V')
-          result += varint(input.script_sig.length)
-          result += input.script_sig
-          result += [SEQUENCE].pack('V')
-        end
-        result += varint(@outputs.length)
-        @outputs.each do |output|
-          result += [output.value].pack('Q<')
-          script = output.script
-          result += varint(script.length)
-          result += script
-        end
-        result += [0].pack('V')
-        result
-      end
+    def serialize
+      result = [VERSION].pack('V')
+      result += varint(@inputs.length)
+      @inputs.each do |input|
+        result += [input.hash].pack('H*').reverse
+        result += [input.index].pack('V')
+        result += varint(input.script_sig.length)
+        result += input.script_sig
+        result += [SEQUENCE].pack('V')
+      end
+      result += varint(@outputs.length)
+      @outputs.each do |output|
+        result += [output.value].pack('Q<')
+        script = output.script
+        result += varint(script.length)
+        result += script
+      end
+      result += [0].pack('V')
+      result
+    end
 
-      def serialize_for_signing(idx)
-        result = [VERSION].pack('V')
-        result += varint(@inputs.length)
-        @inputs.each_with_index do |input, i|
-          result += [input.hash].pack('H*').reverse
-          result += [input.index].pack('V')
-          if i == idx
-            script = [input.prev_script].pack('H*')
-            result += varint(script.length)
-            result += script
-          else
-            result += varint(0)
-          end
-          result += [SEQUENCE].pack('V')
-        end
-        result += varint(@outputs.length)
-        @outputs.each do |output|
-          result += [output.value].pack('Q<')
-          script = output.script
+    def serialize_for_signing(idx)
+      result = [VERSION].pack('V')
+      result += varint(@inputs.length)
+      @inputs.each_with_index do |input, i|
+        result += [input.hash].pack('H*').reverse
+        result += [input.index].pack('V')
+        if i == idx
+          script = [input.prev_script].pack('H*')
           result += varint(script.length)
           result += script
+        else
+          result += varint(0)
         end
-        result += [0].pack('V')
-        result
+        result += [SEQUENCE].pack('V')
       end
-
-      def varint(num)
-        return [num].pack('C') if num < 0xfd
-        return [0xfd, num].pack('Cv') if num <= 0xffff
-        return [0xfe, num].pack('CV') if num <= 0xffffffff
-        [0xff, num].pack('CQ<')
+      result += varint(@outputs.length)
+      @outputs.each do |output|
+        result += [output.value].pack('Q<')
+        script = output.script
+        result += varint(script.length)
+        result += script
       end
+      result += [0].pack('V')
+      result
     end
 
-    # Transaction input.
-    class Input
-      attr_reader :hash, :index, :prev_script, :key
-      attr_accessor :script_sig
+    def varint(num)
+      return [num].pack('C') if num < 0xfd
+      return [0xfd, num].pack('Cv') if num <= 0xffff
+      return [0xfe, num].pack('CV') if num <= 0xffffffff
+      [0xff, num].pack('CQ<')
+    end
+  end
 
-      def initialize(hash, index, script, key)
-        @hash = hash
-        @index = index
-        @prev_script = script
-        @key = key
-        @script_sig = ''
-      end
+  # Transaction input.
+  class Input
+    attr_reader :hash, :index, :prev_script, :key
+    attr_accessor :script_sig
+
+    def initialize(hash, index, script, key)
+      @hash = hash
+      @index = index
+      @prev_script = script
+      @key = key
+      @script_sig = ''
+    end
 
-      def prev_out
-        [@hash].pack('H*')
-      end
+    def prev_out
+      [@hash].pack('H*')
+    end
 
-      def prev_out_index
-        @index
-      end
+    def prev_out_index
+      @index
     end
+  end
 
-    # Transaction output.
-    class Output
-      attr_reader :value
+  # Transaction output.
+  class Output
+    attr_reader :value
 
-      def initialize(value, address)
-        @value = value
-        @address = address
-      end
+    def initialize(value, address)
+      @value = value
+      @address = address
+    end
 
-      def script
-        hash160 = address_to_hash160(@address)
-        [0x76, 0xa9, 0x14].pack('C*') + [hash160].pack('H*') + [0x88, 0xac].pack('C*')
-      end
+    def script
+      hash160 = address_to_hash160(@address)
+      [0x76, 0xa9, 0x14].pack('C*') + [hash160].pack('H*') + [0x88, 0xac].pack('C*')
+    end
 
-      def script_hex
-        script.unpack1('H*')
-      end
+    def script_hex
+      script.unpack1('H*')
+    end
 
-      private
+    private
 
-      def address_to_hash160(addr)
-        decoded = Base58.decode(addr)
-        decoded[2..41]
-      end
+    def address_to_hash160(addr)
+      decoded = Base58.decode(addr)
+      decoded[2..41]
     end
   end
 end

data/lib/sibit/bitcoin/txbuilder.rb

@@ -3,8 +3,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2025 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-require_relative 'tx'
 require_relative 'key'
+require_relative 'tx'
 
 class Sibit
   module Bitcoin