93
All of the opcodes and their complete descriptions are available in the Ethereum Yellow paper. For convenience, though, I've made a handy reference list of them all:
0s: Stop and Arithmetic Operations
0x00 STOP Halts execution
0x01 ADD Addition operation
0x02 MUL Multiplication operation
0x03 SUB Subtraction ...
23
As others have stated, the x
m:=mload(0x40) instruction reads the 32 bytes of memory starting at position 0x40.
In solidity, the 0x40 slot in memory is special: it contains the "free memory pointer" which points to the end of the currently allocated memory.
When you use inline assembly, you should load the data stored at 0x40 and then only write to ...
19
mload(0xAB) Loads the word (32byte) located at the memory address 0xAB. e.g mload(0x60) loads the word located at 0x60 memory address.
let's code to understand more :
function f ()
{
assembly {
let freemem_pointer := mload(0x40)
mstore(add(freemem_pointer,0x00),"36e5236fcd4c61044949678014f0d085")
mstore(...
15
As the author of that module, a few things that came up:
Inline assembly allows you to read entire words (256 bits) from data types like string and bytes in a single operation. Solidity-stringutils uses that to do very fast string comparisons by doing subtraction on 32-byte chunks of the two strings being compared. Without assembly, you have to do this byte-...
14
EDIT: The function will return false if it is invoked from a contract's constructor (because the contract has not been deployed yet).
The code should be used very carefully, if at all, to avoid security hacks such as:
https://www.reddit.com/r/ethereum/comments/916xni/how_to_pwn_fomo3d_a_beginners_guide/ (archive)
To repeat:
Do not use the EXTCODESIZE ...
11
This is the Swarm hash. It is documented at https://solidity.readthedocs.io/en/develop/metadata.html
Extract follows
Contract Metadata
The Solidity compiler automatically generates a JSON file, the
contract metadata, that contains information about the current
contract. It can be used to query the compiler version, the sources
used, the ABI and NatSpec ...
11
Within the assembly code, _data is the memory address of the start of the array data.
However, the first memory word (32 bytes = 0x20 bytes) is reserved for the length of the array, so we need to step over this. Thus, _data[0] is at memory address _data + 0x20. In the code, this looks like add(_data, 0x20).
The array elements follow consecutively, ...
10
All things must have a beginning
I think you're getting called from a contract constructor before it's committed to the chain.
At this point, it will have a (theoretical) address but no code yet in the chain. It will only get code size after the transaction completes and the block is accepted.
10
The explanation is quite simple:
In Solidity, bytes is a dynamically-sized byte array:
Variables of type bytes and string are special arrays. A bytes is
similar to byte[], but it is packed tightly in calldata. string is
equal to bytes but does not allow length or index access (for now).
In Solidity Assembly, variables are pointers to memory ...
8
Martin Holst Swende published an implementation of a cloner contract here! https://gist.github.com/holiman/069de8d056a531575d2b786df3345665
Excerpt:
function clone(address a) returns(address){
/*
Assembly of the code that we want to use as init-code in the new contract,
along with stack values:
# bottom [ STACK ] top
...
8
This code snippet is correct, although it seems important to note that EXTCODESIZE will return 0 when called within the constructor of a contract, since the contract is not created yet. Hence, if msg.sender is a contract, the isContract() modifier could return false if your contract's function is called within the constructor of the msg.sender contract. This ...
7
DELEGATECALL is an instruction interpreted by EVM. So to execute DELEGATECALL you have to have a program (contract) that gets executed on EVM.
DELEGATECALL takes six operands, one of them is the address of the calee.
So it can only call deployed contracts.
Note that so called library is just a special contract which operations are called with DELEGATECALL.
...
7
This works:
return address(keccak256(publicKey) & (2**(8*21)-1));
2**(8*21)-1 is just a trick to get 0xFFFFFF... (40 Fs) without typing it. :-)
EDIT
As pointed out by @schnorr, there's no need for the mask:
return address(keccak256(publicKey));
7
You can use this function to convert bytes to unit:
pragma solidity ^0.4.23;
contract mycontract {
function bytesToUint(bytes b) public returns (uint256){
uint256 number;
for(uint i=0;i<b.length;i++){
number = number + uint(b[i])*(2**(8*(b.length-(i+1))));
}
return number;
}
}
The amount of gas used ...
6
OpenZeppelin's one is the most generic and addresses contract upgrade scenario. It forwards msg.data as is to called contracts, and returns what called contract returned.
MakerDAO's is also generic but it allows passing arbitrary bytes as parameters and packs returned value into bytes as well.
Simple version allows arbitrary bytes as parameters but only ...
5
This is designed to convert an address to a dynamic bytes type. Addresses are 20 bytes long, and occupy the right-most 20 bytes of a 32-byte word:
0x000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
The bytes type is two (or more) words: the number of bytes followed by the data. The number of bytes in an address is 20 = 0x14, so it need to ...
5
Others have pointed in the right direction, but let me try to specifically answer the questions.
First, each 256-bit word of contract storage is very expensive. When a contract is using smaller variables, such as uint32 (32 bits), then Solidity will try to pack multiple variables into one storage word. Most of what you see here is the compiler first ...
5
This worked for CREATE2. Maybe it also works on CREATE?
abi.encodePacked(bytecode, abi.encode(arg1, arg2))
Example (CREATE2)
pragma solidity ^0.5.11;
contract Wallet {
address public owner;
uint public foo;
constructor(address _owner, uint _foo) public {
owner = _owner;
foo = _foo;
}
}
contract Factory {
event ...
5
CREATE opcode is used by default when deploying smart contracts. The deployed contract address is calculated like this.
keccak256(senderAddress, nonce)
CREATE2 opcode is introduced later and allows you to predetermine the contract address. Contract address is computed like this.
keccak256(0xFF, senderAddress, salt, bytecode)
0xFF parameter is a constant to ...
4
Both create a contract.
An externally owned account (EOA) creates a contract by sending a transaction with no to field.
A contract (account) creates another contract by using the CREATE opcode.
It's cheaper gas-wise for a contract to create another contract, than an EOA to create a contract (TODO fill in gas costs). This question inspires Can the CALL ...
4
I know this is an old topic, but here's a couple of tutorials I put together to cover assembly in solidity:
Functional Assembly - https://www.youtube.com/watch?v=nkGN6GwkMzU
Instructional Assembly - https://www.youtube.com/watch?v=axZJ2NFMH5Q
I go into the benefits, disadvantages, examples and debugging assembly.
4
The author of the github page that you referenced didn't update the free memory pointer after allocating the memory. Also as Tjaden Hess noted in the comments
return as an opcode and return as a Solidity statement are very different. The opcode causes the entire contract execution to return at that point, with the return value that you designate in ...
4
Constructor arguments are appended to the deployment byte code in the standard ABI format.
For example, this contract takes uint constructor argument.
contract Foo {
uint a;
function Foo(uint _a) public {
a = _a;
}
}
It compiles to the following deployment bytecode:
...
4
Slicing an uint out of bytes using inline assembly
function sliceUint(bytes bs, uint start)
internal pure
returns (uint)
{
require(bs.length >= start + 32, "slicing out of range");
uint x;
assembly {
x := mload(add(bs, add(0x20, start)))
}
return x;
}
4
The contract prologue instructions changed to provide an additional slot at 0x60, which should always hold the value 0. The documentation states that:
The zero slot is used as initial value for dynamic memory arrays and
should never be written to (the free memory pointer points to 0x80
initially).
FYI I checked several contracts with JEB Decompiler, ...
4
Each storage variable has its own storage slot whose address is a sequential number of this variable within contract:
contract Foo {
uint internal x; // Storage slot #0
mapping (uint => uint) internal y; // Storage slot #1
uint [] internal z; // Storage slot #2
}
For atomic variables, such as x, this slot holds variable value.
For mapping ...
4
This contract is quite "old" (pragma solidity ^0.4.15;). The logic is actually taken from the solidity compiler. When targeting older versions of the evm it was not possible to send along all gas. The solidity code still exists even now: https://github.com/ethereum/solidity/blob/develop/libsolidity/codegen/ExpressionCompiler.cpp#L2343
Solidity changed this ...
4
This is because memory variables are treated as pointers from in solidity assembly - and that pointer points to the start in memory of the variable. The way arrays are stored in memory in Solidity is with the first 0x20 (32) bytes being the length of the data in the array, and then the actual data directly following, which is why add(bytecode, 0x20) is ...
3
This is about the way that Solidity byte types are represented for use in the EVM: byte types are all left-justified within a 32-byte word, i.e. a single byte type is left-shited by 31 * 8 = 248 bits before being put on the stack.
In your first example, variable b is a single-width byte type so it is put on the stack as ...
3
Organize the 5 uint8 values in a single struct. When you compile the contract, make sure optimization is turned on. Since storage slots are 32 bytes, the compiler will automatically squidge your uint8s together in storage for maximum gas efficiency.
Only top voted, non community-wiki answers of a minimum length are eligible
