tx · 9Sd9fKnJy22Q6qdjKALnRW5DMrLQZSXSp1rnJeVj6gbc

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.03100000 Waves

2023.01.17 20:14 [2409217] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9Sd9fKnJy22Q6qdjKALnRW5DMrLQZSXSp1rnJeVj6gbc",
    "fee": 3100000,
    "feeAssetId": null,
    "timestamp": 1673975636583,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "4MPJtBVZwCbQRNZ7XmGUFFFVYaNrBJWaAX6URKTrJaBB94odb3ZBMTxvwUi9bbmKkkmmrhX4iuYeQRtf8n6CH5LY"
    ],
    "script": "base64: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",
    "height": 2409217,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 5hYXzNHpujRezK3uX59EtuPTNcfmz1g94C1gPvpVR763
Next: DyWv9okH8JzzgEuc4VAD3dNV7aD4sqx7VfhGq9mXN3C3

Diff: 

OldNewDifferences
10131013 
10141014 
10151015 @Callable(i)
1016-func mergeLands (landAssetIds) = if ((size(i.payments) != 0))
1017-    then throw("Lands merging doesn't require any payments")
1018-    else mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
1016+func mergeLands (landAssetIds) = if ((i.caller != this))
1017+    then throw("permission denied")
1018+    else if ((size(i.payments) != 0))
1019+        then throw("Lands merging doesn't require any payments")
1020+        else mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
10191021 
10201022 
10211023 
10221024 @Callable(i)
1023-func mergeLandsUsdn (landAssetIds) = if ((size(i.payments) != 1))
1024-    then throw("Exactly one payment required")
1025-    else {
1026-        let pmt = value(i.payments[0])
1027-        if ((pmt.assetId != usdnAssetId))
1028-            then throw("Allowed USDN payment only!")
1029-            else {
1030-                let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
1031-                $Tuple2((result._1 :+ ScriptTransfer(economyAddr, pmt.amount, usdnAssetId)), result._2)
1032-                }
1033-        }
1025+func mergeLandsUsdn (landAssetIds) = if ((i.caller != this))
1026+    then throw("permission denied")
1027+    else if ((size(i.payments) != 1))
1028+        then throw("Exactly one payment required")
1029+        else {
1030+            let pmt = value(i.payments[0])
1031+            if ((pmt.assetId != usdnAssetId))
1032+                then throw("Allowed USDN payment only!")
1033+                else {
1034+                    let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
1035+                    $Tuple2((result._1 :+ ScriptTransfer(economyAddr, pmt.amount, usdnAssetId)), result._2)
1036+                    }
1037+            }
10341038 
10351039 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let chain = toUtf8String(take(drop(this.bytes, 1), 1))
55 
66 let usdnAssetId = match chain {
77     case _ => 
88         if (("W" == $match0))
99             then base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
1010             else if (("T" == $match0))
1111                 then base58'HezsdQuRDtzksAYUy97gfhKy7Z1NW2uXYSHA3bgqenNZ'
1212                 else throw("Unknown chain")
1313 }
1414 
1515 let incubatorAddr = match chain {
1616     case _ => 
1717         if (("W" == $match0))
1818             then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
1919             else if (("T" == $match0))
2020                 then this
2121                 else throw("Unknown chain")
2222 }
2323 
2424 let breederAddr = match chain {
2525     case _ => 
2626         if (("W" == $match0))
2727             then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
2828             else if (("T" == $match0))
2929                 then this
3030                 else throw("Unknown chain")
3131 }
3232 
3333 let economyAddr = match chain {
3434     case _ => 
3535         if (("W" == $match0))
3636             then addressFromStringValue("3P2sk1KncSxRaZs8b4CWGPw2jkvvav74u4D")
3737             else if (("T" == $match0))
3838                 then addressFromStringValue("3N8y4wxX3JC4TdrCJBXX16SjWf6X256hrep")
3939                 else throw("Unknown chain")
4040 }
4141 
4242 let pub = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
4343 
4444 let HEALCOST = 10000
4545 
4646 let LANDPREFIX = "LAND"
4747 
4848 let DUCKPREFIX = "DUCK"
4949 
5050 let DEFAULTLOCATION = "Africa_F_Africa"
5151 
5252 let NUMRES = 6
5353 
5454 let SSIZE = 25
5555 
5656 let MSIZE = 100
5757 
5858 let LSIZE = 225
5959 
6060 let XLSIZE = 400
6161 
6262 let XXLSIZE = 625
6363 
6464 let DAILYRESBYPIECE = 3456000
6565 
6666 let DAYMILLIS = 86400000
6767 
6868 let FIVEMINUTESMILLIS = 300000
6969 
7070 let RESOURCEPRICEMIN = 158549
7171 
7272 let InfraUpgradeCostS = match chain {
7373     case _ => 
7474         if (("W" == $match0))
7575             then 6307198406
7676             else if (("T" == $match0))
7777                 then 63071984
7878                 else throw("Unknown chain")
7979 }
8080 
8181 let InfraUpgradeCostSUsdn = match chain {
8282     case _ => 
8383         if (("W" == $match0))
8484             then 40000000
8585             else if (("T" == $match0))
8686                 then 400000
8787                 else throw("Unknown chain")
8888 }
8989 
9090 let EXPMATERIALS = match chain {
9191     case _ => 
9292         if (("W" == $match0))
9393             then 157679960139
9494             else if (("T" == $match0))
9595                 then 1576799601
9696                 else throw("Unknown chain")
9797 }
9898 
9999 let EXPUSDN = match chain {
100100     case _ => 
101101         if (("W" == $match0))
102102             then 1000000000
103103             else if (("T" == $match0))
104104                 then 10000000
105105                 else throw("Unknown chain")
106106 }
107107 
108108 let MULT6 = 1000000
109109 
110110 let FIVEX = toBigInt(5)
111111 
112112 let TWENTYX = toBigInt(20)
113113 
114114 let TWENTY2X = toBigInt((20 * 20))
115115 
116116 let TWENTY3X = toBigInt(((20 * 20) * 20))
117117 
118118 let TWENTY4X = toBigInt((((20 * 20) * 20) * 20))
119119 
120120 let TWENTY5X = toBigInt(((((20 * 20) * 20) * 20) * 20))
121121 
122122 let matTypes = ["Fuel", "Metal", "Plank", "Glass", "Plastic", "Protein"]
123123 
124124 let continents = ["Asia", "Europe", "Americas", "Oceania", "Africa"]
125125 
126126 let ARTPRESALE = "PRESALE"
127127 
128128 let PRESALENUMLANDS = 500
129129 
130130 func keyNextFreeLandNum () = "nextLandNum"
131131 
132132 
133133 func keyLandToAssetId (landNum) = ("landToAsset_" + landNum)
134134 
135135 
136136 func keyNftName (landNum,landSize) = ((LANDPREFIX + landNum) + landSize)
137137 
138138 
139139 func keyLandAssetIdToOwner (assetId) = ("nftOwner_" + assetId)
140140 
141141 
142142 func keyDuckIdToOwner (assetId) = ("duckOwner_" + assetId)
143143 
144144 
145145 func keyStakedTimeByAssetId (assetId) = ("stakedTime_" + assetId)
146146 
147147 
148148 func keyInfraLevelByAssetId (assetId) = ("infraLevel_" + assetId)
149149 
150150 
151151 func keyInfraLevelByAssetIdAndOwner (assetId,ownerAddr) = ((("infraLevelByAssetIdAndOwner_" + assetId) + "_") + ownerAddr)
152152 
153153 
154154 func keyPresaleArtActivatedByAssetId (assetId) = ("presaleArtActivated_" + assetId)
155155 
156156 
157157 func keyPresaleArtActivatedByAssetIdAndOwner (assetId,ownerAddr) = ((("presaleArtActivatedByAssetIdAndOwner_" + assetId) + "_") + ownerAddr)
158158 
159159 
160160 func keyLandArtStatusByTypeAndAssetId (type,assetId) = makeString(["landArtStatus", type, assetId], "_")
161161 
162162 
163163 func keyLandArtStatusByTypeAssetIdAndOwner (type,assetId,ownerAddr) = makeString(["landArtStatusByTypeAssetIdAndOwner", type, assetId, ownerAddr], "_")
164164 
165165 
166166 func keyStakedDuckByOwner (ownerAddr) = ("stakedDuckByOwner_" + ownerAddr)
167167 
168168 
169169 func keyStakedTimeByTypeAssetIdAndOwner (nftType,assetId,ownerAddr) = ((((("stakedTimeByTypeAssetIdAndOwner_" + nftType) + "_") + assetId) + "_") + ownerAddr)
170170 
171171 
172172 func keyLandNumToOwner (landNum) = ("landOwner_" + landNum)
173173 
174174 
175175 func keyBackpackByDuck (duckAssetId) = ("backPack_" + duckAssetId)
176176 
177177 
178178 func keyDuckLocation (duckAssetId) = ("duckLocation_" + duckAssetId)
179179 
180180 
181181 func keyDuckHealth (duckAssetId) = ("duckHealth_" + duckAssetId)
182182 
183183 
184184 func keyResProportions () = "resTypesProportions"
185185 
186186 
187187 let recLandNum = 0
188188 
189189 let recLandSize = 1
190190 
191191 let recTerrains = 2
192192 
193193 let recContinent = 3
194194 
195195 let locIdxContinent = 0
196196 
197197 let locIdxType = 1
198198 
199199 let locIdxId = 2
200200 
201201 let bpIdxLevel = 0
202202 
203203 let bpIdxRes = 1
204204 
205205 let bpIdxMat = 2
206206 
207207 let bpIdxProd = 3
208208 
209209 func asString (v) = match v {
210210     case s: String => 
211211         s
212212     case _ => 
213213         throw("fail to cast into String")
214214 }
215215 
216216 
217217 func getNeededMaterials (total) = {
218218     let props = split(value(getString(keyResProportions())), "_")
219219     if ((size(props) != NUMRES))
220220         then throw("Wrong proportions data")
221221         else {
222222             let r = [parseIntValue(props[0]), parseIntValue(props[1]), parseIntValue(props[2]), parseIntValue(props[3]), parseIntValue(props[4]), parseIntValue(props[5])]
223223             let sum = (((((r[0] + r[1]) + r[2]) + r[3]) + r[4]) + r[5])
224224             if ((0 >= sum))
225225                 then throw("No lands staked")
226226                 else {
227227                     let norm6 = fraction(total, MULT6, sum)
228228                     func normalizer (acc,elem) =                     (acc :+ fraction(elem, norm6, MULT6))
229229 
230230                     let $l = r
231231                     let $s = size($l)
232232                     let $acc0 = nil
233233                     func $f0_1 ($a,$i) =                     if (($i >= $s))
234234                         then $a
235235                         else normalizer($a, $l[$i])
236236 
237237                     func $f0_2 ($a,$i) =                     if (($i >= $s))
238238                         then $a
239239                         else throw("List size exceeds 6")
240240 
241241                     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
242242                     }
243243             }
244244     }
245245 
246246 
247247 func subtractMaterials (shouldUseMat,has,totalNeed) = {
248248     let need = getNeededMaterials(totalNeed)
249249     func subtractor (acc,idx) =     {
250250         let result = (parseIntValue(has[idx]) - need[idx])
251251         if ((0 > result))
252252             then throw(((((("Not enough material idx=" + toString(idx)) + ", you have ") + has[idx]) + ", but need ") + toString(need[idx])))
253253             else (acc :+ toString(result))
254254         }
255255 
256256     if (shouldUseMat)
257257         then {
258258             let $l = [0, 1, 2, 3, 4, 5]
259259             let $s = size($l)
260260             let $acc0 = nil
261261             func $f0_1 ($a,$i) =             if (($i >= $s))
262262                 then $a
263263                 else subtractor($a, $l[$i])
264264 
265265             func $f0_2 ($a,$i) =             if (($i >= $s))
266266                 then $a
267267                 else throw("List size exceeds 6")
268268 
269269             $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
270270             }
271271         else has
272272     }
273273 
274274 
275275 func updateProportionsInternal (propList,terrainCounts,landSizeIndex,sign) = if ((size(propList) != NUMRES))
276276     then throw("Wrong proportions data")
277277     else {
278278         func updater (acc,i) =         {
279279             let result = (parseIntValue(propList[i]) + ((sign * terrainCounts[i]) * landSizeIndex))
280280             if ((0 > result))
281281                 then throw(((((((("Panic! Pieces of type=" + toString(i)) + ", sign=") + toString(sign)) + ",  terrainCounts[i]=") + toString(terrainCounts[i])) + ", landSizeIndex=") + toString(landSizeIndex)))
282282                 else (acc :+ toString(result))
283283             }
284284 
285285         let r = {
286286             let $l = [0, 1, 2, 3, 4, 5]
287287             let $s = size($l)
288288             let $acc0 = nil
289289             func $f0_1 ($a,$i) =             if (($i >= $s))
290290                 then $a
291291                 else updater($a, $l[$i])
292292 
293293             func $f0_2 ($a,$i) =             if (($i >= $s))
294294                 then $a
295295                 else throw("List size exceeds 6")
296296 
297297             $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
298298             }
299299         makeString(r, "_")
300300         }
301301 
302302 
303303 func updateProportions (terrainCounts,landSizeIndex,sign) = {
304304     let propList = split(valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0"), "_")
305305     updateProportionsInternal(propList, terrainCounts, landSizeIndex, sign)
306306     }
307307 
308308 
309309 func countTerrains (terrains) = [(size(split(terrains, "A")) - 1), (size(split(terrains, "B")) - 1), (size(split(terrains, "C")) - 1), (size(split(terrains, "D")) - 1), (size(split(terrains, "E")) - 1), (size(split(terrains, "F")) - 1)]
310310 
311311 
312312 func numPiecesBySize (landSize) = match landSize {
313313     case _ => 
314314         if (("S" == $match0))
315315             then SSIZE
316316             else if (("M" == $match0))
317317                 then MSIZE
318318                 else if (("L" == $match0))
319319                     then LSIZE
320320                     else if (("XL" == $match0))
321321                         then XLSIZE
322322                         else if (("XXL" == $match0))
323323                             then XXLSIZE
324324                             else throw("Unknown land size")
325325 }
326326 
327327 
328328 func subOneInList (aList,idx,amount) = {
329329     func subber (acc,i) =     (acc :+ (if ((i == idx))
330330         then toString((parseIntValue(aList[i]) - amount))
331331         else aList[i]))
332332 
333333     let r = {
334334         let $l = [0, 1, 2, 3, 4, 5]
335335         let $s = size($l)
336336         let $acc0 = nil
337337         func $f0_1 ($a,$i) =         if (($i >= $s))
338338             then $a
339339             else subber($a, $l[$i])
340340 
341341         func $f0_2 ($a,$i) =         if (($i >= $s))
342342             then $a
343343             else throw("List size exceeds 6")
344344 
345345         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
346346         }
347347     makeString(r, "_")
348348     }
349349 
350350 
351351 func addRes (currentRes,terrainCounts,deltaTime,landSizeIndex,dailyByPieceWithBonuses) = {
352352     func adder (acc,i) =     {
353353         let resOfType = ((fraction(deltaTime, dailyByPieceWithBonuses, DAYMILLIS) * terrainCounts[i]) * landSizeIndex)
354354         (acc :+ toString((parseIntValue(currentRes[i]) + resOfType)))
355355         }
356356 
357357     let r = {
358358         let $l = [0, 1, 2, 3, 4, 5]
359359         let $s = size($l)
360360         let $acc0 = nil
361361         func $f0_1 ($a,$i) =         if (($i >= $s))
362362             then $a
363363             else adder($a, $l[$i])
364364 
365365         func $f0_2 ($a,$i) =         if (($i >= $s))
366366             then $a
367367             else throw("List size exceeds 6")
368368 
369369         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
370370         }
371371     makeString(r, "_")
372372     }
373373 
374374 
375375 func abs (x) = if ((x >= toBigInt(0)))
376376     then x
377377     else -(x)
378378 
379379 
380380 let freq = [[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]]
381381 
382382 func genChar (n,freqs) = {
383383     let rem = toInt((n % TWENTYX))
384384     let letter = if ((freqs[0] > rem))
385385         then "A"
386386         else if ((freqs[1] > rem))
387387             then "B"
388388             else if ((freqs[2] > rem))
389389                 then "C"
390390                 else if ((freqs[3] > rem))
391391                     then "D"
392392                     else if ((freqs[4] > rem))
393393                         then "E"
394394                         else "F"
395395     letter
396396     }
397397 
398398 
399399 func genTerrains (seed,continentIdx) = {
400400     let f = freq[continentIdx]
401401     func terrainGenerator (acc,elem) =     $Tuple2((((((acc._1 + genChar(acc._2, f)) + genChar((acc._2 / TWENTYX), f)) + genChar((acc._2 / TWENTY2X), f)) + genChar((acc._2 / TWENTY3X), f)) + genChar((acc._2 / TWENTY4X), f)), (acc._2 / TWENTY5X))
402402 
403403     let t = {
404404         let $l = [1, 2, 3, 4, 5]
405405         let $s = size($l)
406406         let $acc0 = $Tuple2("", (seed / FIVEX))
407407         func $f0_1 ($a,$i) =         if (($i >= $s))
408408             then $a
409409             else terrainGenerator($a, $l[$i])
410410 
411411         func $f0_2 ($a,$i) =         if (($i >= $s))
412412             then $a
413413             else throw("List size exceeds 5")
414414 
415415         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
416416         }
417417     t._1
418418     }
419419 
420420 
421421 func getBackpack (bpKey) = {
422422     let p = split(valueOrElse(getString(bpKey), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
423423 [toString(valueOrElse(parseInt(p[bpIdxLevel]), 0)), if ((size(split(p[bpIdxRes], "_")) == NUMRES))
424424         then p[bpIdxRes]
425425         else "0_0_0_0_0_0", if ((size(split(p[bpIdxMat], "_")) == NUMRES))
426426         then p[bpIdxMat]
427427         else "0_0_0_0_0_0", p[bpIdxProd]]
428428     }
429429 
430430 
431431 func expeditionCommon (shouldUseMat,caller,txId,message,sig) = if (!(sigVerify_8Kb(message, sig, pub)))
432432     then throw("signature does not match")
433433     else {
434434         let parts = split(toUtf8String(message), ";")
435435         let hp = split(split(parts[0], "|")[0], "_")
436436         let curHP = parseIntValue(hp[0])
437437         let newHP = parseIntValue(hp[1])
438438         let locAndTime = split(parts[1], ":")
439439         let targetLocation = split(locAndTime[0], "_")
440440         if ((targetLocation[1] != "E"))
441441             then throw("expedition target location type should be E")
442442             else {
443443                 let time = parseIntValue(locAndTime[1])
444444                 if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
445445                     then true
446446                     else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
447447                     then throw("signature outdated")
448448                     else {
449449                         let userAddr = toString(caller)
450450                         let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(userAddr)), "You don't have a duck staked")
451451                         let keyHealth = keyDuckHealth(duckAssetId)
452452                         let oldFromState = valueOrElse(getInteger(keyHealth), 100)
453453                         if ((oldFromState != curHP))
454454                             then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
455455                             else if ((0 >= curHP))
456456                                 then throw("You can't fly with zero health")
457457                                 else if ((0 >= newHP))
458458                                     then $Tuple2(((if (!(shouldUseMat))
459459                                         then [ScriptTransfer(caller, EXPUSDN, usdnAssetId)]
460460                                         else nil) :+ IntegerEntry(keyHealth, 0)), "")
461461                                     else {
462462                                         let bpKey = keyBackpackByDuck(duckAssetId)
463463                                         let currentPack = getBackpack(bpKey)
464464                                         let mList = split(currentPack[bpIdxMat], "_")
465465                                         let newMat = makeString(subtractMaterials(shouldUseMat, mList, EXPMATERIALS), "_")
466466                                         let bigNum = abs(toBigInt(txId))
467467                                         let freeNum = valueOrElse(getInteger(keyNextFreeLandNum()), (PRESALENUMLANDS + 1))
468468                                         let landNum = toString(freeNum)
469469                                         let continentIdx = toInt((bigNum % FIVEX))
470470                                         let terrains = genTerrains(bigNum, continentIdx)
471471                                         let continent = continents[continentIdx]
472472                                         let issue = Issue(keyNftName(landNum, "S"), makeString([landNum, "S", terrains, continent], "_"), 1, 0, false)
473473                                         let assetId = calculateAssetId(issue)
474474                                         let id = toBase58String(assetId)
475475                                         $Tuple2([IntegerEntry(keyNextFreeLandNum(), (freeNum + 1)), issue, StringEntry(keyLandToAssetId(landNum), id), StringEntry(keyLandAssetIdToOwner(id), userAddr), StringEntry(keyLandNumToOwner(landNum), userAddr), IntegerEntry(keyInfraLevelByAssetId(id), 0), IntegerEntry(keyInfraLevelByAssetIdAndOwner(id, userAddr), 0), ScriptTransfer(caller, 1, assetId), StringEntry(keyDuckLocation(duckAssetId), makeString([continent, "L", id], "_")), IntegerEntry(keyHealth, newHP), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], currentPack[bpIdxRes], newMat, currentPack[bpIdxProd]], ":"))], id)
476476                                         }
477477                         }
478478                 }
479479         }
480480 
481481 
482482 func applyBonuses (landAssetId,pieces) = {
483483     let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
484484     let artPieces = valueOrElse(getInteger(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)), if (valueOrElse(getBoolean(keyPresaleArtActivatedByAssetId(landAssetId)), false))
485485         then pieces
486486         else 0)
487487     ((DAILYRESBYPIECE + fraction(DAILYRESBYPIECE, infraLevel, 4)) + fraction(DAILYRESBYPIECE, (artPieces * 3), (pieces * 20)))
488488     }
489489 
490490 
491491 func checkClaimConditions (addr) = {
492492     let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
493493     let curLocation = valueOrElse(getString(keyDuckLocation(duckAssetId)), DEFAULTLOCATION)
494494     let loc = split(value(curLocation), "_")
495495     if ((loc[locIdxType] != "L"))
496496         then throw((("Duck location type is " + loc[locIdxType]) + ", but should be L"))
497497         else {
498498             let landAssetId = loc[locIdxId]
499499             let asset = value(assetInfo(fromBase58String(landAssetId)))
500500             let timeKey = keyStakedTimeByAssetId(landAssetId)
501501             let savedTime = valueOrErrorMessage(getInteger(timeKey), (("Your duck is on " + asset.name) + ", which is not staked"))
502502             let owner = valueOrErrorMessage(getString(keyLandAssetIdToOwner(landAssetId)), (("NFT " + asset.name) + " is orphaned"))
503503             if ((owner != addr))
504504                 then throw((LANDPREFIX + " is not yours"))
505505                 else {
506506                     let d = split(asset.description, "_")
507507                     $Tuple4(duckAssetId, landAssetId, d, savedTime)
508508                     }
509509             }
510510     }
511511 
512512 
513513 func claimResInternal (addr,amount) = if ((0 > amount))
514514     then throw("Negative amount")
515515     else {
516516         let c = checkClaimConditions(addr)
517517         let landSize = c._3[recLandSize]
518518         let terrainCounts = countTerrains(c._3[recTerrains])
519519         let deltaTime = (lastBlock.timestamp - c._4)
520520         if ((0 > deltaTime))
521521             then throw(((("Saved timestamp is in future, saved = " + toString(c._4)) + ", current = ") + toString(lastBlock.timestamp)))
522522             else {
523523                 let pieces = numPiecesBySize(landSize)
524524                 let dailyProductionByPiece = applyBonuses(c._2, pieces)
525525                 let availRes = fraction(deltaTime, (dailyProductionByPiece * pieces), DAYMILLIS)
526526                 if ((amount > availRes))
527527                     then throw(((("Not enough resources, available = " + toString(availRes)) + ", requested = ") + toString(amount)))
528528                     else {
529529                         let newDeltaTime = fraction((availRes - amount), DAYMILLIS, (dailyProductionByPiece * pieces))
530530                         let newTimestamp = (lastBlock.timestamp - newDeltaTime)
531531                         let bpKey = keyBackpackByDuck(c._1)
532532                         let currentPack = getBackpack(bpKey)
533533                         let currentRes = split(currentPack[bpIdxRes], "_")
534534                         let bpRes = addRes(currentRes, terrainCounts, (deltaTime - newDeltaTime), (pieces / SSIZE), dailyProductionByPiece)
535535                         $Tuple3([IntegerEntry(keyStakedTimeByAssetId(c._2), newTimestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, c._2, addr), newTimestamp)], bpKey, [currentPack[bpIdxLevel], bpRes, currentPack[bpIdxMat], currentPack[bpIdxProd]])
536536                         }
537537                 }
538538         }
539539 
540540 
541541 func claimAll (addr,landAssetId,pieces) = {
542542     let timeKey = keyStakedTimeByAssetId(landAssetId)
543543     let savedTime = value(getInteger(timeKey))
544544     let availRes = (fraction((lastBlock.timestamp - savedTime), applyBonuses(landAssetId, pieces), DAYMILLIS) * pieces)
545545     claimResInternal(addr, availRes)
546546     }
547547 
548548 
549549 func upInfraCommon (shouldUseMat,caller,paymentAmount) = {
550550     let addr = toString(caller)
551551     let c = checkClaimConditions(addr)
552552     let pieces = numPiecesBySize(c._3[recLandSize])
553553     let infraKey = keyInfraLevelByAssetId(c._2)
554554     let curLevel = valueOrElse(getInteger(infraKey), 0)
555555     if ((curLevel >= 3))
556556         then throw("Currently max infrastructure level = 3")
557557         else {
558558             let newLevel = (curLevel + 1)
559559             let cost = fraction(InfraUpgradeCostSUsdn, (pieces * newLevel), SSIZE)
560560             if (if (!(shouldUseMat))
561561                 then (paymentAmount != cost)
562562                 else false)
563563                 then throw(("Payment attached should be " + toString(cost)))
564564                 else {
565565                     let bpKey = keyBackpackByDuck(c._1)
566566                     let currentPack = getBackpack(bpKey)
567567                     let mList = split(currentPack[bpIdxMat], "_")
568568                     let newMat = makeString(subtractMaterials(shouldUseMat, mList, fraction(InfraUpgradeCostS, (pieces * newLevel), SSIZE)), "_")
569569                     let claimResult = claimAll(addr, c._2, pieces)
570570                     $Tuple2(([IntegerEntry(infraKey, newLevel), IntegerEntry(keyInfraLevelByAssetIdAndOwner(c._2, addr), newLevel), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], claimResult._3[bpIdxRes], newMat, currentPack[bpIdxProd]], ":"))] ++ claimResult._1), newLevel)
571571                     }
572572             }
573573     }
574574 
575575 
576576 func activatePresaleArt (addr) = {
577577     let c = checkClaimConditions(addr)
578578     let landAssetId = c._2
579579     let activationKey = keyPresaleArtActivatedByAssetId(landAssetId)
580580     if (valueOrElse(getBoolean(activationKey), false))
581581         then throw("Presale artifact is already activated")
582582         else if ((parseIntValue(c._3[recLandNum]) > PRESALENUMLANDS))
583583             then throw((((LANDPREFIX + " ") + landAssetId) + " is not eligible for presale artifact"))
584584             else {
585585                 let pieces = numPiecesBySize(c._3[recLandSize])
586586                 let claimResult = claimAll(addr, landAssetId, pieces)
587587                 (((((claimResult._1 :+ BooleanEntry(activationKey, true)) :+ BooleanEntry(keyPresaleArtActivatedByAssetIdAndOwner(landAssetId, addr), true)) :+ IntegerEntry(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId), pieces)) :+ IntegerEntry(keyLandArtStatusByTypeAssetIdAndOwner(ARTPRESALE, landAssetId, addr), pieces)) :+ StringEntry(claimResult._2, makeString(claimResult._3, ":")))
588588                 }
589589     }
590590 
591591 
592592 func mergeInternal (newLandSize,newLevel,formula,addr,landAssetIds,txId,needMat) = {
593593     let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
594594     func checkMerge (acc,landAssetId) =     {
595595         let asset = value(assetInfo(fromBase58String(landAssetId)))
596596         let timeKey = keyStakedTimeByAssetId(landAssetId)
597597         let savedTime = valueOrErrorMessage(getInteger(timeKey), (("NFT " + asset.name) + " is not staked"))
598598         let owner = valueOrErrorMessage(getString(keyLandAssetIdToOwner(landAssetId)), (("NFT " + asset.name) + " is orphaned"))
599599         if ((owner != addr))
600600             then throw((LANDPREFIX + " is not yours"))
601601             else {
602602                 let d = split(asset.description, "_")
603603                 let continent = d[recContinent]
604604                 if (if ((acc._3 != ""))
605605                     then (acc._3 != continent)
606606                     else false)
607607                     then throw("Lands should be on the same continent to merge")
608608                     else {
609609                         let landSize = d[recLandSize]
610610                         let sizesIn = acc._1
611611                         let i = valueOrErrorMessage(indexOf(sizesIn, landSize), "You haven't passed all the lands needed")
612612                         let sizesOut = (take(sizesIn, i) + drop(sizesIn, (i + 1)))
613613                         let pieces = numPiecesBySize(landSize)
614614                         let arts = (acc._2 + valueOrElse(getInteger(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)), if (valueOrElse(getBoolean(keyPresaleArtActivatedByAssetId(landAssetId)), false))
615615                             then pieces
616616                             else 0))
617617                         let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
618618                         let reqLevel =                         match landSize {
619619                             case _ => 
620620                                 if (("S" == $match0))
621621                                     then 3
622622                                     else if (("M" == $match0))
623623                                         then 4
624624                                         else if (("L" == $match0))
625625                                             then 5
626626                                             else if (("XL" == $match0))
627627                                                 then 6
628628                                                 else throw("Only S, M, L, XL can merge")
629629                         }
630630                         if ((infraLevel != reqLevel))
631631                             then throw("All lands should be maxed to merge")
632632                             else {
633633                                 let landNum = d[recLandNum]
634634                                 let terrainCounts = countTerrains(d[recTerrains])
635635                                 let deltaTime = (lastBlock.timestamp - savedTime)
636636                                 if ((0 > deltaTime))
637637                                     then throw(((("Saved timestamp is in future, saved = " + toString(savedTime)) + ", current = ") + toString(lastBlock.timestamp)))
638638                                     else {
639639                                         let dailyProductionByPiece = applyBonuses(landAssetId, pieces)
640640                                         let bpRes = addRes(split(acc._4, "_"), terrainCounts, deltaTime, (pieces / SSIZE), dailyProductionByPiece)
641641                                         let props = updateProportionsInternal(split(acc._6, "_"), terrainCounts, (pieces / SSIZE), -1)
642642                                         $Tuple6(sizesOut, arts, continent, bpRes, (((((((((((((acc._5 :+ DeleteEntry(keyStakedTimeByAssetId(landAssetId))) :+ DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, addr))) :+ DeleteEntry(keyLandToAssetId(landNum))) :+ DeleteEntry(keyNftName(landNum, landSize))) :+ DeleteEntry(keyLandAssetIdToOwner(landAssetId))) :+ DeleteEntry(keyInfraLevelByAssetId(landAssetId))) :+ DeleteEntry(keyInfraLevelByAssetIdAndOwner(landAssetId, addr))) :+ DeleteEntry(keyPresaleArtActivatedByAssetId(landAssetId))) :+ DeleteEntry(keyPresaleArtActivatedByAssetIdAndOwner(landAssetId, addr))) :+ DeleteEntry(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId))) :+ DeleteEntry(keyLandArtStatusByTypeAssetIdAndOwner(ARTPRESALE, landAssetId, addr))) :+ DeleteEntry(keyLandNumToOwner(landNum))) :+ Burn(fromBase58String(landAssetId), 1)), props)
643643                                         }
644644                                 }
645645                         }
646646                 }
647647         }
648648 
649649     let bpKey = keyBackpackByDuck(duckAssetId)
650650     let currentPack = getBackpack(bpKey)
651651     let propStr = valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0")
652652     let r = {
653653         let $l = landAssetIds
654654         let $s = size($l)
655655         let $acc0 = $Tuple6(formula, 0, "", currentPack[bpIdxRes], nil, propStr)
656656         func $f0_1 ($a,$i) =         if (($i >= $s))
657657             then $a
658658             else checkMerge($a, $l[$i])
659659 
660660         func $f0_2 ($a,$i) =         if (($i >= $s))
661661             then $a
662662             else throw("List size exceeds 4")
663663 
664664         $f0_2($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4)
665665         }
666666     let continent = r._3
667667     let continentIdx = valueOrErrorMessage(indexOf(continents, continent), ("Unknown continent: " + continent))
668668     let terrains = genTerrains(abs(toBigInt(txId)), continentIdx)
669669     let freeNum = valueOrElse(getInteger(keyNextFreeLandNum()), (PRESALENUMLANDS + 1))
670670     let newLandNum = toString(freeNum)
671671     let issue = Issue(keyNftName(newLandNum, newLandSize), makeString([newLandNum, newLandSize, terrains, continent], "_"), 1, 0, false)
672672     let assetId = calculateAssetId(issue)
673673     let newLandAssetId = toBase58String(assetId)
674674     let newMat = makeString(subtractMaterials((needMat > 0), split(currentPack[bpIdxMat], "_"), needMat), "_")
675675     $Tuple2((((((((((((((r._5 :+ IntegerEntry(keyNextFreeLandNum(), (freeNum + 1))) :+ issue) :+ StringEntry(keyLandToAssetId(newLandNum), newLandAssetId)) :+ StringEntry(keyLandAssetIdToOwner(newLandAssetId), addr)) :+ StringEntry(keyLandNumToOwner(newLandNum), addr)) :+ IntegerEntry(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, newLandAssetId), r._2)) :+ IntegerEntry(keyLandArtStatusByTypeAssetIdAndOwner(ARTPRESALE, newLandAssetId, addr), r._2)) :+ IntegerEntry(keyInfraLevelByAssetId(newLandAssetId), newLevel)) :+ IntegerEntry(keyInfraLevelByAssetIdAndOwner(newLandAssetId, addr), newLevel)) :+ StringEntry(bpKey, makeString([currentPack[bpIdxLevel], r._4, newMat, currentPack[bpIdxProd]], ":"))) :+ StringEntry(keyResProportions(), r._6)) :+ StringEntry(keyDuckLocation(duckAssetId), makeString([continent, "L", newLandAssetId], "_"))) :+ ScriptTransfer(addressFromStringValue(addr), 1, assetId)), newLandAssetId)
676676     }
677677 
678678 
679679 func s2m (addr,landAssetIds,txId) = mergeInternal("M", 3, "SSSS", addr, landAssetIds, txId, 0)
680680 
681681 
682682 func m2l (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
683683     let cost = (InfraUpgradeCostSUsdn * 4)
684684     if (if (!(shouldUseMat))
685685         then (paymentAmount != cost)
686686         else false)
687687         then throw(("Payment attached should be " + toString(cost)))
688688         else mergeInternal("L", 4, "SMM", addr, landAssetIds, txId, (InfraUpgradeCostS * 4))
689689     }
690690 
691691 
692692 func l2xl (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
693693     let cost = (InfraUpgradeCostSUsdn * 47)
694694     if (if (!(shouldUseMat))
695695         then (paymentAmount != cost)
696696         else false)
697697         then throw(("Payment attached should be " + toString(cost)))
698698         else mergeInternal("XL", 5, "SSSML", addr, landAssetIds, txId, (InfraUpgradeCostS * 47))
699699     }
700700 
701701 
702702 func xl2xxl (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
703703     let cost = (InfraUpgradeCostSUsdn * 54)
704704     if (if (!(shouldUseMat))
705705         then (paymentAmount != cost)
706706         else false)
707707         then throw(("Payment attached should be " + toString(cost)))
708708         else mergeInternal("XXL", 6, "LXL", addr, landAssetIds, txId, (InfraUpgradeCostS * 54))
709709     }
710710 
711711 
712712 func mergeCommon (shouldUseMat,addr,paymentAmount,landAssetIds,txId) = {
713713     let mergeResult =     match size(landAssetIds) {
714714         case _ => 
715715             if ((4 == $match0))
716716                 then s2m(addr, landAssetIds, txId)
717717                 else if ((3 == $match0))
718718                     then m2l(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
719719                     else if ((5 == $match0))
720720                         then l2xl(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
721721                         else if ((2 == $match0))
722722                             then xl2xxl(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
723723                             else throw("Unknown merge")
724724     }
725725     mergeResult
726726     }
727727 
728728 
729729 @Callable(i)
730730 func stakeLand () = if ((size(i.payments) != 1))
731731     then throw("Exactly one payment required")
732732     else {
733733         let pmt = value(i.payments[0])
734734         let assetId = value(pmt.assetId)
735735         let address = toString(i.caller)
736736         if ((pmt.amount != 1))
737737             then throw((("NFT " + LANDPREFIX) + " token should be attached as payment"))
738738             else {
739739                 let asset = value(assetInfo(assetId))
740740                 if ((asset.issuer != this))
741741                     then throw("Unknown issuer of token")
742742                     else if (!(contains(asset.name, LANDPREFIX)))
743743                         then throw((("Only NFT " + LANDPREFIX) + " tokens are accepted"))
744744                         else {
745745                             let landNumSize = drop(asset.name, 4)
746746                             let landNum = if (contains(landNumSize, "XXL"))
747747                                 then dropRight(landNumSize, 3)
748748                                 else if (contains(landNumSize, "XL"))
749749                                     then dropRight(landNumSize, 2)
750750                                     else dropRight(landNumSize, 1)
751751                             if (!(isDefined(parseInt(landNum))))
752752                                 then throw(("Cannot parse land number from " + asset.name))
753753                                 else {
754754                                     let landAssetId = toBase58String(assetId)
755755                                     let timeKey = keyStakedTimeByAssetId(landAssetId)
756756                                     if (isDefined(getInteger(timeKey)))
757757                                         then throw((("NFT " + asset.name) + " is already staked"))
758758                                         else {
759759                                             let d = split(asset.description, "_")
760760                                             let terrainCounts = countTerrains(d[recTerrains])
761761                                             let props = updateProportions(terrainCounts, (numPiecesBySize(d[recLandSize]) / SSIZE), 1)
762762 [IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, address), lastBlock.timestamp), StringEntry(keyLandAssetIdToOwner(landAssetId), address), StringEntry(keyLandNumToOwner(landNum), address), StringEntry(keyResProportions(), props)]
763763                                             }
764764                                     }
765765                             }
766766                 }
767767         }
768768 
769769 
770770 
771771 @Callable(i)
772772 func unstakeLand (landAssetIdStr) = if ((size(i.payments) != 0))
773773     then throw("unstake doesn't require any payments")
774774     else {
775775         let addr = toString(i.caller)
776776         let c = checkClaimConditions(addr)
777777         let terrainCounts = countTerrains(c._3[recTerrains])
778778         let pieces = numPiecesBySize(c._3[recLandSize])
779779         let props = updateProportions(terrainCounts, (pieces / SSIZE), -1)
780780         let claimResult = claimAll(addr, c._2, pieces)
781781 [ScriptTransfer(i.caller, 1, fromBase58String(c._2)), DeleteEntry(keyStakedTimeByAssetId(c._2)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, c._2, addr)), StringEntry(keyResProportions(), props), StringEntry(claimResult._2, makeString(claimResult._3, ":"))]
782782         }
783783 
784784 
785785 
786786 @Callable(i)
787787 func stakeDuck () = if ((size(i.payments) != 1))
788788     then throw("Exactly one payment required")
789789     else {
790790         let pmt = value(i.payments[0])
791791         let assetId = value(pmt.assetId)
792792         let address = toString(i.caller)
793793         if ((pmt.amount != 1))
794794             then throw((("NFT " + DUCKPREFIX) + " token should be attached as payment"))
795795             else {
796796                 let asset = value(assetInfo(assetId))
797797                 if (if ((asset.issuer != incubatorAddr))
798798                     then (asset.issuer != breederAddr)
799799                     else false)
800800                     then throw((("Unknown issuer of " + DUCKPREFIX) + " token"))
801801                     else if (!(contains(asset.name, DUCKPREFIX)))
802802                         then throw((("Only NFT " + DUCKPREFIX) + " tokens are accepted"))
803803                         else {
804804                             let assetIdStr = toBase58String(assetId)
805805                             let timeKey = keyStakedTimeByAssetId(assetIdStr)
806806                             if (isDefined(getInteger(timeKey)))
807807                                 then throw((("NFT " + asset.name) + " is already staked"))
808808                                 else if (isDefined(getString(keyStakedDuckByOwner(address))))
809809                                     then throw(("You already staked one duck: " + asset.name))
810810                                     else {
811811                                         let locKey = keyDuckLocation(assetIdStr)
812812                                         let location = getString(locKey)
813813                                         let bpKey = keyBackpackByDuck(assetIdStr)
814814                                         let backpack = getString(bpKey)
815815                                         ([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, toBase58String(assetId), address), lastBlock.timestamp), StringEntry(keyDuckIdToOwner(assetIdStr), address), StringEntry(keyStakedDuckByOwner(address), assetIdStr)] ++ (if (isDefined(location))
816816                                             then nil
817817                                             else ([StringEntry(locKey, DEFAULTLOCATION)] ++ (if (isDefined(backpack))
818818                                                 then nil
819819                                                 else ([StringEntry(bpKey, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(keyDuckHealth(assetIdStr), 100))))))
820820                                         }
821821                             }
822822                 }
823823         }
824824 
825825 
826826 
827827 @Callable(i)
828828 func unstakeDuck (assetIdStr) = if ((size(i.payments) != 0))
829829     then throw("unstake doesn't require any payments")
830830     else {
831831         let assetId = fromBase58String(assetIdStr)
832832         let address = toString(i.caller)
833833         let asset = value(assetInfo(assetId))
834834         let timeKey = keyStakedTimeByAssetId(toBase58String(assetId))
835835         if (!(isDefined(timeKey)))
836836             then throw((("NFT " + asset.name) + " is not staked"))
837837             else if (!(isDefined(keyStakedDuckByOwner(address))))
838838                 then throw((("The duck " + asset.name) + " is not staked"))
839839                 else {
840840                     let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(toBase58String(assetId))), (("NFT " + asset.name) + " is orphaned"))
841841                     if ((owner != address))
842842                         then throw("Staked NFT is not yours")
843843                         else {
844844                             let keyHealth = keyDuckHealth(assetIdStr)
845845                             let health = getInteger(keyHealth)
846846                             if ((health != 100))
847847                                 then throw("Please heal your duck before unstaking")
848848                                 else [ScriptTransfer(i.caller, 1, assetId), DeleteEntry(timeKey), DeleteEntry(keyHealth), DeleteEntry(keyDuckLocation(assetIdStr)), DeleteEntry(keyDuckIdToOwner(assetIdStr)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, assetIdStr, address)), DeleteEntry(keyStakedDuckByOwner(address))]
849849                             }
850850                     }
851851         }
852852 
853853 
854854 
855855 @Callable(i)
856856 func claimRes (amount,landAssetIdStr) = if ((size(i.payments) != 0))
857857     then throw("claimRes doesn't require any payments")
858858     else {
859859         let addr = toString(i.originCaller)
860860         let result = claimResInternal(addr, amount)
861861         $Tuple2((result._1 :+ StringEntry(result._2, makeString(result._3, ":"))), result._3[bpIdxRes])
862862         }
863863 
864864 
865865 
866866 @Callable(i)
867867 func flight (message,sig) = if (!(sigVerify_8Kb(message, sig, pub)))
868868     then throw("signature does not match")
869869     else if ((size(i.payments) != 0))
870870         then throw("flight doesn't require any payments")
871871         else {
872872             let parts = split(toUtf8String(message), ";")
873873             let hp = split(split(parts[0], "|")[0], "_")
874874             let curHP = parseIntValue(hp[0])
875875             let newHP = parseIntValue(hp[1])
876876             let newLocAndTime = split(parts[1], ":")
877877             let newLocation = newLocAndTime[0]
878878             let time = parseIntValue(newLocAndTime[1])
879879             if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
880880                 then true
881881                 else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
882882                 then throw("signature outdated")
883883                 else {
884884                     let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
885885                     let keyHealth = keyDuckHealth(duckAssetId)
886886                     let oldFromState = valueOrElse(getInteger(keyHealth), 100)
887887                     if ((oldFromState != curHP))
888888                         then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
889889                         else if ((0 >= curHP))
890890                             then throw("You can't fly with zero health")
891891                             else {
892892                                 let locKey = keyDuckLocation(duckAssetId)
893893                                 let curLocation = valueOrElse(getString(locKey), DEFAULTLOCATION)
894894                                 if ((newLocation == curLocation))
895895                                     then throw("You can't fly to the same location")
896896                                     else $Tuple2([StringEntry(locKey, if ((newHP > 0))
897897                                         then newLocation
898898                                         else curLocation), IntegerEntry(keyHealth, newHP)], unit)
899899                                 }
900900                     }
901901             }
902902 
903903 
904904 
905905 @Callable(i)
906906 func setHealth (health,duckAssetId) = if (if ((0 > health))
907907     then true
908908     else (health > 100))
909909     then throw("HP should be within 0..100")
910910     else [IntegerEntry(keyDuckHealth(duckAssetId), health)]
911911 
912912 
913913 
914914 @Callable(i)
915915 func heal (matType,amount) = if (if ((0 > matType))
916916     then true
917917     else (matType >= NUMRES))
918918     then throw(("Unknown material: " + toString(matType)))
919919     else if ((0 >= amount))
920920         then throw(("Amount should be positive! " + toString(amount)))
921921         else {
922922             let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
923923             let keyHealth = keyDuckHealth(duckAssetId)
924924             let oldHealth = valueOrElse(getInteger(keyHealth), 100)
925925             if ((oldHealth >= 100))
926926                 then throw("HP should be < 100 to heal")
927927                 else {
928928                     let bpKey = keyBackpackByDuck(duckAssetId)
929929                     let currentPack = getBackpack(bpKey)
930930                     let mList = split(currentPack[bpIdxMat], "_")
931931                     let currentAmount = parseIntValue(mList[matType])
932932                     let deltaHealth = min([(amount / HEALCOST), (100 - oldHealth)])
933933                     let spendAmount = (deltaHealth * HEALCOST)
934934                     if ((spendAmount > currentAmount))
935935                         then throw(((((("You need " + toString(spendAmount)) + " of ") + matTypes[matType]) + " to heal, but you backpack contains ") + toString(currentAmount)))
936936                         else {
937937                             let newMat = subOneInList(mList, matType, spendAmount)
938938 [IntegerEntry(keyHealth, (oldHealth + deltaHealth)), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], currentPack[bpIdxRes], newMat, currentPack[bpIdxProd]], ":"))]
939939                             }
940940                     }
941941             }
942942 
943943 
944944 
945945 @Callable(i)
946946 func updateBackpack (duckAssetId,newPack) = if ((i.caller != economyAddr))
947947     then throw("permission denied")
948948     else $Tuple2([StringEntry(keyBackpackByDuck(duckAssetId), newPack)], newPack)
949949 
950950 
951951 
952952 @Callable(i)
953953 func expeditionBuy (message,sig) = if ((size(i.payments) != 1))
954954     then throw("Exactly one payment required")
955955     else {
956956         let pmt = value(i.payments[0])
957957         if ((pmt.assetId != usdnAssetId))
958958             then throw("Allowed USDN payment only!")
959959             else if ((pmt.amount != EXPUSDN))
960960                 then throw(("Payment attached should be " + toString(EXPUSDN)))
961961                 else {
962962                     let result = expeditionCommon(false, i.caller, i.transactionId, message, sig)
963963                     if ((result._2 == ""))
964964                         then result
965965                         else $Tuple2((result._1 :+ ScriptTransfer(economyAddr, pmt.amount, usdnAssetId)), result._2)
966966                     }
967967         }
968968 
969969 
970970 
971971 @Callable(i)
972972 func expedition (message,sig) = if ((size(i.payments) != 0))
973973     then throw("expedition doesn't require any payments")
974974     else expeditionCommon(true, i.caller, i.transactionId, message, sig)
975975 
976976 
977977 
978978 @Callable(i)
979979 func upgradeInfra (landAssetIdIgnored) = if ((size(i.payments) != 0))
980980     then throw("Infrastructure upgrade doesn't require any payments")
981981     else upInfraCommon(true, i.caller, 0)
982982 
983983 
984984 
985985 @Callable(i)
986986 func upgradeInfraUsdn (landAssetIdIgnored) = if ((size(i.payments) != 1))
987987     then throw("Exactly one payment required")
988988     else {
989989         let pmt = value(i.payments[0])
990990         if ((pmt.assetId != usdnAssetId))
991991             then throw("Allowed USDN payment only!")
992992             else {
993993                 let result = upInfraCommon(false, i.caller, pmt.amount)
994994                 $Tuple2((result._1 :+ ScriptTransfer(economyAddr, pmt.amount, usdnAssetId)), result._2)
995995                 }
996996         }
997997 
998998 
999999 
10001000 @Callable(i)
10011001 func activateArtifact (artName) = if ((size(i.payments) != 0))
10021002     then throw("Artifact activation doesn't require any payments")
10031003     else {
10041004         let result =         match artName {
10051005             case _ => 
10061006                 if (("PRESALE" == $match0))
10071007                     then activatePresaleArt(toString(i.caller))
10081008                     else throw("Unknown artifact")
10091009         }
10101010         result
10111011         }
10121012 
10131013 
10141014 
10151015 @Callable(i)
1016-func mergeLands (landAssetIds) = if ((size(i.payments) != 0))
1017-    then throw("Lands merging doesn't require any payments")
1018-    else mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
1016+func mergeLands (landAssetIds) = if ((i.caller != this))
1017+    then throw("permission denied")
1018+    else if ((size(i.payments) != 0))
1019+        then throw("Lands merging doesn't require any payments")
1020+        else mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
10191021 
10201022 
10211023 
10221024 @Callable(i)
1023-func mergeLandsUsdn (landAssetIds) = if ((size(i.payments) != 1))
1024-    then throw("Exactly one payment required")
1025-    else {
1026-        let pmt = value(i.payments[0])
1027-        if ((pmt.assetId != usdnAssetId))
1028-            then throw("Allowed USDN payment only!")
1029-            else {
1030-                let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
1031-                $Tuple2((result._1 :+ ScriptTransfer(economyAddr, pmt.amount, usdnAssetId)), result._2)
1032-                }
1033-        }
1025+func mergeLandsUsdn (landAssetIds) = if ((i.caller != this))
1026+    then throw("permission denied")
1027+    else if ((size(i.payments) != 1))
1028+        then throw("Exactly one payment required")
1029+        else {
1030+            let pmt = value(i.payments[0])
1031+            if ((pmt.assetId != usdnAssetId))
1032+                then throw("Allowed USDN payment only!")
1033+                else {
1034+                    let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
1035+                    $Tuple2((result._1 :+ ScriptTransfer(economyAddr, pmt.amount, usdnAssetId)), result._2)
1036+                    }
1037+            }
10341038 
10351039 
github/deemru/w8io/169f3d6 
128.65 ms ◑