tx · 4hn21P4gYWSAu3vjZi2jqG2GELQpf9wfcn3yrEBb2o8V

3N1ZfechNGoBTZyzvCAxGXPKchL4C6438dr:  -0.03300000 Waves

2024.10.07 20:24 [3316719] smart account 3N1ZfechNGoBTZyzvCAxGXPKchL4C6438dr > SELF 0.00000000 Waves

{ "type": 13, "id": "4hn21P4gYWSAu3vjZi2jqG2GELQpf9wfcn3yrEBb2o8V", "fee": 3300000, "feeAssetId": null, "timestamp": 1728321921431, "version": 2, "chainId": 84, "sender": "3N1ZfechNGoBTZyzvCAxGXPKchL4C6438dr", "senderPublicKey": "9JhgPDL4uV7b9tRjpNxGkGVDsbQ2qkEWfjt64wysYmKQ", "proofs": [ "4ekahx4iU7C2tMmSTTiGhfuHLSUcRiThG75L9PYSnJHGXSUq9vzfmKbMLHvXtig9NMrCC7y3LpEGU6QdrNyJYLAb" ], "script": "base64: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", "height": 3316719, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: 2qLvP16Hmrw7N3cJb7Dwt1J4S1EdvqYLoEnhP2SHihaC Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func a () = "static_oracleAddress"
5+
6+
7+func b () = "static_breederAddress"
8+
9+
10+func c () = "static_eggAssetId"
11+
12+
13+func d () = "static_trustedContracts"
14+
15+
16+func e () = "static_rebirthAddress"
17+
18+
19+func f () = "static_turtleRebirthAddress"
20+
21+
22+func g () = "static_pipelineUser"
23+
24+
25+func h () = "static_extraFee"
26+
27+
28+func i () = "static_feeAggregator"
29+
30+
31+func j () = "static_huntDistroAddress"
32+
33+
34+func k () = "static_warsPKey"
35+
36+
37+func l () = "static_duplicatorFee"
38+
39+
40+func m () = "static_canineRebirthAddress"
41+
42+
43+func n () = "static_felineRebirthAddress"
44+
45+
46+func o () = "static_babyDuckAddress"
47+
48+
49+func p () = "static_burnAddress"
50+
51+
52+func q (r,s) = (((r + "_") + s) + "_owner")
53+
54+
55+func t (r,u) = (((r + "_") + u) + "_unstake_height")
56+
57+
58+func v (w) = (w + "_duck_external_boost")
59+
60+
61+func x (y) = (y + "_user_external_boost")
62+
63+
64+func z (A) = ("direct_cosmetic_" + A)
65+
66+
67+func B (A) = (("direct_cosmetic_" + A) + "_max_sales")
68+
69+
70+func C (A) = (("direct_cosmetic_" + A) + "_sale")
71+
72+
73+func D (A) = (("direct_cosmetic_" + A) + "_priceAsset")
74+
75+
76+func E (A) = (("direct_cosmetic_" + A) + "_growing_percentage")
77+
78+
79+func F (A) = (("direct_cosmetic_" + A) + "_sold")
80+
81+
82+func G (A) = (("direct_cosmetic_" + A) + "_last_price")
83+
84+
85+func H (A) = (("direct_cosmetic_" + A) + "_startTs")
86+
87+
88+func I (A) = (("direct_cosmetic_" + A) + "_endTs")
89+
90+
91+func J (y,K) = (((y + "_") + toBase58String(K)) + "_fh")
92+
93+
94+func L () = "static_couponsAddress"
95+
96+
97+let M = ["ART-LAKE", "ART-HOUSE", "ART-BIGHOUSE", "ART-FIXGENE", "ART-FREEGENE", "ART-MIRROR", "ART-POMP", "ART-CAPE", "ART-HAT", "ART-CUSTOMDUCK", "ART-XMISTL", "ART-XHAT", "ART-XSCARF", "ART-XSWEATER", "ART-XSOCK", "ART-XTREE"]
98+
99+let N = ["ART-TINSEL", "ART-FEED10", "ART-GNGR_BREAD", "ART-SNOWBALL", "ART-GIFT_DOUBL"]
100+
101+let O = ["ART-HWRESCUE", "ART-HWERASE", "ART-FEED10", "ART-FEED15", "ART-FEED20", "ART-FEED25", "ART-GIFT_DOUBL"]
102+
103+let P = ["ART-SNW_GLBES", "ART-SKELETON"]
104+
105+let Q = ["G", "H", "I", "K", "L", "M", "N", "O"]
106+
107+func R (S) = {
108+ let T = getBoolean(this, S)
109+ if ($isInstanceOf(T, "Boolean"))
110+ then {
111+ let U = T
112+ U
113+ }
114+ else false
115+ }
116+
117+
118+func V (S) = {
119+ let T = getString(this, S)
120+ if ($isInstanceOf(T, "String"))
121+ then {
122+ let W = T
123+ W
124+ }
125+ else ""
126+ }
127+
128+
129+func X (S) = {
130+ let T = getInteger(this, S)
131+ if ($isInstanceOf(T, "Int"))
132+ then {
133+ let W = T
134+ W
135+ }
136+ else 0
137+ }
138+
139+
140+func Y (y,S) = {
141+ let T = getInteger(y, S)
142+ if ($isInstanceOf(T, "Int"))
143+ then {
144+ let U = T
145+ U
146+ }
147+ else 0
148+ }
149+
150+
151+func Z (aa,K,ab,ac) = {
152+ let ad = value(blockInfoByHeight((ab - 1)))
153+ let ae = sha256(((base58'items' + K) + value(ad.vrf)))
154+ (toInt(ae, ac) % aa)
155+ }
156+
157+
158+func af (y,S) = {
159+ let T = getString(y, S)
160+ if ($isInstanceOf(T, "String"))
161+ then {
162+ let W = T
163+ W
164+ }
165+ else ""
166+ }
167+
168+
169+func ag () = Address(fromBase58String(V(a())))
170+
171+
172+func ah () = Address(fromBase58String(af(ag(), b())))
173+
174+
175+func ai () = fromBase58String(af(ag(), c()))
176+
177+
178+func aj () = af(ag(), d())
179+
180+
181+func ak () = Address(fromBase58String(af(ag(), e())))
182+
183+
184+func al () = Address(fromBase58String(af(ag(), f())))
185+
186+
187+func am () = Address(fromBase58String(af(ag(), m())))
188+
189+
190+func an () = Address(fromBase58String(af(ag(), n())))
191+
192+
193+func ao () = Address(fromBase58String(af(ag(), i())))
194+
195+
196+func ap () = Address(fromBase58String(af(ag(), j())))
197+
198+
199+func aq () = fromBase58String(af(ag(), k()))
200+
201+
202+func ar () = Y(ag(), l())
203+
204+
205+func as () = Address(fromBase58String(af(ag(), L())))
206+
207+
208+func at () = Address(fromBase58String(af(ag(), o())))
209+
210+
211+func au () = Address(fromBase58String(af(ag(), p())))
212+
213+
214+func av (A) = {
215+ let S = z(A)
216+ let T = getInteger(this, S)
217+ if ($isInstanceOf(T, "Int"))
218+ then {
219+ let W = T
220+ W
221+ }
222+ else throw((("ITGCIP: " + A) + " is not available in the store!"))
223+ }
224+
225+
226+func aw (ax) = {
227+ let T = ax
228+ if ($isInstanceOf(T, "String"))
229+ then {
230+ let ay = T
231+ ay
232+ }
233+ else throw("wrong type, expected: String")
234+ }
235+
236+
237+func az (ax) = {
238+ let T = ax
239+ if ($isInstanceOf(T, "Int"))
240+ then {
241+ let aA = T
242+ aA
243+ }
244+ else throw("wrong type, expected: Int")
245+ }
246+
247+
248+func aB (aC,aD,aE) = ((take(aC, (aD - 1)) + aE) + takeRight(aC, (16 - aD)))
249+
250+
251+func aF (r,u) = {
252+ let aG = X(t(r, u))
253+ let aH = 240
254+ if ((height > (aG + aH)))
255+ then false
256+ else true
257+ }
258+
259+
260+func aI () = R("TESTENV")
261+
262+
263+func aJ (aK) = if (isDefined(aK.assetId))
264+ then throw("WCAP: Please attach waves")
265+ else {
266+ let aL = getIntegerValue(ag(), h())
267+ if ((aK.amount != aL))
268+ then throw((("WCAP: Please attach exactly " + toString(aL)) + " amount of wavelets"))
269+ else [ScriptTransfer(ao(), aL, unit)]
270+ }
271+
272+
273+func aM (aN,aO,y) = {
274+ let aP = Issue(aN, "NFT artefact of Waves Ducks game.", 1, 0, false, unit, aO)
275+ let u = calculateAssetId(aP)
276+ $Tuple2([aP, StringEntry((("artefact_" + toBase58String(u)) + "_type"), aN), ScriptTransfer(y, 1, u)], toBase58String(u))
277+ }
278+
279+
280+func aQ (aR,aS,aT,aU,aL,aV,aW,aX,K,aY,aZ,ba,bb) = if ((size(aU) != (aS + 1)))
281+ then throw((("IID: Please attach " + toString((aS + 2))) + " payments!"))
282+ else {
283+ func bc (bd,be) = if (if ((be.assetId == unit))
284+ then true
285+ else (be.assetId == ai()))
286+ then $Tuple5(bd._1, bd._2, bd._3, bd._4, bd._5)
287+ else {
288+ let bf = value(be.assetId)
289+ if ((value(assetInfo(value(bf))).issuer == ah()))
290+ then {
291+ let bg = split(value(assetInfo(value(bf))).name, "")
292+ let bh = bg[14]
293+ let bi = value(indexOf(Q, bh))
294+ $Tuple5(bd._1, bd._2, bd._3, bd._4, (bd._5 + bi))
295+ }
296+ else if ((value(assetInfo(value(bf))).issuer == at()))
297+ then {
298+ let bj = Y(at(), (("duckling_" + toBase58String(bf)) + "_startPercentage"))
299+ let bk = if ((10 > bj))
300+ then 10
301+ else bj
302+ let bl = invoke(au(), "burnDuckling", [toString(aW)], [AttachedPayment(bf, 1)])
303+ if ((bl == bl))
304+ then $Tuple5(bd._1, bd._2, bd._3, (bd._4 + bk), bd._5)
305+ else throw("Strict value is not equal to itself.")
306+ }
307+ else {
308+ let aP = aw(invoke(this, "checkArtefactDetails", [toBase58String(bf)], nil))
309+ if ((aP == aP))
310+ then if ((aP == aR))
311+ then $Tuple5((bd._1 ++ [Burn(bf, 1)]), (bd._2 + 1), bd._3, bd._4, bd._5)
312+ else if ((aP == aY))
313+ then $Tuple5((bd._1 ++ [Burn(bf, 1)]), bd._2, (bd._3 + 1), bd._4, bd._5)
314+ else $Tuple5(bd._1, bd._2, bd._3, bd._4, bd._5)
315+ else throw("Strict value is not equal to itself.")
316+ }
317+ }
318+
319+ let bm = {
320+ let bn = aU
321+ let bo = size(bn)
322+ let bp = $Tuple5(nil, 0, 0, 0, 0)
323+ func bq (br,bs) = if ((bs >= bo))
324+ then br
325+ else bc(br, bn[bs])
326+
327+ func bt (br,bs) = if ((bs >= bo))
328+ then br
329+ else throw("List size exceeds 10")
330+
331+ bt(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bp, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
332+ }
333+ if ((bm._2 != aS))
334+ then throw(((("IID: Please attach " + toString(aS)) + " artefacts of type ") + aR))
335+ else if (if ((aY != ""))
336+ then (bm._3 != aZ)
337+ else false)
338+ then throw(((("IID: Please attach " + toString(aZ)) + " artefacts of type ") + aY))
339+ else if (if ((ba != 0))
340+ then (bm._4 != ba)
341+ else false)
342+ then throw(((("IID: Please attach " + toString(ba)) + " growth, you added ") + toString(bm._4)))
343+ else if (if ((bb != 0))
344+ then (bm._5 != bb)
345+ else false)
346+ then throw(((("IID: Please attach " + toString(bb)) + " gen value, you added ") + toString(bm._5)))
347+ else {
348+ let bu = if ((aL != 0))
349+ then {
350+ let bv = aU[aS]
351+ if ((bv.assetId != aV))
352+ then throw("IID: You miss a payment with the fee!")
353+ else if ((bv.amount != aL))
354+ then throw("IID: You did not attach the correct fee amount!")
355+ else [ScriptTransfer(ao(), aL, bv.assetId)]
356+ }
357+ else nil
358+ if ((bu == bu))
359+ then {
360+ let aP = Issue(aT, ("NFT artefact of Waves Ducks game: " + aT), 1, 0, false, unit, 0)
361+ let u = calculateAssetId(aP)
362+ let bw = if (aX)
363+ then aM(aT, 0, aW)
364+ else $Tuple2(nil, "")
365+ $Tuple2(((([BooleanEntry((("merge_" + K) + "_instant"), aX), StringEntry((("merge_" + K) + "_reward"), aT), BooleanEntry((("merge_" + K) + "_finished"), aX)] ++ bw._1) ++ bm._1) ++ bu), bw._2)
366+ }
367+ else throw("Strict value is not equal to itself.")
368+ }
369+ }
370+
371+
372+func bx (aR) = getStringValue((("merge_" + aR) + "_baseItem"))
373+
374+
375+func by (aR) = getIntegerValue((("merge_" + aR) + "_amount"))
376+
377+
378+func bz (aR) = V((("merge_" + aR) + "_secondaryItem"))
379+
380+
381+func bA (aR) = X((("merge_" + aR) + "_amountSecondaryItem"))
382+
383+
384+func bB (aR) = X((("merge_" + aR) + "_genValue"))
385+
386+
387+func bC (aR) = X((("merge_" + aR) + "_ducklingsPercent"))
388+
389+
390+func bD (aR) = getStringValue((("merge_" + aR) + "_endItem"))
391+
392+
393+func bE (aR) = getIntegerValue((("merge_" + aR) + "_price"))
394+
395+
396+func bF (aR) = getBooleanValue((("merge_" + aR) + "_instant"))
397+
398+
399+func bG (aR) = {
400+ let bH = getStringValue((("merge_" + aR) + "_asset"))
401+ if ((bH == "WAVES"))
402+ then unit
403+ else fromBase58String(bH)
404+ }
405+
406+
407+func bI (bJ) = (bJ + "_experience")
408+
409+
410+func bK (bL,y,aK) = {
411+ let aN = getStringValue((((("address_" + y) + "_initTx_") + bL) + "_type"))
412+ let bM = if ((aN == "ART-SNW_GLBES"))
413+ then 100
414+ else if ((aN == "ART-SKELETON"))
415+ then 200
416+ else throw("FSI: Invalid type")
417+ let bN = if ((aN == "ART-SNW_GLBES"))
418+ then [1, 2, 3, 4, 5, 6]
419+ else if ((aN == "ART-SKELETON"))
420+ then [1, 2, 3, 4, 5, 6, 7]
421+ else throw("FSI: Invalid type")
422+ let bO = size(bN)
423+ let bP = if ((aN == "ART-SNW_GLBES"))
424+ then N
425+ else if ((aN == "ART-SKELETON"))
426+ then O
427+ else throw("FSI: Invalid type")
428+ let bQ = Y(as(), bI(y))
429+ let bR = min([((bQ / bM) + 1), bO])
430+ let bS = getIntegerValue((((("address_" + y) + "_initTx_") + bL) + "_finishBlock"))
431+ if ((bS > height))
432+ then throw("Please wait till the shaking is finished!")
433+ else if ((V((((("address_" + y) + "_initTx_") + bL) + "_status")) != "open"))
434+ then throw("FSI: Only open status can be finished!")
435+ else {
436+ func bT (bU,bV) = if ((bR >= bV))
437+ then {
438+ let bW = Z(size(bP), fromBase58String(bL), bS, bV)
439+ let bX = bP[bW]
440+ ((bU ++ aM(bX, (bV - 1), addressFromStringValue(y))._1) ++ [StringEntry(((((("address_" + y) + "_initTx_") + bL) + "_win") + toString((bV - 1))), bX)])
441+ }
442+ else bU
443+
444+ ({
445+ let bn = bN
446+ let bo = size(bn)
447+ let bp = nil
448+ func bq (br,bs) = if ((bs >= bo))
449+ then br
450+ else bT(br, bn[bs])
451+
452+ func bt (br,bs) = if ((bs >= bo))
453+ then br
454+ else throw("List size exceeds 7")
455+
456+ bt(bq(bq(bq(bq(bq(bq(bq(bp, 0), 1), 2), 3), 4), 5), 6), 7)
457+ } ++ [StringEntry((((("address_" + y) + "_initTx_") + bL) + "_status"), "finish")])
458+ }
459+ }
460+
461+
462+@Callable(bY)
463+func startShakeItBaby () = {
464+ let bZ = value(bY.payments[0])
465+ let ca = aJ(bY.payments[1])
466+ let cb = toBase58String(value(bZ.assetId))
467+ if ((bZ.amount != 1))
468+ then throw("IID: Item NFT is not attached")
469+ else {
470+ let cc = aw(invoke(this, "checkArtefactDetails", [cb], nil))
471+ if ((cc == cc))
472+ then if ((indexOf(P, cc) == unit))
473+ then throw("IID: You need to attach a valid artefact")
474+ else {
475+ let y = toString(bY.caller)
476+ let bL = toBase58String(bY.transactionId)
477+[Burn(value(bZ.assetId), 1), IntegerEntry((((("address_" + y) + "_initTx_") + bL) + "_finishBlock"), (height + 2)), StringEntry((((("address_" + y) + "_initTx_") + bL) + "_status"), "open"), StringEntry((((("address_" + y) + "_initTx_") + bL) + "_assetId"), cb), StringEntry((((("address_" + y) + "_initTx_") + bL) + "_type"), cc)]
478+ }
479+ else throw("Strict value is not equal to itself.")
480+ }
481+ }
482+
483+
484+
485+@Callable(bY)
486+func finishShakeItBaby (bL) = bK(bL, toString(bY.caller), bY.payments[0])
487+
488+
489+
490+@Callable(bY)
491+func instanMergeItem (cd) = if ((V((("merge_" + cd) + "_endItem")) == ""))
492+ then throw("IID: Only certain items can be merged!")
493+ else {
494+ let ce = $Tuple10(by(cd), bD(cd), bE(cd), bG(cd), bF(cd), bz(cd), bA(cd), bC(cd), bx(cd), bB(cd))
495+ let cf = invoke(as(), "increaseExp", [toString(bY.caller)], nil)
496+ if ((cf == cf))
497+ then aQ(ce._9, ce._1, ce._2, bY.payments, ce._3, ce._4, bY.caller, ce._5, toBase58String(bY.transactionId), ce._6, ce._7, ce._8, ce._10)
498+ else throw("Strict value is not equal to itself.")
499+ }
500+
501+
502+
503+@Callable(bY)
504+func directBuyItemMultiple (cg,ch) = {
505+ let ci = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
506+ let cj = av(cg)
507+ let ck = X(E(cg))
508+ let cl = X(H(cg))
509+ let cm = X(I(cg))
510+ if (if ((cl != 0))
511+ then (cl > lastBlock.timestamp)
512+ else false)
513+ then throw("IDBI: The sale did not start yet!")
514+ else if (if ((cm != 0))
515+ then (lastBlock.timestamp > cm)
516+ else false)
517+ then throw("IDBI: The sale has already finished!")
518+ else if (!(R(C(cg))))
519+ then throw(("IDBI: Item not for sale anymore" + C(cg)))
520+ else {
521+ let cn = X(B(cg))
522+ let co = X(F(cg))
523+ if ((ch > size(ci)))
524+ then throw(("IDBI: Max amount to issue is " + toString(size(ci))))
525+ else {
526+ let cp = if ((ck == 0))
527+ then (cj * ch)
528+ else throw("IDBI: Items that grow in price can not be bought in batch!")
529+ if (if ((cn != 0))
530+ then (co >= cn)
531+ else false)
532+ then throw("IDBI: Max editions sold!")
533+ else {
534+ let bf = if ((V(D(cg)) == ""))
535+ then ai()
536+ else if ((V(D(cg)) == "WAVES"))
537+ then unit
538+ else fromBase58String(V(D(cg)))
539+ let ca = aJ(bY.payments[0])
540+ let cq = value(bY.payments[1])
541+ let cr = cq.amount
542+ if ((cq.assetId != bf))
543+ then throw("IDBI: You can attach only tokens with the correct payment ")
544+ else if ((cr != cp))
545+ then throw(("IDBI: Please attach the exact asset amount" + toString(cp)))
546+ else {
547+ let cs = toBase58String(bY.transactionId)
548+ let y = bY.originCaller
549+ func bT (bU,bV) = if ((ch > bV))
550+ then (bU ++ aM(cg, bV, y)._1)
551+ else bU
552+
553+ let ct = {
554+ let bn = ci
555+ let bo = size(bn)
556+ let bp = nil
557+ func bq (br,bs) = if ((bs >= bo))
558+ then br
559+ else bT(br, bn[bs])
560+
561+ func bt (br,bs) = if ((bs >= bo))
562+ then br
563+ else throw("List size exceeds 30")
564+
565+ bt(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bq(bp, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30)
566+ }
567+ (([IntegerEntry(G(cg), cj), IntegerEntry(F(cg), (co + ch)), ScriptTransfer(ao(), cr, bf)] ++ ca) ++ ct)
568+ }
569+ }
570+ }
571+ }
572+ }
573+
574+
575+
576+@Callable(bY)
577+func directBuyItem (cg) = {
578+ let cj = av(cg)
579+ let ck = X(E(cg))
580+ let cl = X(H(cg))
581+ let cm = X(I(cg))
582+ if (if ((cl != 0))
583+ then (cl > lastBlock.timestamp)
584+ else false)
585+ then throw("IDBI: The sale did not start yet!")
586+ else if (if ((cm != 0))
587+ then (lastBlock.timestamp > cm)
588+ else false)
589+ then throw("IDBI: The sale has already finished!")
590+ else if (!(R(C(cg))))
591+ then throw(("IDBI: Item not for sale anymore" + C(cg)))
592+ else {
593+ let cn = X(B(cg))
594+ let co = X(F(cg))
595+ let cp = if ((ck == 0))
596+ then cj
597+ else (cj + ((cj / 100) * (co * ck)))
598+ if (if ((cn != 0))
599+ then (co >= cn)
600+ else false)
601+ then throw("IDBI: Max editions sold!")
602+ else {
603+ let bf = if ((V(D(cg)) == ""))
604+ then ai()
605+ else if ((V(D(cg)) == "WAVES"))
606+ then unit
607+ else fromBase58String(V(D(cg)))
608+ let ca = aJ(bY.payments[0])
609+ let cq = value(bY.payments[1])
610+ let cr = cq.amount
611+ if ((cq.assetId != bf))
612+ then throw("IDBI: You can attach only tokens with the correct payment ")
613+ else if ((cr != cp))
614+ then throw(("IDBI: Please attach the exact asset amount" + toString(cp)))
615+ else {
616+ let cs = toBase58String(bY.transactionId)
617+ let y = bY.originCaller
618+ let aP = Issue(cg, ("NFT artefact of Waves Ducks game: " + cg), 1, 0, false, unit, 0)
619+ let u = calculateAssetId(aP)
620+ $Tuple2(([aP, StringEntry((("artefact_" + toBase58String(u)) + "_type"), cg), IntegerEntry(G(cg), cp), IntegerEntry(F(cg), (co + 1)), ScriptTransfer(y, 1, u), ScriptTransfer(ao(), cr, bf)] ++ ca), toBase58String(u))
621+ }
622+ }
623+ }
624+ }
625+
626+
627+
628+@Callable(bY)
629+func manipulateBoost (cu,w) = {
630+ let cv = aj()
631+ let cw = split(cv, ";")
632+ let cx = toString(bY.caller)
633+ if ((indexOf(cw, cx) == unit))
634+ then throw("IMB: This smart contract can't manipulate the boost!")
635+ else {
636+ let S = v(w)
637+ let cy = X(S)
638+ let cz = (cy + cu)
639+ if ((0 > cz))
640+ then throw("IMB: Something went wrong with boost, please contact the admins!")
641+ else [IntegerEntry(S, cz)]
642+ }
643+ }
644+
645+
646+
647+@Callable(bY)
648+func manipulateBoostAccount (cu,y) = {
649+ let cv = aj()
650+ let cw = split(cv, ";")
651+ let cx = toString(bY.caller)
652+ if ((indexOf(cw, cx) == unit))
653+ then throw("IMBA: This smart contract can't manipulate the boost!")
654+ else {
655+ let S = x(y)
656+ let cy = X(S)
657+ let cz = (cy + cu)
658+ if ((0 > cz))
659+ then throw("IMBA: Something went wrong with boost, please contact the admins!")
660+ else [IntegerEntry(S, cz)]
661+ }
662+ }
663+
664+
665+
666+@Callable(bY)
667+func checkArtefactDetails (bf) = {
668+ let bH = value(assetInfo(fromBase58String(bf)))
669+ let aC = value(bH.name)
670+ if (if (if (containsElement(M, aC))
671+ then true
672+ else isDefined(av(aC)))
673+ then (bH.issuer == this)
674+ else false)
675+ then $Tuple2(nil, aC)
676+ else throw("Invalid artefact")
677+ }
678+
679+
680+
681+@Callable(bY)
682+func configureOracle (cA) = if ((bY.caller != this))
683+ then throw("IC: admin only")
684+ else [StringEntry(a(), cA)]
685+
686+
687+
688+@Callable(bY)
689+func calculateFarmingPowerBoost (w,y) = {
690+ let cB = X(v(w))
691+ let cC = X(x(y))
692+ let cD = (cB + cC)
693+ $Tuple2([IntegerEntry((w + "_last_boost"), cD)], cD)
694+ }
695+
696+
697+
698+@Callable(bY)
699+func itemDuplicator () = if ((size(bY.payments) != 4))
700+ then throw("IID: Four payments are needed!")
701+ else {
702+ let cE = value(bY.payments[0])
703+ let bZ = value(bY.payments[1])
704+ let cF = value(bY.payments[2])
705+ let ca = aJ(bY.payments[3])
706+ let cG = toBase58String(value(cE.assetId))
707+ if ((cE.amount != 1))
708+ then throw("IID: Duplicator NFT is not attached")
709+ else {
710+ let cb = toBase58String(value(bZ.assetId))
711+ if ((bZ.amount != 1))
712+ then throw("IID: Item NFT is not attached")
713+ else {
714+ let cH = value(cF.assetId)
715+ if ((cH != ai()))
716+ then throw("IID: Please attach eggs!")
717+ else if ((ar() > cF.amount))
718+ then throw(("IID: to duplicate an items you need the following amount of egglets: " + toString(ar())))
719+ else {
720+ let cI = aw(invoke(this, "checkArtefactDetails", [cG], nil))
721+ if ((cI == cI))
722+ then if ((cI != "ART-ITEM_DUPLI"))
723+ then throw("IID: You need to attach a ART-ITEM_DUPLI artefact")
724+ else {
725+ let r = aw(invoke(this, "checkArtefactDetails", [cb], nil))
726+ if ((r == r))
727+ then {
728+ let aP = Issue(r, ("NFT artefact of Waves Ducks game: " + r), 1, 0, false, unit, 0)
729+ let u = calculateAssetId(aP)
730+ $Tuple2(([aP, StringEntry((("artefact_" + toBase58String(u)) + "_type"), r), Burn(value(cE.assetId), 1), ScriptTransfer(bY.originCaller, 1, bZ.assetId), ScriptTransfer(bY.originCaller, 1, u), ScriptTransfer(ao(), cF.amount, cF.assetId)] ++ ca), toBase58String(u))
731+ }
732+ else throw("Strict value is not equal to itself.")
733+ }
734+ else throw("Strict value is not equal to itself.")
735+ }
736+ }
737+ }
738+ }
739+
740+
741+
742+@Callable(bY)
743+func copyDuck () = {
744+ let cq = value(bY.payments[0])
745+ let cJ = value(bY.payments[1])
746+ let ca = aJ(bY.payments[2])
747+ let cK = toBase58String(value(cq.assetId))
748+ let cL = az(invoke(ah(), "validateAndGetChildren", [cK], nil))
749+ if ((cL == cL))
750+ then if (if ((cq.amount != 1))
751+ then true
752+ else (cJ.amount != 1))
753+ then throw("NFT is not attached")
754+ else {
755+ let aP = aw(invoke(this, "checkArtefactDetails", [toBase58String(value(cJ.assetId))], nil))
756+ if ((aP == aP))
757+ then if ((aP != "ART-MIRROR"))
758+ then throw("You need to attach a ART-MIRROR artefact")
759+ else {
760+ let cM = value(assetInfo(value(cq.assetId)))
761+ let cN = split(cM.name, "")
762+ if (if ((cN[14] == "G"))
763+ then true
764+ else (cN[14] == "J"))
765+ then throw("You can't mirror this duck")
766+ else {
767+ let cO = cM.name
768+ let cP = invoke(ah(), "createDuckSpecialGenes", [bY.caller.bytes, cO, cL], nil)
769+ if ((cP == cP))
770+ then ([ScriptTransfer(bY.caller, 1, cq.assetId), Burn(value(cJ.assetId), 1)] ++ ca)
771+ else throw("Strict value is not equal to itself.")
772+ }
773+ }
774+ else throw("Strict value is not equal to itself.")
775+ }
776+ else throw("Strict value is not equal to itself.")
777+ }
778+
779+
780+
781+@Callable(bY)
782+func addArteFactToDuck () = {
783+ let cq = value(bY.payments[0])
784+ let cJ = value(bY.payments[1])
785+ let ca = aJ(bY.payments[2])
786+ let cK = toBase58String(value(cq.assetId))
787+ if (if ((cq.amount != 1))
788+ then true
789+ else (cJ.amount != 1))
790+ then throw("NFT is not attached")
791+ else {
792+ let cL = az(invoke(ah(), "validateAndGetChildren", [cK], nil))
793+ if ((cL == cL))
794+ then if ((cL == 0))
795+ then throw("You can only pick a sterile NFT-duck")
796+ else {
797+ let aP = aw(invoke(this, "checkArtefactDetails", [toBase58String(value(cJ.assetId))], nil))
798+ if ((aP == aP))
799+ then if (if ((aP != "ART-XHAT"))
800+ then (aP != "ART-POMP")
801+ else false)
802+ then throw("You need to attach a ART-XHAT or ART-POMP artefact")
803+ else {
804+ let cM = value(assetInfo(value(cq.assetId)))
805+ let cN = split(cM.name, "")
806+ if (if ((cN[14] == "G"))
807+ then true
808+ else (cN[14] == "J"))
809+ then throw("You can't mirror this duck")
810+ else if (if ((cN[5] == "S"))
811+ then true
812+ else (cN[5] == "T"))
813+ then throw("you already attached a artefact")
814+ else {
815+ let aE = if ((aP == "ART-XHAT"))
816+ then "T"
817+ else if ((aP == "ART-POMP"))
818+ then "S"
819+ else throw("No char defined")
820+ let cQ = cM.name
821+ let cR = aw(invoke(ah(), "getGenFromName", [cQ], nil))
822+ if ((cR == cR))
823+ then {
824+ let cO = aB(cQ, 6, aE)
825+ let cP = invoke(ah(), "createDuckSpecialGenes", [bY.caller.bytes, cO, cL], nil)
826+ if ((cP == cP))
827+ then {
828+ let cS = invoke(ah(), "reduceRarity", [cK, cR], nil)
829+ if ((cS == cS))
830+ then ([Burn(value(cq.assetId), 1), Burn(value(cJ.assetId), 1)] ++ ca)
831+ else throw("Strict value is not equal to itself.")
832+ }
833+ else throw("Strict value is not equal to itself.")
834+ }
835+ else throw("Strict value is not equal to itself.")
836+ }
837+ }
838+ else throw("Strict value is not equal to itself.")
839+ }
840+ else throw("Strict value is not equal to itself.")
841+ }
842+ }
843+
844+
845+
846+@Callable(bY)
847+func preInit () = [IntegerEntry("static_ART-LAKE_farmingSlots", 200), IntegerEntry("static_ART-LAKE_farmingBoost", 2), IntegerEntry("static_ART-HOUSE_farmingSlots", 4), IntegerEntry("static_ART-HOUSE_farmingBoost", 30), IntegerEntry("static_ART-BIGHOUSE_farmingSlots", 10), IntegerEntry("static_ART-BIGHOUSE_farmingBoost", 15)]
848+
849+
850+
851+@Callable(bY)
852+func issueArtefact (aN,cT) = if (if (if (if (if (if ((bY.caller != this))
853+ then (bY.caller != ak())
854+ else false)
855+ then (bY.caller != al())
856+ else false)
857+ then (bY.caller != am())
858+ else false)
859+ then (bY.caller != ap())
860+ else false)
861+ then (bY.callerPublicKey != aq())
862+ else false)
863+ then throw("IIA: admin only")
864+ else if (if (if (if ((bY.caller == ap()))
865+ then true
866+ else (bY.callerPublicKey == aq()))
867+ then !(contains(aN, "ART-FIRE_"))
868+ else false)
869+ then !(R((aN + "_issue")))
870+ else false)
871+ then throw("FIRE AND WHITELIST ITEM ONLY!")
872+ else {
873+ let y = Address(fromBase58String(cT))
874+ aM(aN, 0, y)
875+ }
876+
877+
878+
879+@Callable(bY)
880+func issueArtefactIndex (aN,cT,aO) = if (if (if (if (if (if (if ((bY.caller != this))
881+ then (bY.caller != ak())
882+ else false)
883+ then (bY.caller != al())
884+ else false)
885+ then (bY.caller != am())
886+ else false)
887+ then (bY.caller != an())
888+ else false)
889+ then (bY.caller != ap())
890+ else false)
891+ then (bY.callerPublicKey != aq())
892+ else false)
893+ then throw("IIAI: admin only")
894+ else if (if (if (if ((bY.caller == ap()))
895+ then true
896+ else (bY.callerPublicKey == aq()))
897+ then !(contains(aN, "ART-FIRE_"))
898+ else false)
899+ then !(R((aN + "_issue")))
900+ else false)
901+ then throw("FIRE AND WHITELIST ITEM ONLY!")
902+ else {
903+ let y = Address(fromBase58String(cT))
904+ let cU = aM(aN, aO, y)
905+ cU
906+ }
907+
908+
909+
910+@Callable(bY)
911+func setLock (cV) = if ((bY.caller == this))
912+ then [IntegerEntry("global_locked", cV)]
913+ else throw("admin only")
914+
915+
916+
917+@Callable(bY)
918+func addItemToStore (cp,A,cW,cX,cY,cZ,cl,cm) = if ((bY.caller != addressFromStringValue(af(ag(), g()))))
919+ then throw("IAITS: Only for trusted users!")
920+ else [IntegerEntry(z(A), cp), IntegerEntry(B(A), cW), BooleanEntry(C(A), cX), StringEntry(D(A), cY), IntegerEntry(E(A), cZ), IntegerEntry(H(A), cl), IntegerEntry(I(A), cm)]
921+
922+
923+@Verifier(da)
924+func db () = if (aI())
925+ then sigVerify(da.bodyBytes, da.proofs[0], da.senderPublicKey)
926+ else {
927+ let dc = base58'6TdaXEfhnjYquvPf3yV7MFxt2CbgFmaqsvGwkKfXtKi4'
928+ let dd = base58'7DsP2WaMLocbHuUxux7pbXRjTrrZ1TFQPsi5QumS3gr8'
929+ let de = base58'BpFWP3p3JgYrrP45xfrKzeMcWMEXoinj4FVPPkUiA8D3'
930+ let df = if (sigVerify(da.bodyBytes, da.proofs[0], dc))
931+ then 1
932+ else if (sigVerify(da.bodyBytes, da.proofs[1], dc))
933+ then 1
934+ else if (sigVerify(da.bodyBytes, da.proofs[2], dc))
935+ then 1
936+ else 0
937+ let dg = if (sigVerify(da.bodyBytes, da.proofs[0], dd))
938+ then 1
939+ else if (sigVerify(da.bodyBytes, da.proofs[1], dd))
940+ then 1
941+ else if (sigVerify(da.bodyBytes, da.proofs[2], dd))
942+ then 1
943+ else 0
944+ let dh = if (sigVerify(da.bodyBytes, da.proofs[0], de))
945+ then 1
946+ else if (sigVerify(da.bodyBytes, da.proofs[1], de))
947+ then 1
948+ else if (sigVerify(da.bodyBytes, da.proofs[2], de))
949+ then 1
950+ else 0
951+ let di = ((df + dg) + dh)
952+ let T = da
953+ (di >= 2)
954+ }
955+

github/deemru/w8io/c3f4982 
40.15 ms