Base58Check encoding: Difference between revisions

[[Category:Encodings]]

[[Category:Checksums]]

 

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

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

<br><br>

 

=={{header|C sharp|C#}}==

{{trans|Java}}

using System.Collections.Generic;

using System.Numerics;

}

}

{{out}}

<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

 

=={{header|D}}==

import std.stdio;

 

return sb.data.idup;

}

{{out}}

<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

=={{header|FreeBASIC}}==

{{libheader|GMP}}

' compile with: fbc -s console

' uses GMP

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>OkobppXBkab(58) --> RosettaCode

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Printf("%-56s -> %s\n", hash, b58)

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

private static final String ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

private static final BigInteger BIG0 = BigInteger.ZERO

}

}

{{out}}

<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

 

=={{header|Haskell}}==

 

chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

0x572e4794,

0xecac89cad93923c02321,

{{out}}

<pre>

and for bulk encoding, Array access would be one of various slightly faster alternatives to recursive subscripting of linked lists:

{{Trans|Python}}

import Numeric (showHex, showIntAtBase)

 

fTable

"Base 58 encoding:\n"

(("0x" <>) . flip showHex [])

base58Encode

<*> ((" -> " <>) . fxShow . f)

)

{{Out}}

<pre>Base 58 encoding:

{{trans|Kotlin}}

{{works with|Java|9}}

import java.util.List;

 

}

}

{{out}}

<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

0xecac89cad93923c02321 -> EJDM8drfXA6uyA

0x10c8511e -> Rt5zm</pre>

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

function encodebase58(hsh::AbstractString, base::Integer=16)

"0x10c8511e"]

println("# $s\n -> ", encodebase58(s))

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.math.BigInteger

println("${hash.padEnd(56)} -> $b58")

}

 

{{out}}

{{libheader|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 bignum

 

 

for h in Hashes:

 

{{out}}

 

=={{header|Perl}}==

 

sub encode_base58 {

0xecac89cad93923c02321

0x10c8511e

{{out}}

<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

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.

{{out}}

<pre>

"Rt5zm"

</pre>

 

=={{header|PicoLisp}}==

(chop "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz") )

(de b58 (S)

(println (b58 "25420294593250030202636073700053352635053786165627414518"))

(println (b58 "0x626262"))

{{out}}

<pre>

=={{header|Python}}==

===Procedural===

{{trans|C#}}

 

def convertToBase58(num):

r = num % 58

sb = sb + ALPHABET[r]

return sb[::-1]

 

s = 25420294593250030202636073700053352635053786165627414518

b = convertToBase58(s)

 

hash_arr = [0x61, 0x626262, 0x636363, 0x73696d706c792061206c6f6e6720737472696e67, 0x516b6fcd0f, 0xbf4f89001e670274dd, 0x572e4794, 0xecac89cad93923c02321, 0x10c8511e]

for num in hash_arr:

b = convertToBase58(num)

{{out}}

<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

===Composition of pure functions===

{{Works with|Python|3.7}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Base 58 check encoding:

=={{header|Quackery}}==

 

$ "123456789ABCDEFGHJKLMNPQRSTUV"

 

witheach [ base58$ echo$ cr ]

 

{{out}}

=={{header|Racket}}==

(Examples from some other task)

 

(define ((base-n-alphabet-encode alphabet) hash-string (in-base 16))

"0x572e4794"

"0xecac89cad93923c02321"

{{out}}

<pre>"6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"

=={{header|Raku}}==

(formerly Perl 6)

constant @codes = <

1 2 3 4 5 6 7 8 9

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

}

 

=={{header|REXX}}==

I get the result expected there.

Apart for the leading 1 the program works also for the inputs shown above.

s="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

Numeric Digits 100

End

o=o||substr(s,1,1)

{{out}}

<pre>16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM</pre>

===version 2===

does what the others do

s="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

Numeric Digits 1000

Say 'found :' o

End

{{out}}

<pre>expected: check_error_handlimng

 

The algorithm used doesn't need to &nbsp; ''reverse'' &nbsp; the residual string &nbsp; (it uses &nbsp; ''prepend'' &nbsp; instead of &nbsp; ''append'').

/* 0─────────────────I─────O────────────────────l──────────────── ◄───omit.*/

@= space(" 123456789ABCDEFGH JKLMN PQRSTUVWXYZabcdefghi jkmnopqrstuvwxyz", 0)

return right(oz, 60) "───►" left('', L1, 0)$ /*for showing arg and the residual. */

 

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

'ECAC89CAD93923C02321'x ───► 000EJDM8drfXA6uyA

'10C8511E'x ───► Rt5zm

</pre>

 

=={{header|Ruby}}==

nums = [25420294593250030202636073700053352635053786165627414518,

0x61,

 

puts nums.map{|n| n.digits(58).reverse.map{|i| ALPHABET[i]}.join}

{{out}}

<pre>6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

=={{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)].

object Base58 extends App {

}

 

 

=={{header|Seed7}}==

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.

include "encoding.s7i";

 

writeln("16#" <& num radix 16 rpad 53 <& " -> " <& b);

end for;

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

static chars = %w(

1 2 3 4 5 6 7 8 9

printf("%56s -> %s\n", num, encode_base58(num))

assert_eq(encode_base58(num), enc)

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Imports System.Text

 

End Sub

 

{{out}}

<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

 

var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

var b58 = convertToBase58.call(hash, 16)

Fmt.print("$-56s -> $s", hash, b58)

 

{{out}}

=={{header|zkl}}==

Uses libGMP

src="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv",

dst="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

0x516b6fcd0f, "bf4f89001e670274dd", 0x572e4794,

"ecac89cad93923c02321", 0x10c8511e);

{{out}}

<pre>