[FIL-227] Automatic allocator

fplus-database/Cargo.toml

@@ -24,7 +24,7 @@ serde = { version =  "1.0.164", features = ["derive", "std",
 serial_test = "3.0.0"
 sha1 = "0.10.6"
 serde_json = "1.0.96"
-alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", features = [
+alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.3.2", features = [
     "signers",
 ] }
 sea-orm-newtype = "0.0.1"

fplus-database/src/database/applications.rs

@@ -446,3 +446,14 @@ pub async fn delete_application(
     application.delete(&conn).await?;
     Ok(())
 }
+
+pub async fn get_applications_by_client_id(
+    id: &String,
+) -> Result<Vec<ApplicationModel>, sea_orm::DbErr> {
+    let conn = get_database_connection().await?;
+    let result = Application::find()
+        .filter(Column::Id.eq(id))
+        .all(&conn)
+        .await?;
+    Ok(result)
+}

fplus-database/src/database/autoallocations.rs

@@ -1,17 +1,35 @@
 use crate::get_database_connection;
 use crate::models::autoallocations::AddressWrapper;
-use crate::models::autoallocations::{Column, Entity as Autoallocation};
-use chrono::{DateTime, FixedOffset};
+use crate::models::autoallocations::{ActiveModel, Column, Entity as Autoallocations};
+use chrono::{DateTime, FixedOffset, Utc};
 use sea_orm::{entity::*, query::*, DbErr};
 
 pub async fn get_last_client_autoallocation(
     client_evm_address: impl Into<AddressWrapper>,
 ) -> Result<Option<DateTime<FixedOffset>>, DbErr> {
     let conn = get_database_connection().await?;
-    let response = Autoallocation::find()
+    let response = Autoallocations::find()
         .filter(Column::EvmWalletAddress.contains(client_evm_address.into()))
         .one(&conn)
         .await?;
 
     Ok(response.map(|allocation| allocation.last_allocation))
 }
+
+pub async fn create_or_update_autoallocation(
+    client_evm_address: impl Into<AddressWrapper> + Clone,
+) -> Result<(), sea_orm::DbErr> {
+    let conn = get_database_connection().await?;
+    let last_autoallocation = get_last_client_autoallocation(client_evm_address.clone()).await?;
+
+    let autoallocation_active_model = ActiveModel {
+        evm_wallet_address: Set(client_evm_address.into()),
+        last_allocation: Set(Utc::now().into()),
+    };
+    if last_autoallocation.is_some() {
+        autoallocation_active_model.update(&conn).await?;
+    } else {
+        autoallocation_active_model.insert(&conn).await?;
+    }
+    Ok(())
+}

fplus-http-server/Cargo.toml

@@ -29,6 +29,3 @@ async-trait = "0.1.73"
 uuidv4 = "1.0.0"
 log = "0.4.20"
 cron = "0.12.1"
-alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", features = [
-    "signers",
-] }

fplus-http-server/src/main.rs

@@ -109,6 +109,7 @@ async fn main() -> std::io::Result<()> {
             .service(router::allocator::create_allocator_from_json)
             .service(router::allocator::update_allocator_force)
             .service(router::autoallocator::last_client_allocation)
+            .service(router::autoallocator::trigger_autoallocation)
         // .service(router::allocator::get_installation_ids)
     })
     .bind(("0.0.0.0", 8080))?

fplus-http-server/src/router/autoallocator.rs

@@ -1,6 +1,7 @@
-use actix_web::{get, web, HttpResponse, Responder};
+use actix_web::{get, post, web, HttpResponse, Responder};
 use fplus_database::database::autoallocations as autoallocations_db;
-use fplus_lib::core::LastAutoallocationQueryParams;
+use fplus_lib::core::autoallocator;
+use fplus_lib::core::{LastAutoallocationQueryParams, TriggerAutoallocationInfo};
 
 #[get("/autoallocator/last_client_allocation")]
 pub async fn last_client_allocation(
@@ -13,3 +14,11 @@ pub async fn last_client_allocation(
         Err(e) => HttpResponse::BadRequest().body(e.to_string()),
     }
 }
+
+#[post("autoallocator/trigger_autoallocation")]
+pub async fn trigger_autoallocation(info: web::Json<TriggerAutoallocationInfo>) -> impl Responder {
+    match autoallocator::trigger_autoallocation(&info.into_inner()).await {
+        Ok(()) => HttpResponse::Ok().body(serde_json::to_string_pretty("Success").unwrap()),
+        Err(e) => HttpResponse::BadRequest().body(e.to_string()),
+    }
+}

fplus-lib/Cargo.toml

@@ -34,20 +34,10 @@ fplus-database = { path = "../fplus-database", version = "1.8.4"}
 pem = "1.0"
 anyhow = "1.0"
 regex = "1.0"
-alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", features = [
-    "signers",
-    "providers",
-    "node-bindings",
-    "sol-types",
-    "json",
-    "network",
-    "rpc-types-eth",
-    "provider-http",
-    "dyn-abi",
-    "eip712",
-] }
 tempfile = "3.10.1"
 size = "0.5.0-preview2"
+alloy = { version = "0.3.2", features = ["full"] }
+fvm = "4.4.0"
 
 [dev-dependencies]
 actix-rt = "2.9.0"

fplus-lib/src/config.rs

@@ -35,6 +35,17 @@ pub fn default_env_vars() -> &'static HashMap<&'static str, &'static str> {
         m.insert("RPC_URL", "https://mainnet.optimism.io");
         m.insert("DMOB_API_URL", "https://api.datacapstats.io/public/api");
         m.insert("DMOB_API_KEY", "5c993a17-7b18-4ead-a8a8-89dad981d87e");
+        m.insert("DAYS_TO_NEXT_AUTOALLOCATION", "14");
+        m.insert("FILECOIN_RPC_URL", "http://127.0.0.1:8545");
+        m.insert(
+            "ALLOCATOR_CONTRACT_ADDRESS",
+            "0x640bD4be149f40714D95aBcD414338bc7CfF39a3",
+        );
+        m.insert(
+            "PRIVATE_KEY",
+            "257d553b55d5928c7ec48c2f7d1288931640166e2c1269e05492914accf7e966",
+        );
+        m.insert("AMOUNT_TO_AUTOALLOCATION", "68719476736"); // 68719476736 B == 64 GB
         m
     })
 }

fplus-lib/src/core/application/gitcoin_interaction.rs

@@ -15,6 +15,11 @@ use crate::config::get_env_var_or_default;
 use crate::error::LDNError;
 use anyhow::Result;
 
+pub trait ExpirableSolStruct: SolStruct {
+    fn get_expires_at(&self) -> String;
+    fn get_issued_at(&self) -> String;
+}
+
 sol! {
     #[allow(missing_docs)]
     function getScore(address user) view returns (uint256);
@@ -28,6 +33,34 @@ sol! {
         string issued_at;
         string expires_at;
     }
+
+    #[derive(Deserialize)]
+    struct KycAutoallocationApproval {
+        string message;
+        string client_fil_address;
+        string issued_at;
+        string expires_at;
+    }
+}
+
+impl ExpirableSolStruct for KycApproval {
+    fn get_expires_at(&self) -> String {
+        self.expires_at.clone()
+    }
+
+    fn get_issued_at(&self) -> String {
+        self.issued_at.clone()
+    }
+}
+
+impl ExpirableSolStruct for KycAutoallocationApproval {
+    fn get_expires_at(&self) -> String {
+        self.expires_at.clone()
+    }
+
+    fn get_issued_at(&self) -> String {
+        self.issued_at.clone()
+    }
 }
 
 pub async fn verify_on_gitcoin(address_from_signature: &Address) -> Result<f64, LDNError> {
@@ -73,8 +106,8 @@ fn calculate_score(response: Bytes) -> f64 {
     score as f64 / 10000.0
 }
 
-pub fn get_address_from_signature(
-    message: &KycApproval,
+pub fn get_address_from_signature<T: SolStruct>(
+    message: &T,
     signature: &str,
 ) -> Result<Address, LDNError> {
     let domain = eip712_domain! {

fplus-lib/src/core/autoallocator/metaallocator_interaction.rs

@@ -0,0 +1,69 @@
+use std::str::FromStr;
+
+use crate::config::get_env_var_or_default;
+use crate::error::LDNError;
+use alloy::{
+    network::{EthereumWallet, TransactionBuilder},
+    primitives::{Address, Bytes, U256},
+    providers::{Provider, ProviderBuilder},
+    rpc::types::eth::TransactionRequest,
+    signers::local::PrivateKeySigner,
+    sol,
+    sol_types::SolCall,
+};
+use anyhow::Result;
+use fvm::kernel::prelude::Address as FilecoinAddress;
+sol! {
+  #[allow(missing_docs)]
+  function addVerifiedClient(bytes calldata clientAddress, uint256 amount);
+}
+
+pub async fn add_verified_client(address: &String, amount: &u64) -> Result<(), LDNError> {
+    let private_key = get_env_var_or_default("PRIVATE_KEY");
+    let signer: PrivateKeySigner = private_key.parse().expect("Should parse private key");
+    let wallet = EthereumWallet::from(signer);
+    let rpc_url = get_env_var_or_default("FILECOIN_RPC_URL")
+        .parse()
+        .map_err(|e| LDNError::New(format!("Failed to pase string to URL /// {}", e)))?;
+    let provider = ProviderBuilder::new()
+        .with_recommended_fillers()
+        .wallet(wallet)
+        .on_http(rpc_url);
+    let fil_address_bytes = get_filecoin_address_from_string_to_bytes(address)?;
+    let amount = U256::try_from(amount.clone())
+        .map_err(|e| LDNError::New(format!("Failed to prase amount to U256 /// {}", e)))?;
+    let call = addVerifiedClientCall {
+        clientAddress: fil_address_bytes.into(),
+        amount,
+    }
+    .abi_encode();
+    let allocator_contract =
+        Address::parse_checksummed(get_env_var_or_default("ALLOCATOR_CONTRACT_ADDRESS"), None)
+            .map_err(|e| {
+                LDNError::New(format!(
+                    "Parse ALLOCATOR_CONTRACT_ADDRESS to Address failed: {}",
+                    e
+                ))
+            })?;
+    let input = Bytes::from(call);
+
+    let tx = TransactionRequest::default()
+        .with_to(allocator_contract)
+        .with_input(input)
+        .with_gas_limit(45_000_000);
+
+    provider
+        .send_transaction(tx)
+        .await
+        .map_err(|e| LDNError::New(format!("RPC error: {}", e)))?
+        .watch()
+        .await
+        .map_err(|e| LDNError::New(format!("Transaction failed: {}", e)))?;
+    Ok(())
+}
+
+fn get_filecoin_address_from_string_to_bytes(address: &str) -> Result<Vec<u8>, LDNError> {
+    let fil_address = FilecoinAddress::from_str(address)
+        .map_err(|e| LDNError::New(format!("Failed to prase address from string /// {}", e)))?;
+    Ok(fil_address.to_bytes())
+}

fplus-lib/src/core/autoallocator/mod.rs

@@ -1,14 +1,70 @@
-use self::file::Autoallocation;
+use crate::core::autoallocator::metaallocator_interaction::add_verified_client;
+use crate::core::get_env_var_or_default;
+use crate::core::verify_on_gitcoin;
+use crate::core::{LDNApplication, TriggerAutoallocationInfo};
+use crate::error::LDNError;
 use alloy::primitives::Address;
-use chrono::Utc;
+use chrono::{Duration, Utc};
+use fplus_database::database::applications::get_applications_by_client_id;
+use fplus_database::database::autoallocations as autoallocations_db;
 
-pub mod file;
+pub mod metaallocator_interaction;
 
-impl Autoallocation {
-    pub fn new(evm_wallet_address: Address) -> Self {
-        Self {
-            evm_wallet_address,
-            last_allocation: Utc::now().to_string(),
+pub async fn trigger_autoallocation(info: &TriggerAutoallocationInfo) -> Result<(), LDNError> {
+    let evm_address_from_signature =
+        LDNApplication::verify_kyc_data_and_get_eth_address(&info.message, &info.signature)?;
+    autoallocation_timeout_exceeded(&evm_address_from_signature).await?;
+    verify_on_gitcoin(&evm_address_from_signature).await?;
+    let fil_client_address = &info.message.client_fil_address;
+    let client_applications = get_applications_by_client_id(fil_client_address)
+        .await
+        .map_err(|e| LDNError::Load(format!("Get applications for client failed: {}", e)))?;
+    if client_applications.len() != 0 {
+        return Err(LDNError::Load(
+            "Cient already has an application".to_string(),
+        ));
+    }
+
+    let amount = get_env_var_or_default("AMOUNT_TO_AUTOALLOCATION")
+        .parse::<u64>()
+        .map_err(|e| {
+            LDNError::New(format!(
+                "Parse days to next allocation to i64 failed: {}",
+                e
+            ))
+        })?;
+    add_verified_client(&fil_client_address, &amount).await?;
+    autoallocations_db::create_or_update_autoallocation(evm_address_from_signature.clone())
+        .await
+        .map_err(|e| LDNError::New(format!("Create or update autoallocation failed: {}", e)))?;
+    Ok(())
+}
+
+async fn autoallocation_timeout_exceeded(
+    evm_address_from_signature: &Address,
+) -> Result<(), LDNError> {
+    let last_client_allocation =
+        autoallocations_db::get_last_client_autoallocation(evm_address_from_signature.clone())
+            .await
+            .map_err(|e| {
+                LDNError::Load(format!("Failed to get last client allocation /// {}", e))
+            })?;
+
+    if let Some(last_client_allocation) = last_client_allocation {
+        let days_to_next_autoallocation = get_env_var_or_default("DAYS_TO_NEXT_AUTOALLOCATION")
+            .parse::<i64>()
+            .map_err(|e| {
+                LDNError::New(format!(
+                    "Parse days to next allocation to i64 failed: {}",
+                    e
+                ))
+            })?;
+        if (last_client_allocation + Duration::days(days_to_next_autoallocation)) > Utc::now() {
+            return Err(LDNError::Load(format!(
+                "Last allocation was within {} days.",
+                days_to_next_autoallocation
+            )));
         }
     }
+    Ok(())
 }