Merge pull request #102 from RealisNetwork/hot-fix/add-ft-freeze

Hot fix/add ft freeze

Author: BeginArtem

Cargo.lock

@@ -107,7 +107,7 @@ impl Contract {
 
 impl Contract {
     pub fn next_index(&mut self) -> LockupIndex {
-        while self.lockups.keys().any(|key| key == self.index) {
+        if self.lockups.get(&self.index).is_some() {
             self.index = self
                 .index
                 .checked_add(1)

ft-lockup-contract/src/lib.rs

@@ -1,6 +1,6 @@
 [package]
 name = "ft-token-contract"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 
 [lib]

ft-token-contract/Cargo.toml

@@ -24,9 +24,11 @@ pub const DEFAULT_MINT_AMOUNT: u128 = 3_000_000_000 * 10_u128.pow(12);
 pub struct Contract {
     pub owner_id: AccountId,
     pub staking_contract: AccountId,
+    pub lockup_contract: AccountId,
     pub ft: FungibleToken,
     pub last_mint: Timestamp,
     pub backend: UnorderedSet<AccountId>,
+    pub suspensioned_accounts: UnorderedSet<AccountId>,
 }
 
 #[near_bindgen]
@@ -36,21 +38,25 @@ impl Contract {
         owner_id: Option<AccountId>,
         backend_ids: Option<Vec<AccountId>>,
         staking_id: AccountId,
+        lockup_id: AccountId,
     ) -> Self {
         let owner_id = owner_id.unwrap_or_else(env::predecessor_account_id);
         let mut this = Self {
             owner_id: owner_id.clone(),
             staking_contract: staking_id.clone(),
+            lockup_contract: lockup_id.clone(),
             ft: FungibleToken::new(b"a".to_vec()),
             last_mint: env::block_timestamp(),
             backend: UnorderedSet::new(b"b".to_vec()),
+            suspensioned_accounts: UnorderedSet::new(b"c".to_vec()),
         };
 
         this.backend
             .extend(backend_ids.unwrap_or_default().into_iter());
 
         this.ft.internal_register_account(&owner_id);
         this.ft.internal_register_account(&staking_id);
+        this.ft.internal_register_account(&lockup_id);
 
         this.ft.internal_deposit(&owner_id, DEFAULT_MINT_AMOUNT);
         near_contract_standards::fungible_token::events::FtMint {

ft-token-contract/src/lib.rs

@@ -104,12 +104,13 @@ mod tests {
     fn mint_time_check() {
         let owner_id = accounts(0);
         let staking_id = accounts(1);
+        let lockup_id = accounts(2);
         let initial_total_supply = 3_000_000_000 * 10_u128.pow(12);
         let context = VMContextBuilder::new();
 
         // init contract
         testing_env!(context.clone().block_timestamp(WEEK.0).build());
-        let mut contract = Contract::new(Some(owner_id.clone()), None, staking_id);
+        let mut contract = Contract::new(Some(owner_id.clone()), None, staking_id, lockup_id);
         assert_eq!(contract.ft_total_supply().0, initial_total_supply);
 
         // wait week
@@ -170,12 +171,13 @@ mod tests {
     fn mint_before_new_week() {
         let owner_id = accounts(0);
         let staking_id = accounts(1);
+        let lockup_id = accounts(2);
         let initial_total_supply = 3_000_000_000 * 10_u128.pow(12);
         let context = VMContextBuilder::new();
 
         // init contract
         testing_env!(context.clone().block_timestamp(WEEK.0).build());
-        let mut contract = Contract::new(Some(owner_id.clone()), None, staking_id);
+        let mut contract = Contract::new(Some(owner_id.clone()), None, staking_id, lockup_id);
         assert_eq!(contract.ft_total_supply().0, initial_total_supply);
 
         // wait 3 days
@@ -193,11 +195,12 @@ mod tests {
     fn can_mint_only_owner() {
         let owner_id = accounts(0);
         let staking_id = accounts(1);
+        let lockup_id = accounts(2);
         let context = VMContextBuilder::new();
 
         // init contract
         testing_env!(context.clone().block_timestamp(WEEK.0).build());
-        let mut contract = Contract::new(Some(owner_id.clone()), None, staking_id);
+        let mut contract = Contract::new(Some(owner_id.clone()), None, staking_id, lockup_id);
 
         // wait week
         testing_env!(context

ft-token-contract/src/lis_token.rs

@@ -1,6 +1,21 @@
 use crate::*;
-use near_contract_standards::upgrade::Ownable;
-use near_sdk::assert_one_yocto;
+use near_contract_standards::{
+    fungible_token::{receiver::ext_ft_receiver, resolver::ext_ft_resolver},
+    upgrade::Ownable,
+};
+use near_sdk::{assert_one_yocto, env, json_types::U128, Gas, Promise};
+
+#[near_bindgen]
+impl Ownable for Contract {
+    fn get_owner(&self) -> AccountId {
+        self.owner_id.clone()
+    }
+
+    fn set_owner(&mut self, owner: AccountId) {
+        self.assert_owner();
+        self.owner_id = owner;
+    }
+}
 
 #[near_bindgen]
 impl Contract {
@@ -25,4 +40,43 @@ impl Contract {
     pub fn get_backend_accounts(&self) -> Vec<AccountId> {
         self.backend.iter().collect()
     }
+
+    #[payable]
+    pub fn ft_freeze_call(
+        &mut self,
+        account_id: AccountId,
+        amount: U128,
+        memo: Option<String>,
+        msg: String,
+    ) -> Promise {
+        assert_one_yocto();
+        self.assert_owner();
+
+        require!(
+            self.suspensioned_accounts.contains(&account_id),
+            "Not suspensioned account"
+        );
+        require!(
+            env::prepaid_gas() > GAS_FOR_FT_TRANSFER_CALL,
+            "More gas is required"
+        );
+
+        const GAS_FOR_RESOLVE_TRANSFER: Gas = Gas(5_000_000_000_000);
+        const GAS_FOR_FT_TRANSFER_CALL: Gas = Gas(25_000_000_000_000 + GAS_FOR_RESOLVE_TRANSFER.0);
+
+        let receiver_id = self.lockup_contract.clone();
+        let sender_id = account_id;
+        let amount: Balance = amount.into();
+        self.ft
+            .internal_transfer(&sender_id, &receiver_id, amount, memo);
+        // Initiating receiver's call and the callback
+        ext_ft_receiver::ext(receiver_id.clone())
+            .with_static_gas(env::prepaid_gas() - GAS_FOR_FT_TRANSFER_CALL)
+            .ft_on_transfer(env::predecessor_account_id(), amount.into(), msg)
+            .then(
+                ext_ft_resolver::ext(env::current_account_id())
+                    .with_static_gas(GAS_FOR_RESOLVE_TRANSFER)
+                    .ft_resolve_transfer(sender_id, receiver_id, amount.into()),
+            )
+    }
 }

ft-token-contract/src/owner.rs

@@ -1,23 +1,40 @@
 use crate::*;
-use near_contract_standards::upgrade::Ownable;
 
-#[near_bindgen]
-impl Ownable for Contract {
-    fn get_owner(&self) -> AccountId {
-        self.owner_id.clone()
-    }
+// pub struct Contract {
+//     pub owner_id: AccountId,
+//     pub staking_contract: AccountId,
+//     pub lockup_contract: AccountId,
+//     pub ft: FungibleToken,
+//     pub last_mint: Timestamp,
+//     pub backend: UnorderedSet<AccountId>,
+//     pub suspensioned_accounts: UnorderedSet<AccountId>,
+// }
 
-    fn set_owner(&mut self, owner: AccountId) {
-        self.assert_owner();
-        self.owner_id = owner;
-    }
+#[derive(BorshDeserialize, BorshSerialize)]
+pub struct ContractV010 {
+    pub owner_id: AccountId,
+    pub staking_contract: AccountId,
+    pub ft: FungibleToken,
+    pub last_mint: Timestamp,
+    pub backend: UnorderedSet<AccountId>,
 }
 
 #[near_bindgen]
 impl Contract {
     #[private]
     #[init(ignore_state)]
-    pub fn update() -> Self {
-        env::state_read().unwrap_or_else(|| env::panic_str("Not initialized"))
+    pub fn update(lockup_id: AccountId, suspensioned_accounts: Vec<AccountId>) -> Self {
+        let contract_old: ContractV010 = env::state_read().unwrap();
+        let mut this = Self {
+            owner_id: contract_old.owner_id,
+            staking_contract: contract_old.staking_contract,
+            lockup_contract: lockup_id,
+            ft: contract_old.ft,
+            last_mint: contract_old.last_mint,
+            backend: contract_old.backend,
+            suspensioned_accounts: UnorderedSet::new(b"c".to_vec()),
+        };
+        this.suspensioned_accounts.extend(suspensioned_accounts);
+        this
     }
 }

ft-token-contract/src/update.rs

@@ -4,20 +4,23 @@ use workspaces::{network::Sandbox, AccountId, Contract, Worker};
 
 pub const CONTRACT_ACCOUNT: &str = "token.v1.realisnetwork.near";
 pub const STAKING_ACCOUNT: &str = "staking.v1.realisnetwork.near";
+pub const LOCKUP_ACCOUNT: &str = "lockup.v1.realisnetwork.near";
 pub const SPEC_METADATA: &str = "ft-1.0.1";
 
 pub async fn pull_contract(worker: &Worker<Sandbox>) -> anyhow::Result<Contract> {
     let mainnet = workspaces::mainnet_archival().await?;
     let contract_id: AccountId = CONTRACT_ACCOUNT.parse()?;
     let contract = worker
         .import_contract(&contract_id, &mainnet)
-        .initial_balance(parse_near!("1000 N"))
+        .initial_balance(parse_near!("5000 N"))
         .transact()
         .await?;
 
     contract
         .call("new")
-        .args_json(serde_json::json!({ "staking_id": STAKING_ACCOUNT }))
+        .args_json(
+            serde_json::json!({ "staking_id": STAKING_ACCOUNT, "lockup_id": LOCKUP_ACCOUNT }),
+        )
         .transact()
         .await?
         .into_result()?;

ft-token-contract/tests/utils.rs

@@ -112,7 +112,7 @@ then
         --initArgs '{"token_account_id": "'$TOKEN_CONTRACT_ID'", "deposit_whitelist": ["'$OWNER_ID'", "'$STAKING_CONTRACT_ID'"]}' \
         --initGas 300000000000000
     echo "Register in token contract"
-    near call $TOKEN_CONTRACT_ID register '{"account_id": "'$LOCKUP_CONTRACT_ID'"}' --accountId $OWNER_ID
+    near call $TOKEN_CONTRACT_ID storage_deposit '{"account_id": "'$LOCKUP_CONTRACT_ID'"}' --accountId $OWNER_ID --deposit 1
 else
     echo "Updating contract"
     echo y | near deploy --accountId $LOCKUP_CONTRACT_ID \

scripts/deploy.sh

@@ -35,7 +35,7 @@ pub async fn pull(
     let contract_id: AccountId = TOKEN_CONTRACT_ACCOUNT.parse()?;
     let contract = worker
         .import_contract(&contract_id, &mainnet)
-        .initial_balance(parse_near!("1000 N"))
+        .initial_balance(parse_near!("5000 N"))
         .transact()
         .await?;