adds testnet support for genesis block (oreoslabs#22)

Author: jowparks

.DS_Store

@@ -1,5 +1,5 @@
 use axum::{response::IntoResponse, Json};
-use constants::{IRON_NATIVE_ASSET, MAINNET_GENESIS_HASH, MAINNET_GENESIS_SEQUENCE};
+use constants::IRON_NATIVE_ASSET;
 use serde::{Deserialize, Serialize};
 use ureq::json;
 
@@ -28,15 +28,6 @@ pub struct BlockInfo {
     pub sequence: u64,
 }
 
-impl Default for BlockInfo {
-    fn default() -> Self {
-        Self {
-            hash: MAINNET_GENESIS_HASH.to_string(),
-            sequence: MAINNET_GENESIS_SEQUENCE as u64,
-        }
-    }
-}
-
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcImportAccountRequest {
@@ -333,6 +324,7 @@ pub struct BlockIdentifier {
 #[serde(rename_all = "camelCase")]
 pub struct RpcGetLatestBlockResponse {
     pub current_block_identifier: BlockIdentifier,
+    pub genesis_block_identifier: BlockIdentifier,
 }
 
 #[derive(Debug, Deserialize, Serialize)]

crates/networking/src/rpc_abi.rs

@@ -1,4 +1,4 @@
-use constants::{MAINNET_GENESIS_HASH, MAINNET_GENESIS_SEQUENCE};
+use constants::MAINNET_GENESIS_SEQUENCE;
 use db_handler::{address_to_name, Account};
 use oreo_errors::OreoError;
 use serde::{Deserialize, Serialize};
@@ -23,7 +23,7 @@ pub struct ImportAccountResponse {
 }
 
 impl ImportAccountRequest {
-    pub fn to_account(&self) -> Account {
+    pub fn to_account(&self, genesis_hash: String) -> Account {
         let (create_head, create_hash) = match &self.created_at {
             Some(creat) => (Some(creat.sequence as i64), Some(creat.hash.clone())),
             None => (None, None),
@@ -34,7 +34,7 @@ impl ImportAccountRequest {
             create_head,
             create_hash: create_hash.clone(),
             head: create_head.unwrap_or(MAINNET_GENESIS_SEQUENCE),
-            hash: create_hash.unwrap_or(MAINNET_GENESIS_HASH.to_string()),
+            hash: create_hash.unwrap_or(genesis_hash),
             in_vk: self.incoming_view_key.clone(),
             out_vk: self.outgoing_view_key.clone(),
             vk: self.view_key.clone(),

crates/networking/src/web_abi.rs

@@ -5,7 +5,7 @@ use axum::{
     response::IntoResponse,
     Json,
 };
-use constants::{ACCOUNT_VERSION, MAINNET_GENESIS_HASH, MAINNET_GENESIS_SEQUENCE};
+use constants::{ACCOUNT_VERSION, MAINNET_GENESIS_SEQUENCE};
 use db_handler::DBHandler;
 use networking::{
     decryption_message::{DecryptionMessage, ScanRequest, ScanResponse, SuccessResponse},
@@ -30,7 +30,7 @@ pub async fn import_account_handler<T: DBHandler>(
 ) -> impl IntoResponse {
     let account_name = shared
         .db_handler
-        .save_account(import.clone().to_account(), 0)
+        .save_account(import.clone().to_account(shared.genesis_hash.clone()), 0)
         .await;
     if let Err(e) = account_name {
         return e.into_response();
@@ -68,7 +68,10 @@ pub async fn import_account_handler<T: DBHandler>(
                     account: account_name.clone(),
                 })
                 .map(|x| {
-                    let head = x.data.account.head.unwrap_or(BlockInfo::default());
+                    let head = x.data.account.head.unwrap_or(BlockInfo {
+                        hash: shared.genesis_hash.clone(),
+                        sequence: MAINNET_GENESIS_SEQUENCE as u64,
+                    });
                     if latest_height - head.sequence > 1000 {
                         let _ = shared.rpc_handler.set_scanning(RpcSetScanningRequest {
                             account: account_name.clone(),
@@ -157,7 +160,7 @@ pub async fn account_status_handler<T: DBHandler>(
                 Some(_) => {}
                 None => {
                     result.data.account.head = Some(BlockInfo {
-                        hash: MAINNET_GENESIS_HASH.to_string(),
+                        hash: shared.genesis_hash.clone(),
                         sequence: MAINNET_GENESIS_SEQUENCE as u64,
                     })
                 }
@@ -197,7 +200,10 @@ pub async fn rescan_account_handler<T: DBHandler>(
             account: account.name.clone(),
         })
     {
-        let head = status.data.account.head.unwrap_or(BlockInfo::default());
+        let head = BlockInfo {
+            hash: account.create_hash.unwrap_or(shared.genesis_hash.clone()),
+            sequence: account.create_head.unwrap_or(MAINNET_GENESIS_SEQUENCE) as u64,
+        };
         let scan_request = ScanRequest {
             address: account.address.clone(),
             in_vk: account.in_vk.clone(),

crates/server/src/handlers.rs

@@ -35,18 +35,20 @@ pub struct SharedState<T: DBHandler> {
     pub rpc_handler: RpcHandler,
     pub scan_handler: ServerHandler,
     pub secp: SecpKey,
+    pub genesis_hash: String,
 }
 
 impl<T> SharedState<T>
 where
     T: DBHandler,
 {
-    pub fn new(db_handler: T, endpoint: &str, scan: &str, secp: SecpKey) -> Self {
+    pub fn new(db_handler: T, endpoint: &str, scan: &str, secp: SecpKey, genesis_hash: String) -> Self {
         Self {
             db_handler: db_handler,
             rpc_handler: RpcHandler::new(endpoint.into()),
             scan_handler: ServerHandler::new(scan.into()),
             secp,
+            genesis_hash,
         }
     }
 }
@@ -86,6 +88,13 @@ pub async fn run_server(
     sk_u8: [u8; 32],
     pk_u8: [u8; 33],
 ) -> Result<()> {
+    let genesis_hash;
+    {
+        let temp_handler: RpcHandler = RpcHandler::new(rpc_server.clone().into());
+        let latest_block_response = temp_handler.get_latest_block()?.data;
+        genesis_hash = latest_block_response.genesis_block_identifier.hash;
+    }
+    info!("Genesis hash: {}", genesis_hash);
     let shared_resource = Arc::new(SharedState::new(
         db_handler,
         &rpc_server,
@@ -94,6 +103,7 @@ pub async fn run_server(
             sk: sk_u8,
             pk: pk_u8,
         },
+        genesis_hash,
     ));
     let auth_middleware = from_fn_with_state(shared_resource.clone(), auth);