how to pick which crypto projects to buy

Yourself

Everything in this section is about removing your emotions from the decisions.

What is your aim?

Do you want to accumulate BTC, ETH, or USD? Depending on which, you have different trading opportunities. One coin might be a good deal if you’re using ETH to buy it, but not BTC.

How much do you want to risk?

I find that 1 month’s living expenses is a good size, with many psychological benefits. You have a good intuitive feeling for how profitable the trade is, after all.

What is your trading plan?

If it goes up, do you plan to sell everything or keep something? How long can you afford to wait for it to move? Answer these questions first and you can ignore your emotions later, when they endanger you the most.

Project

What does the project do?

Look for something that generates value: opens a new dimension, makes new things possible etc. This is also better for the world.

The difference between a Ponzi scheme and Bitcoin is that the former is just moving money around, and it collects in a few hands. The latter is a whole new asset class with big social implications, i.e. it opened up a new dimension. That is, it generated value.

Bitconnect was an obvious scam, but many people apparently couldn’t tell. A trading bot cannot always make profit. Even if it does, trading is basically taking value from someone else, a zero sum game, so it cannot generate value. This means the value it can gain is limited.

Why will the project succeed?

community

Look at the people involved with the project. What sort of people are they? For example, Ethereum has many idealists building things on top of it. They talk about a world with ‘fair distribution’, ‘decentralized finance’, ‘solving the commons free rider problem’. In many ways it’s about solving social problems that the governments and capitalism can’t fix.

In contrast, if you take a look at the communities of other smart contract projects, it’s usually ‘our coin’, ‘our coin’, ‘something similar to Ethereum project but on our coin’. You cannot inspire people to join you if you’re all about yourself.

There are many people who are really good at something, but because they don’t know how to market themselves, society doesn’t pay them as much, or even listen to them. Projects are like that too. You must look at a project’s community like a person. What’s his character? Is he trustworthy? Is he doing something worthwhile? Can he convince others to believe in him?

For instance, Decred has the best codebase I’ve ever seen, and they have anonymous transactions, a great treasury, a community composed of mature, level headed individuals, but the way they shill their coin on Twitter is just childish, no better than how Emin Gun Sirer keeps trumpeting about Avalanche all the time. Yes they have more than Bitcoin, but they haven’t done enough to truly leapfrog Bitcoin.

economics

A coin’s worth is based on many things, but the most important one of all is people’s belief in the coin, or what Vitalik called Legitimacy.

Take a coin whose worth is purely based on 1 bar of gold. If the number of coins goes up, but the 1 bar of gold is still 1 bar, then the value of each coin must have gone down.

Take a coin whose worth is based on people’s belief. The UK Pound, for example, is based on the belief that a king’s promise to repay a debt (to the bankers) is worth something. If the number of coins goes up… but here’s the thing, it’s difficult to quantify people’s belief. That’s why you can print some more coins. But if you suddenly print trillions in stimulus like the US Fed, then people’s belief will start to waver.

So the question is: can the project market itself successfully to make others believe in it? This ties back to the community section above. What kind of people could inspire you to believe in them?

environment

Even a strong individual can succumb and die if you place him in the wrong environment.

How many competitors are there? How strong are they?

Does the world want something like this yet? (is the time right)

What is the state of the world?

What is the state of the crypto world, i.e. is it going up overall, or is it going sideways, or is it going down?

What is the state of the sector that this crypto project is in? Does it still have room to grow, or is it still relatively unknown?

You need to be able to explain all these by yourself. If you get this information from someone else, and the coin goes down, you will just blame him, sell to cut losses, and learn nothing. Then the coin goes up and you curse yourself.

Then, you need to keep a log to keep track of what you were thinking, whether it was right back then or not.

Optionally you may also choose to create certain rules for yourself so you’re even more divorced from your emotions.

The Art of Buying

A small number 10x-es easier than a large number.

A small number also 0.1x-es easier than a large number, so please take profits. Sell into a coin with a larger number, like BTC or ETH, or into USD.

Iron rule that’s served me well 99% of the time: if the token has gone up, it’s already too late. Buy when the coin is flat. This means nobody knows about this coin yet.

If the coin is going up already, try to catch it on a red candle/correction. What goes up must come down, although not perhaps down to the same level.

Use buying to manage your emotions. Buy a very small stake if you think you get in, but are unsure about the future. Van Tharp calls it Position Sizing in his book, Trade Your Way to Financial Independence.

The Art of Selling

As always, divorce yourself from your emotions.

When you buy, set a target for yourself. You want to 2x your investment. But you might wait a long time for the price to go up at all, if the coin has been flat. So let’s say 10x, to make the wait worth it.

Let’s say the token jumps up 4x. Divorce yourself from your emotions. Your thoughts should be: “Good, but I was expecting more. What is the overall market situation like?”

If the bullrun is just getting started, go do something else like clean your fingernails.

If the rest of the crypto market is dead, dying, or waffling around, sell and be happy.

Use selling to manage your emotions. If you feel like you have a lot to lose, sell a bit along the way up.

Often it pays to be ignorant of what’s going on. Read Edwin Lefevre’s Reminiscences of a Stock Operator: it was always his sitting tight that made him money! The more he paid attention, the worse he did.

Don’t worry, when the rest of the world starts talking about crypto, it’s God’s way of telling you it’s about time to sell.

Emotional Management

When you’ve decided upon a coin, your actions should come from managing your emotions, not how much you hope to make.

Not sure how much to stake? Try a number you won’t care losing.

Not sure how much to stake, but you wanna finally make a difference in your net worth? Try 1 month’s living expenses.

Not sure to buy, but think you probably should? Buy 100USD worth, to keep your inner monkey satisfied.

Not sure to sell, but think you probably should? Sell a part, to keep your inner monkey satisfied.

Preparing Data for a Mere Simulation is Harder Than You’d Think

Balancer Simulations is an open-source cadCAD model of a Balancer V1 AMM smart contract. This is useful for exploring “what if” questions involving an AMM pool e.g. “as an arbitrageur, how could I have made the most profit with this particular AMM pool (given historical data)?” or “how high should I set the pool fees to provide a decent ROI to liquidity providers?”. As a fundamental DeFi composing block, AMMs will be increasingly used to encourage certain behaviour – therefore it is important to find the correct parameters.

Introduction

The simulation is coded to be identical to the original smart contract deployed on Ethereum, so that one can “play” with it and derive some insights. But we still needed a way to feed in user actions to the simulation, reconstructed from what actually happened on Ethereum.

The simulation doesn’t know about transactions or gas fees. Instead, it feeds on user Actions – a user creates the pool; another user joins (deposits tokens into) the pool, providing liquidity; another user swaps token A for token B, paying a fee to the pool for doing so; another user exits, taking out all the tokens he deposited in the pool + a proportion of the pool’s collected fees. These “events”, or what we called “Actions” in the data pulling script, had to be reconstructed from Ethereum log events.

Getting Ethereum log Events

It’s not so easy to get historical data from Ethereum. You need access to an archive node, and an archive node takes at least 4TB of flash storage and a week or two to sync. That’s assuming everything goes well. Plus, when you finally get data out of it, it’s not organized.

Thankfully some people have been putting historical Balancer pool events on a traditional SQL database, which can be queried easily:

select * from blockchain-etl.ethereum_balancer.BFactory_event_LOG_NEW_POOL where pool="0x..."give me all LOG_NEW_POOL events for the pool 0x….. (since a pool is only created once, there can only be one row from this SQL query)
select * from blockchain-etl.ethereum_balancer.BPool_event_LOG_JOIN where contract_address="0x..." order by block_numbergive me all the events where a user added token liquidity to the pool, and sort them by the block in which it happened
select * from blockchain-etl.ethereum_balancer.BPool_event_LOG_SWAP where contract_address="0x..." order by block_numbergive me all the events where a user swapped a token out for another using this pool 0x…, sorted by the block in which it happened

We do this for LOG_NEW_POOL, LOG_SWAP, LOG_JOIN, LOG_EXIT, event_Transfer, fee changes and weight changes (which were too complex to fit into one line of SQL). And afterwards we smush them all together into one sorted list of Events.

“Why didn’t you just get all the Events sorted by block number, you dummy?”
It just wasn’t possible the way the SQL data was organized. Besides, fee changes and weight changes had to be derived, they weren’t actual log Events.

Great, so we don’t need an Ethereum archive node after all, right? Wrong – there is a special anonymous Event emitted in addition to LOG_JOIN, LOG_SWAP, LOG_EXIT that has important information that can affect the simulation accuracy.

Because Ethereum transactions may or may not go through, and tokens in the pool might change in the meantime, you might not get back exactly the amount of tokens you were expecting.

For example, if you swap 1 TOKEN-A for 500 TOKEN-B, you might get 499 or 501 TOKEN-B. Fortunately there are variants of JOIN/SWAP/EXIT methods which let the user decide if he wants to spend exactly this much TOKEN-A, or if getting back exactly 500 TOKEN-B is more important to him.

Unfortunately, this important information was not included in the SQL database, so we needed an Ethereum archive node after all, and fellow developer Raul spent at least 2 nights deciphering this important information from the anonymous Event.

Put all the Events together into a list and group by txhash

events = []
events.extend(turn_events_into_actions(new_events, fees_dict, denorms_results))
events.extend(turn_events_into_actions(join_events, fees_dict, denorms_results))
events.extend(turn_events_into_actions(swap_events, fees_dict, denorms_results))
events.extend(turn_events_into_actions(exit_events, fees_dict, denorms_results))
events.extend(turn_events_into_actions(transfer_events, fees_dict, denorms_results))

events_grouped_by_txhash = {}
for i, action in enumerate(events):
    tx_hash = events[i].tx_hash
    if events_grouped_by_txhash.get(tx_hash) is None:
        events_grouped_by_txhash[tx_hash] = []
    events_grouped_by_txhash[tx_hash].append(action)
# save_pickle(events_grouped_by_txhash, f'{args.pool_address}/events_grouped_by_txhash.pickle')
# events_grouped_by_txhash = load_pickle(f'{args.pool_address}/events_grouped_by_txhash.pickle')

Source

Multiple log Events could actually have been emitted by a single Ethereum transaction. So now, given NEW, JOIN, SWAP, EXIT, and Transfer (pool shares, not the tokens) Events, we want to reconstruct the transactions that were relevant to this particular pool.

The above code simply smushes the events together into a long, unsorted list, and groups them by txhash.

Dirty detail: It says turn_events_into_actions() and it even uses the Action class in data/action.py, but actually they are not yet real Actions, they are still individual Events. That’s because when I wrote the code, I intended to make them Actions, but many other problems came up and I quickly forgot my original intention.

Exception: irregularities in the data caused by 1inch aggregated swaps

We were getting token swaps that didn’t make sense. Which BAL got turned into WBTC, and which into WETH? It is not clear.

"action": {
    "type": "swap",
    "tokens_in": [
        {
            "amount": "447.23532971026",
            "symbol": "BAL"
        },
        {
            "amount": "157.26956649152",
            "symbol": "BAL"
        }
    ],
    "tokens_out": [
        {
            "amount": "7279711",
            "symbol": "WBTC"
        },
        {
            "amount": "6.450635831831913964",
            "symbol": "WETH"
        }
    ]
}

As it turns out, this is the work of smart hacks working at 1inch.exchange to save on gas fees and aggregate swaps into a single transaction. So we had to modify our data parsing script to recognize transactions like these and emit two Actions instead of one.

Turn Events into simulation-relevant Actions

# Remove pool share transfers
grouped_events = list(filter(lambda acts: not (len(acts) == 1 and acts[0].action_type == 'transfer'), grouped_events))

actions = stage3_merge_actions(args.pool_address, grouped_events)

# save_pickle(actions, f"{args.pool_address}/actions.pickle")
# actions = load_pickle(f"{args.pool_address}/actions.pickle")

We remove pool share transfers because they are irrelevant to the simulation (the number of pool shares is a consequence of the inputs, not something we should feed into the simulation).

stage3_merge_actions is where we take Events and merge them into Actions.

Inconsistencies
  • Yes, it should be called stage3_merge_events_into_actions. Naming is hard.
  • stage3_merge_actions() doesn’t even use the actions.py:Action class, which I originally intended to be used here. Oh well.
  • stage3_merge_actions() is also where we ask the Ethereum archive node for the anonymous Event, decipher it and add its data into the “Action”. This should actually belong in section 1, where we get the different Event types from the SQL database, but the code is the way it is.

Interleave hourly prices between the Actions

Since I wrote the part that gets prices from Coingecko API, I’ll explain that here.
As long as you only request 3 months of data, Coingecko gives historical hourly prices. For free. However, this only goes a ways back – you won’t get hourly pricing data for 2018 even if you request 1 day at a time. This inconsistency is conveniently not mentioned on the Coingecko API page.

The hourly pricing data that Coingecko returns is not regular either – you might get


2021-01-01 00:47:33 1000
2021-01-01 01:33:21 1001
2021-01-01 02:17:05 999

which is worrysome. Now I have to round the timestamps to the nearest hour, and 01:33:21 rounds to 02:00:00, but 02:17:05 also rounds to 02:00:00! So I’ll have to throw something away.

Then again, who’s to say other pricing data services like Tradingview aren’t doing this in the background either?

Lesson Learned

Franz Kafka was known to find faults in anything that came from his own pen, except for a chosen few, amongst them The Judgment, which he supposedly wrote in a single 8 hour cohesive sitting, and was the first short story he was truly proud of.

That was also how I wrote the pulldata.py data ingestion script for the simulation. It was a beautiful, cohesive solution that fit very well to the problem.

But the problem changed. The 1inch aggregated swap problem came up. Prices had to be added. The archive node had to be queried for additional information, and nobody had time to rewrite everything. Over time, it became a jumbled mess, far from the elegant solution I had envisioned.

Kafka knew what he wanted to express, and it stayed the same. But as a programmer, we think we know the problem, but we don’t. It changes, or time will show us our understanding was wrong, or incomplete. Hence:

As a programmer, prefer the flexible solution, not the most beautiful/elegant solution.

me, who else

cadCAD can’t simulate humans

Now and then, when people hear I code economic simulations with cadCAD (and I just heard about its rust cousin radCAD), they want me to write one for them. And it usually involves asking how humans would behave in a specific situation.

here’s the thing

I don’t know.

I can’t simulate human psychology.

What would people do in this or that case? This is not what a simulation does. A simulation says “given these conditions, and behaviours, this will happen (most/some of the time)”. One must be very clear about what these behaviours are and formulate the question in such a way that we can answer it without having to program mini-humans. Mini-humans are impossible to verify anyway.

Bad question: “What would humans do if I raised taxes?”
Better question: “How many people would stay in my system given a group of humans (with income distribution A, differing tolerances for tax raises B) and if I raised taxes above a certain threshold?”

You get the idea.

Math helps to set your intentions in stone. If you can express every interaction and change as an equation, everyone can verify that the simulation is working as intended. After all, if I write a complex system that I claim simulates how humans would behave, how is anybody going to verify that? I was probably just guessing; and it’s hard to verify if the code does what I intended. It’s far easier to test if an equation computed the right result.

A Blockchain Use Case for Dancers

Hellen the dancer

wants to make a name for herself, so she uploads a video to Youtube, err, I mean, Odysee/LBRY.tv, which are just the same thing in the background, the LBRY blockchain.

Uploading the video and reserving the channel name @ZoukBerlin costs some LBRY Credits (LBC).

The end result is that the website doesn’t have to show ads, annoying everyone, to sustain itself. It earns from the very act of people uploading and curating videos.

People can choose to tip her in LBC, or support her video (again with LBC) which helps it move up in the search results.

Imagine if a normal company did this with their own credits system. They’d make it impossible for people to cash out their custom credits, locking people in! Those travel companies are doing it right now as we speak.

As people tip her LBC, Hellen could use those to boost her videos, or cash out by converting them to Bitcoin, Ethereum, or anything else. It’s a balancing act.

The Video In Question

Youtube is famous for demonetizing videos for whatever reason. Since Hellen doesn’t usually dance to silence, inevitably some record company will step up and say:

Using our song in your video is a privilege. All proceeds belong to us now, thanks!

Hellen doesn’t think so, naturally. Anselmo Ralph should be honoured that she wanted to dance to his song! Indeed, if you asked the artist himself, he might even say:

Hey, thank you for dancing to my song! (nice ass)

Suffice to say this doesn’t happen on blockchain platforms. If LBRY ever considers demonetizing videos based on their audio, as a LBC token holder, Hellen and many other content creators can even vote on the issue.

Do You Need a Blockchain? Think Again.

So went the memes a few years ago.

But they said that about computers before.

“I think there is a world market for about five computers.”

IBM’s President Thomas J. Watson, early 1940s

Hell, I said that about smartphones too when I first heard of them.

But there are 2 good use cases for a blockchain and 1 great one I thought of myself, hear me out.

An uncorruptible, un-biasable Being

Governments are made of humans, so they can be put under pressure by, let’s say, rich groups of companies. Just like humans, they usually cave in under pressure.

But Bitcoin doesn’t cave in. It doesn’t say “whoops election day is coming up so let’s approve a bailout/stimulus package (aka print more money)”. It doesn’t even need money – it’s its own money! It only needs people agreeing to participate in it.

Well, okay, both Bitcoin and governments print their own money. The only difference is that Bitcoin’s printing is determined by the program that says there will only ever be 21 million Bitcoin, while governments’ printing is determined by humans.

But wait a minute, you say. Humans wrote the program, so how is it going to be any better?

Well, let’s say you want to change the rules to benefit you. Which is harder – convincing everybody who’s already running the Bitcoin software to run your new economic policy Bitcoin, or convincing a few government officials to push your policy?

I thought so.

Distributing power even more than the current stock market allows

I have news for you. None of these startups with their friendly pastel coloured ad campaigns and sans-serif fonts are on your side.

Think of how Uber is organized. At the top you have C-level executives (who own a large part of company stock), and then somewhere below them the programmers (who mostly don’t own any stock), and finally, at the very bottom, the Uber drivers (who most definitely don’t have any stock).

The Uber drivers have to do what the executives want them to do. They don’t have a choice, and they suffer as a result . After all, they’re not stockholders.

But what if in order to have anything to do with Uber, you had to own stock, even a tiny minuscule bit, and that stock came with voting rights? At the very least, drivers would have a way to push back instead of just leaving.

Bitcoin, Ethereum, any of these cryptocurrency tokens are just like a stock – except you don’t have to ask your bank to handle them for you. You can deal with them yourself by going to a website and buying them. That’s the key: it makes owning the token more direct and thereby distributes ownership/power amongst more people.

Escape a bad economy

I’m the most proud of this one, because I thought of it myself.

Think of a healthy, smart, hardworking person in a poor country (let’s call him George). No matter how healthy, smart, or hardworking he is, he’s still poor compared to the average American/European! Why? because he has to use his country’s own currency (assuming he lives there). Maybe his country has bad politicians – but that’s not his fault and he can’t do anything about it.

Now what if George had his own economy, the GeorgeCoin?

(ok it’s an economy of one person but bear with me)

George’s country makes a bad economic decision, and overnight its currency is worth nothing, so food prices skyrocket. But GeorgeCoin’s value is still intact, because it’s separate.

It’s just like owning your house vs renting it.

This works because even if the country’s economy tanks, people still believe in George. You just need an efficient way of converting between everybody’s own Coins.

Blockchains coordinate Humans into larger Organisms

this post is closely related to How token economies organize people around endeavours

The first time I had a hint that “as above, so below” was when learning how to trade crypto. Prices go up and down in waves, and there were waves that manifested themselves on the 10 minute chart, and waves that manifested themselves on a 1 day chart, and one could make money trading on both timeframes. That is, within the larger, longer term waves, there were smaller, short term waves. It’s like fractals that you can zoom infinitely into.

Recently I found this essay “Cognition all the way down” (archive), which proposes that even cells, genes, DNA are agents that are autonomous, who find their way through life, who sense opportunities and try to accomplish things.

Thinking of parts of organisms as agents, detecting opportunities and trying to accomplish missions is risky, but the payoff in insight can be large. Suppose you interfere with a cell or cell assembly during development, moving it or cutting it off from its usual neighbours, to see if it can recover and perform its normal role. Does it know where it is? Does it try to find its neighbours, or perform its usual task wherever it has now landed, or does it find some other work to do? The more adaptive the agent is to your interference, the more competence it demonstrates. When it ‘makes a mistake’, what mistake does it make? Can you ‘trick’ it into acting too early or too late? Such experiments at the tissue and organ level are the counterparts of the thousands of experiments in cognitive science that induce bizarre illusions or distortions or local blindness by inducing pathology, which provide clues about how the ‘magic’ is accomplished, but only if you keep track of what the agents know and want.

OK, so cells are actually selfish agents. How do they cooperate to form a cohesive whole, like a human who has no sense of his constituent cells? I’m just going to quote liberally from this article just to hammer home that you should really read it.

When two cells connect their innards, this ensures that nutrients, information signals, poisons, etc are rapidly and equally shared. Crucially, this merging implements a kind of immediate ‘karma’: whatever happens to one side of the compound agent, good or bad, rapidly affects the other side. Under these conditions, one side can’t fool the other or ignore its messages, and it’s absolutely maladaptive for one side to do anything bad to the other because they now share the slings and fortunes of life. Perfect cooperation is ensured by the impossibility of cheating and erasure of boundaries between the agents. The key here is that cooperation doesn’t require any decrease of selfishness. The agents are just as 100 per cent selfish as before; agents always look out for Number One, but the boundaries of Number One, the self that they defend at all costs, have radically expanded – perhaps to an entire tissue or organ scale.

Sounds just like relationships, doesn’t it? Would you want to connect your innards with somebody who hasn’t got their life together?

The other amazing thing that happens when cells connect their internal signalling networks is that the physiological setpoints that serve as primitive goals in cellular homeostatic loops, and the measurement processes that detect deviations from the correct range, are both scaled up. In large cell collectives, these are scaled massively in both space (to a tissue- or organ-scale) and time (larger memory and anticipation capabilities, because the combined network of many cells has hugely more computational capacity than the sum of individual cells’ abilities).

To paraphrase: a cell’s lifespan and goals are short, perhaps on the order of seconds or hours (don’t ask me I’m not a biologist). As more of them collect together, their biological feedback mechanisms interact such that their lifespan and goals are larger, whether it be in terms of time or space.

Doesn’t this remind you of large sea creatures, or tall trees hundreds of years old?

The cooperation problem and the problem of the origin of unified minds embodied in a swarm (of cells, of ants, etc) are highly related. The key dynamic that evolution discovered is a special kind of communication allowing privileged access of agents to the same information pool, which in turn made it possible to scale selves. This kickstarted the continuum of increasing agency. This even has medical implications: preventing this physiological communication within the body – by shutting down gap junctions or simply inserting pieces of plastic between tissues – initiates cancer, a localised reversion to an ancient, unicellular state in which the boundary of the self is just the surface of a single cell and the rest of the body is just ‘environment’ from its perspective, to be exploited selfishly. And we now know that artificially forcing cells back into bioelectrical connection with their neighbours can normalise such cancer cells, pushing them back into the collective goal of tissue upkeep and maintenance.

Let’s return to talking about blockchain now, remembering that Ralph Merkle first compared Bitcoin to a lifeform.

Recently, humans discovered that they can unite areas larger than towns with the notion of a nation-state. A nation state is a bigger organism than humans, can accomplish more and reach for bigger goals, yet some things are still the same. It’s got an organ that poses a direction called the government (the brain). A nation, just like a human, needs to maintain its boundaries with force and keep order internally (the immune system). And last but not least, a system of transferring value within itself, keeping its various parts fed and nourished (the blood). It’s called a currency.

If we think about it like this, it is only natural that countries stamp out alternative currencies like Bitcoin as soon as they exist, like the Wörgl Experiment in Austria. From their point of view, it is a cancer – a totally different organism. Case in point: the new STABLE ACT from the US is all about banning stablecoins. A coin that has exactly the same value as the USD, but isn’t under the US Treasury’s control? Obviously going to undermine them at some point, which is why this isn’t surprising at all.