Smart Contracts and Oracles

Introduction to Smart Contracts

• Smart contracts automatically execute contract terms via a computerized transaction protocol
• A primary goal is to satisfy standard contractual conditions like payment terms
• Minimizing the requirement for trusted third parties is necessary.
• Smart contracts feature self-executing terms written directly into code
• Ethereum is known as the pioneer platform for smart contracts
• Ether (ETH) is used for transaction fees and computational expenses
• Smart contract execution needs Ether, referred to as "gas," to cover computational expenses.
• Each smart contract is owned, has a lifecycle, and runs on the Ethereum Virtual Machine (EVM).
• They help facilitate peer-to-peer lending by allowing direct lending without traditional banks

Oracles

• Oracles collect required data for smart contracts at scheduled times, storign them on a blockchain at a defined location.
• Oracles are third parties, which contradict blockchain principles.
• They have significant influence over smart contract operations.
• Two potential failures of oracles include the failure to collect data and the introduction of incorrect data (voluntary or involuntary)
• Solutions include provable-honest oracles, consensus-based oracles, and physical oracles

Interacting with Smart Contracts

• Smart contracts aren't self-executable and need an external call to run, otherwise they pend until invoked
• Executed transactions are recorded on the blockchain, updating the smart contract's metadata.
• Communication mandates the contract address and ABI
• Execution can be initiated by a person (using a private key account) or another smart contract (using a public key account).

Smart Contract Lifecycle

• The Application Binary Interface (ABI) is a set of rules for encoding and decoding data and function calls during interactions with Ethereum smart contracts
• Lifecycle steps include:
  • Writing smart contract code in Solidity
  • Compiling the code into bytecode, generating an ABI
  • Deploying the bytecode and ABI to the Ethereum Blockchain
  • A contract address is created
  • Client interacts with the deployed contract by using its contract address and ABI

Introduction to Solidity

• Solidity is a high-level programming language for writing on the Ethereum blockchain
• Solidity code is compiled into bytecode that runs on the Ethereum Virtual Machine (EVM)
• It is an object-oriented programming (OOP) language allowing data and functions to be encapsulated into smart contracts
• It supports OOP principles like inheritance to enable reusable and modular smart contracts

Solidity Syntax and Structure

• Solidity contracts begin with a pragma declaring the Solidity version
• Solidity code has:
  • Contracts are the base building blocks of applications
  • Functions that define actions or behavior
  • Variables to store data within the contract

Solidity Variables and Data Types

• Supports a variety of data types:
  • uint (unsigned integer)
  • int (signed integer)
  • bool (boolean)
  • address (Ethereum address)
• Variables are declared using data types
• State variables store data on the blockchain
• Local variables are temporary

Functions and Modifiers

• Functions perform designated tasks in a smart contract
• Modifiers change function behavior, such as view, pure, payable, and non-payable (default).
• Access rules for functions:
  • Public: can be called internally and externally
  • Private: accessible only within the contract
  • Internal: accessible within the contract and derived contracts
  • External: callable only externally

Gas Usage Considerations for Functions and Modifiers

• Public, inherited and overridden in derived contracts: Higher gas cost because it is similar to internal when called internally
• Internal, accessible only within the current contract, inherited and overridden in derived contracts: More gas-efficient for internal calls; no external call overhead
• External, only accessible externally, cannot be inherited or overridden: More gas-efficient for large inputs; incurs external call overhead
• Private, accessible only within the current contract, cannot be inherited or overridden: Similar to internal in terms of gas usage for internal calls; potential for higher overall deployment gas due to duplication

Control Structures

• Control structures are for decision-making and iteration, and include if statements and loops
• They enable smart contracts to respond to changing conditions.
• Critical to writing accurate smart contracts

Struct

• Structs are data types that group a list of related variables

Mappings

• Mappings let programmers create key-value pairs
• The pairs are stored in the form of a list

Remix IDE

• Remix IDE is an open-source web and desktop application
• An open-source tool for writing smart contracts in Solidity
• It is used for smart contract development, deployment, and testing
• Available at https://remix.ethereum.org/

Development Envirnoment

• Node JS is required
• Truffle installation is required
• Ganache installation is required

Smart Contract Security

• Over 40% of attacks originate from smart contracts
• Examples of hacks:
  • The DAO was hacked and 3.6 million ETH lost
  • Parity was hacked and 150 thousand ETH frozen
  • BEC crashed to zero value
  • SMT, EDU, BAI, and ICX all faced significant crashing problems

Coding Best Practices

• Access Control: restrict sensitive function calls to the contract owner or authorized addresses, use OpenZeppelin's Ownable contract
• Emitting Events: allows off-chain applications to accurately and efficiently monitor on-chain actions, tracks transactions and changes in s
• Data Validation: best practice to ensure data integrity by preventing duplicate entries and ensure accurate and predictable contracts
• Reentrancy Guard: private boolean variable to serve as the flag for the reentrancy guard
• Always prevent reentrancy by updating the state before any payable transfer
• Gas Optimization: Good to optimize

Gas Optimization

• When a function iterates over an array, it could lead to out-of-gas errors, so it is good to reduce redundant gas usage
• Minimize State Changes: Writing to and modifying state variables are among the most gas-intensive.
• Pack Variables in Structs: Try to use the smallest data types necessary and pack variables within structs.
• Optimize Loops: Minimize the logic inside loops and avoid state changes when possible.
• Delete Unused Storage: Deleting a storage variable refunds some gas.
• Use External Functions for External Calls: Mark functions as external, gas efficient
• Use leverage the cheaper cost of accessing and writing to a mapping compared to an array

Advances in Smart Contract Technology

• Solana Sealevel enables parallel execution of contracts, improving blockchain execution.
• It is a runtime that executes smart contracts on GPU cores
• Ethereum Vyper helps with security