From a5330fe0c569b75cb8a524f60f7e8dc06498262b Mon Sep 17 00:00:00 2001 From: Yondon Fu Date: Thu, 12 Oct 2017 10:58:53 -0400 Subject: [PATCH 1/2] accounts/abi: include fixed array size in offset for dynamic type --- accounts/abi/abi_test.go | 50 ++++++++++++++++++++++++++++++++++++++++ accounts/abi/method.go | 13 ++++++++++- 2 files changed, 62 insertions(+), 1 deletion(-) diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go index a3aa9446e..5420eb19a 100644 --- a/accounts/abi/abi_test.go +++ b/accounts/abi/abi_test.go @@ -367,6 +367,56 @@ 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]" } ] } + ]` + + abi, err := JSON(strings.NewReader(definition)) + if err != nil { + t.Error(err) + } + + // test fixed array of uint256 and a string + arrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)} + strin := "hello world" + fixedArrStrPack, err := abi.Pack("fixedArrStr", strin, arrin) + if err != nil { + t.Error(err) + } + + 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 + fixedArrStrPack = fixedArrStrPack[4:] + if !bytes.Equal(fixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, fixedArrStrPack) + } + + // test fixed array of uint256 and a byte array + bytesin := []byte(strin) + fixedArrBytesPack, err := abi.Pack("fixedArrBytes", bytesin, arrin) + if err != nil { + t.Error(err) + } + + // 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) + } +} + func TestDefaultFunctionParsing(t *testing.T) { const definition = `[{ "name" : "balance" }]` diff --git a/accounts/abi/method.go b/accounts/abi/method.go index 62b3d2957..32077e8a6 100644 --- a/accounts/abi/method.go +++ b/accounts/abi/method.go @@ -48,6 +48,16 @@ func (method Method) pack(args ...interface{}) ([]byte, error) { // output. This is used for strings and bytes types input. var variableInput []byte + // 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) + } else { + inputOffset += 32 + } + } + var ret []byte for i, a := range args { input := method.Inputs[i] @@ -60,7 +70,8 @@ func (method Method) pack(args ...interface{}) ([]byte, error) { // check for a slice type (string, bytes, slice) if input.Type.requiresLengthPrefix() { // calculate the offset - offset := len(method.Inputs)*32 + len(variableInput) + offset := inputOffset + len(variableInput) + // set the offset ret = append(ret, packNum(reflect.ValueOf(offset))...) // Append the packed output to the variable input. The variable input From cf7aba36c82a1a6c2b2c9e5c623045093b1827eb Mon Sep 17 00:00:00 2001 From: Yondon Fu Date: Mon, 18 Dec 2017 21:16:25 -0500 Subject: [PATCH 2/2] accounts/abi: update array type check in method.go. Add more packing tests --- accounts/abi/abi_test.go | 140 +++++++++++++++++++++++++++++++++++++-- accounts/abi/method.go | 4 +- 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 }