github.com/linapex/ethereum-go-chinese@v0.0.0-20190316121929-f8b7a73c3fa1/accounts/abi/pack_test.go (about) 1 2 //<developer> 3 // <name>linapex 曹一峰</name> 4 // <email>linapex@163.com</email> 5 // <wx>superexc</wx> 6 // <qqgroup>128148617</qqgroup> 7 // <url>https://jsq.ink</url> 8 // <role>pku engineer</role> 9 // <date>2019-03-16 19:16:31</date> 10 //</624450062411370496> 11 12 13 package abi 14 15 import ( 16 "bytes" 17 "math" 18 "math/big" 19 "reflect" 20 "strings" 21 "testing" 22 23 "github.com/ethereum/go-ethereum/common" 24 ) 25 26 func TestPack(t *testing.T) { 27 for i, test := range []struct { 28 typ string 29 components []ArgumentMarshaling 30 input interface{} 31 output []byte 32 }{ 33 { 34 "uint8", 35 nil, 36 uint8(2), 37 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 38 }, 39 { 40 "uint8[]", 41 nil, 42 []uint8{1, 2}, 43 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 44 }, 45 { 46 "uint16", 47 nil, 48 uint16(2), 49 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 50 }, 51 { 52 "uint16[]", 53 nil, 54 []uint16{1, 2}, 55 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 56 }, 57 { 58 "uint32", 59 nil, 60 uint32(2), 61 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 62 }, 63 { 64 "uint32[]", 65 nil, 66 []uint32{1, 2}, 67 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 68 }, 69 { 70 "uint64", 71 nil, 72 uint64(2), 73 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 74 }, 75 { 76 "uint64[]", 77 nil, 78 []uint64{1, 2}, 79 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 80 }, 81 { 82 "uint256", 83 nil, 84 big.NewInt(2), 85 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 86 }, 87 { 88 "uint256[]", 89 nil, 90 []*big.Int{big.NewInt(1), big.NewInt(2)}, 91 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 92 }, 93 { 94 "int8", 95 nil, 96 int8(2), 97 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 98 }, 99 { 100 "int8[]", 101 nil, 102 []int8{1, 2}, 103 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 104 }, 105 { 106 "int16", 107 nil, 108 int16(2), 109 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 110 }, 111 { 112 "int16[]", 113 nil, 114 []int16{1, 2}, 115 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 116 }, 117 { 118 "int32", 119 nil, 120 int32(2), 121 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 122 }, 123 { 124 "int32[]", 125 nil, 126 []int32{1, 2}, 127 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 128 }, 129 { 130 "int64", 131 nil, 132 int64(2), 133 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 134 }, 135 { 136 "int64[]", 137 nil, 138 []int64{1, 2}, 139 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 140 }, 141 { 142 "int256", 143 nil, 144 big.NewInt(2), 145 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"), 146 }, 147 { 148 "int256[]", 149 nil, 150 []*big.Int{big.NewInt(1), big.NewInt(2)}, 151 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), 152 }, 153 { 154 "bytes1", 155 nil, 156 [1]byte{1}, 157 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 158 }, 159 { 160 "bytes2", 161 nil, 162 [2]byte{1}, 163 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 164 }, 165 { 166 "bytes3", 167 nil, 168 [3]byte{1}, 169 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 170 }, 171 { 172 "bytes4", 173 nil, 174 [4]byte{1}, 175 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 176 }, 177 { 178 "bytes5", 179 nil, 180 [5]byte{1}, 181 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 182 }, 183 { 184 "bytes6", 185 nil, 186 [6]byte{1}, 187 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 188 }, 189 { 190 "bytes7", 191 nil, 192 [7]byte{1}, 193 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 194 }, 195 { 196 "bytes8", 197 nil, 198 [8]byte{1}, 199 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 200 }, 201 { 202 "bytes9", 203 nil, 204 [9]byte{1}, 205 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 206 }, 207 { 208 "bytes10", 209 nil, 210 [10]byte{1}, 211 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 212 }, 213 { 214 "bytes11", 215 nil, 216 [11]byte{1}, 217 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 218 }, 219 { 220 "bytes12", 221 nil, 222 [12]byte{1}, 223 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 224 }, 225 { 226 "bytes13", 227 nil, 228 [13]byte{1}, 229 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 230 }, 231 { 232 "bytes14", 233 nil, 234 [14]byte{1}, 235 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 236 }, 237 { 238 "bytes15", 239 nil, 240 [15]byte{1}, 241 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 242 }, 243 { 244 "bytes16", 245 nil, 246 [16]byte{1}, 247 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 248 }, 249 { 250 "bytes17", 251 nil, 252 [17]byte{1}, 253 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 254 }, 255 { 256 "bytes18", 257 nil, 258 [18]byte{1}, 259 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 260 }, 261 { 262 "bytes19", 263 nil, 264 [19]byte{1}, 265 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 266 }, 267 { 268 "bytes20", 269 nil, 270 [20]byte{1}, 271 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 272 }, 273 { 274 "bytes21", 275 nil, 276 [21]byte{1}, 277 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 278 }, 279 { 280 "bytes22", 281 nil, 282 [22]byte{1}, 283 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 284 }, 285 { 286 "bytes23", 287 nil, 288 [23]byte{1}, 289 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 290 }, 291 { 292 "bytes24", 293 nil, 294 [24]byte{1}, 295 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 296 }, 297 { 298 "bytes25", 299 nil, 300 [25]byte{1}, 301 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 302 }, 303 { 304 "bytes26", 305 nil, 306 [26]byte{1}, 307 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 308 }, 309 { 310 "bytes27", 311 nil, 312 [27]byte{1}, 313 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 314 }, 315 { 316 "bytes28", 317 nil, 318 [28]byte{1}, 319 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 320 }, 321 { 322 "bytes29", 323 nil, 324 [29]byte{1}, 325 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 326 }, 327 { 328 "bytes30", 329 nil, 330 [30]byte{1}, 331 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 332 }, 333 { 334 "bytes31", 335 nil, 336 [31]byte{1}, 337 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 338 }, 339 { 340 "bytes32", 341 nil, 342 [32]byte{1}, 343 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 344 }, 345 { 346 "uint32[2][3][4]", 347 nil, 348 [4][3][2]uint32{{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}, {{13, 14}, {15, 16}, {17, 18}}, {{19, 20}, {21, 22}, {23, 24}}}, 349 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000d000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000f000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000015000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000170000000000000000000000000000000000000000000000000000000000000018"), 350 }, 351 { 352 "address[]", 353 nil, 354 []common.Address{{1}, {2}}, 355 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000"), 356 }, 357 { 358 "bytes32[]", 359 nil, 360 []common.Hash{{1}, {2}}, 361 common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000201000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000"), 362 }, 363 { 364 "function", 365 nil, 366 [24]byte{1}, 367 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), 368 }, 369 { 370 "string", 371 nil, 372 "foobar", 373 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000006666f6f6261720000000000000000000000000000000000000000000000000000"), 374 }, 375 { 376 "string[]", 377 nil, 378 []string{"hello", "foobar"}, 379 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002" + //LeN（数组）＝2 380 "0000000000000000000000000000000000000000000000000000000000000040" + //偏移64到i=0 381 "0000000000000000000000000000000000000000000000000000000000000080" + //偏移128至i=1 382 "0000000000000000000000000000000000000000000000000000000000000005" + //LeN（STR〔0〕）＝5 383 "68656c6c6f000000000000000000000000000000000000000000000000000000" + //STR〔0〕 384 "0000000000000000000000000000000000000000000000000000000000000006" + //LeN（STR〔1〕）＝6 385 "666f6f6261720000000000000000000000000000000000000000000000000000"), //STR〔1〕 386 }, 387 { 388 "string[2]", 389 nil, 390 []string{"hello", "foobar"}, 391 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040" + //偏移到i＝0 392 "0000000000000000000000000000000000000000000000000000000000000080" + //偏移到i＝1 393 "0000000000000000000000000000000000000000000000000000000000000005" + //LeN（STR〔0〕）＝5 394 "68656c6c6f000000000000000000000000000000000000000000000000000000" + //STR〔0〕 395 "0000000000000000000000000000000000000000000000000000000000000006" + //LeN（STR〔1〕）＝6 396 "666f6f6261720000000000000000000000000000000000000000000000000000"), //STR〔1〕 397 }, 398 { 399 "bytes32[][]", 400 nil, 401 [][]common.Hash{{{1}, {2}}, {{3}, {4}, {5}}}, 402 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002" + //LeN（数组）＝2 403 "0000000000000000000000000000000000000000000000000000000000000040" + //偏移64到i=0 404 "00000000000000000000000000000000000000000000000000000000000000a0" + //偏移160至i=1 405 "0000000000000000000000000000000000000000000000000000000000000002" + //len（数组[0]）=2 406 "0100000000000000000000000000000000000000000000000000000000000000" + //数组〔0〕〔0〕 407 "0200000000000000000000000000000000000000000000000000000000000000" + //数组〔0〕〔1〕 408 "0000000000000000000000000000000000000000000000000000000000000003" + //len（数组[1]）=3 409 "0300000000000000000000000000000000000000000000000000000000000000" + //数组〔1〕〔0〕 410 "0400000000000000000000000000000000000000000000000000000000000000" + // 411 "0500000000000000000000000000000000000000000000000000000000000000"), // 412 }, 413 414 { 415 "bytes32[][2]", 416 nil, 417 [][]common.Hash{{{1}, {2}}, {{3}, {4}, {5}}}, 418 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040" + //偏移64到i=0 419 "00000000000000000000000000000000000000000000000000000000000000a0" + //偏移160至i=1 420 "0000000000000000000000000000000000000000000000000000000000000002" + //len（数组[0]）=2 421 "0100000000000000000000000000000000000000000000000000000000000000" + //数组〔0〕〔0〕 422 "0200000000000000000000000000000000000000000000000000000000000000" + //数组〔0〕〔1〕 423 "0000000000000000000000000000000000000000000000000000000000000003" + //len（数组[1]）=3 424 "0300000000000000000000000000000000000000000000000000000000000000" + //数组〔1〕〔0〕 425 "0400000000000000000000000000000000000000000000000000000000000000" + //数组〔1〕〔1〕 426 "0500000000000000000000000000000000000000000000000000000000000000"), //数组〔1〕〔2〕 427 }, 428 429 { 430 "bytes32[3][2]", 431 nil, 432 [][]common.Hash{{{1}, {2}, {3}}, {{3}, {4}, {5}}}, 433 common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000" + //数组〔0〕〔0〕 434 "0200000000000000000000000000000000000000000000000000000000000000" + //数组〔0〕〔1〕 435 "0300000000000000000000000000000000000000000000000000000000000000" + //数组〔0〕〔2〕 436 "0300000000000000000000000000000000000000000000000000000000000000" + //数组〔1〕〔0〕 437 "0400000000000000000000000000000000000000000000000000000000000000" + //数组〔1〕〔1〕 438 "0500000000000000000000000000000000000000000000000000000000000000"), //数组〔1〕〔2〕 439 }, 440 { 441 //静态元组 442 "tuple", 443 []ArgumentMarshaling{ 444 {Name: "a", Type: "int64"}, 445 {Name: "b", Type: "int256"}, 446 {Name: "c", Type: "int256"}, 447 {Name: "d", Type: "bool"}, 448 {Name: "e", Type: "bytes32[3][2]"}, 449 }, 450 struct { 451 A int64 452 B *big.Int 453 C *big.Int 454 D bool 455 E [][]common.Hash 456 }{1, big.NewInt(1), big.NewInt(-1), true, [][]common.Hash{{{1}, {2}, {3}}, {{3}, {4}, {5}}}}, 457 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001" + //结构[ a] 458 "0000000000000000000000000000000000000000000000000000000000000001" + //结构[B] 459 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + //结构[C] 460 "0000000000000000000000000000000000000000000000000000000000000001" + //结构[ D ] 461 "0100000000000000000000000000000000000000000000000000000000000000" + //结构[E]数组[0][0] 462 "0200000000000000000000000000000000000000000000000000000000000000" + //结构[E]数组[0][1] 463 "0300000000000000000000000000000000000000000000000000000000000000" + //结构[E]数组[0][2] 464 "0300000000000000000000000000000000000000000000000000000000000000" + //结构[E]数组[1][0] 465 "0400000000000000000000000000000000000000000000000000000000000000" + //结构[E]数组[1][1] 466 "0500000000000000000000000000000000000000000000000000000000000000"), //结构[E]数组[1][2] 467 }, 468 { 469 //动态元组 470 "tuple", 471 []ArgumentMarshaling{ 472 {Name: "a", Type: "string"}, 473 {Name: "b", Type: "int64"}, 474 {Name: "c", Type: "bytes"}, 475 {Name: "d", Type: "string[]"}, 476 {Name: "e", Type: "int256[]"}, 477 {Name: "f", Type: "address[]"}, 478 }, 479 struct { 480 FieldA string `abi:"a"` //测试ABI标签是否有效 481 FieldB int64 `abi:"b"` 482 C []byte 483 D []string 484 E []*big.Int 485 F []common.Address 486 }{"foobar", 1, []byte{1}, []string{"foo", "bar"}, []*big.Int{big.NewInt(1), big.NewInt(-1)}, []common.Address{{1}, {2}}}, 487 common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000c0" + //结构[A]偏移 488 "0000000000000000000000000000000000000000000000000000000000000001" + //结构[B] 489 "0000000000000000000000000000000000000000000000000000000000000100" + //结构[C]偏移量 490 "0000000000000000000000000000000000000000000000000000000000000140" + //结构[d]偏移量 491 "0000000000000000000000000000000000000000000000000000000000000220" + //结构[e]偏移量 492 "0000000000000000000000000000000000000000000000000000000000000280" + //结构[F]偏移量 493 "0000000000000000000000000000000000000000000000000000000000000006" + //结构长度 494 "666f6f6261720000000000000000000000000000000000000000000000000000" + //结构[A]“foobar” 495 "0000000000000000000000000000000000000000000000000000000000000001" + //结构长度 496 "0100000000000000000000000000000000000000000000000000000000000000" + //[]字节{ 1 } 497 "0000000000000000000000000000000000000000000000000000000000000002" + //结构[d]长度 498 "0000000000000000000000000000000000000000000000000000000000000040" + //浮点偏移 499 "0000000000000000000000000000000000000000000000000000000000000080" + //杆偏置 500 "0000000000000000000000000000000000000000000000000000000000000003" + //英尺长度 501 "666f6f0000000000000000000000000000000000000000000000000000000000" + //福 502 "0000000000000000000000000000000000000000000000000000000000000003" + //杆偏置 503 "6261720000000000000000000000000000000000000000000000000000000000" + //酒吧 504 "0000000000000000000000000000000000000000000000000000000000000002" + //结构长度 505 "0000000000000000000000000000000000000000000000000000000000000001" + //一 506 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + //- 1 507 "0000000000000000000000000000000000000000000000000000000000000002" + //结构长度 508 "0000000000000000000000000100000000000000000000000000000000000000" + //普通地址1 509 "0000000000000000000000000200000000000000000000000000000000000000"), //普通地址2 510 }, 511 { 512 //嵌套元组 513 "tuple", 514 []ArgumentMarshaling{ 515 {Name: "a", Type: "tuple", Components: []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256[]"}}}, 516 {Name: "b", Type: "int256[]"}, 517 }, 518 struct { 519 A struct { 520 FieldA *big.Int `abi:"a"` 521 B []*big.Int 522 } 523 B []*big.Int 524 }{ 525 A: struct { 526 FieldA *big.Int `abi:"a"` //测试ABI标记是否适用于嵌套元组 527 B []*big.Int 528 }{big.NewInt(1), []*big.Int{big.NewInt(1), big.NewInt(0)}}, 529 B: []*big.Int{big.NewInt(1), big.NewInt(0)}}, 530 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040" + //偏移量 531 "00000000000000000000000000000000000000000000000000000000000000e0" + //B偏移量 532 "0000000000000000000000000000000000000000000000000000000000000001" + //A.值 533 "0000000000000000000000000000000000000000000000000000000000000040" + //A.B偏移量 534 "0000000000000000000000000000000000000000000000000000000000000002" + //A.B长度 535 "0000000000000000000000000000000000000000000000000000000000000001" + //A.B.〔0〕值 536 "0000000000000000000000000000000000000000000000000000000000000000" + //A.B.〔1〕值 537 "0000000000000000000000000000000000000000000000000000000000000002" + //B长 538 "0000000000000000000000000000000000000000000000000000000000000001" + //B〔0〕值 539 "0000000000000000000000000000000000000000000000000000000000000000"), //B〔1〕值 540 }, 541 { 542 //元组切片 543 "tuple[]", 544 []ArgumentMarshaling{ 545 {Name: "a", Type: "int256"}, 546 {Name: "b", Type: "int256[]"}, 547 }, 548 []struct { 549 A *big.Int 550 B []*big.Int 551 }{ 552 {big.NewInt(-1), []*big.Int{big.NewInt(1), big.NewInt(0)}}, 553 {big.NewInt(1), []*big.Int{big.NewInt(2), big.NewInt(-1)}}, 554 }, 555 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002" + //元组长度 556 "0000000000000000000000000000000000000000000000000000000000000040" + //元组〔0〕偏移 557 "00000000000000000000000000000000000000000000000000000000000000e0" + //元组〔1〕偏移 558 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + //元组〔0〕 559 "0000000000000000000000000000000000000000000000000000000000000040" + //元组[0].b偏移量 560 "0000000000000000000000000000000000000000000000000000000000000002" + //元组[0].b长度 561 "0000000000000000000000000000000000000000000000000000000000000001" + //元组[0].b[0]值 562 "0000000000000000000000000000000000000000000000000000000000000000" + //元组[0].b[1]值 563 "0000000000000000000000000000000000000000000000000000000000000001" + //元组〔1〕 564 "0000000000000000000000000000000000000000000000000000000000000040" + //元组[1].b偏移量 565 "0000000000000000000000000000000000000000000000000000000000000002" + //元组[1].b长度 566 "0000000000000000000000000000000000000000000000000000000000000002" + //元组[1].b[0]值 567 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), //元组[1].b[1]值 568 }, 569 { 570 //静态元组数组 571 "tuple[2]", 572 []ArgumentMarshaling{ 573 {Name: "a", Type: "int256"}, 574 {Name: "b", Type: "int256"}, 575 }, 576 [2]struct { 577 A *big.Int 578 B *big.Int 579 }{ 580 {big.NewInt(-1), big.NewInt(1)}, 581 {big.NewInt(1), big.NewInt(-1)}, 582 }, 583 common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + //元组〔0〕 584 "0000000000000000000000000000000000000000000000000000000000000001" + //元组〔0〕 585 "0000000000000000000000000000000000000000000000000000000000000001" + //元组〔1〕 586 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), //元组〔1〕 587 }, 588 { 589 //动态元组数组 590 "tuple[2]", 591 []ArgumentMarshaling{ 592 {Name: "a", Type: "int256[]"}, 593 }, 594 [2]struct { 595 A []*big.Int 596 }{ 597 {[]*big.Int{big.NewInt(-1), big.NewInt(1)}}, 598 {[]*big.Int{big.NewInt(1), big.NewInt(-1)}}, 599 }, 600 common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040" + //元组〔0〕偏移 601 "00000000000000000000000000000000000000000000000000000000000000c0" + //元组〔1〕偏移 602 "0000000000000000000000000000000000000000000000000000000000000020" + //元组[0]。偏移量 603 "0000000000000000000000000000000000000000000000000000000000000002" + //元组[0]。长度 604 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + //元组〔0〕A〔0〕 605 "0000000000000000000000000000000000000000000000000000000000000001" + //元组〔0〕A〔1〕 606 "0000000000000000000000000000000000000000000000000000000000000020" + //元组[1]。偏移量 607 "0000000000000000000000000000000000000000000000000000000000000002" + //元组[1]。长度 608 "0000000000000000000000000000000000000000000000000000000000000001" + //元组〔1〕A〔0〕 609 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), //元组〔1〕A〔1〕 610 }, 611 } { 612 typ, err := NewType(test.typ, test.components) 613 if err != nil { 614 t.Fatalf("%v failed. Unexpected parse error: %v", i, err) 615 } 616 output, err := typ.pack(reflect.ValueOf(test.input)) 617 if err != nil { 618 t.Fatalf("%v failed. Unexpected pack error: %v", i, err) 619 } 620 621 if !bytes.Equal(output, test.output) { 622 t.Errorf("input %d for typ: %v failed. Expected bytes: '%x' Got: '%x'", i, typ.String(), test.output, output) 623 } 624 } 625 } 626 627 func TestMethodPack(t *testing.T) { 628 abi, err := JSON(strings.NewReader(jsondata2)) 629 if err != nil { 630 t.Fatal(err) 631 } 632 633 sig := abi.Methods["slice"].Id() 634 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 635 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 636 637 packed, err := abi.Pack("slice", []uint32{1, 2}) 638 if err != nil { 639 t.Error(err) 640 } 641 642 if !bytes.Equal(packed, sig) { 643 t.Errorf("expected %x got %x", sig, packed) 644 } 645 646 var addrA, addrB = common.Address{1}, common.Address{2} 647 sig = abi.Methods["sliceAddress"].Id() 648 sig = append(sig, common.LeftPadBytes([]byte{32}, 32)...) 649 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 650 sig = append(sig, common.LeftPadBytes(addrA[:], 32)...) 651 sig = append(sig, common.LeftPadBytes(addrB[:], 32)...) 652 653 packed, err = abi.Pack("sliceAddress", []common.Address{addrA, addrB}) 654 if err != nil { 655 t.Fatal(err) 656 } 657 if !bytes.Equal(packed, sig) { 658 t.Errorf("expected %x got %x", sig, packed) 659 } 660 661 var addrC, addrD = common.Address{3}, common.Address{4} 662 sig = abi.Methods["sliceMultiAddress"].Id() 663 sig = append(sig, common.LeftPadBytes([]byte{64}, 32)...) 664 sig = append(sig, common.LeftPadBytes([]byte{160}, 32)...) 665 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 666 sig = append(sig, common.LeftPadBytes(addrA[:], 32)...) 667 sig = append(sig, common.LeftPadBytes(addrB[:], 32)...) 668 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 669 sig = append(sig, common.LeftPadBytes(addrC[:], 32)...) 670 sig = append(sig, common.LeftPadBytes(addrD[:], 32)...) 671 672 packed, err = abi.Pack("sliceMultiAddress", []common.Address{addrA, addrB}, []common.Address{addrC, addrD}) 673 if err != nil { 674 t.Fatal(err) 675 } 676 if !bytes.Equal(packed, sig) { 677 t.Errorf("expected %x got %x", sig, packed) 678 } 679 680 sig = abi.Methods["slice256"].Id() 681 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 682 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 683 684 packed, err = abi.Pack("slice256", []*big.Int{big.NewInt(1), big.NewInt(2)}) 685 if err != nil { 686 t.Error(err) 687 } 688 689 if !bytes.Equal(packed, sig) { 690 t.Errorf("expected %x got %x", sig, packed) 691 } 692 693 a := [2][2]*big.Int{{big.NewInt(1), big.NewInt(1)}, {big.NewInt(2), big.NewInt(0)}} 694 sig = abi.Methods["nestedArray"].Id() 695 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 696 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 697 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 698 sig = append(sig, common.LeftPadBytes([]byte{0}, 32)...) 699 sig = append(sig, common.LeftPadBytes([]byte{0xa0}, 32)...) 700 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 701 sig = append(sig, common.LeftPadBytes(addrC[:], 32)...) 702 sig = append(sig, common.LeftPadBytes(addrD[:], 32)...) 703 packed, err = abi.Pack("nestedArray", a, []common.Address{addrC, addrD}) 704 if err != nil { 705 t.Fatal(err) 706 } 707 if !bytes.Equal(packed, sig) { 708 t.Errorf("expected %x got %x", sig, packed) 709 } 710 711 sig = abi.Methods["nestedArray2"].Id() 712 sig = append(sig, common.LeftPadBytes([]byte{0x20}, 32)...) 713 sig = append(sig, common.LeftPadBytes([]byte{0x40}, 32)...) 714 sig = append(sig, common.LeftPadBytes([]byte{0x80}, 32)...) 715 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 716 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 717 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 718 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 719 packed, err = abi.Pack("nestedArray2", [2][]uint8{{1}, {1}}) 720 if err != nil { 721 t.Fatal(err) 722 } 723 if !bytes.Equal(packed, sig) { 724 t.Errorf("expected %x got %x", sig, packed) 725 } 726 727 sig = abi.Methods["nestedSlice"].Id() 728 sig = append(sig, common.LeftPadBytes([]byte{0x20}, 32)...) 729 sig = append(sig, common.LeftPadBytes([]byte{0x02}, 32)...) 730 sig = append(sig, common.LeftPadBytes([]byte{0x40}, 32)...) 731 sig = append(sig, common.LeftPadBytes([]byte{0xa0}, 32)...) 732 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 733 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 734 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 735 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 736 sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...) 737 sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...) 738 packed, err = abi.Pack("nestedSlice", [][]uint8{{1, 2}, {1, 2}}) 739 if err != nil { 740 t.Fatal(err) 741 } 742 if !bytes.Equal(packed, sig) { 743 t.Errorf("expected %x got %x", sig, packed) 744 } 745 } 746 747 func TestPackNumber(t *testing.T) { 748 tests := []struct { 749 value reflect.Value 750 packed []byte 751 }{ 752 //协议限制 753 {reflect.ValueOf(0), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000")}, 754 {reflect.ValueOf(1), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")}, 755 {reflect.ValueOf(-1), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")}, 756 757 //键入角大小写 758 {reflect.ValueOf(uint8(math.MaxUint8)), common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000ff")}, 759 {reflect.ValueOf(uint16(math.MaxUint16)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000ffff")}, 760 {reflect.ValueOf(uint32(math.MaxUint32)), common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000ffffffff")}, 761 {reflect.ValueOf(uint64(math.MaxUint64)), common.Hex2Bytes("000000000000000000000000000000000000000000000000ffffffffffffffff")}, 762 763 {reflect.ValueOf(int8(math.MaxInt8)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000007f")}, 764 {reflect.ValueOf(int16(math.MaxInt16)), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000007fff")}, 765 {reflect.ValueOf(int32(math.MaxInt32)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000007fffffff")}, 766 {reflect.ValueOf(int64(math.MaxInt64)), common.Hex2Bytes("0000000000000000000000000000000000000000000000007fffffffffffffff")}, 767 768 {reflect.ValueOf(int8(math.MinInt8)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80")}, 769 {reflect.ValueOf(int16(math.MinInt16)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8000")}, 770 {reflect.ValueOf(int32(math.MinInt32)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000")}, 771 {reflect.ValueOf(int64(math.MinInt64)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000")}, 772 } 773 for i, tt := range tests { 774 packed := packNum(tt.value) 775 if !bytes.Equal(packed, tt.packed) { 776 t.Errorf("test %d: pack mismatch: have %x, want %x", i, packed, tt.packed) 777 } 778 } 779 } 780