r55-eth
diff --git a/‎contract-derive/src/lib.rs‎
Lines changed: 2 additions & 6 deletions b/‎contract-derive/src/lib.rs‎
Lines changed: 2 additions & 6 deletions
diff --git a/‎erc20/src/lib.rs‎
Lines changed: 6 additions & 1 deletion b/‎erc20/src/lib.rs‎
Lines changed: 6 additions & 1 deletion
diff --git a/‎eth-riscv-runtime/src/lib.rs‎
Lines changed: 15 additions & 0 deletions b/‎eth-riscv-runtime/src/lib.rs‎
Lines changed: 15 additions & 0 deletions
diff --git a/‎eth-riscv-syscalls/src/lib.rs‎
Lines changed: 1 addition & 0 deletions b/‎eth-riscv-syscalls/src/lib.rs‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎r55/src/exec.rs‎
Lines changed: 15 additions & 1 deletion b/‎r55/src/exec.rs‎
Lines changed: 15 additions & 1 deletion
@@ -25,11 +25,7 @@ pub fn contract(_attr: TokenStream, item: TokenStream) -> TokenStream {
     // Iterate over the items in the impl block to find pub methods
     for item in input.items.iter() {
         if let ImplItem::Method(method) = item {
-            if method.vis
-                == syn::Visibility::Public(syn::VisPublic {
-                    pub_token: syn::token::Pub::default(),
-                })
-            {
+            if let syn::Visibility::Public(_) = method.vis {
                 public_methods.push(method.clone());
             }
         }
@@ -80,7 +76,7 @@ pub fn contract(_attr: TokenStream, item: TokenStream) -> TokenStream {
     // Generate the call method implementation
     let call_method = quote! {
         use alloy_sol_types::SolValue;
-        use eth_riscv_runtime::{revert, return_riscv, slice_from_raw_parts, Contract};
+        use eth_riscv_runtime::{revert, msg_sender, return_riscv, slice_from_raw_parts, Contract};
 
         impl Contract for #struct_name {
             fn call(&self) {
 
@@ -6,7 +6,7 @@ use core::default::Default;
 use contract_derive::contract;
 use eth_riscv_runtime::types::Mapping;
 
-use alloy_core::primitives::Address;
+use alloy_core::primitives::{Address, address};
 
 #[derive(Default)]
 pub struct ERC20 {
@@ -32,6 +32,11 @@ impl ERC20 {
     }
 
     pub fn mint(&self, to: Address, value: u64) {
+        let owner = msg_sender();
+        if owner != address!("0000000000000000000000000000000000000007") {
+            revert();
+        }
+
         let to_balance = self.balance.read(to);
         self.balance.write(to, to_balance + value);
     }
 
@@ -6,6 +6,7 @@ use core::arch::asm;
 use core::panic::PanicInfo;
 use core::slice;
 pub use riscv_rt::entry;
+use alloy_core::primitives::Address;
 
 mod alloc;
 pub mod types;
@@ -72,6 +73,20 @@ pub fn revert() -> ! {
     unreachable!()
 }
 
+pub fn msg_sender() -> Address {
+    let first: u64;
+    let second: u64;
+    let third: u64;
+    unsafe {
+        asm!("ecall", lateout("a0") first, lateout("a1") second, lateout("a2") third, in("t0") u32::from(Syscall::Caller));
+    }
+    let mut bytes = [0u8; 20];
+    bytes[0..8].copy_from_slice(&first.to_be_bytes());
+    bytes[8..16].copy_from_slice(&second.to_be_bytes());
+    bytes[16..20].copy_from_slice(&third.to_be_bytes()[..4]);
+    Address::from_slice(&bytes)
+}
+
 #[allow(non_snake_case)]
 #[no_mangle]
 fn DefaultHandler() {
 
@@ -56,4 +56,5 @@ syscalls!(
     (2, SStore, "sstore"),
     (3, Call, "call"),
     (4, Revert, "revert"),
+    (5, Caller, "caller"),
 );
@@ -42,7 +42,7 @@ pub fn run_tx(db: &mut InMemoryDB, addr: &Address, calldata: Vec<u8>) {
     let mut evm = Evm::builder()
         .with_db(db)
         .modify_tx_env(|tx| {
-            tx.caller = address!("0000000000000000000000000000000000000001");
+            tx.caller = address!("0000000000000000000000000000000000000007");
             tx.transact_to = TransactTo::Call(*addr);
             tx.data = calldata.into();
             tx.value = U256::from(0);
@@ -242,6 +242,20 @@ fn execute_riscv(
                             },
                         };
                     }
+                    5 => {
+                        // Syscall::Caller
+                        let caller = interpreter.contract.caller;
+                        // Break address into 3 u64s and write to registers
+                        let caller_bytes = caller.as_slice();
+                        let first_u64 = u64::from_be_bytes(caller_bytes[0..8].try_into().unwrap());
+                        emu.cpu.xregs.write(10, first_u64);
+                        let second_u64 = u64::from_be_bytes(caller_bytes[8..16].try_into().unwrap());
+                        emu.cpu.xregs.write(11, second_u64);
+                        let mut padded_bytes = [0u8; 8];
+                        padded_bytes[..4].copy_from_slice(&caller_bytes[16..20]);
+                        let third_u64 = u64::from_be_bytes(padded_bytes);
+                        emu.cpu.xregs.write(12, third_u64);
+                    }
                     _ => {
                         println!("Unhandled syscall: {:?}", t0);
                         return return_revert(interpreter);