cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #2980 from ethereum/abi-api

Browse Source 
Add abi.encode and abi.encodePacked
This commit is contained in:
chriseth 2018-04-12 20:55:03 +02:00 committed by GitHub
commit 44416d1ac6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 700 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
libsolidity/analysis/GlobalContext.cpp
View File

@ -35,6 +35,7 @@ namespace solidity
GlobalContext::GlobalContext():
m_magicVariables(vector<shared_ptr<MagicVariableDeclaration const>>{
make_shared<MagicVariableDeclaration>("abi", make_shared<MagicType>(MagicType::Kind::ABI)),
make_shared<MagicVariableDeclaration>("addmod", make_shared<FunctionType>(strings{"uint256", "uint256", "uint256"}, strings{"uint256"}, FunctionType::Kind::AddMod, false, StateMutability::Pure)),
make_shared<MagicVariableDeclaration>("assert", make_shared<FunctionType>(strings{"bool"}, strings{}, FunctionType::Kind::Assert, false, StateMutability::Pure)),
make_shared<MagicVariableDeclaration>("block", make_shared<MagicType>(MagicType::Kind::Block)),

42
libsolidity/analysis/TypeChecker.cpp
View File

@ -1688,7 +1688,19 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
}
}
if (!functionType->takesArbitraryParameters() && parameterTypes.size() != arguments.size())
if (functionType->takesArbitraryParameters() && arguments.size() < parameterTypes.size())
{
solAssert(_functionCall.annotation().kind == FunctionCallKind::FunctionCall, "");
m_errorReporter.typeError(
_functionCall.location(),
"Need at least " +
toString(parameterTypes.size()) +
" arguments for function call, but provided only " +
toString(arguments.size()) +
"."
);
}
else if (!functionType->takesArbitraryParameters() && parameterTypes.size() != arguments.size())
{
bool isStructConstructorCall = _functionCall.annotation().kind == FunctionCallKind::StructConstructorCall;
@ -1711,11 +1723,12 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
}
else if (isPositionalCall)
{
// call by positional arguments
bool const abiEncodeV2 = m_scope->sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::ABIEncoderV2);
for (size_t i = 0; i < arguments.size(); ++i)
{
auto const& argType = type(*arguments[i]);
if (functionType->takesArbitraryParameters())
if (functionType->takesArbitraryParameters() && i >= parameterTypes.size())
{
bool errored = false;
if (auto t = dynamic_cast<RationalNumberType const*>(argType.get()))
@ -1724,13 +1737,22 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
m_errorReporter.typeError(arguments[i]->location(), "Invalid rational number (too large or division by zero).");
errored = true;
}
if (!errored && !(
argType->mobileType() &&
argType->mobileType()->interfaceType(false) &&
argType->mobileType()->interfaceType(false)->encodingType() &&
!(dynamic_cast<StructType const*>(argType->mobileType()->interfaceType(false)->encodingType().get()))
))
m_errorReporter.typeError(arguments[i]->location(), "This type cannot be encoded.");
if (!errored)
{
TypePointer encodingType;
if (
argType->mobileType() &&
argType->mobileType()->interfaceType(false) &&
argType->mobileType()->interfaceType(false)->encodingType()
)
encodingType = argType->mobileType()->interfaceType(false)->encodingType();
// Structs are fine as long as ABIV2 is activated and we do not do packed encoding.
if (!encodingType || (
dynamic_cast<StructType const*>(encodingType.get()) &&
!(abiEncodeV2 && functionType->padArguments())
))
m_errorReporter.typeError(arguments[i]->location(), "This type cannot be encoded.");
}
}
else if (!type(*arguments[i])->isImplicitlyConvertibleTo(*parameterTypes[i]))
m_errorReporter.typeError(

7
libsolidity/analysis/ViewPureChecker.cpp
View File

@ -305,10 +305,15 @@ void ViewPureChecker::endVisit(MemberAccess const& _memberAccess)
mutability = StateMutability::View;
break;
case Type::Category::Magic:
{
// we can ignore the kind of magic and only look at the name of the member
if (member != "data" && member != "sig" && member != "blockhash")
set<string> static const pureMembers{
"encode", "encodePacked", "encodeWithSelector", "encodeWithSignature", "data", "sig", "blockhash"
};
if (!pureMembers.count(member))
mutability = StateMutability::View;
break;
}
case Type::Category::Struct:
{
if (_memberAccess.expression().annotation().type->dataStoredIn(DataLocation::Storage))

49
libsolidity/ast/Types.cpp
View File

@ -2375,7 +2375,11 @@ string FunctionType::richIdentifier() const
case Kind::ByteArrayPush: id += "bytearraypush"; break;
case Kind::ObjectCreation: id += "objectcreation"; break;
case Kind::Assert: id += "assert"; break;
case Kind::Require: id += "require";break;
case Kind::Require: id += "require"; break;
case Kind::ABIEncode: id += "abiencode"; break;
case Kind::ABIEncodePacked: id += "abiencodepacked"; break;
case Kind::ABIEncodeWithSelector: id += "abiencodewithselector"; break;
case Kind::ABIEncodeWithSignature: id += "abiencodewithsignature"; break;
default: solAssert(false, "Unknown function location."); break;
}
id += "_" + stateMutabilityToString(m_stateMutability);
@ -2996,6 +3000,8 @@ string MagicType::richIdentifier() const
return "t_magic_message";
case Kind::Transaction:
return "t_magic_transaction";
case Kind::ABI:
return "t_magic_abi";
default:
solAssert(false, "Unknown kind of magic");
}
@ -3036,6 +3042,45 @@ MemberList::MemberMap MagicType::nativeMembers(ContractDefinition const*) const
{"origin", make_shared<IntegerType>(160, IntegerType::Modifier::Address)},
{"gasprice", make_shared<IntegerType>(256)}
});
case Kind::ABI:
return MemberList::MemberMap({
{"encode", make_shared<FunctionType>(
TypePointers(),
TypePointers{make_shared<ArrayType>(DataLocation::Memory)},
strings{},
strings{},
FunctionType::Kind::ABIEncode,
true,
StateMutability::Pure
)},
{"encodePacked", make_shared<FunctionType>(
TypePointers(),
TypePointers{make_shared<ArrayType>(DataLocation::Memory)},
strings{},
strings{},
FunctionType::Kind::ABIEncodePacked,
true,
StateMutability::Pure
)},
{"encodeWithSelector", make_shared<FunctionType>(
TypePointers{make_shared<FixedBytesType>(4)},
TypePointers{make_shared<ArrayType>(DataLocation::Memory)},
strings{},
strings{},
FunctionType::Kind::ABIEncodeWithSelector,
true,
StateMutability::Pure
)},
{"encodeWithSignature", make_shared<FunctionType>(
TypePointers{make_shared<ArrayType>(DataLocation::Memory, true)},
TypePointers{make_shared<ArrayType>(DataLocation::Memory)},
strings{},
strings{},
FunctionType::Kind::ABIEncodeWithSignature,
true,
StateMutability::Pure
)}
});
default:
solAssert(false, "Unknown kind of magic.");
}
@ -3051,6 +3096,8 @@ string MagicType::toString(bool) const
return "msg";
case Kind::Transaction:
return "tx";
case Kind::ABI:
return "abi";
default:
solAssert(false, "Unknown kind of magic.");
}

8
libsolidity/ast/Types.h
View File

@ -917,6 +917,10 @@ public:
ObjectCreation, ///< array creation using new
Assert, ///< assert()
Require, ///< require()
ABIEncode,
ABIEncodePacked,
ABIEncodeWithSelector,
ABIEncodeWithSignature,
GasLeft ///< gasleft()
};
@ -1052,7 +1056,7 @@ public:
ASTPointer<ASTString> documentation() const;
/// true iff arguments are to be padded to multiples of 32 bytes for external calls
bool padArguments() const { return !(m_kind == Kind::SHA3 || m_kind == Kind::SHA256 || m_kind == Kind::RIPEMD160); }
bool padArguments() const { return !(m_kind == Kind::SHA3 || m_kind == Kind::SHA256 || m_kind == Kind::RIPEMD160 || m_kind == Kind::ABIEncodePacked); }
bool takesArbitraryParameters() const { return m_arbitraryParameters; }
bool gasSet() const { return m_gasSet; }
bool valueSet() const { return m_valueSet; }
@ -1210,7 +1214,7 @@ private:
class MagicType: public Type
{
public:
enum class Kind { Block, Message, Transaction };
enum class Kind { Block, Message, Transaction, ABI };
virtual Category category() const override { return Category::Magic; }
explicit MagicType(Kind _kind): m_kind(_kind) {}

102
libsolidity/codegen/ExpressionCompiler.cpp
View File

@ -33,6 +33,8 @@
#include <libsolidity/codegen/LValue.h>
#include <libevmasm/GasMeter.h>
#include <libdevcore/Whiskers.h>
using namespace std;
namespace dev
@ -912,6 +914,106 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
m_context << success;
break;
}
case FunctionType::Kind::ABIEncode:
case FunctionType::Kind::ABIEncodePacked:
case FunctionType::Kind::ABIEncodeWithSelector:
case FunctionType::Kind::ABIEncodeWithSignature:
{
bool const isPacked = function.kind() == FunctionType::Kind::ABIEncodePacked;
bool const hasSelectorOrSignature =
function.kind() == FunctionType::Kind::ABIEncodeWithSelector ||
function.kind() == FunctionType::Kind::ABIEncodeWithSignature;
TypePointers argumentTypes;
TypePointers targetTypes;
for (unsigned i = 0; i < arguments.size(); ++i)
{
arguments[i]->accept(*this);
// Do not keep the selector as part of the ABI encoded args
if (!hasSelectorOrSignature || i > 0)
argumentTypes.push_back(arguments[i]->annotation().type);
}
utils().fetchFreeMemoryPointer();
// stack now: [<selector>] <arg1> .. <argN> <free_mem>
// adjust by 32(+4) bytes to accommodate the length(+selector)
m_context << u256(32 + (hasSelectorOrSignature ? 4 : 0)) << Instruction::ADD;
// stack now: [<selector>] <arg1> .. <argN> <data_encoding_area_start>
if (isPacked)
{
solAssert(!function.padArguments(), "");
utils().packedEncode(argumentTypes, TypePointers());
}
else
{
solAssert(function.padArguments(), "");
utils().abiEncode(argumentTypes, TypePointers());
}
utils().fetchFreeMemoryPointer();
// stack: [<selector>] <data_encoding_area_end> <bytes_memory_ptr>
// size is end minus start minus length slot
m_context.appendInlineAssembly(R"({
mstore(mem_ptr, sub(sub(mem_end, mem_ptr), 0x20))
})", {"mem_end", "mem_ptr"});
m_context << Instruction::SWAP1;
utils().storeFreeMemoryPointer();
// stack: [<selector>] <memory ptr>
if (hasSelectorOrSignature)
{
// stack: <selector> <memory pointer>
solAssert(arguments.size() >= 1, "");
TypePointer const& selectorType = arguments[0]->annotation().type;
utils().moveIntoStack(selectorType->sizeOnStack());
TypePointer dataOnStack = selectorType;
// stack: <memory pointer> <selector>
if (function.kind() == FunctionType::Kind::ABIEncodeWithSignature)
{
// hash the signature
if (auto const* stringType = dynamic_cast<StringLiteralType const*>(selectorType.get()))
{
FixedHash<4> hash(dev::keccak256(stringType->value()));
m_context << (u256(FixedHash<4>::Arith(hash)) << (256 - 32));
dataOnStack = make_shared<FixedBytesType>(4);
}
else
{
utils().fetchFreeMemoryPointer();
// stack: <memory pointer> <selector> <free mem ptr>
utils().packedEncode(TypePointers{selectorType}, TypePointers());
utils().toSizeAfterFreeMemoryPointer();
m_context << Instruction::KECCAK256;
// stack: <memory pointer> <hash>
dataOnStack = make_shared<FixedBytesType>(32);
}
}
else
{
solAssert(function.kind() == FunctionType::Kind::ABIEncodeWithSelector, "");
}
// Cleanup actually does not clean on shrinking the type.
utils().convertType(*dataOnStack, FixedBytesType(4), true);
// stack: <memory pointer> <selector>
// load current memory, mask and combine the selector
string mask = formatNumber((u256(-1) >> 32));
m_context.appendInlineAssembly(R"({
let data_start := add(mem_ptr, 0x20)
let data := mload(data_start)
let mask := )" + mask + R"(
mstore(data_start, or(and(data, mask), and(selector, not(mask))))
})", {"mem_ptr", "selector"});
m_context << Instruction::POP;
}
// stack now: <memory pointer>
break;
}
case FunctionType::Kind::GasLeft:
m_context << Instruction::GAS;
break;

357
test/libsolidity/SolidityEndToEndTest.cpp
View File

@ -3557,6 +3557,45 @@ BOOST_AUTO_TEST_CASE(empty_name_return_parameter)
ABI_CHECK(callContractFunction("f(uint256)", 9), encodeArgs(9));
}
BOOST_AUTO_TEST_CASE(sha256_empty)
{
char const* sourceCode = R"(
contract C {
function f() returns (bytes32) {
return sha256();
}
}
)";
compileAndRun(sourceCode);
ABI_CHECK(callContractFunction("f()"), fromHex("0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"));
}
BOOST_AUTO_TEST_CASE(ripemd160_empty)
{
char const* sourceCode = R"(
contract C {
function f() returns (bytes20) {
return ripemd160();
}
}
)";
compileAndRun(sourceCode);
ABI_CHECK(callContractFunction("f()"), fromHex("0x9c1185a5c5e9fc54612808977ee8f548b2258d31000000000000000000000000"));
}
BOOST_AUTO_TEST_CASE(keccak256_empty)
{
char const* sourceCode = R"(
contract C {
function f() returns (bytes32) {
return keccak256();
}
}
)";
compileAndRun(sourceCode);
ABI_CHECK(callContractFunction("f()"), fromHex("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"));
}
BOOST_AUTO_TEST_CASE(keccak256_multiple_arguments)
{
char const* sourceCode = R"(
@ -11052,6 +11091,324 @@ BOOST_AUTO_TEST_CASE(snark)
BOOST_CHECK(callContractFunction("verifyTx()") == encodeArgs(true));
}
BOOST_AUTO_TEST_CASE(abi_encode)
{
char const* sourceCode = R"(
contract C {
function f0() returns (bytes) {
return abi.encode();
}
function f1() returns (bytes) {
return abi.encode(1, 2);
}
function f2() returns (bytes) {
string memory x = "abc";
return abi.encode(1, x, 2);
}
function f3() returns (bytes r) {
// test that memory is properly allocated
string memory x = "abc";
r = abi.encode(1, x, 2);
bytes memory y = "def";
require(y[0] == "d");
y[0] = "e";
require(y[0] == "e");
}
}
)";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 0));
ABI_CHECK(callContractFunction("f1()"), encodeArgs(0x20, 0x40, 1, 2));
ABI_CHECK(callContractFunction("f2()"), encodeArgs(0x20, 0xa0, 1, 0x60, 2, 3, "abc"));
ABI_CHECK(callContractFunction("f3()"), encodeArgs(0x20, 0xa0, 1, 0x60, 2, 3, "abc"));
}
BOOST_AUTO_TEST_CASE(abi_encode_v2)
{
char const* sourceCode = R"(
pragma experimental ABIEncoderV2;
contract C {
struct S { uint a; uint[] b; }
function f0() public pure returns (bytes) {
return abi.encode();
}
function f1() public pure returns (bytes) {
return abi.encode(1, 2);
}
function f2() public pure returns (bytes) {
string memory x = "abc";
return abi.encode(1, x, 2);
}
function f3() public pure returns (bytes r) {
// test that memory is properly allocated
string memory x = "abc";
r = abi.encode(1, x, 2);
bytes memory y = "def";
require(y[0] == "d");
y[0] = "e";
require(y[0] == "e");
}
S s;
function f4() public view returns (bytes r) {
string memory x = "abc";
s.a = 7;
s.b.push(2);
s.b.push(3);
r = abi.encode(1, x, s, 2);
bytes memory y = "def";
require(y[0] == "d");
y[0] = "e";
require(y[0] == "e");
}
}
)";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 0));
ABI_CHECK(callContractFunction("f1()"), encodeArgs(0x20, 0x40, 1, 2));
ABI_CHECK(callContractFunction("f2()"), encodeArgs(0x20, 0xa0, 1, 0x60, 2, 3, "abc"));
ABI_CHECK(callContractFunction("f3()"), encodeArgs(0x20, 0xa0, 1, 0x60, 2, 3, "abc"));
ABI_CHECK(callContractFunction("f4()"), encodeArgs(0x20, 0x160, 1, 0x80, 0xc0, 2, 3, "abc", 7, 0x40, 2, 2, 3));
}
BOOST_AUTO_TEST_CASE(abi_encodePacked)
{
char const* sourceCode = R"(
contract C {
function f0() public pure returns (bytes) {
return abi.encodePacked();
}
function f1() public pure returns (bytes) {
return abi.encodePacked(uint8(1), uint8(2));
}
function f2() public pure returns (bytes) {
string memory x = "abc";
return abi.encodePacked(uint8(1), x, uint8(2));
}
function f3() public pure returns (bytes r) {
// test that memory is properly allocated
string memory x = "abc";
r = abi.encodePacked(uint8(1), x, uint8(2));
bytes memory y = "def";
require(y[0] == "d");
y[0] = "e";
require(y[0] == "e");
}
}
)";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 0));
ABI_CHECK(callContractFunction("f1()"), encodeArgs(0x20, 2, "\x01\x02"));
ABI_CHECK(callContractFunction("f2()"), encodeArgs(0x20, 5, "\x01" "abc" "\x02"));
ABI_CHECK(callContractFunction("f3()"), encodeArgs(0x20, 5, "\x01" "abc" "\x02"));
}
BOOST_AUTO_TEST_CASE(abi_encode_with_selector)
{
char const* sourceCode = R"(
contract C {
function f0() public pure returns (bytes) {
return abi.encodeWithSelector(0x12345678);
}
function f1() public pure returns (bytes) {
return abi.encodeWithSelector(0x12345678, "abc");
}
function f2() public pure returns (bytes) {
bytes4 x = 0x12345678;
return abi.encodeWithSelector(x, "abc");
}
function f3() public pure returns (bytes) {
bytes4 x = 0x12345678;
return abi.encodeWithSelector(x, uint(-1));
}
}
)";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 4, "\x12\x34\x56\x78"));
bytes expectation;
expectation = encodeArgs(0x20, 4 + 0x60) + bytes{0x12, 0x34, 0x56, 0x78} + encodeArgs(0x20, 3, "abc") + bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f1()"), expectation);
expectation = encodeArgs(0x20, 4 + 0x60) + bytes{0x12, 0x34, 0x56, 0x78} + encodeArgs(0x20, 3, "abc") + bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f2()"), expectation);
expectation = encodeArgs(0x20, 4 + 0x20) + bytes{0x12, 0x34, 0x56, 0x78} + encodeArgs(u256(-1)) + bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f3()"), expectation);
}
BOOST_AUTO_TEST_CASE(abi_encode_with_selectorv2)
{
char const* sourceCode = R"(
pragma experimental ABIEncoderV2;
contract C {
function f0() public pure returns (bytes) {
return abi.encodeWithSelector(0x12345678);
}
function f1() public pure returns (bytes) {
return abi.encodeWithSelector(0x12345678, "abc");
}
function f2() public pure returns (bytes) {
bytes4 x = 0x12345678;
return abi.encodeWithSelector(x, "abc");
}
function f3() public pure returns (bytes) {
bytes4 x = 0x12345678;
return abi.encodeWithSelector(x, uint(-1));
}
struct S { uint a; string b; uint16 c; }
function f4() public pure returns (bytes) {
bytes4 x = 0x12345678;
S memory s;
s.a = 0x1234567;
s.b = "Lorem ipsum dolor sit ethereum........";
s.c = 0x1234;
return abi.encodeWithSelector(x, uint(-1), s, uint(3));
}
}
)";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 4, "\x12\x34\x56\x78"));
bytes expectation;
expectation = encodeArgs(0x20, 4 + 0x60) + bytes{0x12, 0x34, 0x56, 0x78} + encodeArgs(0x20, 3, "abc") + bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f1()"), expectation);
expectation = encodeArgs(0x20, 4 + 0x60) + bytes{0x12, 0x34, 0x56, 0x78} + encodeArgs(0x20, 3, "abc") + bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f2()"), expectation);
expectation = encodeArgs(0x20, 4 + 0x20) + bytes{0x12, 0x34, 0x56, 0x78} + encodeArgs(u256(-1)) + bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f3()"), expectation);
expectation =
encodeArgs(0x20, 4 + 0x120) +
bytes{0x12, 0x34, 0x56, 0x78} +
encodeArgs(u256(-1), 0x60, u256(3), 0x1234567, 0x60, 0x1234, 38, "Lorem ipsum dolor sit ethereum........") +
bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f4()"), expectation);
}
BOOST_AUTO_TEST_CASE(abi_encode_with_signature)
{
char const* sourceCode = R"T(
contract C {
function f0() public pure returns (bytes) {
return abi.encodeWithSignature("f(uint256)");
}
function f1() public pure returns (bytes) {
string memory x = "f(uint256)";
return abi.encodeWithSignature(x, "abc");
}
string xstor;
function f1s() public returns (bytes) {
xstor = "f(uint256)";
return abi.encodeWithSignature(xstor, "abc");
}
function f2() public pure returns (bytes r, uint[] ar) {
string memory x = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
uint[] memory y = new uint[](4);
y[0] = uint(-1);
y[1] = uint(-2);
y[2] = uint(-3);
y[3] = uint(-4);
r = abi.encodeWithSignature(x, y);
// The hash uses temporary memory. This allocation re-uses the memory
// and should initialize it properly.
ar = new uint[](2);
}
}
)T";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 4, "\xb3\xde\x64\x8b"));
bytes expectation;
expectation = encodeArgs(0x20, 4 + 0x60) + bytes{0xb3, 0xde, 0x64, 0x8b} + encodeArgs(0x20, 3, "abc") + bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f1()"), expectation);
ABI_CHECK(callContractFunction("f1s()"), expectation);
expectation =
encodeArgs(0x40, 0x140, 4 + 0xc0) +
(bytes{0xe9, 0xc9, 0x21, 0xcd} + encodeArgs(0x20, 4, u256(-1), u256(-2), u256(-3), u256(-4)) + bytes(0x20 - 4)) +
encodeArgs(2, 0, 0);
ABI_CHECK(callContractFunction("f2()"), expectation);
}
BOOST_AUTO_TEST_CASE(abi_encode_with_signaturev2)
{
char const* sourceCode = R"T(
pragma experimental ABIEncoderV2;
contract C {
function f0() public pure returns (bytes) {
return abi.encodeWithSignature("f(uint256)");
}
function f1() public pure returns (bytes) {
string memory x = "f(uint256)";
return abi.encodeWithSignature(x, "abc");
}
string xstor;
function f1s() public returns (bytes) {
xstor = "f(uint256)";
return abi.encodeWithSignature(xstor, "abc");
}
function f2() public pure returns (bytes r, uint[] ar) {
string memory x = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
uint[] memory y = new uint[](4);
y[0] = uint(-1);
y[1] = uint(-2);
y[2] = uint(-3);
y[3] = uint(-4);
r = abi.encodeWithSignature(x, y);
// The hash uses temporary memory. This allocation re-uses the memory
// and should initialize it properly.
ar = new uint[](2);
}
struct S { uint a; string b; uint16 c; }
function f4() public pure returns (bytes) {
bytes4 x = 0x12345678;
S memory s;
s.a = 0x1234567;
s.b = "Lorem ipsum dolor sit ethereum........";
s.c = 0x1234;
return abi.encodeWithSignature(s.b, uint(-1), s, uint(3));
}
}
)T";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 4, "\xb3\xde\x64\x8b"));
bytes expectation;
expectation = encodeArgs(0x20, 4 + 0x60) + bytes{0xb3, 0xde, 0x64, 0x8b} + encodeArgs(0x20, 3, "abc") + bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f1()"), expectation);
ABI_CHECK(callContractFunction("f1s()"), expectation);
expectation =
encodeArgs(0x40, 0x140, 4 + 0xc0) +
(bytes{0xe9, 0xc9, 0x21, 0xcd} + encodeArgs(0x20, 4, u256(-1), u256(-2), u256(-3), u256(-4)) + bytes(0x20 - 4)) +
encodeArgs(2, 0, 0);
ABI_CHECK(callContractFunction("f2()"), expectation);
expectation =
encodeArgs(0x20, 4 + 0x120) +
bytes{0x7c, 0x79, 0x30, 0x02} +
encodeArgs(u256(-1), 0x60, u256(3), 0x1234567, 0x60, 0x1234, 38, "Lorem ipsum dolor sit ethereum........") +
bytes(0x20 - 4);
ABI_CHECK(callContractFunction("f4()"), expectation);
}
BOOST_AUTO_TEST_CASE(abi_encode_call)
{
char const* sourceCode = R"T(
contract C {
bool x;
function c(uint a, uint[] b) public {
require(a == 5);
require(b.length == 2);
require(b[0] == 6);
require(b[1] == 7);
x = true;
}
function f() public returns (bool) {
uint a = 5;
uint[] memory b = new uint[](2);
b[0] = 6;
b[1] = 7;
require(this.call(abi.encodeWithSignature("c(uint256,uint256[])", a, b)));
return x;
}
}
)T";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f()"), encodeArgs(true));
}
BOOST_AUTO_TEST_CASE(staticcall_for_view_and_pure)
{
char const* sourceCode = R"(

47
test/libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -7061,53 +7061,6 @@ BOOST_AUTO_TEST_CASE(reject_interface_constructors)
CHECK_ERROR(text, TypeError, "Wrong argument count for constructor call: 1 arguments given but expected 0.");
}
BOOST_AUTO_TEST_CASE(tight_packing_literals)
{
char const* text = R"(
contract C {
function f() pure public returns (bytes32) {
return keccak256(1);
}
}
)";
CHECK_WARNING(text, "The type of \"int_const 1\" was inferred as uint8.");
text = R"(
contract C {
function f() pure public returns (bytes32) {
return keccak256(uint8(1));
}
}
)";
CHECK_SUCCESS_NO_WARNINGS(text);
text = R"(
contract C {
function f() pure public returns (bytes32) {
return sha3(1);
}
}
)";
CHECK_WARNING_ALLOW_MULTI(text, (std::vector<std::string>{
"The type of \"int_const 1\" was inferred as uint8.",
"\"sha3\" has been deprecated in favour of \"keccak256\""
}));
text = R"(
contract C {
function f() pure public returns (bytes32) {
return sha256(1);
}
}
)";
CHECK_WARNING(text, "The type of \"int_const 1\" was inferred as uint8.");
text = R"(
contract C {
function f() pure public returns (bytes32) {
return ripemd160(1);
}
}
)";
CHECK_WARNING(text, "The type of \"int_const 1\" was inferred as uint8.");
}
BOOST_AUTO_TEST_CASE(non_external_fallback)
{
char const* text = R"(

13
test/libsolidity/syntaxTests/functionCalls/arbitrary_parameters_but_restricted_first_type.sol Normal file
View File

@ -0,0 +1,13 @@
contract C {
function f() pure public {
abi.encodeWithSelector();
abi.encodeWithSignature();
abi.encodeWithSelector(uint(2), 2);
abi.encodeWithSignature(uint(2), 2);
}
}
// ----
// TypeError: (52-76): Need at least 1 arguments for function call, but provided only 0.
// TypeError: (86-111): Need at least 1 arguments for function call, but provided only 0.
// TypeError: (144-151): Invalid type for argument in function call. Invalid implicit conversion from uint256 to bytes4 requested.
// TypeError: (189-196): Invalid type for argument in function call. Invalid implicit conversion from uint256 to string memory requested.

17
test/libsolidity/syntaxTests/specialFunctions/abi_encode_structs.sol Normal file
View File

@ -0,0 +1,17 @@
contract C {
struct S { uint x; }
S s;
struct T { uint y; }
T t;
function f() public view {
abi.encode(s, t);
}
function g() public view {
abi.encodePacked(s, t);
}
}
// ----
// TypeError: (131-132): This type cannot be encoded.
// TypeError: (134-135): This type cannot be encoded.
// TypeError: (200-201): This type cannot be encoded.
// TypeError: (203-204): This type cannot be encoded.

18
test/libsolidity/syntaxTests/specialFunctions/abi_encode_structs_abiv2.sol Normal file
View File

@ -0,0 +1,18 @@
pragma experimental ABIEncoderV2;
contract C {
struct S { uint x; }
S s;
struct T { uint y; }
T t;
function f() public view {
abi.encode(s, t);
}
function g() public view {
abi.encodePacked(s, t);
}
}
// ----
// Warning: (0-33): Experimental features are turned on. Do not use experimental features on live deployments.
// TypeError: (235-236): This type cannot be encoded.
// TypeError: (238-239): This type cannot be encoded.

9
test/libsolidity/syntaxTests/specialFunctions/types_with_unspecified_encoding_structs.sol
View File

@ -1,14 +1,13 @@
contract C {
struct S { uint x; }
S s;
struct T { }
struct T { uint y; }
T t;
function f() public pure {
function f() public view {
bytes32 a = sha256(s, t);
a;
}
}
// ----
// Warning: (51-63): Defining empty structs is deprecated.
// TypeError: (131-132): This type cannot be encoded.
// TypeError: (134-135): This type cannot be encoded.
// TypeError: (139-140): This type cannot be encoded.
// TypeError: (142-143): This type cannot be encoded.

16
test/libsolidity/syntaxTests/specialFunctions/types_with_unspecified_encoding_structs_abiv2.sol Normal file
View File

@ -0,0 +1,16 @@
pragma experimental ABIEncoderV2;
contract C {
struct S { uint x; }
S s;
struct T { uint y; }
T t;
function f() public view {
bytes32 a = sha256(s, t);
a;
}
}
// ----
// Warning: (0-33): Experimental features are turned on. Do not use experimental features on live deployments.
// TypeError: (174-175): This type cannot be encoded.
// TypeError: (177-178): This type cannot be encoded.

25
test/libsolidity/syntaxTests/tight_packing_literals.sol Normal file
View File

@ -0,0 +1,25 @@
contract C {
function f() pure public returns (bytes32) {
return keccak256(1);
}
function g() pure public returns (bytes32) {
return sha3(1);
}
function h() pure public returns (bytes32) {
return sha256(1);
}
function j() pure public returns (bytes32) {
return ripemd160(1);
}
function k() pure public returns (bytes) {
return abi.encodePacked(1);
}
}
// ----
// Warning: (87-88): The type of "int_const 1" was inferred as uint8. This is probably not desired. Use an explicit type to silence this warning.
// Warning: (161-168): "sha3" has been deprecated in favour of "keccak256"
// Warning: (166-167): The type of "int_const 1" was inferred as uint8. This is probably not desired. Use an explicit type to silence this warning.
// Warning: (247-248): The type of "int_const 1" was inferred as uint8. This is probably not desired. Use an explicit type to silence this warning.
// Warning: (331-332): The type of "int_const 1" was inferred as uint8. This is probably not desired. Use an explicit type to silence this warning.
// Warning: (420-421): The type of "int_const 1" was inferred as uint8. This is probably not desired. Use an explicit type to silence this warning.

11
test/libsolidity/syntaxTests/tight_packing_literals_fine.sol Normal file
View File

@ -0,0 +1,11 @@
contract C {
function f() pure public returns (bytes32) {
return keccak256(uint8(1));
}
function g() pure public returns (bytes) {
return abi.encode(1);
}
function h() pure public returns (bytes) {
return abi.encodePacked(uint8(1));
}
}

8
test/libsolidity/syntaxTests/viewPure/view_pure_abi_encode.sol Normal file
View File

@ -0,0 +1,8 @@
contract C {
function f() pure public returns (bytes r) {
r = abi.encode(1, 2);
r = abi.encodePacked(f());
r = abi.encodeWithSelector(0x12345678, 1);
r = abi.encodeWithSignature("f(uint256)", 4);
}
}

36
test/libsolidity/syntaxTests/viewPure/view_pure_abi_encode_arguments.sol Normal file
View File

@ -0,0 +1,36 @@
contract C {
uint x;
function gView() public view returns (uint) { return x; }
function gNonPayable() public returns (uint) { x = 4; return 0; }
function f1() view public returns (bytes) {
return abi.encode(gView());
}
function f2() view public returns (bytes) {
return abi.encodePacked(gView());
}
function f3() view public returns (bytes) {
return abi.encodeWithSelector(0x12345678, gView());
}
function f4() view public returns (bytes) {
return abi.encodeWithSignature("f(uint256)", gView());
}
function g1() public returns (bytes) {
return abi.encode(gNonPayable());
}
function g2() public returns (bytes) {
return abi.encodePacked(gNonPayable());
}
function g3() public returns (bytes) {
return abi.encodeWithSelector(0x12345678, gNonPayable());
}
function g4() public returns (bytes) {
return abi.encodeWithSignature("f(uint256)", gNonPayable());
}
// This will generate the only warning.
function check() public returns (bytes) {
return abi.encode(2);
}
}
// ----
// Warning: (1044-1121): Function state mutability can be restricted to pure