Learning Blockchain Development with EOS and C++

Explore a practical intro to C++, using a hello world program and main function, while linking iostreams to EOS smart contracts basics.

Explore essential C++ programming constructs for blockchain development, including defining and calling functions with parameters, booleans, and returns, and building control flow with for loops and short-circuiting.

Explore the C++ standard template library core concepts—containers, iterators, algorithms, and functions—through hands-on examples of vector, list, deque, queue, stack, set, and map, with Boost context.

Learn to use vectors and lambdas in C++: templated containers, iterators, for loops, and safe element access with at and exceptions, plus a look at Boost lambda features.

Pass the -std=c++11 flag to enable the modern vector initialization syntax used in this lecture. Resolve compilation errors by adding this extra flag when following along with the code examples.

Explore how to use the Boost library in C++, including installing Boost, locating headers, and using lambda functionality, to enhance smart contract development through hands-on experimentation.

Explore pointers, references, and object oriented programming in C++, using a car class to illustrate memory, arrow syntax, and reference semantics.

Discover templates in c++, using angle brackets to make type-agnostic vectors and a print function. Learn auto type inference, template templates, and operator<< for various types.

Learn C++ namespaces and the scoping operator through a tree example. Organize code in a tree namespace with a trunk class, leaves, and functions, and relate to EOS smart contracts.

Explore the N() macro in EOS blockchain development, showing how it converts a variable name to a 64-bit string and prints the name at compile time.

Clarify the N() macro behavior in a follow-up, showing that removing the pound sign in the stream name macro passes the variable name as the parameter.

Explore the name constructor in a toy EOS smart contract, a UN64 wrapper over an account name, and how to compile, upload, and interact with it by printing the sender.

Deep dive into the multi_index data structure, a central tool in eosio cpp development, contrasting it with boost and setting up upcoming employee examples.

Explore how the boost multi index library models an employee dataset with ID and name, enabling two indices unique by ID and non-unique by name, for ordering without data duplication.

Explore a word count example using a multi index with a sequence index to view data as a list, enabling counting and removal with logarithmic complexity.

Demonstrate using lambdas to query in C++ with Boost, printing doubles between 50 and 200 in a succinct one-line expression and preview updating records in the next video.

Learn how to query multi index containers in EOS smart contracts, using indices, top and bottom bounds, iterators, and range selects to retrieve data like a database.

Explore replacing and modifying objects in a multi index container, including key-based edits, rollback strategies, and iterator projection to switch between logarithmic lookups and sequential iteration for EOS smart contracts.

Explore coding STL data structures using a multi index, comparing set, multiset, list, and map with EOS multi index, including primary and secondary indices.

Explore blockchain basics through a git-inspired lens for EOS and C++ development, covering genesis blocks, hashes, commits, branches, mining, and on-chain transactions.

Explore how Ethereum turns Bitcoin's state transitions into a universal blockchain state with accounts and smart contracts, and how gas prevents infinite loops.

Clarify that blocks contain lists of transactions that update the state, but the state itself is stored in a local disk database on each node, not inside the block.

Examine steem blockchain and steemit’s social platform, showing how single-threaded state transitions shape architecture and how separating core logic from cryptographic operations with in-memory data and state checks enables parallelization.

Compare Ethereum and EOS by examining the EOS white paper, focusing on scalability, free usage, upgradeability, and delegated proof-of-stake with asynchronous Byzantine fault tolerance.

download the latest release binary from the release tag and install the Debian package on Mac OS or Linux, which handles dependencies and adds to your PATH.

Install the EOS development tools, follow the official documentation, clone the repository and submodules, and run the build script to compile the code for local development.

Verify your installation by running the provided commands to perform unit and integration tests, which confirm the build succeeded and allow you to start producing blocks in the next video.

Build and run a local EOS nodeos, install C++ binaries, verify the local blockchain, and upload smart contracts, with IDE setup and code navigation covered in future videos.

Master aliasing to add EOS development commands to your path, enabling you to run tools from anywhere and streamline smart contract workflow.

Import your EOS C++ project into CLion, preserve existing CMakeLists, open the project, configure build settings (boost path), and compile hello contract to verify setup, using the IDE for navigation.

this video shows where nodeos stores data for blocks, state, and the wallet, including config and genesis files, how to access the default wallet, and how to locate data directories.

Explore keosd and wallet management, including creating wallets, listing keys, unlocking, and importing private keys for EOS accounts. Understand key concepts for accounts and smart contracts.

Set up and deploy EOS smart contracts and accounts by loading the BIOS contract, provisioning RAM, and creating user and tester accounts on a local blockchain.

Deploy the token smart contract on a local node and create accounts with a public key. Issue and transfer tokens, then query balances using the token contract interface.

Explore the eosio.token contract in depth, focusing on accounts and stats multi-index tables, asset structures, and the create, issue, and transfer flows that manage balances and symbols.

learn to write an abi by hand for eosio c++, defining types, structs, actions, and multi index tables, and understand why the api generator was removed.

This overview compares erc20 tokens and eosio.token, showing how each token uses its own smart contract with balances, transfer logic, and accounts and stats tables to manage holdings.

Compare erc20 tokens with eosio.token by examining syntax, balances, total supply, transfers, and events. Learn how multi index in eosio contrasts with Solidity mappings for token contracts.

Learn to build eosio.cdt based smart contracts without the full repository, install the cdt binary, deploy to jungle testnet, and adopt the updated action syntax.

Build a hello world smart contract in C++; include a ricardian contract, use annotation to generate the API, and learn about action handling and authorization.

Compare a basic solidity hello world smart contract with an EOS-like approach, showing greeting storage, account name usage, constructor behavior, and the mortal destroy method.

Learn to build an eosio address book smart contract using a multi index database with primary and secondary indices. Explore add, update, remove, and like actions, RAM costs, and authorization.

Deploy and interact with EOS smart contracts by building an address book: create accounts, deploy contracts, push actions, read tables, update and delete entries, and track likes.

Explore the eosjs library to interact with EOS smart contracts, including querying blocks and api endpoints, deploying and using the address book contract, and performing actions and table searches.

Learn to connect to the jungle testnet and mainnet, deploy contracts from a local nodia setup, create accounts with public keys, and use faucet funds to test ram and bandwidth.

Learn how to vote for block producers on the jungle test net by listing candidates and their current vote shares, then cast a vote with an unlocked wallet.

Create a new EOS account, delegate bandwidth, and buy RAM on the jungle test network using system contracts, ensuring sufficient resources and addressing common errors.

Explore how EOS allocates resources—net bandwidth, CPU (cpq), and memory—via staking and the system contract, and how RAM pricing affects dapps and network activity.

Watch EOS transfers between Jungle testnet accounts to observe net and CPU usage rise while RAM stays unchanged, and note that used resources return over three days.

Demux polls the EOS blockchain for transfer actions, updates internal state with volume by symbol and total transfers, and triggers effects to reflect changes in a database or console.

Explore how Scatter integrates identity into the wallet for signing transactions. Set up Scatter with the Chrome extension, import keys, and interact with dapps via JavaScript.

Explore the Sarpy resource planner to calculate EOS resource costs, estimating RAM, bandwidth and account creation costs by hours, and tracking current RAM prices, network prices, and USD conversions.

Explore using the report_endpoints.txt endpoint list to access up-to-date mainnet and testnet blockchain info for deploying contracts, with load balancer advantages for reliability.

Explore the EOS portal to view block producers, voting power, and top 21 producers, then learn to vote via scatter by pairing identity and setting voting power before selecting producers.

Learn to airdrop tokens on the main net with eosdrops, configure the tool, create and deploy a token, test on Jungle, and manage blacklists and RAM costs.

Explore the Everipedia airdrop tool to generate snapshot files with blacklists and whitelists, set token ratios, validate drops, and issue tokens from a genesis snapshot.

Explore cost-efficient airdrops on eos with a token burn and a sign-up method that defers ram costs until users sign up, using a smart contract and kiosk push actions.

Explore TradEOS as a smart contract based exchange on EOS and C++, examine coding style, and learn by compiling, deploying to a testnet, and interacting with the contract.

Explore building a decentralized Twitter on the blockchain using EOS and C++, analyzing a real smart contract implementation and a front end that polls the chain via a database plugin.

Apply the Scatter API in your frontend to sign transactions and interact with the blockchain, using DecentTwitter as a practical example.

The CIB-EOS lecture introduces the CIB project, a community-driven remix-like tool for writing, compiling, and deploying Solidity contracts across chains. It notes added complexity and shows a command-line, Vim-based workflow.

Explore dev4eos, a browser-based tool to write, compile, and deploy eos smart contracts; connect your scatter account, sign on-chain transactions, and test on the jungle testnet.

Explore Buddy CI, a continuous integration and deployment SaaS that automates tests, builds, and deployment of smart contracts for EOS, with a hello world pipeline deploying to jungle net.

Explore dfuse.io's streaming websocket endpoint for real-time blockchain action traces, compare with REST APIs, learn about API tokens, beta access, and available libraries.

Explore MonsterEOS, a tamagotchi-style EOSIO game where you create monsters, sign transactions with Scatter, and watch battles, while the get help repo showcases non block one smart contracts.

Battle a monster on the blockchain by selecting your owned monster, signing the transaction, and watching timed, turn-based attacks play out.

Explore the elemental battles tutorial for building a blockchain app with EOS and C++, and learn front-end and back-end flow, examine smart contracts, and use code snippets to guide development.