2023.03.20 22:11 [3564356] smart account 3PKHGFWhbUavVuvaPYNjEN8L3gpY9kx6tHP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FxBtaJKLAnuU9Pr5da7pCfjaWsLayyBzRiemLvr8XZsB",
    "fee": 2300000,
    "feeAssetId": null,
    "timestamp": 1679339547955,
    "version": 2,
    "chainId": 87,
    "sender": "3PKHGFWhbUavVuvaPYNjEN8L3gpY9kx6tHP",
    "senderPublicKey": "AStfJXMR2duVTHCUrYba3h3tja7k2oqz7cfRERSdyzhY",
    "proofs": [
        "3arH4K3w1fyn6W1Ziagpr6rh7oA6sqYUXnDNaihuiLH4nZCCZ1coPJNLePehCnoPTRHe4wGziuHB5rZ9hMtpipHF"
    ],
    "script": "base64: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",
    "height": 3564356,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEPARATOR = "__"
5+
6+let KEY_INIT = "INIT"
7+
8+let KEY_MULTISIG = "MULTISIG"
9+
10+let KEY_STATUS = "STATUS"
11+
12+let KEY_MIN_SEC_DEPO = "MIN_SEC_DEPO"
13+
14+let KEY_PUNISHMENT = "PUNISHMENT"
15+
16+let KEY_RESET_BLOCK_DELTA = "RESET_BLOCK_DELTA"
17+
18+let KEY_SEC_DEPO = "SEC_DEPO"
19+
20+let KEY_REWARD_TOKEN_ADDRESS = "REWARD_TOKEN_ADDRESS"
21+
22+let KEY_REWARD_AMOUNT = "REWARD_AMOUNT"
23+
24+let KEY_WINTESS_ADDRESS = "WINTESS_ADDRESS"
25+
26+let KEY_CURRENT_EPOCH = "CURRENT_EPOCH"
27+
28+let KEY_SIGNERS_PER_EPOCH = "SIGNERS_PER_EPOCH"
29+
30+let KEY_EVENT_STATUS = "EVENT_STATUS"
31+
32+let KEY_LOCKS = "LOCKS"
33+
34+let KEY_T = "T"
35+
36+let KEY_R = "R"
37+
38+let KEY_S = "S"
39+
40+let KEY_R_SIGNERS = "R_SIGNERS"
41+
42+let KEY_EVENT_START_BLOCK = "EVENT_START_BLOCK"
43+
44+let KEY_R_SIGMA = "R_SIGMA"
45+
46+let KEY_S_SIGMA = "S_SIGMA"
47+
48+let KEY_S_SIGNERS = "S_SIGNERS"
49+
50+let KEY_SIGNED_EVENT_EXECUTOR = "SIGNED_EVENT_EXECUTOR"
51+
52+let KEY_SIZE = "SIZE"
53+
54+let KEY_SIGNER_GROUP_PUBLIC_KEY = "SIGNER_GROUP_PUBLIC_KEY"
55+
56+let FUNC_MINT_MANY = "mintMany"
57+
58+let FUNC_IS_CONFIRMED_EVENT = "isConfirmedEvent"
59+
60+let FUNC_GET_RAW_EVENT = "getRawEvent"
61+
62+let EVENT_TYPE_WAVES = "WAVES"
63+
64+let EVENT_TYPE_EVM = "EVM"
65+
66+let EVENT_STATUS_INIT = 1
67+
68+let EVENT_STATUS_SIGN = 2
69+
70+let EVENT_STATUS_DONE = 3
71+
72+let MAX_INT = 9223372036854775807
73+
74+func _validateAddress (address_,err_) = match addressFromString(address_) {
75+    case a: Address => 
76+        true
77+    case _ => 
78+        throw(err_)
79+}
80+
81+
82+func _validateAsset (assetId_,err_) = match assetInfo(fromBase58String(assetId_)) {
83+    case a: Asset => 
84+        true
85+    case _ => 
86+        throw(err_)
87+}
88+
89+
90+func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
91+    then true
92+    else (val_ > upperBoundary_))
93+    then throw(err_)
94+    else true
95+
96+
97+func _validateString (val_,err_) = if (if ((0 >= size(val_)))
98+    then true
99+    else contains(val_, SEPARATOR))
100+    then throw(err_)
101+    else true
102+
103+
104+func _validatePaymentsSize (payments_,target_,err_) = if ((size(payments_) != target_))
105+    then throw(err_)
106+    else true
107+
108+
109+func _validatePaymentAsset (payment_,asset_,err_) = if ((payment_.assetId != asset_))
110+    then throw(err_)
111+    else true
112+
113+
114+func _validatePublicKey (publicKey_,err_) = if ((size(fromBase58String(publicKey_)) != 32))
115+    then throw(err_)
116+    else true
117+
118+
119+func _validatePublicKeys (publicKeys_,err_) = {
120+    func foldFunc (acc,elem) =     $Tuple2(if (acc._1)
121+        then _validatePublicKey(elem, acc._2)
122+        else false, acc._2)
123+
124+    let result = {
125+        let $l = publicKeys_
126+        let $s = size($l)
127+        let $acc0 = $Tuple2(true, err_)
128+        func $f0_1 ($a,$i) =         if (($i >= $s))
129+            then $a
130+            else foldFunc($a, $l[$i])
131+
132+        func $f0_2 ($a,$i) =         if (($i >= $s))
133+            then $a
134+            else throw("List size exceeds 10")
135+
136+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
137+        }
138+    result._1
139+    }
140+
141+
142+func _loadInit () = match getBoolean(KEY_INIT) {
143+    case a: Boolean => 
144+        a
145+    case _ => 
146+        false
147+}
148+
149+
150+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
151+
152+
153+func _loadMultisig () = match getString(KEY_MULTISIG) {
154+    case a: String => 
155+        addressFromStringValue(a)
156+    case _ => 
157+        Address(base58'')
158+}
159+
160+
161+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
162+
163+
164+func _loadMinSecDepo () = match getInteger(KEY_MIN_SEC_DEPO) {
165+    case a: Int => 
166+        a
167+    case _ => 
168+        0
169+}
170+
171+
172+func _saveMinSecDepo (val_) = [IntegerEntry(KEY_MIN_SEC_DEPO, val_)]
173+
174+
175+func _loadSecDepo (account_) = match getInteger(makeString([KEY_SEC_DEPO, toString(account_)], SEPARATOR)) {
176+    case a: Int => 
177+        a
178+    case _ => 
179+        0
180+}
181+
182+
183+func _saveSecDepo (account_,val_) = [IntegerEntry(makeString([KEY_SEC_DEPO, toString(account_)], SEPARATOR), val_)]
184+
185+
186+func _loadPunishment () = match getInteger(KEY_PUNISHMENT) {
187+    case a: Int => 
188+        a
189+    case _ => 
190+        0
191+}
192+
193+
194+func _savePunishment (val_) = [IntegerEntry(KEY_PUNISHMENT, val_)]
195+
196+
197+func _loadResetBlockDelta () = match getInteger(KEY_RESET_BLOCK_DELTA) {
198+    case a: Int => 
199+        a
200+    case _ => 
201+        0
202+}
203+
204+
205+func _saveResetBlockDelta (val_) = [IntegerEntry(KEY_RESET_BLOCK_DELTA, val_)]
206+
207+
208+func _loadRewardTokenAddress () = match getString(KEY_REWARD_TOKEN_ADDRESS) {
209+    case a: String => 
210+        addressFromStringValue(a)
211+    case _ => 
212+        Address(base58'')
213+}
214+
215+
216+func _saveRewardTokenAddress (val_) = [StringEntry(KEY_REWARD_TOKEN_ADDRESS, toString(val_))]
217+
218+
219+func _loadRewardAmount () = match getInteger(KEY_REWARD_AMOUNT) {
220+    case a: Int => 
221+        a
222+    case _ => 
223+        0
224+}
225+
226+
227+func _saveRewardAmount (val_) = [IntegerEntry(KEY_REWARD_AMOUNT, val_)]
228+
229+
230+func _loadWitnessAddress () = match getString(KEY_WINTESS_ADDRESS) {
231+    case a: String => 
232+        addressFromStringValue(a)
233+    case _ => 
234+        Address(base58'')
235+}
236+
237+
238+func _saveWitnessAddress (val_) = [StringEntry(KEY_WINTESS_ADDRESS, toString(val_))]
239+
240+
241+func _loadCurrentEpoch (execChainId_) = match getInteger(makeString([KEY_CURRENT_EPOCH, toString(execChainId_)], SEPARATOR)) {
242+    case a: Int => 
243+        a
244+    case _ => 
245+        0
246+}
247+
248+
249+func _saveCurrentEpoch (execChainId_,val_) = [IntegerEntry(makeString([KEY_CURRENT_EPOCH, toString(execChainId_)], SEPARATOR), val_)]
250+
251+
252+func _loadSigners (execChainId_,epoch_) = match getString(makeString([KEY_SIGNERS_PER_EPOCH, toString(execChainId_), toString(epoch_)], SEPARATOR)) {
253+    case a: String => 
254+        if ((size(a) > 0))
255+            then split(a, SEPARATOR)
256+            else nil
257+    case _ => 
258+        nil
259+}
260+
261+
262+func _saveSigners (execChainId_,epoch_,signers_) = [StringEntry(makeString([KEY_SIGNERS_PER_EPOCH, toString(execChainId_), toString(epoch_)], SEPARATOR), makeString(signers_, SEPARATOR))]
263+
264+
265+func _loadEventStatus (execChainId_,eventId_) = match getInteger(makeString([KEY_EVENT_STATUS, toString(execChainId_), toString(eventId_)], SEPARATOR)) {
266+    case a: Int => 
267+        a
268+    case _ => 
269+        EVENT_STATUS_INIT
270+}
271+
272+
273+func _saveEventStatus (execChainId_,eventId_,status_) = [IntegerEntry(makeString([KEY_EVENT_STATUS, toString(execChainId_), toString(eventId_)], SEPARATOR), status_)]
274+
275+
276+func _loadLock (publicKey_) = match getInteger(makeString([KEY_LOCKS, publicKey_], SEPARATOR)) {
277+    case a: Int => 
278+        a
279+    case _ => 
280+        0
281+}
282+
283+
284+func _saveLock (publicKey_,val_) = [IntegerEntry(makeString([KEY_LOCKS, publicKey_], SEPARATOR), val_)]
285+
286+
287+func _loadT (execChainId_,epoch_) = match getInteger(makeString([KEY_T, toString(execChainId_), toString(epoch_)], SEPARATOR)) {
288+    case a: Int => 
289+        a
290+    case _ => 
291+        0
292+}
293+
294+
295+func _saveT (execChainId_,epoch_,val_) = [IntegerEntry(makeString([KEY_T, toString(execChainId_), toString(epoch_)], SEPARATOR), val_)]
296+
297+
298+func _loadSignerGroupPublicKey (execChainId_,epoch_) = match getString(makeString([KEY_SIGNER_GROUP_PUBLIC_KEY, toString(execChainId_), toString(epoch_)], SEPARATOR)) {
299+    case a: String => 
300+        fromBase58String(a)
301+    case _ => 
302+        base58''
303+}
304+
305+
306+func _saveSignerGroupPublicKey (execChainId_,epoch_,signerGroupPublicKey_) = [StringEntry(makeString([KEY_SIGNER_GROUP_PUBLIC_KEY, toString(execChainId_), toString(epoch_)], SEPARATOR), toBase58String(signerGroupPublicKey_))]
307+
308+
309+func _loadRsByEvent (execChainId_,eventId_) = match getString(makeString([KEY_R, toString(execChainId_), toString(eventId_)], SEPARATOR)) {
310+    case a: String => 
311+        if ((size(a) > 0))
312+            then split(a, SEPARATOR)
313+            else nil
314+    case _ => 
315+        nil
316+}
317+
318+
319+func _saveRsByEvent (execChainId_,eventId_,rs_) = [StringEntry(makeString([KEY_R, toString(execChainId_), toString(eventId_)], SEPARATOR), makeString(rs_, SEPARATOR))]
320+
321+
322+func _loadSsByEvent (execChainId_,eventId_) = match getString(makeString([KEY_S, toString(execChainId_), toString(eventId_)], SEPARATOR)) {
323+    case a: String => 
324+        if ((size(a) > 0))
325+            then split(a, SEPARATOR)
326+            else nil
327+    case _ => 
328+        nil
329+}
330+
331+
332+func _saveSsByEvent (execChainId_,eventId_,ss_) = [StringEntry(makeString([KEY_S, toString(execChainId_), toString(eventId_)], SEPARATOR), makeString(ss_, SEPARATOR))]
333+
334+
335+func _loadRSigmaByEvent (execChainId_,eventId_) = match getString(makeString([KEY_R_SIGMA, toString(execChainId_), toString(eventId_)], SEPARATOR)) {
336+    case a: String => 
337+        a
338+    case _ => 
339+        ""
340+}
341+
342+
343+func _saveRSigmaByEvent (execChainId_,eventId_,rSigma_) = [StringEntry(makeString([KEY_R_SIGMA, toString(execChainId_), toString(eventId_)], SEPARATOR), rSigma_)]
344+
345+
346+func _loadSSigmaByEvent (execChainId_,eventId_) = match getString(makeString([KEY_S_SIGMA, toString(execChainId_), toString(eventId_)], SEPARATOR)) {
347+    case a: String => 
348+        a
349+    case _ => 
350+        ""
351+}
352+
353+
354+func _saveSSigmaByEvent (execChainId_,eventId_,sSigma_) = [StringEntry(makeString([KEY_S_SIGMA, toString(execChainId_), toString(eventId_)], SEPARATOR), sSigma_)]
355+
356+
357+func _loadRByEventAndSigner (execChainId_,eventId_,signer_) = match getString(makeString([KEY_R, toString(execChainId_), toString(eventId_), signer_], SEPARATOR)) {
358+    case a: String => 
359+        a
360+    case _ => 
361+        ""
362+}
363+
364+
365+func _saveRByEventAndSigner (execChainId_,eventId_,signer_,r_) = [StringEntry(makeString([KEY_R, toString(execChainId_), toString(eventId_), signer_], SEPARATOR), r_)]
366+
367+
368+func _loadSByEventAndSigner (execChainId_,eventId_,signer_) = match getString(makeString([KEY_S, toString(execChainId_), toString(eventId_), signer_], SEPARATOR)) {
369+    case a: String => 
370+        a
371+    case _ => 
372+        ""
373+}
374+
375+
376+func _saveSByEventAndSigner (execChainId_,eventId_,signer_,s_) = [StringEntry(makeString([KEY_S, toString(execChainId_), toString(eventId_), signer_], SEPARATOR), s_)]
377+
378+
379+func _loadSignersWithRByEvent (execChainId_,eventId_) = match getString(makeString([KEY_R_SIGNERS, toString(execChainId_), toString(eventId_)], SEPARATOR)) {
380+    case a: String => 
381+        if ((size(a) > 0))
382+            then split(a, SEPARATOR)
383+            else nil
384+    case _ => 
385+        nil
386+}
387+
388+
389+func _saveSignersWithRByEvent (execChainId_,eventId_,rs_) = [StringEntry(makeString([KEY_R_SIGNERS, toString(execChainId_), toString(eventId_)], SEPARATOR), makeString(rs_, SEPARATOR))]
390+
391+
392+func _loadSignersWithSByEvent (execChainId_,eventId_) = match getString(makeString([KEY_S_SIGNERS, toString(execChainId_), toString(eventId_)], SEPARATOR)) {
393+    case a: String => 
394+        if ((size(a) > 0))
395+            then split(a, SEPARATOR)
396+            else nil
397+    case _ => 
398+        nil
399+}
400+
401+
402+func _saveSignersWithSByEvent (execChainId_,eventId_,ss_) = [StringEntry(makeString([KEY_S_SIGNERS, toString(execChainId_), toString(eventId_)], SEPARATOR), makeString(ss_, SEPARATOR))]
403+
404+
405+func _loadEventStartBlock (execChainId_,eventId_) = match getInteger(makeString([KEY_EVENT_START_BLOCK, toString(execChainId_), toString(eventId_)], SEPARATOR)) {
406+    case a: Int => 
407+        a
408+    case _ => 
409+        0
410+}
411+
412+
413+func _saveEventStartBlock (execChainId_,eventId_,val_) = [IntegerEntry(makeString([KEY_EVENT_START_BLOCK, toString(execChainId_), toString(eventId_)], SEPARATOR), val_)]
414+
415+
416+func _loadSignedEventExecutorIdxSize (executionChainId_) = match getInteger(makeString([KEY_SIGNED_EVENT_EXECUTOR, toString(executionChainId_), KEY_SIZE], SEPARATOR)) {
417+    case a: Int => 
418+        a
419+    case _ => 
420+        0
421+}
422+
423+
424+func _saveSignedEventExecutorIdxSize (executionChainId_,val_) = [IntegerEntry(makeString([KEY_SIGNED_EVENT_EXECUTOR, toString(executionChainId_), KEY_SIZE], SEPARATOR), val_)]
425+
426+
427+func _loadSignedEventExecutorIdx (executionChainId_,idx_) = match getInteger(makeString([KEY_SIGNED_EVENT_EXECUTOR, toString(executionChainId_), toString(idx_)], SEPARATOR)) {
428+    case a: Int => 
429+        a
430+    case _ => 
431+        0
432+}
433+
434+
435+func _saveSignedEventExecutorIdx (executionChainId_,idx_,val_) = [IntegerEntry(makeString([KEY_SIGNED_EVENT_EXECUTOR, toString(executionChainId_), toString(idx_)], SEPARATOR), val_)]
436+
437+
438+func _onlyThisContract (caller_) = if ((caller_ != this))
439+    then throw("_onlyThisContract: revert")
440+    else true
441+
442+
443+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
444+    then throw("_whenMultisigSet: revert")
445+    else true
446+
447+
448+func _whenNotInitialized () = if (_loadInit())
449+    then throw("_whenNotInitialized: revert")
450+    else true
451+
452+
453+func _whenInitialized () = if (!(_loadInit()))
454+    then throw("_whenInitialized: revert")
455+    else true
456+
457+
458+func _isConfirmedEvent (eventId_,execChainId_,err_) = {
459+    let result = invoke(_loadWitnessAddress(), FUNC_IS_CONFIRMED_EVENT, [eventId_, execChainId_], nil)
460+    if ((result == result))
461+        then         match result {
462+            case a: Boolean => 
463+                if (!(a))
464+                    then throw(err_)
465+                    else true
466+            case _ => 
467+                throw(err_)
468+        }
469+        else throw("Strict value is not equal to itself.")
470+    }
471+
472+
473+func _getRawEvent (eventId_,execChainId_) = {
474+    let result = invoke(_loadWitnessAddress(), FUNC_GET_RAW_EVENT, [eventId_, execChainId_], nil)
475+    if ((result == result))
476+        then         match result {
477+            case a: (String, ByteVector) => 
478+                a
479+            case _ => 
480+                throw("_getRawEvent: revert")
481+        }
482+        else throw("Strict value is not equal to itself.")
483+    }
484+
485+
486+func _isActiveSigner (publicKey_,publicKeys_,err_) = if (!(containsElement(publicKeys_, publicKey_)))
487+    then throw(err_)
488+    else true
489+
490+
491+func _checkSecDepo (signer_,err_) = if ((_loadMinSecDepo() > _loadSecDepo(addressFromPublicKey(fromBase58String(signer_)))))
492+    then throw(err_)
493+    else true
494+
495+
496+func _checkEventStatusForSubmitR (execChainId_,eventId_,err_) = if ((_loadEventStatus(execChainId_, eventId_) != EVENT_STATUS_INIT))
497+    then throw(err_)
498+    else true
499+
500+
501+func _checkEventStatusForSubmitS (execChainId_,eventId_,err_) = if ((_loadEventStatus(execChainId_, eventId_) != EVENT_STATUS_SIGN))
502+    then throw(err_)
503+    else true
504+
505+
506+func _checkEventStatusForReset (execChainId_,eventId_,err_) = if (if ((_loadEventStatus(execChainId_, eventId_) != EVENT_STATUS_SIGN))
507+    then true
508+    else ((_loadEventStartBlock(execChainId_, eventId_) + _loadResetBlockDelta()) > height))
509+    then throw(err_)
510+    else true
511+
512+
513+func _incrementLocks (signers_) = {
514+    func foldFunc (acc,elem) =     (acc ++ _saveLock(elem, (_loadLock(elem) + 1)))
515+
516+    let $l = signers_
517+    let $s = size($l)
518+    let $acc0 = nil
519+    func $f0_1 ($a,$i) =     if (($i >= $s))
520+        then $a
521+        else foldFunc($a, $l[$i])
522+
523+    func $f0_2 ($a,$i) =     if (($i >= $s))
524+        then $a
525+        else throw("List size exceeds 10")
526+
527+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
528+    }
529+
530+
531+func _isZeroLock (publicKey_,err_) = if ((_loadLock(publicKey_) > 0))
532+    then throw(err_)
533+    else true
534+
535+
536+func _notSubmittedR (execChainId_,eventId_,signer_,err_) = {
537+    let r = _loadRByEventAndSigner(execChainId_, eventId_, signer_)
538+    if (if ((r != ""))
539+        then containsElement(_loadRsByEvent(execChainId_, eventId_), r)
540+        else false)
541+        then throw(err_)
542+        else true
543+    }
544+
545+
546+func _notSubmittedS (execChainId_,eventId_,signer_,err_) = {
547+    let s = _loadSByEventAndSigner(execChainId_, eventId_, signer_)
548+    if (if ((s != ""))
549+        then containsElement(_loadSsByEvent(execChainId_, eventId_), s)
550+        else false)
551+        then throw(err_)
552+        else true
553+    }
554+
555+
556+func _submittedR (execChainId_,eventId_,signer_,err_) = {
557+    let r = _loadRByEventAndSigner(execChainId_, eventId_, signer_)
558+    if (if ((r == ""))
559+        then true
560+        else !(containsElement(_loadRsByEvent(execChainId_, eventId_), r)))
561+        then throw(err_)
562+        else true
563+    }
564+
565+
566+func _slashIncorrect (signersWithR_,signersWithS_) = {
567+    let punishment = _loadPunishment()
568+    func foldFunc (acc,elem) =     if (containsElement(signersWithS_, elem))
569+        then $Tuple3(acc._1, (acc._2 :+ elem), acc._3)
570+        else {
571+            let signerAddress = addressFromPublicKey(fromBase58String(elem))
572+            $Tuple3((acc._1 ++ _saveSecDepo(signerAddress, (_loadSecDepo(signerAddress) - punishment))), acc._2, (acc._3 + punishment))
573+            }
574+
575+    let $l = signersWithR_
576+    let $s = size($l)
577+    let $acc0 = $Tuple3(nil, nil, 0)
578+    func $f0_1 ($a,$i) =     if (($i >= $s))
579+        then $a
580+        else foldFunc($a, $l[$i])
581+
582+    func $f0_2 ($a,$i) =     if (($i >= $s))
583+        then $a
584+        else throw("List size exceeds 10")
585+
586+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
587+    }
588+
589+
590+func _compensateCorrect (signers_,compensation_) = {
591+    let perSigner = (compensation_ / size(signers_))
592+    func foldFunc (acc,elem) =     (acc :+ ScriptTransfer(addressFromPublicKey(fromBase58String(elem)), perSigner, unit))
593+
594+    let $l = signers_
595+    let $s = size($l)
596+    let $acc0 = nil
597+    func $f0_1 ($a,$i) =     if (($i >= $s))
598+        then $a
599+        else foldFunc($a, $l[$i])
600+
601+    func $f0_2 ($a,$i) =     if (($i >= $s))
602+        then $a
603+        else throw("List size exceeds 10")
604+
605+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
606+    }
607+
608+
609+func _verifySignature (execChainId_,epoch_,eventId_,rSigma_,sSigma_,err_) = {
610+    let event = _getRawEvent(eventId_, execChainId_)
611+    let eventType = event._1
612+    let eventBytes = event._2
613+    let groupPublicKey = _loadSignerGroupPublicKey(execChainId_, epoch_)
614+    if ((eventType == EVENT_TYPE_WAVES))
615+        then {
616+            let signature = (fromBase58String(rSigma_) + fromBase58String(sSigma_))
617+            if (!(sigVerify(keccak256_32Kb(eventBytes), signature, groupPublicKey)))
618+                then throw(err_)
619+                else true
620+            }
621+        else if ((eventType == EVENT_TYPE_EVM))
622+            then true
623+            else throw(err_)
624+    }
625+
626+
627+func _publicKeysToAddrsStr (publicKeys_) = {
628+    func foldfunc (acc_,elem_) =     (acc_ :+ toString(addressFromPublicKey(fromBase58String(elem_))))
629+
630+    let $l = publicKeys_
631+    let $s = size($l)
632+    let $acc0 = nil
633+    func $f0_1 ($a,$i) =     if (($i >= $s))
634+        then $a
635+        else foldfunc($a, $l[$i])
636+
637+    func $f0_2 ($a,$i) =     if (($i >= $s))
638+        then $a
639+        else throw("List size exceeds 51")
640+
641+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 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)
642+    }
643+
644+
645+@Callable(i)
646+func init (minSecDepo_,punishment_,resetBlockDelta_,rewardTokenAddress_,rewardAmount_,witnessAddress_) = {
647+    let err = if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
648+        then _whenNotInitialized()
649+        else false)
650+        then _whenMultisigSet()
651+        else false)
652+        then _validateInt(minSecDepo_, punishment_, MAX_INT, "init: invalid minSecDepo")
653+        else false)
654+        then _validateInt(punishment_, 0, MAX_INT, "init: invalid punishment")
655+        else false)
656+        then _validateInt(resetBlockDelta_, 0, MAX_INT, "init: invalid resetBlockDelta")
657+        else false)
658+        then _validateAddress(rewardTokenAddress_, "init: invalid rewardTokenAddress")
659+        else false)
660+        then _validateInt(rewardAmount_, 0, MAX_INT, "init: invalid rewardAmount")
661+        else false)
662+        then _validateAddress(witnessAddress_, "init: invalid witnessAddress")
663+        else false
664+    if ((err == err))
665+        then $Tuple2(((((((_saveInit(true) ++ _saveMinSecDepo(minSecDepo_)) ++ _savePunishment(punishment_)) ++ _saveResetBlockDelta(resetBlockDelta_)) ++ _saveRewardTokenAddress(addressFromStringValue(rewardTokenAddress_))) ++ _saveRewardAmount(rewardAmount_)) ++ _saveWitnessAddress(addressFromStringValue(witnessAddress_))), unit)
666+        else throw("Strict value is not equal to itself.")
667+    }
668+
669+
670+
671+@Callable(i)
672+func setActiveSigners (execChainId_,signers_,t_,signerGroupPublicKey_) = {
673+    let err = if (if (if (if (_onlyThisContract(i.caller))
674+        then _whenInitialized()
675+        else false)
676+        then _validatePublicKeys(signers_, "setActiveSigners: invalid signers")
677+        else false)
678+        then _validateInt(t_, 2, size(signers_), "setActiveSigners: invalid T")
679+        else false)
680+        then _validateString(signerGroupPublicKey_, "setActiveSigners: invalid signerGroupPublicKey")
681+        else false
682+    if ((err == err))
683+        then {
684+            let epoch = _loadCurrentEpoch(execChainId_)
685+            $Tuple2(((((_saveCurrentEpoch(execChainId_, (epoch + 1)) ++ _saveT(execChainId_, (epoch + 1), t_)) ++ _saveSigners(execChainId_, (epoch + 1), signers_)) ++ _saveSignerGroupPublicKey(execChainId_, (epoch + 1), fromBase58String(signerGroupPublicKey_))) ++ _incrementLocks(signers_)), unit)
686+            }
687+        else throw("Strict value is not equal to itself.")
688+    }
689+
690+
691+
692+@Callable(i)
693+func submitR (eventId_,execChainId_,r_) = {
694+    let callerPublicKey = toBase58String(i.callerPublicKey)
695+    let epoch = _loadCurrentEpoch(execChainId_)
696+    let t = _loadT(execChainId_, epoch)
697+    let err = if (if (if (if (if (if (if (if (_whenInitialized())
698+        then _validateInt(eventId_, 0, MAX_INT, "submitR: invalid eventId")
699+        else false)
700+        then _validateInt(execChainId_, 0, MAX_INT, "submitR: invalid execChainId")
701+        else false)
702+        then _validateString(r_, "submitR: invalid r")
703+        else false)
704+        then _isConfirmedEvent(eventId_, execChainId_, "submitR: event not confirmed")
705+        else false)
706+        then _isActiveSigner(callerPublicKey, _loadSigners(execChainId_, epoch), "submitR: not active")
707+        else false)
708+        then _checkSecDepo(callerPublicKey, "submitR: not enough security deposit")
709+        else false)
710+        then _checkEventStatusForSubmitR(execChainId_, eventId_, "submitR: invalid event status")
711+        else false)
712+        then _notSubmittedR(execChainId_, eventId_, callerPublicKey, "submitR: already submitted")
713+        else false
714+    if ((err == err))
715+        then {
716+            let rArray = _loadRsByEvent(execChainId_, eventId_)
717+            let signersArray = _loadSignersWithRByEvent(execChainId_, eventId_)
718+            let eventStatusActions = if (((size(rArray) + 1) == t))
719+                then (_saveEventStatus(execChainId_, eventId_, EVENT_STATUS_SIGN) ++ _saveEventStartBlock(execChainId_, eventId_, height))
720+                else nil
721+            $Tuple2((((_saveRsByEvent(execChainId_, eventId_, (rArray :+ r_)) ++ _saveRByEventAndSigner(execChainId_, eventId_, callerPublicKey, r_)) ++ _saveSignersWithRByEvent(execChainId_, eventId_, (signersArray :+ callerPublicKey))) ++ eventStatusActions), unit)
722+            }
723+        else throw("Strict value is not equal to itself.")
724+    }
725+
726+
727+
728+@Callable(i)
729+func submitS (eventId_,execChainId_,rSigma_,s_,sSigma_) = {
730+    let callerPublicKey = toBase58String(i.callerPublicKey)
731+    let epoch = _loadCurrentEpoch(execChainId_)
732+    let t = _loadT(execChainId_, epoch)
733+    let err = if (if (if (if (if (if (if (if (if (_whenInitialized())
734+        then _validateInt(eventId_, 0, MAX_INT, "submitS: invalid eventId")
735+        else false)
736+        then _validateInt(execChainId_, 0, MAX_INT, "submitS: invalid execChainId")
737+        else false)
738+        then _validateString(rSigma_, "submitS: invalid r sigma")
739+        else false)
740+        then _validateString(s_, "submitS: invalid s")
741+        else false)
742+        then _isActiveSigner(callerPublicKey, _loadSigners(execChainId_, epoch), "submitS: not active")
743+        else false)
744+        then _checkSecDepo(callerPublicKey, "submitS: not enough security deposit")
745+        else false)
746+        then _checkEventStatusForSubmitS(execChainId_, eventId_, "submitS: invalid event status")
747+        else false)
748+        then _notSubmittedS(execChainId_, eventId_, callerPublicKey, "submitS: already submitted")
749+        else false)
750+        then _submittedR(execChainId_, eventId_, callerPublicKey, "submitS: R is not submitted")
751+        else false
752+    if ((err == err))
753+        then {
754+            let sArray = _loadSsByEvent(execChainId_, eventId_)
755+            let signersArray = _loadSignersWithSByEvent(execChainId_, eventId_)
756+            let eventStatusActions = if (((size(sArray) + 1) == t))
757+                then {
758+                    let err1 = if (_validateString(sSigma_, "submitS: invalid s sigma"))
759+                        then _verifySignature(execChainId_, epoch, eventId_, rSigma_, sSigma_, "submitS: invalid signature")
760+                        else false
761+                    if ((err1 == err1))
762+                        then {
763+                            let executorIdxSize = _loadSignedEventExecutorIdxSize(execChainId_)
764+                            let rewardAddresses = _publicKeysToAddrsStr((signersArray :+ callerPublicKey))
765+                            let signersRewards = invoke(_loadRewardTokenAddress(), FUNC_MINT_MANY, [_loadRewardAmount(), rewardAddresses], nil)
766+                            if ((signersRewards == signersRewards))
767+                                then (((_saveEventStatus(execChainId_, eventId_, EVENT_STATUS_DONE) ++ _saveSignedEventExecutorIdx(execChainId_, executorIdxSize, eventId_)) ++ _saveSignedEventExecutorIdxSize(execChainId_, (executorIdxSize + 1))) ++ _saveSSigmaByEvent(execChainId_, eventId_, sSigma_))
768+                                else throw("Strict value is not equal to itself.")
769+                            }
770+                        else throw("Strict value is not equal to itself.")
771+                    }
772+                else nil
773+            $Tuple2(((((_saveSsByEvent(execChainId_, eventId_, (sArray :+ s_)) ++ _saveSByEventAndSigner(execChainId_, eventId_, callerPublicKey, s_)) ++ _saveSignersWithSByEvent(execChainId_, eventId_, (signersArray :+ callerPublicKey))) ++ _saveRSigmaByEvent(execChainId_, eventId_, rSigma_)) ++ eventStatusActions), unit)
774+            }
775+        else throw("Strict value is not equal to itself.")
776+    }
777+
778+
779+
780+@Callable(i)
781+func reset (eventId_,execChainId_,r_) = {
782+    let callerPublicKey = toBase58String(i.callerPublicKey)
783+    let epoch = _loadCurrentEpoch(execChainId_)
784+    let err = if (if (if (if (if (if (_whenInitialized())
785+        then _validateInt(eventId_, 0, MAX_INT, "reset: invalid eventId")
786+        else false)
787+        then _validateInt(execChainId_, 0, MAX_INT, "reset: invalid execChainId")
788+        else false)
789+        then _validateString(r_, "reset: invalid r")
790+        else false)
791+        then _isActiveSigner(callerPublicKey, _loadSigners(execChainId_, epoch), "reset: not active")
792+        else false)
793+        then _checkSecDepo(callerPublicKey, "reset: not enough security deposit")
794+        else false)
795+        then _checkEventStatusForReset(execChainId_, eventId_, "reset: invalid event status")
796+        else false
797+    if ((err == err))
798+        then {
799+            let slashAmount = 0
800+            let signersWithR = _loadSignersWithRByEvent(execChainId_, eventId_)
801+            let signersWithS = _loadSignersWithSByEvent(execChainId_, eventId_)
802+            let result = _slashIncorrect(signersWithR, signersWithS)
803+            let slashingActions = result._1
804+            let compensatedSigners = result._2
805+            let compensation = result._3
806+            let compensationActions = _compensateCorrect(compensatedSigners, compensation)
807+            $Tuple2((((((((((_saveEventStatus(execChainId_, eventId_, EVENT_STATUS_INIT) ++ _saveRsByEvent(execChainId_, eventId_, [r_])) ++ _saveRByEventAndSigner(execChainId_, eventId_, callerPublicKey, r_)) ++ _saveSignersWithRByEvent(execChainId_, eventId_, [callerPublicKey])) ++ _saveRSigmaByEvent(execChainId_, eventId_, "")) ++ _saveSsByEvent(execChainId_, eventId_, nil)) ++ _saveSignersWithSByEvent(execChainId_, eventId_, nil)) ++ _saveSSigmaByEvent(execChainId_, eventId_, "")) ++ slashingActions) ++ compensationActions), unit)
808+            }
809+        else throw("Strict value is not equal to itself.")
810+    }
811+
812+
813+
814+@Callable(i)
815+func addSecurityDeposit (recipient_) = {
816+    let recipient = if ((recipient_ == ""))
817+        then toString(i.caller)
818+        else recipient_
819+    let err = if (if (_validateAddress(recipient, "addSecurityDeposit: invalid recipient"))
820+        then _validatePaymentsSize(i.payments, 1, "addSecurityDeposit: no payment")
821+        else false)
822+        then _validatePaymentAsset(i.payments[0], unit, "addSecurityDeposit: invalid asset")
823+        else false
824+    if ((err == err))
825+        then {
826+            let recipientAddr = addressFromStringValue(recipient)
827+            let balance = _loadSecDepo(recipientAddr)
828+            let updatedBalance = (balance + i.payments[0].amount)
829+            $Tuple2(_saveSecDepo(recipientAddr, updatedBalance), unit)
830+            }
831+        else throw("Strict value is not equal to itself.")
832+    }
833+
834+
835+
836+@Callable(i)
837+func subSecurityDeposit (amount_) = {
838+    let balance = _loadSecDepo(i.caller)
839+    let err = if (_isZeroLock(toBase58String(i.callerPublicKey), "subSecurityDeposit: locked"))
840+        then if ((amount_ > balance))
841+            then throw("subSecurityDeposit: insufficient balance")
842+            else true
843+        else false
844+    if ((err == err))
845+        then $Tuple2((_saveSecDepo(i.caller, (balance - amount_)) ++ [ScriptTransfer(i.caller, amount_, unit)]), unit)
846+        else throw("Strict value is not equal to itself.")
847+    }
848+
849+
850+
851+@Callable(i)
852+func setMultisig (multisig_) = {
853+    let err = if (_onlyThisContract(i.caller))
854+        then _validateAddress(multisig_, "setMultisig: invalid multisig address")
855+        else false
856+    if ((err == err))
857+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
858+        else throw("Strict value is not equal to itself.")
859+    }
860+
861+
862+@Verifier(tx)
863+func verify () = match getString(KEY_MULTISIG) {
864+    case multisig: String => 
865+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
866+    case _ => 
867+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
868+}
869+
github/deemru/w8io/786bc32 
39.64 ms ◑