cleanup examples

Signed-off-by: Valentyn Faychuk <valy@faychuk.com>

Author: valentynfaychuk

contract_samples/rust/README.md

@@ -26,14 +26,6 @@ cargo install amadeus-cli
 
 To build the wasm smart contracts, simply run the `./build_and_validate.sh`.
 The artifacts will be placed in `target/wasm32-unknown-unknown/release/examples`.
-Optionally you can optimize the resulting wasm contracts.
-
-```bash
-wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/counter.wasm -o counter.wasm
-wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/deposit.wasm -o deposit.wasm
-wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/coin.wasm -o coin.wasm
-wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/nft.wasm -o nft.wasm
-```
 
 ### Testing
 

contract_samples/rust/build_and_validate.sh

@@ -2,19 +2,16 @@
 set -e
 
 cargo build -p amadeus-sdk --example counter --target wasm32-unknown-unknown --release
-cargo build -p amadeus-sdk --example counter_macro --target wasm32-unknown-unknown --release
 cargo build -p amadeus-sdk --example deposit --target wasm32-unknown-unknown --release
 cargo build -p amadeus-sdk --example coin --target wasm32-unknown-unknown --release
 cargo build -p amadeus-sdk --example nft --target wasm32-unknown-unknown --release
 
 wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/counter.wasm -o target/wasm32-unknown-unknown/release/examples/counter_opt.wasm
-wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/counter_macro.wasm -o target/wasm32-unknown-unknown/release/examples/counter_macro_opt.wasm
 wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/deposit.wasm -o target/wasm32-unknown-unknown/release/examples/deposit_opt.wasm
 wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/coin.wasm -o target/wasm32-unknown-unknown/release/examples/coin_opt.wasm
 wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/nft.wasm -o target/wasm32-unknown-unknown/release/examples/nft_opt.wasm
 
 curl -X POST -H "Content-Type: application/octet-stream" --data-binary @target/wasm32-unknown-unknown/release/examples/counter_opt.wasm https://mainnet-rpc.ama.one/api/contract/validate
-curl -X POST -H "Content-Type: application/octet-stream" --data-binary @target/wasm32-unknown-unknown/release/examples/counter_macro_opt.wasm https://mainnet-rpc.ama.one/api/contract/validate
 curl -X POST -H "Content-Type: application/octet-stream" --data-binary @target/wasm32-unknown-unknown/release/examples/deposit_opt.wasm https://mainnet-rpc.ama.one/api/contract/validate
 curl -X POST -H "Content-Type: application/octet-stream" --data-binary @target/wasm32-unknown-unknown/release/examples/coin_opt.wasm https://mainnet-rpc.ama.one/api/contract/validate
 curl -X POST -H "Content-Type: application/octet-stream" --data-binary @target/wasm32-unknown-unknown/release/examples/nft_opt.wasm https://mainnet-rpc.ama.one/api/contract/validate

contract_samples/rust/examples/coin.rs

@@ -2,7 +2,7 @@
 #![no_main]
 extern crate alloc;
 use amadeus_sdk::*;
-use alloc::{vec::Vec};
+use alloc::{vec::Vec, string::String};
 
 fn vault_key(symbol: &Vec<u8>) -> Vec<u8> {
     b!("vault:", account_caller(), ":", symbol)
@@ -11,43 +11,31 @@ fn vault_key(symbol: &Vec<u8>) -> Vec<u8> {
 #[no_mangle]
 pub extern "C" fn init() {
     log("init called");
-
     let mint_a_billion = encoding::coin_raw(1_000_000_000, 9);
     call!("Coin", "create_and_mint", [
         "USDFAKE", mint_a_billion, 9, "false", "false", "false"
     ]);
 }
 
-#[no_mangle]
-pub extern "C" fn deposit() {
+#[contract]
+fn deposit() -> String {
     log("deposit called");
-
     let (has_attachment, (symbol, amount)) = get_attachment();
     amadeus_sdk::assert!(has_attachment, "deposit has no attachment");
-
     let amount_i128 = i128::from_bytes(amount);
     amadeus_sdk::assert!(amount_i128 > 100, "deposit amount less than 100");
-
-    let total_vault_deposited = kv_increment(vault_key(&symbol), amount_i128);
-    ret(total_vault_deposited);
+    kv_increment(vault_key(&symbol), amount_i128)
 }
 
-#[no_mangle]
-pub extern "C" fn withdraw(symbol_ptr: i32, amount_ptr: i32) {
+#[contract]
+fn withdraw(symbol: Vec<u8>, amount: Vec<u8>) -> i128 {
     log("withdraw called");
-
-    let withdraw_symbol = read_bytes(symbol_ptr);
-    let withdraw_amount = read_bytes(amount_ptr);
-    let withdraw_amount_int = encoding::bytes_to_i128(&withdraw_amount);
+    let withdraw_amount_int = encoding::bytes_to_i128(&amount);
     amadeus_sdk::assert!(withdraw_amount_int > 0, "amount lte 0");
-
-    let key = vault_key(&withdraw_symbol);
+    let key = vault_key(&symbol);
     let vault_balance: i128 = kv_get(&key).unwrap_or(0);
     amadeus_sdk::assert!(vault_balance >= withdraw_amount_int, "insufficient funds");
-
     kv_increment(key, -withdraw_amount_int);
-
-    call!("Coin", "transfer", [account_caller(), withdraw_amount, withdraw_symbol]);
-
-    ret(vault_balance - withdraw_amount_int);
+    call!("Coin", "transfer", [account_caller(), amount, symbol]);
+    vault_balance - withdraw_amount_int
 }

contract_samples/rust/examples/counter.rs

@@ -2,29 +2,27 @@
 #![no_main]
 extern crate alloc;
 use amadeus_sdk::*;
+use alloc::{vec::Vec, string::String};
 
 #[no_mangle]
 pub extern "C" fn init() {
     log("Init called during deployment of contract");
     kv_put("inited", "true");
 }
 
-#[no_mangle]
-pub extern "C" fn get() {
-    ret(kv_get("the_counter").unwrap_or(0));
+#[contract]
+fn get() -> i128 {
+    kv_get("the_counter").unwrap_or(0)
 }
 
-#[no_mangle]
-pub extern "C" fn increment(amount_ptr: i32) {
-    let amount = read_bytes(amount_ptr);
-    let new_counter = kv_increment("the_counter", amount);
-    ret(new_counter);
+#[contract]
+fn increment(amount: Vec<u8>) -> String {
+    kv_increment("the_counter", amount)
 }
 
-#[no_mangle]
-pub extern "C" fn increment_another_counter(contract_ptr: i32) {
-    let contract = read_bytes(contract_ptr);
+#[contract]
+fn increment_another_counter(contract: Vec<u8>) -> Vec<u8> {
     let incr_by = 3i64;
     log("increment_another_counter");
-    ret(call!(contract.as_slice(), "increment", [incr_by]));
+    call!(contract.as_slice(), "increment", [incr_by])
 }

contract_samples/rust/examples/counter_macro.rs

@@ -2,56 +2,42 @@
 #![no_main]
 extern crate alloc;
 use amadeus_sdk::*;
-use alloc::{vec::Vec};
+use alloc::{vec::Vec, string::String};
 
 fn vault_key(symbol: &Vec<u8>) -> Vec<u8> {
     b!("vault:", account_caller(), ":", symbol)
 }
 
-#[no_mangle]
-pub extern "C" fn balance(symbol_ptr: i32) {
-    let key = vault_key(&read_bytes(symbol_ptr));
-    ret(kv_get(key).unwrap_or(0));
+#[contract]
+fn balance(symbol: Vec<u8>) -> i128 {
+    kv_get(vault_key(&symbol)).unwrap_or(0)
 }
 
-#[no_mangle]
-pub extern "C" fn deposit() {
+#[contract]
+fn deposit() -> String {
     log("deposit called");
-
     let (has_attachment, (symbol, amount)) = get_attachment();
     amadeus_sdk::assert!(has_attachment, "deposit has no attachment");
-
     let amount_i128 = i128::from_bytes(amount);
     amadeus_sdk::assert!(amount_i128 > 100, "deposit amount less than 100");
-
-    let total_vault_deposited = kv_increment(vault_key(&symbol), amount_i128);
-    ret(total_vault_deposited);
+    kv_increment(vault_key(&symbol), amount_i128)
 }
 
-#[no_mangle]
-pub extern "C" fn withdraw(symbol_ptr: i32, amount_ptr: i32) {
+#[contract]
+fn withdraw(symbol: Vec<u8>, amount: Vec<u8>) -> i128 {
     log("withdraw called");
-
-    let withdraw_symbol = read_bytes(symbol_ptr);
-    let withdraw_amount = read_bytes(amount_ptr);
-    let withdraw_amount_int = encoding::bytes_to_i128(&withdraw_amount);
+    let withdraw_amount_int = encoding::bytes_to_i128(&amount);
     amadeus_sdk::assert!(withdraw_amount_int > 0, "amount lte 0");
-
-    let key = vault_key(&withdraw_symbol);
+    let key = vault_key(&symbol);
     let vault_balance: i128 = kv_get(&key).unwrap_or(0);
     amadeus_sdk::assert!(vault_balance >= withdraw_amount_int, "insufficient funds");
-
     kv_increment(key, -withdraw_amount_int);
-
-    call!("Coin", "transfer", [account_caller(), withdraw_amount, withdraw_symbol]);
-
-    ret(vault_balance - withdraw_amount_int);
+    call!("Coin", "transfer", [account_caller(), amount, symbol]);
+    vault_balance - withdraw_amount_int
 }
 
-#[no_mangle]
-pub extern "C" fn burn(symbol_ptr: i32, amount_ptr: i32) {
-    let symbol = read_string(symbol_ptr);
-    let amount = read_bytes(amount_ptr);
+#[contract]
+fn burn(symbol: String, amount: Vec<u8>) -> Vec<u8> {
     log("burn");
-    ret(call!("Coin", "transfer", [BURN_ADDRESS, amount, symbol]));
+    call!("Coin", "transfer", [BURN_ADDRESS, amount, symbol])
 }

contract_samples/rust/examples/deposit.rs

@@ -2,36 +2,34 @@
 #![no_main]
 extern crate alloc;
 use amadeus_sdk::*;
+use alloc::{vec::Vec, string::String};
 
 #[no_mangle]
 pub extern "C" fn init() {
     call!("Nft", "create_collection", ["AGENTIC", "false"]);
 }
 
-#[no_mangle]
-pub extern "C" fn view_nft(collection_ptr: i32, token_ptr: i32) {
-    let collection = read_string(collection_ptr);
-    let token = read_bytes(token_ptr);
-    let url = match (collection.as_str(), token.as_slice()) {
+#[contract]
+fn view_nft(collection: String, token: Vec<u8>) -> &'static str {
+    match (collection.as_str(), token.as_slice()) {
         ("AGENTIC", b"1") => "https://ipfs.io/ipfs/bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4/welcome-to-IPFS.jpg",
         ("AGENTIC", b"2") => "https://ipfs.io/ipfs/QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG/readme",
         ("AGENTIC", b"3") => "https://ipfs.io/ipfs/QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB",
         ("AGENTIC", b"4") => "https://ipfs.io/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o",
         ("AGENTIC", b"5") => "https://ipfs.io/ipfs/QmZULkCELmmk5XNfCgTnCyFgAVxBRBXyDHGGMVoLFLiXEN",
         ("AGENTIC", b"6") => "https://ipfs.io/ipfs/QmTn4KLRkKPDkB3KpJWGXZHPPh5dFnKqNcPjX4ZcbPvKwv",
         _ => "https://ipfs.io/ipfs/bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4/welcome-to-IPFS.jpg",
-    };
-    ret(url);
+    }
 }
 
-#[no_mangle]
-pub extern "C" fn claim() {
+#[contract]
+fn claim() -> i64 {
     log("claiming");
     call!("Nft", "mint", [account_caller(), 1, "AGENTIC", "2"]);
     call!("Nft", "mint", [account_caller(), 1, "AGENTIC", "2"]);
     let random_token = roll_dice();
     call!("Nft", "mint", [account_caller(), 1, "AGENTIC", random_token]);
-    ret(random_token);
+    random_token
 }
 
 static mut PRNG_STATE: u64 = 0;
@@ -41,25 +39,17 @@ fn roll_dice() -> i64 {
     unsafe {
         if !PRNG_INIT {
             let s = seed();
-
-            // (Using FNV-1a hash algorithm for decent distribution)
             let mut h: u64 = 0xcbf29ce484222325;
             for &byte in s.iter() {
                 h = h ^ (byte as u64);
                 h = h.wrapping_mul(0x100000001b3);
             }
-
             PRNG_STATE = h;
             PRNG_INIT = true;
         }
-
-        // 2. "Increment" the seed (Step the LCG)
-        // Constants from Musl Libc / Knuth
-        // state = state * 6364136223846793005 + 1442695040888963407
         PRNG_STATE = PRNG_STATE
             .wrapping_mul(6364136223846793005)
             .wrapping_add(1442695040888963407);
-
         let result = (PRNG_STATE >> 32) as i64;
         (result.abs() % 6) + 1
     }

contract_samples/rust/examples/nft.rs

@@ -32,7 +32,3 @@ path = "../examples/coin.rs"
 [[example]]
 name = "nft"
 path = "../examples/nft.rs"
-
-[[example]]
-name = "counter_macro"
-path = "../examples/counter_macro.rs"