tx · 5r3XLV17Yia6dNEhJF62ooeEkfL3UtbHsZjLTmbqUP1A

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.05500000 Waves

2023.05.23 00:56 [2589751] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "5r3XLV17Yia6dNEhJF62ooeEkfL3UtbHsZjLTmbqUP1A",
    "fee": 5500000,
    "feeAssetId": null,
    "timestamp": 1684792594822,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "5uJ6dKX1f5snP8PBDdtq8iwt559haMNLw4u3Zobk5GxBo8JJZXQ3cK7od6kmrZTRDN8s2VGgiLtL1AiUayJwCJVT"
    ],
    "script": "base64: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",
    "height": 2589751,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3PrtLkei6Pf89P6qFfWbKVL7csAw9edmfdKjeeM7cate
Next: Fuke2vCseUMvskDqhdD79hcsXP5LNt5a5ZGun1dWR3PJ

Diff: 

OldNewDifferences
812812                                     else $Tuple4((ci + 1), (bJ._2 :+ toString((dL + dB))), (bJ._3 :+ toString((dM - dB))), (bJ._4 + dB))
813813                         }
814814 
815-                    let cX = {
816-                        let bL = dq
817-                        let bM = size(bL)
818-                        let bN = $Tuple4(0, nil, nil, dH._4)
819-                        func dN (bP,bQ) =                         if ((bQ >= bM))
820-                            then bP
821-                            else dK(bP, bL[bQ])
815+                    let cX = if ((size(dq) != 0))
816+                        then {
817+                            let bL = dq
818+                            let bM = size(bL)
819+                            let bN = $Tuple4(0, nil, nil, dH._4)
820+                            func dN (bP,bQ) =                             if ((bQ >= bM))
821+                                then bP
822+                                else dK(bP, bL[bQ])
822823 
823-                        func dO (bP,bQ) =                         if ((bQ >= bM))
824-                            then bP
825-                            else throw("List size exceeds 50")
824+                            func dO (bP,bQ) =                             if ((bQ >= bM))
825+                                then bP
826+                                else throw("List size exceeds 50")
826827 
827-                        dO(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(bN, 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), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
828-                        }
828+                            dO(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(bN, 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), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
829+                            }
830+                        else $Tuple4(0, dx, dz, dH._4)
829831                     let dP = cX._4
830832                     if ((dP > cC))
831833                         then throw((((("Attempt to put total " + toString(dP)) + " stuff, but only ") + toString(cC)) + " warehouse space left"))

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let a = take(drop(this.bytes, 1), 1)
55 
66 let b = {
77     let c = a
88     if ((base58'2W' == c))
99         then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
1010         else if ((base58'2T' == c))
1111             then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
1212             else throw("Unknown chain")
1313     }
1414 
1515 let d = {
1616     let c = a
1717     if ((base58'2W' == c))
1818         then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
1919         else if ((base58'2T' == c))
2020             then this
2121             else throw("Unknown chain")
2222     }
2323 
2424 let e = {
2525     let c = a
2626     if ((base58'2W' == c))
2727         then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
2828         else if ((base58'2T' == c))
2929             then this
3030             else throw("Unknown chain")
3131     }
3232 
3333 let f = {
3434     let c = a
3535     if ((base58'2W' == c))
3636         then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
3737         else if ((base58'2T' == c))
3838             then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
3939             else throw("Unknown chain")
4040     }
4141 
4242 let g = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
4343 
4444 let h = 10000
4545 
4646 let i = "LAND"
4747 
4848 let j = "DUCK"
4949 
5050 let k = "Africa_F_Africa"
5151 
5252 let l = 6
5353 
5454 let m = 25
5555 
5656 let n = 100
5757 
5858 let o = 225
5959 
6060 let p = 400
6161 
6262 let q = 625
6363 
6464 let r = 3456000
6565 
6666 let s = 86400000
6767 
6868 let t = 300000
6969 
7070 let u = 39637
7171 
7272 let v = 10000000000
7373 
7474 let w = 5000000
7575 
7676 let x = 50
7777 
7878 let y = {
7979     let c = a
8080     if ((base58'2W' == c))
8181         then 10000000000
8282         else if ((base58'2T' == c))
8383             then 100000000
8484             else throw("Unknown chain")
8585     }
8686 
8787 let z = {
8888     let c = a
8989     if ((base58'2W' == c))
9090         then 10000000
9191         else if ((base58'2T' == c))
9292             then 10000000
9393             else throw("Unknown chain")
9494     }
9595 
9696 let A = {
9797     let c = a
9898     if ((base58'2W' == c))
9999         then 252289527462
100100         else if ((base58'2T' == c))
101101             then 2522895274
102102             else throw("Unknown chain")
103103     }
104104 
105105 let B = {
106106     let c = a
107107     if ((base58'2W' == c))
108108         then 250000000
109109         else if ((base58'2T' == c))
110110             then 250000000
111111             else throw("Unknown chain")
112112     }
113113 
114114 let C = "__"
115115 
116116 let D = 1000000
117117 
118118 let E = toBigInt(5)
119119 
120120 let F = toBigInt(20)
121121 
122122 let G = toBigInt((20 * 20))
123123 
124124 let H = toBigInt(((20 * 20) * 20))
125125 
126126 let I = toBigInt((((20 * 20) * 20) * 20))
127127 
128128 let J = toBigInt(((((20 * 20) * 20) * 20) * 20))
129129 
130130 let K = ["Fuel", "Metal", "Plank", "Glass", "Plastic", "Protein"]
131131 
132132 let L = ["Asia", "Europe", "Americas", "Oceania", "Africa"]
133133 
134134 let M = "PRESALE"
135135 
136136 let N = 500
137137 
138138 func O (P,Q) = valueOrErrorMessage(getString(P, Q), makeString(["mandatory ", toString(P), ".", Q, " is not defined"], ""))
139139 
140140 
141141 func R (Q,S) = valueOrElse(getInteger(this, Q), S)
142142 
143143 
144144 let T = 1
145145 
146146 let U = 2
147147 
148148 let V = 3
149149 
150150 func W () = "%s__restConfig"
151151 
152152 
153153 func X () = "%s__restAddr"
154154 
155155 
156156 func Y (Z) = split_4C(O(Z, W()), C)
157157 
158158 
159159 func aa (ab,ac) = valueOrErrorMessage(addressFromString(ab[ac]), ("Rest cfg doesn't contain address at index " + toString(ac)))
160160 
161161 
162162 let ad = addressFromStringValue(valueOrElse(getString(this, X()), f))
163163 
164164 let ab = Y(ad)
165165 
166166 let ae = aa(ab, U)
167167 
168168 let af = aa(ab, V)
169169 
170170 func ag (ah) = ("lastTxIdByUser_" + ah)
171171 
172172 
173173 func ai () = "nextLandNum"
174174 
175175 
176176 func aj (ak) = ("landToAsset_" + ak)
177177 
178178 
179179 func al (ak,am) = ((i + ak) + am)
180180 
181181 
182182 func an (ao) = ("nftOwner_" + ao)
183183 
184184 
185185 func ap (ao) = ("landCustomNameByAssetId_" + ao)
186186 
187187 
188188 func aq (ao) = ("duckCustomNameByAssetId_" + ao)
189189 
190190 
191191 func ar (ah) = ("accountCustomNameByAddr_" + ah)
192192 
193193 
194194 func as (at) = ("landByCustomName_" + at)
195195 
196196 
197197 func au (at) = ("duckByCustomName_" + at)
198198 
199199 
200200 func av (at) = ("accountByCustomName_" + at)
201201 
202202 
203203 func aw (ah) = ("accRefBy_" + ah)
204204 
205205 
206206 func ax (ah) = ("accReferrals_" + ah)
207207 
208208 
209209 func ay () = "oldiesList"
210210 
211211 
212212 func az (ao) = ("duckOwner_" + ao)
213213 
214214 
215215 func aA (ao) = ("stakedTime_" + ao)
216216 
217217 
218218 func aB (ao) = ("infraLevel_" + ao)
219219 
220220 
221221 func aC (ao,aD) = ((("infraLevelByAssetIdAndOwner_" + ao) + "_") + aD)
222222 
223223 
224224 func aE (ao) = ("presaleArtActivated_" + ao)
225225 
226226 
227227 func aF (ao,aD) = ((("presaleArtActivatedByAssetIdAndOwner_" + ao) + "_") + aD)
228228 
229229 
230230 func aG (aH,ao) = makeString(["landArtStatus", aH, ao], "_")
231231 
232232 
233233 func aI (aH,ao,aD) = makeString(["landArtStatusByTypeAssetIdAndOwner", aH, ao, aD], "_")
234234 
235235 
236236 func aJ (aD) = ("stakedDuckByOwner_" + aD)
237237 
238238 
239239 func aK (aL,ao,aD) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aL) + "_") + ao) + "_") + aD)
240240 
241241 
242242 func aM (ak) = ("landOwner_" + ak)
243243 
244244 
245245 func aN (aO) = ("backPack_" + aO)
246246 
247247 
248248 func aP (aQ) = ("wareHouse_" + aQ)
249249 
250250 
251251 func aR (aO) = ("duckLocation_" + aO)
252252 
253253 
254254 func aS (aO) = ("duckHealth_" + aO)
255255 
256256 
257257 func aT () = "resTypesProportions"
258258 
259259 
260260 func aU (aD) = ("stakedLandsByOwner_" + aD)
261261 
262262 
263263 func aV () = "contractsBlocked"
264264 
265265 
266266 func aW (aX) = ("%s%s__userGwlReleaseTime__" + aX)
267267 
268268 
269269 let aY = 0
270270 
271271 let aZ = 1
272272 
273273 let ba = 2
274274 
275275 let bb = 3
276276 
277277 let bc = 0
278278 
279279 let bd = 1
280280 
281281 let be = 2
282282 
283283 let bf = 0
284284 
285285 let bg = 1
286286 
287287 let bh = 2
288288 
289289 let bi = 3
290290 
291291 let bj = 0
292292 
293293 let bk = 1
294294 
295295 let bl = 2
296296 
297297 let bm = 3
298298 
299299 let bn = 4
300300 
301301 let bo = 0
302302 
303303 let bp = 1
304304 
305305 let bq = 2
306306 
307307 let br = 0
308308 
309309 let bs = 1
310310 
311311 let bt = 2
312312 
313313 let bu = 3
314314 
315315 let bv = 4
316316 
317317 let bw = 5
318318 
319319 let bx = 6
320320 
321321 func by (bz) = {
322322     let c = bz
323323     if ($isInstanceOf(c, "String"))
324324         then {
325325             let bA = c
326326             bA
327327             }
328328         else throw("fail to cast into String")
329329     }
330330 
331331 
332332 func bB (bz) = {
333333     let c = bz
334334     if ($isInstanceOf(c, "Int"))
335335         then {
336336             let bC = c
337337             bC
338338             }
339339         else throw("fail to cast into Int")
340340     }
341341 
342342 
343343 func bD (bE,bF) = {
344344     let bG = (((((bF[0] + bF[1]) + bF[2]) + bF[3]) + bF[4]) + bF[5])
345345     if ((0 >= bG))
346346         then throw("Zero weights sum")
347347         else {
348348             let bH = fraction(bE, D, bG)
349349             func bI (bJ,bK) =             (bJ :+ fraction(bK, bH, D))
350350 
351351             let bL = bF
352352             let bM = size(bL)
353353             let bN = nil
354354             func bO (bP,bQ) =             if ((bQ >= bM))
355355                 then bP
356356                 else bI(bP, bL[bQ])
357357 
358358             func bR (bP,bQ) =             if ((bQ >= bM))
359359                 then bP
360360                 else throw("List size exceeds 6")
361361 
362362             bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
363363             }
364364     }
365365 
366366 
367367 func bS (bE) = {
368368     let bT = split(value(getString(aT())), "_")
369369     if ((size(bT) != l))
370370         then throw("Wrong proportions data")
371371         else {
372372             let bU = [parseIntValue(bT[0]), parseIntValue(bT[1]), parseIntValue(bT[2]), parseIntValue(bT[3]), parseIntValue(bT[4]), parseIntValue(bT[5])]
373373             bD(bE, bU)
374374             }
375375     }
376376 
377377 
378378 func bV (bW,bX,bY) = {
379379     let bZ = bS(bY)
380380     func ca (bJ,ac) =     {
381381         let cb = (parseIntValue(bX[ac]) - bZ[ac])
382382         if ((0 > cb))
383383             then throw(((((("Not enough material idx=" + toString(ac)) + ", you have ") + bX[ac]) + ", but need ") + toString(bZ[ac])))
384384             else (bJ :+ toString(cb))
385385         }
386386 
387387     if (bW)
388388         then {
389389             let bL = [0, 1, 2, 3, 4, 5]
390390             let bM = size(bL)
391391             let bN = nil
392392             func bO (bP,bQ) =             if ((bQ >= bM))
393393                 then bP
394394                 else ca(bP, bL[bQ])
395395 
396396             func bR (bP,bQ) =             if ((bQ >= bM))
397397                 then bP
398398                 else throw("List size exceeds 6")
399399 
400400             bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
401401             }
402402         else bX
403403     }
404404 
405405 
406406 func cc (cd,ce,cf,cg) = if ((size(cd) != l))
407407     then throw("Wrong proportions data")
408408     else {
409409         func ch (bJ,ci) =         {
410410             let cb = (parseIntValue(cd[ci]) + ((cg * ce[ci]) * cf))
411411             if ((0 > cb))
412412                 then throw(((((((("Panic! Pieces of type=" + toString(ci)) + ", sign=") + toString(cg)) + ",  terrainCounts[i]=") + toString(ce[ci])) + ", landSizeIndex=") + toString(cf)))
413413                 else (bJ :+ toString(cb))
414414             }
415415 
416416         let bU = {
417417             let bL = [0, 1, 2, 3, 4, 5]
418418             let bM = size(bL)
419419             let bN = nil
420420             func bO (bP,bQ) =             if ((bQ >= bM))
421421                 then bP
422422                 else ch(bP, bL[bQ])
423423 
424424             func bR (bP,bQ) =             if ((bQ >= bM))
425425                 then bP
426426                 else throw("List size exceeds 6")
427427 
428428             bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
429429             }
430430         makeString(bU, "_")
431431         }
432432 
433433 
434434 func cj (ce,cf,cg) = {
435435     let cd = split(valueOrElse(getString(aT()), "0_0_0_0_0_0"), "_")
436436     cc(cd, ce, cf, cg)
437437     }
438438 
439439 
440440 func ck (cl) = [(size(split(cl, "A")) - 1), (size(split(cl, "B")) - 1), (size(split(cl, "C")) - 1), (size(split(cl, "D")) - 1), (size(split(cl, "E")) - 1), (size(split(cl, "F")) - 1)]
441441 
442442 
443443 func cm (am) = {
444444     let c = am
445445     if (("S" == c))
446446         then m
447447         else if (("M" == c))
448448             then n
449449             else if (("L" == c))
450450                 then o
451451                 else if (("XL" == c))
452452                     then p
453453                     else if (("XXL" == c))
454454                         then q
455455                         else throw("Unknown land size")
456456     }
457457 
458458 
459459 func cn (co,ac,cp) = {
460460     func cq (bJ,ci) =     (bJ :+ (if ((ci == ac))
461461         then toString((parseIntValue(co[ci]) - cp))
462462         else co[ci]))
463463 
464464     let bU = {
465465         let bL = [0, 1, 2, 3, 4, 5]
466466         let bM = size(bL)
467467         let bN = nil
468468         func bO (bP,bQ) =         if ((bQ >= bM))
469469             then bP
470470             else cq(bP, bL[bQ])
471471 
472472         func bR (bP,bQ) =         if ((bQ >= bM))
473473             then bP
474474             else throw("List size exceeds 6")
475475 
476476         bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
477477         }
478478     makeString(bU, "_")
479479     }
480480 
481481 
482482 func cr (cs,ce,ct,cf,cu) = {
483483     func cv (bJ,ci) =     {
484484         let cw = ((fraction(ct, cu, s) * ce[ci]) * cf)
485485         (bJ :+ toString((parseIntValue(cs[ci]) + cw)))
486486         }
487487 
488488     let bU = {
489489         let bL = [0, 1, 2, 3, 4, 5]
490490         let bM = size(bL)
491491         let bN = nil
492492         func bO (bP,bQ) =         if ((bQ >= bM))
493493             then bP
494494             else cv(bP, bL[bQ])
495495 
496496         func bR (bP,bQ) =         if ((bQ >= bM))
497497             then bP
498498             else throw("List size exceeds 6")
499499 
500500         bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
501501         }
502502     makeString(bU, "_")
503503     }
504504 
505505 
506506 func cx (ce,ct,cf,cu) = {
507507     func cv (bJ,ci) =     {
508508         let cw = ((fraction(ct, cu, s) * ce[ci]) * cf)
509509         $Tuple2((bJ._1 :+ cw), (bJ._2 + cw))
510510         }
511511 
512512     let bL = [0, 1, 2, 3, 4, 5]
513513     let bM = size(bL)
514514     let bN = $Tuple2(nil, 0)
515515     func bO (bP,bQ) =     if ((bQ >= bM))
516516         then bP
517517         else cv(bP, bL[bQ])
518518 
519519     func bR (bP,bQ) =     if ((bQ >= bM))
520520         then bP
521521         else throw("List size exceeds 6")
522522 
523523     bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
524524     }
525525 
526526 
527527 func cy (cz,cA,cB,cC) = {
528528     let cD = cB._1
529529     let cE = cB._2
530530     if ((cE == 0))
531531         then $Tuple2(makeString(cz, "_"), makeString(cA, "_"))
532532         else if ((cC >= cE))
533533             then {
534534                 func cF (bJ,ci) =                 (bJ :+ toString((parseIntValue(cz[ci]) + cD[ci])))
535535 
536536                 let bU = {
537537                     let bL = [0, 1, 2, 3, 4, 5]
538538                     let bM = size(bL)
539539                     let bN = nil
540540                     func bO (bP,bQ) =                     if ((bQ >= bM))
541541                         then bP
542542                         else cF(bP, bL[bQ])
543543 
544544                     func bR (bP,bQ) =                     if ((bQ >= bM))
545545                         then bP
546546                         else throw("List size exceeds 6")
547547 
548548                     bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
549549                     }
550550                 $Tuple2(makeString(bU, "_"), makeString(cA, "_"))
551551                 }
552552             else {
553553                 func cG (bJ,ci) =                 {
554554                     let cH = fraction(cD[ci], cC, cE)
555555                     $Tuple2((bJ._1 :+ toString((parseIntValue(cz[ci]) + cH))), (bJ._2 :+ toString(((parseIntValue(cA[ci]) + cD[ci]) - cH))))
556556                     }
557557 
558558                 let bU = {
559559                     let bL = [0, 1, 2, 3, 4, 5]
560560                     let bM = size(bL)
561561                     let bN = $Tuple2(nil, nil)
562562                     func bO (bP,bQ) =                     if ((bQ >= bM))
563563                         then bP
564564                         else cG(bP, bL[bQ])
565565 
566566                     func bR (bP,bQ) =                     if ((bQ >= bM))
567567                         then bP
568568                         else throw("List size exceeds 6")
569569 
570570                     bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
571571                     }
572572                 $Tuple2(makeString(bU._1, "_"), makeString(bU._2, "_"))
573573                 }
574574     }
575575 
576576 
577577 func cI (cJ) = if ((cJ >= toBigInt(0)))
578578     then cJ
579579     else -(cJ)
580580 
581581 
582582 let cK = [[1, 4, 9, 10, 15], [5, 8, 13, 14, 15], [6, 9, 14, 15, 16], [4, 7, 8, 13, 18], [1, 6, 7, 15, 19]]
583583 
584584 func cL (bC,cM) = {
585585     let cN = toInt((bC % F))
586586     let cO = if ((cM[0] > cN))
587587         then "A"
588588         else if ((cM[1] > cN))
589589             then "B"
590590             else if ((cM[2] > cN))
591591                 then "C"
592592                 else if ((cM[3] > cN))
593593                     then "D"
594594                     else if ((cM[4] > cN))
595595                         then "E"
596596                         else "F"
597597     cO
598598     }
599599 
600600 
601601 func cP (cQ,cR) = {
602602     let cS = cK[cR]
603603     func cT (bJ,bK) =     $Tuple2((((((bJ._1 + cL(bJ._2, cS)) + cL((bJ._2 / F), cS)) + cL((bJ._2 / G), cS)) + cL((bJ._2 / H), cS)) + cL((bJ._2 / I), cS)), (bJ._2 / J))
604604 
605605     let cU = {
606606         let bL = [1, 2, 3, 4, 5]
607607         let bM = size(bL)
608608         let bN = $Tuple2("", (cQ / E))
609609         func bO (bP,bQ) =         if ((bQ >= bM))
610610             then bP
611611             else cT(bP, bL[bQ])
612612 
613613         func bR (bP,bQ) =         if ((bQ >= bM))
614614             then bP
615615             else throw("List size exceeds 5")
616616 
617617         bR(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5)
618618         }
619619     cU._1
620620     }
621621 
622622 
623623 func cV (cW) = {
624624     let cX = split(valueOrElse(getString(cW), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
625625 [toString(valueOrElse(parseInt(cX[bf]), 0)), if ((size(split(cX[bg], "_")) == l))
626626         then cX[bg]
627627         else "0_0_0_0_0_0", if ((size(split(cX[bh], "_")) == l))
628628         then cX[bh]
629629         else "0_0_0_0_0_0", cX[bi]]
630630     }
631631 
632632 
633633 func cY (cZ) = {
634634     let da = split(cZ, "_")
635635     ((v * (parseIntValue(da[1]) + 1)) * parseIntValue(da[0]))
636636     }
637637 
638638 
639639 func db (dc,dd,de) = {
640640     let cZ = ((toString(dd) + "_") + toString(de))
641641     let cX = split(valueOrElse(getString(dc), (cZ + ":0_0_0_0_0_0:0_0_0_0_0_0::0")), ":")
642642 [cX[bj], if ((size(split(cX[bk], "_")) == l))
643643         then cX[bk]
644644         else "0_0_0_0_0_0", if ((size(split(cX[bl], "_")) == l))
645645         then cX[bl]
646646         else "0_0_0_0_0_0", cX[bm], if ((5 > size(cX)))
647647         then "0"
648648         else cX[bn]]
649649     }
650650 
651651 
652652 func df (dg) = {
653653     func bG (bJ,dh) =     (bJ + parseIntValue(dh))
654654 
655655     let bL = split(dg[bk], "_")
656656     let bM = size(bL)
657657     let bN = 0
658658     func bO (bP,bQ) =     if ((bQ >= bM))
659659         then bP
660660         else bG(bP, bL[bQ])
661661 
662662     func bR (bP,bQ) =     if ((bQ >= bM))
663663         then bP
664664         else throw("List size exceeds 6")
665665 
666666     bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
667667     }
668668 
669669 
670670 func di (dg) = {
671671     func bG (bJ,dh) =     (bJ + parseIntValue(dh))
672672 
673673     let bL = split(dg[bl], "_")
674674     let bM = size(bL)
675675     let bN = 0
676676     func bO (bP,bQ) =     if ((bQ >= bM))
677677         then bP
678678         else bG(bP, bL[bQ])
679679 
680680     func bR (bP,bQ) =     if ((bQ >= bM))
681681         then bP
682682         else throw("List size exceeds 6")
683683 
684684     bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
685685     }
686686 
687687 
688688 func dj (dg) = {
689689     let dk = dg[bm]
690690     if ((dk == ""))
691691         then 0
692692         else {
693693             func bG (bJ,dh) =             (bJ + parseIntValue(dh))
694694 
695695             let bL = split_4C(dk, "_")
696696             let bM = size(bL)
697697             let bN = 0
698698             func bO (bP,bQ) =             if ((bQ >= bM))
699699                 then bP
700700                 else bG(bP, bL[bQ])
701701 
702702             func bR (bP,bQ) =             if ((bQ >= bM))
703703                 then bP
704704                 else throw("List size exceeds 50")
705705 
706706             bR(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bN, 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), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
707707             }
708708     }
709709 
710710 
711711 func dl (dm,dg,dn) = if ((size(dm) != 3))
712712     then throw("cargoListStr should contain exactly 2 ':' separators")
713713     else {
714714         let do = split(dm[0], "_")
715715         let dp = split(dm[1], "_")
716716         let dq = if ((dm[2] == ""))
717717             then nil
718718             else split(dm[2], "_")
719719         if ((size(do) != l))
720720             then throw("All 6 resources should be passed")
721721             else if ((size(dp) != l))
722722                 then throw("All 6 materials should be passed")
723723                 else {
724724                     let dr = df(dg)
725725                     let ds = di(dg)
726726                     let dt = dj(dg)
727727                     let du = parseIntValue(dg[bn])
728728                     let cC = ((((cY(dg[bj]) - dr) - ds) - dt) - du)
729729                     let dv = split(dg[bk], "_")
730730                     let dw = split(dg[bl], "_")
731731                     let dx = if ((dg[bm] == ""))
732732                         then nil
733733                         else split(dg[bm], "_")
734734                     let cA = split(dn[bg], "_")
735735                     let dy = split(dn[bh], "_")
736736                     let dz = if ((dn[bi] == ""))
737737                         then nil
738738                         else split(dn[bi], "_")
739739                     func dA (bJ,dh) =                     {
740740                         let ci = bJ._1
741741                         let dB = parseIntValue(dh)
742742                         let dC = parseIntValue(dv[ci])
743743                         let dD = parseIntValue(cA[ci])
744744                         if ((dB == 0))
745745                             then $Tuple4((ci + 1), (bJ._2 :+ dv[ci]), (bJ._3 :+ cA[ci]), bJ._4)
746746                             else if ((dB > 0))
747747                                 then if ((dB > dD))
748748                                     then throw((((("Attempt to take " + dh) + " from backpack, but only ") + toString(dD)) + " available"))
749749                                     else $Tuple4((ci + 1), (bJ._2 :+ toString((dC + dB))), (bJ._3 :+ toString((dD - dB))), (bJ._4 + dB))
750750                                 else if ((-(dB) > dC))
751751                                     then throw((((("Attempt to take " + toString(-(dB))) + " from warehouse, but only ") + toString(dC)) + " available"))
752752                                     else $Tuple4((ci + 1), (bJ._2 :+ toString((dC + dB))), (bJ._3 :+ toString((dD - dB))), (bJ._4 + dB))
753753                         }
754754 
755755                     let bU = {
756756                         let bL = do
757757                         let bM = size(bL)
758758                         let bN = $Tuple4(0, nil, nil, 0)
759759                         func bO (bP,bQ) =                         if ((bQ >= bM))
760760                             then bP
761761                             else dA(bP, bL[bQ])
762762 
763763                         func bR (bP,bQ) =                         if ((bQ >= bM))
764764                             then bP
765765                             else throw("List size exceeds 6")
766766 
767767                         bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
768768                         }
769769                     func dE (bJ,dh) =                     {
770770                         let ci = bJ._1
771771                         let dB = parseIntValue(dh)
772772                         let dF = parseIntValue(dw[ci])
773773                         let dG = parseIntValue(dy[ci])
774774                         if ((dB == 0))
775775                             then $Tuple4((ci + 1), (bJ._2 :+ dw[ci]), (bJ._3 :+ dy[ci]), bJ._4)
776776                             else if ((dB > 0))
777777                                 then if ((dB > dG))
778778                                     then throw((((("Attempt to take " + dh) + " from backpack, but only ") + toString(dG)) + " available"))
779779                                     else $Tuple4((ci + 1), (bJ._2 :+ toString((dF + dB))), (bJ._3 :+ toString((dG - dB))), (bJ._4 + dB))
780780                                 else if ((-(dB) > dF))
781781                                     then throw((((("Attempt to take " + toString(-(dB))) + " from warehouse, but only ") + toString(dF)) + " available"))
782782                                     else $Tuple4((ci + 1), (bJ._2 :+ toString((dF + dB))), (bJ._3 :+ toString((dG - dB))), (bJ._4 + dB))
783783                         }
784784 
785785                     let dH = {
786786                         let bL = dp
787787                         let bM = size(bL)
788788                         let bN = $Tuple4(0, nil, nil, bU._4)
789789                         func dI (bP,bQ) =                         if ((bQ >= bM))
790790                             then bP
791791                             else dE(bP, bL[bQ])
792792 
793793                         func dJ (bP,bQ) =                         if ((bQ >= bM))
794794                             then bP
795795                             else throw("List size exceeds 6")
796796 
797797                         dJ(dI(dI(dI(dI(dI(dI(bN, 0), 1), 2), 3), 4), 5), 6)
798798                         }
799799                     func dK (bJ,dh) =                     {
800800                         let ci = bJ._1
801801                         let dB = parseIntValue(dh)
802802                         let dL = parseIntValue(dx[ci])
803803                         let dM = parseIntValue(dz[ci])
804804                         if ((dB == 0))
805805                             then $Tuple4((ci + 1), (bJ._2 :+ dx[ci]), (bJ._3 :+ dz[ci]), bJ._4)
806806                             else if ((dB > 0))
807807                                 then if ((dB > dM))
808808                                     then throw((((("Attempt to take " + dh) + " from backpack, but only ") + toString(dM)) + " available"))
809809                                     else $Tuple4((ci + 1), (bJ._2 :+ toString((dL + dB))), (bJ._3 :+ toString((dM - dB))), (bJ._4 + dB))
810810                                 else if ((-(dB) > dL))
811811                                     then throw((((("Attempt to take " + toString(-(dB))) + " from warehouse, but only ") + toString(dL)) + " available"))
812812                                     else $Tuple4((ci + 1), (bJ._2 :+ toString((dL + dB))), (bJ._3 :+ toString((dM - dB))), (bJ._4 + dB))
813813                         }
814814 
815-                    let cX = {
816-                        let bL = dq
817-                        let bM = size(bL)
818-                        let bN = $Tuple4(0, nil, nil, dH._4)
819-                        func dN (bP,bQ) =                         if ((bQ >= bM))
820-                            then bP
821-                            else dK(bP, bL[bQ])
815+                    let cX = if ((size(dq) != 0))
816+                        then {
817+                            let bL = dq
818+                            let bM = size(bL)
819+                            let bN = $Tuple4(0, nil, nil, dH._4)
820+                            func dN (bP,bQ) =                             if ((bQ >= bM))
821+                                then bP
822+                                else dK(bP, bL[bQ])
822823 
823-                        func dO (bP,bQ) =                         if ((bQ >= bM))
824-                            then bP
825-                            else throw("List size exceeds 50")
824+                            func dO (bP,bQ) =                             if ((bQ >= bM))
825+                                then bP
826+                                else throw("List size exceeds 50")
826827 
827-                        dO(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(bN, 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), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
828-                        }
828+                            dO(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(dN(bN, 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), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
829+                            }
830+                        else $Tuple4(0, dx, dz, dH._4)
829831                     let dP = cX._4
830832                     if ((dP > cC))
831833                         then throw((((("Attempt to put total " + toString(dP)) + " stuff, but only ") + toString(cC)) + " warehouse space left"))
832834                         else $Tuple6(makeString(bU._2, "_"), makeString(dH._2, "_"), makeString(cX._2, "_"), makeString(bU._3, "_"), makeString(dH._3, "_"), makeString(cX._3, "_"))
833835                     }
834836         }
835837 
836838 
837839 func dQ (dR,dS) = {
838840     let aX = toString(dR)
839841     let dT = cI(toBigInt(dS))
840842     let dU = valueOrElse(getInteger(ai()), (N + 1))
841843     let ak = toString(dU)
842844     let cR = toInt((dT % E))
843845     let cl = cP(dT, cR)
844846     let dV = L[cR]
845847     let dW = Issue(al(ak, "S"), makeString([ak, "S", cl, dV], "_"), 1, 0, false)
846848     let ao = calculateAssetId(dW)
847849     let dX = toBase58String(ao)
848850     $Tuple2([IntegerEntry(ai(), (dU + 1)), dW, StringEntry(aj(ak), dX), StringEntry(an(dX), aX), StringEntry(aM(ak), aX), IntegerEntry(aB(dX), 0), IntegerEntry(aC(dX, aX), 0), ScriptTransfer(dR, 1, ao)], $Tuple2(dX, dV))
849851     }
850852 
851853 
852854 func dY (bW,dR,dS,dZ,ea) = if (!(sigVerify_8Kb(dZ, ea, g)))
853855     then throw("signature does not match")
854856     else {
855857         let da = split(toUtf8String(dZ), ";")
856858         let eb = split(split(da[0], "|")[0], "_")
857859         let ec = parseIntValue(eb[0])
858860         let ed = parseIntValue(eb[1])
859861         let ee = split(da[1], ":")
860862         let ef = split(ee[0], "_")
861863         if ((ef[1] != "E"))
862864             then throw("expedition target location type should be E")
863865             else {
864866                 let eg = parseIntValue(ee[1])
865867                 if (if ((eg > (lastBlock.timestamp + t)))
866868                     then true
867869                     else ((lastBlock.timestamp - t) > eg))
868870                     then throw("signature outdated")
869871                     else {
870872                         let aX = toString(dR)
871873                         let aO = valueOrErrorMessage(getString(aJ(aX)), "You don't have a duck staked")
872874                         let eh = aS(aO)
873875                         let ei = valueOrElse(getInteger(eh), 100)
874876                         if ((ei != ec))
875877                             then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eh), 100))) + " from state does not match one from flight log=") + toString(ec)))
876878                             else if ((0 >= ec))
877879                                 then throw("You can't fly with zero health")
878880                                 else if ((0 >= ed))
879881                                     then $Tuple2(((if (!(bW))
880882                                         then [ScriptTransfer(dR, B, b)]
881883                                         else nil) :+ IntegerEntry(eh, 0)), "")
882884                                     else {
883885                                         let cW = aN(aO)
884886                                         let dn = cV(cW)
885887                                         let ej = split(dn[bh], "_")
886888                                         let ek = makeString(bV(bW, ej, A), "_")
887889                                         let el = dQ(dR, dS)
888890                                         let dX = el._2._1
889891                                         $Tuple2((((el._1 :+ StringEntry(aR(aO), makeString([el._2._2, "L", dX], "_"))) :+ IntegerEntry(eh, ed)) :+ StringEntry(cW, makeString([dn[bf], dn[bg], ek, dn[bi]], ":"))), dX)
890892                                         }
891893                         }
892894                 }
893895         }
894896 
895897 
896898 func em (aQ,en) = {
897899     let de = valueOrElse(getInteger(aB(aQ)), 0)
898900     let eo = valueOrElse(getInteger(aG(M, aQ)), if (valueOrElse(getBoolean(aE(aQ)), false))
899901         then en
900902         else 0)
901903     let ep = (de / 6)
902904     let eq = (de / 7)
903905     ((r + fraction(r, ((de + ep) + (2 * eq)), 5)) + fraction(r, eo, (en * 5)))
904906     }
905907 
906908 
907909 func er (ah,es,et) = {
908910     let eu = if ((es == bo))
909911         then $Tuple2(et, valueOrElse(getString(aJ(ah)), ""))
910912         else {
911913             let aO = valueOrErrorMessage(getString(aJ(ah)), "You don't have a duck staked")
912914             let ev = valueOrElse(getString(aR(aO)), k)
913915             let ew = split(value(ev), "_")
914916             if ((ew[bd] != "L"))
915917                 then throw((("Duck location type is " + ew[bd]) + ", but should be L"))
916918                 else $Tuple2(ew[be], aO)
917919             }
918920     let aQ = eu._1
919921     let ex = eu._2
920922     let ey = value(assetInfo(fromBase58String(aQ)))
921923     let ez = aA(aQ)
922924     let eA = valueOrErrorMessage(getInteger(ez), (("Land " + ey.name) + " is not staked"))
923925     let eB = valueOrErrorMessage(getString(an(aQ)), (("NFT " + ey.name) + " is orphaned"))
924926     if ((eB != ah))
925927         then throw((i + " is not yours"))
926928         else {
927929             let eC = split(ey.description, "_")
928930             $Tuple4(ex, aQ, eC, eA)
929931             }
930932     }
931933 
932934 
933935 func eD (ah,cp,es,et) = if ((0 > cp))
934936     then throw("Negative amount")
935937     else {
936938         let eE = er(ah, es, et)
937939         let am = eE._3[aZ]
938940         let ce = ck(eE._3[ba])
939941         let ct = (lastBlock.timestamp - eE._4)
940942         if ((0 > ct))
941943             then throw(((("Saved timestamp is in future, saved = " + toString(eE._4)) + ", current = ") + toString(lastBlock.timestamp)))
942944             else {
943945                 let en = cm(am)
944946                 let eF = em(eE._2, en)
945947                 let eG = fraction(ct, (eF * en), s)
946948                 if ((cp > eG))
947949                     then throw(((("Not enough resources, available = " + toString(eG)) + ", requested = ") + toString(cp)))
948950                     else {
949951                         let eH = fraction((eG - cp), s, (eF * en))
950952                         let eI = (lastBlock.timestamp - eH)
951953                         let dd = (en / m)
952954                         let cB = cx(ce, (ct - eH), dd, eF)
953955                         let dc = aP(eE._2)
954956                         let de = valueOrElse(getInteger(aB(eE._2)), 0)
955957                         let dg = db(dc, dd, de)
956958                         let dr = df(dg)
957959                         let ds = di(dg)
958960                         let dt = dj(dg)
959961                         let du = parseIntValue(dg[bn])
960962                         let cC = ((((cY(dg[bj]) - dr) - ds) - dt) - du)
961963                         if (if ((es == bo))
962964                             then (cp > cC)
963965                             else false)
964966                             then throw((("Only " + toString(cC)) + " space left in warehouse"))
965967                             else {
966968                                 let cW = aN(eE._1)
967969                                 let dn = cV(cW)
968970                                 let cA = split(dn[bg], "_")
969971                                 let cz = split(dg[bk], "_")
970972                                 let eJ = if ((es == bo))
971973                                     then $Tuple2(cr(cz, ce, (ct - eH), dd, eF), dn[bg])
972974                                     else if ((es == bp))
973975                                         then $Tuple2(dg[bk], cr(cA, ce, (ct - eH), dd, eF))
974976                                         else cy(cz, cA, cB, cC)
975977                                 let eK = eJ._1
976978                                 let eL = eJ._2
977979                                 $Tuple5([IntegerEntry(aA(eE._2), eI), IntegerEntry(aK(i, eE._2, ah), eI)], cW, [dn[bf], eL, dn[bh], dn[bi]], dc, [dg[bj], eK, dg[bl], dg[bm], dg[bn]])
978980                                 }
979981                         }
980982                 }
981983         }
982984 
983985 
984986 func eM (ah,aQ,en,es) = {
985987     let ez = aA(aQ)
986988     let eA = value(getInteger(ez))
987989     let eG = (fraction((lastBlock.timestamp - eA), em(aQ, en), s) * en)
988990     eD(ah, eG, es, aQ)
989991     }
990992 
991993 
992994 func eN (bW,dR,eO,aQ) = {
993995     let ah = toString(dR)
994996     let eE = er(ah, bq, aQ)
995997     let en = cm(eE._3[aZ])
996998     let eP = aB(eE._2)
997999     let eQ = valueOrElse(getInteger(eP), 0)
9981000     if ((eQ >= 3))
9991001         then throw("Currently max infrastructure level = 3")
10001002         else {
10011003             let eR = (eQ + 1)
10021004             let eS = fraction(z, (en * eR), m)
10031005             if (if (!(bW))
10041006                 then (eO != eS)
10051007                 else false)
10061008                 then throw(("Payment attached should be " + toString(eS)))
10071009                 else {
10081010                     let cW = aN(eE._1)
10091011                     let dn = cV(cW)
10101012                     let ej = split(dn[bh], "_")
10111013                     let ek = makeString(bV(bW, ej, fraction(y, (en * eR), m)), "_")
10121014                     let eT = eM(ah, eE._2, en, bq)
10131015                     let eU = eT._5
10141016                     let eV = makeString([split(eU[bj], "_")[0], toString(eR)], "_")
10151017                     $Tuple2(([IntegerEntry(eP, eR), IntegerEntry(aC(eE._2, ah), eR), StringEntry(cW, makeString([dn[bf], eT._3[bg], ek, dn[bi]], ":")), StringEntry(eT._4, makeString([eV, eU[bk], eU[bl], eU[bm], eU[bn]], ":"))] ++ eT._1), eR)
10161018                     }
10171019             }
10181020     }
10191021 
10201022 
10211023 func eW (ah) = 0
10221024 
10231025 
10241026 func eX (ah,et) = {
10251027     let eE = er(ah, bq, et)
10261028     let aQ = eE._2
10271029     let en = cm(eE._3[aZ])
10281030     let eY = aG(M, aQ)
10291031     if ((valueOrElse(getInteger(eY), if (valueOrElse(getBoolean(aE(aQ)), false))
10301032         then en
10311033         else 0) > 0))
10321034         then throw("Presale artifact is already activated")
10331035         else if ((parseIntValue(eE._3[aY]) > N))
10341036             then throw((((i + " ") + aQ) + " is not eligible for presale artifact"))
10351037             else {
10361038                 let eT = eM(ah, aQ, en, bq)
10371039                 ((((eT._1 :+ IntegerEntry(eY, en)) :+ IntegerEntry(aI(M, aQ, ah), en)) :+ StringEntry(eT._2, makeString(eT._3, ":"))) :+ StringEntry(eT._4, makeString(eT._5, ":")))
10381040                 }
10391041     }
10401042 
10411043 
10421044 func eZ (fa,eR,fb,ah,fc,dS,fd) = {
10431045     let aO = valueOrErrorMessage(getString(aJ(ah)), "You don't have a duck staked")
10441046     func fe (bJ,aQ) =     {
10451047         let ey = value(assetInfo(fromBase58String(aQ)))
10461048         let ez = aA(aQ)
10471049         let eA = valueOrErrorMessage(getInteger(ez), (("NFT " + ey.name) + " is not staked"))
10481050         let eB = valueOrErrorMessage(getString(an(aQ)), (("NFT " + ey.name) + " is orphaned"))
10491051         if ((eB != ah))
10501052             then throw((i + " is not yours"))
10511053             else {
10521054                 let eC = split(ey.description, "_")
10531055                 let dV = eC[bb]
10541056                 if (if ((bJ._3 != ""))
10551057                     then (bJ._3 != dV)
10561058                     else false)
10571059                     then throw("Lands should be on the same continent to merge")
10581060                     else {
10591061                         let am = eC[aZ]
10601062                         let ff = bJ._1
10611063                         let ci = valueOrErrorMessage(indexOf(ff, am), "You haven't passed all the lands needed")
10621064                         let fg = (take(ff, ci) + drop(ff, (ci + 1)))
10631065                         let en = cm(am)
10641066                         let fh = (bJ._2 + valueOrElse(getInteger(aG(M, aQ)), if (valueOrElse(getBoolean(aE(aQ)), false))
10651067                             then en
10661068                             else 0))
10671069                         let de = valueOrElse(getInteger(aB(aQ)), 0)
10681070                         let fi = {
10691071                             let c = am
10701072                             if (("S" == c))
10711073                                 then 3
10721074                                 else if (("M" == c))
10731075                                     then 4
10741076                                     else if (("L" == c))
10751077                                         then 5
10761078                                         else if (("XL" == c))
10771079                                             then 6
10781080                                             else throw("Only S, M, L, XL can merge")
10791081                             }
10801082                         if ((de != fi))
10811083                             then throw("All lands should be maxed to merge")
10821084                             else {
10831085                                 let ak = eC[aY]
10841086                                 let ce = ck(eC[ba])
10851087                                 let ct = (lastBlock.timestamp - eA)
10861088                                 if ((0 > ct))
10871089                                     then throw(((("Saved timestamp is in future, saved = " + toString(eA)) + ", current = ") + toString(lastBlock.timestamp)))
10881090                                     else {
10891091                                         let eF = em(aQ, en)
10901092                                         let dd = (en / m)
10911093                                         let eL = cr(split(bJ._4, "_"), ce, ct, dd, eF)
10921094                                         let bT = cc(split(bJ._6, "_"), ce, dd, -1)
10931095                                         let fj = bJ._7
10941096                                         let ac = indexOf(fj, aQ)
10951097                                         if (!(isDefined(ac)))
10961098                                             then throw(("Your staked lands don't contain " + aQ))
10971099                                             else {
10981100                                                 let fk = ap(aQ)
10991101                                                 let fl = valueOrElse(getString(fk), "")
11001102                                                 $Tuple7(fg, fh, dV, eL, ((((((((((((((bJ._5 :+ DeleteEntry(aA(aQ))) :+ DeleteEntry(aK(i, aQ, ah))) :+ DeleteEntry(aj(ak))) :+ DeleteEntry(al(ak, am))) :+ DeleteEntry(an(aQ))) :+ DeleteEntry(aB(aQ))) :+ DeleteEntry(aC(aQ, ah))) :+ DeleteEntry(aG(M, aQ))) :+ DeleteEntry(aI(M, aQ, ah))) :+ DeleteEntry(aM(ak))) :+ DeleteEntry(aP(aQ))) :+ DeleteEntry(fk)) :+ DeleteEntry(as(fl))) :+ Burn(fromBase58String(aQ), 1)), bT, removeByIndex(fj, value(ac)))
11011103                                                 }
11021104                                         }
11031105                                 }
11041106                         }
11051107                 }
11061108         }
11071109 
11081110     let cW = aN(aO)
11091111     let dn = cV(cW)
11101112     let fm = valueOrElse(getString(aT()), "0_0_0_0_0_0")
11111113     let fn = aU(ah)
11121114     let fo = getString(fn)
11131115     let fp = if (isDefined(fo))
11141116         then split_51C(value(fo), "_")
11151117         else nil
11161118     let bU = {
11171119         let bL = fc
11181120         let bM = size(bL)
11191121         let bN = $Tuple7(fb, 0, "", dn[bg], nil, fm, fp)
11201122         func bO (bP,bQ) =         if ((bQ >= bM))
11211123             then bP
11221124             else fe(bP, bL[bQ])
11231125 
11241126         func bR (bP,bQ) =         if ((bQ >= bM))
11251127             then bP
11261128             else throw("List size exceeds 5")
11271129 
11281130         bR(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5)
11291131         }
11301132     let dV = bU._3
11311133     let cR = valueOrErrorMessage(indexOf(L, dV), ("Unknown continent: " + dV))
11321134     let cl = cP(cI(toBigInt(dS)), cR)
11331135     let dU = valueOrElse(getInteger(ai()), (N + 1))
11341136     let fq = toString(dU)
11351137     let dW = Issue(al(fq, fa), makeString([fq, fa, cl, dV], "_"), 1, 0, false)
11361138     let ao = calculateAssetId(dW)
11371139     let fr = toBase58String(ao)
11381140     let ek = makeString(bV((fd > 0), split(dn[bh], "_"), fd), "_")
11391141     $Tuple2(((((((((((((((bU._5 :+ (if ((size(bU._7) > 0))
11401142         then StringEntry(fn, makeString_11C(bU._7, "_"))
11411143         else DeleteEntry(fn))) :+ IntegerEntry(ai(), (dU + 1))) :+ dW) :+ StringEntry(aj(fq), fr)) :+ StringEntry(an(fr), ah)) :+ StringEntry(aM(fq), ah)) :+ IntegerEntry(aG(M, fr), bU._2)) :+ IntegerEntry(aI(M, fr, ah), bU._2)) :+ IntegerEntry(aB(fr), eR)) :+ IntegerEntry(aC(fr, ah), eR)) :+ StringEntry(cW, makeString([dn[bf], bU._4, ek, dn[bi]], ":"))) :+ StringEntry(aT(), bU._6)) :+ StringEntry(aR(aO), makeString([dV, "L", fr], "_"))) :+ ScriptTransfer(addressFromStringValue(ah), 1, ao)), fr)
11421144     }
11431145 
11441146 
11451147 func fs (ah,fc,dS) = eZ("M", 3, "SSSS", ah, fc, dS, 0)
11461148 
11471149 
11481150 func ft (ah,fc,dS,bW,eO) = {
11491151     let eS = (z * 4)
11501152     if (if (!(bW))
11511153         then (eO != eS)
11521154         else false)
11531155         then throw(("Payment attached should be " + toString(eS)))
11541156         else eZ("L", 4, "SMM", ah, fc, dS, (y * 4))
11551157     }
11561158 
11571159 
11581160 func fu (ah,fc,dS,bW,eO) = {
11591161     let eS = (z * 47)
11601162     if (if (!(bW))
11611163         then (eO != eS)
11621164         else false)
11631165         then throw(("Payment attached should be " + toString(eS)))
11641166         else eZ("XL", 5, "SSSML", ah, fc, dS, (y * 47))
11651167     }
11661168 
11671169 
11681170 func fv (ah,fc,dS,bW,eO) = {
11691171     let eS = (z * 54)
11701172     if (if (!(bW))
11711173         then (eO != eS)
11721174         else false)
11731175         then throw(("Payment attached should be " + toString(eS)))
11741176         else eZ("XXL", 6, "LXL", ah, fc, dS, (y * 54))
11751177     }
11761178 
11771179 
11781180 func fw (bW,ah,eO,fc,dS) = {
11791181     let fx = {
11801182         let c = size(fc)
11811183         if ((4 == c))
11821184             then fs(ah, fc, dS)
11831185             else if ((3 == c))
11841186                 then ft(ah, fc, dS, bW, eO)
11851187                 else if ((5 == c))
11861188                     then fu(ah, fc, dS, bW, eO)
11871189                     else if ((2 == c))
11881190                         then fv(ah, fc, dS, bW, eO)
11891191                         else throw("Unknown merge")
11901192         }
11911193     fx
11921194     }
11931195 
11941196 
11951197 func fy (ci) = if (if ((ci.originCaller != ad))
11961198     then valueOrElse(getBoolean(aV()), false)
11971199     else false)
11981200     then throw("Contracts are under maintenance")
11991201     else StringEntry(ag(toString(ci.originCaller)), toBase58String(ci.transactionId))
12001202 
12011203 
12021204 @Callable(ci)
12031205 func constructorV1 (fz) = if ((ci.caller != this))
12041206     then throw("Permission denied")
12051207     else [StringEntry(X(), fz)]
12061208 
12071209 
12081210 
12091211 @Callable(ci)
12101212 func setBlocked (fA) = if ((ci.caller != this))
12111213     then throw("permission denied")
12121214     else [BooleanEntry(aV(), fA)]
12131215 
12141216 
12151217 
12161218 @Callable(ci)
12171219 func stakeLand () = {
12181220     let fB = fy(ci)
12191221     if ((size(ci.payments) != 1))
12201222         then throw("Exactly one payment required")
12211223         else {
12221224             let fC = value(ci.payments[0])
12231225             let ao = value(fC.assetId)
12241226             let P = toString(ci.caller)
12251227             if ((fC.amount != 1))
12261228                 then throw((("NFT " + i) + " token should be attached as payment"))
12271229                 else {
12281230                     let ey = value(assetInfo(ao))
12291231                     if ((ey.issuer != this))
12301232                         then throw("Unknown issuer of token")
12311233                         else if (!(contains(ey.name, i)))
12321234                             then throw((("Only NFT " + i) + " tokens are accepted"))
12331235                             else {
12341236                                 let fD = drop(ey.name, 4)
12351237                                 let ak = if (contains(fD, "XXL"))
12361238                                     then dropRight(fD, 3)
12371239                                     else if (contains(fD, "XL"))
12381240                                         then dropRight(fD, 2)
12391241                                         else dropRight(fD, 1)
12401242                                 if (!(isDefined(parseInt(ak))))
12411243                                     then throw(("Cannot parse land number from " + ey.name))
12421244                                     else {
12431245                                         let aQ = toBase58String(ao)
12441246                                         let ez = aA(aQ)
12451247                                         if (isDefined(getInteger(ez)))
12461248                                             then throw((("NFT " + ey.name) + " is already staked"))
12471249                                             else {
12481250                                                 let eC = split(ey.description, "_")
12491251                                                 let ce = ck(eC[ba])
12501252                                                 let en = cm(eC[aZ])
12511253                                                 let bT = cj(ce, (en / m), 1)
12521254                                                 let eo = valueOrElse(getInteger(aG(M, aQ)), if (valueOrElse(getBoolean(aE(aQ)), false))
12531255                                                     then en
12541256                                                     else 0)
12551257                                                 let fo = getString(aU(P))
12561258                                                 let fj = if (isDefined(fo))
12571259                                                     then split_51C(value(fo), "_")
12581260                                                     else nil
12591261                                                 if (containsElement(fj, aQ))
12601262                                                     then throw(("Your staked lands already contain " + aQ))
12611263                                                     else [IntegerEntry(ez, lastBlock.timestamp), IntegerEntry(aK(i, aQ, P), lastBlock.timestamp), StringEntry(aU(P), makeString_11C((fj :+ aQ), "_")), StringEntry(an(aQ), P), StringEntry(aM(ak), P), IntegerEntry(aI(M, aQ, P), eo), StringEntry(aT(), bT), fB]
12621264                                                 }
12631265                                         }
12641266                                 }
12651267                     }
12661268             }
12671269     }
12681270 
12691271 
12701272 
12711273 @Callable(ci)
12721274 func unstakeLand (et) = {
12731275     let fB = fy(ci)
12741276     if ((size(ci.payments) != 0))
12751277         then throw("No payments required")
12761278         else {
12771279             let ah = toString(ci.caller)
12781280             let eE = er(ah, bp, et)
12791281             let aQ = eE._2
12801282             let fn = aU(ah)
12811283             let ce = ck(eE._3[ba])
12821284             let en = cm(eE._3[aZ])
12831285             let bT = cj(ce, (en / m), -1)
12841286             let eT = eM(ah, aQ, en, bp)
12851287             let fj = split_51C(valueOrElse(getString(fn), ""), "_")
12861288             let ac = indexOf(fj, aQ)
12871289             if (!(isDefined(ac)))
12881290                 then throw(("Your staked lands don't contain " + aQ))
12891291                 else {
12901292                     let cU = value(blockInfoByHeight(height)).timestamp
12911293                     let fE = valueOrElse(getInteger(af, aW(ah)), 0)
12921294                     if ((fE >= cU))
12931295                         then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(fE)))
12941296                         else [ScriptTransfer(ci.caller, 1, fromBase58String(aQ)), DeleteEntry(aA(aQ)), DeleteEntry(aK(i, aQ, ah)), StringEntry(aT(), bT), StringEntry(eT._2, makeString(eT._3, ":")), if ((size(fj) > 1))
12951297                             then StringEntry(fn, makeString_11C(removeByIndex(fj, value(ac)), "_"))
12961298                             else DeleteEntry(fn), fB]
12971299                     }
12981300             }
12991301     }
13001302 
13011303 
13021304 
13031305 @Callable(ci)
13041306 func stakeDuck () = {
13051307     let fB = fy(ci)
13061308     if ((size(ci.payments) != 1))
13071309         then throw("Exactly one payment required")
13081310         else {
13091311             let fC = value(ci.payments[0])
13101312             let ao = value(fC.assetId)
13111313             let P = toString(ci.caller)
13121314             if ((fC.amount != 1))
13131315                 then throw((("NFT " + j) + " token should be attached as payment"))
13141316                 else {
13151317                     let ey = value(assetInfo(ao))
13161318                     if (if ((ey.issuer != d))
13171319                         then (ey.issuer != e)
13181320                         else false)
13191321                         then throw((("Unknown issuer of " + j) + " token"))
13201322                         else if (!(contains(ey.name, j)))
13211323                             then throw((("Only NFT " + j) + " tokens are accepted"))
13221324                             else {
13231325                                 let fF = toBase58String(ao)
13241326                                 let ez = aA(fF)
13251327                                 if (isDefined(getInteger(ez)))
13261328                                     then throw((("NFT " + ey.name) + " is already staked"))
13271329                                     else if (isDefined(getString(aJ(P))))
13281330                                         then throw(("You already staked one duck: " + ey.name))
13291331                                         else {
13301332                                             let fG = aR(fF)
13311333                                             let fH = getString(fG)
13321334                                             let cW = aN(fF)
13331335                                             let fI = getString(cW)
13341336                                             ([IntegerEntry(ez, lastBlock.timestamp), IntegerEntry(aK(j, toBase58String(ao), P), lastBlock.timestamp), StringEntry(az(fF), P), StringEntry(aJ(P), fF)] ++ (if (isDefined(fH))
13351337                                                 then nil
13361338                                                 else ([StringEntry(fG, k)] ++ (if (isDefined(fI))
13371339                                                     then nil
13381340                                                     else (([StringEntry(cW, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(aS(fF), 100)) :+ fB)))))
13391341                                             }
13401342                                 }
13411343                     }
13421344             }
13431345     }
13441346 
13451347 
13461348 
13471349 @Callable(ci)
13481350 func unstakeDuck (fF) = {
13491351     let fB = fy(ci)
13501352     if ((size(ci.payments) != 0))
13511353         then throw("No payments required")
13521354         else {
13531355             let ao = fromBase58String(fF)
13541356             let P = toString(ci.caller)
13551357             let ey = value(assetInfo(ao))
13561358             let ez = aA(toBase58String(ao))
13571359             if (!(isDefined(getInteger(ez))))
13581360                 then throw((("NFT " + ey.name) + " is not staked"))
13591361                 else if (!(isDefined(getString(aJ(P)))))
13601362                     then throw((("The duck " + ey.name) + " is not staked"))
13611363                     else {
13621364                         let eB = valueOrErrorMessage(getString(az(toBase58String(ao))), (("NFT " + ey.name) + " is orphaned"))
13631365                         if ((eB != P))
13641366                             then throw("Staked NFT is not yours")
13651367                             else {
13661368                                 let eh = aS(fF)
13671369                                 let fJ = valueOrElse(getInteger(eh), 100)
13681370                                 if ((100 > fJ))
13691371                                     then throw("Please heal your duck before unstaking")
13701372                                     else [ScriptTransfer(ci.caller, 1, ao), DeleteEntry(ez), DeleteEntry(eh), DeleteEntry(aR(fF)), DeleteEntry(az(fF)), DeleteEntry(aK(j, fF, P)), DeleteEntry(aJ(P)), fB]
13711373                                 }
13721374                         }
13731375             }
13741376     }
13751377 
13761378 
13771379 
13781380 @Callable(ci)
13791381 func claimRes (cp,fK) = {
13801382     let fB = fy(ci)
13811383     if ((size(ci.payments) != 0))
13821384         then throw("No payments required")
13831385         else {
13841386             let ah = toString(ci.originCaller)
13851387             let cb = eD(ah, cp, bp, fK)
13861388             $Tuple2((((cb._1 :+ StringEntry(cb._2, makeString(cb._3, ":"))) :+ StringEntry(cb._4, makeString(cb._5, ":"))) :+ fB), cb._3[bg])
13871389             }
13881390     }
13891391 
13901392 
13911393 
13921394 @Callable(ci)
13931395 func claimResToWH (cp,fK) = {
13941396     let fB = fy(ci)
13951397     if ((size(ci.payments) != 0))
13961398         then throw("No payments required")
13971399         else {
13981400             let ah = toString(ci.originCaller)
13991401             let cb = eD(ah, cp, bo, fK)
14001402             $Tuple2((((cb._1 :+ StringEntry(cb._2, makeString(cb._3, ":"))) :+ StringEntry(cb._4, makeString(cb._5, ":"))) :+ fB), cb._5[bk])
14011403             }
14021404     }
14031405 
14041406 
14051407 
14061408 @Callable(ci)
14071409 func flight (dZ,ea) = {
14081410     let fB = fy(ci)
14091411     if (!(sigVerify_8Kb(dZ, ea, g)))
14101412         then throw("signature does not match")
14111413         else if ((size(ci.payments) != 0))
14121414             then throw("No payments required")
14131415             else {
14141416                 let da = split(toUtf8String(dZ), ";")
14151417                 let fL = split(da[0], "|")
14161418                 let eb = split(fL[br], "_")
14171419                 let ec = parseIntValue(eb[0])
14181420                 let ed = parseIntValue(eb[1])
14191421                 let fM = split(da[1], ":")
14201422                 let fN = fM[0]
14211423                 let eg = parseIntValue(fL[bw])
14221424                 if (if ((eg > (lastBlock.timestamp + t)))
14231425                     then true
14241426                     else ((lastBlock.timestamp - t) > eg))
14251427                     then throw("signature outdated")
14261428                     else {
14271429                         let fO = fM[1]
14281430                         let fP = valueOrElse(getString(ag(toString(ci.originCaller))), "")
14291431                         if ((fP != fO))
14301432                             then throw(((("Tx ids don't match! In state: " + fP) + ", in msg: ") + fO))
14311433                             else {
14321434                                 let aX = toString(ci.caller)
14331435                                 let aO = valueOrErrorMessage(getString(aJ(aX)), "You don't have a duck staked")
14341436                                 let eh = aS(aO)
14351437                                 let ei = valueOrElse(getInteger(eh), 100)
14361438                                 if ((ei != ec))
14371439                                     then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eh), 100))) + " from state does not match one from flight log=") + toString(ec)))
14381440                                     else if ((0 >= ec))
14391441                                         then throw("You can't fly with zero health")
14401442                                         else {
14411443                                             let fG = aR(aO)
14421444                                             let ev = valueOrElse(getString(fG), k)
14431445                                             if ((fN == ev))
14441446                                                 then throw("You can't fly to the same location")
14451447                                                 else {
14461448                                                     let fQ = if ((size(fL) > bx))
14471449                                                         then fL[bx]
14481450                                                         else ""
14491451                                                     let fR = if (if ((ed > 0))
14501452                                                         then (fQ == "$")
14511453                                                         else false)
14521454                                                         then bB(invoke(ad, "sendUsdtPrize", [aX], nil))
14531455                                                         else 0
14541456                                                     $Tuple2([StringEntry(fG, if ((ed > 0))
14551457                                                         then fN
14561458                                                         else ev), IntegerEntry(eh, ed), fB], fR)
14571459                                                     }
14581460                                             }
14591461                                 }
14601462                         }
14611463                 }
14621464     }
14631465 
14641466 
14651467 
14661468 @Callable(ci)
14671469 func setHealth (fJ,aO) = {
14681470     let fB = fy(ci)
14691471     if (if ((0 > fJ))
14701472         then true
14711473         else (fJ > 100))
14721474         then throw("HP should be within 0..100")
14731475         else [IntegerEntry(aS(aO), fJ), fB]
14741476     }
14751477 
14761478 
14771479 
14781480 @Callable(ci)
14791481 func heal (fS,cp) = {
14801482     let fB = fy(ci)
14811483     if (if ((0 > fS))
14821484         then true
14831485         else (fS >= l))
14841486         then throw(("Unknown material: " + toString(fS)))
14851487         else if ((0 >= cp))
14861488             then throw(("Amount should be positive! " + toString(cp)))
14871489             else {
14881490                 let aO = valueOrErrorMessage(getString(aJ(toString(ci.caller))), "You don't have a duck staked")
14891491                 let eh = aS(aO)
14901492                 let fT = valueOrElse(getInteger(eh), 100)
14911493                 if ((fT >= 100))
14921494                     then throw("HP should be < 100 to heal")
14931495                     else {
14941496                         let cW = aN(aO)
14951497                         let dn = cV(cW)
14961498                         let ej = split(dn[bh], "_")
14971499                         let fU = parseIntValue(ej[fS])
14981500                         let fV = min([(cp / h), (100 - fT)])
14991501                         let fW = (fV * h)
15001502                         if ((fW > fU))
15011503                             then throw(((((("You need " + toString(fW)) + " of ") + K[fS]) + " to heal, but you backpack contains ") + toString(fU)))
15021504                             else {
15031505                                 let ek = cn(ej, fS, fW)
15041506 [IntegerEntry(eh, (fT + fV)), StringEntry(cW, makeString([dn[bf], dn[bg], ek, dn[bi]], ":")), fB]
15051507                                 }
15061508                         }
15071509                 }
15081510     }
15091511 
15101512 
15111513 
15121514 @Callable(ci)
15131515 func updateBackpack (aO,fX) = {
15141516     let fB = fy(ci)
15151517     if ((ci.caller != ae))
15161518         then throw("permission denied")
15171519         else $Tuple2([StringEntry(aN(aO), fX), fB], fX)
15181520     }
15191521 
15201522 
15211523 
15221524 @Callable(ci)
15231525 func buySLand () = {
15241526     let fB = fy(ci)
15251527     if ((size(ci.payments) != 1))
15261528         then throw("Exactly one payment required")
15271529         else {
15281530             let fC = value(ci.payments[0])
15291531             if ((fC.assetId != b))
15301532                 then throw("Allowed USDT payment only!")
15311533                 else if ((fC.amount != B))
15321534                     then throw(("Payment attached should be " + toString(B)))
15331535                     else {
15341536                         let cb = dQ(ci.caller, ci.transactionId)
15351537                         $Tuple2(((cb._1 :+ ScriptTransfer(ae, fC.amount, b)) :+ fB), cb._2._1)
15361538                         }
15371539             }
15381540     }
15391541 
15401542 
15411543 
15421544 @Callable(ci)
15431545 func expedition (dZ,ea) = {
15441546     let fB = fy(ci)
15451547     if ((size(ci.payments) != 0))
15461548         then throw("No payments required")
15471549         else {
15481550             let cb = dY(true, ci.caller, ci.transactionId, dZ, ea)
15491551             $Tuple2((cb._1 :+ fB), cb._2)
15501552             }
15511553     }
15521554 
15531555 
15541556 
15551557 @Callable(ci)
15561558 func upgradeInfra (aQ) = {
15571559     let fB = fy(ci)
15581560     if ((size(ci.payments) != 0))
15591561         then throw("No payments required")
15601562         else {
15611563             let cb = eN(true, ci.caller, 0, aQ)
15621564             $Tuple2((cb._1 :+ fB), cb._2)
15631565             }
15641566     }
15651567 
15661568 
15671569 
15681570 @Callable(ci)
15691571 func upgradeInfraUsdt (aQ) = if ((ci.caller != this))
15701572     then throw("Permission denied")
15711573     else {
15721574         let fB = fy(ci)
15731575         if ((size(ci.payments) != 1))
15741576             then throw("Exactly one payment required")
15751577             else {
15761578                 let fC = value(ci.payments[0])
15771579                 if ((fC.assetId != b))
15781580                     then throw("Allowed USDT payment only!")
15791581                     else {
15801582                         let cb = eN(false, ci.caller, fC.amount, aQ)
15811583                         $Tuple2(((cb._1 :+ ScriptTransfer(ae, fC.amount, b)) :+ fB), cb._2)
15821584                         }
15831585                 }
15841586         }
15851587 
15861588 
15871589 
15881590 @Callable(ci)
15891591 func activateArtifact (fY,aQ) = {
15901592     let fB = fy(ci)
15911593     if ((size(ci.payments) != 0))
15921594         then throw("No payments required")
15931595         else {
15941596             let cb = {
15951597                 let c = fY
15961598                 if (("PRESALE" == c))
15971599                     then eX(toString(ci.caller), aQ)
15981600                     else throw("Unknown artifact")
15991601                 }
16001602             (cb :+ fB)
16011603             }
16021604     }
16031605 
16041606 
16051607 
16061608 @Callable(ci)
16071609 func mergeLands (fc) = {
16081610     let fB = fy(ci)
16091611     if ((size(ci.payments) != 0))
16101612         then throw("No payments required")
16111613         else {
16121614             let cb = fw(true, toString(ci.caller), 0, fc, ci.transactionId)
16131615             $Tuple2((cb._1 :+ fB), cb._2)
16141616             }
16151617     }
16161618 
16171619 
16181620 
16191621 @Callable(ci)
16201622 func mergeLandsUsdt (fc) = {
16211623     let fB = fy(ci)
16221624     if ((size(ci.payments) != 1))
16231625         then throw("Exactly one payment required")
16241626         else {
16251627             let fC = value(ci.payments[0])
16261628             if ((fC.assetId != b))
16271629                 then throw("Allowed USDT payment only!")
16281630                 else {
16291631                     let cb = fw(false, toString(ci.caller), fC.amount, fc, ci.transactionId)
16301632                     $Tuple2(((cb._1 :+ ScriptTransfer(ae, fC.amount, b)) :+ fB), cb._2)
16311633                     }
16321634             }
16331635     }
16341636 
16351637 
16361638 
16371639 @Callable(ci)
16381640 func cargoExchange (fZ,aQ) = {
16391641     let fB = fy(ci)
16401642     if ((size(ci.payments) != 0))
16411643         then throw("No payments required")
16421644         else {
16431645             let dm = split_4C(fZ, ":")
16441646             let ah = toString(ci.originCaller)
16451647             let ey = value(assetInfo(fromBase58String(aQ)))
16461648             let ez = aA(aQ)
16471649             if (!(isDefined(getInteger(ez))))
16481650                 then throw((ey.name + " is not staked"))
16491651                 else {
16501652                     let eB = valueOrErrorMessage(getString(an(aQ)), (("NFT " + ey.name) + " is orphaned"))
16511653                     if ((eB != ah))
16521654                         then throw((i + " is not yours"))
16531655                         else {
16541656                             let dd = (cm(split(ey.description, "_")[aZ]) / m)
16551657                             let de = valueOrElse(getInteger(aB(aQ)), 0)
16561658                             let aO = valueOrErrorMessage(getString(aJ(ah)), "You don't have a duck staked")
16571659                             let ev = valueOrElse(getString(aR(aO)), k)
16581660                             let ew = split(value(ev), "_")
16591661                             if ((ew[bd] != "L"))
16601662                                 then throw((("Duck location type is " + ew[bd]) + ", but should be L"))
16611663                                 else if ((ew[be] != aQ))
16621664                                     then throw(("Duck should be on the land " + aQ))
16631665                                     else {
16641666                                         let dc = aP(aQ)
16651667                                         let dg = db(dc, dd, de)
16661668                                         let cW = aN(aO)
16671669                                         let dn = cV(cW)
16681670                                         let cb = dl(dm, dg, dn)
16691671 [StringEntry(cW, makeString([dn[bf], cb._4, cb._5, cb._6], ":")), StringEntry(dc, makeString([dg[bj], cb._1, cb._2, cb._3, dg[bn]], ":")), fB]
16701672                                         }
16711673                             }
16721674                     }
16731675             }
16741676     }
16751677 
16761678 
16771679 
16781680 @Callable(ci)
16791681 func saveWarehouse (ga,aQ) = {
16801682     let fB = fy(ci)
16811683     if ((ci.caller != ae))
16821684         then throw("Access denied")
16831685         else {
16841686             let dc = aP(aQ)
16851687             if ((size(split_4C(ga, ":")) != 5))
16861688                 then throw("warehouse string should contain 4 ':' separators")
16871689                 else $Tuple2([StringEntry(dc, ga), fB], ga)
16881690             }
16891691     }
16901692 
16911693 
16921694 
16931695 @Callable(ci)
16941696 func replaceBooleanArtifact (aQ) = if ((ci.caller != ad))
16951697     then throw("Access denied")
16961698     else {
16971699         let gb = aE(aQ)
16981700         let gc = aG(M, aQ)
16991701         let gd = getBoolean(gb)
17001702         if (isDefined(gd))
17011703             then {
17021704                 let eC = split(value(assetInfo(fromBase58String(aQ))).description, "_")
17031705                 let en = cm(eC[aZ])
17041706                 let eo = valueOrElse(getInteger(gc), en)
17051707                 let eB = getString(an(aQ))
17061708                 let ge = if (isDefined(eB))
17071709                     then [IntegerEntry(aI(M, aQ, value(eB)), eo), DeleteEntry(aF(aQ, value(eB)))]
17081710                     else nil
17091711                 if (value(gd))
17101712                     then $Tuple2(((ge :+ IntegerEntry(gc, eo)) :+ DeleteEntry(gb)), 2)
17111713                     else $Tuple2([DeleteEntry(gb)], 1)
17121714                 }
17131715             else $Tuple2(nil, 0)
17141716         }
17151717 
17161718 
17171719 
17181720 @Callable(ci)
17191721 func setCustomName (ao,fl,aH) = {
17201722     let fB = fy(ci)
17211723     if ((size(ci.payments) != 1))
17221724         then throw("Exactly one payment required")
17231725         else {
17241726             let fC = value(ci.payments[0])
17251727             if ((fC.assetId != b))
17261728                 then throw("Allowed USDT payment only!")
17271729                 else if ((fC.amount != w))
17281730                     then throw(("Payment should be " + toString(w)))
17291731                     else if (contains(fl, "__"))
17301732                         then throw(("Name should not contain '__': " + fl))
17311733                         else if ((size(fl) > x))
17321734                             then throw(("Name too long, maxLength=" + toString(x)))
17331735                             else {
17341736                                 let ah = toString(ci.originCaller)
17351737                                 let gf = {
17361738                                     let c = aH
17371739                                     if (("ACCOUNT" == c))
17381740                                         then {
17391741                                             let gg = av(fl)
17401742                                             let gh = getString(gg)
17411743                                             if (isDefined(gh))
17421744                                                 then throw(("Name already registered: " + fl))
17431745                                                 else [StringEntry(ar(ah), fl), StringEntry(gg, ah)]
17441746                                             }
17451747                                         else if (("LAND" == c))
17461748                                             then {
17471749                                                 let ey = value(assetInfo(fromBase58String(ao)))
17481750                                                 let ez = aA(ao)
17491751                                                 if (!(isDefined(getInteger(ez))))
17501752                                                     then throw((ey.name + " is not staked"))
17511753                                                     else {
17521754                                                         let eB = valueOrErrorMessage(getString(an(ao)), (("NFT " + ey.name) + " is orphaned"))
17531755                                                         if ((eB != ah))
17541756                                                             then throw((i + " is not yours"))
17551757                                                             else {
17561758                                                                 let gg = as(fl)
17571759                                                                 let gh = getString(gg)
17581760                                                                 if (isDefined(gh))
17591761                                                                     then throw(("Name already registered: " + fl))
17601762                                                                     else [StringEntry(ap(ao), fl), StringEntry(gg, ao)]
17611763                                                                 }
17621764                                                         }
17631765                                                 }
17641766                                             else if (("DUCK" == c))
17651767                                                 then {
17661768                                                     let ey = value(assetInfo(fromBase58String(ao)))
17671769                                                     let ez = aA(ao)
17681770                                                     if (if (!(isDefined(getInteger(ez))))
17691771                                                         then true
17701772                                                         else !(isDefined(getString(aJ(ah)))))
17711773                                                         then throw((ey.name + " is not staked"))
17721774                                                         else {
17731775                                                             let eB = valueOrErrorMessage(getString(az(ao)), (("NFT " + ey.name) + " is orphaned"))
17741776                                                             if ((eB != ah))
17751777                                                                 then throw((j + " is not yours"))
17761778                                                                 else {
17771779                                                                     let gg = au(fl)
17781780                                                                     let gh = getString(gg)
17791781                                                                     if (isDefined(gh))
17801782                                                                         then throw(("Name already registered: " + fl))
17811783                                                                         else [StringEntry(aq(ao), fl), StringEntry(gg, ao)]
17821784                                                                     }
17831785                                                             }
17841786                                                     }
17851787                                                 else throw("Unknown entity type")
17861788                                     }
17871789                                 $Tuple2(((gf :+ ScriptTransfer(ae, fC.amount, b)) :+ fB), 0)
17881790                                 }
17891791             }
17901792     }
17911793 
17921794 
17931795 
17941796 @Callable(ci)
17951797 func setReferrals (gi,gj) = if ((ci.callerPublicKey != g))
17961798     then throw("Permission denied")
17971799     else {
17981800         let fB = fy(ci)
17991801         if ((size(ci.payments) != 0))
18001802             then throw("No payments required")
18011803             else if (!(isDefined(addressFromString(gi))))
18021804                 then throw(("Invalid address: " + gi))
18031805                 else if (!(isDefined(addressFromString(gj))))
18041806                     then throw(("Invalid address: " + gj))
18051807                     else {
18061808                         let gk = ay()
18071809                         let gl = getString(gk)
18081810                         let gm = if (isDefined(gl))
18091811                             then split_4C(value(gl), "_")
18101812                             else nil
18111813                         if (containsElement(gm, gj))
18121814                             then throw((gj + " is not newbie (already has referrals)"))
18131815                             else {
18141816                                 let gn = aw(gj)
18151817                                 let go = getString(gn)
18161818                                 if (if (isDefined(go))
18171819                                     then isDefined(addressFromString(value(go)))
18181820                                     else false)
18191821                                     then throw(((gj + " already has refBy: ") + value(go)))
18201822                                     else {
18211823                                         let gp = ax(gi)
18221824                                         let gq = getString(gp)
18231825                                         let gr = if (isDefined(gq))
18241826                                             then split_4C(value(gq), "_")
18251827                                             else nil
18261828                                         if (containsElement(gr, gj))
18271829                                             then throw((((gi + " already contains ") + gj) + " within referrals"))
18281830                                             else {
18291831                                                 let gs = makeString_2C((gr :+ gj), "_")
18301832                                                 let gt = makeString_2C((gm :+ gi), "_")
18311833                                                 $Tuple2([StringEntry(gn, gi), StringEntry(gp, gs), StringEntry(gk, gt), fB], 0)
18321834                                                 }
18331835                                         }
18341836                                 }
18351837                         }
18361838         }
18371839 
18381840 
18391841 
18401842 @Callable(ci)
18411843 func splitByGlobalWeightsREADONLY (cp) = $Tuple2(nil, bS(cp))
18421844 
18431845 
18441846 
18451847 @Callable(ci)
18461848 func splitByGlobalAndLocalWeightsREADONLY (gu,gv,cl) = {
18471849     let ce = ck(cl)
18481850     $Tuple2(nil, $Tuple2(bS(gu), bD(gv, ce)))
18491851     }
18501852 
18511853 
18521854 
18531855 @Callable(ci)
18541856 func getBackpackREADONLY (aO) = $Tuple2(nil, makeString(cV(aN(aO)), ":"))
18551857 
18561858 
18571859 
18581860 @Callable(ci)
18591861 func getWarehouseREADONLY (aQ) = {
18601862     let ey = value(assetInfo(fromBase58String(aQ)))
18611863     let dd = (cm(split(ey.description, "_")[aZ]) / m)
18621864     let de = valueOrElse(getInteger(aB(aQ)), 0)
18631865     $Tuple2(nil, makeString_2C(db(aP(aQ), dd, de), ":"))
18641866     }
18651867 
18661868 
github/deemru/w8io/169f3d6 
215.50 ms ◑