monacoin-ruby 0.1.2 → 0.1.3

data/lib/bitcoin/connection.rb

@@ -0,0 +1,130 @@
+# encoding: ascii-8bit
+
+require 'socket'
+require 'eventmachine'
+require 'bitcoin'
+require 'resolv'
+
+module Bitcoin
+
+  module ConnectionHandler
+    def on_inv_transaction(hash)
+      p ['inv transaction', hash.hth]
+      pkt = Protocol.getdata_pkt(:tx, [hash])
+      send_data(pkt)
+    end
+
+    def on_inv_block(hash)
+      p ['inv block', hash.hth]
+      pkt = Protocol.getdata_pkt(:block, [hash])
+      send_data(pkt)
+    end
+
+    def on_get_transaction(hash)
+      p ['get transaction', hash.hth]
+    end
+
+    def on_get_block(hash)
+      p ['get block', hash.hth]
+    end
+
+    def on_addr(addr)
+      p ['addr', addr, addr.alive?]
+    end
+
+    def on_tx(tx)
+      p ['tx', tx.hash]
+    end
+
+    def on_block(block)
+      p ['block', block.hash]
+      #p block.payload.each_byte.map{|i| "%02x" % [i] }.join(" ")
+      #puts block.to_json
+    end
+
+    def on_version(version)
+      p [@sockaddr, 'version', version, version.time - Time.now.to_i]
+      send_data( Protocol.verack_pkt )
+    end
+
+    def on_verack
+      on_handshake_complete
+    end
+
+    def on_handshake_complete
+      p [@sockaddr, 'handshake complete']
+      @connected = true
+
+      query_blocks
+    end
+
+    def query_blocks
+      start = ("\x00"*32)
+      stop  = ("\x00"*32)
+      pkt = Protocol.pkt("getblocks", "\x00" + start + stop )
+      send_data(pkt)
+    end
+
+    def on_handshake_begin
+      block   = 127953
+      from    = "127.0.0.1:8333"
+      from_id = Bitcoin::Protocol::Uniq
+      to      = @sockaddr.reverse.join(":")
+      # p "==", from_id, from, to, block
+      pkt = Protocol.version_pkt(from_id, from, to, block)
+      p ['sending version pkt', pkt]
+      send_data(pkt)
+    end
+  end
+
+
+  class Connection < EM::Connection
+    include ConnectionHandler
+
+    def initialize(host, port, connections)
+      @sockaddr = [port, host]
+      @connections = connections
+      @parser = Bitcoin::Protocol::Parser.new( self )
+    end
+
+    def post_init
+      p ['connected', @sockaddr]
+      EM.schedule{ on_handshake_begin }
+    end
+
+    def receive_data(data)
+      @parser.parse(data)
+    end
+
+    def unbind
+      p ['disconnected', @sockaddr]
+      self.class.connect_random_from_dns(@connections)
+    end
+
+    def self.connect(host, port, connections)
+      EM.connect(host, port, self, host, port, connections)
+    end
+
+    def self.connect_random_from_dns(connections)
+      seeds = Bitcoin.network[:dns_seeds]
+      if seeds.any?
+        host = Resolv::DNS.new.getaddresses(seeds.sample).map {|a| a.to_s}.sample
+        connect(host, Bitcoin::network[:default_port], connections)
+      else
+        raise "No DNS seeds available. Provide IP, configure seeds, or use different network."
+      end
+    end
+  end
+end
+
+
+if $0 == __FILE__
+  EM.run do
+
+    connections = []
+    #Bitcoin::Connection.connect('127.0.0.1', 8333, connections)
+    #Bitcoin::Connection.connect('217.157.1.202', 8333, connections)
+    Bitcoin::Connection.connect_random_from_dns(connections)
+
+  end
+end

data/lib/bitcoin/contracthash.rb

@@ -0,0 +1,76 @@
+#
+# Ruby port of https://github.com/Blockstream/contracthashtool
+#
+
+module Bitcoin
+  module ContractHash
+
+    HMAC_DIGEST = OpenSSL::Digest.new("SHA256")
+    EC_GROUP = OpenSSL::PKey::EC::Group.new("secp256k1")
+
+    def self.hmac(pubkey, data)
+      OpenSSL::HMAC.hexdigest(HMAC_DIGEST, pubkey, data)
+    end
+
+    # generate a contract address
+    def self.generate(redeem_script_hex, payee_address_or_ascii, nonce_hex=nil)
+      redeem_script = Bitcoin::Script.new([redeem_script_hex].pack("H*"))
+      raise "only multisig redeem scripts are currently supported" unless redeem_script.is_multisig?
+      nonce_hex, data = compute_data(payee_address_or_ascii, nonce_hex)
+
+      derived_keys = []
+      redeem_script.get_multisig_pubkeys.each do |pubkey|
+        tweak = hmac(pubkey, data).to_i(16)
+        raise "order exceeded, pick a new nonce" if tweak >= EC_GROUP.order.to_i
+        tweak = OpenSSL::BN.new(tweak.to_s)
+
+        key = Bitcoin::Key.new(nil, pubkey.unpack("H*")[0])
+        key = key.instance_variable_get(:@key)
+        point = EC_GROUP.generator.mul(tweak).ec_add(key.public_key).to_bn.to_i
+        raise "infinity" if point == 1/0.0
+
+        key = Bitcoin::Key.new(nil, point.to_s(16))
+        key.instance_eval{ @pubkey_compressed = true }
+        derived_keys << key.pub
+      end
+
+      m = redeem_script.get_signatures_required
+      p2sh_script, redeem_script = Bitcoin::Script.to_p2sh_multisig_script(m, *derived_keys)
+
+      [ nonce_hex, redeem_script.unpack("H*")[0], Bitcoin::Script.new(p2sh_script).get_p2sh_address ]
+    end
+
+    # claim a contract
+    def self.claim(private_key_wif, payee_address_or_ascii, nonce_hex)
+      key = Bitcoin::Key.from_base58(private_key_wif)
+      data = compute_data(payee_address_or_ascii, nonce_hex)[1]
+
+      pubkey = [key.pub].pack("H*")
+      tweak = hmac(pubkey, data).to_i(16)
+      raise "order exceeded, verify parameters" if tweak >= EC_GROUP.order.to_i
+
+      derived_key = (tweak + key.priv.to_i(16)) % EC_GROUP.order.to_i
+      raise "zero" if derived_key == 0
+
+      Bitcoin::Key.new(derived_key.to_s(16))
+    end
+
+    # compute HMAC data
+    def self.compute_data(address_or_ascii, nonce_hex)
+      nonce = nonce_hex ? [nonce_hex].pack("H32") : SecureRandom.random_bytes(16)
+      if Bitcoin.valid_address?(address_or_ascii)
+        address_type = case Bitcoin.address_type(address_or_ascii)
+                       when :hash160;  'P2PH'
+                       when :p2sh;     'P2SH'
+                       else
+                         raise "unsupported address type #{address_type}"
+                       end
+        contract_bytes = [ Bitcoin.hash160_from_address(address_or_ascii) ].pack("H*")
+      else
+        address_type = "TEXT"
+        contract_bytes = address_or_ascii
+      end
+      [ nonce.unpack("H*")[0], address_type + nonce + contract_bytes ]
+    end
+  end
+end

data/lib/bitcoin/dogecoin.rb

@@ -0,0 +1,97 @@
+# encoding: ascii-8bit
+
+# This module includes (almost) everything necessary to add dogecoin support
+# to bitcoin-ruby. When switching to a :dogecoin network, it will load its
+# functionality into the Script class.
+# The only things not included here should be parsing the AuxPow, which is
+# done in Protocol::Block directly, and passing the txout to #store_doge from
+# the storage backend.
+module Bitcoin::Dogecoin
+
+  def self.load
+    Bitcoin::Util.class_eval { include Util }
+  end
+
+  # fixed reward past the 600k block
+  POST_600K_REWARD = 10000 * Bitcoin::COIN
+
+  # Dogecoin-specific Script methods for parsing and creating of dogecoin scripts,
+  # as well as methods to extract address, doge_hash, doge and value.
+  module Util
+
+    def self.included(base)
+      base.constants.each {|c| const_set(c, base.const_get(c)) unless constants.include?(c) }
+      base.class_eval do
+
+        def block_creation_reward(block_height)
+          if block_height < Bitcoin.network[:difficulty_change_block]
+            # Dogecoin early rewards were random, using part of the hash of the
+            # previous block as the seed for the Mersenne Twister algorithm.
+            # Given we don't have previous block hash available, and this value is
+            # functionally a maximum (not exact value), I'm using the maximum the random
+            # reward generator can produce and calling it good enough.
+            Bitcoin.network[:reward_base] / (2 ** (block_height / Bitcoin.network[:reward_halving].to_f).floor) * 2
+          elsif block_height < 600000
+            Bitcoin.network[:reward_base] / (2 ** (block_height / Bitcoin.network[:reward_halving].to_f).floor)
+          else
+            POST_600K_REWARD
+          end
+        end
+        
+        def block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
+          new_difficulty_protocol = (prev_height + 1) >= Bitcoin.network[:difficulty_change_block]
+
+          # target interval for block interval in seconds
+          retarget_time = Bitcoin.network[:retarget_time]
+
+          if new_difficulty_protocol
+            # what is the ideal interval between the blocks
+            retarget_time = Bitcoin.network[:retarget_time_new]
+          end
+
+          # actual time elapsed since last retarget
+          actual_time = prev_block_time - last_retarget_time
+
+          if new_difficulty_protocol
+            # DigiShield implementation - thanks to RealSolid & WDC for this code
+            # We round always towards zero to match the C++ version
+            if actual_time < retarget_time
+              actual_time = retarget_time + ((actual_time - retarget_time) / 8.0).ceil
+            else
+              actual_time = retarget_time + ((actual_time - retarget_time) / 8.0).floor
+            end
+            # amplitude filter - thanks to daft27 for this code
+            min = retarget_time - (retarget_time/4)
+            max = retarget_time + (retarget_time/2)
+          elsif prev_height+1 > 10000
+            min = retarget_time / 4
+            max = retarget_time * 4
+          elsif prev_height+1 > 5000
+            min = retarget_time / 8
+            max = retarget_time * 4
+          else
+            min = retarget_time / 16
+            max = retarget_time * 4
+          end
+
+          actual_time = min if actual_time < min
+          actual_time = max if actual_time > max
+
+          # It could be a bit confusing: we are adjusting difficulty of the previous block, while logically
+          # we should use difficulty of the previous 2016th block ("first")
+
+          prev_target = decode_compact_bits(prev_block_bits).to_i(16)
+
+          new_target = prev_target * actual_time / retarget_time
+          if new_target < Bitcoin.decode_compact_bits(Bitcoin.network[:proof_of_work_limit]).to_i(16)
+            encode_compact_bits(new_target.to_s(16))
+          else
+            Bitcoin.network[:proof_of_work_limit]
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/bitcoin/electrum/mnemonic.rb

@@ -0,0 +1,162 @@
+# encoding: ascii-8bit
+
+class Mnemonic
+  # ruby version of: https://github.com/spesmilo/electrum/blob/master/lib/mnemonic.py
+
+  # list of words from http://en.wiktionary.org/wiki/Wiktionary:Frequency_lists/Contemporary_poetry
+  Words = (<<-TEXT).split
+    like just love know never want time out there make look eye down only think
+    heart back then into about more away still them take thing even through long always
+    world too friend tell try hand thought over here other need smile again much cry
+    been night ever little said end some those around mind people girl leave dream left
+    turn myself give nothing really off before something find walk wish good once place ask
+    stop keep watch seem everything wait got yet made remember start alone run hope maybe
+    believe body hate after close talk stand own each hurt help home god soul new
+    many two inside should true first fear mean better play another gone change use wonder
+    someone hair cold open best any behind happen water dark laugh stay forever name work
+    show sky break came deep door put black together upon happy such great white matter
+    fill past please burn cause enough touch moment soon voice scream anything stare sound red
+    everyone hide kiss truth death beautiful mine blood broken very pass next forget tree wrong
+    air mother understand lip hit wall memory sleep free high realize school might skin sweet
+    perfect blue kill breath dance against fly between grow strong under listen bring sometimes speak
+    pull person become family begin ground real small father sure feet rest young finally land
+    across today different guy line fire reason reach second slowly write eat smell mouth step
+    learn three floor promise breathe darkness push earth guess save song above along both color
+    house almost sorry anymore brother okay dear game fade already apart warm beauty heard notice
+    question shine began piece whole shadow secret street within finger point morning whisper child moon
+    green story glass kid silence since soft yourself empty shall angel answer baby bright dad
+    path worry hour drop follow power war half flow heaven act chance fact least tired
+    children near quite afraid rise sea taste window cover nice trust lot sad cool force
+    peace return blind easy ready roll rose drive held music beneath hang mom paint emotion
+    quiet clear cloud few pretty bird outside paper picture front rock simple anyone meant reality
+    road sense waste bit leaf thank happiness meet men smoke truly decide self age book
+    form alive carry escape damn instead able ice minute throw catch leg ring course goodbye
+    lead poem sick corner desire known problem remind shoulder suppose toward wave drink jump woman
+    pretend sister week human joy crack grey pray surprise dry knee less search bleed caught
+    clean embrace future king son sorrow chest hug remain sat worth blow daddy final parent
+    tight also create lonely safe cross dress evil silent bone fate perhaps anger class scar
+    snow tiny tonight continue control dog edge mirror month suddenly comfort given loud quickly gaze
+    plan rush stone town battle ignore spirit stood stupid yours brown build dust hey kept
+    pay phone twist although ball beyond hidden nose taken fail float pure somehow wash wrap
+    angry cheek creature forgotten heat rip single space special weak whatever yell anyway blame job
+    choose country curse drift echo figure grew laughter neck suffer worse yeah disappear foot forward
+    knife mess somewhere stomach storm beg idea lift offer breeze field five often simply stuck
+    win allow confuse enjoy except flower seek strength calm grin gun heavy hill large ocean
+    shoe sigh straight summer tongue accept crazy everyday exist grass mistake sent shut surround table
+    ache brain destroy heal nature shout sign stain choice doubt glance glow mountain queen stranger
+    throat tomorrow city either fish flame rather shape spin spread ash distance finish image imagine
+    important nobody shatter warmth became feed flesh funny lust shirt trouble yellow attention bare bite
+    money protect amaze appear born choke completely daughter fresh friendship gentle probably six deserve expect
+    grab middle nightmare river thousand weight worst wound barely bottle cream regret relationship stick test
+    crush endless fault itself rule spill art circle join kick mask master passion quick raise
+    smooth unless wander actually broke chair deal favorite gift note number sweat box chill clothes
+    lady mark park poor sadness tie animal belong brush consume dawn forest innocent pen pride
+    stream thick clay complete count draw faith press silver struggle surface taught teach wet bless
+    chase climb enter letter melt metal movie stretch swing vision wife beside crash forgot guide
+    haunt joke knock plant pour prove reveal steal stuff trip wood wrist bother bottom crawl
+    crowd fix forgive frown grace loose lucky party release surely survive teacher gently grip speed
+    suicide travel treat vein written cage chain conversation date enemy however interest million page pink
+    proud sway themselves winter church cruel cup demon experience freedom pair pop purpose respect shoot
+    softly state strange bar birth curl dirt excuse lord lovely monster order pack pants pool
+    scene seven shame slide ugly among blade blonde closet creek deny drug eternity gain grade
+    handle key linger pale prepare swallow swim tremble wheel won cast cigarette claim college direction
+    dirty gather ghost hundred loss lung orange present swear swirl twice wild bitter blanket doctor
+    everywhere flash grown knowledge numb pressure radio repeat ruin spend unknown buy clock devil early
+    false fantasy pound precious refuse sheet teeth welcome add ahead block bury caress content depth
+    despite distant marry purple threw whenever bomb dull easily grasp hospital innocence normal receive reply
+    rhyme shade someday sword toe visit asleep bought center consider flat hero history ink insane
+    muscle mystery pocket reflection shove silently smart soldier spot stress train type view whether bus
+    energy explain holy hunger inch magic mix noise nowhere prayer presence shock snap spider study
+    thunder trail admit agree bag bang bound butterfly cute exactly explode familiar fold further pierce
+    reflect scent selfish sharp sink spring stumble universe weep women wonderful action ancient attempt avoid
+    birthday branch chocolate core depress drunk especially focus fruit honest match palm perfectly pillow pity
+    poison roar shift slightly thump truck tune twenty unable wipe wrote coat constant dinner drove
+    egg eternal flight flood frame freak gasp glad hollow motion peer plastic root screen season
+    sting strike team unlike victim volume warn weird attack await awake built charm crave despair
+    fought grant grief horse limit message ripple sanity scatter serve split string trick annoy blur
+    boat brave clearly cling connect fist forth imagination iron jock judge lesson milk misery nail
+    naked ourselves poet possible princess sail size snake society stroke torture toss trace wise bloom
+    bullet cell check cost darling during footstep fragile hallway hardly horizon invisible journey midnight mud
+    nod pause relax shiver sudden value youth abuse admire blink breast bruise constantly couple creep
+    curve difference dumb emptiness gotta honor plain planet recall rub ship slam soar somebody tightly
+    weather adore approach bond bread burst candle coffee cousin crime desert flutter frozen grand heel
+    hello language level movement pleasure powerful random rhythm settle silly slap sort spoken steel threaten
+    tumble upset aside awkward bee blank board button card carefully complain crap deeply discover drag
+    dread effort entire fairy giant gotten greet illusion jeans leap liquid march mend nervous nine
+    replace rope spine stole terror accident apple balance boom childhood collect demand depression eventually faint
+    glare goal group honey kitchen laid limb machine mere mold murder nerve painful poetry prince
+    rabbit shelter shore shower soothe stair steady sunlight tangle tease treasure uncle begun bliss canvas
+    cheer claw clutch commit crimson crystal delight doll existence express fog football gay goose guard
+    hatred illuminate mass math mourn rich rough skip stir student style support thorn tough yard
+    yearn yesterday advice appreciate autumn bank beam bowl capture carve collapse confusion creation dove feather
+    girlfriend glory government harsh hop inner loser moonlight neighbor neither peach pig praise screw shield
+    shimmer sneak stab subject throughout thrown tower twirl wow army arrive bathroom bump cease cookie
+    couch courage dim guilt howl hum husband insult led lunch mock mostly natural nearly needle
+    nerd peaceful perfection pile price remove roam sanctuary serious shiny shook sob stolen tap vain
+    void warrior wrinkle affection apologize blossom bounce bridge cheap crumble decision descend desperately dig dot
+    flip frighten heartbeat huge lazy lick odd opinion process puzzle quietly retreat score sentence separate
+    situation skill soak square stray taint task tide underneath veil whistle anywhere bedroom bid bloody
+    burden careful compare concern curtain decay defeat describe double dreamer driver dwell evening flare flicker
+    grandma guitar harm horrible hungry indeed lace melody monkey nation object obviously rainbow salt scratch
+    shown shy stage stun third tickle useless weakness worship worthless afternoon beard boyfriend bubble busy
+    certain chin concrete desk diamond doom drawn due felicity freeze frost garden glide harmony hopefully
+    hunt jealous lightning mama mercy peel physical position pulse punch quit rant respond salty sane
+    satisfy savior sheep slept social sport tuck utter valley wolf aim alas alter arrow awaken
+    beaten belief brand ceiling cheese clue confidence connection daily disguise eager erase essence everytime expression
+    fan flag flirt foul fur giggle glorious ignorance law lifeless measure mighty muse north opposite
+    paradise patience patient pencil petal plate ponder possibly practice slice spell stock strife strip suffocate
+    suit tender tool trade velvet verse waist witch aunt bench bold cap certainly click companion
+    creator dart delicate determine dish dragon drama drum dude everybody feast forehead former fright fully
+    gas hook hurl invite juice manage moral possess raw rebel royal scale scary several slight
+    stubborn swell talent tea terrible thread torment trickle usually vast violence weave acid agony ashamed
+    awe belly blend blush character cheat common company coward creak danger deadly defense define depend
+    desperate destination dew duck dusty embarrass engine example explore foe freely frustrate generation glove guilty
+    health hurry idiot impossible inhale jaw kingdom mention mist moan mumble mutter observe ode pathetic
+    pattern pie prefer puff rape rare revenge rude scrape spiral squeeze strain sunset suspend sympathy
+    thigh throne total unseen weapon weary
+  TEXT
+
+  def self.encode(hex, words=Words)
+    n = words.size
+    [hex].pack("H*").unpack("N*").map{|x|
+      w1 = x % n
+      w2 = ((x / n) + w1) % n
+      w3 = ((x / n / n) + w2) % n
+      [ words[w1], words[w2], words[w3] ]
+    }.flatten
+  end
+
+  def self.decode(word_list, words=Words)
+    n = words.size
+    word_list.each_slice(3).map{|three_words|
+      w1, w2, w3 = three_words.map{|word| words.index(word) % n }
+      '%08x' % ( w1 + n*((w2-w1)%n) + n*n*((w3-w2)%n) )
+    }.join
+  end
+
+end
+
+
+
+if $0 == __FILE__
+  hex = "4c7d10656aa55383a5d88e3f63300af5e169918f4058bf349d99b20239909b61"
+  expected_words = ['horse', 'love', 'nose', 'speak', 'diamond', 'gaze', 'wash', 'drag', 'glance',
+                    'money', 'cease', 'soft', 'complete', 'huge', 'aside', 'confusion', 'touch',
+                    'grass', 'pie', 'play', 'bread', 'exactly', 'bubble', 'great']
+
+  # from http://brainwallet.org/#chains
+  hex = "ff64b72c431f75799f0c5ebe438e46dd"
+  expected_words = %w[muscle lot sea got revenge crack wait yeah gas study embrace spend]
+  hex = "18cfaf96961750c7a4e4e39c861d1415"
+  expected_words = %w[example poor twice expect decision master blame rub forward easy jump carve]
+
+  # from  https://en.bitcoin.it/wiki/Electrum#Brain_Wallet
+  hex = "431a62f1c86555d3c45e5c4d9e10c8c7"
+  expected_words = %w[constant forest adore false green weave stop guy fur freeze giggle clock]
+
+  #p Mnemonic.encode(hex)
+  p Mnemonic.encode(hex) == expected_words
+  #p Mnemonic.decode(expected_words)
+  p Mnemonic.decode(expected_words) == hex
+end
+