1 of 37

INTRO TO STELLAR

Where Blockchain Meets the Real World

2 of 37

OVERVIEW

What Is Stellar?

01

02

03

04

How Stellar Works

How Stellar Smart Contracts Work

Who Uses Stellar?

Intro to Stellar

2

3 of 37

OVERVIEW

What Is Stellar?

01

02

03

04

How Stellar Works

Freighter Transactions on Stellar

How Stellar Smart Contracts Work

Intro to Stellar

05

06

Who Uses Stellar?

Okashi Cakewalk

3

[Use this slide for Presentation + Optional Freighter and Okashi workshops]

Part 1: What is Stellar? This is a quick overview of what this particular blockchain network is designed to do.
Part 2: How Stellar works. This is a more in-depth look at the fundamental data structures and functions, at how they work and what you can do with them.
Part 3: We’ll get some hands-on time to make a Stellar transaction using Freighter (on Testnet).
Part 4: How Stellar Smart Contracts Work: Here, we'll get into the nuts and bolts of Soroban, a platform that creates immense surface area for innovation by allowing developers to write Turing-complete code to Stellar.
Part 5: Okashi Cakewalk: we’ll spend some time actually writing a smart contract on Okashi, the ecosystem-built IDE (or integrated development environment).
Part 6: Who Uses Stellar? Finally, we'll look at the ecosystem of products and services built on Stellar, and at how they stack together to create end-to-end solutions to real-world problems.
Sound good?
Alright, then: Section 1…

4 of 37

STELLAR AMBASSADOR PROGRAM

5 of 37

WHAT STELLAR CAN DO FOR YOU?

Use Cases

5

6 of 37

DESIGNED TO CREATE EQUITABLE ACCESS TO THE GLOBAL FINANCIAL SYSTEM

Intro to Stellar

6

7 of 37

It provides infrastructure for developers use to:

issue assets
build applications
deploy decentralized financial protocols…

Intro to Stellar

7

8 of 37

It enables connections to real-world assets, payment rails, and cash

Intro to Stellar

8

9 of 37

Products and services built on Stellar interoperate to offer end-to-end solutions to real-world problems

Intro to Stellar

9

10 of 37

Stellar allows people all over the world to make payments, convert assets, and move from cash to DeFi in a borderless economy

Intro to Stellar

10

11 of 37

HOW STELLAR WORKS

Section 2

12 of 37

The Stellar network is made up of connected nodes that work together to validate a common ledger, the Stellar ledger

Intro to Stellar

12

13 of 37

THE LEDGER STORES ACCOUNT DATA

Intro to Stellar

13

Accounts hold balances and sign transactions

	Public Key	XLM	USDC	Etc.*
Alice	GAJYKA3F5X5VE7CXTH5VSYGNN2HA3O5BHGWNIHK4UWTZAQLHTXIPJ5EU	1,000 XLM	5 USDC	*there are thousands of assets on the ledger right now
Bob	GCQ662R3DCS2IKW7BDGTORELSEL26R3NSGEBGWFUINQ2CSKZ37SZKTPT	10 XLM	25 USDC
Carol	GB7SUIYXWRU6PIIOXY2GS5ZOPN4GTNUISNDUILAPLTTAPZBHA42T6TGG	100,000 XLM	1,000,000 USDC
Etc.*	*there are over 8 million accounts on the ledger right now

Let’s take a closer look…
The ledger stores account data.
Accounts are one of the two central data structures in Stellar. The other, contracts, we’ll get into in a moment when we cover Stellar smart contracts.
Accounts hold balances and sign transactions.
Here, you see a ledger of accounts: Alice has a balance of 1,000 XLM and 5 USDC; Bob has a balance of 10 XLM and 25 USDC; and Carol has a balance of 100,000XLM and one million USDC. Lucky Carol!
Currently, there are over 8 million accounts on the ledger holding balances in thousands of different assets.
But the ledger doesn’t actually think in terms of Alice, Bob, and Carol: it thinks in terms of key-pairs. As you can see on this mock ledger here, Alice’s account is represented by that GAJ public key, Bob’s account by the GCQ public key, and Carol’s by the GB7 key.
On Stellar, as in most cryptographic systems, key-pairs consist of two interrelated keys: a public key and a private key.
Public keys are used as public account identifiers. They’re visible to anyone who wants to interact with an account and can be shared openly.
Private keys are used to sign transactions. They are the “secret” part of the key-pair and must be kept secure.

14 of 37

ACCOUNTS CAN ISSUE ASSETS

Intro to Stellar

14

Stablecoins can be redeemed off-chain
Stellar has ecosystem standards to meet compliance requirements (including KYC)
Stellar supports a network of on- and off-ramps

In addition to holding balances and signing transactions, accounts have another important function: they can issue assets.
Issuing assets is central to what makes Stellar so powerful: anyone can, without permission, for little cost, and with a low technical lift, create a representation of value.
That’s not true on the Bitcoin network, for example, which only supports BTC. It’s also a simpler approach than Ethereum, where assets are issued by smart contracts, which is generally more complicated, more error and attack prone, and more expensive.
On Stellar, many of those assets can be redeemed with their issuer for the underlying value they represent.
Stablecoins are the most common, and the most important: they represent real-world fiat currency. Each stablecoin is backed by currency held in reserve.
Take USDC, for example. Circle is the issuer of USDC, and a USDC holder can redeem 1 USDC with Circle in exchange for $1 USD.
In order to move real-world assets, including stablecoins, on and off the chain, regulated financial institutions need to comply with local laws and regulations, which includes collecting Know Your Customer (KYC) information.
There are common ecosystem standards that explain how to do this on Stellar, and projects that follow those standards can easily interoperate with those regulated financial institutions.
As a result, Stellar supports a worldwide network of on- and off-ramps that allow users to move from traditional banking rails and cash onto the network and back again.
These on- and off-ramps and compliance standards fundamentally differentiate Stellar from other blockchains: there are hundreds of thousands of access points that connect to locations all over the world, and Stellar provides the tools to leverage them.

15 of 37

TRANSACTIONS MODIFY THE LEDGER

Intro to Stellar

15

Payments
Swaps (order books, AMMs)
Path payments (payment + swap)

[CLICK] Transactions modify the ledger. You sign and submit transactions to the network in order to do things.
Transactions themselves are made up of operations, which are essentially the functions Stellar supports, and there are 26 of them.
[CLICK] Payments: One key operation is Payments. The Payments operation is used to move assets from one account to another.
[CLICK] Swaps: Then there’s a set of operations that enable swaps. Swaps are used to trade one asset for another. They are important because they allow universal asset conversion.
Stellar also has two types of built-in decentralized exchanges that support swaps:

First, there are order books, which accumulate buy and sell orders and automatically execute trades when the orders cross.
Then there are automated market makers (AMMs), which allow users to pool liquidity and execute swaps against that pool.

[CLICK] Path payments: Finally, path payments are operations that allow you to combine the payment with the asset exchange in one “atomic swap.”

In a path payment, the asset received differs from the asset sent. Rather than the operation transferring assets directly from one account to another, path payments cross through the SDEX and/or liquidity pools before arriving at the destination account.

[CLICK] For example, a user can send money in a USD stablecoin and have it end up in their family’s account in an ARS stablecoin for local redemption.
Path payments find the best conversion rate available on the network, and consume orders in the order books, and/or swap against liquidity pools to offer it.

To summarize that…

To modify the ledger, you submit a transaction made up of operations.
Stellar supports 26 operations that enable payments and swaps, including path payment operations that let you both swap and pay in a single transaction.

16 of 37

VALIDATORS USE SCP TO UPDATE THE LEDGER

Intro to Stellar

16

SCP follows Proof-of-Agreement
SCP is open participation
SCP leverages validators’ real-world reputation

To update the ledger, validators (or network nodes) use the Stellar Consensus Protocol or SCP, which is a Proof-of-Agreement protocol.
Stellar is open participation: anyone can run a validator and join…
And it leverages validators’ real-world reputation rather than computational expense (Proof-of-Work) or financial collateral (Proof-of-Stake) to secure the network.
Here’s how it works…

As part of their configuration, each validator selects a specific set of other validators to trust.
Every 5 seconds or so, all the validators on the network engage in a programmatic multi-stage voting process to update the ledger.
They nominate a transaction set, check its validity, and agree to apply it if and when a sufficient number of validators they trust also agree to its validity.
When enough nodes across the network agree that a transaction set is valid, it’s permanently added to the blockchain.

Because validators choose whom to trust, they usually use an ecosystem standard to identify themselves.
And generally, organizations with the best reputations are more likely to be trusted by other validators in the network.

17 of 37

LEDGERS CHAIN TOGETHER

Intro to Stellar

17

Validators make up a replicated state machine
Transactions are immutable

state

transition

state

transition

input (transactions)

Output (log/history)

state

input (transactions)

Output (log/history)

So, roughly every 5 seconds, validators vote to apply a transaction set to update the ledger.
They modify data like balances based on those transactions, and agree to a new ledger state to close the ledger.
SCP coordinates validators as replicas in a replicated state machine, which is a model used in distributed computing to ensure consistency across multiple nodes in a network.
This model ensure that each validator maintains the same ledger state and can provide the same output for a given input, which is crucial for achieving fault tolerance and consistency in distributed systems.
As ledgers update with each validator vote, every ledger includes a hash, which is a cryptographic link to the previous ledger designed to prevent anyone from tampering with transaction history.
Those hashes create continuity from the current ledger all the way back to the genesis ledger. The ledgers (or blocks) are linked (chained) from one to the next.
This continuity creates an immutable record: once a transaction is included in the ledger, it cannot be altered or deleted. This ensures the integrity and trustworthiness of the network.
So that flow looks like: state, then transition, then state, then transition, and so on… where the “transition” phase is the process of updating the ledger based on inputs, or transactions.

18 of 37

REPLICATED STATE MACHINE

Intro to Stellar

SCP’s consensus algorithm

18

replica 2

replica 3

replica 1

19 of 37

THE LIFECYCLE OF A TRANSACTION

Intro to Stellar

Users compose operations

Users sign and submit transaction

Ledger updates with hash

Validators bundle transactions

Validators vote

19

20 of 37

20

Intro to Stellar

NETWORK STATISTICS

Total Operations

15.6B

Total Transactions

6.8B

Total Accounts

8.2M

From inception to May 2024

21 of 37

LET’S MAKE A STELLAR TRANSACTION

[OPTIONAL Freighter workshop]

Let’s get on the network and add to those growing stats!
Download and Install Freighter:

Use this link to download Freighter: https://www.freighter.app/.
Add Freighter as a Chrome extension.

Set Up Your Wallet:

Open the Freighter extension and select "Create New Wallet."
Follow the prompts to set up your wallet.

Secure Your Recovery Phrase:

During setup, you will be shown a secret recovery phrase. Take a screenshot or a photo of this phrase for this exercise. Ensure you keep this secure and private in real-world use.

Enter Your Secret Recovery Phrase:

Input your secret recovery phrase in the order shown in your screenshot to verify your wallet setup.

Access Your Wallet:

Once your wallet is set up, click on the Freighter extension icon in the Chrome toolbar to access your wallet.

Switch to Test Network:

In the Freighter wallet interface, switch from the main network to the testnet by selecting it from the network options.

Fund Your Account:

Use the Testnet’s faucet feature to add test funds to your account.

Exchange Wallet IDs:

Share your wallet ID with fellow participants.

Send a Transaction:

Enter another participant's wallet ID as the recipient.
Specify the amount to send.
Confirm and sign the transaction to complete it.

So that’s Freighter and the process to make a transaction on the Stellar network.
Now we’ll turn to the newest Stellar smart contracts…

22 of 37

SOROBAN:

AN INFLECTION POINT.

Intro to Stellar

22

23 of 37

HOW STELLAR SMART CONTRACTS WORK

Section 3

24 of 37

Smart contract: code stored on a blockchain

Soroban: platform for smart contracts on Stellar

Intro to Stellar

24

25 of 37

THE LEDGER STORES CONTRACT DATA

Intro to Stellar

25

Contract data can hold Turing-complete code

	Public Key / Contract ID	XLM	USDC	Code
Alice	GAJYKA3F5X5VE7CXTH5VSYGNN2HA3O5BHGWNIHK4UWTZAQLHTXIPJ5EU	1,000 XLM	5 USDC
Bob	GCQ662R3DCS2IKW7BDGTORELSEL26R3NSGEBGWFUINQ2CSKZ37SZKTPT	10 XLM	25 USDC
AMM contract	CCR5C65MAQDYT3RMHFRWILNQ2MJ3B5IER3I3FA3UC2V4CRJCRJTGZNUZ	n/a	n/a	WASM code with AMM logic
Treasury contract	CC2GMSU3J6HWWQLFY6OO23M6PTA7RXWOA7TB3ZL5L3ZS6RDOKKH64RDW	n/a	n/a	WASM code with treasury logic

Remember this depiction of the Stellar “ledger” when we discussed account data?
In addition to storing account data, the ledger also stores contract data.
In addition to the accounts belonging to Alice and Bob, this ledger is also storing contract data. For example, we’ve got an AMM contract and a Treasury contract, with the contract data (the contract ID and the WASM code) written to the ledger.
Contract data uses key/value pair, and is identified by contract ID. As you can see, public keys for accounts start with G, whereas contract IDs start with C.
But the value written to the ledger isn’t static data like a balance. Rather, it’s code that that can be called (or invoked).
And when a contract is invoked, it executes on the functions included in the smart contract code.
Then, when execution is complete, the contract amends previous data or writes new data back to the ledger.

26 of 37

CONTRACT DATA CONTAINS WEBASSEMBLY CODE

Intro to Stellar

26

Wasm is machine-readable bytecode
Wasm uses a virtual machine
Wasm is Turing-complete
Soroban is batteries-included

Contract data contains WebAssembly code.
[CLICK] When a smart contract is compiled, the human-readable Rust code in which the contract was written, is converted into WebAssembly, also known as Wasm, so that it can be deployed on the Stellar blockchain.
Wasm is a bytecode specification created for running sandboxed applications in a browser with high-speed performance.
[CLICK] Stellar uses Wasm to provide what is known as a virtual machine – a software emulation of a computer system that provides the functionality of a physical computer – to execute on smart contracts.
The virtual machine helps limit the potential for malicious code to affect the host system by running the operating system and applications in a completely isolated, protected environment.
[CLICK] Wasm is a good fit for blockchain because it’s designed to be fast, efficient, and portable across platforms, and because it presents the widest set of possible source languages, toolchains, and interpreters.
Wasm is Turing-complete, which means that you can write any logic into the Wasm code.
This means that you can create your own functions based on any conditions you want.
[CLICK] But while there’s no fixed set of functions, the Soroban environment also provides batteries-included functionality…
So, the best of both worlds!

27 of 37

THE LIFECYCLE OF A CONTRACT

Intro to Stellar

Write

Deploy

Invoke

Compile/Build

27

So how does that process work?
A contract has a life cycle: it is written, then compiled, then deployed, and then invoked.
[CLICK] Write: Writing a Soroban smart contract means creating the Rust code that defines the logic, functions, and conditions of your contract.
Contract development can be done on a local computer with as little as three necessary components: an IDE (integrated development environment), a copy of the Rust toolchain, and a copy of the Soroban SDK.
[CLICK] Compile/Build: Once you’ve written your smart contract, building or compiling the contract involves the process of translating the written code into a format that the Stellar network can execute.
As we just saw, that typically involves converting the human-readable Rust code into machine-readable bytecode, which is, in Stellar’s case, WebAssembly (Wasm) bytecode.
The compilation process checks for errors, optimizes the code, and generates a Wasm binary file that contains the smart contract’s logic and functions in a format that can be deployed onto the Stellar blockchain.
[CLICK] Deploy: Deploying a contract means uploading the contract code to the blockchain, making it functional and accessible to users within the network.
The transaction is submitted to the network, where it lives as a contract data ledger entry.
[CLICK] Invoke: Invoking a contract means interacting with it, by calling (executing on) one or more of the smart contract’s functions.

28 of 37

INTERACTING WITH SMART CONTRACTS

Intro to Stellar

28

InvokeHostFunctionOp (via Soroban CLI)

Upload contracts
Deploy new contracts
Invoke contract functions

Okashi.dev (browser sandbox)

Write contracts
Deploy contracts
Invoke contract functions

There are a few ways to interact with a smart contract, depending on the interface you’re using to make a contract call.
[CLICK] Soroban CLI: To interact with contract data using the Soroban CLI, the command-line multi-tool for running and deploying Soroban contracts on the Stellar network, you use a single specific function: InvokeHostFunctionOp
When used, the Invoke Host function gets put into a transaction and is signed and submitted to the network like any other operation on Stellar.
Invoke Host can be used to perform three Soroban operations:

Upload contract Wasm data to the ledger;
Deploy new contracts using the uploaded Wasm data;
Invoke the contract functions of those deployed contracts;

[CLICK] Okashi: It’s also possible to write, build, deploy, and invoke a Stellar smart contract using Okashi, the ecosystem-built sandbox environment for Stellar smart contracts.
Behind the interface, Okashi still uses the Invoke Host function. But the interface abstracts away a lot of the work involved in using the command line:

You don’t need to configure your code editor;
You don’t need to install the Soroban CLI;
You don’t need to use the InvokeHostFunctionOp function directly;
Invoking a contract is as simple as clicking a button. (But we’ll get there in a bit!)

For both interfaces, behind the scenes, invoking a contract to call contract functions spins up a virtual machine instantiation, which is the sandbox environment that lets you interact with the contract while protecting the network servers against any malicious code from that contract.
The virtual machine then loads and instantiates the contract’s Wasm bytecode and invokes the named function, passing the provided arguments.
Once execution completes successfully, the modified ledger entries are written back to the ledger automatically.

29 of 37

Welcome to the Stellar India Ambassador Prog

Intro to Stellar

29

The Stellar Asset Contract:

Works with all Stellar assets
Built-in ERC-20-like interface

Finally, Stellar smart contracts have access to the wide world of Stellar assets, which means that smart contracts can make payments with, interoperate with, and interact with Stellar assets.
To do this, there is a standard ERC-20-like interface called the Stellar Asset Contract, which is a special built-in contract that has access to functionality of the Stellar network and can interact with assets held by Stellar accounts or contracts
That means that any and all assets on Stellar — including all the stablecoins that users can access via banking rails and cash — can be used by contract developers creating DeFi protocols and other decentralized applications.
For instance, smart contracts, like AMM contracts or Treasury contracts, can make use of USDC, which is pretty powerful interoperability.
And it’s that ability to interoperate that I want to cover in our final section, where we delve into actual use cases to see what you can do with everything we’ve covered so far.

30 of 37

ANYTHING AND EVERYTHING :P

STELLAR INDIA AMBASSADOR PROGRAM

31 of 37

THE STELLAR ECOSYSTEM

Intro to Stellar

31

Ecosystem Specialization	Project Stats (currently building on Stellar)
Asset issuers	23
DeFi protocols	38
End-user applications	57
Infrastructure providers	117

A diverse ecosystem uses the Stellar network to interoperate to create end-to-end user experiences.
Projects in the ecosystem often specialize in one aspect of a use case and follow ecosystem standards to make it easy for other projects to connect with them.
Here are some of the key roles projects play:
Asset issuers, as we’ve seen, create digital representations of value that accounts can hold and transact with, and that contracts can deploy. Example: Circle issues USDC.
On/off ramps are the access points that allow users to move from traditional banking rails and cash onto the network while complying with local laws and regulations. Example: Moneygram allows cash in at 400,000 physical locations.
DeFi protocols take advantage of smart contracts to offer the ability to swap and provide liquidity for swaps via automated market makers, and to borrow and lend. Example: Soroswap is a Uniswap-like AMM built on Stellar.
Applications provide friendly interfaces that allow users to create accounts, store value, make payments, and interact with DeFi protocols. Example: Beans has created a wallet, which we'll look at in a second.
Infrastructure providers offer services to access the network, to query network data, and to provide extra-network data to smart contracts that execute based on off-chain conditions. Infrastructure providers include validators, indexers, oracles.
There are many more roles, including dev tooling, audit firms, and custodial services.
But you get the picture: many projects created by many organizations and developers that all fit together like puzzle pieces.

[See the Ecosystem Directory for the most up to date stats.]

32 of 37

PUTTING IT ALL TOGETHER

Intro to Stellar

32

To make that a little more concrete, let’s look at a specific example.
Here's an end-to-end use case demonstrating how ecosystem participants can interoperate through their projects to open up new opportunities for financial access for people all over the world.
Imagine a user without access to a traditional financial institution. They live somewhere without easy access to banks. They keep most of their money in cash.
Their local currency is at risk of inflation, so they want to store some of their savings in USDC, because it’s backed by USD.
They also want to lend digital assets to earn yield (that is, interest from borrowers). They’d like to do this without the fees, intermediaries, and inefficiencies associated with centralized lending markets.
Here’s what they do: [CLICK] they download Beans, an international payments app that allows users to send money all around the world instantly and with zero fees, onto their smartphone.
[CLICK] The Beans wallet also lets them deposit local currency cash through Moneygram (which has 400,000 agent locations in over 180 countries!) [CLICK] and gives them USDC in return.
[CLICK] Via Beans, the user is then able to deposit a portion of their assets into Blend, an integrated lending market protocol built on Soroban, [CLICK] and earn yield back into their Beans wallet.
The integration of protocols like Beans and Blend lets users without traditional financial access deploy their capital to make a loan and earn yield.
And that’s made possible by the combination of the Stellar network and smart contracts:

Beans the smart wallet interoperates with MoneyGram, the on-/off-ramp, which let’s the user convert their cash into USDC, and then lend that money easily with the Blend protocol, in order to earn interest. Cash to DeFi. A pretty exciting opportunity!

33 of 37

A BUILDER’S GREENFIELD

Intro to Stellar

33

Interoperability
Ecosystem innovation
Potential for real-world impact

34 of 37

QUESTIONS?

stellar.org

35 of 37

STELLAR DEVELOPER DOCS

36 of 37

THE OKASHI CAKEWALK

Intro to Stellar

36

Your Mission:

Visit okashi.dev/guides
Using the Okashi playground, update the contract code on the guide, simply by modifying the ASCII characters of the 5x5 grid, to produce your own personal illustration.
Then deploy the contract to Testnet and mint the art as an NFT.

[OPTIONAL: Okashi workshop]

We’re going to do this using Okashi, the ecosystem-built sandbox environment for Stellar smart contracts.
The Okashi interface abstracts away a lot of the set up you usually have to worry about when writing smart contracts using the Soroban CLI.

In Okashi, you don’t have to install Rust or the WASM target;
You don’t have to configure the editor or install the Soroban CLI;
You don’t have to configure the library type in your cargo.toml file in your IDE;
You don’t even have to import the Soroban SDK and dependencies…
Basically, you don’t have to worry about any of that!

Instead, the Okashi “playground” gives you everything you need.
[Share screen Instructions:

Open okashi.dev and start a new project.
Show participants the Code widget where you write code; the Compile button at the bottom of the Code widget; the Contract widget, where the contract’s functions will appear as clickable buttons; and the Console widget, where code execution is logged.
Point out the “okashi” in the Contract widget, which means the project is in the Okashi sandbox. Show how to change to Testnet or Mainnet by clicking the Settings icon at the bottom left.
Point out that Testnet and Mainnet accounts need to be funded, which they can do by clicking the blue-purple icon in the top right and scrolling down until they see the “Fund account” buttons.]

To complete the Okashi Cakewalk, your mission is to update the contract code found in the Cakewalk guide [okashi.dev/guides] by modifying the ASCII characters of the 5x5 grid, to produce your own personal illustration.
You’ll then deploy the contract to Testnet and mint the artwork as your own NFT.
Does someone want to volunteer to share their screen and walk through this process?
[Cakewalk instructions: guide the volunteer through the process of completing the Cakewalk. Follow the guide for additional instructions and context, if needed.]

37 of 37

THANK YOU!

https://quest.stellar.org/

Play Stellar Quest

https://discord.gg/stellardev

Join the Stellar Dev Discord