coin-op 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45dac9e7491f6421517aef93700c6063e977d752
-  data.tar.gz: f32da4cc0cfb9b004fff31a5523dd90c7ad5c847
+  metadata.gz: fb3f0c14ebb0842dde25e82a66276a7f8696ee02
+  data.tar.gz: e9cb449657d9ee89a43c779da8ef4e5d25997ffa
 SHA512:
-  metadata.gz: c41d2028acf3753edf97b35d111c8d3bd1df92b02f5a9ba079c8d13fa89681f386bf3ceb8d0e96cefe18819913fc35f68c0e61a860977e32cf6a8d141824df64
-  data.tar.gz: f8b07a487c25628ba0af70f50a48f56a544ab3766a2d4186b92a31b4d86a4393042655fa0a83c96dc3b913d2cb7a68f2b44221797cff12b06dc7b69b1181e2d5
+  metadata.gz: 3dddf2781e3e9d3aaade199ab6cf30979138f796457fa8d8dfe81d0c656e4224f027571310fd5521980a6dda2baaf102ed50347bde2ebf98aa941aed79e110b9
+  data.tar.gz: 92a224650077948d9a84580349b379e2089b2dc5c4f9ed7ab0f3a916b2588b5c585f1e5a363dfaa89db39be507ccbb9b289476211a12497265162e9c871b82d2

data.tar.gz.sig

@@ -1 +1 @@
-zW����&oM.Rꌹ°5�Ş��!��m'G���.����aC�/v7	�{t˝H��+����V���,�OɓN�k��1�f�oV���x��.mK�^���-�,^�oH[#L�n��!�/�a������l4��'}��	A�Y�4+
+�j� �C=��aYbc�X��

data/lib/coin-op/bit.rb

@@ -1,4 +1,61 @@
-require "bitcoin"
+require 'bitcoin'
+
+Bitcoin::NETWORKS[:dogecoin] = Bitcoin::NETWORKS[:litecoin].merge({
+  project: :dogecoin,
+  magic_head: "\xc0\xc0\xc0\xc0",
+  address_version: "1e",
+  p2sh_version: "16",
+  privkey_version: "9e",
+  default_port: 22556,
+  protocol_version: 70003,
+  max_money: 100_000_000_000 * Bitcoin::COIN,
+  min_tx_fee: Bitcoin::COIN,
+  min_relay_tx_fee: Bitcoin::COIN,
+  free_tx_bytes: 26_000,
+  dust: Bitcoin::COIN,
+  per_dust_fee: true,
+  coinbase_maturity: 30,
+  coinbase_maturity_new: 240,
+  reward_base: 500_000 * Bitcoin::COIN,
+  reward_halving: 100_000,
+  retarget_interval: 240,
+  retarget_time: 14400, # 4 hours
+  retarget_time_new: 60, # 1 minute
+  target_spacing: 60, # block interval
+  dns_seeds: [
+    "seed.dogechain.info", 
+    "seed.dogecoin.com",
+  ],
+  genesis_hash: "1a91e3dace36e2be3bf030a65679fe821aa1d6ef92e7c9902eb318182c355691",
+  proof_of_work_limit: 0x1e0fffff,
+  alert_pubkeys: [],
+  known_nodes: [
+    "daemons.chain.so",
+    "bootstrap.chain.so",
+  ],
+  checkpoints: {
+    0 => "1a91e3dace36e2be3bf030a65679fe821aa1d6ef92e7c9902eb318182c355691",
+    42279 => "8444c3ef39a46222e87584ef956ad2c9ef401578bd8b51e8e4b9a86ec3134d3a",
+    42400 => "557bb7c17ed9e6d4a6f9361cfddf7c1fc0bdc394af7019167442b41f507252b4",
+    104679 => "35eb87ae90d44b98898fec8c39577b76cb1eb08e1261cfc10706c8ce9a1d01cf",
+    128370 => "3f9265c94cab7dc3bd6a2ad2fb26c8845cb41cff437e0a75ae006997b4974be6",
+    145000 => "cc47cae70d7c5c92828d3214a266331dde59087d4a39071fa76ddfff9b7bde72",
+    165393 => "7154efb4009e18c1c6a6a79fc6015f48502bcd0a1edd9c20e44cd7cbbe2eeef1",
+    186774 => "3c712c49b34a5f34d4b963750d6ba02b73e8a938d2ee415dcda141d89f5cb23a",
+    199992 => "3408ff829b7104eebaf61fd2ba2203ef2a43af38b95b353e992ef48f00ebb190",
+    225000 => "be148d9c5eab4a33392a6367198796784479720d06bfdd07bd547fe934eea15a",
+    250000 => "0e4bcfe8d970979f7e30e2809ab51908d435677998cf759169407824d4f36460",
+    270639 => "c587a36dd4f60725b9dd01d99694799bef111fc584d659f6756ab06d2a90d911",
+    299742 => "1cc89c0c8a58046bf0222fe131c099852bd9af25a80e07922918ef5fb39d6742",
+    323141 => "60c9f919f9b271add6ef5671e9538bad296d79f7fdc6487ba702bf2ba131d31d",
+    339202 => "8c29048df5ae9df38a67ea9470fdd404d281a3a5c6f33080cd5bf14aa496ab03"
+  },
+  auxpow_chain_id: 0x0062,
+  # Doge-specific hard-fork cutoffs
+  difficulty_change_block: 145000,
+  maturity_change_block: 145000,
+  auxpow_start_block: 371337
+})
 
 # bitcoin-ruby is not multi-network friendly.  It's also a hassle
 # to tell what network you're using if you don't already know.
@@ -7,12 +64,185 @@ Bitcoin::NETWORKS.each do |name, definition|
   definition[:name] = name
 end
 
+module Bitcoin
+  module OpenSSL_EC
+    attach_function :d2i_ECDSA_SIG, [:pointer, :pointer, :long], :pointer
+    attach_function :i2d_ECDSA_SIG, [:pointer, :pointer], :int
+    attach_function :OPENSSL_free, :CRYPTO_free, [:pointer], :void
+    attach_function :BN_rshift1, [:pointer, :pointer], :int
+    attach_function :BN_sub, [:pointer, :pointer, :pointer], :int
+    attach_function :BN_num_bits, [:pointer], :int
+    
+    def self.BN_num_bytes(ptr); (BN_num_bits(ptr) + 7) / 8; end
+
+    # repack signature for OpenSSL 1.0.1k handling of DER signatures
+    # https://github.com/bitcoin/bitcoin/pull/5634/files
+    def self.repack_der_signature(signature)
+      init_ffi_ssl
+
+      return false if signature.empty?
+
+      # New versions of OpenSSL will reject non-canonical DER signatures. de/re-serialize first.
+      norm_der = FFI::MemoryPointer.new(:pointer)
+      sig_ptr  = FFI::MemoryPointer.new(:pointer).put_pointer(0, FFI::MemoryPointer.from_string(signature))
+
+      norm_sig = d2i_ECDSA_SIG(nil, sig_ptr, signature.bytesize)
+
+      derlen = i2d_ECDSA_SIG(norm_sig, norm_der)
+      ECDSA_SIG_free(norm_sig)
+      return false if derlen <= 0
+
+      ret = norm_der.read_pointer.read_string(derlen)
+      OPENSSL_free(norm_der.read_pointer)
+
+      ret
+    end
+
+    # Regenerate a DER-encoded signature such that the S-value complies with the BIP62
+    # specification.
+    #
+    def self.signature_to_low_s(signature)
+      init_ffi_ssl
+
+      temp = signature.unpack("C*")
+      length_r = temp[3]
+      length_s = temp[5+length_r]
+      sig = FFI::MemoryPointer.from_string(signature)
+
+      # Calculate the lower s value
+      s = BN_bin2bn(sig[6 + length_r], length_s, BN_new())
+      eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+      group, order, halforder, ctx = EC_KEY_get0_group(eckey), BN_new(), BN_new(), BN_CTX_new()
+
+      EC_GROUP_get_order(group, order, ctx)
+      BN_rshift1(halforder, order)
+      if BN_cmp(s, halforder) > 0
+        BN_sub(s, order, s)
+      end
+
+      BN_free(halforder)
+      BN_free(order)
+      BN_CTX_free(ctx)
+      
+      buf = FFI::MemoryPointer.new(:uint8, BN_num_bytes(s))
+      BN_bn2bin(s, buf)
+      length_s = BN_num_bytes(s)
+      # p buf.read_string(length_s).unpack("H*")
+      
+      # Re-encode the signature in DER format
+      sig = [0x30, 0, 0x02, length_r]
+      sig.concat(temp.slice(4, length_r))
+      sig << 0x02
+      sig << length_s
+      sig.concat(buf.read_string(length_s).unpack("C*"))
+      sig[1] = sig.size - 2
+
+      BN_free(s)
+      EC_KEY_free(eckey)
+
+      sig.pack("C*")
+    end
+
+  end
+
+  module Util
+    def verify_signature(hash, signature, public_key)
+      key  = bitcoin_elliptic_curve
+      key.public_key = ::OpenSSL::PKey::EC::Point.from_hex(key.group, public_key)
+      signature = Bitcoin::OpenSSL_EC.repack_der_signature(signature)
+      if signature
+        key.dsa_verify_asn1(hash, signature)
+      else
+        false
+      end
+    rescue OpenSSL::PKey::ECError, OpenSSL::PKey::EC::Point::Error
+      false
+    end
+  end
+
+  class Key
+    # Sign +data+ with the key.
+    #  key1 = Bitcoin::Key.generate
+    #  sig = key1.sign("some data")
+    def sign(data)
+      sig = @key.dsa_sign_asn1(data)
+      if Script::is_low_der_signature?(sig)
+        sig
+      else
+        Bitcoin::OpenSSL_EC.signature_to_low_s(sig)
+      end
+    end
+
+    # Verify signature +sig+ for +data+.
+    #  key2 = Bitcoin::Key.new(nil, key1.pub)
+    #  key2.verify("some data", sig)
+    def verify(data, sig)
+      regenerate_pubkey unless @key.public_key
+      sig = Bitcoin::OpenSSL_EC.repack_der_signature(sig)
+      if sig
+        @key.dsa_verify_asn1(data, sig)
+      else
+        false
+      end
+    end
+  end
+
+  class Script
+    attr_reader :raw, :chunks, :debug, :stack
+
+    # Loosely correlates with IsLowDERSignature() from interpreter.cpp
+    def self.is_low_der_signature?(sig)
+      s = sig.unpack("C*")
+
+      length_r = s[3]
+      length_s = s[5+length_r]
+      s_val = s.slice(6 + length_r, length_s)
+
+      # If the S value is above the order of the curve divided by two, its
+      # complement modulo the order could have been used instead, which is
+      # one byte shorter when encoded correctly.
+      max_mod_half_order = [
+        0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+        0x5d,0x57,0x6e,0x73,0x57,0xa4,0x50,0x1d,
+        0xdf,0xe9,0x2f,0x46,0x68,0x1b,0x20,0xa0]
+
+      compare_big_endian(s_val, [0]) > 0 &&
+        compare_big_endian(s_val, max_mod_half_order) <= 0
+    end
+
+    # Compares two arrays of bytes
+    def self.compare_big_endian(c1, c2)
+      c1, c2 = c1.dup, c2.dup # Clone the arrays
+
+      while c1.size > c2.size
+        return 1 if c1.shift > 0
+      end
+
+      while c2.size > c1.size
+        return -1 if c2.shift > 0
+      end
+
+      c1.size.times{|idx| return c1[idx] - c2[idx] if c1[idx] != c2[idx] }
+      0
+    end
+  end
+
+end
 
 # BIP 32 Hierarchical Deterministic Wallets
 require "money-tree"
 
 # establish the namespace
 module CoinOp
+  @bitcoin_mutex = Mutex.new
+
+  def self.syncbit(network, &block)
+    @bitcoin_mutex.synchronize do
+      Bitcoin.network = network
+      block.call
+    end
+  end
   module Bit
   end
 end
@@ -30,3 +260,4 @@ require_relative "bit/fee"
 # Augmented functionality
 require_relative "bit/multi_wallet"
 
+

data/lib/coin-op/bit/fee.rb

@@ -12,7 +12,7 @@ module CoinOp::Bit
     # that deviate from the customary single signature.
     #
     # Returns the estimated fee in satoshis.
-    def estimate(unspents, payees, tx_size=nil)
+    def estimate(unspents, payees, tx_size=nil, network:)
       # https://en.bitcoin.it/wiki/Transaction_fees
 
       # dupe because we'll need to add a change output
@@ -21,7 +21,7 @@ module CoinOp::Bit
       unspent_total = unspents.inject(0) {|sum, output| sum += output.value}
       payee_total = payees.inject(0) {|sum, payee| sum += payee.value}
       nominal_change = unspent_total - payee_total
-      payees << Output.new(:value => nominal_change)
+      payees << Output.new(value: nominal_change, network: network)
 
       tx_size ||= estimate_tx_size(unspents.size, payees.size)
       min = payees.min_by {|payee| payee.value }
@@ -37,17 +37,17 @@ module CoinOp::Bit
       if small && big_outputs && high_priority
         0
       else
-        fee_for_bytes(tx_size)
+        fee_for_bytes(tx_size, network: network)
       end
 
     end
 
-    def fee_for_bytes(bytes)
+    def fee_for_bytes(bytes, network:) 
       # https://en.bitcoin.it/wiki/Transaction_fees
       # > the reference implementation will round up the transaction size to the
       # > next thousand bytes and add a fee of 0.1 mBTC (0.0001 BTC) per thousand bytes
       size = (bytes / 1000) + 1
-      Bitcoin.network[:min_tx_fee] * size
+      CoinOp.syncbit(network) { Bitcoin.network[:min_tx_fee] * size }
     end
 
     # From http://bitcoinfees.com.  This estimation is only valid for

data/lib/coin-op/bit/input.rb

@@ -19,13 +19,13 @@ module CoinOp::Bit
     # * script_sig_asm - the string form of the scriptSig for this input
     #
     def initialize(options={})
-      @transaction, @index, @output =
-        options.values_at :transaction, :index, :output
+      @transaction, @index, @output, @network =
+        options.values_at :transaction, :index, :output, :network
 
       script_sig_asm = options[:script_sig_asm]
 
       unless @output.is_a? Output
-        @output = Output.new(@output)
+        @output = Output.new(@output, network: @network)
       end
 
       @native = Bitcoin::Protocol::TxIn.new

data/lib/coin-op/bit/multi_wallet.rb

@@ -1,27 +1,15 @@
-require "money-tree"
-require "bitcoin"
-
 module CoinOp::Bit
 
   class MultiWallet
     include CoinOp::Encodings
 
-    NetworkMap = {
-      :testnet3 => :bitcoin_testnet,
-      :bitcoin_testnet => :bitcoin_testnet,
-      :bitcoin => :bitcoin
-    }
-
-    def self.generate(names, network_name=:testnet3)
-      unless network = NetworkMap[network_name]
-        raise ArgumentError, "Unknown network #{network_name}"
-      end
+    def self.generate(names)
       masters = {}
       names.each do |name|
         name = name.to_sym
-        masters[name] = MoneyTree::Master.new(:network => network)
+        masters[name] = MoneyTree::Master.new
       end
-      self.new(:private => masters, :network => network)
+      self.new(private: masters)
     end
 
     attr_reader :trees
@@ -30,7 +18,6 @@ module CoinOp::Bit
       @private_trees = {}
       @public_trees = {}
       @trees = {}
-      @network = NetworkMap[options.include? :network ? options[:network] : :testnet3]
 
       # FIXME: we should allow this.
       # if !private_trees
@@ -57,7 +44,7 @@ module CoinOp::Bit
       when MoneyTree::Node
         arg
       when String
-        MoneyTree::Node.from_serialized_address(arg)
+        MoneyTree::Node.from_bip32(arg)
       else
         raise "Unusable type: #{node.class}"
       end
@@ -83,14 +70,14 @@ module CoinOp::Bit
       names.each do |name|
         name = name.to_sym
         tree = @private_trees.delete(name)
-        address = tree.to_serialized_address
-        @public_trees[name] = MoneyTree::Master.from_serialized_address(address)
+        serialized_priv = tree.to_bip32
+        @public_trees[name] = MoneyTree::Master.from_bip32(serialized_priv)
       end
     end
 
     def import(addresses)
       addresses.each do |name, address|
-        node = MoneyTree::Master.from_serialized_address(address)
+        node = MoneyTree::Master.from_bip32(address)
         if node.private_key
           @private_trees[name] = node
         else
@@ -99,35 +86,34 @@ module CoinOp::Bit
       end
     end
 
-    def private_seed(name)
+    def private_seed(name, network:)
       raise "No such node: '#{name}'" unless (node = @private_trees[name.to_sym])
-      node.to_serialized_address(:private)
+      node.to_bip32(:private, network: network)
     end
 
     alias_method :private_address, :private_seed
 
-    def public_seed(name)
+    def public_seed(name, network:)
       name = name.to_sym
       if node = (@public_trees[name] || @private_trees[name])
-        node.to_serialized_address
+        node.to_bip32(network: network)
       else
         raise "No such node: '#{name}'"
       end
     end
 
-
-    def private_seeds
+    def private_seeds(network:)
       out = {}
       @private_trees.each do |name, tree|
-        out[name] = self.private_address(name)
+        out[name] = self.private_address(name, network: network)
       end
       out
     end
 
-    def public_seeds
+    def public_seeds(network:)
       out = {}
       @private_trees.each do |name, node|
-        out[name] = node.to_serialized_address
+        out[name] = node.to_bip32(network: network)
       end
       out
     end
@@ -141,7 +127,6 @@ module CoinOp::Bit
         :path => path,
         :private => {},
         :public => {},
-        :network => @network
       }
       @private_trees.each do |name, node|
         options[:private][name] = node.node_for_path(path)
@@ -211,7 +196,10 @@ module CoinOp::Bit
       combined = {}
       sig_dicts.each do |sig_dict|
         sig_dict.each do |tree, signature|
-          combined[tree] = decode_base58(signature)
+          decoded_sig = decode_base58(signature)
+          low_s_der_sig = Bitcoin::Script.is_low_der_signature?(decoded_sig) ?
+            decoded_sig : Bitcoin::OpenSSL_EC.signature_to_low_s(decoded_sig)
+          combined[tree] = Bitcoin::OpenSSL_EC.repack_der_signature(low_s_der_sig)
         end
       end
 
@@ -226,6 +214,13 @@ module CoinOp::Bit
   class MultiNode
     include CoinOp::Encodings
 
+    CODE_TO_NETWORK = {
+      0 => :bitcoin,
+      1 => :testnet3,
+      2 => :litecoin,
+      3 => :dogecoin
+    }
+
     attr_reader :path, :private, :public, :keys, :public_keys
     def initialize(options)
       @path = options[:path]
@@ -234,7 +229,6 @@ module CoinOp::Bit
       @public_keys = {}
       @private = options[:private]
       @public = options[:public]
-      @network = options[:network]
 
       @private.each do |name, node|
         key = Bitcoin::Key.new(node.private_key.to_hex, node.public_key.to_hex)
@@ -246,10 +240,14 @@ module CoinOp::Bit
       end
     end
 
+    def network
+      CODE_TO_NETWORK.fetch(@path.split('/')[2].to_i)
+    end
+
     def script(m=2)
       # m of n
       keys = @public_keys.sort_by {|name, key| name }.map {|name, key| key.pub }
-      Script.new(:public_keys => keys, :needed => m, :network => @network)
+      Script.new(public_keys: keys, needed: m, network: network)
     end
 
     def address
@@ -259,21 +257,14 @@ module CoinOp::Bit
     alias_method :p2sh_address, :address
 
     def p2sh_script
-      Script.new(:address => self.script.p2sh_address, :network => @network)
-    end
-
-    def sign(name, value)
-      raise "No such key: '#{name}'" unless (key = @keys[name.to_sym])
-      # \x01 means the hash type is SIGHASH_ALL
-      # https://en.bitcoin.it/wiki/OP_CHECKSIG#Hashtype_SIGHASH_ALL_.28default.29
-      key.sign(value) + "\x01"
+      Script.new(:address => self.script.p2sh_address, network: network)
     end
 
     def signatures(value, names:)
       out = {}
       @keys.each do |name, key|
         next unless names.include?(name)
-        out[name] = base58(self.sign(name, value))
+        out[name] = base58(key.sign(value))
       end
       out
     end

data/lib/coin-op/bit/output.rb

@@ -20,7 +20,9 @@ module CoinOp::Bit
     #   or      :address (a valid Bitcoin address)
     # * :metadata (a Hash with arbitrary contents)
     #
-    def initialize(options)
+    def initialize(options, network: nil)
+      network_name = options[:network] || network
+      raise(ArgumentError, 'Network cannot be nil!') unless network_name
       if options[:transaction]
         @transaction = options[:transaction]
       elsif options[:transaction_hash]
@@ -36,9 +38,9 @@ module CoinOp::Bit
       @metadata[:confirmations] ||= confirmations
 
       if options[:script]
-        @script = Script.new(options[:script])
+        @script = Script.new(options[:script], network: network_name)
       elsif @address
-        @script = Script.new(:address => @address)
+        @script = Script.new(address: @address, network: network_name)
       end
 
 
@@ -95,3 +97,4 @@ module CoinOp::Bit
   end
 
 end
+

data/lib/coin-op/bit/script.rb

@@ -27,46 +27,42 @@ module CoinOp::Bit
     # The name of the crypto-currency network may also be specified.  It
     # defaults to :testnet3.  Names supplied in this manner must correspond
     # to the names in the ::Bitcoin::NETWORKS Hash.
-    def initialize(options)
-      # Doing the rescue in case the input argument is a String.
-      network_name = (options[:network] || :testnet3) rescue :testnet3
+    # TODO: PLEASE refactor this. should not accept either string or hash
+    def initialize(options, network: nil)
+      network_name = network || (options[:network] || :testnet3) rescue :testnet3
       @network = Bitcoin::NETWORKS[network_name]
-      Bitcoin.network = network_name
 
       # literals
-      if options.is_a? String
-        @blob = Bitcoin::Script.binary_from_string options
-      elsif string = options[:string]
-        @blob = Bitcoin::Script.binary_from_string string
-      elsif options[:blob]
-        @blob = options[:blob]
-      elsif options[:hex]
-        @blob = decode_hex(options[:hex])
-      # arguments for constructing
-      else
-        if address = options[:address]
-          unless Bitcoin::valid_address?(address)
-            raise ArgumentError, "Invalid address: #{address}"
-          end
-          @blob = Bitcoin::Script.to_address_script(address)
-        elsif public_key = options[:public_key]
-          @blob = Bitcoin::Script.to_pubkey_script(public_key)
-        elsif (keys = options[:public_keys]) && (needed = options[:needed])
-          @blob = Bitcoin::Script.to_multisig_script(needed, *keys)
-        elsif signatures = options[:signatures]
-          @blob = Bitcoin::Script.to_multisig_script_sig(*signatures)
+      CoinOp.syncbit(network_name) do 
+        if options.is_a? String
+          @blob = Bitcoin::Script.binary_from_string options
+        elsif string = options[:string]
+          @blob = Bitcoin::Script.binary_from_string string
+        elsif options[:blob]
+          @blob = options[:blob]
+        elsif options[:hex]
+          @blob = decode_hex(options[:hex])
+          # arguments for constructing
         else
-          raise ArgumentError
+          if address = options[:address]
+            unless Bitcoin::valid_address?(address)
+              raise ArgumentError, "Invalid address: #{address}"
+            end
+            @blob = Bitcoin::Script.to_address_script(address)
+          elsif public_key = options[:public_key]
+            @blob = Bitcoin::Script.to_pubkey_script(public_key)
+          elsif (keys = options[:public_keys]) && (needed = options[:needed])
+            @blob = Bitcoin::Script.to_multisig_script(needed, *keys)
+          elsif signatures = options[:signatures]
+            @blob = Bitcoin::Script.to_multisig_script_sig(*signatures)
+          else
+            raise ArgumentError
+          end
         end
+        @native = Bitcoin::Script.new @blob
+        @hex = hex(@blob)
+        @string = @native.to_string
       end
-
-      @hex = hex(@blob)
-      @native = Bitcoin::Script.new @blob
-      @string = @native.to_string
-    end
-
-    def address
-      @native.get_p2sh_address
     end
 
     def to_s
@@ -109,7 +105,9 @@ module CoinOp::Bit
     end
 
     def hash160
-      Bitcoin.hash160(@hex)
+      CoinOp.syncbit(@network[:name]) do
+        @native.get_hash160 || Bitcoin.hash160(@hex)
+      end
     end
 
     # Generate the script that uses a P2SH address.
@@ -117,19 +115,25 @@ module CoinOp::Bit
     # can probably be removed, as I think it is equivalent to
     # Script.new :address => some_p2sh_address
     def p2sh_script
-      self.class.new Bitcoin::Script.to_p2sh_script(self.hash160)
+      CoinOp.syncbit(@network[:name]) do |b|
+        self.class.new Bitcoin::Script.to_p2sh_script(self.hash160)
+      end
     end
 
     def p2sh_address
-      Bitcoin.hash160_to_p2sh_address(self.hash160)
+      Bitcoin.encode_address(self.hash160, Bitcoin::NETWORKS[@network[:name]][:p2sh_version])
     end
 
+    alias_method :address, :p2sh_address
+
     # Generate a P2SH script_sig for the current script, using the
     # supplied options, which will, in the case of a multisig input,
     # be {:signatures => array_of_signatures}.
     def p2sh_sig(options)
       string = Script.new(options).to_s
-      Bitcoin::Script.binary_from_string("#{string} #{self.to_hex}")
+      CoinOp.syncbit(@network[:name]) do
+        Bitcoin::Script.binary_from_string("#{string} #{self.to_hex}")
+      end
     end
 
   end

data/lib/coin-op/bit/transaction.rb

@@ -12,26 +12,27 @@ module CoinOp::Bit
 
     # Construct a Transaction from a data structure of nested Hashes
     # and Arrays.
-    def self.data(data)
+    def self.data(data, network:)
       version, lock_time, fee, inputs, outputs, confirmations =
         data.values_at :version, :lock_time, :fee, :inputs, :outputs, :confirmations
 
       transaction = self.new(
         :fee => fee,
         :version => version, :lock_time => lock_time,
-        :confirmations => confirmations
+        :confirmations => confirmations,
+        network: network
       )
 
-      outputs.each do |data|
-        transaction.add_output Output.new(data)
+      outputs.each do |output_hash|
+        transaction.add_output(Output.new(output_hash, network: network))
       end
 
       #FIXME: we're not handling sig_scripts for already signed inputs.
 
       if inputs
         # TODO: use #each instead of #each_with_index
-        inputs.each_with_index do |data, index|
-          transaction.add_input(data)
+        inputs.each_with_index do |input_hash, index|
+          transaction.add_input(input_hash, network: network)
 
           ## FIXME: verify that the supplied and computed sig_hashes match
           #puts :sig_hashes_match => (data[:sig_hash] == input.sig_hash)
@@ -101,6 +102,7 @@ module CoinOp::Bit
       @native = Bitcoin::Protocol::Tx.new
       @inputs = []
       @outputs = []
+      @network = options[:network]
       @fee_override = options[:fee]
       @confirmations = options[:confirmations]
     end
@@ -141,7 +143,6 @@ module CoinOp::Bit
       valid = true
       @inputs.each_with_index do |input, index|
         # TODO: confirm whether we need to mess with the block_timestamp arg
-
         unless self.native.verify_input_signature(index, input.output.transaction.native)
           valid = false
           bad_inputs << index
@@ -157,14 +158,15 @@ module CoinOp::Bit
     # * an instance of Output
     # * a Hash describing an Output
     #
-    def add_input(input)
+    def add_input(input, network:)
       # TODO: allow specifying prev_tx and index with a Hash.
       # Possibly stop using SparseInput.
 
       unless input.is_a?(Input)
         input = Input.new input.merge(
-          :transaction => self,
-          :index => @inputs.size,
+          transaction: self,
+          index: @inputs.size,
+          network: network
         )
       end
 
@@ -178,7 +180,7 @@ module CoinOp::Bit
     # Takes either an Output or a Hash describing an output.
     def add_output(output)
       unless output.is_a? Output
-        output = Output.new(output)
+        output = Output.new(output, network: @network)
       end
 
       index = @outputs.size
@@ -222,12 +224,13 @@ module CoinOp::Bit
     # Typically used only by #to_json.
     def to_hash
       {
+        :confirmations => self.confirmations.nil? ? 0 : self.confirmations,
         :version => self.version,
         :lock_time => self.lock_time,
         :hash => self.hex_hash,
         :fee => self.fee,
         :inputs => self.inputs,
-        :outputs => self.outputs,
+        :outputs => self.outputs
       }
     end
 
@@ -235,10 +238,14 @@ module CoinOp::Bit
       self.to_hash.to_json(*a)
     end
 
-    # Compute the digest for a given input.  In most cases, you need to provide
-    # the script.  Which script to supply can be confusing, especially in the
-    # case of P2SH outputs.
-    # TODO: explain the above more clearly.
+    # Compute the digest for a given input.  This is the value that is actually
+    # signed in a transaction.
+    # e.g. I want to spend UTXO0 - I provide the UTXO0 as an input.
+    #      I provide as a script the script to which UTXO0 was paid.
+    # If UTX0 was paid to a P2SH address, the script here needs to be the correct
+    # m-of-n structure, which may well not be part of the input.output object
+    # - This works here because we default to 2-of-3 and have consistent ordering
+    # When we support multiple m-of-n's, this may become a prollem.
     def sig_hash(input, script=nil)
       # We only allow SIGHASH_ALL at this time
       # https://en.bitcoin.it/wiki/OP_CHECKSIG#Hashtype_SIGHASH_ALL_.28default.29
@@ -286,7 +293,7 @@ module CoinOp::Bit
     end
 
     def fee_override
-      @fee_override || self.estimate_fee
+      @fee_override || self.estimate_fee(network: @network)
     end
 
     # Estimate the fee in satoshis for this transaction.  Takes an optional
@@ -363,3 +370,4 @@ module CoinOp::Bit
   end
 
 end
+

data/lib/coin-op/crypto.rb

@@ -1,5 +1,5 @@
 # Ruby bindings for libsodium, a port of DJB's NaCl crypto library
-require "rbnacl/libsodium"
+require "rbnacl"
 require "openssl"
 
 module CoinOp

data/lib/coin-op/version.rb

@@ -1,3 +1,3 @@
 module CoinOp
-  VERSION = "0.3.0"
-end
+  VERSION = "0.4.0"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coin-op
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Matthew King
@@ -32,7 +32,7 @@ cert_chain:
   tdc4VS7IlSRxlZ3dBOgiigy9GXpJ+7F831AqjxL39EPwdr7RguTNz+pi//RKaT/U
   IlpVB+Xfk0vQdP7iYfjGxDzUf0FACMjsR95waJmadKW1Iy6STw2hwPhYIQz1Hu1A
   -----END CERTIFICATE-----
-date: 2015-05-04 00:00:00.000000000 Z
+date: 2015-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bitcoin-ruby