tx · BWSDNyzKwHA9thE51kmdB6d6Ezie2fxXHanDHHS4YBNC

3MCx8izpAvjWk7XQSEKMntraMmKi5aRW824:  -0.05500000 Waves

2025.11.16 22:07 [645013] smart account 3MCx8izpAvjWk7XQSEKMntraMmKi5aRW824 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BWSDNyzKwHA9thE51kmdB6d6Ezie2fxXHanDHHS4YBNC",
    "fee": 5500000,
    "feeAssetId": null,
    "timestamp": 1763320054528,
    "version": 2,
    "chainId": 82,
    "sender": "3MCx8izpAvjWk7XQSEKMntraMmKi5aRW824",
    "senderPublicKey": "B1EssdqCE6gBQYpZ8Rf3qT5zSRdoD2umHcVKyTakSkrx",
    "proofs": [
        "3Etw2juGS3KqUWSMW6rFjF5BueP7fayhZJPuWqNYZNC3AUgV5kF8KxVadSBTsNmXFm6TU1b5gxYAwYswiSmZkADJ"
    ],
    "script": "base64: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",
    "height": 645013,
    "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 managers = valueOrElse(getString(k_MANAGERS), "")
252+                    let checkIsManager = if ((indexOf(managers, pbk) == unit))
253+                        then true
254+                        else throw("This user is already manager, remove from managers if you need to add it as admin")
255+                    if ((checkIsManager == checkIsManager))
256+                        then {
257+                            let admins = getStringValue(k_ADMINS)
258+                            let checkPresent = if ((indexOf(admins, pbk) != unit))
259+                                then throw("This admin already present")
260+                                else true
261+                            if ((checkPresent == checkPresent))
262+                                then {
263+                                    let newAdminsStr = ((admins + ",") + pbk)
264+[StringEntry(k_ADMINS, newAdminsStr)]
265+                                    }
266+                                else throw("Strict value is not equal to itself.")
267+                            }
268+                        else throw("Strict value is not equal to itself.")
269+                    }
270+                else throw("Strict value is not equal to itself.")
271+            }
272+        else throw("Strict value is not equal to itself.")
273+    }
274+
275+
276+
277+@Callable(i)
278+func removeAdmin (pbk) = {
279+    let callerPbk = toBase58String(i.callerPublicKey)
280+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
281+        then true
282+        else throw("Only self invoke")
283+    if ((isSelf == isSelf))
284+        then {
285+            let isValid = if (_validatePbk(pbk))
286+                then true
287+                else throw("Invalid admin pbk")
288+            if ((isValid == isValid))
289+                then {
290+                    let oldAdminsStr = getStringValue(k_ADMINS)
291+                    let oldAdmins = split(oldAdminsStr, ",")
292+                    let checkCount = if ((1 >= size(oldAdmins)))
293+                        then throw("Cannot remove, at least one admin should remain")
294+                        else true
295+                    if ((checkCount == checkCount))
296+                        then {
297+                            let index = valueOrErrorMessage(indexOf(oldAdmins, pbk), "This pbk is not an admin")
298+                            let newAdmins = removeByIndex(oldAdmins, index)
299+                            let newAdminsStr = makeString(newAdmins, ",")
300+[StringEntry(k_ADMINS, newAdminsStr)]
301+                            }
302+                        else throw("Strict value is not equal to itself.")
303+                    }
304+                else throw("Strict value is not equal to itself.")
305+            }
306+        else throw("Strict value is not equal to itself.")
307+    }
308+
309+
310+
311+@Callable(i)
312+func addManager (pbk) = {
313+    let callerPbk = toBase58String(i.callerPublicKey)
314+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
315+        then true
316+        else throw("Only self invoke")
317+    if ((isSelf == isSelf))
318+        then {
319+            let isValid = if (_validatePbk(pbk))
320+                then true
321+                else throw("Invalid manager pbk")
322+            if ((isValid == isValid))
323+                then {
324+                    let admins = valueOrElse(getString(k_ADMINS), "")
325+                    let checkIsAdmin = if ((indexOf(admins, pbk) == unit))
326+                        then true
327+                        else throw("This user is already admin, remove from admins if you need to add it as manager")
328+                    if ((checkIsAdmin == checkIsAdmin))
329+                        then {
330+                            let managers = valueOrElse(getString(k_MANAGERS), "")
331+                            let checkPresent = if ((indexOf(managers, pbk) != unit))
332+                                then throw("This manager already present")
333+                                else true
334+                            if ((checkPresent == checkPresent))
335+                                then {
336+                                    let newManagersStr = if ((managers == ""))
337+                                        then pbk
338+                                        else ((managers + ",") + pbk)
339+[StringEntry(k_MANAGERS, newManagersStr)]
340+                                    }
341+                                else throw("Strict value is not equal to itself.")
342+                            }
343+                        else throw("Strict value is not equal to itself.")
344+                    }
345+                else throw("Strict value is not equal to itself.")
346+            }
347+        else throw("Strict value is not equal to itself.")
348+    }
349+
350+
351+
352+@Callable(i)
353+func removeManager (pbk) = {
354+    let callerPbk = toBase58String(i.callerPublicKey)
355+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
356+        then true
357+        else throw("Only self invoke")
358+    if ((isSelf == isSelf))
359+        then {
360+            let isValid = if (_validatePbk(pbk))
361+                then true
362+                else throw("Invalid manager pbk")
363+            if ((isValid == isValid))
364+                then {
365+                    let oldManagersStr = getStringValue(k_MANAGERS)
366+                    let oldManagers = split(oldManagersStr, ",")
367+                    let index = valueOrErrorMessage(indexOf(oldManagers, pbk), "This pbk is not an manager")
368+                    let newManagers = removeByIndex(oldManagers, index)
369+                    let newManagersStr = makeString(newManagers, ",")
370+[StringEntry(k_MANAGERS, newManagersStr)]
371+                    }
372+                else throw("Strict value is not equal to itself.")
373+            }
374+        else throw("Strict value is not equal to itself.")
375+    }
376+
377+
378+
379+@Callable(i)
380+func addScriptType (scriptType) = {
381+    let callerPbk = toBase58String(i.callerPublicKey)
382+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
383+        then true
384+        else throw("Only self invoke")
385+    if ((isSelf == isSelf))
386+        then {
387+            let checkEmpty = if ((size(scriptType) == 0))
388+                then throw("Script type can not be empty")
389+                else true
390+            if ((checkEmpty == checkEmpty))
391+                then {
392+                    let scriptTypesStr = valueOrElse(getString(k_SCRIPT_TYPES), "")
393+                    let scriptTypes = split_4C(scriptTypesStr, ",")
394+                    let checkExists = if ((indexOf(scriptTypes, scriptType) != unit))
395+                        then throw((("Script type <" + scriptType) + "> already added"))
396+                        else true
397+                    if ((checkExists == checkExists))
398+                        then {
399+                            let newScriptTypes = if ((scriptTypesStr != ""))
400+                                then (scriptTypes :+ scriptType)
401+                                else [scriptType]
402+                            let newScriptTypesStr = makeString(newScriptTypes, ",")
403+[StringEntry(k_SCRIPT_TYPES, newScriptTypesStr)]
404+                            }
405+                        else throw("Strict value is not equal to itself.")
406+                    }
407+                else throw("Strict value is not equal to itself.")
408+            }
409+        else throw("Strict value is not equal to itself.")
410+    }
411+
412+
413+
414+@Callable(i)
415+func removeScriptType (scriptType) = {
416+    let callerPbk = toBase58String(i.callerPublicKey)
417+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
418+        then true
419+        else throw("Only self invoke")
420+    if ((isSelf == isSelf))
421+        then {
422+            let scriptTypesStr = valueOrElse(getString(k_SCRIPT_TYPES), "")
423+            let scriptTypes = split_4C(scriptTypesStr, ",")
424+            let index = valueOrErrorMessage(indexOf(scriptTypes, scriptType), (("Script type <" + scriptType) + "> is not present"))
425+            let newScriptTypes = removeByIndex(scriptTypes, index)
426+            let newScriptTypesStr = makeString(newScriptTypes, ",")
427+[StringEntry(k_SCRIPT_TYPES, newScriptTypesStr)]
428+            }
429+        else throw("Strict value is not equal to itself.")
430+    }
431+
432+
433+
434+@Callable(i)
435+func setLimit (limit) = {
436+    let callerPbk = toBase58String(i.callerPublicKey)
437+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
438+        then true
439+        else throw("Only self invoke")
440+    if ((isSelf == isSelf))
441+        then {
442+            let zeroLimit = if ((limit > 0))
443+                then true
444+                else throw("Limit should be > 0")
445+            if ((zeroLimit == zeroLimit))
446+                then {
447+                    let admins = getStringValue(k_ADMINS)
448+                    if ((limit > size(admins)))
449+                        then throw(((("Limit quorum should be <= size of list of admins, limit: " + toString(limit)) + ", current size: ") + toString(size(admins))))
450+                        else [IntegerEntry(k_LIMIT, limit)]
451+                    }
452+                else throw("Strict value is not equal to itself.")
453+            }
454+        else throw("Strict value is not equal to itself.")
455+    }
456+
457+
458+
459+@Callable(i)
460+func setCooldownBlocks (scriptsCooldown) = {
461+    let callerPbk = toBase58String(i.callerPublicKey)
462+    let isSelf = if ((addressFromPublicKey(i.callerPublicKey) == this))
463+        then true
464+        else throw("Only self invoke")
465+    if ((isSelf == isSelf))
466+        then {
467+            let checkScriptsCooldown = if ((scriptsCooldown > 0))
468+                then true
469+                else throw("Scripts cooldown should be > 0")
470+            if ((checkScriptsCooldown == checkScriptsCooldown))
471+                then [IntegerEntry(k_SCRIPTS_COOLDOWN, scriptsCooldown)]
472+                else throw("Strict value is not equal to itself.")
473+            }
474+        else throw("Strict value is not equal to itself.")
475+    }
476+
477+
478+
479+@Callable(i)
480+func addScript (scriptType,storageAddress,_scriptHash,desc,initiatorAdr,validBlocks) = {
481+    let callerPbk = toBase58String(i.callerPublicKey)
482+    let storageScriptHash = toBase58String(value(scriptHash(addressFromStringValue(storageAddress))))
483+    let scriptTypesStr = getStringValue(k_SCRIPT_TYPES)
484+    let isAllowed = if (!(_isAdmin(callerPbk)))
485+        then throw("Only admins are allowed")
486+        else true
487+    if ((isAllowed == isAllowed))
488+        then {
489+            let _checkScriptTypes = if ((indexOf(scriptTypesStr, scriptType) == unit))
490+                then throw(("invalid script type or it is not present in storage: " + scriptType))
491+                else true
492+            if ((_checkScriptTypes == _checkScriptTypes))
493+                then {
494+                    let _scriptStorageHashCheck = if ((storageScriptHash != _scriptHash))
495+                        then throw("Stored and passed as argument scriptHashes not match")
496+                        else true
497+                    if ((_scriptStorageHashCheck == _scriptStorageHashCheck))
498+                        then {
499+                            let _descCheck = if ((size(desc) == 0))
500+                                then throw("Description can't be empty")
501+                                else true
502+                            if ((_descCheck == _descCheck))
503+                                then {
504+                                    let _initiatorCheck = if ((toString(addressFromPublicKey(i.callerPublicKey)) != initiatorAdr))
505+                                        then throw("Initiator address doesn't match caller")
506+                                        else true
507+                                    if ((_initiatorCheck == _initiatorCheck))
508+                                        then {
509+                                            let _checkValidBlocks = if ((validBlocks > 0))
510+                                                then true
511+                                                else throw("Valid blocks should be > 0")
512+                                            if ((_checkValidBlocks == _checkValidBlocks))
513+                                                then {
514+                                                    let iteration = (valueOrElse(getInteger(((k_ITERATION + SEP) + scriptType)), 0) + 1)
515+                                                    let scriptId = ((("script%%" + scriptType) + "%%") + _scriptHash)
516+                                                    let _checkPresent = if (isDefined(getString(((scriptId + BIGSEP) + k_scriptHash))))
517+                                                        then throw("Script with this hash already present")
518+                                                        else true
519+                                                    if ((_checkPresent == _checkPresent))
520+                                                        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)]
521+                                                        else throw("Strict value is not equal to itself.")
522+                                                    }
523+                                                else throw("Strict value is not equal to itself.")
524+                                            }
525+                                        else throw("Strict value is not equal to itself.")
526+                                    }
527+                                else throw("Strict value is not equal to itself.")
528+                            }
529+                        else throw("Strict value is not equal to itself.")
530+                    }
531+                else throw("Strict value is not equal to itself.")
532+            }
533+        else throw("Strict value is not equal to itself.")
534+    }
535+
536+
537+
538+@Callable(i)
539+func removeScript (scriptId) = {
540+    let callerPbk = toBase58String(i.callerPublicKey)
541+    if (!(_isAdmin(callerPbk)))
542+        then throw("Only admins are allowed")
543+        else {
544+            let initiatorAdr = getStringValue((scriptId + "__initiator"))
545+            if ((initiatorAdr != toString(addressFromPublicKey(i.callerPublicKey))))
546+                then throw("Only creator can remove")
547+                else {
548+                    let scriptType = getStringValue(((scriptId + BIGSEP) + k_scriptType))
549+                    let _scriptHash = getStringValue(((scriptId + BIGSEP) + k_scriptHash))
550+                    let iter = getIntegerValue(((scriptId + BIGSEP) + k_iter))
551+                    let approvedHashes = valueOrElse(getString((("script_" + scriptType) + "__approved")), "")
552+                    let _checkApproved = if ((indexOf(approvedHashes, _scriptHash) != unit))
553+                        then throw("Cant remove approved script, use revoke")
554+                        else true
555+                    if ((_checkApproved == _checkApproved))
556+                        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))]
557+                        else throw("Strict value is not equal to itself.")
558+                    }
559+            }
560+    }
561+
562+
563+
564+@Callable(i)
565+func addConfirmationScript (scriptId) = {
566+    let callerPbk = toBase58String(i.callerPublicKey)
567+    let limit = _getLimit()
568+    let checkAdmin = if (!(_isValidOperator(callerPbk)))
569+        then throw("Only whitelisted can confirm")
570+        else true
571+    if ((checkAdmin == checkAdmin))
572+        then {
573+            let _scriptHash = valueOrErrorMessage(getString(((scriptId + BIGSEP) + k_scriptHash)), "Ivalid scriptId")
574+            if ((_scriptHash == _scriptHash))
575+                then {
576+                    let scriptType = getStringValue(((scriptId + BIGSEP) + k_scriptType))
577+                    let validBlocks = getIntegerValue(((scriptId + BIGSEP) + k_validBlocks))
578+                    let globalIteration = valueOrElse(getInteger(((k_ITERATION + SEP) + scriptType)), 0)
579+                    let thisIteration = value(getInteger((scriptId + "__iteration")))
580+                    let confirmationsStr = valueOrElse(getString((scriptId + "__confirmations")), "")
581+                    let confirmations = split(confirmationsStr, ",")
582+                    if ((indexOf(confirmations, callerPbk) != unit))
583+                        then throw("You already confirmed this script")
584+                        else {
585+                            let newList = if ((confirmationsStr != ""))
586+                                then (confirmations :+ callerPbk)
587+                                else [callerPbk]
588+                            let newListStr = makeString(newList, ",")
589+                            let approved = (size(newList) >= limit)
590+                            let result = if (approved)
591+                                then [IntegerEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validFrom), (height + getIntegerValue(k_SCRIPTS_COOLDOWN))), IntegerEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo), (height + validBlocks))]
592+                                else nil
593+                            (result ++ [StringEntry((scriptId + "__confirmations"), newListStr)])
594+                            }
595+                    }
596+                else throw("Strict value is not equal to itself.")
597+            }
598+        else throw("Strict value is not equal to itself.")
599+    }
600+
601+
602+
603+@Callable(i)
604+func revokeConfirmationScript (scriptId) = {
605+    let callerPbk = toBase58String(i.callerPublicKey)
606+    let limit = _getLimit()
607+    if (!(_isValidOperator(callerPbk)))
608+        then throw("Only whitelisted can revoke")
609+        else {
610+            let _scriptHash = valueOrErrorMessage(getString((scriptId + "__scriptHash")), "Invalid scriptId")
611+            if ((_scriptHash == _scriptHash))
612+                then {
613+                    let scriptType = getStringValue((scriptId + "__scriptType"))
614+                    let confirmationsStr = valueOrElse(getString((scriptId + "__confirmations")), "")
615+                    let confirmations = split(confirmationsStr, ",")
616+                    let confirmIndex = indexOf(confirmations, callerPbk)
617+                    let isExpired = (height > valueOrElse(getInteger(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo)), (height + 1)))
618+                    let checkExpired = if (!(isExpired))
619+                        then true
620+                        else throw("Expired scripts can't be revoked")
621+                    if ((checkExpired == checkExpired))
622+                        then if ((confirmIndex == unit))
623+                            then throw("You didn't confirm this script, nothing to revoke")
624+                            else {
625+                                let newConfirmations = removeByIndex(confirmations, value(confirmIndex))
626+                                let newConfirmationsStr = makeString(newConfirmations, ",")
627+                                let wasApproved = if (isDefined(getInteger(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validFrom))))
628+                                    then isDefined(getInteger(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo)))
629+                                    else false
630+                                let stillApproved = (size(newConfirmations) >= limit)
631+                                let stateChanges = if (if (wasApproved)
632+                                    then !(stillApproved)
633+                                    else false)
634+                                    then [DeleteEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validFrom)), DeleteEntry(((((("script_" + scriptType) + SEP) + _scriptHash) + SEP) + k_validTo))]
635+                                    else nil
636+                                (stateChanges ++ [StringEntry((scriptId + "__confirmations"), newConfirmationsStr)])
637+                                }
638+                        else throw("Strict value is not equal to itself.")
639+                    }
640+                else throw("Strict value is not equal to itself.")
641+            }
642+    }
643+
644+
645+
646+@Callable(i)
647+func addTask (name,dapp,txid,executeTs,desc,initiatorAdr,txdata) = {
648+    let callerPbk = toBase58String(i.callerPublicKey)
649+    if (!(_isAdmin(callerPbk)))
650+        then throw("Only admins are allowed")
651+        else {
652+            let _nameCheck = if ((size(name) == 0))
653+                then throw("Name can't be empty")
654+                else true
655+            if ((_nameCheck == _nameCheck))
656+                then {
657+                    let _dappCheck = if (!(_validateAddress(dapp)))
658+                        then throw("Incorrect dapp")
659+                        else true
660+                    if ((_dappCheck == _dappCheck))
661+                        then {
662+                            let _txidCheck = if ((size(txid) == 0))
663+                                then throw("txid can't be empty")
664+                                else true
665+                            if ((_txidCheck == _txidCheck))
666+                                then {
667+                                    let _timestampCheck = if (!(_validateTs(executeTs)))
668+                                        then throw("Invalid execution timestamp - cannot be more than 1 hour in the past")
669+                                        else true
670+                                    if ((_timestampCheck == _timestampCheck))
671+                                        then {
672+                                            let _descCheck = if ((size(desc) == 0))
673+                                                then throw("Description can't be empty")
674+                                                else true
675+                                            if ((_descCheck == _descCheck))
676+                                                then {
677+                                                    let _initiatorCheck = if ((toString(addressFromPublicKey(i.callerPublicKey)) != initiatorAdr))
678+                                                        then throw("Initiator address doesn't match caller")
679+                                                        else true
680+                                                    if ((_initiatorCheck == _initiatorCheck))
681+                                                        then {
682+                                                            let _txdataCheck = if ((size(txdata) == 0))
683+                                                                then throw("Tx data can't be empty")
684+                                                                else true
685+                                                            if ((_txdataCheck == _txdataCheck))
686+                                                                then {
687+                                                                    let taskId = ((("tx_" + dapp) + SEP) + txid)
688+[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)]
689+                                                                    }
690+                                                                else throw("Strict value is not equal to itself.")
691+                                                            }
692+                                                        else throw("Strict value is not equal to itself.")
693+                                                    }
694+                                                else throw("Strict value is not equal to itself.")
695+                                            }
696+                                        else throw("Strict value is not equal to itself.")
697+                                    }
698+                                else throw("Strict value is not equal to itself.")
699+                            }
700+                        else throw("Strict value is not equal to itself.")
701+                    }
702+                else throw("Strict value is not equal to itself.")
703+            }
704+    }
705+
706+
707+
708+@Callable(i)
709+func removeTask (taskId) = {
710+    let callerPbk = toBase58String(i.callerPublicKey)
711+    if (!(_isAdmin(callerPbk)))
712+        then throw("Only admins are allowed")
713+        else {
714+            let initiatorAdr = getStringValue((taskId + "__initiator"))
715+            if ((initiatorAdr != toString(addressFromPublicKey(i.callerPublicKey))))
716+                then throw("Only creator can remove")
717+                else {
718+                    let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
719+                    if ((txId == txId))
720+                        then {
721+                            let dapp = getStringValue((taskId + "__dapp"))
722+[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"))]
723+                            }
724+                        else throw("Strict value is not equal to itself.")
725+                    }
726+            }
727+    }
728+
729+
730+
731+@Callable(i)
732+func addConfirmation (taskId) = {
733+    let callerPbk = toBase58String(i.callerPublicKey)
734+    let limit = _getLimit()
735+    if (!(_isValidOperator(callerPbk)))
736+        then throw("Only whitelisted can confirm")
737+        else {
738+            let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
739+            if ((txId == txId))
740+                then {
741+                    let dapp = getStringValue((taskId + "__dapp"))
742+                    let confirmationsStr = valueOrElse(getString((taskId + "__confirmations")), "")
743+                    let confirmations = split(confirmationsStr, ",")
744+                    if ((indexOf(confirmations, callerPbk) != unit))
745+                        then throw("You already confirmed this task")
746+                        else {
747+                            let newList = if ((confirmationsStr != ""))
748+                                then (confirmations :+ callerPbk)
749+                                else [callerPbk]
750+                            let newListStr = makeString(newList, ",")
751+                            let approved = (size(newList) >= limit)
752+[StringEntry((taskId + "__confirmations"), newListStr), BooleanEntry((((dapp + SEP) + txId) + "__approved"), approved)]
753+                            }
754+                    }
755+                else throw("Strict value is not equal to itself.")
756+            }
757+    }
758+
759+
760+
761+@Callable(i)
762+func revokeTask (taskId) = {
763+    let callerPbk = toBase58String(i.callerPublicKey)
764+    let limit = _getLimit()
765+    if (!(_isValidOperator(callerPbk)))
766+        then throw("Only whitelisted can call")
767+        else {
768+            let txId = valueOrErrorMessage(getString((taskId + "__txId")), "Ivalid task")
769+            if ((txId == txId))
770+                then {
771+                    let confirmationsStr = valueOrElse(getString((taskId + "__confirmations")), "")
772+                    let confirmations = split(confirmationsStr, ",")
773+                    let indexMy = indexOf(confirmations, callerPbk)
774+                    if ((indexMy == unit))
775+                        then throw("You did not confirm this task, nothing to revoke")
776+                        else {
777+                            let dapp = getStringValue((taskId + "__dapp"))
778+                            let newList = removeByIndex(confirmations, value(indexMy))
779+                            let newListStr = makeString(newList, ",")
780+                            let approved = (size(newList) >= limit)
781+[StringEntry((taskId + "__confirmations"), newListStr), BooleanEntry((((dapp + SEP) + txId) + "__approved"), approved)]
782+                            }
783+                    }
784+                else throw("Strict value is not equal to itself.")
785+            }
786+    }
787+
788+
789+@Verifier(tx)
790+func verify () = {
791+    let CONTRACT_TYPE = "APPROVER_CONTRACT"
792+    if (_isInited())
793+        then         match tx {
794+            case ttx: SetScriptTransaction => 
795+                let scriptHasha = toBase58String(value(blake2b256(value(ttx.script))))
796+                let validFrom = valueOrErrorMessage(getInteger(this, (((("script_" + CONTRACT_TYPE) + "_") + scriptHasha) + "_validFrom")), "validFrom not set")
797+                let validTo = valueOrErrorMessage(getInteger(this, (((("script_" + CONTRACT_TYPE) + "_") + scriptHasha) + "_validTo")), "validTo not set")
798+                if ((height >= validFrom))
799+                    then (validTo >= height)
800+                    else false
801+            case otx => 
802+                valueOrElse(getBoolean(value(this), (((toString(this) + "_") + toBase58String(otx.id)) + "__approved")), false)
803+        }
804+        else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
805+    }
806+
github/deemru/w8io
59.59 ms ◑