Rosetta Code

Base58Check encoding: Difference between revisions

Page Discussion

Base58Check encoding (view source)

Revision as of 08:28, 19 January 2024

53,083 bytes added ,  4 months ago
→‎{{header|RPL}}: improved processing of large binary integers
(Added example for D)
(→‎{{header|RPL}}: improved processing of large binary integers)
 
(48 intermediate revisions by 21 users not shown)
Line 1:
{{draft task}}
[[Category:Encodings]]
[[Category:Checksums]]
{{draft task}}
 
The popular encoding of small and medium-sized [[:Category:Checksums|checksums]] is [[wp:base16|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: [[wp:base58|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".
Line 14:
The ''reference algorithm'' is at [https://en.bitcoin.it/wiki/Base58Check_encoding#Base58_symbol_chart the Bitcoin's Base58Check page].
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">V ALPHABET = ‘123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz’
 
F convertToBase58(=num)
V sb = ‘’
L num > 0
V r = Int(num % 58)
sb = sb‘’:ALPHABET[r]
num = num I/ 58
R reversed(sb)
 
V s = BigInt(‘25420294593250030202636073700053352635053786165627414518’)
V b = convertToBase58(s)
print(‘#. -> #.’.format(s, b))
 
V hash_arr = [‘61’, ‘626262’, ‘636363’, ‘73696d706c792061206c6f6e6720737472696e67’, ‘516b6fcd0f’, ‘bf4f89001e670274dd’, ‘572e4794’, ‘ecac89cad93923c02321’, ‘10c8511e’]
L(num) hash_arr
b = convertToBase58(BigInt(num, radix' 16))
print(‘0x#<54 -> #.’.format(num, b))</syntaxhighlight>
 
{{out}}
<pre>
25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm
</pre>
 
=={{header|C sharp|C#}}==
{{trans|Java}}
<syntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Numerics;
using System.Text;
 
namespace Base58CheckEncoding {
class Program {
const string ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
static BigInteger ToBigInteger(string value, int @base) {
const string HEX = "0123456789ABCDEF";
if (@base < 1 || @base > HEX.Length) {
throw new ArgumentException("Base is out of range.");
}
 
BigInteger bi = BigInteger.Zero;
foreach (char c in value) {
char c2 = Char.ToUpper(c);
int idx = HEX.IndexOf(c2);
if (idx == -1 || idx >= @base) {
throw new ArgumentOutOfRangeException("Illegal character encountered.");
}
bi = bi * @base + idx;
}
 
return bi;
}
 
static string ConvertToBase58(string hash, int @base = 16) {
BigInteger x;
if (@base == 16 && hash.Substring(0, 2) == "0x") {
x = ToBigInteger(hash.Substring(2), @base);
} else {
x = ToBigInteger(hash, @base);
}
 
StringBuilder sb = new StringBuilder();
while (x > 0) {
BigInteger r = x % 58;
sb.Append(ALPHABET[(int)r]);
x = x / 58;
}
 
char[] ca = sb.ToString().ToCharArray();
Array.Reverse(ca);
return new string(ca);
}
 
static void Main(string[] args) {
string s = "25420294593250030202636073700053352635053786165627414518";
string b = ConvertToBase58(s, 10);
Console.WriteLine("{0} -> {1}", s, b);
 
List<string> hashes = new List<string>() {
"0x61",
"0x626262",
"0x636363",
"0x73696d706c792061206c6f6e6720737472696e67",
"0x516b6fcd0f",
"0xbf4f89001e670274dd",
"0x572e4794",
"0xecac89cad93923c02321",
"0x10c8511e",
};
foreach (string hash in hashes) {
string b58 = ConvertToBase58(hash);
Console.WriteLine("{0,-56} -> {1}", hash, b58);
}
}
}
}</syntaxhighlight>
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm</pre>
 
=={{header|D}}==
<syntaxhighlight lang="d">import std.bigint;
import std.stdio;
 
void main() {
report("25420294593250030202636073700053352635053786165627414518");
report(0x61);
report(0x626262);
report(0x636363);
report("0x73696d706c792061206c6f6e6720737472696e67");
report(0x516b6fcd0f);
report("0xbf4f89001e670274dd");
report(0x572e4794);
report("0xecac89cad93923c02321");
report(0x10c8511e);
}
 
void report(T)(T v) {
import std.traits;
static if (isIntegral!T) {
enum format = "%#56x -> %s";
} else {
enum format = "%56s -> %s";
}
writefln(format, v, v.toBase58);
}
 
string toBase58(T)(T input) {
import std.traits;
static if (isSomeString!T) {
return toBase58(BigInt(input));
} else {
import std.algorithm.mutation : reverse;
import std.array : appender;
enum ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
auto sb = appender!(char[]);
size_t mod;
 
do {
mod = cast(size_t) (input % ALPHABET.length);
sb.put(ALPHABET[mod]);
 
input /= ALPHABET.length;
} while (input);
 
sb.data.reverse;
return sb.data.idup;
}
}</syntaxhighlight>
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm</pre>
 
=={{header|FreeBASIC}}==
{{libheader|GMP}}
<langsyntaxhighlight lang="freebasic">' version 14-08-2017
' compile with: fbc -s console
' uses GMP
Line 76 ⟶ 259:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre>OkobppXBkab(58) --> RosettaCode
Line 91 ⟶ 274:
0x10c8511e --> Rt5zm</pre>
 
=={{header|DGo}}==
{{trans|Kotlin}}
<lang D>import std.bigint;
<syntaxhighlight lang="go">package main
import std.stdio;
 
import (
void main() {
"fmt"
report("25420294593250030202636073700053352635053786165627414518");
report(0x61);"log"
"math/big"
report(0x626262);
"strings"
report(0x636363);
)
report("0x73696d706c792061206c6f6e6720737472696e67");
 
report(0x516b6fcd0f);
const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
report("0xbf4f89001e670274dd");
 
report(0x572e4794);
var big0 = new(big.Int)
report("0xecac89cad93923c02321");
var big58 = big.NewInt(58)
report(0x10c8511e);
 
func reverse(s string) string {
r := []rune(s)
for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
r[i], r[j] = r[j], r[i]
}
return string(r)
}
 
func convertToBase58(hash string, base int) (string, error) {
void report(T)(T v) {
var x, ok = new(big.Int).SetString(hash, base)
import std.traits;
static if (isIntegral!T)ok {
return "", fmt.Errorf("'%v' is not a valid integer in base '%d'", hash, base)
enum format = "%#56x -> %s";
} else {
enum format = "%56s -> %s";
}
var sb strings.Builder
writefln(format, v, v.toBase58);
var rem = new(big.Int)
for x.Cmp(big0) == 1 {
x.QuoRem(x, big58, rem)
r := rem.Int64()
sb.WriteByte(alphabet[r])
}
return reverse(sb.String()), nil
}
 
func main() {
string toBase58(T)(T input) {
s := "25420294593250030202636073700053352635053786165627414518"
import std.traits;
b, err := convertToBase58(s, 10)
static if (isSomeString!T) {
if err != nil {
return toBase58(BigInt(input));
} else { log.Fatal(err)
}
import std.algorithm.mutation : reverse;
fmt.Println(s, "->", b)
import std.array : appender;
hashes := [...]string{
enum ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
"0x61",
"0x626262",
"0x636363",
"0x73696d706c792061206c6f6e6720737472696e67",
"0x516b6fcd0f",
"0xbf4f89001e670274dd",
"0x572e4794",
"0xecac89cad93923c02321",
"0x10c8511e",
}
for _, hash := range hashes {
b58, err := convertToBase58(hash, 0)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%-56s -> %s\n", hash, b58)
}
}</syntaxhighlight>
 
{{out}}
auto sb = appender!(char[]);
<pre>
size_t mod;
25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm
</pre>
 
=={{header|Groovy}}==
do {
{{trans|Java}}
mod = cast(size_t) (input % ALPHABET.length);
<syntaxhighlight lang="groovy">class Base58CheckEncoding {
sb.put(ALPHABET[mod]);
private static final String ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
private static final BigInteger BIG0 = BigInteger.ZERO
private static final BigInteger BIG58 = BigInteger.valueOf(58)
 
private static String convertToBase58(String hash) {
input /= ALPHABET.length;
} whilereturn convertToBase58(inputhash, 16);
}
 
private static String convertToBase58(String hash, int base) {
sb.data.reverse;
returnBigInteger sb.data.idup;x
if (base == 16 && hash.substring(0, 2) == "0x") {
x = new BigInteger(hash.substring(2), 16)
} else {
x = new BigInteger(hash, base)
}
 
StringBuilder sb = new StringBuilder()
while (x > BIG0) {
int r = (x % BIG58).intValue()
sb.append(ALPHABET.charAt(r))
x = x.divide(BIG58)
}
 
return sb.reverse().toString()
}
 
static void main(String[] args) {
String s = "25420294593250030202636073700053352635053786165627414518"
String b = convertToBase58(s, 10)
System.out.printf("%s -> %s\n", s, b)
 
List<String> hashes = new ArrayList<>()
hashes.add("0x61")
hashes.add("0x626262")
hashes.add("0x636363")
hashes.add("0x73696d706c792061206c6f6e6720737472696e67")
hashes.add("0x516b6fcd0f")
hashes.add("0xbf4f89001e670274dd")
hashes.add("0x572e4794")
hashes.add("0xecac89cad93923c02321")
hashes.add("0x10c8511e")
 
for (String hash : hashes) {
String b58 = convertToBase58(hash)
System.out.printf("%-56s -> %s\n", hash, b58)
}
}
}</langsyntaxhighlight>
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 0x61 -> 2g
0x626262 0x626262 -> a3gV
0x636363 0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f 0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd 0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e 0x10c8511e -> Rt5zm</pre>
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Numeric (showIntAtBase)
 
chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
Line 172 ⟶ 436:
0x572e4794,
0xecac89cad93923c02321,
0x10c8511e]</langsyntaxhighlight>
{{out}}
<pre>
Line 185 ⟶ 449:
EJDM8drfXA6uyA
Rt5zm</pre>
 
 
and for bulk encoding, Array access would be one of various slightly faster alternatives to recursive subscripting of linked lists:
{{Trans|Python}}
<lang Haskell>import Numeric (showIntAtBase)
<syntaxhighlight lang="haskell">import Data.Array (Array, listArray, (!))
import Numeric (showHex, showIntAtBase)
 
------------------- BASE58CHECK ENCODING -----------------
base58Codes :: (Num i, Ix i) => Array i Char
base58Codes =
listArray (0, 57) "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 
base58Encode :: (Show a, Integral a) => a -> String
(Integral a, Show a) =>
base58Encode n = showIntAtBase 58 (base58Codes !) n ""
a ->
String
base58Encode =
baseEncode $
listArray (0, 57) $
[ ('1', '9'),
('A', 'H'),
('J', 'N'),
('P', 'Z'),
('a', 'k'),
('m', 'z')
]
>>= uncurry enumFromTo
 
baseEncode ::
(Show a, Integral a) =>
Array Int Char ->
a ->
String
baseEncode cs n =
showIntAtBase
(fromIntegral $ length cs)
(cs !)
n
[]
 
--------------------------- TEST -------------------------
main :: IO ()
main =
putStrLn $
mapM_
fTable
(putStrLn . base58Encode)
"Base 58 encoding:\n"
[ 25420294593250030202636073700053352635053786165627414518
(("0x" <>) . flip showHex [])
, 0x61
, 0x626262 base58Encode
, 0x636363 id
[ 25420294593250030202636073700053352635053786165627414518,
, 0x73696d706c792061206c6f6e6720737472696e67
, 0x516b6fcd0f 0x61,
0x626262,
, 0xbf4f89001e670274dd
, 0x572e4794 0x636363,
0x73696d706c792061206c6f6e6720737472696e67,
, 0xecac89cad93923c02321
, 0x10c8511e 0x516b6fcd0f,
0xbf4f89001e670274dd,
]</lang>
0x572e4794,
0xecac89cad93923c02321,
0x10c8511e
]
 
-------------------- OUTPUT FORMATTING -------------------
fTable ::
String ->
(a -> String) ->
(b -> String) ->
(a -> b) ->
[a] ->
String
fTable s xShow fxShow f xs =
let w = maximum $ fmap length (xShow <$> xs)
rjust n c = (drop . length) <*> (replicate n c <>)
in unlines $
s :
fmap
( ((<>) . rjust w ' ' . xShow)
<*> ((" -> " <>) . fxShow . f)
)
xs</syntaxhighlight>
{{Out}}
<pre>Base 58 encoding:
<pre>6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
 
2g
0x10966776006953d5567439e5e39f86a0d273beed61967f6 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
a3gV
0x61 -> 2g
aPEr
0x626262 -> a3gV
2cFupjhnEsSn59qHXstmK2ffpLv2
0x636363 -> aPEr
ABnLTmg
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
3SEo3LWLoPntC
0x516b6fcd0f -> ABnLTmg
3EFU7m
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
EJDM8drfXA6uyA
0x572e4794 -> 3EFU7m
Rt5zm</pre>
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm</pre>
 
=={{header|Java}}==
{{trans|Kotlin}}
{{works with|Java|9}}
<syntaxhighlight lang="java">import java.math.BigInteger;
import java.util.List;
 
public class Base58CheckEncoding {
private static final String ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
private static final BigInteger BIG0 = BigInteger.ZERO;
private static final BigInteger BIG58 = BigInteger.valueOf(58);
 
private static String convertToBase58(String hash) {
return convertToBase58(hash, 16);
}
 
private static String convertToBase58(String hash, int base) {
BigInteger x;
if (base == 16 && hash.substring(0, 2).equals("0x")) {
x = new BigInteger(hash.substring(2), 16);
} else {
x = new BigInteger(hash, base);
}
 
StringBuilder sb = new StringBuilder();
while (x.compareTo(BIG0) > 0) {
int r = x.mod(BIG58).intValue();
sb.append(ALPHABET.charAt(r));
x = x.divide(BIG58);
}
 
return sb.reverse().toString();
}
 
public static void main(String[] args) {
String s = "25420294593250030202636073700053352635053786165627414518";
String b = convertToBase58(s, 10);
System.out.printf("%s -> %s\n", s, b);
 
List<String> hashes = List.of(
"0x61",
"0x626262",
"0x636363",
"0x73696d706c792061206c6f6e6720737472696e67",
"0x516b6fcd0f",
"0xbf4f89001e670274dd",
"0x572e4794",
"0xecac89cad93923c02321",
"0x10c8511e"
);
for (String hash : hashes) {
String b58 = convertToBase58(hash);
System.out.printf("%-56s -> %s\n", hash, b58);
}
}
}</syntaxhighlight>
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm</pre>
 
=={{header|jq}}==
'''Works with gojq, the Go implementation of jq'''
 
WARNING: The program will also run using the C implementation of jq but the results for the very
large values will be inaccurate.
 
'''Generic utility functions'''
<syntaxhighlight lang=jq>
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
 
# Input: a string in base $b (2 to 35 inclusive)
# Output: the decimal value
def frombase($b):
def decimalValue:
if 48 <= . and . <= 57 then . - 48
elif 65 <= . and . <= 90 then . - 55 # (10+.-65)
elif 97 <= . and . <= 122 then . - 87 # (10+.-97)
else "decimalValue" | error
end;
reduce (explode|reverse[]|decimalValue) as $x ({p:1};
.value += (.p * $x)
| .p *= $b)
| .value ;
</syntaxhighlight>
'''Base58Check'''
<syntaxhighlight lang=jq>
# The base58check alphabet, i.e. 0 => "1", etc
def alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
# input: a string in the specified $base
def convertToBase58($base):
. as $hash
| {x: (if $base == 16 and ($hash|startswith("0x"))
then $hash[2:]|frombase(16)
else $hash|frombase($base)
end),
sb: [] }
| until (.x <= 0;
(.x % 58) as $r
| .sb += [alphabet[$r:$r+1]]
| .x |= (. - $r) / 58 )
| .sb | reverse | join("");
 
def hashes: [
"0x61",
"0x626262",
"0x636363",
"0x73696d706c792061206c6f6e6720737472696e67",
"0x516b6fcd0f",
"0xbf4f89001e670274dd",
"0x572e4794",
"0xecac89cad93923c02321",
"0x10c8511e"
];
 
def task:
def s: "25420294593250030202636073700053352635053786165627414518";
 
(s | "\(lpad(58))-> \(convertToBase58(10))" ),
(hashes[]
| [lpad(58), convertToBase58(16)] | join("-> ") ) ;
 
task
</syntaxhighlight>
{{output}}
<pre>
25420294593250030202636073700053352635053786165627414518-> 6UwLL9RisZVooooooooooooooooooooo
0x61-> 2g
0x626262-> a3gV
0x636363-> aPEr
0x73696d706c792061206c6f6e6720737472696e67-> 2cFupjhnEuPooooooooooooooooo
0x516b6fcd0f-> ABnLTmg
0xbf4f89001e670274dd-> 3SEo3LWLoMXoo
0x572e4794-> 3EFU7m
0xecac89cad93923c02321-> EJDM8drfX5mooo
0x10c8511e-> Rt5zm
</pre>
 
=={{header|Julia}}==
{{works with|Julia|0.6}}
 
<syntaxhighlight lang="julia">const alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 
function encodebase58(hsh::AbstractString, base::Integer=16)
x = if base == 16 && hsh[1:2] == "0x" parse(BigInt, hsh[3:end], 16)
else parse(BigInt, hsh, base) end
sb = IOBuffer()
while x > 0
x, r = divrem(x, 58)
print(sb, alpha[r + 1])
end
return String(sb) |> reverse
end
 
s = "25420294593250030202636073700053352635053786165627414518"
println("# $s\n -> ", encodebase58(s, 10))
for s in ["0x61", "0x626262", "0x636363", "0x73696d706c792061206c6f6e6720737472696e67",
"0x516b6fcd0f", "0xbf4f89001e670274dd", "0x572e4794", "0xecac89cad93923c02321",
"0x10c8511e"]
println("# $s\n -> ", encodebase58(s))
end</syntaxhighlight>
 
{{out}}
<pre># 25420294593250030202636073700053352635053786165627414518
-> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
# 0x61
-> 2g
# 0x626262
-> a3gV
# 0x636363
-> aPEr
# 0x73696d706c792061206c6f6e6720737472696e67
-> 2cFupjhnEsSn59qHXstmK2ffpLv2
# 0x516b6fcd0f
-> ABnLTmg
# 0xbf4f89001e670274dd
-> 3SEo3LWLoPntC
# 0x572e4794
-> 3EFU7m
# 0xecac89cad93923c02321
-> EJDM8drfXA6uyA
# 0x10c8511e
-> Rt5zm</pre>
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.51
 
import java.math.BigInteger
Line 264 ⟶ 770:
println("${hash.padEnd(56)} -> $b58")
}
}</langsyntaxhighlight>
 
{{out}}
Line 280 ⟶ 786:
</pre>
 
=={{header|Perl 6Nim}}==
{{libheader|bignum}}
<lang perl6>sub encode_Base58 ( Int $x ) {
This version takes in account the leading zeroes in hexadecimal representation. It accepts also arrays or sequences of bytes as input, taking in account the leading zero bytes as described in https://en.bitcoin.it/wiki/Base58Check_encoding#Base58_symbol_chart
<syntaxhighlight lang="nim">import sequtils, strutils
import bignum
 
const CodeString = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 
 
proc toBase58*(hashValue: string): string =
## Convert a hash value provided as a string to its base 58 representation.
 
# Build a big integer from the string.
var hexval = ""
var val: Int
if hashValue.startsWith("0x"):
hexval = hashValue[2..^1]
val = newInt(hexval, 16)
else:
val = newInt(hashValue, 10)
 
# Convert to base 58.
while val > 0:
result.add CodeString[(val mod 58).toInt]
val = val div 58
 
# Add codes for leading zeroes.
for c in hexval:
if c == '0': result.add '1'
else: break
 
# Reverse string.
let h = result.high
for i in 0..(h div 2):
swap result[i], result[h - i]
 
 
proc toBase58*(hashValue: openArray[byte]): string =
## Convert an array or sequence of bytes to base 58.
toBase58("0x" & hashValue.join().toHex)
 
 
when isMainModule:
const Hashes = ["0x00010966776006953D5567439E5E39F86A0D273BEED61967F6",
"0x61",
"0x626262",
"0x636363",
"0x73696d706c792061206c6f6e6720737472696e67",
"0x516b6fcd0f",
"0xbf4f89001e670274dd",
"0x572e4794",
"0xecac89cad93923c02321",
"0x10c8511e"]
 
const MaxLength = max(Hashes.mapIt(it.len))
 
for h in Hashes:
echo h.alignLeft(MaxLength), " → ", h.toBase58</syntaxhighlight>
 
{{out}}
<pre>0x00010966776006953D5567439E5E39F86A0D273BEED61967F6 → 1116UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 → 2g
0x626262 → a3gV
0x636363 → aPEr
0x73696d706c792061206c6f6e6720737472696e67 → 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f → ABnLTmg
0xbf4f89001e670274dd → 3SEo3LWLoPntC
0x572e4794 → 3EFU7m
0xecac89cad93923c02321 → EJDM8drfXA6uyA
0x10c8511e → Rt5zm</pre>
 
=={{header|Perl}}==
<syntaxhighlight lang="perl">use Math::BigInt;
 
sub encode_base58 {
my ($num) = @_;
$num = Math::BigInt->new($num);
 
my $chars = [qw(
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
)];
 
my $base58;
while ($num->is_pos) {
my ($quotient, $remainder) = $num->bdiv(58);
$base58 = $chars->[$remainder] . $base58;
}
$base58
}
 
printf "%56s -> %s\n", $_, encode_base58(+$_)
for qw(
25420294593250030202636073700053352635053786165627414518
0x61
0x626262
0x636363
0x73696d706c792061206c6f6e6720737472696e67
0x516b6fcd0f
0xbf4f89001e670274dd
0x572e4794
0xecac89cad93923c02321
0x10c8511e
);</syntaxhighlight>
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm</pre>
 
=={{header|Phix}}==
Slight variation from [[Bitcoin/public_point_to_address#Phix]] in that it accepts any length string (which can be binary or text).<br>
Includes leading zeroes, if you don't want that just comment out the three lines defining/using the integer lz.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">b58</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">out</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">lz</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">trim_head</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\0'</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">out</span><span style="color: #0000FF;">=</span><span style="color: #008000;">""</span> <span style="color: #008080;">then</span> <span style="color: #000000;">lz</span> <span style="color: #0000FF;">-=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">*</span><span style="color: #000000;">256</span><span style="color: #0000FF;">+</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">/</span><span style="color: #000000;">58</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">,</span><span style="color: #000000;">58</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">out</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">b58</span><span style="color: #0000FF;">[</span><span style="color: #000000;">c</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #000000;">out</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'1'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lz</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">out</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"00010966776006953D5567439E5E39F86A0D273BEED61967F6"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"61"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- == base58("a")</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"626262"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- == base58("bbb")</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"636363"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- == base58("ccc")</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"73696d706c792061206c6f6e6720737472696e67"</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- ^ == base58("simply a long string")</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"516b6fcd0f"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"bf4f89001e670274dd"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"572e4794"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"ecac89cad93923c02321"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">base58</span><span style="color: #0000FF;">(</span><span style="color: #008000;">x"10c8511e"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
"16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"
"2g"
"a3gV"
"aPEr"
"2cFupjhnEsSn59qHXstmK2ffpLv2"
"ABnLTmg"
"3SEo3LWLoPntC"
"3EFU7m"
"EJDM8drfXA6uyA"
"Rt5zm"
</pre>
 
=={{header|Picat}}==
<syntaxhighlight lang="picat">main =>
Tests = [[25420294593250030202636073700053352635053786165627414518,"6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"],
["0x61","2g"],
["0x626262", "a3gV"],
["0x636363", "aPEr"],
["0x73696d706c792061206c6f6e6720737472696e67", "2cFupjhnEsSn59qHXstmK2ffpLv2"],
["0x516b6fcd0f", "ABnLTmg"],
["0xbf4f89001e670274dd", "3SEo3LWLoPntC"],
["0x572e4794", "3EFU7m"],
["0xecac89cad93923c02321", "EJDM8drfXA6uyA"],
["0x10c8511e", "Rt5zm"]],
foreach([Test,Check] in Tests)
Res = base58Check(Test),
printf("%-56w -> %w (%s)\n", Test, Res, cond(Res==Check,"ok", "not ok"))
end,
nl.
 
base58Check(Hash) = Out.reverse =>
CodeS = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
(string(Hash) -> X = Hash.to_int ; X = Hash),
Out = "",
while (X > 0)
Rem = X mod 58,
X := X // 58,
Out := Out ++ [CodeS[Rem+1]]
end.</syntaxhighlight>
 
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM (ok)
0x61 -> 2g (ok)
0x626262 -> a3gV (ok)
0x636363 -> aPEr (ok)
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2 (ok)
0x516b6fcd0f -> ABnLTmg (ok)
0xbf4f89001e670274dd -> 3SEo3LWLoPntC (ok)
0x572e4794 -> 3EFU7m (ok)
0xecac89cad93923c02321 -> EJDM8drfXA6uyA (ok)
0x10c8511e -> Rt5zm (ok)</pre>
 
 
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">(setq *B58Alpha
(chop "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz") )
(de b58 (S)
(let N 0
(pack
(make
(if (pre? "0x" S)
(setq N (hex (cddr (chop S))))
(setq N (format S)) )
(while (gt0 N)
(yoke (get *B58Alpha (inc (% N 58))))
(setq N (/ N 58)) ) ) ) ) )
(println (b58 "25420294593250030202636073700053352635053786165627414518"))
(println (b58 "0x626262"))
(println (b58 "0x636363"))</syntaxhighlight>
{{out}}
<pre>
"6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"
"a3gV"
"aPEr"
</pre>
 
=={{header|Python}}==
===Procedural===
===Works with Python 3.9
{{trans|C#}}
<syntaxhighlight lang="python">ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 
def convertToBase58(num):
sb = ''
while (num > 0):
r = num % 58
sb = sb + ALPHABET[r]
num = num // 58;
return sb[::-1]
 
s = 25420294593250030202636073700053352635053786165627414518
b = convertToBase58(s)
print("%-56d -> %s" % (s, b))
 
hash_arr = [0x61, 0x626262, 0x636363, 0x73696d706c792061206c6f6e6720737472696e67, 0x516b6fcd0f, 0xbf4f89001e670274dd, 0x572e4794, 0xecac89cad93923c02321, 0x10c8511e]
for num in hash_arr:
b = convertToBase58(num)
print("0x%-54x -> %s" % (num, b))</syntaxhighlight>
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm</pre>
 
===Composition of pure functions===
{{Works with|Python|3.7}}
<syntaxhighlight lang="python">'''Base 58 check encoding'''
 
from functools import reduce
import itertools
import enum
 
 
# baseEncode :: [Char] -> (Integer -> String)
def baseEncode(cs):
'''Given the character set for a given base,
returns a function from a integer to a string
representing that integer in the base
specified by the length of the character set.
'''
return lambda n: showIntAtBase(len(cs))(
index(cs)
)(n)('')
 
 
# TESTS ---------------------------------------------------
# main :: IO ()
def main():
'''Tests of base58 encoding.'''
 
# base58Encode :: Integer -> String
base58Encode = baseEncode(
reduce(
lambda a, xy: a + uncurry(enumFromTo)(xy),
[
('1', '9'),
('A', 'H'), ('J', 'N'), ('P', 'Z'),
('a', 'k'), ('m', 'z')
],
[]
)
)
 
print(
fTable(__doc__ + ':\n')(hex)(base58Encode)(stet)([
25420294593250030202636073700053352635053786165627414518,
0x61,
0x626262,
0x636363,
0x73696d706c792061206c6f6e6720737472696e67,
0x516b6fcd0f,
0xbf4f89001e670274dd,
0x572e4794,
0xecac89cad93923c02321,
0x10c8511e
])
)
 
 
# GENERIC -------------------------------------------------
 
# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
def compose(g):
'''Right to left function composition.'''
return lambda f: lambda x: g(f(x))
 
 
# enumFromTo :: Enum a => a -> a -> [a]
def enumFromTo(m):
'''Enumeration of values [m..n]'''
def go(x, y):
t = type(m)
i = fromEnum(x)
d = 0 if t != float else (x - i)
return list(map(
lambda x: toEnum(t)(d + x),
range(i, 1 + fromEnum(y))
) if int != t else range(x, 1 + y))
return lambda n: go(m, n)
 
 
# fromEnum :: Enum a => a -> Int
def fromEnum(x):
'''Index integer for enumerable value.'''
Enum = enum.Enum
return ord(x) if str == type(x) else (
x.value if isinstance(x, Enum) else int(x)
)
 
 
# fTable :: String -> (a -> String) ->
# (b -> String) -> (a -> b) -> [a] -> String
def fTable(s):
'''Heading -> x display function ->
fx display function ->
f -> value list -> tabular string.'''
def go(xShow, fxShow, f, xs):
w = max(map(compose(len)(xShow), xs))
return s + '\n' + '\n'.join([
xShow(x).rjust(w, ' ') + (' -> ') + fxShow(f(x))
for x in xs
])
return lambda xShow: lambda fxShow: lambda f: lambda xs: go(
xShow, fxShow, f, xs
)
 
 
# index (!!) :: [a] -> Int -> a
def index(xs):
'''Item at given (zero-based) index.'''
islice = itertools.islice
return lambda n: None if 0 > n else (
xs[n] if (
hasattr(xs, "__getitem__")
) else next(islice(xs, n, None))
)
 
 
# showIntAtBase :: Int -> (Int -> String) -> Int -> String -> String
def showIntAtBase(base):
'''String representation of an integer in a given base,
using a supplied function for the string representation
of digits.'''
def wrap(toChr, n, rs):
def go(nd, r):
n, d = nd
r_ = toChr(d) + r
return go(divmod(n, base), r_) if 0 != n else r_
return 'unsupported base' if 1 >= base else (
'negative number' if 0 > n else (
go(divmod(n, base), rs))
)
return lambda toChr: lambda n: lambda rs: (
wrap(toChr, n, rs)
)
 
 
# stet :: a -> a
def stet(x):
'''The identity function.
The usual 'id' is reserved in Python.'''
return x
 
 
# uncurry :: (a -> b -> c) -> ((a, b) -> c)
def uncurry(f):
'''A function over a tuple,
derived from a default or
curried function.'''
return lambda xy: f(xy[0])(xy[1])
 
 
# toEnum :: Type -> Int -> a
def toEnum(t):
'''Enumerable value from index integer'''
dct = {
int: int,
float: float,
str: chr,
bool: bool
}
return lambda x: dct[t](x) if t in dct else t(x)
 
 
# MAIN ---
if __name__ == '__main__':
main()</syntaxhighlight>
{{Out}}
<pre>Base 58 check encoding:
 
0x10966776006953d5567439e5e39f86a0d273beed61967f6 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="quackery"> [ table ] is base58char ( n --> n )
$ "123456789ABCDEFGHJKLMNPQRSTUV"
$ "WXYZabcdefghijkmnopqrstuvwxyz"
join witheach
[ ' base58char put ]
[ [] swap
[ 58 /mod base58char
rot join swap
dup 0 = until ]
drop ] is base58$ ( n --> $ )
 
' [ 25420294593250030202636073700053352635053786165627414518
hex 61
hex 626262
hex 636363
hex 73696d706c792061206c6f6e6720737472696e67
hex 516b6fcd0f
hex bf4f89001e670274dd
hex 572e4794
hex ecac89cad93923c02321
hex 10c8511e ]
 
witheach [ base58$ echo$ cr ]
</syntaxhighlight>
 
{{out}}
 
<pre>6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
2g
a3gV
aPEr
2cFupjhnEsSn59qHXstmK2ffpLv2
ABnLTmg
3SEo3LWLoPntC
3EFU7m
EJDM8drfXA6uyA
Rt5zm
</pre>
 
 
=={{header|Racket}}==
(Examples from some other task)
<syntaxhighlight lang="racket">#lang racket
 
(define ((base-n-alphabet-encode alphabet) hash-string (in-base 16))
(define out-base (string-length alphabet))
(let reduce-hash ((h (string->number (if (and (= in-base 16) (string-prefix? hash-string "0x"))
(substring hash-string 2)
hash-string)
in-base))
(acc (list)))
(if (zero? h)
(list->string acc)
(let-values (((q r) (quotient/remainder h out-base)))
(reduce-hash q (cons (string-ref alphabet r) acc))))))
 
(define base58-check-encode (base-n-alphabet-encode "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"))
 
(module+ main
(base58-check-encode "25420294593250030202636073700053352635053786165627414518" 10)
(map base58-check-encode (list "0x61"
"0x626262"
"0x636363"
"0x73696d706c792061206c6f6e6720737472696e67"
"0x516b6fcd0f"
"0xbf4f89001e670274dd"
"0x572e4794"
"0xecac89cad93923c02321"
"0x10c8511e")))</syntaxhighlight>
{{out}}
<pre>"6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"
'("2g" "a3gV" "aPEr" "2cFupjhnEsSn59qHXstmK2ffpLv2" "ABnLTmg" "3SEo3LWLoPntC" "3EFU7m" "EJDM8drfXA6uyA" "Rt5zm")</pre>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>sub encode_Base58 ( Int $x ) {
constant @codes = <
1 2 3 4 5 6 7 8 9
Line 307 ⟶ 1,337:
is encode_Base58(.key), .value, "{.key} encodes to {.value}";
}
</syntaxhighlight>
</lang>
 
=={{header|REXX}}==
Line 315 ⟶ 1,345:
I get the result expected there.
Apart for the leading 1 the program works also for the inputs shown above.
<langsyntaxhighlight lang="rexx">/* REXX */
s="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
Numeric Digits 100
Line 327 ⟶ 1,357:
End
o=o||substr(s,1,1)
Say reverse(o)</langsyntaxhighlight>
{{out}}
<pre>16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM</pre>
===version 2===
does what the others do
<langsyntaxhighlight lang="rexx">/* REXX */
s="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
Numeric Digits 1000
Line 367 ⟶ 1,397:
Say 'found :' o
End
Return</langsyntaxhighlight>
{{out}}
<pre>expected: check_error_handlimng
Line 379 ⟶ 1,409:
 
The algorithm used doesn't need to &nbsp; ''reverse'' &nbsp; the residual string &nbsp; (it uses &nbsp; ''prepend'' &nbsp; instead of &nbsp; ''append'').
<langsyntaxhighlight lang="rexx">/*REXX pgm encodes a checksum (hash digest) into Base58 (the standard Bitcoin alphabet).*/
/* 0─────────────────I─────O────────────────────l──────────────── ◄───omit.*/
call B58 25420294593250030202636073700053352635053786165627414518
@= space(" 123456789ABCDEFGH JKLMN PQRSTUVWXYZabcdefghi jkmnopqrstuvwxyz", 0)
call B58 '61'x
numeric digits 500 /*just in case there're huge numberss. */
call B58 '626262'x
say B58(25420294593250030202636073700053352635053786165627414518)
call B58 '636363'x
say B58('61'x) ; say B58('626262'x)
call B58 '73696d706c792061206c6f6e6720737472696e67'x
say B58('636363'x) ; say B58('73696d706c792061206c6f6e6720737472696e67'x)
call B58 '516b6fcd0f'x
callsay B58('516b6fcd0f'x) ; say B58('bf4f89001e670274dd'x)
say B58('572e4794'x) ; say B58('ecac89cad93923c02321'x)
call B58 '572e4794'x
callsay B58 ('ecac89cad93923c0232110c8511e'x)
exit 0 /*stick a fork in it, we're all done. */
call B58 '10c8511e'x
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
B58: parse arg z 1 oz,,$; L1= 0; hx hex= 0; if numeric digits 500z='' then return /*for hugeZ nums.missing?*/
if \datatype(z=, 'W') | then return arg()>1 then do; hex= 1; z= c2d(z); end /*Is Z missingin hex? */
if \datatypeleft(z, 'W'1) | arg()>==1 then hxL1=1; verify(z ., if1) hx- then z=c2d(z)1 /*iscount Znumber inof hexleading ?ones (1's)*/
do until z==0; $= substr(@, z//58 +1, 1)$; z= z % 58
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 hxhex then oz= "'"c2x(oz)"'x" /*Original arg in hex? Transform Then transformit.*/
sayreturn right(oz, 60) '"───►'" left('', L1, 0)$ /*displayfor givenshowing argumentarg &and the residual. */
 
return /* [↑] also prepend residual with 1's.*/</lang>
</syntaxhighlight>
{{out|output}}
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
25420294593250030202636073700053352635053786165627414518 ───► 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
Line 416 ⟶ 1,442:
'ECAC89CAD93923C02321'x ───► 000EJDM8drfXA6uyA
'10C8511E'x ───► Rt5zm
</pre>
 
=={{header|RPL}}==
Binary numbers cannot exceed 64 bits in RPL.
{{works with|HP|48G}}
« "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" → alphabet
« "" 1
'''IF''' 3 PICK TYPE 10 == '''THEN''' SF '''ELSE''' CF '''END'''
'''WHILE''' SWAP #0 DUP2 + ≠ '''REPEAT'''
58
'''IF''' 1 FS? '''THEN''' / LASTARG 3 PICK * - B→R SWAP
'''ELSE''' MOD LASTARG / IP '''END'''
alphabet ROT 1 + DUP SUB
ROT +
'''END''' DROP
» » '<span style="color:blue">→B58</span>' STO <span style="color:grey">''@ ( n or #n → "code" }''</span>
« { 6946892355 #61 #626262 #636363 #516B6FCD0F #572E4794 #10C8511E }
1 « <span style="color:blue">→B58</span> » DOLIST
» '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { "Base58" "2g" "a3gV" "aPEr" "ABnLTmg" "3EFU7m" "Rt5zm" }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
nums = [25420294593250030202636073700053352635053786165627414518,
0x61,
0x626262,
0x636363,
0x73696d706c792061206c6f6e6720737472696e67,
0x516b6fcd0f,
0xbf4f89001e670274dd,
0x572e4794,
0xecac89cad93923c02321,
0x10c8511e]
 
puts nums.map{|n| n.digits(58).reverse.map{|i| ALPHABET[i]}.join}
</syntaxhighlight>
{{out}}
<pre>6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
2g
a3gV
aPEr
2cFupjhnEsSn59qHXstmK2ffpLv2
ABnLTmg
3SEo3LWLoPntC
3EFU7m
EJDM8drfXA6uyA
Rt5zm
</pre>
 
=={{header|Scala}}==
{{Out}}Best seen in running your browser either by [https://scalafiddle.io/sf/GMcrlBB/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org Scastie (remote JVM)].
<syntaxhighlight lang="scala">import java.math.BigInteger
object Base58 extends App {
private val codeString = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
private val (big0, big58) = (BigInt(0), BigInteger.valueOf(58))
 
def convertToBase58(input: String): String = convertToBase58(input, 16)
 
def convertToBase58(input: String, base: Int) = {
if (input.isEmpty) "" else {
val big =
if (base == 16 && input.startsWith("0x")) BigInt(input.substring(2), 16) else BigInt(input, base)
 
@scala.annotation.tailrec
def encode(current: BigInt, sb: StringBuilder): StringBuilder = current match {
case `big0` => sb
case _ =>
val Array(dividend, remainder: BigInteger) = current.bigInteger.divideAndRemainder(big58)
encode(dividend, sb.append(codeString(remainder.intValue)))
}
 
encode(big, new StringBuilder).reverse.toString
}
}
 
private def decode(input: String): Array[Byte] = {
val (mapping, trimmed)= (codeString.zipWithIndex.toMap, input.dropWhile(_ == '1').toList)
 
def zeroes: Array[Byte] = input.takeWhile(_ == '1').map(_ => 0.toByte).toArray
def decoded: BigInt = trimmed.foldLeft(big0)((a, b) => a * big58 + BigInt(mapping(b)))
 
if (trimmed.nonEmpty) zeroes ++ decoded.toByteArray.dropWhile(_ == 0) else zeroes
}
 
private def bytes2Hex(buf: Array[Byte]): String = "0x" + buf.map("%02x" format _).mkString
 
/*
* Running some test examples.
*/
 
private val veryLongNumber = "25420294593250030202636073700053352635053786165627414518"
println(f"$veryLongNumber%-56s -> ${convertToBase58(veryLongNumber, 10)}%s" )
 
private val hashes = List("0x61", "0x626262", "0x636363", "0x73696d706c792061206c6f6e6720737472696e67",
"0x516b6fcd0f", "0xbf4f89001e670274dd", "0x572e4794", "0xecac89cad93923c02321", "0x10c8511e")
 
for (hash <- hashes) {
val b58: String = convertToBase58(hash)
 
println(f"$hash%-56s -> $b58%-28s -> ${bytes2Hex(decode(b58))}%-56s" )
}
 
}</syntaxhighlight>
 
=={{header|Seed7}}==
The Seed7 library [http://seed7.sourceforge.net/libraries/encoding.htm encoding.s7i] defines
the function [http://seed7.sourceforge.net/libraries/encoding.htm#toBase(in_bigInteger,in_string) toBase],
which encodes a number with a positional numeric system. No external library is needed.
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "encoding.s7i";
 
const proc: main is func
local
const bigInteger: s is 25420294593250030202636073700053352635053786165627414518_;
const array bigInteger: hash_arr is [] (16#61_, 16#626262_, 16#636363_, 16#73696d706c792061206c6f6e6720737472696e67_,
16#516b6fcd0f_, 16#bf4f89001e670274dd_, 16#572e4794_, 16#ecac89cad93923c02321_, 16#10c8511e_);
var string: b is "";
var bigInteger: num is 0_;
begin
b := toBase(s, defaultBase58Digits);
writeln(s rpad 56 <& " -> " <& b);
for num range hash_arr do
b := toBase(num, defaultBase58Digits);
writeln("16#" <& num radix 16 rpad 53 <& " -> " <& b);
end for;
end func;</syntaxhighlight>
 
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
16#61 -> 2g
16#626262 -> a3gV
16#636363 -> aPEr
16#73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
16#516b6fcd0f -> ABnLTmg
16#bf4f89001e670274dd -> 3SEo3LWLoPntC
16#572e4794 -> 3EFU7m
16#ecac89cad93923c02321 -> EJDM8drfXA6uyA
16#10c8511e -> Rt5zm</pre>
 
=={{header|Sidef}}==
{{trans|Raku}}
<syntaxhighlight lang="ruby">func encode_base58(n) {
static chars = %w(
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
)
[chars[n.polymod(n.ilog(58).of(58)...)]].join.flip
}
 
var tests = [
[25420294593250030202636073700053352635053786165627414518, "6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"],
[97, "2g"],[6447714, "a3gV"],[6513507, "aPEr"],
[658885050385564465925592505944209249682185612903, "2cFupjhnEsSn59qHXstmK2ffpLv2"],
[349694840079, "ABnLTmg"], [3529059230209907258589, "3SEo3LWLoPntC"],
[1462650772, "3EFU7m"], [1117661258925082241147681, "EJDM8drfXA6uyA"], [281563422, "Rt5zm"]
]
 
for num, enc in (tests) {
printf("%56s -> %s\n", num, encode_base58(num))
assert_eq(encode_base58(num), enc)
}</syntaxhighlight>
{{out}}
<pre>
25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
97 -> 2g
6447714 -> a3gV
6513507 -> aPEr
658885050385564465925592505944209249682185612903 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
349694840079 -> ABnLTmg
3529059230209907258589 -> 3SEo3LWLoPntC
1462650772 -> 3EFU7m
1117661258925082241147681 -> EJDM8drfXA6uyA
281563422 -> Rt5zm
</pre>
 
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Imports System.Numerics
Imports System.Text
 
Module Module1
ReadOnly ALPHABET As String = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
ReadOnly HEX As String = "0123456789ABCDEF"
 
Function ToBigInteger(value As String, base As Integer) As BigInteger
If base < 1 OrElse base > HEX.Length Then
Throw New ArgumentException("Base is out of range.")
End If
 
Dim bi = BigInteger.Zero
For Each c In value
Dim c2 = Char.ToUpper(c)
Dim idx = HEX.IndexOf(c2)
If idx = -1 OrElse idx >= base Then
Throw New ArgumentException("Illegal character encountered.")
End If
bi = bi * base + idx
Next
 
Return bi
End Function
 
Function ConvertToBase58(hash As String, Optional base As Integer = 16) As String
Dim x As BigInteger
If base = 16 AndAlso hash.Substring(0, 2) = "0x" Then
x = ToBigInteger(hash.Substring(2), base)
Else
x = ToBigInteger(hash, base)
End If
 
Dim sb As New StringBuilder
While x > 0
Dim r = x Mod 58
sb.Append(ALPHABET(r))
x = x / 58
End While
 
Dim ca = sb.ToString().ToCharArray()
Array.Reverse(ca)
Return New String(ca)
End Function
 
Sub Main()
Dim s = "25420294593250030202636073700053352635053786165627414518"
Dim b = ConvertToBase58(s, 10)
Console.WriteLine("{0} -> {1}", s, b)
 
Dim hashes = {"0x61", "0x626262", "0x636363", "0x73696d706c792061206c6f6e6720737472696e67", "0x516b6fcd0f", "0xbf4f89001e670274dd", "0x572e4794", "0xecac89cad93923c02321", "0x10c8511e"}
For Each hash In hashes
Dim b58 = ConvertToBase58(hash)
Console.WriteLine("{0,-56} -> {1}", hash, b58)
Next
End Sub
 
End Module</syntaxhighlight>
{{out}}
<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm</pre>
 
=={{header|Wren}}==
{{trans|Kotlin}}
{{libheader|Wren-big}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./big" for BigInt
import "./fmt" for Fmt
 
var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
var big58 = BigInt.new(58)
 
var convertToBase58 = Fn.new { |hash, base|
var x = (base == 16 && hash.startsWith("0x")) ? BigInt.fromBaseString(hash[2..-1], 16) :
BigInt.fromBaseString(hash, base)
var sb = ""
while (x > BigInt.zero) {
var r = (x % big58).toSmall
sb = sb + alphabet[r]
x = x / big58
}
return sb[-1..0]
}
 
var s = "25420294593250030202636073700053352635053786165627414518"
var b = convertToBase58.call(s, 10)
System.print("%(s) -> %(b)")
var hashes = [
"0x61",
"0x626262",
"0x636363",
"0x73696d706c792061206c6f6e6720737472696e67",
"0x516b6fcd0f",
"0xbf4f89001e670274dd",
"0x572e4794",
"0xecac89cad93923c02321",
"0x10c8511e"
]
for (hash in hashes) {
var b58 = convertToBase58.call(hash, 16)
Fmt.print("$-56s -> $s", hash, b58)
}</syntaxhighlight>
 
{{out}}
<pre>
25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61 -> 2g
0x626262 -> a3gV
0x636363 -> aPEr
0x73696d706c792061206c6f6e6720737472696e67 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f -> ABnLTmg
0xbf4f89001e670274dd -> 3SEo3LWLoPntC
0x572e4794 -> 3EFU7m
0xecac89cad93923c02321 -> EJDM8drfXA6uyA
0x10c8511e -> Rt5zm
</pre>
 
=={{header|zkl}}==
Uses libGMP
<langsyntaxhighlight lang="zkl">var [const] BN=Import.lib("zklBigNum"), // GNU Multiple Precision Arithmetic Library
src="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv",
dst="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
Line 432 ⟶ 1,764:
0x516b6fcd0f, "bf4f89001e670274dd", 0x572e4794,
"ecac89cad93923c02321", 0x10c8511e);
ns.pump(Console.println,'wrap(n){ BN(n,16).toString(58).translate(src,dst) });</langsyntaxhighlight>
{{out}}
<pre>
Aerobar
1,150

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/276728...353309"