tx · CFV4eKFz2LV7Rm5AgNaF2642xnVcfVFVH284wv32tPGL

3M3Cd3KGF61DzHzWR2fBvFNHrCaFdw13wUk:  -0.03150000 Waves

2025.11.14 02:01 [621928] smart account 3M3Cd3KGF61DzHzWR2fBvFNHrCaFdw13wUk > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CFV4eKFz2LV7Rm5AgNaF2642xnVcfVFVH284wv32tPGL",
    "fee": 3150000,
    "feeAssetId": null,
    "timestamp": 1763074870815,
    "version": 2,
    "chainId": 82,
    "sender": "3M3Cd3KGF61DzHzWR2fBvFNHrCaFdw13wUk",
    "senderPublicKey": "9EXmPkVGSHKvxha7ciBTCCua7PhuMBtzKcG3kQBAMNKh",
    "proofs": [
        "5y58f5nX7n5tpdafWRv6XNi4rH6YQdDbLURT5HmUoEoxKT7xiN31xruCCVpJXzJfLGbAPaGGumw99sNQsC6pGcLb"
    ],
    "script": "base64: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",
    "height": 621928,
    "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 VERSION = "1.0.3"
5+
6+let SEP = "_"
7+
8+let BIGSEP = "__"
9+
10+let k_ADMINS = "ADMINS_PBKS"
11+
12+let k_SUPERADMINS = "SUPERADMINS_PBKS"
13+
14+let k_MANAGERS = "MANAGERS_PBKS"
15+
16+let k_LIMIT = "VOTES_QUORUM"
17+
18+let k_SCRIPT_TYPES = "SCRIPT_TYPES"
19+
20+let k_ITERATION = "ITERATION"
21+
22+let k_INITED = "INITED"
23+
24+let k_SCRIPTS_COOLDOWN = "SCRIPTSCOOLDOWN"
25+
26+let k_scriptType = "scriptType"
27+
28+let k_scriptHash = "scriptHash"
29+
30+let k_storageAddress = "storageAddress"
31+
32+let k_desc = "desc"
33+
34+let k_iter = "iteration"
35+
36+let k_initiator = "initiator"
37+
38+let k_confirmations = "confirmations"
39+
40+let k_validBlocks = "validBlocks"
41+
42+let k_validTo = "validTo"
43+
44+let k_validFrom = "validFrom"
45+
46+func _validatePbk (pbk) = {
47+    let keyBytes = fromBase58String(pbk)
48+    let checkLength = if ((size(keyBytes) != 32))
49+        then throw("Invalid public key")
50+        else true
51+    if ((checkLength == checkLength))
52+        then {
53+            let address = addressFromPublicKey(keyBytes)
54+            if ((address == address))
55+                then {
56+                    let addressStr = toString(address)
57+                    if ((addressStr == addressStr))
58+                        then (size(addressStr) > 0)
59+                        else throw("Strict value is not equal to itself.")
60+                    }
61+                else throw("Strict value is not equal to itself.")
62+            }
63+        else throw("Strict value is not equal to itself.")
64+    }
65+
66+
67+func _validateAddress (address) = {
68+    let addr = addressFromStringValue(address)
69+    if ((addr == addr))
70+        then true
71+        else throw("Strict value is not equal to itself.")
72+    }
73+
74+
75+func _validateTs (ts) = {
76+    let currTs =     match blockInfoByHeight(height) {
77+        case block: BlockInfo => 
78+            block.timestamp
79+        case _ => 
80+            throw("Can't find block")
81+    }
82+    let oneHour = ((60 * 60) * 1000)
83+    let minTs = (currTs - oneHour)
84+    (ts >= minTs)
85+    }
86+
87+
88+func _getLimit () = valueOrErrorMessage(getInteger(k_LIMIT), "Quorum limit not defined")
89+
90+
91+func _isAdmin (pbk) = {
92+    let adminsStr = valueOrElse(getString(k_ADMINS), "")
93+    let admins = split(adminsStr, ",")
94+    (indexOf(admins, pbk) != unit)
95+    }
96+
97+
98+func _isSuperAdmin (pbk) = {
99+    let superAdminsStr = valueOrElse(getString(k_SUPERADMINS), "")
100+    let superAdmins = split(superAdminsStr, ",")
101+    (indexOf(superAdmins, pbk) != unit)
102+    }
103+
104+
105+func _isManager (pbk) = {
106+    let managersStr = valueOrElse(getString(k_MANAGERS), "")
107+    let managers = split(managersStr, ",")
108+    (indexOf(managers, pbk) != unit)
109+    }
110+
111+
112+func _isValidOperator (pbk) = {
113+    let managersStr = valueOrElse(getString(k_MANAGERS), "")
114+    let managers = split(managersStr, ",")
115+    let isAdmin = _isAdmin(pbk)
116+    let isManager = _isManager(pbk)
117+    if (isAdmin)
118+        then true
119+        else isManager
120+    }
121+
122+
123+func _isInited () = valueOrElse(getBoolean(k_INITED), false)
124+
125+
126+func saveTxData (taskId,data) = {
127+    let indices = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
128+    let dataSize = size(data)
129+    let isNotEmpty = if ((dataSize != 0))
130+        then true
131+        else throw("saveTxData: Empty data passed")
132+    if ((isNotEmpty == isNotEmpty))
133+        then {
134+            let chunkSize = 30000
135+            let chunksCount = if (((dataSize % chunkSize) == 0))
136+                then (dataSize / chunkSize)
137+                else ((dataSize / chunkSize) + 1)
138+            func makeChunks (accum,index) =             {
139+                let chunk = take(accum._1, chunkSize)
140+                if ((size(chunk) == 0))
141+                    then accum
142+                    else {
143+                        let nextData = drop(accum._1, chunkSize)
144+                        $Tuple2(nextData, (accum._2 :+ StringEntry(((taskId + "__txdata_") + toString(index)), chunk)))
145+                        }
146+                }
147+
148+            let entries = {
149+                let $l = indices
150+                let $s = size($l)
151+                let $acc0 = $Tuple2(data, [StringEntry((taskId + "__txdata_chunks"), toString(chunksCount))])
152+                func $f0_1 ($a,$i) =                 if (($i >= $s))
153+                    then $a
154+                    else makeChunks($a, $l[$i])
155+
156+                func $f0_2 ($a,$i) =                 if (($i >= $s))
157+                    then $a
158+                    else throw("List size exceeds 10")
159+
160+                $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)
161+                }
162+            entries._2
163+            }
164+        else throw("Strict value is not equal to itself.")
165+    }
166+
167+
168+@Callable(i)
169+func init (admins_pbks,limit,scriptsCooldown) = {
170+    let checkInited = if (_isInited())
171+        then throw("Already inited")
172+        else true
173+    if ((checkInited == checkInited))
174+        then {
175+            let size_admins = if ((size(admins_pbks) != 0))
176+                then true
177+                else throw("At least one admin pbk should be passed")
178+            if ((size_admins == size_admins))
179+                then {
180+                    let check_admins = if (!(isDefined(getString(k_ADMINS))))
181+                        then true
182+                        else throw("Already inited")
183+                    if ((check_admins == check_admins))
184+                        then {
185+                            let zeroLimit = if ((limit > 0))
186+                                then true
187+                                else throw("Limit should be > 0")
188+                            if ((zeroLimit == zeroLimit))
189+                                then {
190+                                    let checkScriptsCooldown = if ((scriptsCooldown > 0))
191+                                        then true
192+                                        else throw("Scripts cooldown should be > 0")
193+                                    if ((checkScriptsCooldown == checkScriptsCooldown))
194+                                        then {
195+                                            let limit_ok = if ((size(admins_pbks) >= limit))
196+                                                then true
197+                                                else throw(((("Limit quorum should be <= size of list of admins, limit: " + toString(limit)) + ", current size: ") + toString(size(admins_pbks))))
198+                                            if ((limit_ok == limit_ok))
199+                                                then {
200+                                                    func validate (accum,next) =                                                     _validatePbk(next)
201+
202+                                                    let validRes = {
203+                                                        let $l = admins_pbks
204+                                                        let $s = size($l)
205+                                                        let $acc0 = ""
206+                                                        func $f0_1 ($a,$i) =                                                         if (($i >= $s))
207+                                                            then $a
208+                                                            else validate($a, $l[$i])
209+
210+                                                        func $f0_2 ($a,$i) =                                                         if (($i >= $s))
211+                                                            then $a
212+                                                            else throw("List size exceeds 10")
213+
214+                                                        $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)
215+                                                        }
216+                                                    if ((validRes == validRes))
217+                                                        then {
218+                                                            let adminsStr = makeString(admins_pbks, ",")
219+[StringEntry(k_ADMINS, adminsStr), IntegerEntry(k_LIMIT, limit), IntegerEntry(k_SCRIPTS_COOLDOWN, scriptsCooldown), BooleanEntry(k_INITED, true)]
220+                                                            }
221+                                                        else throw("Strict value is not equal to itself.")
222+                                                    }
223+                                                else throw("Strict value is not equal to itself.")
224+                                            }
225+                                        else throw("Strict value is not equal to itself.")
226+                                    }
227+                                else throw("Strict value is not equal to itself.")
228+                            }
229+                        else throw("Strict value is not equal to itself.")
230+                    }
231+                else throw("Strict value is not equal to itself.")
232+            }
233+        else throw("Strict value is not equal to itself.")
234+    }
235+
236+
237+
238+@Callable(i)
239+func addAdmin (pbk) = {
240+    let callerPbk = toBase58String(i.callerPublicKey)
241+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
242+        then true
243+        else throw("Only self invoke")
244+    if ((isSelf == isSelf))
245+        then {
246+            let isValid = if (_validatePbk(pbk))
247+                then true
248+                else throw("Invalid admin pbk")
249+            if ((isValid == isValid))
250+                then {
251+                    let admins = getStringValue(k_ADMINS)
252+                    let checkPresent = if ((indexOf(admins, pbk) != unit))
253+                        then throw("This admin already present")
254+                        else true
255+                    if ((checkPresent == checkPresent))
256+                        then {
257+                            let newAdminsStr = ((admins + ",") + pbk)
258+[StringEntry(k_ADMINS, newAdminsStr)]
259+                            }
260+                        else throw("Strict value is not equal to itself.")
261+                    }
262+                else throw("Strict value is not equal to itself.")
263+            }
264+        else throw("Strict value is not equal to itself.")
265+    }
266+
267+
268+
269+@Callable(i)
270+func removeAdmin (pbk) = {
271+    let callerPbk = toBase58String(i.callerPublicKey)
272+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
273+        then true
274+        else throw("Only self invoke")
275+    if ((isSelf == isSelf))
276+        then {
277+            let isValid = if (_validatePbk(pbk))
278+                then true
279+                else throw("Invalid admin pbk")
280+            if ((isValid == isValid))
281+                then {
282+                    let oldAdminsStr = getStringValue(k_ADMINS)
283+                    let oldAdmins = split(oldAdminsStr, ",")
284+                    let checkCount = if ((1 >= size(oldAdmins)))
285+                        then throw("Cannot remove, at least one admin should remain")
286+                        else true
287+                    if ((checkCount == checkCount))
288+                        then {
289+                            let index = valueOrErrorMessage(indexOf(oldAdmins, pbk), "This pbk is not an admin")
290+                            let newAdmins = removeByIndex(oldAdmins, index)
291+                            let newAdminsStr = makeString(newAdmins, ",")
292+[StringEntry(k_ADMINS, newAdminsStr)]
293+                            }
294+                        else throw("Strict value is not equal to itself.")
295+                    }
296+                else throw("Strict value is not equal to itself.")
297+            }
298+        else throw("Strict value is not equal to itself.")
299+    }
300+
301+
302+
303+@Callable(i)
304+func addManager (pbk) = {
305+    let callerPbk = toBase58String(i.callerPublicKey)
306+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
307+        then true
308+        else throw("Only self invoke")
309+    if ((isSelf == isSelf))
310+        then {
311+            let isValid = if (_validatePbk(pbk))
312+                then true
313+                else throw("Invalid manager pbk")
314+            if ((isValid == isValid))
315+                then {
316+                    let managers = valueOrElse(getString(k_MANAGERS), "")
317+                    let checkPresent = if ((indexOf(managers, pbk) != unit))
318+                        then throw("This manager already present")
319+                        else true
320+                    if ((checkPresent == checkPresent))
321+                        then {
322+                            let newManagersStr = if ((managers == ""))
323+                                then pbk
324+                                else ((managers + ",") + pbk)
325+[StringEntry(k_MANAGERS, newManagersStr)]
326+                            }
327+                        else throw("Strict value is not equal to itself.")
328+                    }
329+                else throw("Strict value is not equal to itself.")
330+            }
331+        else throw("Strict value is not equal to itself.")
332+    }
333+
334+
335+
336+@Callable(i)
337+func removeManager (pbk) = {
338+    let callerPbk = toBase58String(i.callerPublicKey)
339+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
340+        then true
341+        else throw("Only self invoke")
342+    if ((isSelf == isSelf))
343+        then {
344+            let isValid = if (_validatePbk(pbk))
345+                then true
346+                else throw("Invalid manager pbk")
347+            if ((isValid == isValid))
348+                then {
349+                    let oldManagersStr = getStringValue(k_MANAGERS)
350+                    let oldManagers = split(oldManagersStr, ",")
351+                    let index = valueOrErrorMessage(indexOf(oldManagers, pbk), "This pbk is not an manager")
352+                    let newManagers = removeByIndex(oldManagers, index)
353+                    let newManagersStr = makeString(newManagers, ",")
354+[StringEntry(k_MANAGERS, newManagersStr)]
355+                    }
356+                else throw("Strict value is not equal to itself.")
357+            }
358+        else throw("Strict value is not equal to itself.")
359+    }
360+
361+
362+
363+@Callable(i)
364+func addScriptType (scriptType) = {
365+    let callerPbk = toBase58String(i.callerPublicKey)
366+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
367+        then true
368+        else throw("Only self invoke")
369+    if ((isSelf == isSelf))
370+        then {
371+            let checkEmpty = if ((size(scriptType) == 0))
372+                then throw("Script type can not be empty")
373+                else true
374+            if ((checkEmpty == checkEmpty))
375+                then {
376+                    let scriptTypesStr = valueOrElse(getString(k_SCRIPT_TYPES), "")
377+                    let scriptTypes = split_4C(scriptTypesStr, ",")
378+                    let checkExists = if ((indexOf(scriptTypes, scriptType) != unit))
379+                        then throw((("Script type <" + scriptType) + "> already added"))
380+                        else true
381+                    if ((checkExists == checkExists))
382+                        then {
383+                            let newScriptTypes = if ((scriptTypesStr != ""))
384+                                then (scriptTypes :+ scriptType)
385+                                else [scriptType]
386+                            let newScriptTypesStr = makeString(newScriptTypes, ",")
387+[StringEntry(k_SCRIPT_TYPES, newScriptTypesStr)]
388+                            }
389+                        else throw("Strict value is not equal to itself.")
390+                    }
391+                else throw("Strict value is not equal to itself.")
392+            }
393+        else throw("Strict value is not equal to itself.")
394+    }
395+
396+
397+
398+@Callable(i)
399+func removeScriptType (scriptType) = {
400+    let callerPbk = toBase58String(i.callerPublicKey)
401+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
402+        then true
403+        else throw("Only self invoke")
404+    if ((isSelf == isSelf))
405+        then {
406+            let scriptTypesStr = valueOrElse(getString(k_SCRIPT_TYPES), "")
407+            let scriptTypes = split_4C(scriptTypesStr, ",")
408+            let index = valueOrErrorMessage(indexOf(scriptTypes, scriptType), (("Script type <" + scriptType) + "> is not present"))
409+            let newScriptTypes = removeByIndex(scriptTypes, index)
410+            let newScriptTypesStr = makeString(newScriptTypes, ",")
411+[StringEntry(k_SCRIPT_TYPES, newScriptTypesStr)]
412+            }
413+        else throw("Strict value is not equal to itself.")
414+    }
415+
416+
417+
418+@Callable(i)
419+func setLimit (limit) = {
420+    let callerPbk = toBase58String(i.callerPublicKey)
421+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
422+        then true
423+        else throw("Only self invoke")
424+    if ((isSelf == isSelf))
425+        then {
426+            let zeroLimit = if ((limit > 0))
427+                then true
428+                else throw("Limit should be > 0")
429+            if ((zeroLimit == zeroLimit))
430+                then {
431+                    let admins = getStringValue(k_ADMINS)
432+                    if ((limit > size(admins)))
433+                        then throw(((("Limit quorum should be <= size of list of admins, limit: " + toString(limit)) + ", current size: ") + toString(size(admins))))
434+                        else [IntegerEntry(k_LIMIT, limit)]
435+                    }
436+                else throw("Strict value is not equal to itself.")
437+            }
438+        else throw("Strict value is not equal to itself.")
439+    }
440+
441+
442+
443+@Callable(i)
444+func setCooldownBlocks (scriptsCooldown) = {
445+    let callerPbk = toBase58String(i.callerPublicKey)
446+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
447+        then true
448+        else throw("Only self invoke")
449+    if ((isSelf == isSelf))
450+        then {
451+            let checkScriptsCooldown = if ((scriptsCooldown > 0))
452+                then true
453+                else throw("Scripts cooldown should be > 0")
454+            if ((checkScriptsCooldown == checkScriptsCooldown))
455+                then [IntegerEntry(k_SCRIPTS_COOLDOWN, scriptsCooldown)]
456+                else throw("Strict value is not equal to itself.")
457+            }
458+        else throw("Strict value is not equal to itself.")
459+    }
460+
461+
462+
463+@Callable(i)
464+func addScript (scriptType,storageAddress,_scriptHash,desc,initiatorAdr,validBlocks) = {
465+    let callerPbk = toBase58String(i.callerPublicKey)
466+    let storageScriptHash = toBase58String(value(scriptHash(addressFromStringValue(storageAddress))))
467+    let scriptTypesStr = getStringValue(k_SCRIPT_TYPES)
468+    let isAllowed = if (!(_isAdmin(callerPbk)))
469+        then throw("Only admins are allowed")
470+        else true
471+    if ((isAllowed == isAllowed))
472+        then {
473+            let _checkScriptTypes = if ((indexOf(scriptTypesStr, scriptType) == unit))
474+                then throw(("invalid script type or it is not present in storage: " + scriptType))
475+                else true
476+            if ((_checkScriptTypes == _checkScriptTypes))
477+                then {
478+                    let _scriptStorageHashCheck = if ((storageScriptHash != _scriptHash))
479+                        then throw("Stored and passed as argument scriptHashes not match")
480+                        else true
481+                    if ((_scriptStorageHashCheck == _scriptStorageHashCheck))
482+                        then {
483+                            let _descCheck = if ((size(desc) == 0))
484+                                then throw("Description can't be empty")
485+                                else true
486+                            if ((_descCheck == _descCheck))
487+                                then {
488+                                    let _initiatorCheck = if ((toString(addressFromPublicKey(i.callerPublicKey)) != initiatorAdr))
489+                                        then throw("Initiator address doesn't match caller")
490+                                        else true
491+                                    if ((_initiatorCheck == _initiatorCheck))
492+                                        then {
493+                                            let _checkValidBlocks = if ((validBlocks > 0))
494+                                                then true
495+                                                else throw("Valid blocks should be > 0")
496+                                            if ((_checkValidBlocks == _checkValidBlocks))
497+                                                then {
498+                                                    let iteration = (valueOrElse(getInteger(((k_ITERATION + SEP) + scriptType)), 0) + 1)
499+                                                    let scriptId = ((("script%%" + scriptType) + "%%") + _scriptHash)
500+                                                    let _checkPresent = if (isDefined(getString(((scriptId + BIGSEP) + k_scriptHash))))
501+                                                        then throw("Script with this hash already present")
502+                                                        else true
503+                                                    if ((_checkPresent == _checkPresent))
504+                                                        then [StringEntry(((scriptId + BIGSEP) + k_scriptType), scriptType), StringEntry(((scriptId + BIGSEP) + k_storageAddress), storageAddress), StringEntry(((scriptId + BIGSEP) + k_scriptHash), storageScriptHash), StringEntry(((scriptId + BIGSEP) + k_desc), desc), IntegerEntry(((scriptId + BIGSEP) + k_iter), iteration), IntegerEntry(((scriptId + BIGSEP) + k_validBlocks), validBlocks), StringEntry(((scriptId + BIGSEP) + k_initiator), initiatorAdr), StringEntry((((((scriptType + BIGSEP) + k_iter) + BIGSEP) + toString(iteration)) + "__hash"), _scriptHash), IntegerEntry(((k_ITERATION + SEP) + scriptType), iteration)]
505+                                                        else throw("Strict value is not equal to itself.")
506+                                                    }
507+                                                else throw("Strict value is not equal to itself.")
508+                                            }
509+                                        else throw("Strict value is not equal to itself.")
510+                                    }
511+                                else throw("Strict value is not equal to itself.")
512+                            }
513+                        else throw("Strict value is not equal to itself.")
514+                    }
515+                else throw("Strict value is not equal to itself.")
516+            }
517+        else throw("Strict value is not equal to itself.")
518+    }
519+
520+
521+
522+@Callable(i)
523+func removeScript (scriptId) = {
524+    let callerPbk = toBase58String(i.callerPublicKey)
525+    if (!(_isAdmin(callerPbk)))
526+        then throw("Only admins are allowed")
527+        else {
528+            let initiatorAdr = getStringValue((scriptId + "__initiator"))
529+            if ((initiatorAdr != toString(addressFromPublicKey(i.callerPublicKey))))
530+                then throw("Only creator can remove")
531+                else {
532+                    let scriptType = getStringValue(((scriptId + BIGSEP) + k_scriptType))
533+                    let _scriptHash = getStringValue(((scriptId + BIGSEP) + k_scriptHash))
534+                    let iter = getIntegerValue(((scriptId + BIGSEP) + k_iter))
535+                    let approvedHashes = valueOrElse(getString((("script_" + scriptType) + "__approved")), "")
536+                    let _checkApproved = if ((indexOf(approvedHashes, _scriptHash) != unit))
537+                        then throw("Cant remove approved script, use revoke")
538+                        else true
539+                    if ((_checkApproved == _checkApproved))
540+                        then [DeleteEntry(((scriptId + BIGSEP) + k_scriptType)), DeleteEntry(((scriptId + BIGSEP) + k_storageAddress)), DeleteEntry(((scriptId + BIGSEP) + k_scriptHash)), DeleteEntry(((scriptId + BIGSEP) + k_desc)), DeleteEntry(((scriptId + BIGSEP) + k_iter)), DeleteEntry(((scriptId + BIGSEP) + k_validBlocks)), DeleteEntry((((scriptType + "__iteration__") + toString(iter)) + "__hash")), DeleteEntry(((scriptId + BIGSEP) + k_initiator)), DeleteEntry(((scriptId + BIGSEP) + k_confirmations)), DeleteEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validFrom)), DeleteEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo))]
541+                        else throw("Strict value is not equal to itself.")
542+                    }
543+            }
544+    }
545+
546+
547+
548+@Callable(i)
549+func addConfirmationScript (scriptId) = {
550+    let callerPbk = toBase58String(i.callerPublicKey)
551+    let limit = _getLimit()
552+    let checkAdmin = if (!(_isValidOperator(callerPbk)))
553+        then throw("Only whitelisted can confirm")
554+        else true
555+    if ((checkAdmin == checkAdmin))
556+        then {
557+            let _scriptHash = valueOrErrorMessage(getString(((scriptId + BIGSEP) + k_scriptHash)), "Ivalid scriptId")
558+            if ((_scriptHash == _scriptHash))
559+                then {
560+                    let scriptType = getStringValue(((scriptId + BIGSEP) + k_scriptType))
561+                    let validBlocks = getIntegerValue(((scriptId + BIGSEP) + k_validBlocks))
562+                    let globalIteration = valueOrElse(getInteger(((k_ITERATION + SEP) + scriptType)), 0)
563+                    let thisIteration = value(getInteger((scriptId + "__iteration")))
564+                    let confirmationsStr = valueOrElse(getString((scriptId + "__confirmations")), "")
565+                    let confirmations = split(confirmationsStr, ",")
566+                    if ((indexOf(confirmations, callerPbk) != unit))
567+                        then throw("You already confirmed this script")
568+                        else {
569+                            let newList = if ((confirmationsStr != ""))
570+                                then (confirmations :+ callerPbk)
571+                                else [callerPbk]
572+                            let newListStr = makeString(newList, ",")
573+                            let approved = (size(newList) >= limit)
574+                            let result = if (approved)
575+                                then [IntegerEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validFrom), (height + getIntegerValue(k_SCRIPTS_COOLDOWN))), IntegerEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo), (height + validBlocks))]
576+                                else nil
577+                            (result ++ [StringEntry((scriptId + "__confirmations"), newListStr)])
578+                            }
579+                    }
580+                else throw("Strict value is not equal to itself.")
581+            }
582+        else throw("Strict value is not equal to itself.")
583+    }
584+
585+
586+
587+@Callable(i)
588+func revokeConfirmationScript (scriptId) = {
589+    let callerPbk = toBase58String(i.callerPublicKey)
590+    let limit = _getLimit()
591+    if (!(_isValidOperator(callerPbk)))
592+        then throw("Only whitelisted can revoke")
593+        else {
594+            let _scriptHash = valueOrErrorMessage(getString((scriptId + "__scriptHash")), "Invalid scriptId")
595+            if ((_scriptHash == _scriptHash))
596+                then {
597+                    let scriptType = getStringValue((scriptId + "__scriptType"))
598+                    let confirmationsStr = valueOrElse(getString((scriptId + "__confirmations")), "")
599+                    let confirmations = split(confirmationsStr, ",")
600+                    let confirmIndex = indexOf(confirmations, callerPbk)
601+                    let isExpired = (height > valueOrElse(getInteger(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo)), (height + 1)))
602+                    let checkExpired = if (!(isExpired))
603+                        then true
604+                        else throw("Expired scripts can't be revoked")
605+                    if ((checkExpired == checkExpired))
606+                        then if ((confirmIndex == unit))
607+                            then throw("You didn't confirm this script, nothing to revoke")
608+                            else {
609+                                let newConfirmations = removeByIndex(confirmations, value(confirmIndex))
610+                                let newConfirmationsStr = makeString(newConfirmations, ",")
611+                                let wasApproved = if (isDefined(getInteger(((_scriptHash + SEP) + k_validFrom))))
612+                                    then isDefined(getInteger(((_scriptHash + SEP) + k_validTo)))
613+                                    else false
614+                                let stillApproved = (size(newConfirmations) >= limit)
615+                                let stateChanges = if (if (wasApproved)
616+                                    then !(stillApproved)
617+                                    else false)
618+                                    then [DeleteEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validFrom)), DeleteEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo))]
619+                                    else nil
620+                                (stateChanges ++ [StringEntry((scriptId + "__confirmations"), newConfirmationsStr)])
621+                                }
622+                        else throw("Strict value is not equal to itself.")
623+                    }
624+                else throw("Strict value is not equal to itself.")
625+            }
626+    }
627+
628+
629+
630+@Callable(i)
631+func addTask (name,dapp,txid,executeTs,desc,initiatorAdr,txdata) = {
632+    let callerPbk = toBase58String(i.callerPublicKey)
633+    if (!(_isAdmin(callerPbk)))
634+        then throw("Only admins are allowed")
635+        else {
636+            let _nameCheck = if ((size(name) == 0))
637+                then throw("Name can't be empty")
638+                else true
639+            if ((_nameCheck == _nameCheck))
640+                then {
641+                    let _dappCheck = if (!(_validateAddress(dapp)))
642+                        then throw("Incorrect dapp")
643+                        else true
644+                    if ((_dappCheck == _dappCheck))
645+                        then {
646+                            let _txidCheck = if ((size(txid) == 0))
647+                                then throw("txid can't be empty")
648+                                else true
649+                            if ((_txidCheck == _txidCheck))
650+                                then {
651+                                    let _timestampCheck = if (!(_validateTs(executeTs)))
652+                                        then throw("Invalid execution timestamp - cannot be more than 1 hour in the past")
653+                                        else true
654+                                    if ((_timestampCheck == _timestampCheck))
655+                                        then {
656+                                            let _descCheck = if ((size(desc) == 0))
657+                                                then throw("Description can't be empty")
658+                                                else true
659+                                            if ((_descCheck == _descCheck))
660+                                                then {
661+                                                    let _initiatorCheck = if ((toString(addressFromPublicKey(i.callerPublicKey)) != initiatorAdr))
662+                                                        then throw("Initiator address doesn't match caller")
663+                                                        else true
664+                                                    if ((_initiatorCheck == _initiatorCheck))
665+                                                        then {
666+                                                            let _txdataCheck = if ((size(txdata) == 0))
667+                                                                then throw("Tx data can't be empty")
668+                                                                else true
669+                                                            if ((_txdataCheck == _txdataCheck))
670+                                                                then {
671+                                                                    let taskId = ((("tx_" + dapp) + SEP) + txid)
672+[StringEntry((taskId + "__name"), name), StringEntry((taskId + "__dapp"), dapp), StringEntry((taskId + "__txId"), txid), StringEntry((taskId + "__desc"), desc), StringEntry((taskId + "__txdata"), txdata), StringEntry((taskId + "__initiator"), initiatorAdr), IntegerEntry((taskId + "__ts"), executeTs)]
673+                                                                    }
674+                                                                else throw("Strict value is not equal to itself.")
675+                                                            }
676+                                                        else throw("Strict value is not equal to itself.")
677+                                                    }
678+                                                else throw("Strict value is not equal to itself.")
679+                                            }
680+                                        else throw("Strict value is not equal to itself.")
681+                                    }
682+                                else throw("Strict value is not equal to itself.")
683+                            }
684+                        else throw("Strict value is not equal to itself.")
685+                    }
686+                else throw("Strict value is not equal to itself.")
687+            }
688+    }
689+
690+
691+
692+@Callable(i)
693+func removeTask (taskId) = {
694+    let callerPbk = toBase58String(i.callerPublicKey)
695+    if (!(_isAdmin(callerPbk)))
696+        then throw("Only admins are allowed")
697+        else {
698+            let initiatorAdr = getStringValue((taskId + "__initiator"))
699+            if ((initiatorAdr != toString(addressFromPublicKey(i.callerPublicKey))))
700+                then throw("Only creator can remove")
701+                else {
702+                    let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
703+                    if ((txId == txId))
704+                        then {
705+                            let dapp = getStringValue((taskId + "__dapp"))
706+[DeleteEntry((taskId + "__name")), DeleteEntry((taskId + "__dapp")), DeleteEntry((taskId + "__txId")), DeleteEntry((taskId + "__desc")), DeleteEntry((taskId + "__txdata")), DeleteEntry((taskId + "__initiator")), DeleteEntry((taskId + "__ts")), DeleteEntry((taskId + "__confirmations")), DeleteEntry((((dapp + SEP) + txId) + "__approved"))]
707+                            }
708+                        else throw("Strict value is not equal to itself.")
709+                    }
710+            }
711+    }
712+
713+
714+
715+@Callable(i)
716+func addConfirmation (taskId) = {
717+    let callerPbk = toBase58String(i.callerPublicKey)
718+    let limit = _getLimit()
719+    if (!(_isValidOperator(callerPbk)))
720+        then throw("Only whitelisted can confirm")
721+        else {
722+            let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
723+            if ((txId == txId))
724+                then {
725+                    let dapp = getStringValue((taskId + "__dapp"))
726+                    let confirmationsStr = valueOrElse(getString((taskId + "__confirmations")), "")
727+                    let confirmations = split(confirmationsStr, ",")
728+                    if ((indexOf(confirmations, callerPbk) != unit))
729+                        then throw("You already confirmed this task")
730+                        else {
731+                            let newList = if ((confirmationsStr != ""))
732+                                then (confirmations :+ callerPbk)
733+                                else [callerPbk]
734+                            let newListStr = makeString(newList, ",")
735+                            let approved = (size(newList) >= limit)
736+[StringEntry((taskId + "__confirmations"), newListStr), BooleanEntry((((dapp + SEP) + txId) + "__approved"), approved)]
737+                            }
738+                    }
739+                else throw("Strict value is not equal to itself.")
740+            }
741+    }
742+
743+
744+
745+@Callable(i)
746+func revokeTask (taskId) = {
747+    let callerPbk = toBase58String(i.callerPublicKey)
748+    let limit = _getLimit()
749+    if (!(_isValidOperator(callerPbk)))
750+        then throw("Only whitelisted can call")
751+        else {
752+            let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
753+            if ((txId == txId))
754+                then {
755+                    let confirmationsStr = valueOrElse(getString((taskId + "__confirmations")), "")
756+                    let confirmations = split(confirmationsStr, ",")
757+                    let indexMy = indexOf(confirmations, callerPbk)
758+                    if ((indexMy == unit))
759+                        then throw("You did not confirm this task, nothing to revoke")
760+                        else {
761+                            let dapp = getStringValue((taskId + "__dapp"))
762+                            let newList = removeByIndex(confirmations, value(indexMy))
763+                            let newListStr = makeString(newList, ",")
764+                            let approved = (size(newList) >= limit)
765+[StringEntry((taskId + "__confirmations"), newListStr), BooleanEntry((((dapp + SEP) + txId) + "__approved"), approved)]
766+                            }
767+                    }
768+                else throw("Strict value is not equal to itself.")
769+            }
770+    }
771+
772+
773+@Verifier(tx)
774+func verify () = {
775+    let CONTRACT_TYPE = "APPROVER_CONTRACT"
776+    if (_isInited())
777+        then         match tx {
778+            case ttx: SetScriptTransaction => 
779+                let scriptHasha = toBase58String(value(blake2b256(value(ttx.script))))
780+                let validFrom = valueOrErrorMessage(getInteger(this, (((("script_" + CONTRACT_TYPE) + "_") + scriptHasha) + "_validFrom")), "validFrom not set")
781+                let validTo = valueOrErrorMessage(getInteger(this, (((("script_" + CONTRACT_TYPE) + "_") + scriptHasha) + "_validTo")), "validTo not set")
782+                if ((height >= validFrom))
783+                    then (validTo >= height)
784+                    else false
785+            case otx => 
786+                valueOrElse(getBoolean(value(this), (((toString(this) + "_") + toBase58String(otx.id)) + "__approved")), false)
787+        }
788+        else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
789+    }
790+
github/deemru/w8io
24.42 ms ◑