evm | A Simple Elasticsearch Version Manager | Cryptocurrency library

You can decode the revertReason using web3.utils.hexToAscii().

The LINK_TOKEN_POINTER is a contract that is hard-coded with pointers to the LINK token on various chains. This is so that the contract knows which LINK token to use.

For a chain like harmony, the LINK token pointer probably has not been added for that chain.

To get around this, you'll want to manually set the LINK token, like so:

You cannot convert a bytes32 to a uint256.

Your draw array is an array of uint256s. getRandomNumber returns a bytes32.

On this line:

1. Does --opcodes just give a more compact form of assembly code compared to --asm output?

That's somewhat correct. You could still translate the assembly to opcodes and get the same result.

Assembly represents a set of "low level-ish" instructions. Opcodes are the "real" binary instructions passed to the EVM. See for example this table that translates the opcodes to binary.

2. PUSH1 0x80 PUSH1 0x40 MSTORE in --opcodes format vs. mstore(0x40, 0x80) in --asm format. Are they doing the same thing? (I guess so but not 100% sure...)

Yes, they are doing the same thing - see answer to 1. When you run this snippet in Solidity

It looks like you are not passing the userProvidedSeed as an argument to getRandomNumber()

Try putting any number into the box beside the getRandomNumber method in Remix and then click on the method.

Also, fulfillRandomness is only callable by the Chainlink VRF, so do no worry about calling that function.

Whenever you want to interact with a contract on-chain, you need 4 things:

1. The ABI
2. The Address
3. The Blockchain
4. A wallet with funds to pay for the gas

And when you create your contract, yes, your application needs to know what the ABI of the child contract is. So when you create your child contract, you'll need to pass in the ABI.

ETH balance:

The blockchain stores state changes, which are used to calculate the current ETH balance of an address.

You can theoretically create and broadcast a transaction that spends more than your current balance. But the network would refuse this transaction as invalid:

Most likely you would not find any miner that would include this transaction in a block. And if you had a miner that would include the tx in a block, rest of the network would refuse this (invalid) block, and accept someone else's (valid) block.

Token balance:

The token balance is stored in the token contract storage. (In some cases, the balances might be stored in another contract, but it's still some contract's storage.)

Most token contracts' logic contains validation whether the sender has enough token balance to send the tokens. If they don't have enough token balance, the contract creates an invalid EVM opcode, that results in reverting the transaction (so the token balance is not changed). Or sometimes the contract just lets the Ethereum transaction pass, but it doesn't update any token balance.

Example code of the validation on OpenZeppelin's implementation of ERC-20 token: GitHub link (the require() statement in the _transfer() function)

Only few token contracts are faulty and don't have this validation. But a faulty implementation might allow the sender to send more tokens than they currently own.

Got it to work. Problem is, the transaction has to be signed before sending it. Here is the updated deploy function.

I figured it out the problem. I changed the code