Base58Check encoding: Difference between revisions

Content added Content deleted

Inline

Latest revision as of 08:28, 19 January 2024

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:

O the uppercase letter "oh",
I the uppercase letter "eye",
l the lowercase letter "ell", and
0 the digit zero.

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

11l

Translation of: Python

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))

Output:

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

C#

Translation of: Java

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);
            }
        }
    }
}

Output:

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

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;
    }
}

Output:

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

FreeBASIC

Library: GMP

' version 14-08-2017
' compile with: fbc -s console
' uses GMP

#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

Output:

OkobppXBkab(58) --> RosettaCode

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

Go

Translation of: Kotlin

package main

import (
    "fmt"
    "log"
    "math/big"
    "strings"
)

const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

var big0 = new(big.Int)
var big58 = big.NewInt(58)

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) {
    var x, ok = new(big.Int).SetString(hash, base)
    if !ok {
        return "", fmt.Errorf("'%v' is not a valid integer in base '%d'", hash, base)
    }
    var sb strings.Builder
    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() {
    s := "25420294593250030202636073700053352635053786165627414518"
    b, err := convertToBase58(s, 10)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(s, "->", b)
    hashes := [...]string{
        "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)
    }
}

Output:

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

Groovy

Translation of: Java

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) == "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)
        }
    }
}

Output:

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

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]

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:

Translation of: Python

import Data.Array (Array, listArray, (!))
import Numeric (showHex, showIntAtBase)

------------------- BASE58CHECK ENCODING -----------------

base58Encode ::
  (Integral a, Show a) =>
  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 $
    fTable
      "Base 58 encoding:\n"
      (("0x" <>) . flip showHex [])
      base58Encode
      id
      [ 25420294593250030202636073700053352635053786165627414518,
        0x61,
        0x626262,
        0x636363,
        0x73696d706c792061206c6f6e6720737472696e67,
        0x516b6fcd0f,
        0xbf4f89001e670274dd,
        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

Output:

Base 58 encoding:

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

Java

Translation of: Kotlin

Works with: Java version 9

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);
        }
    }
}

Output:

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

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

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 ;

Base58Check

# 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

Output:

  25420294593250030202636073700053352635053786165627414518-> 6UwLL9RisZVooooooooooooooooooooo
                                                      0x61-> 2g
                                                  0x626262-> a3gV
                                                  0x636363-> aPEr
                0x73696d706c792061206c6f6e6720737472696e67-> 2cFupjhnEuPooooooooooooooooo
                                              0x516b6fcd0f-> ABnLTmg
                                      0xbf4f89001e670274dd-> 3SEo3LWLoMXoo
                                                0x572e4794-> 3EFU7m
                                    0xecac89cad93923c02321-> EJDM8drfX5mooo
                                                0x10c8511e-> Rt5zm

Julia

Works with: Julia version 0.6

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

Output:

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

Kotlin

// 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")
    }
}

Output:

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

Nim

Library: bignum

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

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

Output:

0x00010966776006953D5567439E5E39F86A0D273BEED61967F6 → 1116UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
0x61                                                 → 2g
0x626262                                             → a3gV
0x636363                                             → aPEr
0x73696d706c792061206c6f6e6720737472696e67           → 2cFupjhnEsSn59qHXstmK2ffpLv2
0x516b6fcd0f                                         → ABnLTmg
0xbf4f89001e670274dd                                 → 3SEo3LWLoPntC
0x572e4794                                           → 3EFU7m
0xecac89cad93923c02321                               → EJDM8drfXA6uyA
0x10c8511e                                           → Rt5zm

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
    );

Output:

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

Phix

Slight variation from Bitcoin/public_point_to_address#Phix in that it accepts any length string (which can be binary or text).
Includes leading zeroes, if you don't want that just comment out the three lines defining/using the integer lz.

with javascript_semantics
constant b58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 
function base58(string s)
string out = ""
integer lz = length(s)
    while 1 do
        s = trim_head(s,'\0')
        if length(s)=0 then exit end if
        if out="" then lz -= length(s) end if
        integer c = 0
        for i=1 to length(s) do
            c = c*256+s[i]
            s[i] = floor(c/58)
            c = mod(c,58)
        end for
        out &= b58[c+1]
    end while
    out &= repeat('1',lz)
    return reverse(out)
end function
 
?base58(x"00010966776006953D5567439E5E39F86A0D273BEED61967F6")
?base58(x"61")      -- == base58("a")
?base58(x"626262")  -- == base58("bbb")
?base58(x"636363")  -- == base58("ccc")
?base58(x"73696d706c792061206c6f6e6720737472696e67")
 -- ^ == base58("simply a long string")
?base58(x"516b6fcd0f")
?base58(x"bf4f89001e670274dd")
?base58(x"572e4794")
?base58(x"ecac89cad93923c02321")
?base58(x"10c8511e")

Output:

"16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"
"2g"
"a3gV"
"aPEr"
"2cFupjhnEsSn59qHXstmK2ffpLv2"
"ABnLTmg"
"3SEo3LWLoPntC"
"3EFU7m"
"EJDM8drfXA6uyA"
"Rt5zm"

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.

Output:

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)

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"))

Output:

"6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"
"a3gV"
"aPEr"

Python

Procedural

===Works with Python 3.9

Translation of: C#

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))

Output:

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

Composition of pure functions

Works with: Python version 3.7

'''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()

Output:

Base 58 check encoding:

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

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 ]

Output:

6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
2g
a3gV
aPEr
2cFupjhnEsSn59qHXstmK2ffpLv2
ABnLTmg
3SEo3LWLoPntC
3EFU7m
EJDM8drfXA6uyA
Rt5zm

Racket

(Examples from some other task)

#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")))

Output:

"6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"
'("2g" "a3gV" "aPEr" "2cFupjhnEsSn59qHXstmK2ffpLv2" "ABnLTmg" "3SEo3LWLoPntC" "3EFU7m" "EJDM8drfXA6uyA" "Rt5zm")

Raku

(formerly Perl 6)

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}";
}

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.

/* 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)

Output:

16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

version 2

does what the others do

/* 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

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).

/*REXX pgm encodes a checksum (hash digest) into Base58 (the standard Bitcoin alphabet).*/
           /*  0─────────────────I─────O────────────────────l────────────────  ◄───omit.*/
     @= space(" 123456789ABCDEFGH JKLMN PQRSTUVWXYZabcdefghi jkmnopqrstuvwxyz",  0)
numeric digits 500                               /*just in case there're huge numberss. */
say  B58(25420294593250030202636073700053352635053786165627414518)
say  B58('61'x)           ;         say  B58('626262'x)
say  B58('636363'x)       ;         say  B58('73696d706c792061206c6f6e6720737472696e67'x)
say  B58('516b6fcd0f'x)   ;         say  B58('bf4f89001e670274dd'x)
say  B58('572e4794'x)     ;         say  B58('ecac89cad93923c02321'x)
say  B58('10c8511e'x)
exit 0                                           /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
B58: parse arg z 1 oz,,$;    L1= 0;           hex= 0;  if z=''  then return /*Z missing?*/
     if \datatype(z, 'W') | arg()>1  then do; hex= 1;  z= c2d(z);  end      /*Z in hex? */
     if left(z, 1)==1  then L1= verify(z ., 1) - 1  /*count number of leading ones (1's)*/
                                    do until z==0;  $= substr(@, z//58 +1, 1)$;  z= z % 58
                                    end  /*until*/
     if hex  then oz= "'"c2x(oz)"'x"                /*Original arg in hex? Transform it.*/
     return right(oz, 60) "───►"  left('', L1, 0)$  /*for showing arg and the residual. */

output when using the default inputs:

    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

RPL

Binary numbers cannot exceed 64 bits in RPL.

Works with: HP version 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    
» » '→B58' STO     @ ( n or #n → "code" }

« { 6946892355 #61 #626262 #636363 #516B6FCD0F #572E4794 #10C8511E }
  1 « →B58 » DOLIST  
» 'TASK' STO

Output:

1: { "Base58" "2g" "a3gV" "aPEr" "ABnLTmg" "3EFU7m" "Rt5zm" }

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}

Output:

6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
2g
a3gV
aPEr
2cFupjhnEsSn59qHXstmK2ffpLv2
ABnLTmg
3SEo3LWLoPntC
3EFU7m
EJDM8drfXA6uyA
Rt5zm

Scala

Output:

Best seen in running your browser either by ScalaFiddle (ES aka JavaScript, non JVM) or Scastie (remote JVM).

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" )
  }

}

Seed7

The Seed7 library encoding.s7i defines the function toBase, which encodes a number with a positional numeric system. No external library is needed.

$ 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;

Output:

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

Sidef

Translation of: Raku

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)
}

Output:

25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
                                                      97 -> 2g
                                                 6447714 -> a3gV
                                                 6513507 -> aPEr
        658885050385564465925592505944209249682185612903 -> 2cFupjhnEsSn59qHXstmK2ffpLv2
                                            349694840079 -> ABnLTmg
                                  3529059230209907258589 -> 3SEo3LWLoPntC
                                              1462650772 -> 3EFU7m
                               1117661258925082241147681 -> EJDM8drfXA6uyA
                                               281563422 -> Rt5zm

Visual Basic .NET

Translation of: C#

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

Output:

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

Wren

Translation of: Kotlin

Library: Wren-big

Library: Wren-fmt

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)
}

Output:

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

zkl

Uses libGMP

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) });

Output:

OkobppXBkab(58)-->RosettaCode

6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM
2g
a3gV
aPEr
2cFupjhnEsSn59qHXstmK2ffpLv2
ABnLTmg
3SEo3LWLoPntC
3EFU7m
EJDM8drfXA6uyA
Rt5zm