This document discusses smart contracts on the Near Protocol blockchain using Rust and WebAssembly (WASM). It covers: - Using WASM and Rust to build smart contracts due to their advantages like existing tooling, memory safety, and zero-cost abstractions. - Different approaches to building Rust APIs for smart contracts, including eDSL-based, non-invasive, and generating eDSL styles. - Features like asynchronous cross-contract calls, unit/integration testing, and type safety that would be nice to have. - The Near Protocol team of 14 people including experts from Google, Facebook, and TopCoder working to develop the platform.

1. Rust Smart Contracts
Maksym Zavershynskyi, Near Protocol

2. Smart Contracts & AWS Lambda
• Event-driven — executes code
only when needed. Pay per
execution;
• Serverless — no need to provision
servers;
Request
Response
Regular server is active all time
Zzzzz..
Lambda is only active when called

3. Smart Contracts & AWS Lambda
• Event-driven — executes code
only when needed. Pay per
execution;
• Serverless — no need to provision
servers;
Regular server is active all time
Lambda is only active when called
Request
Response
Request
Response

4. A Smart Contract
• Event-driven — executes code only when needed. Pay per execution;
• Serverless — no need to provision servers;
• Decentralized — it is not run by a single entity.

5. Immutable History of Events
Users running nodes collectively build the blockchain

6. Fat Fingers and Bugs in Closed Code

7. Inside a Node
Blockchain Layer
• P2P Network
• Consensus
• Blocks Storage
• RPC API
Runtime Layer
Virtual Machine
State Storage
Code

8. WASM
+ Rust/TypeScript
Pros:
• Existing tooling and community;
• General purpose & Turing complete;
Cons:
• Was not designed for the
blockchain;
• No formal verification.
Specialized
VM + Language
Pros:
• Designed for the blockchain;
• Allows formal verification (?)
Cons:
• Niche language;
• Not Turing complete (?)

9. Requirements for VM
• Platform-independent WASM ✓
• Determinism WASM ✓ w/o floats
• Sand-boxed execution/compilation WASM ✓ certain executors
• Small size of compiled code WASM ✓
• Close to machine code WASM ✓

10. WASM + Rust Bonus Points
• Existing tooling and community;
• Code transfer;
• Memory safety;
• Zero-cost abstractions.

11. Rust Zero-Cost Abstractions
Zero cost abstractions. What you don’t use, you don’t pay for.
And further: What you do use, you couldn’t hand code any better.
- Bjarne Stroustrup

12. Rust APIs
near_bindgen — Rust API for NEAR blockchain
smart_contract — Rust API for Wavelet blockchain by Perlin
EWASM — a subset of WASM for Ethereum-like blockchains
Ink! — Rust API for Substrate/Polkadot blockchain
Mantle — Rust API for Oasis blockchain
Deprecated:
PWASM + Fleetwood — Rust API for Parity's Kovan blockchain

13. Contract Interface and Blockchain Interface
Blockchain Layer
WASM Executor
Rust Contract
Contract Interface
Methods defined by the contract
that the blockchain can call
State Storage
Blockchain Interface
Methods defined by the blockchain
that the contract can call

14. eDSL-based Rust API

15. #![cfg_attr(not(any(test, feature = "test-env")), no_std)]
use ink_core::{memory::format, storage};
use ink_lang::contract;
contract!{
struct Incrementer {
value: storage::Value<u32>,
}
impl Deploy for Incrementer {
fn deploy(&mut self, init_value: u32) {
self.value.set(init_value)
}
}
impl Incrementer {
pub(external) fn inc(&mut self, by: u32) {
env.println(&format!("Incrementer::inc by = {:?}", by));
self.value += by;
}
}
}
Ink! (eDSL)
• Contract Interface:
• Implement Deploy::deploy
• Wrap code into contract!{}
• Blockchain Interface:
• Interactions through env::*
• Blockchain Interface (State):
• Use storage::* wrappers;

16. use mantle::{Context, Service};
#[derive(Service)]
struct Incrementer {
value: u32,
}
impl Incrementer {
pub fn new(_ctx: &Context) -> Result<Self> {
Ok(Self { value: 0 })
}
pub fn inc(&mut self, _ctx: &Context, by: u32) {
self.value += by;
}
}
fn main() {
mantle::service!(Incrementer);
}
Mantle (eDSL)
• Contract Interface:
• Additional argument: &Context
• Decorate with with #[derive(Service)]
• Special main function.
• Blockchain Interface:
• Through &Context
• Blockchain Interface (State):
• Decorate fields with #[indexed];
• Compiler plugin.

17. Non-invasive Rust API

18. #[derive(Default, Serialize, Deserialize)]
struct Incrementer {
value: u32,
}
#[near_bindgen]
impl Incrementer {
pub fn inc(&mut self, by: u32) {
self.value += by;
}
}
near_bindgen (non-invasive)
• Contract Interface:
• Derived from your code.
• Blockchain Interface:
• Interactions through Blockchain<>
• Blockchain Interface (State):
• Derived from your code.
So insignificant that we did not give it a name

19. How Does near_bindgen Work
M.A.G.I.C.

20. How Does near_bindgen Work
Macros
Automatically
Generated
Injected
Code

21. How Does It Work
#[derive(Default, Serialize, Deserialize)]
struct Incrementer {
value: u32,
}
#[near_bindgen]
impl Incrementer {
pub fn inc(&mut self, by: u32) {
self.value += by;
}
}
Injected code uses Default to initialize new
contract.
&self and &mut self tell macro whether
the state needs to be saved.
Arguments and return values are injected with
JSON-serialization/deserialization allowing
cross-contract calls written in other languages,
like TypeScript.
Any Rust struct can be a contract with zero
modifications.

22. Expanded
#[derive(Default, Serialize, Deserialize)]
struct Incrementer {
value: u32,
}
impl Incrementer {
pub fn inc(&mut self, by: u32) {
self.value += by;
}
}
#[no_mangle]
pub extern "C" fn inc() {
let args: serde_json::Value = serde_json::from_slice(&input_read()).unwrap();
let by = serde_json::from_value(args["by"].clone()).unwrap();
let mut contract: Incrementer = read_state().unwrap_or_default();
let result = contract.inc(by);
write_state(&contract);
}

23. Generating eDSL style API
#[derive(Service)]
struct Incrementer {
value: u32,
}
#[mantle_bindgen]
impl Incrementer {
pub fn inc(&mut self, by: u32) {
self.value += by;
}
}
#[derive(Service)]
struct Incrementer {
value: u32,
}
impl Incrementer {
pub fn new(_ctx: &Context) -> Result<Self> {
Ok(Self { value: Default::default() })
}
pub fn inc(&mut self, _ctx: &Context, by: u32) {
self.value += by;
}
}
fn main() {
mantle::service!(Incrementer);
}

24. struct Incrementer {
value: u32,
}
#[smart_contract]
impl Incrementer {
pub fn init(_params: &mut Parameters) -> Self {
Self { value: 0 }
}
pub fn inc(&mut self, params: &mut Parameters)
-> Result<(), Box<dyn Error>> {
let by: u64 = params.read();
self.value += by;
Ok(())
}
}
Wavelet's smart_contract (non-invasive)
• Contract Interface:
• Derived from your code.
• init function.
• Blockchain Interface:
• Interactions through Parameters
• Blockchain Interface (State):
• Derived from your code.

25. WASI — Path to Unification
WASI is a modular system interface for WebAssembly.
WASI
SensorsProcesses
Smart contracts
3D Graphics
Core Crypto

26. WASI — Path to Unification
• Contract Interface — generated by #[near_bindgen]
• Blockchain Interface — available through WASI

27. Nice to Have Features
• Asynchronous cross-contract calls
• Unit tests and integration tests
• Type-safe
• Model checking (?)

28. Asynchronous Calls
Rust Contract A
Rust Contract B
TypeScript Contract C
Combinator All
Callback
Promise
Promise

29. Unit Tests and Integration Tests
Contract A Contract B
Blockchain

30. Dependency Inversion and Dependency Injection
Impl Contract A Impl Contract B
Impl Blockchain
Trait Contract A Trait Contract B
Trait Blockchain

31. Unit Testing Contract A
Impl Contract A Impl Contract B
Impl Blockchain
Trait Contract A Trait Contract B
Trait Blockchain
Injected Mock
Injected Mock

32. Integration Testing Contracts A and B
Impl Contract A Impl Contract B
Impl Blockchain
Trait Contract A Trait Contract B
Trait Blockchain
Injected Mock

33. Async Cross-Contract Calls
#[derive(Serialize, Deserialize)]
struct Incrementer {
value: u32,
blockchain: Blockchain<dyn Generic>,
decrementer: Contract<dyn Decrementer>,
}
#[near_bindgen]
impl Incrementer {
pub fn inc(&mut self, by: u32) {
self.value += by;
let promise = promise!(self.decrementer.dec, by);
callback!(promise, self.dec_result, by);
}
pub fn dec_result(&mut self, result: bool, by: u32) {
if !result {
self.value -= by;
self.blockchain.log("Rolling back the increment.");
}
}
}
impl Default for Incrementer {
fn default() -> Self {
Self {decrementer: Contract::address("8fd6dac32dd220396f2285700c951cd1befb92b0"), ..Default::default()}
}
}
trait Decrementer {
fn dec(&mut self, value: u32) -> bool;

34. About Near Protocol
Team of 14 people:
• 3 ex-MemSQL, 5 ex-Google, 1 ex-Facebook
• 4 TopCoder/ICPC Champions/Medalists/Finalists

35. nearprotocol.com
https://medium.com/nearprotocol
https://twitter.com/NEARProtocol