Chpotl | dev

The Graph: великий, но не такой уж и ужасный

2024-07-19T18:04:59.296Z

Всем привет! В этой статье мы рассмотрим The Graph, зачем он нужен и как у блокчейна может быть API.

Введение

Давайте представим, что мы делаем приложение, которое будет считать объем торгов на Uniswap за последний месяц.

Uniswap это и без нас делает вот тут, используя The Graph, но опустим этот момент.

Так вот, встает вопрос: как же это сделать?

Способ №1

Давайте напишем простой скрипт, который будет с какой-то периодичностью получать текущий номер блока и искать ивенты “Swap” на заранее заданном контракте пула.

Вот примерный псевдо-код:

У этого подхода есть минусы:

RPC: они имеют свойство ломаться, и мы рискуем пропустить несколько блоков, тем самым на выходе получить некорректные данные.
Масштабируемость: когда мы захотим отслеживать не только один пул, а все возможные новые, то тут придется заморочиться.
Архитектура: вставлять модуль, который как-то циклично собирает данные в основное приложение, не очень хорошая идея, нужно его куда-то выносить.

Подход 2

Делать как Aerofrome/Velodrome - свой отдельный контракт с аналитикой.

Вот тут можно посмотреть код: https://github.com/aerodrome-finance/sugar

Вызвав метод epochLatest, мы можем получить данные по последней эпохе или получить данные по каждой эпохе для пула, вызывая epochByAddress.

Минусы:

Сложно.
Дорого.
Не все данные можно собрать.

Таким образом, мы плавно переходим к The Graph.

Subgrpaph

The Graph - это протокол, который включает в себя такие сущности, как сабграфы (subgraph).

Каждый сабграф представляет из себя набор логики, позволяющий обрабатывать набор контрактов.

Если приводить очень простой пример

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

В этом примере библиотека - это блокчейн, а библиотекари - это сабграфы.

Каждый сабграф отслеживает emit событий на контрактах и сохраняет их в свою внутреннюю базу данных, чтобы потом любое приложение могло получить данные о свапах, транзакциях пользователя или еще о каких-либо действиях, произошедших в контрактах, используя GraphQL.

Важно понимать, что сабграф - это больше data layer, чем полноценный бэкенд.

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

Создание сабграфа

Чтобы развернуть свой сабграф, вам необходимо сделать следующие вещи:

Создать обработчики событий, используя AssemblyScript (TypeScript, но с определенными ограничениями).
Задеплоить код в Subgraph Studio - это среда (по сути staging environment) для тестирования и отладки работы сабграфа.
Опубликовать в Subgraph Network, для этого необходимо ~3000 GRT, которые вы залочите, но в любой момент сможете вытащить.

YAML

Первым компонентом необходимо создать .yaml файл, где будет указано, какие события, как часто мы “слушаем”, и какую логику мы хотим с ними сделать.

В качестве примера я взял код PancakeSwap: GitHub PancakeSwap.

Schema

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

Handler

Далее нам необходимо создать обработчик, который будет сохранять события в базу данных.

Указанных выше компонентов нам будет достаточно, чтобы создать полностью рабочий сабграф.

Все остальные шаги в полной мере описывает документация: https://thegraph.com/docs/en/.

Рекомендую читать английскую версию, так как в русской есть места, которые еще не переведены.

Делитесь с друзьями, если статья была полезной 😘

Спасибо за прочтение!

Мой телеграм - https://t.me/chpotldev

Дельта-нейтральные стратегии: просто о сложном

2024-07-01T20:47:29.242Z

Всем привет! В этой статье я расскажу, что такое дельта-нейтральные стратегии и как можно получать доходность на волатильных активах, не теряя при этом на изменении курса.

Хэджирование

Перед тем, как мы перейдем к самому принципу работы дельта-нейтральных стратегий, нам необходимо познакомиться с таким понятием, как хеджирование.

Вот как википедия объясняет этот термин:

Хеджи́рование (от англ. hedge — ограда, изгородь) — открытие сделок на одном рынке для компенсации воздействия ценовых рисков равной, но противоположной позиции на другом рынке.

Чтобы было понятнее, давайте разберем на примерах:

Представим ситуацию: вы хотите участвовать в акции от биржи, где нужно залочить 3,5 ETH на 3 дня. Но эфир это волатильный актив, и за эти 3 дня цена может сильно упасть, и вы потеряете больше, чем заработаете.

Пример акции

Как же нам купить эфириум и одновременно застраховать себя от потери в случае падении цены?

Все достаточно просто!

Нам необходимо открыть 2 противоположные позиции одну в лонг, а вторую в шорт.

Предположим у нас есть 10'000 USDT, мы хотим хэджировать 1 ETH.

Для этого нам необходимо одновременно обменять половину USDT на ETH (предположим, курс 1 ETH = 5’000 USDT, это можно сделать на любой бирже), а также открыть шорт на 5’000 USDT по эфириуму.

Давайте посмотрим, как будет вести себя общая стоимость наших активов в пересчете на USDT, если 1 ETH подешевеет на 40% и будет стоить 3’000 USDT.

Как мы можем заметить, две позиции скомпенсировали друг друга, мы ничего не потеряли, и у нас на кошельке остался 1 ETH.

В случае если 1 ETH подорожает на 40% и будет стоить 7'000 USDT, то мы ничего не заработаем

Таким образом можно заметить, что при любом движении цены мы можем продать 1 ETH и закрыть шорт, и в итоге на балансе мы снова увидим 10’000 USDT.
А пока у нас открыты две противоположные позиции, мы можем делать с нашим эфиром что захотим, не боясь потерять на курсе.

ВАЖНО: этот пример не учитывает риск ликвидации и фандинг рейт, возможность маржинальной торговли и тп.

Дельта-нейтральные стратегии

В примере про хеджирование мы рассмотрели, как можно защитить волатильный актив от движения цены.

Давайте теперь разберемся, что такое дельта-нейтральные стратегии и какие они бывают.

Существует два основных вида дельта-нейтралных стратегий:

Long-short - стратегии, где хэджирование происходит, через фьючерсы
Lend-borrow - стратегии, где хэджирование происходит, через займ

Long-short стратегии

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

Чтобы получать доход на long-short стратегиях, нам нужно:

Вводные данные: мы имеем на балансе 12'000 USDT и хотим фармить, используя эфириум в нашей стратегии.

1 ETH = 4'000 USDT (для примера).

Мы берем наш депозит в стейблах и делим на 3 части (4'000/4'000/4'000);
Первую часть временно откладываем в сторону, а используя две другие части, открываем равные противоположные позиции: лонг (покупаем 1 ETH на любом DEX/CEX) и шорт (открываем sell ордер на бирже или на децентрализованных фьючерсах). Иными словами, мы хеджируем 1 ETH, который мы купили;
Теперь мы имеем 1 ETH и 4'000 USDT на балансе + открытый шорт;
С нашим 1 ETH мы теперь можем делать что угодно, положить в lido, или взять оба актива и положить в пул.

Defilama предоставляет список возможных стратегий в своем интерфейсе

Lend-borrow стратегии

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

Давайте разберемся, откуда тут доходность и почему мы нейтральны.

Сразу уточню: эти стратегии по факту нельзя назвать 100% дельта-нейтральными, дальше объясню почему.

Как мы видим на примере выше, мы положили 5454 USDT в качестве обеспечения, под них взяли 0,9 ETH, и положили все под 10% в пул.

Суммарная доходность: 8%, так как мы получаем 3% APY, за то что дали свои деньги в пользование, платим -5% APY за кредит, и получаем 10% APY с комиссий + наград в пуле. Итого: 8%, если все сложить.

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

Если цена эфириума упадет на -40%, то мы окажемся в плюсе, так как сможем занять еще больше средств или вынуть из пула и погасить часть долга.

Давайте посмотрим, как изменится наша позиция после ребалансировки.

Теперь мы можем получать большую доходность, не изменяя изначальное количество вложенных средств.

Рассмотрим пример, когда цена растет. Тут уже возникает ситуация, когда нам надо компенсировать убытки.

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

Вот так будет выглядеть наша позиция после балансировки:

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

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

Делитесь с друзьями, если статья была полезной 😘

Спасибо за прочтение!

Мой телеграм - https://t.me/chpotldev

Curve StableSwap введение

2024-04-26T12:04:21.827Z

Всех приветствую! В этой стате я расскажу как работают пулы curve.fi, и почему это произвело революцию в мире defi.

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

Немного о Curve

Основная цель curve.fi - это предоставление возможности обмена стейблкоинов с низким проскальзыванием (далее подробнее разберем, что это такое).

Начнем по порядку разбираться, как устроены АММ алогоритмы.

Uniswap AMM

Каждый, кто хоть немного углублялся в defi встречал формулу .

x*y=k

Это упрощенное представление алгоритма, который лежит в основе Uniswap.

Это формула означает, что отношение активов (токенов) в пуле - это неизменное значение.

Пример:

Представим, что у нас есть пул USDT/ETH, и в пуле лежит 40000 USDT (это X) и 10 ETH (это Y), таким образом 40000*10=400’000 (это K).

Теперь к нам пришел условный Вася и хочет обменять свои 4000 USDT на ETH.

Давайте посчитаем как изменится количество токенов в пуле, используя нашу формулу.

После того как Вася внес 4000 USDT, в пуле стало 44000 USDT (там еще Uniswap забирает комиссию 0.3%, но мы опустим это).

Теперь на надо посчитать сколько ETH нужно отдать Васе.

Составим простое уравнение за средней школы:

44000 (наш Х) * y = 400000 (наш К)

Теперь нам надо найти сколько ETH должно быть в пуле, чтобы уравнение сошлось. Разделим обе части на 44000 (то есть X) и получим y=400000/44000. Таким образом y=9.09
Mы получили количество ETH, которое ДОЛЖНО БЫТЬ В ПУЛЕ. Теперь надо разницу отдать Васе. 10ETH - 9.09ETH = 0.91 ETH (куда делось 0.09 ETH???, читать продолжение…)

Автоматическая установка цены

Как мы могли заметить, когда Вася внес 4000 USDT, цена автоматически изменилась.

Теперь 1 ETH стоит Y/X, то есть 44000/9.09=4840 USDT.

Давайте рассмотрим, что произойдет, когда Вася захочет еще раз обменять 4000 USDT.

Произведем еще раз все вычисления:

(44000 + 4000) * y = 400000

Y = 8.33

Таким образом в пуле станет 48000 USDT, 8,33 ETH

И 1 ETH будет стоить 5762 USDT

Как мы увидели на двух примерах, при росте спроса на один из активов, цена второго автоматики изменяется. Потому это и называется AMM (автоматический маркет мейкер).

извиняюсь за качество

Красный график показывает количество токенов в пуле

Синий график (производная от x*y) показывает цену токенов

Проскальзывание

Проскальзывание - это величина, которая показывает насколько изменится цена, после того как покупатель, Вася в нашем случае, захочет обменять средства. Если говорить максимально просто, то это то насколько меньше вы получите по факту сделки.

В первом примере мы увидели, что изначально 1 ETH стоил 4000 USDT, но по факту Вася купил по цене 4395 USDT (4000/0.91)

От чего зависит проскальзывание?

Ответ: от ликвидности (количества токенов в пуле)

Разберемся почему:

Формула для расчета проскальзывания выглядит так:

Чтобы проще понять, как работает эта формула рассмотрим два случая

Если мы захотим купить небольшое количество токенов, то δ (сколько мы купим) будет сильно меньше X (сколько в пуле) (δ << X, это для гиков выражение), и получился S = 1 - (очень близкое к 1 число), то есть проскальзываете будет стремиться к 0.
Для пула, где очень много токенов X будет стремиться к бесконечности, таким образом проскальзывание тоже будет стремиться к 0.

Предположим у нас есть пул, где:

1'000'000 токенов X

5'000'000 токенов Y

K = 5 * 10^12

Рассмотрим два примера, как менялась цена (изначальная цена была 5 у.е):

Выкупаем один актив

Давайте посмотрим, что произойдет, если кто-то захочет полностью забрать один из активов в пуле.

В нашем воображаемом пуле будет

100 ETH

400'000 USDT

В нашем случае Вася будет покупать по 100 ETH на централизованной бирже и продавать в нашем пуле

Купив 100 ETH за 400000 USDT, он пришел в наш пул и продал 100 ETH

Теперь в пуле

200 ETH

200'000 USDT

Вася потратил 4000$

Если сделать так очень много раз и построить график, то получится вот такая зависимость

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

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

Чем плох Uniswap AMM?

Представим ситуацию, что у нас в пуле лежит не ETH/USDT, а пара стейблкоинов USDT/USDC

Опять рассмотрим пример, где Вася на одну и ту же сумму покупает один из активов.

У нас есть пул:

100'000 USDT

100'000 USDC

Из таблиц видно, что при маленьких суммах разница не очень большая, но когда Вася начинает менять по 10000 USDT, то на 3 сделке он теряет 500$ из-за проскальзывания, хотя меняет доллар на доллар.

Пул без проскальзывания (такое бывает ???)

Давайте представим пул, в котором цена активов будет постоянной, то есть я в любой момент смогу обменять 1000 USDT на 1000 USDC 1:1, звучит как решение для нашей проблемы с обменом стейблкоинов.

Но не так все просто и вот почему...

Если описывать такой пул, то это будет пул с линейной зависимостью (как на алгебре в 9 классе y=kx+b).

Например у нас есть пул, и в нем:

1000 USDC

1000 USDT

Выражение описывающее пул будет следующим:

X + Y = C

X - количество токена #1

Y - количество токена #2

C - сумма токенов

в нашем примере мы получим X + Y = 2000

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

Если к нам придет Вася и захочет внести пул 100 USDC, то путь вычислений будет следующий:

(1000+100) + y = 2000

y = 900

значит Васе надо отправить 1000 - 900 = 100 USDT,

Отлично! Вася только что обменял 100 USDT на 100 USDT, не потеряв ничего из-за проскальзывания, как это было в примере с юнисвапом

Но есть одна проблема

Если Вася продолжит менять USDT на USDT, то в пуле закончатся USDT, а это плохо

Что же делать?

Curve AMM

Curve решил это проблему, создав пул, который объединяет в себе прелести двух подходов, которые мы рассмотрели ранее.

Как же у них это получилось?

Основная задача состояла в том, чтобы создать пул, который будет иметь вид X+Y=C, когда цена будет находиться в районе 1$, и принимать вид X*Y=C, когда цена будет сильно отклоняться

На графике видно, что цена при сильном отклонении от 1$ начинает вести себя как в пуле x*y=c

Чтобы получить такую кривую, нам надо сложить выражение для пула x+y=c и x*y=c

Для этого давайте сначала запишем выражения для обоих пулов в общем виде:

Слева для пула с линейной зависимостью, справа для пула с постоянным произведением.

D - это суммарное количество токенов, при условии, что они имеют одинаковую цену

D = 10M USDT + 10M USDC = 20M (при условии, что USDT = USDC)

Давайте теперь посмотрим, как будет выглядеть наш график, если мы построим его для пула USDC/USDT.

В нашем воображаемом пуле будет:

1'500'000 USDC

1'500'000 USDT

Давайте теперь построим график нашего выражения.
Вот так он будет выглядеть:

https://www.desmos.com/calculator/ripcngywnj

На графике видно, что x+y+x*y несильно отличается от Uniswap AMM, чтобы исправить ситуацию нам нужно, сделать его более "плоским" в зоне, где я обвел черненьким.

Давайте умножим выражение для пула без проскальзывания на какое-то число (chi) и посмотри, что произойдет.

Вот так теперь выглядит наше уравнение (3).
Давайте построим график и поиграемся с ним.

https://www.desmos.com/calculator/8vn3ptit9m

Тут я увеличиваю значение chi, и чем больше оно становиться, тем более "плоский" становиться график.

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

Когда chi увеличивается: уменьшается проскальзывание и график становится похож на x+y (красный график)

Когда chi уменьшается: увеличивается проскальзывание и график становится похож на x*y (синий график)

Как выбрать параметры?

Как же нам понять как выбрать chi? Поскольку мы имеем дело с обменом стейблкоинами, нам нужно, чтобы цена возвращалась к 1, когда в пуле USDT = 15M, USDC = 15M, и вела себя как в Uniswap AMM, когда соотношение токенов в пуле не сбалансировано.

Чтобы добиться такого эффекта, chi должно зависеть от количества токенов х и y в пуле. При несбалансированном (USDT > USDC) количестве токенов в пуле, chi должно уменьшаться, чтобы график принимал вид x*y, а при сбалансированном (USDT = USDC) количестве увеличиваться, чтобы график принял вид x+y.

Также важно, чтобы суммарное количество токенов не влияло на наш параметр.

Давайте просто умножим наше выражения для графика x+y в этот раз уже на D:

Для вычисления chi выберем следующее выражение:

Давайте подставим все, что у нас есть в одно выражение:

А теперь построим график и поиграем со значениями.

https://www.desmos.com/calculator/opzbo93gss

Мы можем заметить, что при изменении параметра А, график становиться плоским

Значение этого параметра определяет Curve DAO, а нам самим его можно посмотреть перейдя в пул на Curve.fi и открыв вкладку "Advanced"

Таким образом мы получили выражение, которое позволит пользователем обменивать стейблкоины с минимальной разницей в цене aka проскальзыванием.

Curve whitepaper - https://docs.curve.fi/assets/pdf/stableswap-paper.pdf

Надеюсь статья была полезной

Спасибо за прочтение!

Мой телеграм - https://t.me/chpotldev

Zero-knowledge proof - простыми словам

2022-10-17T13:44:44.982Z

Всем привет!

В этой статье я простым языком расскажу про zero-knowledge proof (ZKP)

Это продолжение серии статей на пути к ZK-SNARKs и более сложным криптографическим штукам

TL;DR

Сейчас из каждого утюга говорят про ZKP. Появляются какие-то "zk rollup-ы", и у меня такое ощущение, что если ты дописываешь к названию технологии "zk", то можешь поднять любые раунды и встать на ступень выше этих одноклеточных "не zk" проектов. Если говорить серьезно, то данный механизм/протокол на самом деле решает много проблем с приватностью данных и все больше приближает нас к настоящей децентрализации (привет CZ) и анонимности

Что такое zero-knowledge proof?

Zero-knowledge proof или zero-knowledge protocol - это метод, с помощью которого Петя (the prover) может доказать Васе (the verifier), что он знает какую-то информацию X, не раскрывая никакую информацию об этом X

Другими словами, я могу доказать преподавателю, что сделал домашнее задание, не принося его

ZKP должен удовлетворять трем условиям:

Completeness (полнота) - если утверждение истинно, то порядочный проверяющий aka "Вася the verifier" - тот, кто честно следует правилам протокола будет убежден в этом факте порядочным проверяющим
Soundness (надежность) - если утверждение ложно, то нечестный доказывающий aka "Петя the prover" не сможет убедить честного проверяющего в том, что оно истинно, за исключением некоторых случаев возможных с очень малой вероятностью
Zero knowledge (нулевое знание) - если утверждение истинно, то проверяющий aka "Вася the verifier" ничего не узнает, кроме того факта, что утверждение истинно

Доказательство с нулевым знанием - это не совсем доказательство, в том смысле, что вывод о правильности информации X делается на основании факта, что вероятность обмана Пети (the prover) настолько мала, что суждение на 99,9999999999% верно

Возможно не совсем понятно, давайте рассмотрим пример с пещерой Али бабы

Пример с пещерой

Представим ситуацию, у нас есть Петя (the prover), Вася (the verifier) и есть пещера, в которой есть дверь

Пете нужно доказать, что он знает код от двери в этой пещере, не говоря самого кода Васе

Для простоты восприятия

Петя = Prover

Вася = Verifier

Петя первый заходит в пещеру и идет по одному из маршрутов к двери с кодом

Теперь Вася заходит в пещеру и просит Петю выйти со стороны B

Представим случай, что Петя на самом деле не знает код от двери, а пытается обмануть. С вероятностью 50% или 1/2 ему могло повезти, и он случайно выбрал сторону В, и когда Вася попросил его выйти со стороны B, то ему не пришлось проходить через дверь

Давайте проведем этот эксперимент 30 раз

Шанс, что Петя угадал каждый раз (1/2)^30 = 0.000000000931 (тут про это и сказано)

для сравнения шанс разбиться на самолете = 0.000000125

И только в случае, если Петя знает код от двери, он сможет безошибочно 30 раз выйти с нужной стороны и доказать Васе, что он знает код

Пример из Рика и Морти (спойлеры)

Рекомендую ознакомиться с этой серией, если уже смотрели, то момент который я привожу в пример начинается с 4:40

https://rick-i-morty.online/episodes/6sez-5seriya/

Для тех кому лень смотреть, расскажу вкратце сюжет

Джерри (желтая футболка) ест печенье с предсказанием, где написано, что он займется сексом со своей мамой. Рик (синие волосы) не верит этому и решает проверить

Рик кладет в одну коробку бумажку с именем мамы Джерри, перемешивает и просит Джерри сказать, куда бы он засунул свой пэнисс

Каждый раз, когда Джерри отворачивается, Рик меняет коробки местами

Это по сути та же задачка с пещерой

Шанс, что Джерри угадает коробку с каждым разом становиться все меньше, тем самым Рик доказывает, что предсказание было настоящим

Надеюсь статья была полезной

Спасибо за прочтение

Мой телеграм - https://t.me/chpotldev

RSA шифрование

2022-08-27T10:21:55.846Z

Всем привет!

В этой статье я старался рассказать максимально простым языком про то, как устроено RSA шифрование

Хочу сделать серию статей, чтобы плавно подойти к тому, как работают ZK-SNARK штуки

Ссылка на гитхаб с исходным кодом будет в конце статьи

Я буду делать все на js

Почему симметричное шифрование = неудобно?

Существует два вида шифрования: симметричное и ассиметричное

Приведу простой пример симметричного шифрования

Есть такая штука, называется шифр цезаря (любители генопетс оценят)

Чтобы зашифровать сообщение, мы берем слово, в моем случае это будет слово "дверь", какое-то число не больше размера алфавита (например 2), и заменяем каждую букву на ту, которая находится на 2 буквы дальше

д->ё

в->д

е->ж

р->т

ь->ю

Получаем "ёджтю"

Теперь отправляем нашему другу это сообщение, а при встрече говорим, что число на которое надо сдвигать - это 2, он получает сообщение, и расшифровывает, зная размер сдвига

НО!

Представим ситуацию, что у нас 8531 друг, и каждый сейчас в другой стране

Возникнут некоторые проблемы

Почему асимметричное шифрование = круто?

Объясню пример этого метода на картинках

Представим, что у нас есть замок и ключ от него, а у нашего друга есть сообщение которое он хочет передать, мы "открываем" наш замок, ключом, которые есть только у нас

Отправляем открытый замок нашему другу СДЭКом или любым другим способом

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

Мы получаем сообщение с замком и ключом, который есть только у нас, открываем его и видим сообщение

Победа! Теперь нам не нужно встречаться с каждым другом, чтобы передать сообщение

RSA

Алгоритм шифрования RSA основан на 2 вещах:

Произведение двух простых чисел делается просто. Умножить на калькуляторе 5569 и 821 займет меньше 5 секунд, а понять, на какие простые множители раскладывается число, сложно. Какие числа перемножили, чтобы получить 467149?
ОЧЕНЬ большие числа длинной 1024 бита. Если кто-то захочет подобрать значения, то уйдут десятки лет

Принцип работы RSA на пальцах

шаг 1. Случайно генерируем два простых числа prime1 и prime2

шаг 2. Вычисляем const n = prime1 * prime2;

и ϕ const phiN = (prime1 - 1) * (prime2 - 1);

ТУТ можно почитать, что за функция ϕ, и почему ϕ(ab)=ϕ(a)*ϕ(b), но в самом алгоритме это несильно важно

шаг 3. Выбираем значение encyptionKey такое, чтобы оно было меньше phiNи было взаимно простое c phiN НОД(encyptionKey, phiN)==1 - его мы будем использовать для шифрования сообщения

шаг 4. Вычисляем значение decryptionKey - его мы будем использовать для расшифровки сообщения (дальше объясню как его считать)

decryptionKey - он лежит у нас, его никто не знает

encyptionKey - его мы передаем другому пользователю

Все! Больше ничего не нужно, теперь шифруем

USER 1 (он хочет получить сообщение). Передает USER 2 n (шаг 2) и encyptionKey (шаг 3)

USER 2 (он хочет отправить сообщение). Получает n и encyptionKey от USER 1, берет свое сообщение m (делаем из текста число, ТУТ написано, как это делается, я использую упрощенный пример m = 5)

и считает encryptedMessage = m^(encyptionKey) mod n

далее предает encryptedMessage USER 1

USER 1. Получает encryptedMessage возводит в степень decryptionKey и берет остаток от деления на n

другими словами decryptedMessage = encryptedMessage^decryptionKey mod n

Победа! decryptedMessage будет равно сообщению, которое мы передали

Проще всего будет понят суть алгоритма на примере кода

Сначала зададим функцию, чтобы проверять простое число или нет. Тут интересный момент, что цикл идет от 2 до sqrt(num), почему это работает написано ТУТ

function isPrime(num) {
  for (let j = 2, n = Math.sqrt(num); j <= n; j++) {
    if (num % j === 0) {
      return false;
    }
  }
  return num;
}

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

const k = 3;
const prime1 = getPrime(k);
const prime2 = getPrime(k);
const n = prime1 * prime2;

Создадим переменную phiN и encyptionKey(взаимно простое с phiN и n)

const phiN = (prime1 - 1) * (prime2 - 1);
const encyptionKey = getEncryptionKey(phiN, n);

function getEncryptionKey(phiN, N) {
  for (let i = 2; i < phiN; i++) {
    if (gcd(i, phiN) === 1 && gcd(i, N) === 1) {
      return i;
    }
  }
}

Тут я использую функцию gcd или Наибольший Общий Делитель по-русски

Существует алгоритм Евклида для поиска НОД, мы вычитаем из наибольшего числа наименьшее, пока одно из них не станет нулем, значит второе - это НОД

Чтобы ускорить процесс мы можем не вычитать, а брать остатки от деления

В JS это выглядит так:

function gcd(a, b) {
  if (a == 0) return b;
  return gcd(b % a, a);
}

Теперь давайте разберемся, как нам найти decriptionKey, чтобы расшифровать сообщение, которое мы потом получим

Нам нужно найти такое значение d(decriptionKey), что при умножении на e(encryptionKey) и получения остатка от деления на ϕ(phiN) получится 1

Это можно сделать перебором, но если числа большие, то процессору будет больно, поэтому используем расширенный алгоритм Евклида ТУТ про то, как он работает, а ТУТ про реализацию, которая работает, потому что важно, чтобы функция не выдавала отрицательные числа, иначе ничего не получится

Вот код на JS:

const decryptionKey = modInv(encyptionKey, phiN);

function modInv(u, v) {
  let u1 = 1;
  let u3 = u;
  let v1 = 0;
  let v3 = v;
  let iter = 1;
  while (v3 != 0) {
    q = Math.floor(u3 / v3);
    t3 = u3 % v3;
    t1 = u1 + q * v1;
    u1 = v1;
    v1 = t1;
    u3 = v3;
    v3 = t3;
    iter--;
  }
  if (u3 != 1) {
    return 0;
  }
  if (iter < 0) {
    inv = v - u1;
  } else {
    inv = u1;
  }
  return inv;
}

Теперь у нас есть encryptionKey, decryptionKey и n

Отправляем второму пользователю encryptionKey и n

Он берет сообщение m(5) возводит в степень encryptionKey и берет остаток от деления на n

Я использовал ethers.js чтобы работать с BigNumber

const m = 5; //less than n-1
const encryptedMessage = BigNumber.from(m).pow(encyptionKey).mod(n);

И отправляет encryptedMessage обратно нам

а мы берем его сообщение и делам почти тоже самое: возводим в степень decryptionKey и берем остаток от деления на n

const decryptedMessage = encryptedMessage.pow(decryptionKey).mod(n);

Ура! Мы расшифровали сообщение и получили 5

Как и обещал, вот ссылка на гитхаб

https://github.com/chpotl/RSAencryption

Тут все про алгоритмы Евклида

https://www.di-mgt.com.au/euclidean.html#extendedeuclidean

Тут про то, почему RSA работает

https://www.youtube.com/watch?v=wXB-V_Keiu8

Тут про то, как RSA работает

https://www.di-mgt.com.au/rsa_alg.html#note4

Тут про функцию Ейлера (ϕ)

https://cp-algorithms.com/algebra/phi-function.html

Надеюсь статья была полезной

Спасибо за прочтение

Мой телеграм - https://t.me/chpotldev

Быстрые запросы баланса кошелька

2022-07-30T17:59:58.571Z

Всем привет!

В этой статье я расскажу, как узнать баланс кошелька пользователя, почему перебор не работает, и почему 1inch умнички???

Ссылка на гитхаб с исходным кодом будет в конце статьи

Я буду делать все на js

Если вы пользовались DEX обменником 1inch, то наверняка замечали, что баланс каждого ERC20 токена загружается мгновенно

Почему это важно?

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

Иными словами, если у вас есть список из 100 монет, и вы хотите узнать сколько монет держит пользователь, то необходимо сделать 100 запросов в блокчейн

А если их много?

Рассмотрим 3 метода получить количество токенов

Простой перебор (brute force)
Множественный запрос
Запрос с оптимизацией газа

В дальнейших примерах я буду использовать пакет 1inch multicall

Установка:

npm install @1inch/multicall

yarn install @1inch/multicall

ПРОСТОЙ ПЕРЕБОР

Тут достаточно простая логика

Мы берем массив tokens и методом map пробегаем по массиву контрактов токенов

return provider.ethCall(tokenAddress, callData); - возврашает нам количество токенов в hex формате

тут я вывел баланс монет на кошельке xdefi, weth, ARMOR (хз че за токен)

Далее идем на сайт перевода систем счисления и видим, что все сходится (это все в wei, а в эфире это как раз 0,001025eth)

НО!

Если у нас не три токена, а 1009, как у 1inch, то получается вот что

Поясняю, 2,7 секунд на запрос - это очень много для веб приложения

А если вы используете провайдера Alchemy/Infurra, то получите такое

Ребята из 1inch решили эту проблему, и вот как...

МНОЖЕСТВЕННЫЙ ЗАПРОС

В чем суть решения

Мы не отправляем 1009 транзакций в блокчейн, а разбиваем их на группы (chunks)

const params = {
  chunkSize: 100,
  retriesLimit: 3,
  blockNumber: 'latest',
};

В объекте params мы указываем

Количество запросов в одном чанке
Количество попыток на запрос
В каком блоке ищем ответ

Далее вызываем асинхронный метод класса multiCallService

multiCallService.callByChunks(callDatas, params).then((res)=>{//тут логика})

И радуемся огромному массиву с балансами токенов)

НО!

Если вызов этого метода достигнет лимита по газу (даже у функций чтения имеется газлимит) при вызове контракта, то запрос развернут, и вы не получите ответа

Для справки

Изначально в блоке 15 млн газа

Но если спрос высокий, то количество газа увеличивается до 30 млн газа

Транзакцию также развернут, если она занимает очень много времени

Поэтому есть еще более умный способ это сделать...

ЗАПРОС С ОПТИМИЗАЦИЕЙ ГАЗА

Чтобы не натыкаться на ограничения по газу на запрос, теперь мы будем узнавать у ноды лимиты на газ и разбивать запрос на чанки в соответсвии с лимитам

Отличие тут в том, что если какой-то чанк не поместится, весь запрос не отклонят, а отклонят только один чанк, и мы потом повторно попробуем получить данные

Вот объяснение на картиночках

У нас есть чанк с максимальным размером 6 запросов

Чтобы узнать лимит по газу на запрос мы берем минимум из максимального лимита на газ, который мы установили, и лимита на газ из ноды,

после этого вычитаем буффер (на схемке все видно)

Теперь мы знаем в какое количество газа нам нужно уложиться и добавляем в чанк запросы пока не достигнем лимита (это произошло на 5 и 11 запросе)

Допустим запросы 4, 9, 10, 12 не выполнились

Теперь мы уменьшаем максимальное количество запросов в чанке в 2 раза и еще раз пытаемся выполнить обращения к блокчейну

Ура! Все запросы выполнены, в конце просто их складываем и получаем ответ

PROFIT: Время запроса уменьшилось в 2 раза, и теперь мы не получаем ошибки из-за огромного количества обращений от Alchemy/Infurra

Как и обещал, вот ссылка на гитхаб https://github.com/chpotl/fastErc20Balance

Тут контракт 1inch - https://etherscan.io/address/0x8d035edd8e09c3283463dade67cc0d49d6868063#code

Тут репозиторий 1inch с этим пакетом - https://github.com/1inch/multicall

Надеюсь статья была полезной

Спасибо за прочтение

Мой телеграм - https://t.me/chpotldev

Web3 реги и как они работают

2022-07-28T22:55:10.009Z

Всем привет!

В этой статье разберем принципы работы регистраций на веб3 сайтах

Ссылка на гитхаб с исходным кодом будет в конце статьи

Я буду делать все на js

В мире веб3 существует несколько способов authenticaton на странице

Как у 1inch - веб приложение выступает чисто интерфейсом для работы с контрактом DEXa и ничего не хранит на серверах
Как у opensea - веб приложение 50/50 на веб3, потому что некоторые моменты хранятся на серверах, а остальное в блокчене
Как у Дегенскана - веб приложение с подключением кошелька, но вся работа с блокчейнами происходит на бэкэнде

Давайте разберёмся, как сделать authentication в каждом случае

1. КАК У 1inch

Существует куча различный гайдов по тому, как добавить в свое приложение кнопку "connect wallet", поэтому не буду заострять внимание на этом. Просто в общих чертах опишу, как это работает.

ШАГ 1 - Создаем файл index.html, туда добавляем кнопку "connect wallet" и подключаем наш будущий файл script.js

ШАГ 2 - Делаем файл script.js, вешаем события на кнопки и используем чудесный API метамаска

Прелесть тут в том, что не нужно не нужно импортировать сторонние библиотеки

А теперь подробнее

window.ethereum - возвращает объект, если у пользователя установлено расширение метамаска, если его нет, то возвращается undefined

await ethereum.request({ method: 'eth_requestAccounts' }); - тут мы асинхронно запрашиваем у пользователя кошельки, чтобы подключится к веб-приложению

ethereum.selectedAddress - хранит массив подключенных адресов. Берем [0] элемент и получаем выбранный адрес, если он один, если много, то можем брать любой

Ура! Мы знаем адрес пользователя и можем делать запросы на отправление транзакций и т.п., а в метамаске теперь написано "подключено"

Теперь нам достаточно создать объект transactionParameters, куда передадим от кого (from), куда (to) и сколько эфира отправить (value)

await ethereum.request({method: 'eth_sendTransaction', params [transactionParameters]}); - делаем еще один request и отправляем транзакцию

При нажатии на кнопку send мы можем делать что угодно, я прикрутил отправку эфиров ortomich.eth

Вот тут документация метамаск апи: https://docs.metamask.io/guide/

Тут неповторимий Патрик делает это на протяжении 10 часов: https://www.youtube.com/watch?v=pdsYCkUWrgQ&t=1406s

Тут про window.ethereum - https://eips.ethereum.org/EIPS/eip-1193

2. КАК У OPENSEA

На всем известной площадке используются такие штуки как ПОДПИСИ

В чем основные плюсы сигнатур (аkа подписей)

Бесплатно
Никто не подделает твою подпись (если только угонит приватный ключ)

Они собственно и придуманы, чтобы подтверждать различные действия на сайте от вашего лица, не платя за газ

Как же их использовать, чтобы зайти на сайт, где нужно не только делать свапы, а еще добавлять в избранное и т.п.?

Вся логика основано на том факте, что кроме самого пользователя, никто не сгенерит уникальную сигнатуру

ШАГ 0 - Инициализируем проект качаем модули

ШАГ 1 - Делаем html + подключаем axios и ethers, чтобы слать запросы на сервер и взаимодействовать с блокчейном

ШАГ 2 - Запускаем чудо-сервер на node.js + нам понадобиться бд чтоб хранить пользователей, mongoDB = 1 love ^_^ У них красивый сайт))))))

Тут стандартные node.js штучки, ну и соответвенно делаем путь /login, чтобы куда-то слать наши подписи

ШАГ 3 - Делаем файл userModel - это чисто для БД, чтобы понимала, что от нее хотят, короче просто поля для бд. По сути нам достаточно хранить только кошелек, чтобы идентифицировать пользователя, но я еще добавил роль, потому что могу x2

ШАГ 4 - Делаем файл authController, там будет лежать логика для autentification на сервере

В нем у нас будет две функции login и signatureVerify, нетрудно догадаться что они делают

Далее в signatureVerify берем подпись, и сообщение, а чудо метод recover возвращает исходный адрес, что с этой информацией делать дальше догадаться несложно.

const signer = await web3.eth.accounts.recover(message, sign);
if (signer != address) {
  res.status(400).json({
    msg: 'error',
    data: 'Wrong signature',
  });
}

Простой if сделает все сам. Если все хорошо, то переходим в функции login

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

const address = req.body.address;
let user = await User.findOne({ address }); //ищем в бд
let dbMsg;
if (!user) {
  user = await User.create({ address: address });//создаем пользователя
  dbMsg = `new user ${address}`;
} else {
  dbMsg = `user exist`;//просто выводим
}

ШАГ 5 - Чтобы сделать модное сообщение для подписания как у опенси...

....просто генерируем случайную строку в hex формате

const genRanHex = (size) =>
  [...Array(size)]
    .map(() => Math.floor(Math.random() * 16).toString(16))
    .join('');
const nonce = genRanHex(32);
const message = `Welcome to OpenSea!\n\nClick to sign in and accept the OpenSea Terms of Service: https://opensea.io/tos\n\nThis request will not trigger a blockchain transaction or cost any gas fees.\n\nYour authentication status will reset after 24 hours.\n\nWallet address:\n${ethereum.selectedAddress}\n\nNonce:\n${nonce}`;

Зачем это нужно

Как можно в теории угнать логин? (Представим мир, где на опенси в подписи текст "1234", и с помощью подписи можно отправить все нфт любому человеку)

Негодяи знают, что на опенси подпись "1234", и делают сайт с такой же подписью
Вы каким-то образом туда заходите, и подписываете сообщение "1234"
Негодяи теперь знают, ваш адрес и подпись сообщения "1234"
Они идут на опенси и заходят под вашим логином

НО!

В реальном мире они максимум уберут лайки с нфт, так что бояться не стоит, но на всякий случай, если будете делать какой-то проект, то имейте это ввиду

Опенси раз в 24 часа просит вас подписать подобное сообщение, чтобы обновить данные и лишить хлеба негодяев

Тут доки ethers - https://docs.ethers.io/v5/

Тут можно поиграться с подписями - https://etherscan.io/verifiedSignatures#

Тут проект, который тоже использует подписи - https://snapshot.org/

Тут как работают сигнатуры - https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm

КАК У ДЕГЕНСКАНА

Тут основная логика в том, что не нужны особо взаимодействия с блокчейном, поэтому работает золотое правило web3

Если можно не использовать блокчейн, то мы им и не пользуемся

Поэтому когда мы нажимаем "connect wallet" и подписываем сообщение, идет запрос на их сервер, где передается просто сигнатура

И получаем такой ответ, у меня нет подписки, поэтому тут false

Делаем вывод из этого, что когда вы делаете подпись, она отправляется на сервер, и там просто проверяется, нет ли у этого пользователя доступа к дегенскану или админке.

Все просто и лаконично

Как и обещал, вот ссылка на гитхаб

https://github.com/chpotl/web3Auth