base58-alphabets 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 000b32a445c54f6eb556e6b6c3804bfa2d4df87c1caef2ff001b10a714b38403
-  data.tar.gz: 2984225c57d1514eb716eaddfb07d66079ba7edcfacf9f722ecfcf22e84015e0
+  metadata.gz: 8735c482bb9af50045ac3bff88b5418b6e5960e03ea08c58f683063ffefae1ee
+  data.tar.gz: 5125cf91554db05f2036f6c9405c36bcaf87de991f9738f255a63228e916aa9d
 SHA512:
-  metadata.gz: 9a71c550deb538e9928a743103435b5ac7c4f544e7d806529a84a52d4e76ff9ee49ccab0d33602a5deff93511dc92dede5e954697aa9cce59eef4c9da3c118dd
-  data.tar.gz: 579c12f8837066b4f4265df52ff36108341a6d290a60d152a195d532171b7fa92cc0d2da58039cd1ce4babe5ab1ac90e85865619cf01ce251193d55cd5b16ead
+  metadata.gz: fc8da02281febbb8cea46a5c9f7b7c304fcfbff15ea22568195ee12f2d577870e8d2dabf358475de7b36b4e427a720b41e198ca965de2b9e4c1c1de1e4c44dd0
+  data.tar.gz: e5eb2757f961cdb42b5dc8b38796740ee9347ba9d0dcf49244c385468bf3ab8e51ad74a3e3793083961117a6bcf71a0ba61117231bff2a449a431469d5afd695

data/Manifest.txt

@@ -6,6 +6,9 @@ lib/base58-alphabets.rb
 lib/base58-alphabets/base.rb
 lib/base58-alphabets/base58.rb
 lib/base58-alphabets/bitcoin.rb
+lib/base58-alphabets/flickr.rb
 lib/base58-alphabets/version.rb
 test/helper.rb
 test/test_base58_bitcoin.rb
+test/test_base58_flickr.rb
+test/test_bytes.rb

data/README.md

@@ -1,6 +1,6 @@
 # Base58 Encoding / Decoding
 
-Encode / decode numbers with Bitcoin or Flickr base58 notation / alphabet
+Encode / decode numbers, hex or binary strings (incl. leading zeros) with Bitcoin or Flickr base58 notation / alphabet
 
 
 * home  :: [github.com/rubycoco/blockchain](https://github.com/rubycoco/blockchain)
@@ -11,31 +11,22 @@ Encode / decode numbers with Bitcoin or Flickr base58 notation / alphabet
 
 
 
-## What's Base 58?
-
+## Base58 Alphabets
 
-> Similar to Base64, but modified to avoid both non-alphanumeric
-> characters (`+` and `/`) and letters which might look ambiguous
-> when printed (`0` - zero, `I` - capital i, `O` - capital o and `l` - lower case L).
-> Satoshi Nakamoto invented the base58 encoding scheme when creating bitcoin.
-> Some messaging and social media systems line break on non-alphanumeric
-> strings. This is avoided by not using URI reserved characters such as `+`.
->
-> (Source: [Base58 @ Wikipedia](https://en.wikipedia.org/wiki/Binary-to-text_encoding#Base58))
+[Bitcoin](#bitcoin) •
+[Flickr](#flickr)
 
 
 
-## Bitcoin
+### Bitcoin
 
 The bitcoin notation / alphabet (`123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`)
 
+The order of it's 58 characters is numeric, uppercase-alpha, lowercase-alpha.
 
-Triva Quiz: What characters (digits/letters) are
-missing in the base 56 alphabets?
 
--  `0` (Zero), `O` (Upper-O), `I` (Upper-I), `l` (Lower-L)
 
-Why use base56 (and not "standard" base64)?
+Why use base58 (and not "standard" base64)?
 
 ```
 // - Don't want 0OIl characters that look the same in some fonts and
@@ -49,7 +40,7 @@ Why use base56 (and not "standard" base64)?
 
 
 
-### Bitcoin (Base58) Notation
+#### Bitcoin (Base58) Notation
 
 |Num  |Character  |Num  |Character  |Num  |Character  |Num  |Character|
 |----:|----------:|----:|----------:|----:|----------:|----:|--------:|
@@ -69,7 +60,159 @@ Why use base56 (and not "standard" base64)?
 | 52  | **u**     |  53 | **v**     |  54 | **w**     |  55 | **x**   |
 | 56  | **y**     |  57 | **z**     |
 
+Note: `0` (Zero), `O` (Upper-O), `I` (Upper-I), `l` (Lower-L) - these four characters (digits/letters) are
+missing in the base 58 alphabets.
+
+
+**Usage**
+
+
+Encode / Decode Numbers
+
+```ruby
+require 'base58-alphabets'
+
+Base58.encode_num( 100 )        #=> "2j"
+Base58.encode_num( 123456789 )  #=> "BukQL"
+
+Base58.decode_num( "2j")        #=> 100
+Base58.decode_num( "BukQL" )    #=> 123456789
+
+# or
+
+Base58::Bitcoin.encode_num( 100 )        #=> "2j"
+Base58::Bitcoin.encode_num( 123456789 )  #=> "BukQL"
+
+Base58::Bitcoin.decode_num( "2j")        #=> 100
+Base58::Bitcoin.decode_num( "BukQL" )    #=> 123456789
+```
+
+Encode / Decode Hex Strings
+
+```ruby
+Base58.encode_hex( "626262" )      #=> "a3gV"
+# Note: The `0x` or `0X` hex prefix is optional.
+Base58.encode_hex( "0x626262" )    #=> "a3gV"
+Base58.encode_hex( "0X626262" )    #=> "a3gV"
+Base58.encode_hex( "516b6fcd0f" )  #=> "ABnLTmg"
+
+Base58.decode_hex( "a3gV" )      #=> "626262"
+Base58.decode_hex( "ABnLTmg" )   #=> "516b6fcd0f"
+
+# or
+
+Base58::Bitcoin.encode_hex( "626262" )      #=> "a3gV"
+Base58::Bitcoin.encode_hex( "516b6fcd0f" )  #=> "ABnLTmg"
+
+Base58::Bitcoin.decode_hex( "a3gV" )      #=> "626262"
+Base58::Bitcoin.decode_hex( "ABnLTmg" )   #=> "516b6fcd0f"
+```
+
+
+What about leading zeros?
+
+Yes, if you use a hex or binary string - the leading zero bytes
+will get encoded / decoded (converted from `00` to `1` and back):
+
+```ruby
+Base58.encode_hex( "00000000000000000000" ) #=> "1111111111"
+Base58.encode_hex( "00000000000000000000123456789abcdef0" ) #=> "111111111143c9JGph3DZ"
+
+Base58.decode_hex( "1111111111" )  #=> "00000000000000000000"
+Base58.decode_hex( "111111111143c9JGph3DZ" )  #=> "00000000000000000000123456789abcdef0"
+```
+
+
+
+Encode / Decode Bin(ary) Strings
+
+```ruby
+Base58.encode_bin( "\xCE\xE99\x86".b )   #=>  "6Hknds"
+
+Base58.decode_bin( "6Hknds" )   #=> "\xCE\xE99\x86"
+
+# or
+
+Base58::Bitcoin.encode_bin( "\xCE\xE99\x86".b )   #=>  "6Hknds"
+
+Base58::Bitcoin.decode_bin( "6Hknds" )   #=> "\xCE\xE99\x86"
+```
+
+
+
+
+### Flickr
+
+The flickr notation / alphabet (`123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ`)
+
+The order of it's 58 characters is numeric, lowercase-alpha, uppercase-alpha.
+
+
+
+Encode / Decode Numbers
+
+```ruby
+Base58.format = :flickr    # switch to flickr alphabet (default is bitcoin)
+
+Base58.encode_num( 12345 )     #=> "4ER"
+
+Base58.decode_num( "4ER" )     #=> 12345
+
+# or
+
+Base58::Flickr.encode_num( 12345 )     #=> "4ER"
+
+Base58::Flickr.decode_num( "4ER" )     #=> 12345
+```
+
+
+That's it.
+
+
+
+## What's Base 58?
+
+The number of characters you are left with when you use
+all the characters in the alphanumeric alphabet,
+but remove all the easily mistakable characters like `0`, `O`, `l` and `I`
+is... 58.
+
+alphanumeric = `0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz` (62 characters)
+
+base58       = ` 123456789ABCDEFGH JKLMN PQRSTUVWXYZabcdefghijk mnopqrstuvwxyz` (58 characters)
+
+
+
+From the Wikipedia:
+
+> Similar to Base64, but modified to avoid both non-alphanumeric
+> characters (`+` and `/`) and letters which might look ambiguous
+> when printed (`0` - zero, `I` - capital i, `O` - capital o and `l` - lower case L).
+> Satoshi Nakamoto invented the base58 encoding scheme when creating bitcoin.
+> Some messaging and social media systems line break on non-alphanumeric
+> strings. This is avoided by not using URI reserved characters such as `+`.
+>
+> (Source: [Base58 @ Wikipedia](https://en.wikipedia.org/wiki/Binary-to-text_encoding#Base58))
+
+
+
+Why use base58?
+
+The more characters you have in your base, the less you will need to use to represent big numbers.
+The bigger your base, the shorter your "number". Example:
+
+``` ruby
+base10( 9999 )  #=> 9999      - decimal
+base16( 9999 )  #=> 270f      - hexadecimal
+base58( 9999 )  #=> 3yQ
+```
+
+
+## Install
+
+Just install the gem:
 
+    $ gem install base58-alphabets
 
 
 

data/Rakefile

@@ -5,7 +5,7 @@ Hoe.spec 'base58-alphabets' do
 
   self.version = Base58::VERSION
 
-  self.summary = "base58-alphabets - base58 encoding / decoding with bitcoin or flickr notation / alphabet"
+  self.summary = "base58-alphabets - base58 encoding / decoding numbers, hex or binary strings (incl. leading zeros) with bitcoin or flickr notation / alphabet"
   self.description = summary
 
   self.urls    = { home: 'https://github.com/rubycoco/blockchain' }

data/lib/base58-alphabets.rb

@@ -8,6 +8,7 @@ require 'base58-alphabets/version'    # note: let version always go first
 
 require 'base58-alphabets/base'
 require 'base58-alphabets/bitcoin'
+require 'base58-alphabets/flickr'
 require 'base58-alphabets/base58'
 
 

data/lib/base58-alphabets/base.rb

@@ -5,37 +5,115 @@
 module Base58
 class Base
 
-  # Converts a base10 integer to a base58 string.
-  def self.encode( num_or_bytes )
-    if num_or_bytes.is_a?( Array )
-      bytes = num_or_bytes
-    else
-      num = num_or_bytes
-      bytes = Base58._bytes( num )
-    end
+  BASE = 58    #  ALPHABET.length == 58   ## 58 chars/letters/digits
+
+  ## check if it is a hex (string)
+  ##  - allow optiona 0x or 0X  and allow abcdef and ABCDEF
+  HEX_RE = /\A(?:0x)?[0-9a-f]+\z/i
+
+
 
-    bytes.reduce( String.new ) do |buf, byte|
+  # Converts a base10 integer to a base58 string.
+  def self.encode_num( num )   ## num_to_base58 / int_to_base58
+    _bytes( num ).reduce( String.new ) do |buf, byte|
       buf << alphabet[byte]
       buf
     end
   end
 
 
+  # Converts binary string into its Base58 representation.
+  # If string is empty returns an empty string.
+  def self.encode_bin( data )   ## todo/check: add alias such as bin_to_base58 / data_to_base58 - why? why not?
+    leading_zeroes = 0
+    num = 0
+    base = 1
+    data.bytes.reverse_each do |byte|
+        if byte == 0
+          leading_zeroes += 1
+        else
+          leading_zeroes = 0
+          num += base*byte
+        end
+        base *= 256
+    end
+
+    (alphabet[0]*leading_zeroes) + encode_num( num )
+  end
+
+
+  # Converts hex string into its Base58 representation.
+  def self.encode_hex( str )
+    ## todo/check: allow empty string ("") - why? why not?
+    raise ArgumentError, "expected hex string (0-9a-f) - got >#{str}< - can't pack string; sorry"   unless str =~ HEX_RE || str.empty?
+
+    str = _strip0x( str )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
+    encode_bin( [str].pack('H*') )
+  end
+
+
+
+
   # Converts a base58 string to a base10 integer.
-  def self.decode( str_or_bytes )
-    if str_or_bytes.is_a?( Array )
-      bytes = str_or_bytes
-    else  ## assume string
-      str   = str_or_bytes
-      bytes = str.each_char.reduce([]) do |bytes,char|
-                                         byte = number[char]
-                                         raise ArgumentError, "Value passed not a valid base58 string - >#{char}< not found in alphabet"  if byte.nil?
-                                         bytes << byte
-                                         bytes
-                                       end
+  def self.decode_num( str )     ## todo/check: add alias base58_to_num / base58_to_int
+    bytes = str.each_char.reduce([]) do |bytes,char|
+                 byte = number[char]
+                 raise ArgumentError, "Value passed not a valid base58 string - >#{char}< not found in alphabet"  if byte.nil?
+                 bytes << byte
+                 bytes
+            end
+    _pack( bytes )
+  end
+
+
+  def self.decode_bin( str )
+    num = decode_num( str )
+
+    ## use base 256 for characters to binary conversion!!!
+    data = _bytes( num, base: 256 ).pack( 'C*' )
+
+    ## check for leading zeros
+    str.bytes.each do |byte|
+      break if byte != alphabet[0].ord
+      data = "\x00" + data
     end
-    Base58._pack( bytes )
+    data
+  end
+
+  def self.decode_hex( str )
+    decode_bin( str ).unpack( 'H*' )[0]
   end
 
+
+
+
+  ####
+  # (private) helper - note: leading underscore in name e.g. _bytes
+  def self._bytes( num, base: BASE )   ## num_to_bytes
+    ## note: 0 leads to empty []  and NOT [0] !!!!
+    b = []
+    while num > 0
+      num, mod = num.divmod( base )
+      b << mod
+    end
+    b = b.reverse
+    b
+  end
+
+
+  def self._pack( bytes )   ## bytes_to_num
+    num = 0
+    bytes.reverse.each_with_index do |byte,index|
+      num += byte * (BASE**(index))
+    end
+    num
+  end
+
+
+  def self._strip0x( str )    ## todo/check: add alias e.g. strip_hex_prefix or such - why? why not?
+    (str[0,2] == '0x' || str[0,2] == '0X') ?  str[2..-1] : str
+  end
+
+
 end # class Base
 end # module Base58

data/lib/base58-alphabets/base58.rb

@@ -1,12 +1,10 @@
 module Base58
 
-  BASE = 58    #  ALPHABET.length == 58   ## 58 chars/letters/digits
-
   class Configuration
 
      MAPPING = {
        bitcoin:    Bitcoin,
-       ## flickr:     Flickr,
+       flickr:     Flickr,
      }
 
      attr_reader :format
@@ -44,38 +42,15 @@ module Base58
 
 
 
-  def self.encode( num_or_bytes, klass: configuration.format )
-    klass.encode( num_or_bytes )
-  end
-
-  def self.decode( str_or_bytes, klass: configuration.format )
-    klass.decode( str_or_bytes )
-  end
-
-
+  def self.encode_num( num,  klass: configuration.format ) klass.encode_num( num );  end
+  def self.encode_bin( data, klass: configuration.format ) klass.encode_bin( data ); end
+  def self.encode_hex( str,  klass: configuration.format ) klass.encode_hex( str );  end
 
+  def self.decode_num( str,  klass: configuration.format ) klass.decode_num( str ); end
+  def self.decode_bin( str,  klass: configuration.format ) klass.decode_bin( str ); end
+  def self.decode_hex( str,  klass: configuration.format ) klass.decode_hex( str ); end
 
-  ####
-  # (private) helper - note: leading underscore in name e.g. _bytes
-  def self._bytes( num )
-    b = []
-    while num >= BASE
-      mod = num % BASE
-      b << mod
-      num = (num - mod) / BASE
-    end
-    b << num
-    b = b.reverse
-    b
-  end
 
-  def self._pack( bytes )
-    num = 0
-    bytes.reverse.each_with_index do |byte,index|
-      num += byte * (BASE**(index))
-    end
-    num
-  end
 
   ## encoding alphabet - letter-to-number by index / array
   def self.alphabet( klass: configuration.format ) klass.alphabet; end

data/lib/base58-alphabets/flickr.rb

@@ -0,0 +1,85 @@
+
+
+module Base58
+class Flickr < Base
+
+ALPHABET = %w[ 1 2 3 4 5 6 7 8 9
+               a b c d e f g h i j k   m n o p q r s t u v w x y z
+               A B C D E F G H   J K L M N   P Q R S T U V W X Y Z ]
+
+
+def self.alphabet() ALPHABET; end    ## add alpha / char aliases - why? why not?
+
+## Note:
+##   for decoding allow (misspelled) l/I for 1  - why? why not?
+##    and               (misspelled) 0/O for o  - why? why not?
+
+
+NUMBER = {
+  '1' => 0,   ## 'l' => 0, 'I' => 0,
+  '2' => 1,
+  '3' => 2,
+  '4' => 3,
+  '5' => 4,
+  '6' => 5,
+  '7' => 6,
+  '8' => 7,
+  '9' => 8,
+  'a' => 9,
+  'b' => 10,
+  'c' => 11,
+  'd' => 12,
+  'e' => 13,
+  'f' => 14,
+  'g' => 15,
+  'h' => 16,
+  'i' => 17,
+  'j' => 18,
+  'k' => 19,
+  'm' => 20,
+  'n' => 21,
+  'o' => 22,   ## '0' => 22, 'O' => 22,
+  'p' => 23,
+  'q' => 24,
+  'r' => 25,
+  's' => 26,
+  't' => 27,
+  'u' => 28,
+  'v' => 29,
+  'w' => 30,
+  'x' => 31,
+  'y' => 32,
+  'z' => 33,
+  'A' => 34,
+  'B' => 35,
+  'C' => 36,
+  'D' => 37,
+  'E' => 38,
+  'F' => 39,
+  'G' => 40,
+  'H' => 41,
+  'J' => 42,
+  'K' => 43,
+  'L' => 44,
+  'M' => 45,
+  'N' => 46,
+  'P' => 47,
+  'Q' => 48,
+  'R' => 49,
+  'S' => 50,
+  'T' => 51,
+  'U' => 52,
+  'V' => 53,
+  'W' => 54,
+  'X' => 55,
+  'Y' => 56,
+  'Z' => 57,
+}
+
+def self.number() NUMBER; end        ## add num alias - why? why not?
+
+## add shortcuts (convenience) aliases
+NUM = NUMBER
+
+end # class Flickr
+end # module Base58

data/lib/base58-alphabets/version.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
 module Base58
-  MAJOR = 0
-  MINOR = 1
+  MAJOR = 1
+  MINOR = 0
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 

data/test/test_base58_bitcoin.rb

@@ -8,25 +8,99 @@ require 'helper'
 
 class TestBase58Bitcoin < MiniTest::Test
 
+NUM_TESTS = [
+  [100,        "2j"],
+  [12345,      "4fr"],
+  [6639914,    "b2pH"],
+  [123456789,  "BukQL"],
 
-def test_bitcoin
-  assert_equal "2j",     Base58::Bitcoin.encode( 100 )
-  assert_equal "4fr",    Base58::Bitcoin.encode( 12345 )
-  assert_equal "b2pH",   Base58::Bitcoin.encode( 6639914 )
+  [3471391110, "6Hknds"],
+  [3470152229, "6HeSMr"],
+  [3470988633, "6Hiizc"],
+  [3470993664, "6HikVM"],
+  [3471485480, "6HmGgw"],
+  [3469844075, "6Hcrkr"],
+]
 
-  assert_equal 100,      Base58::Bitcoin.decode( "2j" )
-  assert_equal 12345,    Base58::Bitcoin.decode( "4fr" )
-  assert_equal 6639914,  Base58::Bitcoin.decode( "b2pH" )
+HEX_TESTS = [
+  ["",  ""],
+  ["00","1"],
+  ["00000000000000000000", "1111111111"],
+  ["00000000000000000000123456789abcdef0", "111111111143c9JGph3DZ"],
+  ["13", "L"],
+  ["2e", "o"],
+  ["61", "2g"],
+  ["626262", "a3gV"],
+  ["636363", "aPEr"],
+  ["73696d706c792061206c6f6e6720737472696e67", "2cFupjhnEsSn59qHXstmK2ffpLv2"],
+  ["00eb15231dfceb60925886b67d065299925915aeb172c06647", "1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L"],
+  ["0093ce48570b55c42c2af816aeaba06cfee1224faebb6127fe", "1EUXSxuUVy2PC5enGXR1a3yxbEjNWMHuem"],
+  ["516b6fcd0f", "ABnLTmg"],
+  ["bf4f89001e670274dd", "3SEo3LWLoPntC"],
+  ["572e4794", "3EFU7m"],
+  ["ecac89cad93923c02321", "EJDM8drfXA6uyA"],
+  ["10c8511e", "Rt5zm"],
+]
 
 
-  Base58.format = :bitcoin
-  assert_equal "2j",     Base58.encode( 100 )
-  assert_equal "4fr",    Base58.encode( 12345 )
-  assert_equal "b2pH",   Base58.encode( 6639914 )
 
-  assert_equal 100,      Base58.decode( "2j" )
-  assert_equal 12345,    Base58.decode( "4fr" )
-  assert_equal 6639914,  Base58.decode( "b2pH" )
+
+
+BIN_TESTS = [
+   ["\xCE\xE99\x86".b, "6Hknds"],
+   ["\xCE\xD6R%".b,    "6HeSMr"],
+   ["\xCE\xE3\x15Y".b, "6Hiizc"],
+   ["\xCE\xE3)\x00".b, "6HikVM"],
+   ["\xCE\xEA\xAA(".b, "6HmGgw"],
+   ["\xCE\xD1\x9Ek".b, "6Hcrkr"],
+   ["\x01\xAD<l'\xAF!\x96N\x93u\x93\xE2\xAF\x92p\x96=\x89n\xD7\x953\x17\x12\x8E\xBD\xA2\x04\x84~Z".b, "7Ycsh3K7oGpLTcQpNx1h7Z19fVbZ4TXqEYePfdFwDZT"],
+
+   ["".b,   ""],
+   [" ".b, "Z"],
+   ["-".b, "n"],
+   ["0".b, "q"],
+   ["1".b, "r"],
+   ["-1".b, "4SU"],
+   ["11".b, "4k8"],
+   ["abc".b, "ZiCa"],
+   ["1234598760".b, "3mJr7AoUXx2Wqd"],
+   ["abcdefghijklmnopqrstuvwxyz".b, "3yxU3u1igY8WkgtjK92fbJQCd4BZiiT1v25f"],
+   ["00000000000000000000000000000000000000000000000000000000000000".b, "3sN2THZeE9Eh9eYrwkvZqNstbHGvrxSAM7gXUXvyFQP8XvQLUqNCS27icwUeDT7ckHm4FUHM2mTVh1vbLmk7y"],
+  ]
+
+
+
+def test_num
+  NUM_TESTS.each do |item|
+    assert_equal item[1],  Base58::Bitcoin.encode_num( item[0] )
+    assert_equal item[0],  Base58::Bitcoin.decode_num( item[1] )
+
+    Base58.format = :bitcoin
+    assert_equal item[1],  Base58.encode_num( item[0] )
+    assert_equal item[0],  Base58.decode_num( item[1] )
+  end
+end
+
+def test_hex
+  HEX_TESTS.each do |item|
+    assert_equal item[1],  Base58::Bitcoin.encode_hex( item[0] )
+    assert_equal item[0],  Base58::Bitcoin.decode_hex( item[1] )
+
+    Base58.format = :bitcoin
+    assert_equal item[1],  Base58.encode_hex( item[0] )
+    assert_equal item[0],  Base58.decode_hex( item[1] )
+  end
+end
+
+def test_bin
+  BIN_TESTS.each do |item|
+    assert_equal item[1],  Base58::Bitcoin.encode_bin( item[0] )
+    assert_equal item[0],  Base58::Bitcoin.decode_bin( item[1] )
+
+    Base58.format = :bitcoin
+    assert_equal item[1],  Base58.encode_bin( item[0] )
+    assert_equal item[0],  Base58.decode_bin( item[1] )
+  end
 end
 
 

data/test/test_base58_flickr.rb

@@ -0,0 +1,35 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_base58_flickr.rb
+
+
+require 'helper'
+
+
+class TestBase58Flickr < MiniTest::Test
+
+NUM_TESTS = [
+  [3471391110,  "6hKMCS"],
+  [3470152229,  "6hDrmR"],
+  [3470988633,  "6hHHZB"],
+  [3470993664,  "6hHKum"],
+  [3471485480,  "6hLgFW"],
+  [3469844075,  "6hBRKR"],
+  [3470820062,  "6hGRTd"],
+  [3469966999,  "6hCuie"],
+]
+
+
+def test_num
+  NUM_TESTS.each do |item|
+    assert_equal item[1],  Base58::Flickr.encode_num( item[0] )
+    assert_equal item[0],  Base58::Flickr.decode_num( item[1] )
+
+    Base58.format = :flickr
+    assert_equal item[1],  Base58.encode_num( item[0] )
+    assert_equal item[0],  Base58.decode_num( item[1] )
+  end
+end
+
+
+end  # class TestBase58Flickr

data/test/test_bytes.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_bytes.rb
+
+
+require 'helper'
+
+
+class TestBytes < MiniTest::Test
+
+
+def test_bytes
+   bytes = Base58::Base._bytes( 123456789 )
+   ## pp bytes
+
+   assert_equal [10,52,43,23,19], bytes
+
+   assert_equal 123456789, Base58::Base._pack( bytes )
+
+
+   assert_equal 123456789, Base58::Base._pack( Base58::Base._bytes( 123456789 ))
+end
+
+end  # class TestBytes

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: base58-alphabets
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-16 00:00:00.000000000 Z
+date: 2021-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -44,8 +44,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.22'
-description: base58-alphabets - base58 encoding / decoding with bitcoin or flickr
-  notation / alphabet
+description: base58-alphabets - base58 encoding / decoding numbers, hex or binary
+  strings (incl. leading zeros) with bitcoin or flickr notation / alphabet
 email: wwwmake@googlegroups.com
 executables: []
 extensions: []
@@ -62,9 +62,12 @@ files:
 - lib/base58-alphabets/base.rb
 - lib/base58-alphabets/base58.rb
 - lib/base58-alphabets/bitcoin.rb
+- lib/base58-alphabets/flickr.rb
 - lib/base58-alphabets/version.rb
 - test/helper.rb
 - test/test_base58_bitcoin.rb
+- test/test_base58_flickr.rb
+- test/test_bytes.rb
 homepage: https://github.com/rubycoco/blockchain
 licenses:
 - Public Domain
@@ -89,6 +92,6 @@ requirements: []
 rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
-summary: base58-alphabets - base58 encoding / decoding with bitcoin or flickr notation
-  / alphabet
+summary: base58-alphabets - base58 encoding / decoding numbers, hex or binary strings
+  (incl. leading zeros) with bitcoin or flickr notation / alphabet
 test_files: []