DEV Community: Stellar Development Foundation

Dev Diaries Ep.6 | Launch Day

James Bachini — Mon, 13 Oct 2025 11:20:15 +0000

Startups in Web3 don’t launch like traditional products, there are no rollbacks, no "patch it later" second tries.

When you hit deploy on-chain, it's live and responsible for financial transactions.

In Episode 6 of the Stellar Dev Diaries, the Freelii team takes the leap every founder dreams about: launching on Stellar mainnet.

🎥 Check out Episode 6: Launch Day

📺 Watch it on YouTube

In this episode, the team reflects on the reality of launch day:

🚀 The emotions of finally going live after months of testing and preparation
😬 The nerves and risks of pushing code to an immutable blockchain
🛠 The last-minute fixes and checks before hitting deploy
🤝 How Stellar’s support—grants, feedback, and guidance—made launch possible
💡 Advice for other Web3 founders preparing for mainnet
🔮 Their vision for how Web3 and DeFi will evolve over the next decade
💳 What’s next for Freelii

Launch day isn't hype, it's execution. Freelii is live. Mainnet is real. And this is just the beginning.

🛠 Ready to build on Stellar? Dive into the dev docs:

🌐 https://developers.stellar.org/

👀 Catch up on the series:

Episode 1: How a Hackathon Project Became a Web3 Startup
Episode 2: How The Freeli Team Raised $70k+ In Funding
Episode 3: User Feedback & The Pivot That Saved The Project
Episode 4: Building Production Systems That Handle Real Money
Episode 5: Startup Life Isn't Always Glamorous
Episode 6: Launch Day

Dev Diaries Episode 5 – Startup Life Isn't Always Glamorous

James Bachini — Fri, 05 Sep 2025 11:34:24 +0000

Startups in Web3 don’t follow straight lines. The technology shifts under your feet, the rules are unclear, and the grind is relentless. In Episode 5 of the Stellar Dev Diaries, we step away from code and architecture to explore the human side of building Freelii.

🎥 Check out Episode 5: Startup Life Isn’t Always Glamorous

📺 Watch it on YouTube

In this episode, Jose and Joseph open up about the unseen struggles of startup life:

⚡ The pressure of shipping products that must work on-chain, with no safety net
💡 Features they dreamed of building if time and resources weren’t constraints
😓 The lowest points of the journey—and what kept them moving forward
🤝 Lessons in trust, persistence, and teamwork that made Freelii possible
🤖 How AI tools like ChatGPT helped (and sometimes failed) when building at the cutting edge
🌐 Why Stellar’s transparency and reliability made it the right home for Freelii

Startup life isn't always glamorous. It’s late nights, broken builds, and quiet persistence. Episode 5 shows what it really takes to keep going when the hype fades and the grind begins.

🛠 Ready to build on Stellar? Dive into the dev docs:
🌐 https://developers.stellar.org/

👀 Catch up on the series:

Episode 1: How a Hackathon Project Became a Web3 Startup
Episode 2: How The Freeli Team Raised $70k+ In Funding
Episode 3: User Feedback & The Pivot That Saved The Project
Episode 4: Building Production Systems That Handle Real Money
Episode 5: Startup Life Isn't Always Glamorous

Dev Diaries Episode 4 – Building A Reliable Payout System In DeFi

James Bachini — Fri, 08 Aug 2025 23:55:41 +0000

Ever wondered what it really takes to move money at scale using blockchain? In Episode 4 of the Stellar Dev Diaries, we go under the hood with the Freelii team as they tackle one of the hardest challenges in Web3: building a secure, reliable, cross-border payout system.

🎥 Check out Episode 4: Building a Reliable Payout System in DeFi

📺 Watch it on YouTube

Missed earlier episodes?
👉 Episode 1: How a Hackathon Project Became a Web3 Startup
👉 Episode 2: How The Freeli Team Raised $70k+ In Funding
👉 Episode 3: User Feedback & The Pivot That Saved The Project
👉 Episode 4: Building Production Systems That Handle Real Money

In Episode 4, we dive deep into the technical architecture behind Freelii’s payout system. The mission? Help businesses pay global teams without the pain of traditional banking delays and fees.

We explore:

🔧 How Freelii designed a system to handle real money, real users, and real risk
🌐 Solving the cross-border payment problem for influencer houses, remote teams, and digital businesses
🚀 Why they chose Stellar for its speed, low fees, and powerful anchor ecosystem
💡 How “policy signers” let them execute secure automated transactions without user interaction
🧪 The challenge of testing without a sandbox—and how the team used Stellar’s testnet and custom tools to bridge the gap
📊 How a serverless backend with Upstash queues ensures reliable transaction execution

🛠 Ready to build on Stellar? Dive into the dev docs:
🌐 https://developers.stellar.org/

Follow the Freelii team as they continue building toward launch. Episode 4 is all about going live on mainnet—don’t miss it!

👀 Watch the series:
🎬 Episode 1: How a Hackathon Project Became a Web3 Startup
🎬 Episode 2: How The Freeli Team Raised $70k+ In Funding
🎬 Episode 3: User Feedback & The Pivot That Saved The Project
🎬 Episode 4: Building Production Systems That Handle Real Money

Dev Diaries Episode 3 - User Feedback & The Pivot That Saved The Project

James Bachini — Tue, 24 Jun 2025 11:58:49 +0000

In the Stellar Dev Diaries series, we’re following the journey of a dev team building on the Stellar Network as they go from hackathon idea to funded startup, testing their product in the real world and adapting as they go.

🎥 Check out Episode 3: User Feedback & The Pivot That Saved The Project

📺 [Watch on YouTube]

Missed the earlier episodes?
👉 Episode 1: How a Hackathon Project Became a Web3 Startup
👉 Episode 2: How the Freelii Team Raised $70k+ In Funding

What’s It All About?

In this series, we go behind the scenes with the team at Freelii as they build and launch a new product on the Stellar Network. You’ll get a raw, unfiltered look at the process—ideation, feedback, failure, and pivots—all while working with the cutting-edge tools Web3 has to offer.

Each episode explores the team’s journey from prototype to product, sharing not only technical insights and code walkthroughs, but also the hard lessons learned when your ideas meet the real world.

Episode 3

Episode 3 is all about the pivot—and the power of listening.

After developing an early version of their chatbot-based remittance product, José and Joseph took it to the Philippines to test in one of the world’s largest remittance markets. The feedback was humbling. Users didn’t trust messaging apps for handling money. The team’s assumptions didn’t hold up, and it forced a tough but necessary shift in direction.

Instead of sticking to the original plan, the team listened. And that led them to a better opportunity: automating business payouts.

💡 “We stopped trying to get individuals to change their behaviour and started solving a real, painful problem for businesses.”

This episode covers:

Field-testing a Web3 prototype in the real world
Gathering user feedback in one of the world’s top remittance markets
Why cultural insights matter when designing fintech tools
Learning that trust and compliance are more important than tech novelty
Discovering a new use case by talking to business owners
Pivoting from a consumer remittance app to a B2B payout automation platform

This pivot plays directly to Stellar’s strengths—fast, low-cost transactions and seamless crypto-to-cash conversion—while giving the team a much clearer go-to-market strategy.

The Takeaway?

If you're building in Web3: talk to your users early and often.
Innovation means nothing if it doesn’t solve a real problem.

Freelii’s journey is a masterclass in adaptability—proof that the best ideas are often uncovered after launch, not before.

Next Up

In Episode 4, we dive into the technical side of the new payout system—how it works, what’s under the hood, and the Stellar features that power it.

Stay tuned.

🛠 Want to start building on Stellar? Check out the dev docs here:
https://developers.stellar.org/docs

🔐 Learn more about passkeys here:
https://jamesbachini.com/webauthn-passkey-smart-wallets/

👀 Catch up on the full series so far:

📺 Episode 1: How a Hackathon Project Became a Web3 Startup
📺 Episode 2: How the Freelii Team Raised $70k+ In Funding
📺 Episode 3: User Feedback & The Pivot That Saved The Project

Follow the journey. Learn by building.

🚀 Stellar Dev Diaries: Episode 2 - Becoming Fundable

James Bachini — Thu, 08 May 2025 07:06:50 +0000

Ever wondered what it takes to build a Web3 startup from scratch? In the Stellar Dev Diaries series, we’re following the journey of a team of developers building on the Stellar Network as they go from hackathon wins to getting funded and launching their product on mainnet.

Check out Episode 2: Becoming Fundable

Missed Episode 1: Watch it here

What’s It All About?

In this series, we take a deep dive into the experiences of the Freelii team as they build and launch their product on the Stellar Network.

Throughout the series, you'll get an inside look at what it takes to go from zero to one: turning ideas into products, getting funded, and scaling a startup in a fast-moving space. Each episode will feature real code examples with walkthroughs of the features the team used and the challenges they encountered along the way.

Episode 2

In Episode 2, we explore how the team pivoted from their initial idea into something with broader appeal to secure more hackathon wins. We also hear more about their experiences navigating the grant application process to secure funding from the Stellar Community Fund.

On the technical side, we go deeper into the tools that Jose and Joseph used to build the first version of the Freelii remittance chatbot, discussing some key Stellar features that made it possible.

In this episode, we dive into:

The experience of going from hackathon partners to full-blown entrepreneurs
Building a Telegram mini app
Leveraging Stellar Anchors for seamless on-ramping
Successfully applying for a grant from the Stellar Community Fund
Managing early-stage costs to maximize runway

Want to know what it takes to build and launch a product in Web3? Then keep watching as we follow José and Joseph on their journey from idea to mainnet.

To learn more about the Stellar Anchors feature that we discussed in the episode, check out the tutorials here:

✒️ https://jamesbachini.com/stellar-anchor-platform/

📺 https://youtu.be/57iZMxAr_1Y

To start building on Stellar, check out the developer docs here.

Follow the Freelii team as they build, adapt, and prepare to launch their product on the Stellar Network. Check out all the episodes here:

Episode 1: How a Hackathon Project Became a Web3 Startup
Episode 2: How The Freeli Team Raised $70k+ In Funding
Episode 3: User Feedback & The Pivot That Saved The Project

🚀 Stellar Dev Diaries Series: Episode 1 is LIVE!

James Bachini — Wed, 09 Apr 2025 19:52:43 +0000

Ever wondered what it takes to build a web3 startup from scratch? In the Stellar Dev Diaries series, we follow the journey of a team of developers building on the Stellar Network as they go from hackathon win to getting funded and launching on mainnet.

Check out Episode 1: How a Hackathon Project Became a Web3 Startup

What’s It All About?

In the Stellar Dev Diaries, we take a dive deep into the experiences of the Freelii team as they build and launch their product on the Stellar Network.

As we follow their journey, you'll get the insider's playbook: turning ideas into products, getting funded, transitioning from Web2 to Web3, and scaling a startup in a space that's still being defined. On top of that, each episode will feature real code examples with walkthroughs of the features they used and challenges they encountered.

Episode 1

In Episode 1, we meet José Toscano and Joseph Anthony, the brains behind Freelii, a startup that started as a hackathon win right here on Dev.to and went on to win again at Stellar’s Hack Meridian in London.
Realizing that they had a winning partnership and a great product idea, José and Joseph secured funding, quit their 9-to-5 jobs, and went all in on Freelii.

In this episode, we dive into:

The hackathon wins that sparked the journey.
The moment José and Joseph decided to go all-in.
Building a working prototype on Stellar.
Using the PassKeys feature of Soroban.
Getting funded via the Stellar Community Fund.

Want to know what it takes to build and launch a product in Web3? Then keep watching as we follow José and Joseph on their journey from idea to mainnet.

If you want to learn more about the PassKeys feature that we discussed in the episode, check out the tutorials here:

If you want to start building on Stellar, check out the developer docs here.

Follow the Freelii team as they build, adapt, and prepare to launch their product on the Stellar Network. Check out all the episodes here:

Episode 1: How a Hackathon Project Became a Web3 Startup
Episode 2: How The Freeli Team Raised $70k+ In Funding
Episode 3: User Feedback & The Pivot That Saved The Project

Building dApps on Stellar

Julian Martinez — Fri, 02 Aug 2024 14:40:35 +0000

This is part of a series of livestreams designed to help the community participate in the Build Better on Stellar: Smart Contract Challenge:

Join Us For The First Community Smart Contract Challenge With $50,000 In Prizes!

dev.to staff for The DEV Team ・ Jul 10 '24

#devchallenge #stellarchallenge #web3 #blockchain

In this video, we build a full-stack crowdfunding dApp using Stellar smart contracts. The session covers the following topics:

Configuring the development environment
Initializing and setting up a project using example templates
Integrating Freighter wallets for user authentication and interaction
Minting tokens
Making deposits and more!

Upcoming Streams

Looking for some live support? Join our next stream. All sessions start at 12pm EDT.

8/1: Intro to Passkeys
8/6: Migrating from Web2 to Web3
8/8: Stellar Community Fund

Intro to Stellar: Get Started in Rust, Set Up Your Development Environment, and Write Your First Smart Contract

Julian Martinez — Thu, 25 Jul 2024 15:51:01 +0000

Hello! This is the first in a series of five livestreams designed to help the community participate in the Build Better on Stellar: Smart Contract Challenge:

Join Us For The First Community Smart Contract Challenge With $50,000 In Prizes!

dev.to staff for The DEV Team ・ Jul 10 '24

#devchallenge #stellarchallenge #web3 #blockchain

In this video, we cover the basics of Rust smart contract development, which includes:

Setting up Okashi, a smart contract playground for Soroban
Key concepts such as data types, storage management, functions, and the Stellar CLI
Deploying on Stellar testnet and more!

Additional Resources:

Julian-dev28 / consensus-hackathon-c2defi

everything you need to know about the consensus hackathon

Consensus Hackathon Cash to DeFi

Welcome to the Consensus Hackathon Cash to DeFi track! This README serves as your comprehensive guide to everything you need to know about the hackathon, from the workshop overview to important resources and judging criteria.

Workshop Overview

This hackathon track is based on the Consensus Workshop: Cash to DeFi Track. The workshop aims to onboard developers to the Stellar ecosystem and provide guidance on building decentralized finance (DeFi) applications using Rust and smart contracts.

Workshop

Introduction to Rust and the Development Environment
Building Defi Smart Contracts
Building Defi Dapp Frontend
Conclusion

Workshop Resources

The concepts behind the Staking Workshop are designed to help you understand the basics of Rust and smart contract development on the Stellar network.

The following resources cover the concepts behind the staking example and provide a foundation for building more complex applications.

Introduction to Rust and the Development Environment

Stellar Docs:…

View on GitHub

Upcoming Streams

Looking for some live support? Join our next stream. All sessions start at 12pm EDT.

7/30: Build a dApp
8/1: Intro to Passkeys
8/6: Migrating from Web2 to Web3
8/8: Stellar Community Fund

Building Hello World Smart Contracts: Solidity vs. Soroban Rust SDK - A Step-by-Step Guide

Julian Martinez — Tue, 09 Jul 2024 13:17:25 +0000

How to migrate smart contracts from Ethereum’s Solidity to Soroban Rust
In this tutorial, we'll explore the intricacies of two major smart contract programming environments: Ethereum's Solidity and Soroban’s Rust SDK and why should consider migrating your smart contracts to Rust

Why would a blockchain developer choose Rust over Solidity?

In the blockchain and smart contract realm, Rust is a standout choice for developers, and here's why:

Speed & Efficiency: Rust whizzes through tasks like a sports car in style. It is super fast, even outpacing C++ when it comes to speed and efficiency so that your blockchain operations are not just quick but also smart, saving on resources.
Type Safety: Picture Rust's type system as a meticulous inspector, who is watching each bit of your code at compile time. This means fewer errors and a safer environment for your smart contracts.
Memory Safety Without the Overhead: Rust boasts top-shelf memory safety, acting as an invisible shield against vulnerabilities critical in the blockchain world. And it does this leanly without needing a garbage collector, keeping your projects lean and fortified.
Conquering Concurrency with Ease: In blockchain, handling simultaneous transactions is like juggling fireballs. Rust excels in managing multiple operations seamlessly, preventing the common complications seen in other languages. This leads to faster, safer processing of transactions, enhancing the overall performance of your smart contracts. Rust combines speed, safety, and execution efficiency making it an ideal language for blockchain development where such qualities are demanded. So how does Rust stack up against Solidity?

What’s the difference between EVM and Soroban?

What is the EVM?

The Ethereum Virtual Machine (EVM) is a core component of the Ethereum blockchain network. It is a virtual environment that allows for the execution of smart contracts and decentralized applications (dApps). While Ethereum is the primary network utilizing the EVM, other blockchain platforms have adopted or created compatible versions of the EVM. For instance:

Avalanche has its own virtual machine, the Avalanche Virtual Machine (AVM), but it also supports the EVM through its C-Chain, enabling compatibility with Ethereum-based applications.
Optimism and Polygon are Layer 2 solutions built on top of the Ethereum blockchain. They use Optimistic Rollups and Polygon's own technology, respectively, but are compatible with the EVM. This means they can run Ethereum smart contracts and dApps.

Each blockchain network can have its own consensus mechanisms, underlying architecture, and protocol implementations. Geth (Go Ethereum, an implementation of an Ethereum node in the Go programming language) is specifically an Ethereum client, and while other networks might draw inspiration or use aspects of Ethereum's technology, they often have distinct core protocols and implementations.

In EVM Land, Solidity is the go-to language for developing smart contracts. Here's a quick rundown for my fellow builders:

Object-Oriented Approach: Just like other OOP languages, Solidity organizes code around data and objects, not just functions and logic.
High-Level Language: It abstracts away from the nitty-gritty of computer hardware, making development smoother and more intuitive.
Statically-Typed: Solidity checks your code for errors and type mismatches at compile time, saving you from a lot of headaches later.

What makes Solidity stand out is its role in powering decentralized transactions and managing blockchain accounts. Plus, if you're comfortable with JavaScript, C++, and Python you'll find Solidity's syntax familiar.

What is Soroban?

Soroban is a smart contracts platform with sensibility, built-to-scale, batteries-included and developer-friendly wants.

While it works great with Stellar being that it shares the blockchain's values of scale and sensibility, it neither depends nor requires Stellar at all and can be used by any transaction processor, including other blockchains, L2s, and permissioned ledgers.

Currently, Soroban is available as a part of the v20 of Stellar protocol stable release. The package for the module consists of - smart contracts environment, a Rust SDK, A CLI, and an RPC server. Writing and testing of the contracts can be carried out on developers' local machines or deployed to Testnet.

Which programming language is used for Stellar smart contracts?

Introduced in 2022, the Soroban Rust SDK is a suite of tools specifically for writing smart contracts on the Soroban platform. Built on Rust, it enables developers to create decentralized finance applications, automated market makers, and tokenized assets, while also leveraging some of Stellar's core functionalities.

How to Build a Hello World Smart Contract

We will create two "Hello World" contracts: first in Solidity, then using the Soroban Rust SDK.

Here is the video if you want to follow along:

Solidity Version

Open the remix-ide in your browser by navigating to: https://remix.ethereum.org/

Click on the “create new file” icon in the "File Explorer" tab:

Type the file name “HelloWorld.sol” and enter the following code into the ide:

// SPDX-License-Identifier: MIT
// compiler version must be greater than or equal to 0.8.20 and less than 0.9.0
pragma solidity >=0.7.0 <0.9.0;

contract HelloWorld {
    function hello(string memory to) public pure returns(string memory){
        string memory greeting = string(abi.encodePacked("hello ", to));
        return greeting;
    }
}

Let's take a quick intermission to break down the code:

// SPDX-License-Identifier: MIT

This comment indicates the license under which the code is released (MIT License).

pragma solidity >=0.7.0 <0.9.0;

This line specifies that this code is compatible with Solidity compiler versions greater than or equal to 0.7.0 and less than 0.9.0. It sets compiler version boundaries to ensure code compatibility and expected behavior.

contract HelloWorld {

Here, we declare a Solidity contract named "HelloWorld."

function hello(string memory to) public pure returns(string memory){

This line defines a function named "hello."

It takes one argument, a string named "to," which represents the name of the person you want to greet.
The function is marked as "public," which means it can be called externally.
The "pure" keyword indicates that this function does not modify the contract's state.

string memory greeting = string(abi.encodePacked("hello ", to));

Inside the "hello" function, a new string variable "greeting" is declared.

It is constructed by concatenating "hello" with the provided name using the abi.encodePacked function.
The result is stored in the "greeting" variable.

return greeting;

Finally, the function returns the "greeting" string as the result of the function call.

Now back to our regularly scheduled programming(🥁)

Once the code is in Remix, click the "Solidity Compiler" icon below the “File Explorer” icon.

Then, click “Compile HelloWorld.sol” or simply press cmd+s

Once compiled successfully click the icon below “Solidity Compiler” that is “Deploy & Run Transactions”.

Without changing any of the values as shown above just click the “Deploy” button to deploy your smart contract. Once deployed you will find your smart contract just below in “Deployed Contracts” heading.

Click “>” before your contract you will see a button “hello” below as our contract has a hello function variable that returns a string composed of “hello” + the value you passed in for the to argument.

Define an value for to and then click the “hello” button to return the greeting:

Nicely done! Now for the real Mccoy!

Soroban Rust SDK Version

Open the smart contract playground built for Soroban, okashi, in your browser by navigating to: https://okashi.dev/

Start a new project and name it HelloWorld.

Enter the following code into the IDE:

#![no_std]
use soroban_sdk::{contract, contractimpl, symbol_short, vec, Env, Symbol, Vec};

#[contract]
pub struct Contract;

#[contractimpl]
impl Contract {
    /// Say Hello to someone or something.
    /// Returns a length-2 vector/array containing 'Hello' and then the value passed as `to`.
    pub fn hello(env: Env, to: Symbol) -> Vec<Symbol> {
        vec![&env, symbol_short!("Hello"), to]
    }
}

Time for another commercial break already!?!

Don't worry this one is going to help you polish up on your Rust(🥁)

#![no_std]

This directive is used at the beginning of the Rust code to specify that the standard library (std) should not be included in the build. In Soroban contracts, the standard library is excluded because it's large and not suitable for deployment on blockchains.

use soroban_sdk::{contract, contractimpl, symbol_short, vec, Env, Symbol, Vec};

The use keyword is used to import external dependencies or modules into the current Rust code.
soroban_sdk: This is the crate/module that provides the necessary functionalities and types for Soroban contracts.
{contract, contractimpl, symbol_short, vec, Env, Symbol, Vec}: These are the specific items being imported from the soroban_sdk module, including attributes, macros (contract, contractimpl, symbol_short!), and data types (Env, Symbol, Vec).

#[contract]
pub struct Contract;

#[contract] is an attribute applied to the Contract struct, designating it as the type to which contract functions are associated. It implies that this struct will have contract functions implemented for it.
pub struct Contract; defines a public struct named Contract. In Soroban contracts, contract functions are associated with this struct.

#[contractimpl]
impl Contract {
    pub fn hello(env: Env, to: Symbol) -> Vec<Symbol> {
        vec![&env, symbol_short!("Hello"), to]
    }
}

#[contractimpl] is an attribute that is applied to the impl block for the Contract struct, indicating that this block contains the implementation of contract functions.
impl Contract { ... }: This is the implementation block for the Contract struct, where contract functions are defined.
pub fn hello(env: Env, to: Symbol) -> Vec { ... }: This line defines a public function named hello. It takes two arguments, env of type Env and "to" of type Symbol(in this case, a string of up to 8 characters). It also specifies the return type as Vec
{ vec![&env, symbol_short!("Hello"), to] }: This block of code is where a length-2 vector/array containing "Hello" and then the value passed as "to" is constructed and returned.

That's all the breaks we have for today. Don't get crabby on me!(🥁)

Now that the code is in the editor, compile it by clicking the compile button or pushing “cmd+k”

Open the contract tab and push the hello() button

Pass in an value for to and click the “call” button

The "Console" tab should open and you should see your message!

Comparison and Conclusion

Both Solidity and Soroban provide the functionality to declare public functions. However, their approaches to data handling and state management differ, influenced by their core languages – JavaScript for Solidity and Rust for Soroban. Solidity is ideal for those familiar with JavaScript, while Soroban's Rust foundation offers advantages in concurrency and safety.

Additional Resources

For developers interested in transitioning from EVM to Soroban, we have comprehensive documentation that covers everything from the basics of the Soroban Rust SDK compared to Solidity, up to deploying your own smart contracts with Rust. Learn more about migrating from EVM here.
If you’re looking for more tools and want to learn more about the sdk, you can check out the official Soroban docs here.

Stay tuned for more insights and tutorials in this series, and happy coding in the world of smart contracts!

Build Better With Stellar Smart Contract Challenge: A Companion Guide

Julian Martinez — Tue, 09 Jul 2024 13:16:16 +0000

Interested in our web3 challenge but not sure where to start? In this post, we'll share an overview of web3 and blockchain technology and set you up with all the information you need to learn about Stellar and the Soroban smart contracts platform.

A Quick Primer on Web3

What is web3 and blockchain?

Blockchain provides a way for people around the world to collectively maintain a database without relying on a central authority. It's a model for sharing and reconciling information, designed for our interconnected, global future. Read Blockchain Basics.

How does crypto relate to this?

The blockchain, the core technology behind cryptocurrencies, is replicated across all computers in the network. New data is added to this chain using cryptographic methods that make it simple to detect even the smallest alteration to any previous transaction. Each time a new block of data is added, the entire network effectively verifies the integrity of all earlier data. This process is known as reaching consensus.

Why are people skeptical of crypto/blockchain?

Critics of cryptocurrency and blockchain technology often make three main arguments:

Crypto and blockchain lack practical applications.
Traditional technologies outperform blockchain for similar functions.
The industry faces significant regulatory uncertainty.

By participating in the Stellar ecosystem and this hackathon, we aim to challenge at least the first two points. Our goal is to show that you can:

Contribute to innovative decentralized finance solutions.
Help provide financial access to billions of people.

While regulatory uncertainty remains a concern, it’s important to remember that most emerging technologies experience regulatory uncertainty, and we encourage developers to explore these technologies responsibly. Our hope is to bridge traditional and decentralized finance in a compliant manner.

What are Smart Contracts?

Smart contracts are programs stored on a blockchain that run automatically when predetermined conditions are met. However, a platform that only allows developers to write code to a blockchain is not enough. To create robust, practical, and sustainable products and services, additional features are necessary to ensure safe and efficient execution. Learn about smart contract basics.

Why are dApps interesting?

Decentralized Applications (dApps) are programs that operate on blockchain networks, enabling direct peer-to-peer services. This eliminates the need for centralized intermediaries, effectively decentralizing various processes.

A common example of a dApp is a decentralized exchange (DEX). On a DEX, users can trade assets directly with each other using a transparent, peer-to-peer order book. This removes the need for a broker or other middleman. Decentralized apps have the potential to improve efficiency and transparency across various applications. They are particularly useful for:

Lending and borrowing
Exchanging value

By removing intermediaries, dApps can offer these services more directly and often at lower costs than traditional centralized systems.

DeFi Glossary

Decentralized Finance (DeFi): A movement that leverages decentralized networks to transform traditional financial products into trustless and transparent protocols.

Wallets: Used to store digital assets like tokens or NFTs, associated with an account. Must be funded on both testnet and mainnet.Learn more about connecting wallets to a dApp here.
Testnet: Sandbox blockchain environment for building and prototyping.
Mainnet: Production blockchain environment for real assets/transactions.
Tokens: These are assets that can be created or are already on the network. They can be tied to real-world value (ex. Stablecoins are pegged to real fiat currency like the dollar), they can be representative of a real-world asset, or they can simply be made unrelated to anything in the real world (ex. memecoin)
Staking: Staking is the process of putting digital assets to productive use within a blockchain network. In decentralized finance (DeFi) applications, users can 'stake' their assets, allowing them to be used by the network in various ways. This often generates rewards for the asset holder in the form of earned interest.
Liquidity Pools: Liquidity pools are collections of funds locked in smart contracts, enabling decentralized trading, lending, and more. Users contribute assets and receive Liquidity Provider (LP) tokens, representing their share. These pools ensure liquidity for traders, reducing slippage and improving market efficiency. Liquidity providers earn rewards through transaction fees and additional incentives from DeFi platforms.

An Overview of Web3 Development

Web3 development introduces new paradigms for creating decentralized applications. This section covers key aspects of the Web3 development process:

Local Development: Local development involves using specialized tools and frameworks that allow you to write, compile, and test smart contracts locally. Stellar's new smart contract platform, Soroban, uses Rust for writing smart contracts. For local development, you'll use the Soroban CLI, which allows you to set up a local network, compile Rust contracts, and deploy them. The Stellar SDK is still used for interacting with the Stellar network, and it's available in multiple languages including JavaScript, Python, and others. Tools like the Stellar Laboratory remain useful for testing operations, and the Stellar Core can be used for running a local network for testing purposes.
App Hosting: Stellar apps usually have a traditional web front-end that can be hosted on standard web servers like Vercel. The backend interacts with the Stellar network through Horizon API. Smart contracts on Stellar, called Stellar Core Contracts, are deployed directly to the Stellar network. Users interact with your app through Stellar-compatible wallets or interfaces you create using the Stellar SDK.
Compute and Storage: Computation happens on the Stellar network when transactions or operations are processed. For data storage, Stellar offers limited on-chain storage through account data entries. For larger data needs, developers often use off-chain solutions and store references or hashes on the Stellar blockchain. Payments for network usage are made in Lumens (XLM), Stellar's native currency.

For more in-depth information about the Stellar tech stack, visit our dev docs.

Learn How to Build dApps

Learn how to build dApps with an example built by PaltaLabs illustrating the implementation of a full-stack dApp using a simple greeting contract. Check out the Create Soroban DApp repository for a practical guide on developing decentralized applications on the Stellar network:

paltalabs / create-soroban-dapp

Boilerplate for Soroban dApps in ReactJS

@create-soroban-dapp

@create-soroban-dapp is both an npx script and a boilerplate dApp for kickstarting any of your ideas for a Soroban-based DApp.

Largely inspired by the ink!athon project by Scio Labs and by @create-t3-app by T3 Open Source for the script mechanisms.

Check the LIVE VERSION of the dApp utilizing already deployed testnet contracts!

Read the docs here 📚📚

Introduction

@create-soroban-dapp is composed of two key components:

A boilerplate dApp utilizing the @soroban-react library.
An npx script allowing any developer to quickly start their project via the command line using npx create-soroban-dapp.

Usage

To create a new Soroban dApp project, simply use one of the following commands:

npx create-soroban-dapp@latest

npm create soroban-dapp@latest

After the script completes, navigate into your newly created project directory:

cd your-project-name

Troubleshooting

If the `npm create` Script Malfunctions

The script, in its early stage, might not function perfectly on every OS and configuration. If it…

View on GitHub

RPCiege: How to Complete Skirmish No.1

Tyler van der Hoeven — Tue, 27 Jun 2023 19:30:53 +0000

Earn digital collectible playing cards in RPCiege, a smart contract coding game teaching the fundamentals of developing and deploying performant and secure blockchain applications though small, fun, code puzzles.

Skirmish 1 of the RPCiege couldn't be any more straight forward. All you've gotta do is successfully invoke a Soroban smart contract on the Futurenet network via the official RPCiege RPC endpoint https://futurenet.rpciege.com:443. Definitely simple however the things you'll learn here will form the foundation for all other Skirmishes so be sure you take your time to fully understand each step of the process.

Step 1: Create a new Soroban smart contract project

Consult https://soroban.stellar.org/docs/getting-started/hello-world for more details

Using the Cargo CLI you installed during the Setup step create a new Rust project.

cargo new --lib <project-name>

From here cd into your new project and edit your Cargo.toml file:

[package]
name = "project-name"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[features]
testutils = ["soroban-sdk/testutils"]

[dependencies]
soroban-sdk = "0.8.4"

[dev_dependencies]
soroban-sdk = { version = "0.8.4", features = ["testutils"] }

[profile.release]
opt-level = "z"
overflow-checks = true
debug = 0
strip = "symbols"
debug-assertions = false
panic = "abort"
codegen-units = 1
lto = true

Step 2: Construct a new empty contract

From here navigate to the src directory and modify the lib.rs file as follows:

#![no_std]

use soroban_sdk::{contractimpl, Address, Env};

pub struct Contract;

#[contractimpl]
impl Contract {
    pub fn run(_env: Env, _nft_dest: Option<Address>) {}
}

mod test;

Next create a test.rs file with the following contents:

#![cfg(test)]

use crate::{Contract, ContractClient};

use soroban_sdk::{Env};

#[test]
fn test() {
    let env = Env::default();
    let contract_id = env.register_contract(None, Contract);
    let client = ContractClient::new(&env, &contract_id);

    client.run(&Option::None);
}

Finally feel free to run:

cargo test

or if you're using VSCode and have Rust Analyzer installed you can just run the tests inline right in the code editor itself!

Step 3: Deploy your contract to the `Futurenet` via the Soroban CLI

Once you've completed constructing your contract you need to deploy it to the Futurenet. We can accomplish this via the Soroban CLI. Before we can do that we need to build our contract and compile it to the WASM format that the Soroban VM expects. To do that simply run:

cargo build --target wasm32-unknown-unknown --release

This will build and place your contract inside the ./target/wasm32-unknown-unknown/release/ directory of your project. From here you can deploy the .wasm file of your contract to the Soroban Futurenet like so:

soroban contract deploy \
--wasm target/wasm32-unknown-unknown/release/hello_world.wasm \
--rpc-url https://futurenet.rpciege.com:443 \
--network-passphrase "Test SDF Future Network ; October 2022"

If all goes according to plan you should receive an output of the freshly deployed contract id. This was mine: 34447d1457fd860d5faec2434c1b6087fa3a7420655593866190b594b1136989.

This is a bit of a messy command though and the Soroban CLI includes a pretty nifty feature which will speed up deploying and invoking contracts in the future via the config command.

soroban config -h
Read and update config

Usage: soroban config <COMMAND>

Commands:
  identity  Configure different identities to sign transactions
  network   Configure different networks

Let's go ahead and configure both a network and an identity for future use so we don't have to use the --rpc-url and --network-passphrase and we aren't borrowing the default Soroban --source which could result in sequence number conflicts if someone else were to also be executing a command with this default Address.

soroban config identity generate Default --global

Next we need to ensure this address is funded so it can be used as a fee source for all our soroban commands. To do this first we need to get the public address of our newly generated Default keypair.

soroban config identity address Default

Mine was GBCXL3JLGJ6V2LFWKX5VZ2D42E65MVLX5LTAAN6H7C57J5US7JNCDOSB. Finally then we can fund this new account on the Futurenet via our Friendbot faucet.

curl -I -X GET "https://friendbot-futurenet.stellar.org/?addr=GBCXL3JLGJ6V2LFWKX5VZ2D42E65MVLX5LTAAN6H7C57J5US7JNCDOSB"

With any luck you should get a successful 200 response.

With a new identity added and funded we're ready to add our Futurenet network shortcut.

soroban config network add Futurenet \
--global \
--rpc-url https://futurenet.rpciege.com:443 \
--network-passphrase "Test SDF Future Network ; October 2022"

Sweet! Now the command from above can be shortened to:

soroban contract deploy \
--wasm target/wasm32-unknown-unknown/release/hello_world.wasm \
--source Default \
--network Futurenet

Pretty clean eh?

Step 4: Invoke your contract

Now that our contract has been deployed to the Futurenet it's time to invoke it and win the skirmish!

soroban contract invoke \
--id <contract-id-from-above> \
--source Default \
--network Futurenet \
-- run \
--_nft_dest <stellar-mainnet-public-key>

<contract-id-from-above> will be the contract id from your previous contract deployment in the prior step. e.g. remember mine was 34447...36989
<stellar-mainnet-public-key> should be your own mainnet Stellar public key where you’d like to receive your pack of commemorative NFT cards. e.g. Mine is GDAYV...5EHHG.

Step 5: Claim your pack of digital collectible cards

The final step to collect your rewards is to navigate to https://rpciege.com/claim and login with your <stellar-mainnet-public-key> account in order to claim your digital collectible card pack for this skirmish.

Congratulations! You've completed the first game, from here on out it'll only get more fun and fantastic!

RPCiege: Setup

Tyler van der Hoeven — Tue, 27 Jun 2023 19:28:39 +0000

Earn digital collectible playing cards in RPCiege, a smart contract coding game teaching the fundamentals of developing and deploying performant and secure blockchain applications though small, fun, code puzzles.

Before we begin the siege of the RPC we need to ensure our system is configured for building Soroban smart contracts. You have two clear options. The first is to use a virtual environment like Gitpod or Codespaces which can have everything pre-installed and configured for you. In fact here's a good hello-world Gitpod VM we've built for you.

The second option is to setup your own local machine to develop Rust Soroban smart contracts. Personally that's my recommendation as everything will be faster and cheaper but if you're just getting started and still evaluating your interest the Gitpod can be great way to get off the ground quickly and painlessly. Here's the instructions for how to do that.

Instructions sniped from https://soroban.stellar.org/docs/getting-started/setup

Soroban contracts are small programs written in the Rust programming language.

To build and develop contracts you need only a couple prerequisites:

A Rust toolchain
An editor that supports Rust
Soroban CLI

Install Rust

If you use macOS, Linux, or another Unix-like OS, the simplest method to install
a Rust toolchain is to install rustup. Install rustup with the following
command.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

If you use Windows, or need an alternative method of installing Rust, check out: https://www.rust-lang.org/tools/install

Install the target

Install the wasm32-unknown-unknown target.

rustup target add wasm32-unknown-unknown

Configure an Editor

Many editors have support for Rust. Visit the following link to find out how to
configure your editor:

https://www.rust-lang.org/tools

A popular editor is Visual Studio Code:

Visual Studio Code editor.
Rust Analyzer for Rust language support.
CodeLLDB for step-through-debugging.

Install the Soroban CLI

The Soroban CLI can execute Soroban contracts in the same environment the
contract will execute on network, however in a local sandbox.

Install the Soroban CLI using cargo install.

# Note depending on when you read this
# 0.8.0 may not be the most recent version
cargo install --locked --version 0.8.0 soroban-cli

Usage

Run the soroban command and you should see output like below.

% soroban
Build, deploy, & interact with contracts; set identities to sign with; configure networks; generate keys; and more.

Intro: https://soroban.stellar.org
CLI Reference: https://github.com/stellar/soroban-tools/tree/main/docs/soroban-cli-full-docs.md

Usage: soroban [OPTIONS] <COMMAND>

Commands:
  contract    Tools for smart contract developers
  config      Read and update config
  events      Watch the network for contract events
  lab         Experiment with early features and expert tools
  version     Print version information
  completion  Print shell completion code for the specified shell

Options:
      --global                     Use global config
  -f, --filter-logs <FILTER_LOGS>  Filter logs output. To turn on "soroban_cli::log::footprint=debug" or off "=off". Can also use env var `RUST_LOG`
  -q, --quiet                      Do not write logs to stderr including `INFO`
  -v, --verbose                    Log DEBUG events
      --very-verbose               Log DEBUG and TRACE events
      --list                       List installed plugins. E.g. `soroban-hello`
  -h, --help                       Print help (see more with '--help')
  -V, --version                    Print version

TESTING_OPTIONS:
      --config-dir <CONFIG_DIR>

Great! Now that you're hopefully all setup you're ready to begin skirmishing! Proceed to The Booklet™ and let the gaming begin!

DEV Community: Stellar Development Foundation

Dev Diaries Ep.6 | Launch Day

Dev Diaries Episode 5 – Startup Life Isn't Always Glamorous

Dev Diaries Episode 4 – Building A Reliable Payout System In DeFi

Dev Diaries Episode 3 - User Feedback & The Pivot That Saved The Project

What’s It All About?

Episode 3

The Takeaway?

Next Up

🚀 Stellar Dev Diaries: Episode 2 - Becoming Fundable

What’s It All About?

Episode 2

🚀 Stellar Dev Diaries Series: Episode 1 is LIVE!

What’s It All About?

Episode 1

Building dApps on Stellar

Join Us For The First Community Smart Contract Challenge With $50,000 In Prizes!

dev.to staff for The DEV Team ・ Jul 10 '24

Upcoming Streams

Intro to Stellar: Get Started in Rust, Set Up Your Development Environment, and Write Your First Smart Contract

Join Us For The First Community Smart Contract Challenge With $50,000 In Prizes!

dev.to staff for The DEV Team ・ Jul 10 '24

Julian-dev28 / consensus-hackathon-c2defi

everything you need to know about the consensus hackathon

Consensus Hackathon Cash to DeFi

Workshop Overview

Workshop

Workshop Resources

Introduction to Rust and the Development Environment

Upcoming Streams

Building Hello World Smart Contracts: Solidity vs. Soroban Rust SDK - A Step-by-Step Guide

Why would a blockchain developer choose Rust over Solidity?

What’s the difference between EVM and Soroban?

What is the EVM?

What is Soroban?

Which programming language is used for Stellar smart contracts?

How to Build a Hello World Smart Contract

Solidity Version

Soroban Rust SDK Version

Comparison and Conclusion

Additional Resources

Build Better With Stellar Smart Contract Challenge: A Companion Guide

A Quick Primer on Web3

What is web3 and blockchain?

How does crypto relate to this?

Why are people skeptical of crypto/blockchain?

What are Smart Contracts?

Why are dApps interesting?

DeFi Glossary

An Overview of Web3 Development

Learn How to Build dApps

paltalabs / create-soroban-dapp

Boilerplate for Soroban dApps in ReactJS

@create-soroban-dapp

Introduction

Usage

Troubleshooting

If the npm create Script Malfunctions

RPCiege: How to Complete Skirmish No.1

Step 1: Create a new Soroban smart contract project

Step 2: Construct a new empty contract

Step 3: Deploy your contract to the Futurenet via the Soroban CLI

Step 4: Invoke your contract

Step 5: Claim your pack of digital collectible cards

RPCiege: Setup

Install Rust

Install the target

Configure an Editor

Install the Soroban CLI

Usage

If the `npm create` Script Malfunctions

Step 3: Deploy your contract to the `Futurenet` via the Soroban CLI