w8 · tx · 2bd···Rpw

tx · 2bdXR5o749gf4wGve1noJMMiUhvGA61adYNYqAr3TRpw

3PLncXtS1U83D6cQbFD3H8rBHPLgzxSFKZ1:  -0.03400000 Waves

2023.01.29 20:44 [3492118] smart account 3PLncXtS1U83D6cQbFD3H8rBHPLgzxSFKZ1 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2bdXR5o749gf4wGve1noJMMiUhvGA61adYNYqAr3TRpw",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1675014235637,
    "version": 2,
    "chainId": 87,
    "sender": "3PLncXtS1U83D6cQbFD3H8rBHPLgzxSFKZ1",
    "senderPublicKey": "BtDpFhgHQKHFVqYTMLReuZzqy94CRPSRkrYcSEVyjt4q",
    "proofs": [
        "XAyUoRQ6Kc2pi8E1vVsQcmtjEcKsFaAp2eRtxvnrScTysDBniXaD9hU1uNmJ7Vhsmhf5zX1Vr7fYZXAsumJfJEm"
    ],
    "script": "base64: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",
    "height": 3492118,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 71Pbz8UAhKFDR9e7mdQw3iFnURpDwqv5RtbhthokL5Lf
Next: 4HfReAZ5UweZTCzPBt5qUBEw4sF8rKxMb2nS8YmLrWj7

Diff: 
Old New Differences
185 185  
186 186  
187 187  func keyResProportions () = "resTypesProportions"
188 + 
189 + 
190 + func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
191 + 
192 + 
193 + func keyBlocked () = "contractsBlocked"
188 194  
189 195  
190 196  let recLandNum = 0
647 653                                          let dailyProductionByPiece = applyBonuses(landAssetId, pieces)
648 654                                          let bpRes = addRes(split(acc._4, "_"), terrainCounts, deltaTime, (pieces / SSIZE), dailyProductionByPiece)
649 655                                          let props = updateProportionsInternal(split(acc._6, "_"), terrainCounts, (pieces / SSIZE), -1)
650 -                                         $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)
656 +                                         let lands = acc._7
657 +                                         let idx = indexOf(lands, landAssetId)
658 +                                         if (!(isDefined(idx)))
659 +                                             then throw(("Your staked lands don't contain " + landAssetId))
660 +                                             else $Tuple7(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, removeByIndex(lands, value(idx)))
651 661                                          }
652 662                                  }
653 663                          }
657 667      let bpKey = keyBackpackByDuck(duckAssetId)
658 668      let currentPack = getBackpack(bpKey)
659 669      let propStr = valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0")
670 +     let landsKey = keyStakedLandsByOwner(addr)
671 +     let landsIn = split_51C(valueOrElse(getString(landsKey), ""), "_")
660 672      let r = {
661 673          let $l = landAssetIds
662 674          let $s = size($l)
663 -         let $acc0 = $Tuple6(formula, 0, "", currentPack[bpIdxRes], nil, propStr)
675 +         let $acc0 = $Tuple7(formula, 0, "", currentPack[bpIdxRes], nil, propStr, landsIn)
664 676          func $f0_1 ($a,$i) =         if (($i >= $s))
665 677              then $a
666 678              else checkMerge($a, $l[$i])
667 679  
668 680          func $f0_2 ($a,$i) =         if (($i >= $s))
669 681              then $a
670 -             else throw("List size exceeds 4")
682 +             else throw("List size exceeds 5")
671 683  
672 -         $f0_2($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4)
684 +         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
673 685          }
674 686      let continent = r._3
675 687      let continentIdx = valueOrErrorMessage(indexOf(continents, continent), ("Unknown continent: " + continent))
680 692      let assetId = calculateAssetId(issue)
681 693      let newLandAssetId = toBase58String(assetId)
682 694      let newMat = makeString(subtractMaterials((needMat > 0), split(currentPack[bpIdxMat], "_"), needMat), "_")
683 -     $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)
695 +     $Tuple2(((((((((((((((r._5 :+ (if ((size(r._7) > 0))
696 +         then StringEntry(landsKey, makeString_11C(r._7, "_"))
697 +         else DeleteEntry(landsKey))) :+ 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)
684 698      }
685 699  
686 700  
737 751  func saveTxId (addr,txId) = StringEntry(keyLastTxIdByUser(toString(addr)), toBase58String(txId))
738 752  
739 753  
754 + func checkBlocked () = if (valueOrElse(getBoolean(keyBlocked()), false))
755 +     then throw("Contracts are under maintenance")
756 +     else unit
757 + 
758 + 
740 759  @Callable(i)
741 - func stakeLand () = if ((size(i.payments) != 1))
742 -     then throw("Exactly one payment required")
743 -     else {
744 -         let pmt = value(i.payments[0])
745 -         let assetId = value(pmt.assetId)
746 -         let address = toString(i.caller)
747 -         if ((pmt.amount != 1))
748 -             then throw((("NFT " + LANDPREFIX) + " token should be attached as payment"))
749 -             else {
750 -                 let asset = value(assetInfo(assetId))
751 -                 if ((asset.issuer != this))
752 -                     then throw("Unknown issuer of token")
753 -                     else if (!(contains(asset.name, LANDPREFIX)))
754 -                         then throw((("Only NFT " + LANDPREFIX) + " tokens are accepted"))
755 -                         else {
756 -                             let landNumSize = drop(asset.name, 4)
757 -                             let landNum = if (contains(landNumSize, "XXL"))
758 -                                 then dropRight(landNumSize, 3)
759 -                                 else if (contains(landNumSize, "XL"))
760 -                                     then dropRight(landNumSize, 2)
761 -                                     else dropRight(landNumSize, 1)
762 -                             if (!(isDefined(parseInt(landNum))))
763 -                                 then throw(("Cannot parse land number from " + asset.name))
764 -                                 else {
765 -                                     let landAssetId = toBase58String(assetId)
766 -                                     let timeKey = keyStakedTimeByAssetId(landAssetId)
767 -                                     if (isDefined(getInteger(timeKey)))
768 -                                         then throw((("NFT " + asset.name) + " is already staked"))
769 -                                         else {
770 -                                             let d = split(asset.description, "_")
771 -                                             let terrainCounts = countTerrains(d[recTerrains])
772 -                                             let props = updateProportions(terrainCounts, (numPiecesBySize(d[recLandSize]) / SSIZE), 1)
773 - [IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, address), lastBlock.timestamp), StringEntry(keyLandAssetIdToOwner(landAssetId), address), StringEntry(keyLandNumToOwner(landNum), address), StringEntry(keyResProportions(), props)]
774 -                                             }
775 -                                     }
776 -                             }
777 -                 }
778 -         }
760 + func setBlocked (isBlocked) = if ((i.caller != this))
761 +     then throw("permission denied")
762 +     else [BooleanEntry(keyBlocked(), isBlocked)]
779 763  
780 764  
781 765  
782 766  @Callable(i)
783 - func unstakeLand (landAssetIdStr) = if ((size(i.payments) != 0))
784 -     then throw("unstake doesn't require any payments")
785 -     else {
786 -         let addr = toString(i.caller)
787 -         let c = checkClaimConditions(addr)
788 -         let terrainCounts = countTerrains(c._3[recTerrains])
789 -         let pieces = numPiecesBySize(c._3[recLandSize])
790 -         let props = updateProportions(terrainCounts, (pieces / SSIZE), -1)
791 -         let claimResult = claimAll(addr, c._2, pieces)
792 - [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, ":"))]
793 -         }
767 + func stakeLand () = {
768 +     let blocked = checkBlocked()
769 +     if ((blocked == blocked))
770 +         then if ((size(i.payments) != 1))
771 +             then throw("Exactly one payment required")
772 +             else {
773 +                 let pmt = value(i.payments[0])
774 +                 let assetId = value(pmt.assetId)
775 +                 let address = toString(i.caller)
776 +                 if ((pmt.amount != 1))
777 +                     then throw((("NFT " + LANDPREFIX) + " token should be attached as payment"))
778 +                     else {
779 +                         let asset = value(assetInfo(assetId))
780 +                         if ((asset.issuer != this))
781 +                             then throw("Unknown issuer of token")
782 +                             else if (!(contains(asset.name, LANDPREFIX)))
783 +                                 then throw((("Only NFT " + LANDPREFIX) + " tokens are accepted"))
784 +                                 else {
785 +                                     let landNumSize = drop(asset.name, 4)
786 +                                     let landNum = if (contains(landNumSize, "XXL"))
787 +                                         then dropRight(landNumSize, 3)
788 +                                         else if (contains(landNumSize, "XL"))
789 +                                             then dropRight(landNumSize, 2)
790 +                                             else dropRight(landNumSize, 1)
791 +                                     if (!(isDefined(parseInt(landNum))))
792 +                                         then throw(("Cannot parse land number from " + asset.name))
793 +                                         else {
794 +                                             let landAssetId = toBase58String(assetId)
795 +                                             let timeKey = keyStakedTimeByAssetId(landAssetId)
796 +                                             if (isDefined(getInteger(timeKey)))
797 +                                                 then throw((("NFT " + asset.name) + " is already staked"))
798 +                                                 else {
799 +                                                     let d = split(asset.description, "_")
800 +                                                     let terrainCounts = countTerrains(d[recTerrains])
801 +                                                     let props = updateProportions(terrainCounts, (numPiecesBySize(d[recLandSize]) / SSIZE), 1)
802 +                                                     let lands = split_51C(valueOrElse(getString(keyStakedLandsByOwner(address)), ""), "_")
803 +                                                     if (containsElement(lands, landAssetId))
804 +                                                         then throw(("Your staked lands already contain " + landAssetId))
805 +                                                         else [IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, address), lastBlock.timestamp), StringEntry(keyStakedLandsByOwner(address), makeString_11C((lands :+ landAssetId), "_")), StringEntry(keyLandAssetIdToOwner(landAssetId), address), StringEntry(keyLandNumToOwner(landNum), address), StringEntry(keyResProportions(), props)]
806 +                                                     }
807 +                                             }
808 +                                     }
809 +                         }
810 +                 }
811 +         else throw("Strict value is not equal to itself.")
812 +     }
794 813  
795 814  
796 815  
797 816  @Callable(i)
798 - func stakeDuck () = if ((size(i.payments) != 1))
799 -     then throw("Exactly one payment required")
800 -     else {
801 -         let pmt = value(i.payments[0])
802 -         let assetId = value(pmt.assetId)
803 -         let address = toString(i.caller)
804 -         if ((pmt.amount != 1))
805 -             then throw((("NFT " + DUCKPREFIX) + " token should be attached as payment"))
817 + func unstakeLand (landAssetIdIgnored) = {
818 +     let blocked = checkBlocked()
819 +     if ((blocked == blocked))
820 +         then if ((size(i.payments) != 0))
821 +             then throw("unstake doesn't require any payments")
806 822              else {
807 -                 let asset = value(assetInfo(assetId))
808 -                 if (if ((asset.issuer != incubatorAddr))
809 -                     then (asset.issuer != breederAddr)
810 -                     else false)
811 -                     then throw((("Unknown issuer of " + DUCKPREFIX) + " token"))
812 -                     else if (!(contains(asset.name, DUCKPREFIX)))
813 -                         then throw((("Only NFT " + DUCKPREFIX) + " tokens are accepted"))
814 -                         else {
815 -                             let assetIdStr = toBase58String(assetId)
816 -                             let timeKey = keyStakedTimeByAssetId(assetIdStr)
817 -                             if (isDefined(getInteger(timeKey)))
818 -                                 then throw((("NFT " + asset.name) + " is already staked"))
819 -                                 else if (isDefined(getString(keyStakedDuckByOwner(address))))
820 -                                     then throw(("You already staked one duck: " + asset.name))
821 -                                     else {
822 -                                         let locKey = keyDuckLocation(assetIdStr)
823 -                                         let location = getString(locKey)
824 -                                         let bpKey = keyBackpackByDuck(assetIdStr)
825 -                                         let backpack = getString(bpKey)
826 -                                         ([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, toBase58String(assetId), address), lastBlock.timestamp), StringEntry(keyDuckIdToOwner(assetIdStr), address), StringEntry(keyStakedDuckByOwner(address), assetIdStr)] ++ (if (isDefined(location))
827 -                                             then nil
828 -                                             else ([StringEntry(locKey, DEFAULTLOCATION)] ++ (if (isDefined(backpack))
829 -                                                 then nil
830 -                                                 else ([StringEntry(bpKey, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(keyDuckHealth(assetIdStr), 100))))))
831 -                                         }
832 -                             }
823 +                 let addr = toString(i.caller)
824 +                 let c = checkClaimConditions(addr)
825 +                 let landAssetId = c._2
826 +                 let landsKey = keyStakedLandsByOwner(addr)
827 +                 let terrainCounts = countTerrains(c._3[recTerrains])
828 +                 let pieces = numPiecesBySize(c._3[recLandSize])
829 +                 let props = updateProportions(terrainCounts, (pieces / SSIZE), -1)
830 +                 let claimResult = claimAll(addr, landAssetId, pieces)
831 +                 let lands = split_51C(valueOrElse(getString(landsKey), ""), "_")
832 +                 let idx = indexOf(lands, landAssetId)
833 +                 if (!(isDefined(idx)))
834 +                     then throw(("Your staked lands don't contain " + landAssetId))
835 +                     else [ScriptTransfer(i.caller, 1, fromBase58String(landAssetId)), DeleteEntry(keyStakedTimeByAssetId(landAssetId)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, addr)), StringEntry(keyResProportions(), props), StringEntry(claimResult._2, makeString(claimResult._3, ":")), if ((size(lands) > 1))
836 +                         then StringEntry(landsKey, makeString_11C(removeByIndex(lands, value(idx)), "_"))
837 +                         else DeleteEntry(landsKey)]
833 838                  }
834 -         }
839 +         else throw("Strict value is not equal to itself.")
840 +     }
835 841  
836 842  
837 843  
838 844  @Callable(i)
839 - func unstakeDuck (assetIdStr) = if ((size(i.payments) != 0))
840 -     then throw("unstake doesn't require any payments")
841 -     else {
842 -         let assetId = fromBase58String(assetIdStr)
843 -         let address = toString(i.caller)
844 -         let asset = value(assetInfo(assetId))
845 -         let timeKey = keyStakedTimeByAssetId(toBase58String(assetId))
846 -         if (!(isDefined(timeKey)))
847 -             then throw((("NFT " + asset.name) + " is not staked"))
848 -             else if (!(isDefined(keyStakedDuckByOwner(address))))
849 -                 then throw((("The duck " + asset.name) + " is not staked"))
850 -                 else {
851 -                     let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(toBase58String(assetId))), (("NFT " + asset.name) + " is orphaned"))
852 -                     if ((owner != address))
853 -                         then throw("Staked NFT is not yours")
854 -                         else {
855 -                             let keyHealth = keyDuckHealth(assetIdStr)
856 -                             let health = valueOrElse(getInteger(keyHealth), 100)
857 -                             if ((health != 100))
858 -                                 then throw("Please heal your duck before unstaking")
859 -                                 else [ScriptTransfer(i.caller, 1, assetId), DeleteEntry(timeKey), DeleteEntry(keyHealth), DeleteEntry(keyDuckLocation(assetIdStr)), DeleteEntry(keyDuckIdToOwner(assetIdStr)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, assetIdStr, address)), DeleteEntry(keyStakedDuckByOwner(address))]
860 -                             }
861 -                     }
862 -         }
845 + func stakeDuck () = {
846 +     let blocked = checkBlocked()
847 +     if ((blocked == blocked))
848 +         then if ((size(i.payments) != 1))
849 +             then throw("Exactly one payment required")
850 +             else {
851 +                 let pmt = value(i.payments[0])
852 +                 let assetId = value(pmt.assetId)
853 +                 let address = toString(i.caller)
854 +                 if ((pmt.amount != 1))
855 +                     then throw((("NFT " + DUCKPREFIX) + " token should be attached as payment"))
856 +                     else {
857 +                         let asset = value(assetInfo(assetId))
858 +                         if (if ((asset.issuer != incubatorAddr))
859 +                             then (asset.issuer != breederAddr)
860 +                             else false)
861 +                             then throw((("Unknown issuer of " + DUCKPREFIX) + " token"))
862 +                             else if (!(contains(asset.name, DUCKPREFIX)))
863 +                                 then throw((("Only NFT " + DUCKPREFIX) + " tokens are accepted"))
864 +                                 else {
865 +                                     let assetIdStr = toBase58String(assetId)
866 +                                     let timeKey = keyStakedTimeByAssetId(assetIdStr)
867 +                                     if (isDefined(getInteger(timeKey)))
868 +                                         then throw((("NFT " + asset.name) + " is already staked"))
869 +                                         else if (isDefined(getString(keyStakedDuckByOwner(address))))
870 +                                             then throw(("You already staked one duck: " + asset.name))
871 +                                             else {
872 +                                                 let locKey = keyDuckLocation(assetIdStr)
873 +                                                 let location = getString(locKey)
874 +                                                 let bpKey = keyBackpackByDuck(assetIdStr)
875 +                                                 let backpack = getString(bpKey)
876 +                                                 ([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, toBase58String(assetId), address), lastBlock.timestamp), StringEntry(keyDuckIdToOwner(assetIdStr), address), StringEntry(keyStakedDuckByOwner(address), assetIdStr)] ++ (if (isDefined(location))
877 +                                                     then nil
878 +                                                     else ([StringEntry(locKey, DEFAULTLOCATION)] ++ (if (isDefined(backpack))
879 +                                                         then nil
880 +                                                         else ([StringEntry(bpKey, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(keyDuckHealth(assetIdStr), 100))))))
881 +                                                 }
882 +                                     }
883 +                         }
884 +                 }
885 +         else throw("Strict value is not equal to itself.")
886 +     }
863 887  
864 888  
865 889  
866 890  @Callable(i)
867 - func claimRes (amount,landAssetIdStr) = if ((size(i.payments) != 0))
868 -     then throw("claimRes doesn't require any payments")
869 -     else {
870 -         let addr = toString(i.originCaller)
871 -         let result = claimResInternal(addr, amount)
872 -         $Tuple2((result._1 :+ StringEntry(result._2, makeString(result._3, ":"))), result._3[bpIdxRes])
873 -         }
891 + func unstakeDuck (assetIdStr) = {
892 +     let blocked = checkBlocked()
893 +     if ((blocked == blocked))
894 +         then if ((size(i.payments) != 0))
895 +             then throw("unstake doesn't require any payments")
896 +             else {
897 +                 let assetId = fromBase58String(assetIdStr)
898 +                 let address = toString(i.caller)
899 +                 let asset = value(assetInfo(assetId))
900 +                 let timeKey = keyStakedTimeByAssetId(toBase58String(assetId))
901 +                 if (!(isDefined(timeKey)))
902 +                     then throw((("NFT " + asset.name) + " is not staked"))
903 +                     else if (!(isDefined(keyStakedDuckByOwner(address))))
904 +                         then throw((("The duck " + asset.name) + " is not staked"))
905 +                         else {
906 +                             let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(toBase58String(assetId))), (("NFT " + asset.name) + " is orphaned"))
907 +                             if ((owner != address))
908 +                                 then throw("Staked NFT is not yours")
909 +                                 else {
910 +                                     let keyHealth = keyDuckHealth(assetIdStr)
911 +                                     let health = valueOrElse(getInteger(keyHealth), 100)
912 +                                     if ((health != 100))
913 +                                         then throw("Please heal your duck before unstaking")
914 +                                         else [ScriptTransfer(i.caller, 1, assetId), DeleteEntry(timeKey), DeleteEntry(keyHealth), DeleteEntry(keyDuckLocation(assetIdStr)), DeleteEntry(keyDuckIdToOwner(assetIdStr)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, assetIdStr, address)), DeleteEntry(keyStakedDuckByOwner(address))]
915 +                                     }
916 +                             }
917 +                 }
918 +         else throw("Strict value is not equal to itself.")
919 +     }
874 920  
875 921  
876 922  
877 923  @Callable(i)
878 - func flight (message,sig) = if (!(sigVerify_8Kb(message, sig, pub)))
879 -     then throw("signature does not match")
880 -     else if ((size(i.payments) != 0))
881 -         then throw("flight doesn't require any payments")
882 -         else {
883 -             let parts = split(toUtf8String(message), ";")
884 -             let hp = split(split(parts[0], "|")[0], "_")
885 -             let curHP = parseIntValue(hp[0])
886 -             let newHP = parseIntValue(hp[1])
887 -             let newLocAndTime = split(parts[1], ":")
888 -             let newLocation = newLocAndTime[0]
889 -             let time = parseIntValue(newLocAndTime[1])
890 -             if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
891 -                 then true
892 -                 else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
893 -                 then throw("signature outdated")
894 -                 else {
895 -                     let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
896 -                     let keyHealth = keyDuckHealth(duckAssetId)
897 -                     let oldFromState = valueOrElse(getInteger(keyHealth), 100)
898 -                     if ((oldFromState != curHP))
899 -                         then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
900 -                         else if ((0 >= curHP))
901 -                             then throw("You can't fly with zero health")
902 -                             else {
903 -                                 let locKey = keyDuckLocation(duckAssetId)
904 -                                 let curLocation = valueOrElse(getString(locKey), DEFAULTLOCATION)
905 -                                 if ((newLocation == curLocation))
906 -                                     then throw("You can't fly to the same location")
907 -                                     else $Tuple2([StringEntry(locKey, if ((newHP > 0))
908 -                                         then newLocation
909 -                                         else curLocation), IntegerEntry(keyHealth, newHP)], unit)
910 -                                 }
911 -                     }
912 -             }
924 + func claimRes (amount,landAssetIdStr) = {
925 +     let blocked = checkBlocked()
926 +     if ((blocked == blocked))
927 +         then if ((size(i.payments) != 0))
928 +             then throw("claimRes doesn't require any payments")
929 +             else {
930 +                 let addr = toString(i.originCaller)
931 +                 let result = claimResInternal(addr, amount)
932 +                 $Tuple2((result._1 :+ StringEntry(result._2, makeString(result._3, ":"))), result._3[bpIdxRes])
933 +                 }
934 +         else throw("Strict value is not equal to itself.")
935 +     }
913 936  
914 937  
915 938  
916 939  @Callable(i)
917 - func setHealth (health,duckAssetId) = if (if ((0 > health))
918 -     then true
919 -     else (health > 100))
920 -     then throw("HP should be within 0..100")
921 -     else [IntegerEntry(keyDuckHealth(duckAssetId), health)]
940 + func flight (message,sig) = {
941 +     let blocked = checkBlocked()
942 +     if ((blocked == blocked))
943 +         then if (!(sigVerify_8Kb(message, sig, pub)))
944 +             then throw("signature does not match")
945 +             else if ((size(i.payments) != 0))
946 +                 then throw("flight doesn't require any payments")
947 +                 else {
948 +                     let parts = split(toUtf8String(message), ";")
949 +                     let hp = split(split(parts[0], "|")[0], "_")
950 +                     let curHP = parseIntValue(hp[0])
951 +                     let newHP = parseIntValue(hp[1])
952 +                     let newLocAndTime = split(parts[1], ":")
953 +                     let newLocation = newLocAndTime[0]
954 +                     let time = parseIntValue(newLocAndTime[1])
955 +                     if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
956 +                         then true
957 +                         else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
958 +                         then throw("signature outdated")
959 +                         else {
960 +                             let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
961 +                             let keyHealth = keyDuckHealth(duckAssetId)
962 +                             let oldFromState = valueOrElse(getInteger(keyHealth), 100)
963 +                             if ((oldFromState != curHP))
964 +                                 then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
965 +                                 else if ((0 >= curHP))
966 +                                     then throw("You can't fly with zero health")
967 +                                     else {
968 +                                         let locKey = keyDuckLocation(duckAssetId)
969 +                                         let curLocation = valueOrElse(getString(locKey), DEFAULTLOCATION)
970 +                                         if ((newLocation == curLocation))
971 +                                             then throw("You can't fly to the same location")
972 +                                             else $Tuple2([StringEntry(locKey, if ((newHP > 0))
973 +                                                 then newLocation
974 +                                                 else curLocation), IntegerEntry(keyHealth, newHP)], unit)
975 +                                         }
976 +                             }
977 +                     }
978 +         else throw("Strict value is not equal to itself.")
979 +     }
922 980  
923 981  
924 982  
925 983  @Callable(i)
926 - func heal (matType,amount) = if (if ((0 > matType))
927 -     then true
928 -     else (matType >= NUMRES))
929 -     then throw(("Unknown material: " + toString(matType)))
930 -     else if ((0 >= amount))
931 -         then throw(("Amount should be positive! " + toString(amount)))
932 -         else {
933 -             let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
934 -             let keyHealth = keyDuckHealth(duckAssetId)
935 -             let oldHealth = valueOrElse(getInteger(keyHealth), 100)
936 -             if ((oldHealth >= 100))
937 -                 then throw("HP should be < 100 to heal")
984 + func setHealth (health,duckAssetId) = {
985 +     let blocked = checkBlocked()
986 +     if ((blocked == blocked))
987 +         then if (if ((0 > health))
988 +             then true
989 +             else (health > 100))
990 +             then throw("HP should be within 0..100")
991 +             else [IntegerEntry(keyDuckHealth(duckAssetId), health)]
992 +         else throw("Strict value is not equal to itself.")
993 +     }
994 + 
995 + 
996 + 
997 + @Callable(i)
998 + func heal (matType,amount) = {
999 +     let blocked = checkBlocked()
1000 +     if ((blocked == blocked))
1001 +         then if (if ((0 > matType))
1002 +             then true
1003 +             else (matType >= NUMRES))
1004 +             then throw(("Unknown material: " + toString(matType)))
1005 +             else if ((0 >= amount))
1006 +                 then throw(("Amount should be positive! " + toString(amount)))
938 1007                  else {
939 -                     let bpKey = keyBackpackByDuck(duckAssetId)
940 -                     let currentPack = getBackpack(bpKey)
941 -                     let mList = split(currentPack[bpIdxMat], "_")
942 -                     let currentAmount = parseIntValue(mList[matType])
943 -                     let deltaHealth = min([(amount / HEALCOST), (100 - oldHealth)])
944 -                     let spendAmount = (deltaHealth * HEALCOST)
945 -                     if ((spendAmount > currentAmount))
946 -                         then throw(((((("You need " + toString(spendAmount)) + " of ") + matTypes[matType]) + " to heal, but you backpack contains ") + toString(currentAmount)))
1008 +                     let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
1009 +                     let keyHealth = keyDuckHealth(duckAssetId)
1010 +                     let oldHealth = valueOrElse(getInteger(keyHealth), 100)
1011 +                     if ((oldHealth >= 100))
1012 +                         then throw("HP should be < 100 to heal")
947 1013                          else {
948 -                             let newMat = subOneInList(mList, matType, spendAmount)
1014 +                             let bpKey = keyBackpackByDuck(duckAssetId)
1015 +                             let currentPack = getBackpack(bpKey)
1016 +                             let mList = split(currentPack[bpIdxMat], "_")
1017 +                             let currentAmount = parseIntValue(mList[matType])
1018 +                             let deltaHealth = min([(amount / HEALCOST), (100 - oldHealth)])
1019 +                             let spendAmount = (deltaHealth * HEALCOST)
1020 +                             if ((spendAmount > currentAmount))
1021 +                                 then throw(((((("You need " + toString(spendAmount)) + " of ") + matTypes[matType]) + " to heal, but you backpack contains ") + toString(currentAmount)))
1022 +                                 else {
1023 +                                     let newMat = subOneInList(mList, matType, spendAmount)
949 1024  [IntegerEntry(keyHealth, (oldHealth + deltaHealth)), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], currentPack[bpIdxRes], newMat, currentPack[bpIdxProd]], ":"))]
1025 +                                     }
950 1026                              }
951 1027                      }
952 -             }
1028 +         else throw("Strict value is not equal to itself.")
1029 +     }
953 1030  
954 1031  
955 1032  
961 1038  
962 1039  
963 1040  @Callable(i)
964 - func expeditionBuy (message,sig) = if ((size(i.payments) != 1))
965 -     then throw("Exactly one payment required")
966 -     else {
967 -         let pmt = value(i.payments[0])
968 -         if ((pmt.assetId != usdnAssetId))
969 -             then throw("Allowed USDN payment only!")
970 -             else if ((pmt.amount != EXPUSDN))
971 -                 then throw(("Payment attached should be " + toString(EXPUSDN)))
972 -                 else {
973 -                     let result = expeditionCommon(false, i.caller, i.transactionId, message, sig)
974 -                     if ((result._2 == ""))
975 -                         then result
976 -                         else $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
977 -                     }
978 -         }
1041 + func expeditionBuy (message,sig) = {
1042 +     let blocked = checkBlocked()
1043 +     if ((blocked == blocked))
1044 +         then if ((size(i.payments) != 1))
1045 +             then throw("Exactly one payment required")
1046 +             else {
1047 +                 let pmt = value(i.payments[0])
1048 +                 if ((pmt.assetId != usdnAssetId))
1049 +                     then throw("Allowed USDN payment only!")
1050 +                     else if ((pmt.amount != EXPUSDN))
1051 +                         then throw(("Payment attached should be " + toString(EXPUSDN)))
1052 +                         else {
1053 +                             let result = expeditionCommon(false, i.caller, i.transactionId, message, sig)
1054 +                             if ((result._2 == ""))
1055 +                                 then result
1056 +                                 else $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1057 +                             }
1058 +                 }
1059 +         else throw("Strict value is not equal to itself.")
1060 +     }
979 1061  
980 1062  
981 1063  
982 1064  @Callable(i)
983 - func expedition (message,sig) = if ((size(i.payments) != 0))
984 -     then throw("expedition doesn't require any payments")
985 -     else expeditionCommon(true, i.caller, i.transactionId, message, sig)
1065 + func expedition (message,sig) = {
1066 +     let blocked = checkBlocked()
1067 +     if ((blocked == blocked))
1068 +         then if ((size(i.payments) != 0))
1069 +             then throw("expedition doesn't require any payments")
1070 +             else expeditionCommon(true, i.caller, i.transactionId, message, sig)
1071 +         else throw("Strict value is not equal to itself.")
1072 +     }
986 1073  
987 1074  
988 1075  
989 1076  @Callable(i)
990 - func upgradeInfra (landAssetIdIgnored) = if ((size(i.payments) != 0))
991 -     then throw("Infrastructure upgrade doesn't require any payments")
992 -     else upInfraCommon(true, i.caller, 0)
1077 + func upgradeInfra (landAssetIdIgnored) = {
1078 +     let blocked = checkBlocked()
1079 +     if ((blocked == blocked))
1080 +         then if ((size(i.payments) != 0))
1081 +             then throw("Infrastructure upgrade doesn't require any payments")
1082 +             else upInfraCommon(true, i.caller, 0)
1083 +         else throw("Strict value is not equal to itself.")
1084 +     }
993 1085  
994 1086  
995 1087  
996 1088  @Callable(i)
997 - func upgradeInfraUsdn (landAssetIdIgnored) = if ((size(i.payments) != 1))
998 -     then throw("Exactly one payment required")
999 -     else {
1000 -         let pmt = value(i.payments[0])
1001 -         if ((pmt.assetId != usdnAssetId))
1002 -             then throw("Allowed USDN payment only!")
1089 + func upgradeInfraUsdn (landAssetIdIgnored) = {
1090 +     let blocked = checkBlocked()
1091 +     if ((blocked == blocked))
1092 +         then if ((size(i.payments) != 1))
1093 +             then throw("Exactly one payment required")
1003 1094              else {
1004 -                 let result = upInfraCommon(false, i.caller, pmt.amount)
1005 -                 $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1095 +                 let pmt = value(i.payments[0])
1096 +                 if ((pmt.assetId != usdnAssetId))
1097 +                     then throw("Allowed USDN payment only!")
1098 +                     else {
1099 +                         let result = upInfraCommon(false, i.caller, pmt.amount)
1100 +                         $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1101 +                         }
1006 1102                  }
1007 -         }
1103 +         else throw("Strict value is not equal to itself.")
1104 +     }
1008 1105  
1009 1106  
1010 1107  
1011 1108  @Callable(i)
1012 - func activateArtifact (artName) = if ((size(i.payments) != 0))
1013 -     then throw("Artifact activation doesn't require any payments")
1014 -     else {
1015 -         let result =         match artName {
1016 -             case _ => 
1017 -                 if (("PRESALE" == $match0))
1018 -                     then activatePresaleArt(toString(i.caller))
1019 -                     else throw("Unknown artifact")
1020 -         }
1021 -         result
1022 -         }
1109 + func activateArtifact (artName) = {
1110 +     let blocked = checkBlocked()
1111 +     if ((blocked == blocked))
1112 +         then if ((size(i.payments) != 0))
1113 +             then throw("Artifact activation doesn't require any payments")
1114 +             else {
1115 +                 let result =                 match artName {
1116 +                     case _ => 
1117 +                         if (("PRESALE" == $match0))
1118 +                             then activatePresaleArt(toString(i.caller))
1119 +                             else throw("Unknown artifact")
1120 +                 }
1121 +                 result
1122 +                 }
1123 +         else throw("Strict value is not equal to itself.")
1124 +     }
1023 1125  
1024 1126  
1025 1127  
1026 1128  @Callable(i)
1027 1129  func mergeLands (landAssetIds) = if ((i.caller != this))
1028 1130      then throw("permission denied")
1029 -     else if ((size(i.payments) != 0))
1030 -         then throw("Lands merging doesn't require any payments")
1031 -         else mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
1131 +     else {
1132 +         let blocked = checkBlocked()
1133 +         if ((blocked == blocked))
1134 +             then if ((size(i.payments) != 0))
1135 +                 then throw("Lands merging doesn't require any payments")
1136 +                 else mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
1137 +             else throw("Strict value is not equal to itself.")
1138 +         }
1032 1139  
1033 1140  
1034 1141  
1035 1142  @Callable(i)
1036 1143  func mergeLandsUsdn (landAssetIds) = if ((i.caller != this))
1037 1144      then throw("permission denied")
1038 -     else if ((size(i.payments) != 1))
1039 -         then throw("Exactly one payment required")
1040 -         else {
1041 -             let pmt = value(i.payments[0])
1042 -             if ((pmt.assetId != usdnAssetId))
1043 -                 then throw("Allowed USDN payment only!")
1145 +     else {
1146 +         let blocked = checkBlocked()
1147 +         if ((blocked == blocked))
1148 +             then if ((size(i.payments) != 1))
1149 +                 then throw("Exactly one payment required")
1044 1150                  else {
1045 -                     let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
1046 -                     $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1151 +                     let pmt = value(i.payments[0])
1152 +                     if ((pmt.assetId != usdnAssetId))
1153 +                         then throw("Allowed USDN payment only!")
1154 +                         else {
1155 +                             let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
1156 +                             $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1157 +                             }
1047 1158                      }
1048 -             }
1159 +             else throw("Strict value is not equal to itself.")
1160 +         }
1049 1161  
1050 1162  
1051 1163  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let chain = take(drop(this.bytes, 1), 1)
5 5  
6 6  let usdnAssetId = match chain {
7 7      case _ => 
8 8          if ((base58'2W' == $match0))
9 9              then base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
10 10              else if ((base58'2T' == $match0))
11 11                  then base58'HezsdQuRDtzksAYUy97gfhKy7Z1NW2uXYSHA3bgqenNZ'
12 12                  else throw("Unknown chain")
13 13  }
14 14  
15 15  let incubatorAddr = match chain {
16 16      case _ => 
17 17          if ((base58'2W' == $match0))
18 18              then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
19 19              else if ((base58'2T' == $match0))
20 20                  then this
21 21                  else throw("Unknown chain")
22 22  }
23 23  
24 24  let breederAddr = match chain {
25 25      case _ => 
26 26          if ((base58'2W' == $match0))
27 27              then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
28 28              else if ((base58'2T' == $match0))
29 29                  then this
30 30                  else throw("Unknown chain")
31 31  }
32 32  
33 33  let economyContract = addressFromStringValue(match chain {
34 34      case _ => 
35 35          if ((base58'2W' == $match0))
36 36              then "3P2sk1KncSxRaZs8b4CWGPw2jkvvav74u4D"
37 37              else if ((base58'2T' == $match0))
38 38                  then "3N8y4wxX3JC4TdrCJBXX16SjWf6X256hrep"
39 39                  else throw("Unknown chain")
40 40  })
41 41  
42 42  let pub = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
43 43  
44 44  let HEALCOST = 10000
45 45  
46 46  let LANDPREFIX = "LAND"
47 47  
48 48  let DUCKPREFIX = "DUCK"
49 49  
50 50  let DEFAULTLOCATION = "Africa_F_Africa"
51 51  
52 52  let NUMRES = 6
53 53  
54 54  let SSIZE = 25
55 55  
56 56  let MSIZE = 100
57 57  
58 58  let LSIZE = 225
59 59  
60 60  let XLSIZE = 400
61 61  
62 62  let XXLSIZE = 625
63 63  
64 64  let DAILYRESBYPIECE = 3456000
65 65  
66 66  let DAYMILLIS = 86400000
67 67  
68 68  let FIVEMINUTESMILLIS = 300000
69 69  
70 70  let RESOURCEPRICEMIN = 158549
71 71  
72 72  let InfraUpgradeCostS = match chain {
73 73      case _ => 
74 74          if ((base58'2W' == $match0))
75 75              then 6307198406
76 76              else if ((base58'2T' == $match0))
77 77                  then 63071984
78 78                  else throw("Unknown chain")
79 79  }
80 80  
81 81  let InfraUpgradeCostSUsdn = match chain {
82 82      case _ => 
83 83          if ((base58'2W' == $match0))
84 84              then 40000000
85 85              else if ((base58'2T' == $match0))
86 86                  then 400000
87 87                  else throw("Unknown chain")
88 88  }
89 89  
90 90  let EXPMATERIALS = match chain {
91 91      case _ => 
92 92          if ((base58'2W' == $match0))
93 93              then 157679960139
94 94              else if ((base58'2T' == $match0))
95 95                  then 1576799601
96 96                  else throw("Unknown chain")
97 97  }
98 98  
99 99  let EXPUSDN = match chain {
100 100      case _ => 
101 101          if ((base58'2W' == $match0))
102 102              then 1000000000
103 103              else if ((base58'2T' == $match0))
104 104                  then 10000000
105 105                  else throw("Unknown chain")
106 106  }
107 107  
108 108  let MULT6 = 1000000
109 109  
110 110  let FIVEX = toBigInt(5)
111 111  
112 112  let TWENTYX = toBigInt(20)
113 113  
114 114  let TWENTY2X = toBigInt((20 * 20))
115 115  
116 116  let TWENTY3X = toBigInt(((20 * 20) * 20))
117 117  
118 118  let TWENTY4X = toBigInt((((20 * 20) * 20) * 20))
119 119  
120 120  let TWENTY5X = toBigInt(((((20 * 20) * 20) * 20) * 20))
121 121  
122 122  let matTypes = ["Fuel", "Metal", "Plank", "Glass", "Plastic", "Protein"]
123 123  
124 124  let continents = ["Asia", "Europe", "Americas", "Oceania", "Africa"]
125 125  
126 126  let ARTPRESALE = "PRESALE"
127 127  
128 128  let PRESALENUMLANDS = 500
129 129  
130 130  func keyLastTxIdByUser (addr) = ("lastTxIdByUser_" + addr)
131 131  
132 132  
133 133  func keyNextFreeLandNum () = "nextLandNum"
134 134  
135 135  
136 136  func keyLandToAssetId (landNum) = ("landToAsset_" + landNum)
137 137  
138 138  
139 139  func keyNftName (landNum,landSize) = ((LANDPREFIX + landNum) + landSize)
140 140  
141 141  
142 142  func keyLandAssetIdToOwner (assetId) = ("nftOwner_" + assetId)
143 143  
144 144  
145 145  func keyDuckIdToOwner (assetId) = ("duckOwner_" + assetId)
146 146  
147 147  
148 148  func keyStakedTimeByAssetId (assetId) = ("stakedTime_" + assetId)
149 149  
150 150  
151 151  func keyInfraLevelByAssetId (assetId) = ("infraLevel_" + assetId)
152 152  
153 153  
154 154  func keyInfraLevelByAssetIdAndOwner (assetId,ownerAddr) = ((("infraLevelByAssetIdAndOwner_" + assetId) + "_") + ownerAddr)
155 155  
156 156  
157 157  func keyPresaleArtActivatedByAssetId (assetId) = ("presaleArtActivated_" + assetId)
158 158  
159 159  
160 160  func keyPresaleArtActivatedByAssetIdAndOwner (assetId,ownerAddr) = ((("presaleArtActivatedByAssetIdAndOwner_" + assetId) + "_") + ownerAddr)
161 161  
162 162  
163 163  func keyLandArtStatusByTypeAndAssetId (type,assetId) = makeString(["landArtStatus", type, assetId], "_")
164 164  
165 165  
166 166  func keyLandArtStatusByTypeAssetIdAndOwner (type,assetId,ownerAddr) = makeString(["landArtStatusByTypeAssetIdAndOwner", type, assetId, ownerAddr], "_")
167 167  
168 168  
169 169  func keyStakedDuckByOwner (ownerAddr) = ("stakedDuckByOwner_" + ownerAddr)
170 170  
171 171  
172 172  func keyStakedTimeByTypeAssetIdAndOwner (nftType,assetId,ownerAddr) = ((((("stakedTimeByTypeAssetIdAndOwner_" + nftType) + "_") + assetId) + "_") + ownerAddr)
173 173  
174 174  
175 175  func keyLandNumToOwner (landNum) = ("landOwner_" + landNum)
176 176  
177 177  
178 178  func keyBackpackByDuck (duckAssetId) = ("backPack_" + duckAssetId)
179 179  
180 180  
181 181  func keyDuckLocation (duckAssetId) = ("duckLocation_" + duckAssetId)
182 182  
183 183  
184 184  func keyDuckHealth (duckAssetId) = ("duckHealth_" + duckAssetId)
185 185  
186 186  
187 187  func keyResProportions () = "resTypesProportions"
188 + 
189 + 
190 + func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
191 + 
192 + 
193 + func keyBlocked () = "contractsBlocked"
188 194  
189 195  
190 196  let recLandNum = 0
191 197  
192 198  let recLandSize = 1
193 199  
194 200  let recTerrains = 2
195 201  
196 202  let recContinent = 3
197 203  
198 204  let locIdxContinent = 0
199 205  
200 206  let locIdxType = 1
201 207  
202 208  let locIdxId = 2
203 209  
204 210  let bpIdxLevel = 0
205 211  
206 212  let bpIdxRes = 1
207 213  
208 214  let bpIdxMat = 2
209 215  
210 216  let bpIdxProd = 3
211 217  
212 218  func asString (v) = match v {
213 219      case s: String => 
214 220          s
215 221      case _ => 
216 222          throw("fail to cast into String")
217 223  }
218 224  
219 225  
220 226  func distributeByWeights (total,weights) = {
221 227      let sum = (((((weights[0] + weights[1]) + weights[2]) + weights[3]) + weights[4]) + weights[5])
222 228      if ((0 >= sum))
223 229          then throw("Zero weights sum")
224 230          else {
225 231              let norm6 = fraction(total, MULT6, sum)
226 232              func normalizer (acc,elem) =             (acc :+ fraction(elem, norm6, MULT6))
227 233  
228 234              let $l = weights
229 235              let $s = size($l)
230 236              let $acc0 = nil
231 237              func $f0_1 ($a,$i) =             if (($i >= $s))
232 238                  then $a
233 239                  else normalizer($a, $l[$i])
234 240  
235 241              func $f0_2 ($a,$i) =             if (($i >= $s))
236 242                  then $a
237 243                  else throw("List size exceeds 6")
238 244  
239 245              $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
240 246              }
241 247      }
242 248  
243 249  
244 250  func getNeededMaterials (total) = {
245 251      let props = split(value(getString(keyResProportions())), "_")
246 252      if ((size(props) != NUMRES))
247 253          then throw("Wrong proportions data")
248 254          else {
249 255              let r = [parseIntValue(props[0]), parseIntValue(props[1]), parseIntValue(props[2]), parseIntValue(props[3]), parseIntValue(props[4]), parseIntValue(props[5])]
250 256              distributeByWeights(total, r)
251 257              }
252 258      }
253 259  
254 260  
255 261  func subtractMaterials (shouldUseMat,has,totalNeed) = {
256 262      let need = getNeededMaterials(totalNeed)
257 263      func subtractor (acc,idx) =     {
258 264          let result = (parseIntValue(has[idx]) - need[idx])
259 265          if ((0 > result))
260 266              then throw(((((("Not enough material idx=" + toString(idx)) + ", you have ") + has[idx]) + ", but need ") + toString(need[idx])))
261 267              else (acc :+ toString(result))
262 268          }
263 269  
264 270      if (shouldUseMat)
265 271          then {
266 272              let $l = [0, 1, 2, 3, 4, 5]
267 273              let $s = size($l)
268 274              let $acc0 = nil
269 275              func $f0_1 ($a,$i) =             if (($i >= $s))
270 276                  then $a
271 277                  else subtractor($a, $l[$i])
272 278  
273 279              func $f0_2 ($a,$i) =             if (($i >= $s))
274 280                  then $a
275 281                  else throw("List size exceeds 6")
276 282  
277 283              $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
278 284              }
279 285          else has
280 286      }
281 287  
282 288  
283 289  func updateProportionsInternal (propList,terrainCounts,landSizeIndex,sign) = if ((size(propList) != NUMRES))
284 290      then throw("Wrong proportions data")
285 291      else {
286 292          func updater (acc,i) =         {
287 293              let result = (parseIntValue(propList[i]) + ((sign * terrainCounts[i]) * landSizeIndex))
288 294              if ((0 > result))
289 295                  then throw(((((((("Panic! Pieces of type=" + toString(i)) + ", sign=") + toString(sign)) + ",  terrainCounts[i]=") + toString(terrainCounts[i])) + ", landSizeIndex=") + toString(landSizeIndex)))
290 296                  else (acc :+ toString(result))
291 297              }
292 298  
293 299          let r = {
294 300              let $l = [0, 1, 2, 3, 4, 5]
295 301              let $s = size($l)
296 302              let $acc0 = nil
297 303              func $f0_1 ($a,$i) =             if (($i >= $s))
298 304                  then $a
299 305                  else updater($a, $l[$i])
300 306  
301 307              func $f0_2 ($a,$i) =             if (($i >= $s))
302 308                  then $a
303 309                  else throw("List size exceeds 6")
304 310  
305 311              $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
306 312              }
307 313          makeString(r, "_")
308 314          }
309 315  
310 316  
311 317  func updateProportions (terrainCounts,landSizeIndex,sign) = {
312 318      let propList = split(valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0"), "_")
313 319      updateProportionsInternal(propList, terrainCounts, landSizeIndex, sign)
314 320      }
315 321  
316 322  
317 323  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)]
318 324  
319 325  
320 326  func numPiecesBySize (landSize) = match landSize {
321 327      case _ => 
322 328          if (("S" == $match0))
323 329              then SSIZE
324 330              else if (("M" == $match0))
325 331                  then MSIZE
326 332                  else if (("L" == $match0))
327 333                      then LSIZE
328 334                      else if (("XL" == $match0))
329 335                          then XLSIZE
330 336                          else if (("XXL" == $match0))
331 337                              then XXLSIZE
332 338                              else throw("Unknown land size")
333 339  }
334 340  
335 341  
336 342  func subOneInList (aList,idx,amount) = {
337 343      func subber (acc,i) =     (acc :+ (if ((i == idx))
338 344          then toString((parseIntValue(aList[i]) - amount))
339 345          else aList[i]))
340 346  
341 347      let r = {
342 348          let $l = [0, 1, 2, 3, 4, 5]
343 349          let $s = size($l)
344 350          let $acc0 = nil
345 351          func $f0_1 ($a,$i) =         if (($i >= $s))
346 352              then $a
347 353              else subber($a, $l[$i])
348 354  
349 355          func $f0_2 ($a,$i) =         if (($i >= $s))
350 356              then $a
351 357              else throw("List size exceeds 6")
352 358  
353 359          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
354 360          }
355 361      makeString(r, "_")
356 362      }
357 363  
358 364  
359 365  func addRes (currentRes,terrainCounts,deltaTime,landSizeIndex,dailyByPieceWithBonuses) = {
360 366      func adder (acc,i) =     {
361 367          let resOfType = ((fraction(deltaTime, dailyByPieceWithBonuses, DAYMILLIS) * terrainCounts[i]) * landSizeIndex)
362 368          (acc :+ toString((parseIntValue(currentRes[i]) + resOfType)))
363 369          }
364 370  
365 371      let r = {
366 372          let $l = [0, 1, 2, 3, 4, 5]
367 373          let $s = size($l)
368 374          let $acc0 = nil
369 375          func $f0_1 ($a,$i) =         if (($i >= $s))
370 376              then $a
371 377              else adder($a, $l[$i])
372 378  
373 379          func $f0_2 ($a,$i) =         if (($i >= $s))
374 380              then $a
375 381              else throw("List size exceeds 6")
376 382  
377 383          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
378 384          }
379 385      makeString(r, "_")
380 386      }
381 387  
382 388  
383 389  func abs (x) = if ((x >= toBigInt(0)))
384 390      then x
385 391      else -(x)
386 392  
387 393  
388 394  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]]
389 395  
390 396  func genChar (n,freqs) = {
391 397      let rem = toInt((n % TWENTYX))
392 398      let letter = if ((freqs[0] > rem))
393 399          then "A"
394 400          else if ((freqs[1] > rem))
395 401              then "B"
396 402              else if ((freqs[2] > rem))
397 403                  then "C"
398 404                  else if ((freqs[3] > rem))
399 405                      then "D"
400 406                      else if ((freqs[4] > rem))
401 407                          then "E"
402 408                          else "F"
403 409      letter
404 410      }
405 411  
406 412  
407 413  func genTerrains (seed,continentIdx) = {
408 414      let f = freq[continentIdx]
409 415      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))
410 416  
411 417      let t = {
412 418          let $l = [1, 2, 3, 4, 5]
413 419          let $s = size($l)
414 420          let $acc0 = $Tuple2("", (seed / FIVEX))
415 421          func $f0_1 ($a,$i) =         if (($i >= $s))
416 422              then $a
417 423              else terrainGenerator($a, $l[$i])
418 424  
419 425          func $f0_2 ($a,$i) =         if (($i >= $s))
420 426              then $a
421 427              else throw("List size exceeds 5")
422 428  
423 429          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
424 430          }
425 431      t._1
426 432      }
427 433  
428 434  
429 435  func getBackpack (bpKey) = {
430 436      let p = split(valueOrElse(getString(bpKey), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
431 437  [toString(valueOrElse(parseInt(p[bpIdxLevel]), 0)), if ((size(split(p[bpIdxRes], "_")) == NUMRES))
432 438          then p[bpIdxRes]
433 439          else "0_0_0_0_0_0", if ((size(split(p[bpIdxMat], "_")) == NUMRES))
434 440          then p[bpIdxMat]
435 441          else "0_0_0_0_0_0", p[bpIdxProd]]
436 442      }
437 443  
438 444  
439 445  func expeditionCommon (shouldUseMat,caller,txId,message,sig) = if (!(sigVerify_8Kb(message, sig, pub)))
440 446      then throw("signature does not match")
441 447      else {
442 448          let parts = split(toUtf8String(message), ";")
443 449          let hp = split(split(parts[0], "|")[0], "_")
444 450          let curHP = parseIntValue(hp[0])
445 451          let newHP = parseIntValue(hp[1])
446 452          let locAndTime = split(parts[1], ":")
447 453          let targetLocation = split(locAndTime[0], "_")
448 454          if ((targetLocation[1] != "E"))
449 455              then throw("expedition target location type should be E")
450 456              else {
451 457                  let time = parseIntValue(locAndTime[1])
452 458                  if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
453 459                      then true
454 460                      else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
455 461                      then throw("signature outdated")
456 462                      else {
457 463                          let userAddr = toString(caller)
458 464                          let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(userAddr)), "You don't have a duck staked")
459 465                          let keyHealth = keyDuckHealth(duckAssetId)
460 466                          let oldFromState = valueOrElse(getInteger(keyHealth), 100)
461 467                          if ((oldFromState != curHP))
462 468                              then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
463 469                              else if ((0 >= curHP))
464 470                                  then throw("You can't fly with zero health")
465 471                                  else if ((0 >= newHP))
466 472                                      then $Tuple2(((if (!(shouldUseMat))
467 473                                          then [ScriptTransfer(caller, EXPUSDN, usdnAssetId)]
468 474                                          else nil) :+ IntegerEntry(keyHealth, 0)), "")
469 475                                      else {
470 476                                          let bpKey = keyBackpackByDuck(duckAssetId)
471 477                                          let currentPack = getBackpack(bpKey)
472 478                                          let mList = split(currentPack[bpIdxMat], "_")
473 479                                          let newMat = makeString(subtractMaterials(shouldUseMat, mList, EXPMATERIALS), "_")
474 480                                          let bigNum = abs(toBigInt(txId))
475 481                                          let freeNum = valueOrElse(getInteger(keyNextFreeLandNum()), (PRESALENUMLANDS + 1))
476 482                                          let landNum = toString(freeNum)
477 483                                          let continentIdx = toInt((bigNum % FIVEX))
478 484                                          let terrains = genTerrains(bigNum, continentIdx)
479 485                                          let continent = continents[continentIdx]
480 486                                          let issue = Issue(keyNftName(landNum, "S"), makeString([landNum, "S", terrains, continent], "_"), 1, 0, false)
481 487                                          let assetId = calculateAssetId(issue)
482 488                                          let id = toBase58String(assetId)
483 489                                          $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)
484 490                                          }
485 491                          }
486 492                  }
487 493          }
488 494  
489 495  
490 496  func applyBonuses (landAssetId,pieces) = {
491 497      let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
492 498      let artPieces = valueOrElse(getInteger(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)), if (valueOrElse(getBoolean(keyPresaleArtActivatedByAssetId(landAssetId)), false))
493 499          then pieces
494 500          else 0)
495 501      ((DAILYRESBYPIECE + fraction(DAILYRESBYPIECE, infraLevel, 4)) + fraction(DAILYRESBYPIECE, (artPieces * 3), (pieces * 20)))
496 502      }
497 503  
498 504  
499 505  func checkClaimConditions (addr) = {
500 506      let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
501 507      let curLocation = valueOrElse(getString(keyDuckLocation(duckAssetId)), DEFAULTLOCATION)
502 508      let loc = split(value(curLocation), "_")
503 509      if ((loc[locIdxType] != "L"))
504 510          then throw((("Duck location type is " + loc[locIdxType]) + ", but should be L"))
505 511          else {
506 512              let landAssetId = loc[locIdxId]
507 513              let asset = value(assetInfo(fromBase58String(landAssetId)))
508 514              let timeKey = keyStakedTimeByAssetId(landAssetId)
509 515              let savedTime = valueOrErrorMessage(getInteger(timeKey), (("Your duck is on " + asset.name) + ", which is not staked"))
510 516              let owner = valueOrErrorMessage(getString(keyLandAssetIdToOwner(landAssetId)), (("NFT " + asset.name) + " is orphaned"))
511 517              if ((owner != addr))
512 518                  then throw((LANDPREFIX + " is not yours"))
513 519                  else {
514 520                      let d = split(asset.description, "_")
515 521                      $Tuple4(duckAssetId, landAssetId, d, savedTime)
516 522                      }
517 523              }
518 524      }
519 525  
520 526  
521 527  func claimResInternal (addr,amount) = if ((0 > amount))
522 528      then throw("Negative amount")
523 529      else {
524 530          let c = checkClaimConditions(addr)
525 531          let landSize = c._3[recLandSize]
526 532          let terrainCounts = countTerrains(c._3[recTerrains])
527 533          let deltaTime = (lastBlock.timestamp - c._4)
528 534          if ((0 > deltaTime))
529 535              then throw(((("Saved timestamp is in future, saved = " + toString(c._4)) + ", current = ") + toString(lastBlock.timestamp)))
530 536              else {
531 537                  let pieces = numPiecesBySize(landSize)
532 538                  let dailyProductionByPiece = applyBonuses(c._2, pieces)
533 539                  let availRes = fraction(deltaTime, (dailyProductionByPiece * pieces), DAYMILLIS)
534 540                  if ((amount > availRes))
535 541                      then throw(((("Not enough resources, available = " + toString(availRes)) + ", requested = ") + toString(amount)))
536 542                      else {
537 543                          let newDeltaTime = fraction((availRes - amount), DAYMILLIS, (dailyProductionByPiece * pieces))
538 544                          let newTimestamp = (lastBlock.timestamp - newDeltaTime)
539 545                          let bpKey = keyBackpackByDuck(c._1)
540 546                          let currentPack = getBackpack(bpKey)
541 547                          let currentRes = split(currentPack[bpIdxRes], "_")
542 548                          let bpRes = addRes(currentRes, terrainCounts, (deltaTime - newDeltaTime), (pieces / SSIZE), dailyProductionByPiece)
543 549                          $Tuple3([IntegerEntry(keyStakedTimeByAssetId(c._2), newTimestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, c._2, addr), newTimestamp)], bpKey, [currentPack[bpIdxLevel], bpRes, currentPack[bpIdxMat], currentPack[bpIdxProd]])
544 550                          }
545 551                  }
546 552          }
547 553  
548 554  
549 555  func claimAll (addr,landAssetId,pieces) = {
550 556      let timeKey = keyStakedTimeByAssetId(landAssetId)
551 557      let savedTime = value(getInteger(timeKey))
552 558      let availRes = (fraction((lastBlock.timestamp - savedTime), applyBonuses(landAssetId, pieces), DAYMILLIS) * pieces)
553 559      claimResInternal(addr, availRes)
554 560      }
555 561  
556 562  
557 563  func upInfraCommon (shouldUseMat,caller,paymentAmount) = {
558 564      let addr = toString(caller)
559 565      let c = checkClaimConditions(addr)
560 566      let pieces = numPiecesBySize(c._3[recLandSize])
561 567      let infraKey = keyInfraLevelByAssetId(c._2)
562 568      let curLevel = valueOrElse(getInteger(infraKey), 0)
563 569      if ((curLevel >= 3))
564 570          then throw("Currently max infrastructure level = 3")
565 571          else {
566 572              let newLevel = (curLevel + 1)
567 573              let cost = fraction(InfraUpgradeCostSUsdn, (pieces * newLevel), SSIZE)
568 574              if (if (!(shouldUseMat))
569 575                  then (paymentAmount != cost)
570 576                  else false)
571 577                  then throw(("Payment attached should be " + toString(cost)))
572 578                  else {
573 579                      let bpKey = keyBackpackByDuck(c._1)
574 580                      let currentPack = getBackpack(bpKey)
575 581                      let mList = split(currentPack[bpIdxMat], "_")
576 582                      let newMat = makeString(subtractMaterials(shouldUseMat, mList, fraction(InfraUpgradeCostS, (pieces * newLevel), SSIZE)), "_")
577 583                      let claimResult = claimAll(addr, c._2, pieces)
578 584                      $Tuple2(([IntegerEntry(infraKey, newLevel), IntegerEntry(keyInfraLevelByAssetIdAndOwner(c._2, addr), newLevel), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], claimResult._3[bpIdxRes], newMat, currentPack[bpIdxProd]], ":"))] ++ claimResult._1), newLevel)
579 585                      }
580 586              }
581 587      }
582 588  
583 589  
584 590  func activatePresaleArt (addr) = {
585 591      let c = checkClaimConditions(addr)
586 592      let landAssetId = c._2
587 593      let activationKey = keyPresaleArtActivatedByAssetId(landAssetId)
588 594      if (valueOrElse(getBoolean(activationKey), false))
589 595          then throw("Presale artifact is already activated")
590 596          else if ((parseIntValue(c._3[recLandNum]) > PRESALENUMLANDS))
591 597              then throw((((LANDPREFIX + " ") + landAssetId) + " is not eligible for presale artifact"))
592 598              else {
593 599                  let pieces = numPiecesBySize(c._3[recLandSize])
594 600                  let claimResult = claimAll(addr, landAssetId, pieces)
595 601                  (((((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, ":")))
596 602                  }
597 603      }
598 604  
599 605  
600 606  func mergeInternal (newLandSize,newLevel,formula,addr,landAssetIds,txId,needMat) = {
601 607      let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
602 608      func checkMerge (acc,landAssetId) =     {
603 609          let asset = value(assetInfo(fromBase58String(landAssetId)))
604 610          let timeKey = keyStakedTimeByAssetId(landAssetId)
605 611          let savedTime = valueOrErrorMessage(getInteger(timeKey), (("NFT " + asset.name) + " is not staked"))
606 612          let owner = valueOrErrorMessage(getString(keyLandAssetIdToOwner(landAssetId)), (("NFT " + asset.name) + " is orphaned"))
607 613          if ((owner != addr))
608 614              then throw((LANDPREFIX + " is not yours"))
609 615              else {
610 616                  let d = split(asset.description, "_")
611 617                  let continent = d[recContinent]
612 618                  if (if ((acc._3 != ""))
613 619                      then (acc._3 != continent)
614 620                      else false)
615 621                      then throw("Lands should be on the same continent to merge")
616 622                      else {
617 623                          let landSize = d[recLandSize]
618 624                          let sizesIn = acc._1
619 625                          let i = valueOrErrorMessage(indexOf(sizesIn, landSize), "You haven't passed all the lands needed")
620 626                          let sizesOut = (take(sizesIn, i) + drop(sizesIn, (i + 1)))
621 627                          let pieces = numPiecesBySize(landSize)
622 628                          let arts = (acc._2 + valueOrElse(getInteger(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)), if (valueOrElse(getBoolean(keyPresaleArtActivatedByAssetId(landAssetId)), false))
623 629                              then pieces
624 630                              else 0))
625 631                          let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
626 632                          let reqLevel =                         match landSize {
627 633                              case _ => 
628 634                                  if (("S" == $match0))
629 635                                      then 3
630 636                                      else if (("M" == $match0))
631 637                                          then 4
632 638                                          else if (("L" == $match0))
633 639                                              then 5
634 640                                              else if (("XL" == $match0))
635 641                                                  then 6
636 642                                                  else throw("Only S, M, L, XL can merge")
637 643                          }
638 644                          if ((infraLevel != reqLevel))
639 645                              then throw("All lands should be maxed to merge")
640 646                              else {
641 647                                  let landNum = d[recLandNum]
642 648                                  let terrainCounts = countTerrains(d[recTerrains])
643 649                                  let deltaTime = (lastBlock.timestamp - savedTime)
644 650                                  if ((0 > deltaTime))
645 651                                      then throw(((("Saved timestamp is in future, saved = " + toString(savedTime)) + ", current = ") + toString(lastBlock.timestamp)))
646 652                                      else {
647 653                                          let dailyProductionByPiece = applyBonuses(landAssetId, pieces)
648 654                                          let bpRes = addRes(split(acc._4, "_"), terrainCounts, deltaTime, (pieces / SSIZE), dailyProductionByPiece)
649 655                                          let props = updateProportionsInternal(split(acc._6, "_"), terrainCounts, (pieces / SSIZE), -1)
650 -                                         $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)
656 +                                         let lands = acc._7
657 +                                         let idx = indexOf(lands, landAssetId)
658 +                                         if (!(isDefined(idx)))
659 +                                             then throw(("Your staked lands don't contain " + landAssetId))
660 +                                             else $Tuple7(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, removeByIndex(lands, value(idx)))
651 661                                          }
652 662                                  }
653 663                          }
654 664                  }
655 665          }
656 666  
657 667      let bpKey = keyBackpackByDuck(duckAssetId)
658 668      let currentPack = getBackpack(bpKey)
659 669      let propStr = valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0")
670 +     let landsKey = keyStakedLandsByOwner(addr)
671 +     let landsIn = split_51C(valueOrElse(getString(landsKey), ""), "_")
660 672      let r = {
661 673          let $l = landAssetIds
662 674          let $s = size($l)
663 -         let $acc0 = $Tuple6(formula, 0, "", currentPack[bpIdxRes], nil, propStr)
675 +         let $acc0 = $Tuple7(formula, 0, "", currentPack[bpIdxRes], nil, propStr, landsIn)
664 676          func $f0_1 ($a,$i) =         if (($i >= $s))
665 677              then $a
666 678              else checkMerge($a, $l[$i])
667 679  
668 680          func $f0_2 ($a,$i) =         if (($i >= $s))
669 681              then $a
670 -             else throw("List size exceeds 4")
682 +             else throw("List size exceeds 5")
671 683  
672 -         $f0_2($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4)
684 +         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
673 685          }
674 686      let continent = r._3
675 687      let continentIdx = valueOrErrorMessage(indexOf(continents, continent), ("Unknown continent: " + continent))
676 688      let terrains = genTerrains(abs(toBigInt(txId)), continentIdx)
677 689      let freeNum = valueOrElse(getInteger(keyNextFreeLandNum()), (PRESALENUMLANDS + 1))
678 690      let newLandNum = toString(freeNum)
679 691      let issue = Issue(keyNftName(newLandNum, newLandSize), makeString([newLandNum, newLandSize, terrains, continent], "_"), 1, 0, false)
680 692      let assetId = calculateAssetId(issue)
681 693      let newLandAssetId = toBase58String(assetId)
682 694      let newMat = makeString(subtractMaterials((needMat > 0), split(currentPack[bpIdxMat], "_"), needMat), "_")
683 -     $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)
695 +     $Tuple2(((((((((((((((r._5 :+ (if ((size(r._7) > 0))
696 +         then StringEntry(landsKey, makeString_11C(r._7, "_"))
697 +         else DeleteEntry(landsKey))) :+ 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)
684 698      }
685 699  
686 700  
687 701  func s2m (addr,landAssetIds,txId) = mergeInternal("M", 3, "SSSS", addr, landAssetIds, txId, 0)
688 702  
689 703  
690 704  func m2l (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
691 705      let cost = (InfraUpgradeCostSUsdn * 4)
692 706      if (if (!(shouldUseMat))
693 707          then (paymentAmount != cost)
694 708          else false)
695 709          then throw(("Payment attached should be " + toString(cost)))
696 710          else mergeInternal("L", 4, "SMM", addr, landAssetIds, txId, (InfraUpgradeCostS * 4))
697 711      }
698 712  
699 713  
700 714  func l2xl (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
701 715      let cost = (InfraUpgradeCostSUsdn * 47)
702 716      if (if (!(shouldUseMat))
703 717          then (paymentAmount != cost)
704 718          else false)
705 719          then throw(("Payment attached should be " + toString(cost)))
706 720          else mergeInternal("XL", 5, "SSSML", addr, landAssetIds, txId, (InfraUpgradeCostS * 47))
707 721      }
708 722  
709 723  
710 724  func xl2xxl (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
711 725      let cost = (InfraUpgradeCostSUsdn * 54)
712 726      if (if (!(shouldUseMat))
713 727          then (paymentAmount != cost)
714 728          else false)
715 729          then throw(("Payment attached should be " + toString(cost)))
716 730          else mergeInternal("XXL", 6, "LXL", addr, landAssetIds, txId, (InfraUpgradeCostS * 54))
717 731      }
718 732  
719 733  
720 734  func mergeCommon (shouldUseMat,addr,paymentAmount,landAssetIds,txId) = {
721 735      let mergeResult =     match size(landAssetIds) {
722 736          case _ => 
723 737              if ((4 == $match0))
724 738                  then s2m(addr, landAssetIds, txId)
725 739                  else if ((3 == $match0))
726 740                      then m2l(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
727 741                      else if ((5 == $match0))
728 742                          then l2xl(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
729 743                          else if ((2 == $match0))
730 744                              then xl2xxl(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
731 745                              else throw("Unknown merge")
732 746      }
733 747      mergeResult
734 748      }
735 749  
736 750  
737 751  func saveTxId (addr,txId) = StringEntry(keyLastTxIdByUser(toString(addr)), toBase58String(txId))
738 752  
739 753  
754 + func checkBlocked () = if (valueOrElse(getBoolean(keyBlocked()), false))
755 +     then throw("Contracts are under maintenance")
756 +     else unit
757 + 
758 + 
740 759  @Callable(i)
741 - func stakeLand () = if ((size(i.payments) != 1))
742 -     then throw("Exactly one payment required")
743 -     else {
744 -         let pmt = value(i.payments[0])
745 -         let assetId = value(pmt.assetId)
746 -         let address = toString(i.caller)
747 -         if ((pmt.amount != 1))
748 -             then throw((("NFT " + LANDPREFIX) + " token should be attached as payment"))
749 -             else {
750 -                 let asset = value(assetInfo(assetId))
751 -                 if ((asset.issuer != this))
752 -                     then throw("Unknown issuer of token")
753 -                     else if (!(contains(asset.name, LANDPREFIX)))
754 -                         then throw((("Only NFT " + LANDPREFIX) + " tokens are accepted"))
755 -                         else {
756 -                             let landNumSize = drop(asset.name, 4)
757 -                             let landNum = if (contains(landNumSize, "XXL"))
758 -                                 then dropRight(landNumSize, 3)
759 -                                 else if (contains(landNumSize, "XL"))
760 -                                     then dropRight(landNumSize, 2)
761 -                                     else dropRight(landNumSize, 1)
762 -                             if (!(isDefined(parseInt(landNum))))
763 -                                 then throw(("Cannot parse land number from " + asset.name))
764 -                                 else {
765 -                                     let landAssetId = toBase58String(assetId)
766 -                                     let timeKey = keyStakedTimeByAssetId(landAssetId)
767 -                                     if (isDefined(getInteger(timeKey)))
768 -                                         then throw((("NFT " + asset.name) + " is already staked"))
769 -                                         else {
770 -                                             let d = split(asset.description, "_")
771 -                                             let terrainCounts = countTerrains(d[recTerrains])
772 -                                             let props = updateProportions(terrainCounts, (numPiecesBySize(d[recLandSize]) / SSIZE), 1)
773 - [IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, address), lastBlock.timestamp), StringEntry(keyLandAssetIdToOwner(landAssetId), address), StringEntry(keyLandNumToOwner(landNum), address), StringEntry(keyResProportions(), props)]
774 -                                             }
775 -                                     }
776 -                             }
777 -                 }
778 -         }
760 + func setBlocked (isBlocked) = if ((i.caller != this))
761 +     then throw("permission denied")
762 +     else [BooleanEntry(keyBlocked(), isBlocked)]
779 763  
780 764  
781 765  
782 766  @Callable(i)
783 - func unstakeLand (landAssetIdStr) = if ((size(i.payments) != 0))
784 -     then throw("unstake doesn't require any payments")
785 -     else {
786 -         let addr = toString(i.caller)
787 -         let c = checkClaimConditions(addr)
788 -         let terrainCounts = countTerrains(c._3[recTerrains])
789 -         let pieces = numPiecesBySize(c._3[recLandSize])
790 -         let props = updateProportions(terrainCounts, (pieces / SSIZE), -1)
791 -         let claimResult = claimAll(addr, c._2, pieces)
792 - [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, ":"))]
793 -         }
767 + func stakeLand () = {
768 +     let blocked = checkBlocked()
769 +     if ((blocked == blocked))
770 +         then if ((size(i.payments) != 1))
771 +             then throw("Exactly one payment required")
772 +             else {
773 +                 let pmt = value(i.payments[0])
774 +                 let assetId = value(pmt.assetId)
775 +                 let address = toString(i.caller)
776 +                 if ((pmt.amount != 1))
777 +                     then throw((("NFT " + LANDPREFIX) + " token should be attached as payment"))
778 +                     else {
779 +                         let asset = value(assetInfo(assetId))
780 +                         if ((asset.issuer != this))
781 +                             then throw("Unknown issuer of token")
782 +                             else if (!(contains(asset.name, LANDPREFIX)))
783 +                                 then throw((("Only NFT " + LANDPREFIX) + " tokens are accepted"))
784 +                                 else {
785 +                                     let landNumSize = drop(asset.name, 4)
786 +                                     let landNum = if (contains(landNumSize, "XXL"))
787 +                                         then dropRight(landNumSize, 3)
788 +                                         else if (contains(landNumSize, "XL"))
789 +                                             then dropRight(landNumSize, 2)
790 +                                             else dropRight(landNumSize, 1)
791 +                                     if (!(isDefined(parseInt(landNum))))
792 +                                         then throw(("Cannot parse land number from " + asset.name))
793 +                                         else {
794 +                                             let landAssetId = toBase58String(assetId)
795 +                                             let timeKey = keyStakedTimeByAssetId(landAssetId)
796 +                                             if (isDefined(getInteger(timeKey)))
797 +                                                 then throw((("NFT " + asset.name) + " is already staked"))
798 +                                                 else {
799 +                                                     let d = split(asset.description, "_")
800 +                                                     let terrainCounts = countTerrains(d[recTerrains])
801 +                                                     let props = updateProportions(terrainCounts, (numPiecesBySize(d[recLandSize]) / SSIZE), 1)
802 +                                                     let lands = split_51C(valueOrElse(getString(keyStakedLandsByOwner(address)), ""), "_")
803 +                                                     if (containsElement(lands, landAssetId))
804 +                                                         then throw(("Your staked lands already contain " + landAssetId))
805 +                                                         else [IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, address), lastBlock.timestamp), StringEntry(keyStakedLandsByOwner(address), makeString_11C((lands :+ landAssetId), "_")), StringEntry(keyLandAssetIdToOwner(landAssetId), address), StringEntry(keyLandNumToOwner(landNum), address), StringEntry(keyResProportions(), props)]
806 +                                                     }
807 +                                             }
808 +                                     }
809 +                         }
810 +                 }
811 +         else throw("Strict value is not equal to itself.")
812 +     }
794 813  
795 814  
796 815  
797 816  @Callable(i)
798 - func stakeDuck () = if ((size(i.payments) != 1))
799 -     then throw("Exactly one payment required")
800 -     else {
801 -         let pmt = value(i.payments[0])
802 -         let assetId = value(pmt.assetId)
803 -         let address = toString(i.caller)
804 -         if ((pmt.amount != 1))
805 -             then throw((("NFT " + DUCKPREFIX) + " token should be attached as payment"))
817 + func unstakeLand (landAssetIdIgnored) = {
818 +     let blocked = checkBlocked()
819 +     if ((blocked == blocked))
820 +         then if ((size(i.payments) != 0))
821 +             then throw("unstake doesn't require any payments")
806 822              else {
807 -                 let asset = value(assetInfo(assetId))
808 -                 if (if ((asset.issuer != incubatorAddr))
809 -                     then (asset.issuer != breederAddr)
810 -                     else false)
811 -                     then throw((("Unknown issuer of " + DUCKPREFIX) + " token"))
812 -                     else if (!(contains(asset.name, DUCKPREFIX)))
813 -                         then throw((("Only NFT " + DUCKPREFIX) + " tokens are accepted"))
814 -                         else {
815 -                             let assetIdStr = toBase58String(assetId)
816 -                             let timeKey = keyStakedTimeByAssetId(assetIdStr)
817 -                             if (isDefined(getInteger(timeKey)))
818 -                                 then throw((("NFT " + asset.name) + " is already staked"))
819 -                                 else if (isDefined(getString(keyStakedDuckByOwner(address))))
820 -                                     then throw(("You already staked one duck: " + asset.name))
821 -                                     else {
822 -                                         let locKey = keyDuckLocation(assetIdStr)
823 -                                         let location = getString(locKey)
824 -                                         let bpKey = keyBackpackByDuck(assetIdStr)
825 -                                         let backpack = getString(bpKey)
826 -                                         ([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, toBase58String(assetId), address), lastBlock.timestamp), StringEntry(keyDuckIdToOwner(assetIdStr), address), StringEntry(keyStakedDuckByOwner(address), assetIdStr)] ++ (if (isDefined(location))
827 -                                             then nil
828 -                                             else ([StringEntry(locKey, DEFAULTLOCATION)] ++ (if (isDefined(backpack))
829 -                                                 then nil
830 -                                                 else ([StringEntry(bpKey, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(keyDuckHealth(assetIdStr), 100))))))
831 -                                         }
832 -                             }
823 +                 let addr = toString(i.caller)
824 +                 let c = checkClaimConditions(addr)
825 +                 let landAssetId = c._2
826 +                 let landsKey = keyStakedLandsByOwner(addr)
827 +                 let terrainCounts = countTerrains(c._3[recTerrains])
828 +                 let pieces = numPiecesBySize(c._3[recLandSize])
829 +                 let props = updateProportions(terrainCounts, (pieces / SSIZE), -1)
830 +                 let claimResult = claimAll(addr, landAssetId, pieces)
831 +                 let lands = split_51C(valueOrElse(getString(landsKey), ""), "_")
832 +                 let idx = indexOf(lands, landAssetId)
833 +                 if (!(isDefined(idx)))
834 +                     then throw(("Your staked lands don't contain " + landAssetId))
835 +                     else [ScriptTransfer(i.caller, 1, fromBase58String(landAssetId)), DeleteEntry(keyStakedTimeByAssetId(landAssetId)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, addr)), StringEntry(keyResProportions(), props), StringEntry(claimResult._2, makeString(claimResult._3, ":")), if ((size(lands) > 1))
836 +                         then StringEntry(landsKey, makeString_11C(removeByIndex(lands, value(idx)), "_"))
837 +                         else DeleteEntry(landsKey)]
833 838                  }
834 -         }
839 +         else throw("Strict value is not equal to itself.")
840 +     }
835 841  
836 842  
837 843  
838 844  @Callable(i)
839 - func unstakeDuck (assetIdStr) = if ((size(i.payments) != 0))
840 -     then throw("unstake doesn't require any payments")
841 -     else {
842 -         let assetId = fromBase58String(assetIdStr)
843 -         let address = toString(i.caller)
844 -         let asset = value(assetInfo(assetId))
845 -         let timeKey = keyStakedTimeByAssetId(toBase58String(assetId))
846 -         if (!(isDefined(timeKey)))
847 -             then throw((("NFT " + asset.name) + " is not staked"))
848 -             else if (!(isDefined(keyStakedDuckByOwner(address))))
849 -                 then throw((("The duck " + asset.name) + " is not staked"))
850 -                 else {
851 -                     let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(toBase58String(assetId))), (("NFT " + asset.name) + " is orphaned"))
852 -                     if ((owner != address))
853 -                         then throw("Staked NFT is not yours")
854 -                         else {
855 -                             let keyHealth = keyDuckHealth(assetIdStr)
856 -                             let health = valueOrElse(getInteger(keyHealth), 100)
857 -                             if ((health != 100))
858 -                                 then throw("Please heal your duck before unstaking")
859 -                                 else [ScriptTransfer(i.caller, 1, assetId), DeleteEntry(timeKey), DeleteEntry(keyHealth), DeleteEntry(keyDuckLocation(assetIdStr)), DeleteEntry(keyDuckIdToOwner(assetIdStr)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, assetIdStr, address)), DeleteEntry(keyStakedDuckByOwner(address))]
860 -                             }
861 -                     }
862 -         }
845 + func stakeDuck () = {
846 +     let blocked = checkBlocked()
847 +     if ((blocked == blocked))
848 +         then if ((size(i.payments) != 1))
849 +             then throw("Exactly one payment required")
850 +             else {
851 +                 let pmt = value(i.payments[0])
852 +                 let assetId = value(pmt.assetId)
853 +                 let address = toString(i.caller)
854 +                 if ((pmt.amount != 1))
855 +                     then throw((("NFT " + DUCKPREFIX) + " token should be attached as payment"))
856 +                     else {
857 +                         let asset = value(assetInfo(assetId))
858 +                         if (if ((asset.issuer != incubatorAddr))
859 +                             then (asset.issuer != breederAddr)
860 +                             else false)
861 +                             then throw((("Unknown issuer of " + DUCKPREFIX) + " token"))
862 +                             else if (!(contains(asset.name, DUCKPREFIX)))
863 +                                 then throw((("Only NFT " + DUCKPREFIX) + " tokens are accepted"))
864 +                                 else {
865 +                                     let assetIdStr = toBase58String(assetId)
866 +                                     let timeKey = keyStakedTimeByAssetId(assetIdStr)
867 +                                     if (isDefined(getInteger(timeKey)))
868 +                                         then throw((("NFT " + asset.name) + " is already staked"))
869 +                                         else if (isDefined(getString(keyStakedDuckByOwner(address))))
870 +                                             then throw(("You already staked one duck: " + asset.name))
871 +                                             else {
872 +                                                 let locKey = keyDuckLocation(assetIdStr)
873 +                                                 let location = getString(locKey)
874 +                                                 let bpKey = keyBackpackByDuck(assetIdStr)
875 +                                                 let backpack = getString(bpKey)
876 +                                                 ([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, toBase58String(assetId), address), lastBlock.timestamp), StringEntry(keyDuckIdToOwner(assetIdStr), address), StringEntry(keyStakedDuckByOwner(address), assetIdStr)] ++ (if (isDefined(location))
877 +                                                     then nil
878 +                                                     else ([StringEntry(locKey, DEFAULTLOCATION)] ++ (if (isDefined(backpack))
879 +                                                         then nil
880 +                                                         else ([StringEntry(bpKey, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(keyDuckHealth(assetIdStr), 100))))))
881 +                                                 }
882 +                                     }
883 +                         }
884 +                 }
885 +         else throw("Strict value is not equal to itself.")
886 +     }
863 887  
864 888  
865 889  
866 890  @Callable(i)
867 - func claimRes (amount,landAssetIdStr) = if ((size(i.payments) != 0))
868 -     then throw("claimRes doesn't require any payments")
869 -     else {
870 -         let addr = toString(i.originCaller)
871 -         let result = claimResInternal(addr, amount)
872 -         $Tuple2((result._1 :+ StringEntry(result._2, makeString(result._3, ":"))), result._3[bpIdxRes])
873 -         }
891 + func unstakeDuck (assetIdStr) = {
892 +     let blocked = checkBlocked()
893 +     if ((blocked == blocked))
894 +         then if ((size(i.payments) != 0))
895 +             then throw("unstake doesn't require any payments")
896 +             else {
897 +                 let assetId = fromBase58String(assetIdStr)
898 +                 let address = toString(i.caller)
899 +                 let asset = value(assetInfo(assetId))
900 +                 let timeKey = keyStakedTimeByAssetId(toBase58String(assetId))
901 +                 if (!(isDefined(timeKey)))
902 +                     then throw((("NFT " + asset.name) + " is not staked"))
903 +                     else if (!(isDefined(keyStakedDuckByOwner(address))))
904 +                         then throw((("The duck " + asset.name) + " is not staked"))
905 +                         else {
906 +                             let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(toBase58String(assetId))), (("NFT " + asset.name) + " is orphaned"))
907 +                             if ((owner != address))
908 +                                 then throw("Staked NFT is not yours")
909 +                                 else {
910 +                                     let keyHealth = keyDuckHealth(assetIdStr)
911 +                                     let health = valueOrElse(getInteger(keyHealth), 100)
912 +                                     if ((health != 100))
913 +                                         then throw("Please heal your duck before unstaking")
914 +                                         else [ScriptTransfer(i.caller, 1, assetId), DeleteEntry(timeKey), DeleteEntry(keyHealth), DeleteEntry(keyDuckLocation(assetIdStr)), DeleteEntry(keyDuckIdToOwner(assetIdStr)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, assetIdStr, address)), DeleteEntry(keyStakedDuckByOwner(address))]
915 +                                     }
916 +                             }
917 +                 }
918 +         else throw("Strict value is not equal to itself.")
919 +     }
874 920  
875 921  
876 922  
877 923  @Callable(i)
878 - func flight (message,sig) = if (!(sigVerify_8Kb(message, sig, pub)))
879 -     then throw("signature does not match")
880 -     else if ((size(i.payments) != 0))
881 -         then throw("flight doesn't require any payments")
882 -         else {
883 -             let parts = split(toUtf8String(message), ";")
884 -             let hp = split(split(parts[0], "|")[0], "_")
885 -             let curHP = parseIntValue(hp[0])
886 -             let newHP = parseIntValue(hp[1])
887 -             let newLocAndTime = split(parts[1], ":")
888 -             let newLocation = newLocAndTime[0]
889 -             let time = parseIntValue(newLocAndTime[1])
890 -             if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
891 -                 then true
892 -                 else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
893 -                 then throw("signature outdated")
894 -                 else {
895 -                     let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
896 -                     let keyHealth = keyDuckHealth(duckAssetId)
897 -                     let oldFromState = valueOrElse(getInteger(keyHealth), 100)
898 -                     if ((oldFromState != curHP))
899 -                         then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
900 -                         else if ((0 >= curHP))
901 -                             then throw("You can't fly with zero health")
902 -                             else {
903 -                                 let locKey = keyDuckLocation(duckAssetId)
904 -                                 let curLocation = valueOrElse(getString(locKey), DEFAULTLOCATION)
905 -                                 if ((newLocation == curLocation))
906 -                                     then throw("You can't fly to the same location")
907 -                                     else $Tuple2([StringEntry(locKey, if ((newHP > 0))
908 -                                         then newLocation
909 -                                         else curLocation), IntegerEntry(keyHealth, newHP)], unit)
910 -                                 }
911 -                     }
912 -             }
924 + func claimRes (amount,landAssetIdStr) = {
925 +     let blocked = checkBlocked()
926 +     if ((blocked == blocked))
927 +         then if ((size(i.payments) != 0))
928 +             then throw("claimRes doesn't require any payments")
929 +             else {
930 +                 let addr = toString(i.originCaller)
931 +                 let result = claimResInternal(addr, amount)
932 +                 $Tuple2((result._1 :+ StringEntry(result._2, makeString(result._3, ":"))), result._3[bpIdxRes])
933 +                 }
934 +         else throw("Strict value is not equal to itself.")
935 +     }
913 936  
914 937  
915 938  
916 939  @Callable(i)
917 - func setHealth (health,duckAssetId) = if (if ((0 > health))
918 -     then true
919 -     else (health > 100))
920 -     then throw("HP should be within 0..100")
921 -     else [IntegerEntry(keyDuckHealth(duckAssetId), health)]
940 + func flight (message,sig) = {
941 +     let blocked = checkBlocked()
942 +     if ((blocked == blocked))
943 +         then if (!(sigVerify_8Kb(message, sig, pub)))
944 +             then throw("signature does not match")
945 +             else if ((size(i.payments) != 0))
946 +                 then throw("flight doesn't require any payments")
947 +                 else {
948 +                     let parts = split(toUtf8String(message), ";")
949 +                     let hp = split(split(parts[0], "|")[0], "_")
950 +                     let curHP = parseIntValue(hp[0])
951 +                     let newHP = parseIntValue(hp[1])
952 +                     let newLocAndTime = split(parts[1], ":")
953 +                     let newLocation = newLocAndTime[0]
954 +                     let time = parseIntValue(newLocAndTime[1])
955 +                     if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
956 +                         then true
957 +                         else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
958 +                         then throw("signature outdated")
959 +                         else {
960 +                             let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
961 +                             let keyHealth = keyDuckHealth(duckAssetId)
962 +                             let oldFromState = valueOrElse(getInteger(keyHealth), 100)
963 +                             if ((oldFromState != curHP))
964 +                                 then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
965 +                                 else if ((0 >= curHP))
966 +                                     then throw("You can't fly with zero health")
967 +                                     else {
968 +                                         let locKey = keyDuckLocation(duckAssetId)
969 +                                         let curLocation = valueOrElse(getString(locKey), DEFAULTLOCATION)
970 +                                         if ((newLocation == curLocation))
971 +                                             then throw("You can't fly to the same location")
972 +                                             else $Tuple2([StringEntry(locKey, if ((newHP > 0))
973 +                                                 then newLocation
974 +                                                 else curLocation), IntegerEntry(keyHealth, newHP)], unit)
975 +                                         }
976 +                             }
977 +                     }
978 +         else throw("Strict value is not equal to itself.")
979 +     }
922 980  
923 981  
924 982  
925 983  @Callable(i)
926 - func heal (matType,amount) = if (if ((0 > matType))
927 -     then true
928 -     else (matType >= NUMRES))
929 -     then throw(("Unknown material: " + toString(matType)))
930 -     else if ((0 >= amount))
931 -         then throw(("Amount should be positive! " + toString(amount)))
932 -         else {
933 -             let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
934 -             let keyHealth = keyDuckHealth(duckAssetId)
935 -             let oldHealth = valueOrElse(getInteger(keyHealth), 100)
936 -             if ((oldHealth >= 100))
937 -                 then throw("HP should be < 100 to heal")
984 + func setHealth (health,duckAssetId) = {
985 +     let blocked = checkBlocked()
986 +     if ((blocked == blocked))
987 +         then if (if ((0 > health))
988 +             then true
989 +             else (health > 100))
990 +             then throw("HP should be within 0..100")
991 +             else [IntegerEntry(keyDuckHealth(duckAssetId), health)]
992 +         else throw("Strict value is not equal to itself.")
993 +     }
994 + 
995 + 
996 + 
997 + @Callable(i)
998 + func heal (matType,amount) = {
999 +     let blocked = checkBlocked()
1000 +     if ((blocked == blocked))
1001 +         then if (if ((0 > matType))
1002 +             then true
1003 +             else (matType >= NUMRES))
1004 +             then throw(("Unknown material: " + toString(matType)))
1005 +             else if ((0 >= amount))
1006 +                 then throw(("Amount should be positive! " + toString(amount)))
938 1007                  else {
939 -                     let bpKey = keyBackpackByDuck(duckAssetId)
940 -                     let currentPack = getBackpack(bpKey)
941 -                     let mList = split(currentPack[bpIdxMat], "_")
942 -                     let currentAmount = parseIntValue(mList[matType])
943 -                     let deltaHealth = min([(amount / HEALCOST), (100 - oldHealth)])
944 -                     let spendAmount = (deltaHealth * HEALCOST)
945 -                     if ((spendAmount > currentAmount))
946 -                         then throw(((((("You need " + toString(spendAmount)) + " of ") + matTypes[matType]) + " to heal, but you backpack contains ") + toString(currentAmount)))
1008 +                     let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
1009 +                     let keyHealth = keyDuckHealth(duckAssetId)
1010 +                     let oldHealth = valueOrElse(getInteger(keyHealth), 100)
1011 +                     if ((oldHealth >= 100))
1012 +                         then throw("HP should be < 100 to heal")
947 1013                          else {
948 -                             let newMat = subOneInList(mList, matType, spendAmount)
1014 +                             let bpKey = keyBackpackByDuck(duckAssetId)
1015 +                             let currentPack = getBackpack(bpKey)
1016 +                             let mList = split(currentPack[bpIdxMat], "_")
1017 +                             let currentAmount = parseIntValue(mList[matType])
1018 +                             let deltaHealth = min([(amount / HEALCOST), (100 - oldHealth)])
1019 +                             let spendAmount = (deltaHealth * HEALCOST)
1020 +                             if ((spendAmount > currentAmount))
1021 +                                 then throw(((((("You need " + toString(spendAmount)) + " of ") + matTypes[matType]) + " to heal, but you backpack contains ") + toString(currentAmount)))
1022 +                                 else {
1023 +                                     let newMat = subOneInList(mList, matType, spendAmount)
949 1024  [IntegerEntry(keyHealth, (oldHealth + deltaHealth)), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], currentPack[bpIdxRes], newMat, currentPack[bpIdxProd]], ":"))]
1025 +                                     }
950 1026                              }
951 1027                      }
952 -             }
1028 +         else throw("Strict value is not equal to itself.")
1029 +     }
953 1030  
954 1031  
955 1032  
956 1033  @Callable(i)
957 1034  func updateBackpack (duckAssetId,newPack) = if ((i.caller != economyContract))
958 1035      then throw("permission denied")
959 1036      else $Tuple2([StringEntry(keyBackpackByDuck(duckAssetId), newPack)], newPack)
960 1037  
961 1038  
962 1039  
963 1040  @Callable(i)
964 - func expeditionBuy (message,sig) = if ((size(i.payments) != 1))
965 -     then throw("Exactly one payment required")
966 -     else {
967 -         let pmt = value(i.payments[0])
968 -         if ((pmt.assetId != usdnAssetId))
969 -             then throw("Allowed USDN payment only!")
970 -             else if ((pmt.amount != EXPUSDN))
971 -                 then throw(("Payment attached should be " + toString(EXPUSDN)))
972 -                 else {
973 -                     let result = expeditionCommon(false, i.caller, i.transactionId, message, sig)
974 -                     if ((result._2 == ""))
975 -                         then result
976 -                         else $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
977 -                     }
978 -         }
1041 + func expeditionBuy (message,sig) = {
1042 +     let blocked = checkBlocked()
1043 +     if ((blocked == blocked))
1044 +         then if ((size(i.payments) != 1))
1045 +             then throw("Exactly one payment required")
1046 +             else {
1047 +                 let pmt = value(i.payments[0])
1048 +                 if ((pmt.assetId != usdnAssetId))
1049 +                     then throw("Allowed USDN payment only!")
1050 +                     else if ((pmt.amount != EXPUSDN))
1051 +                         then throw(("Payment attached should be " + toString(EXPUSDN)))
1052 +                         else {
1053 +                             let result = expeditionCommon(false, i.caller, i.transactionId, message, sig)
1054 +                             if ((result._2 == ""))
1055 +                                 then result
1056 +                                 else $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1057 +                             }
1058 +                 }
1059 +         else throw("Strict value is not equal to itself.")
1060 +     }
979 1061  
980 1062  
981 1063  
982 1064  @Callable(i)
983 - func expedition (message,sig) = if ((size(i.payments) != 0))
984 -     then throw("expedition doesn't require any payments")
985 -     else expeditionCommon(true, i.caller, i.transactionId, message, sig)
1065 + func expedition (message,sig) = {
1066 +     let blocked = checkBlocked()
1067 +     if ((blocked == blocked))
1068 +         then if ((size(i.payments) != 0))
1069 +             then throw("expedition doesn't require any payments")
1070 +             else expeditionCommon(true, i.caller, i.transactionId, message, sig)
1071 +         else throw("Strict value is not equal to itself.")
1072 +     }
986 1073  
987 1074  
988 1075  
989 1076  @Callable(i)
990 - func upgradeInfra (landAssetIdIgnored) = if ((size(i.payments) != 0))
991 -     then throw("Infrastructure upgrade doesn't require any payments")
992 -     else upInfraCommon(true, i.caller, 0)
1077 + func upgradeInfra (landAssetIdIgnored) = {
1078 +     let blocked = checkBlocked()
1079 +     if ((blocked == blocked))
1080 +         then if ((size(i.payments) != 0))
1081 +             then throw("Infrastructure upgrade doesn't require any payments")
1082 +             else upInfraCommon(true, i.caller, 0)
1083 +         else throw("Strict value is not equal to itself.")
1084 +     }
993 1085  
994 1086  
995 1087  
996 1088  @Callable(i)
997 - func upgradeInfraUsdn (landAssetIdIgnored) = if ((size(i.payments) != 1))
998 -     then throw("Exactly one payment required")
999 -     else {
1000 -         let pmt = value(i.payments[0])
1001 -         if ((pmt.assetId != usdnAssetId))
1002 -             then throw("Allowed USDN payment only!")
1089 + func upgradeInfraUsdn (landAssetIdIgnored) = {
1090 +     let blocked = checkBlocked()
1091 +     if ((blocked == blocked))
1092 +         then if ((size(i.payments) != 1))
1093 +             then throw("Exactly one payment required")
1003 1094              else {
1004 -                 let result = upInfraCommon(false, i.caller, pmt.amount)
1005 -                 $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1095 +                 let pmt = value(i.payments[0])
1096 +                 if ((pmt.assetId != usdnAssetId))
1097 +                     then throw("Allowed USDN payment only!")
1098 +                     else {
1099 +                         let result = upInfraCommon(false, i.caller, pmt.amount)
1100 +                         $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1101 +                         }
1006 1102                  }
1007 -         }
1103 +         else throw("Strict value is not equal to itself.")
1104 +     }
1008 1105  
1009 1106  
1010 1107  
1011 1108  @Callable(i)
1012 - func activateArtifact (artName) = if ((size(i.payments) != 0))
1013 -     then throw("Artifact activation doesn't require any payments")
1014 -     else {
1015 -         let result =         match artName {
1016 -             case _ => 
1017 -                 if (("PRESALE" == $match0))
1018 -                     then activatePresaleArt(toString(i.caller))
1019 -                     else throw("Unknown artifact")
1020 -         }
1021 -         result
1022 -         }
1109 + func activateArtifact (artName) = {
1110 +     let blocked = checkBlocked()
1111 +     if ((blocked == blocked))
1112 +         then if ((size(i.payments) != 0))
1113 +             then throw("Artifact activation doesn't require any payments")
1114 +             else {
1115 +                 let result =                 match artName {
1116 +                     case _ => 
1117 +                         if (("PRESALE" == $match0))
1118 +                             then activatePresaleArt(toString(i.caller))
1119 +                             else throw("Unknown artifact")
1120 +                 }
1121 +                 result
1122 +                 }
1123 +         else throw("Strict value is not equal to itself.")
1124 +     }
1023 1125  
1024 1126  
1025 1127  
1026 1128  @Callable(i)
1027 1129  func mergeLands (landAssetIds) = if ((i.caller != this))
1028 1130      then throw("permission denied")
1029 -     else if ((size(i.payments) != 0))
1030 -         then throw("Lands merging doesn't require any payments")
1031 -         else mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
1131 +     else {
1132 +         let blocked = checkBlocked()
1133 +         if ((blocked == blocked))
1134 +             then if ((size(i.payments) != 0))
1135 +                 then throw("Lands merging doesn't require any payments")
1136 +                 else mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
1137 +             else throw("Strict value is not equal to itself.")
1138 +         }
1032 1139  
1033 1140  
1034 1141  
1035 1142  @Callable(i)
1036 1143  func mergeLandsUsdn (landAssetIds) = if ((i.caller != this))
1037 1144      then throw("permission denied")
1038 -     else if ((size(i.payments) != 1))
1039 -         then throw("Exactly one payment required")
1040 -         else {
1041 -             let pmt = value(i.payments[0])
1042 -             if ((pmt.assetId != usdnAssetId))
1043 -                 then throw("Allowed USDN payment only!")
1145 +     else {
1146 +         let blocked = checkBlocked()
1147 +         if ((blocked == blocked))
1148 +             then if ((size(i.payments) != 1))
1149 +                 then throw("Exactly one payment required")
1044 1150                  else {
1045 -                     let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
1046 -                     $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1151 +                     let pmt = value(i.payments[0])
1152 +                     if ((pmt.assetId != usdnAssetId))
1153 +                         then throw("Allowed USDN payment only!")
1154 +                         else {
1155 +                             let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
1156 +                             $Tuple2((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdnAssetId)), result._2)
1157 +                             }
1047 1158                      }
1048 -             }
1159 +             else throw("Strict value is not equal to itself.")
1160 +         }
1049 1161  
1050 1162  
1051 1163  
1052 1164  @Callable(i)
1053 1165  func splitByGlobalWeightsREADONLY (amount) = $Tuple2(nil, getNeededMaterials(amount))
1054 1166  
1055 1167  
1056 1168  
1057 1169  @Callable(i)
1058 1170  func splitByLocalWeightsREADONLY (amount,terrains) = {
1059 1171      let terrainCounts = countTerrains(terrains)
1060 1172      $Tuple2(nil, distributeByWeights(amount, terrainCounts))
1061 1173      }
1062 1174  
1063 1175

Old	New		Differences
185	185
186	186
187	187		func keyResProportions () = "resTypesProportions"
	188	+
	189	+
	190	+	func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
	191	+
	192	+
	193	+	func keyBlocked () = "contractsBlocked"
188	194
189	195
190	196		let recLandNum = 0

647	653		let dailyProductionByPiece = applyBonuses(landAssetId, pieces)
648	654		let bpRes = addRes(split(acc._4, "_"), terrainCounts, deltaTime, (pieces / SSIZE), dailyProductionByPiece)
649	655		let props = updateProportionsInternal(split(acc._6, "_"), terrainCounts, (pieces / SSIZE), -1)
650		-	$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)
	656	+	let lands = acc._7
	657	+	let idx = indexOf(lands, landAssetId)
	658	+	if (!(isDefined(idx)))
	659	+	then throw(("Your staked lands don't contain " + landAssetId))
	660	+	else $Tuple7(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, removeByIndex(lands, value(idx)))
651	661		}
652	662		}
653	663		}

657	667		let bpKey = keyBackpackByDuck(duckAssetId)
658	668		let currentPack = getBackpack(bpKey)
659	669		let propStr = valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0")
	670	+	let landsKey = keyStakedLandsByOwner(addr)
	671	+	let landsIn = split_51C(valueOrElse(getString(landsKey), ""), "_")
660	672		let r = {
661	673		let $l = landAssetIds
662	674		let $s = size($l)
663		-	let $acc0 = $~~Tuple6~~(formula, 0, "", currentPack[bpIdxRes], nil, propStr)
	675	+	let $acc0 = $Tuple7(formula, 0, "", currentPack[bpIdxRes], nil, propStr, landsIn)
664	676		func $f0_1 ($a,$i) = if (($i >= $s))
665	677		then $a
666	678		else checkMerge($a, $l[$i])
667	679
668	680		func $f0_2 ($a,$i) = if (($i >= $s))
669	681		then $a
670		-	else throw("List size exceeds 4")
	682	+	else throw("List size exceeds 5")
671	683
672		-	$f0_2($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4)
	684	+	$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
673	685		}
674	686		let continent = r._3
675	687		let continentIdx = valueOrErrorMessage(indexOf(continents, continent), ("Unknown continent: " + continent))

680	692		let assetId = calculateAssetId(issue)
681	693		let newLandAssetId = toBase58String(assetId)
682	694		let newMat = makeString(subtractMaterials((needMat > 0), split(currentPack[bpIdxMat], "_"), needMat), "_")
683		-	$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)
	695	+	$Tuple2(((((((((((((((r._5 :+ (if ((size(r._7) > 0))
	696	+	then StringEntry(landsKey, makeString_11C(r._7, "_"))
	697	+	else DeleteEntry(landsKey))) :+ 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)
684	698		}
685	699
686	700

737	751		func saveTxId (addr,txId) = StringEntry(keyLastTxIdByUser(toString(addr)), toBase58String(txId))
738	752
739	753
	754	+	func checkBlocked () = if (valueOrElse(getBoolean(keyBlocked()), false))
	755	+	then throw("Contracts are under maintenance")
	756	+	else unit
	757	+
	758	+
740	759		@Callable(i)
741		-	func stakeLand () = if ((size(i.payments) != 1))
742		-	then throw("Exactly one payment required")
743		-	else {
744		-	let pmt = value(i.payments[0])
745		-	let assetId = value(pmt.assetId)
746		-	let address = toString(i.caller)
747		-	if ((pmt.amount != 1))
748		-	then throw((("NFT " + LANDPREFIX) + " token should be attached as payment"))
749		-	else {
750		-	let asset = value(assetInfo(assetId))
751		-	if ((asset.issuer != this))
752		-	then throw("Unknown issuer of token")
753		-	else if (!(contains(asset.name, LANDPREFIX)))
754		-	then throw((("Only NFT " + LANDPREFIX) + " tokens are accepted"))
755		-	else {
756		-	let landNumSize = drop(asset.name, 4)
757		-	let landNum = if (contains(landNumSize, "XXL"))
758		-	then dropRight(landNumSize, 3)
759		-	else if (contains(landNumSize, "XL"))
760		-	then dropRight(landNumSize, 2)
761		-	else dropRight(landNumSize, 1)
762		-	if (!(isDefined(parseInt(landNum))))
763		-	then throw(("Cannot parse land number from " + asset.name))
764		-	else {
765		-	let landAssetId = toBase58String(assetId)
766		-	let timeKey = keyStakedTimeByAssetId(landAssetId)
767		-	if (isDefined(getInteger(timeKey)))
768		-	then throw((("NFT " + asset.name) + " is already staked"))
769		-	else {
770		-	let d = split(asset.description, "_")
771		-	let terrainCounts = countTerrains(d[recTerrains])
772		-	let props = updateProportions(terrainCounts, (numPiecesBySize(d[recLandSize]) / SSIZE), 1)
773		-	[IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, address), lastBlock.timestamp), StringEntry(keyLandAssetIdToOwner(landAssetId), address), StringEntry(keyLandNumToOwner(landNum), address), StringEntry(keyResProportions(), props)]
774		-	}
775		-	}
776		-	}
777		-	}
778		-	}
	760	+	func setBlocked (isBlocked) = if ((i.caller != this))
	761	+	then throw("permission denied")
	762	+	else [BooleanEntry(keyBlocked(), isBlocked)]
779	763
780	764
781	765
782	766		@Callable(i)
783		-	func unstakeLand (landAssetIdStr) = if ((size(i.payments) != 0))
784		-	then throw("unstake doesn't require any payments")
785		-	else {
786		-	let addr = toString(i.caller)
787		-	let c = checkClaimConditions(addr)
788		-	let terrainCounts = countTerrains(c._3[recTerrains])
789		-	let pieces = numPiecesBySize(c._3[recLandSize])
790		-	let props = updateProportions(terrainCounts, (pieces / SSIZE), -1)
791		-	let claimResult = claimAll(addr, c._2, pieces)
792		-	[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, ":"))]
793		-	}
	767	+	func stakeLand () = {
	768	+	let blocked = checkBlocked()
	769	+	if ((blocked == blocked))
	770	+	then if ((size(i.payments) != 1))
	771	+	then throw("Exactly one payment required")
	772	+	else {
	773	+	let pmt = value(i.payments[0])
	774	+	let assetId = value(pmt.assetId)
	775	+	let address = toString(i.caller)
	776	+	if ((pmt.amount != 1))
	777	+	then throw((("NFT " + LANDPREFIX) + " token should be attached as payment"))
	778	+	else {
	779	+	let asset = value(assetInfo(assetId))
	780	+	if ((asset.issuer != this))
	781	+	then throw("Unknown issuer of token")
	782	+	else if (!(contains(asset.name, LANDPREFIX)))
	783	+	then throw((("Only NFT " + LANDPREFIX) + " tokens are accepted"))
	784	+	else {
	785	+	let landNumSize = drop(asset.name, 4)
	786	+	let landNum = if (contains(landNumSize, "XXL"))
	787	+	then dropRight(landNumSize, 3)
	788	+	else if (contains(landNumSize, "XL"))
	789	+	then dropRight(landNumSize, 2)
	790	+	else dropRight(landNumSize, 1)
	791	+	if (!(isDefined(parseInt(landNum))))
	792	+	then throw(("Cannot parse land number from " + asset.name))
	793	+	else {
	794	+	let landAssetId = toBase58String(assetId)
	795	+	let timeKey = keyStakedTimeByAssetId(landAssetId)
	796	+	if (isDefined(getInteger(timeKey)))
	797	+	then throw((("NFT " + asset.name) + " is already staked"))
	798	+	else {
	799	+	let d = split(asset.description, "_")
	800	+	let terrainCounts = countTerrains(d[recTerrains])
	801	+	let props = updateProportions(terrainCounts, (numPiecesBySize(d[recLandSize]) / SSIZE), 1)
	802	+	let lands = split_51C(valueOrElse(getString(keyStakedLandsByOwner(address)), ""), "_")
	803	+	if (containsElement(lands, landAssetId))
	804	+	then throw(("Your staked lands already contain " + landAssetId))
	805	+	else [IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, address), lastBlock.timestamp), StringEntry(keyStakedLandsByOwner(address), makeString_11C((lands :+ landAssetId), "_")), StringEntry(keyLandAssetIdToOwner(landAssetId), address), StringEntry(keyLandNumToOwner(landNum), address), StringEntry(keyResProportions(), props)]
	806	+	}
	807	+	}
	808	+	}
	809	+	}
	810	+	}
	811	+	else throw("Strict value is not equal to itself.")
	812	+	}
794	813
795	814
796	815
797	816		@Callable(i)
798		-	func stakeDuck () = if ((size(i.payments) != 1))
799		-	then throw("Exactly one payment required")
800		-	else {
801		-	let pmt = value(i.payments[0])
802		-	let assetId = value(pmt.assetId)
803		-	let address = toString(i.caller)
804		-	if ((pmt.amount != 1))
805		-	then throw((("NFT " + DUCKPREFIX) + " token should be attached as payment"))
	817	+	func unstakeLand (landAssetIdIgnored) = {
	818	+	let blocked = checkBlocked()
	819	+	if ((blocked == blocked))
	820	+	then if ((size(i.payments) != 0))
	821	+	then throw("unstake doesn't require any payments")
806	822		else {
807		-	let asset = value(assetInfo(assetId))
808		-	if (if ((asset.issuer != incubatorAddr))
809		-	then (asset.issuer != breederAddr)
810		-	else false)
811		-	then throw((("Unknown issuer of " + DUCKPREFIX) + " token"))
812		-	else if (!(contains(asset.name, DUCKPREFIX)))
813		-	then throw((("Only NFT " + DUCKPREFIX) + " tokens are accepted"))
814		-	else {
815		-	let assetIdStr = toBase58String(assetId)
816		-	let timeKey = keyStakedTimeByAssetId(assetIdStr)
817		-	if (isDefined(getInteger(timeKey)))
818		-	then throw((("NFT " + asset.name) + " is already staked"))
819		-	else if (isDefined(getString(keyStakedDuckByOwner(address))))
820		-	then throw(("You already staked one duck: " + asset.name))
821		-	else {
822		-	let locKey = keyDuckLocation(assetIdStr)
823		-	let location = getString(locKey)
824		-	let bpKey = keyBackpackByDuck(assetIdStr)
825		-	let backpack = getString(bpKey)
826		-	([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, toBase58String(assetId), address), lastBlock.timestamp), StringEntry(keyDuckIdToOwner(assetIdStr), address), StringEntry(keyStakedDuckByOwner(address), assetIdStr)] ++ (if (isDefined(location))
827		-	then nil
828		-	else ([StringEntry(locKey, DEFAULTLOCATION)] ++ (if (isDefined(backpack))
829		-	then nil
830		-	else ([StringEntry(bpKey, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(keyDuckHealth(assetIdStr), 100))))))
831		-	}
832		-	}
	823	+	let addr = toString(i.caller)
	824	+	let c = checkClaimConditions(addr)
	825	+	let landAssetId = c._2
	826	+	let landsKey = keyStakedLandsByOwner(addr)
	827	+	let terrainCounts = countTerrains(c._3[recTerrains])
	828	+	let pieces = numPiecesBySize(c._3[recLandSize])
	829	+	let props = updateProportions(terrainCounts, (pieces / SSIZE), -1)
	830	+	let claimResult = claimAll(addr, landAssetId, pieces)
	831	+	let lands = split_51C(valueOrElse(getString(landsKey), ""), "_")
	832	+	let idx = indexOf(lands, landAssetId)
	833	+	if (!(isDefined(idx)))
	834	+	then throw(("Your staked lands don't contain " + landAssetId))
	835	+	else [ScriptTransfer(i.caller, 1, fromBase58String(landAssetId)), DeleteEntry(keyStakedTimeByAssetId(landAssetId)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, addr)), StringEntry(keyResProportions(), props), StringEntry(claimResult._2, makeString(claimResult._3, ":")), if ((size(lands) > 1))
	836	+	then StringEntry(landsKey, makeString_11C(removeByIndex(lands, value(idx)), "_"))
	837	+	else DeleteEntry(landsKey)]
833	838		}
834		-	}
	839	+	else throw("Strict value is not equal to itself.")
	840	+	}
835	841
836	842
837	843
838	844		@Callable(i)
839		-	func unstakeDuck (assetIdStr) = if ((size(i.payments) != 0))
840		-	then throw("unstake doesn't require any payments")
841		-	else {
842		-	let assetId = fromBase58String(assetIdStr)
843		-	let address = toString(i.caller)
844		-	let asset = value(assetInfo(assetId))
845		-	let timeKey = keyStakedTimeByAssetId(toBase58String(assetId))
846		-	if (!(isDefined(timeKey)))
847		-	then throw((("NFT " + asset.name) + " is not staked"))
848		-	else if (!(isDefined(keyStakedDuckByOwner(address))))
849		-	then throw((("The duck " + asset.name) + " is not staked"))
850		-	else {
851		-	let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(toBase58String(assetId))), (("NFT " + asset.name) + " is orphaned"))
852		-	if ((owner != address))
853		-	then throw("Staked NFT is not yours")
854		-	else {
855		-	let keyHealth = keyDuckHealth(assetIdStr)
856		-	let health = valueOrElse(getInteger(keyHealth), 100)
857		-	if ((health != 100))
858		-	then throw("Please heal your duck before unstaking")
859		-	else [ScriptTransfer(i.caller, 1, assetId), DeleteEntry(timeKey), DeleteEntry(keyHealth), DeleteEntry(keyDuckLocation(assetIdStr)), DeleteEntry(keyDuckIdToOwner(assetIdStr)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, assetIdStr, address)), DeleteEntry(keyStakedDuckByOwner(address))]
860		-	}
861		-	}
862		-	}
	845	+	func stakeDuck () = {
	846	+	let blocked = checkBlocked()
	847	+	if ((blocked == blocked))
	848	+	then if ((size(i.payments) != 1))
	849	+	then throw("Exactly one payment required")
	850	+	else {
	851	+	let pmt = value(i.payments[0])
	852	+	let assetId = value(pmt.assetId)
	853	+	let address = toString(i.caller)
	854	+	if ((pmt.amount != 1))
	855	+	then throw((("NFT " + DUCKPREFIX) + " token should be attached as payment"))
	856	+	else {
	857	+	let asset = value(assetInfo(assetId))
	858	+	if (if ((asset.issuer != incubatorAddr))
	859	+	then (asset.issuer != breederAddr)
	860	+	else false)
	861	+	then throw((("Unknown issuer of " + DUCKPREFIX) + " token"))
	862	+	else if (!(contains(asset.name, DUCKPREFIX)))
	863	+	then throw((("Only NFT " + DUCKPREFIX) + " tokens are accepted"))
	864	+	else {
	865	+	let assetIdStr = toBase58String(assetId)
	866	+	let timeKey = keyStakedTimeByAssetId(assetIdStr)
	867	+	if (isDefined(getInteger(timeKey)))
	868	+	then throw((("NFT " + asset.name) + " is already staked"))
	869	+	else if (isDefined(getString(keyStakedDuckByOwner(address))))
	870	+	then throw(("You already staked one duck: " + asset.name))
	871	+	else {
	872	+	let locKey = keyDuckLocation(assetIdStr)
	873	+	let location = getString(locKey)
	874	+	let bpKey = keyBackpackByDuck(assetIdStr)
	875	+	let backpack = getString(bpKey)
	876	+	([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, toBase58String(assetId), address), lastBlock.timestamp), StringEntry(keyDuckIdToOwner(assetIdStr), address), StringEntry(keyStakedDuckByOwner(address), assetIdStr)] ++ (if (isDefined(location))
	877	+	then nil
	878	+	else ([StringEntry(locKey, DEFAULTLOCATION)] ++ (if (isDefined(backpack))
	879	+	then nil
	880	+	else ([StringEntry(bpKey, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(keyDuckHealth(assetIdStr), 100))))))
	881	+	}
	882	+	}
	883	+	}
	884	+	}
	885	+	else throw("Strict value is not equal to itself.")
	886	+	}
863	887
864	888
865	889
866	890		@Callable(i)
867		-	func claimRes (amount,landAssetIdStr) = if ((size(i.payments) != 0))
868		-	then throw("claimRes doesn't require any payments")
869		-	else {
870		-	let addr = toString(i.originCaller)
871		-	let result = claimResInternal(addr, amount)
872		-	$Tuple2((result._1 :+ StringEntry(result._2, makeString(result._3, ":"))), result._3[bpIdxRes])
873		-	}
	891	+	func unstakeDuck (assetIdStr) = {
	892	+	let blocked = checkBlocked()
	893	+	if ((blocked == blocked))
	894	+	then if ((size(i.payments) != 0))
	895	+	then throw("unstake doesn't require any payments")
	896	+	else {
	897	+	let assetId = fromBase58String(assetIdStr)
	898	+	let address = toString(i.caller)
	899	+	let asset = value(assetInfo(assetId))
	900	+	let timeKey = keyStakedTimeByAssetId(toBase58String(assetId))
	901	+	if (!(isDefined(timeKey)))
	902	+	then throw((("NFT " + asset.name) + " is not staked"))
	903	+	else if (!(isDefined(keyStakedDuckByOwner(address))))
	904	+	then throw((("The duck " + asset.name) + " is not staked"))
	905	+	else {
	906	+	let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(toBase58String(assetId))), (("NFT " + asset.name) + " is orphaned"))
	907	+	if ((owner != address))
	908	+	then throw("Staked NFT is not yours")
	909	+	else {
	910	+	let keyHealth = keyDuckHealth(assetIdStr)
	911	+	let health = valueOrElse(getInteger(keyHealth), 100)
	912	+	if ((health != 100))
	913	+	then throw("Please heal your duck before unstaking")
	914	+	else [ScriptTransfer(i.caller, 1, assetId), DeleteEntry(timeKey), DeleteEntry(keyHealth), DeleteEntry(keyDuckLocation(assetIdStr)), DeleteEntry(keyDuckIdToOwner(assetIdStr)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, assetIdStr, address)), DeleteEntry(keyStakedDuckByOwner(address))]
	915	+	}
	916	+	}
	917	+	}
	918	+	else throw("Strict value is not equal to itself.")
	919	+	}
874	920
875	921
876	922
877	923		@Callable(i)
878		-	func flight (message,sig) = if (!(sigVerify_8Kb(message, sig, pub)))
879		-	then throw("signature does not match")
880		-	else if ((size(i.payments) != 0))
881		-	then throw("flight doesn't require any payments")
882		-	else {
883		-	let parts = split(toUtf8String(message), ";")
884		-	let hp = split(split(parts[0], "\|")[0], "_")
885		-	let curHP = parseIntValue(hp[0])
886		-	let newHP = parseIntValue(hp[1])
887		-	let newLocAndTime = split(parts[1], ":")
888		-	let newLocation = newLocAndTime[0]
889		-	let time = parseIntValue(newLocAndTime[1])
890		-	if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
891		-	then true
892		-	else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
893		-	then throw("signature outdated")
894		-	else {
895		-	let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
896		-	let keyHealth = keyDuckHealth(duckAssetId)
897		-	let oldFromState = valueOrElse(getInteger(keyHealth), 100)
898		-	if ((oldFromState != curHP))
899		-	then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
900		-	else if ((0 >= curHP))
901		-	then throw("You can't fly with zero health")
902		-	else {
903		-	let locKey = keyDuckLocation(duckAssetId)
904		-	let curLocation = valueOrElse(getString(locKey), DEFAULTLOCATION)
905		-	if ((newLocation == curLocation))
906		-	then throw("You can't fly to the same location")
907		-	else $Tuple2([StringEntry(locKey, if ((newHP > 0))
908		-	then newLocation
909		-	else curLocation), IntegerEntry(keyHealth, newHP)], unit)
910		-	}
911		-	}
912		-	}
	924	+	func claimRes (amount,landAssetIdStr) = {
	925	+	let blocked = checkBlocked()
	926	+	if ((blocked == blocked))
	927	+	then if ((size(i.payments) != 0))
	928	+	then throw("claimRes doesn't require any payments")
	929	+	else {
	930	+	let addr = toString(i.originCaller)
	931	+	let result = claimResInternal(addr, amount)
	932	+	$Tuple2((result._1 :+ StringEntry(result._2, makeString(result._3, ":"))), result._3[bpIdxRes])
	933	+	}
	934	+	else throw("Strict value is not equal to itself.")
	935	+	}
913	936
914	937
915	938
916	939		@Callable(i)
917		-	func setHealth (health,duckAssetId) = if (if ((0 > health))
918		-	then true
919		-	else (health > 100))
920		-	then throw("HP should be within 0..100")
921		-	else [IntegerEntry(keyDuckHealth(duckAssetId), health)]
	940	+	func flight (message,sig) = {
	941	+	let blocked = checkBlocked()
	942	+	if ((blocked == blocked))
	943	+	then if (!(sigVerify_8Kb(message, sig, pub)))
	944	+	then throw("signature does not match")
	945	+	else if ((size(i.payments) != 0))
	946	+	then throw("flight doesn't require any payments")
	947	+	else {
	948	+	let parts = split(toUtf8String(message), ";")
	949	+	let hp = split(split(parts[0], "\|")[0], "_")
	950	+	let curHP = parseIntValue(hp[0])
	951	+	let newHP = parseIntValue(hp[1])
	952	+	let newLocAndTime = split(parts[1], ":")
	953	+	let newLocation = newLocAndTime[0]
	954	+	let time = parseIntValue(newLocAndTime[1])
	955	+	if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
	956	+	then true
	957	+	else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
	958	+	then throw("signature outdated")
	959	+	else {
	960	+	let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
	961	+	let keyHealth = keyDuckHealth(duckAssetId)
	962	+	let oldFromState = valueOrElse(getInteger(keyHealth), 100)
	963	+	if ((oldFromState != curHP))
	964	+	then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
	965	+	else if ((0 >= curHP))
	966	+	then throw("You can't fly with zero health")
	967	+	else {
	968	+	let locKey = keyDuckLocation(duckAssetId)
	969	+	let curLocation = valueOrElse(getString(locKey), DEFAULTLOCATION)
	970	+	if ((newLocation == curLocation))
	971	+	then throw("You can't fly to the same location")
	972	+	else $Tuple2([StringEntry(locKey, if ((newHP > 0))
	973	+	then newLocation
	974	+	else curLocation), IntegerEntry(keyHealth, newHP)], unit)
	975	+	}
	976	+	}
	977	+	}
	978	+	else throw("Strict value is not equal to itself.")
	979	+	}
922	980
923	981
924	982
925	983		@Callable(i)
926		-	func heal (matType,amount) = if (if ((0 > matType))
927		-	then true
928		-	else (matType >= NUMRES))
929		-	then throw(("Unknown material: " + toString(matType)))
930		-	else if ((0 >= amount))
931		-	then throw(("Amount should be positive! " + toString(amount)))
932		-	else {
933		-	let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
934		-	let keyHealth = keyDuckHealth(duckAssetId)
935		-	let oldHealth = valueOrElse(getInteger(keyHealth), 100)
936		-	if ((oldHealth >= 100))
937		-	then throw("HP should be < 100 to heal")
	984	+	func setHealth (health,duckAssetId) = {
	985	+	let blocked = checkBlocked()
	986	+	if ((blocked == blocked))
	987	+	then if (if ((0 > health))
	988	+	then true
	989	+	else (health > 100))
	990	+	then throw("HP should be within 0..100")
	991	+	else [IntegerEntry(keyDuckHealth(duckAssetId), health)]
	992	+	else throw("Strict value is not equal to itself.")
	993	+	}
	994	+
	995	+
	996	+
	997	+	@Callable(i)
	998	+	func heal (matType,amount) = {
	999	+	let blocked = checkBlocked()
	1000	+	if ((blocked == blocked))
	1001	+	then if (if ((0 > matType))
	1002	+	then true
	1003	+	else (matType >= NUMRES))
	1004	+	then throw(("Unknown material: " + toString(matType)))
	1005	+	else if ((0 >= amount))
	1006	+	then throw(("Amount should be positive! " + toString(amount)))
938	1007		else {
939		-	let bpKey = keyBackpackByDuck(duckAssetId)
940		-	let currentPack = getBackpack(bpKey)
941		-	let mList = split(currentPack[bpIdxMat], "_")
942		-	let currentAmount = parseIntValue(mList[matType])
943		-	let deltaHealth = min([(amount / HEALCOST), (100 - oldHealth)])
944		-	let spendAmount = (deltaHealth * HEALCOST)
945		-	if ((spendAmount > currentAmount))
946		-	then throw(((((("You need " + toString(spendAmount)) + " of ") + matTypes[matType]) + " to heal, but you backpack contains ") + toString(currentAmount)))
	1008	+	let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
	1009	+	let keyHealth = keyDuckHealth(duckAssetId)
	1010	+	let oldHealth = valueOrElse(getInteger(keyHealth), 100)
	1011	+	if ((oldHealth >= 100))
	1012	+	then throw("HP should be < 100 to heal")
947	1013		else {

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let chain = take(drop(this.bytes, 1), 1)
5	5
6	6		let usdnAssetId = match chain {
7	7		case _ =>
8	8		if ((base58'2W' == $match0))
9	9		then base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
10	10		else if ((base58'2T' == $match0))
11	11		then base58'HezsdQuRDtzksAYUy97gfhKy7Z1NW2uXYSHA3bgqenNZ'
12	12		else throw("Unknown chain")
13	13		}
14	14
15	15		let incubatorAddr = match chain {
16	16		case _ =>
17	17		if ((base58'2W' == $match0))
18	18		then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
19	19		else if ((base58'2T' == $match0))
20	20		then this
21	21		else throw("Unknown chain")
22	22		}
23	23
24	24		let breederAddr = match chain {
25	25		case _ =>
26	26		if ((base58'2W' == $match0))
27	27		then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
28	28		else if ((base58'2T' == $match0))
29	29		then this
30	30		else throw("Unknown chain")
31	31		}
32	32
33	33		let economyContract = addressFromStringValue(match chain {
34	34		case _ =>
35	35		if ((base58'2W' == $match0))
36	36		then "3P2sk1KncSxRaZs8b4CWGPw2jkvvav74u4D"
37	37		else if ((base58'2T' == $match0))
38	38		then "3N8y4wxX3JC4TdrCJBXX16SjWf6X256hrep"
39	39		else throw("Unknown chain")
40	40		})
41	41
42	42		let pub = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
43	43
44	44		let HEALCOST = 10000
45	45
46	46		let LANDPREFIX = "LAND"
47	47
48	48		let DUCKPREFIX = "DUCK"
49	49
50	50		let DEFAULTLOCATION = "Africa_F_Africa"
51	51
52	52		let NUMRES = 6
53	53
54	54		let SSIZE = 25
55	55
56	56		let MSIZE = 100
57	57
58	58		let LSIZE = 225
59	59
60	60		let XLSIZE = 400
61	61
62	62		let XXLSIZE = 625
63	63
64	64		let DAILYRESBYPIECE = 3456000
65	65
66	66		let DAYMILLIS = 86400000
67	67
68	68		let FIVEMINUTESMILLIS = 300000
69	69
70	70		let RESOURCEPRICEMIN = 158549
71	71
72	72		let InfraUpgradeCostS = match chain {
73	73		case _ =>
74	74		if ((base58'2W' == $match0))
75	75		then 6307198406
76	76		else if ((base58'2T' == $match0))
77	77		then 63071984
78	78		else throw("Unknown chain")
79	79		}
80	80
81	81		let InfraUpgradeCostSUsdn = match chain {
82	82		case _ =>
83	83		if ((base58'2W' == $match0))
84	84		then 40000000
85	85		else if ((base58'2T' == $match0))
86	86		then 400000
87	87		else throw("Unknown chain")
88	88		}
89	89
90	90		let EXPMATERIALS = match chain {
91	91		case _ =>
92	92		if ((base58'2W' == $match0))
93	93		then 157679960139
94	94		else if ((base58'2T' == $match0))
95	95		then 1576799601
96	96		else throw("Unknown chain")
97	97		}
98	98
99	99		let EXPUSDN = match chain {
100	100		case _ =>
101	101		if ((base58'2W' == $match0))
102	102		then 1000000000
103	103		else if ((base58'2T' == $match0))
104	104		then 10000000
105	105		else throw("Unknown chain")
106	106		}
107	107
108	108		let MULT6 = 1000000
109	109
110	110		let FIVEX = toBigInt(5)
111	111
112	112		let TWENTYX = toBigInt(20)
113	113
114	114		let TWENTY2X = toBigInt((20 * 20))
115	115
116	116		let TWENTY3X = toBigInt(((20 * 20) * 20))
117	117
118	118		let TWENTY4X = toBigInt((((20 * 20) * 20) * 20))
119	119
120	120		let TWENTY5X = toBigInt(((((20 * 20) * 20) * 20) * 20))
121	121
122	122		let matTypes = ["Fuel", "Metal", "Plank", "Glass", "Plastic", "Protein"]
123	123
124	124		let continents = ["Asia", "Europe", "Americas", "Oceania", "Africa"]
125	125
126	126		let ARTPRESALE = "PRESALE"
127	127
128	128		let PRESALENUMLANDS = 500
129	129
130	130		func keyLastTxIdByUser (addr) = ("lastTxIdByUser_" + addr)
131	131
132	132
133	133		func keyNextFreeLandNum () = "nextLandNum"
134	134
135	135
136	136		func keyLandToAssetId (landNum) = ("landToAsset_" + landNum)
137	137
138	138
139	139		func keyNftName (landNum,landSize) = ((LANDPREFIX + landNum) + landSize)
140	140
141	141
142	142		func keyLandAssetIdToOwner (assetId) = ("nftOwner_" + assetId)
143	143
144	144
145	145		func keyDuckIdToOwner (assetId) = ("duckOwner_" + assetId)
146	146
147	147
148	148		func keyStakedTimeByAssetId (assetId) = ("stakedTime_" + assetId)
149	149
150	150
151	151		func keyInfraLevelByAssetId (assetId) = ("infraLevel_" + assetId)
152	152
153	153
154	154		func keyInfraLevelByAssetIdAndOwner (assetId,ownerAddr) = ((("infraLevelByAssetIdAndOwner_" + assetId) + "_") + ownerAddr)
155	155
156	156
157	157		func keyPresaleArtActivatedByAssetId (assetId) = ("presaleArtActivated_" + assetId)
158	158
159	159
160	160		func keyPresaleArtActivatedByAssetIdAndOwner (assetId,ownerAddr) = ((("presaleArtActivatedByAssetIdAndOwner_" + assetId) + "_") + ownerAddr)
161	161
162	162
163	163		func keyLandArtStatusByTypeAndAssetId (type,assetId) = makeString(["landArtStatus", type, assetId], "_")
164	164
165	165
166	166		func keyLandArtStatusByTypeAssetIdAndOwner (type,assetId,ownerAddr) = makeString(["landArtStatusByTypeAssetIdAndOwner", type, assetId, ownerAddr], "_")
167	167
168	168
169	169		func keyStakedDuckByOwner (ownerAddr) = ("stakedDuckByOwner_" + ownerAddr)
170	170
171	171
172	172		func keyStakedTimeByTypeAssetIdAndOwner (nftType,assetId,ownerAddr) = ((((("stakedTimeByTypeAssetIdAndOwner_" + nftType) + "_") + assetId) + "_") + ownerAddr)
173	173
174	174
175	175		func keyLandNumToOwner (landNum) = ("landOwner_" + landNum)
176	176
177	177
178	178		func keyBackpackByDuck (duckAssetId) = ("backPack_" + duckAssetId)
179	179
180	180
181	181		func keyDuckLocation (duckAssetId) = ("duckLocation_" + duckAssetId)
182	182
183	183
184	184		func keyDuckHealth (duckAssetId) = ("duckHealth_" + duckAssetId)
185	185
186	186
187	187		func keyResProportions () = "resTypesProportions"
	188	+
	189	+
	190	+	func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
	191	+
	192	+
	193	+	func keyBlocked () = "contractsBlocked"
188	194
189	195
190	196		let recLandNum = 0
191	197
192	198		let recLandSize = 1
193	199
194	200		let recTerrains = 2
195	201
196	202		let recContinent = 3
197	203
198	204		let locIdxContinent = 0
199	205
200	206		let locIdxType = 1
201	207
202	208		let locIdxId = 2
203	209
204	210		let bpIdxLevel = 0
205	211
206	212		let bpIdxRes = 1
207	213
208	214		let bpIdxMat = 2
209	215
210	216		let bpIdxProd = 3
211	217
212	218		func asString (v) = match v {
213	219		case s: String =>
214	220		s
215	221		case _ =>
216	222		throw("fail to cast into String")
217	223		}
218	224
219	225
220	226		func distributeByWeights (total,weights) = {
221	227		let sum = (((((weights[0] + weights[1]) + weights[2]) + weights[3]) + weights[4]) + weights[5])
222	228		if ((0 >= sum))
223	229		then throw("Zero weights sum")
224	230		else {
225	231		let norm6 = fraction(total, MULT6, sum)
226	232		func normalizer (acc,elem) = (acc :+ fraction(elem, norm6, MULT6))
227	233
228	234		let $l = weights
229	235		let $s = size($l)
230	236		let $acc0 = nil
231	237		func $f0_1 ($a,$i) = if (($i >= $s))
232	238		then $a
233	239		else normalizer($a, $l[$i])
234	240
235	241		func $f0_2 ($a,$i) = if (($i >= $s))
236	242		then $a
237	243		else throw("List size exceeds 6")
238	244
239	245		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
240	246		}
241	247		}
242	248
243	249
244	250		func getNeededMaterials (total) = {
245	251		let props = split(value(getString(keyResProportions())), "_")
246	252		if ((size(props) != NUMRES))
247	253		then throw("Wrong proportions data")
248	254		else {
249	255		let r = [parseIntValue(props[0]), parseIntValue(props[1]), parseIntValue(props[2]), parseIntValue(props[3]), parseIntValue(props[4]), parseIntValue(props[5])]
250	256		distributeByWeights(total, r)
251	257		}
252	258		}
253	259
254	260
255	261		func subtractMaterials (shouldUseMat,has,totalNeed) = {
256	262		let need = getNeededMaterials(totalNeed)
257	263		func subtractor (acc,idx) = {
258	264		let result = (parseIntValue(has[idx]) - need[idx])
259	265		if ((0 > result))
260	266		then throw(((((("Not enough material idx=" + toString(idx)) + ", you have ") + has[idx]) + ", but need ") + toString(need[idx])))
261	267		else (acc :+ toString(result))
262	268		}
263	269
264	270		if (shouldUseMat)
265	271		then {
266	272		let $l = [0, 1, 2, 3, 4, 5]
267	273		let $s = size($l)
268	274		let $acc0 = nil
269	275		func $f0_1 ($a,$i) = if (($i >= $s))
270	276		then $a
271	277		else subtractor($a, $l[$i])
272	278
273	279		func $f0_2 ($a,$i) = if (($i >= $s))
274	280		then $a
275	281		else throw("List size exceeds 6")
276	282
277	283		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
278	284		}
279	285		else has
280	286		}
281	287
282	288
283	289		func updateProportionsInternal (propList,terrainCounts,landSizeIndex,sign) = if ((size(propList) != NUMRES))
284	290		then throw("Wrong proportions data")
285	291		else {
286	292		func updater (acc,i) = {
287	293		let result = (parseIntValue(propList[i]) + ((sign * terrainCounts[i]) * landSizeIndex))
288	294		if ((0 > result))
289	295		then throw(((((((("Panic! Pieces of type=" + toString(i)) + ", sign=") + toString(sign)) + ", terrainCounts[i]=") + toString(terrainCounts[i])) + ", landSizeIndex=") + toString(landSizeIndex)))
290	296		else (acc :+ toString(result))
291	297		}
292	298
293	299		let r = {
294	300		let $l = [0, 1, 2, 3, 4, 5]
295	301		let $s = size($l)
296	302		let $acc0 = nil
297	303		func $f0_1 ($a,$i) = if (($i >= $s))
298	304		then $a
299	305		else updater($a, $l[$i])
300	306
301	307		func $f0_2 ($a,$i) = if (($i >= $s))
302	308		then $a
303	309		else throw("List size exceeds 6")
304	310
305	311		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
306	312		}
307	313		makeString(r, "_")
308	314		}
309	315
310	316
311	317		func updateProportions (terrainCounts,landSizeIndex,sign) = {
312	318		let propList = split(valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0"), "_")
313	319		updateProportionsInternal(propList, terrainCounts, landSizeIndex, sign)
314	320		}
315	321
316	322
317	323		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)]
318	324
319	325
320	326		func numPiecesBySize (landSize) = match landSize {
321	327		case _ =>
322	328		if (("S" == $match0))
323	329		then SSIZE
324	330		else if (("M" == $match0))
325	331		then MSIZE
326	332		else if (("L" == $match0))
327	333		then LSIZE
328	334		else if (("XL" == $match0))
329	335		then XLSIZE
330	336		else if (("XXL" == $match0))
331	337		then XXLSIZE
332	338		else throw("Unknown land size")
333	339		}
334	340
335	341
336	342		func subOneInList (aList,idx,amount) = {
337	343		func subber (acc,i) = (acc :+ (if ((i == idx))
338	344		then toString((parseIntValue(aList[i]) - amount))
339	345		else aList[i]))
340	346
341	347		let r = {
342	348		let $l = [0, 1, 2, 3, 4, 5]
343	349		let $s = size($l)
344	350		let $acc0 = nil
345	351		func $f0_1 ($a,$i) = if (($i >= $s))
346	352		then $a
347	353		else subber($a, $l[$i])
348	354
349	355		func $f0_2 ($a,$i) = if (($i >= $s))
350	356		then $a
351	357		else throw("List size exceeds 6")
352	358
353	359		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
354	360		}
355	361		makeString(r, "_")
356	362		}
357	363
358	364
359	365		func addRes (currentRes,terrainCounts,deltaTime,landSizeIndex,dailyByPieceWithBonuses) = {
360	366		func adder (acc,i) = {
361	367		let resOfType = ((fraction(deltaTime, dailyByPieceWithBonuses, DAYMILLIS) * terrainCounts[i]) * landSizeIndex)
362	368		(acc :+ toString((parseIntValue(currentRes[i]) + resOfType)))
363	369		}
364	370
365	371		let r = {
366	372		let $l = [0, 1, 2, 3, 4, 5]
367	373		let $s = size($l)
368	374		let $acc0 = nil
369	375		func $f0_1 ($a,$i) = if (($i >= $s))
370	376		then $a
371	377		else adder($a, $l[$i])
372	378
373	379		func $f0_2 ($a,$i) = if (($i >= $s))
374	380		then $a
375	381		else throw("List size exceeds 6")
376	382
377	383		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
378	384		}
379	385		makeString(r, "_")
380	386		}
381	387
382	388
383	389		func abs (x) = if ((x >= toBigInt(0)))
384	390		then x
385	391		else -(x)
386	392
387	393
388	394		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]]
389	395
390	396		func genChar (n,freqs) = {
391	397		let rem = toInt((n % TWENTYX))
392	398		let letter = if ((freqs[0] > rem))
393	399		then "A"
394	400		else if ((freqs[1] > rem))
395	401		then "B"
396	402		else if ((freqs[2] > rem))
397	403		then "C"
398	404		else if ((freqs[3] > rem))
399	405		then "D"
400	406		else if ((freqs[4] > rem))
401	407		then "E"
402	408		else "F"
403	409		letter
404	410		}
405	411
406	412
407	413		func genTerrains (seed,continentIdx) = {
408	414		let f = freq[continentIdx]
409	415		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))
410	416
411	417		let t = {
412	418		let $l = [1, 2, 3, 4, 5]
413	419		let $s = size($l)
414	420		let $acc0 = $Tuple2("", (seed / FIVEX))
415	421		func $f0_1 ($a,$i) = if (($i >= $s))
416	422		then $a
417	423		else terrainGenerator($a, $l[$i])
418	424
419	425		func $f0_2 ($a,$i) = if (($i >= $s))
420	426		then $a
421	427		else throw("List size exceeds 5")
422	428
423	429		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
424	430		}
425	431		t._1
426	432		}
427	433
428	434
429	435		func getBackpack (bpKey) = {
430	436		let p = split(valueOrElse(getString(bpKey), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
431	437		[toString(valueOrElse(parseInt(p[bpIdxLevel]), 0)), if ((size(split(p[bpIdxRes], "_")) == NUMRES))
432	438		then p[bpIdxRes]
433	439		else "0_0_0_0_0_0", if ((size(split(p[bpIdxMat], "_")) == NUMRES))
434	440		then p[bpIdxMat]
435	441		else "0_0_0_0_0_0", p[bpIdxProd]]
436	442		}
437	443
438	444
439	445		func expeditionCommon (shouldUseMat,caller,txId,message,sig) = if (!(sigVerify_8Kb(message, sig, pub)))
440	446		then throw("signature does not match")
441	447		else {
442	448		let parts = split(toUtf8String(message), ";")
443	449		let hp = split(split(parts[0], "\|")[0], "_")
444	450		let curHP = parseIntValue(hp[0])
445	451		let newHP = parseIntValue(hp[1])
446	452		let locAndTime = split(parts[1], ":")
447	453		let targetLocation = split(locAndTime[0], "_")
448	454		if ((targetLocation[1] != "E"))
449	455		then throw("expedition target location type should be E")
450	456		else {
451	457		let time = parseIntValue(locAndTime[1])
452	458		if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
453	459		then true
454	460		else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
455	461		then throw("signature outdated")
456	462		else {
457	463		let userAddr = toString(caller)
458	464		let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(userAddr)), "You don't have a duck staked")
459	465		let keyHealth = keyDuckHealth(duckAssetId)
460	466		let oldFromState = valueOrElse(getInteger(keyHealth), 100)
461	467		if ((oldFromState != curHP))
462	468		then throw(((("oldHealth=" + toString(valueOrElse(getInteger(keyHealth), 100))) + " from state does not match one from flight log=") + toString(curHP)))
463	469		else if ((0 >= curHP))
464	470		then throw("You can't fly with zero health")
465	471		else if ((0 >= newHP))
466	472		then $Tuple2(((if (!(shouldUseMat))
467	473		then [ScriptTransfer(caller, EXPUSDN, usdnAssetId)]
468	474		else nil) :+ IntegerEntry(keyHealth, 0)), "")
469	475		else {
470	476		let bpKey = keyBackpackByDuck(duckAssetId)
471	477		let currentPack = getBackpack(bpKey)
472	478		let mList = split(currentPack[bpIdxMat], "_")
473	479		let newMat = makeString(subtractMaterials(shouldUseMat, mList, EXPMATERIALS), "_")
474	480		let bigNum = abs(toBigInt(txId))
475	481		let freeNum = valueOrElse(getInteger(keyNextFreeLandNum()), (PRESALENUMLANDS + 1))
476	482		let landNum = toString(freeNum)
477	483		let continentIdx = toInt((bigNum % FIVEX))
478	484		let terrains = genTerrains(bigNum, continentIdx)
479	485		let continent = continents[continentIdx]
480	486		let issue = Issue(keyNftName(landNum, "S"), makeString([landNum, "S", terrains, continent], "_"), 1, 0, false)
481	487		let assetId = calculateAssetId(issue)
482	488		let id = toBase58String(assetId)
483	489		$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)
484	490		}
485	491		}
486	492		}
487	493		}
488	494
489	495
490	496		func applyBonuses (landAssetId,pieces) = {
491	497		let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
492	498		let artPieces = valueOrElse(getInteger(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)), if (valueOrElse(getBoolean(keyPresaleArtActivatedByAssetId(landAssetId)), false))
493	499		then pieces
494	500		else 0)

github/deemru/w8io/3ef1775 
295.05 ms ◑