_address_test.go raw
1 package btcaddr_test
2
3 import (
4 "bytes"
5 "encoding/hex"
6 "fmt"
7 "github.com/p9c/p9/pkg/btcaddr"
8 "reflect"
9 "strings"
10 "testing"
11
12 "github.com/btcsuite/golangcrypto/ripemd160"
13
14 "github.com/p9c/p9/pkg/chaincfg"
15 "github.com/p9c/p9/pkg/util"
16 )
17
18 func TestAddresses(t *testing.T) {
19 tests := []struct {
20 name string
21 addr string
22 encoded string
23 valid bool
24 result btcaddr.Address
25 f func() (btcaddr.Address, error)
26 net *chaincfg.Params
27 }{
28 // Positive P2PKH tests.
29 {
30 name: "mainnet p2pkh",
31 addr: "1MirQ9bwyQcGVJPwKUgapu5ouK2E2Ey4gX",
32 encoded: "1MirQ9bwyQcGVJPwKUgapu5ouK2E2Ey4gX",
33 valid: true,
34 result: btcaddr.Address(
35 [ripemd160.Size]byte{
36 0xe3, 0x4c, 0xce, 0x70, 0xc8, 0x63, 0x73, 0x27, 0x3e, 0xfc,
37 0xc5, 0x4c, 0xe7, 0xd2, 0xa4, 0x91, 0xbb, 0x4a, 0x0e, 0x84,
38 },
39 chaincfg.MainNetParams.PubKeyHashAddrID,
40 ),
41 f: func() (btcaddr.Address, error) {
42 pkHash := []byte{
43 0xe3, 0x4c, 0xce, 0x70, 0xc8, 0x63, 0x73, 0x27, 0x3e, 0xfc,
44 0xc5, 0x4c, 0xe7, 0xd2, 0xa4, 0x91, 0xbb, 0x4a, 0x0e, 0x84,
45 }
46 return btcaddr.NewPubKeyHash(pkHash, &chaincfg.MainNetParams)
47 },
48 net: &chaincfg.MainNetParams,
49 },
50 {
51 name: "mainnet p2pkh 2",
52 addr: "12MzCDwodF9G1e7jfwLXfR164RNtx4BRVG",
53 encoded: "12MzCDwodF9G1e7jfwLXfR164RNtx4BRVG",
54 valid: true,
55 result: util.TstAddressPubKeyHash(
56 [ripemd160.Size]byte{
57 0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0xf4,
58 0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xaa,
59 },
60 chaincfg.MainNetParams.PubKeyHashAddrID,
61 ),
62 f: func() (btcaddr.Address, error) {
63 pkHash := []byte{
64 0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0xf4,
65 0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xaa,
66 }
67 return btcaddr.NewPubKeyHash(pkHash, &chaincfg.MainNetParams)
68 },
69 net: &chaincfg.MainNetParams,
70 },
71 {
72 name: "testnet p2pkh",
73 addr: "mrX9vMRYLfVy1BnZbc5gZjuyaqH3ZW2ZHz",
74 encoded: "mrX9vMRYLfVy1BnZbc5gZjuyaqH3ZW2ZHz",
75 valid: true,
76 result: util.TstAddressPubKeyHash(
77 [ripemd160.Size]byte{
78 0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83,
79 0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f,
80 },
81 chaincfg.TestNet3Params.PubKeyHashAddrID,
82 ),
83 f: func() (btcaddr.Address, error) {
84 pkHash := []byte{
85 0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83,
86 0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f,
87 }
88 return btcaddr.NewPubKeyHash(pkHash, &chaincfg.TestNet3Params)
89 },
90 net: &chaincfg.TestNet3Params,
91 },
92 // Negative P2PKH tests.
93 {
94 name: "p2pkh wrong hash length",
95 addr: "",
96 valid: false,
97 f: func() (btcaddr.Address, error) {
98 pkHash := []byte{
99 0x00, 0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b,
100 0xf4, 0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad,
101 0xaa,
102 }
103 return btcaddr.NewPubKeyHash(pkHash, &chaincfg.MainNetParams)
104 },
105 net: &chaincfg.MainNetParams,
106 },
107 {
108 name: "p2pkh bad checksum",
109 addr: "1MirQ9bwyQcGVJPwKUgapu5ouK2E2Ey4gY",
110 valid: false,
111 net: &chaincfg.MainNetParams,
112 },
113 // Positive P2SH tests.
114 {
115 // Taken from transactions:
116 // output: 3c9018e8d5615c306d72397f8f5eef44308c98fb576a88e030c25456b4f3a7ac
117 // input: 837dea37ddc8b1e3ce646f1a656e79bbd8cc7f558ac56a169626d649ebe2a3ba.
118 name: "mainnet p2sh",
119 addr: "3QJmV3qfvL9SuYo34YihAf3sRCW3qSinyC",
120 encoded: "3QJmV3qfvL9SuYo34YihAf3sRCW3qSinyC",
121 valid: true,
122 result: util.TstAddressScriptHash(
123 [ripemd160.Size]byte{
124 0xf8, 0x15, 0xb0, 0x36, 0xd9, 0xbb, 0xbc, 0xe5, 0xe9, 0xf2,
125 0xa0, 0x0a, 0xbd, 0x1b, 0xf3, 0xdc, 0x91, 0xe9, 0x55, 0x10,
126 },
127 chaincfg.MainNetParams.ScriptHashAddrID,
128 ),
129 f: func() (btcaddr.Address, error) {
130 script := []byte{
131 0x52, 0x41, 0x04, 0x91, 0xbb, 0xa2, 0x51, 0x09, 0x12, 0xa5,
132 0xbd, 0x37, 0xda, 0x1f, 0xb5, 0xb1, 0x67, 0x30, 0x10, 0xe4,
133 0x3d, 0x2c, 0x6d, 0x81, 0x2c, 0x51, 0x4e, 0x91, 0xbf, 0xa9,
134 0xf2, 0xeb, 0x12, 0x9e, 0x1c, 0x18, 0x33, 0x29, 0xdb, 0x55,
135 0xbd, 0x86, 0x8e, 0x20, 0x9a, 0xac, 0x2f, 0xbc, 0x02, 0xcb,
136 0x33, 0xd9, 0x8f, 0xe7, 0x4b, 0xf2, 0x3f, 0x0c, 0x23, 0x5d,
137 0x61, 0x26, 0xb1, 0xd8, 0x33, 0x4f, 0x86, 0x41, 0x04, 0x86,
138 0x5c, 0x40, 0x29, 0x3a, 0x68, 0x0c, 0xb9, 0xc0, 0x20, 0xe7,
139 0xb1, 0xe1, 0x06, 0xd8, 0xc1, 0x91, 0x6d, 0x3c, 0xef, 0x99,
140 0xaa, 0x43, 0x1a, 0x56, 0xd2, 0x53, 0xe6, 0x92, 0x56, 0xda,
141 0xc0, 0x9e, 0xf1, 0x22, 0xb1, 0xa9, 0x86, 0x81, 0x8a, 0x7c,
142 0xb6, 0x24, 0x53, 0x2f, 0x06, 0x2c, 0x1d, 0x1f, 0x87, 0x22,
143 0x08, 0x48, 0x61, 0xc5, 0xc3, 0x29, 0x1c, 0xcf, 0xfe, 0xf4,
144 0xec, 0x68, 0x74, 0x41, 0x04, 0x8d, 0x24, 0x55, 0xd2, 0x40,
145 0x3e, 0x08, 0x70, 0x8f, 0xc1, 0xf5, 0x56, 0x00, 0x2f, 0x1b,
146 0x6c, 0xd8, 0x3f, 0x99, 0x2d, 0x08, 0x50, 0x97, 0xf9, 0x97,
147 0x4a, 0xb0, 0x8a, 0x28, 0x83, 0x8f, 0x07, 0x89, 0x6f, 0xba,
148 0xb0, 0x8f, 0x39, 0x49, 0x5e, 0x15, 0xfa, 0x6f, 0xad, 0x6e,
149 0xdb, 0xfb, 0x1e, 0x75, 0x4e, 0x35, 0xfa, 0x1c, 0x78, 0x44,
150 0xc4, 0x1f, 0x32, 0x2a, 0x18, 0x63, 0xd4, 0x62, 0x13, 0x53,
151 0xae,
152 }
153 return btcaddr.NewScriptHash(script, &chaincfg.MainNetParams)
154 },
155 net: &chaincfg.MainNetParams,
156 },
157 {
158 // Taken from transactions:
159 // output: b0539a45de13b3e0403909b8bd1a555b8cbe45fd4e3f3fda76f3a5f52835c29d
160 // input: (not yet redeemed at time test was written)
161 name: "mainnet p2sh 2",
162 addr: "3NukJ6fYZJ5Kk8bPjycAnruZkE5Q7UW7i8",
163 encoded: "3NukJ6fYZJ5Kk8bPjycAnruZkE5Q7UW7i8",
164 valid: true,
165 result: util.TstAddressScriptHash(
166 [ripemd160.Size]byte{
167 0xe8, 0xc3, 0x00, 0xc8, 0x79, 0x86, 0xef, 0xa8, 0x4c, 0x37,
168 0xc0, 0x51, 0x99, 0x29, 0x01, 0x9e, 0xf8, 0x6e, 0xb5, 0xb4,
169 },
170 chaincfg.MainNetParams.ScriptHashAddrID,
171 ),
172 f: func() (btcaddr.Address, error) {
173 hash := []byte{
174 0xe8, 0xc3, 0x00, 0xc8, 0x79, 0x86, 0xef, 0xa8, 0x4c, 0x37,
175 0xc0, 0x51, 0x99, 0x29, 0x01, 0x9e, 0xf8, 0x6e, 0xb5, 0xb4,
176 }
177 return btcaddr.NewScriptHashFromHash(hash, &chaincfg.MainNetParams)
178 },
179 net: &chaincfg.MainNetParams,
180 },
181 {
182 // Taken from bitcoind base58_keys_valid.
183 name: "testnet p2sh",
184 addr: "2NBFNJTktNa7GZusGbDbGKRZTxdK9VVez3n",
185 encoded: "2NBFNJTktNa7GZusGbDbGKRZTxdK9VVez3n",
186 valid: true,
187 result: util.TstAddressScriptHash(
188 [ripemd160.Size]byte{
189 0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e,
190 0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a,
191 },
192 chaincfg.TestNet3Params.ScriptHashAddrID,
193 ),
194 f: func() (btcaddr.Address, error) {
195 hash := []byte{
196 0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e,
197 0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a,
198 }
199 return btcaddr.NewScriptHashFromHash(hash, &chaincfg.TestNet3Params)
200 },
201 net: &chaincfg.TestNet3Params,
202 },
203 // Negative P2SH tests.
204 {
205 name: "p2sh wrong hash length",
206 addr: "",
207 valid: false,
208 f: func() (btcaddr.Address, error) {
209 hash := []byte{
210 0x00, 0xf8, 0x15, 0xb0, 0x36, 0xd9, 0xbb, 0xbc, 0xe5, 0xe9,
211 0xf2, 0xa0, 0x0a, 0xbd, 0x1b, 0xf3, 0xdc, 0x91, 0xe9, 0x55,
212 0x10,
213 }
214 return btcaddr.NewScriptHashFromHash(hash, &chaincfg.MainNetParams)
215 },
216 net: &chaincfg.MainNetParams,
217 },
218 // Positive P2PK tests.
219 {
220 name: "mainnet p2pk compressed (0x02)",
221 addr: "02192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4",
222 encoded: "13CG6SJ3yHUXo4Cr2RY4THLLJrNFuG3gUg",
223 valid: true,
224 result: util.TstAddressPubKey(
225 []byte{
226 0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
227 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
228 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
229 0x52, 0xc6, 0xb4,
230 },
231 btcaddr.PKFCompressed, chaincfg.MainNetParams.PubKeyHashAddrID,
232 ),
233 f: func() (btcaddr.Address, error) {
234 serializedPubKey := []byte{
235 0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
236 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
237 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
238 0x52, 0xc6, 0xb4,
239 }
240 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.MainNetParams)
241 },
242 net: &chaincfg.MainNetParams,
243 },
244 {
245 name: "mainnet p2pk compressed (0x03)",
246 addr: "03b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65",
247 encoded: "15sHANNUBSh6nDp8XkDPmQcW6n3EFwmvE6",
248 valid: true,
249 result: util.TstAddressPubKey(
250 []byte{
251 0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
252 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
253 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
254 0xb1, 0x6e, 0x65,
255 },
256 btcaddr.PKFCompressed, chaincfg.MainNetParams.PubKeyHashAddrID,
257 ),
258 f: func() (btcaddr.Address, error) {
259 serializedPubKey := []byte{
260 0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
261 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
262 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
263 0xb1, 0x6e, 0x65,
264 }
265 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.MainNetParams)
266 },
267 net: &chaincfg.MainNetParams,
268 },
269 {
270 name: "mainnet p2pk uncompressed (0x04)",
271 addr: "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2" +
272 "e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3",
273 encoded: "12cbQLTFMXRnSzktFkuoG3eHoMeFtpTu3S",
274 valid: true,
275 result: util.TstAddressPubKey(
276 []byte{
277 0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b,
278 0x49, 0x84, 0x0f, 0x8c, 0x53, 0xbc, 0x1e, 0xb6, 0x8a, 0x38,
279 0x2e, 0x97, 0xb1, 0x48, 0x2e, 0xca, 0xd7, 0xb1, 0x48, 0xa6,
280 0x90, 0x9a, 0x5c, 0xb2, 0xe0, 0xea, 0xdd, 0xfb, 0x84, 0xcc,
281 0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
282 0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
283 0xf6, 0x56, 0xb4, 0x12, 0xa3,
284 },
285 btcaddr.PKFUncompressed, chaincfg.MainNetParams.PubKeyHashAddrID,
286 ),
287 f: func() (btcaddr.Address, error) {
288 serializedPubKey := []byte{
289 0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b,
290 0x49, 0x84, 0x0f, 0x8c, 0x53, 0xbc, 0x1e, 0xb6, 0x8a, 0x38,
291 0x2e, 0x97, 0xb1, 0x48, 0x2e, 0xca, 0xd7, 0xb1, 0x48, 0xa6,
292 0x90, 0x9a, 0x5c, 0xb2, 0xe0, 0xea, 0xdd, 0xfb, 0x84, 0xcc,
293 0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
294 0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
295 0xf6, 0x56, 0xb4, 0x12, 0xa3,
296 }
297 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.MainNetParams)
298 },
299 net: &chaincfg.MainNetParams,
300 },
301 {
302 name: "mainnet p2pk hybrid (0x06)",
303 addr: "06192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4" +
304 "0d45264838c0bd96852662ce6a847b197376830160c6d2eb5e6a4c44d33f453e",
305 encoded: "1Ja5rs7XBZnK88EuLVcFqYGMEbBitzchmX",
306 valid: true,
307 result: util.TstAddressPubKey(
308 []byte{
309 0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
310 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
311 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
312 0x52, 0xc6, 0xb4, 0x0d, 0x45, 0x26, 0x48, 0x38, 0xc0, 0xbd,
313 0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
314 0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
315 0x44, 0xd3, 0x3f, 0x45, 0x3e,
316 },
317 btcaddr.PKFHybrid, chaincfg.MainNetParams.PubKeyHashAddrID,
318 ),
319 f: func() (btcaddr.Address, error) {
320 serializedPubKey := []byte{
321 0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
322 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
323 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
324 0x52, 0xc6, 0xb4, 0x0d, 0x45, 0x26, 0x48, 0x38, 0xc0, 0xbd,
325 0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
326 0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
327 0x44, 0xd3, 0x3f, 0x45, 0x3e,
328 }
329 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.MainNetParams)
330 },
331 net: &chaincfg.MainNetParams,
332 },
333 {
334 name: "mainnet p2pk hybrid (0x07)",
335 addr: "07b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65" +
336 "37a576782eba668a7ef8bd3b3cfb1edb7117ab65129b8a2e681f3c1e0908ef7b",
337 encoded: "1ExqMmf6yMxcBMzHjbj41wbqYuqoX6uBLG",
338 valid: true,
339 result: util.TstAddressPubKey(
340 []byte{
341 0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
342 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
343 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
344 0xb1, 0x6e, 0x65, 0x37, 0xa5, 0x76, 0x78, 0x2e, 0xba, 0x66,
345 0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
346 0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
347 0x1e, 0x09, 0x08, 0xef, 0x7b,
348 },
349 btcaddr.PKFHybrid, chaincfg.MainNetParams.PubKeyHashAddrID,
350 ),
351 f: func() (btcaddr.Address, error) {
352 serializedPubKey := []byte{
353 0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
354 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
355 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
356 0xb1, 0x6e, 0x65, 0x37, 0xa5, 0x76, 0x78, 0x2e, 0xba, 0x66,
357 0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
358 0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
359 0x1e, 0x09, 0x08, 0xef, 0x7b,
360 }
361 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.MainNetParams)
362 },
363 net: &chaincfg.MainNetParams,
364 },
365 {
366 name: "testnet p2pk compressed (0x02)",
367 addr: "02192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4",
368 encoded: "mhiDPVP2nJunaAgTjzWSHCYfAqxxrxzjmo",
369 valid: true,
370 result: util.TstAddressPubKey(
371 []byte{
372 0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
373 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
374 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
375 0x52, 0xc6, 0xb4,
376 },
377 btcaddr.PKFCompressed, chaincfg.TestNet3Params.PubKeyHashAddrID,
378 ),
379 f: func() (btcaddr.Address, error) {
380 serializedPubKey := []byte{
381 0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
382 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
383 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
384 0x52, 0xc6, 0xb4,
385 }
386 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.TestNet3Params)
387 },
388 net: &chaincfg.TestNet3Params,
389 },
390 {
391 name: "testnet p2pk compressed (0x03)",
392 addr: "03b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65",
393 encoded: "mkPETRTSzU8MZLHkFKBmbKppxmdw9qT42t",
394 valid: true,
395 result: util.TstAddressPubKey(
396 []byte{
397 0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
398 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
399 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
400 0xb1, 0x6e, 0x65,
401 },
402 btcaddr.PKFCompressed, chaincfg.TestNet3Params.PubKeyHashAddrID,
403 ),
404 f: func() (btcaddr.Address, error) {
405 serializedPubKey := []byte{
406 0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
407 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
408 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
409 0xb1, 0x6e, 0x65,
410 }
411 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.TestNet3Params)
412 },
413 net: &chaincfg.TestNet3Params,
414 },
415 {
416 name: "testnet p2pk uncompressed (0x04)",
417 addr: "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5" +
418 "cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3",
419 encoded: "mh8YhPYEAYs3E7EVyKtB5xrcfMExkkdEMF",
420 valid: true,
421 result: util.TstAddressPubKey(
422 []byte{
423 0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b,
424 0x49, 0x84, 0x0f, 0x8c, 0x53, 0xbc, 0x1e, 0xb6, 0x8a, 0x38,
425 0x2e, 0x97, 0xb1, 0x48, 0x2e, 0xca, 0xd7, 0xb1, 0x48, 0xa6,
426 0x90, 0x9a, 0x5c, 0xb2, 0xe0, 0xea, 0xdd, 0xfb, 0x84, 0xcc,
427 0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
428 0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
429 0xf6, 0x56, 0xb4, 0x12, 0xa3,
430 },
431 btcaddr.PKFUncompressed, chaincfg.TestNet3Params.PubKeyHashAddrID,
432 ),
433 f: func() (btcaddr.Address, error) {
434 serializedPubKey := []byte{
435 0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b,
436 0x49, 0x84, 0x0f, 0x8c, 0x53, 0xbc, 0x1e, 0xb6, 0x8a, 0x38,
437 0x2e, 0x97, 0xb1, 0x48, 0x2e, 0xca, 0xd7, 0xb1, 0x48, 0xa6,
438 0x90, 0x9a, 0x5c, 0xb2, 0xe0, 0xea, 0xdd, 0xfb, 0x84, 0xcc,
439 0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
440 0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
441 0xf6, 0x56, 0xb4, 0x12, 0xa3,
442 }
443 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.TestNet3Params)
444 },
445 net: &chaincfg.TestNet3Params,
446 },
447 {
448 name: "testnet p2pk hybrid (0x06)",
449 addr: "06192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b" +
450 "40d45264838c0bd96852662ce6a847b197376830160c6d2eb5e6a4c44d33f453e",
451 encoded: "my639vCVzbDZuEiX44adfTUg6anRomZLEP",
452 valid: true,
453 result: util.TstAddressPubKey(
454 []byte{
455 0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
456 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
457 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
458 0x52, 0xc6, 0xb4, 0x0d, 0x45, 0x26, 0x48, 0x38, 0xc0, 0xbd,
459 0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
460 0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
461 0x44, 0xd3, 0x3f, 0x45, 0x3e,
462 },
463 btcaddr.PKFHybrid, chaincfg.TestNet3Params.PubKeyHashAddrID,
464 ),
465 f: func() (btcaddr.Address, error) {
466 serializedPubKey := []byte{
467 0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
468 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
469 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
470 0x52, 0xc6, 0xb4, 0x0d, 0x45, 0x26, 0x48, 0x38, 0xc0, 0xbd,
471 0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
472 0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
473 0x44, 0xd3, 0x3f, 0x45, 0x3e,
474 }
475 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.TestNet3Params)
476 },
477 net: &chaincfg.TestNet3Params,
478 },
479 {
480 name: "testnet p2pk hybrid (0x07)",
481 addr: "07b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e6" +
482 "537a576782eba668a7ef8bd3b3cfb1edb7117ab65129b8a2e681f3c1e0908ef7b",
483 encoded: "muUnepk5nPPrxUTuTAhRqrpAQuSWS5fVii",
484 valid: true,
485 result: util.TstAddressPubKey(
486 []byte{
487 0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
488 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
489 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
490 0xb1, 0x6e, 0x65, 0x37, 0xa5, 0x76, 0x78, 0x2e, 0xba, 0x66,
491 0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
492 0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
493 0x1e, 0x09, 0x08, 0xef, 0x7b,
494 },
495 btcaddr.PKFHybrid, chaincfg.TestNet3Params.PubKeyHashAddrID,
496 ),
497 f: func() (btcaddr.Address, error) {
498 serializedPubKey := []byte{
499 0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
500 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
501 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
502 0xb1, 0x6e, 0x65, 0x37, 0xa5, 0x76, 0x78, 0x2e, 0xba, 0x66,
503 0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
504 0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
505 0x1e, 0x09, 0x08, 0xef, 0x7b,
506 }
507 return btcaddr.NewPubKey(serializedPubKey, &chaincfg.TestNet3Params)
508 },
509 net: &chaincfg.TestNet3Params,
510 },
511 // Segwit, address tests.
512 // {
513 // name: "segwit mainnet p2wpkh v0",
514 // addr: "BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4",
515 // encoded: "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4",
516 // valid: true,
517 // result: util.TstAddressWitnessPubKeyHash(
518 // 0,
519 // [20]byte{
520 // 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54, 0x94,
521 // 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
522 // },
523 // chaincfg.MainNetParams.Bech32HRPSegwit),
524 // f: func () (util.Address, error){
525 // pkHash := []byte{
526 // 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54, 0x94,
527 // 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
528 // }
529 // return util.NewAddressWitnessPubKeyHash(pkHash, &chaincfg.MainNetParams)
530 // },
531 // net: &chaincfg.MainNetParams,
532 // },
533 // {
534 // name: "segwit mainnet p2wsh v0",
535 // addr: "bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3",
536 // encoded: "bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3",
537 // valid: true,
538 // result: util.TstAddressWitnessScriptHash(
539 // 0,
540 // [32]byte{
541 // 0x18, 0x63, 0x14, 0x3c, 0x14, 0xc5, 0x16, 0x68,
542 // 0x04, 0xbd, 0x19, 0x20, 0x33, 0x56, 0xda, 0x13,
543 // 0x6c, 0x98, 0x56, 0x78, 0xcd, 0x4d, 0x27, 0xa1,
544 // 0xb8, 0xc6, 0x32, 0x96, 0x04, 0x90, 0x32, 0x62
545 // },
546 // chaincfg.MainNetParams.Bech32HRPSegwit),
547 // f: func () (util.Address, error){
548 // scriptHash := []byte{
549 // 0x18, 0x63, 0x14, 0x3c, 0x14, 0xc5, 0x16, 0x68,
550 // 0x04, 0xbd, 0x19, 0x20, 0x33, 0x56, 0xda, 0x13,
551 // 0x6c, 0x98, 0x56, 0x78, 0xcd, 0x4d, 0x27, 0xa1,
552 // 0xb8, 0xc6, 0x32, 0x96, 0x04, 0x90, 0x32, 0x62
553 // }
554 // return util.NewAddressWitnessScriptHash(scriptHash, &chaincfg.MainNetParams)
555 // },
556 // net: &chaincfg.MainNetParams,
557 // },
558 // {
559 // name: "segwit testnet p2wpkh v0",
560 // addr: "tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx",
561 // encoded: "tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx",
562 // valid: true,
563 // result: util.TstAddressWitnessPubKeyHash(
564 // 0,
565 // [20]byte{
566 // 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54, 0x94,
567 // 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
568 // },
569 // chaincfg.TestNet3Params.Bech32HRPSegwit),
570 // f: func () (util.Address, error){
571 // pkHash := []byte{
572 // 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54, 0x94,
573 // 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
574 // }
575 // return util.NewAddressWitnessPubKeyHash(pkHash, &chaincfg.TestNet3Params)
576 // },
577 // net: &chaincfg.TestNet3Params,
578 // },
579 // {
580 // name: "segwit testnet p2wsh v0",
581 // addr: "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7",
582 // encoded: "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7",
583 // valid: true,
584 // result: util.TstAddressWitnessScriptHash(
585 // 0,
586 // [32]byte{
587 // 0x18, 0x63, 0x14, 0x3c, 0x14, 0xc5, 0x16, 0x68,
588 // 0x04, 0xbd, 0x19, 0x20, 0x33, 0x56, 0xda, 0x13,
589 // 0x6c, 0x98, 0x56, 0x78, 0xcd, 0x4d, 0x27, 0xa1,
590 // 0xb8, 0xc6, 0x32, 0x96, 0x04, 0x90, 0x32, 0x62
591 // },
592 // chaincfg.TestNet3Params.Bech32HRPSegwit),
593 // f: func () (util.Address, error){
594 // scriptHash := []byte{
595 // 0x18, 0x63, 0x14, 0x3c, 0x14, 0xc5, 0x16, 0x68,
596 // 0x04, 0xbd, 0x19, 0x20, 0x33, 0x56, 0xda, 0x13,
597 // 0x6c, 0x98, 0x56, 0x78, 0xcd, 0x4d, 0x27, 0xa1,
598 // 0xb8, 0xc6, 0x32, 0x96, 0x04, 0x90, 0x32, 0x62
599 // }
600 // return util.NewAddressWitnessScriptHash(scriptHash, &chaincfg.TestNet3Params)
601 // },
602 // net: &chaincfg.TestNet3Params,
603 // },
604 // {
605 // name: "segwit testnet p2wsh witness v0",
606 // addr: "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy",
607 // encoded: "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy",
608 // valid: true,
609 // result: util.TstAddressWitnessScriptHash(
610 // 0,
611 // [32]byte{
612 // 0x00, 0x00, 0x00, 0xc4, 0xa5, 0xca, 0xd4, 0x62,
613 // 0x21, 0xb2, 0xa1, 0x87, 0x90, 0x5e, 0x52, 0x66,
614 // 0x36, 0x2b, 0x99, 0xd5, 0xe9, 0x1c, 0x6c, 0xe2,
615 // 0x4d, 0x16, 0x5d, 0xab, 0x93, 0xe8, 0x64, 0x33
616 // },
617 // chaincfg.TestNet3Params.Bech32HRPSegwit),
618 // f: func () (util.Address, error){
619 // scriptHash := []byte{
620 // 0x00, 0x00, 0x00, 0xc4, 0xa5, 0xca, 0xd4, 0x62,
621 // 0x21, 0xb2, 0xa1, 0x87, 0x90, 0x5e, 0x52, 0x66,
622 // 0x36, 0x2b, 0x99, 0xd5, 0xe9, 0x1c, 0x6c, 0xe2,
623 // 0x4d, 0x16, 0x5d, 0xab, 0x93, 0xe8, 0x64, 0x33
624 // }
625 // return util.NewAddressWitnessScriptHash(scriptHash, &chaincfg.TestNet3Params)
626 // },
627 // net: &chaincfg.TestNet3Params,
628 // },
629 // Unsupported witness versions (version 0 only supported at this point)
630 // {
631 // name: "segwit mainnet witness v1",
632 // addr: "bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k7grplx",
633 // valid: false,
634 // net: &chaincfg.MainNetParams,
635 // },
636 // {
637 // name: "segwit mainnet witness v16",
638 // addr: "BC1SW50QA3JX3S",
639 // valid: false,
640 // net: &chaincfg.MainNetParams,
641 // },
642 // {
643 // name: "segwit mainnet witness v2",
644 // addr: "bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj",
645 // valid: false,
646 // net: &chaincfg.MainNetParams,
647 // },
648 // Invalid segwit addresses
649 // {
650 // name: "segwit invalid hrp",
651 // addr: "tc1qw508d6qejxtdg4y5r3zarvary0c5xw7kg3g4ty",
652 // valid: false,
653 // net: &chaincfg.TestNet3Params,
654 // },
655 // {
656 // name: "segwit invalid checksum",
657 // addr: "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5",
658 // valid: false,
659 // net: &chaincfg.MainNetParams,
660 // },
661 // {
662 // name: "segwit invalid witness version",
663 // addr: "BC13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2",
664 // valid: false,
665 // net: &chaincfg.MainNetParams,
666 // },
667 // {
668 // name: "segwit invalid program length",
669 // addr: "bc1rw5uspcuh",
670 // valid: false,
671 // net: &chaincfg.MainNetParams,
672 // },
673 // {
674 // name: "segwit invalid program length",
675 // addr: "bc10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90",
676 // valid: false,
677 // net: &chaincfg.MainNetParams,
678 // },
679 // {
680 // name: "segwit invalid program length for witness version 0 (per BIP141)",
681 // addr: "BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P",
682 // valid: false,
683 // net: &chaincfg.MainNetParams,
684 // },
685 // {
686 // name: "segwit mixed case",
687 // addr: "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7",
688 // valid: false,
689 // net: &chaincfg.TestNet3Params,
690 // },
691 // {
692 // name: "segwit zero padding of more than 4 bits",
693 // addr: "tb1pw508d6qejxtdg4y5r3zarqfsj6c3",
694 // valid: false,
695 // net: &chaincfg.TestNet3Params,
696 // },
697 // {
698 // name: "segwit non-zero padding in 8-to-5 conversion",
699 // addr: "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv",
700 // valid: false,
701 // net: &chaincfg.TestNet3Params,
702 // },
703 }
704 for _, test := range tests {
705 // Decode addr and compare error against valid.
706 decoded, e := btcaddr.Decode(test.addr, test.net)
707 if (e == nil) != test.valid {
708 t.Errorf("%v: decoding test failed: %v", test.name, e)
709 return
710 }
711 if e == nil {
712 // Ensure the stringer returns the same address as the
713 // original.
714 if decodedStringer, ok := decoded.(fmt.Stringer); ok {
715 addr := test.addr
716 // For Segwit addresses the string representation
717 // will always be lower case, so in that case we
718 // convert the original to lower case first.
719 if strings.Contains(test.name, "segwit") {
720 addr = strings.ToLower(addr)
721 }
722 if addr != decodedStringer.String() {
723 t.Errorf(
724 "%v: String on decoded value does not match expected value: %v != %v",
725 test.name, test.addr, decodedStringer.String(),
726 )
727 return
728 }
729 }
730 // Encode again and compare against the original.
731 encoded := decoded.EncodeAddress()
732 if test.encoded != encoded {
733 t.Errorf(
734 "%v: decoding and encoding produced different addressess: %v != %v",
735 test.name, test.encoded, encoded,
736 )
737 return
738 }
739 // Perform type-specific calculations.
740 var saddr []byte
741 switch d := decoded.(type) {
742 case *btcaddr.PubKeyHash:
743 saddr = util.TstAddressSAddr(encoded)
744 case *btcaddr.ScriptHash:
745 saddr = util.TstAddressSAddr(encoded)
746 case *btcaddr.PubKey:
747 // Ignore the error here since the script
748 // address is checked below.
749 saddr, _ = hex.DecodeString(d.String())
750 // case *util.AddressWitnessPubKeyHash:
751 // saddr = util.TstAddressSegwitSAddr(encoded)
752 // case *util.AddressWitnessScriptHash:
753 // saddr = util.TstAddressSegwitSAddr(encoded)
754 }
755 // Chk script address, as well as the Hash160 method for P2PKH and
756 // P2SH addresses.
757 if !bytes.Equal(saddr, decoded.ScriptAddress()) {
758 t.Errorf(
759 "%v: script addresses do not match:\n%x != \n%x",
760 test.name, saddr, decoded.ScriptAddress(),
761 )
762 return
763 }
764 switch a := decoded.(type) {
765 case *btcaddr.PubKeyHash:
766 if h := a.Hash160()[:]; !bytes.Equal(saddr, h) {
767 t.Errorf(
768 "%v: hashes do not match:\n%x != \n%x",
769 test.name, saddr, h,
770 )
771 return
772 }
773 case *btcaddr.ScriptHash:
774 if h := a.Hash160()[:]; !bytes.Equal(saddr, h) {
775 t.Errorf(
776 "%v: hashes do not match:\n%x != \n%x",
777 test.name, saddr, h,
778 )
779 return
780 }
781 // case *util.AddressWitnessPubKeyHash:
782 // if hrp := a.Hrp(); test.net.Bech32HRPSegwit != hrp {
783 // t.Errorf("%v: hrps do not match:\n%x != \n%x",
784 // test.name, test.net.Bech32HRPSegwit, hrp)
785 // return
786 // }
787 // expVer := test.result.(*util.AddressWitnessPubKeyHash).WitnessVersion()
788 // if v := a.WitnessVersion(); v != expVer {
789 // t.Errorf("%v: witness versions do not match:\n%x != \n%x",
790 // test.name, expVer, v)
791 // return
792 // }
793 // if p := a.WitnessProgram(); !bytes.Equal(saddr, p) {
794 // t.Errorf("%v: witness programs do not match:\n%x != \n%x",
795 // test.name, saddr, p)
796 // return
797 // }
798 // case *util.AddressWitnessScriptHash:
799 // if hrp := a.Hrp(); test.net.Bech32HRPSegwit != hrp {
800 // t.Errorf("%v: hrps do not match:\n%x != \n%x",
801 // test.name, test.net.Bech32HRPSegwit, hrp)
802 // return
803 // }
804 // expVer := test.result.(*util.AddressWitnessScriptHash).WitnessVersion()
805 // if v := a.WitnessVersion(); v != expVer {
806 // t.Errorf("%v: witness versions do not match:\n%x != \n%x",
807 // test.name, expVer, v)
808 // return
809 // }
810 // if p := a.WitnessProgram(); !bytes.Equal(saddr, p) {
811 // t.Errorf("%v: witness programs do not match:\n%x != \n%x",
812 // test.name, saddr, p)
813 // return
814 // }
815 }
816 // Ensure the address is for the expected network.
817 if !decoded.IsForNet(test.net) {
818 t.Errorf(
819 "%v: calculated network does not match expected",
820 test.name,
821 )
822 return
823 }
824 }
825 if !test.valid {
826 // If address is invalid, but a creation function exists,
827 // verify that it returns a nil addr and non-nil error.
828 if test.f != nil {
829 _, e := test.f()
830 if e == nil {
831 t.Errorf(
832 "%v: address is invalid but creating new address succeeded",
833 test.name,
834 )
835 return
836 }
837 }
838 continue
839 }
840 // Valid test, compare address created with f against expected result.
841 addr, e := test.f()
842 if e != nil {
843 t.Errorf(
844 "%v: address is valid but creating new address failed with error %v",
845 test.name, e,
846 )
847 return
848 }
849 if !reflect.DeepEqual(addr, test.result) {
850 t.Errorf(
851 "%v: created address does not match expected result",
852 test.name,
853 )
854 return
855 }
856 }
857 }
858