tx · DyWv9okH8JzzgEuc4VAD3dNV7aD4sqx7VfhGq9mXN3C3

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.03100000 Waves

2023.01.17 20:22 [2409224] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 9Sd9fKnJy22Q6qdjKALnRW5DMrLQZSXSp1rnJeVj6gbc
Next: FR76mzTwWg3XDkGzkWB4iXtjtQn3nhwwdm6VvUqUQBno

Diff: 

OldNewDifferences
10131013 
10141014 
10151015 @Callable(i)
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)
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)
10211019 
10221020 
10231021 
10241022 @Callable(i)
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-            }
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+        }
1034+
1035+
1036+
1037+@Callable(i)
1038+func splitByProportionsREADONLY (amount) = $Tuple2(nil, getNeededMaterials(amount))
10381039 
10391040 

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 ((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)
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)
10211019 
10221020 
10231021 
10241022 @Callable(i)
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-            }
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+        }
1034+
1035+
1036+
1037+@Callable(i)
1038+func splitByProportionsREADONLY (amount) = $Tuple2(nil, getNeededMaterials(amount))
10381039 
10391040 
github/deemru/w8io/169f3d6 
143.55 ms ◑