Blockchain Mastery là hành trình giúp bạn làm chủ công nghệ chuỗi khối -- nền tảng định hình kỷ nguyên tài sản số, trí tuệ nhân tạo và dữ liệu phi tập trung. Công nghệ này không chỉ thay đổi cách chúng ta giao dịch, mà còn thay đổi cách thế giới lưu trữ, chia sẻ và tin tưởng dữ liệu. Blockchain mở ra một cuộc cách mạng mới - nơi niềm tin được lập trình bằng mã nguồn mở, không cần trung gian.
Blockchain là công nghệ lưu trữ và truyền tải thông tin bằng các khối được liên kết với nhau, quản lý bởi nhiều máy tính độc lập. Đây là nền tảng của DeFi, NFT, và tiền mã hóa.
pragma solidity ^0.8.0;
contract HelloWorld {
string public message;
constructor(string memory _message) {
message = _message;
}
function setMessage(string memory _message) public {
message = _message;
}
}
✅ Hiểu sâu về công nghệ Blockchain
✅ Thành thạo Solidity và Smart Contracts
✅ Xây dựng được DApps hoàn chỉnh
✅ Phát triển DeFi protocols
✅ Tạo và quản lý NFT
✅ Nắm vững bảo mật blockchain
✅ Có portfolio dự án thực tế
Blockchain Mastery là khóa học toàn diện giúp bạn từ zero trở thành blockchain developer chuyên nghiệp. Với chương trình học thực tế và mentor hỗ trợ, bạn sẽ sẵn sàng cho sự nghiệp trong ngành Web3.
Tham gia ngay khóa học Blockchain Mastery để bắt đầu hành trình của bạn!
Security là aspect quan trọng nhất trong blockchain development. Một lỗi nhỏ có thể dẫn đến mất hàng triệu USD. Bài viết này cover các vulnerabilities phổ biến và cách phòng tránh.
Reentrancy xảy ra khi external call được thực hiện trước khi update state.
// ❌ VULNERABLE
mapping(address => uint256) public balances;
function withdraw() public {
uint256 amount = balances[msg.sender];
(bool success, ) = msg.sender.call{value: amount}("");
require(success, "Transfer failed");
balances[msg.sender] = 0; // Too late!
}
contract Attacker {
VulnerableContract target;
function attack() external {
target.withdraw();
}
receive() external payable {
if (address(target).balance >= 1 ether) {
target.withdraw(); // Reentrant call!
}
}
}
// ✅ SECURE - Checks-Effects-Interactions pattern
function withdraw() public {
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0; // Effects first
(bool success, ) = msg.sender.call{value: amount}("");
require(success, "Transfer failed");
}
// Or use ReentrancyGuard
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Secure is ReentrancyGuard {
function withdraw() external nonReentrant {
// Safe withdrawal
}
}
Solidity 0.8.0+ tự động check, nhưng cần lưu ý với version cũ.
// ❌ VULNERABLE (Solidity < 0.8.0)
uint8 count = 255;
count++; // Overflows to 0
// ✅ SAFE (Solidity >= 0.8.0)
uint8 count = 255;
count++; // Reverts automatically
// ❌ Missing access control
function withdraw() public {
owner.transfer(address(this).balance);
}
// ✅ With access control
address public owner;
modifier onlyOwner() {
require(msg.sender == owner, "Not owner");
_;
}
function withdraw() public onlyOwner {
payable(owner).transfer(address(this).balance);
}
Attackers có thể thấy pending transactions và submit với higher gas.
// ❌ Dangerous
function transfer(address to, uint256 amount) public {
to.call{value: amount}(""); // No error handling
}
// ✅ Safe
function transfer(address to, uint256 amount) public {
(bool success, ) = to.call{value: amount}("");
require(success, "Transfer failed");
}
// ❌ Vulnerable to DoS
address[] public users;
function refundAll() public {
for (uint i = 0; i < users.length; i++) {
payable(users[i]).transfer(1 ether);
// Could fail if one user is contract without receive()
}
}
// ✅ Safe - Pull pattern
mapping(address => uint256) public refunds;
function refund() public {
uint256 amount = refunds[msg.sender];
refunds[msg.sender] = 0;
payable(msg.sender).transfer(amount);
}
Blockchain không có randomness thực sự.
// ❌ Predictable
uint256 random = uint256(keccak256(abi.encodePacked(block.timestamp, blockhash(block.number))));
// ✅ Use Chainlink VRF or similar
// Or use commit-reveal scheme
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
Always follow this order:
function transfer(address to, uint256 amount) public {
// 1. Checks
require(to != address(0), "Invalid address");
require(balances[msg.sender] >= amount, "Insufficient balance");
// 2. Effects
balances[msg.sender] -= amount;
balances[to] += amount;
// 3. Interactions
emit Transfer(msg.sender, to, amount);
}
Chỉ grant minimum permissions cần thiết:
mapping(address => bool) public canMint;
mapping(address => bool) public canBurn;
modifier onlyMinter() {
require(canMint[msg.sender], "Not minter");
_;
}
function setPrice(uint256 _price) public {
require(_price > 0, "Price must be positive");
require(_price <= MAX_PRICE, "Price too high");
price = _price;
}
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
using SafeMath for uint256;
function add(uint256 a, uint256 b) public pure returns (uint256) {
return a.add(b); // Safe addition
}
// Use custom errors (gas efficient)
error InsufficientBalance(uint256 required, uint256 available);
function withdraw(uint256 amount) public {
if (balances[msg.sender] < amount) {
revert InsufficientBalance(amount, balances[msg.sender]);
}
}
// ❌ Vulnerable to miner manipulation
require(block.timestamp > deadline, "Too early");
// ✅ Use block.number for longer periods
require(block.number > deadlineBlock, "Too early");
// Fuzz test
function testFuzzTransfer(address to, uint256 amount) public {
vm.assume(to != address(0));
vm.assume(amount <= 1000);
token.transfer(to, amount);
assert(token.balanceOf(to) == amount);
}
Cho phép update logic while keeping same address:
Immediate Actions:
Investigation:
Recovery:
Post-mortem:
Security là trách nhiệm của mọi developer. Hiểu về common vulnerabilities, sử dụng best practices, và thực hiện audits đầy đủ là cách duy nhất để bảo vệ users và funds.
Tiếp tục học về Advanced Topics trong Bootcamp Blockchain Mastery!
Blockchain đang phát triển với các giải pháp scaling, interoperability và innovation mới. Bài viết này khám phá các advanced topics và tương lai của blockchain.
Blockchains phải balance giữa 3 yếu tố:
Không thể tối ưu cả 3 cùng lúc.
Layer 2 là protocols được build trên Layer 1, xử lý transactions off-chain và chỉ submit results lên main chain.
Blockchain riêng biệt nhưng kết nối với main chain.
Polygon (Matic)
// Same Solidity code works on Polygon
contract MyContract {
// Deploy to Polygon for lower gas
}
Giả định transactions là valid, có challenge period.
Arbitrum
Optimism
Sử dụng zero-knowledge proofs để verify batches.
zkSync Era
StarkNet
Off-chain channels cho repeated transactions.
Lightning Network (Bitcoin)
Raiden Network (Ethereum)
| Solution | Type | TPS | Cost Reduction | Finality |
|---|---|---|---|---|
| Polygon | Sidechain | ~7000 | 99% | ~2s |
| Arbitrum | Optimistic Rollup | ~4000 | 95% | Instant* |
| Optimism | Optimistic Rollup | ~2000 | 95% | Instant* |
| zkSync | ZK-Rollup | ~3000 | 99% | Instant |
| StarkNet | ZK-Rollup | ~10000+ | 99% | Instant |
*Instant trong L2, ~7 days for withdrawal to L1
Khả năng transfer assets và data giữa các blockchains khác nhau.
Chain A → Lock Assets → Bridge → Mint on Chain B
Chain B → Burn Assets → Bridge → Unlock on Chain A
Polygon Bridge
Arbitrum Bridge
Third-party Bridges
// Detect chain
const chainId = await ethereum.request({ method: 'eth_chainId' });
if (chainId === '0x1') {
// Ethereum mainnet
contractAddress = ETHEREUM_ADDRESS;
} else if (chainId === '0x89') {
// Polygon
contractAddress = POLYGON_ADDRESS;
}
const contract = new ethers.Contract(contractAddress, ABI, signer);
LayerZero
// Send cross-chain message
function sendMessage(uint16 _dstChainId, bytes memory _payload) external {
lzEndpoint.send{value: fee}(
_dstChainId,
trustedRemote[_dstChainId],
_payload
);
}
Thay đổi cách accounts hoạt động:
Value extractable từ reordering transactions:
Non-transferable NFTs:
Modular Blockchains
Celestia
Enterprise Blockchain
Blockchain đang evolve rapidly với Layer 2 solutions, cross-chain protocols và emerging technologies. Hiểu về những developments này giúp bạn stay ahead trong blockchain ecosystem.
Hoàn thành Bootcamp Blockchain Mastery và sẵn sàng cho sự nghiệp trong Web3!
Tất cả 10 bài viết đã hoàn thành trong Bootcamp Blockchain Mastery!
Bạn đã học:
Chúc mừng bạn đã hoàn thành Bootcamp Blockchain Mastery!
Công nghệ Blockchain đã cách mạng hóa cách chúng ta nghĩ về tiền bạc và niềm tin. Hãy khám phá cách công nghệ Blockchain có thể giúp các doanh nghiệp phát triển thông qua một ví dụ điển hình.
Trong thị trường blockchain và cryptocurrency, việc xác định đúng các cơ hội dài hạn là yếu tố quyết định thành công của mỗi nhà đầu tư. Bài viết này sẽ giúp bạn nhận diện và nắm bắt những cơ hội lớn trong nhiều năm tới.
Thị trường blockchain đang trong giai đoạn phát triển mạnh mẽ:
Cơ hội: Giải quyết vấn đề scaling của blockchain
Tại sao là cơ hội lớn?
Các dự án tiềm năng:
Cơ hội: Kết nối các blockchain với nhau
Tại sao quan trọng?
Các dự án theo dõi:
Cơ hội: Token hóa tài sản thực tế
Tiềm năng:
Lĩnh vực tiềm năng:
Cơ hội: Nền tảng cho tài chính phi tập trung
Vì sao là cơ hội?
Các mảng tiềm năng:
Cơ hội: Kết hợp AI với blockchain
Xu hướng:
Cơ hội: Tiền tệ số của ngân hàng trung ương
Triển vọng:
Cơ hội: Game blockchain và virtual worlds
Tại sao hấp dẫn?
Xác định đúng cơ hội lớn cho nhiều năm sau là chìa khóa thành công trong thị trường blockchain. Bằng cách:
Bạn sẽ có cơ hội tận dụng được những cơ hội lớn trong tương lai của thị trường blockchain.
Bắt đầu hành trình xác định cơ hội của bạn ngay hôm nay!
NFT (Non-Fungible Tokens) đã trở thành hiện tượng, thay đổi cách chúng ta sở hữu và giao dịch digital assets. Bài viết này khám phá thế giới NFT.
NFT là token unique, không thể thay thế, đại diện cho quyền sở hữu một asset cụ thể.
| Fungible (ERC-20) | Non-Fungible (NFT) |
|---|---|
| Interchangeable | Unique |
| 1 BTC = 1 BTC | Each NFT is different |
| Divisible | Indivisible (usually) |
| Example: Tokens | Example: Art, collectibles |
Standard cho unique tokens trên Ethereum.
// ERC-721 Interface
interface IERC721 {
function balanceOf(address owner) external view returns (uint256);
function ownerOf(uint256 tokenId) external view returns (address);
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract MyNFT is ERC721 {
uint256 private _tokenIds;
mapping(uint256 => string) private _tokenURIs;
constructor() ERC721("MyNFT", "MNFT") {}
function mint(address to, string memory tokenURI) public returns (uint256) {
_tokenIds++;
uint256 newTokenId = _tokenIds;
_mint(to, newTokenId);
_setTokenURI(newTokenId, tokenURI);
return newTokenId;
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
return _tokenURIs[tokenId];
}
}
Multi-token standard, có thể represent cả fungible và non-fungible tokens.
// ERC-1155 allows both
contract MyMultiToken is ERC1155 {
// Fungible: amount > 1
// Non-fungible: amount = 1
function mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public {
_mint(to, id, amount, data);
}
}
| Feature | ERC-721 | ERC-1155 |
|---|---|---|
| Use Case | Unique items | Both fungible & unique |
| Batch Transfer | No | Yes |
| Gas Efficiency | Higher | Lower (for batches) |
| Metadata | Per token | Per token ID |
NFTs thường store metadata off-chain:
{
"name": "My Awesome NFT",
"description": "This is a unique digital artwork",
"image": "https://ipfs.io/ipfs/QmXxXxXx...",
"attributes": [
{
"trait_type": "Color",
"value": "Blue"
},
{
"trait_type": "Rarity",
"value": "Legendary"
}
]
}
contract NFTMarketplace {
struct Listing {
address seller;
uint256 price;
bool active;
}
mapping(uint256 => Listing) public listings;
IERC721 public nftContract;
function listNFT(uint256 tokenId, uint256 price) external {
require(nftContract.ownerOf(tokenId) == msg.sender, "Not owner");
require(nftContract.isApprovedForAll(msg.sender, address(this)), "Not approved");
listings[tokenId] = Listing({
seller: msg.sender,
price: price,
active: true
});
}
function buyNFT(uint256 tokenId) external payable {
Listing memory listing = listings[tokenId];
require(listing.active, "Not for sale");
require(msg.value >= listing.price, "Insufficient payment");
nftContract.safeTransferFrom(listing.seller, msg.sender, tokenId);
payable(listing.seller).transfer(listing.price);
delete listings[tokenId];
}
}
Artists có thể earn từ mỗi resale:
contract RoyaltyNFT is ERC721 {
uint256 public royaltyPercentage = 5; // 5%
address public artist;
function _calculateRoyalty(uint256 salePrice) internal view returns (uint256) {
return (salePrice * royaltyPercentage) / 100;
}
}
interface IERC2981 {
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
function mint(address to) public {
uint256 tokenId = totalSupply() + 1;
_mint(to, tokenId);
}
mapping(address => bool) public whitelist;
bool public presaleActive;
function presaleMint() external {
require(presaleActive, "Presale not active");
require(whitelist[msg.sender], "Not whitelisted");
// Mint logic
}
Giá giảm dần theo thời gian:
uint256 public startPrice = 1 ether;
uint256 public endPrice = 0.1 ether;
uint256 public duration = 1 hours;
function getCurrentPrice() public view returns (uint256) {
uint256 elapsed = block.timestamp - startTime;
if (elapsed >= duration) return endPrice;
uint256 priceRange = startPrice - endPrice;
return startPrice - (priceRange * elapsed / duration);
}
// Inefficient ❌
function mintMultiple(address[] memory to) public {
for (uint i = 0; i < to.length; i++) {
_mint(to[i], i + 1);
}
}
// More efficient ✅
function batchMint(address[] memory to) public {
for (uint i = 0; i < to.length; i++) {
_mint(to[i], totalSupply() + i + 1);
}
}
uint8 for small numbersbool private locked;
modifier nonReentrant() {
require(!locked, "Reentrant call");
locked = true;
_;
locked = false;
}
mapping(address => bool) public authorizedMinters;
modifier onlyAuthorized() {
require(authorizedMinters[msg.sender] || msg.sender == owner, "Not authorized");
_;
}
function mint(address to, string memory uri) external {
require(to != address(0), "Invalid address");
require(bytes(uri).length > 0, "Empty URI");
// Mint logic
}
NFTs đang mở ra khả năng mới cho digital ownership và creativity. Hiểu về standards, marketplaces và security best practices giúp bạn tham gia ecosystem một cách an toàn và hiệu quả.
Tiếp tục học về Blockchain Security trong Bootcamp Blockchain Mastery!
Bitcoin là đồng tiền mã hóa đầu tiên và lớn nhất thế giới, đánh dấu sự ra đời của công nghệ blockchain. Bài viết này sẽ giúp bạn hiểu sâu về Bitcoin và thị trường tiền mã hóa.
UTXO model là cách Bitcoin quản lý balance:
Alice có:
- UTXO1: 0.5 BTC (địa chỉ A)
- UTXO2: 0.3 BTC (địa chỉ A)
Muốn gửi 0.6 BTC cho Bob:
- Tiêu thụ: UTXO1 (0.5) + UTXO2 (0.3) = 0.8 BTC
- Tạo mới:
- UTXO cho Bob: 0.6 BTC
- UTXO change: 0.2 BTC (về Alice)
| Đặc điểm | UTXO Model | Account Model |
|---|---|---|
| Balance | Tính từ UTXOs | Lưu trực tiếp |
| Privacy | Tốt hơn | Kém hơn |
| Parallelization | Dễ hơn | Khó hơn |
| Smart Contracts | Khó triển khai | Dễ triển khai |
Mining là quá trình:
1. Collect transactions → Mempool
2. Create block header
3. Calculate hash (SHA-256)
4. Check if hash < target difficulty
5. If not → change nonce, repeat step 3
6. If yes → broadcast block
7. Other nodes validate → add to chain
Bitcoin halving xảy ra mỗi 210,000 blocks (~4 năm):
Tokenomics bao gồm:
Bitcoin là nền tảng của toàn bộ thị trường cryptocurrency. Hiểu về Bitcoin giúp bạn có foundation vững chắc để khám phá các blockchain khác và thị trường DeFi.
Tiếp tục học về Ethereum và Smart Contracts trong Bootcamp Blockchain Mastery!
Ethereum là blockchain đầu tiên hỗ trợ smart contracts, mở ra khả năng xây dựng các ứng dụng phi tập trung (DApps). Bài viết này sẽ giúp bạn hiểu về Ethereum và cách smart contracts hoạt động.
Ethereum là một decentralized platform cho việc chạy smart contracts - các ứng dụng chạy chính xác như được lập trình mà không có khả năng downtime, kiểm duyệt, gian lận hay can thiệp từ bên thứ ba.
| Đặc điểm | Bitcoin | Ethereum |
|---|---|---|
| Mục đích | Digital currency | Smart contracts platform |
| Programming | Script language | Turing-complete |
| Block Time | ~10 phút | ~12 giây |
| Consensus | PoW → PoS | PoS (hiện tại) |
| Accounts | UTXO | Account-based |
EVM là môi trường runtime cho smart contracts trên Ethereum. Nó là một máy ảo hoàn chỉnh, cho phép chạy code trong môi trường sandboxed.
Smart Contract Code
↓
Compiler (Solidity)
↓
Bytecode
↓
EVM Execution
↓
State Changes
Gas là đơn vị đo computational effort cần để thực hiện một operation trên Ethereum.
Simple transfer: 21,000 gas
Gas price: 20 Gwei (0.00000002 ETH)
Fee = 21,000 × 0.00000002 = 0.00042 ETH
Các kỹ thuật tối ưu gas:
Mỗi account có 4 fields:
Smart contract là một program chạy trên blockchain, tự động execute các điều khoản đã được code sẵn.
pragma solidity ^0.8.0;
contract SimpleStorage {
uint256 public value;
function setValue(uint256 _value) public {
value = _value;
}
function getValue() public view returns (uint256) {
return value;
}
}
Ethereum 2.0 (nay gọi là "The Merge") là quá trình nâng cấp Ethereum từ Proof of Work sang Proof of Stake.
DeFi là hệ thống tài chính được xây dựng trên blockchain, không cần intermediaries.
Ethereum và smart contracts mở ra một thế giới mới của decentralized applications. Hiểu về EVM, gas, và cách smart contracts hoạt động là nền tảng để phát triển DApps.
Tiếp tục học về Solidity và phát triển Smart Contracts trong Bootcamp Blockchain Mastery!
Solidity là ngôn ngữ lập trình chính để phát triển smart contracts trên Ethereum và các EVM-compatible blockchains. Bài viết này sẽ hướng dẫn bạn từ cơ bản đến nâng cao về Solidity.
Solidity là một statically-typed, contract-oriented programming language được thiết kế để phát triển smart contracts trên EVM.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MyContract {
// State variables
uint256 public value;
// Constructor
constructor(uint256 _initialValue) {
value = _initialValue;
}
// Functions
function setValue(uint256 _newValue) public {
value = _newValue;
}
}
bool public isActive = true;
uint256 public count = 100;
int256 public temperature = -10;
address public owner = msg.sender;
bytes32 public hash;
// Arrays
uint256[] public numbers;
uint256[5] public fixedArray;
// Structs
struct User {
string name;
uint256 age;
address wallet;
}
// Mappings
mapping(address => uint256) public balances;
// Public - có thể gọi từ bên ngoài
function publicFunction() public returns (uint256) {
return 100;
}
// Private - chỉ trong contract
function privateFunction() private returns (uint256) {
return 50;
}
// Internal - contract và children
function internalFunction() internal returns (uint256) {
return 25;
}
// External - chỉ từ bên ngoài
function externalFunction() external returns (uint256) {
return 10;
}
// View - không modify state
function viewFunction() public view returns (uint256) {
return value;
}
// Pure - không đọc/modify state
function pureFunction(uint256 x) public pure returns (uint256) {
return x * 2;
}
// Payable - nhận Ether
function payableFunction() public payable {
// Can receive Ether
}
modifier onlyOwner() {
require(msg.sender == owner, "Not owner");
_; // Execute function body
}
function changeOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address _to, uint256 _amount) public {
// Transfer logic
emit Transfer(msg.sender, _to, _amount);
}
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract MyContract is Ownable {
constructor() {
owner = msg.sender;
}
}
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
}
contract MyContract {
IERC20 public token;
function useToken() public {
token.transfer(msg.sender, 100);
}
}
// VULNERABLE ❌
function withdraw() public {
(bool success, ) = msg.sender.call{value: balances[msg.sender]}("");
balances[msg.sender] = 0;
}
// SAFE ✅
function withdraw() public {
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0; // Checks-Effects-Interactions
(bool success, ) = msg.sender.call{value: amount}("");
require(success, "Transfer failed");
}
import "@openzeppelin/contracts/access/Ownable.sol";
contract MyContract is Ownable {
function adminFunction() public onlyOwner {
// Only owner can call
}
}
// Solidity 0.8.0+ tự động kiểm tra overflow
uint256 public total;
function add(uint256 amount) public {
total += amount; // Auto checked for overflow
}
function transfer(address _to, uint256 _amount) public {
require(_to != address(0), "Invalid address");
require(_amount > 0, "Amount must be positive");
require(balances[msg.sender] >= _amount, "Insufficient balance");
// Transfer logic
}
mapping(address => uint256) public pendingWithdrawals;
function withdraw() public {
uint256 amount = pendingWithdrawals[msg.sender];
require(amount > 0, "Nothing to withdraw");
pendingWithdrawals[msg.sender] = 0;
payable(msg.sender).transfer(amount);
}
// Pull pattern (safer)
mapping(address => uint256) public credits;
function withdraw() public {
uint256 amount = credits[msg.sender];
credits[msg.sender] = 0;
payable(msg.sender).transfer(amount);
}
bool public stopped = false;
modifier stopInEmergency() {
require(!stopped, "Contract is stopped");
_;
}
function emergencyStop() public onlyOwner {
stopped = true;
}
const { expect } = require("chai");
const { ethers } = require("hardhat");
describe("MyContract", function () {
it("Should set and get value", async function () {
const MyContract = await ethers.getContractFactory("MyContract");
const contract = await MyContract.deploy();
await contract.setValue(100);
expect(await contract.getValue()).to.equal(100);
});
});
async function main() {
const [deployer] = await ethers.getSigners();
const MyContract = await ethers.getContractFactory("MyContract");
const contract = await MyContract.deploy();
await contract.deployed();
console.log("Deployed to:", contract.address);
}
npx hardhat verify --network mainnet CONTRACT_ADDRESS
// Expensive ❌
for(uint i = 0; i < array.length; i++) {
doSomething(array[i]);
}
// Cheaper ✅
uint length = array.length; // Cache
for(uint i = 0; i < length; i++) {
doSomething(array[i]);
}
/// @title A simple storage contract
/// @author Your Name
/// @notice Stores a uint256 value
contract SimpleStorage {
/// @notice The stored value
/// @dev This is stored in slot 0
uint256 public value;
/// @notice Sets the value
/// @param _value The new value to store
function setValue(uint256 _value) public {
value = _value;
}
}
error InsufficientBalance(uint256 required, uint256 available);
function withdraw(uint256 amount) public {
if (balances[msg.sender] < amount) {
revert InsufficientBalance(amount, balances[msg.sender]);
}
// ...
}
Solidity là ngôn ngữ mạnh mẽ để phát triển smart contracts. Nắm vững các patterns, security best practices và optimization techniques sẽ giúp bạn xây dựng các smart contracts an toàn và hiệu quả.
Tiếp tục học về DApp Development trong Bootcamp Blockchain Mastery!