DEV Community: Roman Horishkov

How to deploy a smart contract on NEAR using Windows: A step-by-step guide

Roman Horishkov — Tue, 22 Apr 2025 11:06:34 +0000

How to deploy a smart contract on NEAR using Windows: A step-by-step guide

No Linux expertise required — just WSL, coffee, and patience! ☕

🚨 Troubleshooting common issues

Permission errors:
1. Add sudo to commands (e.g., sudo apt-get update).
Node.js/NPM installation fails:
1. Reinstall Ubuntu: wsl --unregister Ubuntu wsl --install --d Ubuntu
Transaction failures:
1. Check gas limits: Use gas: "300000000000000" in functionCall.
2. Validate account ID formatting (e.g., alex_work.testnet).

🛠️ Step 1: Set up Windows Subsystem for Linux (WSL)

NEAR’s tooling works best on Linux, but Windows users can bypass this with WSL (a lightweight Linux VM).

Run these commands in PowerShell (Admin):

wsl --set-default-version 2 # Use WSL2 for better performance wsl --install --d Ubuntu # Install Ubuntu

After installation:

Launch Ubuntu from the Start Menu.
Create a UNIX username/password (store it somewhere safe).

💻 Step 2: Install dependencies in Ubuntu

Copy-paste these commands into your Ubuntu terminal:

Update packages, install dev tools, Rust & WASM target, NEAR CLI, and cargo-near
sudo apt-get update && sudo apt upgrade -y sudo apt-get install gcc make libudev-dev openssl pkg-config unzip -y curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh source $HOME/.cargo/env rustup target add wasm32-unknown-unknown curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/near-cli-rs/releases/latest/download/near-cli-rs-installer.sh | sh curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/cargo-near/releases/latest/download/cargo-near-installer.sh | sh

In the end, you should get this:

📦 Step 3: Create & build a smart contract

NEAR’s "hello-near" template is perfect for testing.

Generate a project, compile to WASM

cargo near new hello-near cd hello-near cargo near build

Looking for this success message: ✅ Contract successfully built!

🔑 Step 4: Deploy to NEAR testnet

Replace your-account-id.testnet with a unique name (e.g., alex_work.testnet, which I was using ).

Create a testnet account (auto-funded via faucet) and Deploy the contract

near create-account <your-account-id.testnet> --useFaucet near deploy <your-account-id.testnet> ./target/near/hello\_near.wasm

This is a contract code:

// Find all our documentation at https://docs.near.org
use near_sdk::{log, near};

// Define the contract structure
#[near(contract_state)]
pub struct Contract {
    greeting: String,
}

// Define the default, which automatically initializes the contract
impl Default for Contract {
    fn default() -> Self {
        Self {
            greeting: "Hello".to_string(),
        }
    }
}

// Implement the contract structure
#[near]
impl Contract {
    // Public method - returns the greeting saved, defaulting to DEFAULT_GREETING
    pub fn get_greeting(&self) -> String {
        self.greeting.clone()
    }

    // Public method - accepts a greeting, such as "howdy", and records it
    pub fn set_greeting(&mut self, greeting: String) {
        log!("Saving greeting: {greeting}");
        self.greeting = greeting;
    }
}

/*
 * The rest of this file holds the inline tests for the code above
 * Learn more about Rust tests: https://doc.rust-lang.org/book/ch11-01-writing-tests.html
 */
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn get_default_greeting() {
        let contract = Contract::default();
        // this test did not call set_greeting so should return the default "Hello" greeting
        assert_eq!(contract.get_greeting(), "Hello");
    }

    #[test]
    fn set_then_get_greeting() {
        let mut contract = Contract::default();
        contract.set_greeting("howdy".to_string());
        assert_eq!(contract.get_greeting(), "howdy");
    }
}

My deployment stats (View on NearBlocks):

Cost: 0.000757 Ⓝ (~$0.0015 USD).
Time: Less than 1 second.

📝 Step 5: Interact with Your Contract

Set a Greeting (Cost: 0.000168 Ⓝ):
near call <your-account-id.testnet> set\_greeting '{"greeting": "Hola NEAR!"}' --accountId <your-account-id.testnet>
Read the Greeting (Free):
near view <your-account-id.testnet> get\_greeting
Output: "Hola NEAR!"

Total spent: 0.000925 Ⓝ (~$0.002 USD) for deployment + interaction.

🎉 Why NEAR dominates

Cost: 1000x cheaper than Ethereum.
Speed: Transactions finalize faster than typing a tweet.
Simplicity: No MetaMask popups or gas anxiety.

Guides for Further Learning:

Now go build something awesome — and let Ethereum devs wonder how you did it for pennies! 🚀

My First Week on NEAR Protocol as a Developer: From Skeptic to Advocate

Roman Horishkov — Thu, 17 Apr 2025 17:18:56 +0000

Hey builders 👋,

I’ve spent years tinkering with Ethereum, Solidity, and the usual L2 suspects. But last week, I decided to dive into NEAR Protocol—and holy cow, it felt like swapping a rusty bike for a Tesla. Here’s my journey, complete with code, aha moments, and a very happy wallet.

🌅 Day 1: Setting up (Faucets, wallets, and Zero gas panic)

Why NEAR?Ethereum’s gas fees had turned my hobby projects into a financial burden. NEAR’s promise of sub-cent transactions and Rust/Wasm support hooked me.

First steps:

1. Created a NEAR wallet in 30 seconds: wallet.near.org.

2. Grabbed testnet tokens from the faucet: No KYC, no drama.

3. Installed NEAR CLI:

npm install -g near-cli-rs near login

Immediate win:

● Gas Costs: Sent 10 test transactions for less than $0.01 total. Ethereum could never.

📝 _Day 2: Deploying my first smart contract (Rust FTW)

The project: A simple DAO voting contract.

Code snippet (Rust):

Deployment:

Why NEAR won me over:

● No Solidity: Rust’s safety + WASM’s speed = fewer runtime errors.

● Instant finality: Transactions are confirmed in 2 seconds.

🖥️ _Day 3: Building a Web3 frontend

Task: Connect a React app using NEAR’s recommended workflow.

Code Snippet (JavaScript):

● Users could vote without gas prompts (sponsored transactions FTW).

● Frontend updates were seamless—no waiting for 12 block confirmations.

● Seamless Reads/Writes of viewFunction and functionCall mirror NEAR’s official examples.

🌐 _Day 4: Exploring the NEAR Ecosystem (BOS + Aurora)

Discoveries:

1. Aurora EVM: Deployed my old Solidity contracts with 2-second finality and $0.001 fees.

○ Tutorial: Aurora + NEAR Guide

2. BOS (Blockchain Operating System): Glued together components from different chains into one UI.

○ Example: BOS Component Gallery

Mind blown:

● Rainbow Bridge: Moved ETH to NEAR in 5 minutes.

● NEAR Social: Built a profile like a Web3 LinkedIn.

🚧 _Day 5: Debugging (Yes, even NEAR has quirks)

Debugging snippet:

Challenges faced:

1. Rust learning curve: Borrow checker fights 😤.

○ Fix: Used NEAR Rust Docs for reference.

2. Sparse SDK examples: Some advanced features lacked tutorials.

○ Fix: Joined NEAR Discord—community helped instantly.

Lesson learned:

● NEAR’s tooling is young but growing fast. The tradeoff? Less boilerplate, more flexibility.

🏁 _Final takeaways

Why NEAR?

● Cost: 1000x cheaper than Ethereum.

● Speed: Sub-3-second transactions.

● UX: Wallet integrations feel magical for end-users.

When to Choose NEAR:

● You’re building user-first dApps (no gas popups!).

● You want Rust’s safety without Solidity’s quirks.

● Your app needs cross-chain features (Aurora + BOS = cheat code).

Get Started Now:

1. NEAR Docs: Best place to start.

2. NEAR Examples: Code templates for everything.

3. Aurora: For Ethereum refugees.

Peace,\
— A dev who finally built something without crying over gas fees. 🚀

Why I changed Uniswap to Rhea Finance for my dApp (Spoiler: Dev life just got easier)

Roman Horishkov — Wed, 09 Apr 2025 12:08:04 +0000

Why I changed Uniswap to Rhea Finance for my dApp (Spoiler: Dev life just got easier)

Hey fellow devs 👋,

I wanted to share a recent shift in my stack that's saved me time, gas, and headaches. For years, I built on Uniswap — solid protocol, great liquidity, no complaints. But when I started developing a high-frequency trading dApp, Ethereum's gas fees and Uniswap's integration complexity became a wall. Enter Rhea Finance on NEAR Protocol. Here's why I made the switch—and why you might consider it too.

😤 The Uniswap struggle

Uniswap's SDK is powerful, but integrating even basic features felt like running a marathon. For example, adding liquidity required:

ERC-20 approvals (hello, gas waste!).
Complex slippage calculations.
Praying for no reverts mid-flow.

Here’s what that looked like in code:

And don't get me started on debugging failed txns costing $50 a pop.

🚀 Rhea Finance: "The simplicity you needed"

Ref's NEAR-based contracts cut steps (and costs) dramatically. Here’s the same liquidity addition on Ref:

Why this won me over:

No approvals: NEAR's account model handles permissions natively.
Atomic transactions: Bundle swaps, deposits, and stakes in one tx.
Gas costs under 0.01: Itested100iterationsforlessthan1cent.

🔄 Uniswap vs Ref. Code comparison (swaps)

Uniswap (Ethereum):

Rhea Finance (NEAR):

No dependency on external routers. Less code = fewer bugs.

Rhea is the winner🏆

🛠️ Fetching Pool Data

Uniswap (The Graph Subgraph)
Requires querying a subgraph:

Rhea Finance (Direct Contract Call)
Query the contract directly via NEAR’s RPC:

Why the Rhea wins here:

No reliance on third-party indexers like The Graph.
Direct contract reads simplify data fetching.

⚠️ Caveats to Know

The Rhea SDK is still evolving (official docs say it's "coming soon"), so compared to Uniswap's battle-tested SDK, it is less complete. But you can use NEAR's core SDK (near-api-js) today for all critical operations.

a. Uniswap's SDK is like IKEA furniture: pre-packaged but rigid.

b. Rhea + NEAR SDK is like a toolbox: fewer pre-built solutions, but you can craft exactly what you need.
Smaller liquidity pools. Unfortunately, Uniswap's depth is unmatched, but NEAR's Rainbow Bridge lets you port Ethereum assets over.

🛠 When to Choose Ref

You're building cost-sensitive apps (e.g., microtransactions, social tokens).
You want atomic multi-action flows (e.g., swap + stake + mint NFT in one click).
You prefer Rust/Wasm's performance over Solidity.

📅 What You Can Do Today

Create a NEAR wallet in 30 seconds: wallet.near.org.
Bridge assets via Rainbow Bridge: Move ETH or USDC to NEAR in 5 minutes: rainbowbridge.app.
Execute your first sub-cent swap: Trade NEAR for USDT here: ref.finance.

🏁 Final Takeaway

Uniswap is still king for Ethereum-native apps, but Rhea Finance saved me weeks of dev time (and my users from gas frustration and anxiety). If you're tired of Metamask popups and want to ship faster, give Rhea a shot—just double-check the contracts if the docs are behind.

Peace,

—A dev who's finally enjoying his coffee without Metamask popups. ☕