r55-eth
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: 11 additions & 4 deletions b/‎eth-riscv-runtime/src/lib.rs‎
Lines changed: 11 additions & 4 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
@@ -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,12 +73,18 @@ pub fn revert() -> ! {
     unreachable!()
 }
 
-pub fn msg_sender() -> u64 {
-    let address: u64;
+pub fn msg_sender() -> Address {
+    let first: u64;
+    let second: u64;
+    let third: u64;
     unsafe {
-        asm!("ecall", lateout("a0") address, in("t0") u32::from(Syscall::Caller));
+        asm!("ecall", lateout("a0") first, lateout("a1") second, lateout("a2") third, in("t0") u32::from(Syscall::Caller));
     }
-    address
+    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)]
 
@@ -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);