RubyGems - crypto-lite - Versions diffs - 0.2.3 → 0.3.1 - Mend

crypto-lite 0.2.3 → 0.3.1

Files changed (19) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +3 -3
data/README.md +1023 -501
data/Rakefile +34 -33
data/lib/crypto/lite.rb +2 -2
data/lib/crypto-lite/config.rb +32 -32
data/lib/crypto-lite/helper.rb +25 -25
data/lib/crypto-lite/metal.rb +135 -128
data/lib/crypto-lite/sign_rsa.rb +29 -29
data/lib/crypto-lite/version.rb +23 -23
data/lib/crypto-lite.rb +145 -147
data/lib/crypto.rb +2 -2
data/test/helper.rb +11 -11
data/test/test_base58.rb +36 -36
data/test/test_bitcoin_addr.rb +58 -58
data/test/test_hash.rb +47 -47
data/test/test_hash_sha.rb +90 -87
data/test/test_version.rb +19 -19
metadata +21 -7

data/README.md CHANGED Viewed

@@ -1,501 +1,1023 @@
-# crypto-lite - Cryptographic Secure Hash Functions and Public Key Signature Algorithms Made Easy
-* home  :: [github.com/rubycoco/blockchain](https://github.com/rubycoco/blockchain)
-* bugs  :: [github.com/rubycoco/blockchain/issues](https://github.com/rubycoco/blockchain/issues)
-* gem   :: [rubygems.org/gems/crypto-lite](https://rubygems.org/gems/crypto-lite)
-* rdoc  :: [rubydoc.info/gems/crypto-lite](http://rubydoc.info/gems/crypto-lite)
-## Usage
-### Secure Hashing / Hash Functions
-**SHA256 - Secure Hash Algorithm (SHA) 256-Bit (32 Bytes)**
-``` ruby
-require 'crypto'      ## or use require 'crypto-lite'
-## try abc
-sha256( "abc" )           #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( "abc".b )         #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( "\x61\x62\x63" )  #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( 0x616263 )        #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( hex: '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( hex: '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( hex: '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-# "auto-magic" hex string to binary string conversion heuristic
-sha256( '0x616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( '0X616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-```
-Bonus Back Stage Tip: How does SHA256 work?
-Try this [amazing animation of the SHA256 hash function in your very own terminal](https://github.com/in3rsha/sha256-animation) by Greg Walker.
-Onwards with more sha256 examples:
-``` ruby
-## try a
-sha256( "a" )         #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256( "\x61" )      #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256( 0b01100001 )  #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256( 0x61 )        #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256( hex: '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256( hex: '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-# "auto-magic" hex string to binary string conversion heuristic
-sha256( '0x61' )      #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-## try some more
-sha256( "Hello, Cryptos!" )  #=> "33eedea60b0662c66c289ceba71863a864cf84b00e10002ca1069bf58f9362d5"
-```
-**SHA3-256 - Secure Hashing Algorthim (SHA) 3, 256-Bit (32 Bytes)**
-``` ruby
-sha3_256( "Hello, Cryptos!" )  #=> "7dddf4bc9b86352b67e8823e5010ddbd2a90a854469e2517992ca7ca89e5bd58"
-```
-Note:  Yes, SHA256 vs SHA3-256 / SHA-2 vs SHA-3 the hashing functions are
-different (although the 256-bit hash size output is the same).
-The sha256 hashing function is part of the Secure Hash Algorithm (SHA) 2 family / standards first published in 2001.
-The sha3_256 is part of the (newer) Secure Hash Algorithm (SHA) 3 family / standards first published in 2015
-(and uses the Keccak cryptographic primitive "under the hood").
-**Keccak 256-Bit**
-``` ruby
-keccak256( "Hello, Cryptos!" )  #=> "2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5"
-```
-#### 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"
-```
-For sha3 256-bit:
-``` ruby
-sha3_256( '' )   #=> "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"
-```
-**RMD / RIPE-MD  - RACE¹ Integrity Primitives Evaluation Message Digest 160-Bit**
-¹: Research and development in Advanced Communications technologies in Europe
-``` ruby
-rmd160( "Hello, Cryptos!" )     #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
-# or use the alias / alternate name
-ripemd160( "Hello, Cryptos!" )  #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
-```
-#### 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.
-Note: For hex strings the `0x` or `0X` prefix is optional.
-Examples of hex strings:
-``` ruby
-# hex string      binary string ("byte array")
-"61"              "\x61" == "a"
-"0x61"            "\x61" == "a"
-"616263"          "\x61\x62\x63" == "abc"
-"0x616263"        "\x61\x62\x63" == "abc"
-"0X616263"        "\x61\x62\x63" == "abc"
-# or   160-bit hex string (hash)
-"93ce48570b55c42c2af816aeaba06cfee1224fae"
-"0x93ce48570b55c42c2af816aeaba06cfee1224fae"
-# or 256-bit hex string (hash)
-"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-"0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-```
-You can use `[str].pack( 'H*' )`
-to convert a hex string into a binary string.
-Note: The standard `Array#pack` conversion
-will NOT "auto-magically" cut-off the `0x` or `0X` prefix.
-If you know you have a hex string use the `hex:` keyword to pass
-in the arg(ument)
-to the hash function and that will "automagically"
-handle the hex-to-bin conversion for you. Example:
-``` ruby
-sha256( hex: '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256( hex: '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256( hex: '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( hex: '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( hex: '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-```
-What about the built-in "auto-magic" hex-to-bin conversion / heuristic?
-Yes, if your passed in string starts with the
-the `0x` or `0X` prefix the string gets "auto-magically" converted
-to binary. Or if your passed in string is all hexadecimal characters,
-that is, `0-9` and `a-f` and has a minimum length of ten characters.
-Example:
-``` ruby
-# "auto-magic" hex string to binary string conversion heuristic
-sha256( '0x616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256( '0X616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-# or without 0x or 0X BUT with minimum heuristic length
-hash160( '02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737' )
-#=> "93ce48570b55c42c2af816aeaba06cfee1224fae"
-hash256( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
-#=> "02335f08b8fe4ddad263a50b7a33c5d38ea1cbd8fd2056a1320a3ddece541711"
-# and so on
-```
-#### Hash Function Helpers
-**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"
-hash160( '02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737' )
-#=> "93ce48570b55c42c2af816aeaba06cfee1224fae"
-```
-**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"
-```
-#### 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"
-```
-### Public Key Signature Algorithms
-**RSA - Rivest, Shamir and Adleman**
-``` ruby
-alice_key, alice_pub =  RSA.generate_keys
-alice_key
-#=> "-----BEGIN RSA PRIVATE KEY-----
-#    MIIEpAIBAAKCAQEAzLpmAQ+MbUTHU1XxzEaQXqiOvk0Vu/skztaMWz+UoGYWU6eW
-#    cr7zVt/Y0SYqzD8LkYireX22FxNNFfhgu3/uC5yTl+dri6PD6NDAmrG+1cyE8kZZ
-#    MGq91wQEemZPuesjTgKEvwZbknjodIKOAP35QycMr4PuWICSrCjhJLrClI7jInTZ
-#    LOLtD5w5U7/xLOJAIfuhjUA4wrFCLJGPe7214KWgDCLmsan4/GVUloUKa6KAHJiH
-#    q4tNxNdSrbOlluZbKQl8REhXOCIb5bEX2KnbQT0nPgKkuOlXgZ7jeyOIk0FG1RGa
-#    FvcGu8LieMgT39WltcHJLblNkDr9YDRGiNiThQIDAQABAoIBAQCE/FPEPqBeXj4I
-#    MRzHL9MZ2e4XSaVjnYjUXuN/ZnaaFpZMMuF0mfshpHiHq35DfHR8TcXtPi6pIJ2D
-#    NvtG8JvlqQjqtKXUaEWbFvb1xZ4L7TUy12WaIMw+PlrWU11YjJg7VUF7gJq9M5L0
-#    E9ZAaLmg2F3SKSYLEUG1WTyeij5ZFqouNjZxD2xo5U5Agy2UVm2D9aUm/n4g8Wnr
-#    HybadhD6V9+BsZ2e9Q6CamHRah9Hs4nDPnycPFXpbs32wx9nvACPMg5+/Fqxr/ZK
-#    cPM4syVBW0lNhpTzhHkPvimAgwgqJYvAj/o9nQnq5i1XyVyXp3uKVnld3FCddf9i
-#    ovQMPmVlAoGBAPHtUKRehy8df/Zw6oGz0WcZCTjEwZ9DEb5rFN9Pr2IyvOhmZ3UJ
-#    JNx9WmiiGB44dbnafMtr2Ya7u4OAM6e190BbcJKTnpWqVlsXw/wyQqIgJb3AtFu4
-#    91mqsDepOWsfs1IjTgmR1OM29WXjGoPHtV9E6//uVmVsciEvkCtcRfGDAoGBANij
-#    IbZ3mL1rr8uRT/czPLkZ3KPLsJhPriuc6yyOq+tqQ6d3u/1DjKxoeYa7Jbyj7Dwl
-#    2wHQf9vRz3Kb2Mw+hPcHGDO9aBWxvZXjxxrVk6g1Ei0mvIP0k8ZbnlReK3cr5ktl
-#    aY/ZWDDVPpY4aqkcOIbAAi95jPlpb2LsntijxoBXAoGABPJRP8sfAHud7jAI23YN
-#    xgnhAmQjgVohtr8Bwj8i2uMmsanGW8JAGrIFczY9QADvh0lMW+xsmjCkeN/aLoet
-#    8obsGlMiXvUIpvwpabKtYhs+Kk8SYP27MP4odDrljacsR3WpVtDAhZTOF7M5C5C9
-#    yKDkImuBILnC66LJU9mjJHkCgYEAntDxDSCeQ/dnOBh+hB323UgdXaMdAnwflm+C
-#    ZPbvCDWuBV6c3W2g+l/Y/7HBV4rgy7OA29KreU5WA5JHHGyU87gqwPuRC55y+yiy
-#    NXTvu7e0bI9iUmaB00AlUXp76PCw8wMUoVVX9uzN5jjT0MgUlIy8zWsRs2LdOqt3
-#    RCDEjB8CgYAO6ZptzyJ4FS7ucjKfjig5WMOiKMcIUtTG9qedHmE2Z6vt3g0SQWaD
-#    zJJacSoRHAdRK61vOlg4k+9/9LjffDrk9uT555BDbYqKWlmST7JMfvO7EpaIMYUu
-#    CN7+3Rx9gSLyScqtAYiT/LgYgL1Vc6/e0XHaVjA85kPvUDKb785oFg==
-#    -----END RSA PRIVATE KEY-----"
-alice_pub
-#=> "-----BEGIN PUBLIC KEY-----
-#    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzLpmAQ+MbUTHU1XxzEaQ
-#    XqiOvk0Vu/skztaMWz+UoGYWU6eWcr7zVt/Y0SYqzD8LkYireX22FxNNFfhgu3/u
-#    C5yTl+dri6PD6NDAmrG+1cyE8kZZMGq91wQEemZPuesjTgKEvwZbknjodIKOAP35
-#    QycMr4PuWICSrCjhJLrClI7jInTZLOLtD5w5U7/xLOJAIfuhjUA4wrFCLJGPe721
-#    4KWgDCLmsan4/GVUloUKa6KAHJiHq4tNxNdSrbOlluZbKQl8REhXOCIb5bEX2Knb
-#    QT0nPgKkuOlXgZ7jeyOIk0FG1RGaFvcGu8LieMgT39WltcHJLblNkDr9YDRGiNiT
-#    hQIDAQAB
-#    -----END PUBLIC KEY-----"
-bob_key, bob_pub = RSA.generate_keys
-bob_key
-#=> "-----BEGIN RSA PRIVATE KEY-----
-#    MIIEpAIBAAKCAQEAzADannvKlfVkZmKA4EDIxTW0HiJzjD6Auh8wLi02+iz2BScz
-#    fECA65Zv+KHfc1B9AWMqGeBIwFE49NrsnXiZwZR3DqcFS8WbnVqpntvhwzlEARna
-#    RWmZ2XjloD7fxILbXtWfMFNjwSfaK0bpArLkrt9d8eni+JI42+ptIWs/bVynACqm
-#    DqOTjoEgajuHVpxHtskPNQrsjxzP+umsUWkbE0iaO7oN1pcgZIR4VRr0bz/3Juif
-#    WmiCgwbDZo1WolfveoCacVsfAB1iesxeWnrGIJUjq8Mqsu9mQz1dg6RF4ElwNJ57
-#    G3T3nlW+qpVBZDU2sHFqUFxbGmWPdRUn1yn4KwIDAQABAoIBAQCOCwotz4P/Zh3C
-#    LFQP0Qv6RKplURejTuHStmSVwmXFTAkBDYqLuV4Kq3TLaepsIF7p2GI4IjKFtggy
-#    dTzLaG2mm/lJ+oF1gOIZbkcslW1cwULYgWe5bQ3ynntEWIL2ESctoRB2VZnfpCAE
-#    ghs8BdO071I6Xt/qs+VjOpdB7ar8OYhFc1vhwiI03FKbjuScH0CQOETIeLCqK5tC
-#    qPnjMTYdaTp/NgcZujsOeOBgbARLzGtCaESbmXHO6mPDkEED5uqZzsNBtdCZIGMF
-#    ApJkZbF6xSRizQhwwRlak1jCkAk2VCYpKPMiop1+cbjs3jU3RyP94RHc/yKo2Rzm
-#    HCl35XYBAoGBAPJDMV9W2scRsMlLw9In3ZzWtammcouE0oXEgizK61Cg/5C5E06a
-#    5anrfwF5bURBANKBqTSHV0u71C2fHs1KO+B+EHzQ4DKsXldCSv2PR/0A6lmF9AIL
-#    DFfup/mU55plbqCnjJe2BOUrOmurSd5MbWtShRdGri/LBqF58BFgT+U1AoGBANeS
-#    RZDsCWelZPGN8Wxp9zxhu1AClNO9S7ITjZOQTYlghCVKAkS1wvB/6TIjaw8DyREs
-#    f6WvtkzQA/vZc4mXE+YM/calL8ee3wVEJJzlGBfuh8mQhxtiLa5PTl7Icv/R8DGV
-#    9hU9GkJgWdi/+Plpqdcv79OWVMTB7igmoN8PAPPfAoGAKqatwI04AygYKbhPB2bB
-#    W2Vpoi6NqAaAUdCg4mXvO8i8daw/u+0FVf8B4y6PkB6pmGX/diIFum2dE1MaRyY0
-#    mHdZS8AyWHmEOnSPY0igceiBWbV9mgZ769c2d3hBtir5aQtWczc2cWpE5MPJQ3vN
-#    H8HtcIWfEQb7ad5f548/QakCgYEAwFDjNRYOkePQ+Vrbjg+/HKRH+mpDId9Xv4eI
-#    H6R2N9/eJHIxMeFCB1Ll1PAaG6wR3ftn6YWnykEtvKpTU+VvQCZI5MYLqTgH2Ofh
-#    DgOoCfmoNF922SwuerqPvSlwxt8hPOt/PZVkbuEMZr1lPgVRGwPOHmKYP2yPrkw/
-#    6p+1BtsCgYABmMLgWhXVD19XxNHm8XpGnPWTEjqAYrw6I5yDUwNhB0n4129qaC+x
-#    MWrdslKBmQh1r1U5QoSSL0CY4Ef5qN02uZl15FN1kYQzZA6kJi+MoBsjzrZCvzsc
-#    Bbahpg363PyHC75zgvazvOr4tK3mzaRi5RNTMgivTVu4FyhkRdJ5wQ==
-#    -----END RSA PRIVATE KEY-----"
-bob_pub
-#=> "-----BEGIN PUBLIC KEY-----
-#    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzADannvKlfVkZmKA4EDI
-#    xTW0HiJzjD6Auh8wLi02+iz2BSczfECA65Zv+KHfc1B9AWMqGeBIwFE49NrsnXiZ
-#    wZR3DqcFS8WbnVqpntvhwzlEARnaRWmZ2XjloD7fxILbXtWfMFNjwSfaK0bpArLk
-#    rt9d8eni+JI42+ptIWs/bVynACqmDqOTjoEgajuHVpxHtskPNQrsjxzP+umsUWkb
-#    E0iaO7oN1pcgZIR4VRr0bz/3JuifWmiCgwbDZo1WolfveoCacVsfAB1iesxeWnrG
-#    IJUjq8Mqsu9mQz1dg6RF4ElwNJ57G3T3nlW+qpVBZDU2sHFqUFxbGmWPdRUn1yn4
-#    KwIDAQAB
-#    -----END PUBLIC KEY-----"
-tx = "from: alice, to: bob,  $21"
-tx_hash = sha256( tx )
-#=> "426a472a6c69bf68354391b7822393bea3952cde9df8949ad7a0f5f405b2fcb5"
-tx_signature = RSA.sign( tx_hash, alice_key )
-#=> "xfhzC6tzXYmA5rFAFybJ9KeWnTcTnC0Plt7cSHky6ZSdBZRKz/sfFcpyIN7w
-#    jWrdPwEREA3nwNu/HSpiGRBFr+lu/YgWGNp6HLGPeL7uHGAfmWPyU5WRzGzf
-#    iEs5B6kdJ3S8LSbP0hkOD8AOgZLPeU5rzA4+/Ymt8e/UOVwwka6Gj13yoBua
-#    mSdsVuQfgh2VpySejCz4ykYlMSHK8Kx8QFt+QbyI5QZUy2dFh6HlcnHR+G9A
-#    RMRZ1vAuQhYqtDSsxwRcZCSFsc6uctAvsgFinhqy6ls5VpcXfuKwZhKAw3Di
-#    E2MYUnT7+i38Mq26iWzgmDbpOrVCO5tjlSiHY1731A=="
-RSA.valid_signature?( tx_hash, tx_signature, alice_pub )
-#=> true
-tx = "from: alice, to: bob,  $22"
-tx_hash = sha256( tx )
-#=> "e899604bb4c95d2f1a7cfe561ad65941769e2064bdbbcaa79eb64ce0a2832380"
-RSA.valid_signature?( tx_hash, tx_signature, alice_pub )
-#=> false
-```
-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)
-Bonus:  Bitcon Tip - How to Buy Bitcoin (The CO₂-Friendly Way)
-> 1. Take one $50 bill, five $10 bills, or ten $5 bills (I wouldn't recommend change - stay with paper money).
-> 2. Go to the bathroom.
-> 3. Lift the lid of the loo.
-> 4. Throw money in.
-> 5. Flush down water.
->
-> Congrats! You just purchased $50 worth of Bitcoin - without fucking the planet!
->
->  -- Trolly McTrollface, Bitcon Greater Fool Court Jester
-Read more [Crypto Quotes »](https://github.com/openblockchains/crypto-quotes)
-## Install
-Just install the gem:
-    $ gem install crypto-lite
-## License
-The scripts are dedicated to the public domain.
-Use it as you please with no restrictions whatsoever.
-## Questions? Comments?
-Send them along to the [wwwmake forum](http://groups.google.com/group/wwwmake).
-Thanks!
+# crypto-lite - Cryptographic Secure Hash Functions and Public Key Signature Algorithms Made Easy
+* home  :: [github.com/rubycocos/blockchain](https://github.com/rubycocos/blockchain)
+* bugs  :: [github.com/rubycocos/blockchain/issues](https://github.com/rubycocos/blockchain/issues)
+* gem   :: [rubygems.org/gems/crypto-lite](https://rubygems.org/gems/crypto-lite)
+* rdoc  :: [rubydoc.info/gems/crypto-lite](http://rubydoc.info/gems/crypto-lite)
+## Usage
+### Secure Hashing / Hash Functions
+**SHA256 - Secure Hash Algorithm (SHA) 256-Bit (32 Bytes)**
+``` ruby
+require 'crypto'      ## or use require 'crypto-lite'
+## try abc
+sha256( "abc" )           #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( "abc".b )         #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( "\x61\x62\x63" )  #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( 0x616263 )        #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+# "auto-magic" hex string to binary string conversion heuristic
+sha256( '0x616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( '0X616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+```
+Bonus Back Stage Tip: How does SHA256 work?
+Try this [amazing animation of the SHA256 hash function in your very own terminal](https://github.com/in3rsha/sha256-animation) by Greg Walker.
+More of a code golfer? See [½ Kilo of SHA256](https://idiosyncratic-ruby.com/51-half-kilo-of-sha256.html) by Jan Lelis - yes, the SHA256 algorithm coded (from scratch) in 500 bytes of ruby.
+Onwards with more sha256 examples:
+``` ruby
+## try a
+sha256( "a" )         #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( "\x61" )      #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( 0b01100001 )  #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( 0x61 )        #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( hex: '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( hex: '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+# "auto-magic" hex string to binary string conversion heuristic
+sha256( '0x61' )      #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+## try some more
+sha256( "Hello, Cryptos!" )  #=> "33eedea60b0662c66c289ceba71863a864cf84b00e10002ca1069bf58f9362d5"
+```
+**SHA3-256 - Secure Hashing Algorthim (SHA) 3, 256-Bit (32 Bytes)**
+``` ruby
+sha3_256( "Hello, Cryptos!" )  #=> "7dddf4bc9b86352b67e8823e5010ddbd2a90a854469e2517992ca7ca89e5bd58"
+```
+Note:  Yes, SHA256 vs SHA3-256 / SHA-2 vs SHA-3 the hashing functions are
+different (although the 256-bit hash size output is the same).
+The sha256 hashing function is part of the Secure Hash Algorithm (SHA) 2 family / standards first published in 2001.
+The sha3_256 is part of the (newer) Secure Hash Algorithm (SHA) 3 family / standards first published in 2015
+(and uses the Keccak cryptographic primitive "under the hood").
+**Keccak 256-Bit**
+``` ruby
+keccak256( "Hello, Cryptos!" )  #=> "2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5"
+```
+#### 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"
+```
+For sha3 256-bit:
+``` ruby
+sha3_256( '' )   #=> "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"
+```
+**RMD / RIPE-MD  - RACE¹ Integrity Primitives Evaluation Message Digest 160-Bit**
+¹: Research and development in Advanced Communications technologies in Europe
+``` ruby
+rmd160( "Hello, Cryptos!" )     #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
+# or use the alias / alternate name
+ripemd160( "Hello, Cryptos!" )  #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
+```
+#### 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.
+Note: For hex strings the `0x` or `0X` prefix is optional.
+Examples of hex strings:
+``` ruby
+# hex string      binary string ("byte array")
+"61"              "\x61" == "a"
+"0x61"            "\x61" == "a"
+"616263"          "\x61\x62\x63" == "abc"
+"0x616263"        "\x61\x62\x63" == "abc"
+"0X616263"        "\x61\x62\x63" == "abc"
+# or   160-bit hex string (hash)
+"93ce48570b55c42c2af816aeaba06cfee1224fae"
+"0x93ce48570b55c42c2af816aeaba06cfee1224fae"
+# or 256-bit hex string (hash)
+"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+"0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+```
+You can use `[str].pack( 'H*' )`
+to convert a hex string into a binary string.
+Note: The standard `Array#pack` conversion
+will NOT "auto-magically" cut-off the `0x` or `0X` prefix.
+If you know you have a hex string use the `hex:` keyword to pass
+in the arg(ument)
+to the hash function and that will "automagically"
+handle the hex-to-bin conversion for you. Example:
+``` ruby
+sha256( hex: '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( hex: '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( hex: '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+```
+What about the built-in "auto-magic" hex-to-bin conversion / heuristic?
+Yes, if your passed in string starts with the
+the `0x` or `0X` prefix the string gets "auto-magically" converted
+to binary. Or if your passed in string is all hexadecimal characters,
+that is, `0-9` and `a-f` and has a minimum length of ten characters.
+Example:
+``` ruby
+# "auto-magic" hex string to binary string conversion heuristic
+sha256( '0x616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( '0X616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+# or without 0x or 0X BUT with minimum heuristic length
+hash160( '02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737' )
+#=> "93ce48570b55c42c2af816aeaba06cfee1224fae"
+hash256( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
+#=> "02335f08b8fe4ddad263a50b7a33c5d38ea1cbd8fd2056a1320a3ddece541711"
+# and so on
+```
+#### Hash Function Helpers
+**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"
+hash160( '02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737' )
+#=> "93ce48570b55c42c2af816aeaba06cfee1224fae"
+```
+**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"
+```
+#### 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"
+```
+### Public Key Signature Algorithms
+**Elliptic Curve Digital Signature Algorithm (ECDSA)**
+Private Key
+An ECDSA (Elliptic Curve Digital Signature Algorithm) private key is a random number between 1 and the order of the elliptic curve group.
+``` ruby
+# Auto-generate (random) private key
+private_key = EC::PrivateKey.generate    # by default uses Secp256k1 curve (used in Bitcoin and Ethereum)
+private_key.to_i
+#=> 29170346885894798724849267297784761178669026868482995474159965944722616190552
+private_key.to_s
+#=> "407dd4ccde53d30f3a9cda74ceccb247f3997466964786b59e4d68e93e8f8658"
+```
+Derive / (Auto-)Calculate the Public Key - Enter Elliptic Curve (EC) Cryptography
+The public key (`K`) are two numbers (that is, a point with the coordinates x and y) computed by multiplying
+the generator point (`G`) of the curve with the private key (`k`) e.g. `K=k*G`.
+This is equivalent to adding the generator to itself `k` times.
+Magic?
+Let's try:
+``` ruby
+# This private key is just an example. It should be much more secure!
+private_key = EC::PrivateKey.new( 1234 )   # by default uses Secp256k1 curve (used in Bitcoin and Ethereum)
+public_key =  private_key.public_key   ## the "magic" one-way K=k*G curve multiplication (K=public key,k=private key, G=generator point)
+point = public_key.point
+point.x
+#=> 102884003323827292915668239759940053105992008087520207150474896054185180420338
+point.y
+#=> 49384988101491619794462775601349526588349137780292274540231125201115197157452
+point.x.to_s(16)
+#=> "e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2"
+point.y.to_s(16)
+#=> "6d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c"
+```
+Sign a transaction with an (elliptic curve) private key:
+``` ruby
+# Step 1 - Calculate the Transaction (tx) Hash
+tx = 'from: Alice  to: Bob     cryptos: 43_000_000_000'
+txhash = sha256( tx )
+# Step 2 - Get the Signer's Private key
+private_key = EC::PrivateKey.new( 1234 )     # This private key is just an example. It should be much more secure!
+# Sign!
+signature = private_key.sign( txhash )
+# -or-
+signature = EC.sign( txhash, private_key )
+signature.r
+#=> 80563021554295584320113598933963644829902821722081604563031030942154621916407
+signature.s
+#=> 58316177618967642068351252425530175807242657664855230973164972803783751708604
+signature.r.to_s(16)
+#=> "3306a2f81ad2b2f62ebe0faec129545bc772babe1ca5e70f6e56556b406464c0"
+signature.s.to_s(16)
+#=> "4fe202bb0835758f514cd4a0787986f8f6bf303df629dc98c5b1a438a426f49a"
+```
+Verify a signed transaction with an (elliptic curve) public key:
+``` ruby
+# Step 1 - Calculate the Transaction (tx) Hash
+tx = 'from: Alice  to: Bob     cryptos: 43_000_000_000'
+txhash = sha256( tx )
+# Step 2 - Get the Signer's Public Key
+public_key = EC::PublicKey.new(
+   102884003323827292915668239759940053105992008087520207150474896054185180420338,
+   49384988101491619794462775601349526588349137780292274540231125201115197157452
+)
+# Step 3 - Get the Transaction's Signature
+signature = EC::Signature.new(
+  80563021554295584320113598933963644829902821722081604563031030942154621916407,
+  58316177618967642068351252425530175807242657664855230973164972803783751708604
+)
+# Don't Trust - Verify
+public_key.verify?( txhash, signature )
+# -or-
+EC.verify?( txhash, signature, public_key )
+#=> true
+# or using hexadecimal numbers
+public_key = EC::PublicKey.new(
+  0xe37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2,
+  0x6d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c
+)
+signature = EC::Signature.new(
+  0x3306a2f81ad2b2f62ebe0faec129545bc772babe1ca5e70f6e56556b406464c0,
+  0x4fe202bb0835758f514cd4a0787986f8f6bf303df629dc98c5b1a438a426f49a
+)
+public_key.verify?( txhash, signature )
+# -or-
+EC.verify?( txhash, signature, public_key )
+#=> true
+```
+To sum up:
+- The (raw) private key is a 256-bit unsigned integer number
+- The (raw) public key is a point (x,y), that is, two 256-bit unsigned integer numbers - derived (calculated) from the private key
+- A (raw) signature is composed of (r,s), that is, two 256-bit unsigned integer numbers
+That's all the magic.
+## Real-World Examples / Cookbook
+**Bitcoin Chains**
+- [Derive the Bitcoin (Elliptic Curve) Public Key from the Private Key](#derive-the-bitcoin-elliptic-curve-public-key-from-the-private-key)
+- [Generate the Bitcoin (Base58) Address from the (Elliptic Curve) Public Key](#generate-the-bitcoin-base58-address-from-the-elliptic-curve-public-key)
+- [Encode the Bitcoin Private Key in the Wallet Import Format (WIF)](#encode-the-bitcoin-private-key-in-the-wallet-import-format-wif)
+**Dodge "Shiba Inu" Chains**
+- [Derive the Dodge (Elliptic Curve) Public Key from the Private Key](#derive-the-dodge-elliptic-curve-public-key-from-the-private-key)
+- [Generate the Dodge Address from the (Elliptic Curve) Public Key](#generate-the-dodge-address-from-the-elliptic-curve-public-key)
+**Litecoin Chains**
+- [Derive the Litecoin (Elliptic Curve) Public Key from the Private Key](#derive-the-litecoin-elliptic-curve-public-key-from-the-private-key)
+- [Generate the Litecoin Address from the (Elliptic Curve) Public Key](#generate-the-litecoin-address-from-the-elliptic-curve-public-key)
+**Ethereum Chains**
+- [Derive the Ethereum (Elliptic Curve) Public Key from the Private Key](#derive-the-ethereum-elliptic-curve-public-key-from-the-private-key)
+- [Generate the Ethereum Address from the (Elliptic Curve) Public Key](#generate-the-ethereum-address-from-the-elliptic-curve-public-key)
+## Bitcoin (BTC), Bitcoin Cash (BCH), Bitcoin Cash Satoshi Vision (BSV), Bitcoin Cash ABC (BCHA)
+**Bitcon Public Service Announcement:**
+> Bitcoin number go up because more people want bitcoin. Bitcoin becomes more and more valuable.
+>
+> - 1,000 HODLers
+> - 10,000 HODLers
+> - 100,000 HODLers
+> - 1,000,000 HODLers
+> - 10,000,000 HODLers
+> - 100,000,000 HODLers
+> - 1,000,000,000 HODLers
+> - 10,000,000,000 HODLers
+> - 100,000,000,000 HODLers and on and on
+>
+> People will come to understand bitcon.
+>
+> -- Dan McArdle, Bitcoin "There is No Alternative", Bitcoin is the New (Gold) Standard
+**[BEWARE: Yes, Bitcoin Is a Ponzi - Learn How the Investment Fraud Works »](https://github.com/openblockchains/bitcoin-ponzi)**
+### Derive the Bitcoin (Elliptic Curve) Public Key from the Private Key
+A private key in bitcoin is a 32-byte (256-bit) unsigned / positive integer number.
+Or more precise the private key is a random number between 1
+and the order of the elliptic curve secp256k1.
+``` ruby
+EC::SECP256K1.order
+#=> 115792089237316195423570985008687907852837564279074904382605163141518161494337
+# or in hexadecimal (base16)
+EC::SECP256K1.order.to_s(16)
+#=> "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"
+```
+#### Step 1 - Let's generate a private key
+``` ruby
+private_key = EC::PrivateKey.generate     # alice
+private_key.to_i
+#=> 50303382071965675924643368363408442017264130870580001935435312336103014915707
+private_key.to_s
+#=> "6f36b48dd130618049ca27e1909debdf3665cf0df0ade0986f0c50123107de7b"
+private_key = EC::PrivateKey.generate     # bob
+private_key.to_i
+#=> 96396065671557366547785856940504404648366202869823009146014078671352808008442
+private_key.to_s
+#=> "d51e3d5ce8fbc6e574cf78d1c46e8936c26f38b002b954d0eac8aef195d6eafa"
+```
+Or use your own (secure) random generator.
+Trivia Note: The smallest possible (BUT HIGHLY UNSECURE)
+private key is 1 (not 0).
+``` ruby
+def generate_key
+  1 + SecureRandom.random_number( EC::SECP256K1.order - 1 )
+end
+generate_key         # alice
+#=> 66010624277151619503613090016410344678572543187504521309126248385615121289833
+generate_key         # bob
+#=> 10004433477200726182517873544056418402326985168039465080040800405880945722868
+```
+Aside:  What's Base 6? Let's Roll the Dice
+An important part of creating a private key is ensuring the random number
+is truly random.
+Physical randomness is better than computer generated pseudo-randomness.
+The easiest way to generate physical randomness is with a dice.
+To create a private key you only need one six-sided die
+which you roll ninety nine times.
+Stopping each time to record the value of the die.
+When recording the values follow these rules: 1=1, 2=2, 3=3, 4=4, 5=5, 6=0.
+By doing this you are recording the big random number, your private key,
+in base 6 format.
+``` ruby
+def roll_dice
+  SecureRandom.random_number( 6 ) ##  returning 0,1,2,3,4, or 5
+end
+priv_base6 = 99.times.reduce('') { |buf,_| buf << roll_dice.to_s }
+#=> "413130205513310000115530450343345150251504444013455422453552225503020102150031231134314351124254004"
+```
+Exercise:
+Turn the ninety nine character base 6 private key into a base 10 or base 16 number.
+``` ruby
+priv = priv_base6.to_i(6)  ## convert to decimal (base 10) from roll-the-dice (base 6) string
+#=> 77254760463198588454157792320308725646096652667800343330432100522222375944308
+priv.to_s(16)
+#=> "aacca516ccbf72dac2c4c447b9f64d12855685e99810ffcf7763a12da6c04074"
+```
+Aside:  What's Base 2? Let's Flip A Coin - Heads or Tails?
+Triva Quiz: For an (unsigned) 256-bit number - how many times
+do you need to flip the coin?
+#### Step 2 - Let's derive / calculate the public key from the private key - Enter elliptic curve (EC) cryptography
+The public key (`K`) are two numbers (that is, a point with the coordinates x and y) computed by multiplying
+the generator point (`G`) of the curve with the private key (`k`) e.g. `K=k*G`.
+This is equivalent to adding the generator to itself `k` times.
+Magic?
+Let's try:
+``` ruby
+# note: by default uses Secp256k1 curve (used in Bitcoin)
+private_key = EC::PrivateKey.new( 50303382071965675924643368363408442017264130870580001935435312336103014915707 )
+public_key =  private_key.public_key   ## the "magic" one-way K=k*G curve multiplication (K=public key,k=private key, G=generator point)
+point = public_key.point
+point.x
+#=> 17761672841523182714332746445483761684317159074072585653954580096478387916431
+point.y
+#=> 81286693084077906561204577435230199871025343781583806206090259868058973358862
+```
+and convert the point to the compressed or uncompressed
+Standards for Efficient Cryptography (SEC)
+format used in Bitcoin:
+``` ruby
+point.to_s( :compressed )
+#=> "022744c02580b4905349bc481a60c308c2d98d823d44888835047f6bc5c38c4e8f"
+point.to_s( :uncompressed )
+#=> "042744c02580b4905349bc481a60c308c2d98d823d44888835047f6bc5c38c4e8fb3b6a34b90a571f6c2a1113dd5ff4576f61bbf3e970a6e148fa02bf9eb7bcb0e"
+```
+References
+- [Private key @ Learn me a bitcoin](https://learnmeabitcoin.com/technical/private-key)
+- [Public key @ Learn me a bitcoin](https://learnmeabitcoin.com/technical/public-key)
+### 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 in compressed format)
+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 Bitcoin 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 in compressed format)
+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 Bitoin 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)
+### Encode the Bitcoin Private Key in the Wallet Import Format (WIF)
+A Wallet Import Format (WIF) private key is a standard private key, but with a few added extras:
+- Version Byte prefix - The network the private key is to be used on.
+  - `0x80` = Mainnet
+  - `0xEF` = Testnet
+- Compression Byte suffix (optional) - Flag if the private key is used to create a compressed public key.
+  - `0x01`
+- Checksum - Useful for detecting errors/typos when you type out your private key; calculated using the first 4 bytes of the double sha256 hash `SHA256(SHA256(X))[:4]`.
+This is all then converted to Base58, which shortens the string and makes it easier to transcribe.
+``` ruby
+privatekey  = "ef235aacf90d9f4aadd8c92e4b2562e1d9eb97f0df9ba3b508258739cb013db2"
+extended = "80" + privatekey + "01"
+#=> "80ef235aacf90d9f4aadd8c92e4b2562e1d9eb97f0df9ba3b508258739cb013db201"
+checksum = hash256( extended )[0..7]
+#=> "66557e53"
+extendedchecksum = extended + checksum
+#=> "80ef235aacf90d9f4aadd8c92e4b2562e1d9eb97f0df9ba3b508258739cb013db20166557e53"
+wif = base58( extendedchecksum )
+#=> "L5EZftvrYaSudiozVRzTqLcHLNDoVn7H5HSfM9BAN6tMJX8oTWz6"
+```
+Or let's try again with the base58check (`BASE58(X || SHA256(SHA256(X))[:4])`) shortcut helper:
+``` ruby
+privatekey = "ef235aacf90d9f4aadd8c92e4b2562e1d9eb97f0df9ba3b508258739cb013db2"
+extended   = "80" + privatekey + "01"
+#=> "80ef235aacf90d9f4aadd8c92e4b2562e1d9eb97f0df9ba3b508258739cb013db201"
+wif = base58check( extended )
+#=> "L5EZftvrYaSudiozVRzTqLcHLNDoVn7H5HSfM9BAN6tMJX8oTWz6"
+```
+References
+- [How to create a WIF private key @ Learn me a bitcoin](https://learnmeabitcoin.com/technical/wif)
+- [Private key to WIF @ Wallet import format](https://en.bitcoin.it/wiki/Wallet_import_format)
+Bonus:  Bitcon Tip - How to Buy Bitcoin (The CO₂-Friendly Way)
+> 1. Take one $50 bill, five $10 bills, or ten $5 bills (I wouldn't recommend change - stay with paper money).
+> 2. Go to the bathroom.
+> 3. Lift the lid of the loo.
+> 4. Throw money in.
+> 5. Flush down water.
+>
+> Congrats! You just purchased $50 worth of Bitcoin - without fucking the planet!
+>
+>  -- Trolly McTrollface, Bitcon Greater Fool Court Jester
+Read more [Crypto Quotes »](https://github.com/openblockchains/crypto-quotes)
+## Dodge
+> Even fun money is money, and a toy cryptocurrency can be turned into real money;
+> the supply of gullibility is deep, if not infinite.
+> So the shibes started dreaming of getting rich for free...
+>
+>  -- David Gerard,  [Confused About Dogecoin? Here's How It (Doesn't) Work](https://foreignpolicy.com/2021/02/11/dogecoin-how-does-it-work-elon-musk-cryptocurrency/)
+>
+>
+> Dogecoin is the people's crypto.
+> The future currency of earth and mars. Much wow!
+>
+> -- Elon Musk, [February 2021](https://twitter.com/elonmusk/status/1357241340313141249)
+<!--
+ sources:
+ https://twitter.com/elonmusk/status/1357241340313141249
+ https://twitter.com/elonmusk/status/1357914696645414913
+ https://twitter.com/elonmusk/status/1357902434580918274
+-->
+### Derive the Dodge (Elliptic Curve) Public Key from the Private Key
+Short version:  Same as in Ethereum, Bitcoin, Litecoin
+Long version:
+A private key in dodge is a 32-byte (256-bit) unsigned / positive integer number.
+Or more precise the private key is a random number between 1
+and the order of the elliptic curve secp256k1.
+``` ruby
+EC::SECP256K1.order
+#=> 115792089237316195423570985008687907852837564279074904382605163141518161494337
+# or in hexadecimal (base16)
+EC::SECP256K1.order.to_s(16)
+#=> "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"
+```
+#### Step 1 - Let's generate a private key
+``` ruby
+private_key = EC::PrivateKey.generate     # alice
+private_key.to_i
+#=> 50303382071965675924643368363408442017264130870580001935435312336103014915707
+private_key.to_s
+#=> "6f36b48dd130618049ca27e1909debdf3665cf0df0ade0986f0c50123107de7b"
+private_key = EC::PrivateKey.generate     # bob
+private_key.to_i
+#=> 96396065671557366547785856940504404648366202869823009146014078671352808008442
+private_key.to_s
+#=> "d51e3d5ce8fbc6e574cf78d1c46e8936c26f38b002b954d0eac8aef195d6eafa"
+```
+#### Step 2 - Let's derive / calculate the public key from the private key - Enter elliptic curve (EC) cryptography
+The public key (`K`) are two numbers (that is, a point with the coordinates x and y) computed by multiplying
+the generator point (`G`) of the curve with the private key (`k`) e.g. `K=k*G`.
+This is equivalent to adding the generator to itself `k` times.
+Magic?
+Let's try:
+``` ruby
+# note: by default uses Secp256k1 curve (used in Dodge)
+private_key = EC::PrivateKey.new( 50303382071965675924643368363408442017264130870580001935435312336103014915707 )
+public_key =  private_key.public_key   ## the "magic" one-way K=k*G curve multiplication (K=public key,k=private key, G=generator point)
+point = public_key.point
+point.x
+#=> 17761672841523182714332746445483761684317159074072585653954580096478387916431
+point.y
+#=> 81286693084077906561204577435230199871025343781583806206090259868058973358862
+```
+and convert the point to the compressed or uncompressed
+Standards for Efficient Cryptography (SEC)
+format used in Dodge:
+``` ruby
+point.to_s( :compressed )
+#=> "022744c02580b4905349bc481a60c308c2d98d823d44888835047f6bc5c38c4e8f"
+point.to_s( :uncompressed )
+#=> "042744c02580b4905349bc481a60c308c2d98d823d44888835047f6bc5c38c4e8fb3b6a34b90a571f6c2a1113dd5ff4576f61bbf3e970a6e148fa02bf9eb7bcb0e"
+```
+### Generate the Dodge Address from the (Elliptic Curve) Public Key
+Short version:
+Same as bitcoin or litecoin.
+Only difference - Add the version byte `0x1e` prefix for Dodge Main Network - P2PKH (pay to public key hash).
+Long version:
+Let's use the shortcut hash function helpers:
+- `HASH160     -  RMD160(SHA256(X))`
+- `BASE58CHECK -  BASE58(X || SHA256(SHA256(X))[:4])`
+``` ruby
+# Lets start with the public key ("raw" hex string encoded in compressed format)
+pk = "022744c02580b4905349bc481a60c308c2d98d823d44888835047f6bc5c38c4e8f"
+# 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 )
+#=> "a1f37969bcb547cd9c3a28fa07c2269ef813340a"
+# 2. Add version byte in front of RIPEMD-160 hash (0x1e for Dodge Main Network)
+step2 = "1e" + step1
+#=> "1ea1f37969bcb547cd9c3a28fa07c2269ef813340a"
+# 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 Dodge Address.
+#    e) Convert the result from a byte string into a base58 string
+#       using Base58 encoding.
+#       This is the most commonly used Dodge Address format.
+addr  = base58check( step2 )
+#=> "DKuR12onkdp5GxC5c8DgXhGe4Z2AqCK3Xh"
+```
+## Litecoin
+### Derive the Litecoin (Elliptic Curve) Public Key from the Private Key
+Short version:  Same as in Ethereum, Bitcoin, Dodge.
+### Generate the Litecoin Address from the (Elliptic Curve) Public Key
+Short version:  Same as in Bitcoin or Dodge.
+Only difference - Add the version byte `0x30` prefix for Litecoin Main Network - P2PKH (pay to public key hash).
+## Ethereum
+### Derive the Ethereum (Elliptic Curve) Public Key from the Private Key
+A private key in ethereum is a 32-byte (256-bit) unsigned / positive integer number.
+Or more precise the private key is a random number between 1
+and the order of the elliptic curve secp256k1.
+``` ruby
+EC::SECP256K1.order
+#=> 115792089237316195423570985008687907852837564279074904382605163141518161494337
+# or in hexadecimal (base16)
+EC::SECP256K1.order.to_s(16)
+#=> "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"
+```
+Note: A "raw" private key in ethereum is the same as in bitcoin, litecoin, dodge & co using the same elliptic curve secp256k1.
+See [Derive the Bitcoin (Elliptic Curve) Public Key from the Private Key](#derive-the-bitcoin-elliptic-curve-public-key-from-the-private-key) above.
+#### Step 1 - Let's generate a private key
+``` ruby
+private_key = EC::PrivateKey.generate     # alice
+private_key.to_i
+#=> 50303382071965675924643368363408442017264130870580001935435312336103014915707
+private_key.to_s
+#=> "6f36b48dd130618049ca27e1909debdf3665cf0df0ade0986f0c50123107de7b"
+private_key = EC::PrivateKey.generate     # bob
+private_key.to_i
+#=> 96396065671557366547785856940504404648366202869823009146014078671352808008442
+private_key.to_s
+#=> "d51e3d5ce8fbc6e574cf78d1c46e8936c26f38b002b954d0eac8aef195d6eafa"
+```
+Or use your own (secure) random number.
+Let's follow along the example
+in the [Mastering Ethereum book](https://github.com/ethereumbook/ethereumbook/blob/develop/04keys-addresses.asciidoc#generating-a-private-key-from-a-random-number) and let's use the random number:
+`0xf8f8a2f43c8376ccb0871305060d7b27b0554d2cc72bccf41b2705608452f315`.
+``` ruby
+private_key = EC::PrivateKey.new( 0xf8f8a2f43c8376ccb0871305060d7b27b0554d2cc72bccf41b2705608452f315 )
+private_key.to_i
+#=> 112612889188223089164322846106333497020645518262799935528047458345719983960853
+private_key.to_s
+#=> "f8f8a2f43c8376ccb0871305060d7b27b0554d2cc72bccf41b2705608452f315"
+```
+#### Step 2 - Let's derive / calculate the public key from the private key - Enter elliptic curve (EC) cryptography
+The public key (`K`) are two numbers (that is, a point with the coordinates x and y) computed by multiplying
+the generator point (`G`) of the curve with the private key (`k`) e.g. `K=k*G`.
+This is equivalent to adding the generator to itself `k` times.
+Magic?
+Let's try:
+``` ruby
+# note: by default uses Secp256k1 curve (used in Ethereum)
+private_key = EC::PrivateKey.new( 0xf8f8a2f43c8376ccb0871305060d7b27b0554d2cc72bccf41b2705608452f315 )
+public_key =  private_key.public_key   ## the "magic" one-way K=k*G curve multiplication (K=public key,k=private key, G=generator point)
+point = public_key.point
+point.x
+#=> 17761672841523182714332746445483761684317159074072585653954580096478387916431
+point.y
+#=> 81286693084077906561204577435230199871025343781583806206090259868058973358862
+# or in hexa(decimal) - base 16
+point.x.to_s(16)
+#=> "6e145ccef1033dea239875dd00dfb4fee6e3348b84985c92f103444683bae07b"
+point.y.to_s(16)
+#=> "83b5c38e5e2b0c8529d7fa3f64d46daa1ece2d9ac14cab9477d042c84c32ccd0"
+```
+and convert the point to the raw uncompressed
+format used in Ethereum:
+``` ruby
+## add together the two points (x,y) in a hex string
+"%64x%64x" % [point.x, point.y]
+#=> "6e145ccef1033dea239875dd00dfb4fee6e3348b84985c92f103444683bae07b83b5c38e5e2b0c8529d7fa3f64d46daa1ece2d9ac14cab9477d042c84c32ccd0"
+# or
+("%64x" % point.x) + ("%64x" % point.y)
+#=> "6e145ccef1033dea239875dd00dfb4fee6e3348b84985c92f103444683bae07b83b5c38e5e2b0c8529d7fa3f64d46daa1ece2d9ac14cab9477d042c84c32ccd0"
+```
+References
+- [Keys and Addresses in Mastering Ethereum](https://github.com/ethereumbook/ethereumbook/blob/develop/04keys-addresses.asciidoc#keys-and-addresses)
+### Generate the Ethereum Address from the (Elliptic Curve) Public Key
+Let's again follow along the example
+in the [Mastering Ethereum book](https://github.com/ethereumbook/ethereumbook/blob/develop/04keys-addresses.asciidoc#ethereum-addresses) and let's (re)use the public key (from above):
+Step 1: Use the keccak256 hashing function
+to calculate the hash of the public key
+``` ruby
+pub = "6e145ccef1033dea239875dd00dfb4fee6e3348b84985c92f103444683bae07b83b5c38e5e2b0c8529d7fa3f64d46daa1ece2d9ac14cab9477d042c84c32ccd0"
+hash = keccak256( pub )
+#=> "2a5bc342ed616b5ba5732269001d3f1ef827552ae1114027bd3ecf1f086ba0f9"
+```
+Step 2: Keep only the last 20 bytes (least significant bytes), this is the ethereum address
+``` ruby
+hash[24,40]    ## last 20 bytes of 32 (skip first 12 bytes (12x2=24 hex chars))
+hash[-40..-1]  ## -or- last 20 bytes (40 hex chars)
+hash[-40,40]   ## -or- last 20 bytes (40 hex chars)
+#=> "001d3f1ef827552ae1114027bd3ecf1f086ba0f9"
+```
+Note: Most often you will see ethereum addresses with the prefix `0x` that indicates
+they are hexadecimal-encoded, like this: `0x001d3f1ef827552ae1114027bd3ecf1f086ba0f9`.
+References
+- [Keys and Addresses in Mastering Ethereum](https://github.com/ethereumbook/ethereumbook/blob/develop/04keys-addresses.asciidoc#keys-and-addresses)
+## Install
+Just install the gem:
+    $ gem install crypto-lite
+## License
+The scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.
+## Questions? Comments?
+Send them along to the [wwwmake forum](http://groups.google.com/group/wwwmake).
+Thanks!