tx · CMpXSrPGqpkQoKJdzK7MYiNCSt36qmxUuv5ZZ1SRskHE

3NBPx1Fciu3JQNEGZ21jSnTdutLNGGBUSXh:  -0.02900000 Waves

2024.11.29 06:35 [3392191] smart account 3NBPx1Fciu3JQNEGZ21jSnTdutLNGGBUSXh > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CMpXSrPGqpkQoKJdzK7MYiNCSt36qmxUuv5ZZ1SRskHE",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1732851368049,
    "version": 2,
    "chainId": 84,
    "sender": "3NBPx1Fciu3JQNEGZ21jSnTdutLNGGBUSXh",
    "senderPublicKey": "3QtfC1XbLZXdeawMDeSERy9vvjUmj1XYd2GFmrvx7pWQ",
    "proofs": [
        "3SvsL8eunES8X1VvkaoRnXgQsXJ6d2HUtJUfcibw119YAjABRVdgvXc541R6uJYDCBi3eptJyDdsvzeYLAG8UrBX"
    ],
    "script": "base64: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",
    "height": 3392191,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: FkuouCruxf26S6783WN9HtAwaEcUXm26w4tpTzigbPrD
Next: GA2UU9F6mipcYYJXiK8DyuuXwDmb63ccEcor7gfsiL85

Diff: 

OldNewDifferences
191191 
192192 let totalFarmingPowerKey = "totalFarmingPower"
193193 
194-let IdxDtx3PercConversion = 0
195-
196194 let MAX_WL_NFTS = 3
197195 
198196 let MAX_ARK_NFTS = 1
264262 
265263 let contentKeys = ["contentShovelP3", "contentPickaxeC1", "contentPickaxeC3", "contentPickaxeC5", "contentPickaxeC10"]
266264 
267-let names = ["Gold shovel", "Pickaxe", "Pickaxe", "Pickaxe", "Pickaxe"]
265+let names = ["Gold shovel", "Pickaxe"]
268266 
269-let descriptions = ["Reward for early birds", "Increases FarmPower", "Increases FarmPower", "Increases FarmPower", "Increases FarmPower"]
267+let descriptions = ["Reward for early birds", "Increases FarmPower"]
270268 
271-let rarities = ["Promo", "Common", "Common", "Common", "Common"]
269+let idxDescrShovel = 0
270+
271+let idxDescrPickaxe = 1
272+
273+let rarities = ["Promo", "Common"]
272274 
273275 let bonuses = [3, 1, 3, 5, 10]
276+
277+let namez = ["SHOVEL", "PICKAXE"]
278+
279+let idxNameShovel = 0
280+
281+let idxNamePickaxe = 1
282+
283+let contentKeyz = ["contentPickaxeC", "contentPickaxeU", "contentPickaxeL", "contentPickaxeE", "contentShovelP"]
284+
285+let idxKeyC = 0
286+
287+let idxKeyP = 4
288+
289+let rarityNames = ["Common", "Uncommon", "Legendary", "Epic", "Promo"]
290+
291+let idxRarityC = 0
292+
293+let idxRarityP = 4
294+
295+let collectionz = ["Digging tools"]
296+
297+let idxCollDig = 0
298+
299+let bonusTypez = ["FarmPower"]
300+
301+let idxBonusTypeFp = 0
274302 
275303 func prolog (i) = if (if ((i.originCaller != rest2Contract))
276304     then valueOrElse(getBoolean(keyBlocked()), false)
279307     else {
280308         let addr = toString(i.originCaller)
281309         let week = (height / WEEK_BLOCKS)
282-        let lastWeekTxIdByUser = getString(keyLastWeekTxIdByUser(addr))
310+        let lastWeekKey = keyLastWeekTxIdByUser(addr)
311+        let lastWeekTxIdByUser = getString(lastWeekKey)
283312         let txId = toBase58String(i.transactionId)
284313         let wtx = ((toString(week) + "_") + txId)
314+        let curWeekKey = keyCurWeekTxIdByUser(addr)
285315         if (isDefined(lastWeekTxIdByUser))
286316             then {
287317                 let lastWeekTx = split(value(lastWeekTxIdByUser), "_")
288318                 if ((lastWeekTx[0] == toString(week)))
289-                    then [StringEntry(keyLastWeekTxIdByUser(addr), wtx), StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
319+                    then [StringEntry(lastWeekKey, wtx), StringEntry(curWeekKey, wtx)]
290320                     else if ((lastWeekTx[0] == toString((week - 1))))
291-                        then [StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
321+                        then [StringEntry(curWeekKey, wtx)]
292322                         else {
293-                            let curWeekTxIdByUser = getStringValue(keyLastWeekTxIdByUser(addr))
323+                            let curWeekTxIdByUser = getStringValue(curWeekKey)
294324                             let curWeekTx = split(curWeekTxIdByUser, "_")
295325                             if ((curWeekTx[0] == toString(week)))
296-                                then [StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
297-                                else [StringEntry(keyLastWeekTxIdByUser(addr), curWeekTxIdByUser), StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
326+                                then [StringEntry(curWeekKey, wtx)]
327+                                else [StringEntry(lastWeekKey, curWeekTxIdByUser), StringEntry(curWeekKey, wtx)]
298328                             }
299329                 }
300-            else [StringEntry(keyLastWeekTxIdByUser(addr), wtx), StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
330+            else [StringEntry(lastWeekKey, wtx), StringEntry(curWeekKey, wtx)]
301331         }
332+
333+
334+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) + "\"}")
335+
336+
337+func issueNftCustom (nameIdx,contKeyIdx,collIdx,rarityIdx,bonusPerc,descrIdx,bonusTypeIdx,addr) = {
338+    let nftSerial = valueOrElse(getInteger(keyNftTotalIssued), 0)
339+    let rarity = rarityNames[rarityIdx]
340+    let name = (((namez[nameIdx] + "-") + take(rarity, 1)) + toString(bonusPerc))
341+    let issue = Issue(name, createNftDescrCustom(contentKeyz[contKeyIdx], nftSerial, collectionz[collIdx], names[nameIdx], descriptions[descrIdx], rarityNames[rarityIdx], bonusPerc, bonusTypez[bonusTypeIdx]), 1, 0, false)
342+    let nftAssetId = calculateAssetId(issue)
343+    $Tuple2([issue, IntegerEntry(keyNftTotalIssued, (nftSerial + 1)), IntegerEntry(keyNftNumberByAssetId(toBase58String(nftAssetId)), nftSerial), ScriptTransfer(addr, 1, nftAssetId)], nftAssetId)
344+    }
302345 
303346 
304347 func createNftDescription (nftIndex,nftSerial) = ((((((((((((((((((((("{\"url\": \"https://waveslands.com\", " + "\"contentKey\": \"") + contentKeys[nftIndex]) + "\", ") + "\"number\": ") + nftSerial) + ", ") + "\"collection\": \"Digging tools") + "\", ") + "\"name\": \"") + names[nftIndex]) + "\", ") + "\"description\": \"") + descriptions[nftIndex]) + "\", ") + "\"rare\": \"") + rarities[nftIndex]) + "\", ") + "\"bonus\": ") + toString(bonuses[nftIndex])) + ", ") + "\"bonusType\": \"FarmPower\"}")
342385                             else false)
343386                             then throw((((("You have only " + fixedPoint(oldBonus, 4)) + "% bonus, and tried to unstake ") + fixedPoint(-(bonusDelta), 4)) + "%"))
344387                             else {
345-                                let $t048204919 = getFarmingPowerByAcresAndBonus(newAcresAmount, (oldBonus + bonusDelta))
346-                                let newBonusedFp = $t048204919._1
347-                                let ignored = $t048204919._2
388+                                let $t066976796 = getFarmingPowerByAcresAndBonus(newAcresAmount, (oldBonus + bonusDelta))
389+                                let newBonusedFp = $t066976796._1
390+                                let ignored = $t066976796._2
348391                                 let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
349392                                 let acresActions = if ((amt == 0))
350393                                     then nil
442485     if ((nftNumber >= limit))
443486         then throw((("You can stake max " + toString(limit)) + " of such NFTs"))
444487         else {
445-            let $t094469522 = stakeUnstakeAcresInternal(0, addr, bonus6)
446-            let actions = $t094469522._1
447-            let wlgClaimedAmount = $t094469522._2
488+            let $t01132311399 = stakeUnstakeAcresInternal(0, addr, bonus6)
489+            let actions = $t01132311399._1
490+            let wlgClaimedAmount = $t01132311399._2
448491             $Tuple2((((actions :+ IntegerEntry(userNumKey, (nftNumber + 1))) :+ IntegerEntry(totalNumKey, (valueOrElse(getInteger(totalNumKey), 0) + 1))) :+ IntegerEntry(keyStakedTimeByAssetIdAndOwner(assetIdStr, addr), lastBlock.timestamp)), wlgClaimedAmount)
449492             }
450493     }
488531                     if ((arbReleaseTime > lastBlock.timestamp))
489532                         then throw(("You traded some WLGOLD, cannot unstake until " + toString(arbReleaseTime)))
490533                         else {
491-                            let $t01109611176 = stakeUnstakeAcresInternal(-(amount), address, 0)
492-                            let actions = $t01109611176._1
493-                            let wlgClaimedAmount = $t01109611176._2
534+                            let $t01297313053 = stakeUnstakeAcresInternal(-(amount), address, 0)
535+                            let actions = $t01297313053._1
536+                            let wlgClaimedAmount = $t01297313053._2
494537                             $Tuple2(((actions :+ ScriptTransfer(i.caller, amount, acresAssetId)) ++ prologActions), wlgClaimedAmount)
495538                             }
496539                     }
513556                 else (value(pmt.assetId) != acresAssetId))
514557                 then throw("ACRES payments only!")
515558                 else {
516-                    let $t01162711703 = stakeUnstakeAcresInternal(amt, address, 0)
517-                    let actions = $t01162711703._1
518-                    let wlgClaimedAmount = $t01162711703._2
559+                    let $t01350413580 = stakeUnstakeAcresInternal(amt, address, 0)
560+                    let actions = $t01350413580._1
561+                    let wlgClaimedAmount = $t01350413580._2
519562                     $Tuple2((actions ++ prologActions), wlgClaimedAmount)
520563                     }
521564             }
579622                     then throw((("Min payment should be " + fixedPoint(MULT7, 8)) + " ACRES"))
580623                     else {
581624                         let addr = toString(i.caller)
582-                        let $t01356013608 = getSwapLimitAcres()
583-                        let limitAction = $t01356013608._1
584-                        let maxUsdt = $t01356013608._2
625+                        let $t01543715485 = getSwapLimitAcres()
626+                        let limitAction = $t01543715485._1
627+                        let maxUsdt = $t01543715485._2
585628                         let maxAcres = (maxUsdt * USDT2ACRES_MULTIPLIER)
586629                         if ((acresAmount > maxAcres))
587630                             then throw((("You can sell max " + fixedPoint(maxAcres, 8)) + " ACRES"))
597640 
598641 @Callable(i)
599642 func sellAcresREADONLY (address,acresAmount) = {
600-    let $t01410414152 = getSwapLimitAcres()
601-    let limitAction = $t01410414152._1
602-    let maxUsdt = $t01410414152._2
643+    let $t01598116029 = getSwapLimitAcres()
644+    let limitAction = $t01598116029._1
645+    let maxUsdt = $t01598116029._2
603646     let usdtAmount = ((acresAmount / USDT2ACRES_MULTIPLIER) / 2)
604647     $Tuple2(nil, [usdtAmount, MULT7, (maxUsdt * USDT2ACRES_MULTIPLIER), 0])
605648     }
651694                                 let req = invoke(oldAcresAddress, "requestAcresCallback", [(((rr._1 + rr._2) + rr._3) + rr._4)], nil)
652695                                 if ((req == req))
653696                                     then {
654-                                        let $t01602116101 = issueNFTinternal(IdxDtx3PercConversion, i.caller)
655-                                        let nftActions = $t01602116101._1
656-                                        let nftAssetId = $t01602116101._2
697+                                        let $t01789818036 = issueNftCustom(idxNameShovel, idxKeyP, idxCollDig, idxRarityP, 3, idxDescrShovel, idxBonusTypeFp, i.caller)
698+                                        let nftActions = $t01789818036._1
699+                                        let nftAssetId = $t01789818036._2
657700                                         $Tuple5(rr._1, rr._2, rr._3, rr._4, nftActions)
658701                                         }
659702                                     else throw("Strict value is not equal to itself.")
720763     let userFpKey = keyFarmingPowerByUser(address)
721764     let oldFp = valueOrElse(getInteger(userFpKey), 0)
722765     let userBonus = valueOrElse(getInteger(acres2Contract, keyUserFullBonus(address)), 0)
723-    let $t01826618353 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
724-    let newBonusedFp = $t01826618353._1
725-    let ignored = $t01826618353._2
766+    let $t02020120288 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
767+    let newBonusedFp = $t02020120288._1
768+    let ignored = $t02020120288._2
726769     let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
727770     let newTotalFp = ((oldTotalFp + newBonusedFp) - oldFp)
728771     $Tuple2(nil, [oldFp, newBonusedFp, oldTotalFp, newTotalFp])
731774 
732775 
733776 @Callable(i)
734-func issueNFT (forAddress,nftIndex) = if ((i.caller != wlgContract))
777+func issuePickC1 (forAddress) = if ((i.caller != wlgContract))
735778     then throw("Permission denied")
736-    else issueNFTinternal(nftIndex, addressFromStringValue(forAddress))
737-
738-
739-
740-@Callable(i)
741-func issueNftAdmin (forAddress,nftIndex,serial) = if ((i.caller != this))
742-    then throw("Permission denied")
743-    else if ((nftIndex >= size(contentKeys)))
744-        then throw("nftIndex out of bounds")
745-        else {
746-            let issue = Issue(nftNames[nftIndex], createNftDescription(nftIndex, toString(serial)), 1, 0, false)
747-            let nftAssetId = calculateAssetId(issue)
748-            $Tuple2([issue, IntegerEntry(keyNftNumberByAssetId(toBase58String(nftAssetId)), serial), ScriptTransfer(addressFromStringValue(forAddress), 1, nftAssetId)], nftAssetId)
749-            }
779+    else issueNftCustom(idxNamePickaxe, idxKeyC, idxCollDig, idxRarityC, 1, idxDescrPickaxe, idxBonusTypeFp, addressFromStringValue(forAddress))
750780 
751781 
752782 
777807                                 let listAction = StringEntry(nftsKey, makeString_2C((nfts :+ assetIdStr), "_"))
778808                                 if ((asset.issuer == this))
779809                                     then {
780-                                        let $t02032220512 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
781-                                        let actions = $t02032220512._1
782-                                        let wlgClaimedAmount = $t02032220512._2
810+                                        let $t02169721887 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
811+                                        let actions = $t02169721887._1
812+                                        let wlgClaimedAmount = $t02169721887._2
783813                                         $Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
784814                                         }
785815                                     else if ((isArkimalIssued(asset) == ""))
786816                                         then throw("Only WavesLands and Arkimals NFT tokens are accepted")
787817                                         else {
788-                                            let $t02069320844 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
789-                                            let actions = $t02069320844._1
790-                                            let wlgClaimedAmount = $t02069320844._2
818+                                            let $t02206822219 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
819+                                            let actions = $t02206822219._1
820+                                            let wlgClaimedAmount = $t02206822219._2
791821                                             $Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
792822                                             }
793823                                 }
824854                                 then {
825855                                     let wlNftNumber = valueOrElse(getInteger(keyUserWlNftNumber(addr)), 0)
826856                                     let bonusVal = (bonusByDescription(value(asset.description)) * 10000)
827-                                    let $t02200922088 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
828-                                    let actions = $t02200922088._1
829-                                    let wlgClaimedAmount = $t02200922088._2
857+                                    let $t02338423463 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
858+                                    let actions = $t02338423463._1
859+                                    let wlgClaimedAmount = $t02338423463._2
830860                                     $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)
831861                                     }
832862                                 else {
835865                                         then throw("Only WavesLands and Arkimals NFT tokens are accepted")
836866                                         else {
837867                                             let arkNftNumber = valueOrElse(getInteger(keyUserArkNftNumber(addr)), 0)
838-                                            let $t02274822832 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
839-                                            let actions = $t02274822832._1
840-                                            let wlgClaimedAmount = $t02274822832._2
868+                                            let $t02412324207 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
869+                                            let actions = $t02412324207._1
870+                                            let wlgClaimedAmount = $t02412324207._2
841871                                             $Tuple2((((((actions :+ listAction) :+ IntegerEntry(keyUserArkNftNumber(addr), (arkNftNumber - 1))) :+ DeleteEntry(keyStakedTimeByAssetIdAndOwner(toBase58String(assetId), addr))) :+ ScriptTransfer(i.caller, 1, assetId)) ++ prologActions), wlgClaimedAmount)
842872                                             }
843873                                     }
874904                                 }
875905                         }
876906 
877-                    let $t02404424123 = {
907+                    let $t02543625515 = {
878908                         let $l = i.payments
879909                         let $s = size($l)
880910                         let $acc0 = $Tuple3(0, 0, nil)
888918 
889919                         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
890920                         }
891-                    let usdtFee = $t02404424123._1
892-                    let totalBonus = $t02404424123._2
893-                    let burnActions = $t02404424123._3
921+                    let usdtFee = $t02543625515._1
922+                    let totalBonus = $t02543625515._2
923+                    let burnActions = $t02543625515._3
894924                     let nftIndex = if ((totalBonus == 3))
895925                         then 2
896926                         else if ((totalBonus == 5))
905935                             let changeActions = if ((change > 0))
906936                                 then [ScriptTransfer(i.caller, change, usdtAssetId)]
907937                                 else nil
908-                            let $t02458024652 = issueNFTinternal(nftIndex, i.caller)
909-                            let issueNftActions = $t02458024652._1
910-                            let nftAssetId = $t02458024652._2
938+                            let $t02597226044 = issueNFTinternal(nftIndex, i.caller)
939+                            let issueNftActions = $t02597226044._1
940+                            let nftAssetId = $t02597226044._2
911941                             let burned = size(burnActions)
912942                             let burnCounterActions = if ((burned == 0))
913943                                 then nil

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 let MULT6 = 1000000
77 
88 let MULT7 = 10000000
99 
1010 let MULT8 = 100000000
1111 
1212 let DAY_MILLIS = 86400000
1313 
1414 let USDT2ACRES_MULTIPLIER = 10
1515 
1616 let ONE_PERCENT_DIVISOR = 100
1717 
1818 let chain = take(drop(this.bytes, 1), 1)
1919 
2020 let WEEK_BLOCKS = match chain {
2121     case _ => 
2222         if ((base58'2W' == $match0))
2323             then 10080
2424             else if ((base58'2T' == $match0))
2525                 then 180
2626                 else throw("Unknown chain")
2727 }
2828 
2929 let usdtAssetId = match chain {
3030     case _ => 
3131         if ((base58'2W' == $match0))
3232             then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
3333             else if ((base58'2T' == $match0))
3434                 then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
3535                 else throw("Unknown chain")
3636 }
3737 
3838 let defaultRest2AddressStr = match chain {
3939     case _ => 
4040         if ((base58'2W' == $match0))
4141             then "3PFwYta8biEz31zpeFe5DJK8wE5trSpQVF8"
4242             else if ((base58'2T' == $match0))
4343                 then "3N7UuYar6264P58FBhVWKPQAh4Yua2hgngv"
4444                 else throw("Unknown chain")
4545 }
4646 
4747 let arbitrageDelay = match chain {
4848     case _ => 
4949         if ((base58'2W' == $match0))
5050             then DAY_MILLIS
5151             else if ((base58'2T' == $match0))
5252                 then 60000
5353                 else throw("Unknown chain")
5454 }
5555 
5656 let oldStakingContractStr = match chain {
5757     case _ => 
5858         if ((base58'2W' == $match0))
5959             then "3PLncXtS1U83D6cQbFD3H8rBHPLgzxSFKZ1"
6060             else if ((base58'2T' == $match0))
6161                 then "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm"
6262                 else throw("Unknown chain")
6363 }
6464 
6565 func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
6666 
6767 
6868 let IdxCfgAcres2Dapp = 1
6969 
7070 let IdxCfgWlgDapp = 2
7171 
7272 let IdxCfgInvestFundDapp = 5
7373 
7474 func keyRestCfg () = "%s__restConfig"
7575 
7676 
7777 func keyRest2Address () = "%s__rest2Addr"
7878 
7979 
8080 func readRestCfgOrFail (rest) = split_4C(getStringOrFail(rest, keyRestCfg()), SEP)
8181 
8282 
8383 func getContractAddressOrFail (rest2Cfg,idx) = valueOrErrorMessage(addressFromString(rest2Cfg[idx]), ("Rest cfg doesn't contain address at index " + toString(idx)))
8484 
8585 
8686 let rest2Contract = addressFromStringValue(valueOrElse(getString(this, keyRest2Address()), defaultRest2AddressStr))
8787 
8888 let rest2Cfg = readRestCfgOrFail(rest2Contract)
8989 
9090 let acres2Contract = getContractAddressOrFail(rest2Cfg, IdxCfgAcres2Dapp)
9191 
9292 let wlgContract = getContractAddressOrFail(rest2Cfg, IdxCfgWlgDapp)
9393 
9494 let investFundContract = getContractAddressOrFail(rest2Cfg, IdxCfgInvestFundDapp)
9595 
9696 let oldAcresContractKey = "oldAcresContract"
9797 
9898 func keyBlocked () = "contractsBlocked"
9999 
100100 
101101 func keyLastWeekTxIdByUser (addr) = ("lastWeekTxIdByUser_" + addr)
102102 
103103 
104104 func keyCurWeekTxIdByUser (addr) = ("curWeekTxIdByUser_" + addr)
105105 
106106 
107107 let acresIssuedAmountKey = "acresIssuedAmount"
108108 
109109 let acresAssetIdKey = "acresAssetId"
110110 
111111 let acresAssetId = valueOrErrorMessage(getBinary(acres2Contract, acresAssetIdKey), "ACRES is not issued yet")
112112 
113113 func keyAcresStakedTimeByUser (addr) = ("acresStakedTimeByUser_" + addr)
114114 
115115 
116116 func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
117117 
118118 
119119 func keyStakedDuckByOwner (ownerAddr) = ("stakedDuckByOwner_" + ownerAddr)
120120 
121121 
122122 func keyStakedTimeByAssetIdAndOwner (assetId,addr) = ((("st_" + assetId) + "_") + addr)
123123 
124124 
125125 func keyStakedNFTsByOwner (ownerAddr) = ("stakedNFTsByOwner_" + ownerAddr)
126126 
127127 
128128 func asInt (v) = match v {
129129     case n: Int => 
130130         n
131131     case _ => 
132132         throw("fail to cast into Int")
133133 }
134134 
135135 
136136 func asTuple5Ints (val) = match val {
137137     case t: (Int, Int, Int, Int, Int) => 
138138         t
139139     case _ => 
140140         throw("fail to cast into (Int, Int, Int, Int, Int)")
141141 }
142142 
143143 
144144 func asTuple4Ints (val) = match val {
145145     case t: (Int, Int, Int, Int) => 
146146         t
147147     case _ => 
148148         throw("fail to cast into (Int, Int, Int, Int)")
149149 }
150150 
151151 
152152 func asTuple3Ints (val) = match val {
153153     case t: (Int, Int, Int) => 
154154         t
155155     case _ => 
156156         throw("fail to cast into (Int, Int, Int)")
157157 }
158158 
159159 
160160 func asTuple2Ints (val) = match val {
161161     case t: (Int, Int) => 
162162         t
163163     case _ => 
164164         throw("fail to cast into (Int, Int)")
165165 }
166166 
167167 
168168 func fixedPoint (val,decimals) = {
169169     let tenPow = pow(10, 0, decimals, 0, 0, DOWN)
170170     let lowPart = toString((val % tenPow))
171171     let zeroes = drop(toString(tenPow), (1 + size(lowPart)))
172172     (((toString((val / tenPow)) + ".") + zeroes) + lowPart)
173173     }
174174 
175175 
176176 let M6_ = 1000000
177177 
178178 let M8_ = 100000000
179179 
180180 let wlgIssuedAmtKey = "wlg_issuedAmount"
181181 
182182 let zbIssuedAmtKey = "zbill_issuedAmount"
183183 
184184 func keyAcresStakedAmtByUser (addr) = ("acresStakedAmountByUser_" + addr)
185185 
186186 
187187 func keyFarmingPowerByUser (addr) = ("farmingPowerByUser_" + addr)
188188 
189189 
190190 let acresStakdTotalKey = "acresStakedAmountTotal"
191191 
192192 let totalFarmingPowerKey = "totalFarmingPower"
193193 
194-let IdxDtx3PercConversion = 0
195-
196194 let MAX_WL_NFTS = 3
197195 
198196 let MAX_ARK_NFTS = 1
199197 
200198 let ARK_NFT_BONUS = 5000
201199 
202200 let MAX_NFTS_STAKED_BY_USER = 4
203201 
204202 let keyNftTotalIssued = "nftTotalIssued"
205203 
206204 let keyNftTotalBurned = "nftTotalBurned"
207205 
208206 let keyWlNftTotalStaked = "WlNftTotalStaked"
209207 
210208 let keyArkNftTotalStaked = "ArkNftTotalStaked"
211209 
212210 func keyNftNumberByAssetId (assetId) = ("nftNumberByAssetId_" + assetId)
213211 
214212 
215213 func keyUserWlNftNumber (addr) = ("userWlNftNumber_" + addr)
216214 
217215 
218216 func keyUserArkNftNumber (addr) = ("userArkNftNumber_" + addr)
219217 
220218 
221219 func keyUserFullBonus (addr) = ("userFullBonus_" + addr)
222220 
223221 
224222 let levelAcres = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
225223 
226224 func getLevelByAcres (acres) = {
227225     let acr = ((acres + 99999999) / M8_)
228226     func checker (acc,item) =     if ((item >= acr))
229227         then acc
230228         else (acc + 1)
231229 
232230     let $l = levelAcres
233231     let $s = size($l)
234232     let $acc0 = 0
235233     func $f0_1 ($a,$i) =     if (($i >= $s))
236234         then $a
237235         else checker($a, $l[$i])
238236 
239237     func $f0_2 ($a,$i) =     if (($i >= $s))
240238         then $a
241239         else throw("List size exceeds 10")
242240 
243241     $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)
244242     }
245243 
246244 
247245 func getFarmingPowerByAcres (acres) = ((acres * 20) * (getLevelByAcres(acres) + 4))
248246 
249247 
250248 func getFarmingPowerByAcresAndBonus (acres,bonus6) = {
251249     let notBonused = getFarmingPowerByAcres(acres)
252250     $Tuple2(fraction(notBonused, (M6_ + bonus6), M6_), notBonused)
253251     }
254252 
255253 
256254 func keyLastWlgTradeTimeByUser (addr) = ("lastArbTimeUser_" + addr)
257255 
258256 
259257 let keyLastAcresSellTime = "lastAcresSellTime"
260258 
261259 let keyLastLimitLeft = "lastLimitLeft"
262260 
263261 let nftNames = ["SHOVEL-P3", "PICKAXE-C1", "PICKAXE-C3", "PICKAXE-C5", "PICKAXE-C10"]
264262 
265263 let contentKeys = ["contentShovelP3", "contentPickaxeC1", "contentPickaxeC3", "contentPickaxeC5", "contentPickaxeC10"]
266264 
267-let names = ["Gold shovel", "Pickaxe", "Pickaxe", "Pickaxe", "Pickaxe"]
265+let names = ["Gold shovel", "Pickaxe"]
268266 
269-let descriptions = ["Reward for early birds", "Increases FarmPower", "Increases FarmPower", "Increases FarmPower", "Increases FarmPower"]
267+let descriptions = ["Reward for early birds", "Increases FarmPower"]
270268 
271-let rarities = ["Promo", "Common", "Common", "Common", "Common"]
269+let idxDescrShovel = 0
270+
271+let idxDescrPickaxe = 1
272+
273+let rarities = ["Promo", "Common"]
272274 
273275 let bonuses = [3, 1, 3, 5, 10]
276+
277+let namez = ["SHOVEL", "PICKAXE"]
278+
279+let idxNameShovel = 0
280+
281+let idxNamePickaxe = 1
282+
283+let contentKeyz = ["contentPickaxeC", "contentPickaxeU", "contentPickaxeL", "contentPickaxeE", "contentShovelP"]
284+
285+let idxKeyC = 0
286+
287+let idxKeyP = 4
288+
289+let rarityNames = ["Common", "Uncommon", "Legendary", "Epic", "Promo"]
290+
291+let idxRarityC = 0
292+
293+let idxRarityP = 4
294+
295+let collectionz = ["Digging tools"]
296+
297+let idxCollDig = 0
298+
299+let bonusTypez = ["FarmPower"]
300+
301+let idxBonusTypeFp = 0
274302 
275303 func prolog (i) = if (if ((i.originCaller != rest2Contract))
276304     then valueOrElse(getBoolean(keyBlocked()), false)
277305     else false)
278306     then throw("Contracts are under maintenance")
279307     else {
280308         let addr = toString(i.originCaller)
281309         let week = (height / WEEK_BLOCKS)
282-        let lastWeekTxIdByUser = getString(keyLastWeekTxIdByUser(addr))
310+        let lastWeekKey = keyLastWeekTxIdByUser(addr)
311+        let lastWeekTxIdByUser = getString(lastWeekKey)
283312         let txId = toBase58String(i.transactionId)
284313         let wtx = ((toString(week) + "_") + txId)
314+        let curWeekKey = keyCurWeekTxIdByUser(addr)
285315         if (isDefined(lastWeekTxIdByUser))
286316             then {
287317                 let lastWeekTx = split(value(lastWeekTxIdByUser), "_")
288318                 if ((lastWeekTx[0] == toString(week)))
289-                    then [StringEntry(keyLastWeekTxIdByUser(addr), wtx), StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
319+                    then [StringEntry(lastWeekKey, wtx), StringEntry(curWeekKey, wtx)]
290320                     else if ((lastWeekTx[0] == toString((week - 1))))
291-                        then [StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
321+                        then [StringEntry(curWeekKey, wtx)]
292322                         else {
293-                            let curWeekTxIdByUser = getStringValue(keyLastWeekTxIdByUser(addr))
323+                            let curWeekTxIdByUser = getStringValue(curWeekKey)
294324                             let curWeekTx = split(curWeekTxIdByUser, "_")
295325                             if ((curWeekTx[0] == toString(week)))
296-                                then [StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
297-                                else [StringEntry(keyLastWeekTxIdByUser(addr), curWeekTxIdByUser), StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
326+                                then [StringEntry(curWeekKey, wtx)]
327+                                else [StringEntry(lastWeekKey, curWeekTxIdByUser), StringEntry(curWeekKey, wtx)]
298328                             }
299329                 }
300-            else [StringEntry(keyLastWeekTxIdByUser(addr), wtx), StringEntry(keyCurWeekTxIdByUser(addr), wtx)]
330+            else [StringEntry(lastWeekKey, wtx), StringEntry(curWeekKey, wtx)]
301331         }
332+
333+
334+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) + "\"}")
335+
336+
337+func issueNftCustom (nameIdx,contKeyIdx,collIdx,rarityIdx,bonusPerc,descrIdx,bonusTypeIdx,addr) = {
338+    let nftSerial = valueOrElse(getInteger(keyNftTotalIssued), 0)
339+    let rarity = rarityNames[rarityIdx]
340+    let name = (((namez[nameIdx] + "-") + take(rarity, 1)) + toString(bonusPerc))
341+    let issue = Issue(name, createNftDescrCustom(contentKeyz[contKeyIdx], nftSerial, collectionz[collIdx], names[nameIdx], descriptions[descrIdx], rarityNames[rarityIdx], bonusPerc, bonusTypez[bonusTypeIdx]), 1, 0, false)
342+    let nftAssetId = calculateAssetId(issue)
343+    $Tuple2([issue, IntegerEntry(keyNftTotalIssued, (nftSerial + 1)), IntegerEntry(keyNftNumberByAssetId(toBase58String(nftAssetId)), nftSerial), ScriptTransfer(addr, 1, nftAssetId)], nftAssetId)
344+    }
302345 
303346 
304347 func createNftDescription (nftIndex,nftSerial) = ((((((((((((((((((((("{\"url\": \"https://waveslands.com\", " + "\"contentKey\": \"") + contentKeys[nftIndex]) + "\", ") + "\"number\": ") + nftSerial) + ", ") + "\"collection\": \"Digging tools") + "\", ") + "\"name\": \"") + names[nftIndex]) + "\", ") + "\"description\": \"") + descriptions[nftIndex]) + "\", ") + "\"rare\": \"") + rarities[nftIndex]) + "\", ") + "\"bonus\": ") + toString(bonuses[nftIndex])) + ", ") + "\"bonusType\": \"FarmPower\"}")
305348 
306349 
307350 func issueNFTinternal (nftIndex,addr) = if ((nftIndex >= size(contentKeys)))
308351     then throw("nftIndex out of bounds")
309352     else {
310353         let nftSerial = valueOrElse(getInteger(keyNftTotalIssued), 0)
311354         let issue = Issue(nftNames[nftIndex], createNftDescription(nftIndex, toString(nftSerial)), 1, 0, false)
312355         let nftAssetId = calculateAssetId(issue)
313356         $Tuple2([issue, IntegerEntry(keyNftTotalIssued, (nftSerial + 1)), IntegerEntry(keyNftNumberByAssetId(toBase58String(nftAssetId)), nftSerial), ScriptTransfer(addr, 1, nftAssetId)], nftAssetId)
314357         }
315358 
316359 
317360 func stakeUnstakeAcresInternal (amt,address,bonusDelta) = if (if ((amt == 0))
318361     then (bonusDelta == 0)
319362     else false)
320363     then throw("Nothing to do")
321364     else {
322365         let wlgResult = invoke(wlgContract, "onStakeUnstakeLand", [address], nil)
323366         if ((wlgResult == wlgResult))
324367             then {
325368                 let now = lastBlock.timestamp
326369                 let timeKey = keyAcresStakedTimeByUser(address)
327370                 let amountKey = keyAcresStakedAmtByUser(address)
328371                 let oldAcresAmount = valueOrElse(getInteger(amountKey), 0)
329372                 if (if ((0 > amt))
330373                     then (0 > (oldAcresAmount + amt))
331374                     else false)
332375                     then throw(((("You have only " + fixedPoint(oldAcresAmount, 8)) + " ACRES staked, tried to unstake ") + fixedPoint(-(amt), 8)))
333376                     else {
334377                         let newAcresAmount = (oldAcresAmount + amt)
335378                         let oldTotal = valueOrElse(getInteger(acresStakdTotalKey), 0)
336379                         let userFpKey = keyFarmingPowerByUser(address)
337380                         let oldFp = valueOrElse(getInteger(userFpKey), 0)
338381                         let bonusKey = keyUserFullBonus(address)
339382                         let oldBonus = valueOrElse(getInteger(acres2Contract, bonusKey), 0)
340383                         if (if ((0 > bonusDelta))
341384                             then (0 > (oldBonus + bonusDelta))
342385                             else false)
343386                             then throw((((("You have only " + fixedPoint(oldBonus, 4)) + "% bonus, and tried to unstake ") + fixedPoint(-(bonusDelta), 4)) + "%"))
344387                             else {
345-                                let $t048204919 = getFarmingPowerByAcresAndBonus(newAcresAmount, (oldBonus + bonusDelta))
346-                                let newBonusedFp = $t048204919._1
347-                                let ignored = $t048204919._2
388+                                let $t066976796 = getFarmingPowerByAcresAndBonus(newAcresAmount, (oldBonus + bonusDelta))
389+                                let newBonusedFp = $t066976796._1
390+                                let ignored = $t066976796._2
348391                                 let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
349392                                 let acresActions = if ((amt == 0))
350393                                     then nil
351394                                     else [IntegerEntry(amountKey, newAcresAmount), IntegerEntry(acresStakdTotalKey, (oldTotal + amt))]
352395                                 $Tuple2(((((acresActions :+ IntegerEntry(timeKey, lastBlock.timestamp)) :+ IntegerEntry(userFpKey, newBonusedFp)) :+ IntegerEntry(totalFarmingPowerKey, ((oldTotalFp + newBonusedFp) - oldFp))) :+ IntegerEntry(bonusKey, (oldBonus + bonusDelta))), wlgResult)
353396                                 }
354397                         }
355398                 }
356399             else throw("Strict value is not equal to itself.")
357400         }
358401 
359402 
360403 func getWlgPrice (usdtBalanceCorrection) = {
361404     let issuedAmount = valueOrErrorMessage(getInteger(wlgContract, wlgIssuedAmtKey), "WLGOLD is not issued yet")
362405     let wlgUsd = assetBalance(wlgContract, usdtAssetId)
363406     let acres2Usd = (assetBalance(acres2Contract, usdtAssetId) - usdtBalanceCorrection)
364407     let investFundTotal = (assetBalance(investFundContract, usdtAssetId) + valueOrElse(getInteger(investFundContract, zbIssuedAmtKey), 0))
365408     let totalFundsUsd = ((acres2Usd + wlgUsd) + investFundTotal)
366409     fraction(totalFundsUsd, MULT8, issuedAmount)
367410     }
368411 
369412 
370413 func getSwapLimitAcres () = {
371414     let wlgUsd = assetBalance(wlgContract, usdtAssetId)
372415     let acres2Usd = assetBalance(this, usdtAssetId)
373416     let investFundTotal = (assetBalance(investFundContract, usdtAssetId) + valueOrElse(getInteger(investFundContract, zbIssuedAmtKey), 0))
374417     let defaultLimit = (((acres2Usd + wlgUsd) + investFundTotal) / ONE_PERCENT_DIVISOR)
375418     let lastLimitLeft = valueOrElse(getInteger(keyLastLimitLeft), defaultLimit)
376419     let lastTime = valueOrElse(getInteger(keyLastAcresSellTime), 0)
377420     let now = lastBlock.timestamp
378421     let currentLimit = (lastLimitLeft + fraction(defaultLimit, (now - lastTime), DAY_MILLIS))
379422     let limitLeftUsdt = min([currentLimit, defaultLimit])
380423     $Tuple2(IntegerEntry(keyLastAcresSellTime, now), limitLeftUsdt)
381424     }
382425 
383426 
384427 let arkOracle = addressFromStringValue("3PJgZ6AK1WVCpdCmEZpesHmaKvrQDdXG5og")
385428 
386429 let incubator = valueOrElse(getString(arkOracle, "static_incubatorAddress"), "")
387430 
388431 let breeder = valueOrElse(getString(arkOracle, "static_breederAddress"), "")
389432 
390433 let turtleIncubator = valueOrElse(getString(arkOracle, "static_turtleIncubatorAddress"), "")
391434 
392435 let turtleBreeder = valueOrElse(getString(arkOracle, "static_turtleBreederAddress"), "")
393436 
394437 let canineIncubator = valueOrElse(getString(arkOracle, "static_canineIncubatorAddress"), "")
395438 
396439 let canineBreeder = valueOrElse(getString(arkOracle, "static_canineBreederAddress"), "")
397440 
398441 let felineIncubator = valueOrElse(getString(arkOracle, "static_felineIncubatorAddress"), "")
399442 
400443 let felineBreeder = valueOrElse(getString(arkOracle, "static_felineBreederAddress"), "")
401444 
402445 let mutantBreeder = valueOrElse(getString(arkOracle, "static_mutantIncubatorAddress"), "")
403446 
404447 func isArkimalIssued (nfo) = {
405448     let issuer = toString(nfo.issuer)
406449     if (if (if (if (if (if (if (if (if (if ((chain == base58'2T'))
407450         then (issuer == oldStakingContractStr)
408451         else false)
409452         then true
410453         else (issuer == incubator))
411454         then true
412455         else (issuer == breeder))
413456         then true
414457         else (issuer == turtleIncubator))
415458         then true
416459         else (issuer == turtleBreeder))
417460         then true
418461         else (issuer == canineIncubator))
419462         then true
420463         else (issuer == canineBreeder))
421464         then true
422465         else (issuer == felineIncubator))
423466         then true
424467         else (issuer == felineBreeder))
425468         then nfo.name
426469         else if ((issuer == mutantBreeder))
427470             then nfo.description
428471             else ""
429472     }
430473 
431474 
432475 func bonusByDescription (descr) = if (!(contains(descr, "\"bonusType\": \"FarmPower\"")))
433476     then throw(("NFT is not supported: " + descr))
434477     else {
435478         let bonusStr = split_4C(split_4C(descr, "\"bonus\":")[1], ",")[0]
436479         parseIntValue(drop(bonusStr, (valueOrElse(lastIndexOf(bonusStr, " "), -1) + 1)))
437480         }
438481 
439482 
440483 func stakeNftInternal (addr,assetIdStr,bonus6,userNumKey,totalNumKey,limit) = {
441484     let nftNumber = valueOrElse(getInteger(userNumKey), 0)
442485     if ((nftNumber >= limit))
443486         then throw((("You can stake max " + toString(limit)) + " of such NFTs"))
444487         else {
445-            let $t094469522 = stakeUnstakeAcresInternal(0, addr, bonus6)
446-            let actions = $t094469522._1
447-            let wlgClaimedAmount = $t094469522._2
488+            let $t01132311399 = stakeUnstakeAcresInternal(0, addr, bonus6)
489+            let actions = $t01132311399._1
490+            let wlgClaimedAmount = $t01132311399._2
448491             $Tuple2((((actions :+ IntegerEntry(userNumKey, (nftNumber + 1))) :+ IntegerEntry(totalNumKey, (valueOrElse(getInteger(totalNumKey), 0) + 1))) :+ IntegerEntry(keyStakedTimeByAssetIdAndOwner(assetIdStr, addr), lastBlock.timestamp)), wlgClaimedAmount)
449492             }
450493     }
451494 
452495 
453496 @Callable(i)
454497 func saveLastTx () = if (!(containsElement([wlgContract], i.caller)))
455498     then throw("Access denied")
456499     else $Tuple2(prolog(i), 42)
457500 
458501 
459502 
460503 @Callable(i)
461504 func constructorV1 (rest2Addr,oldAcrContract) = if ((i.caller != this))
462505     then throw("Permission denied")
463506     else {
464507         let oldAcrContAddr = addressFromStringValue(oldAcrContract)
465508 [IntegerEntry(acresIssuedAmountKey, getIntegerValue(oldAcrContAddr, acresIssuedAmountKey)), BinaryEntry(acresAssetIdKey, getBinaryValue(oldAcrContAddr, acresAssetIdKey)), StringEntry(keyRest2Address(), rest2Addr), StringEntry(oldAcresContractKey, oldAcrContract)]
466509         }
467510 
468511 
469512 
470513 @Callable(i)
471514 func setBlocked (isBlocked) = if ((i.caller != this))
472515     then throw("permission denied")
473516     else [BooleanEntry(keyBlocked(), isBlocked)]
474517 
475518 
476519 
477520 @Callable(i)
478521 func unstakeAcres (amount) = {
479522     let prologActions = prolog(i)
480523     if ((0 >= amount))
481524         then throw("Amount should be positive")
482525         else {
483526             let address = toString(i.caller)
484527             if ((size(i.payments) != 0))
485528                 then throw("No payments required")
486529                 else {
487530                     let arbReleaseTime = (valueOrElse(getInteger(wlgContract, keyLastWlgTradeTimeByUser(address)), 0) + arbitrageDelay)
488531                     if ((arbReleaseTime > lastBlock.timestamp))
489532                         then throw(("You traded some WLGOLD, cannot unstake until " + toString(arbReleaseTime)))
490533                         else {
491-                            let $t01109611176 = stakeUnstakeAcresInternal(-(amount), address, 0)
492-                            let actions = $t01109611176._1
493-                            let wlgClaimedAmount = $t01109611176._2
534+                            let $t01297313053 = stakeUnstakeAcresInternal(-(amount), address, 0)
535+                            let actions = $t01297313053._1
536+                            let wlgClaimedAmount = $t01297313053._2
494537                             $Tuple2(((actions :+ ScriptTransfer(i.caller, amount, acresAssetId)) ++ prologActions), wlgClaimedAmount)
495538                             }
496539                     }
497540             }
498541     }
499542 
500543 
501544 
502545 @Callable(i)
503546 func stakeAcres () = {
504547     let prologActions = prolog(i)
505548     let address = toString(i.caller)
506549     if ((size(i.payments) != 1))
507550         then throw("exactly 1 payment must be attached")
508551         else {
509552             let pmt = i.payments[0]
510553             let amt = pmt.amount
511554             if (if (!(isDefined(pmt.assetId)))
512555                 then true
513556                 else (value(pmt.assetId) != acresAssetId))
514557                 then throw("ACRES payments only!")
515558                 else {
516-                    let $t01162711703 = stakeUnstakeAcresInternal(amt, address, 0)
517-                    let actions = $t01162711703._1
518-                    let wlgClaimedAmount = $t01162711703._2
559+                    let $t01350413580 = stakeUnstakeAcresInternal(amt, address, 0)
560+                    let actions = $t01350413580._1
561+                    let wlgClaimedAmount = $t01350413580._2
519562                     $Tuple2((actions ++ prologActions), wlgClaimedAmount)
520563                     }
521564             }
522565     }
523566 
524567 
525568 
526569 @Callable(i)
527570 func buyAcres () = {
528571     let prologActions = prolog(i)
529572     if ((size(i.payments) != 1))
530573         then throw("exactly 1 payment must be attached")
531574         else {
532575             let pmt = i.payments[0]
533576             let usdtAmount = pmt.amount
534577             if (if (!(isDefined(pmt.assetId)))
535578                 then true
536579                 else (value(pmt.assetId) != usdtAssetId))
537580                 then throw("USDT payments only!")
538581                 else if ((MULT6 > usdtAmount))
539582                     then throw((("Min payment should be " + fixedPoint(MULT6, 6)) + " USDT"))
540583                     else {
541584                         let acresAmount = (usdtAmount * USDT2ACRES_MULTIPLIER)
542585                         let wlgAmount = fraction(usdtAmount, MULT8, getWlgPrice(usdtAmount))
543586                         let oldAcresAddress = addressFromStringValue(getStringValue(oldAcresContractKey))
544587                         let req = invoke(oldAcresAddress, "requestAcresCallback", [acresAmount], nil)
545588                         if ((req == req))
546589                             then {
547590                                 let wlgRemain = asInt(invoke(wlgContract, "burnWlgold", [wlgAmount], nil))
548591                                 $Tuple2(([ScriptTransfer(i.caller, acresAmount, acresAssetId)] ++ prologActions), wlgRemain)
549592                                 }
550593                             else throw("Strict value is not equal to itself.")
551594                         }
552595             }
553596     }
554597 
555598 
556599 
557600 @Callable(i)
558601 func buyAcresREADONLY (usdtAmount) = {
559602     let acresAmount = (usdtAmount * USDT2ACRES_MULTIPLIER)
560603     let wlgToBurn = fraction(usdtAmount, MULT8, getWlgPrice(usdtAmount))
561604     $Tuple2(nil, [acresAmount, MULT6, acresAmount, wlgToBurn])
562605     }
563606 
564607 
565608 
566609 @Callable(i)
567610 func sellAcres () = {
568611     let prologActions = prolog(i)
569612     if ((size(i.payments) != 1))
570613         then throw("exactly 1 payment must be attached")
571614         else {
572615             let pmt = i.payments[0]
573616             let acresAmount = pmt.amount
574617             if (if (!(isDefined(pmt.assetId)))
575618                 then true
576619                 else (value(pmt.assetId) != acresAssetId))
577620                 then throw("ACRES payments only!")
578621                 else if ((MULT7 > acresAmount))
579622                     then throw((("Min payment should be " + fixedPoint(MULT7, 8)) + " ACRES"))
580623                     else {
581624                         let addr = toString(i.caller)
582-                        let $t01356013608 = getSwapLimitAcres()
583-                        let limitAction = $t01356013608._1
584-                        let maxUsdt = $t01356013608._2
625+                        let $t01543715485 = getSwapLimitAcres()
626+                        let limitAction = $t01543715485._1
627+                        let maxUsdt = $t01543715485._2
585628                         let maxAcres = (maxUsdt * USDT2ACRES_MULTIPLIER)
586629                         if ((acresAmount > maxAcres))
587630                             then throw((("You can sell max " + fixedPoint(maxAcres, 8)) + " ACRES"))
588631                             else {
589632                                 let usdtAmount = ((acresAmount / USDT2ACRES_MULTIPLIER) / 2)
590633                                 $Tuple2(([limitAction, IntegerEntry(keyLastLimitLeft, (maxUsdt - usdtAmount)), ScriptTransfer(i.caller, usdtAmount, usdtAssetId)] ++ prologActions), usdtAmount)
591634                                 }
592635                         }
593636             }
594637     }
595638 
596639 
597640 
598641 @Callable(i)
599642 func sellAcresREADONLY (address,acresAmount) = {
600-    let $t01410414152 = getSwapLimitAcres()
601-    let limitAction = $t01410414152._1
602-    let maxUsdt = $t01410414152._2
643+    let $t01598116029 = getSwapLimitAcres()
644+    let limitAction = $t01598116029._1
645+    let maxUsdt = $t01598116029._2
603646     let usdtAmount = ((acresAmount / USDT2ACRES_MULTIPLIER) / 2)
604647     $Tuple2(nil, [usdtAmount, MULT7, (maxUsdt * USDT2ACRES_MULTIPLIER), 0])
605648     }
606649 
607650 
608651 
609652 @Callable(i)
610653 func convertOldStakes () = if ((i.caller != this))
611654     then throw("Temporarily disabled")
612655     else {
613656         let address = toString(i.caller)
614657         if ((size(i.payments) != 0))
615658             then throw("No payments required")
616659             else {
617660                 let oldAcresAddress = addressFromStringValue(getStringValue(oldAcresContractKey))
618661                 let amount = valueOrElse(getInteger(oldAcresAddress, keyAcresStakedAmtByUser(address)), 0)
619662                 let gotAcres0 = if ((amount > 0))
620663                     then asTuple2Ints(invoke(oldAcresAddress, "unstakeAcresCallback", [amount, address], nil))
621664                     else $Tuple2(0, 0)
622665                 let oldStakingAddress = addressFromStringValue(oldStakingContractStr)
623666                 let landsStr = getString(oldStakingAddress, keyStakedLandsByOwner(address))
624667                 let landsResult = if (isDefined(landsStr))
625668                     then {
626669                         let lands = split_51C(value(landsStr), "_")
627670                         func oneLand (acc,landAssetId) =                         if ((landAssetId == ""))
628671                             then throw("landAssetId is required")
629672                             else {
630673                                 let r = asTuple5Ints(invoke(oldStakingAddress, "unstakeLandCallback", [landAssetId, address], nil))
631674                                 $Tuple4((acc._1 + r._1), (acc._2 + r._2), (acc._3 + r._3), (acc._4 + r._4))
632675                                 }
633676 
634677                         let rr = {
635678                             let $l = lands
636679                             let $s = size($l)
637680                             let $acc0 = $Tuple4(0, 0, 0, 0)
638681                             func $f0_1 ($a,$i) =                             if (($i >= $s))
639682                                 then $a
640683                                 else oneLand($a, $l[$i])
641684 
642685                             func $f0_2 ($a,$i) =                             if (($i >= $s))
643686                                 then $a
644687                                 else throw("List size exceeds 100")
645688 
646689                             $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)
647690                             }
648691                         let finalize = invoke(oldStakingAddress, "unstakeLandsFinalizeCallback", [address], nil)
649692                         if ((finalize == finalize))
650693                             then {
651694                                 let req = invoke(oldAcresAddress, "requestAcresCallback", [(((rr._1 + rr._2) + rr._3) + rr._4)], nil)
652695                                 if ((req == req))
653696                                     then {
654-                                        let $t01602116101 = issueNFTinternal(IdxDtx3PercConversion, i.caller)
655-                                        let nftActions = $t01602116101._1
656-                                        let nftAssetId = $t01602116101._2
697+                                        let $t01789818036 = issueNftCustom(idxNameShovel, idxKeyP, idxCollDig, idxRarityP, 3, idxDescrShovel, idxBonusTypeFp, i.caller)
698+                                        let nftActions = $t01789818036._1
699+                                        let nftAssetId = $t01789818036._2
657700                                         $Tuple5(rr._1, rr._2, rr._3, rr._4, nftActions)
658701                                         }
659702                                     else throw("Strict value is not equal to itself.")
660703                                 }
661704                             else throw("Strict value is not equal to itself.")
662705                         }
663706                     else $Tuple5(0, 0, 0, 0, nil)
664707                 let duckAssetId = valueOrElse(getString(oldStakingAddress, keyStakedDuckByOwner(address)), "")
665708                 let duckResult = if ((duckAssetId != ""))
666709                     then asTuple3Ints(invoke(oldStakingAddress, "unstakeDuckCallback", [duckAssetId, address], nil))
667710                     else $Tuple3(0, 0, 0)
668711                 let x = stakeUnstakeAcresInternal((((((((gotAcres0._1 + landsResult._1) + landsResult._2) + landsResult._3) + landsResult._4) + duckResult._1) + duckResult._2) + duckResult._3), address, 0)
669712                 $Tuple2((landsResult._5 ++ x._1), x._2)
670713                 }
671714         }
672715 
673716 
674717 
675718 @Callable(i)
676719 func unstakeLandsREADONLY (address) = {
677720     let oldStakingAddress = addressFromStringValue(oldStakingContractStr)
678721     let landsStr = getString(oldStakingAddress, keyStakedLandsByOwner(address))
679722     let landsResult = if (isDefined(landsStr))
680723         then {
681724             let lands = split_51C(value(landsStr), "_")
682725             func oneLand (acc,landAssetId) =             if ((landAssetId == ""))
683726                 then throw("landAssetId is required")
684727                 else {
685728                     let r = asTuple4Ints(invoke(oldStakingAddress, "unstakeLandREADONLY", [landAssetId, address], nil))
686729                     $Tuple4((acc._1 + r._1), (acc._2 + r._2), (acc._3 + r._3), (acc._4 + r._4))
687730                     }
688731 
689732             let $l = lands
690733             let $s = size($l)
691734             let $acc0 = $Tuple4(0, 0, 0, 0)
692735             func $f0_1 ($a,$i) =             if (($i >= $s))
693736                 then $a
694737                 else oneLand($a, $l[$i])
695738 
696739             func $f0_2 ($a,$i) =             if (($i >= $s))
697740                 then $a
698741                 else throw("List size exceeds 100")
699742 
700743             $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)
701744             }
702745         else $Tuple4(0, 0, 0, 0)
703746     $Tuple2(nil, landsResult)
704747     }
705748 
706749 
707750 
708751 @Callable(i)
709752 func stakeAcresCallback (addr) = if ((i.caller != addressFromStringValue(oldStakingContractStr)))
710753     then throw("Permission denied")
711754     else stakeUnstakeAcresInternal(i.payments[0].amount, addr, 0)
712755 
713756 
714757 
715758 @Callable(i)
716759 func simulateStakeAcresREADONLY (address,addedAmount) = {
717760     let amountKey = keyAcresStakedAmtByUser(address)
718761     let newAcresAmount = (valueOrElse(getInteger(amountKey), 0) + addedAmount)
719762     let oldTotal = valueOrElse(getInteger(acresStakdTotalKey), 0)
720763     let userFpKey = keyFarmingPowerByUser(address)
721764     let oldFp = valueOrElse(getInteger(userFpKey), 0)
722765     let userBonus = valueOrElse(getInteger(acres2Contract, keyUserFullBonus(address)), 0)
723-    let $t01826618353 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
724-    let newBonusedFp = $t01826618353._1
725-    let ignored = $t01826618353._2
766+    let $t02020120288 = getFarmingPowerByAcresAndBonus(newAcresAmount, userBonus)
767+    let newBonusedFp = $t02020120288._1
768+    let ignored = $t02020120288._2
726769     let oldTotalFp = valueOrElse(getInteger(totalFarmingPowerKey), 0)
727770     let newTotalFp = ((oldTotalFp + newBonusedFp) - oldFp)
728771     $Tuple2(nil, [oldFp, newBonusedFp, oldTotalFp, newTotalFp])
729772     }
730773 
731774 
732775 
733776 @Callable(i)
734-func issueNFT (forAddress,nftIndex) = if ((i.caller != wlgContract))
777+func issuePickC1 (forAddress) = if ((i.caller != wlgContract))
735778     then throw("Permission denied")
736-    else issueNFTinternal(nftIndex, addressFromStringValue(forAddress))
737-
738-
739-
740-@Callable(i)
741-func issueNftAdmin (forAddress,nftIndex,serial) = if ((i.caller != this))
742-    then throw("Permission denied")
743-    else if ((nftIndex >= size(contentKeys)))
744-        then throw("nftIndex out of bounds")
745-        else {
746-            let issue = Issue(nftNames[nftIndex], createNftDescription(nftIndex, toString(serial)), 1, 0, false)
747-            let nftAssetId = calculateAssetId(issue)
748-            $Tuple2([issue, IntegerEntry(keyNftNumberByAssetId(toBase58String(nftAssetId)), serial), ScriptTransfer(addressFromStringValue(forAddress), 1, nftAssetId)], nftAssetId)
749-            }
779+    else issueNftCustom(idxNamePickaxe, idxKeyC, idxCollDig, idxRarityC, 1, idxDescrPickaxe, idxBonusTypeFp, addressFromStringValue(forAddress))
750780 
751781 
752782 
753783 @Callable(i)
754784 func stakeNFT () = {
755785     let prologActions = prolog(i)
756786     if ((size(i.payments) != 1))
757787         then throw("Exactly one payment required")
758788         else {
759789             let pmt = value(i.payments[0])
760790             if ((pmt.amount != 1))
761791                 then throw("NFT token should be attached as payment")
762792                 else {
763793                     let assetId = value(pmt.assetId)
764794                     let asset = value(assetInfo(assetId))
765795                     let assetIdStr = toBase58String(assetId)
766796                     let addr = toString(i.caller)
767797                     let nftsKey = keyStakedNFTsByOwner(addr)
768798                     let nftsStr = getString(nftsKey)
769799                     let nfts = if (isDefined(nftsStr))
770800                         then split_4C(value(nftsStr), "_")
771801                         else nil
772802                     if (containsElement(nfts, assetIdStr))
773803                         then throw(("Your staked NFTs already contain " + assetIdStr))
774804                         else if ((size(nfts) >= MAX_NFTS_STAKED_BY_USER))
775805                             then throw((("Your already staked max (" + toString(MAX_NFTS_STAKED_BY_USER)) + ") NFTs"))
776806                             else {
777807                                 let listAction = StringEntry(nftsKey, makeString_2C((nfts :+ assetIdStr), "_"))
778808                                 if ((asset.issuer == this))
779809                                     then {
780-                                        let $t02032220512 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
781-                                        let actions = $t02032220512._1
782-                                        let wlgClaimedAmount = $t02032220512._2
810+                                        let $t02169721887 = stakeNftInternal(addr, assetIdStr, (bonusByDescription(value(asset.description)) * 10000), keyUserWlNftNumber(addr), keyWlNftTotalStaked, MAX_WL_NFTS)
811+                                        let actions = $t02169721887._1
812+                                        let wlgClaimedAmount = $t02169721887._2
783813                                         $Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
784814                                         }
785815                                     else if ((isArkimalIssued(asset) == ""))
786816                                         then throw("Only WavesLands and Arkimals NFT tokens are accepted")
787817                                         else {
788-                                            let $t02069320844 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
789-                                            let actions = $t02069320844._1
790-                                            let wlgClaimedAmount = $t02069320844._2
818+                                            let $t02206822219 = stakeNftInternal(addr, assetIdStr, ARK_NFT_BONUS, keyUserArkNftNumber(addr), keyArkNftTotalStaked, MAX_ARK_NFTS)
819+                                            let actions = $t02206822219._1
820+                                            let wlgClaimedAmount = $t02206822219._2
791821                                             $Tuple2(((prologActions ++ actions) :+ listAction), wlgClaimedAmount)
792822                                             }
793823                                 }
794824                     }
795825             }
796826     }
797827 
798828 
799829 
800830 @Callable(i)
801831 func unstakeNFT (assetIdStr) = {
802832     let prologActions = prolog(i)
803833     if ((size(i.payments) != 0))
804834         then throw("No payments required")
805835         else {
806836             let assetId = fromBase58String(assetIdStr)
807837             let addr = toString(i.caller)
808838             let asset = value(assetInfo(assetId))
809839             let timeKey = keyStakedTimeByAssetIdAndOwner(assetIdStr, addr)
810840             if (!(isDefined(getInteger(timeKey))))
811841                 then throw((("NFT " + asset.name) + " is not staked by you"))
812842                 else {
813843                     let nftsKey = keyStakedNFTsByOwner(addr)
814844                     let nfts = split_4C(valueOrElse(getString(nftsKey), ""), "_")
815845                     let idx = indexOf(nfts, assetIdStr)
816846                     if (!(isDefined(idx)))
817847                         then throw(("Your staked NFTs don't contain " + assetIdStr))
818848                         else {
819849                             let listAction = if ((size(nfts) > 1))
820850                                 then StringEntry(nftsKey, makeString_2C(removeByIndex(nfts, value(idx)), "_"))
821851                                 else DeleteEntry(nftsKey)
822852                             let isWL = (asset.issuer == this)
823853                             if (isWL)
824854                                 then {
825855                                     let wlNftNumber = valueOrElse(getInteger(keyUserWlNftNumber(addr)), 0)
826856                                     let bonusVal = (bonusByDescription(value(asset.description)) * 10000)
827-                                    let $t02200922088 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
828-                                    let actions = $t02200922088._1
829-                                    let wlgClaimedAmount = $t02200922088._2
857+                                    let $t02338423463 = stakeUnstakeAcresInternal(0, addr, -(bonusVal))
858+                                    let actions = $t02338423463._1
859+                                    let wlgClaimedAmount = $t02338423463._2
830860                                     $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)
831861                                     }
832862                                 else {
833863                                     let arkimalName = isArkimalIssued(asset)
834864                                     if ((arkimalName == ""))
835865                                         then throw("Only WavesLands and Arkimals NFT tokens are accepted")
836866                                         else {
837867                                             let arkNftNumber = valueOrElse(getInteger(keyUserArkNftNumber(addr)), 0)
838-                                            let $t02274822832 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
839-                                            let actions = $t02274822832._1
840-                                            let wlgClaimedAmount = $t02274822832._2
868+                                            let $t02412324207 = stakeUnstakeAcresInternal(0, addr, -(ARK_NFT_BONUS))
869+                                            let actions = $t02412324207._1
870+                                            let wlgClaimedAmount = $t02412324207._2
841871                                             $Tuple2((((((actions :+ listAction) :+ IntegerEntry(keyUserArkNftNumber(addr), (arkNftNumber - 1))) :+ DeleteEntry(keyStakedTimeByAssetIdAndOwner(toBase58String(assetId), addr))) :+ ScriptTransfer(i.caller, 1, assetId)) ++ prologActions), wlgClaimedAmount)
842872                                             }
843873                                     }
844874                             }
845875                     }
846876             }
847877     }
848878 
849879 
850880 
851881 @Callable(i)
852882 func exchangeNFTs () = if ((i.caller != this))
853883     then throw("Temporarily disabled")
854884     else {
855885         let prologActions = prolog(i)
856886         if ((3 > size(i.payments)))
857887             then throw("Min one USDT and 2 NFT payments allowed")
858888             else if ((size(i.payments) > 6))
859889                 then throw("Max one USDT and 5 NFT payments allowed")
860890                 else {
861891                     let addr = toString(i.caller)
862892                     func addUp (acc,pmt) =                     {
863893                         let assetId = valueOrErrorMessage(pmt.assetId, "WAVES payments not allowed")
864894                         if ((assetId == usdtAssetId))
865895                             then $Tuple3((acc._1 + pmt.amount), acc._2, acc._3)
866896                             else {
867897                                 let asset = value(assetInfo(assetId))
868898                                 if ((asset.issuer != this))
869899                                     then throw("Only WL-issued NFTs allowed")
870900                                     else {
871901                                         let bonusPerc = bonusByDescription(value(asset.description))
872902                                         $Tuple3(acc._1, (acc._2 + bonusPerc), (acc._3 :+ Burn(assetId, 1)))
873903                                         }
874904                                 }
875905                         }
876906 
877-                    let $t02404424123 = {
907+                    let $t02543625515 = {
878908                         let $l = i.payments
879909                         let $s = size($l)
880910                         let $acc0 = $Tuple3(0, 0, nil)
881911                         func $f0_1 ($a,$i) =                         if (($i >= $s))
882912                             then $a
883913                             else addUp($a, $l[$i])
884914 
885915                         func $f0_2 ($a,$i) =                         if (($i >= $s))
886916                             then $a
887917                             else throw("List size exceeds 6")
888918 
889919                         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
890920                         }
891-                    let usdtFee = $t02404424123._1
892-                    let totalBonus = $t02404424123._2
893-                    let burnActions = $t02404424123._3
921+                    let usdtFee = $t02543625515._1
922+                    let totalBonus = $t02543625515._2
923+                    let burnActions = $t02543625515._3
894924                     let nftIndex = if ((totalBonus == 3))
895925                         then 2
896926                         else if ((totalBonus == 5))
897927                             then 3
898928                             else if ((totalBonus == 10))
899929                                 then 4
900930                                 else throw("Only bonuses of 3%, 5% or 10% are supported")
901931                     let change = (usdtFee - (totalBonus * MULT6))
902932                     if ((0 > change))
903933                         then throw((("You need to attach " + toString(totalBonus)) + " USDT as fee"))
904934                         else {
905935                             let changeActions = if ((change > 0))
906936                                 then [ScriptTransfer(i.caller, change, usdtAssetId)]
907937                                 else nil
908-                            let $t02458024652 = issueNFTinternal(nftIndex, i.caller)
909-                            let issueNftActions = $t02458024652._1
910-                            let nftAssetId = $t02458024652._2
938+                            let $t02597226044 = issueNFTinternal(nftIndex, i.caller)
939+                            let issueNftActions = $t02597226044._1
940+                            let nftAssetId = $t02597226044._2
911941                             let burned = size(burnActions)
912942                             let burnCounterActions = if ((burned == 0))
913943                                 then nil
914944                                 else [IntegerEntry(keyNftTotalBurned, (valueOrElse(getInteger(keyNftTotalBurned), 0) + burned))]
915945                             $Tuple2(((((issueNftActions ++ burnActions) ++ burnCounterActions) ++ prologActions) ++ changeActions), nftAssetId)
916946                             }
917947                     }
918948         }
919949 
920950 
921951 
922952 @Callable(i)
923953 func openNftChest () = if ((i.caller != this))
924954     then throw("Permission denied")
925955     else $Tuple2(nil, 0)
926956 
927957 
github/deemru/w8io/026f985 
125.21 ms ◑