tx · 7xFchdX4EnwvMVvBUeWubHZG7qJkxL2xTEv8YKoYsvAt

3Mvv4Qmio7P85Br7t9httZfdaLBXzrXM538:  -0.01400000 Waves

2024.04.01 18:26 [3043891] smart account 3Mvv4Qmio7P85Br7t9httZfdaLBXzrXM538 > SELF 0.00000000 Waves

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

View: original | compacted
Prev: none
Next: none

Full: 

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