SVM Wallet App (#91)

Author: YaronWittenstein

Cargo.toml

@@ -77,5 +77,4 @@ members = [
 
 exclude = [
   "crates/svm-extern",
-  "apps/transfer",
 ]

apps/.gitignore

@@ -0,0 +1,2 @@
+wasm/*.wasm
+wasm/*.wast

apps/precompiled/transfer.wasm

@@ -1,13 +1,15 @@
 [package]
-name = "transfer"
-version = "0.0.0"
+name = "wallet"
+version = "0.1.0"
 authors = ["Yaron Wittenstein <yaron.wittenstein@gmail.com>"]
 edition = "2018"
 publish = false
 
+[workspace]
+
 [lib]
 path = "src/lib.rs"
-crate-type = ["cdylib"]
+# crate-type = ["cdylib"]
 
 [profile.release]
 panic = "abort"
@@ -16,4 +18,4 @@ debug = false
 lto=true
 
 [dependencies]
-svm-extern = { path = "../../crates/svm-extern" }
+svm-extern = { path = "../../../crates/svm-extern" }

apps/precompiled/transfer.wast

@@ -0,0 +1,7 @@
+cargo +nightly build --target wasm32-unknown-unknown --release
+cp target/wasm32-unknown-unknown/release/*.wasm ../../../apps/wasm
+pushd ../../wasm
+wasm2wat wallet.wasm > wallet.wast
+rm wallet.wasm
+wat2wasm wallet.wast
+popd

apps/transfer/Cargo.lock apps/src/wallet/Cargo.lockapps/transfer/Cargo.lock renamed to apps/src/wallet/Cargo.lock

@@ -0,0 +1,117 @@
+include!("imports.rs");
+
+use super::{read::*, write::*};
+
+use crate::{hostctx, offset, sizeof};
+
+#[no_mangle]
+pub(crate) fn is_multisig() -> bool {
+    match read_is_multisig() {
+        0 => false,
+        _ => true,
+    }
+}
+
+#[no_mangle]
+pub(crate) fn pub_key_auth() {
+    assert!(is_multisig() == false);
+
+    let reg_bits = sizeof!(pub_key) * 8;
+
+    unsafe {
+        reg_push(reg_bits, 0);
+        reg_push(reg_bits, 1);
+
+        copy_host_pub_key_to_reg(reg_bits, 0);
+        read_pub_key(offset!(pub_key1), reg_bits, 1);
+
+        if pub_key_cmp(0, 1) == 0 {
+            panic!("auth failed!")
+        }
+
+        reg_pop(reg_bits, 1);
+        reg_pop(reg_bits, 0);
+    }
+}
+
+#[no_mangle]
+pub(crate) fn multisig_start() {
+    assert!(is_multisig());
+
+    multisig_any_key_auth();
+    write_pending_pub_key();
+}
+
+#[no_mangle]
+pub(crate) fn multisig_complete() {
+    assert!(is_multisig());
+
+    multisig_any_key_auth();
+
+    let reg_bits = sizeof!(pub_key) * 8;
+
+    /// we need to assert that the current `pub_key` is different
+    /// from the presisted `pending_pub_key`.
+    /// If they keys differ - we conclude the multisig auth as a success
+    /// and we zero the `pending_pub_key.`
+    unsafe {
+        reg_push(reg_bits, 0);
+        reg_push(reg_bits, 1);
+
+        copy_host_pub_key_to_reg(reg_bits, 0);
+        read_pending_pub_key(reg_bits, 1);
+
+        if pub_key_cmp(0, 1) == 0 {
+            panic!("auth failed!")
+        }
+
+        reset_pending_pub_key();
+
+        reg_pop(reg_bits, 1);
+        reg_pop(reg_bits, 0);
+    };
+}
+
+/// Private
+
+#[no_mangle]
+fn multisig_any_key_auth() {
+    let reg_bits = sizeof!(pub_key) * 8;
+
+    unsafe {
+        reg_push(reg_bits, 0);
+        reg_push(reg_bits, 1);
+    }
+
+    copy_host_pub_key_to_reg(reg_bits, 0);
+
+    for idx in 0..3 {
+        read_pub_key(offset!(pub_key, idx), reg_bits, 1);
+
+        if pub_key_cmp(0, 1) == 0 {
+            // we've found a match
+
+            // restore regs
+            unsafe {
+                reg_pop(reg_bits, 1);
+                reg_pop(reg_bits, 0);
+            };
+
+            return;
+        }
+    }
+
+    panic!("auth failed")
+}
+
+#[no_mangle]
+fn pub_key_cmp(reg_idx1: u32, reg_idx2: u32) -> i32 {
+    unsafe { reg_cmp(sizeof!(pub_key) * 8, reg_idx1, reg_idx2) }
+}
+
+#[no_mangle]
+fn copy_host_pub_key_to_reg(reg_bits: u32, reg_idx: u32) {
+    unsafe {
+        host_ctx_read_into_reg(hostctx!(pub_key), reg_bits, reg_idx);
+    }
+}

apps/transfer/Cargo.toml apps/src/wallet/Cargo.tomlapps/transfer/Cargo.toml renamed to apps/src/wallet/Cargo.toml

@@ -0,0 +1,63 @@
+///
+/// 𝘓𝘛: Layer time (in seconds).
+/// The time between subsequent Layers is guaranteed to stay constant.
+///
+/// 𝘓𝙞𝑞𝘛: Liquidation time (in seconds).
+///
+/// 𝘓: #Layers during the liquidation time.
+/// 𝘓 = 𝘓𝙞𝑞𝘛 / 𝘓𝘛
+///
+/// 𝘓𝘴:    The layer the liquidation starts (given by the Host).
+/// 𝘓𝘤𝘶𝘳:  The current layer (given by the Host).
+///
+/// 𝙇𝘱𝘳𝘦𝘷: The layer of the last liquidation computation (initialized with 𝘓𝘴).
+///        After each liquidation refresh, we save to the app-storage:
+///        𝙇𝘱𝘳𝘦𝘷 <- 𝙇𝘤𝘶𝘳
+///
+/// 𝗖: total #coins.
+/// 𝘓𝙞𝑞ʟ: liquidation-per-layer
+/// 𝘓𝙞𝑞ʟ = 𝗖 / 𝘓
+///
+/// 𝝙L: Layers delta.
+/// 𝝙L = 𝙇𝘤𝘶𝘳 - 𝙇𝘱𝘳𝘦𝘷
+///
+/// 𝝙𝘓𝙞𝑞: Liquidation delta (𝝙coins that becomes liquidated).
+/// 𝝙𝘓𝙞𝑞 = 𝘓𝙞𝑞ʟ * 𝝙L
+///
+
+/// Computes the total liquidation period in layers.
+///
+/// time_iternval - A time interval (in seconds).
+/// layer_time    - The time time between subsequent layers (in seconds).
+pub(crate) fn layer_count(time_interval: u32, layer_time: u32) -> u32 {
+    assert!(time_interval % layer_time == 0);
+
+    time_interval / layer_time
+}
+
+/// Computes the `liquidation per layer`.
+///
+/// `amount`      - The amount of unliquidated-yet coins.
+/// `layer_count` - The #layers during the liquidation period.
+///
+pub(crate) fn layer_liquidation(amount: u32, layer_count: u32) -> u32 {
+    assert!(amount % layer_count == 0);
+
+    amount / layer_count
+}
+
+/// Computes the new liquidated coins between layers `layer_prev` to `layer_current`
+///
+/// `layer_liq`     - The liquidation per layer. (see: `layer_liquidation` above).
+/// `last_layer`    - The last layer where the liquidation has been calculated.
+/// `current_layer` - The current layer.
+///
+pub(crate) fn liquidation_delta(layer_liq: u32, last_layer: u64, current_layer: u64) -> u32 {
+    assert!(current_layer >= last_layer);
+
+    let delta: u64 = (layer_liq as u64) * (current_layer - last_layer);
+
+    assert!(delta <= 0xFF_FF_FF_FF);
+
+    delta as u32
+}