feat(evm_icp_bridge): bridge API

Author: zensh

Cargo.lock

@@ -28,8 +28,10 @@ ic-dummy-getrandom-for-wasm = { workspace = true }
 ic_auth_types = { workspace = true }
 ic_cose_types = { workspace = true }
 ic-secp256k1 = { workspace = true }
+icrc-ledger-types = { workspace = true }
 lazy_static = { workspace = true }
 once_cell = { workspace = true }
+num-traits = { workspace = true }
 url = { workspace = true }
 serde = { workspace = true }
 serde_bytes = { workspace = true }

src/evm_icp_bridge/Cargo.toml

@@ -1,10 +1,7 @@
-use candid::Principal;
-use ic_cose_types::ANONYMOUS;
-
-use crate::{store, store::StateInfo};
+use crate::{helper::msg_caller, store};
 
 #[ic_cdk::query]
-fn info() -> Result<StateInfo, String> {
+fn info() -> Result<store::StateInfo, String> {
     Ok(store::state::info())
 }
 
@@ -15,11 +12,13 @@ fn evm_address() -> Result<String, String> {
     Ok(addr.to_string())
 }
 
-fn msg_caller() -> Result<Principal, String> {
-    let caller = ic_cdk::api::msg_caller();
-    if caller == ANONYMOUS {
-        Err("anonymous user is not allowed".to_string())
-    } else {
-        Ok(caller)
-    }
+#[ic_cdk::update]
+async fn bridge(
+    from_chain: String,
+    to_chain: String,
+    icp_amount: u128,
+) -> Result<store::BridgeTx, String> {
+    let caller = msg_caller()?;
+    let now_ms = ic_cdk::api::time() / 1_000_000;
+    store::state::bridge(from_chain, to_chain, icp_amount, caller, now_ms).await
 }

src/evm_icp_bridge/src/api.rs

@@ -9,15 +9,14 @@ async fn admin_add_evm_contract(
     chain_name: String,
     chain_id: u64,
     address: String,
-    decimals: u8,
 ) -> Result<(), String> {
-    let address = check_admin_add_evm_contract(&chain_name, chain_id, &address, decimals)?;
+    let address = check_admin_add_evm_contract(&chain_name, chain_id, &address)?;
     let cli = store::state::evm_client(&chain_name);
     let now_ms = ic_cdk::api::time() / 1_000_000;
-    let (cid, gas_price, block_number, symbol, dec) = futures::future::try_join5(
+    let (cid, gas_price, block_number, symbol, decimals) = futures::future::try_join5(
         cli.chain_id(now_ms),
         cli.gas_price(now_ms),
-        cli.finalized_block_number(now_ms),
+        cli.block_number(now_ms),
         cli.erc20_symbol(now_ms, &address),
         cli.erc20_decimals(now_ms, &address),
     )
@@ -29,12 +28,6 @@ async fn admin_add_evm_contract(
             cid, chain_id
         ));
     }
-    if decimals != dec {
-        return Err(format!(
-            "decimals mismatch, got {}, expected {}",
-            dec, decimals
-        ));
-    }
 
     store::state::with_mut(|s| {
         if s.token_symbol != symbol {
@@ -46,8 +39,13 @@ async fn admin_add_evm_contract(
 
         s.evm_token_contracts
             .insert(chain_name.clone(), (address, decimals, chain_id));
-        s.evm_finalized_block
-            .insert(chain_name, (block_number, gas_price));
+        s.evm_finalized_block.insert(
+            chain_name,
+            (
+                block_number.saturating_sub(cli.max_confirmations),
+                gas_price,
+            ),
+        );
         Ok(())
     })
 }
@@ -57,17 +55,15 @@ fn validate_admin_add_evm_contract(
     chain_name: String,
     chain_id: u64,
     address: String,
-    decimals: u8,
 ) -> Result<String, String> {
-    check_admin_add_evm_contract(&chain_name, chain_id, &address, decimals)?;
-    pretty_format(&(chain_name, chain_id, address, decimals))
+    check_admin_add_evm_contract(&chain_name, chain_id, &address)?;
+    pretty_format(&(chain_name, chain_id, address))
 }
 
 fn check_admin_add_evm_contract(
     chain_name: &str,
     chain_id: u64,
     address: &str,
-    decimals: u8,
 ) -> Result<Address, String> {
     if chain_name.trim().to_ascii_uppercase() != chain_name
         || chain_name.is_empty()
@@ -80,13 +76,6 @@ fn check_admin_add_evm_contract(
         .map_err(|err| format!("invalid address: {err:?}"))?;
 
     store::state::with(|s| {
-        if decimals < s.token_decimals {
-            return Err(format!(
-                "decimals must be >= {}, got {}",
-                s.token_decimals, decimals
-            ));
-        }
-
         if s.evm_token_contracts.contains_key(chain_name) {
             return Err("chain_id already exists".to_string());
         }
@@ -103,23 +92,32 @@ fn check_admin_add_evm_contract(
 }
 
 #[ic_cdk::update(guard = "is_controller")]
-fn admin_set_evm_providers(chain_name: String, providers: Vec<String>) -> Result<(), String> {
+fn admin_set_evm_providers(
+    chain_name: String,
+    max_confirmations: u64,
+    providers: Vec<String>,
+) -> Result<(), String> {
     for url in &providers {
         let v = Url::parse(url).map_err(|err| format!("invalid url {url}, error: {err}"))?;
         if v.scheme() != "https" {
             return Err(format!("url scheme must be https, got: {url}"));
         }
     }
+    if max_confirmations < 2 {
+        return Err("max_confirmations must be at least 2".to_string());
+    }
 
     store::state::with_mut(|s| {
-        s.evm_providers.insert(chain_name, providers);
+        s.evm_providers
+            .insert(chain_name, (max_confirmations, providers));
         Ok(())
     })
 }
 
 #[ic_cdk::update]
 fn validate_admin_set_evm_providers(
-    chain_name: u64,
+    chain_name: String,
+    max_confirmations: u64,
     providers: Vec<String>,
 ) -> Result<String, String> {
     for url in &providers {
@@ -128,7 +126,15 @@ fn validate_admin_set_evm_providers(
             return Err(format!("url scheme must be https, got: {url}"));
         }
     }
-    pretty_format(&(chain_name, providers))
+    if max_confirmations < 2 {
+        return Err("max_confirmations must be at least 2".to_string());
+    }
+    pretty_format(&(chain_name, max_confirmations, providers))
+}
+
+#[ic_cdk::update(guard = "is_controller")]
+async fn admin_update_evm_gas_price() -> Result<(), String> {
+    unimplemented!()
 }
 
 fn is_controller() -> Result<(), String> {

src/evm_icp_bridge/src/api_admin.rs

@@ -18,6 +18,7 @@ pub static APP_AGENT: &str = concat!(
 
 pub struct EvmClient {
     pub providers: Vec<String>,
+    pub max_confirmations: u64,
     pub api_token: Option<String>,
 }
 
@@ -35,6 +36,7 @@ pub struct RPCResponse<T> {
     error: Option<Value>,
 }
 
+// https://www.quicknode.com/docs/ethereum
 impl EvmClient {
     pub async fn chain_id(&self, now_ms: u64) -> Result<u64, String> {
         let res: String = self
@@ -50,16 +52,15 @@ impl EvmClient {
         hex_to_u128(&res)
     }
 
-    pub async fn finalized_block_number(&self, now_ms: u64) -> Result<u64, String> {
+    pub async fn block_number(&self, now_ms: u64) -> Result<u64, String> {
         let res: String = self
             .call(
                 format!("eth_blockNumber-{}", now_ms),
                 "eth_blockNumber",
                 &[],
             )
             .await?;
-        let num = hex_to_u64(&res)?;
-        Ok(num.saturating_sub(42)) // consider a block finalized if it is 42 blocks deep
+        hex_to_u64(&res)
     }
 
     pub async fn get_transaction_count(
@@ -92,7 +93,7 @@ impl EvmClient {
         &self,
         now_ms: u64,
         tx_hash: &TxHash,
-    ) -> Result<TransactionReceipt, String> {
+    ) -> Result<Option<TransactionReceipt>, String> {
         self.call(
             format!("eth_getTransactionReceipt-{}", now_ms),
             "eth_getTransactionReceipt",
@@ -103,11 +104,11 @@ impl EvmClient {
 
     pub async fn send_raw_transaction(
         &self,
-        idempotency_key: String,
+        now_ms: u64,
         signed_tx: String,
-    ) -> Result<TxHash, String> {
+    ) -> Result<Value, String> {
         self.call(
-            idempotency_key,
+            format!("eth_sendRawTransaction-{}", now_ms),
             "eth_sendRawTransaction",
             &[signed_tx.into()],
         )
@@ -323,3 +324,10 @@ fn decode_abi_uint(bytes: &[u8]) -> Result<U256, String> {
     }
     Ok(U256::from_be_slice(bytes))
 }
+
+fn decode_abi_address(bytes: &[u8]) -> Result<Address, String> {
+    if bytes.len() != 32 {
+        return Err("abi address result must be 32 bytes".to_string());
+    }
+    Address::try_from(&bytes[12..32]).map_err(|err| err.to_string())
+}

src/evm_icp_bridge/src/evm.rs

@@ -0,0 +1,56 @@
+use candid::{utils::ArgumentEncoder, Principal};
+
+const ANONYMOUS: Principal = Principal::anonymous();
+pub fn msg_caller() -> Result<Principal, String> {
+    let caller = ic_cdk::api::msg_caller();
+    if caller == ANONYMOUS {
+        Err("anonymous user is not allowed".to_string())
+    } else {
+        Ok(caller)
+    }
+}
+
+pub fn convert_amount(
+    src_amount: u128,
+    src_decimals: u8,
+    target_decimals: u8,
+) -> Result<u128, String> {
+    if src_decimals == target_decimals {
+        Ok(src_amount)
+    } else if src_decimals < target_decimals {
+        let factor = 10u128
+            .checked_pow((target_decimals - src_decimals) as u32)
+            .ok_or_else(|| "exponent too large".to_string())?;
+        src_amount
+            .checked_mul(factor)
+            .ok_or_else(|| "multiplication overflow".to_string())
+    } else {
+        let factor = 10u128
+            .checked_pow((src_decimals - target_decimals) as u32)
+            .ok_or_else(|| "exponent too large".to_string())?;
+        Ok(src_amount / factor)
+    }
+}
+
+pub async fn call<In, Out>(
+    id: Principal,
+    method: &str,
+    args: In,
+    cycles: u128,
+) -> Result<Out, String>
+where
+    In: ArgumentEncoder + Send,
+    Out: candid::CandidType + for<'a> candid::Deserialize<'a>,
+{
+    let res = ic_cdk::call::Call::bounded_wait(id, method)
+        .with_args(&args)
+        .with_cycles(cycles)
+        .await
+        .map_err(|err| format!("failed to call {} on {:?}, error: {:?}", method, &id, err))?;
+    res.candid().map_err(|err| {
+        format!(
+            "failed to decode response from {} on {:?}, error: {:?}",
+            method, &id, err
+        )
+    })
+}

src/evm_icp_bridge/src/helper.rs

@@ -4,9 +4,9 @@ mod api_http;
 mod api_init;
 mod ecdsa;
 mod evm;
+mod helper;
 mod store;
 
 use api_init::CanisterArgs;
-use store::StateInfo;
 
 ic_cdk::export_candid!();