smartcontractkit/Web3_tutorial_Chinese: A Chinese Web3 Course Codebase

What Web3_tutorial_Chinese Covers

This repository is the code companion for the video course 《Web3 和区块链技术》. It is aimed at beginners who are moving from blockchain basics into Solidity contracts, local development, token implementation, automated tests, NFTs, and cross-chain examples. The first lesson has no code and concentrates on blockchain history, decentralization, consensus, self-custody with MetaMask, test tokens, transaction signing, and gas. The repository then provides separate lesson directories from lesson-2 through lesson-6.

The code scope is broad for a tutorial repository, but it is still a course sequence rather than a unified application. Lesson 2 covers Solidity fundamentals and contract interaction. Lesson 3 introduces FundMe, ETH transfers, oracle-based minimum amounts, withdrawal logic, modifiers, timelocks, token versus coin terminology, ERC-20 inheritance, deployment, and contract verification. Lesson 4 shifts to Hardhat, including project creation, compilation, deployment, network configuration, interaction with FundMe, and custom tasks. Lesson 5 adds Hardhat testing, deployment tasks, mock contracts, unit and integration tests, gas reporting, and coverage. Lesson 6 covers NFTs, ERC-721, metadata, Chainlink CCIP, a cross-chain asset pool, local testing, and Hardhat tasks for cross-chain NFT work.

That structure makes the repository useful for following lessons in order. It is less suitable as a single reference for selecting a current token implementation or a production cross-chain architecture, because each directory represents a teaching stage and the README does not present a shared release or compatibility matrix.

Lesson Layout and Technical Progression

Based on the repository layout, each lesson is kept in its own directory and linked from the README. This is a useful separation for learners because it prevents the introductory Solidity examples from being mixed with the later Hardhat and cross-chain material. The progression also reflects a practical teaching order. Basic language concepts come first, then a contract that can receive and release ETH, followed by local development, automated tests, and interoperability examples.

The Solidity portion starts with data types, functions, and the `memory`, `storage`, and `calldata` locations. It also covers structs, arrays, mappings, and contract interaction through a factory pattern. Those topics are prerequisites for reading the later FundMe and token examples. The FundMe lesson introduces a concrete application shape, including a minimum amount based on an oracle and a withdrawal function. The repository therefore does more than print contract syntax. It places the syntax in a contract that models a simple funding flow.

The Hardhat material is the main local-development layer. The README names compilation, deployment, network configuration, contract interaction, custom tasks, testing, mocks, gas reporting, and coverage. This indicates a workflow in which Solidity is compiled, deployed to a network, called by scripts or tasks, and checked through tests. The README does not provide a complete dependency list, environment-variable template, migration guide, or deployment runbook in the shown content, so those details must be confirmed from the relevant lesson directory before using it as a reproducible project.

Chainlink, Tokens, NFTs, and Cross-Chain Lessons

The later lessons place the sample contracts in a Chainlink context. The README states that the tutorial demonstrates how to interact with Chainlink systems, products, and services. It specifically lists Chainlink faucets, Chainlink CCIP, a cross-chain asset pool, and `chainlink-local` testing. This makes interoperability more than a topic label in the repository. The examples are intended to connect local contract behavior with oracle and cross-chain services.

The token material covers the difference between tokens and coins, creation of a token contract, inheritance from an ERC-20 contract, deployment, and verification. The NFT lesson covers NFT metadata and an ERC-721 base contract. These examples are likely most useful for learners who need to see the relationship between a Solidity contract and a widely recognized token interface. The repository does not claim to provide audited implementations, and the README warns that the example code has not been audited and may omit checks or error handling.

Cross-chain code has a larger dependency surface than a basic Solidity lesson. CCIP depends on a configured network, contracts, addresses, and service availability. The README names Chainlink CCIP but does not document the exact addresses, environment variables, deployment order, or compatibility constraints in the visible section. Therefore, a learner can understand the intended architecture from the course, but cannot infer a complete production deployment from the repository description alone. The relevant lesson files and current Chainlink documentation must be checked together.

Installing the Course Code and Starting a First Exercise

The README says to install Node.js, VS Code, and Git for the Hardhat environment, and it links to Hardhat, Solidity, OpenZeppelin, ethers, and Chainlink documentation. It does not provide a complete copyable installation command sequence in the visible instructions, so this article does not invent package names, versions, flags, ports, or environment variables. The repository README points readers to the lesson directories and the official documentation rather than giving one universal setup command for every lesson.

A first real use should follow the lesson order rather than immediately deploying the final cross-chain example. For lesson 2, open the linked `lesson-2` directory and use the Solidity examples for the language and contract-interaction topics. For lesson 4, use the Hardhat directory to compile and deploy the FundMe example described by the README. Before running anything, inspect that directory's package metadata, Hardhat configuration, and contract files. The README identifies Hardhat and Solidity as the relevant tools, but it does not state the exact local commands in the shown content.

The test workflow is described in lesson 5. It calls for Hardhat tests, mock contracts, unit and integration tests, gas reporting, and coverage. The repository also links testnet faucets for Chainlink, Alchemy, and Infura. A testnet faucet is only a source of test funds, not evidence that a deployment is configured correctly. Learners still need to confirm the network, signer, contract address, and service parameters from the lesson files.

For the first practical checkpoint, compare the files in one selected lesson with its listed topic, then compile only that lesson and follow its documented task or test entry point. If the current Solidity, Hardhat, OpenZeppelin, ethers, or Chainlink versions no longer match the example, the mismatch is an upgrade issue to resolve before evaluating the contract logic.

Hardhat Testing and the Limits of Example Code

Hardhat testing is a clear strength of the repository's teaching structure. The README explicitly lists mock contracts, unit tests, integration tests, gas reporting, and coverage. Mocks are particularly relevant to the FundMe and Chainlink examples because they can let a local test exercise contract behavior without relying on every external service during the test run. The repository also names `chainlink-local`, which suggests that local interoperability behavior is part of the intended lesson content.

The limitation is equally clear. This is educational sample code, not an audited production suite. The README says the template is provided without warranties, has not been audited, and may omit important checks or error handling. That warning applies directly to any decision involving withdrawals, token transfers, oracle values, cross-chain messages, ownership, or privileged functions. A passing Hardhat test does not establish that a contract is safe for mainnet deployment, because the README does not claim that tests cover every external failure mode or deployment condition.

The repository also has a maintenance caveat. Its description says the code is no longer maintained. The repository is not marked archived, and the last push was on 2026-09-30, but that date does not change the explicit maintenance statement. There are no GitHub releases, so the README does not provide a versioned upgrade path. Dependency upgrades, Chainlink API changes, network changes, and Solidity compiler changes can therefore create work for a learner or adopter.

Comparing Tutorial Code With Production Contract Libraries

The repository includes OpenZeppelin contract documentation as a reference and covers ERC-20 and ERC-721 in the lessons. The README links to OpenZeppelin documentation as a reference. A production-oriented project would need its own application-specific Hardhat setup and tests. The difference is not that OpenZeppelin replaces every tutorial example. The difference is ownership of security and upgrade work. The repository instead offers instructional examples whose code is explicitly unaudited and no longer maintained.

For cross-chain functionality, the README links to Chainlink's official documentation as a reference. This repository can teach the broad subject, but the README does not claim that its CCIP addresses or service setup remain current. A production project would also need to define how messages are authenticated, how failed transfers are handled, and how operators respond to stalled or retried requests.

For someone learning Solidity syntax, the tutorial is direct and sequenced. For someone shipping a token or cross-chain contract, a current official library plus an audit is a better starting point. The decision depends on whether the goal is education or deployment, not on whether the repository contains a contract with the same interface.

Maintenance Status, License, and Adoption Boundaries

The repository description states in English and Chinese that it is no longer maintained. The README's educational and Chainlink disclaimers further narrow its intended role: it is a course codebase for demonstration, with no warranty, no audit, and possible omissions in checks and error handling. The last push was on 2026-09-30, and the repository has no GitHub releases. Those facts matter when estimating upgrade cost because there is no documented release history or migration series visible here.

The repository metadata identifies the license as Other, with a custom license that GitHub cannot classify and a `LICENSE` file. That means an engineer should not assume a familiar permissive or copyleft license from the repository description. The license text controls permissions and obligations, and this review does not interpret its legal effect. Before copying code into another project, read `LICENSE` and preserve any required notices or conditions.

Adoption is reasonable for learners who need the exact Chinese course sequence, want example directories that correspond to video lessons, and can audit each file before using it. Adoption is a poor fit for a production contract, a maintained starter kit, or a current cross-chain deployment. In particular, verify the license, dependency versions, network configuration, Chainlink setup, tests, and contract security controls before using any lesson code outside a local educational environment.

Editorial conclusion

Adopt this repository as a learning aid for the corresponding video course, especially when you want Chinese explanations alongside example Solidity and Hardhat code. Do not treat it as a production starter kit or a current interoperability framework without reviewing the custom LICENSE, auditing the contracts, checking dependency compatibility, and validating the Chainlink and Hardhat configuration yourself. The first practical check is whether the selected lesson directory runs with the current versions of the tools named in its files.

Frequently asked questions

Official sources

1. Issues
2. README
3. smartcontractkit/Web3_tutorial_Chinese on GitHub