contract SimpleContract { uint256 public number = 5; // Long-named function function…
- User
contract SimpleContract { uint256 public number = 5;
// Long-named function function ThisIsAVeryLongFunctionNameThatDoesTheSameThingAsTheShortOne() public { number++; }}
contract SimpleContract { uint256 public number = 5;
// Short-named function function A() public { number++; }} Which of the following functions provided will cost more gas and why?
- Assistant
In the examples you provided, the function names are
ThisIsAVeryLongFunctionNameThatDoesTheSameThingAsTheShortOneandA. Function names in Ethereum smart contracts do not affect the gas cost of executing the functions at runtime. The gas cost is determined by the operation codes (opcodes) executed on the Ethereum Virtual Machine (EVM) and not by the names of the functions in the high-level Solidity code.The actual bytecode that gets deployed when you compile the Solidity contract does not contain the human-readable function names. Instead, function selectors are used. A function selector is the first 4 bytes of the Keccak-256 hash of the function signature (the function name and the list of parameter types). For example, if you have a function named
functionName(uint256), its function signature would be"functionName(uint256)", and the Keccak-256 hash of this signature would be taken. The first 4 bytes of that hash become the function selector used in the bytecode for calling that function.Therefore, both functions in your example, regardless of their name length, will ultimately be represented by a 4-byte function selector in the compiled bytecode. Since they are performing the same operation of incrementing a state variable, the gas costs will be essentially the same (disregarding any minor differences that could arise from different compiler optimizations or Solidity versions).
If there are differences in gas cost, they would likely come from different contexts such as the state of the contract when the function is called (e.g., the
numbervariable being at different values), but not from the length of function names themselves. - User
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20;
contract Callee { function getCodeSize() external pure returns (uint256) { assembly { let size := codesize() mstore(0x80, size) return(0x80, 0x20) } } }
contract Caller { address public calleeAddress;
constructor(address _calleeAddress) { calleeAddress = _calleeAddress; } function delegateGetCodeSize() public returns (uint256) { (bool success, bytes memory data) = calleeAddress.delegatecall( abi.encodeWithSignature("getCodeSize()); ); require(success, "Delegatecall failed"); return abi.decode(data, (uint256)); }} When delegateGetCodeSize() function of the Caller contract is called, whose size does it return - the caller or the callee?
- Assistant
The
delegateGetCodeSize()function of the Caller contract uses adelegatecallto thegetCodeSize()function of the Callee contract. Thedelegatecallis a special type of call that invokes a function in another contract, but it executes within the context of the calling contract. This means that the state, current caller, and value of theETH(if sent along with the call) are kept in the context of the calling contract (Caller), not the called contract (Callee).In the Callee contract, the
getCodeSize()function uses inline assembly to get thecodesize, which is an opcode that returns the size of the code running in the current context. Sincedelegatecallwas used, "the current context" refers to the Caller contract, not the Callee.Therefore, when
delegateGetCodeSize()is called in the Caller contract, the size returned bygetCodeSize()in the Callee contract throughdelegatecallwill be the size of the code of the Caller contract, not of the Callee itself.However, there is an error in your code snippet:
abi.encodeWithSignature("getCodeSize());The parentheses and quotation marks are mismatched here. It should be corrected to:
abi.encodeWithSignature("getCodeSize()");Once the typo is fixed, calling
delegateGetCodeSize()will return the size of the Caller contract's bytecode. - User
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20;
contract Callee { function getCodeSize() external pure returns (uint256) { assembly { let size := codesize() mstore(0x80, size) return(0x80, 0x20) } } }
contract Caller { address public calleeAddress;
constructor(address _calleeAddress) { calleeAddress = _calleeAddress; } function delegateGetCodeSize() public returns (uint256) { (bool success, bytes memory data) = calleeAddress.delegatecall( abi.encodeWithSignature("getCodeSize()); ); require(success, "Delegatecall failed"); return abi.decode(data, (uint256)); }} When delegateGetCodeSize() function of the Caller contract is called, whose size does it return - the caller or the callee?
- Assistant
When
delegateGetCodeSize()is called on theCallercontract, it makes adelegatecalltogetCodeSize()on theCalleecontract. Becausedelegatecallis used, it executes the code ofgetCodeSize()in the context of theCallercontract.In Solidity,
codesize(or theCODESIZEopcode in the EVM) returns the size of the code of the contract currently executing. Since thedelegatecallessentially brings the code fromCalleeinto the context of theCallerto execute it, the code that is being executed is still part of theCaller's code whencodesizeis executed. Therefore,codesizewill return the size of theCallercontract's bytecode, not the bytecode size of theCallee.However, it is important to note there is a syntax error in the code you provided:
abi.encodeWithSignature("getCodeSize());This line should be corrected to:
abi.encodeWithSignature("getCodeSize()");After fixing the syntax error, when you call
delegateGetCodeSize()on theCallercontract, it will return the code size of theCallercontract, because the code is executed in the storage and runtime context of theCaller.