tx · Eo9sx1pFjrdQVHZjHcGUAnpKZBMdzN2bBLct5uaKV68Q

3MxZ7YNAqigXR5jrgvpb48Uc6B29ouDzQyN:  -0.03400000 Waves

2023.03.06 22:39 [2478657] smart account 3MxZ7YNAqigXR5jrgvpb48Uc6B29ouDzQyN > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Eo9sx1pFjrdQVHZjHcGUAnpKZBMdzN2bBLct5uaKV68Q",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1678131559886,
    "version": 2,
    "chainId": 84,
    "sender": "3MxZ7YNAqigXR5jrgvpb48Uc6B29ouDzQyN",
    "senderPublicKey": "HHCdafdi3D2htEYJw8cBoNYC8w76euLWKYENK4kanmGM",
    "proofs": [
        "5WgjbfEw9aJJdrAdKj3H6vsH9rPJtqBo7o76YNfngoTdYVJBupdCq9JiYJzV4eQC6qgAN8gt4RPG7yCc5h5Bqh8u"
    ],
    "script": "base64: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",
    "height": 2478657,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: AejWijU8Z9T6JnLSGmZ75dH1xNnQj4RGUwa9UNthJe8m

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let k_totalSupply = "k_totalSupply"
5+
6+let k_rewardBalance = "k_rewardBalance"
7+
8+let k_lockedBalance = "k_lockedBalance"
9+
10+let k_freeBalance = "k_freeBalance"
11+
12+let k_rate = "k_rate"
13+
14+let k_lastUpdateTime = "k_lastUpdateTime"
15+
16+let k_rewardPerTokenStored = "k_rewardPerTokenStored"
17+
18+let k_rewardRate = "k_rewardRate"
19+
20+let k_periodFinish = "k_periodFinish"
21+
22+let k_userRewardPerToken = "k_userRewardPerToken"
23+
24+let k_userReward = "k_userReward"
25+
26+let k_balance = "k_balance"
27+
28+let k_average_rate = "k_average_rate"
29+
30+let k_withdraw_limit = "k_withdraw_limit"
31+
32+let k_last_withdraw_date = "k_last_withdraw_date"
33+
34+let k_withdraw_in_period = "k_withdraw_in_period"
35+
36+let k_initialized = "k_initialized"
37+
38+let k_coordinatorAddress = "k_coordinatorAddress"
39+
40+let k_amm = "k_amm"
41+
42+let k_governance_asset = "k_gov_asset"
43+
44+let k_quote_asset = "k_quote_asset"
45+
46+let k_admin_address = "k_admin_address"
47+
48+let k_manager_address = "k_manager_address"
49+
50+let k_collateral_address = "k_collateral_address"
51+
52+func toCompositeKey (_key,_address) = ((_key + "_") + _address)
53+
54+
55+func coordinator () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, k_coordinatorAddress), "Coordinator not set")), "Coordinator address invalid")
56+
57+
58+func adminAddress () = addressFromString(valueOrErrorMessage(getString(coordinator(), k_admin_address), "Admin address not set"))
59+
60+
61+func isWhitelist (_address) = valueOrElse(getBoolean(coordinator(), toCompositeKey(k_amm, _address)), false)
62+
63+
64+func governanceAsset () = fromBase58String(valueOrErrorMessage(getString(coordinator(), k_governance_asset), "Governance asset not set"))
65+
66+
67+func quoteAsset () = fromBase58String(valueOrErrorMessage(getString(coordinator(), k_quote_asset), "Quote asset not set"))
68+
69+
70+func managerAddress () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(coordinator(), k_manager_address), "Manager address not set")), "Manager address invalid")
71+
72+
73+let DECIMAL_UNIT = (1 * (((((((10 * 10) * 10) * 10) * 10) * 10) * 10) * 10))
74+
75+let DURATION = (((7 * 60) * 60) * 24)
76+
77+let NO_ADDRESS = ""
78+
79+let NO_STAKER = 0
80+
81+func usdnFromDecimals (_amount) = (_amount / 100)
82+
83+
84+func usdnToDecimals (_amount) = (_amount * 100)
85+
86+
87+func divd (_x,_y) = fraction(_x, DECIMAL_UNIT, _y, HALFEVEN)
88+
89+
90+func muld (_x,_y) = fraction(_x, _y, DECIMAL_UNIT, HALFEVEN)
91+
92+
93+func abs (_x) = if ((_x > 0))
94+    then _x
95+    else -(_x)
96+
97+
98+func minv (_x,_y) = if ((_x > _y))
99+    then _y
100+    else _x
101+
102+
103+let WITHDRAW_PERIOD = (86400 * 1000)
104+
105+let WITHDRAW_PER_PERIOD = divd((1 * DECIMAL_UNIT), (4 * DECIMAL_UNIT))
106+
107+func int (k) = valueOrErrorMessage(getInteger(this, k), ("no value for " + k))
108+
109+
110+func int0 (k) = valueOrElse(getInteger(this, k), 0)
111+
112+
113+func int1 (k) = valueOrElse(getInteger(this, k), DECIMAL_UNIT)
114+
115+
116+func totalSupply () = int0(k_totalSupply)
117+
118+
119+func rate () = int1(k_rate)
120+
121+
122+func balanceOf (_staker) = int0(toCompositeKey(k_balance, _staker))
123+
124+
125+func averageRate (_staker) = int0(toCompositeKey(k_average_rate, _staker))
126+
127+
128+func withdrawLimit (_staker) = int0(toCompositeKey(k_withdraw_limit, _staker))
129+
130+
131+func withdrawnInPeriod (_staker) = int0(toCompositeKey(k_withdraw_in_period, _staker))
132+
133+
134+func lastWithdrawnDate (_staker) = int0(toCompositeKey(k_last_withdraw_date, _staker))
135+
136+
137+func freeBalance () = int0(k_freeBalance)
138+
139+
140+func lockedBalance () = int0(k_lockedBalance)
141+
142+
143+func rewardPerTokenStored () = int0(k_rewardPerTokenStored)
144+
145+
146+func lastUpdateTime () = int0(k_lastUpdateTime)
147+
148+
149+func rewardRate () = int0(k_rewardRate)
150+
151+
152+func periodFinish () = int0(k_periodFinish)
153+
154+
155+func rewardBalance () = int0(k_rewardBalance)
156+
157+
158+func rewards (_staker) = int0(toCompositeKey(k_userReward, _staker))
159+
160+
161+func userRewardPerTokenPaid (_staker) = int0(toCompositeKey(k_userRewardPerToken, _staker))
162+
163+
164+func initialized () = valueOrElse(getBoolean(this, k_initialized), false)
165+
166+
167+func currentTimestamp () = lastBlock.timestamp
168+
169+
170+func currentTimestampSec () = (currentTimestamp() / 1000)
171+
172+
173+func getWithdrawLimitLeft (_staker) = {
174+    let currentDate = currentTimestamp()
175+    let lastWithdrawDate = lastWithdrawnDate(_staker)
176+    let $t049895310 = if (((currentDate - lastWithdrawDate) > WITHDRAW_PERIOD))
177+        then $Tuple3(currentDate, withdrawLimit(_staker), 0)
178+        else $Tuple3(lastWithdrawDate, (withdrawLimit(_staker) - withdrawnInPeriod(_staker)), withdrawnInPeriod(_staker))
179+    let newLastWithdrawnDate = $t049895310._1
180+    let withdrawLimitLeft = $t049895310._2
181+    let alreadyWithdrawnInPeriod = $t049895310._3
182+    $Tuple3(newLastWithdrawnDate, withdrawLimitLeft, alreadyWithdrawnInPeriod)
183+    }
184+
185+
186+func computeNewRate (_amountOfQuoteAsset) = {
187+    let newRate = if ((totalSupply() > 0))
188+        then divd((freeBalance() + _amountOfQuoteAsset), totalSupply())
189+        else DECIMAL_UNIT
190+    newRate
191+    }
192+
193+
194+func lastTimeRewardApplicable () = minv(currentTimestampSec(), periodFinish())
195+
196+
197+func rewardPerToken (_balanceDelta) = if (((totalSupply() + _balanceDelta) == 0))
198+    then rewardPerTokenStored()
199+    else {
200+        let timeInterval = (lastTimeRewardApplicable() - lastUpdateTime())
201+        let actualTimeInterval = if ((0 > timeInterval))
202+            then 0
203+            else timeInterval
204+        let diff = divd((rewardRate() * actualTimeInterval), (totalSupply() + _balanceDelta))
205+        (rewardPerTokenStored() + diff)
206+        }
207+
208+
209+func earned (_staker,_balanceDelta) = {
210+    let rewardDelta = (rewardPerToken(_balanceDelta) - userRewardPerTokenPaid(_staker))
211+    (muld((balanceOf(_staker) + _balanceDelta), rewardDelta) + rewards(_staker))
212+    }
213+
214+
215+func updateReward (_staker,_balanceDelta) = {
216+    let newRewardPerTokenStored = rewardPerToken(_balanceDelta)
217+    let newLastUpdateTime = currentTimestampSec()
218+    let $t065326724 = if ((_staker != ""))
219+        then $Tuple2(earned(_staker, _balanceDelta), newRewardPerTokenStored)
220+        else $Tuple2(0, 0)
221+    let stakerEarned = $t065326724._1
222+    let stakerRewardPerTokenPaid = $t065326724._2
223+    $Tuple4(newRewardPerTokenStored, newLastUpdateTime, stakerEarned, stakerRewardPerTokenPaid)
224+    }
225+
226+
227+func updateUserBalance (_user,_change) = if (((balanceOf(_user) + _change) >= 0))
228+    then [IntegerEntry(toCompositeKey(k_balance, _user), (balanceOf(_user) + _change))]
229+    else throw(((("Vault: can not update user balance. Balance: " + toString(balanceOf(_user))) + " change: ") + toString(_change)))
230+
231+
232+func setUserWithdrawLimit (_user,_rate) = [IntegerEntry(toCompositeKey(k_withdraw_limit, _user), _rate)]
233+
234+
235+func setUserAverageRate (_user,_rate) = [IntegerEntry(toCompositeKey(k_average_rate, _user), _rate)]
236+
237+
238+func updateFreeBalance (_change) = {
239+    let balance = freeBalance()
240+    if (((balance + _change) >= 0))
241+        then [IntegerEntry(k_freeBalance, (balance + _change))]
242+        else throw(((("Vault: can not update free balance. Balance: " + toString(balance)) + " change: ") + toString(_change)))
243+    }
244+
245+
246+func updateLockedBalance (_change) = {
247+    let balance = lockedBalance()
248+    if (((balance + _change) >= 0))
249+        then [IntegerEntry(k_lockedBalance, (balance + _change))]
250+        else throw(((("Vault: can not update locked balance. Balance: " + toString(balance)) + " change: ") + toString(_change)))
251+    }
252+
253+
254+func updateTotalSupply (_change) = [IntegerEntry(k_totalSupply, (totalSupply() + _change))]
255+
256+
257+func updateRate (_rate) = [IntegerEntry(k_rate, _rate)]
258+
259+
260+func setUserWithdrawParams (_user,_lastWithdrawDate,_withdrawn) = [IntegerEntry(toCompositeKey(k_last_withdraw_date, _user), _lastWithdrawDate), IntegerEntry(toCompositeKey(k_withdraw_in_period, _user), _withdrawn)]
261+
262+
263+func updateRewardBalance (_delta) = [IntegerEntry(k_rewardBalance, (rewardBalance() + _delta))]
264+
265+
266+func updateRewardRate (_rewardRate) = [IntegerEntry(k_rewardRate, _rewardRate)]
267+
268+
269+func updateTime (_lastUpdateTime,_periodFinish) = [IntegerEntry(k_lastUpdateTime, _lastUpdateTime), IntegerEntry(k_periodFinish, _periodFinish)]
270+
271+
272+func updateRewardPerTokenStored (_rewardPerTokenStored) = [IntegerEntry(k_rewardPerTokenStored, _rewardPerTokenStored)]
273+
274+
275+func updateUserRewards (_staker,_reward,_userRewardPerToken) = [IntegerEntry(toCompositeKey(k_userReward, _staker), _reward), IntegerEntry(toCompositeKey(k_userRewardPerToken, _staker), _userRewardPerToken)]
276+
277+
278+@Callable(i)
279+func initialize (_coordinator) = if (if (initialized())
280+    then true
281+    else (i.caller != this))
282+    then throw("Unable to initialize")
283+    else [StringEntry(k_coordinatorAddress, toString(valueOrErrorMessage(addressFromString(_coordinator), "Invalid coordinator address"))), BooleanEntry(k_initialized, true)]
284+
285+
286+
287+@Callable(i)
288+func stake () = {
289+    let _staker = toString(i.caller)
290+    let _amount = usdnToDecimals(i.payments[0].amount)
291+    if (if (if ((i.payments[0].assetId != quoteAsset()))
292+        then true
293+        else (size(i.payments) != 1))
294+        then true
295+        else !(initialized()))
296+        then throw("Invalid call to stake")
297+        else {
298+            let $t01017610405 = updateReward(_staker, 0)
299+            let newRewardPerTokenStored = $t01017610405._1
300+            let newLastUpdateTime = $t01017610405._2
301+            let stakerEarned = $t01017610405._3
302+            let stakerRewardPerTokenPaid = $t01017610405._4
303+            let currentRate = rate()
304+            let prevAverageRate = averageRate(_staker)
305+            let vAmount = divd(_amount, currentRate)
306+            let newAverageRate = divd((muld(vAmount, currentRate) + muld(balanceOf(_staker), prevAverageRate)), (vAmount + balanceOf(_staker)))
307+            let newTotalBalance = (vAmount + balanceOf(_staker))
308+            let newWithdrawLimit = muld(newTotalBalance, WITHDRAW_PER_PERIOD)
309+            let stake = invoke(managerAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), usdnFromDecimals(_amount))])
310+            if ((stake == stake))
311+                then (((((((updateUserRewards(_staker, stakerEarned, stakerRewardPerTokenPaid) ++ updateRewardPerTokenStored(newRewardPerTokenStored)) ++ updateTime(newLastUpdateTime, periodFinish())) ++ updateFreeBalance(_amount)) ++ updateUserBalance(_staker, vAmount)) ++ setUserAverageRate(_staker, newAverageRate)) ++ setUserWithdrawLimit(_staker, newWithdrawLimit)) ++ updateTotalSupply(vAmount))
312+                else throw("Strict value is not equal to itself.")
313+            }
314+    }
315+
316+
317+
318+@Callable(i)
319+func unStake (_amount) = {
320+    let _staker = toString(i.caller)
321+    let amountOfQuoteAsset = usdnToDecimals(_amount)
322+    if (if (if ((i.payments != nil))
323+        then true
324+        else (0 >= amountOfQuoteAsset))
325+        then true
326+        else !(initialized()))
327+        then throw("Invalid call to unStake")
328+        else {
329+            let $t01175811974 = updateReward(_staker, 0)
330+            let newRewardPerTokenStored = $t01175811974._1
331+            let newLastUpdateTime = $t01175811974._2
332+            let stakerEarned = $t01175811974._3
333+            let stakerRewardPerTokenPaid = $t01175811974._4
334+            let $t01198112148 = getWithdrawLimitLeft(_staker)
335+            let newLastWithdrawnDate = $t01198112148._1
336+            let withdrawLimitLeft = $t01198112148._2
337+            let alreadyWithdrawnInPeriod = $t01198112148._3
338+            let vAmount = divd(amountOfQuoteAsset, rate())
339+            if ((vAmount > withdrawLimitLeft))
340+                then throw("Invalid call to unStake: withdraw over limit")
341+                else {
342+                    let newWithdrawnInPeriod = (alreadyWithdrawnInPeriod + vAmount)
343+                    if ((amountOfQuoteAsset > freeBalance()))
344+                        then throw("Invalid call to unStake: balance too low")
345+                        else {
346+                            let unstake = invoke(managerAddress(), "withdraw", [toBase58String(quoteAsset()), usdnFromDecimals(amountOfQuoteAsset)], nil)
347+                            if ((unstake == unstake))
348+                                then (((((((updateUserRewards(_staker, stakerEarned, stakerRewardPerTokenPaid) ++ updateRewardPerTokenStored(newRewardPerTokenStored)) ++ updateTime(newLastUpdateTime, periodFinish())) ++ updateFreeBalance(-(amountOfQuoteAsset))) ++ updateUserBalance(_staker, -(vAmount))) ++ updateTotalSupply(-(vAmount))) ++ setUserWithdrawParams(_staker, newLastWithdrawnDate, newWithdrawnInPeriod)) ++ [ScriptTransfer(i.caller, usdnFromDecimals(amountOfQuoteAsset), quoteAsset())])
349+                                else throw("Strict value is not equal to itself.")
350+                            }
351+                    }
352+            }
353+    }
354+
355+
356+
357+@Callable(i)
358+func withdrawRewards () = {
359+    let _staker = toString(i.caller)
360+    let $t01348413629 = updateReward(_staker, 0)
361+    let newRewardPerTokenStored = $t01348413629._1
362+    let newLastUpdateTime = $t01348413629._2
363+    let stakerEarned = $t01348413629._3
364+    let stakerRewardPerTokenPaid = $t01348413629._4
365+    if (if ((0 >= stakerEarned))
366+        then true
367+        else !(initialized()))
368+        then throw("No reward: Vault")
369+        else ((((updateUserRewards(_staker, 0, stakerRewardPerTokenPaid) ++ updateRewardPerTokenStored(newRewardPerTokenStored)) ++ updateTime(newLastUpdateTime, periodFinish())) ++ updateRewardBalance(-(stakerEarned))) ++ [ScriptTransfer(i.caller, stakerEarned, governanceAsset())])
370+    }
371+
372+
373+
374+@Callable(i)
375+func addFree () = {
376+    let _amount = usdnToDecimals(i.payments[0].amount)
377+    if (if (if (if ((i.payments[0].assetId != quoteAsset()))
378+        then true
379+        else (size(i.payments) != 1))
380+        then true
381+        else !(initialized()))
382+        then true
383+        else !(if (isWhitelist(toString(i.caller)))
384+            then true
385+            else (i.caller == adminAddress())))
386+        then throw("Invalid addFree params")
387+        else {
388+            let newRate = computeNewRate(_amount)
389+            let stake = invoke(managerAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), usdnFromDecimals(_amount))])
390+            if ((stake == stake))
391+                then (updateFreeBalance(_amount) ++ updateRate(newRate))
392+                else throw("Strict value is not equal to itself.")
393+            }
394+    }
395+
396+
397+
398+@Callable(i)
399+func addLocked () = {
400+    let _amount = usdnToDecimals(i.payments[0].amount)
401+    if (if (if (if ((i.payments[0].assetId != quoteAsset()))
402+        then true
403+        else (size(i.payments) != 1))
404+        then true
405+        else !(initialized()))
406+        then true
407+        else !(if (isWhitelist(toString(i.caller)))
408+            then true
409+            else (i.caller == adminAddress())))
410+        then throw("Invalid addLocked params")
411+        else {
412+            let unstake = invoke(managerAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), usdnFromDecimals(_amount))])
413+            if ((unstake == unstake))
414+                then updateLockedBalance(_amount)
415+                else throw("Strict value is not equal to itself.")
416+            }
417+    }
418+
419+
420+
421+@Callable(i)
422+func exchangeFreeAndLocked (_amount) = if (if (!(initialized()))
423+    then true
424+    else !(isWhitelist(toString(i.caller))))
425+    then throw("Invalid exchangeFreeAndLocked params")
426+    else {
427+        let amountOfQuoteAsset = usdnToDecimals(_amount)
428+        let newRate = computeNewRate(-(amountOfQuoteAsset))
429+        ((updateLockedBalance(amountOfQuoteAsset) ++ updateFreeBalance(-(amountOfQuoteAsset))) ++ updateRate(newRate))
430+        }
431+
432+
433+
434+@Callable(i)
435+func withdrawLocked (_amount) = if (if (if (!(initialized()))
436+    then true
437+    else (0 >= _amount))
438+    then true
439+    else !(isWhitelist(toString(i.caller))))
440+    then throw("Invalid withdrawLocked params")
441+    else {
442+        let amountOfQuoteAsset = usdnToDecimals(_amount)
443+        let unstake = invoke(managerAddress(), "withdraw", [toBase58String(quoteAsset()), usdnFromDecimals(amountOfQuoteAsset)], nil)
444+        if ((unstake == unstake))
445+            then (updateLockedBalance(-(amountOfQuoteAsset)) ++ [ScriptTransfer(i.caller, usdnFromDecimals(amountOfQuoteAsset), quoteAsset())])
446+            else throw("Strict value is not equal to itself.")
447+        }
448+
449+
450+
451+@Callable(i)
452+func addRewards () = if (if (if ((i.payments[0].assetId != governanceAsset()))
453+    then true
454+    else (size(i.payments) != 1))
455+    then true
456+    else !(initialized()))
457+    then throw("Invalid addRewards params")
458+    else {
459+        let _reward = i.payments[0].amount
460+        let newRewardPerTokenStored = updateReward(NO_ADDRESS, NO_STAKER)._1
461+        let timestamp = currentTimestampSec()
462+        let newRewardRate = if ((timestamp > periodFinish()))
463+            then (_reward / DURATION)
464+            else {
465+                let remainingTime = (periodFinish() - timestamp)
466+                let leftover = (rewardRate() * remainingTime)
467+                ((_reward + leftover) / DURATION)
468+                }
469+        (((updateRewardRate(newRewardRate) ++ updateRewardPerTokenStored(newRewardPerTokenStored)) ++ updateRewardBalance(_reward)) ++ updateTime(timestamp, (timestamp + DURATION)))
470+        }
471+
472+
473+
474+@Callable(i)
475+func ackRewards () = {
476+    let profitResp = invoke(managerAddress(), "claimProfit", [toBase58String(quoteAsset())], nil)
477+    if ((profitResp == profitResp))
478+        then {
479+            let profit =             match profitResp {
480+                case p: Int => 
481+                    usdnToDecimals(p)
482+                case _ => 
483+                    throw("Invalid claimProfit response")
484+            }
485+            let result = if ((profit > 0))
486+                then {
487+                    let newRate = computeNewRate(profit)
488+                    let stake = invoke(managerAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), usdnFromDecimals(profit))])
489+                    if ((stake == stake))
490+                        then (updateFreeBalance(profit) ++ updateRate(newRate))
491+                        else throw("Strict value is not equal to itself.")
492+                    }
493+                else nil
494+            if ((result == result))
495+                then result
496+                else throw("Strict value is not equal to itself.")
497+            }
498+        else throw("Strict value is not equal to itself.")
499+    }
500+
501+
502+
503+@Callable(i)
504+func view_reward (_staker) = {
505+    let balance = balanceOf(_staker)
506+    let depositedAmount = muld(averageRate(_staker), balance)
507+    let currentAmount = muld(rate(), balance)
508+    let earnedQuote = (currentAmount - depositedAmount)
509+    throw(toString(earnedQuote))
510+    }
511+
512+
513+
514+@Callable(i)
515+func view_stakingReward (_staker) = {
516+    let stakerEarned = updateReward(_staker, 0)._3
517+    throw(toString(usdnFromDecimals(stakerEarned)))
518+    }
519+
520+
521+
522+@Callable(i)
523+func view_withdrawLimit (_staker) = {
524+    let withdrawLimitLeft = getWithdrawLimitLeft(_staker)._2
525+    let limitInUsdn = usdnFromDecimals(muld(withdrawLimitLeft, rate()))
526+    throw(toString(limitInUsdn))
527+    }
528+
529+
530+@Verifier(tx)
531+func verify () = {
532+    let coordinatorStr = getString(this, k_coordinatorAddress)
533+    if (isDefined(coordinatorStr))
534+        then {
535+            let admin = getString(addressFromStringValue(value(coordinatorStr)), k_admin_address)
536+            if (isDefined(admin))
537+                then valueOrElse(getBoolean(addressFromStringValue(value(admin)), ((("status_" + toString(this)) + "_") + toBase58String(tx.id))), false)
538+                else throw("unable to verify: admin not set in coordinator")
539+            }
540+        else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
541+    }
542+
github/deemru/w8io/169f3d6 
29.82 ms ◑