Generated candid file for utils

Author: stopak

candid/utils.did

@@ -0,0 +1,64 @@
+type AccessList = record { storage_keys : vec vec nat8; address : vec nat8 };
+type Item = variant {
+  Num : nat64;
+  Raw : vec nat8;
+  Empty;
+  List : List;
+  Text : text;
+};
+type List = record { values : vec Item };
+type Result = variant { Ok : vec nat8; Err : text };
+type Result_1 = variant { Ok : Transaction; Err : text };
+type Result_2 = variant { Ok : List; Err : text };
+type Signature = record {
+  r : vec nat8;
+  s : vec nat8;
+  v : nat64;
+  from : opt vec nat8;
+  hash : vec nat8;
+};
+type Transaction = variant {
+  EIP1559 : Transaction1559;
+  EIP2930 : Transaction2930;
+  Legacy : TransactionLegacy;
+};
+type Transaction1559 = record {
+  to : vec nat8;
+  value : nat64;
+  max_priority_fee_per_gas : nat64;
+  data : vec nat8;
+  sign : opt Signature;
+  max_fee_per_gas : nat64;
+  chain_id : nat64;
+  nonce : nat64;
+  gas_limit : nat64;
+  access_list : vec AccessList;
+};
+type Transaction2930 = record {
+  to : vec nat8;
+  value : nat64;
+  data : vec nat8;
+  sign : opt Signature;
+  chain_id : nat64;
+  nonce : nat64;
+  gas_limit : nat64;
+  access_list : vec AccessList;
+  gas_price : nat64;
+};
+type TransactionLegacy = record {
+  to : vec nat8;
+  value : nat64;
+  data : vec nat8;
+  sign : opt Signature;
+  chain_id : nat64;
+  nonce : nat64;
+  gas_limit : nat64;
+  gas_price : nat64;
+};
+service : {
+  create_transaction : (Transaction) -> (Result) query;
+  keccak256 : (vec nat8) -> (vec nat8) query;
+  parse_transaction : (vec nat8) -> (Result_1) query;
+  rlp_decode : (vec nat8) -> (Result_2) query;
+  rlp_encode : (List) -> (Result) query;
+}

src/evm_utils/src/hash.rs

@@ -1,8 +1,10 @@
 use crate::{types::num::U256, utils};
+use candid::candid_method;
 use ic_cdk::query;
 
 /// Returns hash of given data using keccak256
 #[query]
+#[candid_method(query)]
 fn keccak256(data: Vec<u8>) -> U256 {
     utils::keccak256(&[&data[..]])
 }

src/evm_utils/src/rlp.rs

@@ -1,15 +1,18 @@
 use crate::types::rlp::List;
 
+use candid::candid_method;
 use ic_cdk_macros::query;
 
 #[query]
+#[candid_method(query)]
 fn rlp_encode(data: List) -> Result<Vec<u8>, String> {
     let raw = rlp::encode(&data);
 
     Ok(raw.to_vec())
 }
 
 #[query]
+#[candid_method(query)]
 fn rlp_decode(raw: Vec<u8>) -> Result<List, String> {
     let item: List = rlp::decode(&raw).map_err(|x| format!("{x}"))?;
 

src/evm_utils/src/transaction.rs

@@ -1,9 +1,13 @@
+use candid::{candid_method, export_service};
 use ic_cdk_macros::query;
 
+use crate::types::num::U256;
+use crate::types::rlp::List;
 use crate::types::transaction::Transaction;
 
 /// Encodes transaction in rlp, ready to be signed
 #[query]
+#[candid_method(query)]
 fn create_transaction(data: Transaction) -> Result<Vec<u8>, String> {
     let raw = data.encode(true);
 
@@ -12,9 +16,32 @@ fn create_transaction(data: Transaction) -> Result<Vec<u8>, String> {
 
 /// Parses raw transaction, supports Legacy, EIP1559, EIP2930
 #[query]
+#[candid_method(query)]
 fn parse_transaction(data: Vec<u8>) -> Result<Transaction, String> {
     let item =
         Transaction::decode(&data).map_err(|x| format!("Error while decoding transaction {x}"))?;
 
     Ok(item)
 }
+
+#[query(name = "__get_candid_interface_tmp_hack")]
+fn export_candid() -> String {
+    export_service!();
+    __export_service()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn save_candid() {
+        use std::env;
+        use std::fs::write;
+        use std::path::PathBuf;
+
+        let dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+        let dir = dir.parent().unwrap().parent().unwrap().join("candid");
+        write(dir.join("utils.did"), export_candid()).expect("Write failed.");
+    }
+}

src/evm_utils/src/tree.rs

@@ -1,7 +1,9 @@
+use candid::candid_method;
 use hasher::HasherKeccak;
 use ic_cdk::query;
 
 #[query]
+#[candid_method(query)]
 fn verify_proof(
     root: Vec<u8>,
     key: Vec<u8>,

src/evm_utils/src/utils.rs

@@ -1,5 +1,6 @@
 use std::error::Error;
 
+use candid::candid_method;
 use ic_cdk::query;
 use secp256k1::ecdsa::RecoverableSignature;
 use secp256k1::ecdsa::RecoveryId;
@@ -44,16 +45,12 @@ pub fn _recover_public_key(
     let hash = keccak256(&[msg]);
     let msg = Message::from_slice(&hash.0)?;
 
-    // println!("r {}", hex::encode(r));
-    // println!("s {}", hex::encode(s));
-    // println!("v {}", v);
-    // println!("msg {}", msg);
-
     let pub_k = rec_sig.recover(&msg)?;
     Ok(pub_k)
 }
 
 #[query]
+#[candid_method(query)]
 fn recover_public_key(signature: Vec<u8>, msg: Vec<u8>) -> Result<Vec<u8>, String> {
     if signature.len() != 65 {
         Err(String::from("Invalid signature length!, should be 65"))
@@ -71,6 +68,7 @@ fn recover_public_key(signature: Vec<u8>, msg: Vec<u8>) -> Result<Vec<u8>, Strin
 }
 
 #[query]
+#[candid_method(query)]
 fn pub_to_address(public_key: Vec<u8>) -> Result<Vec<u8>, String> {
     let pub_k = PublicKey::from_slice(&public_key[..])
         .map_err(|x| format!("Error while reading public key {x}"))?;
@@ -81,6 +79,7 @@ fn pub_to_address(public_key: Vec<u8>) -> Result<Vec<u8>, String> {
 }
 
 #[query]
+#[candid_method(query)]
 fn is_valid_public(public_key: Vec<u8>) -> Result<(), String> {
     PublicKey::from_slice(&public_key[..])
         .map_err(|x| format!("Error while reading public key {x}"))?;
@@ -89,6 +88,7 @@ fn is_valid_public(public_key: Vec<u8>) -> Result<(), String> {
 }
 
 #[query]
+#[candid_method(query)]
 fn is_valid_signature(signature: Vec<u8>) -> Result<(), String> {
     if signature.len() != 65 {
         Err(String::from("Invalid signature length!, should be 65"))