feat: compilation script + CREATE opcode (#43)

Author: 0xrusowsky

.cargo/config.toml

@@ -0,0 +1,8 @@
+[alias]
+compile = "run --package r55-compile"
+test-r55 = "test --package r55"
+test-e2e = "test --package r55 --test e2e"
+test-erc20 = "test --package r55 --test erc20"
+test-erc721 = "test --package r55 --test erc721"
+
+

.github/workflows/ci.yml

@@ -65,10 +65,10 @@ jobs:
       # Only run tests on latest stable and above
       - name: build
         if: ${{ matrix.rust == '1.81' }} # MSRV
-        run: cargo build --workspace ${{ matrix.flags }}
+        run: cargo compile --workspace ${{ matrix.flags }}
       - name: test
         if: ${{ matrix.rust != '1.81' }} # MSRV
-        run: cargo test --workspace ${{ matrix.flags }}
+        run: cargo compile && cargo test --workspace ${{ matrix.flags }}
 
   # TODO(fakedev9999): Add wasm tests if needed
 
@@ -90,6 +90,14 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
+      - name: Install Dependencies
+        run: |
+          rustup install nightly-2025-01-07-x86_64-unknown-linux-gnu
+          rustup component add rust-src --toolchain nightly-2025-01-07-x86_64-unknown-linux-gnu
+          sudo apt-get update
+          sudo apt-get install -y gcc-riscv64-unknown-elf make device-tree-compiler
+      - name: Build
+        run: cargo compile
       - name: cargo hack
         run: |
           args=(${{ matrix.flags }})
@@ -107,7 +115,16 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
-      - run: cargo clippy --workspace --all-targets --all-features -- -D warnings
+      - name: Install Dependencies
+        run: |
+          rustup install nightly-2025-01-07-x86_64-unknown-linux-gnu
+          rustup component add rust-src --toolchain nightly-2025-01-07-x86_64-unknown-linux-gnu
+          sudo apt-get update
+          sudo apt-get install -y gcc-riscv64-unknown-elf make device-tree-compiler
+      - name: Compile
+        run: cargo compile
+      - name: Run Clippy
+        run: cargo clippy --workspace --all-targets --all-features -- -D warnings
         env:
           RUSTFLAGS: -D warnings
 
@@ -120,7 +137,14 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
-      - run: cargo doc --workspace --all-features --no-deps --document-private-items
+      - name: Install Dependencies
+        run: |
+          rustup install nightly-2025-01-07-x86_64-unknown-linux-gnu
+          rustup component add rust-src --toolchain nightly-2025-01-07-x86_64-unknown-linux-gnu
+          sudo apt-get update
+          sudo apt-get install -y gcc-riscv64-unknown-elf make device-tree-compiler
+      - name: Run Docs
+        run: cargo compile && cargo doc --workspace --all-features --no-deps --document-private-items
         env:
           RUSTDOCFLAGS: "--cfg docsrs -D warnings"
 

.gitignore

@@ -15,3 +15,10 @@ Cargo.lock
 
 # Ignore RISCV emulator files
 **/rvemu.*
+
+# Ignore auto-generated files
+r55-output-bytecode/
+*/generated/
+
+# Ignore .DS_Store
+.DS_Store

Cargo.toml

@@ -2,7 +2,7 @@
 
 resolver = "2"
 
-members = ["eth-riscv-interpreter", "eth-riscv-syscalls", "r55"]
+members = ["eth-riscv-interpreter", "eth-riscv-syscalls", "r55", "r55-compile"]
 default-members = ["eth-riscv-interpreter", "eth-riscv-syscalls", "r55"]
 
 exclude = [

asm-runtime-example/runtime

@@ -175,6 +175,12 @@ where
             }
         }
 
+        impl <C: CallCtx> #interface_name<C> {
+            pub fn address(&self) -> Address {
+                self.address
+            }
+        }
+
         impl<C: StaticCtx> #interface_name<C> {
             #(#immut_method_impls)*
         }

asm-runtime-example/runtime.o

@@ -454,6 +454,8 @@ pub fn contract(_attr: TokenStream, item: TokenStream) -> TokenStream {
         // only when not in `interface-only` mode
         #[cfg(not(any(feature = "deploy", feature = "interface-only")))]
         #[allow(non_local_definitions)]
+        #[allow(unused_imports)]
+        #[allow(unreachable_code)]
         mod implementation {
             use super::*;
             use alloy_sol_types::SolValue;

contract-derive/src/helpers.rs

@@ -1,5 +1,3 @@
-#![no_std]
-
 extern crate alloc;
 use alloc::vec::Vec;
 use alloy_core::primitives::{Address, Bytes, U256};

contract-derive/src/lib.rs

@@ -0,0 +1,103 @@
+extern crate alloc;
+use alloy_core::primitives::{Address, Bytes, U32};
+use alloy_sol_types::{SolType, SolValue};
+use ext_alloc::vec::Vec;
+use core::{arch::asm, marker::PhantomData, u64};
+use eth_riscv_syscalls::Syscall;
+
+use crate::{FromBuilder, InitInterface, MethodCtx, ReadWrite};
+
+pub trait Deployable {
+    type Interface: InitInterface;
+
+    /// Returns the contract's runtime bytecode
+    fn __runtime() -> &'static [u8];
+
+    /// Returns the contract's runtime bytecode
+    fn bytecode() -> Bytes {
+        Bytes::from(Self::__runtime())
+    }
+
+    // Creates a deployment builder that captures the constructor args
+    fn deploy<Args>(args: Args) -> DeploymentBuilder<Self, Args> 
+    where 
+        Self: Sized,
+        Args: SolValue + core::convert::From<<<Args as SolValue>::SolType as SolType>::RustType>
+    {
+        DeploymentBuilder {
+            args,
+            _phantom: PhantomData,
+        }
+    } 
+}
+
+pub struct DeploymentBuilder<D: Deployable + ?Sized, Args> 
+where
+    Args: SolValue + core::convert::From<<<Args as SolValue>::SolType as SolType>::RustType>
+{
+    args: Args,
+    _phantom: PhantomData<D>,
+}
+
+impl<D: Deployable, Args> DeploymentBuilder<D, Args> 
+where
+    Args: SolValue + core::convert::From<<<Args as SolValue>::SolType as SolType>::RustType>
+{
+
+    // Return the interface with the appropriate context
+    pub fn with_ctx<M, T>(self, ctx: M) -> T 
+    where
+        M: MethodCtx<Allowed = ReadWrite>, // Constrain to mutable contexts only
+        D::Interface: InitInterface,
+        T: FromBuilder<Context = M::Allowed>,
+        D::Interface: crate::IntoInterface<T>
+    {
+        let bytecode = D::__runtime();
+        let encoded_args = self.args.abi_encode();
+
+        // Craft R55 initcode: [0xFF][codesize][bytecode][constructor_args]
+        let codesize = U32::from(bytecode.len());
+
+        let mut init_code = Vec::new();
+        init_code.push(0xff);
+        init_code.extend_from_slice(&Bytes::from(codesize.to_be_bytes_vec()));
+        init_code.extend_from_slice(&bytecode);
+        init_code.extend_from_slice(&encoded_args);
+
+        let offset = init_code.as_ptr() as u64;
+        let size = init_code.len() as u64;
+
+        // TODO: think of an ergonomic API to handle deployments with values
+        create(0, offset, size);
+
+        // Get deployment address
+        let mut ret_data = Vec::with_capacity(20);
+        ret_data.resize(20 as usize, 0);
+        return_create_address(ret_data.as_ptr() as u64);
+
+        let address = Address::from_slice(&ret_data);
+        
+        // Create the interface builder
+        let builder = D::Interface::new(address);
+        
+        // Convert to the actual interface with context
+        builder.with_ctx(ctx)
+    }
+}
+
+fn create(value: u64, data_offset: u64, data_size: u64) {
+    unsafe {
+        asm!(
+            "ecall",
+            in("a0") value, in("a1") data_offset, in("a2") data_size,
+            in("t0") u8::from(Syscall::Create)
+        );
+    }
+}
+
+fn return_create_address(data_offset: u64) {
+    unsafe {
+        asm!(
+            "ecall", in("a0") data_offset, in("t0") u8::from(Syscall::ReturnCreateAddress));
+    }
+}