Base58Check encoding: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|REXX}}: added REXX version 3 (handles null input, handles leading ones in the hash digest which prepends leading zeros).)
m (added whitespace before the TOC.)
Line 8: Line 8:


The ''reference algorithm'' is at [https://en.bitcoin.it/wiki/Base58Check_encoding#Base58_symbol_chart the Bitcoin's Base58Check page].
The ''reference algorithm'' is at [https://en.bitcoin.it/wiki/Base58Check_encoding#Base58_symbol_chart the Bitcoin's Base58Check page].
<br><br>


=={{header|FreeBASIC}}==
=={{header|FreeBASIC}}==

Revision as of 10:31, 17 November 2017

Base58Check encoding is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

The popular encoding of small and medium-sized checksums is base16, that is more compact than usual base10 and is human readable... For checksums resulting in hash digests bigger than ~100 bits, the base16 is too long: base58 is shorter and (when using good alphabet) preserves secure human readability. The most popular alphabet of base58 is the variant used in bitcoin address (see Bitcoin/address validation), so it is the "default base58 alphabet".

Write a program that takes a checksum (resultant hash digest) integer binary representation as argument, and converts (encode it) into base58 with the standard Bitcoin alphabet — which uses an alphabet of the characters 0 .. 9, A ..Z, a .. z, but without the four characters 0, O, I and l.

The reference algorithm is at the Bitcoin's Base58Check page.

FreeBASIC

Library: GMP

<lang freebasic>' version 14-08-2017 ' compile with: fbc -s console ' uses GMP

  1. Include Once "gmp.bi"

Data "25420294593250030202636073700053352635053786165627414518" ' 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM Data "0x61" ' 2g Data "0x626262" ' a3gV Data "0x636363" ' aPEr Data "0x73696d706c792061206c6f6e6720737472696e67" ' 2cFupjhnEsSn59qHXstmK2ffpLv2 Data "0x516b6fcd0f" ' ABnLTmg Data "0xbf4f89001e670274dd" ' 3SEo3LWLoPntC Data "0x572e4794" ' 3EFU7m Data "0xecac89cad93923c02321" ' EJDM8drfXA6uyA Data "0x10c8511e" ' Rt5zm Data ""

Function conv2base58(decimal As String, _base_ As Integer = 0) As String 

   Dim As String convert
   Dim As String base58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
   Dim As String norm58 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv"
   Dim As ZString Ptr gmp_str : gmp_str = Allocate(1000)
   Dim As Mpz_ptr tmp = Allocate(Len(__mpz_struct)) : Mpz_init(tmp)

   Mpz_set_str(tmp, decimal, _base_)
   Mpz_get_str(gmp_str, 58, tmp)

   convert = *gmp_str

   For i As uinteger = 0 To Len(convert) -1
       convert[i] = base58[InStr(norm58, Chr(convert[i])) -1]
   Next

   Mpz_clear(tmp) : DeAllocate(gmp_str)

   Return convert

End Function

' ------=< MAIN >=------ Dim As String str_in

Print "OkobppXBkab(58) --> "; conv2base58("OkobppXBkab", 58) ' 10687460092462769069(10) Print

Do 

   Read str_in
   If str_in = "" Then Exit Do
   Print str_in;
   If Len(str_in) < 54 Then Print Tab(43);
   Print " --> "; conv2base58(str_in)

Loop

' empty keyboard buffer While Inkey <> "" : Wend Print : Print "hit any key to end program" Sleep End</lang>

Output:
OkobppXBkab(58) --> RosettaCode

25420294593250030202636073700053352635053786165627414518 --> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61                                       --> 2g
0x626262                                   --> a3gV
0x636363                                   --> aPEr
0x73696d706c792061206c6f6e6720737472696e67 --> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f                               --> ABnLTmg
0xbf4f89001e670274dd                       --> 3SEo3LWLoPntC
0x572e4794                                 --> 3EFU7m
0xecac89cad93923c02321                     --> EJDM8drfXA6uyA
0x10c8511e                                 --> Rt5zm

Haskell

<lang haskell>import Numeric (showIntAtBase)

chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

base58Encode :: Integer -> String base58Encode n = showIntAtBase 58 (chars !!) n ""

main :: IO () main = mapM_ (putStrLn . base58Encode) 

       [25420294593250030202636073700053352635053786165627414518,
        0x61,
        0x626262,
        0x636363,
        0x73696d706c792061206c6f6e6720737472696e67,
        0x516b6fcd0f,
        0xbf4f89001e670274dd,
        0x572e4794,
        0xecac89cad93923c02321,
        0x10c8511e]</lang>
Output:
6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
2g
a3gV
aPEr
2cFupjhnEsSn59qHXstmK2ffpLv2
ABnLTmg
3SEo3LWLoPntC
3EFU7m
EJDM8drfXA6uyA
Rt5zm

and for bulk encoding, Array access would be one of various slightly faster alternatives to recursive subscripting of linked lists: <lang Haskell>import Numeric (showIntAtBase) import Data.Array

base58Codes :: (Num i, Ix i) => Array i Char base58Codes = 

 listArray (0, 57) "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

base58Encode :: (Show a, Integral a) => a -> String base58Encode n = showIntAtBase 58 (base58Codes !) n ""

main :: IO () main = 

 mapM_
   (putStrLn . base58Encode)
   [ 25420294593250030202636073700053352635053786165627414518
   , 0x61
   , 0x626262
   , 0x636363
   , 0x73696d706c792061206c6f6e6720737472696e67
   , 0x516b6fcd0f
   , 0xbf4f89001e670274dd
   , 0x572e4794
   , 0xecac89cad93923c02321
   , 0x10c8511e
   ]</lang>
Output:
6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
2g
a3gV
aPEr
2cFupjhnEsSn59qHXstmK2ffpLv2
ABnLTmg
3SEo3LWLoPntC
3EFU7m
EJDM8drfXA6uyA
Rt5zm

Kotlin

<lang scala>// version 1.1.51

import java.math.BigInteger

const val ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" val big0 = BigInteger.ZERO val big58 = BigInteger.valueOf(58L)

fun convertToBase58(hash: String, base: Int = 16): String { 

   var x = if (base == 16 && hash.take(2) == "0x") BigInteger(hash.drop(2), 16)
           else BigInteger(hash, base)
   val sb = StringBuilder()
   while (x > big0) {
       val r = (x % big58).toInt()
       sb.append(ALPHABET[r])
       x = x / big58  
   }
   return sb.toString().reversed()

}

fun main(args: Array<String>) { 

   val s = "25420294593250030202636073700053352635053786165627414518"
   val b = convertToBase58(s, 10)
   println("$s -> $b")
   val hashes = listOf(
       "0x61",
       "0x626262",
       "0x636363",
       "0x73696d706c792061206c6f6e6720737472696e67",
       "0x516b6fcd0f",
       "0xbf4f89001e670274dd",
       "0x572e4794",
       "0xecac89cad93923c02321",
       "0x10c8511e"
   )
   for (hash in hashes) {
       val b58 = convertToBase58(hash)
       println("${hash.padEnd(56)} -> $b58")
   }

}</lang>

Output:
25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61                                                     -> 2g
0x626262                                                 -> a3gV
0x636363                                                 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67               -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f                                             -> ABnLTmg
0xbf4f89001e670274dd                                     -> 3SEo3LWLoPntC
0x572e4794                                               -> 3EFU7m
0xecac89cad93923c02321                                   -> EJDM8drfXA6uyA
0x10c8511e                                               -> Rt5zm

Perl 6

<lang perl6>sub encode_Base58 ( Int $x ) { 

   constant @codes = <
         1 2 3 4 5 6 7 8 9
       A B C D E F G H   J K L M N   P Q R S T U V W X Y Z
       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
   >;

   return @codes[ $x.polymod( 58 xx * ) ].join.flip;

}

my @tests = 

   25420294593250030202636073700053352635053786165627414518 => '6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM',
   0x61                    => '2g',
   0x626262                => 'a3gV',
   0x636363                => 'aPEr',
   0x73696d706c792061206c6f6e6720737472696e67 => '2cFupjhnEsSn59qHXstmK2ffpLv2',
   0x516b6fcd0f            => 'ABnLTmg',
   0xbf4f89001e670274dd    => '3SEo3LWLoPntC',
   0x572e4794              => '3EFU7m',
   0xecac89cad93923c02321  => 'EJDM8drfXA6uyA',
   0x10c8511e              => 'Rt5zm',

use Test; for @tests { 

   is encode_Base58(.key), .value, "{.key} encodes to {.value}";

} </lang>

REXX

version 1

Following the description in https://www.anintegratedworld.com/how-to-manually-calculate-base58check-encoding/ I get the result expected there. Apart for the leading 1 the program works also for the inputs shown above. <lang rexx>/* REXX */ s="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" Numeric Digits 100 k='00010966776006953D5567439E5E39F86A0D273BEED61967F6'x n=c2d(k) o= Do Until n=0 

 rem=n//58
 n=n%58
 o=o||substr(s,rem+1,1)
 End

o=o||substr(s,1,1) Say reverse(o)</lang>

Output:
16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

version 2

does what the others do <lang rexx>/* REXX */ s="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" Numeric Digits 1000 cnt_ok=0 Call test 'N',25420294593250030202636073700053352635053786165627414518,, 

            '6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM'

Call test 'X','61'x ,'2g' Call test 'X','626262'x ,'a3gV' Call test 'X','636363'x ,'aPEr' Call test 'X','73696d706c792061206c6f6e6720737472696e67'x,, 

             '2cFupjhnEsSn59qHXstmK2ffpLv2'

Call test 'X','516b6fcd0f'x ,'ABnLTmg' Call test 'X','bf4f89001e670274dd'x ,'3SEo3LWLoPntC' Call test 'X','572e4794'x ,'3EFU7m' Call test 'X','ecac89cad93923c02321'x ,'EJDM8drfXA6uyA' Call test 'X','10c8511e'x ,'Rt5zm' Call test 'X','10c8511e'x ,'check_error_handlimng' Say cnt_ok 'tests ok' Exit test: 

 Parse Arg how,k,res
 If how='X' Then
   k=c2d(k)
 o=
 Do Until k=0
   rem=k//58
   k=k%58
   o=o||substr(s,rem+1,1)
   End
 o=reverse(o)
 If o=res Then cnt_ok+=1
 Else Do
   Say 'expected:' res
   Say 'found   :' o
   End
 Return</lang>
Output:
expected: check_error_handlimng
found   : Rt5zm
10 tests ok

version 3

This REXX version handles a null input.

It also handles the case of the hash digest that contain leading 1's (ones)   which are translated to leading 0's (zeros).

The algorithm used doesn't need to   reverse   the residual string   (it uses   prepend   instead of   append). <lang rexx>/*REXX pgm encodes a checksum (hash digest) into Base58 (the standard Bitcoin alphabet).*/ call B58 25420294593250030202636073700053352635053786165627414518 call B58 '61'x call B58 '626262'x call B58 '636363'x call B58 '73696d706c792061206c6f6e6720737472696e67'x call B58 '516b6fcd0f'x call B58 'bf4f89001e670274dd'x call B58 '572e4794'x call B58 'ecac89cad93923c02321'x call B58 '10c8511e'x exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ B58: parse arg z 1 oz; L1=0; hx=0; numeric digits 500 /*for huge nums.*/ 

    if z=  then return                                               /*Is Z missing? */
    if \datatype(z, 'W') | arg()>1  then hx=1;   if hx  then z=c2d(z)  /*is Z in hex ? */
    if left(z, 1)==1  then L1=verify(z ., 1) -1 /*count number of leading 1's  (ones). */
    /*       0─────────────────I─────O────────────────────l────────────────   ◄───omit.*/
    @=space(" 123456789ABCDEFGH JKLMN PQRSTUVWXYZabcdefghi jkmnopqrstuvwxyz",  0)
    $=
                                   do until z=0;   $=substr(@, z//58 +1, 1)$;    z=z % 58
                                   end  /*until*/
    if hx  then oz="'"c2x(oz)"'x"               /*Original arg in hex?  Then transform.*/
    say right(oz, 60) '───►'  left(, L1, 0)$  /*display given argument & the residual*/
    return                                      /* [↑]  also prepend residual with 1's.*/</lang>
output:
    25420294593250030202636073700053352635053786165627414518 ───► 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
                                                       '61'x ───► 2g
                                                   '626262'x ───► a3gV
                                                   '636363'x ───► aPEr
                 '73696D706C792061206C6F6E6720737472696E67'x ───► 2cFupjhnEsSn59qHXstmK2ffpLv2
                                               '516B6FCD0F'x ───► ABnLTmg
                                       'BF4F89001E670274DD'x ───► 3SEo3LWLoPntC
                                                 '572E4794'x ───► 03EFU7m
                                     'ECAC89CAD93923C02321'x ───► 000EJDM8drfXA6uyA
                                                 '10C8511E'x ───► Rt5zm

zkl

Uses libGMP <lang zkl>var [const] BN=Import.lib("zklBigNum"), // GNU Multiple Precision Arithmetic Library 

  src="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv",
  dst="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

println("OkobppXBkab(58)-->", # 10687460092462769069(10) "OkobppXBkab".translate(src,dst),"\n");

ns:=T(BN("25420294593250030202636073700053352635053786165627414518"), 

     0x61, 0x626262, 0x636363, 
     "73696d706c792061206c6f6e6720737472696e67",
     0x516b6fcd0f, "bf4f89001e670274dd", 0x572e4794,
     "ecac89cad93923c02321", 0x10c8511e);

ns.pump(Console.println,'wrap(n){ BN(n,16).toString(58).translate(src,dst) });</lang>

Output:
OkobppXBkab(58)-->RosettaCode

6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
2g
a3gV
aPEr
2cFupjhnEsSn59qHXstmK2ffpLv2
ABnLTmg
3SEo3LWLoPntC
3EFU7m
EJDM8drfXA6uyA
Rt5zm
Retrieved from "https://rosettacode.org/wiki/Base58Check_encoding?oldid=276726"