tx · Qqu7YujWB4eP3xDxCGWezowjtw915C5a4CRVCvcowan

3Mvv4Qmio7P85Br7t9httZfdaLBXzrXM538:  -0.01400000 Waves

2024.06.14 18:59 [3150631] smart account 3Mvv4Qmio7P85Br7t9httZfdaLBXzrXM538 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Qqu7YujWB4eP3xDxCGWezowjtw915C5a4CRVCvcowan",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1718380744562,
    "version": 2,
    "chainId": 84,
    "sender": "3Mvv4Qmio7P85Br7t9httZfdaLBXzrXM538",
    "senderPublicKey": "6g48VSdUCvENRsNXmBm7cF8aTARRXFVoDpemzzjC69xH",
    "proofs": [
        "4f2J6pGaiTAYnXJ5CWGo5khLL8HXDkTyxxkh1GxutrNMf894pkqeda7A6YnHdUETBBWRAH3mAT9WaB6rD9Jb6N7m"
    ],
    "script": "base64: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",
    "height": 3150631,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 7xFchdX4EnwvMVvBUeWubHZG7qJkxL2xTEv8YKoYsvAt
Next: none

Diff: 
Old
New
Differences
17
17
 
18
18
 
let KEY_TOTAL_BALANCE = "TOTAL_BALANCE"
19
19
 
20
-
let KEY_GLOBAL_RATE = "GLOBAL_RATE"
21
-
22
20
 
let SPOT_WALLET = "SPOT"
23
21
 
24
22
 
let WITHDRAWALS_WALLET = "WITHDRAWALS"
25
23
 
24
+
let STAKING_REWARD_WALLET = "STAKING_REWARD"
25
+
26
26
 
let ZERO_BIGINT = toBigInt(0)
27
-
28
-
let ONE_BIGINT = toBigInt(1)
29
-
30
-
let PERCENT_FACTOR = toBigInt(1000000000000000000)
31
27
 
32
28
 
func _validateAddress (address_,err_) = match addressFromString(address_) {
33
29
 
    case a: Address => 
100
96
 
101
97
 
func _loadUserBalance (user_,wallet_,currency_) = match getString(makeString([KEY_USER_BALANCE, user_, wallet_, currency_], SEPARATOR)) {
102
98
 
    case a: String => 
103
-
        let struct = split(a, SEPARATOR)
104
-
        $Tuple2(parseBigIntValue(struct[0]), parseBigIntValue(struct[1]))
99
+
        parseBigIntValue(a)
105
100
 
    case _ => 
106
-
        $Tuple2(ZERO_BIGINT, PERCENT_FACTOR)
101
+
        ZERO_BIGINT
107
102
 
}
108
103
 
109
104
 
110
-
func _saveUserBalance (user_,wallet_,currency_,balance_,rate_) = [StringEntry(makeString([KEY_USER_BALANCE, user_, wallet_, currency_], SEPARATOR), makeString([toString(balance_), toString(rate_)], SEPARATOR))]
105
+
func _saveUserBalance (user_,wallet_,currency_,balance_) = [StringEntry(makeString([KEY_USER_BALANCE, user_, wallet_, currency_], SEPARATOR), toString(balance_))]
111
106
 
112
107
 
113
108
 
func _loadTotalBalance (currency_) = match getString(makeString([KEY_TOTAL_BALANCE, currency_], SEPARATOR)) {
119
114
 
120
115
 
121
116
 
func _saveTotalBalance (currency_,balance_) = [StringEntry(makeString([KEY_TOTAL_BALANCE, currency_], SEPARATOR), toString(balance_))]
122
-
123
-
124
-
func _loadGlobalRate (wallet_,currency_) = match getString(makeString([KEY_GLOBAL_RATE, wallet_, currency_], SEPARATOR)) {
125
-
    case a: String => 
126
-
        parseBigIntValue(a)
127
-
    case _ => 
128
-
        PERCENT_FACTOR
129
-
}
130
-
131
-
132
-
func _saveGlobalRate (wallet_,currency_,rate_) = [StringEntry(makeString([KEY_GLOBAL_RATE, wallet_, currency_], SEPARATOR), toString(rate_))]
133
117
 
134
118
 
135
119
 
func _onlyThisContract (caller_) = if ((caller_ != this))
160
144
 
func _validateMatcher (caller,err_) = if ((_loadMatcherContract() != caller))
161
145
 
    then throw(err_)
162
146
 
    else true
163
-
164
-
165
-
func _balanceOf (user_,wallet_,currency_) = {
166
-
    let $t048244905 = _loadUserBalance(user_, wallet_, currency_)
167
-
    let prevUserBalance = $t048244905._1
168
-
    let prevUserRate = $t048244905._2
169
-
    let currentRate = _loadGlobalRate(wallet_, currency_)
170
-
    $Tuple2(fraction(prevUserBalance, currentRate, prevUserRate, DOWN), currentRate)
171
-
    }
172
147
 
173
148
 
174
149
 
@Callable(i)
203
178
 
        else false
204
179
 
    if ((err == err))
205
180
 
        then {
206
-
            let $t061366207 = _balanceOf(user_, SPOT_WALLET, currency_)
207
-
            let userBalance = $t061366207._1
208
-
            let userRate = $t061366207._2
209
-
            $Tuple2((_saveUserBalance(user_, SPOT_WALLET, currency_, (userBalance + amount), userRate) ++ _saveTotalBalance(currency_, (_loadTotalBalance(currency_) + amount))), unit)
181
+
            let userBalance = _loadUserBalance(user_, SPOT_WALLET, currency_)
182
+
            $Tuple2((_saveUserBalance(user_, SPOT_WALLET, currency_, (userBalance + amount)) ++ _saveTotalBalance(currency_, (_loadTotalBalance(currency_) + amount))), unit)
210
183
 
            }
211
184
 
        else throw("Strict value is not equal to itself.")
212
185
 
    }
233
206
 
        else false
234
207
 
    if ((err == err))
235
208
 
        then {
236
-
            let $t073117396 = _balanceOf(user_, sourceWallet_, currency_)
237
-
            let userSourceBalance = $t073117396._1
238
-
            let userSourceRate = $t073117396._2
239
-
            let $t074017486 = _balanceOf(user_, targetWallet_, currency_)
240
-
            let userTargetBalance = $t074017486._1
241
-
            let userTargetRate = $t074017486._2
209
+
            let userSourceBalance = _loadUserBalance(user_, sourceWallet_, currency_)
210
+
            let userTargetBalance = _loadUserBalance(user_, targetWallet_, currency_)
242
211
 
            let newUserSourceBalance = (userSourceBalance - amount)
243
212
 
            let newUserTargetBalance = (userTargetBalance + amount)
244
213
 
            let err1 = _validateBigInt(newUserSourceBalance, ZERO_BIGINT, "internalTransfer: insufficient amount")
245
214
 
            if ((err1 == err1))
246
-
                then $Tuple2((_saveUserBalance(user_, sourceWallet_, currency_, newUserSourceBalance, userSourceRate) ++ _saveUserBalance(user_, targetWallet_, currency_, newUserTargetBalance, userTargetRate)), unit)
215
+
                then $Tuple2((_saveUserBalance(user_, sourceWallet_, currency_, newUserSourceBalance) ++ _saveUserBalance(user_, targetWallet_, currency_, newUserTargetBalance)), unit)
247
216
 
                else throw("Strict value is not equal to itself.")
248
217
 
            }
249
218
 
        else throw("Strict value is not equal to itself.")
265
234
 
        else false
266
235
 
    if ((err == err))
267
236
 
        then {
268
-
            let $t084288506 = _balanceOf(user_, WITHDRAWALS_WALLET, currency_)
269
-
            let userBalance = $t084288506._1
270
-
            let userRate = $t084288506._2
237
+
            let userBalance = _loadUserBalance(user_, WITHDRAWALS_WALLET, currency_)
271
238
 
            let newUserBalance = (userBalance - amount)
272
239
 
            let newTotalBalance = (_loadTotalBalance(currency_) - amount)
273
240
 
            let err1 = if (_validateBigInt(newUserBalance, ZERO_BIGINT, "withdraw: insufficient amount"))
274
241
 
                then _validateBigInt(newTotalBalance, ZERO_BIGINT, "withdraw: negative total balance")
275
242
 
                else false
276
243
 
            if ((err1 == err1))
277
-
                then $Tuple2((_saveUserBalance(user_, WITHDRAWALS_WALLET, currency_, newUserBalance, userRate) ++ _saveTotalBalance(currency_, newTotalBalance)), unit)
244
+
                then $Tuple2((_saveUserBalance(user_, WITHDRAWALS_WALLET, currency_, newUserBalance) ++ _saveTotalBalance(currency_, newTotalBalance)), unit)
278
245
 
                else throw("Strict value is not equal to itself.")
279
246
 
            }
280
247
 
        else throw("Strict value is not equal to itself.")
281
248
 
    }
282
-
283
-
284
-
285
-
@Callable(i)
286
-
func addStakingReward (wallet_,currency_,amount_) = $Tuple2(nil, unit)
287
249
 
288
250
 
289
251
 
310
272
 
        else false
311
273
 
    if ((err == err))
312
274
 
        then {
313
-
            let $t01011010189 = _balanceOf(from_, wallet_, currency_)
314
-
            let userSourceBalance = $t01011010189._1
315
-
            let userSourceRate = $t01011010189._2
316
-
            let $t01019410271 = _balanceOf(to_, wallet_, currency_)
317
-
            let userTargetBalance = $t01019410271._1
318
-
            let userTargetRate = $t01019410271._2
319
-
            let $t01027610352 = _balanceOf(dex_, wallet_, currency_)
320
-
            let dexTargetBalance = $t01027610352._1
321
-
            let dexTargetRate = $t01027610352._2
275
+
            let userSourceBalance = _loadUserBalance(from_, wallet_, currency_)
276
+
            let userTargetBalance = _loadUserBalance(to_, wallet_, currency_)
277
+
            let dexTargetBalance = _loadUserBalance(dex_, wallet_, currency_)
322
278
 
            let newUserSourceBalance = ((userSourceBalance - amount) - fee)
323
279
 
            let newUserTargetBalance = (userTargetBalance + amount)
324
280
 
            let newDexTargetBalance = (dexTargetBalance + fee)
325
281
 
            let err1 = _validateBigInt(newUserSourceBalance, ZERO_BIGINT, "externalTransfer: insufficient amount")
326
282
 
            if ((err1 == err1))
327
-
                then $Tuple2(((_saveUserBalance(from_, wallet_, currency_, newUserSourceBalance, userSourceRate) ++ _saveUserBalance(to_, wallet_, currency_, newUserTargetBalance, userTargetRate)) ++ _saveUserBalance(dex_, wallet_, currency_, newDexTargetBalance, dexTargetRate)), unit)
283
+
                then $Tuple2(((_saveUserBalance(from_, wallet_, currency_, newUserSourceBalance) ++ _saveUserBalance(to_, wallet_, currency_, newUserTargetBalance)) ++ _saveUserBalance(dex_, wallet_, currency_, newDexTargetBalance)), unit)
328
284
 
                else throw("Strict value is not equal to itself.")
329
285
 
            }
330
286
 
        else throw("Strict value is not equal to itself.")
333
289
 
334
290
 
335
291
 
@Callable(i)
336
-
func getUserBalance (user_,wallet_,currency_) = {
337
-
    let $t01138411451 = _balanceOf(user_, wallet_, currency_)
338
-
    let userBalance = $t01138411451._1
339
-
    let userRate = $t01138411451._2
340
-
    $Tuple2(nil, toString(userBalance))
292
+
func depositStakingReward (dex_,currency_,amount_) = {
293
+
    let amount = valueOrErrorMessage(parseBigInt(amount_), "depositStakingReward: amount not int")
294
+
    let err = if (if (if (if (_whenInitialized())
295
+
        then _validateString(dex_, "depositStakingReward: invalid dex")
296
+
        else false)
297
+
        then _validateString(currency_, "depositStakingReward: invalid currency")
298
+
        else false)
299
+
        then _validateBigInt(amount, ZERO_BIGINT, "depositStakingReward: invalid amount")
300
+
        else false)
301
+
        then _validateGateway(i.caller, "depositStakingReward: invalid caller")
302
+
        else false
303
+
    if ((err == err))
304
+
        then {
305
+
            let userBalance = _loadUserBalance(dex_, STAKING_REWARD_WALLET, currency_)
306
+
            $Tuple2((_saveUserBalance(dex_, STAKING_REWARD_WALLET, currency_, (userBalance + amount)) ++ _saveTotalBalance(currency_, (_loadTotalBalance(currency_) + amount))), unit)
307
+
            }
308
+
        else throw("Strict value is not equal to itself.")
341
309
 
    }
310
+
311
+
312
+
313
+
@Callable(i)
314
+
func claimReward (dex_,user_,currency_,amount_) = {
315
+
    let amount = valueOrErrorMessage(parseBigInt(amount_), "claimReward: amount not int")
316
+
    let err = if (if (if (if (if (_whenInitialized())
317
+
        then _validateString(dex_, "claimReward: invalid dex")
318
+
        else false)
319
+
        then _validateString(user_, "claimReward: invalid user")
320
+
        else false)
321
+
        then _validateString(currency_, "claimReward: invalid currency")
322
+
        else false)
323
+
        then _validateBigInt(amount, ZERO_BIGINT, "claimReward: invalid amount")
324
+
        else false)
325
+
        then _validateMatcher(i.caller, "claimReward: invalid matcher caller")
326
+
        else false
327
+
    if ((err == err))
328
+
        then {
329
+
            let dexSourceBalance = _loadUserBalance(dex_, STAKING_REWARD_WALLET, currency_)
330
+
            let userTargetBalance = _loadUserBalance(user_, SPOT_WALLET, currency_)
331
+
            let newDexSourceBalance = (dexSourceBalance - amount)
332
+
            let newUserTargetBalance = (userTargetBalance + amount)
333
+
            let err1 = _validateBigInt(newDexSourceBalance, ZERO_BIGINT, "claimReward: insufficient amount")
334
+
            if ((err1 == err1))
335
+
                then $Tuple2((_saveUserBalance(dex_, STAKING_REWARD_WALLET, currency_, newDexSourceBalance) ++ _saveUserBalance(user_, SPOT_WALLET, currency_, newUserTargetBalance)), unit)
336
+
                else throw("Strict value is not equal to itself.")
337
+
            }
338
+
        else throw("Strict value is not equal to itself.")
339
+
    }
340
+
341
+
342
+
343
+
@Callable(i)
344
+
func getUserBalance (user_,wallet_,currency_) = $Tuple2(nil, toString(_loadUserBalance(user_, wallet_, currency_)))
342
345
 
343
346
 
344
347
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 7 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SEPARATOR = "__"
5
5
 
6
6
 
let KEY_MULTISIG = "MULTISIG"
7
7
 
8
8
 
let KEY_STATUS = "STATUS"
9
9
 
10
10
 
let KEY_INIT = "INIT"
11
11
 
12
12
 
let KEY_GATEWAY_CONTRACT = "GATEWAY_CONTRACT"
13
13
 
14
14
 
let KEY_MATCHER_CONTRACT = "MATCHER_CONTRACT"
15
15
 
16
16
 
let KEY_USER_BALANCE = "USER_BALANCE"
17
17
 
18
18
 
let KEY_TOTAL_BALANCE = "TOTAL_BALANCE"
19
19
 
20
-
let KEY_GLOBAL_RATE = "GLOBAL_RATE"
21
-
22
20
 
let SPOT_WALLET = "SPOT"
23
21
 
24
22
 
let WITHDRAWALS_WALLET = "WITHDRAWALS"
25
23
 
24
+
let STAKING_REWARD_WALLET = "STAKING_REWARD"
25
+
26
26
 
let ZERO_BIGINT = toBigInt(0)
27
-
28
-
let ONE_BIGINT = toBigInt(1)
29
-
30
-
let PERCENT_FACTOR = toBigInt(1000000000000000000)
31
27
 
32
28
 
func _validateAddress (address_,err_) = match addressFromString(address_) {
33
29
 
    case a: Address => 
34
30
 
        true
35
31
 
    case _ => 
36
32
 
        throw(err_)
37
33
 
}
38
34
 
39
35
 
40
36
 
func _validateBigInt (val_,lowerBoundary_,err_) = if ((lowerBoundary_ > val_))
41
37
 
    then throw(err_)
42
38
 
    else true
43
39
 
44
40
 
45
41
 
func _validateString (val_,err_) = if (if ((0 >= size(val_)))
46
42
 
    then true
47
43
 
    else contains(val_, SEPARATOR))
48
44
 
    then throw(err_)
49
45
 
    else true
50
46
 
51
47
 
52
48
 
func _validateStringEqual (val1_,val2_,err_) = if ((val1_ != val2_))
53
49
 
    then throw(err_)
54
50
 
    else true
55
51
 
56
52
 
57
53
 
func _loadInit () = match getBoolean(KEY_INIT) {
58
54
 
    case a: Boolean => 
59
55
 
        a
60
56
 
    case _ => 
61
57
 
        false
62
58
 
}
63
59
 
64
60
 
65
61
 
func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
66
62
 
67
63
 
68
64
 
func _loadMultisig () = match getString(KEY_MULTISIG) {
69
65
 
    case a: String => 
70
66
 
        addressFromStringValue(a)
71
67
 
    case _ => 
72
68
 
        Address(base58'')
73
69
 
}
74
70
 
75
71
 
76
72
 
func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
77
73
 
78
74
 
79
75
 
func _loadGatewayContract () = match getString(KEY_GATEWAY_CONTRACT) {
80
76
 
    case a: String => 
81
77
 
        addressFromStringValue(a)
82
78
 
    case _ => 
83
79
 
        Address(base58'')
84
80
 
}
85
81
 
86
82
 
87
83
 
func _saveGatewayContract (gatewayContract_) = [StringEntry(KEY_GATEWAY_CONTRACT, toString(gatewayContract_))]
88
84
 
89
85
 
90
86
 
func _loadMatcherContract () = match getString(KEY_MATCHER_CONTRACT) {
91
87
 
    case a: String => 
92
88
 
        addressFromStringValue(a)
93
89
 
    case _ => 
94
90
 
        Address(base58'')
95
91
 
}
96
92
 
97
93
 
98
94
 
func _saveMatcherContract (matcherContract_) = [StringEntry(KEY_MATCHER_CONTRACT, toString(matcherContract_))]
99
95
 
100
96
 
101
97
 
func _loadUserBalance (user_,wallet_,currency_) = match getString(makeString([KEY_USER_BALANCE, user_, wallet_, currency_], SEPARATOR)) {
102
98
 
    case a: String => 
103
-
        let struct = split(a, SEPARATOR)
104
-
        $Tuple2(parseBigIntValue(struct[0]), parseBigIntValue(struct[1]))
99
+
        parseBigIntValue(a)
105
100
 
    case _ => 
106
-
        $Tuple2(ZERO_BIGINT, PERCENT_FACTOR)
101
+
        ZERO_BIGINT
107
102
 
}
108
103
 
109
104
 
110
-
func _saveUserBalance (user_,wallet_,currency_,balance_,rate_) = [StringEntry(makeString([KEY_USER_BALANCE, user_, wallet_, currency_], SEPARATOR), makeString([toString(balance_), toString(rate_)], SEPARATOR))]
105
+
func _saveUserBalance (user_,wallet_,currency_,balance_) = [StringEntry(makeString([KEY_USER_BALANCE, user_, wallet_, currency_], SEPARATOR), toString(balance_))]
111
106
 
112
107
 
113
108
 
func _loadTotalBalance (currency_) = match getString(makeString([KEY_TOTAL_BALANCE, currency_], SEPARATOR)) {
114
109
 
    case a: String => 
115
110
 
        parseBigIntValue(a)
116
111
 
    case _ => 
117
112
 
        ZERO_BIGINT
118
113
 
}
119
114
 
120
115
 
121
116
 
func _saveTotalBalance (currency_,balance_) = [StringEntry(makeString([KEY_TOTAL_BALANCE, currency_], SEPARATOR), toString(balance_))]
122
-
123
-
124
-
func _loadGlobalRate (wallet_,currency_) = match getString(makeString([KEY_GLOBAL_RATE, wallet_, currency_], SEPARATOR)) {
125
-
    case a: String => 
126
-
        parseBigIntValue(a)
127
-
    case _ => 
128
-
        PERCENT_FACTOR
129
-
}
130
-
131
-
132
-
func _saveGlobalRate (wallet_,currency_,rate_) = [StringEntry(makeString([KEY_GLOBAL_RATE, wallet_, currency_], SEPARATOR), toString(rate_))]
133
117
 
134
118
 
135
119
 
func _onlyThisContract (caller_) = if ((caller_ != this))
136
120
 
    then throw("_onlyThisContract: revert")
137
121
 
    else true
138
122
 
139
123
 
140
124
 
func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
141
125
 
    then throw("_whenMultisigSet: revert")
142
126
 
    else true
143
127
 
144
128
 
145
129
 
func _whenNotInitialized () = if (_loadInit())
146
130
 
    then throw("_whenNotInitialized: revert")
147
131
 
    else true
148
132
 
149
133
 
150
134
 
func _whenInitialized () = if (!(_loadInit()))
151
135
 
    then throw("_whenInitialized: revert")
152
136
 
    else true
153
137
 
154
138
 
155
139
 
func _validateGateway (caller,err_) = if ((_loadGatewayContract() != caller))
156
140
 
    then throw(err_)
157
141
 
    else true
158
142
 
159
143
 
160
144
 
func _validateMatcher (caller,err_) = if ((_loadMatcherContract() != caller))
161
145
 
    then throw(err_)
162
146
 
    else true
163
-
164
-
165
-
func _balanceOf (user_,wallet_,currency_) = {
166
-
    let $t048244905 = _loadUserBalance(user_, wallet_, currency_)
167
-
    let prevUserBalance = $t048244905._1
168
-
    let prevUserRate = $t048244905._2
169
-
    let currentRate = _loadGlobalRate(wallet_, currency_)
170
-
    $Tuple2(fraction(prevUserBalance, currentRate, prevUserRate, DOWN), currentRate)
171
-
    }
172
147
 
173
148
 
174
149
 
@Callable(i)
175
150
 
func init (gatewayContract_,matcherContract_) = {
176
151
 
    let err = if (if (if (if (_onlyThisContract(i.caller))
177
152
 
        then _whenNotInitialized()
178
153
 
        else false)
179
154
 
        then _whenMultisigSet()
180
155
 
        else false)
181
156
 
        then _validateAddress(gatewayContract_, "init: invalid gatewayContract")
182
157
 
        else false)
183
158
 
        then _validateAddress(matcherContract_, "init: invalid matcherContract")
184
159
 
        else false
185
160
 
    if ((err == err))
186
161
 
        then $Tuple2(((_saveInit(true) ++ _saveGatewayContract(addressFromStringValue(gatewayContract_))) ++ _saveMatcherContract(addressFromStringValue(matcherContract_))), unit)
187
162
 
        else throw("Strict value is not equal to itself.")
188
163
 
    }
189
164
 
190
165
 
191
166
 
192
167
 
@Callable(i)
193
168
 
func deposit (user_,currency_,amount_) = {
194
169
 
    let amount = valueOrErrorMessage(parseBigInt(amount_), "deposit: amount not int")
195
170
 
    let err = if (if (if (if (_whenInitialized())
196
171
 
        then _validateString(user_, "deposit: invalid user")
197
172
 
        else false)
198
173
 
        then _validateString(currency_, "deposit: invalid currency")
199
174
 
        else false)
200
175
 
        then _validateBigInt(amount, ZERO_BIGINT, "deposit: invalid amount")
201
176
 
        else false)
202
177
 
        then _validateGateway(i.caller, "deposit: invalid caller")
203
178
 
        else false
204
179
 
    if ((err == err))
205
180
 
        then {
206
-
            let $t061366207 = _balanceOf(user_, SPOT_WALLET, currency_)
207
-
            let userBalance = $t061366207._1
208
-
            let userRate = $t061366207._2
209
-
            $Tuple2((_saveUserBalance(user_, SPOT_WALLET, currency_, (userBalance + amount), userRate) ++ _saveTotalBalance(currency_, (_loadTotalBalance(currency_) + amount))), unit)
181
+
            let userBalance = _loadUserBalance(user_, SPOT_WALLET, currency_)
182
+
            $Tuple2((_saveUserBalance(user_, SPOT_WALLET, currency_, (userBalance + amount)) ++ _saveTotalBalance(currency_, (_loadTotalBalance(currency_) + amount))), unit)
210
183
 
            }
211
184
 
        else throw("Strict value is not equal to itself.")
212
185
 
    }
213
186
 
214
187
 
215
188
 
216
189
 
@Callable(i)
217
190
 
func internalTransfer (user_,sourceWallet_,targetWallet_,currency_,amount_) = {
218
191
 
    let amount = valueOrErrorMessage(parseBigInt(amount_), "internalTransfer: amount not int")
219
192
 
    let err = if (if (if (if (if (if (_whenInitialized())
220
193
 
        then _validateString(user_, "internalTransfer: invalid user")
221
194
 
        else false)
222
195
 
        then _validateString(sourceWallet_, "internalTransfer: invalid sourceWallet")
223
196
 
        else false)
224
197
 
        then _validateString(targetWallet_, "internalTransfer: invalid targetWallet")
225
198
 
        else false)
226
199
 
        then _validateString(currency_, "internalTransfer: invalid currency")
227
200
 
        else false)
228
201
 
        then _validateBigInt(amount, ZERO_BIGINT, "internalTransfer: invalid amount")
229
202
 
        else false)
230
203
 
        then if ((targetWallet_ == WITHDRAWALS_WALLET))
231
204
 
            then _validateGateway(i.caller, "internalTransfer: invalid gw caller")
232
205
 
            else _validateMatcher(i.caller, "internalTransfer: invalid matcher caller")
233
206
 
        else false
234
207
 
    if ((err == err))
235
208
 
        then {
236
-
            let $t073117396 = _balanceOf(user_, sourceWallet_, currency_)
237
-
            let userSourceBalance = $t073117396._1
238
-
            let userSourceRate = $t073117396._2
239
-
            let $t074017486 = _balanceOf(user_, targetWallet_, currency_)
240
-
            let userTargetBalance = $t074017486._1
241
-
            let userTargetRate = $t074017486._2
209
+
            let userSourceBalance = _loadUserBalance(user_, sourceWallet_, currency_)
210
+
            let userTargetBalance = _loadUserBalance(user_, targetWallet_, currency_)
242
211
 
            let newUserSourceBalance = (userSourceBalance - amount)
243
212
 
            let newUserTargetBalance = (userTargetBalance + amount)
244
213
 
            let err1 = _validateBigInt(newUserSourceBalance, ZERO_BIGINT, "internalTransfer: insufficient amount")
245
214
 
            if ((err1 == err1))
246
-
                then $Tuple2((_saveUserBalance(user_, sourceWallet_, currency_, newUserSourceBalance, userSourceRate) ++ _saveUserBalance(user_, targetWallet_, currency_, newUserTargetBalance, userTargetRate)), unit)
215
+
                then $Tuple2((_saveUserBalance(user_, sourceWallet_, currency_, newUserSourceBalance) ++ _saveUserBalance(user_, targetWallet_, currency_, newUserTargetBalance)), unit)
247
216
 
                else throw("Strict value is not equal to itself.")
248
217
 
            }
249
218
 
        else throw("Strict value is not equal to itself.")
250
219
 
    }
251
220
 
252
221
 
253
222
 
254
223
 
@Callable(i)
255
224
 
func withdraw (user_,currency_,amount_) = {
256
225
 
    let amount = valueOrErrorMessage(parseBigInt(amount_), "withdraw: amount not int")
257
226
 
    let err = if (if (if (if (_whenInitialized())
258
227
 
        then _validateString(user_, "withdraw: invalid user")
259
228
 
        else false)
260
229
 
        then _validateString(currency_, "withdraw: invalid currency")
261
230
 
        else false)
262
231
 
        then _validateBigInt(amount, ZERO_BIGINT, "withdraw: invalid amount")
263
232
 
        else false)
264
233
 
        then _validateGateway(i.caller, "withdraw: invalid caller")
265
234
 
        else false
266
235
 
    if ((err == err))
267
236
 
        then {
268
-
            let $t084288506 = _balanceOf(user_, WITHDRAWALS_WALLET, currency_)
269
-
            let userBalance = $t084288506._1
270
-
            let userRate = $t084288506._2
237
+
            let userBalance = _loadUserBalance(user_, WITHDRAWALS_WALLET, currency_)
271
238
 
            let newUserBalance = (userBalance - amount)
272
239
 
            let newTotalBalance = (_loadTotalBalance(currency_) - amount)
273
240
 
            let err1 = if (_validateBigInt(newUserBalance, ZERO_BIGINT, "withdraw: insufficient amount"))
274
241
 
                then _validateBigInt(newTotalBalance, ZERO_BIGINT, "withdraw: negative total balance")
275
242
 
                else false
276
243
 
            if ((err1 == err1))
277
-
                then $Tuple2((_saveUserBalance(user_, WITHDRAWALS_WALLET, currency_, newUserBalance, userRate) ++ _saveTotalBalance(currency_, newTotalBalance)), unit)
244
+
                then $Tuple2((_saveUserBalance(user_, WITHDRAWALS_WALLET, currency_, newUserBalance) ++ _saveTotalBalance(currency_, newTotalBalance)), unit)
278
245
 
                else throw("Strict value is not equal to itself.")
279
246
 
            }
280
247
 
        else throw("Strict value is not equal to itself.")
281
248
 
    }
282
-
283
-
284
-
285
-
@Callable(i)
286
-
func addStakingReward (wallet_,currency_,amount_) = $Tuple2(nil, unit)
287
249
 
288
250
 
289
251
 
290
252
 
@Callable(i)
291
253
 
func externalTransfer (wallet_,currency_,from_,to_,amount_,fee_,dex_) = {
292
254
 
    let amount = valueOrErrorMessage(parseBigInt(amount_), "externalTransfer: amount not int")
293
255
 
    let fee = valueOrErrorMessage(parseBigInt(fee_), "externalTransfer: fee not int")
294
256
 
    let err = if (if (if (if (if (if (if (if (_whenInitialized())
295
257
 
        then _validateString(wallet_, "externalTransfer: invalid wallet")
296
258
 
        else false)
297
259
 
        then _validateString(currency_, "externalTransfer: invalid currency")
298
260
 
        else false)
299
261
 
        then _validateString(from_, "externalTransfer: invalid from")
300
262
 
        else false)
301
263
 
        then _validateString(to_, "externalTransfer: invalid to")
302
264
 
        else false)
303
265
 
        then _validateBigInt(amount, ZERO_BIGINT, "externalTransfer: invalid amount")
304
266
 
        else false)
305
267
 
        then _validateBigInt(fee, ZERO_BIGINT, "externalTransfer: invalid fee")
306
268
 
        else false)
307
269
 
        then _validateString(dex_, "externalTransfer: invalid dex")
308
270
 
        else false)
309
271
 
        then _validateMatcher(i.caller, "externalTransfer: invalid matcher caller")
310
272
 
        else false
311
273
 
    if ((err == err))
312
274
 
        then {
313
-
            let $t01011010189 = _balanceOf(from_, wallet_, currency_)
314
-
            let userSourceBalance = $t01011010189._1
315
-
            let userSourceRate = $t01011010189._2
316
-
            let $t01019410271 = _balanceOf(to_, wallet_, currency_)
317
-
            let userTargetBalance = $t01019410271._1
318
-
            let userTargetRate = $t01019410271._2
319
-
            let $t01027610352 = _balanceOf(dex_, wallet_, currency_)
320
-
            let dexTargetBalance = $t01027610352._1
321
-
            let dexTargetRate = $t01027610352._2
275
+
            let userSourceBalance = _loadUserBalance(from_, wallet_, currency_)
276
+
            let userTargetBalance = _loadUserBalance(to_, wallet_, currency_)
277
+
            let dexTargetBalance = _loadUserBalance(dex_, wallet_, currency_)
322
278
 
            let newUserSourceBalance = ((userSourceBalance - amount) - fee)
323
279
 
            let newUserTargetBalance = (userTargetBalance + amount)
324
280
 
            let newDexTargetBalance = (dexTargetBalance + fee)
325
281
 
            let err1 = _validateBigInt(newUserSourceBalance, ZERO_BIGINT, "externalTransfer: insufficient amount")
326
282
 
            if ((err1 == err1))
327
-
                then $Tuple2(((_saveUserBalance(from_, wallet_, currency_, newUserSourceBalance, userSourceRate) ++ _saveUserBalance(to_, wallet_, currency_, newUserTargetBalance, userTargetRate)) ++ _saveUserBalance(dex_, wallet_, currency_, newDexTargetBalance, dexTargetRate)), unit)
283
+
                then $Tuple2(((_saveUserBalance(from_, wallet_, currency_, newUserSourceBalance) ++ _saveUserBalance(to_, wallet_, currency_, newUserTargetBalance)) ++ _saveUserBalance(dex_, wallet_, currency_, newDexTargetBalance)), unit)
328
284
 
                else throw("Strict value is not equal to itself.")
329
285
 
            }
330
286
 
        else throw("Strict value is not equal to itself.")
331
287
 
    }
332
288
 
333
289
 
334
290
 
335
291
 
@Callable(i)
336
-
func getUserBalance (user_,wallet_,currency_) = {
337
-
    let $t01138411451 = _balanceOf(user_, wallet_, currency_)
338
-
    let userBalance = $t01138411451._1
339
-
    let userRate = $t01138411451._2
340
-
    $Tuple2(nil, toString(userBalance))
292
+
func depositStakingReward (dex_,currency_,amount_) = {
293
+
    let amount = valueOrErrorMessage(parseBigInt(amount_), "depositStakingReward: amount not int")
294
+
    let err = if (if (if (if (_whenInitialized())
295
+
        then _validateString(dex_, "depositStakingReward: invalid dex")
296
+
        else false)
297
+
        then _validateString(currency_, "depositStakingReward: invalid currency")
298
+
        else false)
299
+
        then _validateBigInt(amount, ZERO_BIGINT, "depositStakingReward: invalid amount")
300
+
        else false)
301
+
        then _validateGateway(i.caller, "depositStakingReward: invalid caller")
302
+
        else false
303
+
    if ((err == err))
304
+
        then {
305
+
            let userBalance = _loadUserBalance(dex_, STAKING_REWARD_WALLET, currency_)
306
+
            $Tuple2((_saveUserBalance(dex_, STAKING_REWARD_WALLET, currency_, (userBalance + amount)) ++ _saveTotalBalance(currency_, (_loadTotalBalance(currency_) + amount))), unit)
307
+
            }
308
+
        else throw("Strict value is not equal to itself.")
341
309
 
    }
310
+
311
+
312
+
313
+
@Callable(i)
314
+
func claimReward (dex_,user_,currency_,amount_) = {
315
+
    let amount = valueOrErrorMessage(parseBigInt(amount_), "claimReward: amount not int")
316
+
    let err = if (if (if (if (if (_whenInitialized())
317
+
        then _validateString(dex_, "claimReward: invalid dex")
318
+
        else false)
319
+
        then _validateString(user_, "claimReward: invalid user")
320
+
        else false)
321
+
        then _validateString(currency_, "claimReward: invalid currency")
322
+
        else false)
323
+
        then _validateBigInt(amount, ZERO_BIGINT, "claimReward: invalid amount")
324
+
        else false)
325
+
        then _validateMatcher(i.caller, "claimReward: invalid matcher caller")
326
+
        else false
327
+
    if ((err == err))
328
+
        then {
329
+
            let dexSourceBalance = _loadUserBalance(dex_, STAKING_REWARD_WALLET, currency_)
330
+
            let userTargetBalance = _loadUserBalance(user_, SPOT_WALLET, currency_)
331
+
            let newDexSourceBalance = (dexSourceBalance - amount)
332
+
            let newUserTargetBalance = (userTargetBalance + amount)
333
+
            let err1 = _validateBigInt(newDexSourceBalance, ZERO_BIGINT, "claimReward: insufficient amount")
334
+
            if ((err1 == err1))
335
+
                then $Tuple2((_saveUserBalance(dex_, STAKING_REWARD_WALLET, currency_, newDexSourceBalance) ++ _saveUserBalance(user_, SPOT_WALLET, currency_, newUserTargetBalance)), unit)
336
+
                else throw("Strict value is not equal to itself.")
337
+
            }
338
+
        else throw("Strict value is not equal to itself.")
339
+
    }
340
+
341
+
342
+
343
+
@Callable(i)
344
+
func getUserBalance (user_,wallet_,currency_) = $Tuple2(nil, toString(_loadUserBalance(user_, wallet_, currency_)))
342
345
 
343
346
 
344
347
 
345
348
 
@Callable(i)
346
349
 
func setMultisig (multisig_) = {
347
350
 
    let err = if (_onlyThisContract(i.caller))
348
351
 
        then _validateAddress(multisig_, "setMultisig: invalid multisig")
349
352
 
        else false
350
353
 
    if ((err == err))
351
354
 
        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
352
355
 
        else throw("Strict value is not equal to itself.")
353
356
 
    }
354
357
 
355
358
 
356
359
 
@Verifier(tx)
357
360
 
func verify () = match tx {
358
361
 
    case _ => 
359
362
 
        match getString(KEY_MULTISIG) {
360
363
 
            case multisig: String => 
361
364
 
                valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
362
365
 
            case _ => 
363
366
 
                sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
364
367
 
        }
365
368
 
}
366
369
 

github/deemru/w8io/c3f4982 
40.59 ms ◑