minter client api update

Author: F3kilo

src/minter-client/src/lib.rs

@@ -1,10 +1,9 @@
-use candid::{Nat, Principal};
+use candid::Principal;
 use did::build::BuildData;
 use did::H160;
 use ic_canister_client::{CanisterClient, CanisterClientResult};
 use minter_did::error::Result as McResult;
 use minter_did::id256::Id256;
-use minter_did::init::OperationPricing;
 use minter_did::order::SignedMintOrder;
 use minter_did::reason::Icrc2Burn;
 
@@ -84,40 +83,12 @@ impl<C: CanisterClient> MinterCanisterClient<C> {
             .await
     }
 
-    /// Returns operation points number of the user.
-    pub async fn get_user_operation_points(
-        &self,
-        user: Option<Principal>,
-    ) -> CanisterClientResult<u32> {
-        self.client
-            .query("get_user_operation_points", (user,))
-            .await
-    }
-
-    /// Returns operations pricing.
-    /// This method is available for canister owner only.
-    pub async fn set_operation_pricing(
-        &mut self,
-        pricing: OperationPricing,
-    ) -> CanisterClientResult<McResult<()>> {
-        self.client
-            .update("set_operation_pricing", (pricing,))
-            .await
-    }
-
-    /// Returns operation pricing.
-    pub async fn get_operation_pricing(&self) -> CanisterClientResult<OperationPricing> {
-        self.client.query("get_operation_pricing", ()).await
-    }
-
     /// Creates ERC-20 mint order for ICRC-2 tokens burning.
-    pub async fn create_erc_20_mint_order(
+    pub async fn burn_icrc2(
         &self,
         reason: Icrc2Burn,
     ) -> CanisterClientResult<McResult<SignedMintOrder>> {
-        self.client
-            .update("create_erc_20_mint_order", (reason,))
-            .await
+        self.client.update("burn_icrc2", (reason,)).await
     }
 
     /// Returns `(nonce, mint_order)` pairs for the given sender id.
@@ -131,39 +102,15 @@ impl<C: CanisterClient> MinterCanisterClient<C> {
             .await
     }
 
-    /// Approves ICRC-2 token transfer from minter canister to recepient.
-    /// Returns approved amount.
-    ///
-    /// # Arguments
-    /// - `user` is an address of wallet which has been used for Wrapped token burning.
-    /// - `operation_id` is an ID retuned by `BFTBridge::burn()` operation.
-    pub async fn start_icrc2_mint(
-        &self,
-        user: &H160,
-        operation_id: u32,
-    ) -> CanisterClientResult<McResult<Nat>> {
-        self.client
-            .update("start_icrc2_mint", (user, operation_id))
-            .await
-    }
-
-    /// Transfers ICRC-2 tokens from minter canister to recepient.
-    ///
-    /// Before it can be used, ICRC-2 token must be approved by `start_icrc2_mint` which approves the transfer.
-    /// After the approval, user should finalize Wrapped token burning, using `BFTBridge::finish_burn()`.
-    pub async fn finish_icrc2_mint(
+    /// Returns mint order for the given parameters.
+    pub async fn get_mint_order(
         &self,
+        sender: Id256,
+        src_token: Id256,
         operation_id: u32,
-        address: &H160,
-        icrc2_token: Principal,
-        recipient: Principal,
-        amount: Nat,
-    ) -> CanisterClientResult<McResult<Nat>> {
+    ) -> CanisterClientResult<Option<SignedMintOrder>> {
         self.client
-            .update(
-                "finish_icrc2_mint",
-                (operation_id, address, icrc2_token, recipient, amount),
-            )
+            .query("get_mint_order", (sender, src_token, operation_id))
             .await
     }
 

src/minter-did/src/init.rs

@@ -1,11 +1,6 @@
-use std::borrow::Cow;
-use std::mem::size_of;
-
 use candid::{CandidType, Principal};
-use did::codec::ByteChunkReader;
 use eth_signer::sign_strategy::SigningStrategy;
 use ic_log::LogSettings;
-use ic_stable_structures::{Bound, Storable};
 use serde::Deserialize;
 
 /// Minter canister initialization data.
@@ -27,88 +22,3 @@ pub struct InitData {
     #[serde(default)]
     pub log_settings: Option<LogSettings>,
 }
-
-#[derive(Debug, PartialEq, Eq, Copy, Clone, CandidType, Deserialize, serde::Serialize)]
-pub struct OperationPricing {
-    pub evmc_notification: u32,
-    pub evm_registration: u32,
-    pub icrc_mint_approval: u32,
-    pub icrc_transfer: u32,
-    pub erc20_mint: u32,
-    pub endpoint_query: u32,
-}
-
-impl Default for OperationPricing {
-    fn default() -> Self {
-        Self {
-            evmc_notification: 8,
-            evm_registration: 1,
-            icrc_mint_approval: 1,
-            icrc_transfer: 1,
-            erc20_mint: 1,
-            endpoint_query: 1,
-        }
-    }
-}
-
-impl OperationPricing {
-    pub const STORABLE_BYTE_SIZE: usize = size_of::<u32>() * 6;
-}
-
-impl Storable for OperationPricing {
-    fn to_bytes(&self) -> Cow<'_, [u8]> {
-        let mut buf = Vec::with_capacity(Self::STORABLE_BYTE_SIZE);
-        buf.extend_from_slice(&self.evmc_notification.to_be_bytes());
-        buf.extend_from_slice(&self.evm_registration.to_be_bytes());
-        buf.extend_from_slice(&self.icrc_mint_approval.to_be_bytes());
-        buf.extend_from_slice(&self.icrc_transfer.to_be_bytes());
-        buf.extend_from_slice(&self.erc20_mint.to_be_bytes());
-        buf.extend_from_slice(&self.endpoint_query.to_be_bytes());
-        buf.into()
-    }
-
-    fn from_bytes(bytes: Cow<'_, [u8]>) -> Self {
-        let mut reader = ByteChunkReader::new(&bytes);
-        let evmc_notification = u32::from_be_bytes(*reader.read_slice());
-        let evm_registration = u32::from_be_bytes(*reader.read_slice());
-        let icrc_mint_approval = u32::from_be_bytes(*reader.read_slice());
-        let icrc_transfer = u32::from_be_bytes(*reader.read_slice());
-        let erc20_mint = u32::from_be_bytes(*reader.read_slice());
-        let endpoint_query = u32::from_be_bytes(*reader.read_slice());
-        Self {
-            evmc_notification,
-            evm_registration,
-            icrc_mint_approval,
-            icrc_transfer,
-            erc20_mint,
-            endpoint_query,
-        }
-    }
-
-    const BOUND: Bound = Bound::Bounded {
-        max_size: Self::STORABLE_BYTE_SIZE as _,
-        is_fixed_size: true,
-    };
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn operation_pricing_storable_roundtrip() {
-        let operation_pricing = OperationPricing {
-            evmc_notification: rand::random(),
-            evm_registration: rand::random(),
-            icrc_mint_approval: rand::random(),
-            icrc_transfer: rand::random(),
-            erc20_mint: rand::random(),
-            endpoint_query: rand::random(),
-        };
-
-        let bytes = operation_pricing.to_bytes();
-        let decoded = OperationPricing::from_bytes(bytes);
-
-        assert_eq!(operation_pricing, decoded);
-    }
-}