defuse/contract/tokens/nep245/
force.rs

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