use clap::{App, Arg, SubCommand};
use ethers::prelude::*;
use ethers::signers::LocalWallet;
use parser::{append_js_functions_to_file, generate_import_statement, read_first_account};
use reqwest::Error as ReqwestError;
use serde::{Deserialize, Serialize};
use std::env;
use std::env::current_dir;
use std::error::Error;
use std::fs::{self, OpenOptions};
use std::io::{stderr, stdin, stdout, Read, Write};
use std::path::PathBuf;
use std::process::Command;
use std::{collections::HashMap, os::unix::io, sync::Arc};
use tokio::sync::Mutex;
use warp::filters::body::form;
use warp::Filter;
mod confighandler;
mod filehandler;
mod parser;
use crate::confighandler::{configgenerator, Config};
use crate::filehandler::{build_index_content, index_content};
use crate::filehandler::{filewriter, state_content, tsconfig_content, utils_content};
use crate::parser::configparser;
use crate::parser::create_js_function;
use crate::parser::importparser;
use crate::parser::parse_typescript_file;
use crate::parser::remove_unwanted_lines;
#[derive(Debug, Deserialize)]
struct TokenResponse {
access_token: String,
expires_in: u64,
token_type: String,
refresh_token: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct SignedBinary {
byteCode: Vec<u8>,
signature: String,
appID: i32,
}
#[derive(Serialize, Deserialize)]
struct Genesis {
signedBinary: SignedBinary,
genesisState: String,
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let matches = App::new("My Rust CLI")
.version("1.0")
.author("Your Name")
.about("A CLI with Google Auth")
.subcommand(
SubCommand::with_name("init")
.about("Initialize the application")
.arg(
Arg::with_name("project-name")
.long("project-name")
.help("Sets the project name")
.takes_value(true)
.required(true),
)
.arg(
Arg::with_name("private-key")
.long("private-key")
.help("Takes private key of the operator")
.takes_value(true)
.required(true),
),
)
.subcommand(SubCommand::with_name("compile"))
.subcommand(SubCommand::with_name("deploy"))
.subcommand(SubCommand::with_name("parse"))
.get_matches();
if let Some(init_matches) = matches.subcommand_matches("init") {
let mut config = Config {
project_name: String::new(),
batch_size: 0,
batch_time: 0,
batcher_slot_time: 0,
operator_accounts: Vec::new(),
aggregator_rpcs: Vec::new(),
};
let client_id = "266578720767-7qf52i2g90hjjlv258b2bra1ktt4f9lv.apps.googleusercontent.com";
let clientt_secret = "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";
println!(
r#"
_ _ _ _
___| |_ __ _ ___| | ___ __ ___| (_)
/ __| __/ _` |/ __| |/ / '__| _____ / __| | |
\__ \ || (_| | (__| <| | |_____| | (__| | |
|___/\__\__,_|\___|_|\_\_| \___|_|_|
"#
);
println!("Enter into the world of Micro Rollups");
if let Some(project_name) = init_matches.value_of("project-name") {
config.project_name = project_name.trim().to_string();
}
if let Some(private_key) = init_matches.value_of("private-key") {
let mut operator_address = private_key.trim();
operator_address = operator_address.trim_start_matches("0x");
match operator_address.len() == 64 {
true => println!(""),
false => {
println!("Invalid private key length");
std::process::exit(1);
}
}
config.operator_accounts.push(operator_address.to_string());
}
config.batch_time = 3000;
config.batch_time = 10;
config.batch_time = 1000;
println!("Creating project ... {}", &config.project_name);
let _ = fs::create_dir(&config.project_name);
let path = format!("./{}/src", &config.project_name);
let _ = fs::create_dir(&path);
let _ = std::fs::write(format!("{}/state.ts", &path), state_content());
let _ = std::fs::write(
format!("./{}/stackr.config.ts", &config.project_name),
"contents",
);
let _ = std::fs::write(
format!("./{}/utils.ts", &config.project_name),
utils_content(),
);
let _ = std::fs::write(
format!("./{}/tsconfig.json", &config.project_name),
tsconfig_content(),
);
let _ = filewriter(&config.project_name);
let _ = configgenerator(&config, &config.project_name);
let current_dir = env::current_dir()?;
let project_dir = current_dir.join(format!("{}/", &config.project_name));
let index_file_path = current_dir.join(format!("{}/src/index.ts", &config.project_name));
let state_file_path = current_dir.join(format!("{}/src/state.ts", &config.project_name));
let _ = importparser(&index_file_path);
let _ = importparser(&state_file_path);
println!("Running 'bun init -y'");
let bun_init = Command::new("bun")
.arg("init")
.arg("-y")
.current_dir(&project_dir)
.output();
match bun_init {
Ok(output) => {
eprintln!("{}", &project_dir.display());
stdout().write_all(&output.stdout)?;
stderr().write_all(&output.stderr)?;
if !output.status.success() {
eprintln!("bun install failed with status: {}", output.status);
std::process::exit(1);
}
}
Err(e) => {
eprintln!("Failed to execute bun install: {}", e);
eprintln!("{}", &project_dir.display());
std::process::exit(1);
}
}
println!("Running 'bun install ethers express body-parser'");
let bun_install = Command::new("bun")
.arg("install")
.arg("ethers")
.arg("express")
.arg("body-parser")
.arg("merkletreejs")
.current_dir(&project_dir)
.output();
match bun_install {
Ok(output) => {
eprintln!("{}", &project_dir.display());
stdout().write_all(&output.stdout)?;
stderr().write_all(&output.stderr)?;
if !output.status.success() {
eprintln!("bun install failed with status: {}", output.status);
std::process::exit(1);
}
}
Err(e) => {
eprintln!("Failed to execute bun install: {}", e);
eprintln!("{}", &project_dir.display());
std::process::exit(1);
}
}
}
if matches.subcommand_matches("compile").is_some() {
println!("Compiling...");
let _ = compilation();
}
if matches.subcommand_matches("deploy").is_some() {
println!("Deploying...");
deploy_command().await?;
}
Ok(())
}
fn compilation() -> Result<(), Box<dyn Error>> {
let current_dir = env::current_dir()?;
let build_dir = current_dir.join("build");
if !build_dir.exists() {
fs::create_dir(&build_dir)?;
println!("Created build directory: {:?}", build_dir);
}
let state_file_dir = current_dir.join("src/state.ts");
let _ = fs::copy(&state_file_dir, ¤t_dir.join("build/state.ts"));
let import_statement = generate_import_statement(&state_file_dir)?;
let run_function = create_js_function(&import_statement);
let _ = fs::write(current_dir.join("build/stf.ts"), import_statement);
let mut build_index = OpenOptions::new()
.append(true)
.open(current_dir.join("build/stf.ts"))?;
let _ = build_index.write("\n".as_bytes());
let _ = build_index
.write(r#"import { StateMachine } from "@stackr/stackr-js/execution";"#.as_bytes());
let _ = build_index.write("\n\n".as_bytes());
let _ = build_index.write(run_function?.as_bytes());
let _ = build_index.write("\n\n".as_bytes());
let _ = build_index.write(build_index_content().as_bytes());
let _ = importparser(¤t_dir.join("build/state.ts"));
let _ = remove_unwanted_lines(¤t_dir.join("build/state.ts"));
println!("Transpiling stf.ts from TS -> JS ... ");
let js_transpile = Command::new("bun")
.args(&[
"build",
"./build/stf.ts",
"--outdir=build",
"--target=bun",
"--external=class-transformer",
"--external=class-validator",
"--external=@nestjs/microservices",
"--external=@nestjs/websockets",
"--external=@nestjs/platform-express",
])
.current_dir(¤t_dir)
.output();
match js_transpile {
Ok(output) => {
stdout().write_all(&output.stdout)?;
stderr().write_all(&output.stderr)?;
if !output.status.success() {
eprintln!("js -> wasm failed: {}", output.status);
std::process::exit(1);
}
}
Err(e) => {
eprintln!("Failed to transpile: {}", e);
eprintln!("{}", ¤t_dir.display());
std::process::exit(1);
}
}
println!("Creating a WASM build ...");
let javy_compile = Command::new("javy")
.arg("compile")
.arg("./build/stf.js")
.arg("-o")
.arg("./build/stf.wasm")
.current_dir(¤t_dir)
.output();
match javy_compile {
Ok(output) => {
stdout().write_all(&output.stdout)?;
stderr().write_all(&output.stderr)?;
if !output.status.success() {
eprintln!("js -> wasm failed: {}", output.status);
std::process::exit(1);
}
}
Err(e) => {
eprintln!("Failed to execute javy compile: {}", e);
std::process::exit(1);
}
}
let _ = configparser();
println!("Compilation done !");
Ok(())
}
async fn exchange_code_for_token(
authorization_code: String,
client_id: String,
client_secret: String,
redirect_uri: &str,
) -> Result<TokenResponse, ReqwestError> {
let params = [
("code", authorization_code),
("client_id", client_id),
("client_secret", client_secret),
("redirect_uri", redirect_uri.to_string()),
("grant_type", "authorization_code".to_string()),
];
let client = reqwest::Client::new();
let res = client
.post("https://oauth2.googleapis.com/token")
.form(¶ms)
.send()
.await?;
let token_response: TokenResponse = res.json().await?;
Ok(token_response)
}
fn read_u32(prompt: &str, default: u32) -> u32 {
loop {
println!("{} (default {}):", prompt, default);
let mut input = String::new();
if stdin().read_line(&mut input).is_err() {
println!("Error reading input. Using default value.");
return default;
}
let input = input.trim();
if input.is_empty() {
return default;
}
match input.parse::<u32>() {
Ok(num) => return num,
Err(_) => println!("Invalid input. Please enter a valid number or just press enter to use the default."),
}
}
}
async fn deploy_command() -> Result<(), Box<dyn Error>> {
let client = reqwest::Client::new();
let current_dir = env::current_dir()?;
let first_account_pvt_key = read_first_account(¤t_dir.join("stackr.config.ts"))?;
let binary_path = current_dir.join("build/stf.wasm");
let byte_code = read_byte_code(&binary_path).await?;
let byte_code_hash: [u8; 32] = ethers::utils::keccak256(&byte_code);
let wallet = first_account_pvt_key.parse::<LocalWallet>()?;
println!("Using the account : {}", wallet.address());
let byte_code_signature =
ethers::signers::Wallet::sign_hash(&wallet, (&byte_code_hash).into())?;
let signed_binary = SignedBinary {
byteCode: byte_code.clone(),
signature: byte_code_signature.to_string(),
appID: 0,
};
let genesis_state = "0".to_string();
let payload = Genesis {
signedBinary: signed_binary,
genesisState: genesis_state,
};
let payload_json = serde_json::to_string(&payload)?;
let res = client
.post("http://localhost:3000/v0/genesis")
.header("Content-Type", "application/json")
.body(payload_json)
.send()
.await?;
if res.status().is_success() {
println!("Deployed successfully.");
} else {
eprintln!(
"Failed to deploy: {:?} {:?}",
res.status(),
res.error_for_status()
);
}
Ok(())
}
async fn read_byte_code(file_path: &PathBuf) -> Result<Vec<u8>, Box<dyn Error>> {
let mut file = fs::File::open(file_path)?;
let mut buffer = Vec::new();
file.read_to_end(&mut buffer)?;
Ok(buffer)
}