Bitcoin/address validation: Difference between revisions

{{alertbox|#ffff70|'''<big>Warning:</big>''' Many of these snippets are [[{{TALKPAGENAME}}#C-based_code_.28and_possibly_others.29_improperly_validates|incomplete]]. It is recommended that you use an established [https://en.bitcoin.it/wiki/Software#Libraries library] for any projects that are likely to see external use}}

{{task}}

 

 

<br>You can change a few characters in this string and check that it'll fail the test.

<br><br>

=={{header|Ada}}==

with Ada.Streams;

use Ada.Exceptions, Interfaces;

end;

end Bitcoin_Addr_Validate;

 

{{out}}

1A Na15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i validity: *** Error: Invalid BT address.

</pre>

=={{header|C}}==

#include <string.h>

#include <openssl/sha.h>

 

return 0;

Compile with -lcrypto

{{out}}

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I: bad char

</pre>

This requires [https://www.nuget.org/packages/NUnit/ NUnit package] to compile.

using System;

using System.Linq;

}

}

=={{header|D}}==

This requires the D module from the SHA-256 Task.

{{trans|Go}}

 

struct A25 {

writefln(`"%s": %s`, test, err.empty ? "OK." : err);

}

{{out}}

<pre>"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i": OK.

"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62iz": not Bitcoin version 0.

"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62izz": too long Bitcoin address.</pre>

 

=={{header|Delphi}}==

This requires [http://www.cityinthesky.co.uk/opensource/DCPcrypt/ DCPcrypt library] to compile.

uses

DCPsha256;

raise Exception.Create('Bad digest');

end;

=={{header|Erlang}}==

Using base58 module from http://github.com/titan098/erl-base58.git.

 

-module( bitcoin_address ).

 

{checksum, Checksum} = {checksum, Four_bytes},

ok.

{{out}}

<pre>

</pre>

=={{header|Factor}}==

math.parser sequences ;

IN: rosetta-code.bitcoin.validation

 

: btc-valid? ( str -- ? ) base58> [ btc-checksum ] [ 4 tail* ] bi = ;

 

{{out}}

"1ANNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" btc-valid? . ! f, data changed, original checksum.

</pre>

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Bitcoin address: 1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i is valid

Bitcoin address: 0AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i first character is not 1 or 3

Bitcoin address: 1AGNa15ZQXAZUgFlqJ2i7Z2DPU2J6hW62i bitcoin address contains illegal character</pre>

=={{header|Go}}==

{{trans|C}}

 

import (

os.Stderr.WriteString(m + "\n")

os.Exit(1)

{{out}}

Command line usage examples showing program exit status.

</pre>

=={{header|Haskell}}==

import Data.List (elemIndex)

import Data.Monoid ((<>))

validate "1ANa55215ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" -- too long

validate "i55j" -- too short

{{out}}

<pre style="font-size:80%">"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" -> Valid

"1ANa55215ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" -> "Address length exceeds 25 bytes"

"i55j" -> "Address length less than 4 bytes"</pre>

=={{header|Java}}==

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

throw new AssertionError(String.format("Expected %s for %s, but got %s.", expected, address, actual));

}

=={{header|Julia}}==

{{works with|Julia|0.6}}

{{trans|Python}}

 

bytes(n::Integer, l::Int) = collect(UInt8, (n >> 8i) & 0xFF for i in l-1:-1:0)

for (addr, corr) in addresses

println("Address: $addr\nExpected: $corr\tChecked: ", checkbcaddress(addr))

 

{{out}}

Address: 1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62iz

Expected: false Checked: false</pre>

=={{header|Kotlin}}==

{{trans|Java}}

 

object Bitcoin {

for (address in addresses)

println("${address.padEnd(36)} -> ${if (Bitcoin.validateAddress(address)) "valid" else "invalid"}")

 

{{out}}

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I -> invalid

</pre>

 

=={{header|Oberon-2}}==

{{works with|oo2c}}{{libheader|Crypto}}

MODULE BitcoinAddress;

IMPORT

Out.Bool(Valid("1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I"));Out.Ln

END BitcoinAddress.

{{out}}

<pre>

FALSE

</pre>

=={{header|Perl}}==

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

(pack 'C*', @byte[21..24]) eq

substr sha256(sha256 pack 'C*', @byte[0..20]), 0, 4;

=={{header|PHP}}==

function validate($address){

$decoded = decodeBase58($address);

main();

 

 

{{out}}

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I: invalid character found

</pre>

=={{header|PicoLisp}}==

 

(setq *Alphabet

(valid "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62!")

(valid "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62iz")

=={{header|PureBasic}}==

; using PureBasic 5.50 (x64)

EnableExplicit

EndIf

 

 

{{out}}

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I -> Invalid

</pre>

=={{header|Python}}==

 

digits58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

 

print(check_bc('1AGNa15ZQXAZUgFiqJ3i7Z2DPU2J6hW62i'))

 

{{out}}

:Yuuki-chan edit: Delete this help if it's not needed anymore

:For those looking at examples here to try and work out what is required, the <code>n.to_bytes()</code> call is equivalent to this code which converts a (long) integer into individual bytes of a byte array in a particular order:

>>> length = 25

>>> list( reversed(range(length)) )

[24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

>>> assert n.to_bytes(length, 'big') == bytes( (n >> i*8) & 0xff for i in reversed(range(length)))

=={{header|Racket}}==

#lang racket/base

 

(validate-bitcoin-address "1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nK9") ; => #t

(validate-bitcoin-address "1badbadbadbadbadbadbadbadbadbadbad") ; => #f

 

=={{header|Ruby}}==

# Validate Bitcoin address

#

(n.length...42).each{n.insert(0,'0')}

puts "I think the checksum should be #{g}\nI calculate that it is #{Digest::SHA256.hexdigest(Digest::SHA256.digest(convert(n)))[0,8]}"

{{out}}

With A = '1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i'

I calculate that it is c046b2ff

</pre>

=={{header|Rust}}==

This requires the [https://crates.io/crates/rust-crypto rust-crypto] crate for sha256.

extern crate crypto;

 

Ok(res)

}

{{out}}

<pre>

false

</pre>

=={{header|Scala}}==

import java.util.Arrays.copyOfRange

 

 

private def bitcoinTestHarness(address: String, expected: Boolean): Unit =

 

def sha256(data: Array[Byte]) = {

val md: MessageDigest = MessageDigest.getInstance("SHA-256")

println(s"Successfully completed without errors. [total ${scala.compat.Platform.currentTime - executionStart}ms]")

 

=={{header|Tcl}}==

{{tcllib|sha256}}

 

# Generate a large and boring piece of code to do the decoding of

}

return "$address is ok"

Testing if it works

{{out}}

<pre>

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i is ok

</pre>

=={{header|UNIX Shell}}==

{{works with|bash}}

bitcoinregex="^[$(printf "%s" "${base58[@]}")]{34}$"

 

else return 2

fi

 

=={{header|zkl}}==

Uses shared library zklMsgHash.

const symbols="123456789" // 58 characters: no cap i,o; ell, zero

"ABCDEFGHJKLMNPQRSTUVWXYZ"

(2).reduce(MsgHash.SHA256.fp1(1,dec),dec); // dec is i/o buffer

dec[0,4]==chkSum;

"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62X", // checksum changed, original data.

"1ANNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i", // data changed, original checksum.

"1A Na15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i", // invalid chars

"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62izz", // too long

{{out}}

<pre>L(True,True,False,False,False,False)</pre>