Base58Check encoding: Difference between revisions

{{trans|Python}}

 

 

F convertToBase58(=num)

L(num) hash_arr

b = convertToBase58(BigInt(num, radix' 16))

 

{{out}}

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

 

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

)

{{Out}}

<pre>Base 58 encoding:

{{trans|Kotlin}}

{{works with|Java|9}}

import java.util.List;

 

}

}

{{out}}

<pre>25420294593250030202636073700053352635053786165627414518 -> 6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM

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

<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: #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>

{{out}}

<pre>

 

=={{header|Picat}}==

Tests = [[25420294593250030202636073700053352635053786165627414518,"6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"],

["0x61","2g"],

X := X // 58,

Out := Out ++ [CodeS[Rem+1]]

 

{{out}}

 

=={{header|PicoLisp}}==

(chop "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz") )

(de b58 (S)

(println (b58 "25420294593250030202636073700053352635053786165627414518"))

(println (b58 "0x626262"))

{{out}}

<pre>

===Works with Python 3.9

{{trans|C#}}

 

def convertToBase58(num):

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>

 

=={{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}}

import "/fmt" for Fmt

 

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>