btcruby 1.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64ee5200a38763d90afb6404bd5b5a5f527f144e
-  data.tar.gz: ebcc849873a50338a4d226bdd111bd6988928689
+  metadata.gz: b2ed39f95cdd06b5950c9164180c4086592519ef
+  data.tar.gz: 826463f6e12c74f02e122f696251d9c212cf9077
 SHA512:
-  metadata.gz: 04c8322fc7e1ef83c2f8b4a03d54ec0741776955e95fe92210abcdc80c81fbf999899713d15389fd0875ec5983f770c4e30dcd5372ecbbeafebd5668b2ad8f50
-  data.tar.gz: 730d0a4c98735df953eaa01835055df65a1b24296bb17d06848ecbfd3aad2d3baa7b54f4379fcc47d7ec669fe6a896525eec1794e7d0e3d9610603c9613c2fb4
+  metadata.gz: 26f331d4b44fc40c0e211693baca89866176b101600b6dd70860eef7a05bf4db2047c54f7e2a676cb4154683da2d17764b9bfd1c652de805af259f5ab33e9623
+  data.tar.gz: 96817a00e44da817f3a83d91890c24b6ebde7d5079499e1e759303a99df4002067439761b12f34203f76b26d1afc361d3cb2ff873abde04937fa7ff4a7706858

data/README.md

@@ -62,7 +62,7 @@ $ rake
 ```
 $ git push origin --tags
 $ gem build btcruby.gemspec
-$ gem push btcruby-<version>.gem
+$ gem push btcruby-VER.gem
 ```
 
 ## Authors

data/RELEASE_NOTES.md

@@ -2,6 +2,12 @@
 BTCRuby Release Notes
 =====================
 
+1.1.1 (July 30, 2015)
+---------------------
+
+* Added work computation from bigint and 256-bit hash.
+
+
 1.1 (July 29, 2015)
 --------------------
 

data/lib/btcruby/proof_of_work.rb

@@ -49,6 +49,7 @@ module BTC
     end
 
     # Converts 32-bit compact representation to a 256-bit integer.
+    # int32 -> bigint
     def target_from_bits(bits)
       exponent = ((bits >> 24) & 0xff)
       mantissa = bits & 0x7fffff
@@ -59,31 +60,36 @@ module BTC
     # Computes bits from difficulty.
     # Could be inaccurate since difficulty is a limited-precision floating-point number.
     # Default max_target is for Bitcoin mainnet.
+    # float -> int32
     def bits_from_difficulty(difficulty, max_target: MAX_TARGET_MAINNET)
       bits_from_target(target_from_difficulty(difficulty, max_target: max_target))
     end
 
-    # Computes difficulty from bits. 
+    # Computes difficulty from bits.
     # Default max_target is for Bitcoin mainnet.
+    # int32 -> float
     def difficulty_from_bits(bits, max_target: MAX_TARGET_MAINNET)
       difficulty_from_target(target_from_bits(bits), max_target: max_target)
     end
 
-    # Computes target from difficulty. 
+    # Computes target from difficulty.
     # Could be inaccurate since difficulty is a limited-precision floating-point number.
     # Default max_target is for Bitcoin mainnet.
+    # float -> bigint
     def target_from_difficulty(difficulty, max_target: MAX_TARGET_MAINNET)
       (max_target / difficulty).round.to_i
     end
-    
-    # Compute relative difficulty from a given target. 
+
+    # Compute relative difficulty from a given target.
     # E.g. returns 2.5 if target is 2.5 times harder to reach than the max_target.
     # Default max_target is for Bitcoin mainnet.
+    # bigint -> float
     def difficulty_from_target(target, max_target: MAX_TARGET_MAINNET)
       (max_target / target.to_f)
     end
 
     # Converts target integer to a binary 32-byte hash.
+    # bigint -> hash256
     def hash_from_target(target)
       bytes = []
       while target > 0
@@ -93,7 +99,8 @@ module BTC
       BTC::Data.data_from_bytes(bytes).ljust(32, "\x00".b)
     end
 
-    # Converts 32-byte hash to target integer (hash is treated as little-endian integer)
+    # Converts 32-byte hash to target big integer (hash is treated as little-endian integer)
+    # hash256 -> bigint
     def target_from_hash(hash)
       target = 0
       i = 0
@@ -106,5 +113,22 @@ module BTC
 
     # TODO: add retargeting calculation routines
 
+    # Compute amount of work expressed as a target
+    # Based on `arith_uint256 GetBlockProof(const CBlockIndex& block)` from Bitcoin Core
+    # bigint -> bigint
+    def work_from_target(target)
+      # We need to compute 2**256 / (target+1), but we can't represent 2**256
+      # as it's too large for a arith_uint256. However, as 2**256 is at least as large
+      # as target+1, it is equal to ((2**256 - target - 1) / (target+1)) + 1,
+      # or ~target / (target+1) + 1.
+      # In Ruby bigint is signed, so we can't use '~', but we can use 2**256
+      return ((2**256 - target - 1) / (target + 1)) + 1
+    end
+
+    # hash256 -> bigint
+    def work_from_hash(hash)
+      work_from_target(target_from_hash(hash))
+    end
+
   end # ProofOfWork
 end # BTC

data/lib/btcruby/version.rb

@@ -1,3 +1,3 @@
 module BTC
-  VERSION = "1.1".freeze
+  VERSION = "1.1.1".freeze
 end

data/spec/proof_of_work_spec.rb

@@ -45,9 +45,22 @@ describe BTC::ProofOfWork do
     POW.difficulty_from_target(0x0000000007fff800000000000000000000000000000000000000000000000000,
                                                 max_target: POW::MAX_TARGET_TESTNET).to_i.must_equal 256
   end
-  
+
   it "should convert difficulty to target or bits" do
     POW.target_from_difficulty(1.0).must_equal 0x00000000ffff0000000000000000000000000000000000000000000000000000
     POW.bits_from_difficulty(39603666252.41841).must_equal 0x181bc330
   end
+
+  it "should convert hash to work" do
+    POW.work_from_target(0).must_equal 2**256
+    POW.work_from_target(1).must_equal 2**255
+    POW.work_from_target(2**255).must_equal 1
+    POW.work_from_target(2**256).must_equal 0
+
+    POW.work_from_hash("\x00".b*32).must_equal 2**256
+    POW.work_from_hash("\x01".b + "\x00".b*31).must_equal 2**255
+    POW.work_from_hash("8000000000000000000000000000000000000000000000000000000000000000".from_hex.reverse).must_equal 1
+    POW.work_from_hash("\xff".b*32).must_equal 1
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: btcruby
 version: !ruby/object:Gem::Version
-  version: '1.1'
+  version: 1.1.1
 platform: ruby
 authors:
 - Oleg Andreev
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-29 00:00:00.000000000 Z
+date: 2015-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi