Web 3.0: Потому что Web 2.0 уже не торт

D2 · 7 Апр 2025

Авторство: hackeryaroslav

Источник: xss.is

Многие технологии обещают революцию. Одним из таких трендов последних лет стал Web 3.0, или просто Web3. Этот термин обещает новую эру интернета, основанную на децентрализации, блокчейне и криптовалютах. Но что на самом деле скрывается за этим хайпом? Где настоящий потенциал Web3 и как он может изменить наше взаимодействие с интернетом? Давайте разберемся.

a-photo-of-elon-musk-standing-in-front-of-a-large--qERgx7dnRvS9PEHRA5GQCQ--Tsl-OozRUWaz6twBZE...jpeg

Что такое Web 3.0?

Прежде чем погрузиться в детали, важно понять, что представляет собой Web 3.0. Это концепция развития веб-технологий, которая предполагает переход к децентрализованной архитектуре интернета. В отличие от Web 2.0, где доминируют крупные платформы и централизованные сервисы, Web3 стремится создать интернет, в котором пользователи имеют больше контроля над своими данными и цифровыми активами.

Основные характеристики Web 3.0:

Децентрализация: Отсутствие центрального органа управления, данные распределены по сети.
Блокчейн: Использование технологии распределенного реестра для обеспечения прозрачности и безопасности.
Токенизация: Цифровые активы и криптовалюты как неотъемлемая часть экосистемы.
Смарт-контракты: Автоматизированное выполнение соглашений без посредников.
Семантическая сеть: Улучшенное понимание контекста и значения данных машинами.

Инструменты и фреймворки Web3

Для разработки приложений в экосистеме Web3 существует множество инструментов и фреймворков. Рассмотрим некоторые из наиболее популярных:

Hardhat для Ethereum

Hardhat — мощная и гибкая среда разработки для Ethereum, которая облегчает создание и тестирование смарт-контрактов. Она:

поддерживает написание смарт-контрактов на Solidity,
предоставляет локальную сеть для тестирования,
интегрируется с другими инструментами Ethereum, такими как Ethers.js и Web3.js.

Вот как можно использовать Hardhat для развертывания простого смарт-контракта:
JavaScript: Скопировать в буфер обмена

Код:

const { ethers } = require("hardhat");

async function main() {
  const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
  console.log("Deploying SimpleStorage...");
  const simpleStorage = await SimpleStorage.deploy();
  await simpleStorage.deployed();
  console.log("SimpleStorage deployed to:", simpleStorage.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

getContractFactory: Получает объект контракта "SimpleStorage" для дальнейшего развертывания.
deploy: Отправляет транзакцию для развертывания контракта в сеть.
deployed: Ожидает завершения транзакции и развертывания контракта.
simpleStorage.address: Адрес смарт-контракта, на который он был развернут.

Hardhat автоматически обрабатывает компиляцию, создание и отправку транзакции, делая процесс разработки более плавным и удобным.

Truffle Suite

Truffle - еще один популярный фреймворк для разработки на Ethereum. Он предоставляет инструменты для компиляции, тестирования и управления смарт-контрактами. Truffle включает в себя Ganache - персональный блокчейн для разработки Ethereum, который позволяет разработчикам тестировать свои dApps в безопасной локальной среде.

Пример конфигурации Truffle:

JavaScript: Скопировать в буфер обмена

Код:

module.exports = {
  networks: {
    development: {                 // Сеть для локальной разработки
      host: "127.0.0.1",            // Локальный хост
      port: 7545,                   // Порт Ganache
      network_id: "*"               // Любой network ID
    }
  },
  compilers: {
    solc: {                         // Настройка компилятора Solidity
      version: "0.8.0"              // Указание версии Solidity
    }
  }
};

networks: Определяет параметры сети, к которой подключаться. В данном случае используется Ganache на порте 7545.
network_id: "*": Разрешает подключение к любой сети, что полезно для тестирования.
compilers.solc: Настраивает версию компилятора Solidity для согласованности в разработке.

Web3.js и Ethers.js

Эти библиотеки JavaScript позволяют разработчикам взаимодействовать с блокчейном Ethereum из веб-приложений. Web3.js был первым широко используемым инструментом, в то время как Ethers.js стал популярным благодаря более современному API и лучшей производительности.

Web3.js — первая популярная библиотека для взаимодействия с блокчейном.
Ethers.js — более легковесная и производительная альтернатива с улучшенным API.
Поддержка: Ethers.js лучше подходит для работы с TypeScript и легко интегрируется в современные проекты.

Пример использования Ethers.js для взаимодействия со смарт-контрактом:

JavaScript: Скопировать в буфер обмена

Код:

const { ethers } = require("ethers");


async function interactWithContract() {
  const provider = new ethers.providers.JsonRpcProvider("http://localhost:8545"); // 1. Подключаемся к локальному блокчейну
  const signer = provider.getSigner(); // 2. Получаем кошелек или аккаунт для подписания транзакций


  const contractAddress = "0x..."; // 3. Указываем адрес развернутого контракта
  const contractABI = [...]; // 4. ABI — интерфейс для взаимодействия с контрактом


  const contract = new ethers.Contract(contractAddress, contractABI, signer); // 5. Создаем экземпляр контракта


  // Вызов функции контракта
  const result = await contract.someFunction(); // 6. Асинхронно вызываем функцию контракта
  console.log("Result:", result); // 7. Выводим результат
}


interactWithContract(); // Запускаем функци

JsonRpcProvider: Подключается к сети Ethereum через RPC-сервер (в данном случае локальный узел на порту 8545).
getSigner: Возвращает объект, который может подписывать транзакции.
ethers.Contract: Создает экземпляр контракта для взаимодействия.
someFunction(): Пример вызова функции контракта. Результат возвращается асинхронно.

Примеры децентрализованных приложений (dApps)

Децентрализованные приложения (dApps) - это приложения, работающие на децентрализованной сети, такой как Ethereum. Они отличаются от традиционных приложений тем, что не имеют центрального сервера и используют блокчейн для хранения и обработки данных. Рассмотрим несколько примеров dApps и их реализацию.

1. Децентрализованная биржа (DEX)

Децентрализованные биржи позволяют пользователям обменивать криптовалюты без посредников. Одним из популярных протоколов для создания DEX является Uniswap.

Пример простого смарт-контракта для обмена токенов:

Код: Скопировать в буфер обмена

Код:

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract SimpleExchange {
    // Хранение ликвидности: сколько токенов каждой пары доступно в контракте
    mapping(address => mapping(address => uint256)) public liquidity;

    // Добавление ликвидности для пары токенов
    function addLiquidity(
        address tokenA, 
        address tokenB, 
        uint256 amountA, 
        uint256 amountB
    ) external {
        require(IERC20(tokenA).transferFrom(msg.sender, address(this), amountA), "Transfer of token A failed");
        require(IERC20(tokenB).transferFrom(msg.sender, address(this), amountB), "Transfer of token B failed");

        liquidity[tokenA][tokenB] += amountA;
        liquidity[tokenB][tokenA] += amountB;
    }

    // Обмен токенов через контракт
    function swap(
        address fromToken, 
        address toToken, 
        uint256 amountIn
    ) external {
        require(liquidity[fromToken][toToken] > 0, "Insufficient liquidity");
        
        // Расчет количества токенов для получения
        uint256 amountOut = (amountIn * liquidity[toToken][fromToken]) / liquidity[fromToken][toToken];

        require(IERC20(fromToken).transferFrom(msg.sender, address(this), amountIn), "Transfer of input token failed");
        require(IERC20(toToken).transfer(msg.sender, amountOut), "Transfer of output token failed");

        // Обновление ликвидности после обмена
        liquidity[fromToken][toToken] += amountIn;
        liquidity[toToken][fromToken] -= amountOut;
    }
}

liquidity: Хранит объем доступной ликвидности для каждой пары токенов.
addLiquidity:
- Пользователь переводит две валюты в контракт.
- Эти токены сохраняются в маппинге ликвидности.
swap:
- Проверяет, есть ли необходимая ликвидность для обмена.
- Рассчитывает количество токенов на основе текущего соотношения ликвидности.
- Переводит входящие токены в контракт и возвращает выходные токены пользователю.

Естественно, в коде отсутствуют такие вещи как AMM для ценообразования, предотвращая быстрые колебания. В этом коде используется простой обменный курс, который подвержен манипуляциям. Также, нет защиты от фронтраннинга или арбитражных атак. Поэтому, не используйте его (но он хорош для понятия концепции).

2. Децентрализованное приложение для голосования

Блокчейн может обеспечить прозрачность и неизменяемость результатов голосования. Пример простого смарт-контракта для голосования:

Код: Скопировать в буфер обмена

Код:

pragma solidity ^0.8.0;


contract Voting {
    // Хранит количество голосов для каждого кандидата
    mapping(bytes32 => uint256) public votesReceived;
    // Список кандидатов
    bytes32[] public candidateList;


    // Конструктор: принимает список кандидатов
    constructor(bytes32[] memory candidateNames) {
        candidateList = candidateNames;
    }


    // Функция для голосования за кандидата
    function voteForCandidate(bytes32 candidate) public {
        require(validCandidate(candidate), "Invalid candidate"); // Проверка на валидность кандидата
        votesReceived[candidate] += 1; // Увеличение количества голосов
    }


    // Функция для получения общего количества голосов за кандидата
    function totalVotesFor(bytes32 candidate) view public returns (uint256) {
        require(validCandidate(candidate), "Invalid candidate"); // Проверка на валидность кандидата
        return votesReceived[candidate]; // Возврат количества голосов
    }


    // Проверка, является ли кандидат валидным
    function validCandidate(bytes32 candidate) view public returns (bool) {
        for(uint i = 0; i < candidateList.length; i++) {
            if (candidateList[i] == candidate) {
                return true; // Кандидат найден
            }
        }
        return false; // Кандидат не найден
    }
}

votesReceived: Маппинг для хранения количества голосов для каждого кандидата.
candidateList: Массив, содержащий список кандидатов.
constructor: Принимает список имен кандидатов и инициализирует переменную candidateList.
voteForCandidate:
- Проверяет, является ли кандидат валидным с помощью функции validCandidate.
- Увеличивает количество голосов для выбранного кандидата.
totalVotesFor:
- Проверяет валидность кандидата и возвращает общее количество голосов.
validCandidate:
- Проходит по списку кандидатов и проверяет, существует ли данный кандидат в массиве.

3. Децентрализованная система управления идентификацией

Web3 открывает возможности для управления цифровой идентичностью. Пользователи могут контролировать свои данные и решать, кому предоставлять доступ к ним.

Код: Скопировать в буфер обмена

Код:

pragma solidity ^0.8.0;

contract IdentityManager {
    struct Identity {
        address owner; // Владелец идентичности
        mapping(bytes32 => bytes32) attributes; // Атрибуты идентичности
    }

    mapping(address => Identity) public identities; // Хранение идентичностей

    // Функция для создания идентичности
    function createIdentity() public {
        require(identities[msg.sender].owner == address(0), "Identity already exists"); // Проверка существования
        identities[msg.sender].owner = msg.sender; // Установка владельца
    }

    // Функция для добавления атрибута к идентичности
    function setAttribute(bytes32 name, bytes32 value) public {
        require(identities[msg.sender].owner == msg.sender, "Not the identity owner"); // Проверка прав владельца
        identities[msg.sender].attributes[name] = value; // Установка атрибута
    }

    // Функция для получения атрибута идентичности
    function getAttribute(address identity, bytes32 name) public view returns (bytes32) {
        return identities[identity].attributes[name]; // Возврат значения атрибута
    }
}

Identity: Структура, содержащая адрес владельца и маппинг для хранения атрибутов идентичности.
identities: Маппинг, который связывает адреса пользователей с их идентичностями.
createIdentity:
- Проверяет, существует ли уже идентичность для вызывающего.
- Если не существует, устанавливает адрес владельца.
setAttribute:
- Проверяет, является ли вызывающий владельцем идентичности.
- Добавляет атрибуты к идентичности.
getAttribute:
- Позволяет любому пользователю получать значения атрибутов идентичности по адресу и имени атрибута.

Где настоящий потенциал Web3?

Web3 обладает значительным потенциалом в нескольких ключевых областях:

1. Децентрализованные финансы (DeFi)

DeFi предлагает альтернативу традиционным финансовым услугам, обеспечивая доступ к кредитованию, сбережениям и инвестициям без посредников.

Код: Скопировать в буфер обмена

Код:

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract SimpleLending {
    mapping(address => uint256) public deposits;
    mapping(address => uint256) public loans;
    IERC20 public token;


    constructor(address _token) {
        token = IERC20(_token);
    }

    function deposit(uint256 amount) external {
        require(token.transferFrom(msg.sender, address(this), amount), "
Transfer failed");deposits[msg.sender] += amount;}


function borrow(uint256 amount) external {
require(token.balanceOf(address(this)) >= amount, "Insufficient liquidity");
require(loans[msg.sender] == 0, "Existing loan must be repaid first");

loans[msg.sender] = amount;
require(token.transfer(msg.sender, amount), "Transfer failed");
}

function repay() external {
uint256 amount = loans[msg.sender];
require(amount > 0, "No existing loan");
require(token.transferFrom(msg.sender, address(this), amount), "Transfer failed");

loans[msg.sender] = 0;
}

function withdraw(uint256 amount) external {
require(deposits[msg.sender] >= amount, "Insufficient balance");
deposits[msg.sender] -= amount;
require(token.transfer(msg.sender, amount), "Transfer failed");
}


}

Контракт:
- contract SimpleLending — объявляет контракт для платформы кредитования.
Состояние переменных:
- mapping(address => uint256) public deposits; — хранит суммы депозитов каждого пользователя.
- mapping(address => uint256) public loans; — отслеживает активные займы пользователей.
- IERC20 public token; — переменная для хранения адреса токена, используемого в контракте.
Конструктор:
- constructor(address _token) — принимает адрес токена, который будет использоваться в контракте.
Функции:
- deposit(uint256 amount):
  - Пользователь вносит токены.
  - Проверяет, успешен ли перевод токенов на адрес контракта и увеличивает депозит.
- borrow(uint256 amount):
  - Пользователь может взять займ.
  - Проверяет наличие достаточной ликвидности и отсутствие текущего займа, затем переводит сумму займа пользователю.
- repay():
  - Пользователь погашает займ.
  - Проверяет наличие существующего займа и требует перевод необходимой суммы на адрес контракта.
- withdraw(uint256 amount):
  - Пользователь может снять средства из своего депозита.
  - Проверяет, достаточно ли средств, и переводит указанную сумму обратно пользователю.

2. Невзаимозаменяемые токены (NFT)

NFT открывают возможности для цифрового серфинга, игровой индустрии и управления правами на интеллектуальную собственность. Они позволяют создавать уникальные цифровые активы, которые можно продавать, коллекционировать и использовать в различных приложениях.

Пример простого NFT-контракта:
Код: Скопировать в буфер обмена

Код:

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract SimpleNFT is ERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;

mapping(uint256 => string) private _tokenURIs;

constructor() ERC721("SimpleNFT", "SNFT") {}

function mintNFT(address recipient, string memory tokenURI) public returns (uint256) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(recipient, newItemId);
_setTokenURI(newItemId, tokenURI);
return newItemId;
}

function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}

function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
return _tokenURIs[tokenId];
}
}

Контракт реализует базовую функциональность NFT: создание уникальных токенов с ассоциированными метаданными (URI). Пользователи могут создавать NFT, передавать их другим пользователям и запрашивать информацию о токенах.

3. Децентрализованное управление (DAO)

Децентрализованные автономные организации (DAO) представляют модель управления, основанную на смарт-контрактах. Они позволяют создавать организации с прозрачными правилами и децентрализованным принятием решений.

Пример простого DAO-контракта:

Код: Скопировать в буфер обмена

Код:

pragma solidity ^0.8.0;

contract SimpleDAO {
struct Proposal {
address recipient;
uint amount;
string description;
uint votesFor;
uint votesAgainst;
bool executed;
mapping(address => bool) voted;
}

mapping(uint => Proposal) public proposals;
uint public proposalCount;
mapping(address => bool) public members;
uint public memberCount;

constructor() {
members[msg.sender] = true;
memberCount = 1;
}

function addMember(address _member) public {
require(members[msg.sender], "Only members can add new members");
require(!members[_member], "Address is already a member");
members[_member] = true;
memberCount++;
}

function createProposal(address _recipient, uint _amount, string memory _description) public {
require(members[msg.sender], "Only members can create proposals");
proposalCount++;
Proposal storage p = proposals[proposalCount];
p.recipient = _recipient;
p.amount = _amount;
p.description = _description;
}

function vote(uint _proposalId, bool _support) public {
require(members[msg.sender], "Only members can vote");
Proposal storage p = proposals[_proposalId];
require(!p.voted[msg.sender], "Member has already voted");
require(!p.executed, "Proposal has already been executed");

p.voted[msg.sender] = true;
if (_support) {
p.votesFor++;
} else {
p.votesAgainst++;
}
}

function executeProposal(uint _proposalId) public {
Proposal storage p = proposals[_proposalId];
require(!p.executed, "Proposal has already been executed");
require(p.votesFor > p.votesAgainst, "Proposal needs more votes for execution");

p.executed = true;
(bool success, ) = p.recipient.call{value: p.amount}("");
require(success, "Execution failed");
}

receive() external payable {}
}

Контракт реализует базовую функциональность DAO: создание предложений, голосование и выполнение решений. Члены DAO могут создавать предложения, голосовать за них и выполнять одобренные предложения.

Слои масштабирования (Layer 2)

Одной из ключевых технических проблем Web3 является масштабируемость. Для решения этой проблемы разрабатываются решения второго уровня (Layer 2), которые позволяют обрабатывать транзакции вне основной цепи блокчейна, снижая нагрузку и увеличивая пропускную способность.

Основные типы Layer 2 решений:

Rollups:
- Optimistic Rollups: Выполняют транзакции за пределами основной цепи и публикуют только минимальные данные в основную цепь. Примеры: Optimism, Arbitrum.
- Zero-Knowledge (ZK) Rollups: Используют криптографические доказательства для подтверждения валидности транзакций без необходимости их полной обработки в основной цепи. Примеры: zkSync, StarkNet.
State Channels: Позволяют участникам проводить множество транзакций офчейн, публикуя в основную цепь только начальное и конечное состояние. Пример: Lightning Network для Bitcoin.
Plasma: Создает дочерние цепи, связанные с основной цепью, для обработки транзакций. Хотя популярность Plasma снизилась, некоторые проекты все еще используют эту технологию.

Пример использования Optimistic Rollup с библиотекой ethers.js:

JavaScript: Скопировать в буфер обмена

Код:

const ethers = require('ethers');

// Подключение к Optimistic Ethereum
const l2Provider = new ethers.providers.JsonRpcProvider('https://mainnet.optimism.io');

// Создание кошелька
const privateKey = 'your_private_key_here';
const wallet = new ethers.Wallet(privateKey, l2Provider);

// Отправка транзакции в L2
async function sendL2Transaction() {
const transaction = {
to: '0xRecipientAddress',
value: ethers.utils.parseEther('0.1') // 0.1 ETH
};

const tx = await wallet.sendTransaction(transaction);
console.log('Transaction hash:', tx.hash);
await tx.wait();
console.log('Transaction confirmed');
}

sendL2Transaction().catch(console.error);

Межблокчейновая совместимость

Основные подходы к обеспечению межблокчейновой совместимости:

Мосты (Bridges): Позволяют передавать активы и данные между разными блокчейнами. Примеры: Polygon PoS Bridge, Wormhole.
Кросс-чейн протоколы: Обеспечивают стандартизированный способ взаимодействия между блокчейнами. Пример: Polkadot с его парачейнами и релейной цепью.
Атомарные свопы: Позволяют осуществлять обмен активами между разными блокчейнами без доверенных посредников.

Пример использования моста для передачи токенов с Ethereum на Polygon с использованием Web3.js:

JavaScript: Скопировать в буфер обмена

Код:

const Web3 = require('web3');
const { POSClient } = require('@maticnetwork/maticjs');

// Инициализация провайдеров
const ethereumProvider = new Web3.providers.HttpProvider('https://mainnet.infura.io/v3/YOUR-PROJECT-ID');
const maticProvider = new Web3.providers.HttpProvider('https://rpc-mainnet.maticvigil.com');

// Создание клиента POS Bridge
const posClient = new POSClient();
await posClient.init({
network: 'mainnet',
version: 'v1',
parent: {
provider: ethereumProvider,
defaultConfig: {
from: 'YOUR_ETHEREUM_ADDRESS'
}
},
child: {
provider: maticProvider,
defaultConfig: {
from: 'YOUR_POLYGON_ADDRESS'
}
}
});

// Функция для депозита ETH на Polygon
async function depositEthToPolygon(amount) {
const tx = await posClient.depositEther(amount, {
from: 'YOUR_ETHEREUM_ADDRESS',
gasPrice: '20000000000' // 20 Gwei
});

console.log('Deposit transaction hash:', tx.transactionHash);
await tx.getReceipt();
console.log('Deposit confirmed on Ethereum');
}

// Вызов функции
depositEthToPolygon('1000000000000000000') // 1 ETH
.catch(console.error);

Заключение

Web3 основан на блокчейне, смарт-контрактах и децентрализации. Ключевые компоненты:

dApps (DeFi, NFT, DAO)
Инструменты разработки (Hardhat, Web3.js, Ethers.js)
Масштабирование (Layer 2, Rollups)
Межблокчейновая совместимость

Технология развивается, решая проблемы масштабируемости и интеграции. Спасибо за чтение!

Web 3.0: Потому что Web 2.0 уже не торт

D2

Авторство: hackeryaroslav​

Источник: xss.is​

Что такое Web 3.0?​

Инструменты и фреймворки Web3​

Hardhat для Ethereum​

Truffle Suite​

Web3.js и Ethers.js​

Примеры децентрализованных приложений (dApps)​

1. Децентрализованная биржа (DEX)​

2. Децентрализованное приложение для голосования​

3. Децентрализованная система управления идентификацией​

Где настоящий потенциал Web3?​

1. Децентрализованные финансы (DeFi)​

3. Децентрализованное управление (DAO)​

Слои масштабирования (Layer 2)​

Основные типы Layer 2 решений:​

Межблокчейновая совместимость​

Основные подходы к обеспечению межблокчейновой совместимости:​

Заключение​

Авторство: hackeryaroslav

Источник: xss.is

Что такое Web 3.0?

Инструменты и фреймворки Web3

Hardhat для Ethereum

Truffle Suite

Web3.js и Ethers.js

Примеры децентрализованных приложений (dApps)

1. Децентрализованная биржа (DEX)

2. Децентрализованное приложение для голосования

3. Децентрализованная система управления идентификацией

Где настоящий потенциал Web3?

1. Децентрализованные финансы (DeFi)

3. Децентрализованное управление (DAO)

Слои масштабирования (Layer 2)

Основные типы Layer 2 решений:

Межблокчейновая совместимость

Основные подходы к обеспечению межблокчейновой совместимости:

Заключение