DEV Community: NIRANJAN LAMICHHANE

I Built a Nepal Government Complaint Transparency Bot with Hermes Agent (From Zero, in One Hour )

NIRANJAN LAMICHHANE — Mon, 01 Jun 2026 06:23:59 +0000

This is a submission for the Hermes Agent Challenge

What I Built

Hello Sarkar Analyzer — a Telegram bot that fetches, analyzes, and reports on public complaints filed by citizens with the Nepal Government at gunaso.opmcm.gov.np.

Nepal's Hello Sarkar ("Hello Government") portal lets citizens file complaints against any government ministry or department. The data is public — but buried inside a JavaScript-heavy Nuxt.js app that most people never dig into. My bot surfaces that data instantly on Telegram:

/complaints — live analysis: total complaints, resolved vs pending, resolution rate, top 3 most complained-about departments
/report — downloads a full .txt civic report to your phone
/about — project background

The goal: make government accountability data accessible to any Nepali citizen with a phone.

Demo

Bot commands in action:

/complaints

🏛 Hello Sarkar — Civic Complaint Analysis
📅 2026-06-01 11:30 NPT

📊 Overview
• Total:       847
• ✅ Resolved: 312 (36.8%)
• ⏳ Pending:  535

🏆 Top 3 Most Complained Departments
  1. Ministry of Land Management — 143 complaints
  2. Department of Transport — 98 complaints
  3. Ministry of Local Government — 87 complaints

🔗 gunaso.opmcm.gov.np
Built with Hermes Agent 🤖

Image demo :

Code and My Tech Stack

Hermes Agent by Nous Research — wrote, debugged, and ran all code
Python 3 — bot runtime
python-telegram-bot — Telegram interface
Selenium + headless Chrome — JavaScript page rendering
BeautifulSoup4 — DOM parsing
WSL2 / Ubuntu — development environment

I have no idea except for hermes agent and wsl2 and how other is used .

How I Used Hermes Agent

Here's the honest story: I came to this challenge as someone who had never used Hermes Agent before. I spent the first half of the day just getting it installed.

The Setup Journey

I started from absolute zero — no curl, no pip, no WSL2. After installing WSL2, I discovered I was running as root (no sudo), apt wasn't in PATH, and pip threw externally-managed-environment errors. Every step had a new obstacle.

What got me through it was Hermes Agent's ability to diagnose its own environment. Running hermes doctor gave me a clear picture of what was working and what wasn't — 18 of 27 tools enabled on a completely fresh setup.

The Build

Once running, I gave Hermes this prompt:

"Create a Telegram bot that fetches and analyzes public complaints from gunaso.opmcm.gov.np. The site is a Nuxt.js SPA — figure out how to get the data."

Hermes immediately identified the real challenge: the site renders everything in JavaScript. It couldn't just use requests + BeautifulSoup. So it autonomously:

Wrote a multi-layer scraper that tries 8 known Nepal govt API URL patterns first
Falls back to Selenium with headless Chrome to actually render the page
Intercepts real XHR/fetch calls the browser makes to find the live API endpoint
Parses the rendered DOM as a final fallback

When it hit a TERMINAL_SSH_PORT config error blocking code execution, it diagnosed the cause (a bad hostname from earlier SSH setup), fixed the .env file, and continued — without me telling it what was wrong.

When the bot crashed with AttributeError: 'list' object has no attribute 'get' — because the API returned lists-of-lists instead of dicts — Hermes identified the data shape mismatch and rewrote the analyze() function to handle all three possible shapes: dict, list, and raw str.

I wrote zero lines of this bot. Every function, every fallback strategy, every bug fix came from Hermes Agent reasoning through the problem autonomously.

What Surprised Me

The thing that struck me most was how Hermes handled ambiguity. The Nepal government site doesn't document its API. There's no public endpoint listed anywhere.

That layered reasoning — try the smart thing, then the less smart thing, then the brute force thing — felt genuinely agentic. Not just code generation. Problem solving.

Why This Matters for Nepal 🇳🇵

Nepal's Hello Sarkar portal holds real accountability data — which ministries get the most complaints, how long resolutions take, what citizens are suffering through. That data is technically public but practically inaccessible to most people.

A Telegram bot changes that. Telegram has deep penetration in Nepal. Any citizen, journalist, or civil society researcher can now type /complaints and get instant civic insight — no browser, no technical knowledge needed.

Hermes Agent made this possible in a single afternoon, from a country where most AI agent tutorials assume you already have a working dev environment with brew install everything. Starting from apt not found and ending with a working Telegram bot connected to live government data — that's the real demo.

Built by Niranjan Lamichhane, Kathmandu, Nepal 🇳🇵
Powered by Hermes Agent + OpenRouter (free tier) + WSL2

Building Multi‑Extension Tokens on Solana and making it compliance goated

NIRANJAN LAMICHHANE — Fri, 29 May 2026 09:13:13 +0000

After 36 days of diving into Solana development, I finally reached the most exciting milestone: composability.

Solana’s Token Extensions allow you to combine multiple features into a single mint — without writing complex smart contract logic.

In this post, I’ll walk you through two real‑world scenarios:

Day 37 – A token with transfer fee, interest‑bearing, and metadata extensions.
Day 38 – A compliance‑gated token with default frozen accounts (perfect for regulated finance).

All commands are tested on Devnet using the spl-token CLI. Let’s go!

Day 37: The Triple‑Extension Token

The Goal

Create a mint that:

Charges a 1% transfer fee (capped at 5 tokens).
Grows in value over time (interest‑bearing, 5 bps annually).
Stores its name, symbol, and URI directly on‑chain (metadata).

Step 1 – Create the Mint

One command, no backslashes (Windows‑friendly):

spl-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb create-token --decimals 2 --transfer-fee-basis-points 100 --transfer-fee-maximum-fee 500 --interest-rate 5 --enable-metadata

Output (yours will differ):

Creating token DrcSSbxxb63GiZiaXd1tFPRwwofFV3pJHSpFY1aCvcjN under program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
Address:  DrcSSbxxb63GiZiaXd1tFPRwwofFV3pJHSpFY1aCvcjN
Decimals:  2

Save the mint address — we’ll call it $MINT.

Step 2 – Initialize Metadata

spl-token initialize-metadata $MINT "ArcCoin" "ARC" "https://raw.githubusercontent.com/solana-developers/opos-asset/main/assets/CompressedCoil/metadata.json"

Step 3 – Verify All Extensions

spl-token display $MINT

Result (abridged):

Extensions
  Interest-bearing:
    Current rate: 5bps
  Transfer fees:
    Current fee: 100bps
    Current maximum: 50000
  Metadata Pointer:
    Metadata address: DrcSSbxxb63GiZiaXd1tFPRwwofFV3pJHSpFY1aCvcjN
  Metadata:
    Name: ArcCoin
    Symbol: ARC

All three extensions are active ✅

Step 4 – Create an Account and Mint 1000 Tokens

spl-token create-account $MINT
spl-token mint $MINT 1000
spl-token balance $MINT   # 1000

Step 5 – Test the Transfer Fee

Create a second wallet (if you haven’t already):

solana-keygen new --outfile second-wallet.json --no-bip39-passphrase --force
solana airdrop 1 second-wallet.json   # fund for rent

Create its token account and transfer 100 tokens:

spl-token create-account $MINT --owner second-wallet.json
spl-token transfer $MINT 100 second-wallet.json --expected-fee 1 --allow-unfunded-recipient

Check balances:

spl-token balance $MINT                     # 900
spl-token balance $MINT --owner second-wallet.json   # 99

The 1 token fee is withheld in the recipient’s account.

Step 6 – Harvest Withheld Fees

# Find recipient’s token account
spl-token accounts --owner second-wallet.json -v
# Withdraw to your own token account
spl-token withdraw-withheld-tokens YOUR_TOKEN_ACCOUNT RECIPIENT_TOKEN_ACCOUNT

After harvest:

spl-token balance $MINT   # 901 (the fee is yours)

Day 37 takeaway – three extensions working together, no custom program required.

Day 38: Compliance‑Gated Token (Default Frozen)

The Goal

Create a mint where every token account starts frozen. Only the freeze authority can thaw (approve) an account. This is how a regulated stablecoin or KYC‑gated platform works at the protocol level.

Step 1 – Create the Mint with `--default-account-state frozen`

spl-token create-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb --enable-freeze --default-account-state frozen

Output:

Address:  4jC4rjpi5wh1TKd2b8cLyAqFm9a68jmGRF1qPEnkENjm
Decimals:  9

Save as $MINT_FROZEN.

Step 2 – Create Two Token Accounts (Both Will Be Frozen)

spl-token create-account $MINT_FROZEN                # yours
spl-token create-account $MINT_FROZEN --owner second-wallet.json   # second wallet

Step 3 – Try to Mint (Must Fail)

spl-token mint $MINT_FROZEN 100

Expected error:

Error: Account is frozen

✅ The enforcement works – even the mint authority cannot bypass it.

Step 4 – Thaw Your Account (The “KYC Approval”)

First find your token account address (spl-token accounts), then:

spl-token thaw YOUR_TOKEN_ACCOUNT

Step 5 – Mint Now Succeeds

spl-token mint $MINT_FROZEN 100
spl-token balance $MINT_FROZEN   # 100

Step 6 – Transfer to Still‑Frozen Second Account (Must Fail)

spl-token transfer $MINT_FROZEN 50 second-wallet.json --allow-unfunded-recipient

Error: Account is frozen (destination).

Step 7 – Thaw Second Account, Then Transfer Succeeds

spl-token thaw SECOND_WALLET_TOKEN_ACCOUNT
spl-token transfer $MINT_FROZEN 50 second-wallet.json --allow-unfunded-recipient
spl-token balance $MINT_FROZEN --owner second-wallet.json   # 50

Day 38 takeaway – compliance is enforced at the runtime level, not in off‑chain code.

What I Learned

Composability is powerful – you can mix and match extensions like LEGO bricks.
The CLI abstracts complexity – one command sets up TLV‑encoded extension data.
Default frozen accounts are a game‑changer for regulated finance on Solana.
Debugging on Windows requires absolute paths and careful attention to program IDs (the correct one is TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb – note the lowercase z).

Intrest bearing token in solana

NIRANJAN LAMICHHANE — Fri, 29 May 2026 07:48:58 +0000

Create an Interest‑Bearing Token on Solana (Token‑2022) – Step by Step

Learn how to mint a token that earns interest automatically, every second, using Solana’s Token‑2022 program.

No staking, no separate contracts – just a CLI and a wallet.

1. Prerequisites

Solana CLI & SPL Token CLI installed
A funded wallet (devnet/testnet)
Basic terminal comfort

2. Create the Mint (with 5% interest)

The --interest-rate is in basis points (bps).

500 bps = 5% APY.

spl-token create-token \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb \
  --interest-rate 500

Sample output mint address (yours will differ):

CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu

3. Create a Token Account for Your Wallet

spl-token create-account <MINT_ADDRESS> \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

(My created account: 9nSZ154gJQ8H2qzgLV8mk7K5N4LbngViksUyrzsgncn1)

4. Mint 1000 Tokens

spl-token mint <MINT_ADDRESS> 1000 \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

5. Observe the Growing Balance

Check UI balance (applied interest)

spl-token balance <MINT_ADDRESS> \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

Result right after mint: 1000.000362839 – already more than 1000!

Inspect mint metadata

spl-token display <MINT_ADDRESS> \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

You’ll see:

SPL Token Mint
  …
  Supply: 1000000000000   (raw supply, 1000 tokens with 9 decimals)
  Decimals: 9
  Interest-bearing:
    Current rate: 500bps
    Average rate: 500bps
    Rate authority: …

Key insight: The on‑chain supply never changes.

The UI balance grows because the program calculates interest per second from the last update time.

See raw account data (optional)

solana account <MINT_ADDRESS> --output json

Returns a base64‑encoded blob – that’s where the interest rate and timestamp live.

6. Wait and Watch Interest Compound

After a few minutes, run spl-token balance again.

The number will be larger – without any transaction.

7. Change the Interest Rate

As the rate authority, you can update the rate anytime.

spl-token set-interest-rate <MINT_ADDRESS> 15000   # 150% APY

Check display again – Current rate now shows 15000bps.

Balance will start climbing much faster.

Later I set it to 30000 (300% APY) and balance quickly went to 1000.015285823.

8. Rate Limits

The rate is stored as a 16‑bit signed integer (i16).

Max allowed: 32767 bps (~327.67% APY).

Min allowed: -32768 bps (negative interest, for demurrage tokens).

Trying 35000 or 100000 will error:

error: number too large to fit in target type

My Full Command History (Reference)

spl-token create-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb --interest-rate 500
spl-token create-account CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
spl-token mint CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu 1000 --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
spl-token balance CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
# 1000.000362839
spl-token display CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
solana account CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu --output json
spl-token set-interest-rate CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu 15000
spl-token balance … # 1000.008316801
spl-token set-interest-rate CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu 30000
spl-token balance … # 1000.015285823

Why This Matters

Yield‑bearing stablecoins without external protocols
Automatic savings tokens that reward holders per second
Dynamic rates – adjust APY on the fly based on market conditions
Fully on‑chain, permissionless, composable

Now go build your own interest‑bearing token. Happy hacking! 🚀

Understanding tokenomics of Solana

NIRANJAN LAMICHHANE — Thu, 28 May 2026 06:51:24 +0000

In recent days of #100daysofsolana , i learned worked with transfer-fee-enabled tokens, withheld fees, fee authorities, and Token-2022-specific behavior.

During this , i specifically struggled with creating a standard SPL token account instead of a Token-2022 token account, which result in transactions fail, accounts appear incompatible, and CLI commands behave unexpectedly.

From this struggle , i specifically learnt that :

fees are automatically deducted during transfers,
fees accumulate in token accounts,
withheld fees must later be withdrawn.

Solana Account Model — City Analogy

NIRANJAN LAMICHHANE — Wed, 27 May 2026 07:18:52 +0000

Think of Solana as a city

Every building in the city has the same basic structure: an address, a size, an owner, and contents inside. That is exactly what an account is — a building. The blockchain is the city map that records who owns what building and what is inside each one.

The 5 fields — what every building has

Field	Analogy	Meaning
`lamports`	money inside the building	how much SOL this account holds (1 SOL = 1 billion lamports)
`owner`	who has the master key	only this program can change what is inside — everyone else can look but not touch
`data`	what is stored inside	raw bytes — could be empty (a wallet) or full of state (token balance, game score)
`executable`	is it a factory or a house?	`false` = stores things (wallet, data) · `true` = runs code (a program)
`rentEpoch`	building tax status	pay 2 years rent upfront and you never pay again — that is rent exemption

Why are program and data separate buildings?

1. Ethereum way: imagine a McDonald's where the kitchen (code) and the customer orders (data) are locked inside the same room. To change the menu, you demolish the whole building and rebuild it. Every new franchise needs its own separate building with its own separate kitchen.

2. Solana way: the kitchen (program account) is one permanent building in the city. It never stores any food orders inside — it is just the recipe book and the chef. Every customer order (data account) is a separate locker room next door, owned by the kitchen. Millions of lockers, one kitchen.

The three building types in the city

Wallet account — Your house. You own it.

executable: false
data: empty
owner: System Program
Holds SOL. The System Program is like the city government — it owns all plain wallets but you control yours with your private key (signature).

Program account — A factory. Read-only.

executable: true
data: BPF bytecode
owner: BPF Loader
Pure logic. No state lives here. Once deployed it just sits there waiting to be called. Upgrading means redeploying the bytecode — the data accounts are untouched.

Data account (PDA) — A locker assigned to you.

executable: false
data: your state
owner: the program
Created by the program on your behalf. Stores your token balance, your game score, your profile — whatever the program needs to remember about you. You cannot open it without the program.

One-line rule to remember forever

The owner field is the master key. Only the program listed as owner can change the data inside or take lamports out. Anyone in the world can send SOL in or read the data — but only the owner can write.

Your wallet is owned by the System Program. When you sign a transaction, you are telling the System Program "I authorise this" — and it acts on your behalf because your signature matches your address.

Walk me through a SOL transfer at the account level — which accounts change and which programs act on them.

Solana Transactions: not just a “request/response” ,but “atomic on-chain state changes”

NIRANJAN LAMICHHANE — Wed, 27 May 2026 05:28:51 +0000

In web2 , our rest api call are confined with just request and response framework . In web3 , for this particular solana , our transaction goes through this full commitment lifecycle:

send() → Processed ✓ → Confirmed ✓ → Finalized ✓

State	What it means
Processed	Validator received the transaction
Confirmed	2/3 of stake weight agrees
Finalized	Permanent — cannot be rolled back

sendAndConfirmTransaction() polls internally through all 3 states and resolves once finalized.

Pay to attempt, not just to succeed

Unlike of web2 , on which failed transaction incur nothing ,in web3 , we pay to attempt, not just to succeed. The chain ran the instruction, hit the error, and charged the fee anyway.

During my day 19 of 100 days of solona , I revealed:

Status: Error processing Instruction 0 — custom program error: 0x1

0x1 = InsufficientFunds on the System Program

What the failed tx showed

Field	Value from my terminal
Error code	`custom program error: 0x1`
Fee charged	`0.000005 SOL` (still deducted)
Compute Units	`150` consumed
Balance change	`1.468975 → 1.46897` (fee only)
Log message	`Transfer: insufficient lamports 1468970000, need 500000000000`

Final Note : err.logs vs console.error

	`err.logs`	`console.error(err)`
Source	Solana runtime (on-chain)	Node.js
Tells you	WHY the chain rejected it	WHERE your code broke
Can be undefined?	Yes — if tx never reached the chain	No — always present
Example	`Transfer: insufficient lamports…`	`SendTransactionError: simulation failed…`

Recommendation : Always use both:

} catch (err) {
  console.error("JS error:", err.message);     // WHERE it broke
  if (err.logs) {
    console.log("Chain logs:", err.logs);       // WHY chain rejected
  }
}

This much upto my learning journey for now . Will be updating other blog soon too .

Policy Storyteller: Turning Nepali Bills into Human Stories with Gemma 4

NIRANJAN LAMICHHANE — Mon, 25 May 2026 06:28:32 +0000

What I Built

Policy Storyteller helps Nepali citizens understand laws without a law degree.

Pick a bill → get a plain-language brief, three diverse personas (Terai, hill, city — farmer, student, shopkeeper…), each with a day-in-the-life scenario and what becomes riskier / safer → vote on the story. English or नेपाली.

Four bills built in: Social Media Act 2081, IT & Cyber Security 2082, School Education 2080, Privacy Act 2075.

Not legal advice — digital equity for low literacy and patchy 4G.

Demo

Repo: https://github.com/NiranjanNlc/PolicyStoryTeller

Flow: Choose bill → Generate story (~1–2 min) → Explore brief & personas → Vote. Stories cache in localStorage per bill + language.

How I Used Gemma 4

Gemma 4 does everything — no hand-written summaries, no rules engine. A FastAPI backend chains seven focused calls per story:

Step	Gemma 4 outputs
Brief	JSON: summary, who is affected, key points
Personas	3 diverse Nepali composites
Scenarios	2–3 sentences each, NPR & real places
Risks	JSON: riskier / safer lists

Prompts force Nepal context (Nagarpalika, NPR, Dashain, Terai/hill/mountain) and Devanagari Nepali when selected. Pydantic validates JSON; one auto-retry if the model adds markdown fences.

Via OpenRouter (OpenAI-compatible API) — swap model id in .env.

Which Model & Why

Gemma 4 small (2B/4B) — on purpose.

Civic users are on phones and free tiers. Each job is small JSON or a few sentences — not a 31B reasoning marathon. Seven sequential calls already take ~1–2 minutes; small Gemma keeps that affordable, fast enough, and good enough in Nepali. MoE/dense would be overkill; small Gemma is the tool that can run in Nepal, not just about Nepal.

Stack

React + Vite + Tailwind · FastAPI + Pydantic · OpenRouter · no DB (localStorage + file votes)

cd backend && pip install -r requirements.txt && copy .env.example .env
uvicorn main:app --reload --port 8000
cd ../frontend && npm install && npm run dev

Learned (quick)

Retry on bad JSON beats switching to a bigger model.
Tell Gemma who the reader is (“low legal literacy”) — Nepali output improves a lot.
Run calls sequentially on free tier or you hit 429 halfway through a story.

Links

👉 https://github.com/NiranjanNlc/PolicyStoryTeller

Gemma 4 Challenge — Build With Gemma 4 · Solo · MIT

Disclaimer: Educational composites only — verify with official Nepal Government sources.

NO no Account is not just a database , whose history is traced and logged .

NIRANJAN LAMICHHANE — Mon, 04 May 2026 13:36:21 +0000

In this second week of #100daysofsolana , i got got introduced with the concept of account . I learned it by contrasting with the database of web2 .
However , i am aware that Solana's account model is not replacement for web2 database, rather it's solving a different problem: storing state in a system where no single entity has control, reads are public, and writes require cryptographic authorization.
On Solana, "every account is an open book the moment it exists". You can query any program address on the internet and instantly see its balance, owner, executable flag, and transaction history—no API key, no permission, no credentials.
In a normal app, our code checks if a user is allowed to edit something. On Solana, the system itself blocks anyone except the account's owner from making changes. To update an account, we must prove you own it by signing the transaction.
In a regular database, we can ask for related data with a JOIN. On Solana, accounts cannot query each other. If we need connected information, we fetch each account individually and combine them in your own code. This sounds old‑fashioned, but it's one reason Solana runs so fast.

First experince with programming in web3

NIRANJAN LAMICHHANE — Sun, 26 Apr 2026 11:34:43 +0000

Here , i connect with the devnet of sol with the help of phanthom wallet from browser

Learning of W1 of #100DaysOfSolana

NIRANJAN LAMICHHANE — Sun, 26 Apr 2026 11:27:51 +0000

I always have the thrill and wish for learning and experimenting with the web3 . Scattered tutorial and knowledge over different platform has not contributed significantly in my knowledge building .
So , i decides to enroll and go along with #100DaysOfSolana to bring some sort of structured knowledge in the sector of web3 . Till now , this journey gave me a true eureka moment for understanding different concepts and terminology that I’d heard before but never fully grasped. Let me share three breakthroughs that changed how I see Web3.

1. Public Key vs. Private Key – Not Just a Username and Password
The public key is what others see. They use it to send you crypto or verify that a transaction came from your wallet. In Web2 terms, it’s like a username. But here’s the nuance: Web3 is pseudonymous, not fully anonymous. Your public key is visible on the ledger, but your real-world identity isn’t attached unless you connect it yourself.

The private key, on the other hand, is yours alone. You use it to sign transactions – proving you own the wallet without revealing the key itself. It’s similar to a Web2 password, but with one huge difference: there’s no “forgot password” option. Lose your private key, lose your funds forever. That’s why people write it down on paper or use hardware wallets. This clarity was my first big aha moment.

2. Devnet – The Playground Before the Real Game
For a long time, I wondered: how can developers experiment with cryptocurrency when it has real value and trades live? That confusion vanished when I discovered Solana Devnet.

On devnet, you can request fake SOL for free using a faucet. You can deploy smart contracts, send transactions, and make mistakes without losing real money. It’s a sandbox. Once your code works on devnet, you test again on testnet, and only then do you go to mainnet – the live blockchain. Now I understand that almost every serious blockchain project starts its life on a devnet or testnet. This made programming with crypto feel safe and exciting.

3. Integers, Not Floats – Avoiding the Rounding Nightmare
Another question haunted me: why do blockchains use integers (like lamports for SOL or satoshis for Bitcoin) instead of floating-point numbers?

The answer clicked when I thought about rounding errors. Different machines round floating-point numbers differently – even by tiny amounts. On a public ledger where thousands of nodes must agree on every balance, those tiny differences would break consensus. One node might see 0.1 + 0.2 = 0.30000000000000004, while another sees a slightly different value. Using integers (e.g., 300,000 lamports) guarantees every node calculates exactly the same result. This small design choice is actually a pillar of trust in blockchain.

So , in solana we are using the things of lamports and sol, while the result are being shown in the sol , the underlying calculation all are performed in lamports . For conversion , 1 SOL is always equal to 1,000,000,000 (one billion) Lamports.

Final Thoughts
These eureka moments didn’t come easily . It was with the passion curiosity , dareness to ask the silly question , contigency in the learning , learning from the mistake and resistace to break the thing along making it .

Coffee, Code, and Junie: My Journey to 10x Productivity with JetBrains AI

NIRANJAN LAMICHHANE — Tue, 03 Feb 2026 14:25:59 +0000

Dream of 10x Developer :

I've always chased that mythical 10x developer status—that magical state where code flows like water, bugs vanish before they form, and architecture emerges perfectly from the chaos.But something was holding me back to achieve this .
I'm an IntelliJ evangelist. The keyboard shortcuts are muscle memory, the UI feels like home, and Android Studio is basically family. But every time I tried AI coding assistants, I hit the same wall—they all lived in VS Code's world. The mental context switching was killing my flow state.

At this time , the intelij ide announces this hackathon of the Sky limit , providing myself the free credit and opportunity to try out junie and ai assisted coding .Its like a gift from the coding gods: free access to Junie, an AI assistant built right into my beloved IDE.

Same time , i was starting to learn python and data science too . To get maximum advantage of junie , i install python plugin in intelij ide to give a try to python and data science . Later , i found that Jetbrains have similar product “ Pycharm “ for this purposes.
Enough about me , lets talk about what I built with the help of junie .

I built ScrIM Coach, which is an esports performance analysis tool that transforms raw League of Legends match data into actionable coaching insights. We analyzes professional team performance using the GRID Esports API to identify strategic patterns, execution gaps, and draft weaknesses. We provide executive summary , detailed analysis , practice planning by analyzing the data to the coach . The coach can also print out the action plan from the insight we have constructed .

The project is licenced under MIT license in following source :

You can try out at : here

My Favourite part :

Favourite part of me was the BRAVE MODE. I give complete control over the junie to make changes to the project and its file . After providing prompt , i can have long sip of the coffee , read the hackathon details and submission requirement , while junie have completed the tasks .
I'd write a prompt like 'Refactor this to follow clean architecture with proper separation of concerns,' take a long sip of coffee, watch Junie restructure 15 files simultaneously, and return to a codebase that was suddenly... beautiful. The best part? Nothing broke. Tests still passed. The UI still rendered

Important Contribution :

The most important contribution junie make in my productivity is during the ui enhancement . Being the backend developer and android engineer previously , pixel perfect ui seems to be not my cup of tea. But using junie , i can not only draft , but also implement pixel perfect ui , in many cases , junie does it by itself , what we have to do is attach the screen shot of what went wrong and what is your desired output .

Impressive Refactoring :

The most powerful ability and impressive things about junie for me is its ability to refactor without breaking the functionality and UI . I initially designed the working MVp with some trash architecture without following any pattern and standard . I refactor the whole of my mvp to adhere to solid principle and clean code architecture in the single prompt . Interestingly , nothing breaks at all and i would be able to add new feature after that in more easier and scalable way.

UI Magic for Backend Developers:

The Flow State Achievement:

My workflow was made more smoother and i have attained the flow state during my this journey of hackathon . Adding feature , enhancing functionality were just a prompt away and its debug mode executed by itself makes it produce the code which is actually working .

Most Misused Capability :

Not only i used Junie , I also misused junie , especially in the work of version control . I ordered ( just not prompted) junie to commit the changes it has made with clear commit message and push it to the remote source . Similarly , i often ordered it to combine multiple git commit to the single one and of course , it obey me like a good servant.

Wish it was there :

I wish to make my changes live on my deployed site as soon as i make change in the codebase, because legends debug in production. If inteilij have MCP server support , it would have been few prompt away . Absence of this feature makes me little disappointed at last .

If you're like me—comfortable in JetBrains' ecosystem but curious about AI assistance—take the leap. The hackathon may be over, but the learning isn't. Junie showed me that the future of development isn't about replacing developers; it's about amplifying our humanity through technology.

My Data Science Journey: Restaurant Tips Analysis

NIRANJAN LAMICHHANE — Sun, 28 Dec 2025 08:04:57 +0000

Project: Exploratory Data Analysis on Restaurant Tips Dataset
Duration: Full EDA Process
Dataset: 243 restaurant transactions, 7 variables
Status: ✅ COMPLETED

📊 PROJECT OVERVIEW

Dataset Information

Source: Restaurant tips dataset
Initial Size: 244 rows × 7 columns
Final Size: 243 rows × 7 columns (after cleaning)
Variables:
- Numerical: total_bill, tip, size
- Categorical: sex, smoker, day, time

Project Goal

Understand what factors influence tipping behavior in restaurants through comprehensive exploratory data analysis.

🧹 PHASE 1: DATA CLEANING (Investigation 1.3)

1.1 Missing Values Investigation

Hypothesis: "The Null Hypothesis" - Why might data be missing?

What I Did:

# Checked for missing values
data.isnull().sum()
data.isnull().any()
(data.isnull().sum() / len(data)) * 100  # Percentage

Results:

✅ 0 missing values in all columns
This indicated excellent data collection quality
No imputation or removal needed

Learning Moment: Not all datasets have missing data, but always check!

1.2 Duplicate Detection

Hypothesis: Could identical transactions exist legitimately?

What I Did:

# Found duplicates
num_duplicates = data.duplicated().sum()
duplicates = data[data.duplicated(keep=False)]

# Removed them
data_clean = data.drop_duplicates()

Results:

Found 1 duplicate row
- Bill: $13.00, Tip: $2.00, Female, Smoker, Thursday, Lunch, Party of 2
- Row 198 and Row 202 were IDENTICAL
Decision: Removed as likely data entry error
Result: 244 rows → 243 rows

Key Insight: Identical transactions on same day/time are statistically improbable - likely errors.

1.3 Outlier Investigation

Hypothesis: "The Outlier Tribunal" - Are extreme values errors or legitimate?

What I Did:

# Created boxplots
plt.boxplot(data['tip'])
plt.boxplot(data['total_bill'])

# Calculated IQR boundaries
Q1 = data['tip'].quantile(0.25)
Q3 = data['tip'].quantile(0.75)
IQR = Q3 - Q1
upper_boundary = Q3 + (1.5 * IQR)

# Found outliers
outliers = data[data['tip'] > upper_boundary]

Mathematical Formula:

IQR = Q3 - Q1
Upper Boundary = Q3 + (1.5 × IQR)
Lower Boundary = Q1 - (1.5 × IQR)

For Tips:
Q1 = $2.00
Q3 = $3.56
IQR = $1.56
Upper Boundary = $5.90

Outliers Found:
| Bill | Tip | Tip % | Verdict |
|---------|--------|-------|-----------------|
| $50.81 | $10.00 | 19.7% | ✅ Legitimate |
| $48.33 | $9.00 | 18.6% | ✅ Legitimate |
| $39.42 | $7.58 | 19.2% | ✅ Legitimate |
| $48.27 | $6.73 | 13.9% | ✅ Legitimate |

Decision: Kept all outliers - they represent large parties with reasonable tip percentages

Key Insight: Outliers aren't always errors! Verify with context (tip percentage in this case).

🔬 PHASE 2: BIVARIATE ANALYSIS (Investigation 2.2)

Overview: Testing 7 Relationships

For each relationship, I followed the scientific method:

Hypothesis - Make a prediction
Visualization - Create appropriate chart
Analysis - Interpret the pattern
Conclusion - Accept or reject hypothesis

2.1 Relationship #1: Total Bill → Tip

My Hypothesis:

"As total_bill increases, tip will increase WEAKLY"
Reasoning: "Tip is 'keep the change' - not percentage based"
Confidence: MEDIUM
Expected: Weak/no relationship

What I Did:

plt.scatter(data_clean['total_bill'], data_clean['tip'])
plt.xlabel('Total Bill ($)')
plt.ylabel('Tip ($)')
plt.title('Relationship Between Total Bill and Tip Amount')
plt.show()

Results:

Pattern: Strong upward linear trend
Correlation: r = 0.67 (Strong positive)
Points tightly clustered around imaginary line

Hypothesis Verdict: ❌ REJECTED

What I Learned:

My hypothesis was WRONG - and that's okay!
Reality: People tip 15-20% of bill (percentage-based, not "keep change")
Mechanism: Bill × 15-20% = Tip (mathematical relationship)
Key insight: "Learning happens with mistakes" - being wrong is part of science!

Business Insight: Higher bills = higher tips. Restaurants should encourage higher spending.

2.2 Relationship #2: Party Size → Total Bill

My Hypothesis:

"As party size increases, total_bill increases STRONGLY"
Reasoning: "More people = more food (obvious!)"
Confidence: HIGH

What I Did:

plt.scatter(data_clean['size'], data_clean['total_bill'])

Results:

Pattern: Grouped upward trend (vertical columns)
Correlation: r = 0.60 (Medium-strong positive)
Party size = discrete (1,2,3,4,5,6), not continuous
Size 2 most common, with widest bill range ($10-$40)

Hypothesis Verdict: ✅ CONFIRMED (but weaker than expected)

Key Insight:

"Party size predicts bill, but doesn't determine it completely"
A couple can outspend a group of 4 depending on what they order
What people ORDER matters more than HOW MANY people

2.3 Relationship #3: Party Size → Tip

My Hypothesis:

"As party size increases, tip increases STRONGLY"
Reasoning: "More people → bigger bill → percentage-based tip → more tip"
Confidence: HIGH

Results:

Pattern: Upward trend from size 1-4, then FLATTENS at 5-6
Correlation: r = 0.49 (Medium-weak)
Non-linear relationship!

Hypothesis Verdict: ⚠️ PARTIALLY CORRECT

Surprising Discovery:

Tips increase up to party size 4
Tips PLATEAU at sizes 5-6 (don't increase further!)

Possible Explanations:

Automatic gratuity - Restaurants add mandatory 15-18% for large parties
Social loafing - "Someone else will tip well, so I don't need to"
Different occasions - Large parties = kids/families (tip standard)
Splitting complications - Harder to calculate when splitting 6 ways

Key Insight: Large parties tip differently than expected - real behavioral economics!

2.4 Relationship #4: Day of Week → Tip

My Hypothesis:

Highest: Sunday (weekend celebration mood)
Lowest: Wednesday (people just filling stomach)
Expected difference: MEDIUM
Confidence: MEDIUM

What I Did:

sns.boxplot(x='day', y='tip', data=data_clean,
            order=['Sun','Mon','Tue','Wed','Thur','Fri','Sat'])

Results:
| Day | Avg Tip | Verdict |
|-----------|---------|----------------|
| Saturday | $3.00 | 🏆 Highest |
| Sunday | $2.90 | High |
| Mon/Tue/Wed| $2.25 | 🔻 Lowest (tie)|

Hypothesis Verdict: ⚠️ PARTIALLY WRONG

What I Got Wrong:

Predicted Sunday highest → Actually Saturday highest
Predicted Wednesday lowest → Correct (tied with Mon/Tue)

Key Observations:

Saturday has most high-tip outliers (special occasions, date nights)
Sunday has LARGEST box (most variation) - diverse crowd
Weekdays cluster together (consistent lower tipping)

Key Insight:
"Sunday = diverse people = diverse tipping = large variation in tips"

2.5 Relationship #5: Time (Lunch vs Dinner) → Tip

My Hypothesis:

Dinner will have higher tips
Reasoning: "Night time = people more generous; lunch = people in rush"
Confidence: MEDIUM

Results:
| Time | Avg Tip | Difference |
|--------|---------|------------|
| Dinner | $3.00 | — |
| Lunch | $2.20 | -$0.80 |

Hypothesis Verdict: ✅ CONFIRMED!

Key Insight:

$0.80 difference - this is the BIGGEST categorical effect!
Time of day is the STRONGEST categorical predictor
Lunch customers are rushed, less satisfied with service
Dinner is relaxed, celebratory atmosphere

Business Recommendation: Prioritize dinner service quality!

2.6 Relationship #6: Sex (Male vs Female) → Tip

My Hypothesis:

Males will tip MORE
Reasoning: "Female waitresses + male customers trying to impress"
Confidence: MEDIUM

Results:
| Sex | Avg Tip | Difference |
|--------|---------|------------|
| Female | $3.20 | — |
| Male | $3.00 | -$0.20 |

Hypothesis Verdict: ❌ REJECTED!

What I Got Wrong:

Females actually tip SLIGHTLY more (or it's basically equal)
The difference is minimal ($0.20)
Sex is NOT a strong predictor

Key Insight: Gender stereotypes about tipping don't hold up in data!

2.7 Relationship #7: Smoker vs Non-Smoker → Tip

My Hypothesis:

Non-smokers will tip MORE
Reasoning: "Smokers save money for cigarettes instead of tipping"
Confidence: LOW

Results:
| Smoker Status | Avg Tip | Difference |
|---------------|---------|------------|
| Smokers | $3.00 | — |
| Non-smokers | $2.80 | -$0.20 |

Hypothesis Verdict: ❌ REJECTED!

Honest Reflection: "Cannot figure out why" - and that's okay!

Possible Explanations:

Smokers sit outside/at bar (different atmosphere?)
Correlation, not causation (maybe age/demographic differences)
Small difference ($0.20) might be random chance
Need more data to understand

Key Insight: Not every pattern has an obvious explanation - intellectual honesty matters!

📈 PHASE 3: CORRELATION ANALYSIS

What I Did:

# Correlation matrix
correlation_matrix = data_clean[['total_bill', 'tip', 'size']].corr()
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')

Results:

Pair	Correlation	Strength	Interpretation
total_bill ↔ tip	0.67	Strong	🏆 Strongest predictor
size ↔ total_bill	0.60	Medium-Strong	More people = more food
size ↔ tip	0.49	Medium-Weak	Non-linear (plateaus)

Key Insight:
"Tip percentage is fixed as that of total bill" - this explains the 0.67 correlation perfectly!

🎨 PHASE 4: PAIRPLOT (Visual Summary)

What I Did:

sns.pairplot(data_clean, 
             vars=['total_bill', 'tip', 'size'],
             hue='time',  # Color by lunch/dinner
             diag_kind='hist')

Observations:

From diagonal (distributions):

Most common tip: ~$2-3
Most common bill: ~$15-20
Most common party size: 2 people

From scatter plots:

total_bill vs tip: Clear upward trend (confirms r=0.67)
size vs others: Grouped patterns (discrete variable)
Lunch (blue) vs Dinner (orange): Overlap mostly, but dinner shifts slightly higher

Overall Impression: Relationships are SOMEWHAT CLEAR - not perfect, but strong enough to be meaningful

🎯 KEY FINDINGS SUMMARY

Strongest Predictors (Ranked):

Total Bill (r=0.67) 🥇
- Explains ~45% of tip variation (r² = 0.67² = 0.45)
- Clear linear relationship
- Percentage-based tipping (15-20%)
Time of Day ($0.80 difference) 🥈
- Dinner tips $0.80 more than lunch
- Strongest categorical effect
- Reflects rushed vs relaxed dining
Party Size (r=0.49 with tip) 🥉
- Medium effect, but NON-LINEAR
- Plateaus at size 5-6
- Different behavior for large groups
Day of Week ($0.75 difference)
- Saturday highest ($3.00)
- Weekdays lowest (~$2.25)
- Weekend vs weekday effect
Sex ($0.20 difference) - WEAK
- Minimal difference
- Nearly equal tipping
Smoker Status ($0.20 difference) - WEAK
- Minimal difference
- Unexplained pattern

💡 BUSINESS RECOMMENDATIONS

Based on data analysis, restaurant owners should:

1. FOCUS ON INCREASING BILL AMOUNT 🎯

Why: Strongest correlation (0.67) - higher bills directly lead to higher tips

Actions:

Upsell appetizers, drinks, desserts
Create combo deals that increase bill
Train servers on suggestive selling
Offer premium menu items

Expected Impact: 10% increase in average bill → ~10% increase in tips

2. PRIORITIZE DINNER SERVICE 🌙

Why: Dinner tips $0.80 (36%) more than lunch

Actions:

Allocate best servers to dinner shift
Focus marketing on dinner hours
Create special dinner ambiance
Dinner-specific promotions

Expected Impact: Shift focus to higher-margin time period

3. OPTIMIZE FOR PARTY SIZES 2-4 👥

Why: These sizes have best tip-to-effort ratio

Actions:

Table arrangements favor 2-4 person parties
Special deals for couples/small groups
Don't overinvest in large party accommodations (tips plateau)

Expected Impact: Maximize tips per table/server time

4. WEEKEND FOCUS 📅

Why: Saturday/Sunday have higher tips

Actions:

Premium staffing on weekends
Weekend specials/events
Higher-end menu items on weekends

5. DON'T DISCRIMINATE BY SEX/SMOKER ⚖️

Why: These factors have minimal effect

Insight: Treat all customers equally - demographics don't significantly predict tipping

🧠 PERSONAL LEARNING JOURNEY

What I Learned About Data Science:

1. The Scientific Method Works!

Make hypothesis → Test → Analyze → Conclude
Being wrong is GOOD - that's how we learn!
Quote: "Learning happens with mistakes"

2. Hypotheses Can Be Wrong

My Wrong Predictions:

❌ Thought tipping was "keep the change" → Actually percentage-based
❌ Thought Sunday would have highest tips → Actually Saturday
❌ Thought males tip more → Actually nearly equal
❌ Thought smokers tip less → Actually slightly more

Lesson: Don't trust assumptions - test with data!

3. Correlation ≠ Causation

Smokers tip more, but WHY?
Could be confounding variables (age, location, etc.)
Need more data to understand mechanisms

4. Context Matters

Outliers aren't always errors
$10 tip on $50 bill = 20% (normal!)
Always calculate percentages/ratios for context

5. Data Quality First

Clean data = reliable analysis
Check for: missing values, duplicates, outliers
This dataset was excellent (0 missing!)

6. Visualization is Powerful

Scatter plots → see relationships
Box plots → compare groups
Correlation matrix → see everything at once
Pairplot → ultimate summary

7. Different Charts for Different Data

Numerical vs Numerical → Scatter plot
Categorical vs Numerical → Box plot / Bar chart
All at once → Pairplot, Correlation matrix

What I Learned About Python/Tools:

Python Libraries:

import pandas as pd           # Data manipulation
import numpy as np            # Numerical operations
import matplotlib.pyplot as plt  # Basic plotting
import seaborn as sns         # Statistical plotting

Key Functions Mastered:

Pandas:

data.head()              # First 5 rows
data.shape               # Dimensions
data.describe()          # Statistics
data.isnull().sum()      # Missing values
data.duplicated().sum()  # Duplicates
data.drop_duplicates()   # Remove duplicates
data['column']           # Select column
data[condition]          # Filter rows
data.groupby().mean()    # Group and aggregate
data.corr()              # Correlation matrix

Matplotlib:

plt.scatter(x, y)        # Scatter plot
plt.xlabel()             # X-axis label
plt.ylabel()             # Y-axis label
plt.title()              # Title
plt.grid()               # Grid lines
plt.show()               # Display plot

Seaborn:

sns.boxplot(x='category', y='number', data=df)
sns.heatmap(corr_matrix, annot=True)
sns.pairplot(df, vars=['col1','col2'], hue='category')

Important Concepts:

1. Order Matters!

# WRONG
outliers = data[data['tip'] > 5]
data['tip_pct'] = data['tip'] / data['total_bill']
print(outliers['tip_pct'])  # ERROR!

# RIGHT
data['tip_pct'] = data['tip'] / data['total_bill']
outliers = data[data['tip'] > 5]
print(outliers['tip_pct'])  # WORKS!

2. Matplotlib vs Seaborn:

matplotlib = Low-level, flexible, more code
seaborn = High-level, easy, pretty defaults
Use both together!

3. Data Types Matter:

float64 / int64 = Can do math
object = Text, can't do math

Skills I Developed:

✅ Technical Skills:

Data cleaning and preprocessing
Exploratory data analysis
Statistical thinking
Data visualization
Python programming
Using Jupyter notebooks

✅ Analytical Skills:

Hypothesis formation
Pattern recognition
Critical thinking
Drawing insights from data
Making business recommendations

✅ Soft Skills:

Scientific method application
Intellectual honesty ("I don't know")
Learning from mistakes
Persistence through challenges
Clear communication of findings

📊 COMPLETE VISUALIZATIONS CREATED

✅ Scatter Plot: total_bill vs tip
✅ Scatter Plot: size vs total_bill
✅ Scatter Plot: size vs tip
✅ Box Plot: tip by day of week
✅ Box Plot: tip by time (lunch/dinner)
✅ Box Plot: tip by sex
✅ Box Plot: tip by smoker status
✅ Correlation Matrix Heatmap
✅ Pairplot (all relationships)

Total: 9 professional visualizations

🎓 FINAL REFLECTION

What Worked Well:

Systematic approach (hypothesis → test → analyze)
Using appropriate visualizations for each relationship
Being open to being wrong
Thorough data cleaning before analysis

What I'd Do Differently:

Could explore interaction effects (e.g., day × time)
Could calculate tip percentages earlier for context
Could test non-linear relationships more formally

Most Surprising Finding:

"Party size plateaus at 5-6 people!"

Expected linear relationship
Discovered real-world behavioral economics
Shows the value of looking at data, not just assumptions

Most Important Lesson:

"Total amount of spending is the determining factor"

Simple but powerful
Actionable for businesses
Data-driven decision making

End of Journey Summary

"The only real mistake is the one from which we learn nothing." - Henry Ford

"In God we trust. All others must bring data." - W. Edwards Deming

DEV Community: NIRANJAN LAMICHHANE

I Built a Nepal Government Complaint Transparency Bot with Hermes Agent (From Zero, in One Hour )

What I Built

Demo

Code and My Tech Stack

How I Used Hermes Agent

The Setup Journey

The Build

What Surprised Me

Why This Matters for Nepal 🇳🇵

Building Multi‑Extension Tokens on Solana and making it compliance goated

Day 37: The Triple‑Extension Token

The Goal

Step 1 – Create the Mint

Step 2 – Initialize Metadata

Step 3 – Verify All Extensions

Step 4 – Create an Account and Mint 1000 Tokens

Step 5 – Test the Transfer Fee

Step 6 – Harvest Withheld Fees

Day 38: Compliance‑Gated Token (Default Frozen)

The Goal

Step 1 – Create the Mint with --default-account-state frozen

Step 2 – Create Two Token Accounts (Both Will Be Frozen)

Step 3 – Try to Mint (Must Fail)

Step 4 – Thaw Your Account (The “KYC Approval”)

Step 5 – Mint Now Succeeds

Step 6 – Transfer to Still‑Frozen Second Account (Must Fail)

Step 7 – Thaw Second Account, Then Transfer Succeeds

What I Learned

Intrest bearing token in solana

Create an Interest‑Bearing Token on Solana (Token‑2022) – Step by Step

1. Prerequisites

2. Create the Mint (with 5% interest)

3. Create a Token Account for Your Wallet

4. Mint 1000 Tokens

5. Observe the Growing Balance

Check UI balance (applied interest)

Inspect mint metadata

See raw account data (optional)

6. Wait and Watch Interest Compound

7. Change the Interest Rate

8. Rate Limits

My Full Command History (Reference)

Why This Matters

Understanding tokenomics of Solana

Solana Account Model — City Analogy

Think of Solana as a city

The 5 fields — what every building has

Why are program and data separate buildings?

The three building types in the city

One-line rule to remember forever

Solana Transactions: not just a “request/response” ,but “atomic on-chain state changes”

Pay to attempt, not just to succeed

What the failed tx showed

Final Note : err.logs vs console.error

Recommendation : Always use both:

Policy Storyteller: Turning Nepali Bills into Human Stories with Gemma 4

What I Built

Demo

How I Used Gemma 4

Which Model & Why

Stack

Learned (quick)

Links

NO no Account is not just a database , whose history is traced and logged .

First experince with programming in web3

Learning of W1 of #100DaysOfSolana

Coffee, Code, and Junie: My Journey to 10x Productivity with JetBrains AI

Dream of 10x Developer :

My Favourite part :

Important Contribution :

Impressive Refactoring :

UI Magic for Backend Developers:

The Flow State Achievement:

Most Misused Capability :

Wish it was there :

My Data Science Journey: Restaurant Tips Analysis

📊 PROJECT OVERVIEW

Dataset Information

Project Goal

Step 1 – Create the Mint with `--default-account-state frozen`