feat(evm_icp_bridge): canister API

Author: zensh

src/evm_icp_bridge/src/api.rs

@@ -1,3 +1,8 @@
+use alloy::{
+    eips::Encodable2718,
+    primitives::{Address, Bytes},
+};
+
 use crate::{helper::msg_caller, store};
 
 #[ic_cdk::query]
@@ -6,12 +11,41 @@ fn info() -> Result<store::StateInfo, String> {
 }
 
 #[ic_cdk::query]
-fn evm_address() -> Result<String, String> {
+fn my_evm_address() -> Result<String, String> {
     let caller = msg_caller()?;
     let addr = store::state::evm_address(&caller);
     Ok(addr.to_string())
 }
 
+#[ic_cdk::query]
+async fn my_pending_logs() -> Result<Vec<store::BridgeLog>, String> {
+    let caller = msg_caller()?;
+    let rt = store::state::with(|s| {
+        s.pending
+            .iter()
+            .filter_map(|item| {
+                if item.user == caller {
+                    Some(item.clone())
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<store::BridgeLog>>()
+    });
+    Ok(rt)
+}
+
+#[ic_cdk::query]
+async fn my_finalized_logs(
+    prev: Option<u64>,
+    take: Option<u64>,
+) -> Result<Vec<store::BridgeLog>, String> {
+    let caller = msg_caller()?;
+    let take = take.unwrap_or(10).min(1000) as usize;
+    let rt = store::state::logs(caller, prev, take);
+    Ok(rt)
+}
+
 #[ic_cdk::update]
 async fn bridge(
     from_chain: String,
@@ -22,3 +56,37 @@ async fn bridge(
     let now_ms = ic_cdk::api::time() / 1_000_000;
     store::state::bridge(from_chain, to_chain, icp_amount, caller, now_ms).await
 }
+
+#[ic_cdk::update]
+async fn erc20_transfer_tx(chain: String, to: String, icp_amount: u128) -> Result<String, String> {
+    let to_addr = to
+        .parse::<Address>()
+        .map_err(|err| format!("invalid to address: {}", err))?;
+    let caller = msg_caller()?;
+    let now_ms = ic_cdk::api::time() / 1_000_000;
+    let (_, signed_tx) =
+        store::state::build_erc20_transfer_tx(&chain, &caller, &to_addr, icp_amount, now_ms)
+            .await?;
+    let data = signed_tx.encoded_2718();
+    Ok(Bytes::from(data).to_string())
+}
+
+#[ic_cdk::update]
+async fn erc20_transfer(chain: String, to: String, icp_amount: u128) -> Result<String, String> {
+    let to_addr = to
+        .parse::<Address>()
+        .map_err(|err| format!("invalid to address: {}", err))?;
+    let caller = msg_caller()?;
+    let now_ms = ic_cdk::api::time() / 1_000_000;
+    let (cli, signed_tx) =
+        store::state::build_erc20_transfer_tx(&chain, &caller, &to_addr, icp_amount, now_ms)
+            .await?;
+    let tx_hash = signed_tx.hash().to_string();
+
+    let data = signed_tx.encoded_2718();
+    let _ = cli
+        .send_raw_transaction(now_ms, Bytes::from(data).to_string())
+        .await?;
+
+    Ok(tx_hash)
+}

src/evm_icp_bridge/src/evm.rs

@@ -78,16 +78,16 @@ impl EvmClient {
         hex_to_u64(&res)
     }
 
-    pub async fn get_balance(&self, now_ms: u64, address: &Address) -> Result<u128, String> {
-        let res: String = self
-            .call(
-                format!("eth_getBalance-{}", now_ms),
-                "eth_getBalance",
-                &[address.to_string().into(), "finalized".into()],
-            )
-            .await?;
-        hex_to_u128(&res)
-    }
+    // pub async fn get_balance(&self, now_ms: u64, address: &Address) -> Result<u128, String> {
+    //     let res: String = self
+    //         .call(
+    //             format!("eth_getBalance-{}", now_ms),
+    //             "eth_getBalance",
+    //             &[address.to_string().into(), "finalized".into()],
+    //         )
+    //         .await?;
+    //     hex_to_u128(&res)
+    // }
 
     pub async fn get_transaction_receipt(
         &self,
@@ -137,12 +137,12 @@ impl EvmClient {
         <Vec<u8>>::from_hex(res).map_err(|err| err.to_string())
     }
 
-    pub async fn erc20_name(&self, now_ms: u64, contract: &Address) -> Result<String, String> {
-        let res = self
-            .call_contract(now_ms, contract, "0x06fdde03".to_string())
-            .await?;
-        decode_abi_string(&res)
-    }
+    // pub async fn erc20_name(&self, now_ms: u64, contract: &Address) -> Result<String, String> {
+    //     let res = self
+    //         .call_contract(now_ms, contract, "0x06fdde03".to_string())
+    //         .await?;
+    //     decode_abi_string(&res)
+    // }
 
     pub async fn erc20_symbol(&self, now_ms: u64, contract: &Address) -> Result<String, String> {
         let res = self
@@ -325,9 +325,9 @@ 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())
-}
+// 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())
+// }