Blog RSS Feed

About Me

Gm 👋

I’m Filip

Building the future

No title

A layman opinion on nation states

Wed, 06 Mar 2024 18:00:00 GMT

I’m writing this post just as a short personal note of thought on states in general. I might be very wrong with some opinions. If I am, I’d love to be able to acknowledge it in the future and look at the post in retrospective to better understand evolution of thought.

How states form, probably

States and territories, that formed organically, were formed by ability to coordinate in that specific group which is to form a state.
Coordination in real world relies on trust, and trust is established between groups which share the same or similar enough values.
Even if some values weren’t an exact match, geography or some other physically forced events (conquest for example) would force groups to merge together and over time achieve values similar enough that it’s not a obstacle anymore to coordinate.

Humanity

I currently believe all humans are of the same nature but that the environment where that person is interacting/living in will highly influence opinions. In other words, I believe morality is pre-defined, objective standard in all humans. But it’s just a standard. Genetics, environment, experiences will form and move behaviour and opinions across the spectrum. Coordination becomes harder between two isolated groups after long enough period. but not impossible. (remember objective standard which states all humans are equal and deserve same treatment).

In practice, trust won’t be established without shared values. World was on the verge of nuclear war for most of the 20th century, and not without a reason. When you have two opposing systems of value, you’re subconsciously inferring that you don’t know how person B will react to action X, but you could guess in your group of people. By being able to assume, you make coordination much faster. Basically, establishing trust.

Coordination

It’s a very important topic for humanity, even if we aren’t aware of it, on how to keep our civilisation going without destroying each other. One of my favourite posts of all time cover this to a great extent, I highly recommend reading it here

Solution uno

Establishing humanity wide trust by eliminating the reason fuelling the need for it, fear.

Fear can be either removed by achieving perfect coordination, trans-humanist goal of raising above the material.
Or by removing the emotion itself, but that raises the question if we’d still be human after?

Solution dos

The other solution is much more practical.

We first assume that complexity of the world won’t allow us practically to find perfect common ground between everyone since everyone is prone to have a slightly biased opinion on various things.
Secondly, we make an axiom: “all human beings are valuable and equal”. Although this requires humility on everyone’s end since we’d also be saying that our opinion is also slightly biased and isn’t perfect, because no one is perfect. Subconsciously, that makes us have to accept that we might be wrong on a lot of things and need to keep an objective mind. Again, out of fear for survival or attachment to something, some opinions are very hard to change, and probably justifiably so!
Now that we are aware on why it’s hard but can value objectivity, we can build systems which require no trust and aren’t physically limited.

Basically the second solution is to create tooling which allows trust-less coordination between parties. Although I’m not completely sure on what exactly that tooling would be and the practicality of achieving it.

Network states

The effectiveness of the solution uno seems to be hardly achievable and the morality of it is highly controversial. Solution dos, although at the first glance less efficient, is much more human and personally more likeable.
I’ve just started reading on network states, but it seems like it’s a step in the second direction. It seems like there are a lot of things to be aware about before being able to give even a layman opinion. (incentives, conflicts, governance, obligations etc.)

Expect a layman look at network states at some point, you’ve been warned!

Trustless Attestation

Thu, 01 Jun 2023 15:00:00 GMT

Using his telescope, Galileo Galilei was the first to discover Saturn’s rings. At the time, he still wasn’t quite sure what they were and wanted to spend more time observing them.

Nonetheless, Galileo knew his discovery was something special and wanted to claim it without giving away any info about it. To do that, he went on to send letters to his friends and colleagues containing “Smaismrmilmepoetaleumibunenugttauiras” which, when unscrambled, becomes “Altissimum planetam tergeminum observavi” meaning – “I have observed the most distant planet to have a triple form.”

Why is Attestation important

As you can see, even centuries ago people had a need to prove time and ownership of a document, discovery, or in modern times even pictures. But our ancestors had to rely on letters not ending up lost, damaged, and the trustworthiness of the receiver. Now we have third-party organisations that handle this for us. And while the message probably won’t be eaten by a horse, you are entrusting data to a third party, which could pose a problem for proving to someone it’s valid.

Let’s say you want to prove the time of taking a picture IMG to person P. If you know ahead of time whom you’re proving IMG to, you can timestamp the picture to a third party you both trust. But what happens if you don’t know who person P is or which the third party it trusts? To ensure your proof is going to be accepted – you will need to send your picture to a lot of “trusted” entities.

“Trust no one on the internet, not even yourself.” - Galileo

Practical use cases

You might be thinking – I’m not Galileo, or for the matter, the majority of people are not astronomers, so why should I care about this?

Car renting

Imagine you rent a car, and after you take the car you notice a minor damaged part which doesn’t prevent you from driving. Let’s say you are in a big hurry, and you can’t return it, but you know that after you ride the car you won’t be able to prove it wasn’t you who did the damage. What you could do is take a picture of the damaged part and post it on the blockchain with . And boom, just like that, now you have proof it happened before you drove the car and can still keep driving it without worries.

Notary services

In many third world countries there are no public notaries to memorise agreed contracts. So what happens? Alice agrees with Bob to sign a contract, but that contract can’t be publicly memorised at that moment. So if Bob changes his mind or wants to forge the contract, it’s very hard for Alice to prove the contract ever happened or that it lost its integrity. But if both persons take a picture with a contract, when the contract is published on a blockchain it’s very hard to invalidate its integrity.

And many more…

There are numerous practical use cases where attestation is important.
Use cases where it’s already being used but can be tremendously improved and optimised with the use of right technology.
Or other use cases, where due to previous technical limitations, a solution just isn’t yet available

On-chain KYC validation
DeFi AML validation
Reputation Systems
Parking Ticket integrity
University diplomas
Passports
etc.

Building the base

First things first, before building a house, we need to build a good, strong and stable foundation.

Ethereum gave us an abstract base in form of EVM and Smart Contracts and allowed seamless interoperability through a standardised but decentralised machine on top of which we built whole Ecosystems. Important factor was composability through trustlessness, giving us whole bunch of Lego brick to build more complex protocols on top of each other.

The same thing needs to be done for Attestations, bottom up approach. Standardisation of the base layer on how it should be done, but abstract enough to not limit layers on top.
Upon which we’ll build out all the solutions we discussed above.

Ethereum Attestation Service

As per the words in the documentation of EAS

Ethereum Attestation Service (EAS) is a public good that enables anyone to make attestations on or off-chain about anything. You simply register a schema (or use an existing one) about any topic and make attestations using that schema.

How does it work?

EAS (Ethereum Attestation Service) acts as a global registry for creating, verifying and coordinating unique “schemas” used for later attestations.

It’s a base layer protocol, written in Solidity and running on EVM compatible chains.

The attestations can work both on-chain and off-chain with different pros and cons depending on the use case that we’re building, we can weight the pros and cons of each option and then decide what’s the best solution for us. Important factor is that it’s not opinionated, so it doesn’t limit us instead of empowering us.

On-chain attestation is going to give a bunch of benefits to applications that need to verify on-the-network, but in return will yield higher prices because of transaction costs and depending on if we use Zero-Knowledge proofs or not, degraded privacy for data that shouldn’t be public.

Off-chain attestation provides value in allowing the entity that is using the service as it’s foundation to have more control over privacy and cost of the product. It isn’t stored directly on-chain but still contains all the necessary attestation data (timestamps, messages, signatures for verification…) but in return, while implementing it, we’ll have to be a bit more careful on how to reduce trust.

Smart Contracts

The protocol’s Blockchain layer can be simplified to having two primary smart contracts written in Solidity.

SchemaRegistry.sol - Smart Contract responsible for registering schemas, later used for creating attestations.
EAS.sol - Smart Contract responsible for creating actual attestations on-chain and managing their later state.

So, in a summary:

One to register a schema
The other to make instances of those schemas (Attestations)

Pretty simple, but again pretty powerful.

No-Code UI

If you don’t want yet to get your hands dirty, you can access the protocol through Its website https://easscan.org/ and start interacting immediately.

We choose or create a schema, I’ll pick “Write a message” one here 📝
We make an attestation through a simple form, I’ll claim I’ve discovered Saturn here 🪐
Confirm the transaction in your Metamask ✅

That’s it! In three steps, I’ve claimed some information on-chain in a trustless manner, forever!

My transaction is recorded on Ethereum and I can check the contents of the message in the EAS explorer.

Buidling

It’s exciting to see what other use cases will people come up with. The important thing is that we as a community provide Developers and Builders with good tooling to work with as well as space which encourages and incentivises everyone to do so.

To find out more about Ethereum Attestation Service, you can find protocol’s website here, documentation here and if you want to be more hands one with contributions to the protocol, the Github repo is located here.

Developer's intro to zkEVMs

Mon, 09 Jan 2023 02:00:00 GMT

Since the beginning of Ethereum, there was always a vision of scaling the blockchain up and making it capable of achieving much greater transaction output and speed.

That was especially true after the DeFi summer when Ethereum gas prices skyrocketed and a lot of other Layer 1 solutions came up promising exactly that.
There was a power vacuum that emerged from this but the Layer 2 solutions, Ethereum PoS and Ethereum sharding still weren’t there.
Because of that, chains such as Polygon, Avalanche, Gnosis, Fantom, Solana, Near and many others took the opportunity and created Layer 1s which had to sacrifice decentralization to deliver the promises.

Lately there’s been a lot of buzzing around emerging Layer2’s as the zkEVM space started to mature and optimistic rollups got more attention.
All of a sudden, It seems that decentralization is again the way to go and that we’ll see another wave of competition, just this time it’s going to be between rollup solutions.

What are Layer 2s?

The term refers to solutions that execute blockchain transactions off the chain and compress many times more in a single transaction that is settled on Ethereum (Layer 1), hence keeping the original security and decentralization while scaling its original L1.

What types are there?

There are many unique approaches to these solutions, but the primary ones are Optimistic Rollups and ZK Rollups (Validity proof Rollups).
There’s a lot to cover here, but for this post, we’ll focus on ZK rollups, more precisely on the solutions that solve EVM execution through zero-knowledge proofs or even more precisely: zkEVMs.

zkEVM differences

Not all zkEVMs are created equal. There’s a subdivision here as well.
The primary way we can look at it is through the lens of how easy it is for existing code to be deployed as well as how useful existing infrastructures and developer tooling are.

In relation to EVM, we can create two divisions here:

Language compatible solutions
Bytecode compatible solutions
Consensus level solutions

source: Messari.io

Language compatible solutions

These solutions aim to transpile existing Ethereum smart contract languages to their own bytecode compatible to run on their ZK Virtual Machines.
The primary players here are MatterLab’s zkSync and Starkware’s StarkNet

Bytecode compatible solutions

These solutions aim to interpret EVM bytecode directly, either by translating it to its own VM bytecode (Polygon zkEVM) or by running it directly (Scroll).
Although the former is a good approach from the safety side (maybe some opcodes can’t map properly to zero-knowledge friendly VM) the latter is definitely superior in terms of developer experience.

Scroll

And finally to come to the product you’re probably here for, Scroll.
As per the words of the builders themselves, Scroll is “zkEVM-based zkRollup on Ethereum that enables native compatibility for existing Ethereum applications and tools.”

One of the main principles of Scroll is “EVM Equivalence”. Their main claim is that any existing smart contract can be deployed effortlessly on their network due to the equivalency of the underlying zero-knowledge VM to Ethereum’s VM.

Testing the thesis

I wanted to test this thesis, hence this blog post.
How will I do this?

I’ll take less popular developer tooling to see if it works and to make sure there wasn’t any hard-coded patch made for popular tooling such as Hardhat
I’ll write one smart contract in Solidity and the other in Vyper to make test bytecode compatibility instead of the usual “Solidity” compatibility.

Let’s make an NFT through a custom multisig

Initializing the brownie project

The primary thing to note here are:

contracts folder - This is where our NFT and Multisig contracts are located
tests folder - This is where the unit tests are to make sure everything works as expected
scripts folder - Scripts which we’ll later use to interact with the Scrolls L2 network.

The project structure

Creating the Smart Contracts

Now we’ll create two smart contracts.
One that will manage the NFT logic, minting, ownership etc.
This smart contract will be called TheNFT.sol and is going to be written in Solidity.

The other one will be responsible for managing Multisig logic. We’ll be able to create on-chain smart contract execution proposals, vote for them and finally, execute them.
This smart contract will be called Supersig.vy

You can check the full code base of the project on my github.

Deploying the actual contracts to Scroll

Scroll started opening up its network to the public this summer (2022). Initially, it was a gated alpha where as of now, everyone can use it and try it out, including you and me as well.

We’ll start by running the deploy.py script which will deploy new instances of our smart contracts and return us the addresses.

As we can see, the contracts were successfully deployed. We can find them by typing those into Scroll’s Block Explorer search bar in the top right corner.

TheNFT.sol: Link to contract on L2
Supersig.vy: Link to contract on L2

It seems that contracts are easily deployed, so no problem with developer tooling, even the non-mainstream ones.
That makes one of the statements true, developer tooling does work out of the box. ✅

Interacting with the smart contracts

Now it’s time to interact with our contracts, we have two scripts prepared for this part.
Let’s get our hands dirty.

transfer_ownership.py
This one will prepare our NFT smart contract to be used by the multisig that we deployed earlier by giving it ownership rights. When we run it we get the output below:

Brownie is telling us that the transfer ownership was confirmed and we can commence minting our NFT.

multisig_script.py
Now, we will go through the whole flow of proposing a minting transaction to executing it and finally giving us our very own NFT on Scroll.

Let’s break this down:

First, we propose NFT minting by calling the propose() function inside our contract
Second, we as one of the participants of this multisig approve the proposal. And because we’ve set the threshold to just 1, this one approval will be enough to be able to commence to the next and final step.
Finally, we execute it. We can check out the whole transaction in the block explorer by typing the tx hash into the search bar. Or more easily, just by pressing this link.

And voila, our NFT was minted successfully. Hence the second statement is true as well, the network is bytecode compatible with any language that gets compiled to the EVM bytecode. ✅

The future

Although the race is getting hot, and this is a topic of interest of many right now, there still isn’t a solution that provides a full consensus-level solution that can be replaced inside Ethereum itself. Scroll is possibly the closest protocol right now aspiring to this goal and I’m very excited about the future of the ecosystem.

@pseudotheos wrote a good blog post regarding the breakdown of the current zkEVM space, you can read the post here. It’s on us to research more and develop a truly decentralized solution worthy of scaling Ethereum and reaching out to more users.

There’s a lot to digest here, so get to work anon!

Resources

GitHub Repository of the Project used

From Simple Primitives to Complex DeFi Strategy

Wed, 06 Apr 2022 16:00:00 GMT

Diving into DeFi can be very exciting. It’s a very fast-moving environment with new yield sources being created all the time. This is especially observable compared to TradFi, where stuff moves very slowly and innovation takes more time. But because of transparency and how blockchains work architecturally, the DeFi strategy can be an even more powerful asset if you’re wearing a technical hat.

Programmable money

One of the most important things that were introduced with web3 are smart contracts. Smart contracts are simply pieces of code executed on a decentralized computer in a trustless way.

Although a very dull and simple way of describing them, I want you to take two things from this:

Lego bricks – Smart contracts are pieces of software on a decentralized machine that everybody can use. This means we can take advantage of their composability and create more complex and efficient systems with just a few “primitive” ones.
Code is a law – No one can censor or modify what a smart contract will do once it’s on the chain. A transaction will either revert or not based on the conditions that your transaction fulfilled all “requirements” written in the code.

Flash Loans

Considering these two attributes above, DeFi introduced a powerful and innovative mechanic to the user’s tool belt.

Flash loans are basically unsecured loans that will have to be repaid with interest by the end of the transaction. Thinking in the sense of TradFi, you would intuitively think of only one transaction not being enough for this to be useful. Still, the Lego bricks concept allows us to create complex operations executed in a single transaction.

Because in web3 code is a law, if the flash loan mechanic is implemented correctly, it won’t allow someone to take the money from the protocol and runoff. In other words, we can be sure that that money will be repaid and given to someone without any collateral or any additional check whatsoever.

Source: FLASH LOANS Explained (Aave, dYdX)

Evolution of DEXs

When Ethereum launched in 2014, people immediately saw the opportunity of improving our financial system with more efficient mechanics.

As with most innovations, a project can’t start as a Ferrari. We first need to build a Ford and then reiterate and improve for more efficiency, reliability and functionality.

Order book model

To start off, we (the people) copied an existing working system and put it on-chain. So we created a system following the CLOB design (Central limit order book).

Orders happened on-chain
Actual peers had to identify orders they were willing to take
Execution of those orders happened on chain
This initial model is very expensive in terms of gas and also very inefficient as they require someone on the other side to match them.

The next iterations were in making orders and executions happen off-chain to spend less gas, but there still was a bottleneck in the user’s matching. This is a problem if we are trying to build another protocol on top of these DEXs.

Here come the AMMs

For a protocol to truly strive from the perspective of a blockchain developer, it first needs to allow the ability for it to be automatized. Also, it needs to enable composability, so other more smart people can build on top of it. That’s what we developers do – we make stuff more efficient.

Then Uniswap came. We concluded the Order book model was too slow and expensive, so why not remove it altogether?

This architecture of an AMM allowed Uniswap to achieve amazing growth. Permissionless, “always-on” liquidity allowed other developers to build on top of it and let the creation of much more complex financial systems and the boom of DeFi summer very soon.

Bots

As systems became more developer-friendly, that meant certain operations could be automated.

For example, it keeps the asset prices on DEXs, the same as on the open market by arbitraging and automating this whole process with bots that will do that for you and earn money.

An even more powerful mechanic is that you didn’t have to own any capital at the start. You just needed your brain, and you could leverage mechanisms such as Flash Loans to fund your operations. In other words, finance was democratized to everybody instead of just the wealthy elite.

Yield Farming

Here comes the fun part. The ecosystem grew day by day, and protocols that already existed were improving toward the more efficient philosophy we talked about above.

Lending and borrowing protocols became more efficient and useful to regular users as. Protocols now had competitors with whom they battled for liquidity. Thus each is improving their own protocols and making everything better for us users.

The market grew, thus the total capital and it was becoming harder and harder to keep up with all the opportunities.

You could hardly keep up with what was happening and even more so as a developer to automate the whole process for other protocols which envisioned a different way of doing things.

It was hard to keep track of all your positions, if something won’t get liquidated, if your infrastructure was working properly, was stuff getting compounded, etc.

Yearn Finance

And people said, let there be an automated yield aggregator, and thus automated yield aggregator was.

Yearn abstracted all of the problems above, taking care of possible opportunities, taking care of the infrastructure, and ensuring that assets are safe. They are giving the User a very simple gateway into DeFi in just depositing the asset you want your interest to be made in.

A good comparison in the physical world would be a car. A car is a very complicated piece of machinery. All the parts working together in cohesion to take us from one place to the other efficiently is an amazing achievement of engineering and humanity.

We don’t think too much about it exactly because of how simple it is from the User’s point of view. The same is with yearning and it’s amazing what the Yearn engineers have accomplished here.

The beauty of this is that the composability is infinite. Many other projects are building on top of Yearn, making even more complex financial systems but at the same time even so more elegant and beautiful.

This simplicity on the front and complexity at the back is what drew us to build on top of Yearn Finance. The end-users, in the end, just want a simple and safe way to compound their earnings and grow their principal. Here is an example of what a manual strategy looks like.

After initial fascination with this composable, foldable programmable money, the reality kicks in and you realize that although you can do all of this manually, why should you? We built Tesseract on Polygon and Avalanche (chains that have pretty inexpensive transactions compared to ETH mainnet).

The main value for people is no longer “pool together funds to make farming profitable for smaller amounts”. Instead, we automate things and make sure that things are safe. Things are moving really fast and keeping all the strategies up to date is a pretty monumental task.

Check out the story of Tesseract here.

Leverage farming using Tesseract

Wed, 09 Mar 2022 16:00:00 GMT

Sometimes it seems as if some UIs are deliberately complicated to use. We wanted to help out a bit and show you, through example, one DeFi strategy and how to leverage credit to make money.

In the fast-paced world of web3 and DeFi, it’s easy to lose focus and move to the next great thing, but we think that DeFi is here to stay.

What is AAVE?

AAVE is a decentralized lending protocol that allows users to lend, borrow and earn interest on their assets. In other words, it allows the users to put their assets to work instead of them. They can just sit around in some wallet doing nothing, all without having a middle man.

Where is AAVE available?

AAVE is one of the pioneers in DeFi. It reiterated versions of the protocol over the years, the newest one being v3 and expanded to multiple blockchains.

Currently, the Ethereum mainnet has the legacy v1 market and the current v2 market. But Ethereum can be expensive for most users because of the gas fees. That’s where Polygon and Avalanche markets come in to make decentralized lending available to everyone.

The current TVL of AAVE is around 12 billion USD by Defi Llama data making it very liquid and stable for usage.

How does AAVE work?

Since, at the moment of writing, there aren’t credit checks or credit scores in DeFi, all loans are provided on an overcollateralized basis. This means that you first have to provide a deposit of larger value than the loan itself to take a loan.

The first question that comes to mind is, why would you take a loan if you already have an amount larger than the loan itself to back it? Why not just sell the assets? By selling the assets, you are closing your position completely and losing potential profit if it goes up. In this case, if some unexpected expense comes in, you can borrow some stable coin, for example, and return the loan while still keeping the base deposit for yourself.

The other use cases could be new investment opportunities like shorting another asset, longing the deposited one, or leveraging some asset for larger APY.

What is Leverage?

Leverage is a strategy of using borrowed funds to increase the potential returns of the original investment. You deposit one type of underlying asset to borrow a different one or even the same one to increase your overall liquidity and ability to earn higher rewards.

How to leverage credit using AAVE?

Supplying assets on AAVE

Step 1: Go to the AAVE app and pick your market. For this tutorial, I’ll be using Avalanche. Step 2: Connect your wallet. You’ll see a big shiny “Connect” button in the top right corner. Once pressed, you can pick the wallet you want to use and you are good to go.

Step 3: Pick the asset you want to deposit from the asset list. I’ll be depositing some Avax.

Once you open it, you’ll see all kinds of information, but for now, these four things are important:

Maximum LTV: This is the maximum loan you’ll be able to take for this asset. For example, for 100$ worth of AVAX, you’ll be able to take a loan of 50$ worth of DAI
Used as collateral: This is the flag that tells us if we’ll be able to take a loan with AVAX as the collateral. (Important for our leverage strategy)
Liquidation threshold: This is the point at which our loan will be liquidated if the value of the loan is reached.
Deposit APY: APY that we’ll be making on our AVAX deposit

Step 4: Choose the amount you’ll want to deposit, approve the transactions in your wallet and voila, you are all set. I’ll deposit ~100$ equivalent of AVAX.

You should now be able to track your position on the app’s dashboard page.

Borrowing assets on AAVE

The fun part is that once we have our assets deposited on AAVE that we can use as collateral, we can borrow something that we deem will make us even more money.

Step 1: Go back to the markets page, and find the asset you want to borrow. On the right side of the page, you’ll find the “borrow” button. Once clicked, you’ll be prompted with input on how much money you want to borrow.

Step 2: Determining how much. Based on the health factor, you can choose to be on the loan’s Safe or the Riskier side. Meaning that it’s more likely for your assets to get liquidated or less likely. For the sake of the example, I’ll go into the safer side of the territory and borrow ~20$.

Step 3: Then, we pick the type of interest rate. In this case, only the variable APY is available, wherein there’s also a Stable interest rate. You can consult the difference between these two in the AAVE documentation here.

Step 4: Approve the transaction, wait for it to be mined and now you should have received your dai. To see more information on your position, you can again go to the app dashboard page for a nice overview.

Using newly acquired assets to make more money

We’re almost there! You’ve acquired more funds and determined there’s a good opportunity somewhere to earn interest higher than the borrowed APY and later keep the difference-making the whole hassle worth it.

I won’t be getting into the complete details on how to do this, but I’ll try to give you some general idea on how to make it worthwhile.

We can now use the newly acquired funds to become a liquidity provider on Curve.fi atricrypto pool with its base APY of 3.22%. Which is enough to pay the borrow rate on AAVE once we decide to return the loan. To be clear, I’m talking about this pool here.

But wait, we still want to make some money. We take a look somewhere else and notice that Tesseract finance provides 9.50% APY for atricrypto LP tokens. Meaning, in the end, we get to keep that APY for ourselves.

The non-attractive part

You’re now a certified DeFi degen. Although you’ll now be making a lot more money than before, having leverage means that you’ll have to actively manage it and ensure your assets don’t get liquidated. This can be tiresome and time-consuming, especially if you’re employing a bit more complex strategies like the one described in part above.