Blockchain Developer Interview Questions (Smart Contracts & Web3)

Solidity is statically-typed, high-level programming language designed specifically for writing smart contracts on Ethereum and EVM-compatible blockchains. Unlike traditional languages, Solidity compiles to EVM bytecode running on decentralized network rather than single server.

Key differences:

• Gas costs: Every operation consumes gas paid in Ether requiring optimization
• Immutability: Deployed contracts cannot be modified without proxy patterns
• Global variables: Access to blockchain-specific data like msg.sender, block.timestamp
• State persistence: State variables stored permanently on blockchain

Solidity supports inheritance, libraries, custom types. Contract structure includes pragma statement specifying compiler version, state variables, constructor, and functions with visibility modifiers.

Data location specifies where variables are stored affecting gas costs significantly:

• Storage: Permanent blockchain storage, most expensive. State variables use storage by default
• Memory: Temporary during function execution, moderate cost. Function parameters and local variables
• Calldata: Read-only temporary location for function arguments, cheapest. External function parameters

Example: function process(uint[] calldata ids) external uses calldata for gas efficiency.

function modify(uint[] memory ids) public uses memory allowing modifications.

Storage variables persist between function calls. Memory cleared after execution. Calldata immutable saving gas by avoiding copies.

Visibility modifiers control access to functions:

• public: Callable internally and externally. Generates getter for state variables
• external: Only callable from outside contract. More gas efficient for large arrays using calldata
• internal: Only within contract and derived contracts. Default for state variables
• private: Only within defining contract, not inherited contracts

Security best practice: Use most restrictive visibility. Start with private, make public only when necessary. External functions more efficient than public for external calls since they don’t copy calldata to memory.

require validates inputs and conditions before execution. If fails, reverts transaction and refunds remaining gas. Use for user input validation, access control, external call validation.

Example: require(msg.sender == owner, "Not authorized");

assert checks invariants that should never be false. If fails, consumes all remaining gas indicating serious bug. Use for internal error checking, overflow detection in older Solidity.

Example: assert(balance >= amount);

Solidity 0.8+ has built-in overflow checks making assert less common. Use require for expected failures, assert for impossible conditions indicating bugs.

Web3.js is JavaScript library enabling interaction with Ethereum nodes from web applications. It provides API for sending transactions, calling contract functions, listening to events, and reading blockchain data.

Basic usage:

• Connect to provider: const web3 = new Web3(window.ethereum);
• Create contract instance: const contract = new web3.eth.Contract(ABI, address);
• Call functions: await contract.methods.getValue().call(); (read)
• Send transactions: await contract.methods.setValue(10).send({from: account}); (write)

Alternative: Ethers.js is modern library with better TypeScript support and smaller bundle size. Both libraries require ABI (Application Binary Interface) specifying contract functions and events.

ABI (Application Binary Interface) is JSON specification describing contract’s public interface including functions, parameters, return types, and events. It acts as translation layer between JavaScript and contract bytecode.

ABI contains:

• Function signatures with input/output types
• Event definitions for logging
• Constructor parameters

Generated during compilation from Solidity source. Front-end applications use ABI to encode function calls into bytecode and decode return values. Without ABI, interacting with contracts would require manual bytecode construction impossible for most developers.

Popular frameworks include Hardhat, Truffle, and Foundry. Hardhat is most widely adopted for JavaScript/TypeScript development.

Deployment workflow:

• Write deployment script: const Contract = await ethers.getContractFactory("MyContract"); const contract = await Contract.deploy();
• Configure network in hardhat.config.js with RPC URL and private key
• Run npx hardhat run scripts/deploy.js --network mainnet
• Verify contract on Etherscan for transparency: npx hardhat verify --network mainnet ADDRESS

Test locally using Hardhat Network before deploying to testnet (Goerli, Sepolia) then mainnet. Use deployment tracking to record contract addresses and transaction hashes.

EVM is stack-based virtual machine executing smart contract bytecode across all Ethereum nodes. It provides deterministic execution ensuring all nodes reach same state.

Execution process:

• Solidity compiles to bytecode (opcodes like PUSH, ADD, SSTORE)
• Transactions trigger EVM execution consuming gas per opcode
• EVM manipulates stack, memory, and storage executing instructions
• State changes recorded in blockchain if transaction succeeds

EVM is Turing-complete but gas limits prevent infinite loops. Understanding EVM enables debugging, gas optimization, and security analysis at bytecode level. EVM-compatible chains (Polygon, BSC, Avalanche) run same bytecode enabling multi-chain deployment.