Solidity. Смарт контракты и аудит

Осталось менее 48 часов! Многие задумываются, куда направить свои усилия: выбрать локальную профессиональную школу, зарубежные бесплатные курсы, такие как Updraft, или интенсивные программы вроде RareSkills. Однако ключевой вопрос не в том, где учиться, а в том, насколько вы уверены, что web3 — это ваше будущее. Прежде чем инвестировать значительные средства в обучение, стоит проверить свои силы и понять, готовы ли вы к освоению новой информации и смене карьерного вектора. Летний модуль предлагает идеальный способ сделать это: структурированная подача материала, практические задания с постепенным нарастанием сложности и возможность учиться в комфортном для вас темпе. Вы получите не только знания, но и поддержку: возможность задавать вопросы, отправлять домашние задания на проверку и получать развернутую обратную связь. Этот подход позволит вам не просто изучить основы, а сформировать прочную базу для дальнейшего роста. Пройти модуль до конца — значит получить четкое понимание своих возможностей в web3. Вы сможете уверенно разбирать контракты, стандарты и протоколы, а вопрос углубленного обучения станет осознанным шагом на пути к профессиональному развитию. Сделайте первый шаг уже сейчас — и убедитесь, что ваш потенциал гораздо шире, чем кажется. Присоединяйтесь к Летнему модулю! Программа курса Условия оплаты Стартуем в понедельник. #курс

База, практика и навыки В следующем году войти в Solidity и получить работу в web3 будет еще сложнее. С каждым годом уровень требований к соискателем увеличивается в разы: на это влияет и развитие самого языка, и появление новых блокчейн сетей, и новых программ, и развитие AI. Два года назад, когда запускался первый поток самой сложной темой были прокси контракты и работа с памятью. Год назад обязательным стало знание программ тестирования Foundry или Hardhat. В этом году, по сообщениям в Твиттере, на собеседованиях уже спрашивают знания о transient storage, account abstraction и EIP-7702 на позициях джуна или мидла. И это не смотря на то, что соискатель по умолчанию должен знать информацию по базовым уязвимостям в смарт контрактах и принципы работы основных DeFi протоколов. Что будет в следующем году, можно только гадать... Но точно требования снова возрастут. Вопрос лишь в том, насколько подготовленными вы будете к тому времени? Если отложить свое обучение и подождать еще немного, то есть вероятность уже никогда не успеть за развитием рынка. Летний модуль это лишь небольшой практический курс для более близкого знакомства с Solidity и понимания его основ и паттернов. Он направлен на то, чтобы вы научились думать в рамках языка и понимать структуру контрактов и протоколов. Если просто читать посты и разборы, то вы поймете лишь крошечную долю от того, что могли бы получить в реальной практике. У преподавателей на стримах и Ютуб видео уже готовые контракты и подготовленная среда разработки, поэтому кажется, что все так просто и легко. Но стоит самому сеть за компьютер и попробовать, то начинают возникать ступоры и ошибки, преодоление которых и помогает нам двигаться дальше. Не ждите следующего года, легче не будет. AI также не упростят вам жизнь. Начните этим летом и за год вы сможете много достичь с ежедневной практикой. Присоединяйтесь к Летнему модулю! Программа курса Условия оплаты Стартуем в понедельник. #курс

🔼Первые ученики уже на канале!🔼 Если вы только пришли с работы, то пост для вас! Сегодня старт продаж Летнего модуля нашего курса! Лето - это идеальное время получить новые знания и профессию! Курс построен так, чтобы у вас было достаточно времени на вдумчивое изучение каждой темы — именно поэтому он длится 11 недель. Сложность растёт постепенно, без резких скачков, чтобы материал усваивался легко и без лишнего стресса. Самые первые ученики уже канале! Видно, что они подходят к обучению осознанно, и это главное. Уверенность в своих действиях — половина успеха, и у вас точно получится пройти этот путь до конца.  Ждем остальных, по опросу желающих было куда больше: 45+ проголосовавший ЗА! Продажи открыты! Успейте занять свое место! Условия оплаты в посте выше. Старт уже в понедельник! #курс

🥳🥳🥳 Открытие продаж на Летний модуль! Сегодня мы открываем продажи на наш Летний практический модуль курса "Начинающий разработчик смарт контрактов"! В этот раз продажи продлятся всего 4 дня, успейте занять свое место! Напомню, краткую информацию о модуле: 1. Первые уроки выйдут уже в следующий понедельник, 30 июня; 2. Это будет самый продолжительный модуль - 11 интенсивных недель! 3. Всего будет 50 уроков, 30+ практических заданий с кодом (написание контрактов, анализ и разбор, тесты), 60 продвинутых вопросов, которые могут задать на собеседовании, 3 практикума! 4. Это первый модуль, в который включен блок по тестированию контрактов в Foundry; 5. Уроки проходят в формате текстовых постов с заданиями и дополнительными материалами; 6. Видео, еженедельные созвоны и стримы не предусмотрены. Вы можете планировать свое время на обучение, как пожелаете! Всю программу модуля вы можете найти в этом посте! А тут прочитать, какие знания потребуются для комфортного прохождения. Теперь по условиям оплаты: 1. Оплачиваем по реквизитам ниже; 2. Обязательно присылаем чек-подтверждение или хеш транзакции в личные сообщения - @zaevlad; 3. В ответном сообщении вы получите ссылку приглашение в закрытую группу Телеграмм; Реквизиты: 1. Карта Сбер: 4276520014513846 Владилен Александрович З. 2. Криптокошелек для заребежных переводов: 0x331d8654Ff5c314E2baDAAfA83Fdf635650a9E59 Переводы принимаются только в сети Polygon Pos в USDT или USDC. Стоимость: 1. Для новый учеников - 9000 рублей, 115 USDT/USDC; 2. Для тех был на прошлом Летнем модуле и хочет повторно пройти этот модуль: 3500 рублей, 45 USDT/USDC. 3. Для тех, кто хочет купить 1-й модуль (для самостоятельного прохождения) и 2-й (Летний) модуль вместе - стоимость 12 000 рублей, 155 USDT/USDC. Программу 1-го модуля можно найти тут. До конца этой недели мы ждем желающих в Телеграм канале. В воскресенье в полночь продажи будут закрыты. Обращаю внимание, что эти два модуля можно купить только сейчас! 3-й модуль будет продаваться отдельно, и докупить его будет нельзя! Успейте занять свое место! Начинаем уже в понедельник! #курс

Вайб кодинг и модуль Нейронные сети активно развиваются, но их возможности в генерации качественного кода пока далеки от идеала. Особенно это заметно в Solidity, где каждая строка кода должна быть продумана с учетом безопасности и эффективности. Нейронки часто выдают решения, которые на первый взгляд выглядят корректно, но содержат глупые ошибки — от пропущенных модификаторов до неочевидных уязвимостей. Даже опытный разработчик может потратить время на анализ такого кода, не говоря уже о новичках. На Летнем модуле я не учу работать с нейронными сетями, потому что главная цель — дать вам глубокое понимание Solidity, а не инструментов, которые его генерируют. Однако тут не запрещено их использование, так как это часть современной разработки. Важно научиться критически оценивать сгенерированный код, находить в нем слабые места и исправлять их. Только так можно превратить сырой результат нейронки в надежный и безопасный смарт-контракт. Практика с Foundry включена в программу не случайно. Этот инструмент позволяет вам самостоятельно тестировать контракты, в том числе те, что созданы нейронными сетями. Вы научитесь писать тесты, проверять логику работы и выявлять скрытые проблемы. Это ключевой навык, который поможет вам не только в текущих заданиях, но и в реальных проектах, где ошибки могут стоить больших денег. Использование сетей для выполнения задач — это не плохо, если подходить к процессу осознанно. Когда вы публикуете свой код в чат или присылаете его на проверку, вы получаете обратную связь, которая помогает вам понять, где нейронка ошиблась и как можно улучшить результат. Такой подход развивает вашу способность анализировать код и отличать рабочие решения от потенциально опасных. Главное преимущество этого формата обучения — вы учитесь на практике. Вместо абстрактных советов вы получаете конкретные примеры, разбираете их и сразу применяете знания. Это делает процесс более эффективным, поскольку вы не просто запоминаете теорию, а учитесь думать как разработчик. Курс построен так, чтобы вы могли уверенно работать с Solidity независимо от того, используете вы нейронные сети или нет. Вы научитесь проверять код, писать тесты и понимать, как должен выглядеть качественный смарт-контракт. В результате вы сможете создавать надежные решения, а не просто полагаться на автоматизированные инструменты, чьи ошибки могут дорого обойтись. Программа модуля Старт: 30 июня #курс

Отличие этого Модуля: челленджи для решительных Летний модуль является логичным продолжением первого, где вы освоили основы Solidity и создали свои первые смарт-контракты в Remix IDE. Теперь мы двигаемся дальше: переходим к профессиональным инструментам — выбираем редактор кода, изучаем GitHub и терминал, а затем постепенно углубляемся в работу с токенами, EIP и паттернами. Этот модуль ориентирован на новичков, но также подходит и опытным разработчикам, которые хотят закрепить навыки или пополнить портфолио практическими задачами. Для тех, кто ищет дополнительную нагрузку, предусмотрены еженедельные челленджи. Челлендж — это практическое задание, выходящее за рамки основных уроков. Каждую неделю вас ждет 5 задач на написание смарт-контрактов и 10 сложных вопросов, требующих глубокого понимания материала. Это не только отличный способ прокачать навыки, но и возможность собрать проекты, которые можно будет показать на собеседовании. Всего за модуль вас ждет 7 челленджей — 35 практических задач и 70 вопросов, дополняющих основные задания после уроков. Летний модуль я называю "практическим", потому что теория здесь сведена к необходимому минимуму — ровно столько, чтобы вы поняли, как что-то сделать. Но настоящие навыки вы получите только за практикой: садясь за компьютер и выполняя задания. Здесь придется серьезно напрячь мозги — просто читать уроки и повторять готовые примеры не получится. Вам нужно будет вникать в суть и искать дополнительную информацию: анализировать документацию, проверять решения в нейросетях, обсуждать сложные моменты в чате и задавать вопросы. Только так вы разберетесь в нюансах и научитесь решать реальные задачи. Если ваша цель — за год сменить профессию и быстро выйти на уровень уверенного разработчика смарт-контрактов, этот модуль станет для вас мощным ускорителем. Он даст не просто знания, а практические навыки, которые можно сразу применять в работе. Готовы к интенсивному погружению? Тогда вперёд! Программа модуля Старт: 30 июня #курс

Про формат уроков и материалы модуля Скоро стартуют продажи на Летний модуль курса по Solidity, и я хочу подробнее рассказать о формате обучения — это один из самых частых вопросов перед началом курса. Летний модуль, как и другие, состоит из текстовых уроков с дополнительными материалами и практическими заданиями. Здесь нет видеолекций, которые растягивают простое объяснение на часы, жестких дедлайнов и обязательных созвонов, нервяков из-за того, что не успел к проверке. Вместо этого — четкие, структурированные материалы, которые вы изучаете в удобном темпе. Текстовый формат дает гибкость — не нужно подстраиваться под расписание лекций. Учитесь утром, вечером или даже ночью. Он эффективнее, потому что текст позволяет быстро находить нужную информацию и возвращаться к сложным темам. А еще он фокусируется на практике — вместо пассивного просмотра видео вы сразу применяете знания в заданиях. Я не оставляю учеников один на один с материалом. Вы всегда можете написать в общий чат курса — там помогаю я и другие участники. Или обратиться ко мне в личные сообщения — разберу сложные моменты детально. Выпускники прошлых потоков подтвердят, что все уроки и задания остаются у вас бессрочно. Телеграм-канал и чаты не закрываются после окончания курса. P.S. В следующем году откроется платформа — и все ученики получат бесплатный доступ к обновленным материалам. Готовы учить Solidity без лишней суеты? Жду вас на Летнем модуле. #курс

Какие знания нужны для прохождения Летнего модуля? В прошлом году этот вопрос был одним из самых часто задаваемых перед стартом курса, поэтому сегодня я хочу подробнее осветить данный момент. Весь курс, включая все три модуля, разработан специально для тех, кто только начинает свой путь в программировании. Несмотря на большой объем материала и интенсивный формат обучения, программа построена по принципу «от простого к сложному», что позволяет плавно осваивать новые темы. Первый модуль посвящен фундаментальным основам языка: типам данных, наследованию, интерфейсам, работе с библиотеками и взаимодействию между контрактами. Эти знания станут надежной базой для перехода к Летнему модулю. Курс также включает ключевые аспекты для начинающих разработчиков: настройку профессионального рабочего пространства (ведь, несмотря на удобство Remix IDE, реальные проекты требуют более серьезных инструментов), работу с GitHub и терминалом, изучение структуры стандартов токенов, NFT и других важных компонентов. Можно ли его покупать, если сейчас только начинаешь свой путь? Думаю, да. Во-первых, даже на бесплатных уроках в YouTube можно быстро освоить азы, но для дальнейшего роста нужна системная подача материала. Во-вторых, четкая структура модуля обеспечивает последовательное изучение тем с постепенным увеличением сложности. В-третьих, критически важна практика: понимание теории — это лишь первый шаг, а умение применять знания на практике — ключевой навык, который вы разовьете в процессе обучения. Кроме того, вместе в Летним модулем у вас будет возможность приобрести самый первый модуль для самостоятельного изучения, получив таким образом полный комплект материалов на все четыре месяца курса. Не упустите последний шанс присоединиться — этот поток станет завершающим. Старт программы запланирован на 30 июня! Программа модуля #курс

Сколько будет стоить Летний модуль? Я выделил эту тему в отдельный пост, поскольку для этого есть веские основания. Всегда считал важным делать модули курса доступными по цене, осознавая, насколько сложен путь освоения Solidity и мира web3 в целом. Многие сталкиваются с трудностями, и лишь единицы доходят до финала. Поэтому мой подход — дать возможность начать с минимальных вложений, оценить свою заинтересованность и уже затем принимать решение о дальнейшем обучении: будь то профессиональные школы, индивидуальные наставники или самостоятельное изучение. Курс создавался с расчетом на новичков, без каких-либо предварительных знаний. За годы практики, включая аудит смарт-контрактов, я пришел к выводу, что Solidity невозможно освоить без глубокого понимания базовых принципов: работы типов данных, структуры контрактов, особенностей памяти EVM и написания тестов. К сожалению, многие курсы подают материал поверхностно, делая акцент лишь на готовых решениях, что ограничивает реальное понимание технологии. Летний модуль разработан с упором на практику: он помогает не только усвоить основы, но и научиться уверенно применять их. Это самый масштабный и продолжительный этап обучения — 3 месяца и 50 уроков. Изначально цена должна была быть выше, но есть несколько причин, по которым я решил предложить особые условия. Это последний поток в формате Telegram-уроков. В следующем году курс перейдет на веб-платформу, где обучение станет самостоятельным, без поддержки преподавателя и жестких сроков. Кроме того, 13 июля нашему каналу исполняется 3 года, и я хочу отметить это событие, сделав модуль максимально ценным для участников. Моя цель — чтобы после завершения курса или перехода на другие программы ученики вспоминали его как один из самых насыщенных и полезных этапов своего обучения. Поэтому итоговая стоимость модуля составит всего 9000 рублей — это минимальная цена на рынке за такой объем знаний и продолжительность обучения. Этот модуль — ваш шанс получить структурированные знания, которые заложат прочный фундамент для работы в сфере блокчейн-разработки. Вместо разрозненных уроков и поверхностных объяснений вы получите четкую систему, которая поможет не просто копировать код, а понимать его и создавать свои решения. Выделю главное еще раз: Старт: ориентировочно 30 июня Стоимость: 9000 рублей (115 USDT) Открытие продаж на следующей неделе! #курс

Программа Летнего модуля Буквально через две недели планируется запуск продолжительного Летнего модуля, который в этот раз дополнится интенсивом по Foundry - программе для тестирования смарт контрактов, а также новыми задачами для тех, кто посчитает, что практические задания слишком легкие. В этот раз модуль займет 3 месяца! Программа рассчитана на 11 недель интенсивного ежедневного обучения! Сегодня будет представлена программа, а про стоимость вы узнаете завтра; она будет очень приятной! Итак, программа Летнего модуля нашего курса: Основные уроки Неделя 1 1. Подготовка рабочего пространства 2. Плагины и настройки 3. Терминал, Node JS, NPM 4. Работа с GitHub 5. Стандарт ERC20. Разбор кода и EIP Бонус: дополнительные практические задания Неделя 2 6. ERC20 от Open Zeppelin 7. Свой токен и подключение OZ 8. ERC20. Особенности и разнообразие 9. ERC20. Проблемы безопасности 10. ERC721. Разбор кода и EIP Бонус: задание - челлендж Неделя 3 11. ERC721. Использование в проектах 12. ERC721. Проблемы безопасности 13. Подключение токенов в свой проект 14. Hardhat. Подключение и настройка 15. Hardhat. Подключение контрактов и чтение тестов Бонус: задание - челлендж Неделя 4 16. Foundry. Настройка и запуск 17. Foundry. Тесты Промежуточный практикум 1 месяца 18. Стандарт ERC4626 19. Стандарт ERC4907 Бонус: задание - челлендж Неделя 5 20. Стандарт ERC6551 21. Голландский аукцион 22. Multisig и Timelock 23. Commit/reveal 24. DAO и governance Бонус: задание - челлендж Неделя 6 25. Ролевая система в контрактах 26. File pattern 27. Структуры storage 28. Селекторы функций и поинтеры 29. Defi паттерн: стейкинг Бонус: задание - челлендж Неделя 7 30. Defi паттерн: ликвидации и займы 31. Базовая безопасность и аудит Финальный практикум по основным темам Интенсив по Foundry Неделя 8 32. Установка Foundry: что входит в программу и для чего это нужно 33. Знакомство с cast командами. Чем они нужны и как работают 34. Сложные команды cast, которые пригодятся разработчику 35. Работа с chisel. Побитовые сдвиги и форк сети 36. Настройки Foundry: профили, библиотеки, пути Неделя 9 37. Какие тесты бывают: правила написания и формирования папки проекта 38. Создание setUp() функции для удобного написания тестов. Роли пользователей, управление временем в тестах 39. Логика assert условий 40. Работа с ошибками и событиями в тестах 41. Логирование результатов теста и вывод в консоль Неделя 10 42. Фазз тесты 43. Форк тесты. Интеграции с другими протоколами 44. Мутационные тесты 45. Тестирование подписей в контрактах 46. Деплой в разные сети. Написание простых скриптов Неделя 11. Бонусные уроки 47. Интеграция с Hardhat 48. Хранение приватных ключей 49. Современные программы тестирования 50. Финальный практикум Старт: ориентировочно 30 июня Итого: 11 недель обучения, 50 уроков, 30+ практических заданий с кодом (написание контрактов, анализ и разбор, тесты), 60 продвинутых вопросов, которые могут задать на собеседовании, 3 практикума! По традиции, ниже будет опрос, кто планирует присоединиться к данному модулю. Прошу проголосовать всех заинтересованных! Приятного обучения! #курс

Что-то кончается, что-то начинается На прошлой неделе закончился 1 модуль курса. Он был существенно дополнен новыми уроками по EVM, кучей вопросов для самопроверки, а также небольшой социальной частью. В самом начале модуля я рассказал участникам, что сейчас лучше всего искать работу через web3 сообщество, а именно в социальной сети Твиттер. Вся жизнь web3 происходит именно там: свежие новости о хакерских атаках, полезные советы по Solidity, программы для начинающих разработчиков и, конечно же, вакансии. Гораздо проще получить первую работу, если вы активно ведёте аккаунт и делитесь полезным контентом (не говоря уже об аудиторах, которые благодаря участию в конкурсах получают огромный рост аудитории и стабильный доход). Да и работодателям проще понять, подходите ли вы им, по вашим постам и активности, чем по сухому резюме. Именно поэтому на модуле бонусом были посты про то, как вести свой аккаунт, а также некоторые личные рекомендации пользователей и компаний, за которыми интересно следить. Вести блог или соцсети одновременно и легко, и сложно. Но именно это помогает вас заметить. Если вы меняете профессию — это отличный повод документировать свой путь. Так, например, появился и этот канал — мой личный опыт в web3 и Solidity. Раскрутка аккаунта может занять больше года, и важно работать над этим ежедневно. Поэтому лучше начинать уже во время обучения, а не в конце, когда знания есть, а времени на развитие личного бренда уже нет. Помните: ваш аккаунт — это ваша визитная карточка. Даже если сейчас у вас мало подписчиков, каждый пост — это вклад в вашу репутацию. Комментируйте новости, делитесь своими успехами и ошибками, задавайте вопросы экспертам. Так вы не только учитесь быстрее, но и обрастаете полезными связями. Не ждите идеального момента — его не будет. Начните сегодня: напишите пост о том, что нового узнали, сделайте разбор интересного кейса или просто расскажите о своих целях. Со временем это превратится в мощный ресурс, который откроет вам двери в лучшие проекты. Это было необычным бонусом на этом модуле, а на следующем - будет что-то новое! P.S. Отдельный респект всем, кто узнал отсылку в заголовке поста! #курс

Проект на виду. Часть 7. Обучение с нейронками Вы, наверное, помните, что я уже пару-тройку месяцев интересуюсь языковыми моделями, автоматизированным программированием и всем, что с этим связано. Сегодня хочу обсудить, насколько эффективно можно учиться самостоятельно, используя только современные нейросети. Я пробовал создавать небольшие проекты в Cursor на разных языках - Python, Rust, Java - с использованием соответствующих инструментов вроде Flask для Python. Поскольку я не знал этих языков, мне было интересно проверить, получится ли полноценно программировать, полагаясь только на нейросети. Результат оказался разочаровывающим - об этом я уже писал раньше. После нескольких неудачных попыток разобраться в сгенерированном коде я решил попробовать другой подход: попросил нейросеть научить меня основам Python. Мой запрос был простым: "Ты преподаватель Python. У меня есть опыт в PHP и JavaScript, но о Python я не знаю ничего. Составь пять первых уроков для новичка с примерами кода и заданиями". Нейросеть выдала уроки, которые на первый взгляд выглядели неплохо. Но тут я столкнулся с неожиданной проблемой: как понять, что программа обучения составлена правильно и ничего важного не упущено? Когда я спросил, какие ключевые моменты могли быть пропущены, нейросеть добавила несколько пунктов - например, про отсутствие точек с запятой и важность отступов в Python. Однако чем больше я задавал уточняющих вопросов, тем больше запутывался. В конечном счете мне пришлось искать обычные учебные программы и видеоуроки, потому что нейросеть не смогла предоставить систематизированный подход к обучению. Это подводит меня к важному выводу: когда вы не знаете предмета и не имеете четкого плана обучения, очень сложно чему-то научиться. Даже современные нейросети не могут заменить полноценного учебного курса. Возникает вопрос: зачем вообще учить языки программирования, если нейросети могут писать код? Ответ прост: чтобы понимать, какой код перед вами - качественный или наполненный ненужными элементами вроде избыточного логирования, временных тестов или одноразовых библиотек. То же самое касается и Solidity. Нейросеть может дать сжатый курс, где в первую же неделю будут и типы данных, и функции, и контракты. Но в web3-разработке важны нюансы - недостаточно просто знать о существовании тех или иных возможностей, нужно уметь их правильно применять. В итоге получается, что языковые модели, при всей их эрудированности, пока не способны заменить полноценного преподавателя и хорошо структурированную учебную программу. Лучший способ их использовать - сначала изучать основы по проверенным источникам, а затем обращаться к нейросетям за разъяснением конкретных вопросов и дополнительными деталями. Надеюсь, что скоро расскажу вам, чем я там таким интересным занимаюсь помимо аудитов смарт контрактов! #offtop

Стандарт ERC-6909 Minimal Multi-Token Standard. Часть 4 В последнем посте про этот стандарт поговорим о способах его применения. Как Uniswap v4 PoolManager реализует ERC-6909? В Uniswap третьей версии для каждой новой торговой пары создавался отдельный смарт-контракт через фабрику UniswapV3Factory. Это приводило к высоким комиссиям, поскольку развертывание нового контракта для каждого пула требовало дополнительных затрат газа. Четвертая версия Uniswap кардинально изменила подход, внедрив единый управляющий контракт PoolManager.sol. Вместо создания отдельных контрактов для каждого пула, все операции теперь выполняются в рамках одного главного контракта, что существенно уменьшает затраты на создание новых торговых пар. В предыдущих версиях сложные операции с участием нескольких пулов сопровождались множественными переводами токенов и дублирующими обновлениями данных. В Uniswap v4 применяется принципиально новая схема - токены хранятся в виде внутренних записей стандарта ERC-6909, что исключает необходимость физических переводов. Пользователи по-прежнему могут выводить свои средства в виде стандартных ERC-20 токенов. Однако если активы остаются в протоколе, система использует их виртуальное представление по стандарту ERC-6909, что ускоряет операции и снижает комиссии. Такой подход позволяет совершать сделки без постоянного перемещения токенов между кошельками и контрактами. При торговле между токенами A и B система просто изменяет соответствующие записи в рамках внутреннего учета, а не выполняет фактические переводы. Стоит отметить, что в Uniswap v4 стандарт ERC-6909 не применяется для токенов, представляющих долю в пуле ликвидности (LP-токены). Метаданные ERC-6909 для синглтон-архитектур DeFi и NFT-коллекций Интерфейс IERC6909Metadata определяет, как стандарт ERC-6909 связывает метаданные (name, symbols, decimals) с отдельными токенами. Функции name, symbol и decimals могут изменяться в зависимости от id токена, позволяя разным токенам в рамках одного ERC-6909 контракта иметь уникальные параметры.

/// @notice Contains metadata about individual tokens.
interface IERC6909Metadata is IERC6909 {
    /// @notice Name of a given token.
    /// @param id The id of the token.
    /// @return name The name of the token.
    function name(uint256 id) external view returns (string memory);

    /// @notice Symbol of a given token.
    /// @param id The id of the token.
    /// @return symbol The symbol of the token.
    function symbol(uint256 id) external view returns (string memory);

    /// @notice Decimals of a given token.
    /// @param id The id of the token.
    /// @return decimals The decimals of the token.
    function decimals(uint256 id) external view returns (uint8);
}

Для DeFi-протокола с несколькими LP-токенами может потребоваться стандартизация количества знаков после запятой (например, фиксированные 18 decimal), при этом названия и символы токенов должны отражать различные активы в пуле. В случае с NFT (невзаимозаменяемыми токенами) значение decimals всегда должно быть равно 1, поскольку NFT неделимы. В традиционных NFT-коллекциях (например, ERC-721) все токены используют одинаковые название и символ, представляющие коллекцию целиком (например, "CryptoPunks" с символом "PUNK"). Стандарт ERC-6909 позволяет сохранить подход ERC-721, где все NFT в коллекции разделяют общие метаданные. Еще несколько интересных примеров с кодом вы можете посмотреть в оригинальной статье от RareSkills тут. #eip6909

Стандарт ERC-6909 Minimal Multi-Token Standard. Часть 3 На этой неделе поговорим о функциях в стандарте и некоторых моментах его использования. 1. transfer(): Функция перевода ERC-6909 ведет себя так же, как и трансфер ERC-20, за исключением того, что она применяется к конкретному идентификатору токена. Функция принимает адрес получателя, id токена и сумму для перевода в качестве входных параметров и обновляет балансы с помощью связки balanceOf. Как и в функции перевода ERC-20, необходимо вернуть true, если транзакция выполнена успешно:

    function transfer(address receiver, uint256 id, uint256 amount) public returns (bool) {
        if (balanceOf[msg.sender][id] < amount) revert InsufficientBalance(msg.sender, id);
        balanceOf[msg.sender][id] -= amount;
        balanceOf[receiver][id] += amount;
        emit Transfer(msg.sender, msg.sender, receiver, id, amount);
        return true;
    }

2. transferFrom(): Функция transferFrom в ERC-6909 отличается от функции ERC-20 тем, что требует идентификатор токена. Кроме того, она проверяет наличие одобрения оператора в дополнение к разрешению. Сначала функция проверяет, если (sender != msg.sender && !isOperator[sender][msg.sender]), гарантируя, что вызывающая сторона (msg.sender) является либо: - Владелецем (отправителем), либо - Одобренным оператором (isOperator[sender][msg.sender] == true). Если отправитель msg.sender не является таковыми, то функция проверяет, достаточно ли у вызывающего абонента средств для перевода. Если резерв существует, но не установлен в неограниченное значение (type(uint256).max), то переведенная сумма вычитается из резерва. Кроме того, в стандарте указано, что функция НЕ ДОЛЖНА вычитать сумму из резерва вызывающего абонента по идентификатору токена, если вызывающий абонент является оператором или отправителем.

function transferFrom(address sender, address receiver, uint256 id, uint256 amount) public returns (bool) {

    if (sender != msg.sender && !isOperator[sender][msg.sender]) {
        uint256 senderAllowance = allowance[sender][msg.sender][id];
        if (senderAllowance < amount) revert InsufficientPermission();
        if (senderAllowance != type(uint256).max) {
            allowance[sender][msg.sender][id] = senderAllowance - amount;
        }
    }

    if (balanceOf[sender][id] < amount) revert InsufficientBalance();

    balanceOf[sender][id] -= amount;
    balanceOf[receiver][id] += amount;
    emit Transfer(msg.sender, sender, receiver, id, amount);
    return true;
}

3. approve(): Функция approve позволяет вызывающей стороне (msg.sender) предоставить определенное разрешение к ID спендеру. При этом обновляется маппинг, чтобы отразить новое состояние, и порождается событие Approval:

function approve(address spender, uint256 id, uint256 amount) public returns (bool) {
    allowance[msg.sender][spender][id] = amount;
    emit Approval(msg.sender, spender, id, amount);
    return true;
}

4. setOperator(): Функция setOperator позволяет вызывающей стороне (msg.sender) предоставить или отозвать разрешения оператора для определенного адреса (spender) от своего имени, установив параметр approved в true или false. Функция соответствующим образом обновляет отображение isOperator и порождает событие OperatorSet, чтобы уведомить внешних слушателей об изменении.

function setOperator(address spender, bool approved) public returns (bool) {
    isOperator[msg.sender][spender] = approved;
    emit OperatorSet(msg.sender, spender, approved);
    return true;
}

5. Events: В стандарте предусмотрены три события для порождения в ключевых функциях:

event Transfer(address caller, address indexed sender, address indexed receiver, uint256 indexed id, uint256 amount);

event OperatorSet(address indexed owner, address indexed spender, bool approved);

event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount);

#eip6909

Стандарт ERC-6909 Minimal Multi-Token Standard. Часть 2 Продолжаем знакомится с данным стандартом. Модель оператора в ERC-6909 В функции ERC-6909 setOperator, показанной ниже, переменная spender устанавливается в качестве оператора и получает глобальные разрешения на передачу всех идентификаторов токенов, принадлежащих счету, без ограничений по разрешению.

function setOperator(address spender, bool approved) public returns (bool) {
    isOperator[msg.sender][spender] = approved;
    emit OperatorSet(msg.sender, spender, approved);
   return true;
}

Модель разрешений в ERC-6909 Модель разрешений (allowance model) представляет собой систему управления по конкретным токенам и суммам, в которой учетная запись может установить ограниченное количество разрешений для конкретного ID токена. Например, Алиса может разрешить Бобу перевести 100 единиц токена с ID 42, не предоставляя доступа к другим токенам или неограниченным суммам, используя функцию одобрения в ERC-6909, показанную далее.

function approve(address spender, uint256 id, uint256 amount) public returns (bool) {
    allowance[msg.sender][spender][id] = amount;
    emit Approval(msg.sender, spender, id, amount);
    return true;
}

Переменная spender в approve - это учетная запись, уполномоченная переводить определенные суммы определенного id токена от имени владельца. Например, владелец может разрешить spender переводить <= 100 единиц определенного ID токена. Кроме того, он может дать бесконечное разрешение на перевод определенного id токена, установив разрешение на type(uint256).max. В ERC-6909 не указано, должны ли вычитаться надбавки, установленные в type(uint256).max, или нет. Это поведение оставлено на усмотрение исполнителя, аналогично ERC-20. Основные структуры данных Реализации ERC-6909 используют три маппинга для обновления состояния остатков на счетах и разрешений. 1. balanceOf: Баланс владельца id Маппинг balanceOf отслеживает баланс определенного ID токена, принадлежащего определенному адресу (владельцу). Структура owner => (id => amount) в связке указывает на то, что один владелец может владеть несколькими токенами и отслеживать их баланс по соответствующим ID.

mapping(address owner => mapping(uint256 id => uint256 amount)) public balanceOf;

2. allowance: Разрешение на передачу токена Маппинг allowance определяет, какое количество конкретного токена (ID) может передать spender от имени владельца. Это облегчает тонкий контроль над расходованием токенов.

mapping(address owner => mapping(address spender => mapping(uint256 id => uint256 amount))) public allowance;

3. isOperator: Статус утверждения оператора

mapping(address owner => mapping(address operator => bool isOperator)) public isOperator;

Этот маппинг отслеживает, был ли spender утвержден в качестве оператора для всех токенов, принадлежащих адресу. Например, isOperator[0x123...][0xABC...] возвращает true, если адресу 0xABC... разрешено тратить токены, принадлежащие адресу 0x123...; в противном случае возвращается false. Далее разберем функции. #eip6909

- Нет способа выдать разрешение на перевод конкретных идентификаторов токенов или определённых количеств. - Такой "всё или ничего" подход не подходит для сценариев, где требуется гибкое управление разрешениями. Для реализации более тонкого контроля, в ERC-6909 используется гибридная схема разрешений, которая включает: - модель оператора из ERC-1155, - и модель лимитов (allowance), вдохновлённую стандартом ERC-20. Далее продолжим разговор о нюансах данного стандарта. #eip6909

Стандарт ERC-6909 Minimal Multi-Token Standard. Часть 1 Следующий цикл постов я хочу посвятить этому интересному стандарту. ERC-6909 - это оптимизированная альтернатива ERC-1155. Он представляет интерфейс для нескольких токенов, который позволяет одному смарт контракту включать в себя fungible and non-fungible токены (т. е. ERC20 и ERC721). ERC-1155 позволил решить несколько проблем, таких как снижение затрат на развертывание, минимизация избыточного байткода в блокчейне Ethereum и упрощение процедуры утверждения токенов для торговли несколькими токенами. Однако он привел к некоторому раздуванию и газовой неэффективности из-за обязательных callbacks для каждого трансфера, принудительного включения batch transfer и отсутствия тонкого контроля разрешений одного оператора. ERC-6909 устраняет эти недостатки, а как - узнаем дальше. ERC-6909 удаляет требование callbacks Спецификация ERC-1155 требует, чтобы функции safeTransferFrom и safeBatchTransferFrom проверяли, является ли получатель контрактом. Если это так, то они ОБЯЗАТЕЛЬНО должны вызвать функции интерфейса ERC1155TokenReceiver (onERC1155Received, onERC1155BatchReceived) в контракте-получателе, чтобы проверить, принимает ли он переводы. Эти callbacks полезны в некоторых случаях. Однако они становятся ненужными внешними вызовами для получателя, который хочет отказаться от такого поведения. Callbacks влияют на стоимость газа и размер кода контрактов-получателей, поскольку требуют реализации нескольких callback-функций (например, onERC1155Received, onERC1155BatchReceived) и возврата специальных 4-байтовых значений для получения токенов. В отличие от этого, разработчики, реализующие стандарт ERC-6909, могут самостоятельно выбирать архитектуру своих callback-функций. ERC-6909 не включает логику пакетных переводов (batch transfer) Пакетные переводы, несмотря на свою полезность в некоторых случаях, намеренно исключены из стандарта ERC-6909. Это позволяет разработчикам реализовывать логику таких переводов, адаптированную под конкретные среды исполнения. Разработчики могут реализовать переводы любым удобным для них способом и не обязаны добавлять дополнительную функцию переводов только ради соответствия стандарту. Функция safeBatchTransferFrom , показанная ниже, отвечает за выполнение таких переводов в стандарте ERC-1155. Однако её обязательное присутствие увеличивает объём кода у приложений, которым такие функции не нужны:

// ERC-1155
function safeBatchTransferFrom(
    address _from,
    address _to,
    uint256[] calldata _ids,
    uint256[] calldata _values,
    bytes calldata _data
) external;

Ниже представлена функция ERC-6909 transferFrom. Видно, что функция batch и параметр _data были удалены.

// ERC-6909
function transferFrom(
    address sender,
    address receiver,
    uint256 id,
    uint256 amount
) public returns (bool) {
    if (sender != msg.sender && !isOperator[sender][msg.sender]) {
        uint256 senderAllowance = allowance[sender][msg.sender][id];
        if (senderAllowance < amount) revert InsufficientPermission();
        if (senderAllowance != type(uint256).max) {
            allowance[sender][msg.sender][id] = senderAllowance - amount;
        }
    }
    if (balanceOf[sender][id] < amount) revert InsufficientBalance();
    balanceOf[sender][id] -= amount;
    balanceOf[receiver][id] += amount;
    emit Transfer(msg.sender, sender, receiver, id, amount);
    return true;
}

ERC-6909 поддерживает как глобальные разрешения, так и детализированные лимиты

// in ERC-1155 →
function setApprovalForAll(
    address _operator,
    bool _approved
) external;

Функция setApprovalForAll , показанная выше, реализует модель глобального оператора из стандарта ERC-1155. Она позволяет одному аккаунту авторизовать другой аккаунт для управления (в качестве оператора) всеми идентификаторами токенов от его имени. После авторизации оператор получает неограниченный доступ к переводу любых количеств любых токенов, принадлежащих авторизующему аккаунту. Хотя этот подход упрощает делегирование прав, он не предоставляет возможности точного контроля:

Упрощение сети Эфириум Месяц назад сохранил в закладки для себя статью от Виталика Бутерина и только сейчас дошел до нее. В целом, очень идеи и предположения. Может некоторые из них и будут внедрены в сеть... О чем же сама статья? Виталик предлагает радикально упростить протокол Ethereum, стремясь приблизить его по простоте к Bitcoin. Он утверждает, что чрезмерная сложность текущей архитектуры Ethereum затрудняет развитие, увеличивает риски и препятствует участию новых разработчиков. В отличие от этого, простота Bitcoin делает его более устойчивым и понятным даже для начинающих программистов. Одним из ключевых предложений является внедрение модели консенсуса с трёхслотовой финализацией, которая заменит текущую сложную систему слотов, эпох и комитетов. Эта модель может быть реализована в около 200 строках кода и обеспечивает почти оптимальные свойства безопасности. Уменьшение числа активных валидаторов одновременно упрощает реализацию правил выбора форка и повышает надёжность сети. В области исполнения Бутерин предлагает заменить Ethereum Virtual Machine (EVM) на виртуальную машину, основанную на архитектуре RISC-V. Это позволит значительно упростить протокол и улучшить производительность, особенно в контексте zero-knowledge доказательств. Для обеспечения обратной совместимости предлагается запускать существующие контракты EVM через интерпретатор на новой виртуальной машине. Также предлагается стандартизация протокола, включая использование единых форматов сериализации и структуры данных, таких как SSZ и унифицированные Merkle-деревья. Это позволит улучшить инструментарий, системы доказательств и повторное использование кода, а также упростит разработку и поддержку протокола. Бутерин подчёркивает, что простота протокола способствует его устойчивости, снижает вероятность критических ошибок и уменьшает социальную поверхность атаки. Он признаёт, что предыдущие решения, включая его собственные, способствовали излишней сложности и рискам безопасности, и призывает к переосмыслению архитектуры Ethereum с акцентом на простоту и прозрачность. Предложенные изменения представляют собой долгосрочную стратегию, направленную на повышение устойчивости и масштабируемости Ethereum. Хотя реализация этих изменений потребует значительных усилий и может вызвать временные трудности, Бутерин уверен, что в долгосрочной перспективе они принесут значительные преимущества для всей экосистемы Ethereum. #ethereum

Проект на виду. Часть 6. Нейронки не доступны Сегодня хочу отвлечься от темы EIP-7702 и снова поговорить о нейронных сетях, AI, агентах и том, как они будут заменять программистов... Понемногу каждый день я продолжаю изучать модели, обучение нейронок и как это может быть полезно в моей работе. И с каждым днем я прихожу к мысли, что полноценные нейронные сети одновременно и доступны и недостижимы для простых людей. Да, мы в любой момент можем зайти в DeepSeek, GTP, Grok - написать хороший промт и получить прекрасный результат. Claude и Gemini все лучше пишут код, и казалось бы от оно счастье... Пока вы не задумаете попробовать самому выбрать локальную нейронку для своих задач и попробовать обучить ее. Тут начинаются проблемы, а именно загвоздка в мощностях. Для работы маломальски нормальной нейронки, не обрезанной\облегченной\нишевой, вам потребуется мощная видеокарта уровня 3090, а лучше 4090, и процессор минимум i7. И это будет "в целом ок" для моделей среднего уровня на 13-15 млрд параметров. А более хорошие модели на 32-36 млрд потребуют мощностей куда выше обозначенных. Кроме того, современные модели, например тот же DeepSeek может затянуть на 200 +млрд параметров и вообще запредельных мощностей, которые просто не организовать в домашних условиях. И, если я правильно понял, то такие мощности требуются только для комфортной работы модели, а для ее переобучения нужно больше... К чему я веду? Нейронки (DeepSeek, chatGPT, etc) обучаются на огромных массивах данных, включая все языки, всю документацию, все примеры кода и т.д. Нет четкого фокуса - главное быть лучше и функциональнее конкурента. У разработчиков этих моделей нет задачи сделать их мастерами в React, Solidity или Python. Отсюда у нас идет хороший, но порой "не тот" код. А дообучить\переобучить нейронку для определенного языка - у обычных пользователей нет ресурсов. Вот и получается, что сейчас возможен период, когда компании будут формировать свои ресурсы вокруг опенсорсных моделей, нишево дообучать их для определенной цели и продавать доступ по подписке. В ближайшие лет 5 текущие нейронки выйдут на хороший уровень по коду, но появится много надстроек, которые будут продавать фокусные решения. И пользователи будут платить за модель, которая отлично пишет код Solidity с акцентом на безопасности, чем брать просто хорошие основные сети для "всего". Вот такой пятничный поток мыслей. А вы что думаете по этому поводу? #offtop