1inch запускает Aqua — леер унифицированной ликвидности🏌

Перед тем как выложу обещанную (да-да, очень скоро) статью про стейблы — давайте глянем, что там интересного у 1inch.

1inch выкатывают Aqua — штуку, которая по сути унифицирует ликвидность между разными yield-инструментами, то есть теперь одна и та же ликвидность может работать сразу в нескольких yield стратегиях, повышая эффективность единицы капитала (ровно про это я уже писал в одной из прошлых моих статей)

Чтобы всё это не осталось просто идеей, они собрали:
— тулкит для билдеров (логично — кто-то же должен будет строить yield-инструменты внутри Aqua)
— инцентив программу с приятными бонусами в долларах, если сделать что-то реально годное

Пока остаются открытыми вопросы каскадов, пермишенов на ликвидность внутри каждой стратегии и тд, но скоро всё узнаем — уверен, что у 1inch всё продумано, буду следить за развитием и давать вам апдейты

А пока, вот тут все ссылки для ознакомления
https://1inch.com/aqua
https://x.com/1inch/status/1990389518797557845?s=20

📟 Прилетело из @ortomich_main

gm! В продолжение прошлой темы давайте ретроспективно посмотрим, что вообще происходит в текущей DeFi-мете

С одной стороны — синтетические стейблы с доходностью и непрозрачным коллатералом.

С другой — волты, которые гонят APR за счёт лупинга и заливки ликвы в те самые high risk стейблы.

Кураторы при этом одни и те же, и рассчитывать на «справедливое» разруливание вроде кейса Re7 x MEV Capital, как мы уже увидели, особо не приходится.

При этом главная метрика DeFi-проектов до сих пор — TVL.
Но полноценно использовать этот TVL получается далеко не всегда: в отчётах Ethena хорошо видно, какая часть долларов реально задействована в стратегиях, а какая просто лежит idle. Тем же страдают и AMM-протоколы.

---

Кажется, 1inch решили предложить новую метрику — Total Unlocked Value.
В DeFi-конструкторе появляется новый слой shared liquidity: управляющие капиталом используют его атомарно для исполнения стратегий, а в остальное время средства остаются у пользователей под общим ончейн-учётом.

Ключевая идея Аквы достаточно простая: капитал остаётся в кошельках LP/мейкеров, а не в пуле.
Протокол ведёт виртуальные балансы maker → app → strategy → token, один и тот же капитал может одновременно бэкапить несколько стратегий.

То есть Aqua смещает фокус с «где выше APR и больше TVL» на вопрос «какие стратегии эффективнее используют один и тот же капитал по времени».

Из последнего интервью cp0x с Никитой Овчинниковым мы узнали, что солверы начинают захватывать рынок DEX-ов: у них банально лучше capital efficiency. Сейчас у каждого солвера свой оффчейн-слой управления балансами, и основная прибыль остаётся у них (пользователь видит только чуть более выгодный своп).

Aqua предлагает вынести этот shared-liquidity-слой ончейн и открыть к нему доступ внешним пользователям и LP. Для солверов и маркетмейкеров это потенциальный общий стандарт управления балансами, для девов — новый базовый слой, поверх которого можно строить волты, AMM/PMM и свои RFQ-решения.

---

Будет очень интересно посмотреть, как это поедет, но ощущение такое, что это как раз тот кусок паззла, которого не хватало последние полтора года: новые примитивы в DeFi. Тот же вайб я чувствую от yieldbasis, несмотря на плохой перфоманс rn

Кому интересно покопаться глубже — тут деврелиз и ссылки на SDK / WhitePaper / App Release (1инч, если вы читаете мой канал, вы забыли опубликовать репозиторий, хотя ссылка на него приведена в доке):

https://1inch.com/aqua

📟 Прилетело из @insuline_eth

Запись главных моментов урока - всё про переход на новую версию и написание тестов на Hardhat 3 https://www.youtube.com/watch?v=0BNeWYQk8F0

📟 Прилетело из @dev_in_ruby_colors

RUG RAG

Первой практической штукой, которую мы сделаем, будет RAG система

RAG (Retrieval-Augmented Generation) – это подход, при котором искусственный интеллект сначала находит нужную информацию в базе данных или документах (retrieval), а затем использует её для генерации ответа (generation).

Простыми словами, это способ “научить” модель отвечать с опорой на реальные данные, а не только на то, что она запомнила при обучении.

RAG-системы применяются в чат-ботах, справочных ассистентах и корпоративных поисках — чтобы AI давал точные, актуальные и обоснованные ответы, цитируя источник, а не "выдумывал" их.

Чтобы перейти к практике, нам в любом случае придётся разобраться с тем что такое: AI модель, в чем разница между AI моделью и нейросетью и понять понять какие вообще бывают модели. Всё это я расписал в конспекте, который прикрепляю снизу

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

Читать: AI модели для чайников


SemolinaCode | Chat | YouTube | HowToCode | Prop

📟 Прилетело из @semolina_code_python

Прототип дизайна страницы падения Cloudflare

📟 Прилетело из @danokhlopkov

Погружение в Core Solidity. Часть 2

Алгебраические типы данных и сопоставление с образцом

Алгебраические типы данных (ADT, Algebraic Data Types) предоставляют принципиальную основу для моделирования данных за счёт комбинирования суммарных (sum) и произведённых (product) типов. Суммарные типы являются расширением перечислений (enums) из классического Solidity. Они представляют исключающие друг друга варианты: значение принадлежит ровно одному из возможных вариантов. Произведённые типы объединяют несколько значений в структурированные кортежи. На основе этих двух примитивов можно конструировать точные типы, делающие недопустимые состояния полностью невозможными для представления, что позволяет системе типов обеспечивать соблюдение инвариантов полностью на этапе компиляции.

Начнём с очень простого типа:

data Bool = True | False

Левая часть приведённого выше выражения определяет имя нового типа (Bool), а правая часть задаёт множество значений, составляющих тип Bool (True или False).

С помощью ADT также можно реализовать те же самые паттерны, что и пользовательские типы-значения (User Defined Value Types) в классическом Solidity. Например, значение с фиксированной точкой и 18 знаками после запятой («wad») можно представить следующим образом:

data wad = wad(uint256)

Тип wad (слева) имеет единственный конструктор значений wad (справа), который хранит значение типа uint256 в качестве своего внутреннего представления. Имена типов и конструкторы значений находятся в отдельных пространствах имён, поэтому могут совпадать. Простые обёрточные типы подобного рода будут полностью удалены компилятором при трансляции в Yul, то есть тип wad будет иметь точно такое же представление во время выполнения, как и uint256.

Теперь можно определить процедуру умножения чисел с фиксированной точкой с проверкой типов. Для этого потребуется извлечь внутреннее значение uint256, произвести над ним необходимые операции и обернуть результат в новый конструктор wad. Для распаковки воспользуемся сопоставлением с образцом (pattern matching). Сопоставление с образцом — это механизм управления потоком выполнения, позволяющий деконструировать и анализировать данные по их структуре. Вместо громоздких цепочек if-else можно писать декларативные выражения, полностью перебирающие все возможные значения проверяемого типа.

let WAD = 10 ** 18;

function wmul(lhs : wad, rhs : wad) -> wad {
    match (lhs, rhs) {
    | (wad(l), wad(r)) => return wad((l * r) / WAD);
    }
}

Тип AuctionState, ниже, имеет четыре альтернативных конструктора значений:

- NotStarted указывает, что аукцион ещё не начался, и хранит резервную цену;
- Active означает, что аукцион идёт, и хранит текущую максимальную ставку и адрес того, кто её сделал;
- Ended представляет успешно завершившийся аукцион с максимальной ставкой и адресом победителя;
- Cancelled описывает отменённый аукцион и хранит максимальную ставку и адрес предполагаемого победителя на момент отмены.

Теперь можно определить функцию processAuction, которая изменяет состояние аукциона в зависимости от текущего состояния и значения msg.value. Выражение match позволяет выполнить исчерпывающий разбор всех возможных состояний. Случай _ в конце конструкции match является обработчиком по умолчанию для всех оставшихся состояний, которые явно не были перечислены. Компилятор гарантирует полноту такого разбора, требуя, чтобы каждое возможное состояние обрабатывалось ровно один раз.

function processAuction(state: AuctionState) -> AuctionState {
    match state {
    | NotStarted(reserve) =>
        require(msg.value >= reserve);
        return Active(msg.value, msg.sender);
    | Active(currentBid, bidder) =>
        require(msg.value > currentBid);
        transferFunds(bidder, currentBid);
        return Active(msg.value, msg.sender);
    | _ => return state;
    }
}

#core

📟 Прилетело из @solidityset

Запуск AI-моделей локально

Просто для понимания: ChatGPT 5, Gemini 3, Grok 3 и т. д. – это самые популярные AI-модели от крупных компаний

Но на самом деле этих моделей огромное количество. Только в открытом доступе на Hugging Face находится более 2.2 млн моделей под разные задачи (каждую из которых можно скачать и запустить у себя локально – если, конечно, хватит железа)

Один из самых простых способов запустить модель локально – использовать DMR (Docker Model Runner)
Если вы впервые слышите слово "Docker", ничего страшного. Чтобы скачать и запустить модель, вам не придётся писать код или вводить команды, так как у DMR есть понятный пользовательский интерфейс (см. скрин).

Без лишних слов – всё описал в конспекте:

Читать: DMR: запуск AI-моделей локально

P.S. А вообще, на канале есть урок про основы Docker и docker-compose для кодеров

SemolinaCode | Chat | YouTube | HowToCode | Prop

📟 Прилетело из @semolina_code_python

В продаже появился софт по Outlook'y

- Вход на реальных запросах с браузера.
- Привязка резервной почты с подтверждением.
- Смена пароля.
- Генер рефреш токена
- Генер резервных кодов для входа

Софт фулл на запросах . Outlook удаляет почты в которые не заходили 2+года

За покупкой в лс .

📟 Прилетело из @steamner

Погружение в Core Solidity. Часть 3

Обобщения и классы типов

Core Solidity вводит два новых механизма для повторного использования кода и полиморфизма: обобщения (generics) и классы типов (иногда также называемые трейтами, traits).

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

forall T . function identity(x : T) -> T {
    return x;
}

Здесь forall вводит новую переменную-тип T, область видимости которой ограничена определением функции.

Можно также определять обобщённые типы. Например, следующий тип Result, параметризованный типом полезной нагрузки в случае ошибки:

data Result(T) = Ok | Err(T)

Обобщения весьма мощны, но сами по себе довольно ограничены. Большинство интересных операций не определены для всех типов вообще. Классы типов решают эту проблему: они позволяют задавать перегруженные, специфичные для каждого типа реализации одной и той же сигнатуры функции. В сочетании с ограничениями классов типов они предоставляют возможность писать обобщённые функции, полиморфные лишь над ограниченным подмножеством типов.

Класс типов — это просто спецификация интерфейса. Рассмотрим, например, определение класса типов, которые поддерживают операцию умножения:

forall T . class T:Mul {
    function mul(lhs : T, rhs : T) -> T;
}

Вместо конкретной функции wmul, которую мы определили выше для нашего типа wad с фиксированной точкой, более идиоматично создать экземпляр (в терминологии Rust — impl) класса типов Mul для wad. Это даёт единообразный синтаксис умножения для всех типов и позволяет использовать wad в функциях, обобщённых над любыми типами, реализующими Mul:

instance wad:Mul {
    function mul(lhs : wad, rhs : wad) -> wad {
        return wmul(lhs, rhs);
    }
}

Если мы хотим написать функцию, принимающую любой тип, для которого определён экземпляр Mul, необходимо добавить ограничение в сигнатуру:

forall T . T:Mul => function square(val : T) -> T {
    return Mul.mul(val, val);
}

Простые обёрточные типы вроде wad встречаются очень часто. Один из особенно полезных классов типов при работе с ними — Typedef:

forall T U . class T:Typedef(U) {
    function abs(x : U) -> T;
    function rep(x : T) -> U;
}

Функции abs (абстрагирование) и rep (представление) позволяют единообразно преобразовывать обёрточные типы во внутренние и наоборот, избегая синтаксического шума, связанного с необходимостью использовать сопоставление с образцом каждый раз при распаковке значения. Экземпляр для wad выглядел бы так:

instance wad:Typedef(uint256) {
    function abs(u : uint256) -> wad {
        return wad(u);
    }

    function rep(x : wad) -> uint256 {
        match x {
        | wad(u) => return u;
        }
    }
}

Обратите внимание: параметры, следующие после имени класса (например, U в определении Typedef выше), являются «слабыми» — их значение однозначно определяется значением параметра T. Если вы знакомы с Haskell или Rust, то это по сути ассоциированный тип (associated type) (хотя, для тех, кто разбирается в системах типов, реализовано это с помощью ограниченной формы функциональных зависимостей). Проще говоря, для wad можно определить только один экземпляр Typedef: компилятор не разрешит одновременно объявить и wad:Typedef(uint256), и wad:Typedef(uint128). Это ограничение делает вывод типов значительно более предсказуемым и надёжным, избегая многих неоднозначностей, присущих полноценным многопараметрическим классам типов.

📟 Прилетело из @solidityset

В качестве реального примера того, как обобщения и ограничения через классы типов помогают устранить шаблонный и повторяющийся код, сравним комбинаторный взрыв перегрузок, необходимых для реализации console.log в библиотеке forge-std, с одной обобщённой функцией в Core Solidity, которая покрывает функциональность всех перегрузок с одним аргументом из оригинальной библиотеки. Слово word в этой реализации обозначает низкоуровневый тип, представляющий переменную на языке Yul, и является единственным типом, который можно передавать в блоки assembly и получать из них.

forall T . T:ABIEncode => function log(val : T) {
    let CONSOLE_ADDRESS : word = 0x000000000000000000636F6e736F6c652e6c6f67;
    let payload = abi_encode(val);

    // извлекаем внутреннее представление payload как word
    let ptr = Typedef.rep(payload);

    assembly {
        pop(
            staticcall(
                gas(),
                CONSOLE_ADDRESS,
                add(ptr, 32),
                mload(ptr),
                0,
                0
            )
        )
    }
}

Подобно Rust и Lean, все вызовы классов типов и обобщённых функций полностью мономорфизируются (monomorphized) на этапе компиляции. Это означает, что полиморфные функции не несут накладных расходов во время выполнения по сравнению с полностью конкретизированными функциями. Хотя это действительно приводит к тому, что скомпилированный код для EVM может содержать несколько специализированных версий одной и той же обобщённой функции, это не увеличивает размер бинарного файла по сравнению с классическим Solidity, где для получения эквивалентной функциональности в любом случае потребовалось бы определять несколько отдельных функций. Мы считаем такой компромисс полностью оправданным для нашей предметной области.

#core

📟 Прилетело из @solidityset

Запуск AI-моделей локально (способ 2)

Запускать ai модели ещё можно через ollama

Функции почти те же, что и у Docker:
– есть GUI
– устанавливается одной командой
– есть hub моделей
– гибкие настройки
– поддержка openai api
– есть возможность запуска моделей с Hugging Face (в формате GGUF)
– большое комьюнити

Читать: Запуск моделей локально через Ollama

SemolinaCode | Chat | YouTube | HowToCode | Prop

📟 Прилетело из @semolina_code_python

Open Academy, самая крупная биржа Binance и их совместный курс по фьючерсам!

Как принять участие, заработать $15 в BNB, доход от рефералов и получить сертификат.

Что мне понравилось:

1. Можно указать свою рефку на Бинансе прямо в курсе и приглашать рефералов в Open Academy. А те, регистрируясь в Binance, станут вашими рефералами и там.
Это даст доп. доход в случае их торговли.

2. Также вы сможете получить 15 $ в $BNB, завершив изучение курса с квестами до 27 ноября 19:00 по МСК.
Важное условие: нужен торговый объём в размере "$1000" на Binance Futures.

Проходите всего 10 уроков длительностью от 2 до 4 минут, и вы сможете получить бонусы + сертификат!

Изучать

P. S. Если вы в РФ, KYC (проверку личности) можно пройти только на загран-паспорт и выписку из банка с подтверждением адреса.

😎 Незрячий web3 программист (подписаться)
Чат | бот

📟 Прилетело из @blind_dev

Open Academy, самая крупная биржа Binance и их совместный курс по фьючерсам!

Как принять участие, заработать $15 в BNB, доход от рефералов и получить сертификат.

Что мне понравилось:

1. Можно указать свою рефку на Бинансе прямо в курсе и приглашать рефералов в Open Academy. А те, регистрируясь в Binance, станут вашими рефералами и там.
Это даст доп. доход в случае их торговли.

2. Также вы сможете получить 15 $ в $BNB, завершив изучение курса с квестами до 27 ноября 19:00 по МСК.
Важное условие: нужен торговый объём в размере "$1000" на Binance Futures.

Проходите всего 10 уроков длительностью от 2 до 4 минут, и вы сможете получить бонусы + сертификат!

Изучать

P. S. Если вы в РФ, KYC (проверку личности) можно пройти только на загран-паспорт и выписку из банка с подтверждением адреса.

😎 Незрячий web3 программист (подписаться)
Чат | бот

📟 Прилетело из @blind_dev