hermit_toolkit_hmip21/
handle.rs

1use serde::Serialize;
2
3use cosmwasm_std::{to_binary, Binary, Coin, CosmosMsg, HumanAddr, StdResult, Uint128, WasmMsg};
4
5use crate::batch::{
6    BurnFromAction, MintAction, SendAction, SendFromAction, TransferAction, TransferFromAction,
7};
8use hermit_toolkit_utils::space_pad;
9
10/// SNIP20 token handle messages
11#[derive(Serialize, Clone, Debug, PartialEq)]
12#[serde(rename_all = "snake_case")]
13pub enum HandleMsg {
14    // Native coin interactions
15    Redeem {
16        amount: Uint128,
17        // TODO: remove skip_serializing once denom is added to sSCRT stored on mainnet
18        #[serde(skip_serializing_if = "Option::is_none")]
19        denom: Option<String>,
20        padding: Option<String>,
21    },
22    Deposit {
23        padding: Option<String>,
24    },
25
26    // Basic SNIP20 functions
27    Transfer {
28        recipient: HumanAddr,
29        amount: Uint128,
30        memo: Option<String>,
31        padding: Option<String>,
32    },
33    Send {
34        recipient: HumanAddr,
35        recipient_code_hash: Option<String>,
36        amount: Uint128,
37        msg: Option<Binary>,
38        memo: Option<String>,
39        padding: Option<String>,
40    },
41    BatchTransfer {
42        actions: Vec<TransferAction>,
43        padding: Option<String>,
44    },
45    BatchSend {
46        actions: Vec<SendAction>,
47        padding: Option<String>,
48    },
49    Burn {
50        amount: Uint128,
51        memo: Option<String>,
52        padding: Option<String>,
53    },
54    RegisterReceive {
55        code_hash: String,
56        padding: Option<String>,
57    },
58    CreateViewingKey {
59        entropy: String,
60        padding: Option<String>,
61    },
62    SetViewingKey {
63        key: String,
64        padding: Option<String>,
65    },
66
67    // Allowance functions
68    IncreaseAllowance {
69        spender: HumanAddr,
70        amount: Uint128,
71        expiration: Option<u64>,
72        padding: Option<String>,
73    },
74    DecreaseAllowance {
75        spender: HumanAddr,
76        amount: Uint128,
77        expiration: Option<u64>,
78        padding: Option<String>,
79    },
80    TransferFrom {
81        owner: HumanAddr,
82        recipient: HumanAddr,
83        amount: Uint128,
84        memo: Option<String>,
85        padding: Option<String>,
86    },
87    SendFrom {
88        owner: HumanAddr,
89        recipient: HumanAddr,
90        recipient_code_hash: Option<String>,
91        amount: Uint128,
92        msg: Option<Binary>,
93        memo: Option<String>,
94        padding: Option<String>,
95    },
96    BatchTransferFrom {
97        actions: Vec<TransferFromAction>,
98        padding: Option<String>,
99    },
100    BatchSendFrom {
101        actions: Vec<SendFromAction>,
102        padding: Option<String>,
103    },
104    BurnFrom {
105        owner: HumanAddr,
106        amount: Uint128,
107        memo: Option<String>,
108        padding: Option<String>,
109    },
110    BatchBurnFrom {
111        actions: Vec<BurnFromAction>,
112        padding: Option<String>,
113    },
114
115    // Mint
116    Mint {
117        recipient: HumanAddr,
118        amount: Uint128,
119        memo: Option<String>,
120        padding: Option<String>,
121    },
122    BatchMint {
123        actions: Vec<MintAction>,
124        padding: Option<String>,
125    },
126    AddMinters {
127        minters: Vec<HumanAddr>,
128        padding: Option<String>,
129    },
130    RemoveMinters {
131        minters: Vec<HumanAddr>,
132        padding: Option<String>,
133    },
134    SetMinters {
135        minters: Vec<HumanAddr>,
136        padding: Option<String>,
137    },
138}
139
140impl HandleMsg {
141    /// Returns a StdResult<CosmosMsg> used to execute a SNIP20 contract function
142    ///
143    /// # Arguments
144    ///
145    /// * `block_size` - pad the message to blocks of this size
146    /// * `callback_code_hash` - String holding the code hash of the contract being called
147    /// * `contract_addr` - address of the contract being called
148    /// * `send_amount` - Optional Uint128 amount of native coin to send with the callback message
149    ///                 NOTE: Only a Deposit message should have an amount sent with it
150    pub fn to_cosmos_msg(
151        &self,
152        mut block_size: usize,
153        callback_code_hash: String,
154        contract_addr: HumanAddr,
155        send_amount: Option<Uint128>,
156    ) -> StdResult<CosmosMsg> {
157        // can not have block size of 0
158        if block_size == 0 {
159            block_size = 1;
160        }
161        let mut msg = to_binary(self)?;
162        space_pad(&mut msg.0, block_size);
163        let mut send = Vec::new();
164        if let Some(amount) = send_amount {
165            send.push(Coin {
166                amount,
167                denom: String::from("uscrt"),
168            });
169        }
170        let execute = WasmMsg::Execute {
171            msg,
172            contract_addr,
173            callback_code_hash,
174            send,
175        };
176        Ok(execute.into())
177    }
178}
179
180/// Returns a StdResult<CosmosMsg> used to execute Redeem
181///
182/// # Arguments
183///
184/// * `amount` - Uint128 amount of token to redeem for SCRT
185/// * `denom` - Optional String to hold the denomination of tokens to redeem
186/// * `padding` - Optional String used as padding if you don't want to use block padding
187/// * `block_size` - pad the message to blocks of this size
188/// * `callback_code_hash` - String holding the code hash of the contract being called
189/// * `contract_addr` - address of the contract being called
190pub fn redeem_msg(
191    amount: Uint128,
192    denom: Option<String>,
193    padding: Option<String>,
194    block_size: usize,
195    callback_code_hash: String,
196    contract_addr: HumanAddr,
197) -> StdResult<CosmosMsg> {
198    HandleMsg::Redeem {
199        amount,
200        denom,
201        padding,
202    }
203        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
204}
205
206/// Returns a StdResult<CosmosMsg> used to execute Deposit
207///
208/// # Arguments
209///
210/// * `amount` - Uint128 amount of uSCRT to convert to the SNIP20 token
211/// * `padding` - Optional String used as padding if you don't want to use block padding
212/// * `block_size` - pad the message to blocks of this size
213/// * `callback_code_hash` - String holding the code hash of the contract being called
214/// * `contract_addr` - address of the contract being called
215pub fn deposit_msg(
216    amount: Uint128,
217    padding: Option<String>,
218    block_size: usize,
219    callback_code_hash: String,
220    contract_addr: HumanAddr,
221) -> StdResult<CosmosMsg> {
222    HandleMsg::Deposit { padding }.to_cosmos_msg(
223        block_size,
224        callback_code_hash,
225        contract_addr,
226        Some(amount),
227    )
228}
229
230/// Returns a StdResult<CosmosMsg> used to execute Transfer
231///
232/// # Arguments
233///
234/// * `recipient` - the address the tokens are to be sent to
235/// * `amount` - Uint128 amount of tokens to send
236/// * `memo` - A message to include in transaction
237/// * `padding` - Optional String used as padding if you don't want to use block padding
238/// * `block_size` - pad the message to blocks of this size
239/// * `callback_code_hash` - String holding the code hash of the contract being called
240/// * `contract_addr` - address of the contract being called
241pub fn transfer_msg(
242    recipient: HumanAddr,
243    amount: Uint128,
244    memo: Option<String>,
245    padding: Option<String>,
246    block_size: usize,
247    callback_code_hash: String,
248    contract_addr: HumanAddr,
249) -> StdResult<CosmosMsg> {
250    HandleMsg::Transfer {
251        recipient,
252        amount,
253        memo,
254        padding,
255    }
256        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
257}
258
259/// Returns a StdResult<CosmosMsg> used to execute Send
260///
261/// # Arguments
262///
263/// * `recipient` - the address tokens are to be sent to
264/// * `amount` - Uint128 amount of tokens to send
265/// * `msg` - Optional base64 encoded string to pass to the recipient contract's
266///           Receive function
267/// * `memo` - A message to include in transaction
268/// * `padding` - Optional String used as padding if you don't want to use block padding
269/// * `block_size` - pad the message to blocks of this size
270/// * `callback_code_hash` - String holding the code hash of the contract being called
271/// * `contract_addr` - address of the contract being called
272#[allow(clippy::too_many_arguments)]
273pub fn send_msg(
274    recipient: HumanAddr,
275    amount: Uint128,
276    msg: Option<Binary>,
277    memo: Option<String>,
278    padding: Option<String>,
279    block_size: usize,
280    callback_code_hash: String,
281    contract_addr: HumanAddr,
282) -> StdResult<CosmosMsg> {
283    HandleMsg::Send {
284        recipient,
285        recipient_code_hash: None,
286        amount,
287        msg,
288        memo,
289        padding,
290    }
291        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
292}
293
294/// Returns a StdResult<CosmosMsg> used to execute Send
295///
296/// # Arguments
297///
298/// * `recipient` - the address tokens are to be sent to
299/// * `recipient_code_hash` - override the `recipient_code_hash` registered with the `RegisterReceiver` interface
300/// * `amount` - Uint128 amount of tokens to send
301/// * `msg` - Optional base64 encoded string to pass to the recipient contract's
302///           Receive function
303/// * `memo` - A message to include in transaction
304/// * `padding` - Optional String used as padding if you don't want to use block padding
305/// * `block_size` - pad the message to blocks of this size
306/// * `callback_code_hash` - String holding the code hash of the contract being called
307/// * `contract_addr` - address of the contract being called
308#[allow(clippy::too_many_arguments)]
309pub fn send_msg_with_code_hash(
310    recipient: HumanAddr,
311    recipient_code_hash: Option<String>,
312    amount: Uint128,
313    msg: Option<Binary>,
314    memo: Option<String>,
315    padding: Option<String>,
316    block_size: usize,
317    callback_code_hash: String,
318    contract_addr: HumanAddr,
319) -> StdResult<CosmosMsg> {
320    HandleMsg::Send {
321        recipient,
322        recipient_code_hash,
323        amount,
324        msg,
325        memo,
326        padding,
327    }
328        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
329}
330
331/// Returns a StdResult<CosmosMsg> used to execute BatchTransfer
332///
333/// # Arguments
334/// * `actions` - Batch of actions
335/// * `padding` - Optional String used as padding if you don't want to use block padding
336/// * `block_size` - pad the message to blocks of this size
337/// * `callback_code_hash` - String holding the code hash of the contract being called
338/// * `contract_addr` - address of the contract being called
339pub fn batch_transfer_msg(
340    actions: Vec<TransferAction>,
341    padding: Option<String>,
342    block_size: usize,
343    callback_code_hash: String,
344    contract_addr: HumanAddr,
345) -> StdResult<CosmosMsg> {
346    HandleMsg::BatchTransfer { actions, padding }.to_cosmos_msg(
347        block_size,
348        callback_code_hash,
349        contract_addr,
350        None,
351    )
352}
353
354/// Returns a StdResult<CosmosMsg> used to execute BatchSend
355///
356/// # Arguments
357/// * `actions` - Batch of actions
358/// * `padding` - Optional String used as padding if you don't want to use block padding
359/// * `block_size` - pad the message to blocks of this size
360/// * `callback_code_hash` - String holding the code hash of the contract being called
361/// * `contract_addr` - address of the contract being called
362pub fn batch_send_msg(
363    actions: Vec<SendAction>,
364    padding: Option<String>,
365    block_size: usize,
366    callback_code_hash: String,
367    contract_addr: HumanAddr,
368) -> StdResult<CosmosMsg> {
369    HandleMsg::BatchSend { actions, padding }.to_cosmos_msg(
370        block_size,
371        callback_code_hash,
372        contract_addr,
373        None,
374    )
375}
376
377/// Returns a StdResult<CosmosMsg> used to execute Burn
378///
379/// # Arguments
380///
381/// * `amount` - Uint128 amount of tokens to burn
382/// * `memo` - A message to include in transaction
383/// * `padding` - Optional String used as padding if you don't want to use block padding
384/// * `block_size` - pad the message to blocks of this size
385/// * `callback_code_hash` - String holding the code hash of the contract being called
386/// * `contract_addr` - address of the contract being called
387pub fn burn_msg(
388    amount: Uint128,
389    memo: Option<String>,
390    padding: Option<String>,
391    block_size: usize,
392    callback_code_hash: String,
393    contract_addr: HumanAddr,
394) -> StdResult<CosmosMsg> {
395    HandleMsg::Burn {
396        amount,
397        memo,
398        padding,
399    }
400        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
401}
402
403/// Returns a StdResult<CosmosMsg> used to execute CreateViewingKey
404///
405/// # Arguments
406/// * `entropy` - Random bytes used to generate the viewing key
407/// * `padding` - Optional String used as padding if you don't want to use block padding
408/// * `block_size` - pad the message to blocks of this size
409/// * `callback_code_hash` - String holding the code hash of the contract being called
410/// * `contract_addr` - address of the contract being called
411pub fn create_viewing_key_msg(
412    entropy: String,
413    padding: Option<String>,
414    block_size: usize,
415    callback_code_hash: String,
416    contract_addr: HumanAddr,
417) -> StdResult<CosmosMsg> {
418    HandleMsg::CreateViewingKey { entropy, padding }.to_cosmos_msg(
419        block_size,
420        callback_code_hash,
421        contract_addr,
422        None,
423    )
424}
425
426/// Returns a StdResult<CosmosMsg> used to execute RegisterReceive
427///
428/// # Arguments
429///
430/// * `your_contracts_code_hash` - String holding the code hash of your contract
431/// * `padding` - Optional String used as padding if you don't want to use block padding
432/// * `block_size` - pad the message to blocks of this size
433/// * `callback_code_hash` - String holding the code hash of the contract being called
434/// * `contract_addr` - address of the contract being called
435pub fn register_receive_msg(
436    your_contracts_code_hash: String,
437    padding: Option<String>,
438    block_size: usize,
439    callback_code_hash: String,
440    contract_addr: HumanAddr,
441) -> StdResult<CosmosMsg> {
442    HandleMsg::RegisterReceive {
443        code_hash: your_contracts_code_hash,
444        padding,
445    }
446        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
447}
448
449/// Returns a StdResult<CosmosMsg> used to execute SetViewingKey
450///
451/// # Arguments
452///
453/// * `key` - String holding the authentication key used for later queries
454/// * `padding` - Optional String used as padding if you don't want to use block padding
455/// * `block_size` - pad the message to blocks of this size
456/// * `callback_code_hash` - String holding the code hash of the contract being called
457/// * `contract_addr` - address of the contract being called
458pub fn set_viewing_key_msg(
459    key: String,
460    padding: Option<String>,
461    block_size: usize,
462    callback_code_hash: String,
463    contract_addr: HumanAddr,
464) -> StdResult<CosmosMsg> {
465    HandleMsg::SetViewingKey { key, padding }.to_cosmos_msg(
466        block_size,
467        callback_code_hash,
468        contract_addr,
469        None,
470    )
471}
472
473/// Returns a StdResult<CosmosMsg> used to execute IncreaseAllowance
474///
475/// # Arguments
476///
477/// * `spender` - the address of the allowed spender
478/// * `amount` - Uint128 additional amount the spender is allowed to send/burn
479/// * `expiration` - Optional u64 denoting the epoch time in seconds that the allowance will expire
480/// * `padding` - Optional String used as padding if you don't want to use block padding
481/// * `block_size` - pad the message to blocks of this size
482/// * `callback_code_hash` - String holding the code hash of the contract being called
483/// * `contract_addr` - address of the contract being called
484pub fn increase_allowance_msg(
485    spender: HumanAddr,
486    amount: Uint128,
487    expiration: Option<u64>,
488    padding: Option<String>,
489    block_size: usize,
490    callback_code_hash: String,
491    contract_addr: HumanAddr,
492) -> StdResult<CosmosMsg> {
493    HandleMsg::IncreaseAllowance {
494        spender,
495        amount,
496        expiration,
497        padding,
498    }
499        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
500}
501
502/// Returns a StdResult<CosmosMsg> used to execute DecreaseAllowance
503///
504/// # Arguments
505///
506/// * `spender` - the address of the allowed spender
507/// * `amount` - Uint128 amount the spender is no longer allowed to send/burn
508/// * `expiration` - Optional u64 denoting the epoch time in seconds that the allowance will expire
509/// * `padding` - Optional String used as padding if you don't want to use block padding
510/// * `block_size` - pad the message to blocks of this size
511/// * `callback_code_hash` - String holding the code hash of the contract being called
512/// * `contract_addr` - address of the contract being called
513pub fn decrease_allowance_msg(
514    spender: HumanAddr,
515    amount: Uint128,
516    expiration: Option<u64>,
517    padding: Option<String>,
518    block_size: usize,
519    callback_code_hash: String,
520    contract_addr: HumanAddr,
521) -> StdResult<CosmosMsg> {
522    HandleMsg::DecreaseAllowance {
523        spender,
524        amount,
525        expiration,
526        padding,
527    }
528        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
529}
530
531/// Returns a StdResult<CosmosMsg> used to execute TransferFrom
532///
533/// # Arguments
534///
535/// * `owner` - the address of the owner of the tokens to be sent
536/// * `recipient` - the address the tokens are to be sent to
537/// * `amount` - Uint128 amount of tokens to send
538/// * `memo` - A message to include in transaction
539/// * `padding` - Optional String used as padding if you don't want to use block padding
540/// * `block_size` - pad the message to blocks of this size
541/// * `callback_code_hash` - String holding the code hash of the contract being called
542/// * `contract_addr` - address of the contract being called
543#[allow(clippy::too_many_arguments)]
544pub fn transfer_from_msg(
545    owner: HumanAddr,
546    recipient: HumanAddr,
547    amount: Uint128,
548    memo: Option<String>,
549    padding: Option<String>,
550    block_size: usize,
551    callback_code_hash: String,
552    contract_addr: HumanAddr,
553) -> StdResult<CosmosMsg> {
554    HandleMsg::TransferFrom {
555        owner,
556        recipient,
557        amount,
558        memo,
559        padding,
560    }
561        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
562}
563
564/// Returns a StdResult<CosmosMsg> used to execute SendFrom
565///
566/// # Arguments
567///
568/// * `owner` - the address of the owner of the tokens to be sent
569/// * `recipient` - the address the tokens are to be sent to
570/// * `amount` - Uint128 amount of tokens to send
571/// * `msg` - Optional base64 encoded string to pass to the recipient contract's
572///           Receive function
573/// * `memo` - A message to include in transaction
574/// * `padding` - Optional String used as padding if you don't want to use block padding
575/// * `block_size` - pad the message to blocks of this size
576/// * `callback_code_hash` - String holding the code hash of the contract being called
577/// * `contract_addr` - address of the contract being called
578#[allow(clippy::too_many_arguments)]
579pub fn send_from_msg(
580    owner: HumanAddr,
581    recipient: HumanAddr,
582    amount: Uint128,
583    msg: Option<Binary>,
584    memo: Option<String>,
585    padding: Option<String>,
586    block_size: usize,
587    callback_code_hash: String,
588    contract_addr: HumanAddr,
589) -> StdResult<CosmosMsg> {
590    HandleMsg::SendFrom {
591        owner,
592        recipient,
593        recipient_code_hash: None,
594        amount,
595        msg,
596        memo,
597        padding,
598    }
599        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
600}
601
602/// Returns a StdResult<CosmosMsg> used to execute SendFrom
603///
604/// # Arguments
605///
606/// * `owner` - the address of the owner of the tokens to be sent
607/// * `recipient` - the address the tokens are to be sent to
608/// * `recipient_code_hash` - override the `recipient_code_hash` registered with the `RegisterReceiver` interface
609/// * `amount` - Uint128 amount of tokens to send
610/// * `msg` - Optional base64 encoded string to pass to the recipient contract's
611///           Receive function
612/// * `memo` - A message to include in transaction
613/// * `padding` - Optional String used as padding if you don't want to use block padding
614/// * `block_size` - pad the message to blocks of this size
615/// * `callback_code_hash` - String holding the code hash of the contract being called
616/// * `contract_addr` - address of the contract being called
617#[allow(clippy::too_many_arguments)]
618pub fn send_from_msg_with_code_hash(
619    owner: HumanAddr,
620    recipient: HumanAddr,
621    recipient_code_hash: Option<String>,
622    amount: Uint128,
623    msg: Option<Binary>,
624    memo: Option<String>,
625    padding: Option<String>,
626    block_size: usize,
627    callback_code_hash: String,
628    contract_addr: HumanAddr,
629) -> StdResult<CosmosMsg> {
630    HandleMsg::SendFrom {
631        owner,
632        recipient,
633        recipient_code_hash,
634        amount,
635        msg,
636        memo,
637        padding,
638    }
639        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
640}
641
642/// Returns a StdResult<CosmosMsg> used to execute BatchTransferFrom
643///
644/// # Arguments
645/// * `actions` - Batch of actions
646/// * `padding` - Optional String used as padding if you don't want to use block padding
647/// * `block_size` - pad the message to blocks of this size
648/// * `callback_code_hash` - String holding the code hash of the contract being called
649/// * `contract_addr` - address of the contract being called
650pub fn batch_transfer_from_msg(
651    actions: Vec<TransferFromAction>,
652    padding: Option<String>,
653    block_size: usize,
654    callback_code_hash: String,
655    contract_addr: HumanAddr,
656) -> StdResult<CosmosMsg> {
657    HandleMsg::BatchTransferFrom { actions, padding }.to_cosmos_msg(
658        block_size,
659        callback_code_hash,
660        contract_addr,
661        None,
662    )
663}
664
665/// Returns a StdResult<CosmosMsg> used to execute BatchSendFrom
666///
667/// # Arguments
668/// * `actions` - Batch of actions
669/// * `padding` - Optional String used as padding if you don't want to use block padding
670/// * `block_size` - pad the message to blocks of this size
671/// * `callback_code_hash` - String holding the code hash of the contract being called
672/// * `contract_addr` - address of the contract being called
673pub fn batch_send_from_msg(
674    actions: Vec<SendFromAction>,
675    padding: Option<String>,
676    block_size: usize,
677    callback_code_hash: String,
678    contract_addr: HumanAddr,
679) -> StdResult<CosmosMsg> {
680    HandleMsg::BatchSendFrom { actions, padding }.to_cosmos_msg(
681        block_size,
682        callback_code_hash,
683        contract_addr,
684        None,
685    )
686}
687
688/// Returns a StdResult<CosmosMsg> used to execute BurnFrom
689///
690/// # Arguments
691///
692/// * `owner` - the address of the owner of the tokens to be burnt
693/// * `amount` - Uint128 amount of tokens to burn
694/// * `memo` - A message to include in transaction
695/// * `padding` - Optional String used as padding if you don't want to use block padding
696/// * `block_size` - pad the message to blocks of this size
697/// * `callback_code_hash` - String holding the code hash of the contract being called
698/// * `contract_addr` - address of the contract being called
699pub fn burn_from_msg(
700    owner: HumanAddr,
701    amount: Uint128,
702    memo: Option<String>,
703    padding: Option<String>,
704    block_size: usize,
705    callback_code_hash: String,
706    contract_addr: HumanAddr,
707) -> StdResult<CosmosMsg> {
708    HandleMsg::BurnFrom {
709        owner,
710        amount,
711        memo,
712        padding,
713    }
714        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
715}
716
717/// Returns a StdResult<CosmosMsg> used to execute BatchBurnFrom
718///
719/// # Arguments
720/// * `actions` - Batch of actions
721/// * `padding` - Optional String used as padding if you don't want to use block padding
722/// * `block_size` - pad the message to blocks of this size
723/// * `callback_code_hash` - String holding the code hash of the contract being called
724/// * `contract_addr` - address of the contract being called
725pub fn batch_burn_from_msg(
726    actions: Vec<BurnFromAction>,
727    padding: Option<String>,
728    block_size: usize,
729    callback_code_hash: String,
730    contract_addr: HumanAddr,
731) -> StdResult<CosmosMsg> {
732    HandleMsg::BatchBurnFrom { actions, padding }.to_cosmos_msg(
733        block_size,
734        callback_code_hash,
735        contract_addr,
736        None,
737    )
738}
739
740/// Returns a StdResult<CosmosMsg> used to execute Mint
741///
742/// # Arguments
743///
744/// * `recipient` - the address that will receive the newly minted tokens
745/// * `amount` - Uint128 amount of tokens to mint
746/// * `memo` - A message to include in transaction
747/// * `padding` - Optional String used as padding if you don't want to use block padding
748/// * `block_size` - pad the message to blocks of this size
749/// * `callback_code_hash` - String holding the code hash of the contract being called
750/// * `contract_addr` - address of the contract being called
751pub fn mint_msg(
752    recipient: HumanAddr,
753    amount: Uint128,
754    memo: Option<String>,
755    padding: Option<String>,
756    block_size: usize,
757    callback_code_hash: String,
758    contract_addr: HumanAddr,
759) -> StdResult<CosmosMsg> {
760    HandleMsg::Mint {
761        recipient,
762        amount,
763        memo,
764        padding,
765    }
766        .to_cosmos_msg(block_size, callback_code_hash, contract_addr, None)
767}
768
769/// Returns a StdResult<CosmosMsg> used to execute BatchMint
770///
771/// # Arguments
772/// * `actions` - Batch of actions
773/// * `padding` - Optional String used as padding if you don't want to use block padding
774/// * `block_size` - pad the message to blocks of this size
775/// * `callback_code_hash` - String holding the code hash of the contract being called
776/// * `contract_addr` - address of the contract being called
777pub fn batch_mint_msg(
778    actions: Vec<MintAction>,
779    padding: Option<String>,
780    block_size: usize,
781    callback_code_hash: String,
782    contract_addr: HumanAddr,
783) -> StdResult<CosmosMsg> {
784    HandleMsg::BatchMint { actions, padding }.to_cosmos_msg(
785        block_size,
786        callback_code_hash,
787        contract_addr,
788        None,
789    )
790}
791
792/// Returns a StdResult<CosmosMsg> used to execute AddMinters
793///
794/// # Arguments
795///
796/// * `minters` - list of new addresses that will be allowed to mint
797/// * `padding` - Optional String used as padding if you don't want to use block padding
798/// * `block_size` - pad the message to blocks of this size
799/// * `callback_code_hash` - String holding the code hash of the contract being called
800/// * `contract_addr` - address of the contract being called
801pub fn add_minters_msg(
802    minters: Vec<HumanAddr>,
803    padding: Option<String>,
804    block_size: usize,
805    callback_code_hash: String,
806    contract_addr: HumanAddr,
807) -> StdResult<CosmosMsg> {
808    HandleMsg::AddMinters { minters, padding }.to_cosmos_msg(
809        block_size,
810        callback_code_hash,
811        contract_addr,
812        None,
813    )
814}
815
816/// Returns a StdResult<CosmosMsg> used to execute RemoveMinters
817///
818/// # Arguments
819///
820/// * `minters` - list of addresses that are no longer allowed to mint
821/// * `padding` - Optional String used as padding if you don't want to use block padding
822/// * `block_size` - pad the message to blocks of this size
823/// * `callback_code_hash` - String holding the code hash of the contract being called
824/// * `contract_addr` - address of the contract being called
825pub fn remove_minters_msg(
826    minters: Vec<HumanAddr>,
827    padding: Option<String>,
828    block_size: usize,
829    callback_code_hash: String,
830    contract_addr: HumanAddr,
831) -> StdResult<CosmosMsg> {
832    HandleMsg::RemoveMinters { minters, padding }.to_cosmos_msg(
833        block_size,
834        callback_code_hash,
835        contract_addr,
836        None,
837    )
838}
839
840/// Returns a StdResult<CosmosMsg> used to execute SetMinters
841///
842/// # Arguments
843///
844/// * `minters` - list of the only addresses that are allowed to mint
845/// * `padding` - Optional String used as padding if you don't want to use block padding
846/// * `block_size` - pad the message to blocks of this size
847/// * `callback_code_hash` - String holding the code hash of the contract being called
848/// * `contract_addr` - address of the contract being called
849pub fn set_minters_msg(
850    minters: Vec<HumanAddr>,
851    padding: Option<String>,
852    block_size: usize,
853    callback_code_hash: String,
854    contract_addr: HumanAddr,
855) -> StdResult<CosmosMsg> {
856    HandleMsg::SetMinters { minters, padding }.to_cosmos_msg(
857        block_size,
858        callback_code_hash,
859        contract_addr,
860        None,
861    )
862}
hermit_toolkit_hmip21/handle.rs

hermit_toolkit_hmip21/
handle.rs
