tx · Er7MGMgKd4yErVUwoorS5G1coV36uFpgsCz2XvfxVxwe

3MLJ2ToimXKkwEbBrBwyZLNN2gLV2ZoLjzw:  -0.05500000 Waves

2025.10.26 17:42 [566030] smart account 3MLJ2ToimXKkwEbBrBwyZLNN2gLV2ZoLjzw > SELF 0.00000000 Waves

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