aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorYondon Fu <yondon.fu@gmail.com>2017-12-19 10:16:25 +0800
committerYondon Fu <yondon.fu@gmail.com>2017-12-19 10:16:25 +0800
commitcf7aba36c82a1a6c2b2c9e5c623045093b1827eb (patch)
tree4eebc93fc1c32456bfb6670b02f548a632f4d734
parent3857cdc267e3192697f561df0a0f827f65dfb6b5 (diff)
downloaddexon-cf7aba36c82a1a6c2b2c9e5c623045093b1827eb.tar
dexon-cf7aba36c82a1a6c2b2c9e5c623045093b1827eb.tar.gz
dexon-cf7aba36c82a1a6c2b2c9e5c623045093b1827eb.tar.bz2
dexon-cf7aba36c82a1a6c2b2c9e5c623045093b1827eb.tar.lz
dexon-cf7aba36c82a1a6c2b2c9e5c623045093b1827eb.tar.xz
dexon-cf7aba36c82a1a6c2b2c9e5c623045093b1827eb.tar.zst
dexon-cf7aba36c82a1a6c2b2c9e5c623045093b1827eb.zip
accounts/abi: update array type check in method.go. Add more packing tests
-rw-r--r--accounts/abi/abi_test.go140
-rw-r--r--accounts/abi/method.go4
2 files changed, 138 insertions, 6 deletions
diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go
index 2ae7488a4..2775c4b1c 100644
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
@@ -351,7 +351,10 @@ func TestInputVariableInputLength(t *testing.T) {
func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
const definition = `[
{ "type" : "function", "name" : "fixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] },
- { "type" : "function", "name" : "fixedArrBytes", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] }
+ { "type" : "function", "name" : "fixedArrBytes", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] },
+ { "type" : "function", "name" : "mixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type": "uint256[2]" }, { "name" : "dynArr", "type": "uint256[]" } ] },
+ { "type" : "function", "name" : "doubleFixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type": "uint256[2]" }, { "name" : "fixedArr2", "type": "uint256[3]" } ] },
+ { "type" : "function", "name" : "multipleMixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type": "uint256[2]" }, { "name" : "dynArr", "type" : "uint256[]" }, { "name" : "fixedArr2", "type" : "uint256[3]" } ] }
]`
abi, err := JSON(strings.NewReader(definition))
@@ -359,14 +362,15 @@ func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
t.Error(err)
}
- // test fixed array of uint256 and a string
- arrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ // test string, fixed array uint256[2]
strin := "hello world"
+ arrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)}
fixedArrStrPack, err := abi.Pack("fixedArrStr", strin, arrin)
if err != nil {
t.Error(err)
}
+ // generate expected output
offset := make([]byte, 32)
offset[31] = 96
length := make([]byte, 32)
@@ -384,18 +388,146 @@ func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
t.Errorf("expected %x, got %x\n", exp, fixedArrStrPack)
}
- // test fixed array of uint256 and a byte array
+ // test byte array, fixed array uint256[2]
bytesin := []byte(strin)
+ arrin = [2]*big.Int{big.NewInt(1), big.NewInt(2)}
fixedArrBytesPack, err := abi.Pack("fixedArrBytes", bytesin, arrin)
if err != nil {
t.Error(err)
}
+ // generate expected output
+ offset = make([]byte, 32)
+ offset[31] = 96
+ length = make([]byte, 32)
+ length[31] = byte(len(strin))
+ strvalue = common.RightPadBytes([]byte(strin), 32)
+ arrinvalue1 = common.LeftPadBytes(arrin[0].Bytes(), 32)
+ arrinvalue2 = common.LeftPadBytes(arrin[1].Bytes(), 32)
+ exp = append(offset, arrinvalue1...)
+ exp = append(exp, arrinvalue2...)
+ exp = append(exp, append(length, strvalue...)...)
+
// ignore first 4 bytes of the output. This is the function identifier
fixedArrBytesPack = fixedArrBytesPack[4:]
if !bytes.Equal(fixedArrBytesPack, exp) {
t.Errorf("expected %x, got %x\n", exp, fixedArrBytesPack)
}
+
+ // test string, fixed array uint256[2], dynamic array uint256[]
+ strin = "hello world"
+ fixedarrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ dynarrin := []*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}
+ mixedArrStrPack, err := abi.Pack("mixedArrStr", strin, fixedarrin, dynarrin)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // generate expected output
+ stroffset := make([]byte, 32)
+ stroffset[31] = 128
+ strlength := make([]byte, 32)
+ strlength[31] = byte(len(strin))
+ strvalue = common.RightPadBytes([]byte(strin), 32)
+ fixedarrinvalue1 := common.LeftPadBytes(fixedarrin[0].Bytes(), 32)
+ fixedarrinvalue2 := common.LeftPadBytes(fixedarrin[1].Bytes(), 32)
+ dynarroffset := make([]byte, 32)
+ dynarroffset[31] = byte(160 + ((len(strin)/32)+1)*32)
+ dynarrlength := make([]byte, 32)
+ dynarrlength[31] = byte(len(dynarrin))
+ dynarrinvalue1 := common.LeftPadBytes(dynarrin[0].Bytes(), 32)
+ dynarrinvalue2 := common.LeftPadBytes(dynarrin[1].Bytes(), 32)
+ dynarrinvalue3 := common.LeftPadBytes(dynarrin[2].Bytes(), 32)
+ exp = append(stroffset, fixedarrinvalue1...)
+ exp = append(exp, fixedarrinvalue2...)
+ exp = append(exp, dynarroffset...)
+ exp = append(exp, append(strlength, strvalue...)...)
+ dynarrarg := append(dynarrlength, dynarrinvalue1...)
+ dynarrarg = append(dynarrarg, dynarrinvalue2...)
+ dynarrarg = append(dynarrarg, dynarrinvalue3...)
+ exp = append(exp, dynarrarg...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ mixedArrStrPack = mixedArrStrPack[4:]
+ if !bytes.Equal(mixedArrStrPack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, mixedArrStrPack)
+ }
+
+ // test string, fixed array uint256[2], fixed array uint256[3]
+ strin = "hello world"
+ fixedarrin1 := [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ fixedarrin2 := [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}
+ doubleFixedArrStrPack, err := abi.Pack("doubleFixedArrStr", strin, fixedarrin1, fixedarrin2)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // generate expected output
+ stroffset = make([]byte, 32)
+ stroffset[31] = 192
+ strlength = make([]byte, 32)
+ strlength[31] = byte(len(strin))
+ strvalue = common.RightPadBytes([]byte(strin), 32)
+ fixedarrin1value1 := common.LeftPadBytes(fixedarrin1[0].Bytes(), 32)
+ fixedarrin1value2 := common.LeftPadBytes(fixedarrin1[1].Bytes(), 32)
+ fixedarrin2value1 := common.LeftPadBytes(fixedarrin2[0].Bytes(), 32)
+ fixedarrin2value2 := common.LeftPadBytes(fixedarrin2[1].Bytes(), 32)
+ fixedarrin2value3 := common.LeftPadBytes(fixedarrin2[2].Bytes(), 32)
+ exp = append(stroffset, fixedarrin1value1...)
+ exp = append(exp, fixedarrin1value2...)
+ exp = append(exp, fixedarrin2value1...)
+ exp = append(exp, fixedarrin2value2...)
+ exp = append(exp, fixedarrin2value3...)
+ exp = append(exp, append(strlength, strvalue...)...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ doubleFixedArrStrPack = doubleFixedArrStrPack[4:]
+ if !bytes.Equal(doubleFixedArrStrPack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, doubleFixedArrStrPack)
+ }
+
+ // test string, fixed array uint256[2], dynamic array uint256[], fixed array uint256[3]
+ strin = "hello world"
+ fixedarrin1 = [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ dynarrin = []*big.Int{big.NewInt(1), big.NewInt(2)}
+ fixedarrin2 = [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}
+ multipleMixedArrStrPack, err := abi.Pack("multipleMixedArrStr", strin, fixedarrin1, dynarrin, fixedarrin2)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // generate expected output
+ stroffset = make([]byte, 32)
+ stroffset[31] = 224
+ strlength = make([]byte, 32)
+ strlength[31] = byte(len(strin))
+ strvalue = common.RightPadBytes([]byte(strin), 32)
+ fixedarrin1value1 = common.LeftPadBytes(fixedarrin1[0].Bytes(), 32)
+ fixedarrin1value2 = common.LeftPadBytes(fixedarrin1[1].Bytes(), 32)
+ dynarroffset = U256(big.NewInt(int64(256 + ((len(strin)/32)+1)*32)))
+ dynarrlength = make([]byte, 32)
+ dynarrlength[31] = byte(len(dynarrin))
+ dynarrinvalue1 = common.LeftPadBytes(dynarrin[0].Bytes(), 32)
+ dynarrinvalue2 = common.LeftPadBytes(dynarrin[1].Bytes(), 32)
+ fixedarrin2value1 = common.LeftPadBytes(fixedarrin2[0].Bytes(), 32)
+ fixedarrin2value2 = common.LeftPadBytes(fixedarrin2[1].Bytes(), 32)
+ fixedarrin2value3 = common.LeftPadBytes(fixedarrin2[2].Bytes(), 32)
+ exp = append(stroffset, fixedarrin1value1...)
+ exp = append(exp, fixedarrin1value2...)
+ exp = append(exp, dynarroffset...)
+ exp = append(exp, fixedarrin2value1...)
+ exp = append(exp, fixedarrin2value2...)
+ exp = append(exp, fixedarrin2value3...)
+ exp = append(exp, append(strlength, strvalue...)...)
+ dynarrarg = append(dynarrlength, dynarrinvalue1...)
+ dynarrarg = append(dynarrarg, dynarrinvalue2...)
+ exp = append(exp, dynarrarg...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ multipleMixedArrStrPack = multipleMixedArrStrPack[4:]
+ if !bytes.Equal(multipleMixedArrStrPack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, multipleMixedArrStrPack)
+ }
}
func TestDefaultFunctionParsing(t *testing.T) {
diff --git a/accounts/abi/method.go b/accounts/abi/method.go
index 609a71f07..673695aa8 100644
--- a/accounts/abi/method.go
+++ b/accounts/abi/method.go
@@ -51,8 +51,8 @@ func (method Method) pack(args ...interface{}) ([]byte, error) {
// input offset is the bytes offset for packed output
inputOffset := 0
for _, input := range method.Inputs {
- if input.Type.IsArray {
- inputOffset += (32 * input.Type.SliceSize)
+ if input.Type.T == ArrayTy {
+ inputOffset += (32 * input.Type.Size)
} else {
inputOffset += 32
}