Self-enforcing

Standard contracts bind the parties involved according to their legal system and are enforceable by the law and its institutions. Smart contracts, on the other hand, are self-enforcing contracts. They are written into the lines of code that is distributed across the decentralized blockchain network. They need no central authority to validate them.

Unstoppable

Smart contracts should be irreversible and irrevocable. So for example the accounts to which tokens will be transferred can’t be changed or deleted. But exceptions apply, such as TransparentUpgradeableProxy. Ethereum Smart Contracts can’t be re-deployed on the same address.

Secure

Many Smart Contracts have bugs that make it easy for hackers to operate with tokens to their advantage.

Atomicity

Transactions are atomic operations, they can’t be divided or interrupted. Transaction is either done, or not.

Accounts

There are two types of accounts. First, it’s the externally owned accounts (EOA). Those are the accounts of the users that have a balance, are autonomous and controlled by a private key. Second, it’s the contract accounts that contain the EVM code.

Deployment transaction

Contract creation is a transaction. Each contract has its own storage and code. During the initial transaction, a new irreversible code is created.

Calls vs. transactions

There are two ways to communicate with a smart contract. The first way is transactions, which change the network state. Transactions consume resources of the network and, of course, costs some gas. After you confirm the transaction, it becomes listed among the pending transactions and waits for a miner to validate it. The second way is the Smart Contract Call that calls the storage and returns its content. SSCs are simple RPC calls that you can run using e.g. geth requests. SSCs cost no gas and you get the response immediately. Calls don’t change the network state.

Tutorial objectives

We will learn how to compile and deploy smart contracts.

Tutorial pre-requirements

Compile a contract

Once the contract enters the network, you can’t find out anything about its license, unless it’s specified in the body of the contract. Also always define compatible versions of solidity compilers.

// SPDX-License-Identifier: GPL-3.0
// pragma solidity ^0.8.9;
pragma solidity 0.8.9;

contract Name {
    string myName;

    function getMyName() public view returns (string memory) {
        return myName;
    }

    function changeMyName(string memory _newName) public {
        myName = _newName;
    }
}

Deploy the contract (using geth)

Initialise again a new local chain with a a new genesis block. See chaged chain parameters.

{
  "config": {
    "chainId": 15,
    "byzantiumBlock": 0,
    "constantinopleBlock": 0,
    "petersburgBlock": 0,
    "istanbulBlock": 0,
    "homesteadBlock": 0,
    "eip150Block": 0,
    "eip155Block": 0,
    "eip158Block": 0
  },
  "difficulty": "0x40000",
  "gasLimit": "2100000",
  "alloc": {
    "7df9a875a174b3bc565e6424a0050ebc1b2d1d82": { "balance": "30000000000" },
    "f41c74c9ae680c1aa78f42e5647a62f353b7bdde": { "balance": "40000000000" },
    "0332a7cb94a12d0980f44b2b751f11a4db8cf17e": { "balance": "50000000000" }
  }
}

Deploy the contract. Which is, as we mentioned earlier, another type of transaction apart from the transaction used to send tokens.

[Deprecated] Deploy the contract (using Truffle)

The default template, created using the command truffle unbox, is MetaCoin. Learn more about Truffle Boxes at https://www.trufflesuite.com/boxes.

const Migrations = artifacts.require("Migrations");
const Name = artifacts.require("Name");

module.exports = function (deployer) {
 deployer.deploy(Migrations);
 deployer.deploy(Name);
};

Deploy the contract (using Remix)

Visit https://remix.ethereum.org/.

Build and deploy a contract using Hardhat

Deploy name_contract.sol using Hardhat https://hardhat.org/hardhat-runner/docs/getting-started