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