6 releases
0.7.0 | Mar 22, 2024 |
---|---|
0.6.6 | Jan 9, 2024 |
0.6.5 | Sep 24, 2023 |
0.6.2 | Aug 31, 2023 |
#205 in #building
166 downloads per month
20KB
340 lines
Loam SDK
A Software Development Kit (SDK) and build tool for writing smart contracts in Rust on Wasm blockchains.
Currently, the focus is on the Soroban VM, but the same ideas apply to other VMs.
Table of Contents
Getting Started
Installation
To install just
, run the following command:
cargo install just
Setup
To set up the environment, run:
just setup
Redeploy
To see redeployment in action, use:
just redeploy
Contract Riffs
A contract riff (or mixin) is a type that implements the IntoKey
trait, which is used for lazily loading and storing the type.
Creating Contract Riffs
Here's an example of how to create a contract riff:
#[contracttype]
#[derive(IntoKey)]
pub struct Messages(Map<Address, String>);
This generates the following implementation:
impl IntoKey for Messages {
type Key = IntoVal<Env, RawVal>;
fn into_key() -> Self::Key {
String::from_slice("messages")
}
External API
You can also create and implement external APIs for contract riffs:
#[riff]
pub trait IsPostable {
fn messages_get(&self, author: Address) -> Option<String>;
fn messages_set(&mut self, author: Address, text: String);
}
CoreRiff
The CoreRiff
trait provides the minimum logic needed for a contract to be redeployable. A contract should be able to be redeployed to another wasm binary that can also be redeployed. Redeployment requires the contract to have an admin, as it would be undesirable for any account to redeploy the contract.
Using the CoreRiff
To use the core riff, create a Contract
structure and implement the CoreRiff
for it. The Contract
will be redeployable and will be able to implement other Riffs.
use loam_sdk::{soroban_contract, soroban_sdk};
use loam_sdk_core_riff::{admin::Admin, CoreRiff};
pub struct Contract;
impl CoreRiff for Contract {
type Impl = Admin;
}
soroban_contract!();
This code generates the following implementation:
struct SorobanContract;
#[contractimpl]
impl SorobanContract {
pub fn admin_set(env: Env, admin: Address) {
set_env(env);
Contract::admin_set(admin);
}
pub fn admin_get(env: Env) -> Option<Address> {
set_env(env);
Contract::admin_get()
}
pub fn redeploy(env: Env, wasm_hash: BytesN<32>) {
set_env(env);
Contract::redeploy(wasm_hash);
}
// Riff methods would be inserted here.
// Contract must implement all Riffs and is the proxy for the contract calls.
// This is because the Riffs have default implementations which call the associated type
}
By specifying the associated Impl
type for CoreRiff
, you enable the default Admin
methods to be used (admin_set
, admin_get
, redeploy
). However, you can also provide a different implementation if needed by replacing Admin
with a different struct/enum that also implements IsCoreRiff.
Notice that the generated code calls Contract::redeploy
and other methods. This ensures that the Contract
type is redeployable, while also allowing for extensions, as Contract
can overwrite the default methods.
Dependencies
~5–14MB
~126K SLoC