SIMPLE CAIRO VM WRITTEN IN RUST;

This repo is an implementation of a simple cairo vm for compiling Cairo language, written in rust.

Introduction

Cairo is a unique language tailored for zk-STARKs and has applications in creating scalable and transparent computational integrity proofs.

This project aims to provide a Rust-based environment for compiling and running Cairo programs.

Features of the VM

The VM Consists of a ;

Lexer : Tokenize Cairo Code
Parser: Analyzes the tokenized output from the lexer and builds an Abstract Syntax Tree (AST).
Type-Checker: Validates the types used in the Cairo programs to ensure correctness.
Translator: Converts the AST into bytecode or machine code suitable for the VM.
Runtime environment: Executes the translated code.

N.B extra features and complexity will be added to mimic starknet and cairo architcture properly.

The lexer is currently under construction. It's a manual lexer, for more efficiency the logos Rust crate will be used to build a more efficient and stable lexer.

Clone the Repo

git clone https://github.com/CyndieKamau/cairovm_rust

cd cairovm_rust

cargo build

Here's an overview of how the current lexer is functioning;

hp@Cyndie:~/Desktop/cairovm/lexer/src$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.05s
     Running `/home/hp/Desktop/cairovm/lexer/target/debug/lexer`
Please enter a simple cairo code here: 
let mut x = 5_u32
[Let, Mut, Identifier("x"), Assign, Number("5", None), Identifier("u32")]

Deployment of Actix Web Server using DigitalOcean

STEP 1: Create a Digital Ocean account

STEP 2: Create a New Droplet:

Choose a region (San Francisco, New York etc)
Choose a Data Center within the region (San Francisco.Datacenter 3. SF03)
Choose an image (Ubuntu 22.04 LTS x64 etc)
Choose Size (Basic, General Purpose etc)
Choose CPU options (Regular, Premium Intel etc)
Choose SSH Authentication method :
- To generate a new SSH key:
- Run ssh-keygen
- You will be prompted to save and name the key:
```
Generating public/private rsa key pair.
Enter file in which to save the key
(/Users/USER/.ssh/id_rsa):
```
N.B: If you have setup ssh already with github rename the id_rsa file to avoid over-writing it, example dig_id_rsa
- Create and confirm a passphrase for the key (highly recommended):
```
Enter passphrase (empty for no passphrase):

Enter same passphrase again:
```
- This will generate two files: dig_id_rsa and dig_id_rsa.pub
- Copy paste the dig_id_rsa.pub to the SSH Key content field in Digital Ocean:
cat ~/.ssh/dig_id_rsa.pub
Create Doplet

Once done, ssh into your virtual machine using the IP address allocated by Digital Ocean:

$ ssh root@your_ip_address
The authenticity of host ' ()' can't be established.
ECDSA key fingerprint is SHA256:glf52FoAchmTtbFsYDHXiigswi9LWtFYIya4eJtKDto.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '' (ECDSA) to the list of known hosts.
Welcome to Ubuntu 22.04.2 LTS (GNU/Linux 5.15.0-67-generic x86_64)
...

STEP 3: Installing Dependencies in your VM

The VM is in essence an empty Linux VM
First update it: sudo apt update && sudo apt upgrade

Install the dependencies needed to run the rust web server:

Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Node:

# install nvm first
$ sudo apt install curl
$ curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash 

# Load your environment
$  source ~/.bashrc

# Install Node using nvm
$ nvm install node 

# If you want specific node version
$ nvm install 18.16.0

Nginx: sudo apt install nginx

Copy Paste your IP address to the browser.

You should see such a message that confirms Nginx is properly installed:

  ```
  Welcome to nginx!

  If you see this page, the nginx web server is successfully installed and working
  ....
  ```

STEP 4: Configure Nginx as a reverse proxy server

Access the Nginx configuration:

Create a new config file in /etc/nginx/sites-available/ directory:

sudo nano /etc/nginx/sites-available/myapp

Replace myapp with the name of your choice.

Create a symbolic link to the config file created to link it to sites-enabled directory:

sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/

Check if the Nginx connection is Okay:

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

N.B. If you get this error your symlink has not been configured properly:

  ```sh
  nginx: [emerg] open() "/etc/nginx/sites-enabled/cairovm" failed (40: Too many levels of symbolic links) in /etc/nginx/nginx.conf:60
  nginx: configuration file /etc/nginx/nginx.conf test failed

  ```

Configure the myapp file:

server {

    server_name cairovm.supercodehive.com www.cairovm.supercodehive.com;

    location / {
        proxy_pass http://localhost:8080; # Point to the Actix web server
        proxy_buffering off;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Note that the server name should be your domain name.

You should also specify your Actix web server port: http://localhost:8080

Configure firewall settings to allow traffic:

$ sudo ufw allow 'Nginx Full'
$ sudo ufw allow 'Nginx HTTP'

STEP 5: Clone and Run your Rust project in the VM:

Create a directory to hold your Rust project:

mkdir apps && cd apps

Clone your repo inside the apps dir, and build the dependencies:

$ git clone https://github.com/CyndieKamau/cairovm_rust.git

$ cd cairovm_rust

$ cargo run

STEP 6: Create systemd service to serve your web application

Create a systemd service for your web server

Open a new service file:

sudo nano /etc/systemd/system/cairovm.service

Rename the file to suit your project.
Edit the cairovm.service file:
```
    [Unit]
    Description=Actix Web Application

    [Service]
    User=root
    Group=root
    WorkingDirectory=/path/to/your/rust/app/
    # Set any environment variables your app needs, e.g., database URLs
    Environment="RUST_LOG=info"
    ExecStart=/path/to/your/app/target/release/your_app_executable

    [Install]
    WantedBy=multi-user.target
```
Add the appropriate user and group, based on your server configuration.

To get the number of users and groups in your server, use getent passwd

WorkingDirectory is the file path to your rust project

ExecStart is the path to your rust binary after running the program.

It's release if you ran in production mode; for local development its debug.
Restart the systemd daemon:

$ sudo systemctl daemon-reload
Enable cairovm.service to run automatically after every boot up:

$ sudo systemctl enable cairovm.service
Start cairovm.service:

sudo systemctl start cairovm.service

Successful configuration will be like this:

  $ sudo systemctl status cairovm.service
  ● cairovm.service - Actix Web Application
      Loaded: loaded (/etc/systemd/system/cairovm.service; enabled; vendor preset: enabled)
      Active: active (running) since Wed 2023-11-29 15:40:15 UTC; 3min 16s ago
  Main PID: 32594 (cairovm)
      Tasks: 3 (limit: 1116)
      Memory: 1.1M
          CPU: 133ms
      CGroup: /system.slice/cairovm.service
              └─32594 /root/apps/cairovm_rust/target/debug/cairovm

  Nov 29 15:40:15 ubuntu-22-04 cairovm[32594]: [2023-11-29T15:40:15Z INFO  actix_server::builder] starting 1 workers
  Nov 29 15:40:15 ubuntu-22-04 systemd[1]: Started Actix Web Application.
  Nov 29 15:40:15 ubuntu-22-04 cairovm[32594]: [2023-11-29T15:40:15Z INFO  actix_server::server] Actix runtime found; starting in Actix

Incase you get this error, ensure while writing the path to your ExecStart avoid including / at the end as the executable is treated as a directory:

    Failed to restart cairovm.service: Unit cairovm.service has a bad unit file setting.
See system logs and 'systemctl status cairovm.service' for details.
root@ubuntu-22-04:~/apps/cairovm_rust/target/debug# systemctl status cairovm.service
○ cairovm.service - Actix Web Application
    Loaded: bad-setting (Reason: Unit cairovm.service has a bad unit file setting.)
    Active: inactive (dead)

Nov 29 15:23:31 ubuntu-22-04 systemd[1]: /etc/systemd/system/cairovm.service:10: Executable path specifies a directory: /root/apps/cai>
Nov 29 15:23:31 ubuntu-22-04 systemd[1]: cairovm.service: Unit configuration has fatal error, unit will not be started.
Nov 29 15:24:24 ubuntu-22-04 systemd[1]: /etc/systemd/system/cairovm.service:10: Executable path specifies a directory: /root/apps/cai>
Nov 29 15:24:24 ubuntu-22-04 systemd[1]: cairovm.service: Unit configuration has fatal error, unit will not be started.
Nov 29 15:29:55 ubuntu-22-04 systemd[1]: /etc/systemd/system/cairovm.service:10: Executable path specifies a directory: /root/apps/cai>
Nov 29 15:29:55 ubuntu-22-04 systemd[1]: cairovm.service: Unit configuration has fatal error, unit will not be started.
...skipping...
○ cairovm.service - Actix Web Application
    Loaded: bad-setting (Reason: Unit cairovm.service has a bad unit file setting.)
    Active: inactive (dead)

STEP 7: Enable Https for your website

Install certbot:

$ sudo snap install --classic certbot

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Enable Https using certbot:

$ sudo certbot --nginx

....
Successfully received certificate.
Certificate is saved at: /etc/letsencrypt/live/cairovm.supercodehive.com/fullchain.pem
Key is saved at:         /etc/letsencrypt/live/cairovm.supercodehive.com/privkey.pem
This certificate expires on 2024-02-27.
These files will be updated when the certificate renews.
Certbot has set up a scheduled task to automatically renew this certificate in the background.

Deploying certificate
Successfully deployed certificate for cairovm.supercodehive.com to /etc/nginx/sites-enabled/cairovm
Successfully deployed certificate for www.cairovm.supercodehive.com to /etc/nginx/sites-enabled/cairovm
Congratulations! You have successfully enabled HTTPS on https://cairovm.supercodehive.com and https://www.cairovm.supercodehive.com

Renew the generated certificates:

$ sudo certbot renew --dry-run

....
Congratulations, all simulated renewals succeeded: 
/etc/letsencrypt/live/cairovm.supercodehive.com/fullchain.pem (success)

okolievans / cairovm_rust Goto Github PK

cairovm_rust's Introduction

SIMPLE CAIRO VM WRITTEN IN RUST;

Introduction

Features of the VM

Lexer : Tokenize Cairo Code

Parser: Analyzes the tokenized output from the lexer and builds an Abstract Syntax Tree (AST).

Type-Checker: Validates the types used in the Cairo programs to ensure correctness.

Translator: Converts the AST into bytecode or machine code suitable for the VM.

Runtime environment: Executes the translated code.

Clone the Repo

Deployment of Actix Web Server using DigitalOcean

STEP 1: Create a Digital Ocean account

STEP 2: Create a New Droplet:

STEP 3: Installing Dependencies in your VM

STEP 4: Configure Nginx as a reverse proxy server

STEP 5: Clone and Run your Rust project in the VM:

STEP 6: Create systemd service to serve your web application

STEP 7: Enable Https for your website

cairovm_rust's People

Contributors

Recommend Projects

Recommend Topics

Recommend Org