tx · ygmS5eW56soj83v4sp8Rc7uvDy5Bde4tKsM6jhRyBAP

3MH4kWUTyJhR7n7mRuFPjTFf8TWqqhRv6NC:  -0.05500000 Waves

2025.11.13 20:55 [620165] smart account 3MH4kWUTyJhR7n7mRuFPjTFf8TWqqhRv6NC > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "ygmS5eW56soj83v4sp8Rc7uvDy5Bde4tKsM6jhRyBAP",
    "fee": 5500000,
    "feeAssetId": null,
    "timestamp": 1763056524877,
    "version": 2,
    "chainId": 82,
    "sender": "3MH4kWUTyJhR7n7mRuFPjTFf8TWqqhRv6NC",
    "senderPublicKey": "FCrCHKPz2vQrJNCUtkGYLdNrSDfxnj3g9BixeL6F17z8",
    "proofs": [
        "2iGAWwUtyL5SiLo8hFgJdccfUGZaAV3i9LiE5bXqxLMBWpgmKD3arLXJVv57okQVJdMrfTXRxHP3cUkmWUGDWhLr"
    ],
    "script": "base64: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",
    "height": 620165,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: F97KSCwETDrvKSVAdKZJCPgCSgSkaWH5se2ie4HXe92M

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 addScriptType (scriptType) = {
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 checkEmpty = if ((size(scriptType) == 0))
312+                then throw("Script type can not be empty")
313+                else true
314+            if ((checkEmpty == checkEmpty))
315+                then {
316+                    let scriptTypesStr = valueOrElse(getString(k_SCRIPT_TYPES), "")
317+                    let scriptTypes = split_4C(scriptTypesStr, ",")
318+                    let checkExists = if ((indexOf(scriptTypes, scriptType) != unit))
319+                        then throw((("Script type <" + scriptType) + "> already added"))
320+                        else true
321+                    if ((checkExists == checkExists))
322+                        then {
323+                            let newScriptTypes = if ((scriptTypesStr != ""))
324+                                then (scriptTypes :+ scriptType)
325+                                else [scriptType]
326+                            let newScriptTypesStr = makeString(newScriptTypes, ",")
327+[StringEntry(k_SCRIPT_TYPES, newScriptTypesStr)]
328+                            }
329+                        else throw("Strict value is not equal to itself.")
330+                    }
331+                else throw("Strict value is not equal to itself.")
332+            }
333+        else throw("Strict value is not equal to itself.")
334+    }
335+
336+
337+
338+@Callable(i)
339+func removeScriptType (scriptType) = {
340+    let callerPbk = toBase58String(i.callerPublicKey)
341+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
342+        then true
343+        else throw("Only self invoke")
344+    if ((isSelf == isSelf))
345+        then {
346+            let scriptTypesStr = valueOrElse(getString(k_SCRIPT_TYPES), "")
347+            let scriptTypes = split_4C(scriptTypesStr, ",")
348+            let index = valueOrErrorMessage(indexOf(scriptTypes, scriptType), (("Script type <" + scriptType) + "> is not present"))
349+            let newScriptTypes = removeByIndex(scriptTypes, index)
350+            let newScriptTypesStr = makeString(newScriptTypes, ",")
351+[StringEntry(k_SCRIPT_TYPES, newScriptTypesStr)]
352+            }
353+        else throw("Strict value is not equal to itself.")
354+    }
355+
356+
357+
358+@Callable(i)
359+func setLimit (limit) = {
360+    let callerPbk = toBase58String(i.callerPublicKey)
361+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
362+        then true
363+        else throw("Only self invoke")
364+    if ((isSelf == isSelf))
365+        then {
366+            let zeroLimit = if ((limit > 0))
367+                then true
368+                else throw("Limit should be > 0")
369+            if ((zeroLimit == zeroLimit))
370+                then {
371+                    let admins = getStringValue(k_ADMINS)
372+                    if ((limit > size(admins)))
373+                        then throw(((("Limit quorum should be <= size of list of admins, limit: " + toString(limit)) + ", current size: ") + toString(size(admins))))
374+                        else [IntegerEntry(k_LIMIT, limit)]
375+                    }
376+                else throw("Strict value is not equal to itself.")
377+            }
378+        else throw("Strict value is not equal to itself.")
379+    }
380+
381+
382+
383+@Callable(i)
384+func setCooldownBlocks (scriptsCooldown) = {
385+    let callerPbk = toBase58String(i.callerPublicKey)
386+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
387+        then true
388+        else throw("Only self invoke")
389+    if ((isSelf == isSelf))
390+        then {
391+            let checkScriptsCooldown = if ((scriptsCooldown > 0))
392+                then true
393+                else throw("Scripts cooldown should be > 0")
394+            if ((checkScriptsCooldown == checkScriptsCooldown))
395+                then [IntegerEntry(k_SCRIPTS_COOLDOWN, scriptsCooldown)]
396+                else throw("Strict value is not equal to itself.")
397+            }
398+        else throw("Strict value is not equal to itself.")
399+    }
400+
401+
402+
403+@Callable(i)
404+func addScript (scriptType,storageAddress,_scriptHash,desc,initiatorAdr,validBlocks) = {
405+    let callerPbk = toBase58String(i.callerPublicKey)
406+    let storageScriptHash = toBase58String(value(scriptHash(addressFromStringValue(storageAddress))))
407+    let scriptTypesStr = getStringValue(k_SCRIPT_TYPES)
408+    let isAllowed = if (!(_isValidOperator(callerPbk)))
409+        then throw("You are not allowed")
410+        else true
411+    if ((isAllowed == isAllowed))
412+        then {
413+            let _checkScriptTypes = if ((indexOf(scriptTypesStr, scriptType) == unit))
414+                then throw(("invalid script type or it is not present in storage: " + scriptType))
415+                else true
416+            if ((_checkScriptTypes == _checkScriptTypes))
417+                then {
418+                    let _scriptStorageHashCheck = if ((storageScriptHash != _scriptHash))
419+                        then throw("Stored and passed as argument scriptHashes not match")
420+                        else true
421+                    if ((_scriptStorageHashCheck == _scriptStorageHashCheck))
422+                        then {
423+                            let _descCheck = if ((size(desc) == 0))
424+                                then throw("Description can't be empty")
425+                                else true
426+                            if ((_descCheck == _descCheck))
427+                                then {
428+                                    let _initiatorCheck = if ((toString(addressFromPublicKey(i.callerPublicKey)) != initiatorAdr))
429+                                        then throw("Initiator address doesn't match caller")
430+                                        else true
431+                                    if ((_initiatorCheck == _initiatorCheck))
432+                                        then {
433+                                            let _checkValidBlocks = if ((validBlocks > 0))
434+                                                then true
435+                                                else throw("Valid blocks should be > 0")
436+                                            if ((_checkValidBlocks == _checkValidBlocks))
437+                                                then {
438+                                                    let iteration = (valueOrElse(getInteger(((k_ITERATION + SEP) + scriptType)), 0) + 1)
439+                                                    let scriptId = ((("script%%" + scriptType) + "%%") + _scriptHash)
440+                                                    let _checkPresent = if (isDefined(getString(((scriptId + BIGSEP) + k_scriptHash))))
441+                                                        then throw("Script with this hash already present")
442+                                                        else true
443+                                                    if ((_checkPresent == _checkPresent))
444+                                                        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)]
445+                                                        else throw("Strict value is not equal to itself.")
446+                                                    }
447+                                                else throw("Strict value is not equal to itself.")
448+                                            }
449+                                        else throw("Strict value is not equal to itself.")
450+                                    }
451+                                else throw("Strict value is not equal to itself.")
452+                            }
453+                        else throw("Strict value is not equal to itself.")
454+                    }
455+                else throw("Strict value is not equal to itself.")
456+            }
457+        else throw("Strict value is not equal to itself.")
458+    }
459+
460+
461+
462+@Callable(i)
463+func removeScript (scriptId) = {
464+    let callerPbk = toBase58String(i.callerPublicKey)
465+    if (!(_isValidOperator(callerPbk)))
466+        then throw("Not allowed")
467+        else {
468+            let initiatorAdr = getStringValue((scriptId + "__initiator"))
469+            if ((initiatorAdr != toString(addressFromPublicKey(i.callerPublicKey))))
470+                then throw("Only creator can remove")
471+                else {
472+                    let scriptType = getStringValue(((scriptId + BIGSEP) + k_scriptType))
473+                    let _scriptHash = getStringValue(((scriptId + BIGSEP) + k_scriptHash))
474+                    let iter = getIntegerValue(((scriptId + BIGSEP) + k_iter))
475+                    let approvedHashes = valueOrElse(getString((("script_" + scriptType) + "__approved")), "")
476+                    let _checkApproved = if ((indexOf(approvedHashes, _scriptHash) != unit))
477+                        then throw("Cant remove approved script, use revoke")
478+                        else true
479+                    if ((_checkApproved == _checkApproved))
480+                        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))]
481+                        else throw("Strict value is not equal to itself.")
482+                    }
483+            }
484+    }
485+
486+
487+
488+@Callable(i)
489+func addConfirmationScript (scriptId) = {
490+    let callerPbk = toBase58String(i.callerPublicKey)
491+    let limit = _getLimit()
492+    let checkAdmin = if (!(_isAdmin(callerPbk)))
493+        then throw("Only admins can confirm")
494+        else true
495+    if ((checkAdmin == checkAdmin))
496+        then {
497+            let _scriptHash = valueOrErrorMessage(getString(((scriptId + BIGSEP) + k_scriptHash)), "Ivalid scriptId")
498+            if ((_scriptHash == _scriptHash))
499+                then {
500+                    let scriptType = getStringValue(((scriptId + BIGSEP) + k_scriptType))
501+                    let validBlocks = getIntegerValue(((scriptId + BIGSEP) + k_validBlocks))
502+                    let globalIteration = valueOrElse(getInteger(((k_ITERATION + SEP) + scriptType)), 0)
503+                    let thisIteration = value(getInteger((scriptId + "__iteration")))
504+                    let confirmationsStr = valueOrElse(getString((scriptId + "__confirmations")), "")
505+                    let confirmations = split(confirmationsStr, ",")
506+                    if ((indexOf(confirmations, callerPbk) != unit))
507+                        then throw("You already confirmed this script")
508+                        else {
509+                            let newList = if ((confirmationsStr != ""))
510+                                then (confirmations :+ callerPbk)
511+                                else [callerPbk]
512+                            let newListStr = makeString(newList, ",")
513+                            let approved = (size(newList) >= limit)
514+                            let result = if (approved)
515+                                then [IntegerEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validFrom), (height + getIntegerValue(k_SCRIPTS_COOLDOWN))), IntegerEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo), (height + validBlocks))]
516+                                else nil
517+                            (result ++ [StringEntry((scriptId + "__confirmations"), newListStr)])
518+                            }
519+                    }
520+                else throw("Strict value is not equal to itself.")
521+            }
522+        else throw("Strict value is not equal to itself.")
523+    }
524+
525+
526+
527+@Callable(i)
528+func revokeConfirmationScript (scriptId) = {
529+    let callerPbk = toBase58String(i.callerPublicKey)
530+    let limit = _getLimit()
531+    if (!(_isAdmin(callerPbk)))
532+        then throw("Only admins can revoke")
533+        else {
534+            let _scriptHash = valueOrErrorMessage(getString((scriptId + "__scriptHash")), "Invalid scriptId")
535+            if ((_scriptHash == _scriptHash))
536+                then {
537+                    let scriptType = getStringValue((scriptId + "__scriptType"))
538+                    let confirmationsStr = valueOrElse(getString((scriptId + "__confirmations")), "")
539+                    let confirmations = split(confirmationsStr, ",")
540+                    let confirmIndex = indexOf(confirmations, callerPbk)
541+                    if ((confirmIndex == unit))
542+                        then throw("You didn't confirm this script, nothing to revoke")
543+                        else {
544+                            let newConfirmations = removeByIndex(confirmations, value(confirmIndex))
545+                            let newConfirmationsStr = makeString(newConfirmations, ",")
546+                            let wasApproved = if (isDefined(getInteger(((_scriptHash + SEP) + k_validFrom))))
547+                                then isDefined(getInteger(((_scriptHash + SEP) + k_validTo)))
548+                                else false
549+                            let stillApproved = (size(newConfirmations) >= limit)
550+                            let stateChanges = if (if (wasApproved)
551+                                then !(stillApproved)
552+                                else false)
553+                                then [DeleteEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validFrom)), DeleteEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo))]
554+                                else nil
555+                            (stateChanges ++ [StringEntry((scriptId + "__confirmations"), newConfirmationsStr)])
556+                            }
557+                    }
558+                else throw("Strict value is not equal to itself.")
559+            }
560+    }
561+
562+
563+
564+@Callable(i)
565+func addTask (name,dapp,txid,executeTs,desc,initiatorAdr,txdata) = {
566+    let callerPbk = toBase58String(i.callerPublicKey)
567+    if (!(_isValidOperator(callerPbk)))
568+        then throw("Not allowed")
569+        else {
570+            let _nameCheck = if ((size(name) == 0))
571+                then throw("Name can't be empty")
572+                else true
573+            if ((_nameCheck == _nameCheck))
574+                then {
575+                    let _dappCheck = if (!(_validateAddress(dapp)))
576+                        then throw("Incorrect dapp")
577+                        else true
578+                    if ((_dappCheck == _dappCheck))
579+                        then {
580+                            let _txidCheck = if ((size(txid) == 0))
581+                                then throw("txid can't be empty")
582+                                else true
583+                            if ((_txidCheck == _txidCheck))
584+                                then {
585+                                    let _timestampCheck = if (!(_validateTs(executeTs)))
586+                                        then throw("Invalid execution timestamp - cannot be more than 1 hour in the past")
587+                                        else true
588+                                    if ((_timestampCheck == _timestampCheck))
589+                                        then {
590+                                            let _descCheck = if ((size(desc) == 0))
591+                                                then throw("Description can't be empty")
592+                                                else true
593+                                            if ((_descCheck == _descCheck))
594+                                                then {
595+                                                    let _initiatorCheck = if ((toString(addressFromPublicKey(i.callerPublicKey)) != initiatorAdr))
596+                                                        then throw("Initiator address doesn't match caller")
597+                                                        else true
598+                                                    if ((_initiatorCheck == _initiatorCheck))
599+                                                        then {
600+                                                            let _txdataCheck = if ((size(txdata) == 0))
601+                                                                then throw("Tx data can't be empty")
602+                                                                else true
603+                                                            if ((_txdataCheck == _txdataCheck))
604+                                                                then {
605+                                                                    let taskId = ((("tx_" + dapp) + SEP) + txid)
606+[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)]
607+                                                                    }
608+                                                                else throw("Strict value is not equal to itself.")
609+                                                            }
610+                                                        else throw("Strict value is not equal to itself.")
611+                                                    }
612+                                                else throw("Strict value is not equal to itself.")
613+                                            }
614+                                        else throw("Strict value is not equal to itself.")
615+                                    }
616+                                else throw("Strict value is not equal to itself.")
617+                            }
618+                        else throw("Strict value is not equal to itself.")
619+                    }
620+                else throw("Strict value is not equal to itself.")
621+            }
622+    }
623+
624+
625+
626+@Callable(i)
627+func removeTask (taskId) = {
628+    let callerPbk = toBase58String(i.callerPublicKey)
629+    if (!(_isValidOperator(callerPbk)))
630+        then throw("Not allowed")
631+        else {
632+            let initiatorAdr = getStringValue((taskId + "__initiator"))
633+            if ((initiatorAdr != toString(addressFromPublicKey(i.callerPublicKey))))
634+                then throw("Only creator can remove")
635+                else {
636+                    let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
637+                    if ((txId == txId))
638+                        then {
639+                            let dapp = getStringValue((taskId + "__dapp"))
640+[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"))]
641+                            }
642+                        else throw("Strict value is not equal to itself.")
643+                    }
644+            }
645+    }
646+
647+
648+
649+@Callable(i)
650+func addConfirmation (taskId) = {
651+    let callerPbk = toBase58String(i.callerPublicKey)
652+    let limit = _getLimit()
653+    if (!(_isAdmin(callerPbk)))
654+        then throw("Only admins can confirm")
655+        else {
656+            let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
657+            if ((txId == txId))
658+                then {
659+                    let dapp = getStringValue((taskId + "__dapp"))
660+                    let confirmationsStr = valueOrElse(getString((taskId + "__confirmations")), "")
661+                    let confirmations = split(confirmationsStr, ",")
662+                    if ((indexOf(confirmations, callerPbk) != unit))
663+                        then throw("You already confirmed this task")
664+                        else {
665+                            let newList = if ((confirmationsStr != ""))
666+                                then (confirmations :+ callerPbk)
667+                                else [callerPbk]
668+                            let newListStr = makeString(newList, ",")
669+                            let approved = (size(newList) >= limit)
670+[StringEntry((taskId + "__confirmations"), newListStr), BooleanEntry((((dapp + SEP) + txId) + "__approved"), approved)]
671+                            }
672+                    }
673+                else throw("Strict value is not equal to itself.")
674+            }
675+    }
676+
677+
678+
679+@Callable(i)
680+func revokeTask (taskId) = {
681+    let callerPbk = toBase58String(i.callerPublicKey)
682+    let limit = _getLimit()
683+    if (!(_isAdmin(callerPbk)))
684+        then throw("Only admins can call")
685+        else {
686+            let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
687+            if ((txId == txId))
688+                then {
689+                    let confirmationsStr = valueOrElse(getString((taskId + "__confirmations")), "")
690+                    let confirmations = split(confirmationsStr, ",")
691+                    let indexMy = indexOf(confirmations, callerPbk)
692+                    if ((indexMy == unit))
693+                        then throw("You did not confirm this task, nothing to revoke")
694+                        else {
695+                            let dapp = getStringValue((taskId + "__dapp"))
696+                            let newList = removeByIndex(confirmations, value(indexMy))
697+                            let newListStr = makeString(newList, ",")
698+                            let approved = (size(newList) >= limit)
699+[StringEntry((taskId + "__confirmations"), newListStr), BooleanEntry((((dapp + SEP) + txId) + "__approved"), approved)]
700+                            }
701+                    }
702+                else throw("Strict value is not equal to itself.")
703+            }
704+    }
705+
706+
707+@Verifier(tx)
708+func verify () = {
709+    let CONTRACT_TYPE = "APPROVER_CONTRACT"
710+    if (_isInited())
711+        then         match tx {
712+            case ttx: SetScriptTransaction => 
713+                let scriptHasha = toBase58String(value(blake2b256(value(ttx.script))))
714+                let validFrom = valueOrErrorMessage(getInteger(this, (((("script_" + CONTRACT_TYPE) + "_") + scriptHasha) + "_validFrom")), "validFrom not set")
715+                let validTo = valueOrErrorMessage(getInteger(this, (((("script_" + CONTRACT_TYPE) + "_") + scriptHasha) + "_validTo")), "validTo not set")
716+                if ((height >= validFrom))
717+                    then (validTo >= height)
718+                    else false
719+            case otx => 
720+                valueOrElse(getBoolean(value(this), (((toString(this) + "_") + toBase58String(otx.id)) + "__approved")), false)
721+        }
722+        else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
723+    }
724+
github/deemru/w8io
37.28 ms ◑