feat: imt_mint/imt_burn intents

core/src/engine/state/cached.rs

@@ -374,6 +374,26 @@ where
 
         Ok(())
     }
+
+    #[inline]
+    fn mt_mint(
+        &mut self,
+        owner_id: AccountId,
+        tokens: Amounts,
+        _memo: Option<String>,
+    ) -> Result<()> {
+        self.internal_add_balance(owner_id, tokens)
+    }
+
+    #[inline]
+    fn mt_burn(
+        &mut self,
+        owner_id: &AccountIdRef,
+        tokens: Amounts,
+        _memo: Option<String>,
+    ) -> Result<()> {
+        self.internal_sub_balance(owner_id, tokens)
+    }
 }
 
 #[derive(Debug, Default)]

core/src/engine/state/deltas.rs

@@ -213,6 +213,26 @@ where
     fn auth_call(&mut self, signer_id: &AccountIdRef, auth_call: AuthCall) -> Result<()> {
         self.state.auth_call(signer_id, auth_call)
     }
+
+    #[inline]
+    fn mt_mint(
+        &mut self,
+        owner_id: AccountId,
+        tokens: Amounts,
+        memo: Option<String>,
+    ) -> Result<()> {
+        self.state.mt_mint(owner_id, tokens, memo)
+    }
+
+    #[inline]
+    fn mt_burn(
+        &mut self,
+        owner_id: &AccountIdRef,
+        tokens: Amounts,
+        memo: Option<String>,
+    ) -> Result<()> {
+        self.state.mt_burn(owner_id, tokens, memo)
+    }
 }
 
 /// Accumulates internal deposits and withdrawals on different tokens

core/src/engine/state/mod.rs

@@ -127,4 +127,14 @@ pub trait State: StateView {
     fn set_auth_by_predecessor_id(&mut self, account_id: AccountId, enable: bool) -> Result<bool>;
 
     fn auth_call(&mut self, signer_id: &AccountIdRef, auth_call: AuthCall) -> Result<()>;
+
+    fn mt_mint(&mut self, owner_id: AccountId, tokens: Amounts, memo: Option<String>)
+    -> Result<()>;
+
+    fn mt_burn(
+        &mut self,
+        owner_id: &AccountIdRef,
+        tokens: Amounts,
+        memo: Option<String>,
+    ) -> Result<()>;
 }

core/src/events.rs

@@ -10,7 +10,9 @@ use crate::{
         IntentEvent,
         account::SetAuthByPredecessorId,
         token_diff::TokenDiffEvent,
-        tokens::{FtWithdraw, MtWithdraw, NativeWithdraw, NftWithdraw, StorageDeposit},
+        tokens::{
+            FtWithdraw, MtBurn, MtMint, MtWithdraw, NativeWithdraw, NftWithdraw, StorageDeposit,
+        },
     },
 };
 
@@ -54,6 +56,12 @@ pub enum DefuseEvent<'a> {
     #[event_version("0.3.0")]
     StorageDeposit(Cow<'a, [IntentEvent<AccountEvent<'a, Cow<'a, StorageDeposit>>>]>),
 
+    #[event_version("0.3.0")]
+    MtMint(Cow<'a, [IntentEvent<AccountEvent<'a, Cow<'a, MtMint>>>]>),
+
+    #[event_version("0.3.0")]
+    MtBurn(Cow<'a, [IntentEvent<AccountEvent<'a, Cow<'a, MtBurn>>>]>),
+
     #[event_version("0.3.0")]
     #[from(skip)]
     AccountLocked(AccountEvent<'a, ()>),

core/src/intents/mod.rs

@@ -12,7 +12,11 @@ use tokens::{NativeWithdraw, StorageDeposit};
 use crate::{
     Result,
     engine::{Engine, Inspector, State},
-    intents::{account::SetAuthByPredecessorId, auth::AuthCall},
+    intents::{
+        account::SetAuthByPredecessorId,
+        auth::AuthCall,
+        tokens::{MtBurn, MtMint},
+    },
 };
 
 use self::{
@@ -68,6 +72,12 @@ pub enum Intent {
 
     /// See [`AuthCall`]
     AuthCall(AuthCall),
+
+    // See [`MtMint`]
+    MtMint(MtMint),
+
+    // See [`MtBurn`]
+    MtBurn(MtBurn),
 }
 
 pub trait ExecutableIntent {
@@ -125,6 +135,8 @@ impl ExecutableIntent for Intent {
                 intent.execute_intent(signer_id, engine, intent_hash)
             }
             Self::AuthCall(intent) => intent.execute_intent(signer_id, engine, intent_hash),
+            Self::MtMint(intent) => intent.execute_intent(signer_id, engine, intent_hash),
+            Self::MtBurn(intent) => intent.execute_intent(signer_id, engine, intent_hash),
         }
     }
 }

core/src/intents/tokens.rs

@@ -1,5 +1,6 @@
 use std::{borrow::Cow, collections::BTreeMap};
 
+use defuse_token_id::nep245::Nep245TokenId;
 use near_contract_standards::non_fungible_token;
 use near_sdk::{
     AccountId, AccountIdRef, CryptoHash, Gas, NearToken, json_types::U128, near,
@@ -516,3 +517,95 @@ impl ExecutableIntent for StorageDeposit {
         engine.state.storage_deposit(owner_id, self)
     }
 }
+
+#[near(serializers = [borsh, json])]
+#[derive(Debug, Clone)]
+/// Mint a set of tokens from the signer to a specified account id, within the intents contract.
+pub struct MtMint {
+    pub receiver_id: AccountId,
+
+    #[serde_as(as = "Amounts<BTreeMap<_, DisplayFromStr>>")]
+    pub tokens: Amounts,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub memo: Option<String>,
+}
+
+impl ExecutableIntent for MtMint {
+    #[inline]
+    fn execute_intent<S, I>(
+        self,
+        owner_id: &AccountIdRef,
+        engine: &mut Engine<S, I>,
+        intent_hash: CryptoHash,
+    ) -> Result<()>
+    where
+        S: State,
+        I: Inspector,
+    {
+        engine.inspector.on_event(DefuseEvent::MtMint(Cow::Borrowed(
+            [IntentEvent::new(
+                AccountEvent::new(owner_id, Cow::Borrowed(&self)),
+                intent_hash,
+            )]
+            .as_slice(),
+        )));
+
+        let tokens = Amounts::new(
+            self.tokens
+                .iter()
+                .map(|(token_id, amount)| {
+                    let token = Nep245TokenId::new(owner_id, token_id.to_string());
+                    (token.into(), *amount)
+                })
+                .collect::<BTreeMap<_, _>>(),
+        );
+
+        engine.state.mt_mint(self.receiver_id, tokens, self.memo)
+    }
+}
+
+#[near(serializers = [borsh, json])]
+#[derive(Debug, Clone)]
+/// Burn a set of tokens minted by signer, within the intents contract.
+pub struct MtBurn {
+    #[serde_as(as = "Amounts<BTreeMap<_, DisplayFromStr>>")]
+    pub tokens: Amounts,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub memo: Option<String>,
+}
+
+impl ExecutableIntent for MtBurn {
+    #[inline]
+    fn execute_intent<S, I>(
+        self,
+        owner_id: &AccountIdRef,
+        engine: &mut Engine<S, I>,
+        intent_hash: CryptoHash,
+    ) -> Result<()>
+    where
+        S: State,
+        I: Inspector,
+    {
+        engine.inspector.on_event(DefuseEvent::MtBurn(Cow::Borrowed(
+            [IntentEvent::new(
+                AccountEvent::new(owner_id, Cow::Borrowed(&self)),
+                intent_hash,
+            )]
+            .as_slice(),
+        )));
+
+        let tokens = Amounts::new(
+            self.tokens
+                .iter()
+                .map(|(token_id, amount)| {
+                    let token = Nep245TokenId::new(owner_id, token_id.to_string());
+                    (token.into(), *amount)
+                })
+                .collect::<BTreeMap<_, _>>(),
+        );
+
+        engine.state.mt_burn(owner_id, tokens, self.memo)
+    }
+}

defuse/src/account_sync.rs

@@ -0,0 +1,17 @@
+use defuse_core::crypto::PublicKey;
+use near_sdk::{AccountId, ext_contract};
+
+// TODO: locked accounts + accounts with predecessor id disabled should be also synchronized
+#[ext_contract(ext_pk_sync_manager)]
+pub trait AccountSyncManager {
+    /// Registers or re-activates `public_key` under the user account_id.
+    ///
+    /// NOTE: MUST attach 1 yⓃ for security purposes.
+    fn force_add_public_keys(&mut self, public_keys: Vec<(AccountId, Vec<PublicKey>)>);
+
+    /// Deactivate `public_key` from the user account_id,
+    /// i.e. this key can't be used to make any actions unless it's re-created.
+    ///
+    /// NOTE: MUST attach 1 yⓃ for security purposes.
+    fn force_remove_public_keys(&mut self, public_keys: Vec<(AccountId, Vec<PublicKey>)>);
+}

defuse/src/contract/account_sync.rs

@@ -0,0 +1,61 @@
+use std::borrow::Cow;
+
+use defuse_core::{
+    accounts::{AccountEvent, PublicKeyEvent},
+    crypto::PublicKey,
+    engine::State,
+    events::DefuseEvent,
+};
+
+use defuse_near_utils::UnwrapOrPanic;
+
+use near_plugins::{AccessControllable, access_control_any};
+use near_sdk::{AccountId, assert_one_yocto, near};
+
+use crate::{
+    account_sync::AccountSyncManager,
+    contract::{Contract, ContractExt, Role},
+};
+
+#[near]
+impl AccountSyncManager for Contract {
+    #[access_control_any(roles(Role::DAO, Role::PubKeySynchronizer))]
+    #[payable]
+    fn force_add_public_keys(&mut self, entries: Vec<(AccountId, Vec<PublicKey>)>) {
+        assert_one_yocto();
+
+        for (account_id, keys) in entries {
+            for public_key in keys {
+                State::add_public_key(self, account_id.clone(), public_key).unwrap_or_panic();
+
+                DefuseEvent::PublicKeyAdded(AccountEvent::new(
+                    Cow::Borrowed(account_id.as_ref()),
+                    PublicKeyEvent {
+                        public_key: Cow::Borrowed(&public_key),
+                    },
+                ))
+                .emit();
+            }
+        }
+    }
+
+    #[access_control_any(roles(Role::DAO, Role::PubKeySynchronizer))]
+    #[payable]
+    fn force_remove_public_keys(&mut self, entries: Vec<(AccountId, Vec<PublicKey>)>) {
+        assert_one_yocto();
+
+        for (account_id, keys) in entries {
+            for public_key in keys {
+                State::remove_public_key(self, account_id.clone(), public_key).unwrap_or_panic();
+
+                DefuseEvent::PublicKeyRemoved(AccountEvent::new(
+                    Cow::Borrowed(account_id.as_ref()),
+                    PublicKeyEvent {
+                        public_key: Cow::Borrowed(&public_key),
+                    },
+                ))
+                .emit();
+            }
+        }
+    }
+}

defuse/src/contract/intents/state.rs

@@ -344,4 +344,24 @@ impl State for Contract {
 
         Ok(())
     }
+
+    #[inline]
+    fn mt_mint(
+        &mut self,
+        owner_id: AccountId,
+        tokens: Amounts,
+        memo: Option<String>,
+    ) -> Result<()> {
+        self.deposit(owner_id, tokens, memo.as_deref())
+    }
+
+    #[inline]
+    fn mt_burn(
+        &mut self,
+        owner_id: &AccountIdRef,
+        tokens: Amounts,
+        memo: Option<String>,
+    ) -> Result<()> {
+        self.withdraw(owner_id, tokens, memo, false)
+    }
 }

defuse/src/contract/mod.rs

@@ -1,5 +1,6 @@
 #[cfg(all(feature = "abi", not(target_arch = "wasm32")))]
 mod abi;
+mod account_sync;
 mod accounts;
 mod admin;
 pub mod config;
@@ -53,6 +54,8 @@ pub enum Role {
     SaltManager,
 
     GarbageCollector,
+
+    PubKeySynchronizer,
 }
 
 #[access_control(role_type(Role))]

defuse/src/lib.rs

@@ -13,6 +13,8 @@ pub mod salts;
 pub mod simulation_output;
 pub mod tokens;
 
+pub mod account_sync;
+
 pub use defuse_core as core;
 pub use defuse_nep245 as nep245;