If you’ve been following me, you know I hadn’t gone this long without publishing a single thing in years.

I was building a product.

A friend had an idea. I was supposed to bring it to life technically. Write the code, make it work, move on. But the problem hooked me. Every layer I peeled back revealed another question I wanted to answer. She eventually stepped away. I didn’t.

That was January. I went full-time on it, which at first meant stacking a second full-time commitment on top of the job that was paying my rent. Build before work, build after work, build on weekends. There were stretches where I forgot what day it was because every day had the same shape: wake up, code, eat, code, handle a customer issue, code, sleep at some hour I’d rather forget, repeat.

Eventually I quit the job. My brain is wired in a way where I give myself the best chance at success when there’s no contingency plan. No fallback, no safety net, no “if this doesn’t work out I’ll just go back to...” I needed to be all the way in. So I stepped off the ledge.

Which means I started watching my savings thin out while building infrastructure for strangers to trade on. Every month, money leaves. Server costs, RPC fees, database hosting, the bleed of keeping a live product alive. The work is rewarding. The math is stressful. You learn to hold both of those truths at the same time.

Then there’s the legal side. When you’re building a product that handles real money, entire weeks disappear into conversations with lawyers about entity structure, compliance, regulatory gray areas. You emerge from those weeks having shipped exactly zero features. The product looks the same as it did before, but underneath, the foundation is a little more solid, a little more defensible. It’s necessary work that nobody will ever see.

And the loneliness of it is something people skip over when they talk about building. You wake up alone with your editor and a list of things that needed to exist yesterday. I had help from incredible people. Cofounders who carried entire dimensions of the product I couldn’t. But when the bug at 2 AM is yours, and the user who can’t deposit is yours, the weight follows you into everything. Sleep, meals, conversations about anything else.

The mental whiplash is its own kind of exhausting. At 10 AM you’re designing an architecture. At 10:15 you’re in someone’s DMs troubleshooting a trade that didn’t clear. At 11 you’re back to writing a settlement engine. At noon you’re thinking about marketing copy. The range of problems you solve in a single day as a solo founder is absurd, and none of it prepares you for the next day, which will be a completely different set of fires.

I built an observatory system to catch errors before they reached anyone. A real-time dashboard tracking every transaction, every settlement, every failure. I’m obsessive about data, and that obsession shaped everything: every metric, every flow, every interaction designed with operational numbers guiding the decisions. The kind of numbers that tell you something is about to break before it breaks. That same obsession shaped the product itself. Every screen, every interaction had to feel worthy of the trust someone places in you when they hand over their money.

And still, users surprise you. You think you’ve mapped every edge case. Then someone does something you never anticipated and your entire model of how people behave gets rewritten overnight. You fix it, absorb the lesson, and keep going.

Six months of that.

So what was I building? And why couldn’t I let go?

Scroll through your timeline right now. Twitter, wherever you spend your time online. Someone on there is confidently predicting the Naira will crash, or that a company is going under, or that some policy is guaranteed to fail. They’re loud about it. The algorithm rewards them handsomely for the confidence alone.

Now think about what happens when they’re catastrophically wrong.

Absolutely nothing. They delete the tweet, keep the followers, move on. Tomorrow, same energy, different prediction. Economists call this the Pundit’s Free Option: all the upside of being right, zero cost of being wrong.

This is the fundamental bug in how the internet distributes information. Talk is cheap, confidence is rewarded, and accuracy is entirely optional. The whole system runs on volume.

The fix: make people put something on the line.

There’s a story I keep coming back to. In 1986, the Space Shuttle Challenger exploded on live television. Four companies had built parts for that shuttle. The government assembled a panel of the best scientists on the planet, Richard Feynman included, to determine which company’s component failed. It took them six months.

The stock market got there in minutes. On the day of the disaster, one company’s stock dropped 12%. The other three barely moved. Thousands of people, each holding a fragment of knowledge, each with money at stake, collectively priced the truth before anyone could articulate what went wrong.

That’s what a prediction market does. It takes an argument about the future and forces everyone to back their position with real money. Robin Hanson, the economist who pioneered the modern concept, put it in a way that stuck with me permanently: “A bet is a tax on bullshit.”

When being wrong costs something, behavior changes immediately. People stop performing and start calculating. What emerges is probability, crowd-sourced and remarkably accurate.

Someone always asks at this point: so this is just gambling?

A casino manufactures risk for entertainment. You spin a wheel, the house collects, society gains nothing. Closed loop.

A prediction market prices risk that already exists. Inflation, elections, policy changes, things that affect your life whether you participate or not. You’re trading against another person’s conviction, and the platform is just the matching engine. The byproduct is foresight: crowd-sourced probability on questions that actually matter.

Here’s what makes this especially interesting in Nigeria. Sixty million people here analyze odds and make probabilistic decisions with real money every single day. They study form, track variables, calculate risk. All that analytical brainpower, locked inside sportsbooks mathematically engineered to drain them. All that energy, producing value for exactly one party: the house.

That instinct, applied to questions that actually matter, is the opportunity I saw and couldn’t walk away from.

The product is called Hot Take.

You open it and see a feed. Full-screen cards, each one a question the internet is arguing about. Sports, politics, crypto, culture. If you’ve done your homework and you think the answer is yes, you tap Stamp It. If you think the crowd is chasing a bad narrative, you tap Fade It.

You sign up with your email. A wallet gets created behind the scenes. You deposit in whatever currency works for you. The trade routes through Solana, settles in under a second, and the blockchain stays completely invisible throughout. I spent months engineering that invisibility. The product should feel like a place where having a strong opinion is all you need to participate.

The thing that surprised me most came from the data, and it started before anyone even touched the product.

I’m a stickler for data. So even the waitlist was a data play. Before you got access, you’d answer five questions that mapped your responses to one of four behavioral archetypes: Contrarian, Degen, Analyst, or Gut Caller. For me it was pure data collection, a way to understand who was showing up and how they think about risk. We’d let people in slowly, in batches, scaling the userbase in a controlled way so the product could grow with it.

In an unplanned stroke of genius, people loved it. They wanted to share what they got. “I’m a Contrarian.” “Of course you’re a Degen.” It turned into a viral loop we never designed. Everybody wanted their friends to take the quiz, which meant more signups, which meant more data.

But the real insight came from what happened after people got in.

People signed up. They cleared verification. Some deposited money. And then a huge chunk of them just didn’t trade. They had opinions. They were interested. They came all the way to the edge and didn’t follow through.

The window moved too fast. The moment passed before they could act on it.

That gap between interest and action sits underneath every prediction market in existence. Every platform in this space assumes its users already know how to trade. Most people with strong opinions just need the friction to disappear before the moment does.

That realization is what I’m building around now. The problem I can’t stop thinking about.

I’m working on something called Sage. An advisor that lives inside the product, watching the things you care about. When something moves, it tells you. If you want, it’ll prepare a trade for you to approve with a single tap. If you trust it enough, it’ll act within limits you set and you review the receipts later.

Sage holds your position in the world while you go live your life.

It’s early. But it solves the follow-through problem directly, and that’s the whole game.

The bigger picture is this: prediction markets as a category have existed for years, but the way people discover them, interact with them, and consume them hasn’t changed since the first order book went live. It’s still a trading terminal. Hot Take is the first step toward building a true consumer layer for prediction markets. A feed you scroll, an advisor that watches for you, a product designed around opinions and culture instead of charts and order flow. Sage is one piece of that. The product itself is another. Everything we build from here serves that same thesis: prediction markets belong in everyone’s hands, and the interface is the only thing standing in the way.

Six months ago I was a guy with opinions and a code editor. Today I have a live product on Solana, real users, real money moving through it, and a hackathon submission I’m proud of. The product has rough edges I’ll be sanding for months. And it works. People trade on it. Settlements clear. The system does what it’s supposed to do.

I disappeared because I was building. I’m back because it’s time to let people in.

Hot Take is now open to the public. Some regions are geoblocked for now while we work through the regulatory side, but we're actively expanding access.

If any of this resonated, if you’re curious, or if you just fw me and want to see what I made:

→ hottake.markets

Come take a position. I want to see if your instincts are sharper than mine.

If you’re a builder going through the same stretch right now, solo, exhausted, wondering if the silence is worth it: it is. Keep building.

I learn by building. If you do too, this is for you.

Let’s get into it.

Why This Exists

In 2022, over $3 billion was lost to smart contract exploits. Solana, despite its reputation for speed and low fees, is not immune. The Sealevel runtime’s unique account model creates a distinct attack surface that Ethereum developers don’t encounter.

The problem? Most security resources either:

- List vulnerabilities without runnable code

- Show Anchor examples only, ignoring the growing Pinocchio ecosystem

- Don’t prove the attacks actually work

This article is different. Every vulnerability has:

Vulnerable code that compiles and runs

Secure code showing the fix

Exploit tests proving the attack succeeds on vulnerable programs

Defense tests proving the attack fails on secure programs

I built this in both Anchor (the high-level framework) and Pinocchio (the lightweight, zero-dependency alternative) so you can see how security patterns translate across abstraction levels.

The Ten Patterns

Pattern 01: Missing Signer Check

The Setup: You’re building a vault. Users deposit tokens, then can withdraw later. The vault stores an authority pubkey—only this account should be able to withdraw.

The Vulnerability: The program accepts the authority’s pubkey but never verifies they actually signed the transaction.

❌ VULNERABLE FLOW:

1. Attacker reads vault’s authority pubkey from chain

2. Attacker includes that pubkey in their transaction (no signature)

3. Program trusts the pubkey without checking is_signer()

4. Attacker drains the vault

Pinocchio Implementation

Vulnerable:

// ❌ No signer check - anyone can pass any pubkey

let authority = accounts.get(1)?;

let amount = parse_amount(data);

transfer(vault, recipient, amount);

Secure:

// ✅ Verify the authority actually signed

let authority = accounts.get(1)?;

if !authority.is_signer() {

return Err(ProgramError::MissingRequiredSignature);

}

transfer(vault, recipient, amount);

Anchor Implementation

Vulnerable:

#[derive(Accounts)]

pub struct Withdraw<’info> {

// ❌ AccountInfo doesn’t enforce signing

pub authority: AccountInfo<’info>,

    #[account(mut)]

pub vault: Account<’info, Vault>,

}

Secure:

#[derive(Accounts)]

pub struct Withdraw<’info> {

// ✅ Signer<’info> enforces signature at deserialization

pub authority: Signer<’info>,

    #[account(mut)]

pub vault: Account<’info, Vault>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Pinocchio | Check `account.is_signer()` before trusting identity |

| Anchor | Use `Signer<’info>` instead of `AccountInfo<’info>` |

Key Insight: Solana’s runtime passes signature status as a flag on each account. If you don’t check it, you’re accepting an unsigned claim of identity.

Pattern 02: Missing Owner Check

The Setup: Your program reads balance data from a token account to gate access. Users with 1000+ tokens get premium features.

The Vulnerability: The program reads account data without verifying which program owns (created) that account.

❌ VULNERABLE FLOW:

1. Attacker creates their own account with fabricated data

2. Account shows balance = 999,999,999 tokens

3. Program reads balance without checking owner == SPL Token

4. Attacker gets premium access without owning any real tokens

Pinocchio Implementation

Vulnerable:

// ❌ Trusts any account data blindly

let token = accounts.get(0)?;

let balance = parse_balance(token.data()?);

if balance >= REQUIRED_BALANCE {

grant_premium_access();

}

Secure:

// ✅ Verify the account is owned by SPL Token program

let token = accounts.get(0)?;

if token.owner() != &spl_token::ID {

return Err(ProgramError::InvalidAccountOwner);

}

let balance = parse_balance(token.data()?);

Anchor Implementation

Vulnerable:

#[derive(Accounts)]

pub struct Check<’info> {

// ❌ No owner validation - accepts any account

pub token: AccountInfo<’info>,

}

Secure:

#[derive(Accounts)]

pub struct Check<’info> {

// ✅ Account<’_, T> validates owner == T’s program

pub token: Account<’info, TokenAccount>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Pinocchio | Check `account.owner() == &EXPECTED_PROGRAM_ID` |

| Anchor | Use `Account<’info, T>` which auto-validates ownership |

Key Insight: In Solana, any program can write arbitrary data to accounts it owns. If you don’t verify ownership, you’re reading potentially malicious data.

Pattern 03: Account Reinitialization

The Setup: Your DeFi protocol has a config account with an `authority` field. The authority can adjust fees, pause trading, etc.

The Vulnerability: The initialization function can be called on an already-initialized account, overwriting the existing authority.

❌ VULNERABLE FLOW:

1. Legitimate admin initializes config with their pubkey as authority

2. Attacker calls initialize() again on the same account

3. Program overwrites authority with attacker’s pubkey

4. Attacker now controls the entire protocol

Pinocchio Implementation

Vulnerable:

// ❌ No check if already initialized

pub fn initialize(accounts: &[AccountView], data: &[u8]) -> ProgramResult {

let config = accounts.get(0)?;

let mut config_data = config.try_borrow_mut_data()?;

config_data.authority = parse_pubkey(data);

config_data.initialized = true;

Ok(())

}

Secure:

// ✅ Reject if already initialized

pub fn initialize(accounts: &[AccountView], data: &[u8]) -> ProgramResult {

let config = accounts.get(0)?;

let config_data = config.try_borrow_data()?;

if config_data.initialized {

return Err(ProgramError::AccountAlreadyInitialized);

    }

let mut config_data = config.try_borrow_mut_data()?;

config_data.authority = parse_pubkey(data);

config_data.initialized = true;

Ok(())

}

Anchor Implementation

Vulnerable:

#[derive(Accounts)]

pub struct Initialize<’info> {

// ❌ #[account(mut)] allows reinit

    #[account(mut)]

pub config: Account<’info, Config>,

}

Secure:

#[derive(Accounts)]

pub struct Initialize<’info> {

// ✅ #[account(init, ...)] fails if account exists

    #[account(

        init,

        payer = user,

        space = 8 + Config::SIZE

    )]

pub config: Account<’info, Config>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Pinocchio | Check `is_initialized` flag before writing |

| Anchor | Use `#[account(init)]` which requires fresh accounts |

Key Insight: Anchor’s init constraint is more than convenience—it’s a security feature. It ensures the account is rent-exempt, properly sized, and never existed before.

Pattern 04: Type Confusion

The Setup: Your program has multiple account types: UserAccount, AdminAccount, VaultAccount. Admin accounts can perform privileged operations.

The Vulnerability: Account data is deserialized without verifying the account type, allowing a regular user account to be treated as an admin account.

❌ VULNERABLE FLOW:

1. Attacker creates a UserAccount

2. Attacker calls admin function, passing their UserAccount

3. Program deserializes raw bytes as AdminAccount

4. Fields happen to align—attacker gets admin powers

Pinocchio Implementation

Vulnerable:

// ❌ Deserializes without checking discriminator

pub fn admin_action(accounts: &[AccountView]) -> ProgramResult {

let admin = accounts.get(0)?;

let admin_data = AdminAccount::try_from_slice(admin.data()?)?;

// Oops! This might actually be a UserAccount

perform_admin_action(admin_data);

}

Secure:

// ✅ Check 8-byte discriminator first

pub fn admin_action(accounts: &[AccountView]) -> ProgramResult {

let admin = accounts.get(0)?;

let data = admin.data()?;

if data[0..8] != ADMIN_DISCRIMINATOR {

return Err(ProgramError::InvalidAccountData);

    }

let admin_data = AdminAccount::try_from_slice(&data[8..])?;

perform_admin_action(admin_data);

}

Anchor Implementation

Vulnerable:

#[derive(Accounts)]

pub struct AdminAction<’info> {

// ❌ UncheckedAccount accepts any type

pub account: UncheckedAccount<’info>,

}

Secure:

#[derive(Accounts)]

pub struct AdminAction<’info> {

// ✅ Account<’info, AdminData> validates discriminator

pub account: Account<’info, AdminData>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Pinocchio | Use 8-byte discriminator per account type |

| Anchor | Use `Account<’info, T>` which auto-validates type |

Key Insight: Anchor generates 8-byte discriminators from sha256(”account:<struct_name>”). In Pinocchio, you must implement this manually—typically the first 8 bytes of your account data.

Pattern 05: Arithmetic Overflow

The Setup: Users can withdraw tokens from a vault. The balance is a u64.

The Vulnerability: Using wrapping or unchecked arithmetic causes underflow, turning 100 - 200 into a massive positive number.

❌ VULNERABLE FLOW:

1. Vault has 100 tokens

2. Attacker requests withdrawal of 200 tokens

3. balance.wrapping_sub(200) → 18,446,744,073,709,551,516

4. Check `if balance >= required` passes

5. Attacker drains the vault (or worse)

Pinocchio Implementation

Vulnerable:

// ❌ Wrapping arithmetic—100 - 200 = massive number

vault.balance = vault.balance.wrapping_sub(amount);

// Now balance = 18,446,744,073,709,551,516

Secure:

// ✅ Checked arithmetic returns None on underflow

vault.balance = vault.balance

    .checked_sub(amount)

    .ok_or(ProgramError::InsufficientFunds)?;

Anchor Implementation

Vulnerable:

// ❌ Native subtraction can panic or wrap

vault.balance = vault.balance - amount;

Secure:

// ✅ Checked arithmetic with custom error

vault.balance = vault.balance

    .checked_sub(amount)

    .ok_or(ErrorCode::InsufficientFunds)?;

The Fix

| Framework | Solution |

|-----------|----------|

| Both | Always use `checked_add`, `checked_sub`, `checked_mul`, `checked_div` |

| Cargo.toml | Enable `overflow-checks = true` in release profile |

Key Insight: Rust’s default release mode disables overflow checks for performance. Solana programs run in release mode. Enable checks explicitly:

[profile.release]

overflow-checks = true

Pattern 06: Unsafe Account Closing

The Setup: Users can close their vault account to reclaim rent. The program transfers lamports back to the user.

The Vulnerability: The program zeroes lamports but leaves data intact, allowing the account to be “revived” in the same transaction.

❌ VULNERABLE FLOW:

1. User calls close() - lamports move to recipient

2. In same transaction, attacker sends small lamport amount back

3. Account is “revived” with original data still intact

4. Attacker can now access stale/privileged state

Pinocchio Implementation

Vulnerable:

// ❌ Data not zeroed—can be revived

pub fn close(accounts: &[AccountView]) -> ProgramResult {

let vault = accounts.get(0)?;

let recipient = accounts.get(1)?;

let lamports = vault.lamports();

    **vault.try_borrow_mut_lamports()? = 0;

    **recipient.try_borrow_mut_lamports()? += lamports;

// Data is still intact!

Ok(())

}

Secure:

// ✅ Zero data FIRST, then transfer lamports

pub fn close(accounts: &[AccountView]) -> ProgramResult {

let vault = accounts.get(0)?;

let recipient = accounts.get(1)?;

// Zero ALL data first

vault.try_borrow_mut_data()?.fill(0);

let lamports = vault.lamports();

    **vault.try_borrow_mut_lamports()? = 0;

    **recipient.try_borrow_mut_lamports()? += lamports;

Ok(())

}

Anchor Implementation

Vulnerable:

// ❌ Manual close without data zeroing

pub fn close(ctx: Context<Close>) -> Result<()> {

let vault = &ctx.accounts.vault;

    **vault.to_account_info().try_borrow_mut_lamports()? = 0;

Ok(())

}

Secure:

#[derive(Accounts)]

pub struct Close<’info> {

// ✅ close constraint handles everything safely

    #[account(mut, close = recipient)]

pub vault: Account<’info, Vault>,

    #[account(mut)]

pub recipient: SystemAccount<’info>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Pinocchio | Zero data with `.fill(0)` before transferring lamports |

| Anchor | Use `#[account(close = recipient)]` constraint |

Key Insight: Anchor’s close constraint zeros account data, transfers all lamports, and assigns ownership to the system program—all in the correct order.

Pattern 07: Arbitrary CPI

The Setup: Your DEX calls the SPL Token program to transfer tokens between accounts.

The Vulnerability: The program accepts a user-provided “token program” account and invokes it without verifying it’s actually SPL Token.

❌ VULNERABLE FLOW:

1. Attacker deploys malicious program that mimics token transfer interface

2. Attacker calls DEX, passing malicious program as “token_program”

3. DEX invokes attacker’s program

4. Malicious program does whatever attacker wants

Pinocchio Implementation

Vulnerable:

// ❌ Invokes user-provided program without verification

let token_program = accounts.get(3)?;

let ix = create_transfer_ix(...);

invoke(&ix, &[token_program.clone()])?;

Secure:

// ✅ Verify program ID before CPI

let token_program = accounts.get(3)?;

if token_program.key() != &spl_token::ID {

return Err(ProgramError::IncorrectProgramId);

}

let ix = create_transfer_ix(...);

invoke(&ix, &[token_program.clone()])?;

Anchor Implementation

Vulnerable:

#[derive(Accounts)]

pub struct Transfer<’info> {

// ❌ No program verification

pub token_program: AccountInfo<’info>,

}

Secure:

#[derive(Accounts)]

pub struct Transfer<’info> {

// ✅ Program<’info, Token> validates program ID

pub token_program: Program<’info, Token>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Pinocchio | Check `program.key() == &expected_program_id` |

| Anchor | Use `Program<’info, T>` for CPI targets |

Key Insight: Cross-program invocations inherit the caller’s privileges. An attacker-controlled program can drain funds, modify state, or perform any action your program is authorized to do.

Pattern 08: Duplicate Accounts

The Setup: Your transfer function moves tokens from account A to account B.

The Vulnerability: The program doesn’t check that A and B are different accounts. If they’re the same, the math breaks.

❌ VULNERABLE FLOW:

1. User passes same account as both ‘from’ and ‘to’

2. from.balance -= 100 → balance = 900

3. to.balance += 100 → balance = 1000

4. Net result: user gained 100 tokens from nothing

Pinocchio Implementation

Vulnerable:

// ❌ No uniqueness check

let from = accounts.get(0)?;

let to = accounts.get(1)?;

from.balance -= amount;  // 1000 - 100 = 900

to.balance += amount;    // 900 + 100 = 1000 (same account!)

// Net gain: 100 tokens created from nothing

Secure:

// ✅ Verify accounts are distinct

let from = accounts.get(0)?;

let to = accounts.get(1)?;

if from.key() == to.key() {

return Err(ProgramError::InvalidArgument);

}

from.balance -= amount;

to.balance += amount;

Anchor Implementation

Vulnerable:

#[derive(Accounts)]

pub struct Transfer<’info> {

    #[account(mut)]

pub from: Account<’info, Wallet>,

    #[account(mut)]

pub to: Account<’info, Wallet>,

}

Secure:

#[derive(Accounts)]

pub struct Transfer<’info> {

// ✅ Constraint ensures from != to

    #[account(mut, constraint = from.key() != to.key())]

pub from: Account<’info, Wallet>,

    #[account(mut)]

pub to: Account<’info, Wallet>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Pinocchio | Check `account_a.key() != account_b.key()` |

| Anchor | Use `constraint` to enforce uniqueness |

Key Insight: This bug is subtle because it violates assumptions, not explicit checks. Any time two accounts should be different, verify it explicitly.

Pattern 09: Bump Seed Canonicalization

The Setup: Your program derives PDAs (Program Derived Addresses) for user vaults.

The Vulnerability: Multiple bump values can produce valid PDAs for the same seeds. The program accepts any valid bump instead of the canonical one.

❌ VULNERABLE FLOW:

1. Program uses find_program_address() to get canonical bump = 254

2. Attacker discovers bump = 250 also produces valid PDA

3. Attacker creates account at alternate PDA

4. Program accepts it because create_program_address() succeeds

5. Two “valid” vaults exist for same user—accounting chaos

Pinocchio Implementation

Vulnerable:

// ❌ Accepts user-provided bump without validation

let user_bump = data[0];

let pda = create_program_address(

    &[b”vault”, user.key().as_ref(), &[user_bump]],

program_id

)?;

Secure:

// ✅ Derive and store canonical bump

let (pda, canonical_bump) = find_program_address(

    &[b”vault”, user.key().as_ref()],

program_id

);

// Store bump in account for future verification

vault_data.bump = canonical_bump;

// On subsequent calls, verify stored bump matches

assert_eq!(provided_bump, vault_data.bump);

Anchor Implementation

Vulnerable:

#[derive(Accounts)]

pub struct Create<’info> {

// ❌ No bump validation

    #[account(seeds = [b”vault”, user.key().as_ref()])]

pub vault: Account<’info, Vault>,

}

Secure:

#[derive(Accounts)]

pub struct Create<’info> {

// ✅ bump = vault.bump validates stored bump

    #[account(

        seeds = [b”vault”, user.key().as_ref()],

bump = vault.bump

    )]

pub vault: Account<’info, Vault>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Pinocchio | Use `find_program_address()`, store bump, verify on access |

| Anchor | Store bump in account, use `bump = account.bump` in seeds |

Key Insight: find_program_address() returns the canonical (highest valid) bump. Always use it, store the result, and verify it on subsequent accesses.

Pattern 10: PDA Sharing

The Setup: Your lending protocol has multiple pools, each with a vault PDA.

The Vulnerability: PDA seeds are too generic, causing different pools to share the same vault address.

❌ VULNERABLE FLOW:

1. Pool A vault = PDA([”vault”], program_id) → address X

2. Pool B vault = PDA([”vault”], program_id) → address X (same!)

3. User deposits to Pool A → funds go to address X

4. Attacker withdraws from Pool B → drains address X

5. Attacker stole Pool A deposits via Pool B

Pinocchio Implementation

Vulnerable:

// ❌ Same seeds for ALL pools

let (vault, _) = find_program_address(

    &[b”vault”],  // No pool identifier!

program_id

);

Secure:

// ✅ Include pool identifier in seeds

let (vault, _) = find_program_address(

    &[b”vault”, pool_id.as_ref()],

program_id

);

// Each pool now has unique vault address

Anchor Implementation

Vulnerable:

#[derive(Accounts)]

pub struct Deposit<’info> {

// ❌ Shared across all pools

    #[account(seeds = [b”vault”])]

pub vault: Account<’info, Vault>,

pub pool: Account<’info, Pool>,

}

Secure:

#[derive(Accounts)]

pub struct Deposit<’info> {

// ✅ Pool-specific vault

    #[account(seeds = [b”vault”, pool.key().as_ref()])]

pub vault: Account<’info, Vault>,

pub pool: Account<’info, Pool>,

}

The Fix

| Framework | Solution |

|-----------|----------|

| Both | Include ALL identifying context in PDA seeds |

Seed Hygiene Checklist:

- User-specific? Include user.key()

- Pool-specific? Include pool.key()

- Token-specific? Include mint.key()

- Time-specific? Include epoch or timestamp

Key Insight: PDAs are deterministic. Same seeds = same address. When in doubt, add more specificity to your seeds.

Anchor vs Pinocchio: When to Use Which

| Aspect | Anchor | Pinocchio |

|--------|--------|-----------|

| Compute Units | ~50-100k per tx typical | ~5-20k per tx |

| Binary Size | ~200-500KB .so | ~20-50KB .so |

| Learning Curve | Gentler | Steeper |

| Boilerplate | Macro-heavy | Manual |

| Security By Default | High (many checks automatic) | Low (all checks manual) |

| Best For | Complex DeFi, rapid prototyping | Performance-critical, gas-sensitive |

My Recommendation:

Use Anchor if you’re shipping fast, have complex account relationships, or prioritize readability.

Use Pinocchio if you need maximum efficiency, are compute-constrained, or building infrastructure that will be called millions of times.

The Security Tradeoff: Anchor’s type system catches many vulnerabilities at compile time. Pinocchio requires you to implement all checks manually—but gives you complete control.

Builder’s Learnings

Building 40 programs across two frameworks taught me lessons that aren’t in any documentation.

Pinocchio v0.10 is a Complete Rewrite

If you’re coming from older Pinocchio or solana-program, forget what you know:

// OLD                      // NEW (v0.10)

AccountInfo                 → AccountView

Pubkey                      → Address

account.key()               → account.address()

try_borrow_mut_data()       → try_borrow_mut()

declare_id!()               → (removed)

entrypoint!()               → program_entrypoint!()

And for BPF builds, you need these three lines in every program:

program_entrypoint!(process_instruction);

default_allocator!();

nostd_panic_handler!();

Solana’s Toolchain Lags Behind Rust

I spent 7 hours debugging why Anchor wouldn’t build. The culprit: a transitive dependency (constant_time_eq) updated to Rust edition2024.

Problem: Solana’s bundled cargo (1.84.0) didn’t support edition2024.

Solution: Manually upgrade ~/.cache/solana/v1.51/platform-tools by symlinking to v1.52.

Lesson: When cargo build-sbf fails on ecosystem crates, check if Solana’s bundled cargo is too old.

LiteSVM is the Future of Testing

Forget solana-test-validator. LiteSVM runs entirely in-process, with deterministic block hashes, instant transaction processing, and full control over program execution.

let mut svm = LiteSVM::new();

svm.add_program_from_file(program_id, “program.so”)?;

// Set exact slot, blockhash, account state

svm.set_slot(42);

svm.set_account(pubkey, account_data);

// Execute and inspect

let result = svm.send_transaction(tx);

assert!(result.is_err()); // Expected to fail!

My test suite runs 42 exploit simulations in under 2 seconds.

WSL + Windows = Filesystem Pain

Building Solana programs in WSL while code lives on Windows (/mnt/c/...) causes random permission errors.

Solution: Copy test code to WSL-native filesystem (~/).

cp -r /mnt/c/project/tests ~/security-tests

cd ~/security-tests

cargo test

How to Use This Reference

For Developers

1. Read through each pattern before starting your project

2. Use the secure versions as templates

3. Run vulnerable versions to understand why they fail

4. Add the checks to your security checklist

For Educators

1. Each pattern is self-contained—assign them individually

2. Students can modify vulnerable code and run tests

3. Compare Anchor vs Pinocchio to teach abstraction tradeoffs

Final Thoughts

Every vulnerability in this guide has caused real-world losses. The Sealevel runtime is powerful but unforgiving. Missing one check—signer, owner, type, overflow—can drain an entire protocol.

I built this reference because I believe the Solana ecosystem deserves better security education. Not theoretical blog posts, but runnable, testable, provable examples.

Use it. Break it. Learn from it.

And when you’re auditing that next protocol or shipping your own—remember these ten patterns.

Links

- GitHub Repository: https://github.com/AngryPacifist/solana-security-patterns

- Interactive Guide: https://solana-security-patterns.pxxl.click

Subscribe now

If you found this article helpful, please consider liking and sharing it.

Connect with me on X: @angry__pacifist

“Automated rent-reclaim bot for Kora operators.” What does that even mean?

But the bounty description had this line that stuck with me:

> ”Over time, many of these accounts become inactive, closed, or no longer needed. In most cases, operators do not actively track or reclaim this rent, leading to silent capital loss.”

Silent capital loss. That phrase made me curious. If Kora operators are losing money without even knowing it, and there’s no tool to help them—that’s a real problem worth solving.

So I decided to dig in. To genuinely understand what was happening under the hood.

Understanding the Problem: What Even Is Rent?

Before I could build anything, I needed to understand Solana’s rent model. I spent the first few hours reading documentation.

The Rent-Exemption Model

Every account on Solana must maintain a minimum SOL balance to exist. This isn’t a fee you pay periodically—it’s a one-time deposit that makes your account “rent-exempt.”

The math is roughly: 0.00000696 SOL per byte.

For a typical Token Account (also called ATA—Associated Token Account), that’s about 0.00203 SOL for 165 bytes of storage.

Doesn’t sound like much, right? But here’s where it gets interesting.

When Kora Sponsors a Transaction

Kora is gasless transaction infrastructure. Apps use Kora to sponsor user transactions so users don’t need SOL to pay fees.

When Kora sponsors a transaction that creates an account:

1. Kora’s fee payer deposits the rent (0.00203 SOL)

2. The account’s owner is set to the user

3. The rent is now “locked” in that account

Here’s the problem: Kora paid for the account, but Kora doesn’t own it.

For a Kora node processing thousands of transactions:

- 1,000 ATAs = ~2 SOL locked

- 10,000 ATAs = ~20 SOL locked

- 100,000 ATAs = ~200 SOL locked

This is real money sitting in accounts that Kora has no direct control over.

The Research Phase: Reading Before Building

I’m a firm believer in understanding before implementing. So before writing a single line of code, I read:

1. Kora Operator Documentation — All of it. Learned about kora.toml, signers.toml, the RPC gateway, fee payer policies.

2. Solana Core Concepts — Accounts, transactions, programs, PDAs. The ~3,000 line documentation file. I needed to understand how data flows.

3. Solana Token Program — This was the big one. 18,000+ lines of documentation about token accounts, mints, and crucially: the CloseAccount instruction.

4. Solana RPC API — Understanding getSignaturesForAddress, getTransaction, getAccountInfo. These would be my tools for scanning the blockchain.

The Critical Question

After reading everything, I had one question I couldn’t answer from the docs:

> “If Kora pays rent for a user’s token account, can Kora close that account and get the rent back?”

I found this in the Token Program docs:

> ”The CloseAccount instruction permanently closes a token account and transfers all remaining SOL (rent) to a specified destination account. The token account balance must be zero before closing. Only the token account owner or designated close authority can execute this instruction.”

Only the owner or close authority. Not the person who paid the rent.

This was concerning. I reached out to the bounty organizers to clarify:

> Me: “Is pure monitoring/alerting acceptable if there is any constraint around claiming the rent?”

> @codewithmide: “Pure monitoring/alerting is acceptable. The goal is to make the node operator aware of a rent they can claim if that process cannot be automated.”

Okay. So if Kora can’t always auto-reclaim, at least monitoring is valuable. But I wasn’t satisfied. I kept digging.

Setting Up the Lab: Kora Node Configuration

Before building the bot, I needed real test data. That meant running an actual Kora node.

The Setup

I installed:

- Rust & Cargo (for Kora CLI)

- Solana CLI 3.0.13

- Kora CLI 2.0.2

- Node.js (for the bot)

Created a devnet wallet with 1 SOL for testing (address: 8F9ijbjy1LLLTnEtx9jv7D4i5J2oFSERivE1bZkLiL2v).

Configuration Files

kora.toml — The main config:

[kora]

rate_limit = 100

[validation]

price_source = “Mock”  # Devnet testing

max_allowed_lamports = 100000000  # 0.1 SOL max

allowed_programs = [

    “11111111111111111111111111111111”,      # System Program

    “TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA”,  # SPL Token

    “ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL”, # Associated Token

]

signers.toml — Keypair configuration:

[signer_pool]

strategy = “round_robin”

[[signers]]

name = “devnet_signer”

type = “memory”

private_key_env = “KORA_PRIVATE_KEY”

Starting the Node

$env:KORA_PRIVATE_KEY = (Get-Content “path/to/keypair.json” -Raw)

kora --config kora.toml rpc start --signers-config signers.toml

Kora was now running at http://127.0.0.1:8080. Time to create some test data.

Generating Sponsored Accounts

I wrote a script (sponsor-transactions.js) that:

1. Generates random test wallets

2. Creates ATA creation transactions

3. Sends them through Kora for sponsorship

After running it, I had 3 sponsored ATAs on devnet:

| # | ATA Address | Rent Locked |

|---|-------------|-------------|

| 1 | `Ht4WXqZq...` | ~0.00203 SOL |

| 2 | `Bz91aHTH...` | ~0.00203 SOL |

| 3 | `DqwGYZDZ...` | ~0.00203 SOL |

Total rent locked: ~0.0061 SOL. My test data was ready.

The Breakthrough: close_authority Discovery

This is where things got exciting.

I was reading the Token Program source code more carefully and noticed something: the CloseAccount instruction checks for either the owner or the close_authority.

Wait. What if we could set close_authority to the Kora fee payer during account creation?

Testing the Hypothesis

I wrote a test script (test-close-authority.js):

// 1. Create ATA (Kora pays rent)

const ata = await createAssociatedTokenAccount(...)

// 2. Set close_authority to Kora’s fee payer

await setAuthority(

ata,

user,  // current authority (owner)

AuthorityType.CloseAccount,

feePayer  // new authority = Kora!

)

// 3. Later, when balance is zero...

await closeAccount(ata, destination, feePayer)  // Kora signs!

The Test

=== Testing Rent Reclaim via close_authority ===

1. Loading Kora fee payer keypair...

   Fee Payer: 8F9ijbjy1LLLTnEtx9jv7D4i5J2oFSERivE1bZkLiL2v

   Balance: 0.99180288 SOL

2. Creating test user wallet...

3. Creating ATA (Kora pays rent)...

4. Setting close_authority to Kora fee payer...

... [account emptied] ...

8. Kora balance after close: 0.99178788 SOL

   💰 Rent reclaimed: 0.00203428 SOL

🎉 SUCCESS! Rent reclaim via close_authority works!

This was the breakthrough.

If Kora is set as close_authority during ATA creation, Kora CAN close the account and reclaim the rent!

The Classification System

This discovery led me to design a classification system:

| Classification | Condition | Can Auto-Reclaim? |

|----------------|-----------|-------------------|

| RECLAIMABLE | `close_authority` = fee payer | ✅ Yes |

| MONITOR_ONLY | `close_authority` = owner or null | ❌ No (alert only) |

The tool couldn’t reclaim everything, but it could reclaim properly-configured accounts AND alert operators about the rest.

This was better than “pure monitoring.” This was a real solution.

Building Solvent: From Core Library to Four Interfaces

With the classification system designed, it was time to build. I named the project Solvent—a play on SOL + solvent (dissolves accounts to release SOL).

The Architecture Decision

I decided to build a monorepo with a shared core library and multiple interfaces:

┌─────────────────────────────────────────────────────────────┐

│                     PRESENTATION LAYER                      │

├──────────────────┬──────────────────┬──────────────────────┤

│       CLI        │   Web Dashboard  │    Telegram Bot      │

│    (Primary)     │   (Impressive)   │   (Alerts/Mobile)    │

├──────────────────┴──────────────────┴──────────────────────┤

│                       @solvent/core                         │

│  scanner.ts → classifier.ts → analyzer.ts → reclaimer.ts   │

├─────────────────────────────────────────────────────────────┤

│                      SOLANA RPC                             │

│        Devnet ↔ Mainnet (configurable)                      │

└─────────────────────────────────────────────────────────────┘

Why four interfaces?

- CLI — Fast to build, practical for real operators

- Dashboard — Visually impressive for demos and quick scans

- Telegram Bot — Mobile alerts and passive monitoring

- npm Package — Let others build their own tools

Building the Core Library

The @solvent/core package became the heart of everything:

scanner.ts — Scans a fee payer’s transaction history:

export async function scanAndParseAccounts(

address: string,

network: Network,

options?: { limit?: number; rpcUrl?: string }

): Promise<ParsedAccountCreation[]>

classifier.ts — Determines if accounts are reclaimable:

export async function classifyAccounts(

creations: ParsedAccountCreation[],

feePayerAddress: string,

network: Network,

rpcUrl?: string

): Promise<SponsoredAccount[]>

analyzer.ts — Calculates rent statistics:

export function calculateRentStats(accounts: SponsoredAccount[]): RentStats

reclaimer.ts — Actually closes accounts:

export async function reclaimRent(

accounts: SponsoredAccount[],

keypair: Keypair,

network: Network,

options?: { dryRun?: boolean }

): Promise<ReclaimResult[]>

Building the CLI

I wanted the CLI to be practical. Six commands:

solvent scan <address>   # Quick summary with rent stats

solvent list <address>   # Detailed table of all accounts

solvent reclaim <address> --dry-run   # Preview what would be reclaimed

solvent reclaim <address> --keypair ~/.config/solana/id.json   # Actually reclaim

solvent export <address> --format csv   # Export for reporting

solvent watch <address> --interval 60   # Live monitoring

The CLI test on my devnet fee payer:

Classification complete:

  Total: 26

  Reclaimable: 7

  Closeable (balance=0): 24

╔══════════════════════════════════════════════════════════════╗

║                    SOLVENT RENT REPORT                       ║

╠══════════════════════════════════════════════════════════════╣

║  📊 Total Accounts:                   24                     ║

║  💰 Total Rent Locked:          0.048943 SOL                 ║

╠══════════════════════════════════════════════════════════════╣

║  ✅ Reclaimable Accounts:              7                     ║

║  💎 Reclaimable Rent:           0.014275 SOL                 ║

╠══════════════════════════════════════════════════════════════╣

║  👁️  Monitor-Only Rent:          0.034668 SOL                 ║

║  ⏳ Closeable (balance=0):            24                     ║

╚══════════════════════════════════════════════════════════════╝

It worked! I could see exactly how much rent was locked and how much was reclaimable.

Building the Dashboard

The dashboard was about making this visually impressive. React + Vite + a dark theme with teal accents.

Features I implemented:

- Address input with network toggle (devnet/mainnet)

- Stats cards showing key metrics

- Filterable accounts table

- Rent chart showing cumulative rent over time

- Multi-wallet tabs (scan and compare multiple fee payers)

- Export to JSON/CSV

- Animated “bubbling test tube” loading screen (on brand!)

One bug I ran into: the chart was showing 26 accounts, but the stats showed 24. Turns out the chart was including CLOSED accounts while calculateRentStats filtered them out. Fixed by adding the same filter to the chart data.

Building the Telegram Bot

This was the most complex interface. I used grammY (a Telegram bot framework) with Upstash Redis for persistence.

Features:

- Inline Keyboards — Buttons instead of just text commands

- Conversation States — /scan prompts for an address if not provided

- User Preferences — Network, custom RPC, alert settings stored in Redis

- Scheduled Alerts — Cron job scans tracked addresses and sends notifications

The bot has 10 commands and multiple callback handlers for the inline buttons.

The Vercel Deployment Saga

I thought deployment would be easy. It was not.

Dashboard Deployment: 10+ Attempts

Problem: The dashboard depends on @solvent/core, which is a workspace package in the monorepo. Vercel couldn’t resolve it.

Attempt 1: vercel.json at repo root

{

“buildCommand”: “npm run build”,

“outputDirectory”: “packages/dashboard/dist”

}

Result: ❌ “Cannot find module @solvent/core”

Attempt 2: Explicit workspace builds

{

“buildCommand”: “npm run build -w @solvent/core && npm run build -w dashboard”

}

Result: ❌ “No workspaces found: --workspace=packages/dashboard”

I was mixing up package names with package paths. Rookie mistake.

Attempts 3-9: Various combinations. All failed.

Attempt 10+: The Solution

I realized Vercel’s Root Directory was set to packages/dashboard, which meant vercel.json at the repo root was never being read.

I created packages/dashboard/vercel.json:

{

“installCommand”: “cd ../.. && npm install”,

“buildCommand”: “cd ../.. && npm run build -w @solvent/core && cd packages/dashboard && npm run build”,

“outputDirectory”: “dist”

}

Navigate up to repo root → install all workspaces → build core first → build dashboard.

Result: ✅ Deployed!

Telegram Bot Deployment: More Challenges

Different challenges:

- Challenge 1: Vercel’s deployment protection was blocking public API access

- Challenge 2: Leftover .js files in /api causing 404s

- Challenge 3: npm run build was failing

The solution: ”buildCommand”: “” in vercel.json. Skip the build step entirely—Vercel auto-compiles TypeScript for serverless functions.

But even after deploying, the bot was missing all the good features. Turns out I had two separate files:

- local.ts — 758 lines, full-featured for local testing

- bot.ts — 218 lines, basic version for webhooks

I had to port all 500+ lines of features from local.ts to bot.ts. That was a 2-hour session.

Publishing to npm: More Hurdles

To make the Telegram bot work cleanly on Vercel, I decided to publish @solvent/core to npm instead of inlining the code.

Scoped Package Naming

Original plan: @solvent/core

Problem: Requires creating an npm organization

Solution: @angrypacifist/solvent-core (user scope)

2FA Requirement

npm requires a “granular access token with bypass 2FA” for scoped packages, even without 2FA enabled on my account. Spent 20 minutes figuring out the right token permissions.

Monorepo Workspace Conflicts

npm commands in the workspace context kept failing with ENOWORKSPACES error.

Solution: Create ~/.npmrc in my user home directory with the auth token directly. This bypassed the workspace issues.

Finally:

+ @angrypacifist/solvent-core@1.0.0

Published! Now the Telegram bot could import cleanly.

End-to-End Verification

Before calling it done, I needed to verify everything worked together.

The Test Pipeline

1. Start Kora node — Used my devnet keypair

2. Create 5 test accounts — ATAs with close_authority set to fee payer

3. Scan with CLI — Verify they show as RECLAIMABLE + CLOSEABLE

4. Trigger cron job — Manually hit the cron endpoint

5. Check Telegram — Did the alert arrive?

Step 1: Starting Kora

Found an interesting Windows quirk—the keypair was at C:\Users\Outis\~\.config\solana\kora-keypair.json. That’s a literal `~` folder, not the home directory shortcut!

$env:KORA_PRIVATE_KEY = Get-Content “C:\Users\Outis\~\.config\solana\kora-keypair.json” -Raw

kora --config kora.toml rpc start --signers-config signers.toml

Step 2: Creating Test Accounts

Wrote create-5-closeable.js:

// Creates 5 WSOL ATAs with close_authority = fee payer

// These should be detected as RECLAIMABLE by Solvent

Created 10 total across two batches.

Step 3: CLI Verification

solvent scan 8F9ijbjy1LLLTnEtx9jv7D4i5J2oFSERivE1bZkLiL2v --network devnet

Classification complete:

  Total: 29

  Reclaimable: 10

  Closeable (balance=0): 27

⚠ NEW! +3 closeable account(s)!

  +0.0061 SOL now reclaimable.

The CLI detected the new accounts.

Step 4: Triggering the Cron

Invoke-WebRequest -Uri “https://solvent-telegram-bot.vercel.app/api/cron” `

  -Headers @{”Authorization”=”Bearer solvent_cron_secret_...”}

Response:

{”message”:”Cron job completed”,”scanned”:2,”alertsSent”:1}

Step 5: Telegram Alert Received! 🎉

🔔 SOLVENT ALERT

5 new closeable account(s) detected!

📍 Address: 8F9ijb...iL2v

📊 Total Closeable: 36

💰 Total Rent: 0.0734 SOL

Run /scan 8F9ijbjy1LLL... for details

The entire pipeline worked end-to-end.

Final Thoughts & Lessons Learned

Technical Lessons

1. Read documentation thoroughly before building. I spent 2 days just reading. It saved me from building the wrong thing.

2. The close_authority discovery was key. Without it, this would have been just a monitoring tool. With it, it’s a real rent recovery system.

3. Vercel monorepo deployment is tricky. Put vercel.json in the subdirectory if that’s your Root Directory. Use cd ../.. to navigate up.

4. npm publishing has friction. Especially with scoped packages and monorepos. Plan for token/permission issues.

5. Test end-to-end early. I found bugs in the Telegram bot that I wouldn’t have caught with unit tests.

What I Would Do Differently

- Start with the Telegram webhook version, not the local polling version. Would have avoided porting 500+ lines of code.

- Publish to npm earlier in the process for cleaner dependencies.

- Add more comments as I went. Some files ended up with 700+ lines.

What I’m Proud Of

- Four working interfaces from a shared core library

- The close_authority discovery — a genuine technical finding

- End-to-end verification — not just “it compiles”

- 2000+ line builder’s log documenting everything as I went

The Real Value

For Kora operators, this tool provides:

1. Visibility into how much rent is locked in sponsored accounts

2. Classification of which accounts can be auto-reclaimed vs. require user action

3. Automation for reclaiming properly-configured accounts

4. Alerts when new reclaimable accounts appear

And for future Kora implementations, the recommendation is clear: always set `close_authority` to the fee payer when creating ATAs. This enables full rent recovery automation.

Links

- GitHub Repository: github.com/AngryPacifist/solvent

- npm Package: @angrypacifist/solvent-core

- Telegram Bot: @solvent_rent_bot

- Dashboard: solvent-kora.vercel.app

Subscribe now

If you found this article helpful, please consider liking and sharing it.

Connect with me on X: @angry__pacifist

There is something performative about waiting for a calendar page to flip before deciding to become a different version of yourself. I operate on output. If there is work to be done, you do it. If there is a wall, you break it.

And yet, looking back at the script of 2025, I have to admit: this was a strange, and wildly productive year.

My Twitter header says "I can do all things." It’s a terrifying obligation I put on myself. It is the fuel for the moniker everyone seems to have adopted for me lately: The Machine.

The Machine worked hard this year. But as the year ends, the Machine is undergoing a significant refactor.

For a long time, my primary output has been the SuperteamNG Writers Guild—the "Scribloors."

What started as a community management role morphed into something that felt more like a family. It was, frankly, a thankless job in many ways. It required absorbing the friction of a decentralized system so that others could just write. But the bench of research talent we developed is deep, and the culture we built is real.

The highlight of that grind was designing and delivering the first-ever blockchain writing course for the Federal Ministry of Youth Development. We translated the chaos of Web3 into a writing syllabus the government could actually use. That is a win that stays on the ledger.

However, ecosystems evolve. SuperteamNG is transitioning to a community-first structure, which means my role as Guild Lead is dissolving. Technically, you could call it a layoff. I call it a natural conclusion. I am stepping back from the leadership role, leaving the Guild in capable hands. I’m tired, but I’m grateful.

December was about breaking my own limits.

With the launch of Google's Antigravity, I stopped being just a writer and started becoming a builder.

In a span of weeks, I went on a tear. I built an analytics platform for Xandeum. I took my personal financial tracker and upgraded it into a full Progressive Web App, Zence, letting Gemini handle the branding while I handled the logic. I built 8 games for the Scrolly game jam. I even used AI to compose music and generate a music video for an ElevenLabs bounty. This, to mention but a few.

I didn't have a background in half of these things. I just had the tools and the stubborn refusal to accept that I couldn't do it.

Financially, I didn't hit the highs of the previous year. I traded arbitrage for stability with my main role at Little Unusual, and while I was inexperienced at first, I learned to kill it.

But December brought a script I wouldn't wish on anyone. My cats fell ill—one is still in surgery. I lost jobs. The "End of Year" felt more like a series of blows.

Life couldn't have written a more haunting ending to the chapter. And yet, I find myself incapable of being sad. Perhaps that’s the curse—or the blessing—of being the Machine. You process the data, you acknowledge the error logs, and you keep running.

So, what is the plan for 2026?

As usual, I don’t make resolutions. I don't necessarily believe in them. I believe in getting shit done.

But there are coordinates set. I am locked in, and I intend to exceed my own benchmarks.

And then there is Project Sinan.

As my partner Ral put it, we are writing "the greatest origin story for Research and Data in Africa." We have a data problem on this continent, and folks don't know how to research. We are going to fix that. If you are a researcher who actually cares about data integrity, or a creative who is tired of superficial, generic slop, get in touch. We’re going to be building a new bench.

One final note on logistics: I am fully aware of my reputation. The Machine is excellent at shipping projects but notoriously terrible at DM replies. I promise to be better at communication in 2026. (Please read that promise with the appropriate amount of skepticism. I am trying, but I am also likely deep in the labs somewhere).

The year is wrapping up with a lot of uncertainty. I am down a few roles, I am watching over a sick cat, and I am tired. (If you have any spare energy, send some to the cat. He’s the only one allowed to sleep on the job right now).

But the header on the profile isn't changing.

I can do all things. Even this.

For now, I'll be enjoying what's left of the holiday.

Happy New Year.

Subscribe now

Link to presentation can be found here

gm everyone.

The title of this is ‘The Bounty to Job Arc.’ It’s a true story, and it’s the main reason I’m here. I have a full-time job today, one that I love, because I submitted a piece to a bounty sprint... and I lost.

I know that sounds backward. We’re all here to learn ‘how to win.’

But I’m here to show you why losing might be the most valuable thing that happens to your career. We’re going to talk about a different way to play this game—a way that’s not about W/L ratios, but about building an undeniable portfolio and a real career.

My Origin Story: The Bear Market & The NFT

To get there, we have to go back to August 2023. It’s the peak of the bear market. I’m unemployed, living in a tiny apartment.

My entire professional and personal support system... my #1 cheerleader... is my neighbor, Mr. Martin. He’s reading my drafts. He’s not in crypto—he trades a bit on CEXes, but that’s it. So he’s learning from my work. He’s asking questions, he’s giving feedback, he’s telling me he’s proud of me. His family was my family. His support, honestly, is what kept me going. He’s moved, but he’s still my biggest fan today. You’d see him under every single content I put out.

At the same time, I’ve got this small WhatsApp community. I’m trying to convince them, ‘Guys, stop chasing airdrops. Go do bounties. It’s a real, sustainable way to earn. Especially in this market.’ But... no one’s listening.

And I’m trying to get into Superteam. Back then, they had the ‘Proof of Work’ NFT. This thing was a golden ticket. It vouched for your skill. Spontaneously increases your chances at getting hired within the ecosystem.

My network wasn’t getting me in. So I figured, I’ve got to work my way in.

This led to two goals:

1. Show my community this was a viable path.

2. Get that NFT.

So, I went bounty shopping.

The First Win & The Birth of a Method

The first one I found was a deep dive for Marinade. I’d used their platform, so I thought, ‘This should be easy.’

...It was not.

It took me the entire month. And this is where my first core principle was forged: ‘Anything worth doing is worth doing well.’

I had to dig through everything. Old Discord announcements, ancient Twitter spaces... I was literally transcribing recordings. Just... a mountain of raw data.

This grind... it forced me to build a process. I call it ‘Guerilla Research.’

Now, when people teach research, they tell you to start with a rigid outline. I do not do that. That’s not how ‘Guerilla Research’ works. My process is built on a simple idea: ‘Research is just asking a lot of questions... and then finding the proof to back your answers.’

So, the process has three steps.

1. The ‘Hunt’ (Finding the Proof): This is where I find everything. But the tactic changes based on the bounty.

   • Tactic A: The Digital Deep Dive. This is the ‘grind.’ This is the Marinade bounty. It’s transcribing spaces, reading old Discord posts, finding what’s already recorded.

   • Tactic B: The Human Source. This is creating proof that doesn’t exist by talking to people.

2. The ‘Sort’ (Asking the Questions): This is the ‘ugly’ part. I take all the chaos from ‘The Hunt’ and I just... start asking questions.

   • ‘Why did they really name it Kamino?’

   • ‘What’s the one detail everyone else is missing?’

   • ‘What’s the real story behind their B2B model?’

3. The ‘Narrative’ (The Answer): The final article... the thread... it’s just the answer to the most interesting question I found.

This is what I mean. This is my ‘Sort’ doc for the Deus Ex DAT piece, my latest. It’s not just ‘finding patterns.’ It’s literally a list of questions I wrote to myself. I’d write a question... then I’d go on a ‘Hunt’ to find the answer... and I’d paste the proof right below it. The final article is just these answers, cleaned up and structured into a story. The ‘Guerilla’ part is that the questions are mine, not from a template. This method scales, and is the core of all my work.

The “Guerilla” Process in Action

So, that Marinade win. That was 90% ‘Tactic A: The Digital Deep Dive.’ It was a pure grind. My question was ‘What is their entire history?’ and the ‘Hunt’ took a month. And after I won, I DMed the sponsor to ask for feedback. This is a step almost everyone skips. It immediately frames you as a professional, not just a contestant.

The Kamino bounty... this one was all about ‘The Sort.’ I won second place. My question was ‘Why that name? It sounds familiar.’ That question made me ‘Hunt’ through a one-hour recording... and buried in the middle, I found it. One of the founders mentions they named it ‘Kamino’ after the water planet in Star Wars, because they wanted to be the liquidity destination for Solana. This is information you couldn’t find anywhere else. It’s a human detail. That became my entire narrative. That’s the ‘Easter Egg’ you find when you do the real work.

And the Decharge bounty, a market landscape research bounty sponsored by Superteam Nigeria... this was 100% ‘Tactic B: The Human Source.’ The prompt was the start. But my question was ‘What does this look like in the real world in Nigeria?’ The proof didn’t exist online. So my ‘Hunt’ had to be in real life. I went the extra mile. I rented an EV... just so I could get an audience with the manager of an EV infrastructure company. I interviewed him. I incorporated those findings into my piece.

I always treat the bounty scope as a suggestion. If you write only what’s in the scope, you’ve shown you can follow instructions. That’s it. My best insights always come from going beyond the scope.

I won that one, too.

The Goal Evolves: “The New Game”

So, I’m on this heater. Marinade, Kamino, Decharge... But remember that NFT?

...They discontinued it.

My original goal... just vanished. I was bummed. But I did get into the SuperteamNG chapter. Shoot for the stars, land on the moon, right?

But this forced me to evolve. My goal couldn’t be a thing. My goal had to be bigger.

My new filter for before I embark on bounties became:

1. Is it long-form? (This is my strength).

2. Is it something I’d enjoy working on?

3. Is it something I’d be proud to share on my page, even if I lose?

This... this is the entire playbook. This is ‘The New Game.’

“The New Game” in Action: The KAST “Loss”

Which brings me to KAST. This is a key story.

KAST listed a bounty. And they listed a job opening for a marketing manager. I wanted that job.

So I decided: my bounty submission wasn’t for the prize. It was my job application. I would prove I could do the marketing by... doing the marketing.

I did the ‘Guerilla’ research. I wrote an article and a thread. My thread was my single best-performing piece of content. It raked in referrals. I’m getting DMs from ecosystem figures asking about the product.

I didn’t win the bounty. And I didn’t get the job.

I ‘lost’ twice.

But... I got proof. I got this email. The KAST concierge team reached out because my referral link was broken... probably from the amount of traffic I was sending. They had to manually credit me points for all the signups.

I had proven my point. I ‘lost’ the bounty, but I won the real game. I proved I was a marketer.

The KAST ‘loss’ was the final lesson. It taught me two things:

1. My ‘Guerilla Research’ could produce work that outperformed the winners.

2. The real audience, the one that matters for your career, isn’t the bounty judge—it’s the founder.

The Climax: The “Bounty to Job Arc”

So when the next opportunity came, I was ready.

Solana Collective hosts a ‘Hidden Treasures’ content sprint. The goal was to find a lesser-known project and tell their story. I didn’t go ‘shopping.’ I knew who I was writing about. I was already a fan of Little Unusual.

So I ran them through my filter:

1. ‘Is it long-form?’ (The deliverable was a thread, but the research could be. Check.)

2. ‘Will I enjoy it?’ (I was already a fan. Check.)

3. ‘Will I be proud of this, win or lose?’ (Hell yes. Check.)

It was a perfect fit. And I knew exactly how to play it, thanks to the lesson from KAST.

My ‘Hunt’ began. Tactic B: The Human Source.

I sent this DM to the co-founder, Tushar. ‘I want to tell your story.’

When he said yes, my mindset was locked in. I was not writing this piece for the bounty judges.

I was writing this piece for an audience of one.

We did an interview. I did all my research. I wrote an entire article, which I never published. The deliverable for the bounty was a thread. So, I took my article-level research, my deep interview, my ‘Guerilla’ process... and I packaged it into a thread. The depth was my edge.

I submitted.

And... I lost. The judges picked someone else.

But it didn’t matter.

Because my real audience... the one I’d focused on... saw it.

I get these messages. “Great write up.” ... “Do you like writing often?” ... “Lets schedule a call for Monday.”

Tushar didn’t care about the bounty. He saw a high-quality piece of content. He saw a professional... who showed initiative, did deep research, and told their story well.

Two weeks later, I was on the payroll.

That’s the ‘Bounty to Job Arc.’ The portfolio piece, the one I did because I wanted to be proud of it, became my career.

The Payoff: The Guild

This whole journey... the wins, the losses, the portfolio I built... That’s what led to this.

In September, I became the SuperteamNG Writers Guild Lead.

It wasn’t an accident. It was the logical next step. I was already contributing. I’d won the STNG-sponsored Decharge bounty, so they knew my work. My public content—the KAST piece, the LU piece—all reflected the standard they wanted.

When the role opened, my portfolio was my application. It was an easy choice for them because I had proven I had the standards to teach.

The Most Important Skill: How to Lose

So, this is the most important part of the playbook. Because you will lose.

My win rate... it’s not a clean streak. It’s something like 8/18. But 3 of those were hackathons, 2 were job applications... so the real bounty-for-bounty ratio is more like 7/12. But honestly? The number doesn’t matter. That’s the whole point.

And this is the most important takeaway: Losing doesn’t necessarily mean your work is subpar.

The ‘Bounty to Job Arc’ is proof of that. The ‘KAST’ story is proof of that.

It just means your piece wasn’t their pick. That’s all.

When you lose, you have a 3-part plan.

1. The Internal Battle: You must kill the entitlement. My method is simple. I say to myself: “Their money, their decision.” You are in a global competition. You can’t control the judge’s taste. That’s subjective. Sometimes, like with a big sprint, you can’t get individualized feedback. That’s just how it is. The only thing you can control is the quality of your own work.

2. The External Support: You need a Mr. Martin. My neighbor was my #1 cheerleader. He believed in the work, not the win. He kept me going. Your ‘How to Lose’ plan must include an external support system.

3. The Real Win (The Growth): This is the key. You always grow.

• With the Futarchy bounty, I lost... but I learned a new form of decentralized governance.

• With the Decharge bounty, I won... but the real win was proving I could do market analysis.

• With the cNFT bounty for ST India, I won... but the real win was learning ecosystem-wide data analysis.

Win or lose, you always walk away with a new skill. That is the real prize.

The Final Playbook

So, this is the playbook I’m giving you.

1. THE FILTER: Before you start, ask: ‘Am I interested? Will I be proud of this, win or lose?’

2. THE METHOD: Use ‘Guerilla Research.’ Ask better questions. Find better proof.

3. THE GOAL: Always have a goal beyond the prize money. (A job, a new skill, a relationship).

4. THE “HOW TO LOSE” PLAN:

   • Internal: “Their money, their decision.”

   • External: Find your Mr. Martin.

   • Growth: Catalogue the new skill you just learned.

5. THE HABIT: Ask for feedback. That DM to Marinade? That was me escalating a habit I already had. Start small.

Because good work will intercede for you, often in ways you can’t even predict.

Bounties are a great way to get your foot out the gate, give you a shot at a professional career opportunity. Treat it as serious business.

Stop just bounty hopping. Start building your career.

Subscribe now

Connect with me on X: @angry__pacifist

Editor’s Note: All financial figures, market capitalizations, and treasury holdings in this article are based on publicly available data as of October 15, 2025, unless otherwise specified. The digital asset market is highly volatile, and these figures are subject to change.

This article is for informational and educational purposes only and should not be construed as financial or investment advice. Readers should conduct their own research and consult with a qualified financial advisor before making any investment decisions.

In ancient theater, when a plot became impossibly tangled, the playwright would invoke a ‘Deus Ex Machina’—a ‘god from the machine’—lowered onto the stage to solve everything. For years, the crypto industry has been stuck in its own tangled plot: the impossible problem of onboarding trillions from traditional finance. Its solution is a high-stakes gambit: a corporate entity designed as a perpetual motion machine, relentlessly accumulating the very asset it was built to hold. This is the story of that machine, and the question of whether its creators have built a god, or unleashed a ghost.

This vehicle, the Digital Asset Treasury (DAT), fundamentally rewires the relationship between blockchains and institutional capital, creating immense opportunity alongside unforeseen risk.

This article centers on a single question: Are Solana DATs the ultimate Trojan horse for mainstream adoption, or a gilded cage that trades decentralization for institutional acceptance?

A Better Playbook.

To understand the machine, we must first examine its design. At its core, the Digital Asset Treasury is an evolution of a now-familiar playbook popularized and executed at scale by Strategy (Formerly MicroStrategy). This model is distinct from a simple “strategic reserve”, where a company might hold digital assets in addition to its main business. A Digital Asset Treasury, by contrast, is a vehicle whose primary purpose is to increase its exposure to the underlying asset. It uses sophisticated financial engineering—issuing instruments like convertible debt (debt that can later be converted into company stock) and running at-the-market (ATM) share programs (allowing the company to sell new shares directly into the open market over time)—to raise capital and accumulate tokens. The ultimate goal is to maximize a key metric known as “token per share”, which a successful DAT aims to grow over time for its shareholders.

At a deeper level, a Digital Asset Treasury company functions almost exactly like a bank or an insurance company. The model is a form of capital markets arbitrage. A DAT raises funds from the capital markets, invests those funds into a digital asset like Solana, and earns the spread between the return on that asset and its own cost of capital. The market, in turn, calculates the present value of all that potential future spread income and adds it to the company’s Net Asset Value (NAV) (the total value of the company’s assets minus its liabilities, often calculated per share), causing its stock to trade at a premium (a market price higher than the calculated NAV per share).

This premium exists because a DAT solves what industry insiders call a “plumbing issue”^[2] for institutional investors. Hunter Horsley of Bitwise provides a concrete example: many large funds are mandate-restricted, meaning they are “only allowed to invest in equities”.^[3] For these multi-trillion dollar asset managers, a DAT is the sole vehicle available to express conviction on a digital asset. This function as a necessary bridge creates a “supply chain setup”, connecting the deep pools of traditional capital to the new on-chain economy and allowing for unique value accrual mechanisms unavailable to individual holders.

This dynamic creates a powerful “financial flywheel”. According to Pantera Capital’s Cosmo Jiang, this capital markets flywheel is the primary driver of value, accounting for 85-95% of the total value creation^[4] for a successful DAT. When a DAT’s stock trades at a premium to its NAV, it can issue new shares at this favorable valuation. In effect, it is selling a dollar for two, or buying the underlying asset at a discount. The proceeds from this issuance are then used to buy even more of the digital asset, which can further increase the share price and allow the cycle to repeat. This process of accretive dilution (issuing new shares in a way that increases the value per share for existing shareholders) is the primary engine for growing the asset-per-share for its investors.

For treasuries built on Solana, however, this playbook has a critical advantage over its Bitcoin-centric predecessors: native yield. Solana is a productive asset; as a generalized smart contract platform, it generates fees from network activity, capturing real fundamental value that is returned to token holders. This allows the asset to be staked to generate a significant return, currently around 8% annually. This provides a foundational yield that makes the entire model more sustainable. As Kyle Samani, chairman of the largest Solana DAT, noted, the “intellectually honest benchmark” is not just the asset itself, but a Solana staking ETF^[5]—a passive fund designed to capture that same yield. This native yield means the machine is productive before any financial engineering, making the playbook fundamentally better.

The Architects & Their Machines

Executing this better playbook, however, is a new class of architects, each with a distinct and competing vision for the machine they are building.

Forward Industries

Leading the charge is Forward Industries, Inc. (NASDAQ: FORD), the largest Solana Digital Asset Treasury by a significant margin. Chaired by Kyle Samani of Multicoin Capital, Forward Industries swiftly established its dominance by closing a $1.65 billion all-cash Private Investment in Public Equity (PIPE) deal^[6] (a way for public companies to raise capital quickly from a select group of investors). This deliberate choice bypassed the lengthy shareholder votes required for in-kind contributions (paying with assets instead of cash), allowing the company to execute its first massive SOL purchases within days.

The company currently holds 6.822 million SOL, valued at approximately $1.32 billion as of mid-October 2025.^[7] With a market capitalization of $2.09 billion,^[8] its stock trades at an approximate 58% premium to its Net Asset Value (NAV), a key metric indicating strong investor expectations.

Forward’s pivot is driven by a mission that, in Chairman Kyle Samani’s words, transcends simply raising money for Solana; it aims to actively “advancing the objectives of Project Crypto”.^[4] This philosophy of fundamentally transforming finance itself is a vision shared by their key financial partners.

“Project Crypto” refers to an initiative announced by SEC Chairman Paul Atkins to move all U.S. securities markets onto the blockchain.^[9] Forward’s stated goal is to accelerate that vision by becoming the world’s most on-chain native public company. This mission informs every aspect of their strategy. They are partnering with Superstate to tokenize their own $FORD equity on Solana, a move designed to unlock 24/7 trading and enable integration with DeFi protocols like Jupiter, Kamino, and Drift. Their commitment extends to core operations, with plans to handle everything from vendor payments to shareholder governance on-chain.

To support this vision, the company runs its own institutional-grade validator in partnership with DoubleZero, staking its entire treasury with 0% commission on a high-performance Firedancer client from Jump Crypto. This allows them to capture extra fees and MEV directly. While this provides a strong base yield, their strategy to outperform the “intellectually honest benchmark”—a Solana staking ETF—relies on a three-pronged approach: negotiating special deals like equity stakes in partners, actively participating in DeFi, and arbitraging the spread between low-rate institutional debt and high-yield on-chain opportunities.

This ambitious mission is tempered by institutional discipline. The company favors perpetual preferred instruments for leverage, which avoids margin calls, and views inevitable bear markets as opportunities for the accretive Mergers and Acquisitions (M&A) of smaller, less-prepared DATs.

Yet, for every architect aiming to rewrite market structure, another is focused on perfecting the machine itself.

Solana Company

Backed by the formidable expertise of Pantera Capital, Solana Company, Inc. (NASDAQ: HSDT) represents the arrival of a purely institutional playbook. The company is a recent and significant pivot from its former life as Helius Medical Technologies, a neurotechnology firm. While continuing its legacy medical device operations, the company officially rebranded in September 2025 to execute a new, singular focus: building the “preeminent Solana treasury” through sophisticated financial engineering. The clarity of their vision for Solana is often distilled into a simple, powerful analogy for traditional investors, comparing it to the core principle of Amazon: consumers always want things “faster, cheaper, and more accessible”.^[4]

This mission is funded by aggressive capital accumulation, building a treasury of over 2.2 million SOL valued at approximately $520 million at its announcement in early October 2025.^[10] The company reinforces its institutional focus through partnerships with top-tier custodians Coinbase, BitGo, and Anchorage, and by providing sophisticated liquidity tools for investors with the launch of options trading on the CBOE. With a market capitalization of around $625.6 million,^[11] its stock trades at a significant premium of approximately 37% to its Net Asset Value (NAV)—a key metric that quantifies the market’s high expectations for Pantera’s strategy.

The entire strategy is grounded in a classic TradFi discipline, viewing the DAT model through the familiar lens of established financial institutions.

Pantera’s framework dictates that 85-95% of a DAT’s value creation comes from the capital markets flywheel,^[4] with the remainder generated by on-chain yield. Their initial $500 million private placement showcased this expertise, incorporating stapled warrants (options issued alongside shares, giving the right to buy more shares later at a set price) that pre-authorize an additional $750 million in capital if performance targets are met^[4]—a powerful, built-in mechanism for accretive growth.

Their on-chain execution is equally disciplined. The company targets high single-digit returns by leveraging its scale to secure preferential, zero-commission staking rates and participating in established DeFi protocols. This operational yield is part of an all-weather approach to capital allocation: the company will issue stock when trading above a 1x NAV multiple and buy it back when trading below, ensuring they can grow their SOL-per-share in any market condition.

This all-weather mastery of the capital markets flywheel is the institutional playbook, leaving the network’s core infrastructure as a frontier for other architects to conquer.

DeFi Development Corp

The singular goal of DeFi Development Corp. (NASDAQ: DFDV) is to relentlessly compound its SOL Per Share (SPS). To achieve this, the company pivoted from its fintech roots in early 2025 under the leadership of CEO Joseph Onorati, a former Kraken executive, embarking on a strategy of aggressive technical and financial integration while continuing to operate its legacy fintech platform, Janover Inc.

Beyond simple accumulation, DFDV operates as a true infrastructure player. The company runs its own validators to capture extra fees and MEV, then deploys proprietary on-chain products—from its tokenized stock, $DFDVx, to its Liquid Staking Token, dfdvSOL —to execute complex yield strategies like “stake looping” in protocols like Kamino and Drift. This philosophy of scalable growth extends globally through their “Treasury Accelerator”, a franchising model that has already launched its first international entity in Japan with DFDV JP.

The company funds this complex strategy with an equally complex capital stack, powering its flywheel with everything from a $125 million PIPE^[12] deal and a massive $5 billion equity line^[13] (an agreement allowing the company to sell shares over time up to a certain limit) to an acquisition strategy that includes buying locked SOL from the FTX estate at a discount. As of mid-September 2025, this aggressive approach has amassed a treasury of approx. 2,095,748 SOL.

DFDV’s profile, however, provides a stark, real-world lesson in the risks of this model. As of mid-October 2025, with a market capitalization of around $403.28 million^[14], its stock was trading at a discount (a market price lower than the calculated NAV per share) to the value of its assets. The company’s financial flywheel was effectively turned off. This dynamic illustrates a critical challenge: market factors, such as concerns over dilution from aggressive fundraising, can erase the NAV premium that is the primary engine of a DAT’s growth.

Despite these market pressures, the company’s core strategy remains one of relentless compounding. This complete fusion of finance and technology defines the playbook of the infrastructure operator.

SOL Strategies

The earliest pioneer of this infrastructure playbook, however, approached it with a purer, technology-first philosophy. SOL Strategies Inc. (NASDAQ: STKE), which began its life in 2018 as Cypherpunk Holdings, was the first publicly traded company to put Bitcoin on its balance sheet—predating even Strategy. After pivoting to Solana in 2024, the company defined itself as a “DAT++” entity, a model combining a digital asset treasury with a real, revenue-generating infrastructure business.

This identity is best explained by the analogy from their former CEO, Leah Wald.

This “miner” ethos is driven by a core philosophy; that a sustainable tech business provides a more durable “organic growth” flywheel than pure financial engineering. Under the technical leadership of CTO Max Kaplan, their mission is to help build Solana into the “decentralized NASDAQ”^[16] by creating the best possible on-chain trading experience. This tech-first philosophy is backed by a suite of proprietary products and services, including their Stakewiz analytics platform, the first dedicated mobile app for native Solana staking, and institutional-grade validator services that are ISO 27001 certified and trusted by clients like Cathie Wood’s Ark.

The data confirms this focus: while the company’s own treasury holds 523,433 SOL,^[17] its validator business manages a delegated stake of approx. 2.8 million SOL^[18] for third parties, generating revenue that grows their treasury without diluting shareholders.

Their pioneer status, however, has exposed them to the harsh realities of a maturing market. In a September 2025 report, SOL Strategies disclosed that its delegated stake had declined by 23.7%, attributing the drop to “heightened competition among validator operators, new entrants to the digital asset treasury space, and shifting institutional preferences”.^[18] This illustrates the intense competitive pressure on the infrastructure model and helps explain why, like DFDV, their stock has recently traded at a discount to its NAV.

In response, the company is actively defending its moat by expanding its business development, deepening its engagement with ETF providers, and securing strategic partnerships, such as integrating its validator services with Crypto.com for institutional clients. This intense focus on building a defensible technology business, navigating the complexities of validator economics, defines the playbook of the technological infrastructure operator.

But another architect argues that the ultimate competitive edge comes not from technical complexity, but from radical simplicity.

Upexi

Upexi, Inc. (NASDAQ: UPXI) is the embodiment of a prudent, finance-first playbook designed for the traditional investor. The company, a diversified owner of consumer brands in sectors like pet care and wellness, pivoted into the treasury space in April 2025 under the guidance of CSO Brian Rudick, a veteran of TradFi firms like Citadel and Millennium. Their strategy is built to appeal to a traditional investor, focusing on accessibility and disciplined risk management over the complex on-chain maneuvers of their peers. This focus is reinforced by a savvy advisory committee that includes both crypto legends like Arthur Hayes and SOLBigBrain.

CEO Allan Marshall encapsulates their core value proposition directly:

This “keep it simple” philosophy dictates their operational choices. Upexi deliberately avoids running its own validators, arguing it is more capital-efficient and prevents confusing investors with the technicalities of proof-of-stake.^[20] Their primary method for seeking an edge is purely financial: they have aggressively used their $300 million in capital raises to acquire locked SOL at a significant discount,^[21] creating built-in gains for shareholders. This straightforward approach has resonated so strongly that their stock has become a foundational asset for other financial products, including the first 2x leveraged ETF (ticker: PXIU) launched by T-Rex.

As of mid-October 2025, this strategy has accumulated a treasury of 2,018,419 SOL.^[21] However, like other DATs, Upexi has not been immune to market pressures. A direct comparison of its market cap ($368.05 million)^[22] to its raw treasury value (~$409.3 million) shows the stock trading at an approximate 10% discount to its NAV. This unadjusted view reflects market skepticism around factors like potential dilution. The company itself reports an adjusted “fully-loaded” mNAV that shows a premium by accounting for liabilities like its $150 million in convertible notes.^[19]

Upexi’s entire approach mirrors that of an established financial institution. They aim to keep leverage below 20% of NAV, a discipline borrowed from Strategy, and have so far avoided speculative DeFi protocols in favor of a straightforward 7-9% staking yield. This disciplined, finance-first approach defines the playbook of the prudent accumulator.

The final architect in our lineup, however, seeks an edge by moving deeper down the technology stack—past the financial and software layers—to master the physical hardware itself.

Solmate

Solmate Infrastructure (NASDAQ: SLMT) is the most unconventional architect in the landscape, a high-conviction bet on a physical, sovereign infrastructure advantage. The company is a recent and dramatic pivot from its former life as Brera Holdings, an international multi-club football ownership firm. Rebranded in October 2025, Solmate’s new mission, under the leadership of CEO Marco Santori (formerly of Pantera and Kraken), is to build high-performance Solana infrastructure from the ground up.

Their core strategy is the “bare metal” thesis: they are building and operating their own physical servers in Abu Dhabi, aiming to run the first performant validator in the Middle East and process transactions “faster, more efficiently, and more profitably”^[23] than competitors renting cloud hardware. This move is a strategic play to become a key player in the region, underscored by their public plans for a dual listing on a UAE exchange.^[24] This builder-oriented, opportunistic philosophy was best captured by CEO Marco Santori’s simple, confident statement during a market liquidation event:

The statement announced their historic first treasury acquisition: a $50 million purchase of SOL directly from the Solana Foundation at a 15% discount.^[25] This single transaction established their initial treasury of approximately 294,000 SOL,^[25] and was the first major deployment of capital from their recent ~$300 million PIPE financing.^[24] The deal brought powerful institutional players to their side, including the Solana Foundation and a board of directors featuring famed economist Arthur Laffer. The most significant validation, however, came from Cathie Wood’s ARK Invest, which took a direct 11.5% stake^[25] in the company.

As a company in the midst of a radical transformation, its market valuation has been extremely volatile. In the weeks following its pivot, its market cap has fluctuated between $35 million and $60 million.^[27] This has caused its stock to swing wildly between trading at a steep ~40% discount to its Net Asset Value (NAV) and a slight ~5% premium, a clear illustration of a market struggling to price in a high-risk, high-reward pivot in real-time.

This strategy of building a sovereign, physical infrastructure stack—a bet on atoms as much as bits—defines the playbook of the sovereign infrastructure operator.

Beyond these key architects, the landscape is filled with a rapidly growing class of treasury accumulators. Companies like Sharps Technology (NASDAQ: STSS), Mercury FinTech (OTCMKTS: MFH), and others represent a diverse long tail of public entities adopting the Solana treasury model, collectively validating the strategy’s broad appeal across different sectors, from biotechnology to healthcare.

The Gravity Well Effect

While each architect pursues a unique playbook, their combined actions exert a powerful, unified force on the Solana network. Their relentless accumulation is forming a new economic center of gravity—a gravity well of permanent capital. The question then becomes: what happens to an ecosystem when a black hole of permanent capital forms at its center?

The Supply Sink

The primary impact of these Digital Asset Treasuries is the creation of a massive “supply sink”. Because the core strategy for nearly every DAT is to “buy-and-HODL-only”, every token they acquire is effectively removed from the liquid, tradable supply forever.

Based on the most recent official disclosures, the combined holdings of the six architects spotlighted in this article—Forward Industries, Solana Company, DeFi Development Corp., Upexi, SOL Strategies, and Solmate Infrastructure—alone total a confirmed 14,103,377 SOL.

Against a total circulating supply of approximately 546.8 million SOL,^[28] these six companies have already acquired over 2.58% of the entire network. It is important to note that aggregator sites report varying totals as high as 20 million SOL,^[29] as the landscape of new and undisclosed treasuries changes daily. This “fog of war” in the data is itself a symptom of a movement expanding so rapidly that even market trackers struggle to keep pace.

Market Impact and Network Security

This relentless accumulation creates a consistent source of structural buying pressure on the market. However, the data reveals a nuanced reality. While some acquisition announcements in September 2025 coincided with positive price momentum, the cluster of major purchases in mid-October occurred during a significant market-wide downturn, with SOL’s price dropping each day. This demonstrates that while DATs provide a steady demand floor, they do not operate in a vacuum and cannot single-handedly override powerful macro market trends.

Moreover, some market participants speculate that the method of acquisition matters, theorizing that large-scale purchases of heavily discounted or locked SOL by DATs might, counterintuitively, exert downward pressure on the spot price as the market attempts to align values, potentially “neutering” performance until those discounts are absorbed.^[30]

The more significant, second-order effect of this activity is the enhancement of network security. In Solana’s Proof-of-Stake system, network security is a function of the total value of all staked SOL, which currently stands at over 416 million tokens.^[31] An attacker would need to acquire a supermajority of this stake (over 66%) to halt or compromise the network’s finality. By contributing to a higher overall market capitalization—which stood at approximately $96.9 billion as of mid-October^[28]—the DATs’ activity directly increases the economic cost of acquiring such a controlling stake, making a successful attack economically irrational and rendering the network more resilient and secure.

This creation of a supply sink and the resulting impact on network security are the direct consequences of a fierce, ongoing battle for accumulation. The essential question then becomes: what drives this battle, and how are the different ecosystems competing in this new L1 Treasury War?

The L1 Treasury Wars

Understanding this competition requires recognizing the fundamental clash at its core: the established playbook of the non-yielding monetary asset versus the emerging strategy centered on productive, yield-bearing platforms.

The Productive Asset Advantage

Bitcoin’s model, championed by companies like Strategy and Metaplanet, is built on the thesis that Bitcoin is the “Apex monetary asset”—a pure store of value whose scarcity is its primary feature. As a non-yielding asset, any returns for a Bitcoin DAT must come from financial engineering or price appreciation. While new protocols like Babylon are experimenting with “Bitcoin restaking”, the yields are minimal, often below 1% APR.^[32]

In stark contrast, architects on both Solana and Ethereum argue their platforms represent a superior model because they are “productive assets”. These networks generate fees from real economic activity, which are returned to token holders through staking yields. However, the data reveals a significant performance gap: while Ethereum’s staking yield hovers around 2.7-3.3% APR,^[33] Solana’s is consistently higher at around 7%.^[34] This yield advantage extends into their respective DeFi ecosystems, where major Solana protocols like Kamino and Jupiter offer lending and liquidity provision APYs in the 10-25% range,^[35] significantly outpacing the low single-digit base yields on Ethereum’s primary platforms like Aave and Compound.^[36]

The Institutional Battleground

For institutional investors, the choice between these ecosystems is framed by a debate over “active vs. passive” management. Exchange-Traded Funds (ETFs) offer passive exposure, but as experts on the TOKEN2049 Singapore 2025 panels explained, Digital Asset Treasuries offer the promise of “active management” from sophisticated firms like Pantera and Jump. DATs have a key structural advantage: they hold “captive money” and do not face daily redemptions, allowing them to deploy capital into long-term strategies like staking far more effectively than an ETF. Some even predict that “DATs are going to do to ETFs what ETFs did to closed-end funds and mutual funds”.^[2]

While the Ethereum DAT architects argue that recent regulatory clarity has finally “unleashed” their ecosystem to compete on a level playing field with Bitcoin, the hard data on new institutional adoption tells a different story. According to CME Group, the premier market for institutional derivatives, Solana futures reached the $1 billion open interest mark in just five months—significantly faster than it took Ether (eight months) or Bitcoin (three years).^[37] This verifiable data point is a powerful signal of Solana’s potent and accelerating appeal to the institutional world.

The Endgame: Consolidation

Given the rapid proliferation of DAT vehicles across Bitcoin, Ethereum, and Solana, a near-universal consensus exists among industry architects: the current crowded landscape is unsustainable.

Most predict a future marked by significant consolidation, suggesting that only a few dominant, well-capitalized players in each major ecosystem will ultimately survive this phase of the L1 Treasury Wars. The specific dynamics and strategic implications of this expected M&A wave, shaping the long-term structure of the DAT market itself, will be explored later in this analysis. For now, the clear takeaway is that a fierce battle for scale and survival looms—an endgame of consolidation that will define the market’s long-term structure.

The Bridge to Wall Street

With the L1 Treasury War intensifying and its endgame likely involving significant market shifts, the ability to capture institutional capital becomes paramount. Success hinges on the effectiveness of the DATs as financial conduits, forcing a closer examination of how this bridge to Wall Street actually functions and why institutions are choosing to cross it now.

The Three Institutional Archetypes

For many institutional investors, direct exposure to crypto is fraught with operational and regulatory friction. DATs solve this by providing a familiar, accessible wrapper. As experts on the TOKEN2049 Singapore 2025 panels explained, this solves a core “plumbing issue”, fitting a new asset into the existing back-end systems of Wall Street. This necessity creates three distinct archetypes of institutional DAT investors.

First is the Mandate-Restricted Investor. Hunter Horsley of Bitwise provides a perfect real-world example: a portfolio manager at Capital Group, one of the world’s largest investment firms, who has deep conviction on Bitcoin but whose fund is “only allowed to invest in equities”.^[3] For this multi-trillion dollar class of asset managers, a DAT is the only vehicle available to express their investment thesis.

Second is the Interim On-Ramp Investor. This includes slow-moving giants like sovereign wealth funds. Horsley cites the case of a sovereign fund that is six months away from getting internal approval to buy Bitcoin directly. Their solution? They “own shares of Strategy now”^[3] as a temporary, compliant way to get exposure while their internal bureaucracy catches up.

Finally, there is the Corporate Treasury Allocator. Beyond dedicated DATs, a broader trend is emerging where traditional corporations are beginning to allocate a small portion of their own treasuries to digital assets. As Richard from Binance noted, many are starting to look at allocating “5% of their treasuries, 10% of their treasuries”^[3] into the space, viewing it as a new, essential component of a modern balance sheet.

The Macro Tailwinds

This flood of institutional interest is being accelerated by two powerful macro tailwinds. The first is a significant regulatory shift in the United States. The passage of stablecoin legislation and the increasing clarity from regulators have, as one architect put it, “unleashed”^[38] the ecosystem, giving institutions the confidence to deploy capital without fear of legal ambiguity.

The second tailwind is the rise of stablecoins as a gateway drug for institutional DeFi. Heath from Circle argues that as traditional companies begin using stablecoins for basic treasury management, they will inevitably look to “diversify into other digital assets”.^[3] Stablecoins are the “pathway”^[3] that brings institutions on-chain, and once there, the high-yield environment of platforms like Solana becomes the next logical destination for their capital.

The Solana-Specific Advantage

This accelerating institutional appeal is driven by real-world adoption. As Kyle Samani points out, the world’s largest payments companies—Worldpay, Fiserv, and Visa^[5]—are all coalescing around Solana for their on-chain strategies, drawn by its superior speed and low cost. This combination of explosive institutional interest and real-world utility is what positions Solana’s architects to be the primary beneficiaries of the capital now crossing the bridge from Wall Street.

The Dragon of Centralization

Digital Asset Treasuries indeed act as a powerful engine for growth, successfully bridging Wall Street and attracting institutional capital onto Solana. This success, however, forces a critical look at the network’s foundational principles. As vast sums of SOL concentrate within a handful of corporate entities, a new “dragon” of centralization emerges, potentially undermining the very decentralization that gives the network its value.

Stake Concentration and the Nakamoto Coefficient

The most direct measure of decentralization is often the Nakamoto Coefficient (NC)—the minimum number of entities required to collude to compromise a network. While Solana boasts a relatively high theoretical NC (around 20, based on validator count)^[39], experts like Mert Mumtaz argue that the effective NC is much lower, possibly as low as 7,^[40] due to the concentration of stake within large custodians like Coinbase and Figment, amplified by the Solana Foundation’s own delegation program.

Digital Asset Treasuries add a new layer to this dynamic. Based on recent disclosures, the six architects spotlighted in this article collectively control approximately 14.1 million SOL, representing roughly 3.82% of the total staked supply.^[31] While this figure alone does not drastically alter the NC, the way this stake is deployed matters. If DATs choose to concentrate their delegations with the largest existing validators (often run by exchanges or custodians), they could inadvertently exacerbate the centralization risks Mumtaz identified, further lowering the network’s effective decentralization.

Validator Influence: MEV and Censorship Risks

Such concentration carries tangible risks, particularly concerning Maximal Extractable Value (MEV) and potential transaction censorship. Large validators with significant stake can dominate block production and transaction ordering, enabling aggressive MEV strategies like sandwich attacks that extract value from users. This creates a negative feedback loop: MEV profits are often restaked, further consolidating control and potentially allowing dominant entities to capture an ever-larger share of network rewards.

Furthermore, concentrated stake lowers the threshold for potential censorship. A small group of powerful validators could theoretically collude to reorder, delay, or even exclude certain transactions, perhaps to maximize their own MEV or comply with external pressures. While Solana’s design aims to mitigate MEV, and initiatives like Jito Labs’ Block Assembly Marketplace actively combat “bad MEV,”^[41] the underlying risk remains tied to stake distribution. While no DATs have been publicly implicated in such practices, their growing influence necessitates vigilance.

Governance Impact and Conflicts of Interest

Solana’s governance largely relies on stake-weighted voting by validators on Solana Improvement Documents (SIMDs).^[42] With DATs controlling nearly 4% of the staked SOL, their chosen validators gain proportional influence over proposals affecting network upgrades, fee structures, and economic policies.

This introduces potential conflicts of interest. As noted in analyses by Helius^[43] and SEC filings,^[44] validators (and by extension, the large entities delegating to them) may have incentives that diverge from broader network health. They might oppose upgrades that reduce their MEV opportunities or commission structures, even if beneficial for users. Large corporate entities could also exert influence—formally through voting or informally through relationships—to steer protocol development in ways that favor their business models. Some critics, like Omid Malekan, even foresee scenarios where large, regulated entities could push for protocol-level compliance features, potentially eroding censorship resistance.^[45]

While the Solana Foundation and core developers currently hold significant sway, the growing stake controlled by publicly traded DATs represents a new, powerful constituency. Balancing their influence with the network’s core principles of decentralization will be a critical challenge as the ecosystem matures.

The House of Cards

The risks posed by DATs extend beyond network centralization; the corporate structure itself harbors vulnerabilities, particularly its reliance on volatile market dynamics. The financial flywheel, so effective during bull markets, contains fragilities. When market sentiment shifts, the premium to Net Asset Value (NAV) fueling this mechanism can evaporate, exposing the DAT to significant dangers and potentially amplifying losses.

The Premium Collapse: Beta on Beta

The core vulnerability lies in the premium to NAV. As discussed, this premium is the lifeblood of the DAT’s ability to accretively grow its tokens per share. However, this premium is not guaranteed; it is a reflection of market sentiment, hype, and the perceived value of the DAT’s active management. In a market downturn, this sentiment can evaporate instantly.

The market crashes of October 2025^[46] provided a brutal, real-world stress test of this dynamic. As both traditional equities and crypto markets plunged simultaneously, DATs were hit with a double blow. Not only did the value of their underlying asset (SOL) fall, but their stock prices often fell even harder as the NAV premium collapsed or flipped into a steep discount. This demonstrates the “beta on beta” effect: investors are exposed to the high volatility of the underlying crypto asset, compounded by the volatility of the equity wrapper itself. Our own analysis revealed multiple major DATs—including DFDV, SOL Strategies, Upexi, and the newly pivoted Solmate Infrastructure—trading at discounts to their NAV in mid-October, effectively shutting off their primary growth engine.

Corporate & Financial Fragilities

Beyond the premium collapse, the DAT model carries other significant corporate and financial risks. The use of leverage, while potentially amplifying returns, adds a layer of fragility. While some architects like Upexi aim for disciplined leverage limits (e.g., under 20% of NAV), the temptation to increase leverage during bull markets is ever-present. In a severe downturn, overleveraged DATs could become forced sellers of their underlying assets to meet debt obligations, exacerbating market crashes.

Furthermore, the very act of trying to manage a NAV discount carries risks. Joseph Onorati of DFDV warns against the temptation to sell treasury assets to fund stock buybacks when trading below NAV, calling it a potential “death spiral”.^[47] Such actions deplete the core asset without necessarily fixing the underlying market confidence issue that caused the discount in the first place.

Regulatory & Jurisdictional Arbitrage

Finally, the structure of many DATs relies on a degree of regulatory and jurisdictional arbitrage. By incorporating in specific locations (like Delaware, Canada, or Ireland) and using existing corporate structures, they have largely bypassed the need for new, crypto-specific regulatory approvals faced by products like ETFs. While this has enabled speed to market, it also carries the risk that regulators could eventually scrutinize these structures more closely, potentially classifying them as investment companies or imposing stricter requirements that could impact their operational flexibility or cost structure.

These combined risks paint a picture of a powerful but potentially fragile model. The long-term success of any DAT hinges not just on the performance of its underlying asset, but on its management team’s ability to navigate these inherent structural challenges.

The Paths Forward

The fragilities exposed within the DAT model demand strategic answers. As this landscape matures, the architects behind Solana’s treasuries are not following a single blueprint. Instead, distinct and competing philosophies are emerging, carving out divergent paths for this new financial machine. We see this in the mission of Forward Industries as an “On-Chain Pioneer”, Upexi’s disciplined focus as a “Prudent Accumulator”, Pantera’s “Institutional Strategist” mastering the capital markets flywheel, and the varied approaches of infrastructure players like DFDV, SOL Strategies, and Solmate.

The DAT++ Evolution: Two Competing Visions

This strategic divergence hints at the future evolution of the model, often conceptualized under the “DAT++” banner that SOL Strategies pioneered. However, even this term represents two competing visions for what comes next.

Kyle Samani envisions the DAT++ as an “On-Chain Venture Fund”,^[48] leveraging its treasury not just for yield but to actively invest in and incubate new projects within the Solana ecosystem, creating a powerful flywheel for ecosystem growth. This aligns with Joe Lubin’s “civilization building” vision for Ethereum DATs.^[38]

SOL Strategies, conversely, pioneered a DAT++ model focused on becoming an “Infrastructure Operator”, combining treasury management with a real, revenue-generating business running validators and building proprietary technology. Their goal is less about venture investing and more about building a defensible, sustainable tech company on top of the treasury.

The Endgame: Consolidation

Regardless of which strategic model proves superior, there is a near-universal consensus among the architects themselves: the current crowded landscape is unsustainable. A massive wave of Mergers and Acquisitions (M&A) is coming.

Experts like Cosmo Jiang predict only “two, maybe three, scaled DATs for each of the large-cap assets” will survive.^[2] Jason Urban forecasts a period reminiscent of the “corporate raiders” of the 1980s, where larger players act as “apex predators”, acquiring struggling competitors trading at discounts.^[3] While some, like Tom Lee, hope for collaboration over hostile takeovers, the fundamental dynamic is clear: scale matters, and the market will inevitably consolidate around the most effective and well-capitalized teams. Real-world examples, like Strive’s acquisition of Semler Scientific, already point towards this future.^[49]

The Philosophical Debate: Trojan Horse or Gilded Cage?

This brings us back to the central question posed at the outset. Are Solana DATs the ultimate Trojan horse for mainstream adoption, successfully bridging the gap between traditional finance and the on-chain world? Or do they represent a gilded cage, concentrating power and potentially sacrificing the core principles of decentralization in exchange for institutional acceptance?

The evidence suggests they are both. DATs undeniably solve a crucial “plumbing issue,” providing a necessary, compliant on-ramp for trillions in institutional capital that cannot or will not touch crypto directly. They are powerful advocates, educating Wall Street about Solana’s potential and driving adoption. Visionaries like Jason Urban even see them as the vehicle to “make TradFi start to look a lot like crypto”.^[2]

Yet, the risks previously detailed remain real. The ultimate path forward will depend on the ability of these architects, and the Solana ecosystem as a whole, to navigate this inherent tension—harnessing the immense power of institutional capital without succumbing to the centralizing forces that often accompany it.

Conclusion: The God from the Machine

The question was whether the Solana Digital Asset Treasury is the ultimate Trojan horse for mainstream adoption or a gilded cage for decentralization. After examining the machine from every angle, the answer is not a simple verdict, but an observation of its inherent nature: it must be both.

It is undeniably the most potent tool yet devised for bridging Wall Street to the on-chain world, solving real problems of access and legitimacy for institutional capital. Yet, its very mechanics introduce new financial fragilities and centralizing pressures—the ghosts in the machine—that run counter to the ethos of the networks it inhabits. The ultimate outcome, therefore, seems to hinge less on the design of the machine itself and more on the wisdom and discipline of its architects as they navigate this fundamental tension.

The machine has been lowered onto the stage, the plot has been irrevocably changed, and now, the entire world of finance is watching to see what the god from the machine does next.

Subscribe now

If you found this article helpful, please consider liking and sharing it. If you spot any inaccuracies or have suggestions for improvement, feel free to leave a comment. Together, we can uphold the quality and usefulness of the information we share.

Connect with me on X: @angry__pacifist

References

1. Upexi CEO & CSO break down their Solana treasury strategy

2. The Solana Treasury Bet: From Balance Sheets to Ecosystem Flywheel - TOKEN2049 Singapore 2025

3. Institutional Flows into Digital Assets - TOKEN2049 Singapore 2025

4. Inside Pantera’s $500M Solana Treasury Play, with Cosmo Jiang, GP at Pantera Capital

5. Insider Buys $1.5B Solana! Is SOL Becoming Wall Street’s Favorite Bet?| Kyle Samani

6. Creating The World’s Leading Solana Treasury Company

7. Forward Industries Now Holds More Than 6.8 Million SOL Tokens as It Commences Solana Treasury Strategy

8. Forward Industries, Inc. (FORD) Valuation Measures & Financial Statistics

9. The SEC Launches “Project Crypto”

10. Solana Company (NASDAQ:HSDT), Formerly Helius, Continues Amassing SOL, the Native Asset of Solana Blockchain

11. Solana Company (HSDT) Valuation Measures & Financial Statistics

12. DeFi Development Corp. Announces $125 Million Equity Raise to Accelerate Solana Treasury Growth

13. DeFi Development Corp. Announces $5 Billion Equity Line of Credit

14. DeFi Development Corp. (DFDV) Valuation Measures & Financial Statistics

15. Scaling Solana for the Public Markets with Leah Wald and Max Kaplan of Sol Strategies

16. Solana’s HFT Problem | Rightcurve ep. 05

17. SOL Strategies Announces Purchase of 88,433 SOL from LIFE Offering Proceeds

18. SOL Strategies September Monthly Business Update

19. Upexi

20. Is Solana a Better Treasury Asset Than Bitcoin & Ethereum?

21. Press Releases :: Upexi, Inc. (UPXI)

22. Upexi, Inc. (UPXI) Valuation Measures & Financial Statistics

23. Solmate CEO Marco Santori on its Solana bet

24. Wall Street Finds Its Solmate: Brera Holdings PLC (NASDAQ: BREA) Announces Oversubscribed $300 Million Private Placement to Fund Establishment of Solana Digital Asset Treasury Backed by Ark Invest and UAE Investors

25. Solmate Infrastructure (SLMT) Makes Historic Purchase of Discounted $SOL from the Solana Foundation as Cathie Wood’s Ark Invest Discloses Significant Position | Nasdaq

26. Marco Santori on X

27. Brera Holdings PLC (SLMT) Valuation Measures & Financial Statistics

28. Solana Price: SOL Live Price Chart, Market Cap & News Today | CoinGecko

29. Strategic SOL Reserve

30. Cloakd on X

31. Solana Beach

32. Babylon - Staking Dashboard

33. Ethereum (ETH) Staking Rewards: Earn ∼2.87%

34. Solana (SOL) Staking Rewards: Earn ∼7%

35. Kamino Finance

36. Aavescan

37. XRP News: Institutions Embrace CME’s XRP and Solana Futures

38. The Rise of Digital Asset Treasuries - TOKEN2049 Singapore 2025

39. Nakaflow

40. mert | helius.dev on X

41. Introducing BAM: The Future of Block Building on Solana

42. Solana IMprovement Documents (SIMDs) describe proposed and accepted changes to the Solana protocol.

43. Solana Governance: A Comprehensive Analysis

44. canary marinade solana etf s-1/a

45. Omid Malekan on X

46. Inside the $19B Flash Crash | insights4.vc

47. Solana’s Rise as a Treasury Powerhouse: DeFi Development Corp’s Bold Strategy

48. $1.6 Billion Solana Treasury Bet: Biggest Signal Yet?

49. Strive to acquire Semler Scientific at 210% premium, adds 5,816 Bitcoin

This isn't me disrespecting a new and undeniably effective skill. I’m drawing a sharp, necessary line between the timeless craft of writing—the artisan's work—and the new science of performance marketing—the technician's expertise—before we mistake one for the other.

The Core Distinction: Why We Need New Language

Let's begin with precision:

• A Niche is the what. It's your subject matter, your industry, your specific field of expertise. Think "Web3 content," "SaaS marketing," or "ancient history."

• A Skill Set is the how. It's the craft you employ to communicate your message—be it copywriting, journalism, or long-form analysis.

This is where the confusion begins. "Thread writer" is not a niche. Nobody wakes up passionate about "threads." It is a skill set, a highly specialized method of communication tailored for a very specific platform. To call it a niche is like calling "Microsoft Word User" a niche for a novelist. The tool defines the method, not the domain of expertise.

And this distinction leads us to a fundamental shift in purpose:

• In traditional writing, the message is the master. The writer selects the format (article, essay, book) that best serves the integrity, depth, and clarity of their idea. The format is a vehicle for the message.

• In thread writing, the platform is the master. The writer's primary constraint is not the idea itself, but the architecture of the platform—its character limits, UI, and, most importantly, its algorithm, which rewards continuous, fragmented interaction. Here, the message is refactored to serve the platform's demands.

The Anatomy of an Engagement Farm

To understand why this is performance marketing, we must dissect the thread itself. It is not designed primarily for holistic information transfer, but for a sequence of engagement triggers:

1. The Hook: Always a hyper-optimized, vague, clickbait promise designed to exploit curiosity. Not a literary opening. This is a copywriting formula engineered to stop the scroll.

2. The Pacing & UI Manipulation: Ideas are atomized into single-tweet fragments. Excessive line breaks and short sentences are not for stylistic elegance; they manipulate the mobile interface, forcing more scrolling and screen time, feeding the algorithm signals of engagement.

3. The Content Aggregation: Often, the "research" claimed for threads is a skillful summary or repackaging of information already published elsewhere. It's content aggregation, artfully presented, rather than original investigation or deep analytical thought.

4. The Call to Action (CTA): Threads rarely end with a thoughtful conclusion that leaves the reader in contemplation. They conclude with a demand: "Retweet," "Follow," "Click this link." This is the unmistakable endpoint of a marketing funnel, not a narrative arc.

The thread, in its very structure, is a meticulously crafted sequence of psychological prompts designed to cultivate interaction. It is not marketed; it is marketing.

Addressing the Misconceptions: Purpose vs. Performance

Let's tackle the common rebuttals head-on, because they often stem from a confusion of effort for purpose, or components for the whole:

• "But isn't all writing just marketing these days?" This is a lazy oversimplification that confuses a component with the primary purpose. A world-class chef uses a stove (a tool), but cooking is not "stove operation." A brain surgeon uses instruments (tools), but surgery is not "tool handling." Yes, an article, like a gourmet meal or a life-saving surgery, needs to be "marketed" to be seen. But the marketing serves the work. For an engagement thread, the "work" serves the marketing. The hierarchy is reversed.

• "But threads are more engaging than a boring article!" "Engaging" is a metric, not a measure of quality or purpose. A movie trailer is far more "engaging" than the full two-hour film; its entire purpose is to be an advertisement. But the trailer is not the movie. A thread is the trailer—a performance designed solely for attention—not the complete, self-contained "film" of an article. Equating their engagement is to mistake the advertisement for the art itself.

• "But it requires immense creativity, skill, and research!" Absolutely. The skill is undeniable. But the key distinction is whether that skill is foundational or system-dependent. It's the difference between a world-class DJ and a classically trained Musician. The DJ is a master of a specific system—the turntables, the mixer—and can expertly blend pre-existing tracks into a seamless performance. But the Musician understands the foundational principles of music theory and composition. They can create something new in any context. Both are skilled, but one masters a foundational craft, while the other masters a specific system. The thread writer is a highly skilled technician of a specific platform.

The Bigger Picture: Career Fragility and the Future of the Artisan Writer

This isn't an academic debate; it has profound implications for a writing career. I see it as the fundamental distinction between the Artisan Writer and the Technician Writer:

• The Artisan Writer cultivates foundational skills: deep research, critical thinking, nuanced argumentation, compelling storytelling, and the ability to structure a cohesive narrative. These skills are portable and platform-agnostic. They are the carpenter, capable of building anything.

• The Technician Writer cultivates hyper-specialized skills for a specific platform's algorithm and psychology. They are experts at generating immediate, measurable engagement.

My concern is simple: When a writer builds their entire identity and career on mastering the algorithm of a single platform, they are building on rented land. What happens when the platform changes its algorithm, loses popularity, or simply disappears? The Technician's entire playbook becomes obsolete overnight. The Artisan, however, with their deep, portable skills, can adapt, learn new tools, and continue their craft on any new medium.

Conclusion: A Defense of the Craft

Let me reiterate: I am not "dunking on" or "looking down" on thread writers. I am defending the foundational integrity of the word "writer" itself.

There is an incredibly valuable place for the skilled individual who can strategically leverage a platform for attention and growth. Let's call them what they are: "Digital Marketing Specialists," "Growth Hackers," "Audience Acquisition Experts," or "Platform Performance Strategists." These are honest and respected titles for an undeniable skill.

But we must resist the urge to blur the lines. To confuse a highly effective marketing tactic with the foundational craft of writing is to diminish what writing truly is. It is to mistake the signpost for the destination, the echo for the voice, and the performance for the truth.

What follows is a lightly reconstructed transcript of that talk. I don’t recall every word, but I’ve done my best to capture the essentials from my slide deck.

Why Purpose Matters

Let me begin with a story.

It’s a dark evening. The power has just gone out – NEPA don carry light (sound familiar?). By the glow of a kerosene lamp, my siblings and I huddle around my grandmother. In a calm, spellbinding voice, she begins to tell us a tale. It might be a story about the clever tortoise outwitting the mighty elephant, or a wise hunter in a faraway village. I’m 8 years old, completely enthralled. There’s no TV, no distractions – just the magic of words. By the end of the story, there’s always a lesson: maybe “slow and steady wins the race” or “honesty is the best policy.” I didn’t know it then, but those nights were my first lessons in writing with purpose. My grandmother never used fancy literary terms – she simply had something to say, a message to impart, and she used story to say it.

Why do I share this? Because writing with purpose is as old as our oldest folktales. It’s not some high-tech modern idea – it’s deeply human. It’s the reason a simple story told in the dark can resonate for years. It’s the reason we write. So let me ask you all: Why do you write?
Take a second and think about it. Is it to express yourself? To inform or educate others? To entertain, to inspire change, or maybe to understand the world around you? There’s no wrong answer.

That reason – your “why” – is powerful. It’s the fuel that will keep you going through late nights and writer’s block. And when you infuse that purpose into your writing, something happens: your words gain impact. As the great James Baldwin put it, “You write in order to change the world… The world changes according to the way people see it, and if you alter even by a millimeter the way people look at reality, then you can change it.”

Think about that – even a millimeter of change in someone’s perspective can be world-changing. Maybe your poem won’t topple governments, but if it helps one person see something in a new light, you’ve done something profound.

For me, sitting in that lantern-lit room as a child, my world did change, millimeter by millimeter, with each story. I learned about kindness, bravery, cunning – not through lectures, but through narrative. Purpose in writing doesn’t have to be grand or preachy; it can be as simple as leaving your reader a little better than you found them.

I always say there’s a writer in everyone. Not just in published authors or grammar geeks.
But in every person who’s ever had something to say but didn’t know how to say it. Writing with purpose isn’t about being perfect. It’s about being honest — and bold enough to put that honesty into words.

Now, writing with purpose also means writing what truly matters to you. Toni Morrison once said, “If there’s a book that you want to read, but it hasn’t been written yet, then you must write it.”. I love that quote. It says that your voice matters, that the stories or topics you yearn for are exactly the ones you should be creating. Don’t we all have a story or an idea that we wish was out there? That is your purpose knocking at the door. Open it.

Sometimes, writing with purpose is also about reclaiming our own narratives. There’s a proverb Chinua Achebe popularized: “Until the lions have their own historians, the history of the hunt will always glorify the hunter.” In other words, if we don’t tell our stories, someone else will – and they might get it wrong. As Nigerian writers, or wherever you’re from, we have perspectives that only we can authentically share. Whether you’re writing about your hometown, your culture, your grandma’s recipes, or your personal struggles, you are the lion writing your history. That is purpose.

So, hold on to that why – that sense of purpose. Think of it as the compass for everything you write. When you have a clear purpose, it guides your decisions: what to include, what to research, what to cut, what tone to strike. Purpose will keep you going when you’re tired, and keep your writing honest and focused when a dozen tempting tangents appear. In this talk, I’m going to share how to harness that purpose at two crucial stages of the writing process: research and drafting. These are the less glamorous parts of writing that nobody sees – the digging, the false starts, the messy middle – but they are where your purpose truly comes alive.

So let’s set off on this journey together. First stop: Research – the art of digging deep and gathering the riches that will feed your writing.

Research: Fueling Your Writing with Substance

I know, I know – “research” might sound dry or daunting to some of you. Maybe it conjures up memories of school assignments or endless Googling. But stick with me, because research is nothing more than curiosity in action. It’s asking questions and seeking answers. And when you approach it with the purpose behind your writing in mind, it can actually be exciting – even liberating.

Let’s do a quick show of hands (yes, I’m going to make you work a little!). How many of you love the research part of writing? And how many dread it or get overwhelmed by it? It’s okay, we’re all friends here – no judgment! I see a mix of both. That’s normal.

The key is to make research serve your story, not the other way around. Most people get it wrong. Research is there to empower you, to give you confidence, and to enrich your writing with details and truth. It’s not there to bury you in irrelevant facts or procrastination. Trust me, I’ve fallen down the “rabbit hole” more times than I can count – like when I was writing a short story about my time in Lagos. I needed it to be factual and backed by data, but ended up reading academic papers on 19th-century trade routes. Fascinating? Yes. Useful for that particular story? Not one bit! I had strayed off purpose.

So, how do we research with purpose? Here are a few strategies that have helped me (and might help you):

• Start with your questions: Begin by asking, “What do I need to know to tell this story effectively?” Make a list of questions. For example, if you’re writing a historical piece, you might ask: When and where did this event happen? What did people wear, eat, believe then? If you’re writing a personal essay, you might need to research statistics to support your experience, or simply reflect on your own memories (yes, memory is a research tool too!). Starting with specific questions focuses your research.

• Use diverse sources: Don’t just rely on Google or Wikipedia (though those can be fine for a start). Think of books, newspapers, academic articles, documentaries, interviews with real people, even songs and oral histories. If you’re writing fiction set in a real place, try to visit or at least watch videos about it; if you can’t, read travel blogs or speak to someone who lives there. Are you writing about a science topic? Maybe find a YouTube lecture or ask a scientist on Twitter. Mixing sources will give you a richer picture. And importantly – especially as Nigerians and Africans – include sources from our perspective, not just foreign ones. When I researched the Biafran War for a story, reading Western historians was fine, but talking to my uncle who lived through it was invaluable. That’s where the real insights came – the smell of the air, the songs they sang to keep hope alive. Those details can make your writing soar.

• Stay organized: I cannot emphasize this enough. You’ll gather a ton of nuggets and facts; find a system to keep track. Maybe you have a dedicated notebook or google doc where you jot down key points. Some writers use index cards, some have fancy apps (In Turbin3, I learnt to use Zotero) – use whatever works for you, but don’t rely on your memory alone. If you find a juicy quote or a statistic, note it along with the source. Not only will this save you from plagiarism pitfalls, it will also help later if you need to fact-check. Personally, I keep a folder for each project with sub-notes like “Character backgrounds,” “Setting details,” “Cool facts to possibly use.” It sounds nerdy, but when you sit down to write, Future You will thank Past You for that neat organization.

• Know when to go deep (and when to stop): Here’s a trick: identify a few core areas where you need deep knowledge, and be okay skimming the rest. If you’re writing a medical drama, you’d better get the hospital details right (deep research), but do you need to read the entire 300-year history of medicine? Probably not. Go deep on what directly impacts your story’s credibility and skip or lightly research what doesn’t. And remember, you will never know “everything.” At some point, you have to put down the books and turn on the writing lamp. If you find yourself researching endlessly as a way to delay writing (been there!), remind yourself of your purpose. You’re not researching for a PhD thesis; you’re researching to tell a story or make a point. Once you have enough to do that authentically – start writing. The rabbit hole has no bottom, so climb out when you’ve got what you need.

• Stay open to discovery: While you want to stay focused, also allow for the happy surprises research can bring. Some of the best ideas in your piece might come from serendipitous findings. Maybe a tiny footnote gives you a plot idea, or a photo you find sparks an emotional scene. Let purpose be your guide, but don’t wear blinders – sometimes your story’s purpose evolves because of something you uncovered. That’s the beauty of creative research: it’s part discovery, part design.

Notice something about all these tips: they’re about making research serve your story’s purpose. We’re not collecting facts for the sake of it. We’re filling the well so that when we write, we’re drawing from rich, authentic water. Readers can tell when a writer has done their homework – the story feels immersive and credible. And readers can definitely tell when a writer wings it and gets a detail wrong (nothing pulls you out of a story faster than, say, a novel that sets Lagos in South Africa – yikes!). Research is how we show respect to the reality we’re writing about, and to our readers’ trust.

Let me share a quick anecdote. A friend of mine (I’ll call him Tunde) decided to write a short story about a fisherman in a small Nigerian coastal town. (Say Calabar) Tunde had never been to that town. He had a great plot, compelling characters, but when I read his first draft, something felt… off. The details were generic – palm trees, “the ocean breeze,” and jollof rice for dinner. Now, I love palm trees and jollof, but I couldn’t tell if this story was set in Badagry or Barbados. I asked him if he had researched the town – its unique customs, maybe the local slang or what fish they catch there. He admitted he hadn’t. So he went back, interviewed a cousin who’d lived there and did a bit of reading. In his next draft, the village came alive: I could smell the roasting prawns by the beach, hear children playing suwe (hopscotch) by the shoreline, and when a character spoke, he said "Abeg, no fall my hand!" – something authentic. It was the same story, but the purpose – showing the richness of that local life – now shone through, all because of a bit of research.

That’s what I mean by research fueling your writing. It’s not about dumping all those facts on the page – it’s about selecting the right ones that ignite your reader’s imagination or strengthens your argument. You’re curating reality to support your purpose.

Before I move on, I want to acknowledge: research can feel intimidating. You might think, “I’m just an amateur writer, I’m not a scholar or journalist.” But you don’t have to be. Start small. Be curious. Enjoy the process. And remember, you’re not in this alone. If you feel stuck, reach out – ask a friend, a librarian, a writing group (we have a wonderful one right here!). Sometimes a quick conversation can save you hours of Googling.

Alright, now you’ve gathered your material – your brain (and notebook or Google Doc) is brimming with ideas, facts, quotes, scenes. You’re pumped with new inspiration and understanding. Now comes the moment of truth: sitting down to write that first draft. This is where many of us hear a little voice in our head go, “Are you sure about this? Can you do it justice? What if it’s no good?” That, my friends, is the sound of doubt — and it visits every writer I know. But we have a secret weapon: we have purpose, and we have all this great research which gives us confidence. Now we need to transform that raw material into something real on the page.

So… let’s talk about drafting.

Drafting: From Shitty First Draft to Polished Purpose

Ah, the first draft. Is there anything simultaneously more exhilarating and terrifying? It’s like standing at the foot of a mountain you decided to climb. You’re excited to reach the top, but also thinking, “What was I thinking? There’s no way up this thing!” If you’ve ever opened a blank document and promptly felt the urge to run away and arrange your shoe rack instead, you’re not alone.

Let’s break the tension with a bit of wisdom (and humor) from writers who’ve been there. Ernest Hemingway, a man known for his no-nonsense prose, famously said: “The first draft of anything is shit.”(Pardon my language, that’s Hemingway, not me!). Blunt, but freeing, isn’t it? And the wonderful Terry Pratchett said, “The first draft is just you telling yourself the story.” I often share these quotes with writers because it liberates us from the myth that our first draft must be perfect. News flash: it won’t be. And it doesn’t have to be.

So, if you remember nothing else from this section, remember this: give yourself permission to write a bad first draft. In fact, give yourself permission to write a hideous, messy, ridiculous first draft, as long as you write it. Anne Lamott, another brilliant writer, calls this embracing the “shitty first draft” – the idea that you just get it down on paper without judging it. Write with the door closed, as if no one will ever read that draft (because likely, no one will – except maybe a very patient friend or editor down the line).

When I draft, I often imagine I’m back in that dark room with my grandma – no critics, no red pens hovering – just a story that needs telling. I pour it out. Does that mean I magically banish all self-doubt? Oh no, my self-doubt sits right next to me, eating popcorn, whispering, “This is garbage.” I nod and say, “Yes it is, and that’s okay because I’m writing now.” There will be time to make it better, but you can’t edit a blank page.

Now, practically, how do we approach drafting in a way that stays true to our purpose? Here are some strategies and tips, much like we did for research:

• Write fast, write free: When you’re writing that first draft, try to keep your inner editor muzzled. Don’t stop to polish every sentence or check every fact. If you’re on a roll describing a character and you suddenly realize you don’t know what the capital of that country was in 1920, use placeholders. Just write in a bracket “[find capital later]” and keep going. Seriously, I have brackets like that all over my first drafts. Write as if you’re telling yourself the story. Let it flow, even if it’s imperfect. If a section is hard, I sometimes literally write “Blah blah, something happens here – fix later” and move on. Stay in the creative zone. The goal is to get to the end of a draft with your core story or argument in place.

• Reconnect with your purpose often: As you draft, occasionally pause and ask, “What am I really trying to say here?” It’s easy to get caught up in the weeds – a flashy metaphor here, a witty aside there – and suddenly you’ve wandered off track. Gently steering yourself back to your main purpose will help your draft stay cohesive. One technique: write your story’s or essay’s purpose in one sentence on a sticky note and stick it to your writing desk or at the top of your document. Maybe it’s “Show how hope persists even in war” or “Explain the impact of social media on mental health with honesty and humor.” When you get stuck or lost, glance at that guiding sentence. It’s your North Star.

• Embrace the mess (then step back): Your first draft will likely be messy – not just in prose quality, but in structure. That’s fine. Once you have that ugly fucking draft, take a break. Seriously, step away. A few hours, a day, a week – whatever you can afford. This creates a little distance so you can come back with fresh eyes. When you do, read it through from start to finish if you can, without tweaking anything at first. Note where the heart of it is shining and where it’s muddled. Maybe section 2 is brilliant but section 3 is a snooze-fest – that’s okay. Maybe your article’s introduction meanders – mark it. At this stage, big-picture thinking is key. Ask yourself: Does this fulfill the purpose I intended? Is the message or story clear? Where do I feel the most emotion or interest as a reader of my own work? Those are likely the parts closest to your purpose. And where do I get bored or confused? Those might be places you lost sight of the purpose or didn’t know what you wanted yet.

• Revise with intention: Now we get into rewriting – which is writing, too! In revision, you are the sculptor chipping away at the stone, revealing the art that was always inside. This is where you align your draft with your purpose more tightly. You might cut out brilliant but irrelevant passages (yes, kill those darlings, ouch). You might realize you need a new scene that supports the theme. Perhaps your characters’ dialogue isn’t conveying the right tone – tweak it. This is the time to dig deep. Remember that quote: “The first draft reveals the art; revision reveals the artist.” That is, in revision you get to be intentional about every choice. It’s hard work, but also where you truly craft your piece into something that resonates. Here, also consider feedback – a trusted friend or fellow writer can give you perspective on whether your story is hitting its mark. They might say, “I really love the part where X happens,” and you realize that’s the core and you should emphasize it more. Or they might gently point out, “I’m not sure what the main point is in this section,” which is a cue to clarify or cut. Revision is where your purpose and your storytelling techniques marry each other.

• Polish last: When the structure and content feel solid – then you can polish. Correct grammar, find the perfect word instead of that placeholder, fix the timeline details, double-check your facts from research. It’s important, but if you polish too early, you might end up with beautiful sentences that ultimately get cut entirely. (And that hurts more if you spent an hour perfecting them early on!). So save the fine-tuning for the end. That said, some folks polish a bit as they go – do what works for you, but just beware of getting stuck on polishing at the expense of finishing. You can’t publish or share a half-draft no matter how lovely section 1 is. Better to have a complete piece that’s 80% there, then refine it to 100%.

By now, I hope you’re realizing — research doesn’t belong to scholars. Drafting isn’t just for novelists. These tools? They’re for everyone who has a voice. Everyone who has something worth shaping.

So let me say it again — there’s a writer in everyone. And research? Drafting? That’s just the chiseling. The writer’s already in there.

Let me tell you about one of my own drafting experiences to illustrate these points. A few years ago, I was writing an essay for a mini blog about the importance of local languages in education. I had so much passion for the topic (being a Nigerian who studied in English but spoke pidgin at home, it was personal). I researched statistics, I had anecdotes – I was ready. And yet, when I sat down to write, I froze. Why? Because I desperately wanted it to be perfect. My purpose was so important to me that I started second-guessing every sentence. I wrote one paragraph in an hour – and it was awful, stilted, over-thought. I felt defeated. The next morning, I remembered the advice I’d given to others (funny how we forget to take our own advice): just write a “letter” to a friend about this. Essentially, tell myself the story. I literally opened a new doc and started with, “Dear Tunde, I want to tell you why it matters that kids learn in their mother tongue…” I pretended I was talking to my friend. And the draft flowed – it was informal, raw, full of typos and some all-caps when I got excited, but it was authentic. From that messy draft, I then extracted an outline, rearranged points, added a stat here, a proverb there. After several rounds, I had a polished essay.
When it was published, I got messages from readers saying it moved them, that they saw their own childhood in it. That was the best feeling in the world – not because my sentences were grammatically correct (though yay, they were), but because the purpose of the piece shone through and connected with people. And it only happened because I allowed myself to draft freely first and polish later.

So, to sum up the drafting stage: be brave in writing that first version, and be ruthless in revising it. Your writing becomes powerful when you combine the heart and the head – the heart is the first draft, the head is the editing. Don’t expect yourself to do both at the same time perfectly.

Alright. We’ve talked about purpose – your why. We’ve talked about research – digging for treasure and truth to feed your writing. We’ve talked about drafting – getting the words down and then sculpting them into shape. Now let’s bring it all together before we conclude.

Bringing It All Together: Writing with Purpose, Every Step of the Way

At the heart of it, writing with purpose means being intentional at every stage: before you write, while you write, and after you write. It’s a continuous thread. Your purpose is like a friendly ghost hovering around – whispering in your ear, sometimes rattling the table to get your attention when you stray!

When you choose what to research, you’re deciding what knowledge will shape your story – that’s purpose. When you’re drafting, every scene or paragraph you choose to include (or cut) is guided by what you want the reader to feel or understand – that’s purpose. When you revise, you’re literally honing in on that purpose, sharpening it so it pierces the reader’s heart or mind exactly as you intend.

I want to emphasize something: Your purpose can evolve, and that’s okay. Maybe you start writing a piece thinking your purpose is to argue X, but through research and drafting you discover Y is actually the real heart of the piece. That’s beautiful – it means you’ve learned something. Don’t be afraid to follow that. Writing is a form of thinking. As the novelist Flannery O’Connor said, “I write because I don’t know what I think until I read what I say.” Sometimes we only uncover our true purpose by writing. So if that happens, refine your approach and let the new purpose lead.

At the same time, if you have a burning message from the start, fight for it. Don’t let it get lost in the noise. If you’re writing a novel about love and you realize your fancy subplots are overshadowing the love story, be brave to cut them out and spotlight what matters. If you’re writing a blog to raise awareness on climate change and find yourself spending pages on a funny travel anecdote that’s off-topic, maybe save that for another piece. Serve the purpose.

Think of the books, articles, or speeches that have moved you deeply. They were written with purpose, right? That author or speaker had something they needed to share. You could feel it. It’s like a song that hits the right note – it stays with you. That’s what we’re aiming for. Not every piece will save a life or spark a revolution, but each time you write with clarity of intent, you are contributing something meaningful to the world.

Earlier, I talked about my grandmother’s folktales. Let’s return to that image for a moment. A humble old woman, with no fancy education, certainly no internet, managed to imprint life lessons on a bunch of rowdy kids using nothing but words and voice. She didn’t need a research database or a drafting workshop – though, who knows, maybe in her head she reworked the telling each time to make it better! The point is, heart and purpose were at the core. We, with all our modern tools and techniques, are just continuing that tradition. We owe it to ourselves and to our heritage to tell stories that matter, to write with the kind of heart that a grandma telling a folktale has – but also using all the craft we can muster to make sure it lands.

As we close, I want to leave you with a powerful thought from, fittingly, an African female writer whose work embodies purpose: Chimamanda Ngozi Adichie. She said, “Stories have been used to dispossess and to malign, but stories can also be used to empower and to humanize. Stories can break the dignity of a people, but stories can also repair that broken dignity.”. Stories matter, she reminds us. Your stories matter. They can heal, they can bridge gaps, they can shine a light in darkness.

Toni Morrison, whom I quoted earlier, also said, “We speak, we write, we do language. That is how civilizations heal.”. I get goosebumps every time I read that. It underscores that what we do as writers is not trivial – it is, in fact, the way societies mend and grow. Writing with purpose is part of that healing and growing.

So, as you leave here and continue on your writing journey, I encourage you to carry these three things with you:

1. A clear purpose – your unique reason for writing each piece.

2. A researcher’s curiosity – the courage to ask questions and seek truth to deepen that piece.

3. A reviser’s patience – the humility to rewrite and refine until your work truly speaks what’s in your heart.

With those tools, your pen becomes mighty. With those tools, your writing will not just be words on a page – it will be a message, a gift from you to whoever reads it.

Remember the title of this talk: The Art of Writing with Purpose. Art and purpose go hand in hand. Your art, your writing, becomes so much more impactful when it has purpose. And your purpose finds its fullest expression when you apply it through the art and craft of writing.

In the spirit of the event we’re in – Pen, Purpose & Power – I want you to leave feeling that your pen holds your purpose, and in that combination lies your power. The power to change a mind, to comfort a heart, to entertain, to educate, to leave a mark on the world – even if it’s “by a millimeter” as Baldwin said.

Thank you for sharing this time with me. I can’t wait to see what meaningful, purposeful writing you all will create. Keep the fire burning, keep that research going, keep those drafts coming. Your stories matter, and the world needs them.

‘There’s a writer in everyone.’ — And today, you’ve met yours.

Thank you!

Subscribe now

Connect with me on X: @angry__pacifist

This research piece examines six distinct industries and the pressing problems they face today. For each case, we detail the challenges, assess whether Solana’s high-speed, low-cost blockchain technology is the right tool, and compare its advantages over current systems. Each section provides technical, business, and operational analysis, backed by numerous references.

1. Medical Record Interoperability

Problem

Fragmented healthcare: hospitals and clinics use incompatible electronic medical record (EMR) systems, causing delayed care and duplicated tests. For example, 34% of U.S. patients experience errors during referrals due to poor data sharing.

Centralized databases are vulnerable to breaches, and strict regulations (e.g., HIPAA, GDPR) complicate cross-institutional data access.

Solana’s Solution

• Decentralized Health Data Network: Solana’s blockchain can enable real-time updates of patient records across institutions. Its 65,000+ transactions per second (TPS) and 400ms block times can allow instant synchronization of data, reducing delays in critical care.

• Privacy Mechanisms: Zero-knowledge proofs (ZKPs) or cryptographic access control (e.g., role-based permissions via programmable contracts) can ensure only authorized providers access patient data.

• Interoperability: Solana blockchain can act as a universal layer, integrating with existing EMR systems (e.g., Epic, Cerner) through APIs. For example, Hospital A in this case study achieved seamless data sharing by linking Solana to legacy systems.

Past Attempts

1. MediBloc

   • Problem: Aimed to unify fragmented healthcare data but faced technical limitations.

   • Blockchain Architecture: Built on Cosmos SDK/Tendermint, with negligible fees (~$0.001 per transaction).

   • Why It Struggled:

     • Throughput capped at ~1,000 TPS, insufficient for real-time medical data sharing.

     • Hospitals resisted replacing legacy systems.

2. Hyperledger Fabric

   • Problem: Designed for secure healthcare data sharing among institutions.

   • Blockchain Architecture: Permissioned network requiring centralized consortium approval.

   • Why It Struggled:

     • Real-world deployments (e.g., Synaptic Health Alliance) achieved only ~500 TPS due to complex access controls.

     • Could not integrate with external systems, creating new data silos.

Feasibility

• Technical:

  • Solana’s compression techniques (e.g., state compression, archival nodes) can reduce storage costs for large medical datasets.

  • Integration with zero-trust architecture (ZTA) and AI-driven intrusion detection systems (IDS) enhances security, as proposed in the blockHealthSecure framework.

• Business:

  • Adoption hinges on partnerships with EHR vendors. EHR giants like Epic (28% U.S. market share) and Cerner (24%) act as gatekeepers to hospital data. Integration with their systems is non-negotiable for adoption.

  • A hypothetical collaboration with Teladoc Health could use Solana to timestamp and hash remote patient monitoring data (e.g., glucose levels), accessible to EHRs via FHIR APIs.

• Regulatory:

  • Solana’s immutable audit trails comply with HIPAA/GDPR.

  • Solana’s immutable timestamps satisfy HIPAA’s 6-year record retention rule. However, blockchain immutability clashes with GDPR’s “right to erasure.”

    • Solution: Store raw data in GDPR-compliant cloud storage (AWS HealthLake) and only hash on-chain. Deletion requests remove cloud data, leaving non-PHI hashes intact.

Potential Challenges:

• Epic’s 40-year-old codebase complicates blockchain integration.

• Medical devices (e.g., pacemakers) transmitting data to Solana require FDA 510(k) clearance. No blockchain-integrated device has been approved to date.

• FDA guidelines for blockchain medical devices won’t emerge until 2026 (per HHS).

• EHR companies monetize data siloes (e.g., Epic charges $0.10 per API call). Solana must prove cost savings (e.g., reducing duplicate testing, which wastes billions of dollars per year).

• Without vendor buy-in, Solana's solution risks becoming another MediBloc—technically sound but unused.

2. Pharmaceutical Anti-Counterfeiting

The Problem

• Scale of Counterfeiting:

  • 10% of global medicines are substandard or falsified, contributing to 500,000+ annual deaths from fake malaria and tuberculosis drugs alone (WHO).

• Economic Impact: Counterfeits cost the pharmaceutical industry ~$150B annually, with supply chain gaps enabling fake drugs to infiltrate legitimate distribution channels.

Current Solutions Fall Short:

• RFID Tags: Expensive ($0.10–0.50 per unit) and require specialized scanners, making them impractical for low-cost generics.

• Fragmented Systems: Regional track-and-trace frameworks (e.g., EU’s FMD, U.S. DSCSA) lack interoperability, creating blind spots in global supply chains.

Solana’s Solution

1. Batch NFT Minting: At production, each drug batch receives a Solana NFT containing:

   • Unique identifier (e.g., GTIN + serial number).

   • Manufacturer details.

   • Timestamped production/expiry dates (via Proof of History).

2. QR Code Verification: Pharmacies scan QR codes on packaging to check the NFT’s on-chain history. A mismatch (e.g., expired batch, duplicate serial number) triggers alerts.

3. Granular Tracking: Solana’s $0.002 fees enable tracking down to individual pill bottles, not just pallets.

Technical Advantages:

• Speed: 65k TPS processes millions of verification requests in real time (vs. IBM Hyperledger’s 500 TPS).

• Interoperability: Public ledger allows regulators, hospitals, and pharmacies to access the same data without permissioned gates.

Past Attempts

• IBM Hyperledger & DSCSA:

  • Closed Ecosystem: IBM’s Drug Supply Chain Security Act (DSCSA) solution used Hyperledger Fabric, restricting participation to vetted partners. Small pharmacies and developing-world suppliers were excluded.

  • Cost: Hyperledger’s $1–5 per transaction made unit-level tracking prohibitive.

• Walmart’s Blockchain Pilot:

  • Success: Walmart reduced inspection time by 97% using Hyperledger to trace mango shipments. However, scalability limitations prevented expansion to pharmaceuticals.

Why They Failed:

• Centralization: Permissioned chains like Hyperledger replicated existing trust hierarchies.

• Cost: High fees made item-level tracking economically unviable.

Feasibility

• Technical:

  • Proven Use Case: Solana’s NFT standard (Metaplex) already supports 10M+ tokens in gaming/collectibles. Adapting this for pharma requires minimal code changes.

  • Privacy: Zero-knowledge proofs (e.g., Light Protocol) can hide sensitive data (e.g., batch locations) while proving authenticity.

• Business Feasibility:

  • Regulatory Tailwinds: FDA’s 2023 DSCSA mandate requires unit-level traceability by November 2024, forcing pharma companies to adopt new systems.

  • Cost Savings: Solana’s $0.002 per transaction is 500x cheaper than Hyperledger, enabling unit−level tracking for generics (e.g., $0.002 per bottle vs. $1+).

Potential Challenges:

• Adoption Incentives: Manufacturers need ROI beyond compliance.

• Global Coordination: Competing regulatory frameworks (EU FMD vs. U.S. DSCSA) require interoperable standards.

3. Tamper-Proof Voting Systems

The Problem

• Electoral Integrity Challenges:

  • Fraud Allegations: 40–45% of Americans distrust election results, fueled by vulnerabilities in mail-in ballots and centralized electronic systems.

  • Attack Vectors:

    • Mail-in Ballots: Susceptible to interception, forgery, or “ballot harvesting” scams.

    • Centralized Databases: State voter rolls can be hacked or manipulated (e.g., 2016 Illinois voter database breach).

• Global Impact:

  • Developing Nations: Countries like Nigeria, Kenya, and Brazil face violent post-election disputes due to opaque tallying processes.

Solana’s Solution

1. Voter Authentication: Citizens verify identity via government-issued credentials (e.g., mobile driver’s licenses) tied to zero-knowledge proofs (ZKPs) to anonymize identities.

2. Vote Submission: Votes are encrypted, hashed, and timestamped via Solana’s Proof of History (PoH), creating an immutable audit trail.

3. Tallying: Votes are counted on-chain in real time, with results auditable via public explorers (e.g., Solscan).

Technical Advantages:

• Throughput: Solana’s 65,000 TPS can process 200M votes in <1 hour (200M ÷ 3,600 seconds = ~55,556 TPS).

• Cost: $0.002 per transaction enables free voting for citizens.

• Transparency: Public ledger allows third-party audits without revealing voter identities.

Example Workflow:
Solana Beach, CA Pilot (Hypothetical):

1. Voters authenticate via state ID app.

2. Cast votes via mobile dApp, generating a ZKP-anonymized ballot.

3. Votes are hashed and recorded on Solana.

4. Results publish instantly, with cryptographic proof of integrity.

Past Attempts

• Voatz (U.S.):

  • Architecture: Permissioned blockchain with biometric authentication.

  • Failure: Crashed during 2020 West Virginia primaries at 15 TPS, disenfranchising remote military voters.

  • Criticism: Closed-source code and reliance on centralized validators undermined trust.

• Moscow’s Blockchain Voting (2019):

  • Opacity: Authorities refused to release source code or audit logs, leading to accusations of tampering in city council elections.

  • Centralization: Votes were processed on government-controlled nodes, defeating decentralization’s purpose .

Why They Failed:

• Scalability: Systems buckled under real-world voter loads.

• Trust Deficits: Closed ecosystems and lack of transparency bred suspicion.

Feasibility Today

• Technical Feasibility:

  • Anonymity: Projects like Light Protocol enable ZK-proofs on Solana, separating voter identity from ballot content.

  • Security: Solana’s Sealevel runtime isolates voting programs from network vulnerabilities.

• Business Feasibility:

  • Regulatory Hurdles: U.S. Election Assistance Commission (EAC) bans internet voting for federal elections due to hacking risks.

  • Public Trust: 67% of voters oppose blockchain voting until open-source audits are standard.

Challenges:

• Sybil Attacks: Preventing fake identities without compromising privacy.

• Recounts: Immutable logs complicate legal challenges (e.g., no way to “re-run” an election).

4. Decentralized Energy Grids

The Problem

• Renewable Energy Tracking Challenges:

  • Micro-Producer Boom: Over 3 million U.S. households now have solar panels, but legacy grids struggle to track small-scale contributions. Manual meter readings and centralized databases lead to billing errors and delays.

  • Double-Counting Risks: Renewable Energy Certificates (RECs) are often fraudulently claimed across regions due to poor auditing, undermining carbon offset markets.

  • Grid Instability: Real-time fluctuations in solar/wind output require second-by-second tracking to balance supply/demand—a task impossible for analog systems.

• Economic Impact:

  • Lost Revenue: Micro-producers lose ~15% of potential earnings due to inefficient settlement systems.

  • Delayed Incentives: Government solar rebates take 6–18 months to process via legacy systems.

Solana’s Solution

Project Zero Workflow (Hypothetical):

1. Smart Meter Integration: IoT devices (e.g., Tesla Powerwalls) record energy contributions in 5-second intervals.

2. Tokenization: Each kWh fed into the grid mints a SOL-based token (e.g., 1 kWh = 0.1 SOL), timestamped via Proof of History.

3. Real-Time Trading: Tokens are traded peer-to-peer on DEXs (e.g., Raydium) or sold to utilities via Solana programs.

Past Attempts

• Brooklyn Microgrid (2016–2021):

  • Architecture: Ethereum-based P2P energy trading among 50+ households.

  • Failure: 50+ monthly fees per user made microtransactions (e.g., 0.10/kWh trades) unsustainable. Users switched to centralized apps like LO3 Energy.

  • Technical Debt: Batching transactions introduced 3–5 day delays, defeating real-time goals.

• Power Ledger (Australia):

  • Outcome: Despite $8M+ in funding, its Ethereum sidechain couldn’t scale.

  • Note: Power Ledger has recently integrated with Solana, harnessing its network for product capabilities.

Why They Failed:

• Cost: Ethereum’s fees devoured profits from small-scale trades.

• Speed: Slow settlement times mismatched energy’s real-time needs.

Feasibility Today

• Technical Feasibility:

  • Hardware: 90% of U.S. smart meters (e.g., Landis+Gyr) now support API integration with blockchains.

  • Regulatory Progress: FERC Order 2222 (2021) mandates U.S. grids to integrate decentralized energy resources by 2026, creating legal pathways.

• Business Feasibility:

  • Deregulated Markets: Texas (ERCOT), the EU, and Australia allow P2P energy trading. ERCOT’s 2023 trial saw 89% participant retention.

  • Corporate Demand: Google and Microsoft now require hourly-matched renewables for data centers—Solana’s granular tracking meets this need.

Challenges:

• Grid Upgrades: Utilities must adopt blockchain-compatible inverters (200–200–500 per household).

• Policy Gaps: Most U.S. states lack clear rules for on-chain REC trading.

5. Academic Credential Fraud

The Problem

• Scale of Fraud:

  • 30% of Employers: A HireRight survey found ~35% of hiring managers encountered falsified academic credentials, with forged diplomas and fake transcripts being the most common.

  • Economic Impact: The U.S. loses billions of dollars annually in productivity costs from unqualified hires, while universities spend millions/year on manual verification services like National Student Clearinghouse.

Current Verification Bottlenecks:

• Manual Processes: Employers often rely on slow, error-prone methods (e.g., calling registrar offices). The National Association of Colleges and Employers (NACE) Report found 45% of hiring managers face delays of 3+ days for credential checks, derailing recruitment timelines.

• Third-Party Risks: Centralized services like Parchment charge 15–15–50 per verification and are vulnerable to data breaches (e.g., 2023 Clark County Schools hack exposing 200k student records).

Solana’s Solution

1. NFT Issuance: Universities mint NFTs (via Solana’s Metaplex standard) containing:

   • Hashed student data (name, degree, GPA).

   • Digital signatures from the registrar’s wallet.

   • Timestamped issuance/expiry dates.

2. Verification: Employers use a Solana explorer (e.g., Solscan) to:

   • Confirm the NFT’s issuer (university public key).

   • Validate metadata against the institution’s published schema.

3. Automation: Smart programs trigger alerts if credentials are revoked (e.g., due to academic misconduct).

Technical Advantages:

• Speed: Solana’s 400ms block time enables instant verification vs. Bitcoin’s 10+ minutes.

• Cost: Minting 10,000 diplomas costs ~$20(vs.50k+ for traditional secure printing).

• Interoperability: NFTs integrate with LinkedIn, Indeed, and HR platforms via APIs.

Past Attempts

• Blockcerts (Bitcoin):

  • Workflow: Institutions issue credentials anchored to Bitcoin’s blockchain.

  • Failure: Verification took 10–60 minutes due to Bitcoin’s 10-minute block time, making it unusable for job fairs or instant background checks.

  • Adoption: Only 120+ institutions adopted it by 2023, citing high complexity.

• MIT Digital Diplomas (2017):

  • Pilot: Issued Blockcerts to 100 graduates.

  • Outcome: Abandoned due to employer complaints about slow verification. Switched to centralized platforms in 2020.

Why They Failed:

• Speed: Bitcoin/Ethereum’s latency mismatched real-world hiring needs.

• Cost: $10+ minting fees per diploma were prohibitive at scale.

Feasibility Today

• Technical Feasibility:

  • Standards: The W3C Verifiable Credentials framework aligns with Solana NFTs, enabling cross-platform compatibility.

  • Privacy: Zero-knowledge proofs (e.g., Light Protocol) allow employers to verify credentials without accessing sensitive data (e.g., GPA).

• Business Feasibility:

  • Low Resistance: 68% of universities in an EDUCAUSE survey expressed openness to blockchain credentials if costs are low.

  • Corporate Demand: IBM and Google now accept blockchain-based credentials for certifications, citing fraud reduction.

Challenges:

• Key Management: Students losing wallet access (e.g., forgotten seed phrases) require institutional recovery options.

• Legacy Systems: Integration with Student Information Systems (SIS) like Banner or PeopleSoft needs custom APIs.

6. Cross-Game Digital Identity

The Problem

• Fragmented Gaming Identities:

  • Account Proliferation: The average gamer maintains 8.5 separate gaming accounts, leading to password fatigue and security risks.

  • Item Theft: $1B+ in virtual items are stolen annually via phishing, SIM swaps, and marketplace hacks (e.g., CS:GO skins, Fortnite accounts).

• Economic Impact:

  • Lost Value: 23% of gamers abandon accounts with compromised items instead of pursuing recovery.

  • Interoperability Costs: Developers spend 30% of project budgets building proprietary identity systems.

Solana’s Solution

“Passport” NFT Workflow (Hypothetical):

1. Identity Minting: Gamers create a non-transferable NFT storing:

   • Achievements (e.g., Elden Ring boss kills).

   • Inventory (e.g., Steam skins, Axie Infinity creatures).

   • Reputation scores (e.g., League of Legends honor level).

2. Cross-Game Integration: Games like Star Atlas read/write to the NFT via Solana programs. Example:

   • Unlock Star Atlas ship skins by proving Call of Duty achievements.

3. Security: Biometric 2FA (e.g., FaceID) tied to wallet prevents unauthorized transfers.

Technical Advantages:

• Speed: Solana’s 400ms block time enables real-time inventory updates vs. Ethereum’s 15-second lag.

• Fees: Trading a Fortnite skin costs $0.002 on Solana vs. $1.50 on Ethereum.

Past Attempts

• Decentraland (Ethereum):

  • Performance Issues: During Metaverse Fashion Week 2023, Ethereum’s 15-second block time caused avatars to glitch when transferring wearables between scenes.

  • Cost: Trading a virtual hat incurred $10 in gas fees, stifling microtransactions.

• Enjin (Ethereum Sidechain):

  • Centralization Trade-offs: To reduce fees, Enjin moved to a private JumpNet chain, sacrificing decentralization.

Why They Failed:

• Speed: Ethereum’s architecture couldn’t handle real-time metaverse interactions.

• Cost: Fees exceeded item values for 68% of sub-$5 transactions.

Feasibility Today

• Technical Feasibility:

  • Standards: Solana’s Metaplex NFT standard supports composable assets (e.g., wearables usable across games).

  • Wallets: Phantom Wallet’s 18M+ users (as of Q1 2024) already manage Solana-based identities.

• Business Feasibility:

  • Adoption: 100+ Web3 games built on Solana in 2023, including Star Atlas and Aurory.

  • Interoperability: Solana-based projects like Star Atlas actively participate in OMA3 working groups to develop open metaverse standards. OMA3’s interoperability guidelines (e.g., asset portability) align with Solana’s Metaplex NFT standard, and can enable cross-game compatibility.

Challenges:

• Platform Resistance: Sony/Microsoft resist blockchain integration to protect PlayStation/Xbox ecosystems.

• Regulation: South Korea’s 2023 Game Industry Promotion Act bans NFTs in P2E games, complicating global rollouts.

Some more industries Solana can be beneficial to:

• Digital Art Provenance: Address $6B in annual forgery losses.

• Advertising: Eliminate $50B+ in ad fraud.

• Music & Media: Automate royalty distribution.
  and more…

  ---

Conclusion

Solana’s architecture solves past blockchain adoption barriers—speed, cost, and scalability—but success hinges on aligning incentives. Healthcare and energy projects show near-term promise, while voting and other systems face regulatory and social hurdles. The key is targeting problems where transparency and real-time data matter more than absolute privacy. As Solana’s ecosystem matures, its role in rebuilding institutional trust could redefine industries far beyond finance.

If you found this article helpful, please consider liking and sharing it. If you spot any inaccuracies or have suggestions for improvement, feel free to leave a comment. Together, we can uphold the quality and usefulness of the information we share.

References

1.
3 Patient Referrals Process Pain Points—And How To Solve Them
blockHealthSecure: Integrating Blockchain and Cybersecurity in Post-Pandemic Healthcare Systems
Revolutionizing Healthcare: Enhancing Interoperability and Security in Personal Health Record Management through Solana Blockchain and Custodial Wallet Architecture
Blockchain integration in healthcare: a comprehensive investigation of use cases, performance issues, and mitigation strategies

2.
Substandard and falsified medical products
Drug Supply Chain Security Act (DSCSA) | FDA
Food Traceability on Blockchain: Walmart's Pork and Mango Pilots with IBM
Metaplex Developer Hub
https://lightprotocol.com/whitepaper

3.
Views of election administration and confidence in vote counts | Pew Research Center
Administering Accessible Vote by Mail Systems
The Ballot is Busted Before the Blockchain: A Security Analysis of Voatz, the First Internet Voting Application Used in U.S. Federal Elections
Internet Voting in the USA: History and Prospects; or,

4.
FERC Order No. 2222 Explainer: Facilitating Participation in Electricity Markets by Distributed Energy Resources[i]
Grid Modernization Initiative | Department of Energy
How the Brooklyn Microgrid and TransActive Grid are paving the way to next-gen energy markets - ScienceDirect
Texas’ ERCOT approved an Aggregated Distributed Energy Resource (DER) Pilot Project. What challenges lie ahead?

5.
2021 Global Benchmark Report | HireRight
Judge denies motion to dismiss cybersecurity lawsuit against Clark County schools - The Nevada Independent
Digital Diploma debuts at MIT | MIT News | Massachusetts Institute of Technology
Verifiable Credentials Data Model v1.1
Will Blockchains Revolutionize Education? | EDUCAUSE Review

6.
Study: 47% of gamers play on multiple platforms | GamesIndustry.biz
NCSIR 2021: Special Release – Gaming & Cybercrime | Norton
https://web.archive.org/web/20230327012810/https://status.decentraland.org/
The Verdict On Decentraland Metaverse Fashion Week 2023 | Jing Daily
South Korean court rules NFTs as speculative and not protected under legislation - CoinGeek

Connect with me on X: @angry__pacifist

Subscribe now

Stablecoins combine the speed of digital currencies with the reliability of traditional finance. As a result, they enable real-time transactions, including instant cross-border transfers. This is particularly beneficial for international remittances and urgent payments, eliminating the delays often associated with conventional banking.

Stablecoins also offer a cost-effective alternative to traditional payment methods. By removing intermediaries, they significantly lower transaction fees, making them attractive to businesses and consumers alike. Small enterprises and individuals in regions with limited banking infrastructure stand to benefit the most, with research indicating that stablecoins can reduce cross-border remittance costs by up to 80%.

Unlike other cryptocurrencies, stablecoins are shielded from extreme price volatility, making them practical for everyday transactions and as a dependable store of value.

PayFi: Reimagining Payment Financing.

Building on the foundation of stablecoins, innovative financial models like PayFi are emerging to address inefficiencies in traditional payment systems. PayFi, short for "Payment Finance," reimagines payment processes by leveraging blockchain technology to enhance financial flexibility and liquidity.

Introduced by Lily Liu, Chairwoman of the Solana Foundation, PayFi operates on the principle of the Time Value of Money (TVM)—that money available now is more valuable than the same amount in the future. Utilizing blockchain and stablecoins, PayFi ensures immediate liquidity, allowing users to receive payments without the delays typical of traditional financial systems. This approach improves cash flow management, giving businesses the flexibility to allocate resources more effectively.

Challenges in Traditional Payment Systems

Traditional payment financing is plagued by inefficiencies that hinder financial growth and agility. Key challenges include:

• Delays in Credit Card Settlements: Settlement times for credit card transactions can stretch over several days, disrupting cash flow and complicating financial planning for businesses. These delays are particularly burdensome for small and medium-sized enterprises that depend on timely payments to sustain operations.

• Prefunding Requirements for Cross-Border Transactions: Cross-border payments in traditional banking often require businesses to maintain substantial reserves in foreign accounts to facilitate future transactions. In fact, recent data shows that more than $4 trillion is currently locked up in these prefunded accounts worldwide, representing a massive—yet largely hidden—cost to financial institutions and the broader payments industry. This prefunding ties up capital that could otherwise be invested in growth opportunities and adds complexity to financial management by forcing businesses to navigate fluctuating exchange rates and diverse regulatory frameworks.

• Lack of Transparency in Trade Finance: Trade finance involves multiple stakeholders, including exporters, importers, banks, and insurers. Traditional systems often lack transparency, leading to inefficiencies, disputes, and delays. Limited visibility into transaction statuses and terms undermines trust and hampers smooth trade operations.

PayFi tackles these challenges head-on, offering a solution that simplifies and modernizes payment financing. This not only enhances operational efficiency but also gives businesses and individuals greater control over their financial transactions.

Huma Finance

Huma Finance stands at the forefront of transforming global payment systems as the first PayFi network. Leveraging a decentralized, scalable infrastructure for payments, financing, and credit, Huma aims to overcome the persistent inefficiencies of traditional financial systems. As the first protocol enabling real-world asset-backed payment financing on the blockchain, Huma bridges the gap between conventional finance and emerging digital economies.

At its core, Huma Finance empowers users to seize control of their cash flow. With instant access to future funds, businesses and individuals alike can maintain liquidity without relying on intermediaries—a particularly valuable benefit for SMEs frequently constrained by delayed settlements or limited access to credit. Beyond immediate cash flow solutions, Huma’s tools also facilitate more flexible financial planning, helping users tailor and execute strategies that support long-term growth.

The mission of Huma Finance is threefold:

1. Democratize Access to Liquidity: Ensure both individuals and businesses, especially in underserved regions, can obtain credit and liquidity with ease and immediacy.

2. Decentralize Payment Financing: Shift away from legacy, centralized frameworks toward an open, transparent blockchain infrastructure, providing greater efficiency and autonomy for all participants.

3. Promote Financial Inclusion: Empower underbanked communities by offering stablecoin-based solutions and intuitive financial products that help bridge the gap between traditional and digital finance.

Huma’s PayFi approach highlights three key innovations:

1. T+0 Payment Settlements
   Short for “transaction date plus zero days,” T+0 payment settlements eliminate waiting periods by finalizing transactions instantly. This real-time availability of funds enables better liquidity management and quicker reinvestment into operations.

2. Prefunding-Free Cross-Border Transactions
   Remove the need for prefunding in international payments. This not only streamlines cross-border commerce but also ensures businesses keep vital working capital at their disposal.

3. Enhanced Trade Finance Transparency
   Harness the power of blockchain’s immutable ledger to provide real-time visibility into trade finance transactions, reducing disputes, mitigating risks, and promoting trust among stakeholders.

Huma’s Milestones in 2024

1. Merger with Arf
In April 2024, Huma Finance merged with Arf, a global transaction services platform specializing in scalable liquidity for financial institutions. This strategic merger:

• Combined the expertise of both companies in stablecoin-based cross-border payment solutions.

• Expanded the network’s capacity to handle complex liquidity requirements for businesses worldwide.

• Resulted in $1.6 billion in jointly processed payment transactions by the end of 2024.

• Positioned Huma to advance toward its ambitious goal of $10 billion in total transactions by 2025.

2. Series A Funding: $38 Million
In September 2024, Huma Finance announced that it secured a total of $38 million in a Series A funding round, led by Distributed Global with notable participation from HashKey Capital, Folius Ventures, the Stellar Development Foundation, and TIBAS Ventures (the corporate venture capital arm of İşbank). Of this total, $10 million was raised in equity, while $28 million was structured as real-world asset (RWA)-backed loans. This investment underscores market confidence in Huma’s mission to bring real-world asset-backed payment financing to the blockchain.

These funds fueled the launch of Huma V2, marking the protocol’s evolution from a simple income-based lending platform into a global PayFi network.

3. Launch on Solana
In November 2024, Huma Finance deployed its protocol on the Solana blockchain, renowned for its high-speed and low-cost transactions. This expansion broadens the accessibility and efficiency of Huma’s payment financing solutions, enabling businesses worldwide to benefit from quicker settlements and more affordable on-chain transactions.

To celebrate its launch on Solana, Huma and Arf introduced a limited-time campaign offering double-digit stablecoin yields to accredited investors. This initiative captures revenues from Arf’s cross-border payment financing, ensuring sustainable returns through transaction fees of 8–10 basis points charged to institutional clients.

Key highlights of the campaign include:

• Three-Month Lock-Up Pools: Annual yields of up to 15% APY for senior tranches and 16.61% APY for junior tranches.

• Six-Month Lock-Up Pools: Elevated annual yields of 16% APY for senior tranches and up to 20.69% APY for junior tranches.

• Huma Points Rewards: Eligible investors can also earn Huma Points, adding an extra layer of incentive.

4. Surpassing $2 Billion in Transactions
Huma Finance processed over $2 billion in transactions throughout 2024—a reflection of its rapid adoption. Key highlights include:

• Real-time cross-border payments that simplified liquidity management for businesses.

• Tokenized real-world asset financing, paving the way for innovation in trade finance and receivables.

• Stablecoin-backed payment networks, driving broader use cases in seamless on-chain transactions.

Notably, Huma achieved this transaction volume with zero credit defaults and is on track to exceed $10 billion in transaction volume by 2025.

The PayFi Stack and the Vision for an Internet of Money

Huma Finance envisions an Internet of Money—a global financial ecosystem where value moves as seamlessly as data does across the Internet. By applying modular, standardized principles similar to the OSI model, Huma’s PayFi Stack establishes a blueprint for an interconnected, borderless financial system. This approach directly tackles the inefficiencies and exclusivity of legacy finance, paving the way for decentralized, programmable, and universally accessible payments, credit, and financing.

The Internet of Money

The Internet of Money operates on the premise of establishing a universal, open financial network that breaks free from the constraints of geography, bureaucracy, and outdated infrastructure. Much like how the Internet of Data reshaped communication, the Internet of Money aims to:

• Accelerate financial transactions: Replace multi-day settlement delays with near-instant payments.

• Reduce costs: Eliminate intermediaries by leveraging low-cost, high-speed blockchain networks.

• Increase accessibility: Invite individuals and businesses from all corners of the globe to participate in financial markets without high barriers to entry.

• Enhance transparency: Leverage open ledgers to ensure traceability, compliance, and security.

Huma’s PayFi Stack is purpose-built to realize these ambitions, addressing the foundational challenges in global payment financing and creating an ecosystem where the movement of money is as frictionless as sending an email.

How the PayFi Stack Aligns with the Internet of Money

Drawing inspiration from the layered OSI model, the PayFi Stack divides on-chain payment finance into six specialized layers: Transaction, Currency, Custody, Compliance, Financing, and Application. Each layer performs a distinct function while working in tandem to provide a robust, interoperable framework. Just as the OSI model unified disparate communication protocols to form today’s Internet, the PayFi Stack unites fragmented financial systems to create an open, borderless Internet of Money. To solve real-world challenges such as the high costs of cross-border transactions, sluggish settlement times, opaque credit frameworks, and legacy financial infrastructure ill-equipped for a rapidly globalizing economy.

The Six Layers of the PayFi Stack

1. Transaction Layer

At the foundation lies the Transaction Layer, responsible for fast, low-cost, and reliable payments. Huma’s deployment on high-throughput chains like Solana enables finality times of around 400 milliseconds and transaction costs as low as $0.00025. By eliminating the bottlenecks that have plagued traditional finance for decades, the Transaction Layer makes real-time operations not just possible but practical for a multitude of applications.

2. Currency Layer

Here, stablecoins act as the primary medium of exchange. From USDC to region-specific assets like EURC, the Currency Layer ensures transactions remain stable, compliant, and interoperable across jurisdictions. This design offers predictable value transfers—vital for everything from remittances and payroll to everyday purchases—without the volatility issues often associated with cryptocurrencies.

3. Custody Layer

Security is paramount in any decentralized financial ecosystem. The Custody Layer employs advanced solutions such as multi-party computation (MPC) and programmable asset locks to guarantee the safekeeping of on-chain assets.
MPC splits private keys (or other sensitive data) among multiple parties, ensuring that no single party ever holds the entire key. This significantly reduces the risk of hacking or misuse, as multiple independent approvals are required to authorize any transaction.
Industry platforms like Fireblocks, Cobo, and Copper offer features like multi-party asset management and enhanced account controls. Combined, these innovations provide institutions with the secure yet flexible treasury operations they need, ensuring T+0 settlements become the new baseline.

4. Compliance Layer

The Compliance Layer embeds KYC, AML, and attestation frameworks into the very fabric of the transaction flow. Instead of taking on compliance as an afterthought, it becomes a seamless element of each operation. This is crucial for stablecoins used in real-world payments, where robust AML measures are a regulatory necessity. Solutions from Chainalysis, Elliptic, and TRM labs help meet these requirements, alongside emerging privacy-focused attestation platforms.

5. Financing Layer

At the heart of Huma’s offerings lies the Financing Layer, bridging capital providers and borrowers through mechanisms like tokenized assets, oracle-based risk assessments, and automated credit structuring. This layer is where real-world asset-backed payment financing becomes a reality, unlocking new avenues in trade finance, cross-border payments, and decentralized physical infrastructure networks (DePIN). It redefines how credit is issued, how risk is managed, and how underbanked communities can gain access to capital.

6. Application Layer

Crowning the stack is the Application Layer, which empowers developers to build user-facing products—ranging from payment gateways and decentralized lending platforms to sophisticated financial management tools. This layer is where the theory of the Internet of Money becomes tangible, offering end-users an intuitive, accessible interface to interact with advanced financial protocols.

Conclusion

Quoting Anna, “Stablecoins are the future of banking, payments, leverage, lending, dollar remittance, education, and literally the entire global economy.”
As demand for payment financing accelerates, it becomes clear that traditional financial institutions cannot keep pace. The continued expansion of stablecoins, the unfolding progress of PayFi, and the innovations from Huma Finance signal a new era of democratized access to capital—one in which money can move at the speed of the Internet.

PayFi offers individuals unprecedented flexibility in deciding when to receive payments and when to pay—ultimately paving the way for greater financial freedom. Looking ahead, we can expect one of the most significant transformations in the global financial landscape in decades.

If you found this article helpful, please consider liking and sharing it. If you spot any inaccuracies or have suggestions for improvement, feel free to leave a comment. Together, we can uphold the quality and usefulness of the information we share.

References

Time value of money - Wikipedia
OSI model - Wikipedia
Anchoring Economies: The Role Of Stablecoins In Emerging Markets - Squads Blog Huma Finance and Arf Merge to Transform Global Finance Through Real World Asset Tokenization
Case Studies - arf | Borderless Finance Unlocked
Global liquidity for real-time payments with Arf and USDC
Huma Finance
Huma Overview | Dune
Tranches | Huma V2
PayFi - The New Frontier of RWA
Understanding The PayFi Stack: The Tech That Powers A New Financial Paradigm
Huma Finance Launches on Solana, Expanding Access to On-Chain Payment Financing.
PayFi, How Solana Enables the Original Vision of Blockchain Lily Liu, Solana Foundation

Subscribe now

Connect with me on X: @angry__pacifist

However, one challenge quickly became apparent: finding a way to spend my stablecoins, such as USDT and USDC, easily. While earning in a stable currency like USD was a huge financial advantage in a country plagued by inflation, spending those earnings wasn’t as straightforward. After years of navigating different solutions, I recently found what I believe is the perfect way to spend my stablecoins without hassle. Here’s how I got there.

The Problem: Payments in a Broken System

Like many Nigerians, I frequently need to make payments in USD for a range of services—streaming platforms like Prime Video and YouTube Music, subscriptions for educational tools, and even online shopping for fashion items. The demand for USD is constant, but accessing it has been a major obstacle, primarily due to the Central Bank of Nigeria’s restrictions on foreign exchange transactions. As a result, Nigerian debit cards are often useless for online purchases in USD, leaving many of us searching for alternatives.

Cryptocurrencies, particularly stablecoins, offer a promising solution. These digital currencies maintain their value by being pegged to the U.S. dollar, providing a safe way to store wealth and make transactions without losing value to inflation. However, the problem of spending stablecoins directly persists. Most merchants don’t accept stablecoins, and converting them to fiat currency has its complications—local debit cards are inefficient, and converting back to naira leads to inevitable losses due to inflation.

I was stuck in a frustrating cycle: I held stablecoins to protect my assets, but spending them felt nearly impossible.

The Existing Solutions: Limited, Expensive, and Frustrating

Over the years, several new platforms offered a workaround. The rise of neobanks—digital banks that operate without physical branches—appeared promising. These platforms often provide virtual cards and digital wallets, allowing users to make international transactions. However, in practice, these solutions fell short in several critical areas.

For one, currency conversion rates were often extremely high. A purchase that should have cost $10 could easily cost $12 or more due to poor exchange rates. On top of that, many neobanks were plagued by fees—fees for deposits, withdrawals, transfers, and even for creating and maintaining virtual cards. Some charged monthly maintenance fees of up to $5, which, while seemingly small, quickly added up when trying to make routine purchases.

Additionally, the friction involved in international transfers and top-ups meant that even when these platforms worked, they were far from seamless. The whole point of using crypto was to bypass these traditional banking obstacles, but many of the available solutions felt like a digital version of the same old system—inefficient, expensive, and frustrating.

KAST: A Seamless Solution for Stablecoin Spending

This all changed when I discovered KAST. After years of struggling with cumbersome alternatives, I was initially skeptical, but KAST proved different. Within a week of using it, I realized that KAST offered a stablecoin-to-debit card solution that was both practical and simple, finally allowing me to spend my stablecoins with ease.

Founded by Raagulan Pathy, who previously drove growth at Circle (a major stablecoin provider) in APAC, and Daniel Bertoli, a fintech VC, KAST provides users with a card—available both virtually and physically—that can be topped up with stablecoins like USDT or USDC. This card is accepted by millions of merchants globally, both online and in-store, in over 150 countries.

KAST stands out in several key ways:

1. Rapid Onboarding: Signing up for KAST is a breeze. Unlike traditional financial platforms that require tedious paperwork and days of waiting, KAST offers a swift onboarding process. I completed my registration and KYC verification in just three minutes. It’s probably the quickest onboarding I’ve ever experienced in fintech.

2. No Fees for Virtual Card Creation: Many neobanks charge fees for creating and maintaining virtual cards. KAST, however, offers a virtual K-Card at no cost. Users can keep a zero balance, and linking the card to digital wallets like Google Pay or Apple Pay is seamless, allowing stablecoin holders to make contactless payments without fuss.

3. Generous Spending Limits: One of the most impressive features is KAST’s high spending limits—up to $100,000 per transaction. This eliminates the usual restrictions associated with digital wallets and bank cards, making large purchases far more convenient.

4. Transparent Fee Structure: With KAST, what you see is what you get. USD transactions are charged on a one-for-one basis, meaning no hidden fees. There’s a modest 2% foreign exchange fee for transactions in other currencies like EUR, which is still far more affordable than traditional banking options.

5. Low Maintenance Fees: The K-Card is free for the first three months. After that, it costs only $18 per year—a small price for its convenience and flexibility. For those looking for an even higher service tier, the premium X-Card, which comes with a physical card and numerous additional perks, is available for $888 annually.

6. Loyalty Program: KAST’s loyalty program is one of the most generous in the market. Depending on the card tier, users can earn between 5% and 18% cashback on purchases deposited directly into their accounts. Soon, KAST will also offer exclusive merchant benefits based on card tiers, giving users even more incentives to stick with the platform. For now, they’re offered in KAST points.

KAST X Solana

KAST’s ambitions don’t stop at spending solutions. The platform recently launched a collaboration with the Solana Foundation through the Solana x KAST Card series, adding another layer of benefits for users in the Solana ecosystem. These themed virtual cards come with perks like fee waivers for the first year and tiered benefits.

In addition, KAST has partnered with Kiln to launch a Solana Validator.

The validator offers zero commission and a 100% kickback against MEV (Maximum Extractable Value). Stakers can enjoy additional KAST rewards on top of a regular staking yield of 7.6% APY.

The Solana X KAST card lineup includes four distinct types:

• Solana Card (Virtual): Free to get, with no fees for the first year.

• Solana Illuma (Metal): Priced at 10 SOL and features a tap-to-pay option that lights up the Solana logo.

• Solana Gold (Gold-plated, 24k): Priced at 50 SOL, limited to 888 cards, with no fees for the first year.

• Solana Solid (Heavy solid gold): Priced at 250 SOL, it is limited to just 88 cards. It offers two years free of fee and three complimentary gold-plated metal cards.

Here’s where it gets interesting. KAST’s vision is to be a stablecoin neobank, providing all the services one would expect from a traditional bank yet entirely built on stablecoins and blockchain technology. This encompasses spending, saving, investing services, and the ability to send money globally through an intuitive app experience.

This partnership plays a significant role in achieving that vision. When you stake with KAST or bring your SOL for spending, you can borrow against your SOL and spend, or even use up to 60% of your SOL holdings on your card—interest-free, forever, thanks to a new feature called PayFi.

Additionally, Superteam members can obtain custom virtual cards tailored to their region at no cost. These unique cards include all the premium benefits of the X card, which normally retails for $888.

Oh, and let’s not forget the KAST Points—a rewards program known for its transparency. As part of the loyalty program I mentioned, these points are earned through card interactions and spending activities within the app. In the near future, KAST will introduce a token, allowing these points to be converted on a 1:1 basis into KAST tokens—straightforward, with no hidden catches.

Conclusion: KAST as the Future of Stablecoin Banking

In my experience, KAST has succeeded where other solutions have failed. In essence, KAST works—and it does so even more efficiently than traditional fiat cards. KAST understands the friction that exists when moving between stablecoins and fiat, and they’re laser-focused on fixing that.

KAST aims to be the premier stablecoin neobank rather than just another wallet or exchange platform.

Presently, KAST offers a card product, but plans are underway to introduce on-chain savings backed by treasuries and investment services—all within a user-friendly app, among other features. Significantly, the platform does not facilitate crypto purchases, a deliberate choice to ensure a high-quality banking experience for stablecoin users. KAST is committed to delivering excellence in this niche.

If you’re in the Web3 space or looking for a better way to manage and spend your stablecoins, I highly recommend trying KAST.

Get started today: ☛HERE.

Learn more:

Twitter

Website

KAST x Solana

KAST Points

If you found this article helpful, please like and share it. If you spot any errors or have suggestions for improvement, feel free to share them in the comments. Together, we can ensure the accuracy and value of the content we share.

Subscribe now

Connect with me on X: @angry__pacifist

Coal provides more ways to stress test the Solana network and is built with the same fair launch and distribution ethos in mind as Ore.

Before we proceed, a full disclaimer: this is not financial advice, and I am only mildly technically savvy. The contents of this guide are a rundown of the steps that worked for me, and I'm documenting them so anyone else can replicate them.

Getting Started

This guide is straightforward and relies heavily on using the command line interface. Here are the steps:

Install WSL (Windows Subsystem for Linux):

• WSL is a compatibility layer for running Linux binary executables natively on Windows. It allows you to use a Linux environment without the need for a virtual machine.

Step 1: Install WSL from the Microsoft Store

• Open the Microsoft Store on your Windows device.

• In the search bar, type "WSL".

• For this guide, I used the Ubuntu 22.04.3 LTS version, but you can choose any distribution that suits your needs. They should all work similarly.

• Click install

Alternatively, you can;

• Open PowerShell as an Administrator.

• Run the command:

wsl --install

• Restart your computer when prompted.

• Once restarted, WSL will install and set up a default Linux distribution.

Step 2: Set Up Your Linux Distribution

• After installing WSL, open the newly installed Linux distribution from your Windows Start menu.

• Follow the on-screen instructions to set up your username and password.

Once your Linux distribution is set up, it's a good practice to update and upgrade the packages:

• Open your Linux terminal.

• Run the commands:

sudo apt update
sudo apt upgrade

Step 3: Set Up Your Mining Environment

Install the Rust Programming Language:

• In your WSL command interface, type the following command:

curl https://sh.rustup.rs -sSf | sh

• Hit Enter at the installation options prompt.

• Once the installation is complete, you'll see a confirmation message indicating that Rust has been successfully installed.

Step 4: Install the Solana Toolchain:

• In your WSL command interface, type the following command:

curl -sSfL https://release.solana.com/v1.18.4/install | sh 

This command downloads and runs the Solana installation script, allowing you to perform Solana transactions from within your shell, which is necessary to mine Coal.

After the installation, restart your command line interface by closing and reopening it to apply the changes.

Step 5: Set Up a Solana Wallet in the CLI

Create a New Wallet:

• It is best practice to create a fresh wallet. In your command line interface, type:

solana-keygen new

• Hit Enter when prompted for a passphrase to leave it empty.

Secure Your Wallet Information:

• A new wallet will be created, and the public key (pubkey) and seed phrase will be displayed on the screen.

• Ensure you copy and store the seed phrase securely, as it is essential for wallet recovery.

• Copy your public key (wallet address) and fund it with some SOL (Solana tokens).

  

Step 6: Install Dependencies

Update Package Lists:

• First, update your package lists to ensure you have the latest information on the newest versions of packages and their dependencies:

sudo apt update

Install Build Essentials:

• Next, install the build-essential package, which includes a collection of tools for compiling software:

sudo apt install build-essential

• When prompted, type 'y' and hit Enter to confirm the installation.

Install Additional Dependencies:

• Install the pkg-config and libssl-dev packages, necessary for compiling and running the Coal miner program:

sudo apt install pkg-config libssl-dev

• As before, type 'y' and hit Enter to confirm the installation.

Verify Installation:

• Once the installations are complete, you can verify them by running:

which cc

• If the command returns a path, such as /usr/bin/cc, your installation was successful and you’re all set.

Step 7: Install the Coal CLI Miner

By now, your system should be ready to install the Coal Miner program.

Install the Coal Miner Program:

• To install, use the following command

cargo install --git https://github.com/Findiglay/coal-cli.git

• This installation process might take a while, so you can take a break and relax.

Start Mining:

• Once the installation is complete, ensure you have SOL deposited in your wallet from Step 5.

• To begin mining, simply use the command

coal mine

Additional Information

It's worth noting that mining rewards are heavily weighted towards miners who:

• Stake Coal: Increase their mining rate multipliers by staking Coal.

• Use High-Performance Hardware: Mining relies on CPU power, so having a PC with more CPUs is advantageous.

• Utilize a Reliable RPC Node: Faster transaction processing is possible with a reliable RPC node.

Having one or all of these factors puts you at an advantage.

Staking Coal:

• If you buy Coal on the market to stake, use the following command to activate your stake:

coal stake

Utilizing PC Hardware for Mining:

• To make use of your PC's hardware, add the --cores argument to the mine command:

coal mine --cores x

Replace x with the number of CPUs available on your PC or the amount you want to utilize. For example, using 8 cores:

coal mine --cores 8

This helps with mining difficulty and enables you to solve complex hashes. Check your PC system settings to know your specifications and tweak accordingly.

Using a Custom/Dedicated RPC:

• To use a custom or dedicated RPC for mining, add the --rpc argument to your mine command:

coal mine --rpc custom_rpc_url --cores 8

• Replace custom_rpc_url with your RPC URL. You can get free or custom RPCs from providers like Helius, QuickNode, or Alchemy.

Adjusting Priority Fees:

• You can change the amount you pay in fees using the --priority-fee argument. Add it to the mine command along with other arguments as needed.

Claiming Mining Rewards:

• To claim your mining rewards, use the following command:

coal claim

And there you have it – you're all set.
I’ll see you in the mines!

For more information: Coal Linktree

If you've found this article enlightening and engaging, kindly express your support by liking and sharing it. Furthermore, should you come across any discrepancies or possess suggestions to enrich this discourse, we welcome your input in the comments section. Through collaborative efforts, we ensure the precision and relevance of the knowledge we share.

Subscribe now

Connect with me on X: @angry__pacifist

The State of Energy in Nigeria

Nigeria's energy sector is characterized by a paradox: while the country has abundant natural resources, it suffers from severe energy shortages. Over 140 million Nigerians, about 71% of the population, lack access to reliable electricity. This energy deficit has far-reaching implications on health, education, and economic development.

The energy sector in Nigeria heavily relies on fossil fuels, particularly oil and gas, which account for the majority of the country's energy production. Hydropower, the primary source of renewable energy, contributes to a smaller portion of the energy mix.

Energy Infrastructure

Nigeria has an installed capacity of about 13,000 MW, but only 4,000 MW to 7,000 MW is typically available due to various inefficiencies.

• The transmission network is plagued by inadequate infrastructure and frequent breakdowns, resulting in significant power losses and unreliable electricity supply.

• Distribution companies (DisCos) struggle with high levels of technical and commercial losses, poor metering, and low revenue collection rates.

• A large portion of the population relies on expensive and polluting diesel generators for electricity. This not only increases the cost of energy but also has severe environmental and health impacts.

• The energy sector faces regulatory uncertainties and financial constraints, hindering the development of new projects. However, recent legislative changes, such as the Electricity Act of 2023, aim to address some of these issues by decentralizing the electricity market.

Energy Consumption and Demand

Nigeria's energy consumption patterns reflect its economic activities and population distribution. The industrial and residential sectors are the largest consumers of electricity.

Industries, particularly manufacturing, consume a significant portion of the electricity supply. However, frequent power outages force many businesses to rely on expensive and polluting diesel generators.

The residential sector also accounts for a large share of electricity consumption, with urban households using more electricity compared to rural ones.

Opportunities for Electric Energy Storage in Nigeria

Energy storage is crucial for addressing power reliability issues and supporting the integration of renewable energy sources. Nigeria's frequent power outages necessitate reliable energy storage solutions to ensure continuous power supply.

Currently, Nigeria's energy storage solutions are limited. Existing implementations include battery storage systems for renewable energy projects and small-scale off-grid solutions. Successful case studies, such as solar mini-grids with battery storage, demonstrate the potential of energy storage to improve power reliability in rural areas.

Market Potential

The market demand for energy storage solutions in Nigeria is significant. With the government's push for renewable energy integration, the potential economic and environmental benefits are substantial. Scaling rural electrification through distributed solar generation and mini-grids could generate $9.2 billion in annual market investments and save Nigerian households and companies $4.4 billion annually.

Renewable Energy Potential

Nigeria has significant renewable energy potential, particularly in solar and biomass. The country's geographical location provides ample solar radiation, making it ideal for solar power projects. Additionally, biomass from agricultural residues and waste can be used for power generation.

Recent Developments

Recent developments in the Nigerian energy sector include the implementation of mini-grid regulations, support for decentralized energy solutions, and increased investments in renewable energy. The World Bank's $1.5 billion financing for Nigeria’s energy transition is a significant boost, aiming to improve energy access and support renewable energy projects.

State of Rechargeable Devices in Nigeria

Nigeria's market for rechargeable devices, including power banks, solar-powered systems, and rechargeable household appliances, is expanding rapidly. This growth is driven by frequent power outages and the need for reliable backup power solutions.

Market Overview

• Solar home systems are increasingly popular, particularly in rural areas where grid electricity is unavailable. These systems provide reliable power for lighting, charging devices, and powering small appliances.

• The demand for power banks and rechargeable batteries is high due to frequent power outages. These devices provide essential backup power for mobile phones and other small electronics.

• Rechargeable household appliances, such as fans and lights, are widely used in both urban and rural areas. These appliances offer a cost-effective solution to power interruptions.

The State of Electric Vehicles (EVs) in Nigeria

An Electric Vehicle (EV) is powered entirely or partially by electricity, rather than using traditional internal combustion engines (ICE) that run on gasoline or diesel. The adoption of electric vehicles (EVs) in Nigeria is in its early stages, with several challenges impeding widespread adoption. However, the growing focus on renewable energy and the potential for decentralized energy solutions create a promising environment for EVs.

Current State and Challenges

• EVs are currently more expensive than traditional gasoline vehicles, making them less accessible to the average Nigerian consumer. Import duties and taxes further increase the cost.

• The lack of charging infrastructure is a significant barrier to EV adoption. Most existing infrastructure is concentrated in urban areas, leaving rural regions underserved.

• There is limited public awareness about the benefits of EVs, including cost savings on fuel and maintenance, and environmental benefits.

Government Initiatives and Existing Players

The Nigerian government is taking steps to promote EV adoption through policies and incentives. These include tax incentives for EV manufacturers, subsidies for EV buyers, and investments in charging infrastructure. Additionally, the government’s focus on renewable energy projects is expected to support the development of EV infrastructure.

Examples of existing EV players in Nigeria include:

• Jet Motors: A Nigerian automotive company focusing on electric mobility solutions. Jet Motors is known for its electric vans, which are gaining traction in the commercial sector.

• Stallion Group: A major player in the Nigerian automotive industry, Stallion Group has introduced Hyundai Kona, an electric SUV, into the Nigerian market. This move marks a significant step towards promoting EVs in Nigeria.

Other prominent players include ReviveEarth (Enugu-based EV retrofitting startup), Osquareteck (providing energy storage as a service and gridless power system for EVs), Volta EV (Lagos-based), Quadcycle Automobile (Abuja-based).

EV Charging Infrastructure in Nigeria

The electric vehicle (EV) charging infrastructure in Nigeria is still in its infancy, facing several significant challenges and limited development. Despite the growing interest in EVs, the lack of a widespread and reliable charging network is a primary barrier to the adoption of electric vehicles in the country.

Key Developments and Initiatives

• Government and Private Sector Initiatives:

  • Nigeria’s first public EV charging station was opened by Possible EVS in Abuja. This facility, known as Charging Hub, offers super-fast charging solutions and is aimed at encouraging the adoption of EVs by providing convenient and accessible charging options.

  • Sterling Bank launched Nigeria’s first publicly available EV charging station in Lagos, as part of its efforts to promote renewable energy and sustainable transportation solutions.

  • Trekk Scooters, a local company, has been developing EV charging infrastructure to support its fleet of electric scooters. This includes setting up solar-powered charging stations in urban areas.

• Challenges:

  • The cost of setting up EV charging stations is high, which deters widespread deployment. Additionally, the high cost of EVs compared to conventional vehicles makes it difficult for many Nigerians to consider switching to electric vehicles.

  • Many Nigerian mechanics and technicians lack the training required to maintain and repair EVs and their charging infrastructure, which is a significant barrier to the growth of the EV market.

  • Nigeria's energy sector is plagued by unreliable electricity supply, which poses a challenge for the development of a dependable EV charging network. Over 85 million Nigerians lack access to grid electricity, and those with access often face frequent power outages.

Future Prospects

• Possible EVS plans to deploy 10,000 public charging stations across Nigeria within the next five years, aiming to make EV charging more accessible and support the growth of the EV market.

• Companies like Phoenix Renewables are focusing on solar-powered charging stations to provide reliable and sustainable energy for EVs. These initiatives are crucial given Nigeria's abundant solar energy potential.

• The Nigerian government’s efforts to promote renewable energy and sustainable transportation, including policies and incentives for EV adoption, are expected to drive the expansion of the EV charging infrastructure.

  

Market Potential

The EV charging infrastructure market in Nigeria is projected to experience significant growth due to government support, increased foreign investment, rising consumer awareness, and the application of innovative technologies. The commercial segment holds the highest market share, driven by the need for public and accessible charging solutions.

Introducing DeCharge

DeCharge is a pioneering solution aimed at revolutionizing the EV charging infrastructure. The initiative focuses on democratizing ownership and improving capital efficiency within the EV charging economy. By offering an EV charging network integrated with Solana and equipped with globally compatible hardware, DeCharge ensures affordable and accessible charging options for all. The platform envisions a future where EV users are free from range anxiety, supported by a robust protocol designed to meet immediate needs and foster long-term sustainability.

The Problem DeCharge Addresses

The team behind DeCharge identified a significant market opportunity in the EV mobility industry, particularly in the area of charging infrastructure. One stark example of the problem is found in India, where there is only one charging station for every 140 vehicles. This ratio highlights the severe lack of infrastructure, which contributes to range anxiety among EV users.

Range anxiety and inadequate charging infrastructure are real challenges that need to be addressed to facilitate the widespread adoption of EVs. The need to scale infrastructure to meet global demand is critical, and DeCharge aims to tackle these pressing issues. The DeCharge initiative was born from this recognition of disparity and has become a beacon for a greener future.

In the Solana Renaissance Hackathon, DeCharge was awarded second place in the DePIN track, demonstrating its potential and innovation in providing globally compatible hardware for affordable EV charging. Additionally, DeCharge is among the 10 startups selected and accepted into The Colosseum's inaugural accelerator program.

DeCharge's initial focus is on addressing range anxiety for EV users. DeCharge aims to solve these issues by building lightweight hardware/infrastructure that is easy to deploy. The sizable device serves as a charge point conduit that can be plugged directly into an AC outlet. This mechanism does not require reliance on high-end infrastructure like DC chargers or those reliant on transformers that charge at a faster rate, which are typically deployed by larger companies. This deployment can be operated by anyone and monetized via DeCharge's software.

Strategic Opportunities for DeCharge in Nigeria

Given the current state of the energy sector, EVs, and rechargeable devices in Nigeria, DeCharge can capitalize on several strategic opportunities to enter and thrive in this market.

• Invest in Renewable Energy-Powered Charging Stations: DeCharge can address the energy deficit and support the growth of the EV market by establishing solar-powered EV charging stations. Solar-powered stations can provide reliable, clean energy for EVs, reducing dependence on the grid and lowering operational costs.

• Partner with Local Governments and Communities: Collaborating with state governments and local communities to develop decentralized energy solutions can enhance DeCharge’s market presence. The recent legislative changes encouraging state-level electricity markets provide a conducive environment for such partnerships.

  

• Conduct Educational Campaigns and Awareness Programs: Conducting educational campaigns to raise awareness about the benefits of EVs and renewable energy can drive market demand. Highlighting the cost savings, environmental benefits, and energy security provided by renewable energy and EVs can encourage adoption.

• Leverage Government Incentives and Support: Taking advantage of government incentives and support for renewable energy projects can reduce operational costs and enhance profitability. Engaging with initiatives like the Nigeria Electrification Project (NEP) can provide additional funding and support.

• Engage in Research and Development (R&D): Investing in R&D can help DeCharge stay ahead of the curve by developing innovative solutions tailored to the Nigerian market. This includes creating more efficient solar panels, improving battery storage technology, and designing cost-effective mini-grid systems. Collaborating with local universities and research institutions can also foster innovation and provide valuable insights into the unique challenges and opportunities in Nigeria’s energy sector.

Viability of DeCharge's Business Model in Nigeria: A Realistic Assessment

DeCharge aims to democratize the EV charging infrastructure using Decentralized Physical Infrastructure Networks (DePIN), integrated with Solana, and providing affordable, globally compatible hardware. This concept addresses range anxiety and offers a decentralized approach to EV charging. However, the viability of this business model in Nigeria, a country plagued with energy poverty, requires a thorough analysis.

Government Stance and Crypto Regulations

The Nigerian government has a complex relationship with cryptocurrencies. In 2021, the Central Bank of Nigeria (CBN) issued a directive prohibiting banks from facilitating cryptocurrency transactions, reflecting a cautious stance towards digital currencies. Given this stance, leveraging government incentives becomes challenging for a business model heavily reliant on blockchain and crypto elements like DePIN. This regulatory environment might hinder DeCharge's ability to fully utilize its decentralized model.

Urban vs. Rural Adoption and Infrastructure Challenges

The adoption of EVs in Nigeria is predominantly urban, with a few public charging stations in cities like Lagos and Abuja. Most EVs are imported, and their high cost compared to gasoline vehicles limits widespread adoption. While involving local communities is a great idea, its practicality in a country where EV adoption is still nascent and predominantly urban is questionable. The benefits of community involvement in urban areas may be limited unless there is significant growth in EV adoption.

Technical and Maintenance Issues

Nigeria faces a dearth of qualified mechanics and technicians trained to service EVs and their charging infrastructure. This lack of technical know-how can lead to longer downtimes for charging stations and reduced reliability, which can deter potential EV users. Establishing extensive training programs to upskill local technicians is essential, but it requires time and investment. This adds to the initial cost and complexity of implementing DeCharge’s business model.

Economic and Logistical Realities

The initial cost of setting up EV charging stations is high. Solar-powered solutions, while reliable, require significant investment in solar panels and battery storage systems. The economic reality in Nigeria, with its relatively low per capita income, makes these investments challenging without substantial financial backing. Ongoing maintenance and operational costs need to be managed carefully to ensure the sustainability of the charging network.

Market Readiness and Consumer Behavior

The EV market in Nigeria is still in its early stages. The market readiness for a widespread, decentralized charging network is low, primarily due to the high cost of EVs, lack of infrastructure, and limited consumer awareness. Nigerian consumers are more familiar with gasoline vehicles, and the transition to EVs requires significant shifts in consumer behavior and perception, which is a slow process.

Strategic Recommendations

• Concentrate efforts on urban centers where EV adoption is more likely to grow in the short term.

• Partner with local businesses and government entities to navigate regulatory challenges and secure financial incentives.

• Begin with pilot projects to demonstrate the viability and benefits of the DePIN model before scaling up.

• Launch educational campaigns to increase awareness and acceptance of EVs and possibly DePIN among Nigerian consumers.

Conclusion

DeCharge’s business model is innovative and holds promise for addressing range anxiety and democratizing EV charging infrastructure.

While DeCharge's model is innovative and potentially transformative, its success in Nigeria will require careful navigation of regulatory, economic, and logistical challenges, alongside a phased and strategic approach to implementation.

If you've found this article enlightening and engaging, kindly express your support by liking and sharing it. Furthermore, should you come across any discrepancies or possess suggestions to enrich this discourse, we welcome your input in the comments section. Through collaborative efforts, we ensure the precision and relevance of the knowledge we share.

Subscribe now

References

Senate rejects Bill to phase out petrol vehicles by 2035 - Punch Newspapers

Is there a future for Electric Vehicles in Nigeria? - Nairametrics

Accelerating Electric Mobility in Nigeria - Energy for Growth Hub

Nigeria launches first solar-powered charging station for electric vehicles | TheCable

Nigeria’s bold leap to boost e-mobility and shrink its emissions | EnergyTransition.org

Possible EVS set to launch fast electric vehicle charging stations in Nigeria - Nairametrics

List of charging stations for electric vehicles in Nigeria

Auto firm opens electric vehicle charging station in Nigeria - Vanguard News

Powering Nigeria: A Recap of Recent Developments in the Electric Power Sector as 2024 Commences with a Flurry of Regulatory Interventions and Proposed Power Asset Sales - Aluko & Oyebode

Watts New: Assessing The Electricity Landscape In Nigeria

Nigeria Energy Outlook – Analysis - IEA

Renewable Energy Roadmap: Nigeria

GRID TO GREEN: NIGERIA'S TRANSITION TO RENEWABLE ENERGY FOR ELECTRICITY SUPPLY — The Firma Law Practice

(PDF) Electric Vehicle: Prospects and Possibility in Nigeria

Driving the electric vehicle agenda in Nigeria: The challenges, prospects and opportunities - ScienceDirect.

Energy sector in Nigeria - statistics & facts | Statista

The promising future of renewables in Nigeria - Power Technology

Pillars of Effective and Efficient Energy Systems in Nigeria.

Electric Vehicles In Nigeria: Opportunities, Considerations and Requirements

NNPC Spearheads Clean Energy Initiative, Unveils Nigeria's First EV Charging Station In Abuja - Arise News

Here's how Nigeria is tackling the barriers to its green energy transition

Nigeria to Expand Access to Clean Energy for 17.5 Million People

Renewable Energy Laws and Regulations Report 2024 Nigeria

Nigeria Electric Vehicle Charging Infrastructure Market

Cryptocurrency Trading: CBN Orders Banks To Close Operating Accounts

peaq | DePIN: What are Decentralized Physical Infrastructure Networks?

Lightspeed Newsletter: New Solana startup accelerator has a DePIN flavor - Blockworks

Meet the Winners of the Solana Renaissance Hackathon

Introducing Colosseum Accelerator Cohort 1

2. DeCharge | Renaissance Hack

De Charge (@DeCharge__) / X

DeCharge

Lessons Nigeria can learn from India’s EV policy | TechCabal

Senate rejects Bill to phase out petrol vehicles by 2035 - Punch Newspapers

Renewables - Energy Transition And The Future Of Oil In Nigeria

Connect with me on X: @angry__pacifist

You've probably heard of Proof of Work (PoW), especially if you've dabbled in the world of cryptocurrencies like Bitcoin or Litecoin. It's essentially the backbone of how these blockchain systems operate, facilitating the validation of transactions and the creation of new blocks on the blockchain. But if you're scratching your head wondering what exactly PoW entails, don't worry – I've got your back.

In a PoW system, miners compete to solve complex mathematical puzzles, requiring significant computational power. The first miner to solve the puzzle is rewarded with newly minted cryptocurrency and the opportunity to add a new block to the blockchain. This process not only ensures the integrity of the network but also incentivizes miners to contribute their resources to the network's security.

Think of it as a digital puzzle-solving race, where miners expend energy (in the form of computing power) to validate transactions and maintain the integrity of the blockchain. The difficulty of the puzzles adjusts dynamically to ensure a consistent rate of block creation, making PoW-based blockchains secure and resistant to malicious attacks.

Now, let's delve into Solana. Think of it as the wild west of blockchains – it's where anything seems possible and innovation knows no bounds.

One notable example of Solana's versatility comes from the ingenious mind of Hardhat Chad, a prominent developer in the Solana community. He employed the PoW concept in the token launch for his project, Ore. And let me tell you, this launch is turning heads. It's being hailed as one of the fairest token distributions yet. Intrigued? You can read more about the launch here.

In the upcoming sections, I'll walk you through the process of mining and participating in this token launch right from the comfort of your own home, using your trusty Windows machine.

There are already options available for starting your mining journey. You can begin mining through your browser by simply visiting the website using any device. Additionally, if you're using a Mac, you can download the desktop client for now. More platforms will be rolled out later to accommodate a wider range of users.

First things first – let's talk requirements. Here's what you'll need to get started:

• Rust Installer

• Node.js

• Code Editor

• Solana Wallet

Step 1:

Firstly, acquire a Solana wallet. It's advisable to create a new one and transfer a minimum of 0.01 SOL to this wallet. I recommend using Phantom. Once this step is completed, it's crucial to export the private key and keep it readily accessible, as you will require it later in the guide. Always remember never to share your passphrases or keys with anyone, as they are sensitive and vital for securing your assets.

Step 2:

Next, you'll need to set up the Rust environment manually. Begin by downloading the Rust installer and proceed with the installation process.

Please note that the application package relies on Microsoft Visual Studio build tools. If you don't already have it installed, you'll be prompted to download and install it during the Rust installation process. Alternatively, you can acquire it manually from here and install it before proceeding with the Rust installation.

Once you've completed the Rust setup, it's time to launch the Windows Command Line Interface (CLI). You can do this by searching for "Command Prompt" in the Start menu and clicking on it. Then, use the command cargo --version to check your Rust installation. If it displays the version information as shown below, you're good to go.

Step 3:

Now, it's time to install Node.js. Head over to the website and download the Node.js installer. Once the download is complete, proceed with the installation process.

After installing Node.js, you can verify the installation by typing node --version. This command will display the Node.js version installed on your system. If everything is set up correctly, you should see the version number displayed as in the image below.

Step 4:

Next, you'll want to obtain the official Ore source code. You can find it at Github. Download the source code by clicking on the "Code" button and selecting "Download ZIP". Once the download is complete, extract the contents of the ZIP file onto your desktop.

Alternatively, if you're comfortable using the command line interface, you can navigate to your preferred installation directory. For example, in this guide, we'll use the downloads folder. In the command prompt, navigate to your downloads directory by typing cd Downloads.

Once you're in the desired directory, clone the Ore repository by running the command git clone https://github.com/HardhatChad/ore-cli.git. This will create a local copy of the Ore source code on your machine. You should see a message like the one below indicating that the repository has been cloned successfully.

Step 5:

Now, let's navigate into the Ore CLI directory using the command line.
Type cd .\ore-cli\ to change into the Ore CLI directory.

Once you're inside the Ore CLI directory, it's time to compile the program. Run the command cargo build --release to initiate the compilation process.

Please be aware that this process may take some time depending on your system's specifications. You'll see various messages and progress indicators during the compilation process. Allow it to run until completion.

Step 6:

After the completion of the previous step, you'll need to navigate to the directory where your newly compiled program is located.
To do this, type cd .\target\release\ in the command prompt. This command will take you to the specified directory where the compiled program is stored.

Step 7:

Now, let's locate the directory where the compiled version of ore-cli is stored using your file explorer. Typically, this would be located at a path similar to C:\Users\user\Downloads\ore-cli\target\release, but please adjust accordingly based on your specific setup.

Once you've located the directory, open it. Within this directory, create two new files named generateKeypair.js and keypair.json, respectively. These files will be essential for the next steps in the process.

Step 8:

To proceed with this step, you'll need a code editor. Personally, I prefer to use Visual Studio Code (VSCode). If you don't have it already, you can download it from here.

Once you have VSCode installed, open the generateKeypair.js file in the editor. You can do this by launching VSCode and then either dragging the file into the editor window or using the "File" > "Open File" option to navigate to the file location and open it.

Next, paste the following code snippet into the generateKeypair.js file:

const { Keypair } = require("@solana/web3.js");
const bs58 = require("bs58");

(async () => {
  const secretKeyBase58 = "your_private_key_here"; // Replace your_private_key_here with your actual private key
  const secretKeyBytes = bs58.decode(secretKeyBase58);
  const keypair = Keypair.fromSecretKey(secretKeyBytes);
  
  console.log("Public Key:", keypair.publicKey.toBase58());

  // If you need to work with the Uint8Array representation of the secret key:
  console.log("Secret Key (Uint8Array):", keypair.secretKey);
})();

In the code snippet provided, you'll notice a placeholder text your_private_key_here. Replace this placeholder text with your actual private key, which you exported in Step 1 of this guide. Ensure to input your private key between the double quotation marks.

Once you've replaced the placeholder text with your private key, save the file. We'll use this code later in the process to generate your keypair.

Step 9:

After saving the generateKeypair.js file with your updated private key, return to your command prompt window.

First, run the following command to install the necessary packages:

npm install @solana/web3.js bs58

This command will install the required dependencies for the code to function properly. It may take a few minutes to complete. Once the installation is finished, you'll see a message like the one below, indicating success.

Next, execute the following command to generate your keypair:

node generateKeypair.js

Running this command will execute the JavaScript code in the generateKeypair.js file, generating your keypair. The output will consist of an array of numbers, which represents your keypair as seen in the image below.

Step 10:

Now that you've generated your keypair, it's time to save it for future use. Copy the keypair output that was displayed in your command prompt or terminal window.

Next, open the keypair.json file that you created in Step 7 using a text editor. Paste the copied keypair output into this file.

Ensure that the keypair output is properly formatted within the keypair.json file. Once you've pasted the keypair, save the file to preserve your keypair information for use in subsequent steps of the mining process.

Step 11:

Congratulations, you've successfully set up your mining environment! To commence mining, execute the following command in your command prompt or terminal:

.\ore --rpc https://linguistic-dulcea-fast-mainnet.helius-rpc.com --keypair keypair.json --priority-fee 1 mine --threads 8

Executing this command will initiate the mining process.

You'll observe output indicating the status of your miner. Be patient and allow the process to complete.

Please note that Solana's network may experience congestion at times, resulting in occasional failures. If you encounter any issues, simply rerun the command provided in this step to resume mining.

Step 12:

Occasionally, you may encounter errors like the one depicted below;

To rectify this, you'll need to utilize a custom RPC. For this guide, we'll utilize Helius. Begin by navigating to https://dev.helius.xyz and sign in using your preferred method. Here, I used my Phantom wallet and verified my identity via email. Once logged in, click on the "RPCs" menu.

On the RPC page, locate the desired RPC URL and copy it to your clipboard.

Next, navigate to your Ore installation directory. Open the src/main.rs file in Visual Studio Code (VSCode).

Within this file, locate the NETWORK_URL text. Under the default_value, replace the existing URL with the RPC link you copied from Helius.

Return to your command line interface and attempt to run the command again. This time, replace the URL in the rpc parameter with the copied URL from Helius.

Additionally, increase the priority-fee to 2 or your preferred value to expedite transactions. You can also adjust the number of threads from 8 to 16. While the exact function of this parameter is uncelar to me, I think its related to allocating your computer's memory resources for mining.

Here's the revised command:

.\ore --rpc YOUR_HELIUS_RPC --keypair keypair.json --priority-fee 2 mine --threads 16

Once you've made these adjustments, you should be all set to resume mining. Keep in mind that network issues may cause occasional failures. Simply rerun the commands as necessary to keep your miner operational.

Step 13:

To check your mined rewards, use the following command:

.\ore.exe --keypair keypair.json rewards

To claim your mined rewards, execute the following command:

.\ore.exe --keypair keypair.json claim

Extras:

If you find that your miner frequently stops due to network issues and you're tired of manually restarting it, you can utilize a Windows batch script created by Palinko to automate the process. Follow these steps to set it up:

1. Navigate to the directory where your ore-cli is located, typically .\ore-cli\target\release\.

2. Create a new file with the extension .bat. For example, you can name it autorun.bat.

   

3. Open the .bat file in Visual Studio Code (VSCode) or any text editor of your choice.

4. Paste the following code snippet into the file:

@echo off
echo Ore mining started...
:restart
ore --rpc RPC_URL --keypair keypair.json --priority-fee 1000 mine --threads 16
echo Ore miner restarts in 2 sec
timeout /t 2 /nobreak > nul
goto :restart

5. Replace RPC_URL in the code with your custom RPC from Helius.

6. Save the file.

To run your miner using this script, simply locate the autorun.bat file and double-click to launch it. This script will continuously run your miner, automatically restarting it whenever it stops, ensuring that your mining operations remain uninterrupted.

With this setup, you're all set to keep your miner running smoothly without the need for manual intervention.

And there you have it – you're all set.

If you've found this article enlightening and engaging, kindly express your support by liking and sharing it. Furthermore, should you come across any discrepancies or possess suggestions to enrich this discourse, we welcome your input in the comments section. Through collaborative efforts, we ensure the precision and relevance of the knowledge we share.

Subscribe now

Connect with me on X: @angry__pacifist

The Mad Lads PFPs are celebrated for their exceptional aesthetic appeal, showcasing diverse biological and unique human traits. Notably, the collection is known for arguably hosting the best female PFPs on Solana. Its consistent dominance in the Solana NFT landscape over the past year highlights its historical and cultural significance within the Solana ecosystem.

Why is this collection so important, you may wonder? And why should you care?
The significance of the Mad Lads NFT collection lies in its historical context and the innovation it represents within the Solana NFT ecosystem. To truly appreciate its importance, we need to delve into the background, understand its origins, and grasp why it holds such value and potential for the future.

Understanding xNFTs: The Birth of Coral and Backpack

The story begins with the inception of xNFTs (executable Non-Fungible Tokens), which revolutionized the concept of NFTs. Originally, NFTs were tokenized digital collectibles with limited utility, primarily popular among digital artists.
Then came xNFTs, which are non-fungible tokens embedded with executable code. These tokens grant ownership rights over their execution, enabling control over dynamic functionalities within decentralized applications (DApps) or smart contracts. This innovation expanded the possibilities of traditional NFTs, offering new ways for ownership and interaction within blockchain ecosystems.

However, a significant hurdle emerged: no existing wallet or product supported this standard for NFTs or facilitated these advanced interactions. Nonetheless, the potential of this idea was substantial enough to warrant the launch of a business venture. This led to the inception of Coral, the company behind the Mad Lads collection.
Tristan Yver and Armani Ferrante founded Coral, distinguished figures in the Solana community. Ferrante, in particular, had a storied history within the Solana ecosystem, having played pivotal roles in the development of key infrastructure such as Sollet (one of the first Solana wallets), the first CLOB (Central Limit Order Book) Serum, and perhaps most notably, Anchor, which stands as the most widely used development tooling in the entire ecosystem.

Backpack

Establishing a company was the initial stride toward realizing the vision of xNFTs. Subsequently, they developed a flagship consumer application to actualize this vision: Backpack.

Picture Backpack as similar to an operating system, such as iOS, where all your applications—except in this case, they're xNFTs—are stored.
xNFTs inject life into the traditional concept of NFTs. Instead of just having static images stored on a blockchain, why not encode functionality into these NFTs, turning them into portals for a wide range of experiences? In essence, rather than merely serving as access passes to token-gated content on other platforms or websites, xNFTs can contain interactive experiences and exclusive content that users can access directly through Backpack. This approach introduces a completely new paradigm for composability.

The concept proved promising, and Coral managed to secure $20 million in funding from FTX Ventures and Jump Crypto in September 2022 to develop this product.

However, fortune took an unexpected turn in November 2022 with the collapse of FTX, leaving customers stranded as their funds on the exchange became inaccessible. Regrettably, the Backpack team was among those adversely affected, losing a staggering $14.5 million to the collapse—equivalent to 88% of its operational capital.

As a result of the FTX-Alameda fallout, Solana's price dropped by over 90% due to its association with the crypto exchange. This led to a mass exodus of ecosystem participants. In December 2022, the top collections, Degods and Yoots, decided to leave the chain. Their migration was completed in March of 2023.

Mad Lads

Mad Lads emerged during a period of uncertainty in the Solana ecosystem when community morale was at its lowest, and user engagement was scarce. However, amidst this challenging backdrop, a small cohort of steadfast builders, including the Backpack team, remained steadfast in their belief in the technology and its potential.

Despite facing adversity, the Backpack team persevered, redoubling their efforts to advance their product.
Mad Lads served as a beacon of hope, revitalizing faith in the ecosystem and galvanizing entire communities to rally in support. They effectively countered the negative narratives stemming from the FTX associations.

You may wonder why would a product company venture into launching an NFT collection, and how does Mad Lads fit into this narrative?

In contrast to other profile picture projects, the Backpack team garnered significant community support by first dedicating time to develop a unique product before unveiling their NFT collection. Mad Lads serves as a testament to the possibilities unlocked by the technology the company had built, being the first-ever xNFT collection minted.

For a technology company operating within the crypto space, gaining distribution without resorting to paid promotion is exceptionally challenging. Few users are inclined to utilize on-chain applications without a compelling reason. Thus, the Backpack team recognized the need for a dedicated group of evangelists willing to bridge this gap.

Mad Lads transcends being a mere marketing ploy or revenue-generating endeavor; they represent the forefront of the Backpack team's vision. Positioned at the top of the consumer engagement funnel, Mad Lads serves as a rallying point for mass consumer interaction.
Moreover, Mad Lads go beyond passive NFT holders; they actively contribute to and participate in a larger community-driven movement. This sense of belonging fosters an environment where individuals are motivated to be part of something greater than themselves.

The primary objectives of Mad Lads are twofold:

1. Product feedback: The Backpack team gains valuable insights and feedback from the community by having an NFT collection closely integrated with the product.

2. Intentional bootstrapping mechanism: Mad Lads play a pivotal role in driving the adoption and usage of Backpack. They serve as a strategic tool for cultivating a network effect, fostering sustained growth beyond the initial hype.

In essence, Mad Lads serves as a decentralized cultural hub, enriching the ecosystem and facilitating the growth of the Backpack product through active community engagement and feedback loops.

The Mad Lads Mint

The Mad Lads mint marked a significant milestone as the first-ever mint conducted within the Backpack, creating a truly immersive and groundbreaking experience for participants. However, the journey leading up to the mint was equally remarkable. Here's how it unfolded.

Did you know, the collection was originally going to be named “ONE collection”?

The Blue Ball Era: Building Community

The cultivation of the Mad Lads community was a deliberate and strategic process, recognizing the paramount importance of community in the success of an NFT project. This community would eventually evolve into a cohort of power users for the suite of products developed by the Backpack team. The team sought both beta testers for their upcoming product and individuals passionate enough about the project to provide invaluable feedback.
The anticipation surrounding this groundbreaking product, promising to revolutionize the wallet and NFT experience, was palpable.

During the closed beta phase, access to the Backpack app was restricted to those with an invite code, obtainable exclusively through Twitter. With high demand, only the most creative and witty content or comments were selected to receive codes. Once chosen, recipients were greeted with a GIF depicting being struck by a blue dodgeball, adding an element of fun to the process.

Upon selection, users were welcomed into the Discord community, providing a platform for feedback and interaction. Additionally, they were granted an access code to claim a unique username within the app, streamlining the user experience and eliminating the need for cumbersome wallet addresses. This personalized username not only served as an identifier but also facilitated seamless interactions with other users and applications within the ecosystem

The Waiting Room Era: Community Engagement

As demand continued to surge, the team devised new strategies to streamline the onboarding process, leading to the introduction of the waitlist and waiting room.
Users were required to download the app extension from the Google Chrome Store and sign up for the waitlist, a pivotal step in gaining access to the platform.
Subsequently, they were ushered into a communal waiting room alongside other eager users.

What distinguished this phase was the introduction of the waiting room game, adding an element of excitement and engagement. Participants were tasked with guessing the prompt used to generate an AI-generated image or sound. This game not only fostered a sense of camaraderie among users but also leveled the playing field, offering everyone an equal opportunity to gain access to the app.

Access codes were distributed through various creative channels beyond the traditional methods. Among these were the renowned "moongame," engaging content challenges like "Lads and Lightning," Backpack Instagram stories, Solana Ecosystem Calls, strategic partnerships, and many more avenues.

The Madlist: Setting a New Standard

Before the Mad Lads mint, distributing whitelists (WL) for NFT projects primarily involved collaborations at best and, at worst, community members engaging in unsavory activities to secure WL spots. This approach was far from ideal and often resulted in inflated hype and engagement metrics. However, the Backpack team set themselves apart with their clear communication and transparency, offering a refreshing departure from the norms of the space. It was only fitting that their WL selection process followed suit.

Even before any promises of rewards or incentives, the product was already generating organic hype and attracting users. Then, the team made waves by announcing the launch of a 10,000-piece NFT collection, previously known as the ONE collection, alongside the introduction of the cult tagline WAO, standing for "WE ARE ONE!"
This announcement sent metrics for Backpack downloads skyrocketing, with over 69,000 downloads from the Google Chrome store alone by the mint date.

To sweeten the deal, the team announced that claiming for the Madlist (Whitelist) on February 28, 2023, would take place exclusively within Backpack. Moreover, individuals who had claimed a username before January 20, 2023, were automatically eligible for the whitelist—a move that further cemented the team's commitment to inclusivity and fairness.

This development caught many by surprise, intensifying interest and bolstering faith in both the project and the team behind it. The process of claiming the Madlist was exceptionally smooth, pushing boundaries and demonstrating the potential of what could be achieved within Backpack.

The Big Day: The Mad Mint

Then, on April 20, 2023, the mint took place within Backpack, marking one of the most significant events in Solana's history. Those who had been whitelisted through the Madlist had the opportunity to mint their NFTs a day prior. Priced at 6.9 SOL, the minting process was remarkably smooth and straightforward, underscoring the potential of Backpack and its xNFT technology.
Approximately 4,000 "rugs" (yes, literal rugs) were minted during the Madlist phase, leaving only 6,000 slots available to the public.

However, the following day presented unexpected challenges. Despite the anticipation surrounding the mint, excitement quickly turned to frustration as a distributed denial-of-service (DDoS) attack disrupted proceedings, with bad actors attempting to exploit the mint by flooding the contract with a barrage of transactions, rendering it inaccessible to legitimate users. As a result, the mint was postponed until the following day.

Undeterred, the team returned on the second day with a strategic plan to combat the bots and bad actors. They implemented a clever decoy mint to distract attackers while genuine users were able to proceed with minting. This tactic proved effective, as the decoy contract tricked attackers into expending over $250,000 without gaining anything in return. As a gesture of goodwill, the team generously refunded the bad actors' transactions, leading to a surge in project momentum.

Two hours later, the highly anticipated art reveal took place, showcasing the capabilities of xNFT technology in a gamified manner. The team employed a raid boss approach, transforming the reveal into a literal video game experience. The Mad King depicted as a raid boss with a substantial XP bar, was collectively attacked by holders, rapidly clicking on the image until the XP was depleted. Upon the Mad King's defeat, rug holders were able to locate their rugs on a giant rug image, revealing the art for the first time in an electrifying and unforgettable spectacle.

Post Mint: The Rise of Mad Lads

The journey of Backpack and the Mad Lads was just beginning, attracting attention from across various chains and ecosystems, with a particular spotlight on Solana. The Solana ecosystem experienced a resurgence of energy and vitality, with the Mad Lads community flourishing and confidence in the Solana blockchain being rekindled, especially given that xNFT technology was only possible on Solana

In the days following the mint, there was a whirlwind of activity to process. The newfound interest in the Solana chain and the Mad Lads collection propelled them to the top spot by volume, surpassing collections on every other chain. This included esteemed collections such as Bored Ape Yacht Club (BAYC), Cryptopunks, and Azuki.

Secondary sales soared, with subcommunities forming around specific traits. The Mad Skulls emerged as the most coveted trait, commanding the highest prices in the collection. Notably, one MadSkull NFT sold for an impressive 1000 SOL ($173,038.22) just seven days ago.

Following closely behind were the female PFPs, known as the Mad Lassies, along with other subcommunities like the Mad Androids and MadGalaxies. On average, there are 26 Mad Lads sales daily, generating an impressive volume of $800,000.

Additionally, honorary NFTs were distributed to key figures, leaders, and contributors within the Solana community, including individuals like Mert, Toly, Austin, and David. This gesture further solidified the sense of community and camaraderie within the ecosystem

Staking: A New Frontier

The Mad Lads revolutionized the concept of staking NFTs by introducing a novel approach. Unlike traditional views of staking as merely a product milestone, the Mad Lads recognized it as a potent tool and explored innovative avenues to leverage its potential. They understood the significance of community and customer loyalty, prompting them to develop a staking mechanism with arguably the most compelling loyalty rewards system in the entire crypto sphere.

Upon announcing staking, users could stake their Mad Lads directly within Backpack, eliminating the need to transfer them to a separate contract. Through this mechanism, Mad Lads staking became more than just a means of earning rewards; it became a measure of loyalty. Staked Mad Lads accrued points, with their value enshrined in a history marked by golden coins. This approach fostered a symbiotic relationship, rewarding users for their loyalty while also allowing other projects to target Mad Lads holders for high-profile partnerships. These partnerships not only targeted individuals but engaged with the entire Mad Lads community simultaneously, resulting in holders benefiting from some of the ecosystem's most significant airdrops, such as Pyth and Wormhole.

A well-designed reward funnel created a powerful loop, incentivizing users to remain active participants rather than passive observers. This, among other factors, solidified Mad Lads' reputation as the premier Solana NFT, driving community growth and fostering increased engagement among its holders.

The Mad Roster: Beyond Web3

Every Web3 project encounters a significant challenge: how to expand in a space where the user base is relatively small. Web3 users constitute a minority globally, with only a fraction deeply engaged in the crypto community. Recognizing this hurdle, the Mad Lads team understood that for crypto and Web3 to gain widespread adoption, they needed to reach beyond the confines of the crypto bubble and cater to a global audience. They aimed to make Backpack and its intuitive UX accessible to those venturing into Web3, inspiring people to care about the technology and embrace on-chain applications.

To achieve this ambitious goal of expanding their reach beyond the crypto sphere, the Mad Lads team adopted a marketing strategy akin to Red Bull's approach, leveraging extreme sports to promote their products. They introduced the Mad Roster campaign, a curated selection of top content creators, professional athletes, and individuals from diverse fields. By sponsoring these individuals, the team aimed to create compelling content that would resonate with a broader audience, fostering brand affinity and raising awareness beyond the crypto demographic.

Mad Lads sought to become synonymous with Web3 adoption, positioning themselves as the leading brand in the space and serving as the vanguard for Backpack's broader vision. For those who encounter Mad Lads before delving into Web3, the brand serves as a trusted leader and a gateway into this new realm. As users engage with Mad Lads’ content and become familiar with the brand, they are gradually introduced to the suite of products offered by Backpack, including its flagship wallet. Ultimately, Mad Lads aspire to be more than just an NFT collection; they aim to be a catalyst for Web3 adoption and a guiding force in the journey toward decentralization.

Future Outlook: Charting the Course Ahead

At this juncture, the ascent of Backpack and Mad Lads is undeniably exponential, poised to endure for the long haul. Their achievements thus far are impressive: they've developed mobile wallets for both Android and iOS, established a Solana validator to fortify the network's security, and at the Breakpoint of 2023 in Amsterdam, unveiled X—a centralized exchange. This exchange aims to address lingering issues left unresolved by previous centralized exchanges following the FTX collapse, notably the challenge of self-custody. Despite encountering hurdles along the road to success, the exchange garnered significant interest, with over 90,000 individuals signing up for the waitlist. During its beta phase, it processed over $27 billion in trading volume.

Moving forward, Backpack's focus remains squarely on execution across various fronts. Product distribution ranks as a top priority for the company, with Mad Lads positioned at the forefront. As an integral part of the community, individuals play a pivotal role in shaping the features, experiences, and essence of Backpack. Mad Lads serve as the cultural cornerstone and distribution channel for Backpack's tooling, embodying the spirit of innovation and inclusivity. Furthermore, all of Backpack's on-chain products, except the exchange, are open-sourced, underscoring their commitment to transparency and collaboration within the ecosystem.

Conclusion

The Mad Lads’ success lies in their ability to blend Web3, innovative products, top-notch art, global brand awareness, and a tight-knit community supporting a talented team.
Mad Lads represents more than just an NFT collection; it embodies a community-driven approach to innovation. Though the journey has been arduous, it has been nothing short of extraordinary.
Happy Anniversary in advance MadLads!

If you've found this article enlightening and engaging, kindly express your support by liking and sharing it. Furthermore, should you come across any discrepancies or possess suggestions to enrich this discourse, we welcome your input in the comments section. Through collaborative efforts, we ensure the precision and relevance of the knowledge we share.

Subscribe now

Connect with me on X: @angry__pacifist

Introduction to Solana

What is Solana?

Solana is a highly performant blockchain known for its unparalleled transaction speeds and minimal fees. It was developed to address the scalability challenges encountered by earlier blockchains such as Bitcoin and Ethereum, without sacrificing security or decentralization. This is achieved through its unique Proof of History (PoH) consensus mechanism.

Founded in 2017 by Anatoly Yakovenko and Raj Gokal, Solana aims to provide a scalable and user-friendly platform for the world. It offers an infrastructure that supports Decentralized Applications (DApps), enhancing efficiency and utility across various applications

Why Solana?

With its ability to process thousands of transactions per second at negligible costs, Solana presents an ideal environment for Decentralized Finance (DeFi) projects, Non-Fungible Tokens (NFTs), gaming, and more. This makes it an attractive platform for a broad spectrum of blockchain applications.
The growing ecosystem is a testament to its reliability, attracting both developers and users.
Solana is home to a diverse range of applications that leverage its high-speed infrastructure.

Getting Started with Solana

Engaging with the Solana ecosystem can be approached in several ways, but this guide will concentrate on the aspects of ease of use, great user experience, and user-friendly platforms.

Setting Up a Wallet

To interact with the Solana ecosystem, you'll require a digital wallet. While there are several popular options like Phantom, Solflare, and Backpack, this ultimate guide will introduce you to the "Ultimate Wallet," a mobile-focused and exceptionally user-friendly wallet.

Download and Install: Visit the official website and click the download button. You will be redirected to the appropriate app store (Google Play for Android users and App Store for iOS users), where you can download the app onto your mobile device.

Create a New Wallet: Open the app after installation and select the option to create a new wallet. Follow the steps below to complete the setup process:

Acquiring SOL: To start using Solana's services or investing in its ecosystem, you'll need some SOL, the native cryptocurrency.
Within your wallet, click on the “Deposit” option. You'll be presented with multiple purchase options. Once you've successfully purchased SOL and deposited it into your wallet, you're ready to begin exploring.

Exploring DApps: Solana's ecosystem is brimming with innovative Decentralized Applications (DApps). From DeFi platforms to NFT marketplaces, there's a vast array of options to explore. For ease of access, the Ultimate Wallet features an integrated DApp browser. This browser lists verified Solana DApps for enhanced security and reliability. To discover these applications, simply click on the browser icon within your wallet and use the search bar to find DApps that interest you.

Back-Up your Wallet: Cryptocurrency wallets don't store your digital assets; instead, they hold the private keys necessary to access those assets on the blockchain. Losing access to your wallet without having a backup means permanently losing access to your cryptocurrencies. Therefore, backing up your wallet is a critical step to ensure that you can recover your assets in the event of device failure, loss, or theft.
Follow the steps below to back up your newly created wallet:

Navigating the DeFi Landscape

The DeFi ecosystem on Solana is a rapidly evolving landscape, brimming with opportunities for yield, innovation, and financial empowerment.
Let's delve into what DeFi on Solana encompasses and how you can actively engage with it.

What is DeFi?

DeFi, short for Decentralized Finance, represents a shift from traditional, centralized financial systems to peer-to-peer finance enabled by decentralized technologies built on blockchain networks, with Solana being a prominent player. DeFi leverages smart contracts to create protocols that replicate existing financial services in a more open, interoperable, and transparent way.

DeFi on Solana distinguishes itself through the blockchain's architectural advantages, ensuring a seamless user experience even during market volatility when traditional Ethereum-based DApps might suffer from congestion and high fees.
Additionally, there are cost benefits to using DeFi on Solana, as transaction fees are a fraction of a cent, making it economically feasible to partake in DeFi activities that necessitate frequent transactions.

Using DeFi Platforms

Engaging with DeFi platforms on Solana can be an exhilarating journey into financial autonomy, but it's essential to understand the basics of interacting with these platforms.

How to Swap Tokens:

Swapping tokens is a fundamental DeFi activity, allowing users to exchange one cryptocurrency for another without using traditional exchanges.
In your Ultimate wallet, navigate to the DApp browser, then search for an app named Jupiter, Solana’s #1 user-friendly Decentralized Exchange (DEX). Launch the app and connect your wallet to the DEX.

• Select the tokens you wish to swap (e.g., SOL to USDC).

• Enter the amount to swap and confirm the transaction.

• Approve the transaction in your wallet, and the swap will be executed, with the new tokens appearing in your wallet.

  

How to Lend and Earn Interest:

Lending in DeFi presents a potent opportunity to earn interest on your digital assets by providing them as loans to other users. Solana's lending platforms operate by establishing liquidity pools of various cryptocurrencies from which users can borrow, subject to certain conditions and collateral requirements. Lenders contribute to these pools and earn interest payments based on the demand for borrowing the assets they've supplied.

To initiate Lending:

• Navigate to your DApp browser and search for an app named Kamino, known as Solana’s premier liquidity destination.

• Launch the app and connect your wallet.

• Select the cryptocurrency you wish to lend and enter the amount to deposit, then confirm the transaction in your wallet.

• Once your assets are deposited, you'll begin accruing interest based on the current rates.
  Monitor your lending position through the dashboard to track your earnings and any changes in interest rates.

• You have the flexibility to withdraw your lent assets and the earned interest at any time, subject to the platform's terms and liquidity conditions.
  When you're ready, initiate a withdrawal request and confirm the transaction in your wallet.

  

How to Provide Liquidity and Earn Rewards:

Providing liquidity involves depositing a pair of tokens into a liquidity pool to facilitate trading on a DEX, earning rewards in return:
In your Ultimate wallet’s DApp browser, navigate to Kamino. Launch the app and connect your wallet.

• Access the Liquidity section of the platform.

• Choose a liquidity pool that matches the tokens you hold and wish to provide as liquidity.

• Deposit your tokens into the pool and approve the transaction. (In Kamino, you can deposit a single token, and the rest is automated)

• As trades occur within your pool, you'll earn a portion of the trading fees, accruing rewards over time.

  

While participating in DeFi can be lucrative, it's crucial to be aware of the risks involved, such as smart contract vulnerabilities, impermanent loss, questions regarding platform solvency, and market volatility.
There are many more DeFi activities you can participate in, but for the sake of this guide, we’ll limit it to the basic ones.
Ultimately, as you evolve from a beginner to a power user, you'll discover that the breadth of your DeFi engagements, while potentially broadening, remains well-supported by the foundational platforms highlighted in this guide.

Diving into NFTs

Before diving into the specifics of NFTs on Solana, it's essential to grasp what NFTs are and why they've become a significant part of the digital and creative worlds.

Non-fungible tokens (NFTs) are digital assets that represent ownership or proof of authenticity of a unique item or piece of content using blockchain technology. Unlike cryptocurrencies like Bitcoin or Solana's SOL, which are fungible, meaning each unit is the same as every other unit, NFTs are one-of-a-kind. Each NFT has distinct properties and cannot be exchanged on a one-to-one basis with another NFT.
NFTs can represent a wide range of unique tangible and intangible items, from digital art and music to collectibles, virtual real estate, and more.

On Solana, the NFT ecosystem is expansive, offering a dynamic platform for artists, collectors, and enthusiasts alike. This makes it an exciting place for exploring the world of digital ownership and creativity.

Collecting NFTs

There are numerous ways you can interact with NFTs on Solana, with equally many prominent marketplaces. However, for the sake of this guide and to focus on ease of usage, let's explore how to get the most out of your experience.

A reliable, low-cost way to experience NFTs is via Drip Haus, a creator economy platform. Drip is home to a range of creators spanning art, video, music, photography, and podcasts.
To get started with DripHaus:

• Open your DApp browser and search for an app named "Drip Haus."

• Launch the app and click on “start collecting” to connect your wallet. Then, approve the transaction signature.

• You'll be prompted for an invite code if you're a first-time user. However, access is still possible if your wallet has a balance of more than 0.1 SOL.

• Proceed to create your profile. As a welcome gesture, you'll receive some free droplets, which are used within the app's economy.

• You can buy more droplets if you wish and subscribe to creators on the platform. This way, you'll start receiving their creations directly in your wallet at the set frequency.

• Additionally, you can support creators and their work by tipping them in droplets.

Buying NFTs:

Collecting NFTs can also be done by purchasing them directly from a marketplace. While there are many options available, our focus remains on convenience and user-friendliness. For this purpose, we recommend using Magic Eden, a leading Solana marketplace for trading NFTs.

To buy NFTs on MagicEden:
Open the Magic Eden DApp in your wallet's browser.

• Connect your wallet and approve the signature to proceed.

• Navigate to the Solana section of the platform to begin.

• Explore the top collections on Solana or browse through the extensive list of NFTs available on the blockchain.

• When you find an NFT that catches your interest, click on it to view more details.

• Proceed with the purchase if you decide to buy the NFT.

  

Important Note: Shopping for NFTs on marketplaces requires some research and due diligence. Some NFTs offer community perks or utilities, while others may be valued for their historical significance or artistic merit. It's highly advisable to understand what you're buying before making a purchase.

Selling NFTs:

If you have NFTs you're interested in selling, you can easily list them on the marketplace by setting your desired price. Once a buyer shows interest and purchases your NFT, the sale proceeds will be automatically transferred to your wallet.

Participating in the Solana Community

The Solana ecosystem, like many in the crypto world, thrives on a vibrant and active community that spans various platforms. Engaging with this community and staying informed is essential for maximizing your experience within the Solana ecosystem, as well as ensuring your digital assets remain secure.

The Importance of Community in Crypto

The community is the lifeblood of any crypto project. It's a gathering place for users, developers, investors, and enthusiasts to share information, collaborate on projects, and support each other. A strong community can drive the platform's adoption, provide valuable feedback to developers, and assist new users in navigating the ecosystem. In the decentralized world of crypto, the community often plays a critical role in governance and decision-making processes.

Solana's pace is rapid, and so is its community's. Keeping up can be challenging. Below is a non-exhaustive list of Solana communities and accounts you might consider following or joining to stay updated and enhance your experience on Solana:

• Official Solana Channels:

  • Twitter

  • Website

  • Discord

  • Reddit

  • Telegram

• Solana Collective: A community of contributors in the Solana ecosystem created by the Solana Foundation. The mission is straightforward: to create a space for Solana's best to network and grow, thereby strengthening the ecosystem. Whether you're into content creation, community organizing, or coding, The Collective offers a haven from the daily drama. Joining is gated but simple. Transitioning from a 'prospect' to a full-fledged member involves passing a 20-question 'bootcamp' on basic Solana knowledge. It's more of an initiation than a barrier.

  • Twitter

  • Discord

• Superteam: Dubbed the Grail of Solana communities, Superteam is a global community of top talent learning, earning, and building in Web3. It's a pool of developers, creatives, operators, and builders assisting promising Solana ecosystem projects in launching and growing. With 13 Superteam chapters across different global regions, membership is earned by contributing to the ecosystem in any capacity—from coding to designing to writing.
  Superteam hosts Solana’s largest bounty platform, Superteam Earn, where participants can contribute to the ecosystem’s growth in various capacities and get compensated. It's also the venue for the ecosystem’s most significant monthly event, The Solana Ecosystem Call, which recaps ecosystem happenings and shares updates, among many other offerings.
  Superteam is THE community for anyone serious about Solana.

  • Website

  • Twitter

• LamportDAO: The hub for Solana Developers, LamportDAO is home to some of the best developers in the ecosystem.
  For those inclined towards development, Solana offers a robust environment with tools and languages suited for developers eager to build on the platform. LamportDAO is also known for hosting some of Solana’s notable community-driven hackathons. If you're looking to start with Solana development, contribute to open-source projects, or connect with existing developers and mentors, LamportDAO is the community to join.

  • Twitter

  • Discord

Keep Up with Solana Updates and News

Staying informed about the latest updates and news in the Solana ecosystem is essential for both maximizing your engagement and ensuring your investments are secure. Besides the community platforms mentioned above, consider the following:

• Subscribe to the official Solana newsletter for the latest official announcements.

• Subscribe to the Superteam Blog for in-depth and comprehensive articles.

• Follow Solana Developers on Twitter for updates on development.

• Engage with Conference and Hackerhouses accounts to participate in Solana-related events, which offer fantastic opportunities to learn from experts and meet other community members.

• Follow Solana Floor and Degen News for news, insights, and analysis.

• Listen to Solana Weekly, Lightspeed, Unlayered, Validated, and the Superteam for insightful podcasts.

Beware of Scams

The crypto space, including Solana, is prone to scams and malicious activities. Staying aware and vigilant is your first line of defense against common scams such as phishing attacks, fake airdrops, and impersonation.

• Be cautious with emails or messages asking for your private keys or seed phrases. Always verify the URLs of websites you visit.

• Be skeptical of fake airdrops or giveaways that require you to send crypto or connect your wallet to a suspicious website. If it seems too good to be true, it usually is.

• Scammers may pretend to be Solana officials, developers, or community leaders. Always check the identity of people in direct messages or emails, especially if they request sensitive information or promote unexpected offers.

Enhancing Your Security

• Use Hardware Wallets: For additional security, consider using a hardware wallet to store your SOL and other assets, particularly if you have a substantial amount.

• Enable Two-Factor Authentication (2FA): Apply 2FA on your accounts wherever possible to add another security layer.

Advanced Exploration (Optional)

Staking SOL

For those looking to dive deeper into the Solana ecosystem, participating in staking is an advanced area that offers both growth and contribution opportunities. Staking your SOL tokens not only helps secure the network but also earns rewards.
By staking SOL, you're contributing to the network's decentralization and resilience against attacks, making the ecosystem stronger and more secure.

How to Stake SOL:

For staking, we recommend using Marinade Finance, a leading platform known for its user-friendly staking solutions on Solana.

• In your wallet’s browser, search for a dApp named Marinade and launch it.

• Connect your wallet. You will then see your dashboard.

• Click on "Stake more SOL".

• You will be presented with two options: “native” or “liquid”.

  • Choose "native" if you plan to stake long-term and won't need access to your funds.

  • Select "liquid" if you prefer to stake while maintaining liquidity, allowing you to participate in the DeFi activities mentioned earlier in this guide.

• Enter the amount you wish to stake and click on "stake".

• Approve the transaction to finalize the staking process.

  

Conclusion

You've just scratched the surface of what Solana has to offer. With its robust infrastructure and vibrant community, the possibilities are endless. Remember, the world of blockchain is always evolving, so continue exploring, learning, and staying engaged with the community.

As you delve deeper into the ecosystem, let your curiosity drive you, and don't hesitate to seek support from the community. Welcome to Solana!

If you've found this article enlightening and engaging, kindly express your support by liking and sharing it. Furthermore, should you come across any discrepancies or possess suggestions to enrich this discourse, we welcome your input in the comments section. Through collaborative efforts, we ensure the precision and relevance of the knowledge we share.

Subscribe now

Connect with me on X: @angry__pacifist

Among the key players catalyzing this shift is Solblaze, a protocol that has rapidly ascended to prominence within Solana's DeFi ecosystem. Solblaze distinguishes itself through its novel liquid staking solutions, meticulously designed to optimize capital efficiency and enhance network participation.

Solblaze's innovative approach to liquid staking has not only addressed capital inefficiency but has also contributed significantly to the network's liquidity and security.

Understanding Staking and Its Significance on Solana

To fully appreciate Solblaze's impact, it's essential to grasp the fundamentals of staking and its pivotal role in Solana's infrastructure.

Solana employs a hybrid consensus mechanism, integrating Proof of History (PoH) with Proof of Stake (PoS), leveraging staking as a core mechanism to secure the network and validate transactions.

In this model, participants, or stakers, commit their SOL tokens to validators, who, in turn, facilitate network operations and transaction verifications.
Stakers are rewarded for their contributions with additional tokens, aligning their interests with the network's overall health and security.

The Imperative for Liquid Staking

Despite its benefits, traditional staking presents a significant challenge: liquidity. Staked assets become illiquid for a duration known as an 'epoch,' rendering them inaccessible for other uses. Liquid staking emerges as a solution to this dilemma, offering stakers liquid stake tokens (LSTs) that represent their staked assets. These tokens maintain the staking benefits while providing the flexibility to engage in other DeFi activities.

Solblaze: A Closer Look

Solblaze introduces BlazeStake as its flagship product, a user-friendly, open-source and non-custodial liquid staking solution designed for the Solana ecosystem.
By staking SOL through BlazeStake, users receive bSOL, a token that reflects the value of their staked SOL within the Solblaze pool.

BlazeStake employs an algorithmic delegation strategy, distributing staked SOL across over 200 high-quality validators, democratizing access to staking rewards and contributing to a more decentralized and secure network.
The protocol actively manages staked assets to optimize yields, mitigate risks associated with validator performance, and ensure continuous reward accrual.

By broadening the validator base, BlazeStake contributes to increasing Solana's Nakamoto Coefficient, a critical measure of blockchain decentralization.

As the network progresses through each epoch, the rewards generated from staked SOL are added to the bSOL/SOL liquidity pool, incrementally increasing bSOL's value relative to SOL. So you get more SOL for the same value of bSOL.

Pathways to Liquid Staking with Solblaze

Solblaze recognizes the diverse preferences of its users, offering multiple avenues for liquid staking

BlazeStake: The primary pathway where users stake SOL and receive bSOL.
The stake is then delegated to over 200 high-performing validators, forming 80% of the Blazestake algorithmic delegation strategy. The bSOL obtained can be utilized across various DeFi protocols, including lending and liquidity provisioning, to maximize yield on top of staking rewards.

Custom Liquid Staking: Custom Liquid Staking enables users to back their preferred validators with bSOL while maintaining liquidity. This includes validators outside the super minority or those typically not receiving stake from the standard Blazestake delegation. Through the BlazeBoost program, users can ensure their preferred validators receive additional stake from Blazestake, constituting 10% of the Solblaze standard delegation. This offers a supportive avenue for validators embracing Blazestake.

BLZE Gauges: A novel feature empowering the Solblaze DAO and BLZE token holders to influence the delegation of 10% of the protocol's stake through a unique gauge-based voting system, promoting governance participation and validator diversity.

The Advantages of Liquid Staking with Solblaze

Decentralization: Solblaze's algorithmic management of staked SOL across a broad spectrum of validators, both large and small, plays a crucial role in promoting network decentralization. By distributing stakes more evenly across the validator landscape, Solblaze not only enhances the security and robustness of the Solana network but also supports smaller validators who might otherwise struggle to compete with larger entities. This approach aligns with the broader ethos of blockchain and DeFi, aiming to create a more equitable and decentralized ecosystem.

Yield Optimization and DeFi Integration: One of the standout features of Solblaze is its ability to unlock additional yield opportunities for stakers. By receiving bSOL in exchange for staked SOL, users can participate in a variety of DeFi protocols, leveraging their assets for lending, liquidity provisioning, and other yield-generating activities.

This layered yield strategy, compounded with the inherent staking rewards, presents a compelling value proposition for SOL holders. Additionally, bSOL's extensive integration with leading DeFi platforms compared to its competitors ensures that users have multiple avenues to optimize their earnings, further enhancing the liquidity and utility of bSOL within the Solana ecosystem.

Mitigating Risks and Ensuring Liquidity: The liquid staking model introduced by Solblaze addresses several risks associated with traditional staking, such as validator downtime, performance issues, and the risk of 'commission rugging'.
By dynamically reallocating stakes away from underperforming or unreliable validators, Solblaze ensures that users' assets continue to generate rewards consistently. Furthermore, the instant liquidity provided by bSOL tokens means that users can respond swiftly to market movements or personal liquidity needs without having to wait for unstaking periods, significantly reducing the opportunity cost of staking.

Security: Security is paramount in the DeFi space, and Solblaze has demonstrated its commitment to maintaining the highest standards of security through multiple comprehensive audits conducted by reputable firms. This rigorous approach to security not only protects users' assets but also builds trust within the community, a critical factor for the adoption and success of any DeFi protocol.

The Economic and Network Implications of Liquid Staking with Solblaze

The advent of liquid staking, particularly through platforms like Solblaze, has far-reaching implications for Solana's network economics and the broader validator ecosystem. By lowering the entry barriers for both stakers and potential validators, Solblaze democratizes participation in network security and consensus processes. This inclusivity can lead to a more vibrant and competitive validator landscape, ultimately benefiting the network's security and performance.

Supporting Independent Validators: The high start-up costs associated with becoming a validator on networks like Solana can be prohibitive, with significant SOL holdings required to become economically viable. Solblaze's model, particularly through features like custom liquid staking and BLZE Gauges, offers a lifeline to smaller or emerging validators. By directing staking power towards these entities, Solblaze not only aids in their economic sustainability but also contributes to a more decentralized and resilient network infrastructure.

Driving Total Value Locked (TVL) and Network Growth: The liquid staking solutions provided by Solblaze have the potential to significantly impact Solana's Total Value Locked (TVL), a key metric reflecting the health and activity level of the DeFi ecosystem. As more SOL holders engage in liquid staking, the increased liquidity and capital efficiency could fuel further growth in TVL, attracting additional projects and investment to the Solana ecosystem.

Additionally, the integration of liquid stake tokens like bSOL into various DeFi protocols and potentially NFT marketplaces could create new economic loops and synergies, further propelling Solana's growth and adoption.

Conclusion

Solblaze is at the vanguard of Solana's liquid staking revolution, offering a compelling blend of security, liquidity, and yield optimization. By addressing the liquidity constraints of traditional staking and fostering a more decentralized and inclusive validator ecosystem, Solblaze not only enhances the individual staker's experience but also contributes to the broader health and vitality of the Solana network.

As the DeFi landscape continues to evolve, the innovative solutions and community-driven approach of Solblaze will undoubtedly play a pivotal role in shaping the future of the Solana Network.

If you've found this article enlightening and engaging, kindly express your support by liking and sharing it. Furthermore, should you come across any discrepancies or possess suggestions to enrich this discourse, we welcome your input in the comments section. Through collaborative efforts, we ensure the precision and relevance of the knowledge we share.

Subscribe now

Connect with me on X: @angry__pacifist

In the cryptocurrency space, where regulatory oversight is often limited, project founders wield significant influence over the direction of their projects. They have the authority to introduce, modify, or remove features, alter the project's trajectory, make substantial investments on behalf of the protocol, or even cease operations without requiring external approval.
Some projects have implemented decentralized governance models, such as Decentralized Autonomous Organizations(DAOs) to establish greater credibility and inclusivity. These frameworks allow users to have a voice in decision-making processes, and the weight of their input is often determined by their level of investment in the project.

Understanding DAOs

A DAO, or Decentralized Autonomous Organization, represents a groundbreaking way to organize human activities using blockchain technology. Instead of relying on human management, DAOs are governed by code and are collectively owned and operated transparently by their members.

The potential applications of DAOs are diverse, ranging from managing shared funds to functioning as fully-fledged businesses. They are inclusive and open to anyone, anywhere, without the need for a central authority. DAOs provide a novel approach to collaboration and value creation, independent of traditional institutions.
Members trust each other to act in the collective best interest and adhere to the organization's rules, which are transparent and enforced by code, minimizing the potential for manipulation or corruption.

A key advantage of DAOs lies in their democratic foundation, enabling individuals from diverse backgrounds worldwide to collaborate on large-scale projects with substantial financial impact, requiring only a single governance token and an internet connection.

Challenges Facing DAOs

However, DAOs encounter significant hurdles. The current DAO model often leads to a "too many cooks in the kitchen" scenario, creating alignment issues where individual actions may detrimentally impact the collective good. Despite the decentralized label, power within many DAOs is disproportionately held by a few, undermining the core principles of transparency and accountability.

Apathy among voters poses another challenge. With little incentive to engage in governance, decision-making often falls to a small, non-representative segment of the community, compromising the quality of outcomes. Additionally, the complexity and time demands of the voting process can hinder swift decision-making and adaptability.

Expertise gaps within the membership can also impede informed decision-making, stalling progress towards organizational objectives. Moreover, despite the democratic foundation of DAOs, the reality often reflects a disparity between control by token holders and the actual decision-making carried out by core contributors, questioning the decentralized and autonomous nature of these organizations.

The Meta-DAO concept developed by proph3t emerges as an innovative solution to the challenges faced by traditional DAOs. It introduces a layer of meta-governance that employs futarchy—a decision-making framework that leverages speculative markets to guide decisions based on their predicted outcomes rather than direct voting on the proposals themselves.

The Need for an Alternative: Meta-DAO and Futarchy

Futarchy is a form of government proposed in the early 2000s by economist Robin Hanson, in which decisions are made based on predictions about their outcomes. The basic idea is to use prediction markets to guide policy decisions: if a proposed policy is expected to improve a predefined national welfare metric, then the policy is adopted.

In a futarchy, when a policy needs to be decided upon, bets are placed on whether implementing a particular policy will increase or decrease the welfare metric, such as GDP, health outcomes, or any other measure that the government decides to use. Market participants would buy and sell contracts based on their predictions of the policy's outcome, and the policy with the most favorable market forecast would be implemented.

The underlying principle of futarchy is to "vote on values, but bet on beliefs." This means that while the overall goals and values of the society (like maximizing health or wealth) are determined democratically through voting, the decisions on how to achieve these goals are made based on collective intelligence and information aggregated through betting markets.

How the Meta-DAO Implements Futarchy

The Meta-DAO is the first practical implementation of futarchy in the history of human civilization.
This implementation is made possible through a set of open-source programs on the Solana blockchain.

• Conditional Vault Program: Handles the creation of conditional tokens, which are essential for simulating the reverting of trades, a key aspect of futarchy.

• TWAP (Time-Weighted Average Price) Program: Provides a manipulation-resistant way to measure the average price of tokens over time, used to determine the outcome of proposals.

• Autocrat: Orchestrates the futarchy process by managing proposals, creating conditional vaults, and executing decisions based on market outcomes.

• META: The native token within the Meta-DAO ecosystem

The Meta-DAO operates on top of OpenBook V2's central limit order book, utilizing its trading infrastructure.

Key Processes:

1. Conditional Tokens via Conditional Vaults:

   • Conditional vaults are set up for each proposal, tied to an underlying token (META or USDC) and the Meta-DAO as the settlement authority.

   • Participants deposit tokens into these vaults and receive two types of conditional tokens: one redeemable if the proposal passes (conditional-on-pass) and one if it fails (conditional-on-fail).

   • The settlement authority (Meta-DAO) can finalize or revert these vaults, determining which set of conditional tokens can be redeemed for the underlying tokens.

     

2. Decision Markets for Proposals:

   • For each proposal, two markets are created: one for trading conditional-on-pass tokens and another for conditional-on-fail tokens.

   • This setup allows market participants to speculate on the value of tokens based on the outcome of the proposal, reflecting their belief in whether the proposal should pass or fail.

     

     Here's why conditional markets are crucial in this setup:

     • Isolation of Decision Effects: Conditional markets allow participants to speculate on the outcome of a particular decision in isolation, independent of other external market factors. This focused speculation provides clearer insights into the collective market sentiment regarding the decision at hand.

     • Simulating "What-If" Scenarios: By creating separate markets for each potential decision outcome, futarchy enables participants to effectively bet on the consequences of each scenario. This simulation of "what-if" scenarios helps in understanding the potential impact of each decision on the organization's value.

     • Reverting Trades: A unique feature of conditional markets in the Meta-DAO's futarchy model is the ability to "revert" trades based on the decision outcome. Since blockchains typically do not allow the reversal of transactions, conditional markets use a mechanism where trades are made in conditional tokens that can be redeemed based on the outcome. This ensures that participants are effectively betting on the outcomes without permanent financial commitment unless the decision aligns with their speculation.

     • Reducing Market Manipulation: Real markets are influenced by a wide range of factors, including economic indicators, global events, and market sentiment. Conditional markets, by focusing solely on the decision at hand, reduce the noise and potential for manipulation that can arise from these external factors.

3. TWAP Calculation:

   • The Meta-DAO's TWAP program calculates the average price of tokens over time, ensuring that this measure is resistant to manipulation.

   • This average price is used to assess the market consensus on proposals.

4. Proposal Management with Autocrat:

   • Proposals are created and managed through the Autocrat program, containing details like the proposal number, description, and executable instructions for the Solana Virtual Machine (SVM) if the proposal passes.

   • After a set period (currently set to 5 days), the outcome of the proposal is determined by comparing the TWAP of the pass and fail markets. The Autocrat program then executes the proposal if the pass market's TWAP is higher (by at least 5%) or marks the proposal as failed otherwise.

Advantages of Meta-DAO's Governance Model

The Meta-DAO’s implementation of Futarchy offers several advantages over traditional forms of governance.

Information Aggregation: Prediction markets can aggregate diverse information from a wide range of participants. They efficiently incorporate all available information, including private and insider information, into the decision-making process.

Incentive Alignment: Participants in prediction markets have financial incentives to accurately predict outcomes. This leads to more accurate and unbiased forecasts about the effects of policies, as participants stand to gain from making correct predictions.

Reduced Bias and Corruption: Since policy decisions are based on market predictions rather than direct human decision-making, there is less room for biases, lobbying, and corruption to influence policy outcomes. The focus is on measurable outcomes, not on who supports or opposes a policy.

Decentralized Decision-Making: Futarchy decentralizes decision-making by allowing anyone who participates in the market to contribute to policy decisions. This could democratize policy-making and harness the collective intelligence of a larger group of people, beyond just elected officials or experts.

Focus on Outcomes: By tying policy implementation to specific, measurable outcomes, Meta-DAO ensures that government actions are always aimed at improving the predefined welfare metrics. This results-oriented approach helps in keeping the government's focus on tangible benefits for the organization.

Adaptability and Experimentation: Futarchy allows for rapid feedback and adjustment. Policies that are predicted to be unsuccessful won't be implemented, and the success of implemented policies can be continuously evaluated through markets, allowing for quick adaptation and experimentation.

Limitations and Future Outlook

The essence of the Meta-DAO experiment is to transcend the limitations of existing governance structures by leveraging the predictive power of markets. If the futarchy model proves successful, it could set a precedent for organizations seeking a more dynamic and responsive governance model, contingent upon the critical ability to assign value to decision outcomes.

However, this approach is not without its challenges. The phenomenon known as the "Keynesian Beauty Contest" a critique often leveled at market-based systems, highlights the risk of speculative decision-making driven not by intrinsic value but by anticipations of future market behavior. This critique, while pertinent to general markets, especially within the volatile realms of cryptocurrency, does not inherently undermine the Meta-DAO's foundation, thanks to its commitment to fostering a community grounded in rationality, thereby mitigating the risks associated with irrational speculative behavior.
This commitment is evident in the market's response to the most controversial proposal to date, proposal 6.

The Meta-DAO aims to position itself as a pivotal entity, a central DAO with the overarching objective of enhancing cash flow within economic organizations. This goal underscores a broader vision of redefining economic coordination and governance through a symbiotic fusion of decentralized decision-making and market-driven insights.

Conclusion

Decentralized governance represents a significant evolution in how collective decisions are made, offering a more transparent, inclusive, and efficient alternative to traditional centralized models. DAOs and innovations like the Meta-DAO and futarchy provide promising frameworks for harnessing the collective wisdom and aligning incentives within decentralized communities.

As we venture forward, the Meta-DAO and the application of futarchy in decentralized governance will undoubtedly offer invaluable lessons and insights, potentially reshaping the landscape of collective decision-making in the digital age.

If you've found this article enlightening and engaging, kindly express your support by liking and sharing it. Furthermore, should you come across any discrepancies or possess suggestions to enrich this discourse, we welcome your input in the comments section. Through collaborative efforts, we ensure the precision and relevance of the knowledge we share.

Subscribe now

Connect with me on X: @angry__pacifist

This dual perception, coupled with the current association of NFTs with profile pictures (PFPs), cultural items, and their heavy reliance on speculative trading, has led to a pervasive lack of understanding regarding the true potential of this transformative technology. The central challenge lies in transcending the current speculative framework and endowing NFTs with intrinsic values beyond mere collectibility and investment.

Amid this dynamic landscape, the Solana NFT ecosystem has emerged as a fertile ground for innovation, driven by its unmatched cost efficiency and scalability. However, as its NFT space continues to expand, challenges related to storage, and cost-efficiency have arisen, creating barriers to the widespread adoption and practical utilization of NFTs.
Despite being positioned as a pivotal force in the adoption of web3 technologies, NFTs have yet to fully realize their potential due to barriers to adoption, particularly among retail and enterprise/institutional users.

An ideal example is one of Solana’s prominent NFT projects Claynosaurz, a collection comprising 10,000 endearing 3D dinosaurs.
The storage costs for minting the entire series amount to over $60,000, underscoring a clear lack of scalability.

Solana addresses this challenge by introducing a compelling solution that overcomes the limitations of traditional NFTs: compression.
Compressed NFTs circumvent these obstacles by encoding their data into an on-chain fingerprint that references the data off-chain.

The advent of compressed NFTs (cNFTs) has injected renewed vitality into the network, significantly reducing the cost of minting by a factor of at least 1000, thereby facilitating the practical application of this technology.
This drastic reduction in minting costs has paved the way for a myriad of new use cases and opportunities to attract a broader user base.

Understanding Compressed NFTs

Compressed NFTs utilize state compression and Merkle trees to condense the data associated with an NFT into a compact "hash" or "fingerprint," securely stored within the ledger. Instead of storing the NFT's metadata in a typical Solana account, compressed NFTs store the metadata within the ledger itself, enabling cost-effective and secure storage.

Key Components

Smart Contracts: Two smart contracts work together:

• Bubblegum: Verifies the structural correctness of the NFT.

• Gummyroll: Manages a concurrent Merkle tree on the chain.

Merkle Trees:

• Compressed NFTs store their metadata within a Merkle tree structure. A Merkle tree is a type of data structure that is used to efficiently store and verify the integrity of large sets of data. It organizes the data into a hierarchical tree, with the "root" of the tree serving as a compact cryptographic representation of the entire dataset.

• Each NFT's metadata is stored as a leaf node in the Merkle tree, and the root of the tree acts as a compact "hash" or "fingerprint" that represents the entire set of NFT metadata. This allows for efficient verification and retrieval of the NFT metadata.

  

Bubblegum Program:

• The compression process is powered by Metaplex protocol’s Bubblegum program. Bubblegum is responsible for organizing the NFT metadata into Merkle trees and managing the state compression process.

Compressed NFTs use indexers to manage transaction data and facilitate data queries between RPCs (Remote Procedure Calls) and on-chain smart contracts.

By leveraging state compression and Merkle trees, compressed NFTs can cut minting costs by up to 99.9% compared to conventional NFTs. This makes them a game-changer for creators and allows businesses and individuals to mint NFTs on a massive scale without incurring prohibitive costs.

Advantages of Compressed NFTs over Traditional NFTs

• Cost savings: Compressed NFTs can significantly reduce minting costs compared to regular NFTs. This makes them more accessible to creators and allows for the creation of NFTs on a larger scale.

• Scalability: The use of state compression and Merkle trees enables compressed NFTs to be stored more efficiently, allowing for greater scalability. This means that more NFTs can be stored and accessed without overwhelming the network.

• New distribution models: Compressed NFTs unlock new possibilities for consumer applications to experiment with different distribution models. They free applications from the burden of high creation costs, enabling more innovative and diverse approaches to NFT distribution.

• Secure storage: By leveraging the security of the underlying blockchain ledger, compressed NFTs ensure the safe storage of NFT metadata. The use of Merkle trees and compact hashes provides a secure and tamper-resistant way to store and verify the authenticity of NFTs.

Transformative Use Cases

Beyond these benefits, compressed NFTs (cNFTs) have ushered in a new era of innovative product use cases and a dynamic ecosystem, reshaping the landscape of NFT adoption and community engagement.

Pioneering products like DRiP exemplify the transformative potential of compressed NFTs, redefining creator content monetization, ownership, and distribution through free weekly airdrops. By leveraging compressed NFTs, DRiP facilitates a shift in the creator-consumer relationship, fostering engaging in-app experiences and empowering creators to build communities around their content at minimal costs to the consumer. This direct relationship between creators and consumers eliminates the need for traditional web2 models reliant on spammy ads and clickbait content.

Another compelling example is Access Protocol’s creator NFT discovery platform, Sketch, which harnesses the power of compressed NFTs to enable creators to mint and distribute content and rewards to their subscribers in a cost-effective manner.

Furthermore, Dialect, a web3 messaging platform, leverages compressed NFTs to distribute chat sticker packs, allowing users to mint, share, and utilize these stickers in-app at no cost, thanks to compression.

The impact of compressed NFTs extends to the gaming industry, as evidenced by PicoPlay, a classic puzzle game that rewards players with cNFT-powered incentives for solving daily puzzles.

Compressed NFTs are also used in the distribution of Solana POAPs (SOAPs).
Has been used at hacker houses for people to collect, and on the network’s favorite event, the monthly ecosystem call powered by Superteam.

Moreover, compressed NFTs play a pivotal role in the distribution of Solana POAPs (SOAPs), utilized at hacker houses for collection and during the network’s monthly ecosystem call powered by Superteam.

The versatility of compressed NFTs also extends to their use in Decentralized Physical Infrastructure Networks (DePIN) such as Helium, a decentralized wireless network, where they represent over 1 million hotspots across 700,000 wallets, reducing mint costs and enabling tracking and rewards.

These are just a few examples of the myriad applications made possible by compression, enabling diverse experiments, including an NFT-deflation and merging mechanism by Radiants.

Additionally, numerous vibrant communities have emerged around compressed NFTs, with one of the most notable being the McDegens DAO. This is the first Decentralized Autonomous Organization (DAO) specifically dedicated to and established around cNFTs. Through their shared passion for collecting DRiP the Faceless cNFT collection with the McDegen trait, they have collaborated to create, develop, and open-source tools, protocols, and dApps focused on advancing cNFT technology and art.

Of course, none of these advancements would be achievable without the essential compressed NFT tooling and infrastructure providers such as Helius Labs, TipLink, CrossMint, and Underdog Protocol. These platforms offer comprehensive tool suites that empower developers to seamlessly integrate compressed NFTs into their products, creating intuitive user experiences while providing rich data.

A Glimpse into the Numbers

Speaking of data, Let's delve into the metrics to gain insights into the impact of compressed NFTs in contrast with traditional NFTs on Solana.

As of December 11, the cumulative compressed NFT mints have reached a total of 93.4 million (with a weekly average of 3 million), surpassing the 36.6 million traditional NFT mints, despite being live for only a few months. This highlights the enthusiastic reception of compression among Solana developers and consumers. What's remarkable is that the cost to mint all of that per compressed.app data is approximately 62 SOL, equivalent to just over $4400 at the current price of SOL.

Compressed NFTs also account for over 90% of the total weekly mints on Solana since its inception in early 2023, with users being charged $0 to participate in collecting them. This underscores the substantial resurgence of compressed NFTs in the Solana NFT ecosystem, a compelling demonstration of product-market fit in the crypto space.

The increasing value accrual of cNFTs indicates a shift from mere cost efficiency to genuine market demand and appreciation from users and creators, signaling a promising trajectory for compressed NFTs.

Future Outlook

Based on the current growth trend, it is conceivable that at least 70% of all Solana NFT activity will be in compressed NFTs, both in quantity and trading volume, within the next two years.

The potential of cNFTs to significantly impact Solana's product growth and user adoption lies in their ability to address key challenges associated with traditional NFTs, such as scalability and cost efficiency. As cNFT adoption expands, it will attract a diverse range of users, developers, and businesses seeking to leverage the benefits of compressed NFTs. This increased adoption will fuel the development of innovative applications, marketplaces, and infrastructure tailored to cNFTs, fostering a thriving ecosystem on Solana.

Furthermore, the efficiency of cNFTs will contribute to a more sustainable and accessible NFT environment, driving increased user engagement and participation across various industries and communities. Solana's performance and scalability advantages position it as an optimal platform for realizing the full potential of NFTs.

Looking ahead, envisioning new real-world use cases for cNFT adoption, such as integrating cNFTs in gaming and media to enable players to trade and own in-game assets and characters, holds the potential to redefine engagement and ownership in virtual environments. Additionally, the application of cNFTs in real estate and identity credentials could enhance the security and authentication of digital identities, streamlining the verification process and offering tamper-proof digital copies of vital credentials and licenses.

CONCLUSION

In conclusion, compression on Solana extends beyond current use cases, opening doors for applications previously constrained by high costs, such as mass-scale gaming assets, ticketing systems, and enterprise solutions. The process of minting compressed NFTs is significantly more cost-effective than minting conventional NFTs, leading to a diverse range of new use cases and avenues for broader adoption.

By harnessing compression, cNFTs present a more efficient and scalable approach to tokenizing digital assets, unlocking fresh opportunities for creators, collectors, and businesses.

While speculation and investing are integral to the ecosystem, true mass adoption stems from user engagement, not just investor activity. The potential ushered in by this new technology transcends transient entertainment like flash games and casinos, offering boundless opportunities.

If you have found this article engaging and informative, I would greatly appreciate your support by liking and sharing it. Additionally, if you come across any inaccuracies, you're welcome to share them in the comment section. Through collaborative efforts, we commit to maintaining the accuracy and relevance of the knowledge we share.

Subscribe now

Connect with me on X: @angry__pacifist

However, this passion often collides with the harsh realities of the digital media landscape

Inflexible Monetization Models: Traditional monetization models, including subscriptions and the dominant yet inefficient advertising revenue streams, are rigid and lack adaptability. Subscriptions demand fixed, regular payments from consumers, deterring potential supporters who might prefer a more flexible, pay-as-you-go approach. On the other hand, ad-based revenue models force creators to conform to specific content formats and styles to optimize click-through rates. This inflexibility limits creative freedom and artistic expression, shaping content to meet the demands of algorithms rather than the genuine interests of the audience.

Inefficiency in Value Capture: One of the fundamental inefficiencies in the traditional digital media ecosystem lies in the capture of value. Creators, despite their talent and effort, often find their earnings limited by intermediaries and platforms. These intermediaries absorb a significant portion of the revenue generated, leaving creators with a fraction of what their content truly earns. This inefficiency in value capture not only hampers the financial growth of creators but also disincentivizes them from producing high-quality, engaging content.

Low Conversion Rates: Conversion rates, the percentage of viewers who transform into paying supporters, are notoriously low in traditional digital media models. While creators amass large followings, only a fraction of these followers convert into subscribers or patrons. This low conversion rate creates a disconnect between a creator's potential audience and their actual supporter base, hindering sustainable monetization and long-term viability.

Value Extraction vs. Value Creation: The prevalent models of digital media often prioritize value extraction over value creation. Intermediaries, advertisers, and platforms focus on extracting maximum profit from the content without necessarily reinvesting in the creators or enhancing the audience experience. This extraction-centric approach leads to a lopsided ecosystem where creators struggle to receive fair compensation for their work, further stifling innovation and creativity.

Navigating the Dilemma

This paradox of passion and profit underscores the need for a paradigm shift in digital media. Creators require a platform that appreciates their artistry, encourages authentic expression, and rewards meaningful engagement.

Access Protocol: Transforming Challenges into Opportunities

In a landscape marred by these challenges, Access Protocol introduces a paradigm where consumers become stakeholders, their engagement directly shaping the content they adore.

What is Access protocol?

Built by the Access Foundation, Access Protocol emerges as a beacon of change, bridging the chasm between creators and consumers. This revolutionary platform leverages the power of web3 technology and Solana blockchain, offering a decentralized, transparent, and user-centric approach to content monetization. By redefining the relationship between creators and consumers, Access Protocol dismantles barriers and ensures creators receive the full worth of their content. Liberating creators from the constraints of rigid payment structures, Access Protocol fosters genuine engagement, encourages value creation, and empowers creators to unleash their creative brilliance.

How it works?

Central to Access Protocol's innovative model is the utilization of a fungible token, Access Credits (ACS). These fungible tokens serve as a bridge between creators and consumers, empowering both parties with unique opportunities and incentives. Unlike traditional subscription models, ACS provides a flexible and dynamic medium of exchange. Users can stake ACS tokens in specific creator pools to gain access to exclusive content.

Creator Pools

Creator Pools represent collective hubs where creators and their supporters converge. These pools operate on the foundational principle of mutual benefit. Supporters invest their ACS (Access Credits) tokens into specific Creator Pools. In return, they gain exclusive access to premium content, valuable insights, and other enticing offerings determined by the creators.
Unlike traditional subscription models that demand a fixed fee, Creator Pools operates on a flexible, stake-based system. Supporters willingly stake ACS tokens in their chosen pools, signaling their commitment to the creator. The more tokens locked, the stronger the vote of confidence in the creator’s work.
This is a one-time action - they do it once and maintain access to the content as long as the tokens remain locked.

One of the unique aspects of Creator Pools is the democratization of content monetization. Creators, regardless of their follower count or mainstream recognition, can establish their pools. This empowerment nurtures a sense of agency among creators, encouraging them to curate content that resonates deeply with their audience.

As consumers lock ACS tokens, both the consumers and creators are rewarded. These rewards come from the protocol's inflation mechanism. The protocol mints new ACS tokens over time, and a portion of these newly minted tokens are distributed to both consumers and creators. The number of tokens they receive is proportional to the amount of ACS tokens locked in their pool relative to the total locked tokens in the ecosystem.
This incentive structure ensures that creators are continually motivated to produce high-quality content, engage with their audience, and expand their Creator Pools.

Products and Features

Access Protocol empowers creators with a diverse suite of products tailored to enhance their digital presence. Let's delve into each offering:

Access Content Hub: This decentralized content discovery platform hosts creator pools and serves as the epicenter of user engagement. It allows subscribers to seamlessly manage their subscriptions and explore a plethora of creators.

Access Publisher: Designed for publishers, this feature enables effortless integration of Access Protocol monetization directly onto their websites. Through onsite integrations, creators connect with users right where they consume content. Publishers have the freedom to select content for the Access Paywall, engaging users via the Access front-end widget.
Notable publishers utilizing this feature are The Block and CryptoSlate.

Access Newsletter: Access Protocol recognizes the power of newsletters in fostering direct, meaningful relationships between creators and their audience. This feature allows creators to share exclusive content, updates, and insights directly with their subscribers.
Notably, CoinGecko, a prominent cryptocurrency data aggregator, has adeptly utilized this offering, delivering bi-weekly newsletters to their premium subscribers

Access Scribe: A novel product for independent publishers/creators, built to be a competitor to platforms like Substack and Medium, but with the added layer of Access Protocol’s monetization.
It empowers individual publishers, offering flexibility in monetizing their content according to their preferences.

Sketch: Utilizing the Solana compressed NFT standard, Sketch is a user-friendly, no-code NFT minting and distribution platform. It empowers creators to distribute NFTs cost-effectively.
For consumers, Sketch doubles as an NFT explorer/gallery, and artist discovery platform, enhancing the overall experience.

Access Community: This feature seamlessly integrates the Access monetization layer into Telegram or Discord communities, providing creators with the ability to gate specific content or channels.

Access Protocol is not only open-source but has also been meticulously audited for security, having undergone three comprehensive audits by Halborn Security. This transparency encourages other developers and protocols to build on its robust framework, fostering a collaborative and innovative ecosystem.

Benefits of Access Protocol

Access Protocol fosters alignment between consumers and creators, ensuring that both parties are invested in the content they create and consume. This symbiotic relationship results in an increase in fee-generating users and elevates the overall value per user.

The flexible staking system of Access Protocol ensures that consumers invest in the content they genuinely value, leading to a higher Average Revenue Per User (ARPU).
Additionally, Access Protocol enhances the Lifetime Value (LTV) of users by promoting meaningful engagement and providing creators with a direct channel to their audience. The exclusive content and sense of community within Access Protocol’s Creator Pools keep users engaged and invested over the long term.

In contrast to other platforms, Access Protocol stands out by not being directly value extractive. It offers a superior User Experience (UX), allowing users to effortlessly cancel or manage multiple subscriptions.
Access Credits (ACS) are conveniently listed on major exchanges, enhancing accessibility. Moreover, Access Protocol covers users' gas fees, eliminating the need for SOL (Solana) and simplifying blockchain complexities, making it user-friendly and accessible to all.

The Future of Access Protocol

In envisioning the future trajectory of Access Protocol, several key principles and developments guide its evolution:

Chain Agnosticism and Expansion - While currently anchored in the Solana blockchain, Access Protocol is poised for multi-chain rollouts, extending its footprint to chains like Starknet and Polygon.
This strategic diversification ensures wider accessibility and inclusivity within the blockchain sphere.

User-Friendly Integration - Access Protocol seeks seamless integration with wallets that abstract the complexities of cryptocurrencies. This user-centric approach ensures a hassle-free experience, encouraging broader adoption and participation.

Simplified Onboarding - The protocol aims to facilitate direct onboarding from fiat currencies, eliminating barriers for newcomers.
By bridging the gap between traditional finance and Web3, Access Protocol democratizes access to its innovative offerings.

Decentralization at its Core - All vital parameters of the Access Protocol are destined for decentralization. This commitment ensures that decisions regarding the protocol's future are community-driven, fostering a sense of ownership and active participation among its users.

Permissionless Creator Pools - Access Protocol champions the concept of permissionless creator pools and onboarding.
This inclusivity empowers creators of all scales, ensuring a level playing field where talent and innovation flourish unencumbered.

Innovative Subscription Models - Access Protocol looks to introduce advanced subscription types, including the intriguing concept of "forever locks." These innovations redefine how creators and users engage financially, offering novel avenues for sustainable revenue generation and value exchange.

Community-Led Governance - Access Protocol's governance structure is designed to transition progressively into a decentralized on-chain model, wherein ACS token holders shape the protocol's future. This community-driven governance underscores the protocol's commitment to democratization and transparency.

Personal Thoughts

Access Protocol transcends the transactional nature of traditional media consumer-creator relationships. By fostering stronger bonds between creators and users, the protocol nurtures a vibrant ecosystem where every new addition strengthens its fabric. This interdependence enriches the space with diverse utilities and values, creating a thriving environment for innovation and collaboration.

Recognizing the power of network effects in blockchain technology, Access Protocol advocates for a uniform ecosystem. This unity enables creators to leverage cross-pollination among users, expanding their reach and influence. Simultaneously, users benefit from a seamless experience and enhanced discoverability, enriching their interactions within the Access community.

While Access Protocol introduces groundbreaking innovations in the web3 landscape, challenges persist. Technical barriers to entry and potential limitations for specific content creators need to be acknowledged.
Web3 is still relatively new, it will require technical understanding to set up and manage, which could be a hurdle for some creators. Additionally, the effectiveness of web3 paywalls may vary depending on the type of content and the target audience. For example, creators who cater to a less tech-savvy audience might face challenges in adopting web3 paywalls, as their audience may need more time to navigate the new technology.

Conclusion

As web3 technology continues to evolve, the protocol remains committed to addressing these hurdles, ensuring a user-friendly experience for all.
This revolutionary paradigm shift transcends the traditional transactional relationships between creators and consumers. It forges genuine connections, allowing creativity to flourish, unburdened by the constraints of the past.
By embracing innovation while remaining mindful of user needs, Access Protocol pioneers a future where decentralized creativity thrives, setting new standards for the digital content ecosystem.

If you have found this article insightful and engaging, kindly show your support by liking and sharing it. Additionally, if you come across any discrepancies or have suggestions to enhance this discussion, we warmly welcome your input in the comments section below. Through collaborative efforts, we ensure the accuracy and relevance of the knowledge we share.

Subscribe now

Connect with me on X: @angry__pacifist