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;

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

</pre>

=={{header|C}}==

#include <string.h>

#include <openssl/sha.h>

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I: bad char

</pre>

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

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

using System;

using System.Linq;

}

</syntaxhighlight>

=={{header|D}}==

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

{{trans|Go}}

 

struct A25 {

"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62iz": not Bitcoin version 0.

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

=={{header|dart}}==

This requires [https://pub.dev/packages/crypto Crypto package] to compile.

{{trans|Java}}

 

class Bitcoin {

"1BNGaR29FmfAqidXmD9HLws" false

</pre>

=={{header|Delphi}}==

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

uses

DCPsha256;

end;

</syntaxhighlight>

=={{header|Erlang}}==

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

 

-module( bitcoin_address ).

 

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

</pre>

=={{header|Factor}}==

math.parser sequences ;

IN: rosetta-code.bitcoin.validation

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

</pre>

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

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

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

=={{header|Go}}==

{{trans|C}}

 

import (

1

</pre>

=={{header|Haskell}}==

import Data.List (elemIndex)

import Data.Monoid ((<>))

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

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

=={{header|Java}}==

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

}

}</syntaxhighlight>

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

Address: 1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62iz

Expected: false Checked: false</pre>

=={{header|Kotlin}}==

{{trans|Java}}

 

object Bitcoin {

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I -> invalid

</pre>

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

IntegerDigits[

FromDigits[

<pre>True

False</pre>

=={{header|Nim}}==

Tests on first digit character and on address length have been added to detect wrong addresses such as "BZbvjr".

===Using “libssl”===

 

 

const SHA256Len = 32

===Using “nimcrypto”===

{{libheader|nimcrypto}}

import strformat

 

Address “1111111111111111111114oLvT2” is valid.

Address “BZbvjr” is invalid (starting character is not 1 or 3).</pre>

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

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

MODULE BitcoinAddress;

IMPORT

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

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

}</syntaxhighlight>

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\bitcoin_address_validation.exw

<!--</syntaxhighlight>-->

(No output other than "done" since all tests pass)

=={{header|PHP}}==

function validate($address){

$decoded = decodeBase58($address);

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I: invalid character found

</pre>

=={{header|PicoLisp}}==

 

(setq *Alphabet

(valid "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62iz")

(valid "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62izz") ) )</syntaxhighlight>

=={{header|PureBasic}}==

; using PureBasic 5.50 (x64)

EnableExplicit

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I -> Invalid

</pre>

=={{header|Python}}==

 

digits58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

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

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

>>> </syntaxhighlight>

=={{header|Racket}}==

#lang racket/base

 

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

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

given run <openssl dgst -sha256 -binary>, :in, :out, :bin {

.in.write: $b;

{{out}}

<pre>｢1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i｣</pre>

=={{header|Ruby}}==

# Validate Bitcoin address

#

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;

 

false

</pre>

=={{header|Scala}}==

import java.util.Arrays.copyOfRange

 

 

}</syntaxhighlight>

=={{header|Seed7}}==

The Seed7 library [http://seed7.sourceforge.net/libraries/encoding.htm encoding.s7i] defines

No external library is needed.

 

include "msgdigest.s7i";

include "encoding.s7i";

16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM: TRUE

</pre>

=={{header|Tcl}}==

{{tcllib|sha256}}

 

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

}</syntaxhighlight>

Testing if it works

puts [bitcoin_addressValid 1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i]</syntaxhighlight>

{{out}}

1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i is ok

</pre>

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

{{works with|bash}}

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

 

fi

}</syntaxhighlight>

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|wren-str}}

{{libheader|Wren-fmt}}

 

class Bitcoin {

=={{header|zkl}}==

Uses shared library zklMsgHash.

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

"ABCDEFGHJKLMNPQRSTUVWXYZ"

dec[0,4]==chkSum;

}</syntaxhighlight>

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

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

{{out}}

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