1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use ic_cdk::api::call::CallResult;
use ic_cdk::call;
use ic_cdk::export::candid::Principal;

use crate::types::{
    BurnRequest, DequeueRecurrentTaskRequest, DequeueRecurrentTaskResponse, GetBalanceOfRequest,
    GetBalanceOfResponse, GetControllersResponse, GetInfoResponse, GetRecurrentMintTasksResponse,
    GetRecurrentTransferTasksRequest, GetRecurrentTransferTasksResponse, GetTotalSupplyResponse,
    TransferRequest, UpdateControllersRequest, UpdateControllersResponse, UpdateInfoRequest,
    UpdateInfoResponse,
};

/// Client struct for easier interaction from other rust canisters
pub struct CurrencyTokenClient {
    pub canister_id: Principal,
}

impl CurrencyTokenClient {
    #[inline(always)]
    pub fn new(canister_id: Principal) -> Self {
        CurrencyTokenClient { canister_id }
    }

    #[inline(always)]
    pub async fn mint(&self, request: TransferRequest) -> CallResult<()> {
        call(self.canister_id, "mint", (request,)).await
    }

    #[inline(always)]
    pub async fn transfer(&self, request: TransferRequest) -> CallResult<()> {
        call(self.canister_id, "transfer", (request,)).await
    }

    #[inline(always)]
    pub async fn burn(&self, request: BurnRequest) -> CallResult<()> {
        call(self.canister_id, "burn", (request,)).await
    }

    #[inline(always)]
    pub async fn get_balance_of(
        &self,
        request: GetBalanceOfRequest,
    ) -> CallResult<(GetBalanceOfResponse,)> {
        call(self.canister_id, "get_balance_of", (request,)).await
    }

    #[inline(always)]
    pub async fn get_total_supply(&self) -> CallResult<(GetTotalSupplyResponse,)> {
        call(self.canister_id, "get_total_supply", ()).await
    }

    #[inline(always)]
    pub async fn get_info(&self) -> CallResult<(GetInfoResponse,)> {
        call(self.canister_id, "get_info", ()).await
    }

    #[inline(always)]
    pub async fn update_info(
        &self,
        request: UpdateInfoRequest,
    ) -> CallResult<(UpdateInfoResponse,)> {
        call(self.canister_id, "update_info", (request,)).await
    }

    #[inline(always)]
    pub async fn get_controllers(&self) -> CallResult<(GetControllersResponse,)> {
        call(self.canister_id, "get_controllers", ()).await
    }

    #[inline(always)]
    pub async fn update_info_controller(
        &self,
        request: UpdateControllersRequest,
    ) -> CallResult<(UpdateControllersResponse,)> {
        call(self.canister_id, "update_info_controller", (request,)).await
    }

    #[inline(always)]
    pub async fn update_mint_controller(
        &self,
        request: UpdateControllersRequest,
    ) -> CallResult<(UpdateControllersResponse,)> {
        call(self.canister_id, "update_mint_controller", (request,)).await
    }

    #[inline(always)]
    pub async fn dequeue_recurrent_transfer_tasks(
        &self,
        request: DequeueRecurrentTaskRequest,
    ) -> CallResult<(DequeueRecurrentTaskResponse,)> {
        call(
            self.canister_id,
            "dequeue_recurrent_transfer_tasks",
            (request,),
        )
        .await
    }

    #[inline(always)]
    pub async fn get_recurrent_transfer_tasks(
        &self,
        request: GetRecurrentTransferTasksRequest,
    ) -> CallResult<(GetRecurrentTransferTasksResponse,)> {
        call(self.canister_id, "get_recurrent_transfer_tasks", (request,)).await
    }

    #[inline(always)]
    pub async fn dequeue_recurrent_mint_tasks(
        &self,
        request: DequeueRecurrentTaskRequest,
    ) -> CallResult<(DequeueRecurrentTaskResponse,)> {
        call(self.canister_id, "dequeue_recurrent_mint_tasks", (request,)).await
    }

    #[inline(always)]
    pub async fn get_recurrent_mint_tasks(&self) -> CallResult<(GetRecurrentMintTasksResponse,)> {
        call(self.canister_id, "get_recurrent_mint_tasks", ()).await
    }
}