2
Due to their unpredictable size, dynamically-sized array types use a Keccak-256 hash computation to find the starting position of the array data.
So in your example:
The position of storageArr[0] is at keccak256(uint256(0)) + 0
The position of storageArr[1] is at keccak256(uint256(0)) + 1
The position of storageArr[2] is at keccak256(uint256(0)) + 2
Here ...
2
This is about how the variables are packed together and about how smart the compiler is (hint: not very smart). The compiler only tries to pack subsequent variables together but it can't pack variables which have something else between them.
In your first case the variables could all fit inside a single 32 byte slot, but if I'm not mistaken the compiler ...
2
The return-value of a non-constant (neither pure nor view) function is available only when the function is called on-chain (i.e., from this contract or from another contract).
When you call such function from the off-chain (e.g., from an ethers.js script), you need to execute it within a transaction, and the return-value is the hash of that transaction.
This ...
2
A copy of structTest is saved separately in the array and in the mapping.
In order to get rid of this redundancy, you can maintain an array of keys instead of values:
uint[] all; // instead of `test[] all;`
mappings (uint => test) map;
function bla() {
test memory structTest = test(5);
all.push(10); // instead of `all.push(structTest);`
map[...
2
CREATE2 is very cool, I was one of the engineers that worked on this project at Coinbase Commerce. You can read more about the implementation and our approach at the following blogpost
https://blog.coinbase.com/usdc-payment-processing-in-coinbase-commerce-b1af1c82fb0
2
Yes. You can achieve this by using signatures of the member keys instead of transactions.
To achieve this, each members of the multisig can sign a message attesting that they approve of the transaction. They can then give their signatures to a single entity who broadcasts the transaction that includes all the signatures as data. On-chain, the smart contract ...
1
Your concept of "speed" is a bit wrong. Transactions which utilize less gas are not faster.
Assuming that your transaction fits inside a block the only thing which affects the transaction speed is the gas price. The size of the transaction mostly does not affect the speed. Miners mostly order the transactions they take in their blocks by their gas ...
1
getBalance is a function of the Ether.js blockchain provider object, it is used this way :
const balance = await provider.getBalance("address");
Note that you can use contract.address to obtain the address of the contract instance.
1
This is a bug in geth that was resolved in v1.9.13.
The original issue can be found in Issue #16999 and the fix can be found in PR #20783.
The issue was basically that geth was subtracting 0 by (gasLimit * gasPrice), which underflowed and resulted in the large number you saw. In your case, you were probably using the default Remix values of gasPrice = ...
1
Is this how it's supposed to be?
No, you can (and should) omit the uint amount parameter.
Instead, the user should pass the desired amount within the msg.value.
This way, the user (and not your contract) will be the one providing the funds.
1
Get the pool address
Go to the Uniswap UI at https://app.uniswap.org/. Choose the token pair you want and then click the View pair analytics ↗. This will take you to a link like https://uniswap.info/pair/<poolAddress>. Note down poolAddress.
Approve via Etherscan
Go to https://etherscan.io/token/<tokenAddress>#writeContract where tokenAddress ...
1
The article is wrong. Value types like bool, uintXXX, bytesYY, etc. are stored in stack, for dynamic types you are forced to choose memory or storage.
To read the array data just mload the address. Fixed size data arrays only contains the data, they don't store the length at the beginning like dynamic arrays.
function test() public view returns (uint r) {
...
1
When a smart contract has been deployed its bytecode is saved on the chain. To execute the contract you send a transaction with the smart contracts address as recipient. Additional data can be passed to the contract as calldata which can be imagined as parameters to the contracts execution.
When the node validates the transaction it notices that the ...
1
You cannot transfer tokens from a contract address, unless that contract address has a function built-in to send a transaction or recover tokens in some way. It doesn't look like DAI has this built-in, so I'm afraid that your tokens are lost.
In the future, double check the address you're sending to, and send a small test transaction if you're moving a ...
1
There's Simple Multisig, by Christian Lundkvist, that requires sending all signatures in a single transaction.
It has a execute function that validates the signatures and executes the operation requested:
function execute(
uint8[] sigV,
bytes32[] sigR,
bytes32[] sigS,
address destination,
uint value,
bytes data,
address ...
Only top voted, non community-wiki answers of a minimum length are eligible
