
In the world of finance, every millisecond counts. The faster you can get information, the quicker you can make decisions. This is especially true at Mechanism Capital, where I need to stay ahead of the curve, always ready to act on the latest news. That's why I've developed the [Blazing Fast RSS Watcher](https://github.com/brianfakhoury/blazing-fast-rss-watcher), a project that combines the power of Rust, the simplicity of containerization, and the speed of low latency systems to deliver news as it happens.

![Telegram screenshot of message sent from program](Blog/Assets/Screenshot%202023-06-06%20at%203.56.15%20PM.png)

## The Need for Speed

The Blazing Fast RSS Watcher was born out of necessity. I needed a way to get instant alerts about new articles, allowing our trading desk to have a raw feed of headlines at their fingertips. But I didn't just want any RSS watcher (we already had one set one up). I wanted one that was fast. Blazing fast. And that's where Rust comes in.

Rust is a systems programming language that guarantees thread safety and prevents *segfaults*. It's known for its speed and memory safety, making it the perfect choice for this project. Not only did it allow us to create a high-performance RSS watcher, but it also gave me a chance to improve my Rust abilities. 

Here's a snippet showing how Rust isn't all that alien to an interpreter-lover like me:

```rust
for item in channel.items() {
    let title = item.title().unwrap_or_default().to_owned();
    let description = item.description().unwrap_or_default().to_owned();
    let link = item.link().unwrap_or_default().to_owned();

    let article = ArticleInfo {
        title: title.clone(),
        description: description.clone(),
        link: link.clone(),
    };

    // Depending on the mode, do something with the article...
}
```

## Containerization and Simplicity

In addition to speed, I also wanted our RSS watcher to be simple and easy to deploy. That's why I focused on containerization. By packaging the application into a container, I can deploy it anywhere, easily - whether it's on a local machine or a Linux server in the cloud.

I'm also planning on rounding out the project with full websub support. This will make deployment even faster, allowing us to get our RSS watcher up and running in no time.

Simplicity was another goal of this project. For this, I focused on creating a single asynchronous function that could be called to start processing RSS feeds. The `main()` function in `main.rs` pulls this off elegantly:

```rust
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = AppConfig::from_env_args()?;

    process_rss_feeds(&config).await?;

    Ok(())
}
```

## Pushing the Limits

There's a certain joy in making really fast software. It's like a game, trying to push the limits, to see just how fast you can go. And with the Blazing Fast RSS Watcher, I'm doing just that. With Rust, we can indeed max out the news wire.

I'm not just creating an RSS watcher. I're creating the fastest RSS watcher. One that can keep up with the rapid pace of the financial world. One that can deliver news as it happens, giving us the edge we need to stay ahead.

And the best part? I'm just getting started. With plans for full websub support and a Docker image, the future of the Blazing Fast RSS Watcher is looking brighter (and faster) than ever.

As I prepare to deploy this tool on a Linux server in the cloud, I reflect on the experience that trying new things can be. The combination of instant alerts, Rust programming, and the challenge of low latency, all bundled into a project that's practical for our trading desk at Mechanism Capital, has made this not just a task, but a labor of love.

The next time you find yourself needing a similar solution, I highly recommend giving Rust a shot. Its performance and memory-safety, combined with its modern syntax, makes it an excellent choice for developing high-performance applications.

Thanks for reading!

### P.S. For Those Who Care

Rust has some truly beautiful syntax. Any chance one gets to flex the `match` syntax, one should take it. Here's a snippet from the configuration module:

```rust
        match mode.as_str() {
            "test" | "http" => {}
            "telegram" => {
                dotenv().ok();
                chat_id = Some(
                    env::var("CHAT_ID").expect("CHAT_ID not found. Please set it in the .env file"),
                );
                bot_token = Some(
                    env::var("BOT_TOKEN")
                        .expect("BOT_TOKEN not found. Please set it in the .env file"),
                );
            }
            _ => {
                eprintln!(
                    "Invalid mode: {}. Please choose one of: test, telegram, http",
                    mode
                );
                std::process::exit(1);
            }
        }
```

And also, it's not so bad sending a Telegram message:

```rust
    let message = format!("<b>{}</b>\n\n{}", title, description);
    let parse_mode = String::from("HTML");
    let disable_web_page_preview = String::from("true");
    let reply_markup = format!(
        "{{\"inline_keyboard\":[[{{\"text\":\"Open Article on Coindesk\",\"url\":\"{}\"}}]]}}",
        link
    );

    client
        .post(format!(
            "https://api.telegram.org/bot{}/sendMessage",
            bot_token
        ))
        .form(&[
            ("chat_id", chat_id),
            ("text", &message),
            ("parse_mode", &parse_mode),
            ("disable_web_page_preview", &disable_web_page_preview),
            ("reply_markup", &reply_markup),
        ])
        .send()
        .await?;
```

Maxing Out the News Wire: An Adventure in Rust



Unveiling the extraordinary, Apple presents the Vision Pro, a mixed-reality headset that serves as a striking change agent. This isn't just another addition to the ever-growing range of AR/VR gadgets. Instead, it embodies a transformative shift in our interaction and perception of the world around us. From a crypto angle, it's the potential substrate that is needed to allow for experience to finally trump narrative when it comes to digital assets.

## Perception Redefined

Vision Pro offers a window to the world rather than a screen you gaze at. This tool is set to revolutionize how we communicate, collaborate, and live in our world. It is a triumph of technological innovation, incorporating 4K displays, infrared cameras, LED illuminators, and a state-of-the-art mixed-reality-specific R1 chip. Fueled by Apple's M2 chip for reliable performance, the R1 chip helps achieve near-zero lag, dispatching images to the displays within a mere 12ms. These impressive features, while characteristic of Apple's tech prowess, still inspire awe and ignite the inner geek in me. I'm on the edge of my seat, waiting to be amazed at what is ready to be created and consumed.

## Stepping into Tomorrow

The Vision Pro harks back to the debut iPhone - an innovative marvel with extensive scope for future enhancements. The headset also marks a significant juncture, amalgamating recent strides in AI with the existing blockchain infrastructure. As one of the global corporate giants, Apple's hefty bet on this spatial computing platform signifies a future brimming with potential. Vision Pro transcends entertainment; it's a tool engineered to make work more engaging and meaningful. Imagine the power to interact with digital content as though it's a part of your physical space, thereby experiencing work in a wholly immersive way. This platform provides a unified field for converging trends in AI, crypto, and health, offering a novel experience to a broad spectrum of users.

## Paving the Way Forward

While the Vision Pro concentrates on vision and sound, it's evident that the incorporation of smell and haptic technology will soon become imperative. Our perception of life is heavily influenced by these senses (for instance, recall how black and white TVs shaped the memory experience of an entire generation). As we delve deeper and broaden the horizons of this technology, we can anticipate even more immersive and interactive experiences. This is precisely why I think crypto's future moment to shine might very well lie in the lands of the AR headset.

On the cusp of this groundbreaking era, it's valuable to ponder the far-reaching implications of this technology. The Vision Pro isn't merely altering how we perceive the world; it's redefining our interactions, our work, our leisure. It's recreating our reality, one pixel at a time. Yet, while we welcome this new dimension, we must not lose touch with the splendor our natural sight offers. It's our innate vision that presents the world in its raw beauty and compels us to appreciate it in its entirety. As technology enriches our vision, let's not forfeit the marvel that our natural sight gifts us.

In essence, Vision Pro doesn't seek to substitute our natural sight, but to enhance it. It equips us to perceive the world in unprecedented ways, to venture into unexplored territories of possibilities, and to immerse ourselves in our world like never before. This in itself is a spectacle. After all, the future is not just about seeing; it's about experiencing, comprehending, and cherishing the world in its multifaceted glory and wonder.

Replacing Natural Sight



I plan on keeping this list regularly updated. Obviously there are orders of magnitude more "self-help tips" residing in our heads than we'll ever be able to take note of in an organized way. But, here's my attempt. Enjoy!

1. **Finding a problem that you care about is the key to being genuine and committed.** Working on things that you care about gives you a boost in genuineness. This lets you work on things for more than 5 days a week, not feel like it's work, and make the process of selling easier. All this to say -- find your problem, not your passion. **Passions come and go, but problems are sticky**, and they build expertise over time. [1](https://justinmares.com/how-to-find-meaningful-work/)
2. **You are likely to believe the things that you hope for.** This is the classic observation that outcomes are driven by incentives. Charlie Munger refers to this quote by Demosthenes: "what a man wishes, he will believe." [1](https://www.amazon.com/Charlie-Munger-Complete-Investor-Publishing/dp/0231170998)
3. **Learn to self-soothe your mind.** Being able to control your level of emotions is important in relationships and in general management of stress. One tool to do this is the physiological sigh, essentially two breaths in and one slow breath out through the mouth. [1](https://lexfridman.com/andrew-huberman-3/)
4. **Self-glorification as an end goal is a bad idea.** In the name of a means to an end, it leads to negligence, denial, and unethical behavior. [1](https://www.goodreads.com/book/show/629.Zen_and_the_Art_of_Motorcycle_Maintenance)
5. **Invent a character that you want to be when it comes to being your best**, turn that mode on when certain conditions are met. 1) Identify the situations where you'd like to show up as the best version of yourself. 2) Envision the character you would like to embody in each situation. 3) Get yourself some reps by turning on this character in those situations. This process is meant to help attenuate the ability to become the best version of yourself. [1](https://share.transistor.fm/s/0adf53ff)
6. **Refuse to enter the arena.** Don't enter a set of rules that limits your ability to act. For example, don't argue with strangers on social media, the set of rules imposed by the message box put you at an immediate negative expected value. [1](https://www.goodreads.com/book/show/629.Zen_and_the_Art_of_Motorcycle_Maintenance)
7. **Be aware of slave mentality.** Students learn to only do work to get graded. When grades are no longer present, they won't do the work. Pull the cart of society without an expectation of reward. Find work that is meaningful and do it. [1](https://www.goodreads.com/book/show/629.Zen_and_the_Art_of_Motorcycle_Maintenance)
8. **We only need a few secure friends to not feel incessantly driven by the status game.** Having three secure friends, or so, is enough to change how stressed we might feel in the race to acquire accolades and things of that nature. [1](https://twitter.com/AskYatharth/status/1600214163292270592)
9. **Put more effort into setting yearly goals than daily goals.** You should be productive in the right direction, therefore you must spend time thinking about what to work on. [1](https://blog.samaltman.com/productivity)
10. **Avoid a 400% increase in all-cause mortality by not being in the bottom quartile of fitness** for your age group. This one is self-explanatory. [1](https://sites.libsyn.com/115004/613-peter-attia)
11. More coming soon

Every self-help tip I've discovered



If you're like me, using Next.js to hack a personal blog together on the weekend, you're going to love the latest update from Next.js - version 13.4!

## A Little Background: The Page Router

Before we dive into the exciting new stuff, let's take a quick detour to understand how routing used to work in Next.js. Traditionally, Next.js used a system known as the "Page Router". In this system, every file inside the 'pages' directory automatically became a route. For instance, if you had a file named 'blog.js' inside your 'pages' directory, it would be accessible via the '/blog' route in your application.

```jsx
// pages/blog.js

export default function Blog() {
  return <div>Welcome to my blog!</div>
}
```

This approach was simple and intuitive, but it had its limitations. The main constraint was that it forced a strictly "pages-only" directory structure, which could lead to a cluttered directory if you had other files you wanted to keep alongside your pages.

## The Game Changer: The App Router

Now, let's get to the exciting part. Next.js 13.4 introduces a new feature called the App Router, which is a game changer for hobbyist developers like myself. The App Router allows us to have a single 'app' directory where we can organize our pages alongside any other related files. This concept is known as colocation and it allows for more efficient development.

```jsx
// app/blog/page.tsx

export default function Blog() {
  return <div>Welcome to my tech blog!</div>
}
```

In the example above, the 'page.tsx' file inside the 'blog' directory would be accessible via the '/blog' route in your application. This approach allows you to keep all files related to a specific feature or page together in the same directory, improving the maintainability and navigation of your codebase.

## Embracing a Feature-Driven Structure

The App Router encourages a feature-driven structure. A feature is a group of files that are related to each other and represent an area or topic of your project. For example, you might have features for your blog, a crypto tracker, and a script for automating some work tasks.

```jsx
// app/crypto-tracker/page.tsx

export default function CryptoTracker() {
  return <div>Welcome to my crypto tracker!</div>
}
```

In the example above, the 'page.tsx' file inside the 'crypto-tracker' directory would be accessible via the '/crypto-tracker' route in your application. This approach allows you to keep all files related to the 'crypto-tracker' feature together in the same directory.

## Why I'm Excited About the App Router

The App Router brings several benefits that make me excited:

1. **Colocation**: I can keep related files together, which makes it easier to understand and navigate my codebase.
2. **Scalability**: The feature-driven structure scales well as my projects grow.
3. **Flexibility**: I have more freedom in how I structure my projects.
4. **Intuitiveness**: The structure aligns with the way I think about features and functionality.

## A Glimpse at My Project Structure

Here's a glimpse at how I might structure a project using the App Router:

```jsx
// app structure
app/
├── components/
│   ├── FancyButton/
│   │   └── FancyButton.tsx
├── blog/
│   ├── BlogPost/
│   │   └── BlogPost.tsx
│   ├── page.tsx
│   └── useBlogPosts.ts
├── crypto-tracker/
│   ├── CryptoChart/
│   │   └── CryptoChart.tsx
│   ├── page.tsx
│   └── useCryptoData.ts
├── work-scripts/
│   ├── EmailAutomation/
│   │   └── EmailAutomation.tsx
│   ├── page.tsx
│   └── useWorkScripts.ts
├── hooks/
│   └── useSomething.ts
└── utils/
    └── makeThings.ts
```

In this structure, we have global folders like 'components', 'hooks', and 'utils'. We also have feature folders like 'blog', 'crypto-tracker', and 'work-scripts'. Each feature folder contains all the relevant files for that feature, including components, hooks, and a 'page.tsx' file for the route.

## Wrapping Up

The shift from the Page Router to the App Router in Next.js 13.4 is a significant development in the Next.js ecosystem. It provides developers with more flexibility and control over their project structure, making it easier to build and maintain large-scale applications. As a hobbyist, I find this update particularly exciting as it aligns with the way I think about features and functionality, making my development process more intuitive and efficient. So, if you're like me, hacking away on personal projects over the weekend, give Next.js 13.4 a try. I'm sure you'll find it as exciting as I do as I implement it for this blog! Happy coding!

Why Next.js 13.4 is Exciting: A Personal Perspective



ECMAScript, the standard specification that JavaScript is based on, has been evolving rapidly over the years. With each new edition, it introduces a set of features that aim to improve the language, making it more powerful, flexible, and easier to work with. The 14th edition, ECMAScript 2023 (also known as ES14), is no exception. This article will explore some of the coolest features introduced in ES14 that developers should start using as soon as possible.

> [!info] Transparency notice: This article was written with the help of GPT4.

## 1. Array.prototype and TypedArray.prototype Enhancements

ES14 introduces several new methods on `Array.prototype` and `TypedArray.prototype` that can significantly improve the way you work with arrays.

### 1.1 toSorted

The `toSorted` method sorts the elements of an array in place and returns the array. This method is similar to the existing `sort` method but does not mutate the original array.

```javascript
let arr = [5, 2, 1, 4, 3];
let sortedArr = arr.toSorted();
console.log(sortedArr); // Output: [1, 2, 3, 4, 5]
console.log(arr); // Output: [5, 2, 1, 4, 3]
```

### 1.2 toReversed

The `toReversed` method reverses an array in place. Like `toSorted`, this method does not mutate the original array.

```javascript
let arr = [1, 2, 3, 4, 5];
let reversedArr = arr.toReversed();
console.log(reversedArr); // Output: [5, 4, 3, 2, 1]
console.log(arr); // Output: [1, 2, 3, 4, 5]
```

### 1.3 with

The `with` method returns a new array with one specific element from the original array replaced with a new value.

```javascript
let arr = [1, 2, 3, 4, 5];
let newArr = arr.with(2, 'a');
console.log(newArr); // Output: [1, 2, 'a', 4, 5]
```

### 1.4 findLast and findLastIndex

The `findLast` method returns the last element in the array that satisfies a provided testing function. The `findLastIndex` method, on the other hand, returns the index of the last element in the array that satisfies the provided testing function.

```javascript
let arr = [1, 2, 3, 4, 5, 4, 3, 2, 1];
let lastFour = arr.findLast(x => x === 4);
console.log(lastFour); // Output: 4

let lastFourIndex = arr.findLastIndex(x => x === 4);
console.log(lastFourIndex); // Output: 5
```

### 1.5 toSpliced

The `toSpliced` method changes the contents of an array by removing or replacing existing elements and/or adding new elements in place. This method is similar to the existing `splice` method but does not mutate the original array.

```javascript
let arr = [1, 2, 3, 4, 5];
let newArr = arr.toSpliced(2, 1, 'a', 'b');
console.log(newArr); // Output: [1, 2, 'a', 'b', 4, 5]
console.log(arr); // Output: [1, 2, 3, 4, 5]
```

## 2. Support for #! Comments

ES14 adds support for `#!` comments at the beginning of files. This feature is often used in Unix-based systems to indicate an interpreter for script execution. This addition will better facilitate executable ECMAScript files.

```javascript
#!/usr/bin/env node
console.log("Hello, World!");
```

## 3. Symbols as Keys in Weak Collections

ES14 allows the use of most Symbols as keys in weak collections (`WeakMap` and `WeakSet`). This is a significant enhancement as it allows developers to use Symbols, which are unique and immutable, as weak references in these collections.

```javascript
let weakMap = new WeakMap();
let obj = {};
let sym = Symbol('example');

weakMap.set(sym, 'value');
console.log(weakMap.get(sym)); // Output: 'value'
```

## Conclusion

The ECMAScript 2023 (ES14) edition brings a host of new features and improvements that make JavaScript more powerful and easier to work with. The enhancements to `Array.prototype` and `TypedArray.prototype`, support for `#!` comments, and the ability to use Symbols as keys in weak collections are just a few of the cool features that developers should start using as soon as possible. As JavaScript continues to evolve, it's essential for developers to stay up-to-date with the latest features and best practices to write more efficient, maintainable, and robust code.

Exciting New Features in ECMAScript 2023 (ES14)


A Million Markets: From the Bazaar to the DEX



Zero-knowledge proofs (ZKPs) are an absurd technological breakthrough, and people like [@VitalikButerin](https://twitter.com/VitalikButerin) have publicly commented that they're likely on par with blockchains in terms of ideological importance for this decade. The power of ZKPs can be generally split into two superpowers: privacy & compression. Both sides of this technology are incredibly important, but I want to focus on the compression superpower as it relates to the first line of this thread. How do ZKPs help power compression in a new way?

You can think of using ZKPs for compression like receiving a college degree. The graduation diploma, issued by an "accredited" university, serves as a form of proof (so long as you trust the accreditation). The graduated individual (prover) can convince a third party (of whom might not fully trust the individual) that they've been through years of academic training. Instead of showing the third party dozens of syllabi and exam scores, the diploma serves as a compact proof. We can generalize the diploma in the example to be a "receipt", a general-purpose proof of validity that something happened.

When it comes to computers, ZKPs must be completely math based (no human trust), otherwise, a verifier risks being fooled by a fake proof. The ZKP revolution really kicked off this past decade with narrow applications (in blockchains) for things such as proving you've committed to a number within some allowed range without having to reveal it, and more recently being used to rollup transactions onto Ethereum. Importantly, every zero-knowledge proof system defines its own miniature language in the form of circuits. Therefore, we can think of ZKPs themselves as virtual computers (similar to high-level language interpreters, smart contract platforms, operating system emulators, etc). To make an analogy: Bitcoin was a narrow application of a crypto network, while Ethereum is a fully programmable instance of a crypto network. Some might be familiar with this property as being "Turing complete."

![Relative Turing completeness of Bitcoin and Ethereum](Blog/Assets/Relative_Turing_completeness_of_Bitcoin_and_Ethereum.png)

Relative Turing completeness of Bitcoin and Ethereum

In this same way, ZKPs have only recently had "languages" that are fully expressive. While this is a great property to have, these languages aren't created equal. Ethereum's computer language for example is fairly mature, but not popular outside blockchains. Just like human programmers have preferred languages (JS, Python, Rust, etc...), computers themselves have a most common language that these high-level languages compile into. If we think about ZKPs as virtual computers, then it's important to analyze the proof system language in relation to the high-level human programmer language. Much work has been done here, but none have come close to uniting the two, except for one project (as far as I know). Let's look at this fundamentally:

What is an example of a top machine language, also known as an instruction set architecture (ISA)?

A: RISC V (targetted with LLVM bindings)

What is a popular compiled programming language that can target the above?

A: Most compiled languages.

So logically speaking, the puck is headed toward ZKP systems that speak the same language as a normal computer, and can therefore be directly programmed by anyone with knowledge of a compiled language. The implications here are countless, but I'll try nonetheless to analyze them.

To be concrete, I'm referring to [@RiscZero](https://twitter.com/RiscZero) as the top project I know of that is making this a reality. RISC Zero is designing a virtual computer, aka a VM, that runs the popular ISA called RISC V, with the catch that the whole thing is a zero-knowledge proof system. This is mind blowing because it means if a program can run on a normal computer, it can run in RISC Zero's zero knowledge computer, also known as the "zkVM". The most popular languages (like C++ and Rust) can be easily compiled to target their instruction set. There's also nothing stopping you from using an interpreted language like Python -- which is itself a program. That program can run on the zkVM once it has been compiled for it (with your Python code as input). Okay, so the zkVM can run a program like a normal computer, great. How is this related to the compression superpower of ZKPs? Because the zkVM is a proof system, every time it runs a program, it also generates a receipt, like the diploma in the earlier example. This receipt contains sufficient proof to convince a third party, with pure math, that a given program, when run, maps to a given output.

Simple example: I give you a zkVM receipt of 1) a program that multiplies two primes and 2) the large number output. Without having to brute force check that the number is composite, you can verify I ran the program and generated the composite number, meaning I know its factors.

![Console output of a zkVM program](Blog/Assets/Console_output_of_a_zkVM_program.png)

Console output of a zkVM program

This compression of information becomes even more apparent when you think of machine learning models that take weeks to train. You can prove with a receipt how the model was trained and that you're being served inferences with the said model. We've made it this far, and have barely drawn the use cases of the zkVM in blockchains. That's because there are so many non-crypto applications of this technology! It's a NASA moment in terms of an industry spurring research that has completely orthogonal applications. The Risc Zero zkVM isn't the first zkVM in the blockchain space. There are already other instances of zkVMs, including zkEVMs (which use Ethereum's existing instruction set language). The Risc Zero one is particularly exciting though because it speaks the RISC V instruction set. As RISC V has truly global adoption, this opens the door to a whole new wave of developers, I would guess orders of magnitude larger than what exists in the blockchain space right now.

Back to blockchains. The Risc Zero zkVM can be used in two high-level ways:

1. Create new rollups and new layer 1s. Combine the zkVM with a consensus layer and data layer, and you've got a new smart contract platform that can rival the existing players.
    
2. The zkVM receipt standard can be consumed by existing contracts to verify offchain computation.
    

![Three different zkVM use cases as it relates to blockchains](Blog/Assets/Three_different_zkVM_use_cases_as_it_relates_to_blockchains.png)

Three different zkVM use cases as it relates to blockchains

The logical conclusion of zero-knowledge computation is universally accessible zero-knowledge computers. Everyone has access to computational receipts and provable execution (without a blockchain in many cases). While I think zkVMs are the best place to follow this trend, it's worth noting narrow silicon (see ASICs) are being developed for ZKPs, perhaps we aren't too far from a Turing complete zk processor! There are numerous other areas that can benefit from the zkVM. Healthcare systems, geopolitics, scientific research, gaming, and more. The opportunities are endless, and that's why you should be excited to watch this space in the coming years. Thanks for reading!

The logical conclusion of zero knowledge computation



**A settlement layer is where the final ledger of an asset lies.**

For physical goods & commodities, this definition is trivial, it’s just physics. For traditional, intangible financial assets, the ledger lies with some central authority. In the world of digital assets where the assets themselves are emergent from cryptonetworks, it’s not as straightforward.

Bitcoin’s settlement layer is on the bitcoin network. ETH settles on Ethereum mainnet. USDC has multiple settlement layers across many smart contract platforms (Circle mints canonical USDC on a handful of different chains). USDC on Arbtirum settles on Ethereum mainnet. USDC.e on Avalanche C-chain settles on Ethereum mainnet while USDC on Avalanche C-chain settles natively on the Avalanche C-chain.

Settlement layers have gotten significantly more complex as modular blockchains have become the [preferred scaling method](https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698) for Ethereum, and have always been the [long-term](https://v1.cosmos.network/resources/whitepaper) vision for Cosmos. In the context of settlement layers, to be modular means to (optionally) have a native unit of account whose ledger is not stored locally. For example, this could mean using ETH as a gas token for another network, as Arbitrum and Optimism do for their rollups. While you can deploy an ERC20 token on Arbitrum One that natively settles within the Arbitrum execution environment, many tokens on Arbitrum One, including ETH itself, settle back on the Ethereum mainnet. Since these tokens are brought over through an enshrined bridge in the Arbitrum protocol, we can say that Arbtitrum settles on Ethereum. If tokens are brought over (wrapped) by a third-party bridge from another network, Solana for example, we would _not_ say that Arbitrum settles on Solana.

![Source: Celestia's Twitter Account](Blog/Assets/Source!_Celestia's_Twitter_Account.png)

Source: Celestia's Twitter Account

**Being a settlement layer brings long-term network effects.**

Since a settlement layer is where the ledger of an asset lies, it becomes very sticky once a specific settlement layer is settling many assets. The best example here is the Ethereum mainnet. The canonical Ethereum network pioneered the ERC20 smart contract-based token, which caught fire during the ICO boom and has led to billions of dollars of non-ETH value being recorded on the Ethereum network.

ETH being the biggest settlement network for tokens has forced new networks to depend on the bridging of these tokens to help bring assets into their new ecosystem, inadvertently strengthening Ethereum’s grasp as a settlement layer. Tokens like LINK, USDC, stETH, etc… have all been popular assets in crypto to bring over to new networks in order to bootstrap economic activity on the new chain.

![DeFiLlama Total Value Secured relative comparison across 149 chains.](Blog/Assets/DeFiLlama_Total_Value_Secured_relative_comparison_across_149_chains.png)

DeFiLlama Total Value Secured relative comparison across 149 chains.

With over $100B+ of assets at its peak, Ethereum became an indispensable settlement layer in the crypto economy. It still dominates today because of the network effects of being a settlement layer, namely: long-term **integrity**, deep stablecoin **liquidity**, and credible **neutrality** (anyone can bridge assets from Ethereum without risk of censorship).

It’s not necessarily always going to be this way. Creating a ledger and settling on Ethereum is relatively slow, very expensive, and prone to bugs. A number of projects are vying to become “optimized” settlement layers to take the ease off of building a hardened bridge to Ethereum, which has proven to be a very difficult endeavor (see [here](https://www.cnbc.com/2022/08/10/hackers-have-stolen-1point4-billion-this-year-using-crypto-bridges.html) and [here](https://cointelegraph.com/news/barely-halfway-and-october-s-the-biggest-month-in-crypto-hacks-chainalysis)).

_Settlement layers are a killer app for crypto nonetheless_, and the value of settlement comes from the value of the assets that are being settled. As crypto grows in importance and market cap, what look to be small settlement layers today can quickly become a global super highway of value. Serving the accounting for this value will prove to be massively valuable. _That’s why you should pay attention to settlement layers._

Settlement Layers



_TLDR; Crypto doesn’t matter until it does._

> “what if all the layer 1's and eth died tomorrow
> 
> would anyone care?”

I saw this question floated around in a group chat and was surprised by my kneejerk reaction: “of course people would care!”

But there is plenty of truth in the demise of smart contract platforms not affecting the real world. Airplanes would continue flying, grocery stores would still sell food, businesses would keep conducting business, and people would keep living without a hiccup. It’s the truth at the moment. The only effect would be loss of paper wealth.

But, there is a trap here: one of linear thinking. To see why this is _likely_ the case that crypto is an exponential technology regarding its real-world importance, let’s look at the analogy to the internet.

Harkening back to the primordial days (c. the 1980s-1995), it’s easy to find endless recounts of how the internet appeared to most as just a toy, albeit a confusing one at best. Things started to shift in 1995 when the first web browser, Netscape, went public. This was more than 10 whole years after TCP/IP, the defining technology of the web, was invented. Yet, most looked at it and would’ve said “_what if the web browser died tomorrow, would anyone care?_“

At that time, the web browser was used to read horribly plain pieces of text, something that had plenty of alternatives should the technology of the world wide web disappear. This was compounded by the relative friction needed to even get online and the slow speeds for loading a page. Marc Andreesen himself admits this.

Fast forward 5 more years to the height of the dotcom boom. Tons of businesses were being launched in an attempt to recreate the odd success of the Netscape IPO. These businesses, such as online book stores and search engines, again played folly to the disappearance test. People could still buy books in bookstores and could still look up information in a physical book. But a sore piece of data just was not lining up with this sentiment:

![](Blog/Assets/image-4.png)

**How could the internet have had so many users in 2000 if people didn’t care whether or not it disappeared?** The logical conclusion is that usage is a leading indicator of societal relevance. Technology gets adopted _before_ it can’t be lived without.

The TCP/IP of crypto is Bitcoin, and it has been roughly 15 years since the network saw its first block. Here’s a chart to see its usage growth:

![](Blog/Assets/image-3.png)

So, 15 years after its invention, how can there be 1 billion unique addresses that have interacted with bitcoin if it’s just a toy? If it were to disappear tomorrow, would anyone care? I’ll admit for bitcoin, the case is different. It’s just trying to be hard money, and by that nature, anyone using it cares deeply about its existence (as money).

On this same timeline, Ethereum (HTTP of crypto?) is in the dotcom era of its existence. It’s the web browser of digitally native value. Whether or not you believe ETH to be money, the service of selling blockspace is the metric that I believe to be the leading indicator of its societal relevance. And just as the physical world connection & importance of the internet today is less about consumers and more about the industrial application, I think the same analogy can be said of what is something as boring as blockspace (see layer 2 networks to expand on this). To continue drawing our line, here’s the chart that says “how come Ethereum is selling so much blockspace if no one cares if it disappeared tomorrow?”:

![](Blog/Assets/image-2.png)

This graph is about a year old, unfortunately, but it makes the point clear. There’s plenty of paid usage here for a thing that people don’t care for if it “died tomorrow.” If this dependence continues, it cannot be long (a decade max if looking at web history) before the real world starts to feel the externalities of Ethereum. It’s impossible to say what this dependence will be, but Google does a lot more than simple text search now and Amazon does a lot more than sell books. In the same vein, Ethereum will be a lot more than a casino in the future, and applications on ethereum will be a lot more than a token exchange or lending protocol. To get there, tons of these will need to fail, capital will have to flow, and social perception will have to shift to one of dependence. We’re not there, but look up and see where we’re headed.

### Concluding Thoughts

Admissions:

- Yes, people mostly use crypto right now to make money.
- No, people do not use crypto to make purchases.

Counterfactuals:

- Stablecoins as a remittance and settlement mechanism are excellent and actively being integrated into society.
- Crypto applications are trying to replace their analog counterparts rather than augment them.
- Marc Andreesen said that the biggest mistake with Netscape was not building payments into the browser because it was too hard to overcome.

I think now is the time to be phenomenally bullish on the future of crypto networks, while also taking heed to the fact that 95% of the “stuff” out there will die. In my opinion, it’s not hard to see the things that are headed to the grave at this very moment. Just look at usage as a function of organic demand to pay.

For the more crypto native, my opinion is: I think most alt L1s/independent zones are going to die through heat death -- overpaying for network security in the same token that tries to "differentiate" the network. This is a partial ultimatum to the question first posed at the top: of course, there are things out there that no one cares about. These networks will end up competing against ethereum L2s (see the recent ImmutableX versus Avalanche fight for BAYC). Furthermore, L2s will destroy the alt L1s on unit economics, leaving mostly a long tail of small zones that serve local internet communities. Ethereum dominance as a smart contract layer will continue and grow as a supermajority this decade. Other L1s will compete against L2s on ethereum and will struggle as they slowly lose out on a black swan event basis that exposes risks of lower security networks.

What’s actually going to appear to happen these next few years will be a result of high noise to signal as investors pump cash into irrelevant networks. This will cause continued narrative confusion around all versus a few surviving, but ultimately crypto has come to change the world.

History Rhymes, In Defense Of Crypto



It’s exceedingly clear to me that I have a very chatty internal monologue. From the first signs of an awakening mind to the moments before sleep, there exists a flurry of loose-ended thought processes in my head that range from explaining technical concepts to coming up with my own “self-help” principles. In parallel, I believe there is a common narrative that has been growing over the years in my social circles: that writing is a powerful tool. In the age of Proof-of-Stake blockchains, private space industry, CRISPR and other genomic technologies, AI language models, etc… it's quite silly to think of _writing_ as a _technology_. Unfortunately, writing does not have a token to speculate on, nor stock to list on a public market. It doesn’t rely on power laws in computing to get more powerful, nor does it need to be unlocked inside a laboratory environment. It’s a simple technology, thousands of years old, that gave us the ability to control our minds in a way that enables precise and compact knowledge.

As of late, I’ve lamented the fact that after graduating college, my rate of learning hard knowledge from various fields has compressed. While I wasn’t the most eager to do random homework, I always cared deeply for the educational compass that schoolwork and formal instruction gave. But all is not lost, the act of writing pushes one to learn what one may not have premeditated to learn about. And if the quality of the writing is a goal to optimize, then it’s sufficient to say that writing, both literary and technical, is the path to being an **inveterate student**. How does writing make one rich? It doesn’t passively make one rich, but rather one finds capital through writing. It’s the active use of writing as a technology. One of the fundamental characteristics of _technology_ is that it provides humankind with leverage. The asterisk in the title is a nod toward being _rich_ in _non-monetary capital_, achieved by pursuing what one wants in life, with the tool of writing in an easy-to-reach part of the toolbelt.

Writing Can Make One Rich*



Context: I had written this as a note many months ago. On reflection, I think the term _bribe token_ might better be reserved for the ongoing “Curve” wars and the rise of DeFi gauge bribes…

## 🧙🏼‍♂️ Gaming the blockchain

```jsx
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0-solc-0.7/contracts/token/ERC20/ERC20.sol";

contract BigBlockToken is ERC20("Big Block Gang", "BB") {
    fallback() external {
        require(block.gaslimit >= 25_000_000, "your block is too small ;)");
        ERC20._mint(block.coinbase, 1);
    }
}
```

_Figure 1. Simple Miner Incentivisation Token. Inspired by [@thegostep](https://twitter.com/thegostep/status/1364660556234383366/photo/1)_

The unfortunate reality of a state machine with distributed consensus is that there will be politics. Just like the legacy financial system was supplanted by the coded rules of defi, the politics of tomorrow will be coded in smart contracts.

Today, this looks like harmless on-chain voting. Tomorrow, it looks like the simple contract above. Roughly stated, that contract is an ERC20 token that can only be minted to Ethereum miners (and future validators) that submit blocks of 25M gas or greater. Just like a majority of tokens on Ethereum, this one has no inherent value. But if I'm a third party that wants larger blocks, perhaps because I run a large farm and would benefit from centralization or I'm a nation-state that wants to take over Ethereum, I can simply buy these tokens off a Uniswap market (seeded by the miners). What's the effect? Miners are now incentivized to collect these tokens. It's MEV gone wrong.

## ⛏ Digging Deeper

The quick solution to the above is to code a block limit into the Ethereum protocol and include it in one of the many upgrades that happen every year. Indeed, that's exactly what should happen this summer with the London hard fork.

But what happens when you generalize this? I think bribe tokens are primed to change the way the politics of blockchain economies work. In fact, there's quite an elegant analogy in this concept. Consider:

- Lobbying → buying bribe tokens
- Politicians → contract deployer and social promoter
- Protocols → legislature

While I don't expect the base layer blockchain protocol to be the ultimate victim of bribe tokens, though I'm sure we'll continue to see renditions of the above, the real target is the existent DeFi protocols.

_💡 Important aside: bribe tokens are always created by a third party with no on-chain relationship to the target. Otherwise, this would just be standard community incentives through rewards._

## Example

I think a protocol that could be an easy target of a bribe token campaign is a dex aggregator like 1inch. Given that order routing is a commodity, an actor might want to incentivize order flow to _not_ go through the 1inch contract. This could happen if 1inch consistently got worse-than-optimal prices.

In this case, the bribe token would have the following functionality: Mint for every sandwich attack on a 1inch trade.

Here's a skeleton implementation:

```jsx
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0-solc-0.7/contracts/token/ERC20/ERC20.sol";

contract Make1InchIrrelevant is ERC20("F 1inch", "f1inch") {
			// set Helper contract as minter
}

contract Helper {
		// escrow token ahead of 1inch transaction
		// log pool balance
		// require change in second transaction
		// return token difference/profit
		Make1InchIrrelevant._mint(/* mint token to caller address */)
}
```

Now, any actor who agrees with the anti-1inch political view can purchase/bid these tokens and contribute toward consensus incentives to front-run 1inch trades.

## Okay, but what's the opportunity?

If bribe tokens succeed in being used effectively, I would hope to see a "Gauntlet network for bribe tokens". If set up as an effective, altruistic DAO, I imagine a protocol that acts in public goods-like service to ensure the social arbitrage of a protocol is not left unchecked. Restated, this means that the irrational behavior of blockchain participants does not cause a contract to not function as intended (exogenously). In the case of 1inch, ensuring that it cannot have a sandwichgate attack.

Bribe Tokens



I originally posted this analysis on Twitter here: https://twitter.com/brianfakhoury/status/1485150532897591301

I came across something interesting that the team behind Boba network is working on: https://github.com/omgnetwork/optimism-v2

TLDR: blockchains are *supposed* to be perfectly discrete state machines with no outside effects. But, if you're a rollup, perhaps fraud proofs can add some slack.

The idea here is "hybrid compute" smart contracts -- everything functions normally, but contract code can also query an external API.

On an L1 chain, this would be ludicrous as APIs are the antithesis to a predictable/unchanging state. The number of attack vectors would be huge.

You need to be able to replay the chain and not have to worry about an API endpoint being down or returning different data.

Throwing this assumption aside for a moment, this power would be incredibly useful for things like random number generation, price oracles, compute, etc..

Of course, it falls heavily on developers to use secure endpoints and correctly represent the risk on the front end.

I'm not saying it's a good idea, I just think it's sick tech. Here's a quick overview of how it works in their "Turing" implementation:

Imagine being able to write code like this inside a contract.

(technically only 1 turning call can happen per transaction, assuming this is bc of a recursion attack)

![](Blog/Assets/image.png)

To enable this type of EVM execution, the Geth client (L2TGeth) is first modified at the execution layer.

L2TGeth, in simple terms, intercepts function calls that have an external effect, replaces the inputs, and continues executing EVM like nothing happened.

The hard part comes at the consensus -- it's difficult for other verifiers to re-execute transactions with an RNG, for example.

To overcome this part, Turing transactions are saved into block metadata which is understood to be parsed "as is" by other L2TGeth clients.

The representation of Turing transactions occurs in the canonical transaction chain (CTC), meaning there are no special exceptions happening at the consensus layer, and consequentially in the L1 contracts...

Assuming all the complicated plumbing works, how is fraud prevented?

As a quick refresher, blocks on rollups are put together by "sequencers," a special node on the network that is responsible for ordering transactions. Sequencers do not have to be fully decentralized, and it's up to the rollup governance to decide who has the ability to run one

So while anyone can verify the validity of an optimistic rollup like Boba, only a privileged sequencer can actually produce a block.

In the case of a system like Turing, this is especially important because sequencers can have a reputation.

Right now, there's only 1 sequencer on the Boba network, while there are many nodes that relay transactions and verify the state. So, if you see where I'm going here, the sequencer, being metaphorically watched by the whole world, can't risk losing trust.

On one hand, user funds are always available by mainnet security, and on the other hand, funds that are ephemerally at risk by a Turing call, likely a fraction of the economic value of the rollup, are kept in check by social consensus.

Should the sequencer try to game a Turing transaction, it's likely social consensus will halt the flow of future Turing transactions immediately and punish the sequencer later perhaps by removing it entirely!

These types of economic systems are exciting *because* they are imperfect, yet they have the potential to further open up the design space on public blockchains.

You don't have to look much farther than current bridges/xchain messaging to see these same dynamics...

So while the fraud proving system doesn't directly disincentivize bad behavior, the nature of permissioned sequencers and public state make this something possible in practice.

Unfortunately, I couldn't get the tests to work on my machine, which is a hint at the lift that this probably takes for it to be considered robust.

Regardless, hope someone learned something from this, and I hope to see others experimenting as well

![](Blog/Assets/image-1.png)

Hybrid Compute Smart Contract Platforms



![Puente romano de Alcántara. An old Roman bridge.](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2Fdc1528bb-ae8f-47ab-9c8c-5e7b49f99b5f_800x524.jpeg "File:Puente romano de Alcántara, en El Museo Universal.jpg")

I always come back to this metaphor: a blockchain is an economy. Yes, blockchains partake in _our_ economies. But, on their own, networks like Ethereum are their _own_ economy. They are capable of (virtual) production without any external effects.

In the real world, economies are likely to benefit from interacting with one another. This is also the case in crypto. To date, the absolute number of blockchains has, in a Cambrian way, exploded. Bitcoin’s beloved distributed ledger technology was (this is oversimplified) sliced and diced hundreds of times to create cryptocurrencies like Dogecoin that we all know and love. This has collectively built a multi-trillion dollar asset class in the span of a decade, and, as we’ll come to see, the economic opportunity here is only just getting started because of bridges.

![Most Popular Blockchains. With a total count of 253 being tracked. Source: Messari](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2Fa23f7852-63c8-4db6-8bf4-30d81081a27b_1334x1538.png "image.png")

#### What is a bridge when it comes to blockchains?

Let’s use the United States for this example. Within the US borders, economic activity happens quite freely, being curbed here and there by regulation and law, but mostly replicable and interoperable state by state.

In a closed system, materials originate in the US, are processed here, and the product is sold here. In theory, this would absolutely be a valuable and productive system. In practice, we build bridges and move materials, money, and products across them, dealing with the two-sided complexity of converting from one set of rules to another. We build economic bridges to Canada, Mexico, China, Europe, etc... why? Without getting beyond the scope of my knowledge, it’s because there are valuable economies outside the US that we benefit from interacting with. There are assets elsewhere in the world that, when utilized correctly, make our own assets more productive.

Blockchains are, and I cannot stress this enough, no different aside from having virtual rather than physical goods. In fact, the most shy adopters of crypto have indeed used a bridge. For people in the US, that bridge is likely Coinbase. If we think of Ethereum as its own economy, you need a way to get into that state. What Coinbase has built for us in the US economy is a bridge to the Ethereum economy, wherein Coinbase will hold Ethereum assets in our name and give us an interface for that representation. Should we want to go elsewhere in the Ethereum economy, perhaps to buy an NFT or join a DAO, we would cross the Coinbase bridge, take custody of our assets, and no longer be interacting with that bridge. But while we were still with Coinbase, our assets where merely a US economy representation of them on the real blockchain. When we cross the bridge, we receive those assets in our own wallet, and only then are we independent actors in the Ethereum economy.

#### Enough jargon, what’s the utility here?

Simply put, Ethereum is extremely secure but **slow** and **expensive**. I think MakerDAO’s $DAI is a great example to illustrate this. DAI is a “stablecoin” built on Ethereum. It’s always worth $1, is backed by other crypto assets, and can be used by anyone around the world without permission. Don’t take my word for it, take the billions of dollars of DAI that have been minted for crypto natives to use as a stable asset:

![Amount of DAI in existence over time. Source: daistats.com](Blog/Assets/Amount_of_DAI_in_existence_over_time._Source!_daistats.com.png)

DAI is a great asset, so much so that people want to use it _outside_ of Ethereum. **And here’s a major point on why other blockchains exist: you don’t need the full backing of Ethereum if you want to pay for a coffee with crypto, say in DAI.** For this use case, while blockchains are still very practical, there exist other chains that process transactions must faster than Ethereum, one of these being the (Ethereum friendly) Polygon Network. A transaction on Ethereum ranges from a few dollars worth of Ether to hundreds of dollars worth of Ether. They also take at least 15 seconds to go through and be confirmed. I’m not saying this is bad, Ethereum is massively useful. But when I use Polygon, the transaction is confirmed in a couple seconds and the fee never gets near a penny even.

_“Great! I would like to transact with DAI on Polygon then.”_

Not so fast. DAI is created on Ethereum much like US Dollars are created in the United States. Any DAI that I use on Polygon has to have been brought over either by myself or someone else at some point. Thankfully, the Polygon developers have built a nice bridge for any assets on Ethereum to easily be brought over to Polygon: 

![Ethereum to Polygon Bridge](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2F9e420ff1-5b04-43bf-a493-cc81d0ff224c_998x854.png "image.png")

The bridge works by holding custody of the assets on Ethereum, and issuing 1:1 that asset on the Polygon network. This doesn’t require any input from MakerDAO because DAI is permissionless, and DAI issued on Polygon by the bridge is backed by the real thing on Ethereum. But, because of high transaction costs on Ethereum, it’s not cheap to move DAI over. Though once it’s there, it’s easy and inexpensive to use. (for those that are extra curious: MakerDAO is considering **creating** DAI on Polygon in the future through the same collateral process as on Ethereum)

In my head, I think of this Ethereum<>Polygon bridge as a blockchain international highway. Assets leave the borders of Ethereum in bulk, and are redistributed in another economic region. Given that the bridge acts perfectly and does not mess up the accounting for assets on both sides, this is indistinguishable in nature from physical goods crossing physical bridges.

Another easy example here is **Bitcoin**. Compared to Ethereum, the Bitcoin network is even slower and can only do a fraction of the things that Ethereum can do. Regardless, there’s still a trillion dollars of assets on bitcoin. Let’s bring it over the highway and use it in the Ethereum economy?

The difference in this example is that neither Bitcoin developers nor Ethereum developers have built an “official” bridge for bitcoin to come onto ethereum (Ether could never go onto Bitcoin because of limitations of the network).

Therefore, it’s up to third parties to “bridge” bitcoin over. There’s a wide range of solutions here. On one end, you have traditional companies like BitGo who will take people’s bitcoin, and issue them a “wrapped” version on Ethereum ($wBTC), with the ability to come back and “unwrap” the tokens for their original bitcoin. Other solutions focus on permissionless bridges where a group of independent validators put up some collateral for the ability to wrap/unwrap bitcoins with the penalty of losing the collateral should they act maliciously. Examples of this are Ren Protocol and Keep Network.

To sum it up, blockchains have a native asset, like BTC or ETH, and possibly tokens within their network, like DAI, that have utility or need outside of their native chain. Let’s continue.

#### Why go through all this trouble?

It doesn’t end here. Building the bridge from Ethereum is a tough task. With a growing number of blockchains, the number of required bridges will grow exponentially:

![There will be lots of highways between blockchains.](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2F8539c1bd-2667-474d-8867-7acfbdc0a4ef_1400x1274.png "image.png")


As is apparent with Bitcoin and Polygon, different blockchains have fundamentally different security/decentralization/fee tradeoffs. On one end, you have something like Binance Smart Chain. It functions very similarly to Ethereum, except it is much more centralized. At the cost of only a few parties controlling the whole thing, fees are cheaper and transactions go through faster. This works fine for an average person with relatively small financial activity, but if you’re a big institution, this amounts to real counterparty risk. NFTs are a popular application of blockchains, but do I really need the same security promises for my ownership of a cat JPG that I do for my financial assets? Probably not, and this is why the market is keen towards different blockchains with different characteristics.

[

![](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2F1c7fed19-9423-4bdb-9caa-6db27179ffc7_936x808.png "image.png")

#### Scalability and dependency

As bridges get stronger, the economic security of Ethereum actually becomes a better selling factor as I see it: you can leave and come back to the strongest economy with increasing ease. In this regard, asset architects might always elect to mint on ethereum, but have available liquidity on other chains.

On one hand, lots of independent blockchains exist that have nothing in common with Ethereum. For example, Solana can process 50,000 transactions a second with fees that are a fraction of Ethereum’s. This is great for things like trading, but aren’t as useful for something like NFTs. Still, a lot of assets on Solana come from Ethereum through their bridge.

This begs the question, should other blockchains strive to be independent, or share a commonality with Ethereum? The Polygon network elects the latter, choosing to “commit” checkpoints of its own state onto Ethereum, have a built-in asset bridge, and use the same programming language as Ethereum for its smart contracts. Others that do this in one way or another are the Fantom Network, Avalance, Celo, Binance Smart Chain, xDai, and more.

Another variation here is “Layer 2”. While a blockchain like Binance Smart Chain does not depend at all on Ethereum, something like Polygon needs Ethereum to serve as “checkpoints” in case of critical failure. This makes the Polygon network a sort of second layer on top of Ethereum. One that runs faster and cheaper, enabling the underlying layer to be more productive. Sound familiar? “Assets elsewhere that make ours more productive.” Ethereum stands to benefit most from L2 scaling. It’s like having remote colonies that are highly productive and on your side. In this regard, a whole class of technologies have been launching that take the heavy lifting off of Ethereum until it needs a “checkpoint”. These include Optimism, Arbitrum, and many more key players.

This critically improves end user experience as transactions that share the security of Ethereum appear cheaper and faster, and in the background, ultimately settle on Ethereum, the L1.

BUT, there’s a big piece missing here. Going back to the beginning, virtual assets only exist in the economy in which they were created. Having 1 ETH on Ethereum means nothing to Polygon if I can’t use it in the Polygon network. That’s what bridges solve, but in Layer 2 scaling world, there won’t be a winner-takes-all. Polygon, Optimism, Starkware, and Solana will all have functioning ecosystems that users will want to be a part of. If each one has it’s own bridge to Ethereum, great, but that makes switching between them expensive and complex. What we need is true interoperability between blockchains. I need to be able to have DAI on Polygon and move it over to Optimism directly. The DAI that I receive there should still be the 1:1 backed DAI that exists locked on the Ethereum network. If this problem is solved, the native digital economy of the internet will be without limit. No matter where value is created, it will be honored and useable anywhere else.

#### The Connext Way

Connext is a leading project in solving blockchain interoperability. They already have a working bridge [here](https://xpollinate.io/) that allows for transfer of tokens between an assortment of EVM (that more or less means can easily run code built for Ethereum) blockchains:

![Connext enabled bridge.](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2Fff69ddc1-5a2d-4b44-b759-77df6ded486f_1312x892.png "image.png")

How does this work? It’s actually fairly straightforward if we skip some of the technicality. Since the asset already exists on all these blockchains because of their bridge with Ethereum, Connext creates pools of each token, say DAI, on each network. Then, users and applications alike can swap between the pools by depositing DAI into a pool on one network and taking it out of the other. The benefit of EVM blockchains is that existing addresses and private keys work across any of the networks, so your asset is ready to go in your wallet once the swap is done.

#### fin

This is ultimately the game of snakes and ladders. In a crypto economy where capital is vying to be productive, the game is sped up and slowed down by cross-chain liquidity pools and baked-in asset bridges that will truly make the Internet of Value an unbounded economic arena.

---
[1] [https://stonecoldpat.medium.com/a-note-on-bridges-layer-2-protocols-b01f8fc22324](https://stonecoldpat.medium.com/a-note-on-bridges-layer-2-protocols-b01f8fc22324)
[2] [https://insights.deribit.com/market-research/making-sense-of-rollups-part-one-optimistic-vs-zero-knowledge/](https://insights.deribit.com/market-research/making-sense-of-rollups-part-one-optimistic-vs-zero-knowledge/)

The Snakes and Ladders of Crypto



![The Code Of Honor—A Duel in the Bois De Boulogne](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2F1d371797-67c7-4bca-b260-188c2aaaf53e_1221x903.jpeg)

There's an analogy I've heard a number of times that is paraphrased as:

> When you go to buy a coffee, it's the fighter jets in the US Military that, after quite a sequence of cause & effect, ensure that your credit card transaction credits the merchant.

This sounds absurd, but it's really not. Provenance in the real world is tricky. Our trust assumptions rest on our courts upholding a fairly neutral account of (paper) law. But what upholds the courts? Well if you're an individual challenger, maybe a police officer or two will "uphold the courts." if you're a large, organized group, or perhaps a nation-state, the military will uphold the courts. The point is that government in the physical world has a sort of monopoly on violence, and under that assumption, we're free to go about making deals and contracts with other people.

Crypto is quite wacky. If someone halfway around the world steals your funds or your favorite NFT project rug pulls, there's no universal authority you go to right the wrong. In fact, with the way crypto is built, you'll likely _never_ be able to resolve the problem after the fact. Crypto economies differ from traditional economies in that:
- Crypto economies are sovereign and self-sustaining, and can even function in a (virtual) vacuum.
- Traditional economies scale with labor, while crypto economies scale with the distribution.

When enough participants of a shared system are at risk of general conflict, we need a mechanism for **consensus.** Paying for your coffee at Starbucks, consensus lies with a centralized authority that is likely Visa or Mastercard (and the courts as a backup if they become unruly). When sending cryptocurrency like bitcoin, the consensus is the proof of work algorithm that miners run on dedicated hardware that underscores the bitcoin network.

It's a huge breakthrough that consensus in crypto is derived from cryptography. There's a side argument to be made around social consensus on which blockchain is legitimate, but assuming the big ones like Bitcoin, Ethereum, and Solana have a sufficient number of people that believe assets in their ecosystem are real, the consensus is then fully derived from cryptography.

The handy thing about cryptography is that it is as sovereign as the laws of physics. There's no human influence, and you're better off trusting (to the nth degree) information made by wallets signing with a private key over trusting information from "people" on social media networks.

### Ethereum scaling solutions

Conflict resolution re-enters the sphere of thought once we look at scaling blockchains by doing things _off-chain_ and then reporting related data _on-chain_. This is essentially what the [rollups](https://insights.deribit.com/market-research/making-sense-of-rollups-part-one-optimistic-vs-zero-knowledge/) do. Think of it as a zip file for transactions. Rather than using precious units of gas on an expensive chain like Ethereum, why not compute the result somewhere else and just post the result? The technical issue is with conflict resolution. In a world without zk-snark rollups (that let us prove the computation was correct with cryptography), we need ways to resolve conflict when a rollup posts the wrong data/results. The elegant consensus for this turns out to simply be **optimistic.**

Optimistic conflict resolution says that we only assume no conflict until there's proof that wrongdoing happened. Optimistic rollups as an Ethereum scaling solution, hence, can zip up any number of transactions and say they happened to Ethereum.

Example: Say I'm a participant in the economy on Arbitrum (an optimistic rollup). I'm providing whatever value by selling NFTs, and Arbitrum makes these transactions way cheaper by computing my complex royalties logic for how much I should get paid when people are trading my art, and then simply posting the resulting balances back to good ole secure Ethereum. If a bad actor colludes with an Arbitrum node to trade one of my NFTs _without_ paying the royalty defined in the smart contract, I'm on the tail end of that and will be upset. Thankfully, conflict resolution is simply going to Ethereum, and asking it to prove the legitimacy of the suspicious transaction. The cryptography will quickly surface that the result is **fraudulent** since I wasn't credited my royalty, and punish the node that colluded with the bad actor. A lose-lose situation for all.

### Oracles

Oracles are so important to blockchain economies because they inform autonomous participants like smart contracts what's going on **outside** (i.e. I want to know the weather in Boston to settle a bet). Oracles are a tough problem because we cannot use cryptography to stop them from posting wrong answers. We can only achieve strong oracles through incentives and reputation. The problem space that intrigues me here is (surprise) optimistic oracles.

Here's a thought experiment. You and I are going to race, 100 meters. I'm confident that I'll smoke you, and you are equally as confident that you will prevail. Let's highlight two variants of outcomes. In one variant, there's a clear winner, and in the other, it's too hard for you and me to tell. In the former case, when the race ends and I win, we're fine settling the bet between us since it was obvious I won. In the second case, we were neck and neck, and we can't be sure that I won. If I try to claim victory, you'll object, and we'll ask our friend who was watching. They say I won and we settle the bet.

An optimistic oracle does _nothing_ most of the time as the resulting data that is needed is entered manually by parties and everyone agrees.

![](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2F01d742ae-6b19-4a36-b168-6bf8871099de_1024x734.png)

[UMA](https://umaproject.org/) has such a neat implementation of this. It's literally a court system built on-chain that acts as the fighter jets for any smart contract ecosystem. Without this system, smart contracts would have to query an oracle like Chainlink for any off-chain info, adding to costs and complexity. With UMA oracles, we can go about making deals & contracts with each other and with smart contracts, knowing that we can integrate with UMA and settle disputes with their DVM (data verification module). I think this is crucial for a crypto economy.

### Parting words (I'm very tired at this point)

Optimistic conflict resolution has served humanity well for centuries and has now shown its prowess in virtual economies. While ZK-proofs (a technology so powerful that it'll be a game-changer for this century) might offer the transcendence step to perfect provenance, in the meantime, let's build optimistically.

---
[1] [https://www.weforum.org/agenda/2020/12/dispute-resolution-is-critical-for-blockchains-successful-growth-heres-5-reasons-why/](https://www.weforum.org/agenda/2020/12/dispute-resolution-is-critical-for-blockchains-successful-growth-heres-5-reasons-why/)
[2] [https://docs.umaproject.org/oracle/econ-architecture](https://docs.umaproject.org/oracle/econ-architecture)

Conflict Resolution, Optimistically



![John Law’s Bank Royale. Not a liquid super community. RIP.](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fbucketeer-e05bbc84-baa3-437e-9518-adb32be77984.s3.amazonaws.com%2Fpublic%2Fimages%2F6d7924d3-0e47-48fb-9618-acc5041f3622_1000x575.jpeg "John Law: Genius or Fraud? — Parisology")

There’s a recent article by Packy McCormick that made rounds for describing “liquid super teams.” It’s a neat way of thinking about how small teams can come together online and build a digital product quickly, efficiently, and without the burden of a traditional company with an HR department 😬. https://www.notboring.co/p/the-cooperation-economy

I think this idea can be expanded to liquid super _communities_. In the era of _web3.0_, projects & startups derive value **from their community**, especially in the early days. These early communities tangibly contribute to marketing, development, and governance. Unlike web2 counterpart communities, these communities stand to be rewarded _[without friction](https://www.reddit.com/r/TheoryOfReddit/comments/1ktcye/have_their_been_attempts_to_monetize_a_subreddit/)._

The community stack for crypto has (roughly) been
- **Place:** Discord
- **Wealth:** Governance and/or utility tokens
- **Polls:** [Snapshot](https://snapshot.org/#/)

Tokens are what make super communities _liquid._ What used to be restricted to organic & fragile growth is now exponential & antifragile. Take a look at [Friends with Benefits](https://www.fwb.help/) — an obviously high-value group of people that will slowly but surely attract more awesome people if it were on a web2 forum like Reddit. The difference? Token-gated Discord. There are 1M FWB tokens in existence, and you need 75 at the time of writing to join.

I joined when the requirement was 60 tokens, requiring me to swap ~$300 of ether on Uniswap to join. Unlike a country club, my tokens never leave my custody. Depending on market prices, my “membership” can likely be sold without a loss of capital. What drives the market here then? Demand to be in the community. The special part? People can join and leave, either enriching the community with their presence or detracting with their departure. This is directly measurable by the current cost of membership.

The innovative model here is in the EARLY days. The monetary rewards and wealth creation of these communities will A) drive development for infrastructure tooling and B) lead to wackier experiments (see [Partybid](https://www.partybid.app/) 🙌🏼).

There are a few extraneous catalysts also happening:
1. Smart contract platforms are proliferating. Ethereum is on the cusp of Eth2.0, Polygon has full blocks (it’s highly utilized because it’s a cheaper Ethereum experience), and Solana is ridiculously performant.
2. The world is harder to get around, yet talent is cropping up everywhere. What other way to coordinate valuable activities with your friends in India and Argentina than through a shared bank account and community on a blockchain?

I guess the real reason I wanted to write about this is token gating. I think token gating is underrated and far more innovative than people realize. We’ve grown used to a world with digitally gated events (i.e. concert tickets and such). But there’s no standard here. Tokens on-chain are ERC20 (super easy and quick to [spin up](https://mobile.twitter.com/genzDAO/status/1420574312726212610)), can be used for financial leverage, can be composed into other apps, can be read by 3rd parties, and are a digital collectible that won’t break if a server goes down ;’) I postulate you can’t [route value in web2](https://twitter.com/owocki/status/1390357136815779845).

That’s it. There’s a lot more to be talked about here, but it’s likely I’ll be diving into something more technical next week to stretch that muscle. If you’re not part of a DAO or web3 community, I always like to recommend the [Discord](https://seedclub.xyz/) of Seedclub as a way to get started. From there you might be interested in FWB or maybe [SquiggleDAO](https://squiggledao.com/) 🤔. More to come on our very own Gen Z DAO as well for all the zoomers out there.

Liquid Super Communities



One year ago, the world was learning to adapt to being digital-first. In the wake of the pandemic, markets across the world were quickly selling off. And within the crypto community lay murky aftertaste and a not-so-fond memory of “Black Thursday,” a day when the price of all crypto tanked in unison, pushing crypto infrastructure to its knees.

Institutions, small businesses, and individuals alike all lost wealth as measured by their assets. Another category of organizations, called DAOs, or **decentralized autonomous organizations**, had felt this pain too. What came from it? The story that is told in the year to follow sets the case that these mystical, and somewhat theoretical, organizations might just be the premiere setup for all institutions and businesses alike one day.

The name decentralized autonomous organization can be confusing. Let’s break it down, in reverse:

1. **Organization:** everyone knows this part, and it can be easily referred to as a group of humans and optionally other organizations.
2. **Autonomous:** in this context, meaning able to self-persevere without outside influence. Similar to an “autonomous” region in a country that is able to self-govern (i.e. Hong Kong).
3. **Decentralized:** referring to the technology on which these autonomous organizations are built, and further referenced in this piece as smart contracts on the Ethereum blockchain. The opposite of this might be organizations built on legal papers ratified by a central authority, aka government.

In summary: a DAO is created by a group of crypto wallets controlled by individuals and other organizations that executes all its movements through code, making it possible to manage assets and votes safely without the need for underlying legal or traditional banking setups. Membership in a DAO can be extremely fluid compared to what traditional organizations can achieve, and DAOs have been used to manage assets, build protocols, vote on community matters, and create niche factions for interests like digital art collecting.

Let’s look back to 2020 one more time and paint a picture of trajectory. At a time when [$ETH](https://messari.io/asset/ethereum) was trading at $230, DAOs barely made a dent in the financial world, with the long tail of them holding only a few thousand dollars worth of assets:

![Snapshot of DAO assets. Source: Messari Crypto](Blog/Assets/Snapshot_of_DAO_assets._Source!_Messari_Crypto.png)

After a year-long crypto bull market, millions of new people introduced to crypto, and thousands of projects launched and generating fees — let’s just say things are different today:

![Figure 2. 2021 Snapshot of DAO assets. Source: Messari Crypto](Blog/Assets/Figure_2._2021_Snapshot_of_DAO_assets._Source!_Messari_Crypto.png)

We’re now measuring DAO holdings in the millions. It doesn’t stop there even — widely adopted crypto protocols that have been built over the past year control huge treasuries of their native token, sometimes totaling in the billions in terms of the worth of those assets. An example of this is [Uniswap](https://uniswap.org/), a massively successful protocol that allows for decentralized and permissionless trading of assets on Ethereum. Their treasury? About $7,200,000,000; or over seven billion dollars worth of mostly UNI tokens. (we can check this total along with treasury movements at any time we want; the data is fully transparent and able to be queried by anyone!)

The effect of this massive wealth inflation by this category of organizations is wondrous. As Ethereum- founder Vitalik Buterin points out in [this great blog post](https://vitalik.ca/general/2021/03/23/legitimacy.html), funding of engineering and development for public blockchains is minuscule compared to the value they create.

![Figure 3. Relative funding of public blockchain development. Source: Vitalik Buterin](Blog Posts/Assets/Figure_3._Relative_funding_of_public_blockchain_development._Source!_Vitalik_Buterin.png)

From millions to billions in assets, a zeitgeist-market fit, and a future irreversibly dominated by the internet, DAOs have gone from being a clubhouse for crypto-nerds, to the equivalent of a boardroom full of suits when it comes to dealing with serious matters of business. With this level of power comes the ability for the early crypto community to now build out serious grant ecosystems for public goods, provide benefits for users of their ecosystem, decentralized philanthropy, and most importantly — further decentralize.

## The Future Boardroom of Internet Organizations

_A simple thesis:_ the most important DAOs will govern many billions of dollars and control, as just one example, the upgrade path for the future financial infrastructure of the world. The tokens by which grant access to DAO voting will play an increasingly important position for investors to take best interest changes into their own hands, while also earning revenue from the success playing out through protocol fees. These assets are a superset of what equity in a traditional public company is, and thus will flourish in the DeFi world in which they were natively built. Furthermore, lending and borrowing of governance tokens will make voting power fluid and reactive to the value of the vote, incentivizing great protocols to make great decisions. **Welcome to the internet boardroom.**

## Compound Finance DAO Example #1

Let’s start with a concrete example: [Compound Finance](https://compound.finance/).

Compound is an algorithmic money market built on Ethereum. This basically allows you to borrow money by putting up other money as collateral. Have some bitcoin? Put it in Compound and borrow dollars against it. Earn interest on the bitcoin, pay interest on the dollars. Or just put in dollars and earn interest, which is currently sitting at a cool 6% APR.

The magic and excitement enabled here is that it is unstoppable, permissionless, and algorithmically controlled. An application built on ethereum cannot be censored, anyone with access to the internet can use it, and all the calculations (i.e. APRs) are done by well-audited code.

Where do DAOs come in? Well, the Compound protocol needs community consensus on which new markets to add, what parameters to change, how to issue COMP governance tokens (as a reward to protocol participants so they can participate in the DAO as well), and what to do with their three billion dollar treasury! Amazingly, by owning COMP tokens, your ownership weight is your voting weight! Own 1% of the COMP supply, get 1% of the vote for proposals. This is similar to having voting shares in a company, except you’ll enjoy much more freedom by owning transferable, permissionless COMP tokens.

Because the proposal and implementation process is algorithmic and on-chain at the end of the day, we can use a tool called Tally (though there’s plenty of others that will display the same info) to view what’s going on with Compound: [withtally.com/governance/compound](http://withtally.com/governance/compound).

Let’s look at a simple proposal for Compound, proposal 37: _“Return Accidentally Sent Funds.”_

Should Compound implement functionality in their smart contracts on Ethereum to return whatever tokens that some user accidentally sent directly to the protocol on accident? The way it sat, the protocol had no way of returning those funds — code is law! If passed, the updated code will be deployed as new contracts on the Ethereum blockchain (automatically if the signature threshold is passed), and now a future user can claim funds that they accidentally sent to the wrong Compound pool address. How helpful! _(FYI do not send funds directly to smart contracts unless stated otherwise, it’s obviously a big enough issue to warrant governance vote!)_

According to the Tally page, [Robert Leshner](http://withtally.com/governance/compound), founder of Compound, and owner of over 1% of COMP tokens, votes yes by signing with his wallet that holds the COMP tokens. Let’s repeat this, by holding COMP tokens, there is no second step needed to vote from any address in the world. No KYC, no jurisdiction, no overhead. Just pure community consensus on what is best for the DAO.

## The new properties of organizations built as a DAO

A lot of DAOs implement a function in their smart contracts called ragequit. This function serves simply to let any DAO member call it, and immediately remove themselves from the DAO, receiving their pro rata assortment of assets. This is remarkable in a number of ways! Let’s think of a real-world example where a partnership agreement specifies in writing how a member could leave and take their share of money out of the company. Traditionally, if all goes well, paperwork is signed, and in a few days, all is well and on its way. Some of the assets might be hard to liquidate or split up, but it’ll get sorted. In another scenario where there is a dispute on the terms, lawyers involved and all, leaving a partnership might take months and be very expensive! The ragequit function is agnostic to all this. The second it’s called, assets are transferred according to the rules, no papers are signed, no one even has to check! This can all happen within a few seconds. Most importantly, it’s agnostic to how anyone feels. An unruly member can’t get in the way.

![Figure 3. Generic DAO flowchart with ragequit(). Source: Consensys](Blog/Assets/Figure_3._Generic_DAO_flowchart_with_ragequit()._Source!_Consensys.png)

The disparity between traditional organizations and DAOs in these edge cases is really important, and what in essence can lead to their future takeover. By natural selection, the organizations that are the most fit and resilient will last. What’s more resilient and permanent than a DAO? Nothing! The fluidity goes above and beyond what any paperwork can ever implement, and can scale larger than any corporation that exists right now. In fact, there’s no reason why an entire country cannot be a DAO.

Let’s go a step further in terms of mechanics. Going back to the Compound example, since COMP tokens are required to vote, and since they’re freely traded on the market, it’s really easy to buy votes! While this might give inherent value to these tokens (if they were super cheap, a bad actor could buy them all up and ruin the system), this also sets up secondary money markets for power. Instead of depositing collateral to get some cash, you can in theory deposit collateral, and take out voting power! This puts a whole new spin on “money is power”. A large bitcoin whale could deposit wrapped bitcoins into compound, borrow a bunch of COMP, vote on their wishes, return the COMP, and leave with their BTC untouched.

This might sound scary, and even borderline plutocratic. The point that I think should be driven home is that we’re about to see a whole new level of efficiency where the lines between capital and governance are blurred (hat tip to [Joel Monegro on governance](https://www.placeholder.vc/blog/2019/2/19/cryptonetwork-governance-as-capital)).

## Other Examples of DAOs, in and out of DeFi

DAOs can be charged with doing anything really. There are DAOs for bringing bitcoin to ethereum ([BadgerDAO](https://badger.finance/)), collecting art ([FlamingoDAO](https://flamingodao.xyz/) — check out their entire collection [here](https://opensea.io/accounts/0xb88f61e6fbda83fbfffabe364112137480398018)), and even a DAO run by other DAOs responsible for building DAO tools.

This last one is called UberHaus, and they’re responsible for governing the [DAOhaus](https://daohaus.club/) platform so that new DAOs can launch with all the tools they need. More on this in the picks and shovels section.

An internet boardroom does not need to apply solely to profit-generating organizations. [The rise of NFTs, which Underscore VC wrote about back in 2019](https://underscore.vc/blog/the-non-fungible-tokens-landscape/) has shown artist and cultural interest in crypto beyond the cypherpunks. This has been validated as DAOs have spun up to manage digital art collections. For example, a last minute DAO, called [PleasrDAO](https://twitter.com/pleasrDAO) (collection [here](https://opensea.io/accounts/0xf5c27c6fe782cbb5c85989ea3e75754748153459)), was spun up to buy a commemorative NFT for the launch of a new Uniswap version with the proceeds going to charity. The group funded the DAO extremely quickly and bought the NFT for $2.5M! Here it is:

_Figure 4. A $2.5M mp4 file owned by PleasrDAO. [Source](https://etherscan.io/token/0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405?a=13623)_

What about traditional businesses, say your run-of-the-mill Fortune 500 company? Why would all businesses be controlled by a DAO on day? Nexus Mutual is an insurance mutual that provides cover to its members that are exposed to various risks in crypto. The DAO model is wrapped in a legal entity for compliance purposes, but otherwise is able to operate ultra-efficiently as a DAO on ethereum. This model allows for them to operate an insurance mutual solely over the internet, with a rigid and trustworthy structure that is incentivized to pay out claims.

## Picks and Shovels for DAOs

DAOs are code, and code is hard. As things progress, not every group of people will be able to program their own DAO, just like not everyone can write up the legal papers for an LLC or code their own website. The tools here are incredibly important.

![Figure 5. A rough landscape of the picks and shovels for DAOs. Source: Underscore VC](Blog/Assets/fig5.png)

I mentioned [DAOhaus](https://daohaus.club/) as an all-in-one solution, but as we see above, there’s plenty of individual tools that can be used. For example, Snapshot lets you collect signatures for a proposal in an off-chain manner. The use case is that for wallets that hold your governance token, a signature by that wallet is more than enough proof of vote, and saves the costs of creating transactions on the blockchain. Imagine holding $100 worth of COMP and having to pay $20 to vote on a single proposal. [Aragon](https://aragon.org/) is more similar to DAOhaus, offering a modular assembly approach to pick and choose for your DAO.

### A Call to Action: Are You Working On DAO Tools? Do you know of interesting projects in the space? Let’s talk!

At Underscore, we believe DeFi will rewrite the financial operating system of the world, and that governance of crypto at large is a trillion-dollar opportunity. Innovations that help control treasuries and better organize economic players will make the crypto metaverse a well-oiled business machine capable of capital coordination at scale that will make the future brighter.

### Fun fact:

As I was writing this article, the Compound treasury went from $2B to $3B. The Uniswap treasury increased by over a billion dollars as well. I had to revise these numbers 3 times!

---
## Other reading and sources

[https://medium.com/odyssy/moloch-primer-for-humans-9e6a4f258f78](https://medium.com/odyssy/moloch-primer-for-humans-9e6a4f258f78)  
[https://daohaus.substack.com/p/rage-quit-exit-rights-and-real-skin](https://daohaus.substack.com/p/rage-quit-exit-rights-and-real-skin)  
[https://consensys.net/diligence/audits/2020/01/the-lao/](https://consensys.net/diligence/audits/2020/01/the-lao/)  
[https://ournetwork.substack.com/p/our-network-deep-dive-2](https://ournetwork.substack.com/p/our-network-deep-dive-2)  
[https://newsletter.banklesshq.com/p/how-daos-should-approach-treasury](https://newsletter.banklesshq.com/p/how-daos-should-approach-treasury)  
[https://medium.com/daohaus-club/uberhaus-is-alive-%EF%B8%8F-3af528dc3494](https://medium.com/daohaus-club/uberhaus-is-alive-%EF%B8%8F-3af528dc3494) 
[https://www.placeholder.vc/blog/2019/2/19/cryptonetwork-governance-as-capital](https://www.placeholder.vc/blog/2019/2/19/cryptonetwork-governance-as-capital)

The Future is DAO: A Primer on DAOs and Their Explosive Growth



![](Blog/Assets/0!H0n3mLNUMbaJIBr5.jpg)

## 1. Thinking Fast and Slow

Mixing economics and human behavior, Daniel Kahneman — a wonderful economist — masterfully translated the consequences of quick human evolution into how our everyday lives are impacted by our circuitry. A great example I learned about was that persuasion relies on a relaxed mind listening to a repeated message. According to Kahneman, this happens in the “fast” system in the brain, while the slow system is more energy-consuming and less relaxing as a consequence. The takeaway for me is that the balance of these two systems is what we’re fighting to figure out in the modern world, where once it was easy to use the slow system when necessary and trust the fast system otherwise, we know overuse the slow system and engage the fast system in the wrong moments.

![](Blog/Assets/0!EVyyAZeIm8O-WXXc.jpg)

## 2. Joyful

This one stands out of the list as markedly different, as it is written on design and the philosophy thereof. Having sympathized with minimalism since high school, this book challenged my previous mode of thought and was successful at that as a matter of fact. My main takeaway is that objects and settings that are natural and colorful can spark a ceaseless joy that will improve one’s life. This is different than a burst of happiness, it’s more of an increased ambiance that does not wither. Practically, this fits my philosophy of carefully designing my living environment to be aesthetic, and I’ve picked up a few tips on adding color and random items that fit the atmosphere to achieve a greater feeling of joy.

![](Blog/Assets/0!tllELwQGkj7_vn7i.jpg)

## 3. Homo Deus

Long overdue, the middle child to Sapiens and 21 Lessons was yet another fascinating read by a prolific author, Yuval Harari. He really highlights the changing nature of how we view the world, and how it is accelerating. A takeaway point from the book is that the dominant story of liberalism is built on human experience, and threatened by science, and more specifically, algorithms. Free will, while a comforting myth, is being more and more challenged by technological evolution.

![](Blog/Assets/0!hVXm6lHwgKhlKhdc.jpg)

## 4. Secrets of Sand Hill Road

I picked up this book to learn more about venture capital but found the VC standpoint lacking. Still, the startup advice was top notch. The two biggest points I got from the book was the importance of founder-market fit and product breakthrough. Founder-market fit is all about why the founder of a startup is the right person to solve a market’s problem. Many people can arrive at a great idea and begin to execute on it, but a differentiating factor can come down to a founder having the right qualities and experience to grow in that market exponentially faster. On the other hand, the given product cannot be a little bit better than what current market solutions — it has to be much better, a breakthrough, in order for adoption to happen and high-growth to take place.

![](Blog/Assets/0!fbgDA8Vyk8yBN9PQ.jpg)

## 5. Super Thinking

I had this book on an open amazon tab for the entire summer because I was really excited to read something on this topic. After the dust settled, I was not too impressed, but I still had some great takeaways. The key point this book is trying to convey is that you can apply a few common frameworks to a host of thought processes and questions that you might experience throughout the day. For example, when you’re unsure of what to do, the scientific method is a fantastic framework for testing your own hypothesis, and not relying on Google and someone else’s thoughts. Now take this framework, and use it as a foundation for other frameworks. Critical mass, Occam’s razor, etc… can then be applied on top of the scientific method. One more great tip I learned was to use a variant of a pro-con list called a numbered pro-con list where you assign weights to the pros/cons.

![](Blog/Assets/0!tnyo9rabZyyPQjhP.jpg)

## 6. Influence

For being an older book, I was pleasantly surprised by how relevant the information was while reading it. I mainly took home some everyday tactics. For example, I learned that favors should always come attached with a reason as it makes people much more likely to respond. I learned that hard work makes people value the thing they worked for (of course) and that social proof (queue the laugh track) is always sought after by people — that's why we often hear phrases like “fastest-growing” and “best selling”. Also, limiting something by time influences people to act rather than not. These were all pretty general and not hard to come by, but it’s always impactful reading them in text and mulling over it some more in your mind.

![](Blog/Assets/0!vDA-Jxo3YvU6ZS6X.jpg)

## 7. Common Sense

Last on my list predates everything else on the list by a long shot. I read common sense hoping to see backward in time a few centuries. The two big points I got, from the setup of America, is that given people are equal and identify however they want, people in America at the time decided to identify as American, not British. This led to them breaking off, and the USA was born. Next, from this point, monarchy does not let identity play a part in government nor treat people as equal, and, therefore, representative governments are the better alternative for individual expression and equality.

I hope you enjoyed my thoughts!

Until the next book snippets,

Brian.

7 Books for August — Quick Snippets on What I’ve Read



![](Blog/Assets/0!xNfkwcRnxFBm7M_p.jpg)

There exists an industry in electronics that caters to the nerds, is consumer friendly, and can be a hobby. PC’s are inherently customizable because of the modular nature of the components. This characteristic allows for any person to learn how the pieces go together, like a lego set or jigsaw puzzle, and create their own masterpiece. Depending on budget and needs, anyone can create their own computer. So in 2014, I joined this community of custom PC’s. I built a modest Intel i3 system, learned the basics, and learned to enjoy this form of art.

After a year with my trusty, first desktop, I decided to create a new monster. Excuse me while I get technical if you will. For processing power, the Intel i7 chips have four physical cores plus four more hyperthreaded cores. This power, no matter the frequency or architecture, allows for creative tasks ranging from streaming media to editing media to massive algorithmic calculations. Gaming, content production, research (like Stanford’s Folding at Home project) are shown new light with the capabilities of an i7. The chip I chose was of the newest generation extreme edition i7’s, but this is a caveat. Extreme editions, or enthusiast chips, run one architectural generation behind. So going for the i7 5820k was only 4th gen architecture comparable to the mainstream 4790k. Still, the 5820k has six hyperthreaded and (importantly) overclockable cores. Combined with my AIO liquid cooler, I am able to run my chip stable at 4.4 GHz @ 1.315 Volts.

To complement the linear compute power of this i7, and add performance in other areas, I chose nVidia’s GeForce GTX 970. Back in 2015, 3.9 TFLOPS of raw shader compute for less than $400 was amazing (not anymore) and was a great complement for my 5820k. My 970 has an ASIC quality of 75% and runs almost perfect around 1600 MHz!

Here is a complete list of my setup:

PCPartPicker part list: [https://pcpartpicker.com/list/F6j2RG](https://pcpartpicker.com/list/F6j2RG)

Overall, my system falls under a very high end category. The 16GB of RAM will be upgraded eventually along followed by the SSD and video card. While the system pulls around 500W from the wall, I hope that future generations of silicon will allow an even lower power draw for less environmental impact. Anyways, I love all this kind of computer stuff, and this does not include the software and electrical side.

The Rig (Computer)



![](Blog/Assets/0!mbht_WGFbs70Rb6g.jpg)

I call this speech “Smooth Reverie.” I wrote this in a series of sweaty sessions across particularly random hours of the 24-hour day, and fully understand and admit that by no means this writing would receive a passing grade from one of my stricter English teachers. Now, a reverie is a daydream, or fantastic vision, and tonight, we capture a part of our lives in a snapshot that will forever shine brilliantly in our memories. Like a herd of water buffalo, we as a class have stomped through our grade school years, and like a lost lion, we as a class have courageously made it to graduation.

Although our lives before 9th grade are nonexistent to the university’s cold eye sockets, it is still important to reflect on what brought us here today. Our families loved and supported us… Our teachers guided us… And our friends marched with us…. Every one of my classmates’ names that will be read tonight carries a story, a unique and individual story that will hopefully affect the world.

Audience, you are looking at young adults that constitute the larger age group that will change the world, undeniably. Just as any student body becomes great, and any group of people becomes great, we have shared and nurtured our unique talents, for we the people are only powerful because of “we.” Not you, or him or her, or ze or zer; but “Us,” and when we understand who we each are, we can turn to each other, and make our contribution like Kennedy’s request that we people ask what can we do for our country. Let me continue to reflect on who we became with this inspiring quote:

> _I guess you’re right, Plankton. I am just a kid. And you know, I’ve been through a lot in the past six days, five minutes, twenty-seven-and-a-half seconds. And if I’ve learned anything during that time, it’s that you are who you are. And no amount of mermaid magic… or managerial promotion… or some other third thing… can make me anything more than what I really am inside [….] But that’s okay. Because I did what everyone said [I] couldn’t do. I made it […] So, yeah, I’m a kid. And I’m also a goofball. And a wing nut. And a Knucklehead McSpazatron! But most of all…_

In the case of this street poet and philosopher, Mr. Squarepants; most of all, he was a goofy goober. While I assume that partially describes most of us, I asked others who they were inside, above all, who they understood themselves to be. Many stand confident they are different. Nicholas is excited, Clayton knows he is unique, Caden is a child of God, John from Florida is certain that life is a labyrinth, Jesus from the Walmart Janitorial Staff is happy, but I digress from our class… Madison and Aaron are looking forward, Madeline is thankful for the people, and Parker is “ready.” Ready for what, we may never know, I hope it is legal. The phenomenal thing about this is the character of the present, and that is the celebration of the moment tonight, who we are at the present, and who we have become.

Now, as many of you know me, I cannot help but stray from the serious flow of ideas. So, I would like to tell of our past high school years in a form of story.

It is August of 2012 in North America. In a remote grassland, the sunshine flows over a flock of young kids, the freshman, who have for the first time reached new grounds, high school. The morning heat carries the sweet, sensational aromas of coffee, deodorant, and various teenage pheromones. Their parents have left them to fend on their own. They hope their bright yellow shoes and backpacks will be a valid form of disguise. They scurry straight into the cafeteria, avoiding the dangerous parking lot grounds, were the elder reign freely. Some of the more anxious males attempt to court females, but fail to no ado, wondering if it was because they were not wearing enough assorted colognes. But, this is only the calm. All of a sudden the scene turns dark, malicious; the freshmen are about to gaze into the face of true hysteria. The first bell of the day has rung. Like a stampede, the upper-class begins their migration disregarding the small, innocent bodies of the young, and instinctually moving to their dedicated learning rooms, leaving behind remnants of trash and excrement. The freshmen are left behind to trickle to their rooms, sadly, but courageously; bruised, but standing strong. Skip forward one year, now they are more trained, titled sophomores. Some have infiltrated and befriended the higher ranks. Importantly, they know to move to the side to let an upperclassman pass as a sign of respect and fear, that bright blue is way cooler than bright yellow, and mitochondria are the powerhouse of the cell. Slowly, through the years, social structure emerges. The athletes, the nerds, the cool guys, the band geeks, the man buns, etc…. Four years later, these tiny, wide-eyed beings have grown to full size, have mastered the teenage slang, and are more fun than ever seen before. They have now mastered their survival skills, being able to judge anyone in less than a millisecond. Now, it is May, 2016. These seniors have quite developed their own attitude, independent of other grades, and have learned what it takes to fend for one’s self. The wild cycle continues as this emotional group cries over their years of harsh training, claiming it was fun.

While this story is powerful, it is imperative to note that figurative phrases are only a part of describing our success. Just like first is worst and second is best, we let each other guide, and trust in ourselves to uphold our standards. I am so proud of our generation. Look at our vocabulary, we have constructed ways to explain our feelings and situations like never before. For example, words like “yeet, lit, dab, lean, fleek” have truly been synthesized. Besides our culture, we have been a conscious generation, whether it comes to roasting others or discussing awfully annoying issues in our world, we fully understand what is to come. On behalf of our generation, we the graduates, sitting on the floor tonight, assume our societal responsibilities.

Now, before I close, let me clarify to some degree. What we have worked so hard for does not simply amount to a diploma. You cannot actually do much with the physical diploma. You could smoke it but I would not advise it… Instead, it is up to us to continue our work, and action, and take tonight as a check point in our pursuit of better.

Like a lost lion, we as a class have made it to graduation, congratulations, I love you all so much.

Written Words