func TestBase58Check(t *testing.T) {
for x, test := range checkEncodingStringTests {
var ver [2]byte
ver[0] = test.version
ver[1] = 0
// test encoding
if res := base58.CheckEncode([]byte(test.in), ver); res != test.out {
t.Errorf("CheckEncode test #%d failed: got %s, want: %s", x, res, test.out)
}
// test decoding
res, version, err := base58.CheckDecode(test.out)
if err != nil {
t.Errorf("CheckDecode test #%d failed with err: %v", x, err)
} else if version != ver {
t.Errorf("CheckDecode test #%d failed: got version: %d want: %d", x, version, ver)
} else if string(res) != test.in {
t.Errorf("CheckDecode test #%d failed: got: %s want: %s", x, res, test.in)
}
}
// test the two decoding failure cases
// case 1: checksum error
_, _, err := base58.CheckDecode("Axk2WA6M")
if err != base58.ErrChecksum {
t.Error("Checkdecode test failed, expected ErrChecksum")
}
// case 2: invalid formats (string lengths below 5 mean the version byte and/or the checksum
// bytes are missing).
testString := ""
for len := 0; len < 4; len++ {
// make a string of length `len`
_, _, err = base58.CheckDecode(testString)
if err != base58.ErrInvalidFormat {
t.Error("Checkdecode test failed, expected ErrInvalidFormat")
}
}
}
// This example demonstrates how to decode Base58Check encoded data.
func ExampleCheckDecode() {
// Decode an example Base58Check encoded data.
encoded := "11Jd3UC9A6K74nhNDieHobyxT1hyRfhHDWQQ81CcUT4EMFdXZTpJemXF5s8FiZ"
decoded, version, err := base58.CheckDecode(encoded)
if err != nil {
fmt.Println(err)
return
}
// Show the decoded data.
fmt.Printf("Decoded data: %x\n", decoded)
fmt.Println("Version Byte:", version)
// Output:
// Decoded data: 36326539303762313563626632376435343235333939656266366630666235306562623838663138
// Version Byte: [0 0]
}
// DecodeAddress decodes the string encoding of an address and returns
// the Address if addr is a valid encoding for a known address type on
// the network provided.
func DecodeAddress(addr string, defaultNet *chaincfg.Params) (Address, error) {
// Switch on decoded length to determine the type.
decoded, netID, err := base58.CheckDecode(addr)
if err != nil {
if err == base58.ErrChecksum {
return nil, ErrChecksumMismatch
}
return nil, fmt.Errorf("decoded address is of unknown format: %v",
err.Error())
}
if defaultNet == nil {
return nil, ErrMissingDefaultNet
}
switch netID {
case defaultNet.PubKeyAddrID:
// First byte is the signature suite and ybit.
suite := decoded[0]
suite &= ^uint8(1 << 7)
ybit := !(decoded[0]&(1<<7) == 0)
switch int(suite) {
case chainec.ECTypeSecp256k1:
if len(decoded) == 33 {
toAppend := uint8(0x02)
if ybit {
toAppend = 0x03
}
return NewAddressSecpPubKey(
append([]byte{toAppend}, decoded[1:]...),
defaultNet)
}
case chainec.ECTypeEdwards:
if len(decoded) == 33 {
return NewAddressEdwardsPubKey(decoded, defaultNet)
}
case chainec.ECTypeSecSchnorr:
if len(decoded) == 33 {
toAppend := uint8(0x02)
if ybit {
toAppend = 0x03
}
return NewAddressSecSchnorrPubKey(
append([]byte{toAppend}, decoded[1:]...),
defaultNet)
}
}
return nil, ErrUnknownAddressType
case defaultNet.PubKeyHashAddrID:
return NewAddressPubKeyHash(decoded, defaultNet, chainec.ECTypeSecp256k1)
case defaultNet.PKHEdwardsAddrID:
return NewAddressPubKeyHash(decoded, defaultNet, chainec.ECTypeEdwards)
case defaultNet.PKHSchnorrAddrID:
return NewAddressPubKeyHash(decoded, defaultNet, chainec.ECTypeSecSchnorr)
case defaultNet.ScriptHashAddrID:
return NewAddressScriptHashFromHash(decoded, defaultNet)
default:
return nil, ErrUnknownAddressType
}
}
