DEV Community: Tyler van der Hoeven

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!