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

Существует разное множество баз данных для работы с временными рядами, к примеру InfluxDB и ей подобные. Я же, решил, что мне будет удобней работать с ElasticDB.

Если посмотреть схематично на реализацию, то она будет состоять из следующих компонентов:
— Конфиг для docker-compose для деплоя Elasticsearch и Kibana (второе необязательно)
— Скрипт загрузки данных из файлов в базу
— WebSocketServer который собственно и будет транслировать наши данные из бд
— WebSockerClient для удобства и мониторинга

Первым делом задеплоим докер контейнер с Elasticsearch. В него мы загрузим все данные из файлов по иструментам, которые подготавливали в прошлой статье.

docker-compose.ymlversion: '3.7'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.4.0
    container_name: elasticsearch
    environment:
      - xpack.security.enabled=false
      - discovery.type=single-node
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536
    cap_add:
      - IPC_LOCK
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
      - 9300:9300

  kibana:
    container_name: kibana
    image: docker.elastic.co/kibana/kibana:7.4.0
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    ports:
      - 5601:5601
    depends_on:
      - elasticsearch

volumes:
  elasticsearch-data:
    driver: local

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

run_elastic.pyimport datetime
import os
import sys
from pprint import pprint as pp
from memory_profiler import profile
from elasticsearch import Elasticsearch
from elasticsearch.helpers import parallel_bulk, bulk
from dotenv import load_dotenv
load_dotenv()

class Parser:
    es = Elasticsearch(os.environ["DB"])
    symbol = None
    iterator = 1
    bulk_data = list()

    def __init__(self, symbol):
        self.symbol = symbol

    def add(self, data: list, send: int = 0):
        self.bulk_data.append({
                "_op_type": "index",
                "_index": self.symbol,
                "_source": data,
            })
        if len(self.bulk_data) == 1000 or send == 1:
            bulk(self.es, self.bulk_data)
            self.bulk_data = list()
        self.iterator+=1

    def prepare(self, fl: str):
        with open(fl, "r") as f:
            i = 0; _data = dict({"ts":0,"a":[],"b":[],"delay":0})
            for n in f:
                if i==0: i+=1; continue
                if (i%1000000)==0: print(i)
                nd = n.split(",")
                if int(nd[0]) == _data["ts"]:
                    if nd[1] == 'a':
                        _data['a'].append( [float(nd[2]), float(nd[3])] )
                    elif nd[1] == 'b':
                        _data['b'].append( [float(nd[2]), float(nd[3])] )
                elif not _data["ts"]:
                    if nd[1] == 'a':
                        _data['a'].append( [float(nd[2]), float(nd[3])] )
                    elif nd[1] == 'b':
                        _data['b'].append( [float(nd[2]), float(nd[3])] )
                    _data["ts"] = int(nd[0])
                    _data['delay'] = float(nd[4].replace("\n", ""))
                else:
                    self.add(_data)
                    _data = dict({"ts":0,"a":[],"b":[],"delay":0})
                i+=1
            if _data: self.add(_data,1); del _data

name = os.environ["SYMBOL"]
p = Parser(name)

directory = os.environ["PATH_TO_FILES"]
for n in  os.listdir(directory):
    nd = os.path.join(directory,n)
    if os.path.isdir(nd) and name.upper() in n:
        for f in os.listdir(nd):
            print(nd + "/"+ f)
            s = datetime.datetime.now()
            p.prepare(nd + "/"+ f)
            delay = datetime.datetime.now() - s
            print("Time execute: " + str(delay))
            print("Rows in DB: " + str(p.iterator))

И сразу же файл конфига

.envDB="http://localhost:9200"
PATH_TO_FILES="Полный путь до директории с файлами"
SYMBOL="Наименование инструмента, к примеру atomusdt"
WS_URL="ws://localhost:5678"
WS_HOST="127.0.0.1"
WS_PORT="5678"
EMU_SYMBOL="atomusdt"
EMU_FROM="Дата и время с которого будет трансляция к примеру 01.01.2022 10:29:20.221"

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

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

ws_server.pyfrom elasticsearch import Elasticsearch
from datetime import datetime, timezone
from pprint import pprint as pp
import asyncio
import random
import websockets
import json
import sys
import threading
from dotenv import load_dotenv
load_dotenv()
es = Elasticsearch()


class Emulator:
    data = None
    ts_from = None
    index = None
    delta = 60

    def __init__(self,symbol, dt):
        self.ts_from = int(datetime.strptime(dt, "%d.%m.%Y %H:%M:%S.%f").replace(tzinfo=timezone.utc).timestamp() * 1000)
        self.index = symbol

        self._getData()

    def _ts_to(self, ts_from):
        return ts_from + self.delta * 1000

    def _getData(self):
        q = {
            "query": {
                "range": {
                    "ts": {
                        "gte": self.ts_from,
                        "lt": self._ts_to(self.ts_from)
                    }
                }
            },
            "size": 1000,
        }
        resp = es.search(index=self.index, body=q)

        if resp['hits']['total']['value'] > 0:
            self.data = [hit['_source'] for hit in resp['hits']['hits']]
        print("Got %d Hits" % resp['hits']['total']['value'])
        print("In self.data: %d"% len(self.data))
    
    def _append(self, ts_from):
        q = {
            "query": {
                "range": {
                    "ts": {
                        "gte": ts_from,
                        "lt": self._ts_to(ts_from)
                    }
                }
            },
            "size": 1000,
        }
        resp = es.search(index=self.index, body=q)

        if resp['hits']['total']['value'] > 0:
            self.data.extend([hit['_source'] for hit in resp['hits']['hits']])
        print("Got %d Hits" % resp['hits']['total']['value'])
        print("In self.data after append: %d"% len(self.data))

    async def translation(self, websocket, path):
        while True:
            if self.data:
                current = self.data.pop(0)
                sys.stdout.write("\rCurrent length: %d "% len(self.data))    
                sys.stdout.flush()
                await websocket.send(json.dumps(current))
                if len(self.data) < 500:
                    threading.Thread(target=self._append, args=[self.data[len(self.data)-1]["ts"]]).start()

            await asyncio.sleep(int(current['delay'])/1000)
    
    def run(self):
        start_server = websockets.serve(self.translation, '127.0.0.1', 5678)
        asyncio.get_event_loop().run_until_complete(start_server)
        asyncio.get_event_loop().run_forever()


em = Emulator("atomusdt","01.01.2022 10:29:20.221")
em.run()

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

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

Но для полноты картины напишем клиент для сервера.

ws_client.pyimport asyncio
import websockets
from pprint import pprint as pp
import json
import os
import sys
from collections import OrderedDict
from dotenv import load_dotenv
load_dotenv()

class WSClient:
    asks = dict()
    bids = dict()
    best_bid = None
    best_ask = None

    async def connect(self):
        uri = os.environ['WS_URL']
        async with websockets.connect(uri) as websocket:
            while 1:
                obj = await websocket.recv()
                obj = json.loads(obj)
                
                best_bid = .0
                for n in obj['b']: 
                    if best_bid < n[0] and n[1] > .0:
                        best_bid = n[0]
                self.best_bid = best_bid

                best_ask = 999999999
                for n in obj['a']: 
                    if best_ask > n[0] and n[1] > .0:
                        best_ask = n[0]
                self.best_ask = best_ask

                self._pp()

    def _pp(self):
        sys.stdout.write("\rASK: %f BID: %f SPREAD: %f\t\t\t"% (self.best_ask,self.best_bid, (self.best_ask-self.best_bid)))
        sys.stdout.flush()

try:
    ws = WSClient()
    asyncio.run(ws.connect())
except KeyboardInterrupt:
    print("\n Stop")

Теперь запустив клиент и сервер, можно посмотреть как работает наша сборка

Или проверив работу запустив клиента в виде плагина chrome

• Как хранить данные ?
• Где взять такие наборы данных ?
• Как эмулировать не только данные, но и интервалы между ними ?

Я произвел поверхностный ресёрч по данному вопросу и понял, что бесплатно, в нужном объеме и нужные данные я не получу.

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

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

Для выгрузки я выбрал биржу Binance, но думаю она не единственная, кто предоставляет подобные данные.

Первым делом необходимо подать заявку тут. Нас интересует “Futures Order Book Data”. Форма простая и не должна вызывать сложности. Как только заявку одобрят на почту упадет письмо.

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

На этом можно было бы закончить, если бы не нюансы.

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

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

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

Еще мне не понравилось, что в выгрузках есть ненужные мне колонки и дублирующие значения, не то, чтобы они сильно портили картинку, но за счет этого размер сильно увеличивался. К примеру, распакованная выгрузка одного дня вполне может достигать 10Gb, так что - да, место тут критично.

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

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

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

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

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

Исходники можно взять из github

Мне нужно в дискорд вывести некоторую информацию в виде среза статистики. Как вариант создать несколько каналов, залочить их и средствами бота, обновлять имя канала с какой-то периодикой новыми метриками. Обновлять я буду инфу по количеству нод в проекте noder.one. Сам проект на джанго, но связку именно в среде джанго делать наверное нет смысла, поэтому опишу здесь обособленный вариант.

Регистрация приложения и бота

Первым делом идем https://discord.com/developers и создаем приложение.

Далее, проваливаемся в наше приложение, и слева, в разделе Bot, добавляем бота.

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

Теперь нам осталось авторизовать нашего бота у себя на канале, для этого заходим в раздел OAuth2 в левом меню и в подменю выбираем URL Generator. В окне, в разделе Scopes выбираем чекбокс bot, в разделе Bot permission выбираем Administrator. Если ваш бот будет выполнять строго определенные функции и вы не собираетесь расширять функционал, то я настоятельно рекомендую выбрать точечно для него права. После проделанной операции, в поле Generated url будет ссылка по которой необходимо пройти и авторизовать вашего бота на канале.

Пишем функционал

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

mkdir ./discord_bot
cd discord_bot
python -m venv .venv
source .venv/bin/activate
pip install discord.py

Создаем наш файл с ботом, и записываем следующий код:

import discord
import asyncio

discord_channel_id = 0000000000000
discord_bot_token = "TOKEN"
discord_timeout = 60

class Client(discord.Client):
    def __init__(self, *, loop=None, **options):
        super().__init__(loop=loop, **options)
        self.loop.create_task(self.update_count_user_task())

    async def on_ready(self):
        print('Loged in as: {0}'.format(self.user))
        

    async def update_count_user_task(self):
        await self.wait_until_ready()
        while not self.is_closed():
            info_channel = self.get_channel(discord_channel_id)
            await info_channel.edit(name="new_name_channel")
            await asyncio.sleep(discord_timeout)

client = Client()
client.run(discord_bot_token)

discord_channel_id = идентификатор канала который будем обновлять
discord_bot_token = токен бота, сохраненный ранее
discord_timeout = сколько секунд курим между обновлениями

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

Применение

Деревья Меркла используются в разных сферах, если говорить про блокчейн, то яркий пример это сеть Bitcoin, в ней все хешируется в SHA-256. И применяется для проверки упрощенной верификации платежей, ведь для проверки не нужно вычислять все хеши, достаточно получить хеш корневого узла включающего все узлы до нужной транзакции. Такой подход значительно увеличивает производительность и пропускную способность сети.

Как использовать в Solidity ?

Если наш смарт-контракт подразумевает хранение большого кол-ва данных, которые необходимо будет валидировать, то использовать деревья Меркла не плохая мысль. К примеру в нашем проекте предусмотрен вайтлист, хранить тысячи адресов в смарт-контракте не самая оптимальная идея. Мы могли бы хранить корневой хеш всего в контракте, в контракт передавать только адрес и необходимые родительские узлы для вычислений, смарт-контракт сам будет высчитывать рут из переданных данных и сравнивать его с сохраненным корневым. Таким образом мы могли бы реализовать проверку валидности адреса кошелька на предмет минта в нужный момент. Давайте напишем на python функционал генерации такой структуры для вайтлиста.

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

import json
import os
import secrets
from coincurve import PublicKey
from pprint import pprint as pp
from sha3 import keccak_256
os.system("clear")

def getPK() -> None:
    return PublicKey.from_valid_secret(keccak_256(secrets.token_bytes(32)).digest()).format(compressed=False)[1:]

def addressGenerate(total: int) -> None:
    address_list = dict()
    address_list = {
        "addresses": list("0x" + keccak_256(getPK()).digest()[-20:].hex() for x in range(0,total)),
        "hashes": []
    } 
    with open("./address_list.json", "w") as fp:
        json.dump(address_list, fp,indent=4)
    print(f"\nADDRESS LIST:\n" + "\n".join(address_list['addresses']))

def getAddressList() -> None:
    with open("./address_list.json", "r", encoding='utf-8') as fp:
        return json.load(fp)

def keccak256(hc: list) -> str:
    hs = keccak_256()
    hs.update("".join(hc).encode('utf-8'))
    return hs.hexdigest()

def merkleTreeEncode(al: list) -> list:
    al = al['addresses']
    hash_candidate, hash_tree, loop = list(), list(), 0

    while(True):
        if loop == len(hash_tree):
            hash_tree.append(list())
        hash_candidate.append(al.pop())
        if (len(hash_candidate) == 1 and loop == 0) or (len(hash_candidate) == 2 and loop > 0):
            hash_tree[loop].append(keccak256(hash_candidate))
            hash_candidate = list()
        elif len(hash_candidate) == 1 and len(al) == 0 and loop > 0:
            hash_candidate.append(hash_candidate[0])
            hash_tree[loop].append(keccak256(hash_candidate))
        if len(al) == 0:
            if len(hash_tree[loop]) > 1:
                al = list(hash_tree[loop])
                hash_candidate = list()
                loop += 1
            else:
                break
    
    data = json.load(open("address_list.json", "r"))
    data['hashes'] = hash_tree
    json.dump(data, open("address_list.json", "w"), indent=4)
    return hash_tree

def merkleTreeDependens(address: str)-> dict:
    address_list = getAddressList()
    try:
        index = address_list['addresses'].index(address)
    except Exception as e:
        print('invalid address')
        return []

    data = {}
    data['index'] = index
    data['hash'] = address_list['hashes'][0][index]
    data['root'] = address_list['hashes'][len(address_list['hashes'])-1]

    out = []
    first = True
    total = len(address_list['hashes'][0])

    for level in address_list['hashes']:
        if len(level) == 1:
            break
        if len(level) % 2 != 0:
            level.append(level[len(level)-1])
        if first:
            if (index+1) % 2 == 0:    
                out.append(level[index-1])
            else:
                out.append(level[index+1])
            first = False
        else:
            if (index+1) % 2 == 0:    
                out.append(level[index-1])
            else:
                out.append(level[index+1])
        index = int((index) / 2)
        total = total/2
    data['proof'] = out
    return data



len_address = 15
try:
    adress_list = getAddressList()
    hashes = merkleTreeEncode(adress_list)
except Exception as e:
    print(e)
    addressGenerate(len_address)
    adress_list = getAddressList()
    hashes = merkleTreeEncode(adress_list)

hash_root = hashes[len(hashes)-1][0]
print(f"root hash: {hash_root} \n")


dep = merkleTreeDependens("0xcc28d2781aff9db54861f4a29624eefdfff0d6ec")
pp(dep)

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

github

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

ИДЕЯ

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

РЕШЕНЕНИЕ

Создадим файл и сделаем исполняемым

cd $HOME && touch ./check_network.sh && chmod +x ./check_network.sh

И добавим следующий код, в котором нам необходимо изменить SERVER_IP на свой публичный внешний адрес, по нему будет проверяться работоспособность сети и OLDTIME который отвечает сколько секунд после изменения файла конфига мы ничего не проверяем. Так как мы будем это вешать на планировщик, на каждую минуту, то есть смысла выставлять значения только наверное больше 2 минут — то-есть значения 120

check_network.sh#/bin/bash

SERVER_IP=127.0.0.1
FILE=/etc/network/interfaces
BACKUP_FILE=$HOME/interfaces.backup
LAST_GOOD_UPDATE=0
OLDTIME=10

CURTIME=$(date +%s)
FILETIME=$(stat $FILE -c %Y)
TIMEDIFF=$(expr $CURTIME - $FILETIME)

if [ $FILETIME -gt $LAST_GOOD_UPDATE ]; then
    if [ $TIMEDIFF -gt $OLDTIME ]; then
        ping $SERVER_IP -c 5 2>&1 > /dev/null && RESULT=1 || RESULT=0
        if [ $RESULT -eq 1 ]; then
            echo -e '\033[1;32m'
            echo "The interface has been changed and after a while it works. We backup it"
            echo -e '\033[0m'
            sed -i "6s/LAST_GOOD_UPDATE=.*/LAST_GOOD_UPDATE=${FILETIME}/" ./check_network.sh
            cp $FILE $BACKUP_FILE
        else
            echo -e '\033[1;31m'
            echo "The interface has been changed and after a while it NOT works. We restore it"
            echo -e '\033[0m'
            cp $BACKUP_FILE $FILE
            FILETIME=$(stat $FILE -c %Y)
            sed -i "6s/LAST_GOOD_UPDATE=.*/LAST_GOOD_UPDATE=${FILETIME}/" ./check_network.sh
            systemctl restart networking.service
        fi
    fi
fi

Разберем по порядку:
:4 — путь до нашего конфига
:5 — путь до бэкапа конфига
:6 — таймштамп изменения конфига
:13 — проверяем есть ли изменения
:14 — выдержали ли мы паузу (задается в секундах строка :7)
:15 — пингуем сами себя через внешний публичный ip
:20-21 — сеть есть, обновляем время изменения конфига в 6 строке и БЭКАПИМ сам конфиг
:26-28 — сети нет, обновляем время изменения файла в 6 строке и РЕСТОРИМ конфиг

На этом все, теперь можно протестировать и закинуть в крон с повторениями на каждую минуту

Итак, нам необходимо заказать на аукционе в Hetzner (немецкий хостер) VDS сервер, так же, для того чтобы на этом сервере поднимать свои независимые VPS нам понадобится публичные ip адреса и да, они тоже стоят денег.

Летим по рефералке и регаемся на hetzner — получаем 20 евро в виде облачных кредитов, либо без рефералки здесь. В разделе аукциона выбираем подходящий сервер

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

Отлично, теперь летим в лк во вкладку IPs и берем ip адреса в подсети /29. Это будет 8 штук., но не спешите радоваться, первый в подсети это сетевой адрес, а последний broadcast адрес и их нельзя использовать. Просто имейте это в виду.

IP адреса готовы и мы можем заняться установкой ПО. Для управления нашими виртуалками мы будем использовать Proxmox v.7

Переходим на вкладку Rescue и запускаем систему. Для подключения к серверу я использую ранее загруженный ключ, но можно и по логину паролю зайти. Я пользуюсь стандартным терминалом.

Вводим из терминала ssh root@<SERVER IP> и попадаем на сервер

Не теряя времени набираем в командной строке installimage, в списке выбираем Other и далее выбираем последнюю версию Proxmox Bullseye, он идет с 11 версией debian. Все предупреждения читаем и скипаем, они ни на что не влияют.

В пред установочном конфиге я изменил только SWRAIDLEVEL с 6 на 0, т.к. скорость и свободное место для меня приоритетнее, нежели отказоусточивость. Так же измените HOSTNAME, во всем остальном меня все устраивает. Сохраняем нажатием F2 с подтверждением и выходим F10. При выходе будет несколько подтверждений о том что диски затрутся, соглашаемся и идем пить чай, установка началась.

После установки отправляем сервер на перезагрузку командой reboot, если заходили по ssh с помощью ключей, не забудьте сбросить fingerprint командой ssh-keygen -R <SERVER IP>. После перезагрузки снова подключаемся к серверу и открываем конфиг с нашими сетевыми интерфейсами nano /etc/network/interfaces

У вас конечно будет по другому, но сути не меняет, на этом этапе нам нужно настроить с учетом наших купленных адресов

source /etc/network/interfaces.d/*

auto lo
iface lo inet loopback

iface enp98s0f0 inet manual
iface enp97s0f0 inet manual
iface enp97s0f1 inet manual
iface enp98s0f1 inet manual

auto vmbr0
iface vmbr0 inet static
        address 195.xxx.xxx.43/32
        gateway 195.xxx.xxx.1
        bridge-ports enp98s0f0
        bridge-stp off
        bridge-fd 1
        pointopoint 195.xxx.xxx.1

auto vmbr100
iface vmbr100 inet static
        address 78.xxx.xxx.30/29
        bridge-ports none
        bridge-stp off
        bridge-fd 0

Тут мы создали 2 моста, vmbr0 для нашей основной сети, в address указываем ip сервера с указанием подсети /32, так же указываем шлюзы, эти данные есть во вкладке IPs в лк.

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

Сохраняем и применяем наши изменения командой ifup -a, теперь командой passwd зададим пароль и отправимся в вебморду https://<SERVER IP>:8006

Сейчас у нас нет подключенных образов ОС и мы не сможем ничего установить, давайте это исправим, переходим в раздел как ISO и вставляем ссылку на дистрибутив Ubuntu 20.04 взятый с официального сайта https://releases.ubuntu.com/20.04.4/ubuntu-20.04.4-live-server-amd64.iso

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

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

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

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

wget -O massa.sh https://raw.githubusercontent.com/shmeller86/guides/master/massa.sh && chmod +x massa.sh && ./massa.sh

после установки заходим в клиент

source ~/.bash_profile && cd ~/massa/massa-client && cargo run --release

создаем или восстанавливаем по ключу кошелек

wallet_generate_private_key # создаем
wallet_add_private_keys <your_private_key> # восстанавливаем

проверяем

wallet_info

отправляем в дис канал #testnet-faucet свой адрес кошелька и покупаем ролл

buy_rolls <ADDRESS> 1 0

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

node_add_staking_private_keys <PRIVAT KEY>

регаемся на фазу тестнета в боте MassaBot, отправляем ему ip сервера, в ответ пришлет твой discord id и вставляем его в лиенте

node_testnet_rewards_program_ownership_proof <ADDRESS> <DISCORD ID>

На этом все. Следим, переживаем, исправляем.

Github

Установка ноды и фармера для Subspace.
github
источник

В переменных SUBSPACE_WALLET_ADDRESS и SUBSPACE_NODE_NAME необходимо указать название ноды и свой адрес кошелька.

SUBSPACE_WALLET_ADDRESS=""
SUBSPACE_NODE_NAME=""
cd ~
wget -O subspace-node https://github.com/subspace/subspace/releases/download/gemini-1a-2022-may-31/subspace-node-ubuntu-x86_64-gemini-1a-2022-may-31
wget -O subspace-farmer https://github.com/subspace/subspace/releases/download/gemini-1a-2022-may-31/subspace-farmer-ubuntu-x86_64-gemini-1a-2022-may-31
mv subspace* /usr/local/bin/
chmod +x /usr/local/bin/subspace*
adduser --system --home=/var/lib/subspace subspace
tee <<EOF >/dev/null /etc/systemd/system/subspace-node.service
[Unit]
Description=Subspace Node
After=network.target
[Service]
Type=simple
User=subspace
ExecStart=/usr/local/bin/subspace-node \
--chain gemini-1 \
--execution wasm \
--pruning 1024 \
--keep-blocks 1024 \
--validator \
--name $SUBSPACE_NODE_NAME
Restart=alwa
EOF
tee <<EOF >/dev/null /etc/systemd/system/subspace-farmer.service
[Unit]
Description=Subspace Farmer
Requires=subspace-node.service
After=network.target
After=subspace-node.service
[Service]
Type=simpleUser=subspace
ExecStart=/usr/local/bin/subspace-farmer farm --reward-address=$SUBSPACE_WALLET_ADDRESS --plot-size=200G
Restart=always
RestartSec=10
LimitNOFILE=10000
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl start subspace-node
systemctl start subspace-farmer

READ TIME:14 MINUTE, 0 SECOND

Для web3 есть одноименная библиотека написанная для разных языков, в том числе для python, называется web3py.
Здесь мы интегрируем наши 2 проекта в наш телеграм бот. У нас будет игра «Камень, ножницы, бумага» на внутренние токены, смарт-контракт на solidity писали тут и реализуем генерацию ethereum кошельков тык.
Взаиподействие с telegram api переложим на python-telegram-bot. Создадим проект и склонируем репозиторий телеграм бота.

cd ~ && mkdir tgbot && cd tgbot
python -m venv .venv
source .venv/bin/activate
pip install python-telegram-bot coincurve pysha3 web3
git clone https://github.com/python-telegram-bot/python-telegram-bot --recursive
cd python-telegram-bot
python setup.py install && cd .. && mv -f * ../ && touch start.py

Нам нужно будет хранить немного данных, не будем заморачиваться и используем sqllite, можете создать сами, либо взять просто готувую из гита

CREATE TABLE "users" (
	"id"	INTEGER NOT NULL UNIQUE,
	"id_tg"	INTEGER NOT NULL UNIQUE,
	"address"	TEXT UNIQUE,
	"private_key"	TEXT UNIQUE,
	"balance"	INTEGER,
	"win"	INTEGER,
	"lose"	INTEGER,
	"dt_create"	TEXT,
	"first_name"	TEXT,
	"last_name"	TEXT,
	"user_name"	TEXT,
	"last_game"	INTEGER,
	PRIMARY KEY("id" AUTOINCREMENT)
)

Так же создадим конфиг и запишем в него кошельки, токен нашел бота и другие параметры

{
    "proxy": {
        "http": "http://login:password@address:port",
        "https": "http://login:password@address:port"
    },
    "rpc": "https://polygon-rpc.com",
    "contract": "0x000.... CONTRACT ADDRESS",
    "bank_wallet_from": "0x000... WALLET",
    "bank_private_key": "... PRIVATE KEY",
    "url_addr": "https://polygonscan.com/tx/",
    "bot_token": "TOKEN TELEGRAM BOT"
}

Импортируем нужные библиотеки для работы

import json
import logging
import secrets
import sqlite3
from coincurve import PublicKey
from sha3 import keccak_256
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update, constants
from telegram.ext import Application, CallbackQueryHandler, CommandHandler, ContextTypes
from web3 import Web3
from web3.logs import DISCARD

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

con = sqlite3.connect('db.db')
cur = con.cursor()

logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
)
logger = logging.getLogger(__name__)

k_1 = [
    [
        InlineKeyboardButton("Play", callback_data="play_rsp"),
        InlineKeyboardButton("Balance", callback_data="get_balance"),
        InlineKeyboardButton("Deposit", callback_data="deposite"),
        InlineKeyboardButton("Make wallets", callback_data="gen_wal")
    ]
]

k_2 = [
    [
        InlineKeyboardButton("1", callback_data="1"),
        InlineKeyboardButton("5", callback_data="5"),
        InlineKeyboardButton("10", callback_data="10"),
        InlineKeyboardButton("Return", callback_data="menu")
    ],
]

k_3 = [
    [
        InlineKeyboardButton(" Rock", callback_data="rock"),
        InlineKeyboardButton(" Scissors", callback_data="scissors"),
        InlineKeyboardButton(" Paper", callback_data="paper"),
    ],
    [
        InlineKeyboardButton("Return", callback_data="menu")
    ]
]

k_4 = [
    [
        InlineKeyboardButton("Check winner", callback_data="reload")
    ]
]

reply_markup_main = InlineKeyboardMarkup(k_1)
reply_markup_numbers = InlineKeyboardMarkup(k_2)
reply_markup_play = InlineKeyboardMarkup(k_3)
reply_markup_reload = InlineKeyboardMarkup(k_4)

with open('./config.json', 'r') as f:
    config = json.load(f)

proxies = config['proxy']

RPC = config['rpc']
contract = config['contract']
bank_wallet_from = config['bank_wallet_from']
bank_private_key = config['bank_private_key']
url_addr = config['url_addr']
BOT_TOKEN = config['bot_token']
ERC20_ABI = json.loads('''[{"inputs": [],"stateMutability": "nonpayable","type": "constructor"},{"anonymous": false,"inputs": [{"indexed": true,"internalType": "address","name": "owner","type": "address"},{"indexed": true,"internalType": "address","name": "spender","type": "address"},{"indexed": false,"internalType": "uint256","name": "value","type": "uint256"}],"name": "Approval","type": "event"},{"anonymous": false,"inputs": [{"indexed": false,"internalType": "uint256","name": "number","type": "uint256"}],"name": "NumberPlay","type": "event"},{"anonymous": false,"inputs": [{"indexed": true,"internalType": "address","name": "from","type": "address"},{"indexed": true,"internalType": "address","name": "to","type": "address"},{"indexed": false,"internalType": "uint256","name": "value","type": "uint256"}],"name": "Transfer","type": "event"},{"inputs": [{"internalType": "address","name": "owner","type": "address"},{"internalType": "address","name": "spender","type": "address"}],"name": "allowance","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "address","name": "spender","type": "address"},{"internalType": "uint256","name": "amount","type": "uint256"}],"name": "approve","outputs": [{"internalType": "bool","name": "","type": "bool"}],"stateMutability": "nonpayable","type": "function"},{"inputs": [{"internalType": "address","name": "account","type": "address"}],"name": "balanceOf","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"},{"inputs": [],"name": "decimals","outputs": [{"internalType": "uint8","name": "","type": "uint8"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "address","name": "spender","type": "address"},{"internalType": "uint256","name": "subtractedValue","type": "uint256"}],"name": "decreaseAllowance","outputs": [{"internalType": "bool","name": "","type": "bool"}],"stateMutability": "nonpayable","type": "function"},{"inputs": [],"name": "gameCost","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "uint256","name": "id","type": "uint256"}],"name": "gameHistory","outputs": [{"components": [{"internalType": "address","name": "player_1","type": "address"},{"internalType": "address","name": "player_2","type": "address"},{"internalType": "int8","name": "player_1_action","type": "int8"},{"internalType": "int8","name": "player_2_action","type": "int8"},{"internalType": "int8","name": "player_win","type": "int8"}],"internalType": "struct RSP._game[]","name": "","type": "tuple[]"}],"stateMutability": "view","type": "function"},{"inputs": [],"name": "gameId","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "address","name": "spender","type": "address"},{"internalType": "uint256","name": "addedValue","type": "uint256"}],"name": "increaseAllowance","outputs": [{"internalType": "bool","name": "","type": "bool"}],"stateMutability": "nonpayable","type": "function"},{"inputs": [],"name": "jackPot","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"},{"inputs": [],"name": "name","outputs": [{"internalType": "string","name": "","type": "string"}],"stateMutability": "view","type": "function"},{"inputs": [],"name": "players","outputs": [{"internalType": "address payable[]","name": "","type": "address[]"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "uint256","name": "_modulus","type": "uint256"}],"name": "randMod","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "uint256","name": "cost","type": "uint256"}],"name": "setGameCost","outputs": [{"internalType": "bool","name": "","type": "bool"}],"stateMutability": "nonpayable","type": "function"},{"inputs": [],"name": "symbol","outputs": [{"internalType": "string","name": "","type": "string"}],"stateMutability": "view","type": "function"},{"inputs": [],"name": "totalSupply","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "address","name": "to","type": "address"},{"internalType": "uint256","name": "amount","type": "uint256"}],"name": "transfer","outputs": [{"internalType": "bool","name": "","type": "bool"}],"stateMutability": "nonpayable","type": "function"},{"inputs": [{"internalType": "address","name": "from","type": "address"},{"internalType": "address","name": "to","type": "address"},{"internalType": "uint256","name": "amount","type": "uint256"}],"name": "transferFrom","outputs": [{"internalType": "bool","name": "","type": "bool"}],"stateMutability": "nonpayable","type": "function"},{"inputs": [{"internalType": "uint256","name": "amount","type": "uint256"},{"internalType": "int8","name": "action","type": "int8"}],"name": "transferPerGame","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "nonpayable","type": "function"}]''')

w3 = Web3(Web3.HTTPProvider(RPC,request_kwargs={"proxies":proxies}))
coin = w3.eth.contract(contract, abi=ERC20_ABI)
gasLimit = 210000

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

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    try:
        first_name = update.message.chat.first_name
        last_name = update.message.chat.last_name
        user_name = update.message.chat.username
        user_id = update.message.chat.id
        row = cur.execute("SELECT * FROM users WHERE id_tg = '%s'" % user_id).fetchone()
        if row:
            await update.message.reply_text(f"You are already registered!", parse_mode=constants.ParseMode.HTML)
            await update.message.reply_text("Please choose:", reply_markup=reply_markup_main)
            return False
        private_key = keccak_256(secrets.token_bytes(32)).digest()
        public_key = PublicKey.from_valid_secret(private_key).format(compressed=False)[1:]
        address = keccak_256(public_key).digest()[-20:]
        new_address = Web3.toChecksumAddress("0x"+str(address.hex()))
        await update.message.reply_text(f"Hi Bro\! you are here for the first time, \
    so I created a wallet for you, it will be useful for you to interact\. Write \
    down your private key and don't share it with anyone\!\n\n\
        *Wallet address\:* {new_address}\n\
        *Private key\:* ||{private_key.hex()}||", parse_mode=constants.ParseMode.MARKDOWN_V2)
        await update.message.reply_text(f"And now I will transfer 10 tokens to your wallet so that you can start spending them...\n\n Just wait 5 second...", 
        parse_mode=constants.ParseMode.HTML)
        transaction = {
            'chainId': 137,
            'to': new_address,
            'from': bank_wallet_from,
            'value': Web3.toWei(0.1, 'ether'),
            'nonce': w3.eth.getTransactionCount(bank_wallet_from),
            'gas': gasLimit,
            'gasPrice': w3.eth.gas_price * 2
        }
        signed_txn = w3.eth.account.sign_transaction(transaction, bank_private_key)
        txn_hash = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
        native_hash = txn_hash.hex()
        dict_transaction = {
            'chainId': 137,
            'from': bank_wallet_from,
            'gas': gasLimit,
            'gasPrice': w3.eth.gas_price * 2,
            'nonce': w3.eth.getTransactionCount(bank_wallet_from) + 1,
        }
        coin_decimals = coin.functions.decimals().call()
        one_coin = 10 * 10 ** coin_decimals
        transaction = coin.functions.transfer(new_address, one_coin).buildTransaction(dict_transaction)
        signed_txn = w3.eth.account.sign_transaction(transaction, bank_private_key)
        txn_hash = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
        await update.message.reply_text(f"Alright, bro! I sent you <b>10 RSP</b> native tokens and <b>0.1 MATIC</b> for transaction.\n\n\n\
RSP transaction hash: <a href='{url_addr}{txn_hash.hex()}'>{txn_hash.hex()}</a>\n\n\
MATIC transaction hash: <a href='{url_addr}{native_hash}'>{native_hash}</a>", 
        parse_mode=constants.ParseMode.HTML, disable_web_page_preview=True)
        cur.execute(f"INSERT INTO users (first_name, last_name, user_name, id_tg, address, private_key, balance, win, lose, dt_create) VALUES ('{first_name}','{last_name}','{user_name}','{user_id}' ,'{new_address}', '{private_key.hex()}', 10, 0,0,'2022-05-19');")
        con.commit()
        await update.message.reply_text("Please choose:", reply_markup=reply_markup_main)
    except Exception as e:
        print(e)
        await update.message.reply_text("Something wrong... Try again command /start")

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

async def button(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Parses the CallbackQuery and updates the message text."""
    query = update.callback_query
    user_id = update.callback_query.from_user.id
    if query.data == "play_rsp":
        await query.answer()
        row = cur.execute("SELECT * FROM users WHERE id_tg = '%s'" % user_id).fetchone()
        if row:
            cost_play = coin.functions.gameCost().call() / (10**18)
            reward = cost_play * 2 * .9
            if row[4] >= cost_play:
                await query.edit_message_text(f"The game costs {str(cost_play)} RSP tokens, if you win, you will take {str(reward)} RSP tokens", reply_markup=reply_markup_play)
                return None
            else:
                await query.edit_message_text(f"Sorry, but need more RSP tokens", reply_markup=reply_markup_main)
                return None
    elif query.data == "get_balance":
        row = cur.execute("SELECT * FROM users WHERE id_tg = '%s'" % user_id).fetchone()
        if row:
            msg = f"*Your balance:* {row[4]} RSP"
        else:
            msg = f"*Your balance:* \-\-\- RSP"
    elif query.data == "deposite":
        row = cur.execute("SELECT * FROM users WHERE id_tg = '%s'" % user_id).fetchone()
        if row:
            await query.edit_message_text(f"I will transfer 5 tokens to your address\n Just wait 5 second...\n", 
            parse_mode=constants.ParseMode.HTML)
            dict_transaction = {
                'chainId': 137,
                'from': bank_wallet_from,
                'gas': gasLimit,
                'gasPrice': w3.eth.gas_price * 2,
                'nonce': w3.eth.getTransactionCount(bank_wallet_from),
            }
            coin_decimals = coin.functions.decimals().call()
            one_coin = 5 * 10 ** coin_decimals
            transaction = coin.functions.transfer(row[2], one_coin).buildTransaction(dict_transaction)
            signed_txn = w3.eth.account.sign_transaction(transaction, bank_private_key)
            txn_hash = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
            await query.message.reply_text(f"Alright! I sent you 5 RSP. Transaction hash <a href='{url_addr}{txn_hash.hex()}'>{txn_hash.hex()}</a>", 
            parse_mode=constants.ParseMode.HTML)
            new_balance = row[4] + 5
            cur.execute(f"UPDATE users SET balance={new_balance} where id={row[0]};")
            con.commit()
        await query.answer()
        await query.message.reply_text("Please choose:", reply_markup=reply_markup_main)
        return True
    elif query.data == "gen_wal":
        await query.answer()
        await query.edit_message_text("How many?:", reply_markup=reply_markup_numbers)
        return None
    elif query.data == "menu":
        msg=''
    elif query.data == "rock":
        try:
            await query.answer()
            await query.edit_message_text(text="Your choice is accepted, the transaction is being executed...")
            row = cur.execute("SELECT * FROM users WHERE id_tg = '%s'" % user_id).fetchone()
            if row:
                cost_play = coin.functions.gameCost().call()
                dict_transaction = coin.functions.transferPerGame(cost_play,1).buildTransaction({
                    'chainId': 137,
                    'from': row[2],
                    'gas': gasLimit,
                    'gasPrice': w3.eth.gas_price * 2,
                    'nonce': w3.eth.getTransactionCount(row[2])
                }) 
                signed_txn = w3.eth.account.signTransaction(dict_transaction, private_key=row[3])
                txn_hash = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
                receipt = w3.eth.wait_for_transaction_receipt(txn_hash,timeout=120, poll_latency=0.1)
                logs = coin.events.NumberPlay().processReceipt(receipt, errors=DISCARD)
                number = logs[0]['args']['number']
                msg = f"Your playID: {number}\n Push the button and check winner!"
        except Exception as e:
            msg = e
        finally:
            new_balance = row[4] - (cost_play / 10**18)
            cur.execute(f"UPDATE users SET balance={new_balance}, last_game={int(number)} where id={row[0]};")
            con.commit()
            await query.edit_message_text(msg, reply_markup=reply_markup_reload)
            return None
    elif query.data == "scissors":
        try:
            await query.answer()
            await query.edit_message_text(text="Your choice is accepted, the transaction is being executed...")
            row = cur.execute("SELECT * FROM users WHERE id_tg = '%s'" % user_id).fetchone()
            if row:
                cost_play = coin.functions.gameCost().call()
                dict_transaction = coin.functions.transferPerGame(cost_play,2).buildTransaction({
                    'chainId': 137,
                    'from': row[2],
                    'gas': gasLimit,
                    'gasPrice': w3.eth.gas_price * 2,
                    'nonce': w3.eth.getTransactionCount(row[2])
                }) 
                signed_txn = w3.eth.account.signTransaction(dict_transaction, private_key=row[3])
                txn_hash = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
                receipt = w3.eth.wait_for_transaction_receipt(txn_hash,timeout=120, poll_latency=0.1)
                logs = coin.events.NumberPlay().processReceipt(receipt, errors=DISCARD)
                number = logs[0]['args']['number']
                msg = f"Your playID: {number}\n Push the button and check winner!"
        except Exception as e:
            msg = e
        finally:
            new_balance = row[4] - (cost_play / 10**18)
            cur.execute(f"UPDATE users SET balance={new_balance}, last_game={int(number)} where id={row[0]};")
            con.commit()
            await query.edit_message_text(msg, reply_markup=reply_markup_reload)
            return None
    elif query.data == "paper":
        try:
            await query.answer()
            await query.edit_message_text(text="Your choice is accepted, the transaction is being executed...")
            row = cur.execute("SELECT * FROM users WHERE id_tg = '%s'" % user_id).fetchone()
            if row:
                cost_play = coin.functions.gameCost().call()
                dict_transaction = coin.functions.transferPerGame(cost_play,3).buildTransaction({
                    'chainId': 137,
                    'from': row[2],
                    'gas': gasLimit,
                    'gasPrice': w3.eth.gas_price * 2,
                    'nonce': w3.eth.getTransactionCount(row[2])
                }) 
                signed_txn = w3.eth.account.signTransaction(dict_transaction, private_key=row[3])
                txn_hash = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
                receipt = w3.eth.wait_for_transaction_receipt(txn_hash,timeout=120, poll_latency=0.1)
                logs = coin.events.NumberPlay().processReceipt(receipt, errors=DISCARD)
                number = logs[0]['args']['number']
                msg = f"Your playID: {number}\n Push the button and check winner!"
        except Exception as e:
            msg = e
        finally:
            new_balance = row[4] - (cost_play / 10**18)
            cur.execute(f"UPDATE users SET balance={new_balance}, last_game={int(number)} where id={row[0]};")
            con.commit()
            await query.edit_message_text(msg, reply_markup=reply_markup_reload)
            return None
    elif query.data == "reload":
        await query.answer()
        row = cur.execute("SELECT * FROM users WHERE id_tg = '%s'" % user_id).fetchone()
        if row:
            history = coin.functions.gameHistory(row[12]).call()
            if row[2] == history[0][0]:
                if history[0][4] == 0:
                    cost_play = coin.functions.gameCost().call()
                    new_balance = row[4] + ((cost_play / 10**18) * 2 / 100 * 90)
                    msg = f"Congratulations!!!\nYou Won!!! Your balance is increased and now equal {new_balance} RSP"
                    cur.execute(f"UPDATE users SET balance={new_balance} where id={row[0]};")
                elif history[0][4] == 1:
                    msg = "You lost, but next time you will be lucky!!!"
                else:
                    msg = "No one won in this game, the cost is returned"
            elif row[2] == history[0][1]:
                if history[0][4] == 1:
                    cost_play = coin.functions.gameCost().call()
                    new_balance = row[4] + ((cost_play / 10**18) * 2 / 100 * 90)
                    msg = f"Congratulations!!!\nYou Won!!! Your balance is increased and now equal {new_balance} RSP"
                    cur.execute(f"UPDATE users SET balance={new_balance} where id={row[0]};")
                elif history[0][4] == 0:
                    msg = "You lost, but next time you will be lucky!!!"
                else:
                    msg = "No one won in this game, the cost is returned"
            print(history)
    elif int(query.data) > 0:
        msg = "<b>ADDRESS:PRIVATE_KEY</b>\n\n"
        for i in range(0,int(query.data)):
            private_key = keccak_256(secrets.token_bytes(32)).digest()
            public_key = PublicKey.from_valid_secret(private_key).format(compressed=False)[1:]
            address = keccak_256(public_key).digest()[-20:]
            msg += f"<code>{address.hex()}:{private_key.hex()}</code>\n\n"

    await query.answer()
    if msg:
        await query.edit_message_text(text=msg, parse_mode=constants.ParseMode.HTML)
        await query.message.reply_text("Please choose:", reply_markup=reply_markup_main)
    else:
        await query.edit_message_text("Please choose:", reply_markup=reply_markup_main)

Теперь допишем обработчкики и стартанем наш скрипт

def main() -> None:
    application = Application.builder().token(BOT_TOKEN).build()
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CallbackQueryHandler(button))
    application.run_polling()

if __name__ == "__main__":
    main()

Напишем смарт-контракт всем известной игры «Камень, ножницы, бумага». Контракт будет иметь свой нативный токен, которым будут вестись все расчеты между участниками, игра будет на внутренние токены, смарт-контракт напишем для сети Polygon исключительно из соображений экономии комиссии за деплой контракта, это обойдется нам меньше 1$, в то время как в Ethereum комса встать может нам в 200$.

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

Вкратце о контракте

Будем наследоваться от смарт-конракта токена ERC20 предоставленным командой OpenZeppelin. Будет функции установки стоимости игры, просмотр истории игр, с каждого купленного взноса будет удерживаться 10% на джекпот или комсу) по итоку победитель возвращает ticket price * 2 player * 0.8.

Сам контракт можно писать в разных IDE, например в VSCode, но лично я предпочитаю remix, это online IDE в которой можно сразу деплоить наш контракт как в тестнет так и мэиннет, дебажить и использовать разные версии компилятора.

Создадим новый файл RSP.sol, и пропишем версию solidity, импортируем контракт ERC20 для нашего нативного токена и создадим контракт унаследовав ERC20

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.11;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";

contract RSP is ERC20 {
}

Объявим наши переменные для дальнейшей работы

// Список из сыгранных игр
mapping(uint256 => _game[]) private _gameHistory;

// Кол-во выпущенных токенов
uint256 private _totalSupply;
// Идентификатор актуальной игры
uint256 private _gameId;
// Кубышка
uint256 private _jackPot;
// Стоимость одной игры
uint256 private _gameCost;
// 10**18 для упрощения
uint256 private _x;

// Действие игрока
int8[] private _playerAction;

// Список адресов игроков
address payable[] _players;
// Владелец контракта
address private _contractOwner;

// Название токена
string private _name;
// Короткое символичное название токена
string private _symbol;

// Событие, которое будет вызываться при входе участника
event NumberPlay(uint256 number);

// Структура в срезе 1 игры, для истории
struct _game {
  address player_1;
  address player_2;
  int8 player_1_action;
  int8 player_2_action;
  int8 player_win;
}

Создадим конструктор, по сути это функция которая выполняется один раз при деплое смарт-контракта и полезна нам тем, что в ней мы задами стартовые дефолтные настройки для игры, так же там укажем нашего владельца контракта, который в дальнейшем сможет, например изменить стоимость входа в игру.
И заминтим от общего кол-ва токенов, а это у нас 1000 RSP токенов, на два адреса. Первый адрес контракта на него мы выпустим 20% от общего кол-ва, а второй адрес, это адрес владельца контракта, на него мы отправим 80% всех токенов RSP.

constructor() ERC20 ("Rock Scissors Paper", "RSP"){
        _x = 10 ** 18;
        _totalSupply = 1000 * _x;
        _jackPot = 0;
        _gameCost = 3 * _x;
        _gameId = 1;
        _contractOwner = msg.sender;

        _mint(address(this), _totalSupply/100*20);
        _mint(_contractOwner, _totalSupply/100*80);
 
    }

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

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

/**
* @dev Returns the game identificator 
*/
function gameId() public view returns (uint256){
    return _gameId;
}

/**
* @dev Returns the total jackpot pot 
*/
function jackPot() public view returns (uint256){
    return _jackPot;
}

/**
* @dev Returns the game cost 
*/
function gameCost() public view returns (uint256){
    return _gameCost;
}    
/**
* @dev Returns current players 
*/
function players() public view returns(address payable[] memory) {
    return _players;
}

/**
* @dev Returns the game history by id
*/
function gameHistory(uint256 id) public view returns (_game[] memory) {
    return _gameHistory[id];
}

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

/**
* @dev Set the game cost 
* Integer must beetwen 1 and 999
*/
function setGameCost(uint256 cost) public onlyContractOwner returns (bool){
    require(cost >= 1 && cost < 1000, "Invalid cost, 1-999");
    _gameCost = cost * _x;
    return true;
}

Теперь напишем функцию приема платежа за игру и передачи в нее, собственно, действия, а действий у нас 3: это камень, ножницы или бумага.
В данную функцию будут передаваться 2 параметра, это сумма и действие. Из проверок после вызова это то, что передаваемая сумма соответствует стоимости билета, нам лишнего не надо, но и если денег нет — простите). Так же проверка на передаваемое действие, ограничимся условными 1, 2 или 3. После на адрес контракта от игрока мы переводим стоимость игры заданную ранее, и проверяем на количество игроков на данный момент в принимающих участие. Наша игра подразумевает 2 игрока, поэтому когда игрок только 1, то необходимо просто выйти из функции зарегистрировав игрока. В случае, если вы уже второй игрок, то логично было бы сразу инициализировать процесс выбора победителя и расчета ревардов.

/**
    * @dev See {IERC20-transfer}.
    *
    * Requirements:
    *
    * - the caller must have a balance of at least `amount`.
    */
function transferPerGame(uint256 amount, int8 action) external returns (uint256) {
    require(amount == gameCost(), "Sent token are not equal to the cost of the game");
    require(0 < action && action < 4, "Invalid value for action (1-3)");

    address to = address(this);
    address owner = _msgSender();
    uint256 curGameId = gameId();
    _transfer(owner, to, amount);
    if (players().length < 2) {  
        _players.push(payable(owner));
        _playerAction.push(action);
        if (players().length == 2) {
            int8 indexWinner = calculateWinner(_playerAction[0], _playerAction[1]);
            _gameHistory[curGameId].push(_game(_players[0],_players[1],_playerAction[0],_playerAction[1],indexWinner));
            setWinner(indexWinner);
        }
    }
    emit NumberPlay(curGameId);
    return curGameId;
}

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

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

/* @dev calculate the winner
* Requirements:
*   - Action of the first player 
*   - Action of the second player
*   1 - Stone | 2 - Scissor | 3 - Paper
*   1 => 2 => 3 => 1 => 2 => 3
*/
function calculateWinner(int8 p1, int8 p2) private pure returns(int8) {
    // 1 - k; 2 - n; 3 - b
    if (p1 > p2){
        //return (p1 - p2) > 1 ? 0 : 1;
        if ((p1 - p2) > 1){
            return 0;
        }
        else {
            return 1;
        }
    }
    else if (p1 < p2){
        //return (p2 - p1) > 1 ? 1 : 0;
        if ((p2 - p1) > 1) {
            return 1;
        }
        else {
            return 0;
        }
    }
    return -1;
}

После того как определили победителя у нас идет вызов функции распределения ревардов setWinner(). Если в данной игре есть победитель, то на его счет упадут токены рассчитанные по формуле (gameCost() * 2) / 100 * 90, это 90% от стоимости двух входных билетов, оставшиеся 10% летят в наш банк, можно реализовать супер лотерею на которой будет один или несколько счастливчиков, либо оставить в виде комиссии. Реализации в данном контексте нет, остаток просто оседает на адресе контракта. В случае когда победителей нет, мы честно возвращаем стоимости билетов без издержек.

/* @dev calculate the prize and transfer to the participants
*
*/
function setWinner(int indexWinner) private {

    if (indexWinner >= 0) {
        _jackPot = jackPot() + ((gameCost() * 2) / 100 * 10 );
        uint256 reward = (gameCost() * 2) / 100 * 90;
        if (indexWinner == 0) {
            _transfer(address(this),_players[0], reward);
        }
        else if (indexWinner == 1) {
            _transfer(address(this),_players[1], reward);
        }
    }
    else if (indexWinner < 0) {
        _transfer(address(this),_players[0], gameCost());
        _transfer(address(this),_players[1], gameCost());
    }

    _gameId++;
    _players = new address payable[](0);
    _playerAction = new int8[](0);
}

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

modifier onlyContractOwner() {
    require(_contractOwner == _msgSender());
    _;
}

Наш смарт-контракт готов, осталось сделать деплой и проверить все.

Код на github