До транзакции:
Алиса: 1000 ETH
Боб: 500 ETH

Транзакция: Алиса → Боб (100 ETH)

После транзакции:
Алиса: 900 ETH
Боб: 600 ETH

До выполнения:
Контракт DEX: 10000 USDT, 5 ETH
Алиса: 1000 ETH, 0 USDT

Транзакция: Алиса обменивает 1 ETH на USDT

После выполнения:
Контракт DEX: 8000 USDT, 6 ETH
Алиса: 999 ETH, 2000 USDT

До создания:
Алиса: 1000 ETH
Новый контракт: не существует

Транзакция: Алиса создает токен-контракт

После создания:
Алиса: 999.5 ETH (потратила газ)
Новый контракт: существует, имеет код и данные

Пример: 0x742d35Cc6634C0532925a3b8D4C9db96590c6C87
Длина: 40 символов (20 байт)
Уникальность: каждый адрес уникален
Генерация: из публичного ключа пользователя

Единица измерения: wei
1 ETH = 1,000,000,000,000,000,000 wei (10^18)
Максимальное значение: очень большое число (2^256 - 1)

Примеры:
1 ETH = 1000000000000000000 wei
0.5 ETH = 500000000000000000 wei
0.001 ETH = 1000000000000000 wei

Начальное значение: 0
Увеличивается: на 1 с каждой отправленной транзакцией
Назначение: предотвращение повторного выполнения транзакций

Пример:
Первая транзакция: nonce = 0
Вторая транзакция: nonce = 1
Третья транзакция: nonce = 2

Обычный аккаунт: код отсутствует
Смарт-контракт: содержит байт-код программы

Пример байт-кода:
0x608060405234801561001057600080fd5b50600436106100365760003560e01c8063...

Структура: ключ → значение
Размер ключа: 32 байта
Размер значения: 32 байта
Количество слотов: практически неограниченно

Пример хранилища токена:
Слот 0: общее количество токенов
Слот 1: название токена
Слот 2: символ токена
Слот mapping(address => uint256): балансы пользователей

contract SimpleToken {
    uint256 public totalSupply;     // Слот 0
    string public name;             // Слот 1
    string public symbol;           // Слот 2

    mapping(address => uint256) public balances; // Динамические слоты

    function transfer(address to, uint256 amount) public {
        balances[msg.sender] -= amount;  // Изменение хранилища
        balances[to] += amount;          // Изменение хранилища
    }
}

// Состояние ДО транзакции
const stateBefore = {
  '0xAlice': { balance: '1000000000000000000', nonce: 5 }, // 1 ETH
  '0xBob': { balance: '500000000000000000', nonce: 2 }, // 0.5 ETH
};

// Транзакция
const transaction = {
  from: '0xAlice',
  to: '0xBob',
  value: '100000000000000000', // 0.1 ETH
  gas: 21000,
  gasPrice: '20000000000', // 20 gwei
};

// Состояние ПОСЛЕ транзакции
const stateAfter = {
  '0xAlice': {
    balance: '879580000000000000', // 1 - 0.1 - 0.00042 (газ)
    nonce: 6, // увеличился на 1
  },
  '0xBob': {
    balance: '600000000000000000', // 0.5 + 0.1
    nonce: 2, // не изменился
  },
};

// Вызов функции transfer в токен-контракте
const tokenTransfer = {
  from: '0xAlice',
  to: '0xTokenContract',
  data: 'transfer(0xBob, 1000)', // Перевести 1000 токенов Бобу
  gas: 50000,
};

// Изменения в базе данных:
// 1. Баланс Алисы (ETH) уменьшился на стоимость газа
// 2. Nonce Алисы увеличился на 1
// 3. В хранилище контракта изменились балансы токенов:
//    - Баланс токенов Алисы уменьшился на 1000
//    - Баланс токенов Боба увеличился на 1000

// Создание нового токена
const contractCreation = {
  from: '0xAlice',
  to: null, // null означает создание контракта
  data: '0x608060405...', // байт-код контракта
  gas: 500000,
};

// Изменения в базе данных:
// 1. Создается новый аккаунт для контракта
// 2. В новом аккаунте сохраняется код контракта
// 3. Инициализируется хранилище контракта
// 4. Баланс и nonce Алисы изменяются

BALANCE: получить баланс аккаунта
SELFBALANCE: получить баланс текущего контракта
CALL: вызвать другой контракт (может изменить балансы)

SLOAD: загрузить значение из хранилища
SSTORE: сохранить значение в хранилище

CODECOPY: скопировать код контракта
EXTCODECOPY: скопировать код другого контракта
CREATE: создать новый контракт

// Простая функция перевода токенов
function transfer(address to, uint256 amount) public {
    // 1. EVM загружает баланс отправителя (SLOAD)
    uint256 senderBalance = balances[msg.sender];

    // 2. EVM проверяет достаточность средств
    require(senderBalance >= amount, "Insufficient balance");

    // 3. EVM изменяет баланс отправителя (SSTORE)
    balances[msg.sender] = senderBalance - amount;

    // 4. EVM загружает баланс получателя (SLOAD)
    uint256 receiverBalance = balances[to];

    // 5. EVM изменяет баланс получателя (SSTORE)
    balances[to] = receiverBalance + amount;
}

const regularAccount = {
  address: '0x742d35Cc6634C0532925a3b8D4C9db96590c6C87',
  balance: '1500000000000000000', // 1.5 ETH
  nonce: 42, // 42 транзакции отправлено
  code: null, // нет кода
  storage: {}, // нет хранилища
};

const contractAccount = {
  address: '0x1234567890123456789012345678901234567890',
  balance: '0', // может иметь ETH
  nonce: 1, // количество созданных контрактов
  code: '0x608060405...', // байт-код контракта
  storage: {
    // хранилище данных
    '0x0': '1000000000000000000000000', // totalSupply
    '0x1': 'MyToken', // name
    '0x2': 'MTK', // symbol
  },
};

const blockData = {
  number: 18500000,
  timestamp: 1699123456,
  transactions: [
    // Список всех транзакций в блоке
  ],
  stateChanges: {
    // Все изменения состояния аккаунтов
    '0xAlice': { balanceChange: '-100000000000000000' },
    '0xBob': { balanceChange: '+100000000000000000' },
  },
};

const transactionData = {
  hash: '0xabcd1234...',
  from: '0xAlice',
  to: '0xBob',
  value: '100000000000000000',
  gas: 21000,
  gasPrice: '20000000000',
  nonce: 5,
  status: 'success', // успешно выполнена
  gasUsed: 21000, // использовано газа
  logs: [], // события контрактов
};

// Исходное состояние
const initialState = {
  accounts: {
    '0xAlice': { balance: '2000000000000000000', nonce: 10 }, // 2 ETH
    '0xBob': { balance: '1000000000000000000', nonce: 5 }, // 1 ETH
  },
};

// Транзакция: Алиса отправляет 0.5 ETH Бобу
const transaction = {
  from: '0xAlice',
  to: '0xBob',
  value: '500000000000000000', // 0.5 ETH
  gasLimit: 21000,
  gasPrice: '20000000000', // 20 gwei
};

// Расчет стоимости газа
const gasCost = 21000 * 20000000000; // 420000000000000 wei = 0.00042 ETH

// Финальное состояние
const finalState = {
  accounts: {
    '0xAlice': {
      balance: '1499580000000000000', // 2 - 0.5 - 0.00042
      nonce: 11, // увеличился
    },
    '0xBob': {
      balance: '1500000000000000000', // 1 + 0.5
      nonce: 5, // не изменился
    },
  },
};

// Алиса создает новый токен
const tokenCreation = {
  from: '0xAlice',
  to: null, // создание контракта
  data: 'constructor(MyToken, MTK, 1000000)', // параметры конструктора
  gas: 500000,
};

// Новое состояние базы данных
const stateAfterCreation = {
  accounts: {
    '0xAlice': {
      balance: '1990000000000000000', // потратила газ
      nonce: 11, // увеличился
    },
    '0xNewTokenContract': {
      // новый контракт
      balance: '0',
      nonce: 1,
      code: '0x608060405...', // код токена
      storage: {
        '0x0': '1000000000000000000000000', // totalSupply = 1M токенов
        '0x1': 'MyToken', // name
        '0x2': 'MTK', // symbol
        'balanceOf[0xAlice]': '1000000000000000000000000', // все токены у Алисы
      },
    },
  },
};

// Алиса обменивает токены на DEX
const dexSwap = {
  from: '0xAlice',
  to: '0xDEXContract',
  data: 'swap(1000 MTK → ETH)',
  gas: 150000,
};

// Изменения в базе данных:
const swapChanges = {
  '0xAlice': {
    balance: '+950000000000000000', // получила 0.95 ETH
    nonce: 12, // увеличился
  },
  '0xTokenContract': {
    storage: {
      'balanceOf[0xAlice]': '-1000000000000000000000', // потеряла 1000 токенов
      'balanceOf[0xDEXContract]': '+1000000000000000000000', // DEX получил токены
    },
  },
  '0xDEXContract': {
    balance: '-950000000000000000', // отдал 0.95 ETH
    storage: {
      reserves: 'updated', // обновились резервы
    },
  },
};