sdk-4mica 1.1.0

Official Rust SDK for interacting with the 4Mica payment network.
Documentation 
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

use alloy::primitives::U256;
use rpc::{
    AssetBalanceInfo as RpcAssetBalanceInfo, CollateralEventInfo as RpcCollateralEventInfo,
    GuaranteeInfo as RpcGuaranteeInfo, PendingRemunerationInfo as RpcPendingRemunerationInfo,
    TabInfo as RpcTabInfo, UserTransactionInfo as RpcUserTransactionInfo,
};

use crate::contract::Core4Mica;

#[derive(Debug, Clone)]
pub struct TabPaymentStatus {
    pub paid: U256,
    pub remunerated: bool,
    pub asset: String,
}

#[derive(Debug, Clone)]
pub struct UserInfo {
    pub asset: String,
    pub collateral: U256,
    pub withdrawal_request_amount: U256,
    pub withdrawal_request_timestamp: u64,
}

impl From<Core4Mica::UserAssetInfo> for UserInfo {
    fn from(value: Core4Mica::UserAssetInfo) -> Self {
        Self {
            asset: value.asset.to_string(),
            collateral: value.collateral,
            withdrawal_request_amount: value.withdrawalRequestAmount,
            withdrawal_request_timestamp: value.withdrawalRequestTimestamp.to(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct TabInfo {
    pub tab_id: U256,
    pub user_address: String,
    pub recipient_address: String,
    pub asset_address: String,
    pub start_timestamp: i64,
    pub ttl_seconds: i64,
    pub status: String,
    pub settlement_status: String,
    pub created_at: i64,
    pub updated_at: i64,
}

impl From<RpcTabInfo> for TabInfo {
    fn from(value: RpcTabInfo) -> Self {
        Self {
            tab_id: value.tab_id,
            user_address: value.user_address,
            recipient_address: value.recipient_address,
            asset_address: value.asset_address,
            start_timestamp: value.start_timestamp,
            ttl_seconds: value.ttl_seconds,
            status: value.status,
            settlement_status: value.settlement_status,
            created_at: value.created_at,
            updated_at: value.updated_at,
        }
    }
}

#[derive(Debug, Clone)]
pub struct GuaranteeInfo {
    pub tab_id: U256,
    pub req_id: U256,
    pub from_address: String,
    pub to_address: String,
    pub asset_address: String,
    pub amount: U256,
    pub timestamp: u64,
    pub certificate: Option<String>,
}

impl From<RpcGuaranteeInfo> for GuaranteeInfo {
    fn from(value: RpcGuaranteeInfo) -> Self {
        Self {
            tab_id: value.tab_id,
            req_id: value.req_id,
            from_address: value.from_address,
            to_address: value.to_address,
            asset_address: value.asset_address,
            amount: value.amount,
            timestamp: value.start_timestamp as u64,
            certificate: value.certificate,
        }
    }
}

#[derive(Debug, Clone)]
pub struct PendingRemunerationInfo {
    pub tab: TabInfo,
    pub latest_guarantee: Option<GuaranteeInfo>,
}

impl From<RpcPendingRemunerationInfo> for PendingRemunerationInfo {
    fn from(value: RpcPendingRemunerationInfo) -> Self {
        Self {
            tab: value.tab.into(),
            latest_guarantee: value.latest_guarantee.map(Into::into),
        }
    }
}

#[derive(Debug, Clone)]
pub struct CollateralEventInfo {
    pub id: String,
    pub user_address: String,
    pub asset_address: String,
    pub amount: U256,
    pub event_type: String,
    pub tab_id: Option<U256>,
    pub req_id: Option<U256>,
    pub tx_id: Option<String>,
    pub created_at: i64,
}

impl From<RpcCollateralEventInfo> for CollateralEventInfo {
    fn from(value: RpcCollateralEventInfo) -> Self {
        Self {
            id: value.id,
            user_address: value.user_address,
            asset_address: value.asset_address,
            amount: value.amount,
            event_type: value.event_type,
            tab_id: value.tab_id,
            req_id: value.req_id,
            tx_id: value.tx_id,
            created_at: value.created_at,
        }
    }
}

#[derive(Debug, Clone)]
pub struct AssetBalanceInfo {
    pub user_address: String,
    pub asset_address: String,
    pub total: U256,
    pub locked: U256,
    pub version: i32,
    pub updated_at: i64,
}

impl From<RpcAssetBalanceInfo> for AssetBalanceInfo {
    fn from(value: RpcAssetBalanceInfo) -> Self {
        Self {
            user_address: value.user_address,
            asset_address: value.asset_address,
            total: value.total,
            locked: value.locked,
            version: value.version,
            updated_at: value.updated_at,
        }
    }
}

#[derive(Debug, Clone)]
pub struct RecipientPaymentInfo {
    pub user_address: String,
    pub recipient_address: String,
    pub tx_hash: String,
    pub amount: U256,
    pub verified: bool,
    pub finalized: bool,
    pub failed: bool,
    pub created_at: i64,
}

impl From<RpcUserTransactionInfo> for RecipientPaymentInfo {
    fn from(value: RpcUserTransactionInfo) -> Self {
        Self {
            user_address: value.user_address,
            recipient_address: value.recipient_address,
            tx_hash: value.tx_hash,
            amount: value.amount,
            verified: value.verified,
            finalized: value.finalized,
            failed: value.failed,
            created_at: value.created_at,
        }
    }
}