The Web3 Rust Course - NEAR Smart Contracts Web Development

Analyze the core concepts of web3, including decentralization, permissionless access, native payments, data ownership, and trustless incentives within the Near Protocol ecosystem.

Web3 offers a decentralized internet where you own digital assets and your reputation, delivering censorship resistance and portable identity across platforms.

Web3 faces user experience challenges due to high technical barriers, security concerns, and complex documentation that hinder intuitive navigation; NEAR wallets offer seamless browser integration to improve this.

Explore blockchain as a distributed ledger technology and a ledger of transactions, and how a decentralized network authenticates this ledger; analyze scaling and why NIR is a top scaling solution.

Explore how blocks link via cryptographic hashes to form a public, immutable blockchain and understand why timestamps and previous hashes enable transparent, decentralized ledgers.

Explore how blockchains like Bitcoin, Ethereum, Binance, NEAR, and Tether use peer-to-peer networks of nodes and consensus to add, validate blocks, and manage forks, achieving immutability.

Explore the double spending problem in digital currency and how bitcoin's blockchain authenticates owners by linking blocks, timestamps, and verified transactions, laying groundwork for near protocol.

Explore how NEAR, a simple, scalable, secure blockchain built from the ground up after Bitcoin and Ethereum, prioritizes scalable design to improve user and developer experience.

Develop a local environment from scratch for Near smart contracts using Rust, learning step by step how to read smart contracts and perform unit testing without overwhelming libraries.

Master prerequisites for the web3 rust course, including Rust, Cargo, Node.js, and VS Code, with optional Ethereum knowledge. The instructor guides beginners through setup, tools, and next steps.

Learn to code three basic automation scripts in the contract project: build.sh, test.sh, and a third script, using bash, cargo build, and wasm32 target to streamline near smart contract development.

Learn to write and run test and build scripts using cargo test and cargo build, manage batch files, and understand boilerplate structure for a near React project.

Modify the cargo.toml manifest to configure metadata and dependencies for a Rust Near smart contract project and prepare for unit testing and build verification.

Master selling your web3 project by communicating ideas clearly, using stories, case studies, and eye contact, to persuade decision makers for funding, sponsorships, or jobs.

Rust emphasizes memory safety and high performance, similar to C and C++. It differentiates itself by supporting concurrent programming with an effective compiler, enabling large data processing.

Explore how Rust addresses memory safety and reference safety beyond C and C++, with the borrow checker preventing use-after-free and invalid references through disciplined initialization.

Explore Rust lifetimes to guarantee reference validity and compare safe Rust's restricted memory safety with unsafe Rust's raw pointers, balancing safety and control.

Explore the Rust ide playground in your browser, write and run an fn domain function, and view its output and errors in the console.

Begin by writing your first Rust program in a main function using the println! macro. Compile and run, observe the console output, and save as you learn.

Explore how Rust macros enable meta programming and syntactic sugar to write more code. Learn formatting macros like format, print, println, eprint, and eprintln, defined with preprocessor directives.

Explore how the print and println macros in Rust format strings with positional and named arguments, handle stringified values, and diagnose formatting errors in main.

Implement a print line macro in Rust's main function using x and y to print 'Hello, my friend' with proper formatting. Explore macro usage and formatting rules.

Explore data types in Rust, understand how the static type system validates values before storage and manipulation, and see how the compiler infers types for variables.

Demonstrate printing variables in Rust using curly brackets with the println macro, showing how strings, booleans, and numbers are assigned and displayed.

Create two variables in main: a boolean switch set to false and a volume set to ten, then print them with contextual messages using Rust macros and scope.

Explore Rust integers, including signed and unsigned types, default i32, explicit u32 and i32, and 64-bit sizing, with examples on creating, printing, and basic operations.

Explore integer ranges for signed and unsigned types in Rust, using -2^(n-1) to 2^(n-1)-1 for signed and 0 to 2^n-1 for unsigned, and how overflow occurs.

Practice integer handling in Rust by writing a main function with a 16-bit unsigned variable, exploring overflow with two over time values, and printing results to reveal console warning errors.

Demonstrate 16‑bit unsigned integers in Rust by assigning the max value 65,535, then show overflow to zero with 65,536 and observe two overflow variables.

Explore Rust coding fundamentals by building a simple add function, exposing it publicly, and creating unit tests with cargo test to validate results.

Master interview confidence for web3 NEAR roles by practicing on video, refining your delivery, and presenting as a human, not just your resume, to win a job or grant.

Develop smart contracts from scratch in Rust, deploy them, and create unit tests, using password authentication and cryptographic hashing to securely store hashed passwords on the blockchain.

Clone or download the skeleton near smart contracts project from GitHub, open it in your editor, modify cargo.toml for the contract name and author, and build to wasm.

Explore reading basic smart contract code in rust on near by examining a contract struct, near-sdk imports, borsh serialization, and near_bindgen macro, plus contract initialization, impl methods, and tests.

Explore Rust syntax by examining macro, struct, pub, use, and implement in a hands-on exercise, then share explanations in the Rust Discord channel, with a bonus on creating a macro.

implement contract basics on near by adding a constant password number and a string password solution, then implement a public get_password_number function that returns the stored value using self.

Implement public functions to set the password solution in contract state and to guess it, using a mutable self. Log outcomes with env log_string and use if-else for access.

Enhance your NEAR projects and smart contracts by positioning the camera at eye level, improving lighting and audio, and using varied voice and natural hand gestures.

Build and compile a Near smart contract wasm, deploy it to a sub account, then interact, address security vulnerabilities, and write unit tests to prepare for the Near credentials exam.

Learn to create a near sub account from the terminal, attach it to a master account, and initialize it with a balance to cover gas.

Create a NEAR sub account from a master account using near create account, set an initial balance of one token, and save the new credentials.

Verify the deployed NEAR smart contract by calling the get_password_number view function on the sub account, using a view call rather than a transaction.

Interact with NEAR smart contracts by invoking a view function to retrieve the password number from deployed contract, using the NEAR state to verify the code hash on the blockchain.

Call the password guess method on the live Rust smart contract to attempt solving the set password, practicing the guess solution logic and evaluating success.

Hash passwords using SHA-256 in the Rust SDK to securely store credentials while integrating with NEAR, and reinforce best practices with basic unit tests.

Learn to write unit tests for a Rust smart contract by adding a SHA 256 hash test, using a mock context, the SDK, and hex encoding to log debug output.

Explore cryptographic hashing of strings in rust for NEAR by hashing input, encoding the hash, and printing it in a unit test to debug smart contract code.

Learn to implement a near rust contract with a new method, pass a contract hash, and validate outcomes using assertions and get_logs in tests.

Learn to secure near smart contracts by replacing settable state with an init macro, using hash input logic, and returning a boolean via sha256 and hex encoding for guesses.

Modify a contract to initialize with a hash and validate hash inputs with hex encoding and boolean checks, using cryptographic tools, and test with cargo test on the blockchain.

Build a fresh NEAR contract, clean the state by deleting and recreating the subaccount, then deploy to the testnet and verify via the transaction and state.

Orchestrates batch deployment to initialize a NEAR smart contract with a solution hash using the new function and init, ensuring security from reinitialization.