Nice to meet you, I'm Pavel!
Currently I'm a blockchain developer, doing different things trying to find out what I like the most
The most interesting so far is designing the systems making sure that they can interact with every other part of the system, and developing automations/internal tools that will solve some problem that exists either for the whole team or just for me
My own projects
MyOwn
CEO & CTO & The one and only employee, 1999-09 - Present,
Building stuff for myself
This website :)
This page is the second version of the page where I collect information on what I've done so far
Learning projects
Until recently most of the projects that I was a part of required learning a lot of new technologies, that I didn't know how to deal with
This lead to creating a lot of micro learning projects that helped me to get a grasp of what is going on and how i can use it at my work, most of those projects are not published and are unavailable for the public
This way I've being learning Go, NestJS, React, Svelte, Huff, Redis, RabbitMQ, Svelte, React, NextJS, Kubernetes, ...
Huff hackathon 2023
This one is cool one, because it allowed me to get better with EVM assembly and try to make something without any guardrails
I've being interested in EVM assembly for quite some time, and this was a perfect opportunity for a deeper dive
Fun fact: the hackathon was hosted using Optimism network, which did not include all the new opcodes, to be exact it didn't have PUSH0 opcode, which adds zero to the stack. How do i know this? I've spent 3 hours trying to understand why my code isn't working, before finding out that the problem was with this opcode. Hackathon was hosted in 24 non-stop format, but after this one I was not ready to continue unfortunately.
NeoVim extension for usage counters
When I started using NeoVim (I use Vim btw, just joking, I use Jetbrains IDEs and very happy with it), one of the problems was that I didn't know amount of references to a class/constant
After a quick search I found an extension that was able to solve the problem, but it didn't work correctly.
So I've forked it, modified it in a way I wanted and now it's useful for me from time to time
Snake in GO
What can you build to learn some new language? Snake game
Event gathering service in GO
I decided to start learning Go, the first idea for a backend service was to create event gathering service, so here it is
Http service monitor with Telegram notifications
The idea was to create a generic solution for monitoring http endpoints with notifications that will be delivered to me via convenient medium for me (in Telegram), so here's a http service monitor with Telegram notifications :)
To be continued...
And here's the stuff I've being doing professionally for some time (creating web-pages was I not)
Statecraft
Blockchain developer
2024-03 - Present
Bluelight
Blockchain developer
2022-11 - 2024-02
HodlTree
Blockchain developer
2022-01 - 2022-05
Tokenstation
Blockchain developer
2021-09 - 2024-01
SVOIdev
Blockchain developer
2020-09 - 2022-02
IZZZIO
Blockchain developer
2020-03 - 2020-06
¯\_(ツ)_/¯
Vniins
DevOps engineer
2018-12 - 2022-06
Let's dive in!
Statecraft
Blockchain developer, 2024-03 - Present,
Building platform for creating network states
Key problems
Extensibility
As we don't know where the system will be in one year, two years or in five years, it's required to make base architecture as flexible and extensible as possible
Security
While thinking about extensibility it's also very important to remember that if everything is stolen and broken, perfect and extensible architecture doesn't really matter
Throughput
As the target amount of users lies somewhere in thousands, it's crucial to make sure that all of the operations are either atomic, or they try to be as close to atomic as possible. One operation must only interact with user data, shared data and temporary data. In other case operation in most cases (where we've got more than 10 users) cannot be completed.
Highlights of what I've done at this point
Designing smart-contracts
We need smart-contracts to get something done, so we need to know in advance how the system components will interact with each other, making sure that the system is extensible and we can support it in the future
System for executing custom user actions
- We needed a system that will allow users to perform any kind of action that is available in the system, while providing security, integrity and an option for easy extension
- To solve this I've developed a modular system that provided required extensibility and required security and system integrity levels
Deployment system for user's network states
- Deployment system uses smart-contracts to create a safe deployment environment
- It's possible to create deployment of any size and perform it step-by-step achieving desired system state
- Deployment uses checksums and IPFS to achieve this
Extension system
- We had a problem of making system extensible, easy to operate and have an option to add new functions dynamically
- To achieve this I've developed set of custom smart-contracts so now we can hit all of the requirements
Bluelight
Blockchain developer, 2022-11 - 2024-02,
Building smart-contracts and backend services for web3 game
Key problems
Who must pay for transactions?
A lot of work was spent trying to come up with a solution for providing system security and making sure that we can handle user operations in different ways - if the operations are performed only by the users (they spend their money paying for the operations) or combined approach, where we can perform some operations for users (they pay nothing for the transactions)
web2 - web3 interactions
Another problem was that this project is 2.5web game - it has web2 backend services for the game part and web3 elements, so we needed a way to allow backend part to make decisions if the action is allowed for user, or not, e.g. is it okay for user to withdraw 200 in-game tokens to blockchain or not
So what's the solution?
One of the solutions that I've come up to was to use EIP-712 signatures that provide us required security for user operations, so most of the time was spent developing smart-contracts and backend services that will grant users approval for performing actions
Highlights of what I've done
Designing and developing smart-contract system
As usual - it's required to make sure that smart-contracts can interact with each other in extensible manner, securely and other parts of the system - backend and frontend can get all the required information and perform all the actions required
Anti-bot system
- After initial launch we have encountered bot attacks that threatened to drain our system
- By analyzing transactions and way that these bot farms were organized, I've proposed a solution (that cannot be named) and implemented it
- It was possible to detect most of the bot addresses based on the on-chain activity analysis of the player addresses (around third of the players were bots), and after implementing and integrating this service the bot attacks stopped
TheGraph subgraph for the smart-contracts
- Developed subgraph that stores all the required information about the smart-contracts
- Information was used by backend services and frontend application, that were developed by me and other team members. As a result it was possible to lower reads from blockchain and perform almost all data fetching using provided graphQL interface
OpenTelemetry and Sentry integration
While developing backend services I've encountered problem - we don't know pod load, when it crashed and what endpoints got hit the most
- I've integrated OpenTelemetry to the blockchain-related backend services and set up metrics in Prometheus
- I've integrated Sentry to the blockchain-related backend services, so we had all the information about crashes (there were almost none :) )
Application management and server/cloud setup
- Containerization of applications, creating K8s and Kustomize files for deployments
- Setting up base Ubuntu servers for selfhosted TheGraph node and some internal tools
- Setting up and managing Kubernetes clusters for dev/staging/prod in Azure cloud
Tokenstation
Blockchain developer, 2021-09 - 2024-01,
Building stuff with friends :)
Key problems
No money
Solution
Make something that will bring us money
What have we done?
TRON hackathon 2022
While working at HodlTree I had to work a little bit with Balancer protocol and was interested in how it works and the idea of making different liquidity pools to work together was very fascinating, so i started deconstructing the protocol and thinking how can i implement it in a different way.
With this idea to create a solution that will unite different liquidity pools in one system we entered the TRON hackathon 2022 and took 4th place in DeFi category.
I was a single solidity dev responsible for all the smart-contracts and helped a little with our backend services for gathering events (TheGraph-like solution for TRON is still non-existent)
NFTs
Everyone did it, but not everyone wants to tell you about it
The most interesting part was optimizing open-source Python image generator by adding multiprocessing (not multithreading) to it, thus making it run 6-7 times faster than original single-threaded version
AML service integration
Not a lot of interesting stuff, just making a service that glues together AML service and custom smart-contracts
HodlTree
Blockchain developer, 2022-01 - 2022-05,
Supporting existing projects
Not really a lot to tell, this was the place where I was introduced to stand ups, sprint planning and discovered a lot of web3 projects
Onchain arbitrage
- Discovered what delegatecall can be used for
- Added new DeXes to the platform - a lot of UniswapV2-like, Balancer, mStable, 0x and some others
- Added notes on the inner working of the exchanges to help with their integration to the backend system
Stablecoins flashloan solution
- Added new tokens to the flashloan system
- Extended test cases
Hedging solution
- Bugfixes, testing
SVOIdev
Blockchain developer, 2020-09 - 2022-02,
Developing stuff that the boss wanted us to
Key problems
Asynchronous blockchain
In this company we worked with an asynchronous blockchain, called Everscale
Asynchronous in this case means that there is no single point of fail, anything may fail and you wouldn't even know about it, as calls to smart-contracts are spread across different blocks.
No developer tools
Almost no tools were available for developers, we had only compiler for the smart-contracts and NodeJS bindings for basic operations, so everything from smart-contracts deploy system to debuggers had to be written from scratch
No documentation
We had only official documentation, which was not very clear for some topics and a chat in Telegram that hosted (I think) all of the developers for Everscale (or at least most of them)
Solution
Create our own developer tools from scratch, report bugs back to the developers of Everscale and be active in Telegram chat :)
So what was possible to do in this conditions? (spoiler: everything)
Developer tools
It was a bit tough, but I've managed to create some tools that helped us on the way to building stuff
- Small framework for testing that simplified testing of smart-contracts
- Deploy tool for the smart-contracts
- Debug tool that helped to debug asynchronous smart-contracts interaction and performed decoding of transactions so it would be easier to understand where something failed
Jury duty
Yup, I was a part of jury for the hackathons for Everscale as one of developers that had at least some idea of what is going on. I've managed to find the proposal that was required for becoming a jury :)
DeFi hackathon, part 1
This project was developed for the hackathon that was hosted by the community of the chain, it consisted of three stages - initial development, improvement and user incentives
At this stage we just tried to copy the UniswapV2 architecture to the asynchronous blockchain and learnt how it works and what quirks Everscale blockchain had, it was very painful to be honest
DeFi hackathon, part 2
After the initial stage, the smart-contracts looked like a mess, so I've decided to step back and rewrite the original smart-contracts so that they would fit the developing patterns that started to pop up
Full rewrite of the smart-contracts, so they would work and could interact with new token standard (TIP-3)
DeFi hackathon, part 3
At this stage base smart-contracts were finished and the only thing that we needed to do was create some user incentives like staking
So, I've developed
- Staking smart-contracts for user incentives
- Backend service for gathering events from our smart-contracts
Lending protocol
Long story short: we received a task for creating lending solution
What was done in order to try and make it work:
- I've researched well-known lending protocols, e.g. Compound, AAVE, Maker and JUST to find out how they work and got sad because they all work in synchronous world, which makes everything 2 times easier
- Created math model that will serve as a base for our lending protocol
- Created set of smart-contracts that implemented math model, base operations and accounts for users that held information about the user
- Tried to test it all, but failed in the end, as the system was too large for a single smart-contract developer (me) to handle, as asynchronous model turned the system in callback hell with a lot of security problems
IZZZIO
Blockchain developer, 2020-03 - 2020-06,
Building our own custom blockchain
Key problems
NodeJS
I don't know anything about NodeJS and asynchronous operations
Blockchain
A lot of people
This was the first time working at a place where I had to interact with a lot of people working with the same code base
THE solution
Just sit down and learn everything required, while trying to be useful for the team and making contributions that I can handle or that relate to my previous experience
What have I managed to do before Corona hit everyone and sadly we got closed too :C ?
Learn stuff
- Learn how GitHub works and how to automate
- Learn basics of NodeJS
- Learn basics of Blockchain
- Learn basics of working with people on a single codebase
Caching for blocks
The blocks that were requested recently are the ones that will be requested more frequently than others, as most of the time it's either a fresh block and we need to distribute it/perform some reads or requesting some historical information for a specific block
Loading data from storage is slower than loading it from memory, so a timeout-based cache was added
Automation for building executables
We needed a pipeline that will automate building Windows and Linux executables for every release, so that we wouldn't need to do it manually
¯\_(ツ)_/¯
Vniins
DevOps engineer, 2018-12 - 2022-06,
Doing stuff
Here's the stuff I can disclose:
Changed background image for GRUB :D
It was a bit painful, but fun and here I found out that Polish notation exists and GIMP is not a meme, but a useful piece of software
Supported bash-scripts for building OS
A lot of Bash and pain
Fuzzing of custom Linux core
syzkaller one love, making custom core work with it is pain
Load testing of data center
Ansible + Bash magic + Zabbix + help us gods
