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

 

Write a program that takes a [[wp:bitcoin|bitcoin address]] as argument,

and checks whether or not this address is valid.

 

 

With this encoding, a bitcoin address encodes 25 bytes:

* the next twenty bytes are a [[RIPEMD-160]] digest, but you don't have to know that for this task: you can consider them a pure arbitrary data ;

* the last four bytes are a checksum check. They are the first four bytes of a double [[SHA-256]] digest of the previous 21 bytes.

 

To check the bitcoin address, you must read the first twenty-one bytes, compute the checksum, and check that it corresponds to the last four bytes.

You can use a digest library for [[SHA-256]].

 

 

 

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

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

 

-module( bitcoin_address ).

 

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

ok.

{{out}}

<pre>

in call from bitcoin_address:task/0 (src/bitcoin_address.erl, line 9)

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

 

-- Convert from base58 encoded value to Integer

decode58 :: String -> Maybe Integer

 

 

 

-- Run one validity check and display results.

validate :: String -> IO ()

 

-- Run some validity check tests.

validate "1A Na15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" -- invalid chars

validate "1ANa55215ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" -- too long

{{out}}

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

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

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

=={{header|Mathematica}} / {{header|Wolfram Language}}==

IntegerDigits[

FromDigits[

Hash[FromCharacterCode[

IntegerDigits[Hash[FromCharacterCode[data[[;; -5]]], "SHA256"],

{{in}}

<pre>1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i

<pre>True

False</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|Python}}==

 

digits58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

return n.to_bytes(length, 'big')

def check_bc(bc):

 

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

 

fcn unbase58(str){ // --> Data (byte bucket)

out[idx]=c;

},n) : if(_) throw(Exception.ValueError("address too long"));

});

 

fcn coinValide(addr){

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