 Marios asks, Can you explain the process from the time an Ethereum user wants to execute a smart contract, until it is uploaded on the blockchain, executed and displayed on a valid block? That's a great question, Marios. First of all, in order to explain this, keep in mind that there are effectively three different types of transactions in Ethereum. The first one is a straight payment. That's a transaction that happens from a regular account, as it's known in Ethereum, an externally owned account, or EOA, to another externally owned account, basically from a private key, public key pair that a user has, to another private key, public key pair in the form of an Ethereum address, to another user. So this is just a payment from one user to another, from one address to another, exactly the same as you see in a Bitcoin transaction. There is another type of transaction where you send payment and data, or both, not to another user, but instead to the address of a contract. So this is a big distinction in Ethereum between an address that belongs to a user that has a private public key behind it, an externally owned address, or EOA, as it's known, or an address that belongs to a contract which does not have a private key behind it. It's run by the code in the contract. So an address that's run by a contract can receive a transaction, and this transaction may include data that tells it what to do, or a payment. And that's how you make a contract run in Ethereum. You send a transaction to the contract address, and instead of that going to the address of a user, it goes to the address of a contract where the contract executes with that input. Finally, there's a third type of transaction, a kind of special transaction, which is sending data to the zero address. And what that does is it registers a contract for the first time. So let's put all of those ideas together and explain the process from the moment the Ethereum user wants to run a contract. Now, let's say that contract doesn't exist. Well, the first thing they would need to do is write the contract, compile it, create the code for the contract, then embed the contract in a special transaction to the zero address, and pay to get that contract mined. Now, at this point, what that will do is it will create an address for the contract, and it will record the code of the contract onto the blockchain. So now the contract can be run. To run the contract, any user would then send a transaction to the address of the contract. And that transaction can contain some value, like a payment. It can also contain some data, and the data may call one of the functions in the contract. Or it can contain both value, payment, and data at the same time. Once a user sends a transaction to the address of a contract, the Ethereum virtual machine, and this applies to other blockchains that use a virtual machine, will start executing the contract, passing the transaction as input to it, so that the contract knows what to run. And then that execution happens under the consensus rules, and it causes changes to the state of the contract. It might cause a contract to make a payment, to call other contracts, to run a function, to update some internal data, etc. All of these things happen as a direct result of that transaction to the contract, which is what causes it to run. So every contract runs when it's triggered by a transaction, and using that transaction's input as its input. A contract doesn't run on its own. Contracts never run on their own. They have to be triggered by a transaction. And before that even happens, the contract has to first be registered with the Ethereum blockchain. Can you explain how a user can define the gas price? They have paid for a transaction. And if not enough gas, the transaction will still be processed. Is there an advantage to always put more than what is required, in order to get the transaction process faster? When you create a transaction in an Ethereum wallet, your wallet gets to set two parameters. One is the gas price, and the other one is the gas limit. The gas price creates an exchange rate between gas and Ether. Gas is not Ether, but it is used to measure Ether, meaning that the gas is priced in the Ether. For example, you say how much gas you want to put in, and then each gas unit has a price in Ether, and that price in Ether determines how much you are willing to spend, in total, to have that transaction processed. If you have enough in your limit, then the transaction will be processed, and you will be charged how much gas you actually used in your transaction, which depends on what contracts you are executing or what payments you are making. For example, a simple payment costs 21,000 units of gas. Now, when you create a transaction, you can set not the amount of gas, because that is really about whether it will execute or not, but you can also set the gas price in order to prioritize your transaction vis-à-vis the other transactions. In that way, it works very similar to Bitcoin fees. The way GasWit works in Ethereum has similarities to the way Bitcoin fees work, but there are some important differences. By putting a higher amount of gas in your transaction, you make it more enticing to miners, so that they will mine it at a higher priority or sooner, than if you have a lower price. Again, this mostly matters when the blockchain is operating at or near capacity, at which point there are more transactions than can fit in each block, and some have to be prioritized over others. Gas determines that. There is a separate question, however, in Ethereum, which is the gas limit. You have to understand that one of the things that Gas does in Ethereum, is it prevents unlimited computation or denial of service attacks. That is its most important function. It does that because in Ethereum, processing a contract, a transaction that leads to running a contract, could run forever. It could involve other contracts. It could create loops. It can just keep running, consuming memory, updating data, and trying to do a lot of different things. Because everybody has to run that transaction and that contract, in order to participate in consensus, that means using a lot of resources on the system. In order to prevent runaway or abusive transactions and contracts that use too much computing, you have Gas. It is basically a system of controlling how many resources are being used. This is different from its function as a fee. The function is a fee to prioritize one thing. Again, the ultimate function is to set a limit on the maximum amount of computation you are willing to pay for. As a user, when you send a transaction or when your wallet creates a transaction, you or your wallet gets to decide how much maximum amount of gas you are willing to spend in order to get this transaction processed via the network. The network will take that maximum amount of gas from your account when the transaction starts executing, and then will gradually count how much of it you are using. If you run out of gas mid-computation, you are going to get an error, the transaction is going to get rejected, you will lose your gas, you will pay the fee, and your transaction won't actually work. If you have enough gas, because you set a high gas limit, then your transaction will execute, and you will be charged only for the amount of gas you actually use. That is how the function works. Remember, gas does two things in Ethereum, unlike Bitcoin fees that do one. It is used to prioritize transactions when the blockchain is at or near capacity, by ensuring that the transactions that are more important, because people are willing to pay more for their gas, are processed faster, and prioritized. Secondly, the main function of gas is to control how many resources the Ethereum blockchain spends on validating transactions by putting a limit on how much computation and data storage operations happen in the form of gas.