crypto-lite 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d361cfd5f45ee36170d5efa9e63194a453dc8401334f8eb9db47d15344c74a9b
-  data.tar.gz: 40de7d4721e87e02b8157b0668814a91a75ef3ebd4d5d202e2b0d4085fd52e59
+  metadata.gz: cb39c213dfc1d3d5f0625fceed1aa57ba57094838d6b4fa792388aa914764ec5
+  data.tar.gz: 9222110e4d2a56e99704ae234213438251cc6259d446ea974bb3dcc6f7195669
 SHA512:
-  metadata.gz: f6543504e262d4ea380e529abd15e6789d1cb19988dec206028ad2f715b4ad556838e00c01dd865378a59dc3da2a602371a00a4e7d32db93d374233525be836a
-  data.tar.gz: f541ff370e6a134d5f84a65cc5381d75d8016f9e0ac16d927695507726809d71532acd4ae0b799ab57febf8ee288ac2fdcecf63b3ee7bb9ac17a0e350ac0c8c5
+  metadata.gz: f644ce38c52fb2b6bb670616619548752a261147515461558dda726309fed4bba5f1e6f1bdb21eaa9923c8cecfd4bd92dd8d30717487f1dc994d48183848867d
+  data.tar.gz: 594fb0787715b39c9995384f650ed261c4455dd0827d08d65286410d8b9b5f77ce27afae8297f78e558ea0006f592fca6dd52dac55f453528f7b62d90fd43b3e

data/Manifest.txt

@@ -3,10 +3,13 @@ Manifest.txt
 README.md
 Rakefile
 lib/crypto-lite.rb
+lib/crypto-lite/config.rb
 lib/crypto-lite/version.rb
 lib/crypto.rb
 lib/crypto/lite.rb
 test/helper.rb
+test/test_base58.rb
+test/test_bitcoin_addr.rb
 test/test_hash_keccak.rb
 test/test_hash_sha.rb
 test/test_version.rb

data/README.md

@@ -12,7 +12,7 @@
 
 ### Secure Hashing / Hash Functions
 
-**SHA256 - Secure Hash Algorithm (SHA) 256-Bits (32 Bytes)**
+**SHA256 - Secure Hash Algorithm (SHA) 256-Bit (32 Bytes)**
 
 
 ``` ruby
@@ -52,7 +52,7 @@ sha256( "Hello, Cryptos!" )  #=> "33eedea60b0662c66c289ceba71863a864cf84b00e1000
 
 
 
-#### Aside - Hex String `'0x616263'` vs Binary String `'abc' == "\x61\x62\x63"`
+#### Aside - Hex String `"0x616263"` vs Binary String `"\x61\x62\x63" == "abc"`
 
 Note: All hash functions operate on binary strings ("byte arrays")
 and NOT hex strings.
@@ -62,20 +62,20 @@ Examples of hex strings:
 
 ``` ruby
 # hex string      binary string ("byte array")
-'61'              'a' == "\x61"
-'0x61'            'a' == "\x61"
+"61"              "\x61" == "a"
+"0x61"            "\x61" == "a"
 
-'616263'          'abc' == "\x61\x62\x63"
-'0x616263'        'abc' == "\x61\x62\x63"
-'0X616263'        'abc' == "\x61\x62\x63"
+"616263"          "\x61\x62\x63" == "abc"
+"0x616263"        "\x61\x62\x63" == "abc"
+"0X616263"        "\x61\x62\x63" == "abc"
 
 # or   160-bit hex string (hash)
-'93ce48570b55c42c2af816aeaba06cfee1224fae'
-'0x93ce48570b55c42c2af816aeaba06cfee1224fae'
+"93ce48570b55c42c2af816aeaba06cfee1224fae"
+"0x93ce48570b55c42c2af816aeaba06cfee1224fae"
 
 # or 256-bit hex string (hash)
-'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
-'0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
+"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+"0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
 ```
 
 You can use `[str].pack( 'H*' )`
@@ -126,47 +126,113 @@ hash256( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
 
 ``` ruby
 keccak256( "Hello, Cryptos!" )  #=> "2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5"
+keccak256( '' )                 #=> "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
 ```
 
 
+#### Aside - Keccak vs SHA3 / Original vs Official
+
+In 2004 the U.S. National Institute of Standards and Technology (NIST)
+changed the padding to `SHA3-256(M) = KECCAK [512] (M || 01, 256)`.
+This is different from the padding proposed by the Keccak team in
+the original Keccak SHA-3 submission version 3 (the final, winning version).
+The difference is the additional `'01'` bits appended to the message.
+
+To help avoid confusion the "submitted original version 3" SHA-3 Keccak
+hashing is now called "Keccak"
+and the finalized NIST SHA-3 standard "SHA3".
+
+Tip: If you don't know what variant of the hash function you have -
+original or official? - check your hash:
+
+For keccak 256-bit:
+
+``` ruby
+keccak256( '' )                #=> "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
+keccak256( 'Hello, Cryptos!' ) #=> "2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5"
+```
+
+For sha3 256-bit:
+
+``` ruby
+sha3_256( '' )                 #=> "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"
+sha3_256( 'Hello, Cryptos!' )  #=> "7dddf4bc9b86352b67e8823e5010ddbd2a90a854469e2517992ca7ca89e5bd58"
+```
+
+
+
 **RMD  - RACE¹ Integrity Primitives Evaluation Message Digest 160-Bit**
 
 ¹: Research and development in Advanced Communications technologies in Europe
 
 
 ``` ruby
-rmd160( "Hello, Cryptos!" )  #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
+rmd160( "Hello, Cryptos!" )     #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
+# or use the alias / alternate name
+ripemd160( "Hello, Cryptos!" )  #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
 ```
 
 
 
-#### Helpers
+#### Hash Function Helpers
 
-**HASH160 -  RMD160(SHA256())**
+**HASH160 -  RMD160(SHA256(X))**
 
 All-in-one "best-of-both-worlds" helper - first hash with sha256 and than hash with rmd160. Why?  Get the higher security of sha256 and the smaller size of rmd160.
 
 
 ``` ruby
 hash160( '02b9d1cc0b793b03b9f64d022e9c67d5f32670b03f636abf0b3147b34123d13990' )
-=> "e6b145a3908a4d6616b13c1109717add8672c900"
+#=> "e6b145a3908a4d6616b13c1109717add8672c900"
 
 hash160( '02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737' )
-=> "93ce48570b55c42c2af816aeaba06cfee1224fae"
+#=> "93ce48570b55c42c2af816aeaba06cfee1224fae"
 ```
 
 
-
-**HASH256 -  SHA256(SHA256())**
+**HASH256 -  SHA256(SHA256(X))**
 
 All-in-one double sha256 hash helper, that is, first hash with sha256 and than hash with sha256 again. Why?  Arguably higher security.
 
+> SHA256(SHA256(X)) was proposed by Ferguson and Schneier in their excellent book "Practical Cryptography"
+> (later updated by Ferguson, Schneier, and Kohno and renamed "Cryptography Engineering") as a way to make SHA256 invulnerable
+> to "length-extension" attack. They called it "SHA256D".
+
+
 ``` ruby
 hash256( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
-=> "02335f08b8fe4ddad263a50b7a33c5d38ea1cbd8fd2056a1320a3ddece541711"
+#=> "02335f08b8fe4ddad263a50b7a33c5d38ea1cbd8fd2056a1320a3ddece541711"
+```
+
+##### Base58 Encoding / Decoding Helpers
+
+**BASE58**
+
+Base58 encoding / decoding with leading zero bytes (in hex or binary strings) getting encoded from `00` to `1` and back:
+
+``` ruby
+base58( "516b6fcd0f" )    #=> "ABnLTmg"
+base58( "00000000000000000000123456789abcdef0" )   #=> "111111111143c9JGph3DZ"
+# or with optional 0x or 0X prefix
+base58( "0x516b6fcd0f" )  #=> "ABnLTmg"
+base58( "0x00000000000000000000123456789abcdef0" ) #=> "111111111143c9JGph3DZ"
+
+unbase58( "ABnLTmg" )  #=> "516b6fcd0f"
+unbase58( "111111111143c9JGph3DZ" ) #=> "00000000000000000000123456789abcdef0"
 ```
 
 
+**BASE58CHECK -  BASE58(X || SHA256(SHA256(X))[:4])**
+
+Base58 encoding with an extra 4-byte secure hash checksum.
+
+``` ruby
+base58check( "516b6fcd0f" )  #=> "237LSrY9NUUas"
+base58check( "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31" ) #=> "1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs"
+
+unbase58check( "237LSrY9NUUas" )   #=> "516b6fcd0f"
+unbase58check( "1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs" )   #=> "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31"
+```
 
 
 
@@ -291,6 +357,95 @@ and some more.
 
 
 
+
+## Examples
+
+### Generate the Bitcoin (Base58) Address from the (Elliptic Curve) Public Key
+
+Let's follow the steps from [How to create Bitcoin Address](https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses#How_to_create_Bitcoin_Address):
+
+``` ruby
+# Lets start with the public key ("raw" hex string encoded)
+pk = "0250863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352"
+
+# 1. Perform SHA-256 hashing on the public key
+step1 = sha256( pk )
+#=> "0b7c28c9b7290c98d7438e70b3d3f7c848fbd7d1dc194ff83f4f7cc9b1378e98"
+
+# 2. Perform RIPEMD-160 hashing on the result of SHA-256
+step2 = ripemd160( step1 )
+#=> "f54a5851e9372b87810a8e60cdd2e7cfd80b6e31"
+
+# 3. Add version byte in front of RIPEMD-160 hash (0x00 for Main Network)
+step3 = "00" + step2
+#=> "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31"
+
+# 4. Perform SHA-256 hash on the extended RIPEMD-160 result
+step4 = sha256( step3 )
+#=> "ad3c854da227c7e99c4abfad4ea41d71311160df2e415e713318c70d67c6b41c"
+
+# 5. Perform SHA-256 hash on the result of the previous SHA-256 hash
+step5 = sha256( step4 )
+#=> "c7f18fe8fcbed6396741e58ad259b5cb16b7fd7f041904147ba1dcffabf747fd"
+
+# 6. Take the first 4 bytes of the second SHA-256 hash. This is the address checksum
+step6 = step5[0..7]      # note: 4 bytes in hex string are 8 digits/chars
+#=> "c7f18fe8"
+
+# 7. Add the 4 checksum bytes from step 6 at the end of
+#    extended RIPEMD-160 hash from step 3.
+#    This is the 25-byte binary Bitcoin Address.
+step7 = step3 + step6
+#=> "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31c7f18fe8"
+
+# 8. Convert the result from a byte string into a base58 string using Base58 encoding.
+#  This is the most commonly used Bitcoin Address format.
+addr  = base58( step7 )
+#=> "1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs"
+```
+
+Or let's try again with the shortcut helpers:
+
+- `HASH160     -  RMD160(SHA256(X))`
+- `BASE58CHECK -  BASE58(X || SHA256(SHA256(X))[:4])`
+
+``` ruby
+# Lets start with the public key ("raw" hex string encoded)
+pk = "0250863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352"
+
+# 1. Perform HASH-160 hashing on the public key
+#    a) Perform SHA-256 hashing on the public key
+#    b) Perform RIPEMD-160 hashing on the result of SHA-256
+step1 = hash160( pk )
+#=> "f54a5851e9372b87810a8e60cdd2e7cfd80b6e31"
+
+# 2. Add version byte in front of RIPEMD-160 hash (0x00 for Main Network)
+step2 = "00" + step1
+#=> "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31"
+
+# 3. Encode with BASE58CHECK
+#    a) Perform SHA-256 hash on the extended RIPEMD-160 result
+#    b) Perform SHA-256 hash on the result of the previous SHA-256 hash
+#    c) Take the first 4 bytes of the second SHA-256 hash. This is the address checksum
+#    d) Add the 4 checksum bytes at the end of
+#       extended RIPEMD-160 hash from step 2.
+#       This is the 25-byte binary Bitcoin Address.
+#    e) Convert the result from a byte string into a base58 string
+#       using Base58 encoding.
+#       This is the most commonly used Bitcoin Address format.
+addr  = base58check( step2 )
+#=> "1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs"
+```
+
+
+References
+
+- [How to create Bitcoin Address](https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses#How_to_create_Bitcoin_Address)
+- [Ruby Quiz #15 - Generate the Bitcoin (Base58) Address from the (Elliptic Curve) Public Key](https://github.com/planetruby/quiz/tree/master/015)
+
+
+
+
 ## Install
 
 Just install the gem:

data/Rakefile

@@ -19,7 +19,9 @@ Hoe.spec 'crypto-lite' do
   self.history_file = 'CHANGELOG.md'
 
   self.extra_deps = [
-     ['digest-sha3-patched']
+     ['digest-sha3-patched'],
+     ['base32-alphabets'],
+     ['base58-alphabets'],
   ]
 
   self.licenses = ['Public Domain']

data/lib/crypto-lite.rb

@@ -8,10 +8,16 @@ require 'digest/sha3'  # e.g. keccak (original submission/proposal NOT official
 ## see https://rubygems.org/gems/digest-sha3-patched
 ##     https://github.com/teamhedge/digest-sha3-ruby
 
+## our own 3rd party (2nd party?)
+require 'base32-alphabets'
+require 'base58-alphabets'
+
 
 
 ## our own code
 require 'crypto-lite/version'    # note: let version always go first
+require 'crypto-lite/config'
+
 
 
 
@@ -23,13 +29,55 @@ module Crypto
 
 
 
+  def self.base58bin( input )
+    ## todo/check: input must be a (binary) string - why? why not?
+    Base58::Bitcoin.encode_bin( input )
+  end
+
+  def self.base58( input )
+    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
+    base58bin( input )
+  end
+
+  def self.base58hex( input )
+    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   unless input =~ HEX_RE
+
+    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
+    base58bin( [input].pack( 'H*' ) )
+  end
+
+
+  def self.base58bin_check( input )
+    ## todo/check: input must be a (binary) string - why? why not?
+    hash256 = hash256bin( input )
+    base58bin( input + hash256[0,4] )
+  end
+
+  def self.base58check( input )
+    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
+    base58bin_check( input )
+  end
+
+  def self.base58hex_check( input )
+    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   unless input =~ HEX_RE
+
+    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
+    base58bin_check( [input].pack( 'H*' ) )
+  end
+
+
+  ########################
+  # (secure) hash functions
+
   def self.message( input )  ## convert input to (binary) string
-    input_type = if input.is_a?( String )
-                  "#{input.class.name}/#{input.encoding}"
-                 else
-                  input.class.name
-                 end
-    puts "  input: #{input} (#{input_type})"
+    if debug?
+      input_type = if input.is_a?( String )
+                    "#{input.class.name}/#{input.encoding}"
+                   else
+                    input.class.name
+                   end
+      puts "  input: #{input} (#{input_type})"
+    end
 
     message = if input.is_a?( Integer )  ## assume byte if single (unsigned) integer
                 raise ArgumentError, "expected unsigned byte (0-255) - got #{input} (0x#{input.to_s(16)}) - can't pack negative number; sorry"   if input < 0
@@ -40,12 +88,14 @@ module Crypto
                 input
               end
 
-    bytes = message.bytes
-    bin   = bytes.map {|byte| byte.to_s(2).rjust(8, "0")}.join( ' ' )
-    hex   = bytes.map {|byte| byte.to_s(16).rjust(2, "0")}.join( ' ' )
-    puts "  #{pluralize( bytes.size, 'byte')}:  #{bytes.inspect}"
-    puts "  binary: #{bin}"
-    puts "  hex:    #{hex}"
+    if debug?
+      bytes = message.bytes
+      bin   = bytes.map {|byte| byte.to_s(2).rjust(8, "0")}.join( ' ' )
+      hex   = bytes.map {|byte| byte.to_s(16).rjust(2, "0")}.join( ' ' )
+      puts "  #{pluralize( bytes.size, 'byte')}:  #{bytes.inspect}"
+      puts "  binary: #{bin}"
+      puts "  hex:    #{hex}"
+    end
 
     message
   end
@@ -73,7 +123,12 @@ module Crypto
     input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
     rmd160bin( input ).unpack( 'H*' )[0]
   end
-  ## todo/fix: add alias RIPEMD160 - why? why not?
+
+  ## add alias RIPEMD160 - why? why not?
+  class << self
+    alias_method :ripemd160,    :rmd160
+    alias_method :ripemd160bin, :rmd160bin
+  end
 
 
 
@@ -81,7 +136,7 @@ module Crypto
        message = message( input )  ## "normalize" / convert to (binary) string
 
        if engine && ['openssl'].include?( engine.to_s.downcase )
-         puts "  engine: #{engine}"
+         puts "  engine: #{engine}"    if debug?
          digest = OpenSSL::Digest::SHA256.new
          digest.update( message )
          digest.digest
@@ -228,6 +283,8 @@ def sha256hex( input, engine=nil ) Crypto.sha256hex( input, engine ); end
 def keccak256( input )    Crypto.keccak256( input ); end
 
 def rmd160( input )    Crypto.rmd160( input ); end
+def ripemd160( input ) Crypto.rmd160( input ); end
+## alias_method :ripemd160, :rmd160
 
 def hash160( input )    Crypto.hash160( input ); end
 def hash160hex( input ) Crypto.hash160hex( input ); end
@@ -236,6 +293,14 @@ def hash256( input )    Crypto.hash256( input ); end
 def hash256hex( input ) Crypto.hash256hex( input ); end
 
 
+def base58( input )     Crypto.base58( input ); end
+def base58hex( input )  Crypto.base58hex( input ); end
+
+
+def base58check( input ) Crypto.base58check( input ); end
+
+
+
 RSA = Crypto::RSA
 
 

data/lib/crypto-lite/config.rb

@@ -0,0 +1,32 @@
+module Crypto
+
+  class Configuration
+
+    def initialize
+      @debug = false
+    end
+
+    def debug?()         @debug || false; end
+    def debug=(value)    @debug = value; end
+  end # class Configuration
+
+  ## lets you use
+  ##   Crypto.configure do |config|
+  ##      config.debug  =  true
+  ##   end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield( configuration )
+  end
+
+  ## add convenience helper for format
+  def self.debug?() configuration.debug?; end
+  def self.debug=(value) self.configuration.debug = value; end
+end # module Crypto
+
+
+

data/lib/crypto-lite/version.rb

@@ -3,7 +3,7 @@ module CryptoLite
 
   MAJOR = 0
   MINOR = 2
-  PATCH = 1
+  PATCH = 2
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/test/test_base58.rb

@@ -0,0 +1,35 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_base58.rb
+
+
+require 'helper'
+
+
+class TestBase58 < MiniTest::Test
+
+HEX_TESTS = [
+   ["00000000000000000000", "1111111111"],
+   ["00000000000000000000123456789abcdef0", "111111111143c9JGph3DZ"],
+]
+
+def test_hex
+   HEX_TESTS.each do |item|
+      assert_equal item[1],  base58hex( item[0] )
+      assert_equal item[1],  base58( item[0] )
+    end
+end
+
+
+def test_bitcoin_addr
+   addr_exp = '1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs'
+
+   pkh = 'f54a5851e9372b87810a8e60cdd2e7cfd80b6e31'
+
+   ## all-in-one
+   assert_equal addr_exp, base58check( '00' + pkh )
+   assert_equal addr_exp, Crypto.base58hex_check( '00' + pkh )
+   assert_equal addr_exp, Crypto.base58bin_check( "\x00" + [pkh].pack('H*') )
+end
+
+end # class TestBase58

data/test/test_bitcoin_addr.rb

@@ -0,0 +1,58 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_bitcoin_addr.rb
+
+
+require 'helper'
+
+class TestBitcoinAddr < MiniTest::Test
+
+
+def test_bitcoin_addr_v1
+   pk = "0250863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352"
+
+   step1 = sha256( pk )
+   assert_equal "0b7c28c9b7290c98d7438e70b3d3f7c848fbd7d1dc194ff83f4f7cc9b1378e98",
+                step1
+
+   step2 = ripemd160( step1 )
+   assert_equal "f54a5851e9372b87810a8e60cdd2e7cfd80b6e31",
+                step2
+
+   step3 = "00" + step2
+   assert_equal "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31",
+                step3
+
+   step4 = sha256( step3 )
+   assert_equal "ad3c854da227c7e99c4abfad4ea41d71311160df2e415e713318c70d67c6b41c",
+                step4
+
+   step5 = sha256( step4 )
+   assert_equal "c7f18fe8fcbed6396741e58ad259b5cb16b7fd7f041904147ba1dcffabf747fd",
+                 step5
+
+   step6 = step5[0..7]      # note: 4 bytes in hex string are 8 digits/chars
+   assert_equal "c7f18fe8", step6
+
+   step7 = step3 + step6
+   assert_equal "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31c7f18fe8", step7
+
+   addr  = base58( step7 )
+   assert_equal "1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs", addr
+end
+
+
+def test_bitcoin_addr_v2
+   pk = "0250863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352"
+
+   step1 = hash160( pk )
+   assert_equal "f54a5851e9372b87810a8e60cdd2e7cfd80b6e31", step1
+
+   step2 = "00" + step1
+   assert_equal "00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31", step2
+
+   addr  = base58check( step2 )
+   assert_equal "1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs", addr
+end
+
+end # class TestBitcoinAddr

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crypto-lite
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-15 00:00:00.000000000 Z
+date: 2021-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest-sha3-patched
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: base32-alphabets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: base58-alphabets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -73,10 +101,13 @@ files:
 - README.md
 - Rakefile
 - lib/crypto-lite.rb
+- lib/crypto-lite/config.rb
 - lib/crypto-lite/version.rb
 - lib/crypto.rb
 - lib/crypto/lite.rb
 - test/helper.rb
+- test/test_base58.rb
+- test/test_bitcoin_addr.rb
 - test/test_hash_keccak.rb
 - test/test_hash_sha.rb
 - test/test_version.rb