Skip to main content

defuse/contract/tokens/nep245/
force.rs

1#![allow(clippy::too_many_arguments)]
2
3use defuse_nep245::TokenId;
4use near_plugins::{AccessControllable, access_control_any};
5use near_sdk::{
6    AccountId, FunctionError, PromiseOrValue, assert_one_yocto, json_types::U128, near, require,
7};
8
9use crate::{
10    contract::{Contract, ContractExt, Role},
11    tokens::nep245::MultiTokenForcedCore,
12};
13
14#[near]
15impl MultiTokenForcedCore for Contract {
16    #[access_control_any(roles(Role::DAO, Role::UnrestrictedWithdrawer))]
17    #[payable]
18    fn mt_force_transfer(
19        &mut self,
20        owner_id: AccountId,
21        receiver_id: AccountId,
22        token_id: TokenId,
23        amount: U128,
24        approval: Option<(AccountId, u64)>,
25        memo: Option<String>,
26    ) {
27        self.mt_force_batch_transfer(
28            owner_id,
29            receiver_id,
30            [token_id].into(),
31            [amount].into(),
32            approval.map(|a| vec![Some(a)]),
33            memo,
34        );
35    }
36
37    #[access_control_any(roles(Role::DAO, Role::UnrestrictedWithdrawer))]
38    #[payable]
39    fn mt_force_batch_transfer(
40        &mut self,
41        owner_id: AccountId,
42        receiver_id: AccountId,
43        token_ids: Vec<TokenId>,
44        amounts: Vec<U128>,
45        approvals: Option<Vec<Option<(AccountId, u64)>>>,
46        memo: Option<String>,
47    ) {
48        assert_one_yocto();
49        require!(approvals.is_none(), "approvals are not supported");
50
51        self.internal_mt_batch_transfer(
52            &owner_id,
53            &receiver_id,
54            &token_ids,
55            &amounts,
56            memo.as_deref(),
57            true,
58        )
59        .unwrap_or_else(|err| err.panic())
60    }
61
62    #[access_control_any(roles(Role::DAO, Role::UnrestrictedWithdrawer))]
63    #[payable]
64    fn mt_force_transfer_call(
65        &mut self,
66        owner_id: AccountId,
67        receiver_id: AccountId,
68        token_id: TokenId,
69        amount: U128,
70        approval: Option<(AccountId, u64)>,
71        memo: Option<String>,
72        msg: String,
73    ) -> PromiseOrValue<Vec<U128>> {
74        self.mt_force_batch_transfer_call(
75            owner_id,
76            receiver_id,
77            [token_id].into(),
78            [amount].into(),
79            approval.map(|a| vec![Some(a)]),
80            memo,
81            msg,
82        )
83    }
84
85    #[access_control_any(roles(Role::DAO, Role::UnrestrictedWithdrawer))]
86    #[payable]
87    fn mt_force_batch_transfer_call(
88        &mut self,
89        owner_id: AccountId,
90        receiver_id: AccountId,
91        token_ids: Vec<TokenId>,
92        amounts: Vec<U128>,
93        approvals: Option<Vec<Option<(AccountId, u64)>>>,
94        memo: Option<String>,
95        msg: String,
96    ) -> PromiseOrValue<Vec<U128>> {
97        assert_one_yocto();
98        require!(approvals.is_none(), "approvals are not supported");
99
100        self.internal_mt_batch_transfer_call(
101            owner_id,
102            receiver_id,
103            token_ids,
104            amounts,
105            memo.as_deref(),
106            msg,
107            true,
108        )
109        .unwrap_or_else(|err| err.panic())
110    }
111}