w8 · tx · JB8···SfR

tx · JB8gexeB8Er7QWWNEHJ1A9GmL1Md6r36n3VxZNqScSfR

3NBPx1Fciu3JQNEGZ21jSnTdutLNGGBUSXh:  -0.03200000 Waves

2024.12.05 03:32 [3400620] smart account 3NBPx1Fciu3JQNEGZ21jSnTdutLNGGBUSXh > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "JB8gexeB8Er7QWWNEHJ1A9GmL1Md6r36n3VxZNqScSfR",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1733358725554,
    "version": 2,
    "chainId": 84,
    "sender": "3NBPx1Fciu3JQNEGZ21jSnTdutLNGGBUSXh",
    "senderPublicKey": "3QtfC1XbLZXdeawMDeSERy9vvjUmj1XYd2GFmrvx7pWQ",
    "proofs": [
        "5QjygSXHrdX3xhgbtYgbx5kffV5v6XWZ7ZxpbbYZMMojxd7Dzb6KvrWjwjaQRh7sx6E9BGchoTgqANcTEiBBCwmW"
    ],
    "script": "base64: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",
    "height": 3400620,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 865Bu7UjvUGMa5QuUniGdKNvfhjyYFxJA2n9AQYN4LeW
Next: Asci4rkPJSMMiAbwkqrPCczRn23phQpsQ9vUse34dTUR

Diff: 
Old New Differences
679 679  
680 680  
681 681  @Callable(i)
682 - func convertOldStakes () = {
682 + func convertOldStakes (address) = {
683 683      let prologActions = prolog(i)
684 684      if ((OLD_STAKING_DEADL > lastBlock.timestamp))
685 685          then throw(("Disabled until " + toString((OLD_STAKING_DEADL / 1000))))
686 686          else {
687 -             let address = toString(i.caller)
687 +             let caller = addressFromStringValue(address)
688 688              if ((size(i.payments) != 0))
689 689                  then throw("No payments required")
690 690                  else {
729 729                                      let req = invoke(oldAcresAddress, "requestAcresCallback", [(((rr._1 + rr._2) + rr._3) + rr._4)], nil)
730 730                                      if ((req == req))
731 731                                          then {
732 -                                             let $t01802418162 = issueNftCustom(idxNameShovel, idxKeyP, idxCollDig, idxRarityP, 3, idxDescrShovel, idxBonusTypeFp, i.caller)
733 -                                             let nftActions = $t01802418162._1
734 -                                             let nftAssetId = $t01802418162._2
732 +                                             let $t01808618222 = issueNftCustom(idxNameShovel, idxKeyP, idxCollDig, idxRarityP, 3, idxDescrShovel, idxBonusTypeFp, caller)
733 +                                             let nftActions = $t01808618222._1
734 +                                             let nftAssetId = $t01808618222._2
735 735                                              $Tuple6(rr._1, rr._2, rr._3, rr._4, rr._5, nftActions)
736 736                                              }
737 737                                          else throw("Strict value is not equal to itself.")
799 799      let userFpKey = keyFarmingPowerByUser(address)
800 800      let oldFp = valueOrElse(getInteger(userFpKey), 0)
801 801      let userBonus = valueOrElse(getInteger(acres2Contract, keyUserFullBonus(address)), 0)
802 -     let $t02038620473 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
803 -     let newBonusedFp = $t02038620473._1
804 -     let ignored = $t02038620473._2
802 +     let $t02044620533 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
803 +     let newBonusedFp = $t02044620533._1
804 +     let ignored = $t02044620533._2
805 805      let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
806 806      let newTotalFp = ((oldTotalFp + newBonusedFp) - oldFp)
807 807      $Tuple2(nil, [oldFp, newBonusedFp, oldTotalFp, newTotalFp])
843 843                                  let listAction = StringEntry(nftsKey, makeString_2C((nfts :+ assetIdStr), "_"))
844 844                                  if ((asset.issuer == this))
845 845                                      then {
846 -                                         let $t02188222072 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
847 -                                         let actions = $t02188222072._1
848 -                                         let wlgClaimedAmount = $t02188222072._2
846 +                                         let $t02194222132 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
847 +                                         let actions = $t02194222132._1
848 +                                         let wlgClaimedAmount = $t02194222132._2
849 849                                          $Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
850 850                                          }
851 851                                      else if ((isArkimalIssued(asset) == ""))
852 852                                          then throw("Only WavesLands and Arkimals NFT tokens are accepted")
853 853                                          else {
854 -                                             let $t02225322404 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
855 -                                             let actions = $t02225322404._1
856 -                                             let wlgClaimedAmount = $t02225322404._2
854 +                                             let $t02231322464 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
855 +                                             let actions = $t02231322464._1
856 +                                             let wlgClaimedAmount = $t02231322464._2
857 857                                              $Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
858 858                                              }
859 859                                  }
890 890                                  then {
891 891                                      let wlNftNumber = valueOrElse(getInteger(keyUserWlNftNumber(addr)), 0)
892 892                                      let bonusVal = (bonusByDescription(value(asset.description)) * 10000)
893 -                                     let $t02356923648 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
894 -                                     let actions = $t02356923648._1
895 -                                     let wlgClaimedAmount = $t02356923648._2
893 +                                     let $t02362923708 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
894 +                                     let actions = $t02362923708._1
895 +                                     let wlgClaimedAmount = $t02362923708._2
896 896                                      $Tuple2(((((((actions :+ listAction) :+ IntegerEntry(keyUserWlNftNumber(addr), (wlNftNumber - 1))) :+ IntegerEntry(keyWlNftTotalStaked, max([0, (valueOrElse(getInteger(keyWlNftTotalStaked), 0) - 1)]))) :+ DeleteEntry(keyStakedTimeByAssetIdAndOwner(toBase58String(assetId), addr))) :+ ScriptTransfer(i.caller, 1, assetId)) ++ prologActions), wlgClaimedAmount)
897 897                                      }
898 898                                  else {
901 901                                          then throw("Only WavesLands and Arkimals NFT tokens are accepted")
902 902                                          else {
903 903                                              let arkNftNumber = valueOrElse(getInteger(keyUserArkNftNumber(addr)), 0)
904 -                                             let $t02430824392 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
905 -                                             let actions = $t02430824392._1
906 -                                             let wlgClaimedAmount = $t02430824392._2
904 +                                             let $t02436824452 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
905 +                                             let actions = $t02436824452._1
906 +                                             let wlgClaimedAmount = $t02436824452._2
907 907                                              $Tuple2((((((actions :+ listAction) :+ IntegerEntry(keyUserArkNftNumber(addr), (arkNftNumber - 1))) :+ DeleteEntry(keyStakedTimeByAssetIdAndOwner(toBase58String(assetId), addr))) :+ ScriptTransfer(i.caller, 1, assetId)) ++ prologActions), wlgClaimedAmount)
908 908                                              }
909 909                                      }
945 945                              }
946 946                      }
947 947  
948 -                 let $t02578125997 = {
948 +                 let $t02584126057 = {
949 949                      let $l = i.payments
950 950                      let $s = size($l)
951 951                      let $acc0 = $Tuple4(0, 0, nil, -1)
959 959  
960 960                      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
961 961                      }
962 -                 let wlgFee = $t02578125997._1
963 -                 let totalBonus = $t02578125997._2
964 -                 let burnActions = $t02578125997._3
965 -                 let rarityIdx = $t02578125997._4
962 +                 let wlgFee = $t02584126057._1
963 +                 let totalBonus = $t02584126057._2
964 +                 let burnActions = $t02584126057._3
965 +                 let rarityIdx = $t02584126057._4
966 966                  let newRarityIdx = if ((rarityIdx == idxRarityC))
967 967                      then if ((rarityThresholds[idxThresholdC] > totalBonus))
968 968                          then idxRarityC
994 994                          let changeActions = if ((change > 0))
995 995                              then [ScriptTransfer(i.caller, change, wlgAssetId)]
996 996                              else nil
997 -                         let $t02753427695 = issueNftCustom(idxNamePickaxe, newRarityIdx, idxCollDig, newRarityIdx, totalBonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
998 -                         let issueNftActions = $t02753427695._1
999 -                         let nftAssetId = $t02753427695._2
997 +                         let $t02759427755 = issueNftCustom(idxNamePickaxe, newRarityIdx, idxCollDig, newRarityIdx, totalBonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
998 +                         let issueNftActions = $t02759427755._1
999 +                         let nftAssetId = $t02759427755._2
1000 1000                          let burned = size(burnActions)
1001 1001                          let burnCounterActions = if ((burned == 0))
1002 1002                              then nil
1040 1040                                      let entropy = value(value(blockInfoByHeight(finishBlock)).vrf)
1041 1041                                      let salt = fromBase58String(split(valueOrElse(getString(keyCurWeekTxIdByUser(addr)), "42_DEFAULT"), "_")[1])
1042 1042                                      let rand = getRandomNumber(100, salt, entropy)
1043 -                                     let $t02971429986 = if ((84 > rand))
1043 +                                     let $t02977430046 = if ((84 > rand))
1044 1044                                          then $Tuple2(1, idxRarityC)
1045 1045                                          else if ((98 > rand))
1046 1046                                              then $Tuple2(5, idxRarityU)
1047 1047                                              else $Tuple2(10, idxRarityL)
1048 -                                     let bonus = $t02971429986._1
1049 -                                     let rarityIdx = $t02971429986._2
1050 -                                     let $t02998930139 = issueNftCustom(idxNamePickaxe, rarityIdx, idxCollDig, rarityIdx, bonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
1051 -                                     let issueNftActions = $t02998930139._1
1052 -                                     let nftAssetId = $t02998930139._2
1048 +                                     let bonus = $t02977430046._1
1049 +                                     let rarityIdx = $t02977430046._2
1050 +                                     let $t03004930199 = issueNftCustom(idxNamePickaxe, rarityIdx, idxCollDig, rarityIdx, bonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
1051 +                                     let issueNftActions = $t03004930199._1
1052 +                                     let nftAssetId = $t03004930199._2
1053 1053                                      $Tuple2(((((issueNftActions ++ prologActions) ++ changeActions) :+ ScriptTransfer(addressFromStringValue(getStringValue(wlgContract, teamAddrKey)), forTeam, wlgAssetId)) :+ DeleteEntry(finishKey)), $Tuple2(nftAssetId, wlgRemain))
1054 1054                                      }
1055 1055                              }
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let SEP = "__"
5 5  
6 6  let MULT6 = 1000000
7 7  
8 8  let MULT7 = 10000000
9 9  
10 10  let MULT8 = 100000000
11 11  
12 12  let MULT14 = 100000000000000
13 13  
14 14  let DAY_MILLIS = 86400000
15 15  
16 16  let USDT2ACRES_MULTIPLIER = 10
17 17  
18 18  let ONE_PERCENT_DIVISOR = 100
19 19  
20 20  let RANDOM_DELAY = 2
21 21  
22 22  let NFT_CHEST_PRICE_USDT = 5000000
23 23  
24 24  let chain = take(drop(this.bytes, 1), 1)
25 25  
26 26  let WEEK_BLOCKS = match chain {
27 27      case _ => 
28 28          if ((base58'2W' == $match0))
29 29              then 10080
30 30              else if ((base58'2T' == $match0))
31 31                  then 180
32 32                  else throw("Unknown chain")
33 33  }
34 34  
35 35  let usdtAssetId = match chain {
36 36      case _ => 
37 37          if ((base58'2W' == $match0))
38 38              then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
39 39              else if ((base58'2T' == $match0))
40 40                  then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
41 41                  else throw("Unknown chain")
42 42  }
43 43  
44 44  let defaultRest2AddressStr = match chain {
45 45      case _ => 
46 46          if ((base58'2W' == $match0))
47 47              then "3PFwYta8biEz31zpeFe5DJK8wE5trSpQVF8"
48 48              else if ((base58'2T' == $match0))
49 49                  then "3N7UuYar6264P58FBhVWKPQAh4Yua2hgngv"
50 50                  else throw("Unknown chain")
51 51  }
52 52  
53 53  let arbitrageDelay = match chain {
54 54      case _ => 
55 55          if ((base58'2W' == $match0))
56 56              then DAY_MILLIS
57 57              else if ((base58'2T' == $match0))
58 58                  then 60000
59 59                  else throw("Unknown chain")
60 60  }
61 61  
62 62  let oldStakingContractStr = match chain {
63 63      case _ => 
64 64          if ((base58'2W' == $match0))
65 65              then "3PLncXtS1U83D6cQbFD3H8rBHPLgzxSFKZ1"
66 66              else if ((base58'2T' == $match0))
67 67                  then "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm"
68 68                  else throw("Unknown chain")
69 69  }
70 70  
71 71  func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
72 72  
73 73  
74 74  let IdxCfgAcres2Dapp = 1
75 75  
76 76  let IdxCfgWlgDapp = 2
77 77  
78 78  let IdxCfgInvestFundDapp = 5
79 79  
80 80  func keyRestCfg () = "%s__restConfig"
81 81  
82 82  
83 83  func keyRest2Address () = "%s__rest2Addr"
84 84  
85 85  
86 86  func readRestCfgOrFail (rest) = split_4C(getStringOrFail(rest, keyRestCfg()), SEP)
87 87  
88 88  
89 89  func getContractAddressOrFail (rest2Cfg,idx) = valueOrErrorMessage(addressFromString(rest2Cfg[idx]), ("Rest cfg doesn't contain address at index " + toString(idx)))
90 90  
91 91  
92 92  let rest2Contract = addressFromStringValue(valueOrElse(getString(this, keyRest2Address()), defaultRest2AddressStr))
93 93  
94 94  let rest2Cfg = readRestCfgOrFail(rest2Contract)
95 95  
96 96  let acres2Contract = getContractAddressOrFail(rest2Cfg, IdxCfgAcres2Dapp)
97 97  
98 98  let wlgContract = getContractAddressOrFail(rest2Cfg, IdxCfgWlgDapp)
99 99  
100 100  let investFundContract = getContractAddressOrFail(rest2Cfg, IdxCfgInvestFundDapp)
101 101  
102 102  let oldAcresContractKey = "oldAcresContract"
103 103  
104 104  func keyBlocked () = "contractsBlocked"
105 105  
106 106  
107 107  func keyLastWeekTxIdByUser (addr) = ("lastWeekTxIdByUser_" + addr)
108 108  
109 109  
110 110  func keyCurWeekTxIdByUser (addr) = ("curWeekTxIdByUser_" + addr)
111 111  
112 112  
113 113  func keyCommit (address) = ("finishBlockFor_" + address)
114 114  
115 115  
116 116  let wlgAssetIdKey = "wlg_assetId"
117 117  
118 118  let wlgAssetId = valueOrErrorMessage(getBinary(wlgContract, wlgAssetIdKey), "WLGOLD is not issued yet")
119 119  
120 120  let acresIssuedAmountKey = "acresIssuedAmount"
121 121  
122 122  let acresAssetIdKey = "acresAssetId"
123 123  
124 124  let acresAssetId = valueOrErrorMessage(getBinary(acres2Contract, acresAssetIdKey), "ACRES is not issued yet")
125 125  
126 126  func keyAcresStakedTimeByUser (addr) = ("acresStakedTimeByUser_" + addr)
127 127  
128 128  
129 129  func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
130 130  
131 131  
132 132  func keyStakedDuckByOwner (ownerAddr) = ("stakedDuckByOwner_" + ownerAddr)
133 133  
134 134  
135 135  func keyStakedTimeByAssetIdAndOwner (assetId,addr) = ((("st_" + assetId) + "_") + addr)
136 136  
137 137  
138 138  func keyStakedNFTsByOwner (ownerAddr) = ("stakedNFTsByOwner_" + ownerAddr)
139 139  
140 140  
141 141  func asInt (v) = match v {
142 142      case n: Int => 
143 143          n
144 144      case _ => 
145 145          throw("fail to cast into Int")
146 146  }
147 147  
148 148  
149 149  func asTuple5Ints (val) = match val {
150 150      case t: (Int, Int, Int, Int, Int) => 
151 151          t
152 152      case _ => 
153 153          throw("fail to cast into (Int, Int, Int, Int, Int)")
154 154  }
155 155  
156 156  
157 157  func asTuple4Ints (val) = match val {
158 158      case t: (Int, Int, Int, Int) => 
159 159          t
160 160      case _ => 
161 161          throw("fail to cast into (Int, Int, Int, Int)")
162 162  }
163 163  
164 164  
165 165  func asTuple3Ints (val) = match val {
166 166      case t: (Int, Int, Int) => 
167 167          t
168 168      case _ => 
169 169          throw("fail to cast into (Int, Int, Int)")
170 170  }
171 171  
172 172  
173 173  func asTuple2Ints (val) = match val {
174 174      case t: (Int, Int) => 
175 175          t
176 176      case _ => 
177 177          throw("fail to cast into (Int, Int)")
178 178  }
179 179  
180 180  
181 181  func fixedPoint (val,decimals) = {
182 182      let tenPow = pow(10, 0, decimals, 0, 0, DOWN)
183 183      let lowPart = toString((val % tenPow))
184 184      let zeroes = drop(toString(tenPow), (1 + size(lowPart)))
185 185      (((toString((val / tenPow)) + ".") + zeroes) + lowPart)
186 186      }
187 187  
188 188  
189 189  func getRandomNumber (maxValue,salt,entropy) = if ((0 >= maxValue))
190 190      then throw("maxValue should be > 0")
191 191      else {
192 192          let randomHash = sha256_16Kb((salt + entropy))
193 193          (toInt(randomHash) % maxValue)
194 194          }
195 195  
196 196  
197 197  let M6_ = 1000000
198 198  
199 199  let M8_ = 100000000
200 200  
201 201  let wlgIssuedAmtKey = "wlg_issuedAmount"
202 202  
203 203  let zbIssuedAmtKey = "zbill_issuedAmount"
204 204  
205 205  func keyAcresStakedAmtByUser (addr) = ("acresStakedAmountByUser_" + addr)
206 206  
207 207  
208 208  func keyFarmingPowerByUser (addr) = ("farmingPowerByUser_" + addr)
209 209  
210 210  
211 211  let acresStakdTotalKey = "acresStakedAmountTotal"
212 212  
213 213  let totalFarmingPowerKey = "totalFarmingPower"
214 214  
215 215  let MAX_WL_NFTS = 3
216 216  
217 217  let MAX_ARK_NFTS = 1
218 218  
219 219  let ARK_NFT_BONUS = 5000
220 220  
221 221  let MAX_NFTS_STAKED_BY_USER = 4
222 222  
223 223  let keyNftTotalIssued = "nftTotalIssued"
224 224  
225 225  let keyNftTotalBurned = "nftTotalBurned"
226 226  
227 227  let keyWlNftTotalStaked = "WlNftTotalStaked"
228 228  
229 229  let keyArkNftTotalStaked = "ArkNftTotalStaked"
230 230  
231 231  func keyNftNumberByAssetId (assetId) = ("nftNumberByAssetId_" + assetId)
232 232  
233 233  
234 234  func keyUserWlNftNumber (addr) = ("userWlNftNumber_" + addr)
235 235  
236 236  
237 237  func keyUserArkNftNumber (addr) = ("userArkNftNumber_" + addr)
238 238  
239 239  
240 240  func keyUserFullBonus (addr) = ("userFullBonus_" + addr)
241 241  
242 242  
243 243  let levelAcres = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
244 244  
245 245  func getLevelByAcres (acres) = {
246 246      let acr = ((acres + 99999999) / M8_)
247 247      func checker (acc,item) =     if ((item >= acr))
248 248          then acc
249 249          else (acc + 1)
250 250  
251 251      let $l = levelAcres
252 252      let $s = size($l)
253 253      let $acc0 = 0
254 254      func $f0_1 ($a,$i) =     if (($i >= $s))
255 255          then $a
256 256          else checker($a, $l[$i])
257 257  
258 258      func $f0_2 ($a,$i) =     if (($i >= $s))
259 259          then $a
260 260          else throw("List size exceeds 10")
261 261  
262 262      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
263 263      }
264 264  
265 265  
266 266  func getFarmingPowerByAcres (acres) = ((acres * 20) * (getLevelByAcres(acres) + 4))
267 267  
268 268  
269 269  func getFarmingPowerByAcresAndBonus (acres,bonus6) = {
270 270      let notBonused = getFarmingPowerByAcres(acres)
271 271      $Tuple2(fraction(notBonused, (M6_ + bonus6), M6_), notBonused)
272 272      }
273 273  
274 274  
275 275  let teamAddrKey = "teamAddr"
276 276  
277 277  func keyLastWlgTradeTimeByUser (addr) = ("lastArbTimeUser_" + addr)
278 278  
279 279  
280 280  let OLD_STAKING_DEADL = 1733346000000
281 281  
282 282  let keyLastAcresSellTime = "lastAcresSellTime"
283 283  
284 284  let keyLastLimitLeft = "lastLimitLeft"
285 285  
286 286  let names = ["Gold shovel", "Pickaxe"]
287 287  
288 288  let descriptions = ["Reward for early birds", "Increases FarmPower"]
289 289  
290 290  let idxDescrShovel = 0
291 291  
292 292  let idxDescrPickaxe = 1
293 293  
294 294  let rarityThresholds = [5, 10, 20]
295 295  
296 296  let idxThresholdC = 0
297 297  
298 298  let idxThresholdU = 1
299 299  
300 300  let idxThresholdL = 2
301 301  
302 302  let namez = ["SHOVEL", "PICKAXE"]
303 303  
304 304  let idxNameShovel = 0
305 305  
306 306  let idxNamePickaxe = 1
307 307  
308 308  let contentKeyz = ["contentPickaxeC", "contentPickaxeU", "contentPickaxeL", "contentPickaxeE", "contentShovelP"]
309 309  
310 310  let idxKeyC = 0
311 311  
312 312  let idxKeyP = 4
313 313  
314 314  let rarityNames = ["Common", "Uncommon", "Legendary", "Epic", "Promo"]
315 315  
316 316  let idxRarityC = 0
317 317  
318 318  let idxRarityU = 1
319 319  
320 320  let idxRarityL = 2
321 321  
322 322  let idxRarityE = 3
323 323  
324 324  let idxRarityP = 4
325 325  
326 326  let collectionz = ["Digging tools"]
327 327  
328 328  let idxCollDig = 0
329 329  
330 330  let bonusTypez = ["FarmPower"]
331 331  
332 332  let idxBonusTypeFp = 0
333 333  
334 334  func prolog (i) = if (if ((i.originCaller != rest2Contract))
335 335      then valueOrElse(getBoolean(keyBlocked()), false)
336 336      else false)
337 337      then throw("Contracts are under maintenance")
338 338      else {
339 339          let addr = toString(i.originCaller)
340 340          let week = (height / WEEK_BLOCKS)
341 341          let lastWeekKey = keyLastWeekTxIdByUser(addr)
342 342          let lastWeekTxIdByUser = getString(lastWeekKey)
343 343          let txId = toBase58String(i.transactionId)
344 344          let wtx = ((toString(week) + "_") + txId)
345 345          let curWeekKey = keyCurWeekTxIdByUser(addr)
346 346          if (isDefined(lastWeekTxIdByUser))
347 347              then {
348 348                  let lastWeekTx = split(value(lastWeekTxIdByUser), "_")
349 349                  if ((lastWeekTx[0] == toString(week)))
350 350                      then [StringEntry(lastWeekKey, wtx), StringEntry(curWeekKey, wtx)]
351 351                      else if ((lastWeekTx[0] == toString((week - 1))))
352 352                          then [StringEntry(curWeekKey, wtx)]
353 353                          else {
354 354                              let curWeekTxIdByUser = getStringValue(curWeekKey)
355 355                              let curWeekTx = split(curWeekTxIdByUser, "_")
356 356                              if ((curWeekTx[0] == toString(week)))
357 357                                  then [StringEntry(curWeekKey, wtx)]
358 358                                  else [StringEntry(lastWeekKey, curWeekTxIdByUser), StringEntry(curWeekKey, wtx)]
359 359                              }
360 360                  }
361 361              else [StringEntry(lastWeekKey, wtx), StringEntry(curWeekKey, wtx)]
362 362          }
363 363  
364 364  
365 365  func createNftDescrCustom (contKey,nftSerial,collection,name,descr,rarity,bonus,bonusType) = (((((((((((((((((((((((("{\"url\": \"https://waveslands.com\", " + "\"contentKey\": \"") + contKey) + "\", ") + "\"number\": ") + toString(nftSerial)) + ", ") + "\"collection\": \"") + collection) + "\", ") + "\"name\": \"") + name) + "\", ") + "\"description\": \"") + descr) + "\", ") + "\"rare\": \"") + rarity) + "\", ") + "\"bonus\": ") + toString(bonus)) + ", ") + "\"bonusType\": \"") + bonusType) + "\"}")
366 366  
367 367  
368 368  func issueNftCustom (nameIdx,contKeyIdx,collIdx,rarityIdx,bonusPerc,descrIdx,bonusTypeIdx,addr) = {
369 369      let nftSerial = valueOrElse(getInteger(keyNftTotalIssued), 0)
370 370      let rarity = rarityNames[rarityIdx]
371 371      let name = (((namez[nameIdx] + "-") + take(rarity, 1)) + toString(bonusPerc))
372 372      let issue = Issue(name, createNftDescrCustom(contentKeyz[contKeyIdx], nftSerial, collectionz[collIdx], names[nameIdx], descriptions[descrIdx], rarityNames[rarityIdx], bonusPerc, bonusTypez[bonusTypeIdx]), 1, 0, false)
373 373      let nftAssetId = calculateAssetId(issue)
374 374      $Tuple2([issue, IntegerEntry(keyNftTotalIssued, (nftSerial + 1)), IntegerEntry(keyNftNumberByAssetId(toBase58String(nftAssetId)), nftSerial), ScriptTransfer(addr, 1, nftAssetId)], nftAssetId)
375 375      }
376 376  
377 377  
378 378  func bonusByDescription (descr) = if (!(contains(descr, "\"bonusType\": \"FarmPower\"")))
379 379      then throw(("NFT is not supported: " + descr))
380 380      else {
381 381          let bonusStr = split_4C(split_4C(descr, "\"bonus\":")[1], ",")[0]
382 382          parseIntValue(drop(bonusStr, (valueOrElse(lastIndexOf(bonusStr, " "), -1) + 1)))
383 383          }
384 384  
385 385  
386 386  func rarityIdxByDescriprion (descr) = if (!(contains(descr, "\"rare\"")))
387 387      then throw(("NFT is not supported: " + descr))
388 388      else {
389 389          let rarityStr = split_4C(split_4C(split_4C(descr, "\"rare\"")[1], ",")[0], "\"")[1]
390 390          value(indexOf(rarityNames, rarityStr))
391 391          }
392 392  
393 393  
394 394  func stakeUnstakeAcresInternal (amt,address,bonusDelta) = if (if ((amt == 0))
395 395      then (bonusDelta == 0)
396 396      else false)
397 397      then throw("Nothing to do")
398 398      else {
399 399          let wlgResult = invoke(wlgContract, "onStakeUnstakeLand", [address, true], nil)
400 400          if ((wlgResult == wlgResult))
401 401              then {
402 402                  let now = lastBlock.timestamp
403 403                  let timeKey = keyAcresStakedTimeByUser(address)
404 404                  let amountKey = keyAcresStakedAmtByUser(address)
405 405                  let oldAcresAmount = valueOrElse(getInteger(amountKey), 0)
406 406                  if (if ((0 > amt))
407 407                      then (0 > (oldAcresAmount + amt))
408 408                      else false)
409 409                      then throw(((("You have only " + fixedPoint(oldAcresAmount, 8)) + " ACRES staked, tried to unstake ") + fixedPoint(-(amt), 8)))
410 410                      else {
411 411                          let newAcresAmount = (oldAcresAmount + amt)
412 412                          let oldTotal = valueOrElse(getInteger(acresStakdTotalKey), 0)
413 413                          let userFpKey = keyFarmingPowerByUser(address)
414 414                          let oldFp = valueOrElse(getInteger(userFpKey), 0)
415 415                          let bonusKey = keyUserFullBonus(address)
416 416                          let oldBonus = valueOrElse(getInteger(acres2Contract, bonusKey), 0)
417 417                          if (if ((0 > bonusDelta))
418 418                              then (0 > (oldBonus + bonusDelta))
419 419                              else false)
420 420                              then throw((((("You have only " + fixedPoint(oldBonus, 4)) + "% bonus, and tried to unstake ") + fixedPoint(-(bonusDelta), 4)) + "%"))
421 421                              else {
422 422                                  let $t063056404 = getFarmingPowerByAcresAndBonus(newAcresAmount, (oldBonus + bonusDelta))
423 423                                  let newBonusedFp = $t063056404._1
424 424                                  let ignored = $t063056404._2
425 425                                  let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
426 426                                  let acresActions = if ((amt == 0))
427 427                                      then nil
428 428                                      else [IntegerEntry(amountKey, newAcresAmount), IntegerEntry(acresStakdTotalKey, (oldTotal + amt))]
429 429                                  let bonusActions = if ((bonusDelta == 0))
430 430                                      then nil
431 431                                      else [IntegerEntry(bonusKey, (oldBonus + bonusDelta))]
432 432                                  $Tuple2(((((acresActions ++ bonusActions) :+ IntegerEntry(timeKey, lastBlock.timestamp)) :+ IntegerEntry(userFpKey, newBonusedFp)) :+ IntegerEntry(totalFarmingPowerKey, ((oldTotalFp + newBonusedFp) - oldFp))), wlgResult)
433 433                                  }
434 434                          }
435 435                  }
436 436              else throw("Strict value is not equal to itself.")
437 437          }
438 438  
439 439  
440 440  func getWlgPrice (usdtBalanceCorrection) = {
441 441      let issuedAmount = valueOrErrorMessage(getInteger(wlgContract, wlgIssuedAmtKey), "WLGOLD is not issued yet")
442 442      let wlgUsd = assetBalance(wlgContract, usdtAssetId)
443 443      let acres2Usd = (assetBalance(acres2Contract, usdtAssetId) - usdtBalanceCorrection)
444 444      let investFundTotal = (assetBalance(investFundContract, usdtAssetId) + valueOrElse(getInteger(investFundContract, zbIssuedAmtKey), 0))
445 445      let totalFundsUsd = ((acres2Usd + wlgUsd) + investFundTotal)
446 446      fraction(totalFundsUsd, MULT8, issuedAmount)
447 447      }
448 448  
449 449  
450 450  func getSwapLimitAcres () = {
451 451      let wlgUsd = assetBalance(wlgContract, usdtAssetId)
452 452      let acres2Usd = assetBalance(this, usdtAssetId)
453 453      let investFundTotal = (assetBalance(investFundContract, usdtAssetId) + valueOrElse(getInteger(investFundContract, zbIssuedAmtKey), 0))
454 454      let defaultLimit = (((acres2Usd + wlgUsd) + investFundTotal) / ONE_PERCENT_DIVISOR)
455 455      let lastLimitLeft = valueOrElse(getInteger(keyLastLimitLeft), defaultLimit)
456 456      let lastTime = valueOrElse(getInteger(keyLastAcresSellTime), 0)
457 457      let now = lastBlock.timestamp
458 458      let currentLimit = (lastLimitLeft + fraction(defaultLimit, (now - lastTime), DAY_MILLIS))
459 459      let limitLeftUsdt = min([currentLimit, defaultLimit])
460 460      $Tuple2(IntegerEntry(keyLastAcresSellTime, now), limitLeftUsdt)
461 461      }
462 462  
463 463  
464 464  let arkOracle = addressFromStringValue("3PJgZ6AK1WVCpdCmEZpesHmaKvrQDdXG5og")
465 465  
466 466  let incubator = valueOrElse(getString(arkOracle, "static_incubatorAddress"), "")
467 467  
468 468  let breeder = valueOrElse(getString(arkOracle, "static_breederAddress"), "")
469 469  
470 470  let turtleIncubator = valueOrElse(getString(arkOracle, "static_turtleIncubatorAddress"), "")
471 471  
472 472  let turtleBreeder = valueOrElse(getString(arkOracle, "static_turtleBreederAddress"), "")
473 473  
474 474  let canineIncubator = valueOrElse(getString(arkOracle, "static_canineIncubatorAddress"), "")
475 475  
476 476  let canineBreeder = valueOrElse(getString(arkOracle, "static_canineBreederAddress"), "")
477 477  
478 478  let felineIncubator = valueOrElse(getString(arkOracle, "static_felineIncubatorAddress"), "")
479 479  
480 480  let felineBreeder = valueOrElse(getString(arkOracle, "static_felineBreederAddress"), "")
481 481  
482 482  let mutantBreeder = valueOrElse(getString(arkOracle, "static_mutantIncubatorAddress"), "")
483 483  
484 484  func isArkimalIssued (nfo) = {
485 485      let issuer = toString(nfo.issuer)
486 486      if (if (if (if (if (if (if (if (if (if ((chain == base58'2T'))
487 487          then (issuer == oldStakingContractStr)
488 488          else false)
489 489          then true
490 490          else (issuer == incubator))
491 491          then true
492 492          else (issuer == breeder))
493 493          then true
494 494          else (issuer == turtleIncubator))
495 495          then true
496 496          else (issuer == turtleBreeder))
497 497          then true
498 498          else (issuer == canineIncubator))
499 499          then true
500 500          else (issuer == canineBreeder))
501 501          then true
502 502          else (issuer == felineIncubator))
503 503          then true
504 504          else (issuer == felineBreeder))
505 505          then nfo.name
506 506          else if ((issuer == mutantBreeder))
507 507              then nfo.description
508 508              else ""
509 509      }
510 510  
511 511  
512 512  func stakeNftInternal (addr,assetIdStr,bonus6,userNumKey,totalNumKey,limit) = {
513 513      let nftNumber = valueOrElse(getInteger(userNumKey), 0)
514 514      if ((nftNumber >= limit))
515 515          then throw((("You can stake max " + toString(limit)) + " of such NFTs"))
516 516          else {
517 517              let $t01068310759 = stakeUnstakeAcresInternal(0, addr, bonus6)
518 518              let actions = $t01068310759._1
519 519              let wlgClaimedAmount = $t01068310759._2
520 520              $Tuple2((((actions :+ IntegerEntry(userNumKey, (nftNumber + 1))) :+ IntegerEntry(totalNumKey, (valueOrElse(getInteger(totalNumKey), 0) + 1))) :+ IntegerEntry(keyStakedTimeByAssetIdAndOwner(assetIdStr, addr), lastBlock.timestamp)), wlgClaimedAmount)
521 521              }
522 522      }
523 523  
524 524  
525 525  @Callable(i)
526 526  func saveLastTx () = if (!(containsElement([wlgContract], i.caller)))
527 527      then throw("Access denied")
528 528      else $Tuple2(prolog(i), 42)
529 529  
530 530  
531 531  
532 532  @Callable(i)
533 533  func constructorV1 (rest2Addr,oldAcrContract) = if ((i.caller != this))
534 534      then throw("Permission denied")
535 535      else {
536 536          let oldAcrContAddr = addressFromStringValue(oldAcrContract)
537 537  [IntegerEntry(acresIssuedAmountKey, getIntegerValue(oldAcrContAddr, acresIssuedAmountKey)), BinaryEntry(acresAssetIdKey, getBinaryValue(oldAcrContAddr, acresAssetIdKey)), StringEntry(keyRest2Address(), rest2Addr), StringEntry(oldAcresContractKey, oldAcrContract)]
538 538          }
539 539  
540 540  
541 541  
542 542  @Callable(i)
543 543  func setBlocked (isBlocked) = if ((i.caller != this))
544 544      then throw("permission denied")
545 545      else [BooleanEntry(keyBlocked(), isBlocked)]
546 546  
547 547  
548 548  
549 549  @Callable(i)
550 550  func unstakeAcres (amount) = {
551 551      let prologActions = prolog(i)
552 552      if ((0 >= amount))
553 553          then throw("Amount should be positive")
554 554          else {
555 555              let address = toString(i.caller)
556 556              if ((size(i.payments) != 0))
557 557                  then throw("No payments required")
558 558                  else {
559 559                      let arbReleaseTime = (valueOrElse(getInteger(wlgContract, keyLastWlgTradeTimeByUser(address)), 0) + arbitrageDelay)
560 560                      if ((arbReleaseTime > lastBlock.timestamp))
561 561                          then throw(("You traded some WLGOLD, cannot unstake until " + toString(arbReleaseTime)))
562 562                          else {
563 563                              let $t01233312413 = stakeUnstakeAcresInternal(-(amount), address, 0)
564 564                              let actions = $t01233312413._1
565 565                              let wlgClaimedAmount = $t01233312413._2
566 566                              $Tuple2(((actions :+ ScriptTransfer(i.caller, amount, acresAssetId)) ++ prologActions), wlgClaimedAmount)
567 567                              }
568 568                      }
569 569              }
570 570      }
571 571  
572 572  
573 573  
574 574  @Callable(i)
575 575  func stakeAcres () = {
576 576      let prologActions = prolog(i)
577 577      let address = toString(i.caller)
578 578      if ((size(i.payments) != 1))
579 579          then throw("exactly 1 payment must be attached")
580 580          else {
581 581              let pmt = i.payments[0]
582 582              let amt = pmt.amount
583 583              if (if (!(isDefined(pmt.assetId)))
584 584                  then true
585 585                  else (value(pmt.assetId) != acresAssetId))
586 586                  then throw("ACRES payments only!")
587 587                  else {
588 588                      let $t01286412940 = stakeUnstakeAcresInternal(amt, address, 0)
589 589                      let actions = $t01286412940._1
590 590                      let wlgClaimedAmount = $t01286412940._2
591 591                      $Tuple2((actions ++ prologActions), wlgClaimedAmount)
592 592                      }
593 593              }
594 594      }
595 595  
596 596  
597 597  
598 598  @Callable(i)
599 599  func buyAcres () = {
600 600      let prologActions = prolog(i)
601 601      if ((size(i.payments) != 1))
602 602          then throw("exactly 1 payment must be attached")
603 603          else {
604 604              let pmt = i.payments[0]
605 605              let usdtAmount = pmt.amount
606 606              if (if (!(isDefined(pmt.assetId)))
607 607                  then true
608 608                  else (value(pmt.assetId) != usdtAssetId))
609 609                  then throw("USDT payments only!")
610 610                  else if ((MULT6 > usdtAmount))
611 611                      then throw((("Min payment should be " + fixedPoint(MULT6, 6)) + " USDT"))
612 612                      else {
613 613                          let acresAmount = (usdtAmount * USDT2ACRES_MULTIPLIER)
614 614                          let wlgAmount = fraction(usdtAmount, MULT8, getWlgPrice(usdtAmount))
615 615                          let oldAcresAddress = addressFromStringValue(getStringValue(oldAcresContractKey))
616 616                          let req = invoke(oldAcresAddress, "requestAcresCallback", [acresAmount], nil)
617 617                          if ((req == req))
618 618                              then {
619 619                                  let wlgRemain = asInt(invoke(wlgContract, "burnWlgold", [wlgAmount], nil))
620 620                                  $Tuple2(([ScriptTransfer(i.caller, acresAmount, acresAssetId)] ++ prologActions), wlgRemain)
621 621                                  }
622 622                              else throw("Strict value is not equal to itself.")
623 623                          }
624 624              }
625 625      }
626 626  
627 627  
628 628  
629 629  @Callable(i)
630 630  func buyAcresREADONLY (usdtAmount) = {
631 631      let acresAmount = (usdtAmount * USDT2ACRES_MULTIPLIER)
632 632      let wlgToBurn = fraction(usdtAmount, MULT8, getWlgPrice(usdtAmount))
633 633      $Tuple2(nil, [acresAmount, MULT6, acresAmount, wlgToBurn])
634 634      }
635 635  
636 636  
637 637  
638 638  @Callable(i)
639 639  func sellAcres () = {
640 640      let prologActions = prolog(i)
641 641      if ((size(i.payments) != 1))
642 642          then throw("exactly 1 payment must be attached")
643 643          else {
644 644              let pmt = i.payments[0]
645 645              let acresAmount = pmt.amount
646 646              if (if (!(isDefined(pmt.assetId)))
647 647                  then true
648 648                  else (value(pmt.assetId) != acresAssetId))
649 649                  then throw("ACRES payments only!")
650 650                  else if ((MULT7 > acresAmount))
651 651                      then throw((("Min payment should be " + fixedPoint(MULT7, 8)) + " ACRES"))
652 652                      else {
653 653                          let addr = toString(i.caller)
654 654                          let $t01479714845 = getSwapLimitAcres()
655 655                          let limitAction = $t01479714845._1
656 656                          let maxUsdt = $t01479714845._2
657 657                          let maxAcres = (maxUsdt * USDT2ACRES_MULTIPLIER)
658 658                          if ((acresAmount > maxAcres))
659 659                              then throw((("You can sell max " + fixedPoint(maxAcres, 8)) + " ACRES"))
660 660                              else {
661 661                                  let usdtAmount = ((acresAmount / USDT2ACRES_MULTIPLIER) / 2)
662 662                                  $Tuple2(([limitAction, IntegerEntry(keyLastLimitLeft, (maxUsdt - usdtAmount)), ScriptTransfer(i.caller, usdtAmount, usdtAssetId)] ++ prologActions), usdtAmount)
663 663                                  }
664 664                          }
665 665              }
666 666      }
667 667  
668 668  
669 669  
670 670  @Callable(i)
671 671  func sellAcresREADONLY (address,acresAmount) = {
672 672      let $t01534115389 = getSwapLimitAcres()
673 673      let limitAction = $t01534115389._1
674 674      let maxUsdt = $t01534115389._2
675 675      let usdtAmount = ((acresAmount / USDT2ACRES_MULTIPLIER) / 2)
676 676      $Tuple2(nil, [usdtAmount, MULT7, (maxUsdt * USDT2ACRES_MULTIPLIER), 0])
677 677      }
678 678  
679 679  
680 680  
681 681  @Callable(i)
682 - func convertOldStakes () = {
682 + func convertOldStakes (address) = {
683 683      let prologActions = prolog(i)
684 684      if ((OLD_STAKING_DEADL > lastBlock.timestamp))
685 685          then throw(("Disabled until " + toString((OLD_STAKING_DEADL / 1000))))
686 686          else {
687 -             let address = toString(i.caller)
687 +             let caller = addressFromStringValue(address)
688 688              if ((size(i.payments) != 0))
689 689                  then throw("No payments required")
690 690                  else {
691 691                      let oldAcresAddress = addressFromStringValue(getStringValue(oldAcresContractKey))
692 692                      let amount = valueOrElse(getInteger(oldAcresAddress, keyAcresStakedAmtByUser(address)), 0)
693 693                      let gotAcres0 = if ((amount > 0))
694 694                          then asTuple2Ints(invoke(oldAcresAddress, "unstakeAcresCallback", [amount, address], nil))
695 695                          else $Tuple2(0, 0)
696 696                      let oldStakingAddress = addressFromStringValue(oldStakingContractStr)
697 697                      let landsStr = getString(oldStakingAddress, keyStakedLandsByOwner(address))
698 698                      let landsResult = if (isDefined(landsStr))
699 699                          then {
700 700                              let landsVal = value(landsStr)
701 701                              let cutLands = if ((900 > size(landsVal)))
702 702                                  then landsVal
703 703                                  else take(landsVal, value(lastIndexOf(landsVal, "_", (45 * 20))))
704 704                              let lands = split_51C(value(cutLands), "_")
705 705                              func oneLand (acc,landAssetId) =                             if ((landAssetId == ""))
706 706                                  then throw("landAssetId is required")
707 707                                  else {
708 708                                      let r = asTuple5Ints(invoke(oldStakingAddress, "unstakeLandCallback", [landAssetId, address], nil))
709 709                                      $Tuple5((acc._1 + r._1), (acc._2 + r._2), (acc._3 + r._3), (acc._4 + r._4), (acc._5 + r._5))
710 710                                      }
711 711  
712 712                              let rr = {
713 713                                  let $l = lands
714 714                                  let $s = size($l)
715 715                                  let $acc0 = $Tuple5(0, 0, 0, 0, 0)
716 716                                  func $f0_1 ($a,$i) =                                 if (($i >= $s))
717 717                                      then $a
718 718                                      else oneLand($a, $l[$i])
719 719  
720 720                                  func $f0_2 ($a,$i) =                                 if (($i >= $s))
721 721                                      then $a
722 722                                      else throw("List size exceeds 100")
723 723  
724 724                                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
725 725                                  }
726 726                              let finalize = invoke(oldStakingAddress, "unstakeLandsFinalizeCallback", [address], nil)
727 727                              if ((finalize == finalize))
728 728                                  then {
729 729                                      let req = invoke(oldAcresAddress, "requestAcresCallback", [(((rr._1 + rr._2) + rr._3) + rr._4)], nil)
730 730                                      if ((req == req))
731 731                                          then {
732 -                                             let $t01802418162 = issueNftCustom(idxNameShovel, idxKeyP, idxCollDig, idxRarityP, 3, idxDescrShovel, idxBonusTypeFp, i.caller)
733 -                                             let nftActions = $t01802418162._1
734 -                                             let nftAssetId = $t01802418162._2
732 +                                             let $t01808618222 = issueNftCustom(idxNameShovel, idxKeyP, idxCollDig, idxRarityP, 3, idxDescrShovel, idxBonusTypeFp, caller)
733 +                                             let nftActions = $t01808618222._1
734 +                                             let nftAssetId = $t01808618222._2
735 735                                              $Tuple6(rr._1, rr._2, rr._3, rr._4, rr._5, nftActions)
736 736                                              }
737 737                                          else throw("Strict value is not equal to itself.")
738 738                                      }
739 739                                  else throw("Strict value is not equal to itself.")
740 740                              }
741 741                          else $Tuple6(0, 0, 0, 0, 0, nil)
742 742                      let duckAssetId = valueOrElse(getString(oldStakingAddress, keyStakedDuckByOwner(address)), "")
743 743                      let duckResult = if ((duckAssetId != ""))
744 744                          then asTuple3Ints(invoke(oldStakingAddress, "unstakeDuckCallback", [duckAssetId, address], nil))
745 745                          else $Tuple3(0, 0, 0)
746 746                      let x = stakeUnstakeAcresInternal((((((((gotAcres0._1 + landsResult._1) + landsResult._2) + landsResult._3) + landsResult._4) + duckResult._1) + duckResult._2) + duckResult._3), address, 0)
747 747                      $Tuple2(((landsResult._6 ++ x._1) ++ prologActions), $Tuple3(gotAcres0._2, landsResult._5, x._2))
748 748                      }
749 749              }
750 750      }
751 751  
752 752  
753 753  
754 754  @Callable(i)
755 755  func unstakeLandsREADONLY (address) = {
756 756      let oldStakingAddress = addressFromStringValue(oldStakingContractStr)
757 757      let landsStr = getString(oldStakingAddress, keyStakedLandsByOwner(address))
758 758      let landsResult = if (isDefined(landsStr))
759 759          then {
760 760              let lands = split_51C(value(landsStr), "_")
761 761              func oneLand (acc,landAssetId) =             if ((landAssetId == ""))
762 762                  then throw("landAssetId is required")
763 763                  else {
764 764                      let r = asTuple4Ints(invoke(oldStakingAddress, "unstakeLandREADONLY", [landAssetId, address], nil))
765 765                      $Tuple4((acc._1 + r._1), (acc._2 + r._2), (acc._3 + r._3), (acc._4 + r._4))
766 766                      }
767 767  
768 768              let $l = lands
769 769              let $s = size($l)
770 770              let $acc0 = $Tuple4(0, 0, 0, 0)
771 771              func $f0_1 ($a,$i) =             if (($i >= $s))
772 772                  then $a
773 773                  else oneLand($a, $l[$i])
774 774  
775 775              func $f0_2 ($a,$i) =             if (($i >= $s))
776 776                  then $a
777 777                  else throw("List size exceeds 100")
778 778  
779 779              $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
780 780              }
781 781          else $Tuple4(0, 0, 0, 0)
782 782      $Tuple2(nil, landsResult)
783 783      }
784 784  
785 785  
786 786  
787 787  @Callable(i)
788 788  func stakeAcresCallback (addr) = if ((i.caller != addressFromStringValue(oldStakingContractStr)))
789 789      then throw("Permission denied")
790 790      else stakeUnstakeAcresInternal(i.payments[0].amount, addr, 0)
791 791  
792 792  
793 793  
794 794  @Callable(i)
795 795  func simulateStakeAcresREADONLY (address,addedAmount) = {
796 796      let amountKey = keyAcresStakedAmtByUser(address)
797 797      let newAcresAmount = (valueOrElse(getInteger(amountKey), 0) + addedAmount)
798 798      let oldTotal = valueOrElse(getInteger(acresStakdTotalKey), 0)
799 799      let userFpKey = keyFarmingPowerByUser(address)
800 800      let oldFp = valueOrElse(getInteger(userFpKey), 0)
801 801      let userBonus = valueOrElse(getInteger(acres2Contract, keyUserFullBonus(address)), 0)
802 -     let $t02038620473 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
803 -     let newBonusedFp = $t02038620473._1
804 -     let ignored = $t02038620473._2
802 +     let $t02044620533 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
803 +     let newBonusedFp = $t02044620533._1
804 +     let ignored = $t02044620533._2
805 805      let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
806 806      let newTotalFp = ((oldTotalFp + newBonusedFp) - oldFp)
807 807      $Tuple2(nil, [oldFp, newBonusedFp, oldTotalFp, newTotalFp])
808 808      }
809 809  
810 810  
811 811  
812 812  @Callable(i)
813 813  func issuePickC1 (forAddress) = if ((i.caller != wlgContract))
814 814      then throw("Permission denied")
815 815      else issueNftCustom(idxNamePickaxe, idxKeyC, idxCollDig, idxRarityC, 1, idxDescrPickaxe, idxBonusTypeFp, addressFromStringValue(forAddress))
816 816  
817 817  
818 818  
819 819  @Callable(i)
820 820  func stakeNFT () = {
821 821      let prologActions = prolog(i)
822 822      if ((size(i.payments) != 1))
823 823          then throw("Exactly one payment required")
824 824          else {
825 825              let pmt = value(i.payments[0])
826 826              if ((pmt.amount != 1))
827 827                  then throw("NFT token should be attached as payment")
828 828                  else {
829 829                      let assetId = value(pmt.assetId)
830 830                      let asset = value(assetInfo(assetId))
831 831                      let assetIdStr = toBase58String(assetId)
832 832                      let addr = toString(i.caller)
833 833                      let nftsKey = keyStakedNFTsByOwner(addr)
834 834                      let nftsStr = getString(nftsKey)
835 835                      let nfts = if (isDefined(nftsStr))
836 836                          then split_4C(value(nftsStr), "_")
837 837                          else nil
838 838                      if (containsElement(nfts, assetIdStr))
839 839                          then throw(("Your staked NFTs already contain " + assetIdStr))
840 840                          else if ((size(nfts) >= MAX_NFTS_STAKED_BY_USER))
841 841                              then throw((("Your already staked max (" + toString(MAX_NFTS_STAKED_BY_USER)) + ") NFTs"))
842 842                              else {
843 843                                  let listAction = StringEntry(nftsKey, makeString_2C((nfts :+ assetIdStr), "_"))
844 844                                  if ((asset.issuer == this))
845 845                                      then {
846 -                                         let $t02188222072 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
847 -                                         let actions = $t02188222072._1
848 -                                         let wlgClaimedAmount = $t02188222072._2
846 +                                         let $t02194222132 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
847 +                                         let actions = $t02194222132._1
848 +                                         let wlgClaimedAmount = $t02194222132._2
849 849                                          $Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
850 850                                          }
851 851                                      else if ((isArkimalIssued(asset) == ""))
852 852                                          then throw("Only WavesLands and Arkimals NFT tokens are accepted")
853 853                                          else {
854 -                                             let $t02225322404 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
855 -                                             let actions = $t02225322404._1
856 -                                             let wlgClaimedAmount = $t02225322404._2
854 +                                             let $t02231322464 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
855 +                                             let actions = $t02231322464._1
856 +                                             let wlgClaimedAmount = $t02231322464._2
857 857                                              $Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
858 858                                              }
859 859                                  }
860 860                      }
861 861              }
862 862      }
863 863  
864 864  
865 865  
866 866  @Callable(i)
867 867  func unstakeNFT (assetIdStr) = {
868 868      let prologActions = prolog(i)
869 869      if ((size(i.payments) != 0))
870 870          then throw("No payments required")
871 871          else {
872 872              let assetId = fromBase58String(assetIdStr)
873 873              let addr = toString(i.caller)
874 874              let asset = value(assetInfo(assetId))
875 875              let timeKey = keyStakedTimeByAssetIdAndOwner(assetIdStr, addr)
876 876              if (!(isDefined(getInteger(timeKey))))
877 877                  then throw((("NFT " + asset.name) + " is not staked by you"))
878 878                  else {
879 879                      let nftsKey = keyStakedNFTsByOwner(addr)
880 880                      let nfts = split_4C(valueOrElse(getString(nftsKey), ""), "_")
881 881                      let idx = indexOf(nfts, assetIdStr)
882 882                      if (!(isDefined(idx)))
883 883                          then throw(("Your staked NFTs don't contain " + assetIdStr))
884 884                          else {
885 885                              let listAction = if ((size(nfts) > 1))
886 886                                  then StringEntry(nftsKey, makeString_2C(removeByIndex(nfts, value(idx)), "_"))
887 887                                  else DeleteEntry(nftsKey)
888 888                              let isWL = (asset.issuer == this)
889 889                              if (isWL)
890 890                                  then {
891 891                                      let wlNftNumber = valueOrElse(getInteger(keyUserWlNftNumber(addr)), 0)
892 892                                      let bonusVal = (bonusByDescription(value(asset.description)) * 10000)
893 -                                     let $t02356923648 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
894 -                                     let actions = $t02356923648._1
895 -                                     let wlgClaimedAmount = $t02356923648._2
893 +                                     let $t02362923708 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
894 +                                     let actions = $t02362923708._1
895 +                                     let wlgClaimedAmount = $t02362923708._2
896 896                                      $Tuple2(((((((actions :+ listAction) :+ IntegerEntry(keyUserWlNftNumber(addr), (wlNftNumber - 1))) :+ IntegerEntry(keyWlNftTotalStaked, max([0, (valueOrElse(getInteger(keyWlNftTotalStaked), 0) - 1)]))) :+ DeleteEntry(keyStakedTimeByAssetIdAndOwner(toBase58String(assetId), addr))) :+ ScriptTransfer(i.caller, 1, assetId)) ++ prologActions), wlgClaimedAmount)
897 897                                      }
898 898                                  else {
899 899                                      let arkimalName = isArkimalIssued(asset)
900 900                                      if ((arkimalName == ""))
901 901                                          then throw("Only WavesLands and Arkimals NFT tokens are accepted")
902 902                                          else {
903 903                                              let arkNftNumber = valueOrElse(getInteger(keyUserArkNftNumber(addr)), 0)
904 -                                             let $t02430824392 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
905 -                                             let actions = $t02430824392._1
906 -                                             let wlgClaimedAmount = $t02430824392._2
904 +                                             let $t02436824452 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
905 +                                             let actions = $t02436824452._1
906 +                                             let wlgClaimedAmount = $t02436824452._2
907 907                                              $Tuple2((((((actions :+ listAction) :+ IntegerEntry(keyUserArkNftNumber(addr), (arkNftNumber - 1))) :+ DeleteEntry(keyStakedTimeByAssetIdAndOwner(toBase58String(assetId), addr))) :+ ScriptTransfer(i.caller, 1, assetId)) ++ prologActions), wlgClaimedAmount)
908 908                                              }
909 909                                      }
910 910                              }
911 911                      }
912 912              }
913 913      }
914 914  
915 915  
916 916  
917 917  @Callable(i)
918 918  func exchangeNFTs () = {
919 919      let prologActions = prolog(i)
920 920      if ((3 > size(i.payments)))
921 921          then throw("Min one WLGOLD and 2 NFT payments allowed")
922 922          else if ((size(i.payments) > 10))
923 923              then throw("Max one WLGOLD and 9 NFT payments allowed")
924 924              else {
925 925                  let addr = toString(i.caller)
926 926                  func addUp (acc,pmt) =                 {
927 927                      let assetId = valueOrErrorMessage(pmt.assetId, "WAVES payments not allowed")
928 928                      if ((assetId == wlgAssetId))
929 929                          then $Tuple4((acc._1 + pmt.amount), acc._2, acc._3, acc._4)
930 930                          else {
931 931                              let asset = value(assetInfo(assetId))
932 932                              if ((asset.issuer != this))
933 933                                  then throw("Only WL-issued NFTs allowed")
934 934                                  else {
935 935                                      let rarityIx = rarityIdxByDescriprion(value(asset.description))
936 936                                      if (if ((acc._4 > 0))
937 937                                          then (rarityIx != acc._4)
938 938                                          else false)
939 939                                          then throw("You can exchange only NFTs of the same rarity")
940 940                                          else {
941 941                                              let bonusPerc = bonusByDescription(value(asset.description))
942 942                                              $Tuple4(acc._1, (acc._2 + bonusPerc), (acc._3 :+ Burn(assetId, 1)), rarityIx)
943 943                                              }
944 944                                      }
945 945                              }
946 946                      }
947 947  
948 -                 let $t02578125997 = {
948 +                 let $t02584126057 = {
949 949                      let $l = i.payments
950 950                      let $s = size($l)
951 951                      let $acc0 = $Tuple4(0, 0, nil, -1)
952 952                      func $f0_1 ($a,$i) =                     if (($i >= $s))
953 953                          then $a
954 954                          else addUp($a, $l[$i])
955 955  
956 956                      func $f0_2 ($a,$i) =                     if (($i >= $s))
957 957                          then $a
958 958                          else throw("List size exceeds 10")
959 959  
960 960                      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
961 961                      }
962 -                 let wlgFee = $t02578125997._1
963 -                 let totalBonus = $t02578125997._2
964 -                 let burnActions = $t02578125997._3
965 -                 let rarityIdx = $t02578125997._4
962 +                 let wlgFee = $t02584126057._1
963 +                 let totalBonus = $t02584126057._2
964 +                 let burnActions = $t02584126057._3
965 +                 let rarityIdx = $t02584126057._4
966 966                  let newRarityIdx = if ((rarityIdx == idxRarityC))
967 967                      then if ((rarityThresholds[idxThresholdC] > totalBonus))
968 968                          then idxRarityC
969 969                          else if ((rarityThresholds[idxThresholdU] > totalBonus))
970 970                              then idxRarityU
971 971                              else throw((("You can advance only one level of rarity, max total bonus " + toString(rarityThresholds[idxThresholdU])) + "%"))
972 972                      else if ((rarityIdx == idxRarityU))
973 973                          then if ((rarityThresholds[idxThresholdU] > totalBonus))
974 974                              then idxRarityU
975 975                              else if ((rarityThresholds[idxThresholdL] > totalBonus))
976 976                                  then idxRarityL
977 977                                  else throw((("You can advance only one level of rarity, max total bonus " + toString(rarityThresholds[idxThresholdL])) + "%"))
978 978                          else if ((rarityIdx == idxRarityL))
979 979                              then if ((rarityThresholds[idxThresholdL] > totalBonus))
980 980                                  then idxRarityL
981 981                                  else idxRarityE
982 982                              else if ((rarityIdx == idxRarityE))
983 983                                  then idxRarityE
984 984                                  else if ((rarityIdx == idxRarityP))
985 985                                      then throw("You can't exchange NFTs of this rarity")
986 986                                      else throw("Unknown rarity")
987 987                  let minWlgFee = fraction(totalBonus, MULT14, getWlgPrice(0))
988 988                  let change = (wlgFee - minWlgFee)
989 989                  let forTeam = (minWlgFee / 2)
990 990                  let wlgRemain = asInt(invoke(wlgContract, "burnWlgold", [(minWlgFee - forTeam)], nil))
991 991                  if ((0 > change))
992 992                      then throw((("You need to attach " + fixedPoint(minWlgFee, 8)) + " WLGOLD as fee"))
993 993                      else {
994 994                          let changeActions = if ((change > 0))
995 995                              then [ScriptTransfer(i.caller, change, wlgAssetId)]
996 996                              else nil
997 -                         let $t02753427695 = issueNftCustom(idxNamePickaxe, newRarityIdx, idxCollDig, newRarityIdx, totalBonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
998 -                         let issueNftActions = $t02753427695._1
999 -                         let nftAssetId = $t02753427695._2
997 +                         let $t02759427755 = issueNftCustom(idxNamePickaxe, newRarityIdx, idxCollDig, newRarityIdx, totalBonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
998 +                         let issueNftActions = $t02759427755._1
999 +                         let nftAssetId = $t02759427755._2
1000 1000                          let burned = size(burnActions)
1001 1001                          let burnCounterActions = if ((burned == 0))
1002 1002                              then nil
1003 1003                              else [IntegerEntry(keyNftTotalBurned, (valueOrElse(getInteger(keyNftTotalBurned), 0) + burned))]
1004 1004                          $Tuple2((((((issueNftActions ++ burnActions) ++ burnCounterActions) ++ prologActions) ++ changeActions) :+ ScriptTransfer(addressFromStringValue(getStringValue(wlgContract, teamAddrKey)), forTeam, wlgAssetId)), $Tuple2(nftAssetId, wlgRemain))
1005 1005                          }
1006 1006                  }
1007 1007      }
1008 1008  
1009 1009  
1010 1010  
1011 1011  @Callable(i)
1012 1012  func openNftChest () = {
1013 1013      let prologActions = prolog(i)
1014 1014      if ((size(i.payments) != 1))
1015 1015          then throw("exactly 1 payment must be attached")
1016 1016          else {
1017 1017              let pmt = i.payments[0]
1018 1018              let wlgAmount = pmt.amount
1019 1019              if (if (!(isDefined(pmt.assetId)))
1020 1020                  then true
1021 1021                  else (value(pmt.assetId) != wlgAssetId))
1022 1022                  then throw("WLGOLD payments only!")
1023 1023                  else {
1024 1024                      let minWlgFee = fraction(NFT_CHEST_PRICE_USDT, MULT8, getWlgPrice(0))
1025 1025                      let change = (wlgAmount - minWlgFee)
1026 1026                      let forTeam = (minWlgFee / 2)
1027 1027                      let wlgRemain = asInt(invoke(wlgContract, "burnWlgold", [(minWlgFee - forTeam)], nil))
1028 1028                      if ((0 > change))
1029 1029                          then throw((("You need to attach " + fixedPoint(minWlgFee, 8)) + " WLGOLD as fee"))
1030 1030                          else {
1031 1031                              let changeActions = if ((change > 0))
1032 1032                                  then [ScriptTransfer(i.caller, change, wlgAssetId)]
1033 1033                                  else nil
1034 1034                              let addr = toString(i.caller)
1035 1035                              let finishKey = keyCommit(addr)
1036 1036                              let finishBlock = valueOrErrorMessage(getInteger(finishKey), "You have to commitForRandom() first!")
1037 1037                              if ((finishBlock > height))
1038 1038                                  then throw(("Random number is not ready yet, wait until height = " + toString(finishBlock)))
1039 1039                                  else {
1040 1040                                      let entropy = value(value(blockInfoByHeight(finishBlock)).vrf)
1041 1041                                      let salt = fromBase58String(split(valueOrElse(getString(keyCurWeekTxIdByUser(addr)), "42_DEFAULT"), "_")[1])
1042 1042                                      let rand = getRandomNumber(100, salt, entropy)
1043 -                                     let $t02971429986 = if ((84 > rand))
1043 +                                     let $t02977430046 = if ((84 > rand))
1044 1044                                          then $Tuple2(1, idxRarityC)
1045 1045                                          else if ((98 > rand))
1046 1046                                              then $Tuple2(5, idxRarityU)
1047 1047                                              else $Tuple2(10, idxRarityL)
1048 -                                     let bonus = $t02971429986._1
1049 -                                     let rarityIdx = $t02971429986._2
1050 -                                     let $t02998930139 = issueNftCustom(idxNamePickaxe, rarityIdx, idxCollDig, rarityIdx, bonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
1051 -                                     let issueNftActions = $t02998930139._1
1052 -                                     let nftAssetId = $t02998930139._2
1048 +                                     let bonus = $t02977430046._1
1049 +                                     let rarityIdx = $t02977430046._2
1050 +                                     let $t03004930199 = issueNftCustom(idxNamePickaxe, rarityIdx, idxCollDig, rarityIdx, bonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
1051 +                                     let issueNftActions = $t03004930199._1
1052 +                                     let nftAssetId = $t03004930199._2
1053 1053                                      $Tuple2(((((issueNftActions ++ prologActions) ++ changeActions) :+ ScriptTransfer(addressFromStringValue(getStringValue(wlgContract, teamAddrKey)), forTeam, wlgAssetId)) :+ DeleteEntry(finishKey)), $Tuple2(nftAssetId, wlgRemain))
1054 1054                                      }
1055 1055                              }
1056 1056                      }
1057 1057              }
1058 1058      }
1059 1059  
1060 1060  
1061 1061  
1062 1062  @Callable(i)
1063 1063  func commitForRandom () = {
1064 1064      let prologActions = prolog(i)
1065 1065      let addr = toString(i.caller)
1066 1066      let finishKey = keyCommit(addr)
1067 1067      if (isDefined(getInteger(finishKey)))
1068 1068          then throw("You already commited for random, please use it")
1069 1069          else {
1070 1070              let finishBlock = (height + RANDOM_DELAY)
1071 1071              $Tuple2(([IntegerEntry(finishKey, finishBlock)] ++ prologActions), finishBlock)
1072 1072              }
1073 1073      }
1074 1074  
1075 1075

Old	New		Differences
679	679
680	680
681	681		@Callable(i)
682		-	func convertOldStakes () = {
	682	+	func convertOldStakes (address) = {
683	683		let prologActions = prolog(i)
684	684		if ((OLD_STAKING_DEADL > lastBlock.timestamp))
685	685		then throw(("Disabled until " + toString((OLD_STAKING_DEADL / 1000))))
686	686		else {
687		-	let ~~address~~ = ~~toString~~(~~i.caller~~)
	687	+	let caller = addressFromStringValue(address)
688	688		if ((size(i.payments) != 0))
689	689		then throw("No payments required")
690	690		else {

729	729		let req = invoke(oldAcresAddress, "requestAcresCallback", [(((rr._1 + rr._2) + rr._3) + rr._4)], nil)
730	730		if ((req == req))
731	731		then {
732		-	let $~~t01802418162~~ = issueNftCustom(idxNameShovel, idxKeyP, idxCollDig, idxRarityP, 3, idxDescrShovel, idxBonusTypeFp, i.caller)
733		-	let nftActions = $~~t01802418162~~._1
734		-	let nftAssetId = $~~t01802418162~~._2
	732	+	let $t01808618222 = issueNftCustom(idxNameShovel, idxKeyP, idxCollDig, idxRarityP, 3, idxDescrShovel, idxBonusTypeFp, caller)
	733	+	let nftActions = $t01808618222._1
	734	+	let nftAssetId = $t01808618222._2
735	735		$Tuple6(rr._1, rr._2, rr._3, rr._4, rr._5, nftActions)
736	736		}
737	737		else throw("Strict value is not equal to itself.")

799	799		let userFpKey = keyFarmingPowerByUser(address)
800	800		let oldFp = valueOrElse(getInteger(userFpKey), 0)
801	801		let userBonus = valueOrElse(getInteger(acres2Contract, keyUserFullBonus(address)), 0)
802		-	let $~~t02038620473~~ = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
803		-	let newBonusedFp = $~~t02038620473~~._1
804		-	let ignored = $~~t02038620473~~._2
	802	+	let $t02044620533 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
	803	+	let newBonusedFp = $t02044620533._1
	804	+	let ignored = $t02044620533._2
805	805		let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
806	806		let newTotalFp = ((oldTotalFp + newBonusedFp) - oldFp)
807	807		$Tuple2(nil, [oldFp, newBonusedFp, oldTotalFp, newTotalFp])

843	843		let listAction = StringEntry(nftsKey, makeString_2C((nfts :+ assetIdStr), "_"))
844	844		if ((asset.issuer == this))
845	845		then {
846		-	let $~~t02188222072~~ = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
847		-	let actions = $~~t02188222072~~._1
848		-	let wlgClaimedAmount = $~~t02188222072~~._2
	846	+	let $t02194222132 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
	847	+	let actions = $t02194222132._1
	848	+	let wlgClaimedAmount = $t02194222132._2
849	849		$Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
850	850		}
851	851		else if ((isArkimalIssued(asset) == ""))
852	852		then throw("Only WavesLands and Arkimals NFT tokens are accepted")
853	853		else {
854		-	let $~~t02225322404~~ = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
855		-	let actions = $~~t02225322404~~._1
856		-	let wlgClaimedAmount = $~~t02225322404~~._2
	854	+	let $t02231322464 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
	855	+	let actions = $t02231322464._1
	856	+	let wlgClaimedAmount = $t02231322464._2
857	857		$Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
858	858		}
859	859		}

890	890		then {
891	891		let wlNftNumber = valueOrElse(getInteger(keyUserWlNftNumber(addr)), 0)
892	892		let bonusVal = (bonusByDescription(value(asset.description)) * 10000)
893		-	let $~~t02356923648~~ = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
894		-	let actions = $~~t02356923648~~._1
895		-	let wlgClaimedAmount = $~~t02356923648~~._2
	893	+	let $t02362923708 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
	894	+	let actions = $t02362923708._1
	895	+	let wlgClaimedAmount = $t02362923708._2
896	896		$Tuple2(((((((actions :+ listAction) :+ IntegerEntry(keyUserWlNftNumber(addr), (wlNftNumber - 1))) :+ IntegerEntry(keyWlNftTotalStaked, max([0, (valueOrElse(getInteger(keyWlNftTotalStaked), 0) - 1)]))) :+ DeleteEntry(keyStakedTimeByAssetIdAndOwner(toBase58String(assetId), addr))) :+ ScriptTransfer(i.caller, 1, assetId)) ++ prologActions), wlgClaimedAmount)
897	897		}
898	898		else {

901	901		then throw("Only WavesLands and Arkimals NFT tokens are accepted")
902	902		else {
903	903		let arkNftNumber = valueOrElse(getInteger(keyUserArkNftNumber(addr)), 0)
904		-	let $~~t02430824392~~ = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
905		-	let actions = $~~t02430824392~~._1
906		-	let wlgClaimedAmount = $~~t02430824392~~._2
	904	+	let $t02436824452 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
	905	+	let actions = $t02436824452._1
	906	+	let wlgClaimedAmount = $t02436824452._2
907	907		$Tuple2((((((actions :+ listAction) :+ IntegerEntry(keyUserArkNftNumber(addr), (arkNftNumber - 1))) :+ DeleteEntry(keyStakedTimeByAssetIdAndOwner(toBase58String(assetId), addr))) :+ ScriptTransfer(i.caller, 1, assetId)) ++ prologActions), wlgClaimedAmount)
908	908		}
909	909		}

945	945		}
946	946		}
947	947
948		-	let $~~t02578125997~~ = {
	948	+	let $t02584126057 = {
949	949		let $l = i.payments
950	950		let $s = size($l)
951	951		let $acc0 = $Tuple4(0, 0, nil, -1)

959	959
960	960		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
961	961		}
962		-	let wlgFee = $~~t02578125997~~._1
963		-	let totalBonus = $~~t02578125997~~._2
964		-	let burnActions = $~~t02578125997~~._3
965		-	let rarityIdx = $~~t02578125997~~._4
	962	+	let wlgFee = $t02584126057._1
	963	+	let totalBonus = $t02584126057._2
	964	+	let burnActions = $t02584126057._3
	965	+	let rarityIdx = $t02584126057._4
966	966		let newRarityIdx = if ((rarityIdx == idxRarityC))
967	967		then if ((rarityThresholds[idxThresholdC] > totalBonus))
968	968		then idxRarityC

994	994		let changeActions = if ((change > 0))
995	995		then [ScriptTransfer(i.caller, change, wlgAssetId)]
996	996		else nil
997		-	let $~~t02753427695~~ = issueNftCustom(idxNamePickaxe, newRarityIdx, idxCollDig, newRarityIdx, totalBonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
998		-	let issueNftActions = $~~t02753427695~~._1
999		-	let nftAssetId = $~~t02753427695~~._2
	997	+	let $t02759427755 = issueNftCustom(idxNamePickaxe, newRarityIdx, idxCollDig, newRarityIdx, totalBonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
	998	+	let issueNftActions = $t02759427755._1
	999	+	let nftAssetId = $t02759427755._2
1000	1000		let burned = size(burnActions)
1001	1001		let burnCounterActions = if ((burned == 0))
1002	1002		then nil

1040	1040		let entropy = value(value(blockInfoByHeight(finishBlock)).vrf)
1041	1041		let salt = fromBase58String(split(valueOrElse(getString(keyCurWeekTxIdByUser(addr)), "42_DEFAULT"), "_")[1])
1042	1042		let rand = getRandomNumber(100, salt, entropy)
1043		-	let $~~t02971429986~~ = if ((84 > rand))
	1043	+	let $t02977430046 = if ((84 > rand))
1044	1044		then $Tuple2(1, idxRarityC)
1045	1045		else if ((98 > rand))
1046	1046		then $Tuple2(5, idxRarityU)
1047	1047		else $Tuple2(10, idxRarityL)
1048		-	let bonus = $~~t02971429986~~._1
1049		-	let rarityIdx = $~~t02971429986~~._2
1050		-	let $~~t02998930139~~ = issueNftCustom(idxNamePickaxe, rarityIdx, idxCollDig, rarityIdx, bonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
1051		-	let issueNftActions = $~~t02998930139~~._1
1052		-	let nftAssetId = $~~t02998930139~~._2
	1048	+	let bonus = $t02977430046._1
	1049	+	let rarityIdx = $t02977430046._2
	1050	+	let $t03004930199 = issueNftCustom(idxNamePickaxe, rarityIdx, idxCollDig, rarityIdx, bonus, idxDescrPickaxe, idxBonusTypeFp, i.caller)
	1051	+	let issueNftActions = $t03004930199._1
	1052	+	let nftAssetId = $t03004930199._2
1053	1053		$Tuple2(((((issueNftActions ++ prologActions) ++ changeActions) :+ ScriptTransfer(addressFromStringValue(getStringValue(wlgContract, teamAddrKey)), forTeam, wlgAssetId)) :+ DeleteEntry(finishKey)), $Tuple2(nftAssetId, wlgRemain))
1054	1054		}
1055	1055		}

Old	New	Differences
1	1	{-# STDLIB_VERSION 6 #-}
2	2	{-# SCRIPT_TYPE ACCOUNT #-}
3	3	{-# CONTENT_TYPE DAPP #-}
4	4	let SEP = "__"
5	5
6	6	let MULT6 = 1000000
7	7
8	8	let MULT7 = 10000000
9	9
10	10	let MULT8 = 100000000
11	11
12	12	let MULT14 = 100000000000000
13	13
14	14	let DAY_MILLIS = 86400000
15	15
16	16	let USDT2ACRES_MULTIPLIER = 10
17	17
18	18	let ONE_PERCENT_DIVISOR = 100
19	19
20	20	let RANDOM_DELAY = 2
21	21
22	22	let NFT_CHEST_PRICE_USDT = 5000000
23	23
24	24	let chain = take(drop(this.bytes, 1), 1)
25	25
26	26	let WEEK_BLOCKS = match chain {
27	27	case _ =>
28	28	if ((base58'2W' == $match0))
29	29	then 10080
30	30	else if ((base58'2T' == $match0))
31	31	then 180
32	32	else throw("Unknown chain")
33	33	}
34	34
35	35	let usdtAssetId = match chain {
36	36	case _ =>
37	37	if ((base58'2W' == $match0))
38	38	then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
39	39	else if ((base58'2T' == $match0))
40	40	then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
41	41	else throw("Unknown chain")
42	42	}
43	43
44	44	let defaultRest2AddressStr = match chain {
45	45	case _ =>
46	46	if ((base58'2W' == $match0))
47	47	then "3PFwYta8biEz31zpeFe5DJK8wE5trSpQVF8"
48	48	else if ((base58'2T' == $match0))
49	49	then "3N7UuYar6264P58FBhVWKPQAh4Yua2hgngv"
50	50	else throw("Unknown chain")
51	51	}
52	52
53	53	let arbitrageDelay = match chain {
54	54	case _ =>
55	55	if ((base58'2W' == $match0))
56	56	then DAY_MILLIS
57	57	else if ((base58'2T' == $match0))
58	58	then 60000
59	59	else throw("Unknown chain")
60	60	}
61	61
62	62	let oldStakingContractStr = match chain {
63	63	case _ =>
64	64	if ((base58'2W' == $match0))
65	65	then "3PLncXtS1U83D6cQbFD3H8rBHPLgzxSFKZ1"
66	66	else if ((base58'2T' == $match0))
67	67	then "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm"
68	68	else throw("Unknown chain")
69	69	}
70	70
71	71	func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
72	72
73	73
74	74	let IdxCfgAcres2Dapp = 1
75	75
76	76	let IdxCfgWlgDapp = 2
77	77
78	78	let IdxCfgInvestFundDapp = 5
79	79
80	80	func keyRestCfg () = "%s__restConfig"
81	81
82	82
83	83	func keyRest2Address () = "%s__rest2Addr"
84	84
85	85
86	86	func readRestCfgOrFail (rest) = split_4C(getStringOrFail(rest, keyRestCfg()), SEP)
87	87
88	88
89	89	func getContractAddressOrFail (rest2Cfg,idx) = valueOrErrorMessage(addressFromString(rest2Cfg[idx]), ("Rest cfg doesn't contain address at index " + toString(idx)))
90	90
91	91
92	92	let rest2Contract = addressFromStringValue(valueOrElse(getString(this, keyRest2Address()), defaultRest2AddressStr))
93	93
94	94	let rest2Cfg = readRestCfgOrFail(rest2Contract)
95	95
96	96	let acres2Contract = getContractAddressOrFail(rest2Cfg, IdxCfgAcres2Dapp)
97	97
98	98	let wlgContract = getContractAddressOrFail(rest2Cfg, IdxCfgWlgDapp)
99	99
100	100	let investFundContract = getContractAddressOrFail(rest2Cfg, IdxCfgInvestFundDapp)
101	101
102	102	let oldAcresContractKey = "oldAcresContract"
103	103
104	104	func keyBlocked () = "contractsBlocked"
105	105
106	106
107	107	func keyLastWeekTxIdByUser (addr) = ("lastWeekTxIdByUser_" + addr)
108	108
109	109
110	110	func keyCurWeekTxIdByUser (addr) = ("curWeekTxIdByUser_" + addr)
111	111
112	112
113	113	func keyCommit (address) = ("finishBlockFor_" + address)
114	114
115	115
116	116	let wlgAssetIdKey = "wlg_assetId"
117	117
118	118	let wlgAssetId = valueOrErrorMessage(getBinary(wlgContract, wlgAssetIdKey), "WLGOLD is not issued yet")
119	119
120	120	let acresIssuedAmountKey = "acresIssuedAmount"
121	121
122	122	let acresAssetIdKey = "acresAssetId"
123	123
124	124	let acresAssetId = valueOrErrorMessage(getBinary(acres2Contract, acresAssetIdKey), "ACRES is not issued yet")
125	125
126	126	func keyAcresStakedTimeByUser (addr) = ("acresStakedTimeByUser_" + addr)
127	127
128	128
129	129	func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
130	130
131	131
132	132	func keyStakedDuckByOwner (ownerAddr) = ("stakedDuckByOwner_" + ownerAddr)
133	133
134	134
135	135	func keyStakedTimeByAssetIdAndOwner (assetId,addr) = ((("st_" + assetId) + "_") + addr)
136	136
137	137
138	138	func keyStakedNFTsByOwner (ownerAddr) = ("stakedNFTsByOwner_" + ownerAddr)
139	139
140	140
141	141	func asInt (v) = match v {
142	142	case n: Int =>
143	143	n
144	144	case _ =>
145	145	throw("fail to cast into Int")
146	146	}
147	147
148	148
149	149	func asTuple5Ints (val) = match val {
150	150	case t: (Int, Int, Int, Int, Int) =>
151	151	t
152	152	case _ =>
153	153	throw("fail to cast into (Int, Int, Int, Int, Int)")
154	154	}
155	155
156	156
157	157	func asTuple4Ints (val) = match val {
158	158	case t: (Int, Int, Int, Int) =>
159	159	t
160	160	case _ =>
161	161	throw("fail to cast into (Int, Int, Int, Int)")
162	162	}
163	163
164	164
165	165	func asTuple3Ints (val) = match val {
166	166	case t: (Int, Int, Int) =>
167	167	t
168	168	case _ =>
169	169	throw("fail to cast into (Int, Int, Int)")
170	170	}
171	171
172	172
173	173	func asTuple2Ints (val) = match val {
174	174	case t: (Int, Int) =>
175	175	t
176	176	case _ =>
177	177	throw("fail to cast into (Int, Int)")
178	178	}
179	179
180	180
181	181	func fixedPoint (val,decimals) = {
182	182	let tenPow = pow(10, 0, decimals, 0, 0, DOWN)
183	183	let lowPart = toString((val % tenPow))
184	184	let zeroes = drop(toString(tenPow), (1 + size(lowPart)))
185	185	(((toString((val / tenPow)) + ".") + zeroes) + lowPart)
186	186	}
187	187
188	188
189	189	func getRandomNumber (maxValue,salt,entropy) = if ((0 >= maxValue))
190	190	then throw("maxValue should be > 0")
191	191	else {
192	192	let randomHash = sha256_16Kb((salt + entropy))
193	193	(toInt(randomHash) % maxValue)
194	194	}
195	195
196	196
197	197	let M6_ = 1000000
198	198
199	199	let M8_ = 100000000
200	200
201	201	let wlgIssuedAmtKey = "wlg_issuedAmount"
202	202
203	203	let zbIssuedAmtKey = "zbill_issuedAmount"
204	204
205	205	func keyAcresStakedAmtByUser (addr) = ("acresStakedAmountByUser_" + addr)
206	206
207	207
208	208	func keyFarmingPowerByUser (addr) = ("farmingPowerByUser_" + addr)
209	209
210	210
211	211	let acresStakdTotalKey = "acresStakedAmountTotal"
212	212
213	213	let totalFarmingPowerKey = "totalFarmingPower"
214	214
215	215	let MAX_WL_NFTS = 3
216	216
217	217	let MAX_ARK_NFTS = 1
218	218
219	219	let ARK_NFT_BONUS = 5000
220	220
221	221	let MAX_NFTS_STAKED_BY_USER = 4
222	222
223	223	let keyNftTotalIssued = "nftTotalIssued"
224	224
225	225	let keyNftTotalBurned = "nftTotalBurned"
226	226
227	227	let keyWlNftTotalStaked = "WlNftTotalStaked"
228	228
229	229	let keyArkNftTotalStaked = "ArkNftTotalStaked"
230	230
231	231	func keyNftNumberByAssetId (assetId) = ("nftNumberByAssetId_" + assetId)
232	232
233	233
234	234	func keyUserWlNftNumber (addr) = ("userWlNftNumber_" + addr)
235	235
236	236
237	237	func keyUserArkNftNumber (addr) = ("userArkNftNumber_" + addr)
238	238
239	239
240	240	func keyUserFullBonus (addr) = ("userFullBonus_" + addr)
241	241
242	242
243	243	let levelAcres = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
244	244
245	245	func getLevelByAcres (acres) = {
246	246	let acr = ((acres + 99999999) / M8_)
247	247	func checker (acc,item) = if ((item >= acr))
248	248	then acc
249	249	else (acc + 1)
250	250
251	251	let $l = levelAcres
252	252	let $s = size($l)
253	253	let $acc0 = 0
254	254	func $f0_1 ($a,$i) = if (($i >= $s))
255	255	then $a
256	256	else checker($a, $l[$i])
257	257
258	258	func $f0_2 ($a,$i) = if (($i >= $s))
259	259	then $a
260	260	else throw("List size exceeds 10")
261	261
262	262	$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
263	263	}
264	264
265	265
266	266	func getFarmingPowerByAcres (acres) = ((acres * 20) * (getLevelByAcres(acres) + 4))
267	267
268	268
269	269	func getFarmingPowerByAcresAndBonus (acres,bonus6) = {
270	270	let notBonused = getFarmingPowerByAcres(acres)
271	271	$Tuple2(fraction(notBonused, (M6_ + bonus6), M6_), notBonused)
272	272	}
273	273
274	274
275	275	let teamAddrKey = "teamAddr"
276	276
277	277	func keyLastWlgTradeTimeByUser (addr) = ("lastArbTimeUser_" + addr)
278	278
279	279
280	280	let OLD_STAKING_DEADL = 1733346000000
281	281
282	282	let keyLastAcresSellTime = "lastAcresSellTime"
283	283
284	284	let keyLastLimitLeft = "lastLimitLeft"
285	285
286	286	let names = ["Gold shovel", "Pickaxe"]
287	287
288	288	let descriptions = ["Reward for early birds", "Increases FarmPower"]
289	289
290	290	let idxDescrShovel = 0
291	291
292	292	let idxDescrPickaxe = 1
293	293
294	294	let rarityThresholds = [5, 10, 20]
295	295
296	296	let idxThresholdC = 0
297	297
298	298	let idxThresholdU = 1
299	299
300	300	let idxThresholdL = 2
301	301
302	302	let namez = ["SHOVEL", "PICKAXE"]
303	303
304	304	let idxNameShovel = 0
305	305
306	306	let idxNamePickaxe = 1
307	307
308	308	let contentKeyz = ["contentPickaxeC", "contentPickaxeU", "contentPickaxeL", "contentPickaxeE", "contentShovelP"]
309	309
310	310	let idxKeyC = 0
311	311
312	312	let idxKeyP = 4
313	313
314	314	let rarityNames = ["Common", "Uncommon", "Legendary", "Epic", "Promo"]
315	315
316	316	let idxRarityC = 0
317	317
318	318	let idxRarityU = 1
319	319
320	320	let idxRarityL = 2
321	321
322	322	let idxRarityE = 3
323	323
324	324	let idxRarityP = 4
325	325
326	326	let collectionz = ["Digging tools"]
327	327
328	328	let idxCollDig = 0
329	329
330	330	let bonusTypez = ["FarmPower"]
331	331
332	332	let idxBonusTypeFp = 0
333	333
334	334	func prolog (i) = if (if ((i.originCaller != rest2Contract))
335	335	then valueOrElse(getBoolean(keyBlocked()), false)
336	336	else false)
337	337	then throw("Contracts are under maintenance")
338	338	else {
339	339	let addr = toString(i.originCaller)
340	340	let week = (height / WEEK_BLOCKS)
341	341	let lastWeekKey = keyLastWeekTxIdByUser(addr)
342	342	let lastWeekTxIdByUser = getString(lastWeekKey)
343	343	let txId = toBase58String(i.transactionId)
344	344	let wtx = ((toString(week) + "_") + txId)
345	345	let curWeekKey = keyCurWeekTxIdByUser(addr)
346	346	if (isDefined(lastWeekTxIdByUser))
347	347	then {
348	348	let lastWeekTx = split(value(lastWeekTxIdByUser), "_")
349	349	if ((lastWeekTx[0] == toString(week)))
350	350	then [StringEntry(lastWeekKey, wtx), StringEntry(curWeekKey, wtx)]
351	351	else if ((lastWeekTx[0] == toString((week - 1))))
352	352	then [StringEntry(curWeekKey, wtx)]
353	353	else {
354	354	let curWeekTxIdByUser = getStringValue(curWeekKey)
355	355	let curWeekTx = split(curWeekTxIdByUser, "_")
356	356	if ((curWeekTx[0] == toString(week)))
357	357	then [StringEntry(curWeekKey, wtx)]
358	358	else [StringEntry(lastWeekKey, curWeekTxIdByUser), StringEntry(curWeekKey, wtx)]
359	359	}
360	360	}
361	361	else [StringEntry(lastWeekKey, wtx), StringEntry(curWeekKey, wtx)]
362	362	}
363	363
364	364
365	365	func createNftDescrCustom (contKey,nftSerial,collection,name,descr,rarity,bonus,bonusType) = (((((((((((((((((((((((("{\"url\": \"https://waveslands.com\", " + "\"contentKey\": \"") + contKey) + "\", ") + "\"number\": ") + toString(nftSerial)) + ", ") + "\"collection\": \"") + collection) + "\", ") + "\"name\": \"") + name) + "\", ") + "\"description\": \"") + descr) + "\", ") + "\"rare\": \"") + rarity) + "\", ") + "\"bonus\": ") + toString(bonus)) + ", ") + "\"bonusType\": \"") + bonusType) + "\"}")
366	366
367	367
368	368	func issueNftCustom (nameIdx,contKeyIdx,collIdx,rarityIdx,bonusPerc,descrIdx,bonusTypeIdx,addr) = {
369	369	let nftSerial = valueOrElse(getInteger(keyNftTotalIssued), 0)
370	370	let rarity = rarityNames[rarityIdx]
371	371	let name = (((namez[nameIdx] + "-") + take(rarity, 1)) + toString(bonusPerc))
372	372	let issue = Issue(name, createNftDescrCustom(contentKeyz[contKeyIdx], nftSerial, collectionz[collIdx], names[nameIdx], descriptions[descrIdx], rarityNames[rarityIdx], bonusPerc, bonusTypez[bonusTypeIdx]), 1, 0, false)
373	373	let nftAssetId = calculateAssetId(issue)
374	374	$Tuple2([issue, IntegerEntry(keyNftTotalIssued, (nftSerial + 1)), IntegerEntry(keyNftNumberByAssetId(toBase58String(nftAssetId)), nftSerial), ScriptTransfer(addr, 1, nftAssetId)], nftAssetId)
375	375	}
376	376
377	377
378	378	func bonusByDescription (descr) = if (!(contains(descr, "\"bonusType\": \"FarmPower\"")))
379	379	then throw(("NFT is not supported: " + descr))
380	380	else {
381	381	let bonusStr = split_4C(split_4C(descr, "\"bonus\":")[1], ",")[0]
382	382	parseIntValue(drop(bonusStr, (valueOrElse(lastIndexOf(bonusStr, " "), -1) + 1)))
383	383	}
384	384
385	385
386	386	func rarityIdxByDescriprion (descr) = if (!(contains(descr, "\"rare\"")))
387	387	then throw(("NFT is not supported: " + descr))
388	388	else {
389	389	let rarityStr = split_4C(split_4C(split_4C(descr, "\"rare\"")[1], ",")[0], "\"")[1]
390	390	value(indexOf(rarityNames, rarityStr))
391	391	}
392	392
393	393
394	394	func stakeUnstakeAcresInternal (amt,address,bonusDelta) = if (if ((amt == 0))
395	395	then (bonusDelta == 0)
396	396	else false)
397	397	then throw("Nothing to do")
398	398	else {
399	399	let wlgResult = invoke(wlgContract, "onStakeUnstakeLand", [address, true], nil)
400	400	if ((wlgResult == wlgResult))
401	401	then {
402	402	let now = lastBlock.timestamp
403	403	let timeKey = keyAcresStakedTimeByUser(address)
404	404	let amountKey = keyAcresStakedAmtByUser(address)
405	405	let oldAcresAmount = valueOrElse(getInteger(amountKey), 0)
406	406	if (if ((0 > amt))
407	407	then (0 > (oldAcresAmount + amt))
408	408	else false)
409	409	then throw(((("You have only " + fixedPoint(oldAcresAmount, 8)) + " ACRES staked, tried to unstake ") + fixedPoint(-(amt), 8)))
410	410	else {
411	411	let newAcresAmount = (oldAcresAmount + amt)
412	412	let oldTotal = valueOrElse(getInteger(acresStakdTotalKey), 0)
413	413	let userFpKey = keyFarmingPowerByUser(address)
414	414	let oldFp = valueOrElse(getInteger(userFpKey), 0)
415	415	let bonusKey = keyUserFullBonus(address)
416	416	let oldBonus = valueOrElse(getInteger(acres2Contract, bonusKey), 0)
417	417	if (if ((0 > bonusDelta))
418	418	then (0 > (oldBonus + bonusDelta))
419	419	else false)
420	420	then throw((((("You have only " + fixedPoint(oldBonus, 4)) + "% bonus, and tried to unstake ") + fixedPoint(-(bonusDelta), 4)) + "%"))
421	421	else {
422	422	let $t063056404 = getFarmingPowerByAcresAndBonus(newAcresAmount, (oldBonus + bonusDelta))
423	423	let newBonusedFp = $t063056404._1
424	424	let ignored = $t063056404._2
425	425	let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
426	426	let acresActions = if ((amt == 0))
427	427	then nil
428	428	else [IntegerEntry(amountKey, newAcresAmount), IntegerEntry(acresStakdTotalKey, (oldTotal + amt))]
429	429	let bonusActions = if ((bonusDelta == 0))
430	430	then nil
431	431	else [IntegerEntry(bonusKey, (oldBonus + bonusDelta))]
432	432	$Tuple2(((((acresActions ++ bonusActions) :+ IntegerEntry(timeKey, lastBlock.timestamp)) :+ IntegerEntry(userFpKey, newBonusedFp)) :+ IntegerEntry(totalFarmingPowerKey, ((oldTotalFp + newBonusedFp) - oldFp))), wlgResult)
433	433	}
434	434	}
435	435	}
436	436	else throw("Strict value is not equal to itself.")
437	437	}
438	438
439	439
440	440	func getWlgPrice (usdtBalanceCorrection) = {
441	441	let issuedAmount = valueOrErrorMessage(getInteger(wlgContract, wlgIssuedAmtKey), "WLGOLD is not issued yet")
442	442	let wlgUsd = assetBalance(wlgContract, usdtAssetId)
443	443	let acres2Usd = (assetBalance(acres2Contract, usdtAssetId) - usdtBalanceCorrection)
444	444	let investFundTotal = (assetBalance(investFundContract, usdtAssetId) + valueOrElse(getInteger(investFundContract, zbIssuedAmtKey), 0))
445	445	let totalFundsUsd = ((acres2Usd + wlgUsd) + investFundTotal)
446	446	fraction(totalFundsUsd, MULT8, issuedAmount)
447	447	}
448	448
449	449
450	450	func getSwapLimitAcres () = {
451	451	let wlgUsd = assetBalance(wlgContract, usdtAssetId)
452	452	let acres2Usd = assetBalance(this, usdtAssetId)
453	453	let investFundTotal = (assetBalance(investFundContract, usdtAssetId) + valueOrElse(getInteger(investFundContract, zbIssuedAmtKey), 0))
454	454	let defaultLimit = (((acres2Usd + wlgUsd) + investFundTotal) / ONE_PERCENT_DIVISOR)
455	455	let lastLimitLeft = valueOrElse(getInteger(keyLastLimitLeft), defaultLimit)
456	456	let lastTime = valueOrElse(getInteger(keyLastAcresSellTime), 0)
457	457	let now = lastBlock.timestamp
458	458	let currentLimit = (lastLimitLeft + fraction(defaultLimit, (now - lastTime), DAY_MILLIS))
459	459	let limitLeftUsdt = min([currentLimit, defaultLimit])
460	460	$Tuple2(IntegerEntry(keyLastAcresSellTime, now), limitLeftUsdt)
461	461	}
462	462
463	463
464	464	let arkOracle = addressFromStringValue("3PJgZ6AK1WVCpdCmEZpesHmaKvrQDdXG5og")
465	465
466	466	let incubator = valueOrElse(getString(arkOracle, "static_incubatorAddress"), "")
467	467
468	468	let breeder = valueOrElse(getString(arkOracle, "static_breederAddress"), "")
469	469
470	470	let turtleIncubator = valueOrElse(getString(arkOracle, "static_turtleIncubatorAddress"), "")
471	471
472	472	let turtleBreeder = valueOrElse(getString(arkOracle, "static_turtleBreederAddress"), "")
473	473
474	474	let canineIncubator = valueOrElse(getString(arkOracle, "static_canineIncubatorAddress"), "")
475	475
476	476	let canineBreeder = valueOrElse(getString(arkOracle, "static_canineBreederAddress"), "")
477	477
478	478	let felineIncubator = valueOrElse(getString(arkOracle, "static_felineIncubatorAddress"), "")
479	479
480	480	let felineBreeder = valueOrElse(getString(arkOracle, "static_felineBreederAddress"), "")
481	481
482	482	let mutantBreeder = valueOrElse(getString(arkOracle, "static_mutantIncubatorAddress"), "")
483	483
484	484	func isArkimalIssued (nfo) = {
485	485	let issuer = toString(nfo.issuer)
486	486	if (if (if (if (if (if (if (if (if (if ((chain == base58'2T'))
487	487	then (issuer == oldStakingContractStr)
488	488	else false)
489	489	then true
490	490	else (issuer == incubator))
491	491	then true
492	492	else (issuer == breeder))
493	493	then true
494	494	else (issuer == turtleIncubator))
495	495	then true
496	496	else (issuer == turtleBreeder))
497	497	then true
498	498	else (issuer == canineIncubator))
499	499	then true
500	500	else (issuer == canineBreeder))

github/deemru/w8io/026f985 
113.05 ms ◑