tx · D29kBp3N4g14JqRFvanaL1j4Q5p1Dcy3VdjVk1cMkr6W

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.06700000 Waves

2023.06.21 14:30 [2632347] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "D29kBp3N4g14JqRFvanaL1j4Q5p1Dcy3VdjVk1cMkr6W",
    "fee": 6700000,
    "feeAssetId": null,
    "timestamp": 1687347060762,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "iVeFxM3dvPb8xhVDCRWSfXH27wdASKUzuQ3fAmxumiADrsYS6ivXtzs9u77wfnmdVwQ6geubJSoGU3yVTTAs7PD"
    ],
    "script": "base64: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",
    "height": 2632347,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Yn7jTiNBWNi5G94z6SCngKNKXUP3d8VDT8A3VAf1UXs
Next: 5BeNQiorLDbL2pTybbEdae74L8EtwFmKQ6QpnJMvrM4A

Diff: 
Old
New
Differences
1521
1521
 
                                                    then throw(("Your staked lands already contain " + aW))
1522
1522
 
                                                    else {
1523
1523
 
                                                        let eC = valueOrElse(getInteger(aP(aW)), 0)
1524
-
[IntegerEntry(gd, lastBlock.timestamp), IntegerEntry(aS(k, aW, ap), lastBlock.timestamp), StringEntry(gX, makeString_11C((bU :+ aW), "_")), IntegerEntry(aY(ap), (valueOrElse(getInteger(aY(ap)), 0) + fS)), StringEntry(aL(aW), ap), StringEntry(cC(cx), ap), IntegerEntry(cB(m, aW, ap), fT), IntegerEntry(cA(aW, ap), eC), StringEntry(bj(), bG), hm]
1524
+
                                                        let hb = aY(ap)
1525
+
                                                        let hp = valueOrElse(getInteger(hb), 0)
1526
+
                                                        let hq = if ((hp == 0))
1527
+
                                                            then bv(invoke(aI, "onStakeLand", [ap], nil))
1528
+
                                                            else -1
1529
+
                                                        $Tuple2([IntegerEntry(gd, lastBlock.timestamp), IntegerEntry(aS(k, aW, ap), lastBlock.timestamp), StringEntry(gX, makeString_11C((bU :+ aW), "_")), IntegerEntry(hb, (hp + fS)), StringEntry(aL(aW), ap), StringEntry(cC(cx), ap), IntegerEntry(cB(m, aW, ap), fT), IntegerEntry(cA(aW, ap), eC), StringEntry(bj(), bG), hm], hq)
1525
1530
 
                                                        }
1526
1531
 
                                                }
1527
1532
 
                                        }
1552
1557
 
                then throw(("Your staked lands don't contain " + aW))
1553
1558
 
                else {
1554
1559
 
                    let eh = value(blockInfoByHeight(height)).timestamp
1555
-
                    let hp = valueOrElse(getInteger(aH, bl(aK)), 0)
1556
-
                    if ((hp >= eh))
1557
-
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hp)))
1560
+
                    let hr = valueOrElse(getInteger(aH, bl(aK)), 0)
1561
+
                    if ((hr >= eh))
1562
+
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hr)))
1558
1563
 
                        else {
1559
1564
 
                            let hb = aY(aK)
1560
1565
 
                            let hc = valueOrElse(getInteger(hb), 0)
1561
-
[ScriptTransfer(dB.caller, 1, fromBase58String(aW)), DeleteEntry(aO(aW)), DeleteEntry(aS(k, aW, aK)), StringEntry(bj(), bG), StringEntry(gB._2, makeString(gB._3, ":")), if ((size(bU) > 1))
1566
+
                            let hs = if ((fS > hc))
1567
+
                                then 0
1568
+
                                else (hc - fS)
1569
+
                            let hq = if ((hs == 0))
1570
+
                                then bv(invoke(aI, "onUnstakeLand", [aK], nil))
1571
+
                                else -1
1572
+
                            $Tuple2([ScriptTransfer(dB.caller, 1, fromBase58String(aW)), DeleteEntry(aO(aW)), DeleteEntry(aS(k, aW, aK)), StringEntry(bj(), bG), StringEntry(gB._2, makeString(gB._3, ":")), if ((size(bU) > 1))
1562
1573
 
                                then StringEntry(gX, makeString_11C(removeByIndex(bU, value(aD)), "_"))
1563
-
                                else DeleteEntry(gX), IntegerEntry(hb, if ((fS > hc))
1564
-
                                then 0
1565
-
                                else (hc - fS)), hm]
1574
+
                                else DeleteEntry(gX), IntegerEntry(hb, hs), hm], hq)
1566
1575
 
                            }
1567
1576
 
                    }
1568
1577
 
            }
1590
1599
 
                        else if (!(contains(bW.name, l)))
1591
1600
 
                            then throw((("Only NFT " + l) + " tokens are accepted"))
1592
1601
 
                            else {
1593
-
                                let hq = toBase58String(aM)
1594
-
                                let gd = aO(hq)
1602
+
                                let ht = toBase58String(aM)
1603
+
                                let gd = aO(ht)
1595
1604
 
                                if (isDefined(getInteger(gd)))
1596
1605
 
                                    then throw((("NFT " + bW.name) + " is already staked"))
1597
1606
 
                                    else if (isDefined(getString(be(ap))))
1598
1607
 
                                        then throw(("You already staked one duck: " + bW.name))
1599
1608
 
                                        else {
1600
-
                                            let hr = bh(hq)
1601
-
                                            let hs = getString(hr)
1602
-
                                            let ej = bf(hq)
1603
-
                                            let ht = getString(ej)
1604
-
                                            ([IntegerEntry(gd, lastBlock.timestamp), IntegerEntry(aS(l, toBase58String(aM), ap), lastBlock.timestamp), StringEntry(bd(hq), ap), StringEntry(be(ap), hq)] ++ (if (isDefined(hs))
1609
+
                                            let hu = bh(ht)
1610
+
                                            let hv = getString(hu)
1611
+
                                            let ej = bf(ht)
1612
+
                                            let hw = getString(ej)
1613
+
                                            ([IntegerEntry(gd, lastBlock.timestamp), IntegerEntry(aS(l, toBase58String(aM), ap), lastBlock.timestamp), StringEntry(bd(ht), ap), StringEntry(be(ap), ht)] ++ (if (isDefined(hv))
1605
1614
 
                                                then nil
1606
-
                                                else ([StringEntry(hr, w)] ++ (if (isDefined(ht))
1615
+
                                                else ([StringEntry(hu, w)] ++ (if (isDefined(hw))
1607
1616
 
                                                    then nil
1608
-
                                                    else (([StringEntry(ej, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(bi(hq), 100)) :+ hm)))))
1617
+
                                                    else (([StringEntry(ej, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(bi(ht), 100)) :+ hm)))))
1609
1618
 
                                            }
1610
1619
 
                                }
1611
1620
 
                    }
1615
1624
 
1616
1625
 
1617
1626
 
@Callable(dB)
1618
-
func unstakeDuck (hq) = {
1627
+
func unstakeDuck (ht) = {
1619
1628
 
    let hm = hj(dB)
1620
1629
 
    if ((size(dB.payments) != 0))
1621
1630
 
        then throw("No payments required")
1622
1631
 
        else {
1623
-
            let aM = fromBase58String(hq)
1632
+
            let aM = fromBase58String(ht)
1624
1633
 
            let ap = toString(dB.caller)
1625
1634
 
            let bW = value(assetInfo(aM))
1626
1635
 
            let gd = aO(toBase58String(aM))
1633
1642
 
                        if ((gf != ap))
1634
1643
 
                            then throw("Staked NFT is not yours")
1635
1644
 
                            else {
1636
-
                                let fI = bi(hq)
1637
-
                                let hu = valueOrElse(getInteger(fI), 100)
1638
-
                                if ((100 > hu))
1645
+
                                let fI = bi(ht)
1646
+
                                let hx = valueOrElse(getInteger(fI), 100)
1647
+
                                if ((100 > hx))
1639
1648
 
                                    then throw("Please heal your duck before unstaking")
1640
-
                                    else [ScriptTransfer(dB.caller, 1, aM), DeleteEntry(gd), DeleteEntry(fI), DeleteEntry(bh(hq)), DeleteEntry(bd(hq)), DeleteEntry(aS(l, hq, ap)), DeleteEntry(be(ap)), hm]
1649
+
                                    else [ScriptTransfer(dB.caller, 1, aM), DeleteEntry(gd), DeleteEntry(fI), DeleteEntry(bh(ht)), DeleteEntry(bd(ht)), DeleteEntry(aS(l, ht, ap)), DeleteEntry(be(ap)), hm]
1641
1650
 
                                }
1642
1651
 
                        }
1643
1652
 
            }
1646
1655
 
1647
1656
 
1648
1657
 
@Callable(dB)
1649
-
func claimRes (eP,hv) = {
1658
+
func claimRes (eP,hy) = {
1650
1659
 
    let hm = hj(dB)
1651
1660
 
    if ((size(dB.payments) != 0))
1652
1661
 
        then throw("No payments required")
1653
1662
 
        else {
1654
1663
 
            let aK = toString(dB.originCaller)
1655
-
            let dh = gh(aK, eP, cH, hv)
1664
+
            let dh = gh(aK, eP, cH, hy)
1656
1665
 
            $Tuple2((((dh._1 :+ StringEntry(dh._2, makeString(dh._3, ":"))) :+ StringEntry(dh._4, makeString(dh._5, ":"))) :+ hm), dh._3[aj])
1657
1666
 
            }
1658
1667
 
    }
1660
1669
 
1661
1670
 
1662
1671
 
@Callable(dB)
1663
-
func claimResToWH (eP,hv) = {
1672
+
func claimResToWH (eP,hy) = {
1664
1673
 
    let hm = hj(dB)
1665
1674
 
    if ((size(dB.payments) != 0))
1666
1675
 
        then throw("No payments required")
1667
1676
 
        else {
1668
1677
 
            let aK = toString(dB.originCaller)
1669
-
            let dh = gh(aK, eP, cG, hv)
1678
+
            let dh = gh(aK, eP, cG, hy)
1670
1679
 
            $Tuple2((((dh._1 :+ StringEntry(dh._2, makeString(dh._3, ":"))) :+ StringEntry(dh._4, makeString(dh._5, ":"))) :+ hm), dh._5[aa])
1671
1680
 
            }
1672
1681
 
    }
1681
1690
 
        else {
1682
1691
 
            let bm = toString(dB.caller)
1683
1692
 
            let ef = fw(bm, fx, fy)
1684
-
            let hr = bh(ef._2)
1685
-
            let ga = valueOrElse(getString(hr), w)
1693
+
            let hu = bh(ef._2)
1694
+
            let ga = valueOrElse(getString(hu), w)
1686
1695
 
            if ((ef._4 == ga))
1687
1696
 
                then throw("You can't fly to the same location")
1688
1697
 
                else {
1689
1698
 
                    let ej = bf(ef._2)
1690
1699
 
                    let eS = ei(ej)
1691
1700
 
                    let du = di(eS[al], ef._5)
1692
-
                    $Tuple2([StringEntry(hr, if ((ef._1 > 0))
1701
+
                    $Tuple2([StringEntry(hu, if ((ef._1 > 0))
1693
1702
 
                        then ef._4
1694
1703
 
                        else ga), StringEntry(ej, makeString([eS[ai], eS[aj], eS[ak], du], ":")), IntegerEntry(bi(ef._2), ef._1), hm], ef._3)
1695
1704
 
                    }
1699
1708
 
1700
1709
 
1701
1710
 
@Callable(dB)
1702
-
func heal (hw,hx,hy) = {
1711
+
func heal (hz,hA,hB) = {
1703
1712
 
    let hm = hj(dB)
1704
-
    if (if (if ((0 > hw))
1713
+
    if (if (if ((0 > hz))
1705
1714
 
        then true
1706
-
        else (0 > hx))
1715
+
        else (0 > hA))
1707
1716
 
        then true
1708
-
        else (0 > hy))
1717
+
        else (0 > hB))
1709
1718
 
        then throw("Quantity cannot be negative")
1710
1719
 
        else {
1711
1720
 
            let bg = valueOrErrorMessage(getString(be(toString(dB.caller))), "You don't have a duck staked")
1712
-
            let hz = [hw, hx, hy]
1721
+
            let hC = [hz, hA, hB]
1713
1722
 
            let fI = bi(bg)
1714
-
            let hA = valueOrElse(getInteger(fI), 100)
1715
-
            if ((hA >= B))
1723
+
            let hD = valueOrElse(getInteger(fI), 100)
1724
+
            if ((hD >= B))
1716
1725
 
                then throw((("HP should be < " + toString(B)) + " to heal"))
1717
1726
 
                else {
1718
1727
 
                    let ej = bf(bg)
1719
1728
 
                    let eS = ei(ej)
1720
-
                    let hB = if ((eS[al] == ""))
1729
+
                    let hE = if ((eS[al] == ""))
1721
1730
 
                        then nil
1722
1731
 
                        else split(eS[al], "_")
1723
-
                    func hC (bI,hD) =                     {
1732
+
                    func hF (bI,hG) =                     {
1724
1733
 
                        let bw = bI._2
1725
-
                        let dW = if ((size(hB) > bw))
1726
-
                            then parseIntValue(hB[bw])
1734
+
                        let dW = if ((size(hE) > bw))
1735
+
                            then parseIntValue(hE[bw])
1727
1736
 
                            else 0
1728
1737
 
                        if ((3 > bw))
1729
1738
 
                            then {
1730
-
                                let hE = hz[bw]
1731
-
                                if ((hE > dW))
1739
+
                                let hH = hC[bw]
1740
+
                                if ((hH > dW))
1732
1741
 
                                    then throw(((("You have only " + toString(dW)) + " of ") + E[bw]))
1733
-
                                    else $Tuple3((bI._1 :+ toString((dW - hE))), (bw + 1), (bI._3 + (ch[bw] * hE)))
1742
+
                                    else $Tuple3((bI._1 :+ toString((dW - hH))), (bw + 1), (bI._3 + (ch[bw] * hH)))
1734
1743
 
                                }
1735
1744
 
                            else $Tuple3((bI._1 :+ toString(dW)), (bw + 1), bI._3)
1736
1745
 
                        }
1741
1750
 
                        let bN = $Tuple3(nil, 0, 0)
1742
1751
 
                        func bO (bP,bQ) =                         if ((bQ >= bM))
1743
1752
 
                            then bP
1744
-
                            else hC(bP, bL[bQ])
1753
+
                            else hF(bP, bL[bQ])
1745
1754
 
1746
1755
 
                        func bR (bP,bQ) =                         if ((bQ >= bM))
1747
1756
 
                            then bP
1749
1758
 
1750
1759
 
                        bR(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bN, 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)
1751
1760
 
                        }
1752
-
                    let hF = min([B, (hA + dh._3)])
1753
-
                    $Tuple2([IntegerEntry(fI, hF), StringEntry(ej, makeString_2C([eS[ai], eS[aj], eS[ak], makeString(dh._1, "_")], ":")), hm], hF)
1761
+
                    let hI = min([B, (hD + dh._3)])
1762
+
                    $Tuple2([IntegerEntry(fI, hI), StringEntry(ej, makeString_2C([eS[ai], eS[aj], eS[ak], makeString(dh._1, "_")], ":")), hm], hI)
1754
1763
 
                    }
1755
1764
 
            }
1756
1765
 
    }
1769
1778
 
                else {
1770
1779
 
                    let bg = valueOrErrorMessage(getString(be(toString(dB.caller))), "You don't have a duck staked")
1771
1780
 
                    let fI = bi(bg)
1772
-
                    let hA = valueOrElse(getInteger(fI), 100)
1773
-
                    if ((hA > 0))
1781
+
                    let hD = valueOrElse(getInteger(fI), 100)
1782
+
                    if ((hD > 0))
1774
1783
 
                        then throw("HP should be 0 to call Emergency Service")
1775
1784
 
                        else {
1776
1785
 
                            let ej = bf(bg)
1777
1786
 
                            let eS = ei(ej)
1778
-
                            let hB = if ((eS[al] == ""))
1787
+
                            let hE = if ((eS[al] == ""))
1779
1788
 
                                then nil
1780
1789
 
                                else split(eS[al], "_")
1781
-
                            let hG = if ((size(hB) > 0))
1782
-
                                then parseIntValue(hB[0])
1790
+
                            let hJ = if ((size(hE) > 0))
1791
+
                                then parseIntValue(hE[0])
1783
1792
 
                                else 0
1784
-
                            let hH = if ((size(hB) > 1))
1785
-
                                then parseIntValue(hB[1])
1793
+
                            let hK = if ((size(hE) > 1))
1794
+
                                then parseIntValue(hE[1])
1786
1795
 
                                else 0
1787
-
                            let hI = if ((size(hB) > 2))
1788
-
                                then parseIntValue(hB[2])
1796
+
                            let hL = if ((size(hE) > 2))
1797
+
                                then parseIntValue(hE[2])
1789
1798
 
                                else 0
1790
-
                            if (if (if ((hG > 0))
1799
+
                            if (if (if ((hJ > 0))
1791
1800
 
                                then true
1792
-
                                else (hH > 0))
1801
+
                                else (hK > 0))
1793
1802
 
                                then true
1794
-
                                else (hI > 0))
1803
+
                                else (hL > 0))
1795
1804
 
                                then throw("You have to use own Medical Kit")
1796
1805
 
                                else {
1797
-
                                    let hJ = getString(aG, bo())
1798
-
                                    let hK = if (isDefined(hJ))
1799
-
                                        then split(value(hJ), "_")
1806
+
                                    let hM = getString(aG, bo())
1807
+
                                    let hN = if (isDefined(hM))
1808
+
                                        then split(value(hM), "_")
1800
1809
 
                                        else nil
1801
-
                                    let hL = if ((size(hK) > 0))
1802
-
                                        then parseIntValue(hK[0])
1810
+
                                    let hO = if ((size(hN) > 0))
1811
+
                                        then parseIntValue(hN[0])
1803
1812
 
                                        else 0
1804
-
                                    if ((0 >= hL))
1813
+
                                    if ((0 >= hO))
1805
1814
 
                                        then throw("There are no Medical Kits L1 at Emergency Service storage")
1806
1815
 
                                        else {
1807
-
                                            let hF = (hA + ch[0])
1808
-
                                            let hM = makeString([toString((hL - 1)), removeByIndex(hK, 0)], "_")
1816
+
                                            let hI = (hD + ch[0])
1817
+
                                            let hP = makeString([toString((hO - 1)), removeByIndex(hN, 0)], "_")
1809
1818
 
                                            let ca = split(G[0], "_")
1810
-
                                            let hN = bZ(ca)
1811
-
                                            let hO = parseIntValue(ca[T])
1812
-
                                            let hP = fraction((hN * A), x, (10 * hO))
1813
-
                                            if ((hn.amount != hP))
1814
-
                                                then throw(("Payment attached should be " + toString(hP)))
1819
+
                                            let hQ = bZ(ca)
1820
+
                                            let hR = parseIntValue(ca[T])
1821
+
                                            let hS = fraction((hQ * A), x, (10 * hR))
1822
+
                                            if ((hn.amount != hS))
1823
+
                                                then throw(("Payment attached should be " + toString(hS)))
1815
1824
 
                                                else {
1816
-
                                                    let dh = bs(invoke(aG, "updateEsStorage", [hM], [AttachedPayment(b, hP)]))
1817
-
                                                    $Tuple2([IntegerEntry(fI, hF), hm], dh)
1825
+
                                                    let dh = bs(invoke(aG, "updateEsStorage", [hP], [AttachedPayment(b, hS)]))
1826
+
                                                    $Tuple2([IntegerEntry(fI, hI), hm], dh)
1818
1827
 
                                                    }
1819
1828
 
                                            }
1820
1829
 
                                    }
1826
1835
 
1827
1836
 
1828
1837
 
@Callable(dB)
1829
-
func updateBackpack (bg,hQ) = {
1838
+
func updateBackpack (bg,hT) = {
1830
1839
 
    let hm = hj(dB)
1831
1840
 
    if ((dB.caller != aG))
1832
1841
 
        then throw("permission denied")
1833
-
        else $Tuple2([StringEntry(bf(bg), hQ), hm], hQ)
1842
+
        else $Tuple2([StringEntry(bf(bg), hT), hm], hT)
1834
1843
 
    }
1835
1844
 
1836
1845
 
1902
1911
 
1903
1912
 
1904
1913
 
@Callable(dB)
1905
-
func activateArtifact (hR,aW) = {
1914
+
func activateArtifact (hU,aW) = {
1906
1915
 
    let hm = hj(dB)
1907
1916
 
    if ((size(dB.payments) != 0))
1908
1917
 
        then throw("No payments required")
1909
1918
 
        else {
1910
1919
 
            let dh = {
1911
-
                let c = hR
1920
+
                let c = hU
1912
1921
 
                if (("PRESALE" == c))
1913
1922
 
                    then gI(toString(dB.caller), aW)
1914
1923
 
                    else throw("Unknown artifact")
1951
1960
 
1952
1961
 
1953
1962
 
@Callable(dB)
1954
-
func cargoExchange (hS,aW) = {
1963
+
func cargoExchange (hV,aW) = {
1955
1964
 
    let hm = hj(dB)
1956
1965
 
    if ((size(dB.payments) != 0))
1957
1966
 
        then throw("No payments required")
1958
1967
 
        else {
1959
-
            let eR = split_4C(hS, ":")
1968
+
            let eR = split_4C(hV, ":")
1960
1969
 
            let aK = toString(dB.originCaller)
1961
1970
 
            let bW = value(assetInfo(fromBase58String(aW)))
1962
1971
 
            let gd = aO(aW)
2005
2014
 
            if ((size(eF) != 5))
2006
2015
 
                then throw("warehouse string should contain 4 ':' separators")
2007
2016
 
                else {
2008
-
                    let hT = split(eF[ad], "_")[ae]
2017
+
                    let hW = split(eF[ad], "_")[ae]
2009
2018
 
                    let gs = en(eF)
2010
-
                    let hU = el(eF[Z])
2011
-
                    let gt = ((hU - parseIntValue(hT)) - gs)
2012
-
                    let hV = makeString_2C([eF[Z], eF[aa], eF[ab], eF[ac], makeString([hT, toString(gs), toString(gt), toString(hU)], "_")], ":")
2013
-
                    $Tuple2([StringEntry(eA, hV), hm], hV)
2019
+
                    let hX = el(eF[Z])
2020
+
                    let gt = ((hX - parseIntValue(hW)) - gs)
2021
+
                    let hY = makeString_2C([eF[Z], eF[aa], eF[ab], eF[ac], makeString([hW, toString(gs), toString(gt), toString(hX)], "_")], ":")
2022
+
                    $Tuple2([StringEntry(eA, hY), hm], hY)
2014
2023
 
                    }
2015
2024
 
            }
2016
2025
 
    }
2026
2035
 
        let eB = (bA(split(bW.description, "_")[W]) / o)
2027
2036
 
        let eC = valueOrElse(getInteger(aP(aW)), 0)
2028
2037
 
        let eF = ez(eA, eB, eC)
2029
-
        let hT = bv(invoke(aG, "recalcLockedVolumeREADONLY", [aW, eF], nil))
2038
+
        let hW = bv(invoke(aG, "recalcLockedVolumeREADONLY", [aW, eF], nil))
2030
2039
 
        let gs = en(eF)
2031
-
        let hU = el(eF[Z])
2032
-
        let gt = ((hU - hT) - gs)
2033
-
        let hV = makeString_2C([eF[Z], eF[aa], eF[ab], eF[ac], makeString([toString(hT), toString(gs), toString(gt), toString(hU)], "_")], ":")
2034
-
        $Tuple2([StringEntry(eA, hV)], hV)
2040
+
        let hX = el(eF[Z])
2041
+
        let gt = ((hX - hW) - gs)
2042
+
        let hY = makeString_2C([eF[Z], eF[aa], eF[ab], eF[ac], makeString([toString(hW), toString(gs), toString(gt), toString(hX)], "_")], ":")
2043
+
        $Tuple2([StringEntry(eA, hY)], hY)
2035
2044
 
        }
2036
2045
 
2037
2046
 
2088
2097
 
                            then throw(("Name too long, maxLength=" + toString(ck)))
2089
2098
 
                            else {
2090
2099
 
                                let aK = toString(dB.originCaller)
2091
-
                                let hW = {
2100
+
                                let hZ = {
2092
2101
 
                                    let c = aR
2093
2102
 
                                    if (("ACCOUNT" == c))
2094
2103
 
                                        then {
2095
-
                                            let hX = cE(gV)
2096
-
                                            let hY = getString(hX)
2097
-
                                            if (isDefined(hY))
2104
+
                                            let ia = cE(gV)
2105
+
                                            let ib = getString(ia)
2106
+
                                            if (isDefined(ib))
2098
2107
 
                                                then throw(("Name already registered: " + gV))
2099
2108
 
                                                else {
2100
-
                                                    let hZ = ba(aK)
2101
-
                                                    let ia = getString(hZ)
2102
-
                                                    let ib = if (isDefined(ia))
2103
-
                                                        then [DeleteEntry(cE(value(ia)))]
2109
+
                                                    let ic = ba(aK)
2110
+
                                                    let id = getString(ic)
2111
+
                                                    let ie = if (isDefined(id))
2112
+
                                                        then [DeleteEntry(cE(value(id)))]
2104
2113
 
                                                        else nil
2105
-
                                                    ((ib :+ StringEntry(hZ, gV)) :+ StringEntry(hX, aK))
2114
+
                                                    ((ie :+ StringEntry(ic, gV)) :+ StringEntry(ia, aK))
2106
2115
 
                                                    }
2107
2116
 
                                            }
2108
2117
 
                                        else if (("LAND" == c))
2116
2125
 
                                                        if ((gf != aK))
2117
2126
 
                                                            then throw((k + " is not yours"))
2118
2127
 
                                                            else {
2119
-
                                                                let hX = cy(gV)
2120
-
                                                                let hY = getString(hX)
2121
-
                                                                if (isDefined(hY))
2128
+
                                                                let ia = cy(gV)
2129
+
                                                                let ib = getString(ia)
2130
+
                                                                if (isDefined(ib))
2122
2131
 
                                                                    then throw(("Name already registered: " + gV))
2123
2132
 
                                                                    else {
2124
-
                                                                        let ic = aN(aM)
2125
-
                                                                        let ia = getString(ic)
2126
-
                                                                        let ib = if (isDefined(ia))
2127
-
                                                                            then [DeleteEntry(cy(value(ia)))]
2133
+
                                                                        let if = aN(aM)
2134
+
                                                                        let id = getString(if)
2135
+
                                                                        let ie = if (isDefined(id))
2136
+
                                                                            then [DeleteEntry(cy(value(id)))]
2128
2137
 
                                                                            else nil
2129
-
                                                                        ((ib :+ StringEntry(ic, gV)) :+ StringEntry(hX, aM))
2138
+
                                                                        ((ie :+ StringEntry(if, gV)) :+ StringEntry(ia, aM))
2130
2139
 
                                                                        }
2131
2140
 
                                                                }
2132
2141
 
                                                        }
2144
2153
 
                                                            if ((gf != aK))
2145
2154
 
                                                                then throw((l + " is not yours"))
2146
2155
 
                                                                else {
2147
-
                                                                    let hX = cD(gV)
2148
-
                                                                    let hY = getString(hX)
2149
-
                                                                    if (isDefined(hY))
2156
+
                                                                    let ia = cD(gV)
2157
+
                                                                    let ib = getString(ia)
2158
+
                                                                    if (isDefined(ib))
2150
2159
 
                                                                        then throw(("Name already registered: " + gV))
2151
2160
 
                                                                        else {
2152
-
                                                                            let ic = aZ(aM)
2153
-
                                                                            let ia = getString(ic)
2154
-
                                                                            let ib = if (isDefined(ia))
2155
-
                                                                                then [DeleteEntry(cD(value(ia)))]
2161
+
                                                                            let if = aZ(aM)
2162
+
                                                                            let id = getString(if)
2163
+
                                                                            let ie = if (isDefined(id))
2164
+
                                                                                then [DeleteEntry(cD(value(id)))]
2156
2165
 
                                                                                else nil
2157
-
                                                                            ((ib :+ StringEntry(ic, gV)) :+ StringEntry(hX, aM))
2166
+
                                                                            ((ie :+ StringEntry(if, gV)) :+ StringEntry(ia, aM))
2158
2167
 
                                                                            }
2159
2168
 
                                                                    }
2160
2169
 
                                                            }
2161
2170
 
                                                    }
2162
2171
 
                                                else throw("Unknown entity type")
2163
2172
 
                                    }
2164
-
                                $Tuple2(((hW :+ ScriptTransfer(aG, hn.amount, b)) :+ hm), 0)
2173
+
                                $Tuple2(((hZ :+ ScriptTransfer(aG, hn.amount, b)) :+ hm), 0)
2165
2174
 
                                }
2166
2175
 
            }
2167
2176
 
    }
2169
2178
 
2170
2179
 
2171
2180
 
@Callable(dB)
2172
-
func setReferrals (id,ie) = if ((dB.callerPublicKey != cg))
2181
+
func setReferrals (ig,ih) = if ((dB.callerPublicKey != cg))
2173
2182
 
    then throw("Permission denied")
2174
2183
 
    else {
2175
2184
 
        let hm = hj(dB)
2176
2185
 
        if ((size(dB.payments) != 0))
2177
2186
 
            then throw("No payments required")
2178
-
            else if (!(isDefined(addressFromString(id))))
2179
-
                then throw(("Invalid address: " + id))
2180
-
                else if (!(isDefined(addressFromString(ie))))
2181
-
                    then throw(("Invalid address: " + ie))
2187
+
            else if (!(isDefined(addressFromString(ig))))
2188
+
                then throw(("Invalid address: " + ig))
2189
+
                else if (!(isDefined(addressFromString(ih))))
2190
+
                    then throw(("Invalid address: " + ih))
2182
2191
 
                    else {
2183
-
                        let if = cF()
2184
-
                        let ig = getString(if)
2185
-
                        let ih = if (isDefined(ig))
2186
-
                            then split_4C(value(ig), "_")
2192
+
                        let ii = cF()
2193
+
                        let ij = getString(ii)
2194
+
                        let ik = if (isDefined(ij))
2195
+
                            then split_4C(value(ij), "_")
2187
2196
 
                            else nil
2188
-
                        if (containsElement(ih, ie))
2189
-
                            then throw((ie + " is not newbie (already has referrals)"))
2197
+
                        if (containsElement(ik, ih))
2198
+
                            then throw((ih + " is not newbie (already has referrals)"))
2190
2199
 
                            else {
2191
-
                                let ii = bb(ie)
2192
-
                                let ij = getString(ii)
2193
-
                                if (if (isDefined(ij))
2194
-
                                    then isDefined(addressFromString(value(ij)))
2200
+
                                let il = bb(ih)
2201
+
                                let im = getString(il)
2202
+
                                if (if (isDefined(im))
2203
+
                                    then isDefined(addressFromString(value(im)))
2195
2204
 
                                    else false)
2196
-
                                    then throw(((ie + " already has refBy: ") + value(ij)))
2205
+
                                    then throw(((ih + " already has refBy: ") + value(im)))
2197
2206
 
                                    else {
2198
-
                                        let ik = bc(id)
2199
-
                                        let il = getString(ik)
2200
-
                                        let im = if (isDefined(il))
2201
-
                                            then split_4C(value(il), "_")
2207
+
                                        let in = bc(ig)
2208
+
                                        let io = getString(in)
2209
+
                                        let ip = if (isDefined(io))
2210
+
                                            then split_4C(value(io), "_")
2202
2211
 
                                            else nil
2203
-
                                        if (containsElement(im, ie))
2204
-
                                            then throw((((id + " already contains ") + ie) + " within referrals"))
2212
+
                                        if (containsElement(ip, ih))
2213
+
                                            then throw((((ig + " already contains ") + ih) + " within referrals"))
2205
2214
 
                                            else {
2206
-
                                                let in = makeString_2C((im :+ ie), "_")
2207
-
                                                let io = if (containsElement(ih, id))
2208
-
                                                    then value(ig)
2209
-
                                                    else makeString_2C((ih :+ id), "_")
2210
-
                                                $Tuple2([StringEntry(ii, id), StringEntry(ik, in), StringEntry(if, io), hm], 0)
2215
+
                                                let iq = makeString_2C((ip :+ ih), "_")
2216
+
                                                let ir = if (containsElement(ik, ig))
2217
+
                                                    then value(ij)
2218
+
                                                    else makeString_2C((ik :+ ig), "_")
2219
+
                                                $Tuple2([StringEntry(il, ig), StringEntry(in, iq), StringEntry(ii, ir), hm], 0)
2211
2220
 
                                                }
2212
2221
 
                                        }
2213
2222
 
                                }
2222
2231
 
2223
2232
 
2224
2233
 
@Callable(dB)
2225
-
func splitByGlobalAndLocalWeightsREADONLY (ip,iq,dE) = {
2234
+
func splitByGlobalAndLocalWeightsREADONLY (is,it,dE) = {
2226
2235
 
    let dx = dD(dE)
2227
-
    $Tuple2(nil, $Tuple2(cZ(ip), cS(iq, dx)))
2236
+
    $Tuple2(nil, $Tuple2(cZ(is), cS(it, dx)))
2228
2237
 
    }
2229
2238
 
2230
2239
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let a = take(drop(this.bytes, 1), 1)
5
5
 
6
6
 
let b = {
7
7
 
    let c = a
8
8
 
    if ((base58'2W' == c))
9
9
 
        then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
10
10
 
        else if ((base58'2T' == c))
11
11
 
            then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
12
12
 
            else throw("Unknown chain")
13
13
 
    }
14
14
 
15
15
 
let d = {
16
16
 
    let c = a
17
17
 
    if ((base58'2W' == c))
18
18
 
        then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
19
19
 
        else if ((base58'2T' == c))
20
20
 
            then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
21
21
 
            else throw("Unknown chain")
22
22
 
    }
23
23
 
24
24
 
let e = {
25
25
 
    let c = a
26
26
 
    if ((base58'2W' == c))
27
27
 
        then 10000000000
28
28
 
        else if ((base58'2T' == c))
29
29
 
            then 100000000
30
30
 
            else throw("Unknown chain")
31
31
 
    }
32
32
 
33
33
 
let f = "__"
34
34
 
35
35
 
let g = 1000000
36
36
 
37
37
 
let h = 10000000
38
38
 
39
39
 
let i = 100000000
40
40
 
41
41
 
let j = 10000000000
42
42
 
43
43
 
let k = "LAND"
44
44
 
45
45
 
let l = "DUCK"
46
46
 
47
47
 
let m = "PRESALE"
48
48
 
49
49
 
let n = 6
50
50
 
51
51
 
let o = 25
52
52
 
53
53
 
let p = 100
54
54
 
55
55
 
let q = 225
56
56
 
57
57
 
let r = 400
58
58
 
59
59
 
let s = 625
60
60
 
61
61
 
let t = 3456000
62
62
 
63
63
 
let u = 86400000
64
64
 
65
65
 
let v = 10000000000
66
66
 
67
67
 
let w = "Africa_F_Africa"
68
68
 
69
69
 
let x = 39637
70
70
 
71
71
 
let y = 3
72
72
 
73
73
 
let z = 4
74
74
 
75
75
 
let A = 10
76
76
 
77
77
 
let B = 100
78
78
 
79
79
 
let C = ["Oil", "Ore", "Wood", "Sand", "Clay", "Organic"]
80
80
 
81
81
 
let D = ["Fuel", "Metal", "Plank", "Glass", "Plastic", "Protein"]
82
82
 
83
83
 
let E = ["First Aid Kit L1", "First Aid Kit L2", "First Aid Kit L3", "Backpack L1", "Backpack L2", "Backpack L3", "Food Ration L1", "Food Ration L2", "Food Ration L3", "Jet Pack L1", "Jet Pack L2", "Jet Pack L3", "Shield L1", "Shield L2", "Shield L3"]
84
84
 
85
85
 
let F = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
86
86
 
87
87
 
let G = ["1_1_1_2_2_5_1_10_0", "2_2_2_4_4_10_1_10_0", "3_3_3_6_6_15_1_10_0", "2_5_5_2_7_5_2_100_1", "4_10_10_4_14_10_2_100_1", "6_15_15_6_21_15_2_100_1", "1_1_1_1_1_8_1_10_2", "2_2_2_2_2_16_1_10_2", "3_3_3_3_3_24_1_10_2", "9_9_1_5_5_1_5_100_3", "18_18_2_10_10_2_5_100_3", "27_27_3_15_15_3_5_100_3", "2_2_1_2_2_2_1_10_4", "4_4_2_4_4_4_1_10_4", "6_6_3_6_6_6_1_10_4"]
88
88
 
89
89
 
let H = 0
90
90
 
91
91
 
let I = 1
92
92
 
93
93
 
let J = 2
94
94
 
95
95
 
let K = 3
96
96
 
97
97
 
let L = 4
98
98
 
99
99
 
let M = 0
100
100
 
101
101
 
let N = 1
102
102
 
103
103
 
let O = 2
104
104
 
105
105
 
let P = 3
106
106
 
107
107
 
let Q = 4
108
108
 
109
109
 
let R = 5
110
110
 
111
111
 
let S = 6
112
112
 
113
113
 
let T = 7
114
114
 
115
115
 
let U = 8
116
116
 
117
117
 
let V = 0
118
118
 
119
119
 
let W = 1
120
120
 
121
121
 
let X = 2
122
122
 
123
123
 
let Y = 3
124
124
 
125
125
 
let Z = 0
126
126
 
127
127
 
let aa = 1
128
128
 
129
129
 
let ab = 2
130
130
 
131
131
 
let ac = 3
132
132
 
133
133
 
let ad = 4
134
134
 
135
135
 
let ae = 0
136
136
 
137
137
 
let af = 1
138
138
 
139
139
 
let ag = 2
140
140
 
141
141
 
let ah = 3
142
142
 
143
143
 
let ai = 0
144
144
 
145
145
 
let aj = 1
146
146
 
147
147
 
let ak = 2
148
148
 
149
149
 
let al = 3
150
150
 
151
151
 
func am (an) = parseIntValue(split(G[an], "_")[T])
152
152
 
153
153
 
154
154
 
func ao (ap,aq) = valueOrErrorMessage(getString(ap, aq), makeString(["mandatory ", toString(ap), ".", aq, " is not defined"], ""))
155
155
 
156
156
 
157
157
 
func ar (aq,as) = valueOrElse(getInteger(this, aq), as)
158
158
 
159
159
 
160
160
 
let at = 1
161
161
 
162
162
 
let au = 2
163
163
 
164
164
 
let av = 3
165
165
 
166
166
 
let aw = 4
167
167
 
168
168
 
func ax () = "%s__restConfig"
169
169
 
170
170
 
171
171
 
func ay () = "%s__restAddr"
172
172
 
173
173
 
174
174
 
func az (aA) = split_4C(ao(aA, ax()), f)
175
175
 
176
176
 
177
177
 
func aB (aC,aD) = valueOrErrorMessage(addressFromString(aC[aD]), ("Rest cfg doesn't contain address at index " + toString(aD)))
178
178
 
179
179
 
180
180
 
let aE = addressFromStringValue(valueOrElse(getString(this, ay()), d))
181
181
 
182
182
 
let aC = az(aE)
183
183
 
184
184
 
let aF = aB(aC, at)
185
185
 
186
186
 
let aG = aB(aC, au)
187
187
 
188
188
 
let aH = aB(aC, av)
189
189
 
190
190
 
let aI = aB(aC, aw)
191
191
 
192
192
 
func aJ (aK) = ("lastTxIdByUser_" + aK)
193
193
 
194
194
 
195
195
 
func aL (aM) = ("nftOwner_" + aM)
196
196
 
197
197
 
198
198
 
func aN (aM) = ("landCustomNameByAssetId_" + aM)
199
199
 
200
200
 
201
201
 
func aO (aM) = ("stakedTime_" + aM)
202
202
 
203
203
 
204
204
 
func aP (aM) = ("infraLevel_" + aM)
205
205
 
206
206
 
207
207
 
func aQ (aR,aM) = makeString(["landArtStatus", aR, aM], "_")
208
208
 
209
209
 
210
210
 
func aS (aT,aM,aU) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aT) + "_") + aM) + "_") + aU)
211
211
 
212
212
 
213
213
 
func aV (aW) = ("wareHouse_" + aW)
214
214
 
215
215
 
216
216
 
func aX (aU) = ("stakedLandsByOwner_" + aU)
217
217
 
218
218
 
219
219
 
func aY (aU) = ("stakedPiecesByOwner_" + aU)
220
220
 
221
221
 
222
222
 
func aZ (aM) = ("duckCustomNameByAssetId_" + aM)
223
223
 
224
224
 
225
225
 
func ba (aK) = ("accountCustomNameByAddr_" + aK)
226
226
 
227
227
 
228
228
 
func bb (aK) = ("accRefBy_" + aK)
229
229
 
230
230
 
231
231
 
func bc (aK) = ("accReferrals_" + aK)
232
232
 
233
233
 
234
234
 
func bd (aM) = ("duckOwner_" + aM)
235
235
 
236
236
 
237
237
 
func be (aU) = ("stakedDuckByOwner_" + aU)
238
238
 
239
239
 
240
240
 
func bf (bg) = ("backPack_" + bg)
241
241
 
242
242
 
243
243
 
func bh (bg) = ("duckLocation_" + bg)
244
244
 
245
245
 
246
246
 
func bi (bg) = ("duckHealth_" + bg)
247
247
 
248
248
 
249
249
 
func bj () = "resTypesProportions"
250
250
 
251
251
 
252
252
 
func bk () = "contractsBlocked"
253
253
 
254
254
 
255
255
 
func bl (bm) = ("%s%s__userGwlReleaseTime__" + bm)
256
256
 
257
257
 
258
258
 
func bn (aW) = ("landOrder_" + aW)
259
259
 
260
260
 
261
261
 
func bo () = "emergencyWarehouseProducts"
262
262
 
263
263
 
264
264
 
let bp = 0
265
265
 
266
266
 
let bq = 1
267
267
 
268
268
 
let br = 2
269
269
 
270
270
 
func bs (bt) = {
271
271
 
    let c = bt
272
272
 
    if ($isInstanceOf(c, "String"))
273
273
 
        then {
274
274
 
            let bu = c
275
275
 
            bu
276
276
 
            }
277
277
 
        else throw("fail to cast into String")
278
278
 
    }
279
279
 
280
280
 
281
281
 
func bv (bt) = {
282
282
 
    let c = bt
283
283
 
    if ($isInstanceOf(c, "Int"))
284
284
 
        then {
285
285
 
            let bw = c
286
286
 
            bw
287
287
 
            }
288
288
 
        else throw("fail to cast into Int")
289
289
 
    }
290
290
 
291
291
 
292
292
 
func bx (bt) = {
293
293
 
    let c = bt
294
294
 
    if ($isInstanceOf(c, "List[Any]"))
295
295
 
        then {
296
296
 
            let by = c
297
297
 
            by
298
298
 
            }
299
299
 
        else throw("fail to cast into List[Any]")
300
300
 
    }
301
301
 
302
302
 
303
303
 
func bz (bt) = {
304
304
 
    let c = bt
305
305
 
    if ($isInstanceOf(c, "Boolean"))
306
306
 
        then {
307
307
 
            let bu = c
308
308
 
            bu
309
309
 
            }
310
310
 
        else throw("fail to cast into Boolean")
311
311
 
    }
312
312
 
313
313
 
314
314
 
func bA (bB) = {
315
315
 
    let c = bB
316
316
 
    if (("S" == c))
317
317
 
        then o
318
318
 
        else if (("M" == c))
319
319
 
            then p
320
320
 
            else if (("L" == c))
321
321
 
                then q
322
322
 
                else if (("XL" == c))
323
323
 
                    then r
324
324
 
                    else if (("XXL" == c))
325
325
 
                        then s
326
326
 
                        else throw("Unknown land size")
327
327
 
    }
328
328
 
329
329
 
330
330
 
let bC = 0
331
331
 
332
332
 
let bD = 1
333
333
 
334
334
 
func bE (bF) = {
335
335
 
    let bG = split(valueOrElse(getString(aF, bj()), "0_0_0_0_0_0"), "_")
336
336
 
    func bH (bI,bJ) =     (bI + parseIntValue(bJ))
337
337
 
338
338
 
    let bK = {
339
339
 
        let bL = bG
340
340
 
        let bM = size(bL)
341
341
 
        let bN = 0
342
342
 
        func bO (bP,bQ) =         if ((bQ >= bM))
343
343
 
            then bP
344
344
 
            else bH(bP, bL[bQ])
345
345
 
346
346
 
        func bR (bP,bQ) =         if ((bQ >= bM))
347
347
 
            then bP
348
348
 
            else throw("List size exceeds 6")
349
349
 
350
350
 
        bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
351
351
 
        }
352
352
 
    let bS = if ((bF == ""))
353
353
 
        then 0
354
354
 
        else {
355
355
 
            let bT = getString(aF, aX(bF))
356
356
 
            let bU = if (isDefined(bT))
357
357
 
                then split_51C(value(bT), "_")
358
358
 
                else nil
359
359
 
            func bV (bI,aW) =             {
360
360
 
                let bW = value(assetInfo(fromBase58String(aW)))
361
361
 
                let bB = split(bW.description, "_")[W]
362
362
 
                (bI + bA(bB))
363
363
 
                }
364
364
 
365
365
 
            let bL = bU
366
366
 
            let bM = size(bL)
367
367
 
            let bN = 0
368
368
 
            func bX (bP,bQ) =             if ((bQ >= bM))
369
369
 
                then bP
370
370
 
                else bV(bP, bL[bQ])
371
371
 
372
372
 
            func bY (bP,bQ) =             if ((bQ >= bM))
373
373
 
                then bP
374
374
 
                else throw("List size exceeds 100")
375
375
 
376
376
 
            bY(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bX(bN, 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)
377
377
 
            }
378
378
 
[bK, bS]
379
379
 
    }
380
380
 
381
381
 
382
382
 
func bZ (ca) = {
383
383
 
    func cb (cc,cd) =     (cc + parseIntValue(ca[cd]))
384
384
 
385
385
 
    let bL = [0, 1, 2, 3, 4, 5]
386
386
 
    let bM = size(bL)
387
387
 
    let bN = 0
388
388
 
    func bO (bP,bQ) =     if ((bQ >= bM))
389
389
 
        then bP
390
390
 
        else cb(bP, bL[bQ])
391
391
 
392
392
 
    func bR (bP,bQ) =     if ((bQ >= bM))
393
393
 
        then bP
394
394
 
        else throw("List size exceeds 6")
395
395
 
396
396
 
    bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
397
397
 
    }
398
398
 
399
399
 
400
400
 
let ce = {
401
401
 
    let c = a
402
402
 
    if ((base58'2W' == c))
403
403
 
        then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
404
404
 
        else if ((base58'2T' == c))
405
405
 
            then this
406
406
 
            else throw("Unknown chain")
407
407
 
    }
408
408
 
409
409
 
let cf = {
410
410
 
    let c = a
411
411
 
    if ((base58'2W' == c))
412
412
 
        then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
413
413
 
        else if ((base58'2T' == c))
414
414
 
            then this
415
415
 
            else throw("Unknown chain")
416
416
 
    }
417
417
 
418
418
 
let cg = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
419
419
 
420
420
 
let ch = [30, 60, 120]
421
421
 
422
422
 
let ci = 300000
423
423
 
424
424
 
let cj = 5000000
425
425
 
426
426
 
let ck = 50
427
427
 
428
428
 
let cl = 10000000
429
429
 
430
430
 
let cm = {
431
431
 
    let c = a
432
432
 
    if ((base58'2W' == c))
433
433
 
        then 252289527462
434
434
 
        else if ((base58'2T' == c))
435
435
 
            then 2522895274
436
436
 
            else throw("Unknown chain")
437
437
 
    }
438
438
 
439
439
 
let cn = {
440
440
 
    let c = a
441
441
 
    if ((base58'2W' == c))
442
442
 
        then 250000000
443
443
 
        else if ((base58'2T' == c))
444
444
 
            then 250000000
445
445
 
            else throw("Unknown chain")
446
446
 
    }
447
447
 
448
448
 
let co = toBigInt(5)
449
449
 
450
450
 
let cp = toBigInt(20)
451
451
 
452
452
 
let cq = toBigInt((20 * 20))
453
453
 
454
454
 
let cr = toBigInt(((20 * 20) * 20))
455
455
 
456
456
 
let cs = toBigInt((((20 * 20) * 20) * 20))
457
457
 
458
458
 
let ct = toBigInt(((((20 * 20) * 20) * 20) * 20))
459
459
 
460
460
 
let cu = 500
461
461
 
462
462
 
func cv () = "nextLandNum"
463
463
 
464
464
 
465
465
 
func cw (cx) = ("landToAsset_" + cx)
466
466
 
467
467
 
468
468
 
func cy (cz) = ("landByCustomName_" + cz)
469
469
 
470
470
 
471
471
 
func cA (aM,aU) = ((("infraLevelByAssetIdAndOwner_" + aM) + "_") + aU)
472
472
 
473
473
 
474
474
 
func cB (aR,aM,aU) = makeString(["landArtStatusByTypeAssetIdAndOwner", aR, aM, aU], "_")
475
475
 
476
476
 
477
477
 
func cC (cx) = ("landOwner_" + cx)
478
478
 
479
479
 
480
480
 
func cD (cz) = ("duckByCustomName_" + cz)
481
481
 
482
482
 
483
483
 
func cE (cz) = ("accountByCustomName_" + cz)
484
484
 
485
485
 
486
486
 
func cF () = "oldiesList"
487
487
 
488
488
 
489
489
 
let cG = 0
490
490
 
491
491
 
let cH = 1
492
492
 
493
493
 
let cI = 2
494
494
 
495
495
 
let cJ = 0
496
496
 
497
497
 
let cK = 1
498
498
 
499
499
 
let cL = 2
500
500
 
501
501
 
let cM = 3
502
502
 
503
503
 
let cN = 4
504
504
 
505
505
 
let cO = 5
506
506
 
507
507
 
let cP = 6
508
508
 
509
509
 
let cQ = 7
510
510
 
511
511
 
func cR (cx,bB) = ((k + cx) + bB)
512
512
 
513
513
 
514
514
 
func cS (cT,cU) = {
515
515
 
    let cV = (((((cU[0] + cU[1]) + cU[2]) + cU[3]) + cU[4]) + cU[5])
516
516
 
    if ((0 >= cV))
517
517
 
        then throw("Zero weights sum")
518
518
 
        else {
519
519
 
            let cW = fraction(cT, g, cV)
520
520
 
            func cX (bI,cY) =             (bI :+ fraction(cY, cW, g))
521
521
 
522
522
 
            let bL = cU
523
523
 
            let bM = size(bL)
524
524
 
            let bN = nil
525
525
 
            func bO (bP,bQ) =             if ((bQ >= bM))
526
526
 
                then bP
527
527
 
                else cX(bP, bL[bQ])
528
528
 
529
529
 
            func bR (bP,bQ) =             if ((bQ >= bM))
530
530
 
                then bP
531
531
 
                else throw("List size exceeds 6")
532
532
 
533
533
 
            bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
534
534
 
            }
535
535
 
    }
536
536
 
537
537
 
538
538
 
func cZ (cT) = {
539
539
 
    let bG = split(value(getString(bj())), "_")
540
540
 
    if ((size(bG) != n))
541
541
 
        then throw("Wrong proportions data")
542
542
 
        else {
543
543
 
            let da = [parseIntValue(bG[0]), parseIntValue(bG[1]), parseIntValue(bG[2]), parseIntValue(bG[3]), parseIntValue(bG[4]), parseIntValue(bG[5])]
544
544
 
            cS(cT, da)
545
545
 
            }
546
546
 
    }
547
547
 
548
548
 
549
549
 
func db (dc,dd,de) = {
550
550
 
    let df = cZ(de)
551
551
 
    func dg (bI,aD) =     {
552
552
 
        let dh = (parseIntValue(dd[aD]) - df[aD])
553
553
 
        if ((0 > dh))
554
554
 
            then throw(((((("Not enough material idx=" + toString(aD)) + ", you have ") + dd[aD]) + ", but need ") + toString(df[aD])))
555
555
 
            else (bI :+ toString(dh))
556
556
 
        }
557
557
 
558
558
 
    if (dc)
559
559
 
        then {
560
560
 
            let bL = [0, 1, 2, 3, 4, 5]
561
561
 
            let bM = size(bL)
562
562
 
            let bN = nil
563
563
 
            func bO (bP,bQ) =             if ((bQ >= bM))
564
564
 
                then bP
565
565
 
                else dg(bP, bL[bQ])
566
566
 
567
567
 
            func bR (bP,bQ) =             if ((bQ >= bM))
568
568
 
                then bP
569
569
 
                else throw("List size exceeds 6")
570
570
 
571
571
 
            bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
572
572
 
            }
573
573
 
        else dd
574
574
 
    }
575
575
 
576
576
 
577
577
 
func di (dj,dk) = if ((dk == ""))
578
578
 
    then dj
579
579
 
    else {
580
580
 
        let dl = if ((dj == ""))
581
581
 
            then nil
582
582
 
            else split(dj, "_")
583
583
 
        func dm (bI,bJ) =         {
584
584
 
            let cd = bI._1
585
585
 
            func dn (cc,do) =             {
586
586
 
                let dp = split(do, ",")
587
587
 
                if ((size(dp) != 2))
588
588
 
                    then throw("Incorrect format, should be index,amount")
589
589
 
                    else {
590
590
 
                        let aD = parseIntValue(dp[0])
591
591
 
                        if (if ((0 > aD))
592
592
 
                            then true
593
593
 
                            else (aD >= size(G)))
594
594
 
                            then throw("Unknown product idx")
595
595
 
                            else if ((aD != cd))
596
596
 
                                then cc
597
597
 
                                else {
598
598
 
                                    let dq = parseIntValue(dp[1])
599
599
 
                                    if ((0 >= dq))
600
600
 
                                        then throw("Pass only positive amounts")
601
601
 
                                        else (cc + dq)
602
602
 
                                    }
603
603
 
                        }
604
604
 
                }
605
605
 
606
606
 
            let dr = {
607
607
 
                let bL = split(dk, "_")
608
608
 
                let bM = size(bL)
609
609
 
                let bN = 0
610
610
 
                func bO (bP,bQ) =                 if ((bQ >= bM))
611
611
 
                    then bP
612
612
 
                    else dn(bP, bL[bQ])
613
613
 
614
614
 
                func bR (bP,bQ) =                 if ((bQ >= bM))
615
615
 
                    then bP
616
616
 
                    else throw("List size exceeds 10")
617
617
 
618
618
 
                bR(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
619
619
 
                }
620
620
 
            let ds = if ((size(dl) > cd))
621
621
 
                then parseIntValue(dl[cd])
622
622
 
                else 0
623
623
 
            let dt = if ((dr > ds))
624
624
 
                then throw(((((("You have " + toString(ds)) + " of ") + E[cd]) + ", but tried to use ") + toString(dr)))
625
625
 
                else (ds - dr)
626
626
 
            $Tuple2((cd + 1), (bI._2 :+ toString(dt)))
627
627
 
            }
628
628
 
629
629
 
        let du = {
630
630
 
            let bL = G
631
631
 
            let bM = size(bL)
632
632
 
            let bN = $Tuple2(0, nil)
633
633
 
            func bO (bP,bQ) =             if ((bQ >= bM))
634
634
 
                then bP
635
635
 
                else dm(bP, bL[bQ])
636
636
 
637
637
 
            func bR (bP,bQ) =             if ((bQ >= bM))
638
638
 
                then bP
639
639
 
                else throw("List size exceeds 50")
640
640
 
641
641
 
            bR(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bN, 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)
642
642
 
            }
643
643
 
        makeString(du._2, "_")
644
644
 
        }
645
645
 
646
646
 
647
647
 
func dv (dw,dx,dy,dz) = if ((size(dw) != n))
648
648
 
    then throw("Wrong proportions data")
649
649
 
    else {
650
650
 
        func dA (bI,dB) =         {
651
651
 
            let dh = (parseIntValue(dw[dB]) + ((dz * dx[dB]) * dy))
652
652
 
            if ((0 > dh))
653
653
 
                then throw(((((((("Panic! Pieces of type=" + toString(dB)) + ", sign=") + toString(dz)) + ",  terrainCounts[i]=") + toString(dx[dB])) + ", landSizeIndex=") + toString(dy)))
654
654
 
                else (bI :+ toString(dh))
655
655
 
            }
656
656
 
657
657
 
        let da = {
658
658
 
            let bL = [0, 1, 2, 3, 4, 5]
659
659
 
            let bM = size(bL)
660
660
 
            let bN = nil
661
661
 
            func bO (bP,bQ) =             if ((bQ >= bM))
662
662
 
                then bP
663
663
 
                else dA(bP, bL[bQ])
664
664
 
665
665
 
            func bR (bP,bQ) =             if ((bQ >= bM))
666
666
 
                then bP
667
667
 
                else throw("List size exceeds 6")
668
668
 
669
669
 
            bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
670
670
 
            }
671
671
 
        makeString(da, "_")
672
672
 
        }
673
673
 
674
674
 
675
675
 
func dC (dx,dy,dz) = {
676
676
 
    let dw = split(valueOrElse(getString(bj()), "0_0_0_0_0_0"), "_")
677
677
 
    dv(dw, dx, dy, dz)
678
678
 
    }
679
679
 
680
680
 
681
681
 
func dD (dE) = [(size(split(dE, "A")) - 1), (size(split(dE, "B")) - 1), (size(split(dE, "C")) - 1), (size(split(dE, "D")) - 1), (size(split(dE, "E")) - 1), (size(split(dE, "F")) - 1)]
682
682
 
683
683
 
684
684
 
func dF (dG,dx,dH,dy,dI) = {
685
685
 
    func bH (bI,dB) =     {
686
686
 
        let dJ = ((fraction(dH, dI, u) * dx[dB]) * dy)
687
687
 
        (bI :+ toString((parseIntValue(dG[dB]) + dJ)))
688
688
 
        }
689
689
 
690
690
 
    let da = {
691
691
 
        let bL = [0, 1, 2, 3, 4, 5]
692
692
 
        let bM = size(bL)
693
693
 
        let bN = nil
694
694
 
        func bO (bP,bQ) =         if ((bQ >= bM))
695
695
 
            then bP
696
696
 
            else bH(bP, bL[bQ])
697
697
 
698
698
 
        func bR (bP,bQ) =         if ((bQ >= bM))
699
699
 
            then bP
700
700
 
            else throw("List size exceeds 6")
701
701
 
702
702
 
        bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
703
703
 
        }
704
704
 
    makeString(da, "_")
705
705
 
    }
706
706
 
707
707
 
708
708
 
func dK (dx,dH,dy,dI) = {
709
709
 
    func bH (bI,dB) =     {
710
710
 
        let dJ = ((fraction(dH, dI, u) * dx[dB]) * dy)
711
711
 
        $Tuple2((bI._1 :+ dJ), (bI._2 + dJ))
712
712
 
        }
713
713
 
714
714
 
    let bL = [0, 1, 2, 3, 4, 5]
715
715
 
    let bM = size(bL)
716
716
 
    let bN = $Tuple2(nil, 0)
717
717
 
    func bO (bP,bQ) =     if ((bQ >= bM))
718
718
 
        then bP
719
719
 
        else bH(bP, bL[bQ])
720
720
 
721
721
 
    func bR (bP,bQ) =     if ((bQ >= bM))
722
722
 
        then bP
723
723
 
        else throw("List size exceeds 6")
724
724
 
725
725
 
    bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
726
726
 
    }
727
727
 
728
728
 
729
729
 
func dL (dM,dN,dO,dP) = {
730
730
 
    let dQ = dO._1
731
731
 
    let dR = dO._2
732
732
 
    if ((dR == 0))
733
733
 
        then $Tuple2(makeString(dM, "_"), makeString(dN, "_"))
734
734
 
        else if ((dP >= dR))
735
735
 
            then {
736
736
 
                func dS (bI,dB) =                 (bI :+ toString((parseIntValue(dM[dB]) + dQ[dB])))
737
737
 
738
738
 
                let da = {
739
739
 
                    let bL = [0, 1, 2, 3, 4, 5]
740
740
 
                    let bM = size(bL)
741
741
 
                    let bN = nil
742
742
 
                    func bO (bP,bQ) =                     if ((bQ >= bM))
743
743
 
                        then bP
744
744
 
                        else dS(bP, bL[bQ])
745
745
 
746
746
 
                    func bR (bP,bQ) =                     if ((bQ >= bM))
747
747
 
                        then bP
748
748
 
                        else throw("List size exceeds 6")
749
749
 
750
750
 
                    bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
751
751
 
                    }
752
752
 
                $Tuple2(makeString(da, "_"), makeString(dN, "_"))
753
753
 
                }
754
754
 
            else {
755
755
 
                func dT (bI,dB) =                 {
756
756
 
                    let dU = fraction(dQ[dB], dP, dR)
757
757
 
                    $Tuple2((bI._1 :+ toString((parseIntValue(dM[dB]) + dU))), (bI._2 :+ toString(((parseIntValue(dN[dB]) + dQ[dB]) - dU))))
758
758
 
                    }
759
759
 
760
760
 
                let da = {
761
761
 
                    let bL = [0, 1, 2, 3, 4, 5]
762
762
 
                    let bM = size(bL)
763
763
 
                    let bN = $Tuple2(nil, nil)
764
764
 
                    func bO (bP,bQ) =                     if ((bQ >= bM))
765
765
 
                        then bP
766
766
 
                        else dT(bP, bL[bQ])
767
767
 
768
768
 
                    func bR (bP,bQ) =                     if ((bQ >= bM))
769
769
 
                        then bP
770
770
 
                        else throw("List size exceeds 6")
771
771
 
772
772
 
                    bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
773
773
 
                    }
774
774
 
                $Tuple2(makeString(da._1, "_"), makeString(da._2, "_"))
775
775
 
                }
776
776
 
    }
777
777
 
778
778
 
779
779
 
func dV (dW) = if ((dW >= toBigInt(0)))
780
780
 
    then dW
781
781
 
    else -(dW)
782
782
 
783
783
 
784
784
 
let dX = [[6, 9, 14, 15, 16], [5, 8, 13, 14, 15], [1, 4, 9, 10, 15], [1, 6, 7, 15, 19], [4, 7, 8, 13, 18]]
785
785
 
786
786
 
func dY (bw,dZ) = {
787
787
 
    let ea = toInt((bw % cp))
788
788
 
    let eb = if ((dZ[0] > ea))
789
789
 
        then "A"
790
790
 
        else if ((dZ[1] > ea))
791
791
 
            then "B"
792
792
 
            else if ((dZ[2] > ea))
793
793
 
                then "C"
794
794
 
                else if ((dZ[3] > ea))
795
795
 
                    then "D"
796
796
 
                    else if ((dZ[4] > ea))
797
797
 
                        then "E"
798
798
 
                        else "F"
799
799
 
    eb
800
800
 
    }
801
801
 
802
802
 
803
803
 
func ec (ed,ee) = {
804
804
 
    let ef = dX[ee]
805
805
 
    func eg (bI,cY) =     $Tuple2((((((bI._1 + dY(bI._2, ef)) + dY((bI._2 / cp), ef)) + dY((bI._2 / cq), ef)) + dY((bI._2 / cr), ef)) + dY((bI._2 / cs), ef)), (bI._2 / ct))
806
806
 
807
807
 
    let eh = {
808
808
 
        let bL = [1, 2, 3, 4, 5]
809
809
 
        let bM = size(bL)
810
810
 
        let bN = $Tuple2("", (ed / co))
811
811
 
        func bO (bP,bQ) =         if ((bQ >= bM))
812
812
 
            then bP
813
813
 
            else eg(bP, bL[bQ])
814
814
 
815
815
 
        func bR (bP,bQ) =         if ((bQ >= bM))
816
816
 
            then bP
817
817
 
            else throw("List size exceeds 5")
818
818
 
819
819
 
        bR(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5)
820
820
 
        }
821
821
 
    eh._1
822
822
 
    }
823
823
 
824
824
 
825
825
 
func ei (ej) = {
826
826
 
    let ek = split(valueOrElse(getString(ej), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
827
827
 
[toString(valueOrElse(parseInt(ek[ai]), 0)), if ((size(split(ek[aj], "_")) == n))
828
828
 
        then ek[aj]
829
829
 
        else "0_0_0_0_0_0", if ((size(split(ek[ak], "_")) == n))
830
830
 
        then ek[ak]
831
831
 
        else "0_0_0_0_0_0", ek[al]]
832
832
 
    }
833
833
 
834
834
 
835
835
 
func el (em) = {
836
836
 
    let dp = split(em, "_")
837
837
 
    ((v * (parseIntValue(dp[1]) + 1)) * parseIntValue(dp[0]))
838
838
 
    }
839
839
 
840
840
 
841
841
 
func en (eo) = {
842
842
 
    let ep = eo[ac]
843
843
 
    func eq (bI,bJ) =     (bI + parseIntValue(bJ))
844
844
 
845
845
 
    func er (bI,bJ) =     {
846
846
 
        let aD = bI._1
847
847
 
        let es = am(aD)
848
848
 
        let et = (((parseIntValue(bJ) + es) - 1) / es)
849
849
 
        $Tuple2((aD + 1), (bI._2 + (et * i)))
850
850
 
        }
851
851
 
852
852
 
    let eu = {
853
853
 
        let bL = split(eo[aa], "_")
854
854
 
        let bM = size(bL)
855
855
 
        let bN = 0
856
856
 
        func bO (bP,bQ) =         if ((bQ >= bM))
857
857
 
            then bP
858
858
 
            else eq(bP, bL[bQ])
859
859
 
860
860
 
        func bR (bP,bQ) =         if ((bQ >= bM))
861
861
 
            then bP
862
862
 
            else throw("List size exceeds 6")
863
863
 
864
864
 
        bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
865
865
 
        }
866
866
 
    let ev = {
867
867
 
        let bL = split(eo[ab], "_")
868
868
 
        let bM = size(bL)
869
869
 
        let bN = 0
870
870
 
        func bX (bP,bQ) =         if ((bQ >= bM))
871
871
 
            then bP
872
872
 
            else eq(bP, bL[bQ])
873
873
 
874
874
 
        func bY (bP,bQ) =         if ((bQ >= bM))
875
875
 
            then bP
876
876
 
            else throw("List size exceeds 6")
877
877
 
878
878
 
        bY(bX(bX(bX(bX(bX(bX(bN, 0), 1), 2), 3), 4), 5), 6)
879
879
 
        }
880
880
 
    let ew = if ((ep == ""))
881
881
 
        then 0
882
882
 
        else (        let bL = split_4C(ep, "_")
883
883
 
        let bM = size(bL)
884
884
 
        let bN = $Tuple2(0, 0)
885
885
 
        func ex (bP,bQ) =         if ((bQ >= bM))
886
886
 
            then bP
887
887
 
            else er(bP, bL[bQ])
888
888
 
889
889
 
        func ey (bP,bQ) =         if ((bQ >= bM))
890
890
 
            then bP
891
891
 
            else throw("List size exceeds 50")
892
892
 
893
893
 
        ey(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(bN, 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))._2
894
894
 
    ((eu + ev) + ew)
895
895
 
    }
896
896
 
897
897
 
898
898
 
func ez (eA,eB,eC) = {
899
899
 
    let em = ((toString(eB) + "_") + toString(eC))
900
900
 
    let eD = el(em)
901
901
 
    let eE = valueOrElse(getString(eA), (em + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
902
902
 
    let eF = split_4C(eE, ":")
903
903
 
    let eG = en(eF)
904
904
 
    let eH = if ((5 > size(eF)))
905
905
 
        then makeString(["0", toString(eG), toString((eD - eG)), toString(eD)], "_")
906
906
 
        else {
907
907
 
            let eI = split(eF[ad], "_")
908
908
 
            let eJ = parseIntValue(eI[ae])
909
909
 
            let eK = if ((size(eI) > 1))
910
910
 
                then parseIntValue(eI[af])
911
911
 
                else eG
912
912
 
            makeString([toString(eJ), toString(eK), toString(((eD - eJ) - eK)), toString(eD)], "_")
913
913
 
            }
914
914
 
[eF[Z], if ((size(split(eF[aa], "_")) == n))
915
915
 
        then eF[aa]
916
916
 
        else "0_0_0_0_0_0", if ((size(split(eF[ab], "_")) == n))
917
917
 
        then eF[ab]
918
918
 
        else "0_0_0_0_0_0", eF[ac], eH]
919
919
 
    }
920
920
 
921
921
 
922
922
 
func eL (eo) = {
923
923
 
    let eM = en(eo)
924
924
 
    let eN = parseIntValue(split(eo[ad], "_")[ae])
925
925
 
    ((el(eo[Z]) - eM) - eN)
926
926
 
    }
927
927
 
928
928
 
929
929
 
func eO (eP,es) = {
930
930
 
    let et = if ((eP >= 0))
931
931
 
        then (((eP + es) - 1) / es)
932
932
 
        else -((((-(eP) + es) - 1) / es))
933
933
 
    (et * i)
934
934
 
    }
935
935
 
936
936
 
937
937
 
func eQ (eR,eo,eS) = if ((size(eR) != 3))
938
938
 
    then throw("cargoListStr should contain exactly 2 ':' separators")
939
939
 
    else {
940
940
 
        let eT = split(eR[0], "_")
941
941
 
        let eU = split(eR[1], "_")
942
942
 
        let eV = if ((eR[2] == ""))
943
943
 
            then nil
944
944
 
            else split(eR[2], "_")
945
945
 
        if ((size(eT) != n))
946
946
 
            then throw("All 6 resources should be passed")
947
947
 
            else if ((size(eU) != n))
948
948
 
                then throw("All 6 materials should be passed")
949
949
 
                else {
950
950
 
                    let dP = eL(eo)
951
951
 
                    let eW = split(eo[aa], "_")
952
952
 
                    let eX = split(eo[ab], "_")
953
953
 
                    let eY = if ((eo[ac] == ""))
954
954
 
                        then nil
955
955
 
                        else split(eo[ac], "_")
956
956
 
                    let dN = split(eS[aj], "_")
957
957
 
                    let eZ = split(eS[ak], "_")
958
958
 
                    let fa = if ((eS[al] == ""))
959
959
 
                        then nil
960
960
 
                        else split(eS[al], "_")
961
961
 
                    func fb (bI,bJ) =                     {
962
962
 
                        let dB = bI._1
963
963
 
                        let fc = parseIntValue(bJ)
964
964
 
                        let fd = parseIntValue(eW[dB])
965
965
 
                        let fe = parseIntValue(dN[dB])
966
966
 
                        if ((fc == 0))
967
967
 
                            then $Tuple4((dB + 1), (bI._2 :+ eW[dB]), (bI._3 :+ dN[dB]), bI._4)
968
968
 
                            else if ((fc > 0))
969
969
 
                                then if ((fc > fe))
970
970
 
                                    then throw((((("Attempt to take " + bJ) + " from backpack, but only ") + toString(fe)) + " available"))
971
971
 
                                    else $Tuple4((dB + 1), (bI._2 :+ toString((fd + fc))), (bI._3 :+ toString((fe - fc))), (bI._4 + fc))
972
972
 
                                else if ((-(fc) > fd))
973
973
 
                                    then throw((((("Attempt to take " + toString(-(fc))) + " from warehouse, but only ") + toString(fd)) + " available"))
974
974
 
                                    else $Tuple4((dB + 1), (bI._2 :+ toString((fd + fc))), (bI._3 :+ toString((fe - fc))), (bI._4 + fc))
975
975
 
                        }
976
976
 
977
977
 
                    let da = {
978
978
 
                        let bL = eT
979
979
 
                        let bM = size(bL)
980
980
 
                        let bN = $Tuple4(0, nil, nil, 0)
981
981
 
                        func bO (bP,bQ) =                         if ((bQ >= bM))
982
982
 
                            then bP
983
983
 
                            else fb(bP, bL[bQ])
984
984
 
985
985
 
                        func bR (bP,bQ) =                         if ((bQ >= bM))
986
986
 
                            then bP
987
987
 
                            else throw("List size exceeds 6")
988
988
 
989
989
 
                        bR(bO(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5), 6)
990
990
 
                        }
991
991
 
                    func ff (bI,bJ) =                     {
992
992
 
                        let dB = bI._1
993
993
 
                        let fc = parseIntValue(bJ)
994
994
 
                        let fg = parseIntValue(eX[dB])
995
995
 
                        let fh = parseIntValue(eZ[dB])
996
996
 
                        if ((fc == 0))
997
997
 
                            then $Tuple4((dB + 1), (bI._2 :+ eX[dB]), (bI._3 :+ eZ[dB]), bI._4)
998
998
 
                            else if ((fc > 0))
999
999
 
                                then if ((fc > fh))
1000
1000
 
                                    then throw((((("Attempt to take " + bJ) + " from backpack, but only ") + toString(fh)) + " available"))
1001
1001
 
                                    else $Tuple4((dB + 1), (bI._2 :+ toString((fg + fc))), (bI._3 :+ toString((fh - fc))), (bI._4 + fc))
1002
1002
 
                                else if ((-(fc) > fg))
1003
1003
 
                                    then throw((((("Attempt to take " + toString(-(fc))) + " from warehouse, but only ") + toString(fg)) + " available"))
1004
1004
 
                                    else $Tuple4((dB + 1), (bI._2 :+ toString((fg + fc))), (bI._3 :+ toString((fh - fc))), (bI._4 + fc))
1005
1005
 
                        }
1006
1006
 
1007
1007
 
                    let fi = {
1008
1008
 
                        let bL = eU
1009
1009
 
                        let bM = size(bL)
1010
1010
 
                        let bN = $Tuple4(0, nil, nil, da._4)
1011
1011
 
                        func bX (bP,bQ) =                         if ((bQ >= bM))
1012
1012
 
                            then bP
1013
1013
 
                            else ff(bP, bL[bQ])
1014
1014
 
1015
1015
 
                        func bY (bP,bQ) =                         if ((bQ >= bM))
1016
1016
 
                            then bP
1017
1017
 
                            else throw("List size exceeds 6")
1018
1018
 
1019
1019
 
                        bY(bX(bX(bX(bX(bX(bX(bN, 0), 1), 2), 3), 4), 5), 6)
1020
1020
 
                        }
1021
1021
 
                    func fj (bI,bJ) =                     {
1022
1022
 
                        let dB = bI._1
1023
1023
 
                        let es = am(dB)
1024
1024
 
                        let fc = parseIntValue(bJ)
1025
1025
 
                        let fk = if ((size(eY) > dB))
1026
1026
 
                            then parseIntValue(eY[dB])
1027
1027
 
                            else 0
1028
1028
 
                        let fl = if ((size(fa) > dB))
1029
1029
 
                            then parseIntValue(fa[dB])
1030
1030
 
                            else 0
1031
1031
 
                        if ((fc == 0))
1032
1032
 
                            then $Tuple4((dB + 1), (bI._2 :+ toString(fk)), (bI._3 :+ toString(fl)), bI._4)
1033
1033
 
                            else if ((fc > 0))
1034
1034
 
                                then if ((fc > fl))
1035
1035
 
                                    then throw((((("Attempt to take " + bJ) + " from backpack, but only ") + toString(fl)) + " available"))
1036
1036
 
                                    else {
1037
1037
 
                                        let fm = (eO((fk + fc), es) - eO(fk, es))
1038
1038
 
                                        $Tuple4((dB + 1), (bI._2 :+ toString((fk + fc))), (bI._3 :+ toString((fl - fc))), (bI._4 + fm))
1039
1039
 
                                        }
1040
1040
 
                                else if ((-(fc) > fk))
1041
1041
 
                                    then throw((((("Attempt to take " + toString(-(fc))) + " from warehouse, but only ") + toString(fk)) + " available"))
1042
1042
 
                                    else {
1043
1043
 
                                        let fm = (eO((fk + fc), es) - eO(fk, es))
1044
1044
 
                                        $Tuple4((dB + 1), (bI._2 :+ toString((fk + fc))), (bI._3 :+ toString((fl - fc))), (bI._4 + fm))
1045
1045
 
                                        }
1046
1046
 
                        }
1047
1047
 
1048
1048
 
                    let ek = if ((size(eV) != 0))
1049
1049
 
                        then {
1050
1050
 
                            let bL = eV
1051
1051
 
                            let bM = size(bL)
1052
1052
 
                            let bN = $Tuple4(0, nil, nil, fi._4)
1053
1053
 
                            func ex (bP,bQ) =                             if ((bQ >= bM))
1054
1054
 
                                then bP
1055
1055
 
                                else fj(bP, bL[bQ])
1056
1056
 
1057
1057
 
                            func ey (bP,bQ) =                             if ((bQ >= bM))
1058
1058
 
                                then bP
1059
1059
 
                                else throw("List size exceeds 50")
1060
1060
 
1061
1061
 
                            ey(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(ex(bN, 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)
1062
1062
 
                            }
1063
1063
 
                        else $Tuple4(0, eY, fa, fi._4)
1064
1064
 
                    let fn = ek._4
1065
1065
 
                    if ((fn > dP))
1066
1066
 
                        then throw((((("Attempt to put total " + toString(fn)) + " stuff, but only ") + toString(dP)) + " warehouse space left"))
1067
1067
 
                        else $Tuple7(makeString(da._2, "_"), makeString(fi._2, "_"), makeString(ek._2, "_"), makeString(da._3, "_"), makeString(fi._3, "_"), makeString(ek._3, "_"), fn)
1068
1068
 
                    }
1069
1069
 
        }
1070
1070
 
1071
1071
 
1072
1072
 
func fo (fp,fq) = {
1073
1073
 
    let bm = toString(fp)
1074
1074
 
    let fr = dV(toBigInt(fq))
1075
1075
 
    let fs = valueOrElse(getInteger(cv()), (cu + 1))
1076
1076
 
    let cx = toString(fs)
1077
1077
 
    let ee = toInt((fr % co))
1078
1078
 
    let dE = ec(fr, ee)
1079
1079
 
    let ft = F[ee]
1080
1080
 
    let fu = Issue(cR(cx, "S"), makeString([cx, "S", dE, ft], "_"), 1, 0, false)
1081
1081
 
    let aM = calculateAssetId(fu)
1082
1082
 
    let fv = toBase58String(aM)
1083
1083
 
    $Tuple2([IntegerEntry(cv(), (fs + 1)), fu, StringEntry(cw(cx), fv), StringEntry(aL(fv), bm), StringEntry(cC(cx), bm), IntegerEntry(aP(fv), 0), IntegerEntry(cA(fv, bm), 0), ScriptTransfer(fp, 1, aM)], $Tuple2(fv, ft))
1084
1084
 
    }
1085
1085
 
1086
1086
 
1087
1087
 
func fw (bm,fx,fy) = if (!(sigVerify_8Kb(fx, fy, cg)))
1088
1088
 
    then throw("signature does not match")
1089
1089
 
    else {
1090
1090
 
        let dp = split(toUtf8String(fx), ";")
1091
1091
 
        let fz = split(dp[0], "|")
1092
1092
 
        let fA = split(fz[cJ], "_")
1093
1093
 
        let fB = parseIntValue(fA[0])
1094
1094
 
        let fC = parseIntValue(fA[1])
1095
1095
 
        let fD = split(dp[1], ":")
1096
1096
 
        let fE = fD[0]
1097
1097
 
        let fF = parseIntValue(fz[cO])
1098
1098
 
        if (if ((fF > (lastBlock.timestamp + ci)))
1099
1099
 
            then true
1100
1100
 
            else ((lastBlock.timestamp - ci) > fF))
1101
1101
 
            then throw(((("signature outdated: logTime=" + toString(fF)) + ", bcTime=") + toString(lastBlock.timestamp)))
1102
1102
 
            else {
1103
1103
 
                let fG = fD[1]
1104
1104
 
                let fH = valueOrElse(getString(aJ(bm)), "")
1105
1105
 
                if ((fH != fG))
1106
1106
 
                    then throw(((("Tx ids don't match! In state: " + fH) + ", in msg: ") + fG))
1107
1107
 
                    else {
1108
1108
 
                        let bg = valueOrErrorMessage(getString(be(bm)), "You don't have a duck staked")
1109
1109
 
                        let fI = bi(bg)
1110
1110
 
                        let fJ = valueOrElse(getInteger(fI), 100)
1111
1111
 
                        if ((fJ != fB))
1112
1112
 
                            then throw(((("oldHealth=" + toString(valueOrElse(getInteger(fI), 100))) + " from state does not match one from flight log=") + toString(fB)))
1113
1113
 
                            else if ((0 >= fB))
1114
1114
 
                                then throw("You can't fly with zero health")
1115
1115
 
                                else {
1116
1116
 
                                    let fK = if ((size(fz) > cP))
1117
1117
 
                                        then fz[cP]
1118
1118
 
                                        else ""
1119
1119
 
                                    let fL = if ((size(fz) > cQ))
1120
1120
 
                                        then fz[cQ]
1121
1121
 
                                        else ""
1122
1122
 
                                    let fM = if (if ((fC > 0))
1123
1123
 
                                        then (fK == "$")
1124
1124
 
                                        else false)
1125
1125
 
                                        then bv(invoke(aE, "sendUsdtPrize", [bm], nil))
1126
1126
 
                                        else 0
1127
1127
 
                                    $Tuple5(fC, bg, fM, fE, fL)
1128
1128
 
                                    }
1129
1129
 
                        }
1130
1130
 
                }
1131
1131
 
        }
1132
1132
 
1133
1133
 
1134
1134
 
func fN (fp,fq,fx,fy) = {
1135
1135
 
    let bm = toString(fp)
1136
1136
 
    let ef = fw(bm, fx, fy)
1137
1137
 
    let fI = bi(ef._2)
1138
1138
 
    let ej = bf(ef._2)
1139
1139
 
    let eS = ei(ej)
1140
1140
 
    let fO = split(eS[ak], "_")
1141
1141
 
    let fP = makeString(db(true, fO, cm), "_")
1142
1142
 
    let du = di(eS[al], ef._5)
1143
1143
 
    if ((0 >= ef._1))
1144
1144
 
        then $Tuple3([IntegerEntry(fI, 0), StringEntry(ej, makeString([eS[ai], eS[aj], eS[ak], du], ":"))], "", 0)
1145
1145
 
        else {
1146
1146
 
            let fQ = fo(fp, fq)
1147
1147
 
            let fv = fQ._2._1
1148
1148
 
            $Tuple3((((fQ._1 :+ StringEntry(bh(ef._2), makeString([fQ._2._2, "L", fv], "_"))) :+ IntegerEntry(fI, ef._1)) :+ StringEntry(ej, makeString([eS[ai], eS[aj], fP, du], ":"))), fv, ef._3)
1149
1149
 
            }
1150
1150
 
    }
1151
1151
 
1152
1152
 
1153
1153
 
func fR (aW,fS) = {
1154
1154
 
    let eC = valueOrElse(getInteger(aP(aW)), 0)
1155
1155
 
    let fT = valueOrElse(getInteger(aQ(m, aW)), 0)
1156
1156
 
    let fU = (eC / 6)
1157
1157
 
    let fV = (eC / 7)
1158
1158
 
    ((t + fraction(t, ((eC + fU) + (2 * fV)), 5)) + fraction(t, fT, (fS * 5)))
1159
1159
 
    }
1160
1160
 
1161
1161
 
1162
1162
 
func fW (aK,fX,fY) = {
1163
1163
 
    let fZ = if ((fX == cG))
1164
1164
 
        then $Tuple2(fY, valueOrElse(getString(be(aK)), ""))
1165
1165
 
        else {
1166
1166
 
            let bg = valueOrErrorMessage(getString(be(aK)), "You don't have a duck staked")
1167
1167
 
            let ga = valueOrElse(getString(bh(bg)), w)
1168
1168
 
            let gb = split(value(ga), "_")
1169
1169
 
            if ((gb[bq] != "L"))
1170
1170
 
                then throw((("Duck location type is " + gb[bq]) + ", but should be L"))
1171
1171
 
                else $Tuple2(gb[br], bg)
1172
1172
 
            }
1173
1173
 
    let aW = fZ._1
1174
1174
 
    let gc = fZ._2
1175
1175
 
    let bW = value(assetInfo(fromBase58String(aW)))
1176
1176
 
    let gd = aO(aW)
1177
1177
 
    let ge = valueOrErrorMessage(getInteger(gd), (("Land " + bW.name) + " is not staked"))
1178
1178
 
    let gf = valueOrErrorMessage(getString(aL(aW)), (("NFT " + bW.name) + " is orphaned"))
1179
1179
 
    if ((gf != aK))
1180
1180
 
        then throw((k + " is not yours"))
1181
1181
 
        else {
1182
1182
 
            let gg = split(bW.description, "_")
1183
1183
 
            $Tuple4(gc, aW, gg, ge)
1184
1184
 
            }
1185
1185
 
    }
1186
1186
 
1187
1187
 
1188
1188
 
func gh (aK,eP,fX,fY) = if ((0 > eP))
1189
1189
 
    then throw("Negative amount")
1190
1190
 
    else {
1191
1191
 
        let gi = fW(aK, fX, fY)
1192
1192
 
        let bB = gi._3[W]
1193
1193
 
        let dx = dD(gi._3[X])
1194
1194
 
        let dH = (lastBlock.timestamp - gi._4)
1195
1195
 
        if ((0 > dH))
1196
1196
 
            then throw(((("Saved timestamp is in future, saved = " + toString(gi._4)) + ", current = ") + toString(lastBlock.timestamp)))
1197
1197
 
            else {
1198
1198
 
                let fS = bA(bB)
1199
1199
 
                let gj = fR(gi._2, fS)
1200
1200
 
                let gk = fraction(dH, (gj * fS), u)
1201
1201
 
                if ((eP > gk))
1202
1202
 
                    then throw(((("Not enough resources, available = " + toString(gk)) + ", requested = ") + toString(eP)))
1203
1203
 
                    else {
1204
1204
 
                        let gl = fraction((gk - eP), u, (gj * fS))
1205
1205
 
                        let gm = (lastBlock.timestamp - gl)
1206
1206
 
                        let eB = (fS / o)
1207
1207
 
                        let dO = dK(dx, (dH - gl), eB, gj)
1208
1208
 
                        let eA = aV(gi._2)
1209
1209
 
                        let eC = valueOrElse(getInteger(aP(gi._2)), 0)
1210
1210
 
                        let eo = ez(eA, eB, eC)
1211
1211
 
                        let eI = split(eo[ad], "_")
1212
1212
 
                        let dP = parseIntValue(eI[ag])
1213
1213
 
                        if (if ((fX == cG))
1214
1214
 
                            then (eP > dP)
1215
1215
 
                            else false)
1216
1216
 
                            then throw((("Only " + toString(dP)) + " space left in warehouse"))
1217
1217
 
                            else {
1218
1218
 
                                let ej = bf(gi._1)
1219
1219
 
                                let eS = ei(ej)
1220
1220
 
                                let dN = split(eS[aj], "_")
1221
1221
 
                                let dM = split(eo[aa], "_")
1222
1222
 
                                let gn = if ((fX == cG))
1223
1223
 
                                    then $Tuple4(dF(dM, dx, (dH - gl), eB, gj), eS[aj], (parseIntValue(eI[af]) + dO._2), (parseIntValue(eI[ag]) - dO._2))
1224
1224
 
                                    else if ((fX == cH))
1225
1225
 
                                        then $Tuple4(eo[aa], dF(dN, dx, (dH - gl), eB, gj), parseIntValue(eI[af]), parseIntValue(eI[ag]))
1226
1226
 
                                        else {
1227
1227
 
                                            let go = dL(dM, dN, dO, dP)
1228
1228
 
                                            let gp = min([parseIntValue(eI[ag]), dO._2])
1229
1229
 
                                            $Tuple4(go._1, go._2, (parseIntValue(eI[af]) + gp), (parseIntValue(eI[ag]) - gp))
1230
1230
 
                                            }
1231
1231
 
                                let gq = gn._1
1232
1232
 
                                let gr = gn._2
1233
1233
 
                                let gs = gn._3
1234
1234
 
                                let gt = gn._4
1235
1235
 
                                $Tuple5([IntegerEntry(aO(gi._2), gm), IntegerEntry(aS(k, gi._2, aK), gm)], ej, [eS[ai], gr, eS[ak], eS[al]], eA, [eo[Z], gq, eo[ab], eo[ac], makeString([eI[ae], toString(gs), toString(gt), eI[ah]], "_")])
1236
1236
 
                                }
1237
1237
 
                        }
1238
1238
 
                }
1239
1239
 
        }
1240
1240
 
1241
1241
 
1242
1242
 
func gu (aK,aW,fS,fX) = {
1243
1243
 
    let gd = aO(aW)
1244
1244
 
    let ge = value(getInteger(gd))
1245
1245
 
    let gk = (fraction((lastBlock.timestamp - ge), fR(aW, fS), u) * fS)
1246
1246
 
    gh(aK, gk, fX, aW)
1247
1247
 
    }
1248
1248
 
1249
1249
 
1250
1250
 
func gv (dc,fp,gw,aW) = {
1251
1251
 
    let aK = toString(fp)
1252
1252
 
    let gi = fW(aK, cI, aW)
1253
1253
 
    let fS = bA(gi._3[W])
1254
1254
 
    let gx = aP(gi._2)
1255
1255
 
    let gy = valueOrElse(getInteger(gx), 0)
1256
1256
 
    if ((gy >= 3))
1257
1257
 
        then throw("Currently max infrastructure level = 3")
1258
1258
 
        else {
1259
1259
 
            let gz = (gy + 1)
1260
1260
 
            let gA = fraction(cl, (fS * gz), o)
1261
1261
 
            if (if (!(dc))
1262
1262
 
                then (gw != gA)
1263
1263
 
                else false)
1264
1264
 
                then throw(("Payment attached should be " + toString(gA)))
1265
1265
 
                else {
1266
1266
 
                    let ej = bf(gi._1)
1267
1267
 
                    let eS = ei(ej)
1268
1268
 
                    let fO = split(eS[ak], "_")
1269
1269
 
                    let fP = makeString(db(dc, fO, fraction(e, (fS * gz), o)), "_")
1270
1270
 
                    let gB = gu(aK, gi._2, fS, cI)
1271
1271
 
                    let gC = gB._5
1272
1272
 
                    let gD = el(gC[Z])
1273
1273
 
                    let gE = makeString([split(gC[Z], "_")[0], toString(gz)], "_")
1274
1274
 
                    let gF = el(gE)
1275
1275
 
                    let eI = split(gC[ad], "_")
1276
1276
 
                    let gG = makeString([eI[ae], eI[af], toString(((parseIntValue(eI[ag]) + gF) - gD)), toString(gF)], "_")
1277
1277
 
                    $Tuple2(([IntegerEntry(gx, gz), IntegerEntry(cA(gi._2, aK), gz), StringEntry(ej, makeString([eS[ai], gB._3[aj], fP, eS[al]], ":")), StringEntry(gB._4, makeString([gE, gC[aa], gC[ab], gC[ac], gG], ":"))] ++ gB._1), gz)
1278
1278
 
                    }
1279
1279
 
            }
1280
1280
 
    }
1281
1281
 
1282
1282
 
1283
1283
 
func gH (aK) = 0
1284
1284
 
1285
1285
 
1286
1286
 
func gI (aK,fY) = {
1287
1287
 
    let gi = fW(aK, cI, fY)
1288
1288
 
    let aW = gi._2
1289
1289
 
    let fS = bA(gi._3[W])
1290
1290
 
    let gJ = aQ(m, aW)
1291
1291
 
    if ((valueOrElse(getInteger(gJ), 0) > 0))
1292
1292
 
        then throw("Presale artifact is already activated")
1293
1293
 
        else if ((parseIntValue(gi._3[V]) > cu))
1294
1294
 
            then throw((((k + " ") + aW) + " is not eligible for presale artifact"))
1295
1295
 
            else {
1296
1296
 
                let gB = gu(aK, aW, fS, cI)
1297
1297
 
                ((((gB._1 :+ IntegerEntry(gJ, fS)) :+ IntegerEntry(cB(m, aW, aK), fS)) :+ StringEntry(gB._2, makeString(gB._3, ":"))) :+ StringEntry(gB._4, makeString(gB._5, ":")))
1298
1298
 
                }
1299
1299
 
    }
1300
1300
 
1301
1301
 
1302
1302
 
func gK (gL,gz,gM,aK,gN,fq,gO) = {
1303
1303
 
    let bg = valueOrErrorMessage(getString(be(aK)), "You don't have a duck staked")
1304
1304
 
    func gP (bI,aW) =     {
1305
1305
 
        let bW = value(assetInfo(fromBase58String(aW)))
1306
1306
 
        let gd = aO(aW)
1307
1307
 
        let ge = valueOrErrorMessage(getInteger(gd), (("NFT " + bW.name) + " is not staked"))
1308
1308
 
        let gf = valueOrErrorMessage(getString(aL(aW)), (("NFT " + bW.name) + " is orphaned"))
1309
1309
 
        if ((gf != aK))
1310
1310
 
            then throw((k + " is not yours"))
1311
1311
 
            else {
1312
1312
 
                let gg = split(bW.description, "_")
1313
1313
 
                let ft = gg[Y]
1314
1314
 
                if (if ((bI._3 != ""))
1315
1315
 
                    then (bI._3 != ft)
1316
1316
 
                    else false)
1317
1317
 
                    then throw("Lands should be on the same continent to merge")
1318
1318
 
                    else {
1319
1319
 
                        let bB = gg[W]
1320
1320
 
                        let gQ = bI._1
1321
1321
 
                        let dB = valueOrErrorMessage(indexOf(gQ, bB), "You haven't passed all the lands needed")
1322
1322
 
                        let gR = (take(gQ, dB) + drop(gQ, (dB + 1)))
1323
1323
 
                        let fS = bA(bB)
1324
1324
 
                        let gS = (bI._2 + valueOrElse(getInteger(aQ(m, aW)), 0))
1325
1325
 
                        let eC = valueOrElse(getInteger(aP(aW)), 0)
1326
1326
 
                        let gT = {
1327
1327
 
                            let c = bB
1328
1328
 
                            if (("S" == c))
1329
1329
 
                                then 3
1330
1330
 
                                else if (("M" == c))
1331
1331
 
                                    then 4
1332
1332
 
                                    else if (("L" == c))
1333
1333
 
                                        then 5
1334
1334
 
                                        else if (("XL" == c))
1335
1335
 
                                            then 6
1336
1336
 
                                            else throw("Only S, M, L, XL can merge")
1337
1337
 
                            }
1338
1338
 
                        if ((eC != gT))
1339
1339
 
                            then throw("All lands should be maxed to merge")
1340
1340
 
                            else {
1341
1341
 
                                let cx = gg[V]
1342
1342
 
                                let dx = dD(gg[X])
1343
1343
 
                                let dH = (lastBlock.timestamp - ge)
1344
1344
 
                                if ((0 > dH))
1345
1345
 
                                    then throw(((("Saved timestamp is in future, saved = " + toString(ge)) + ", current = ") + toString(lastBlock.timestamp)))
1346
1346
 
                                    else {
1347
1347
 
                                        let gj = fR(aW, fS)
1348
1348
 
                                        let eB = (fS / o)
1349
1349
 
                                        let gr = dF(split(bI._4, "_"), dx, dH, eB, gj)
1350
1350
 
                                        let bG = dv(split(bI._6, "_"), dx, eB, -1)
1351
1351
 
                                        let bU = bI._7
1352
1352
 
                                        let aD = indexOf(bU, aW)
1353
1353
 
                                        if (!(isDefined(aD)))
1354
1354
 
                                            then throw(("Your staked lands don't contain " + aW))
1355
1355
 
                                            else {
1356
1356
 
                                                let gU = aN(aW)
1357
1357
 
                                                let gV = valueOrElse(getString(gU), "")
1358
1358
 
                                                $Tuple8(gR, gS, ft, gr, (((((((((((((bI._5 :+ DeleteEntry(aO(aW))) :+ DeleteEntry(aS(k, aW, aK))) :+ DeleteEntry(cw(cx))) :+ DeleteEntry(aL(aW))) :+ DeleteEntry(aP(aW))) :+ DeleteEntry(cA(aW, aK))) :+ DeleteEntry(aQ(m, aW))) :+ DeleteEntry(cB(m, aW, aK))) :+ DeleteEntry(cC(cx))) :+ DeleteEntry(aV(aW))) :+ DeleteEntry(gU)) :+ DeleteEntry(cy(gV))) :+ Burn(fromBase58String(aW), 1)), bG, removeByIndex(bU, value(aD)), (bI._8 + fS))
1359
1359
 
                                                }
1360
1360
 
                                        }
1361
1361
 
                                }
1362
1362
 
                        }
1363
1363
 
                }
1364
1364
 
        }
1365
1365
 
1366
1366
 
    let ej = bf(bg)
1367
1367
 
    let eS = ei(ej)
1368
1368
 
    let gW = valueOrElse(getString(bj()), "0_0_0_0_0_0")
1369
1369
 
    let gX = aX(aK)
1370
1370
 
    let bT = getString(gX)
1371
1371
 
    let gY = if (isDefined(bT))
1372
1372
 
        then split_51C(value(bT), "_")
1373
1373
 
        else nil
1374
1374
 
    let da = {
1375
1375
 
        let bL = gN
1376
1376
 
        let bM = size(bL)
1377
1377
 
        let bN = $Tuple8(gM, 0, "", eS[aj], nil, gW, gY, 0)
1378
1378
 
        func bO (bP,bQ) =         if ((bQ >= bM))
1379
1379
 
            then bP
1380
1380
 
            else gP(bP, bL[bQ])
1381
1381
 
1382
1382
 
        func bR (bP,bQ) =         if ((bQ >= bM))
1383
1383
 
            then bP
1384
1384
 
            else throw("List size exceeds 5")
1385
1385
 
1386
1386
 
        bR(bO(bO(bO(bO(bO(bN, 0), 1), 2), 3), 4), 5)
1387
1387
 
        }
1388
1388
 
    let ft = da._3
1389
1389
 
    let ee = valueOrErrorMessage(indexOf(F, ft), ("Unknown continent: " + ft))
1390
1390
 
    let dE = ec(dV(toBigInt(fq)), ee)
1391
1391
 
    let fs = valueOrElse(getInteger(cv()), (cu + 1))
1392
1392
 
    let gZ = toString(fs)
1393
1393
 
    let fu = Issue(cR(gZ, gL), makeString([gZ, gL, dE, ft], "_"), 1, 0, false)
1394
1394
 
    let aM = calculateAssetId(fu)
1395
1395
 
    let ha = toBase58String(aM)
1396
1396
 
    let fP = makeString(db((gO > 0), split(eS[ak], "_"), gO), "_")
1397
1397
 
    let hb = aY(aK)
1398
1398
 
    let hc = valueOrElse(getInteger(hb), 0)
1399
1399
 
    $Tuple2((((((((((((((((da._5 :+ (if ((size(da._7) > 0))
1400
1400
 
        then StringEntry(gX, makeString_11C(da._7, "_"))
1401
1401
 
        else DeleteEntry(gX))) :+ IntegerEntry(hb, if ((da._8 > hc))
1402
1402
 
        then 0
1403
1403
 
        else (hc - da._8))) :+ IntegerEntry(cv(), (fs + 1))) :+ fu) :+ StringEntry(cw(gZ), ha)) :+ StringEntry(aL(ha), aK)) :+ StringEntry(cC(gZ), aK)) :+ IntegerEntry(aQ(m, ha), da._2)) :+ IntegerEntry(cB(m, ha, aK), da._2)) :+ IntegerEntry(aP(ha), gz)) :+ IntegerEntry(cA(ha, aK), gz)) :+ StringEntry(ej, makeString([eS[ai], da._4, fP, eS[al]], ":"))) :+ StringEntry(bj(), da._6)) :+ StringEntry(bh(bg), makeString([ft, "L", ha], "_"))) :+ ScriptTransfer(addressFromStringValue(aK), 1, aM)), ha)
1404
1404
 
    }
1405
1405
 
1406
1406
 
1407
1407
 
func hd (aK,gN,fq) = gK("M", 3, "SSSS", aK, gN, fq, 0)
1408
1408
 
1409
1409
 
1410
1410
 
func he (aK,gN,fq,dc,gw) = {
1411
1411
 
    let gA = (cl * 4)
1412
1412
 
    if (if (!(dc))
1413
1413
 
        then (gw != gA)
1414
1414
 
        else false)
1415
1415
 
        then throw(("Payment attached should be " + toString(gA)))
1416
1416
 
        else gK("L", 4, "SMM", aK, gN, fq, (e * 4))
1417
1417
 
    }
1418
1418
 
1419
1419
 
1420
1420
 
func hf (aK,gN,fq,dc,gw) = {
1421
1421
 
    let gA = (cl * 47)
1422
1422
 
    if (if (!(dc))
1423
1423
 
        then (gw != gA)
1424
1424
 
        else false)
1425
1425
 
        then throw(("Payment attached should be " + toString(gA)))
1426
1426
 
        else gK("XL", 5, "SSSML", aK, gN, fq, (e * 47))
1427
1427
 
    }
1428
1428
 
1429
1429
 
1430
1430
 
func hg (aK,gN,fq,dc,gw) = {
1431
1431
 
    let gA = (cl * 54)
1432
1432
 
    if (if (!(dc))
1433
1433
 
        then (gw != gA)
1434
1434
 
        else false)
1435
1435
 
        then throw(("Payment attached should be " + toString(gA)))
1436
1436
 
        else gK("XXL", 6, "LXL", aK, gN, fq, (e * 54))
1437
1437
 
    }
1438
1438
 
1439
1439
 
1440
1440
 
func hh (dc,aK,gw,gN,fq) = {
1441
1441
 
    let hi = {
1442
1442
 
        let c = size(gN)
1443
1443
 
        if ((4 == c))
1444
1444
 
            then hd(aK, gN, fq)
1445
1445
 
            else if ((3 == c))
1446
1446
 
                then he(aK, gN, fq, dc, gw)
1447
1447
 
                else if ((5 == c))
1448
1448
 
                    then hf(aK, gN, fq, dc, gw)
1449
1449
 
                    else if ((2 == c))
1450
1450
 
                        then hg(aK, gN, fq, dc, gw)
1451
1451
 
                        else throw("Unknown merge")
1452
1452
 
        }
1453
1453
 
    hi
1454
1454
 
    }
1455
1455
 
1456
1456
 
1457
1457
 
func hj (dB) = if (if ((dB.originCaller != aE))
1458
1458
 
    then valueOrElse(getBoolean(bk()), false)
1459
1459
 
    else false)
1460
1460
 
    then throw("Contracts are under maintenance")
1461
1461
 
    else StringEntry(aJ(toString(dB.originCaller)), toBase58String(dB.transactionId))
1462
1462
 
1463
1463
 
1464
1464
 
@Callable(dB)
1465
1465
 
func constructorV1 (hk) = if ((dB.caller != this))
1466
1466
 
    then throw("Permission denied")
1467
1467
 
    else [StringEntry(ay(), hk)]
1468
1468
 
1469
1469
 
1470
1470
 
1471
1471
 
@Callable(dB)
1472
1472
 
func setBlocked (hl) = if ((dB.caller != this))
1473
1473
 
    then throw("permission denied")
1474
1474
 
    else [BooleanEntry(bk(), hl)]
1475
1475
 
1476
1476
 
1477
1477
 
1478
1478
 
@Callable(dB)
1479
1479
 
func stakeLand () = {
1480
1480
 
    let hm = hj(dB)
1481
1481
 
    if ((size(dB.payments) != 1))
1482
1482
 
        then throw("Exactly one payment required")
1483
1483
 
        else {
1484
1484
 
            let hn = value(dB.payments[0])
1485
1485
 
            let aM = value(hn.assetId)
1486
1486
 
            let ap = toString(dB.caller)
1487
1487
 
            if ((hn.amount != 1))
1488
1488
 
                then throw((("NFT " + k) + " token should be attached as payment"))
1489
1489
 
                else {
1490
1490
 
                    let bW = value(assetInfo(aM))
1491
1491
 
                    if ((bW.issuer != this))
1492
1492
 
                        then throw("Unknown issuer of token")
1493
1493
 
                        else if (!(contains(bW.name, k)))
1494
1494
 
                            then throw((("Only NFT " + k) + " tokens are accepted"))
1495
1495
 
                            else {
1496
1496
 
                                let ho = drop(bW.name, 4)
1497
1497
 
                                let cx = if (contains(ho, "XXL"))
1498
1498
 
                                    then dropRight(ho, 3)
1499
1499
 
                                    else if (contains(ho, "XL"))
1500
1500
 
                                        then dropRight(ho, 2)
1501
1501
 
                                        else dropRight(ho, 1)
1502
1502
 
                                if (!(isDefined(parseInt(cx))))
1503
1503
 
                                    then throw(("Cannot parse land number from " + bW.name))
1504
1504
 
                                    else {
1505
1505
 
                                        let aW = toBase58String(aM)
1506
1506
 
                                        let gd = aO(aW)
1507
1507
 
                                        if (isDefined(getInteger(gd)))
1508
1508
 
                                            then throw((("NFT " + bW.name) + " is already staked"))
1509
1509
 
                                            else {
1510
1510
 
                                                let gg = split(bW.description, "_")
1511
1511
 
                                                let dx = dD(gg[X])
1512
1512
 
                                                let fS = bA(gg[W])
1513
1513
 
                                                let bG = dC(dx, (fS / o), 1)
1514
1514
 
                                                let fT = valueOrElse(getInteger(aQ(m, aW)), 0)
1515
1515
 
                                                let gX = aX(ap)
1516
1516
 
                                                let bT = getString(gX)
1517
1517
 
                                                let bU = if (isDefined(bT))
1518
1518
 
                                                    then split_51C(value(bT), "_")
1519
1519
 
                                                    else nil
1520
1520
 
                                                if (containsElement(bU, aW))
1521
1521
 
                                                    then throw(("Your staked lands already contain " + aW))
1522
1522
 
                                                    else {
1523
1523
 
                                                        let eC = valueOrElse(getInteger(aP(aW)), 0)
1524
-
[IntegerEntry(gd, lastBlock.timestamp), IntegerEntry(aS(k, aW, ap), lastBlock.timestamp), StringEntry(gX, makeString_11C((bU :+ aW), "_")), IntegerEntry(aY(ap), (valueOrElse(getInteger(aY(ap)), 0) + fS)), StringEntry(aL(aW), ap), StringEntry(cC(cx), ap), IntegerEntry(cB(m, aW, ap), fT), IntegerEntry(cA(aW, ap), eC), StringEntry(bj(), bG), hm]
1524
+
                                                        let hb = aY(ap)
1525
+
                                                        let hp = valueOrElse(getInteger(hb), 0)
1526
+
                                                        let hq = if ((hp == 0))
1527
+
                                                            then bv(invoke(aI, "onStakeLand", [ap], nil))
1528
+
                                                            else -1
1529
+
                                                        $Tuple2([IntegerEntry(gd, lastBlock.timestamp), IntegerEntry(aS(k, aW, ap), lastBlock.timestamp), StringEntry(gX, makeString_11C((bU :+ aW), "_")), IntegerEntry(hb, (hp + fS)), StringEntry(aL(aW), ap), StringEntry(cC(cx), ap), IntegerEntry(cB(m, aW, ap), fT), IntegerEntry(cA(aW, ap), eC), StringEntry(bj(), bG), hm], hq)
1525
1530
 
                                                        }
1526
1531
 
                                                }
1527
1532
 
                                        }
1528
1533
 
                                }
1529
1534
 
                    }
1530
1535
 
            }
1531
1536
 
    }
1532
1537
 
1533
1538
 
1534
1539
 
1535
1540
 
@Callable(dB)
1536
1541
 
func unstakeLand (fY) = {
1537
1542
 
    let hm = hj(dB)
1538
1543
 
    if ((size(dB.payments) != 0))
1539
1544
 
        then throw("No payments required")
1540
1545
 
        else {
1541
1546
 
            let aK = toString(dB.caller)
1542
1547
 
            let gi = fW(aK, cH, fY)
1543
1548
 
            let aW = gi._2
1544
1549
 
            let gX = aX(aK)
1545
1550
 
            let dx = dD(gi._3[X])
1546
1551
 
            let fS = bA(gi._3[W])
1547
1552
 
            let bG = dC(dx, (fS / o), -1)
1548
1553
 
            let gB = gu(aK, aW, fS, cH)
1549
1554
 
            let bU = split_51C(valueOrElse(getString(gX), ""), "_")
1550
1555
 
            let aD = indexOf(bU, aW)
1551
1556
 
            if (!(isDefined(aD)))
1552
1557
 
                then throw(("Your staked lands don't contain " + aW))
1553
1558
 
                else {
1554
1559
 
                    let eh = value(blockInfoByHeight(height)).timestamp
1555
-
                    let hp = valueOrElse(getInteger(aH, bl(aK)), 0)
1556
-
                    if ((hp >= eh))
1557
-
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hp)))
1560
+
                    let hr = valueOrElse(getInteger(aH, bl(aK)), 0)
1561
+
                    if ((hr >= eh))
1562
+
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hr)))
1558
1563
 
                        else {
1559
1564
 
                            let hb = aY(aK)
1560
1565
 
                            let hc = valueOrElse(getInteger(hb), 0)
1561
-
[ScriptTransfer(dB.caller, 1, fromBase58String(aW)), DeleteEntry(aO(aW)), DeleteEntry(aS(k, aW, aK)), StringEntry(bj(), bG), StringEntry(gB._2, makeString(gB._3, ":")), if ((size(bU) > 1))
1566
+
                            let hs = if ((fS > hc))
1567
+
                                then 0
1568
+
                                else (hc - fS)
1569
+
                            let hq = if ((hs == 0))
1570
+
                                then bv(invoke(aI, "onUnstakeLand", [aK], nil))
1571
+
                                else -1
1572
+
                            $Tuple2([ScriptTransfer(dB.caller, 1, fromBase58String(aW)), DeleteEntry(aO(aW)), DeleteEntry(aS(k, aW, aK)), StringEntry(bj(), bG), StringEntry(gB._2, makeString(gB._3, ":")), if ((size(bU) > 1))
1562
1573
 
                                then StringEntry(gX, makeString_11C(removeByIndex(bU, value(aD)), "_"))
1563
-
                                else DeleteEntry(gX), IntegerEntry(hb, if ((fS > hc))
1564
-
                                then 0
1565
-
                                else (hc - fS)), hm]
1574
+
                                else DeleteEntry(gX), IntegerEntry(hb, hs), hm], hq)
1566
1575
 
                            }
1567
1576
 
                    }
1568
1577
 
            }
1569
1578
 
    }
1570
1579
 
1571
1580
 
1572
1581
 
1573
1582
 
@Callable(dB)
1574
1583
 
func stakeDuck () = {
1575
1584
 
    let hm = hj(dB)
1576
1585
 
    if ((size(dB.payments) != 1))
1577
1586
 
        then throw("Exactly one payment required")
1578
1587
 
        else {
1579
1588
 
            let hn = value(dB.payments[0])
1580
1589
 
            let aM = value(hn.assetId)
1581
1590
 
            let ap = toString(dB.caller)
1582
1591
 
            if ((hn.amount != 1))
1583
1592
 
                then throw((("NFT " + l) + " token should be attached as payment"))
1584
1593
 
                else {
1585
1594
 
                    let bW = value(assetInfo(aM))
1586
1595
 
                    if (if ((bW.issuer != ce))
1587
1596
 
                        then (bW.issuer != cf)
1588
1597
 
                        else false)
1589
1598
 
                        then throw((("Unknown issuer of " + l) + " token"))
1590
1599
 
                        else if (!(contains(bW.name, l)))
1591
1600
 
                            then throw((("Only NFT " + l) + " tokens are accepted"))
1592
1601
 
                            else {
1593
-
                                let hq = toBase58String(aM)
1594
-
                                let gd = aO(hq)
1602
+
                                let ht = toBase58String(aM)
1603
+
                                let gd = aO(ht)
1595
1604
 
                                if (isDefined(getInteger(gd)))
1596
1605
 
                                    then throw((("NFT " + bW.name) + " is already staked"))
1597
1606
 
                                    else if (isDefined(getString(be(ap))))
1598
1607
 
                                        then throw(("You already staked one duck: " + bW.name))
1599
1608
 
                                        else {
1600
-
                                            let hr = bh(hq)
1601
-
                                            let hs = getString(hr)
1602
-
                                            let ej = bf(hq)
1603
-
                                            let ht = getString(ej)
1604
-
                                            ([IntegerEntry(gd, lastBlock.timestamp), IntegerEntry(aS(l, toBase58String(aM), ap), lastBlock.timestamp), StringEntry(bd(hq), ap), StringEntry(be(ap), hq)] ++ (if (isDefined(hs))
1609
+
                                            let hu = bh(ht)
1610
+
                                            let hv = getString(hu)
1611
+
                                            let ej = bf(ht)
1612
+
                                            let hw = getString(ej)
1613
+
                                            ([IntegerEntry(gd, lastBlock.timestamp), IntegerEntry(aS(l, toBase58String(aM), ap), lastBlock.timestamp), StringEntry(bd(ht), ap), StringEntry(be(ap), ht)] ++ (if (isDefined(hv))
1605
1614
 
                                                then nil
1606
-
                                                else ([StringEntry(hr, w)] ++ (if (isDefined(ht))
1615
+
                                                else ([StringEntry(hu, w)] ++ (if (isDefined(hw))
1607
1616
 
                                                    then nil
1608
-
                                                    else (([StringEntry(ej, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(bi(hq), 100)) :+ hm)))))
1617
+
                                                    else (([StringEntry(ej, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(bi(ht), 100)) :+ hm)))))
1609
1618
 
                                            }
1610
1619
 
                                }
1611
1620
 
                    }
1612
1621
 
            }
1613
1622
 
    }
1614
1623
 
1615
1624
 
1616
1625
 
1617
1626
 
@Callable(dB)
1618
-
func unstakeDuck (hq) = {
1627
+
func unstakeDuck (ht) = {
1619
1628
 
    let hm = hj(dB)
1620
1629
 
    if ((size(dB.payments) != 0))
1621
1630
 
        then throw("No payments required")
1622
1631
 
        else {
1623
-
            let aM = fromBase58String(hq)
1632
+
            let aM = fromBase58String(ht)
1624
1633
 
            let ap = toString(dB.caller)
1625
1634
 
            let bW = value(assetInfo(aM))
1626
1635
 
            let gd = aO(toBase58String(aM))
1627
1636
 
            if (!(isDefined(getInteger(gd))))
1628
1637
 
                then throw((("NFT " + bW.name) + " is not staked"))
1629
1638
 
                else if (!(isDefined(getString(be(ap)))))
1630
1639
 
                    then throw((("The duck " + bW.name) + " is not staked"))
1631
1640
 
                    else {
1632
1641
 
                        let gf = valueOrErrorMessage(getString(bd(toBase58String(aM))), (("NFT " + bW.name) + " is orphaned"))
1633
1642
 
                        if ((gf != ap))
1634
1643
 
                            then throw("Staked NFT is not yours")
1635
1644
 
                            else {
1636
-
                                let fI = bi(hq)
1637
-
                                let hu = valueOrElse(getInteger(fI), 100)
1638
-
                                if ((100 > hu))
1645
+
                                let fI = bi(ht)
1646
+
                                let hx = valueOrElse(getInteger(fI), 100)
1647
+
                                if ((100 > hx))
1639
1648
 
                                    then throw("Please heal your duck before unstaking")
1640
-
                                    else [ScriptTransfer(dB.caller, 1, aM), DeleteEntry(gd), DeleteEntry(fI), DeleteEntry(bh(hq)), DeleteEntry(bd(hq)), DeleteEntry(aS(l, hq, ap)), DeleteEntry(be(ap)), hm]
1649
+
                                    else [ScriptTransfer(dB.caller, 1, aM), DeleteEntry(gd), DeleteEntry(fI), DeleteEntry(bh(ht)), DeleteEntry(bd(ht)), DeleteEntry(aS(l, ht, ap)), DeleteEntry(be(ap)), hm]
1641
1650
 
                                }
1642
1651
 
                        }
1643
1652
 
            }
1644
1653
 
    }
1645
1654
 
1646
1655
 
1647
1656
 
1648
1657
 
@Callable(dB)
1649
-
func claimRes (eP,hv) = {
1658
+
func claimRes (eP,hy) = {
1650
1659
 
    let hm = hj(dB)
1651
1660
 
    if ((size(dB.payments) != 0))
1652
1661
 
        then throw("No payments required")
1653
1662
 
        else {
1654
1663
 
            let aK = toString(dB.originCaller)
1655
-
            let dh = gh(aK, eP, cH, hv)
1664
+
            let dh = gh(aK, eP, cH, hy)
1656
1665
 
            $Tuple2((((dh._1 :+ StringEntry(dh._2, makeString(dh._3, ":"))) :+ StringEntry(dh._4, makeString(dh._5, ":"))) :+ hm), dh._3[aj])
1657
1666
 
            }
1658
1667
 
    }
1659
1668
 
1660
1669
 
1661
1670
 
1662
1671
 
@Callable(dB)
1663
-
func claimResToWH (eP,hv) = {
1672
+
func claimResToWH (eP,hy) = {
1664
1673
 
    let hm = hj(dB)
1665
1674
 
    if ((size(dB.payments) != 0))
1666
1675
 
        then throw("No payments required")
1667
1676
 
        else {
1668
1677
 
            let aK = toString(dB.originCaller)
1669
-
            let dh = gh(aK, eP, cG, hv)
1678
+
            let dh = gh(aK, eP, cG, hy)
1670
1679
 
            $Tuple2((((dh._1 :+ StringEntry(dh._2, makeString(dh._3, ":"))) :+ StringEntry(dh._4, makeString(dh._5, ":"))) :+ hm), dh._5[aa])
1671
1680
 
            }
1672
1681
 
    }
1673
1682
 
1674
1683
 
1675
1684
 
1676
1685
 
@Callable(dB)
1677
1686
 
func flight (fx,fy) = {
1678
1687
 
    let hm = hj(dB)
1679
1688
 
    if ((size(dB.payments) != 0))
1680
1689
 
        then throw("No payments required")
1681
1690
 
        else {
1682
1691
 
            let bm = toString(dB.caller)
1683
1692
 
            let ef = fw(bm, fx, fy)
1684
-
            let hr = bh(ef._2)
1685
-
            let ga = valueOrElse(getString(hr), w)
1693
+
            let hu = bh(ef._2)
1694
+
            let ga = valueOrElse(getString(hu), w)
1686
1695
 
            if ((ef._4 == ga))
1687
1696
 
                then throw("You can't fly to the same location")
1688
1697
 
                else {
1689
1698
 
                    let ej = bf(ef._2)
1690
1699
 
                    let eS = ei(ej)
1691
1700
 
                    let du = di(eS[al], ef._5)
1692
-
                    $Tuple2([StringEntry(hr, if ((ef._1 > 0))
1701
+
                    $Tuple2([StringEntry(hu, if ((ef._1 > 0))
1693
1702
 
                        then ef._4
1694
1703
 
                        else ga), StringEntry(ej, makeString([eS[ai], eS[aj], eS[ak], du], ":")), IntegerEntry(bi(ef._2), ef._1), hm], ef._3)
1695
1704
 
                    }
1696
1705
 
            }
1697
1706
 
    }
1698
1707
 
1699
1708
 
1700
1709
 
1701
1710
 
@Callable(dB)
1702
-
func heal (hw,hx,hy) = {
1711
+
func heal (hz,hA,hB) = {
1703
1712
 
    let hm = hj(dB)
1704
-
    if (if (if ((0 > hw))
1713
+
    if (if (if ((0 > hz))
1705
1714
 
        then true
1706
-
        else (0 > hx))
1715
+
        else (0 > hA))
1707
1716
 
        then true
1708
-
        else (0 > hy))
1717
+
        else (0 > hB))
1709
1718
 
        then throw("Quantity cannot be negative")
1710
1719
 
        else {
1711
1720
 
            let bg = valueOrErrorMessage(getString(be(toString(dB.caller))), "You don't have a duck staked")
1712
-
            let hz = [hw, hx, hy]
1721
+
            let hC = [hz, hA, hB]
1713
1722
 
            let fI = bi(bg)
1714
-
            let hA = valueOrElse(getInteger(fI), 100)
1715
-
            if ((hA >= B))
1723
+
            let hD = valueOrElse(getInteger(fI), 100)
1724
+
            if ((hD >= B))
1716
1725
 
                then throw((("HP should be < " + toString(B)) + " to heal"))
1717
1726
 
                else {
1718
1727
 
                    let ej = bf(bg)
1719
1728
 
                    let eS = ei(ej)
1720
-
                    let hB = if ((eS[al] == ""))
1729
+
                    let hE = if ((eS[al] == ""))
1721
1730
 
                        then nil
1722
1731
 
                        else split(eS[al], "_")
1723
-
                    func hC (bI,hD) =                     {
1732
+
                    func hF (bI,hG) =                     {
1724
1733
 
                        let bw = bI._2
1725
-
                        let dW = if ((size(hB) > bw))
1726
-
                            then parseIntValue(hB[bw])
1734
+
                        let dW = if ((size(hE) > bw))
1735
+
                            then parseIntValue(hE[bw])
1727
1736
 
                            else 0
1728
1737
 
                        if ((3 > bw))
1729
1738
 
                            then {
1730
-
                                let hE = hz[bw]
1731
-
                                if ((hE > dW))
1739
+
                                let hH = hC[bw]
1740
+
                                if ((hH > dW))
1732
1741
 
                                    then throw(((("You have only " + toString(dW)) + " of ") + E[bw]))
1733
-
                                    else $Tuple3((bI._1 :+ toString((dW - hE))), (bw + 1), (bI._3 + (ch[bw] * hE)))
1742
+
                                    else $Tuple3((bI._1 :+ toString((dW - hH))), (bw + 1), (bI._3 + (ch[bw] * hH)))
1734
1743
 
                                }
1735
1744
 
                            else $Tuple3((bI._1 :+ toString(dW)), (bw + 1), bI._3)
1736
1745
 
                        }
1737
1746
 
1738
1747
 
                    let dh = {
1739
1748
 
                        let bL = G
1740
1749
 
                        let bM = size(bL)
1741
1750
 
                        let bN = $Tuple3(nil, 0, 0)
1742
1751
 
                        func bO (bP,bQ) =                         if ((bQ >= bM))
1743
1752
 
                            then bP
1744
-
                            else hC(bP, bL[bQ])
1753
+
                            else hF(bP, bL[bQ])
1745
1754
 
1746
1755
 
                        func bR (bP,bQ) =                         if ((bQ >= bM))
1747
1756
 
                            then bP
1748
1757
 
                            else throw("List size exceeds 50")
1749
1758
 
1750
1759
 
                        bR(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bN, 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)
1751
1760
 
                        }
1752
-
                    let hF = min([B, (hA + dh._3)])
1753
-
                    $Tuple2([IntegerEntry(fI, hF), StringEntry(ej, makeString_2C([eS[ai], eS[aj], eS[ak], makeString(dh._1, "_")], ":")), hm], hF)
1761
+
                    let hI = min([B, (hD + dh._3)])
1762
+
                    $Tuple2([IntegerEntry(fI, hI), StringEntry(ej, makeString_2C([eS[ai], eS[aj], eS[ak], makeString(dh._1, "_")], ":")), hm], hI)
1754
1763
 
                    }
1755
1764
 
            }
1756
1765
 
    }
1757
1766
 
1758
1767
 
1759
1768
 
1760
1769
 
@Callable(dB)
1761
1770
 
func healES () = {
1762
1771
 
    let hm = hj(dB)
1763
1772
 
    if ((size(dB.payments) != 1))
1764
1773
 
        then throw("Exactly one payment required")
1765
1774
 
        else {
1766
1775
 
            let hn = value(dB.payments[0])
1767
1776
 
            if ((hn.assetId != b))
1768
1777
 
                then throw("Allowed USDT payment only!")
1769
1778
 
                else {
1770
1779
 
                    let bg = valueOrErrorMessage(getString(be(toString(dB.caller))), "You don't have a duck staked")
1771
1780
 
                    let fI = bi(bg)
1772
-
                    let hA = valueOrElse(getInteger(fI), 100)
1773
-
                    if ((hA > 0))
1781
+
                    let hD = valueOrElse(getInteger(fI), 100)
1782
+
                    if ((hD > 0))
1774
1783
 
                        then throw("HP should be 0 to call Emergency Service")
1775
1784
 
                        else {
1776
1785
 
                            let ej = bf(bg)
1777
1786
 
                            let eS = ei(ej)
1778
-
                            let hB = if ((eS[al] == ""))
1787
+
                            let hE = if ((eS[al] == ""))
1779
1788
 
                                then nil
1780
1789
 
                                else split(eS[al], "_")
1781
-
                            let hG = if ((size(hB) > 0))
1782
-
                                then parseIntValue(hB[0])
1790
+
                            let hJ = if ((size(hE) > 0))
1791
+
                                then parseIntValue(hE[0])
1783
1792
 
                                else 0
1784
-
                            let hH = if ((size(hB) > 1))
1785
-
                                then parseIntValue(hB[1])
1793
+
                            let hK = if ((size(hE) > 1))
1794
+
                                then parseIntValue(hE[1])
1786
1795
 
                                else 0
1787
-
                            let hI = if ((size(hB) > 2))
1788
-
                                then parseIntValue(hB[2])
1796
+
                            let hL = if ((size(hE) > 2))
1797
+
                                then parseIntValue(hE[2])
1789
1798
 
                                else 0
1790
-
                            if (if (if ((hG > 0))
1799
+
                            if (if (if ((hJ > 0))
1791
1800
 
                                then true
1792
-
                                else (hH > 0))
1801
+
                                else (hK > 0))
1793
1802
 
                                then true
1794
-
                                else (hI > 0))
1803
+
                                else (hL > 0))
1795
1804
 
                                then throw("You have to use own Medical Kit")
1796
1805
 
                                else {
1797
-
                                    let hJ = getString(aG, bo())
1798
-
                                    let hK = if (isDefined(hJ))
1799
-
                                        then split(value(hJ), "_")
1806
+
                                    let hM = getString(aG, bo())
1807
+
                                    let hN = if (isDefined(hM))
1808
+
                                        then split(value(hM), "_")
1800
1809
 
                                        else nil
1801
-
                                    let hL = if ((size(hK) > 0))
1802
-
                                        then parseIntValue(hK[0])
1810
+
                                    let hO = if ((size(hN) > 0))
1811
+
                                        then parseIntValue(hN[0])
1803
1812
 
                                        else 0
1804
-
                                    if ((0 >= hL))
1813
+
                                    if ((0 >= hO))
1805
1814
 
                                        then throw("There are no Medical Kits L1 at Emergency Service storage")
1806
1815
 
                                        else {
1807
-
                                            let hF = (hA + ch[0])
1808
-
                                            let hM = makeString([toString((hL - 1)), removeByIndex(hK, 0)], "_")
1816
+
                                            let hI = (hD + ch[0])
1817
+
                                            let hP = makeString([toString((hO - 1)), removeByIndex(hN, 0)], "_")
1809
1818
 
                                            let ca = split(G[0], "_")
1810
-
                                            let hN = bZ(ca)
1811
-
                                            let hO = parseIntValue(ca[T])
1812
-
                                            let hP = fraction((hN * A), x, (10 * hO))
1813
-
                                            if ((hn.amount != hP))
1814
-
                                                then throw(("Payment attached should be " + toString(hP)))
1819
+
                                            let hQ = bZ(ca)
1820
+
                                            let hR = parseIntValue(ca[T])
1821
+
                                            let hS = fraction((hQ * A), x, (10 * hR))
1822
+
                                            if ((hn.amount != hS))
1823
+
                                                then throw(("Payment attached should be " + toString(hS)))
1815
1824
 
                                                else {
1816
-
                                                    let dh = bs(invoke(aG, "updateEsStorage", [hM], [AttachedPayment(b, hP)]))
1817
-
                                                    $Tuple2([IntegerEntry(fI, hF), hm], dh)
1825
+
                                                    let dh = bs(invoke(aG, "updateEsStorage", [hP], [AttachedPayment(b, hS)]))
1826
+
                                                    $Tuple2([IntegerEntry(fI, hI), hm], dh)
1818
1827
 
                                                    }
1819
1828
 
                                            }
1820
1829
 
                                    }
1821
1830
 
                            }
1822
1831
 
                    }
1823
1832
 
            }
1824
1833
 
    }
1825
1834
 
1826
1835
 
1827
1836
 
1828
1837
 
@Callable(dB)
1829
-
func updateBackpack (bg,hQ) = {
1838
+
func updateBackpack (bg,hT) = {
1830
1839
 
    let hm = hj(dB)
1831
1840
 
    if ((dB.caller != aG))
1832
1841
 
        then throw("permission denied")
1833
-
        else $Tuple2([StringEntry(bf(bg), hQ), hm], hQ)
1842
+
        else $Tuple2([StringEntry(bf(bg), hT), hm], hT)
1834
1843
 
    }
1835
1844
 
1836
1845
 
1837
1846
 
1838
1847
 
@Callable(dB)
1839
1848
 
func buySLand () = {
1840
1849
 
    let hm = hj(dB)
1841
1850
 
    if ((size(dB.payments) != 1))
1842
1851
 
        then throw("Exactly one payment required")
1843
1852
 
        else {
1844
1853
 
            let hn = value(dB.payments[0])
1845
1854
 
            if ((hn.assetId != b))
1846
1855
 
                then throw("Allowed USDT payment only!")
1847
1856
 
                else if ((hn.amount != cn))
1848
1857
 
                    then throw(("Payment attached should be " + toString(cn)))
1849
1858
 
                    else {
1850
1859
 
                        let dh = fo(dB.caller, dB.transactionId)
1851
1860
 
                        $Tuple2(((dh._1 :+ ScriptTransfer(aG, hn.amount, b)) :+ hm), dh._2._1)
1852
1861
 
                        }
1853
1862
 
            }
1854
1863
 
    }
1855
1864
 
1856
1865
 
1857
1866
 
1858
1867
 
@Callable(dB)
1859
1868
 
func expedition (fx,fy) = {
1860
1869
 
    let hm = hj(dB)
1861
1870
 
    if ((size(dB.payments) != 0))
1862
1871
 
        then throw("No payments required")
1863
1872
 
        else {
1864
1873
 
            let dh = fN(dB.caller, dB.transactionId, fx, fy)
1865
1874
 
            $Tuple2((dh._1 :+ hm), $Tuple2(dh._2, dh._3))
1866
1875
 
            }
1867
1876
 
    }
1868
1877
 
1869
1878
 
1870
1879
 
1871
1880
 
@Callable(dB)
1872
1881
 
func upgradeInfra (aW) = {
1873
1882
 
    let hm = hj(dB)
1874
1883
 
    if ((size(dB.payments) != 0))
1875
1884
 
        then throw("No payments required")
1876
1885
 
        else {
1877
1886
 
            let dh = gv(true, dB.caller, 0, aW)
1878
1887
 
            $Tuple2((dh._1 :+ hm), dh._2)
1879
1888
 
            }
1880
1889
 
    }
1881
1890
 
1882
1891
 
1883
1892
 
1884
1893
 
@Callable(dB)
1885
1894
 
func upgradeInfraUsdt (aW) = if ((dB.caller != this))
1886
1895
 
    then throw("Permission denied")
1887
1896
 
    else {
1888
1897
 
        let hm = hj(dB)
1889
1898
 
        if ((size(dB.payments) != 1))
1890
1899
 
            then throw("Exactly one payment required")
1891
1900
 
            else {
1892
1901
 
                let hn = value(dB.payments[0])
1893
1902
 
                if ((hn.assetId != b))
1894
1903
 
                    then throw("Allowed USDT payment only!")
1895
1904
 
                    else {
1896
1905
 
                        let dh = gv(false, dB.caller, hn.amount, aW)
1897
1906
 
                        $Tuple2(((dh._1 :+ ScriptTransfer(aG, hn.amount, b)) :+ hm), dh._2)
1898
1907
 
                        }
1899
1908
 
                }
1900
1909
 
        }
1901
1910
 
1902
1911
 
1903
1912
 
1904
1913
 
@Callable(dB)
1905
-
func activateArtifact (hR,aW) = {
1914
+
func activateArtifact (hU,aW) = {
1906
1915
 
    let hm = hj(dB)
1907
1916
 
    if ((size(dB.payments) != 0))
1908
1917
 
        then throw("No payments required")
1909
1918
 
        else {
1910
1919
 
            let dh = {
1911
-
                let c = hR
1920
+
                let c = hU
1912
1921
 
                if (("PRESALE" == c))
1913
1922
 
                    then gI(toString(dB.caller), aW)
1914
1923
 
                    else throw("Unknown artifact")
1915
1924
 
                }
1916
1925
 
            (dh :+ hm)
1917
1926
 
            }
1918
1927
 
    }
1919
1928
 
1920
1929
 
1921
1930
 
1922
1931
 
@Callable(dB)
1923
1932
 
func mergeLands (gN) = {
1924
1933
 
    let hm = hj(dB)
1925
1934
 
    if ((size(dB.payments) != 0))
1926
1935
 
        then throw("No payments required")
1927
1936
 
        else {
1928
1937
 
            let dh = hh(true, toString(dB.caller), 0, gN, dB.transactionId)
1929
1938
 
            $Tuple2((dh._1 :+ hm), dh._2)
1930
1939
 
            }
1931
1940
 
    }
1932
1941
 
1933
1942
 
1934
1943
 
1935
1944
 
@Callable(dB)
1936
1945
 
func mergeLandsUsdt (gN) = {
1937
1946
 
    let hm = hj(dB)
1938
1947
 
    if ((size(dB.payments) != 1))
1939
1948
 
        then throw("Exactly one payment required")
1940
1949
 
        else {
1941
1950
 
            let hn = value(dB.payments[0])
1942
1951
 
            if ((hn.assetId != b))
1943
1952
 
                then throw("Allowed USDT payment only!")
1944
1953
 
                else {
1945
1954
 
                    let dh = hh(false, toString(dB.caller), hn.amount, gN, dB.transactionId)
1946
1955
 
                    $Tuple2(((dh._1 :+ ScriptTransfer(aG, hn.amount, b)) :+ hm), dh._2)
1947
1956
 
                    }
1948
1957
 
            }
1949
1958
 
    }
1950
1959
 
1951
1960
 
1952
1961
 
1953
1962
 
@Callable(dB)
1954
-
func cargoExchange (hS,aW) = {
1963
+
func cargoExchange (hV,aW) = {
1955
1964
 
    let hm = hj(dB)
1956
1965
 
    if ((size(dB.payments) != 0))
1957
1966
 
        then throw("No payments required")
1958
1967
 
        else {
1959
-
            let eR = split_4C(hS, ":")
1968
+
            let eR = split_4C(hV, ":")
1960
1969
 
            let aK = toString(dB.originCaller)
1961
1970
 
            let bW = value(assetInfo(fromBase58String(aW)))
1962
1971
 
            let gd = aO(aW)
1963
1972
 
            if (!(isDefined(getInteger(gd))))
1964
1973
 
                then throw((bW.name + " is not staked"))
1965
1974
 
                else {
1966
1975
 
                    let gf = valueOrErrorMessage(getString(aL(aW)), (("NFT " + bW.name) + " is orphaned"))
1967
1976
 
                    if ((gf != aK))
1968
1977
 
                        then throw((k + " is not yours"))
1969
1978
 
                        else {
1970
1979
 
                            let eB = (bA(split(bW.description, "_")[W]) / o)
1971
1980
 
                            let eC = valueOrElse(getInteger(aP(aW)), 0)
1972
1981
 
                            let bg = valueOrErrorMessage(getString(be(aK)), "You don't have a duck staked")
1973
1982
 
                            let ga = valueOrElse(getString(bh(bg)), w)
1974
1983
 
                            let gb = split(value(ga), "_")
1975
1984
 
                            if ((gb[bq] != "L"))
1976
1985
 
                                then throw((("Duck location type is " + gb[bq]) + ", but should be L"))
1977
1986
 
                                else if ((gb[br] != aW))
1978
1987
 
                                    then throw(("Duck should be on the land " + aW))
1979
1988
 
                                    else {
1980
1989
 
                                        let eA = aV(aW)
1981
1990
 
                                        let eo = ez(eA, eB, eC)
1982
1991
 
                                        let ej = bf(bg)
1983
1992
 
                                        let eS = ei(ej)
1984
1993
 
                                        let dh = eQ(eR, eo, eS)
1985
1994
 
                                        let eI = split(eo[ad], "_")
1986
1995
 
                                        let gs = (parseIntValue(eI[af]) + dh._7)
1987
1996
 
                                        let gt = (parseIntValue(eI[ag]) - dh._7)
1988
1997
 
[StringEntry(ej, makeString_2C([eS[ai], dh._4, dh._5, dh._6], ":")), StringEntry(eA, makeString_2C([eo[Z], dh._1, dh._2, dh._3, makeString([eI[ae], toString(gs), toString(gt), eI[ah]], "_")], ":")), hm]
1989
1998
 
                                        }
1990
1999
 
                            }
1991
2000
 
                    }
1992
2001
 
            }
1993
2002
 
    }
1994
2003
 
1995
2004
 
1996
2005
 
1997
2006
 
@Callable(dB)
1998
2007
 
func saveWarehouse (eE,aW) = {
1999
2008
 
    let hm = hj(dB)
2000
2009
 
    if ((dB.caller != aG))
2001
2010
 
        then throw("Access denied")
2002
2011
 
        else {
2003
2012
 
            let eA = aV(aW)
2004
2013
 
            let eF = split_4C(eE, ":")
2005
2014
 
            if ((size(eF) != 5))
2006
2015
 
                then throw("warehouse string should contain 4 ':' separators")
2007
2016
 
                else {
2008
-
                    let hT = split(eF[ad], "_")[ae]
2017
+
                    let hW = split(eF[ad], "_")[ae]
2009
2018
 
                    let gs = en(eF)
2010
-
                    let hU = el(eF[Z])
2011
-
                    let gt = ((hU - parseIntValue(hT)) - gs)
2012
-
                    let hV = makeString_2C([eF[Z], eF[aa], eF[ab], eF[ac], makeString([hT, toString(gs), toString(gt), toString(hU)], "_")], ":")
2013
-
                    $Tuple2([StringEntry(eA, hV), hm], hV)
2019
+
                    let hX = el(eF[Z])
2020
+
                    let gt = ((hX - parseIntValue(hW)) - gs)
2021
+
                    let hY = makeString_2C([eF[Z], eF[aa], eF[ab], eF[ac], makeString([hW, toString(gs), toString(gt), toString(hX)], "_")], ":")
2022
+
                    $Tuple2([StringEntry(eA, hY), hm], hY)
2014
2023
 
                    }
2015
2024
 
            }
2016
2025
 
    }
2017
2026
 
2018
2027
 
2019
2028
 
2020
2029
 
@Callable(dB)
2021
2030
 
func fixWarehouseFormat (aW) = if ((dB.caller != aE))
2022
2031
 
    then throw("Access denied")
2023
2032
 
    else {
2024
2033
 
        let eA = aV(aW)
2025
2034
 
        let bW = value(assetInfo(fromBase58String(aW)))
2026
2035
 
        let eB = (bA(split(bW.description, "_")[W]) / o)
2027
2036
 
        let eC = valueOrElse(getInteger(aP(aW)), 0)
2028
2037
 
        let eF = ez(eA, eB, eC)
2029
-
        let hT = bv(invoke(aG, "recalcLockedVolumeREADONLY", [aW, eF], nil))
2038
+
        let hW = bv(invoke(aG, "recalcLockedVolumeREADONLY", [aW, eF], nil))
2030
2039
 
        let gs = en(eF)
2031
-
        let hU = el(eF[Z])
2032
-
        let gt = ((hU - hT) - gs)
2033
-
        let hV = makeString_2C([eF[Z], eF[aa], eF[ab], eF[ac], makeString([toString(hT), toString(gs), toString(gt), toString(hU)], "_")], ":")
2034
-
        $Tuple2([StringEntry(eA, hV)], hV)
2040
+
        let hX = el(eF[Z])
2041
+
        let gt = ((hX - hW) - gs)
2042
+
        let hY = makeString_2C([eF[Z], eF[aa], eF[ab], eF[ac], makeString([toString(hW), toString(gs), toString(gt), toString(hX)], "_")], ":")
2043
+
        $Tuple2([StringEntry(eA, hY)], hY)
2035
2044
 
        }
2036
2045
 
2037
2046
 
2038
2047
 
2039
2048
 
@Callable(dB)
2040
2049
 
func fixStakedPieces (ap) = if ((dB.caller != aE))
2041
2050
 
    then throw("Access denied")
2042
2051
 
    else {
2043
2052
 
        let hc = if ((ap == ""))
2044
2053
 
            then 0
2045
2054
 
            else {
2046
2055
 
                let bT = getString(aF, aX(ap))
2047
2056
 
                let bU = if (isDefined(bT))
2048
2057
 
                    then split_51C(value(bT), "_")
2049
2058
 
                    else nil
2050
2059
 
                func bV (bI,aW) =                 {
2051
2060
 
                    let bW = value(assetInfo(fromBase58String(aW)))
2052
2061
 
                    let bB = split(bW.description, "_")[W]
2053
2062
 
                    (bI + bA(bB))
2054
2063
 
                    }
2055
2064
 
2056
2065
 
                let bL = bU
2057
2066
 
                let bM = size(bL)
2058
2067
 
                let bN = 0
2059
2068
 
                func bO (bP,bQ) =                 if ((bQ >= bM))
2060
2069
 
                    then bP
2061
2070
 
                    else bV(bP, bL[bQ])
2062
2071
 
2063
2072
 
                func bR (bP,bQ) =                 if ((bQ >= bM))
2064
2073
 
                    then bP
2065
2074
 
                    else throw("List size exceeds 100")
2066
2075
 
2067
2076
 
                bR(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bO(bN, 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)
2068
2077
 
                }
2069
2078
 
        $Tuple2([IntegerEntry(aY(ap), hc)], hc)
2070
2079
 
        }
2071
2080
 
2072
2081
 
2073
2082
 
2074
2083
 
@Callable(dB)
2075
2084
 
func setCustomName (aM,gV,aR) = {
2076
2085
 
    let hm = hj(dB)
2077
2086
 
    if ((size(dB.payments) != 1))
2078
2087
 
        then throw("Exactly one payment required")
2079
2088
 
        else {
2080
2089
 
            let hn = value(dB.payments[0])
2081
2090
 
            if ((hn.assetId != b))
2082
2091
 
                then throw("Allowed USDT payment only!")
2083
2092
 
                else if ((hn.amount != cj))
2084
2093
 
                    then throw(("Payment should be " + toString(cj)))
2085
2094
 
                    else if (contains(gV, "__"))
2086
2095
 
                        then throw(("Name should not contain '__': " + gV))
2087
2096
 
                        else if ((size(gV) > ck))
2088
2097
 
                            then throw(("Name too long, maxLength=" + toString(ck)))
2089
2098
 
                            else {
2090
2099
 
                                let aK = toString(dB.originCaller)
2091
-
                                let hW = {
2100
+
                                let hZ = {
2092
2101
 
                                    let c = aR
2093
2102
 
                                    if (("ACCOUNT" == c))
2094
2103
 
                                        then {
2095
-
                                            let hX = cE(gV)
2096
-
                                            let hY = getString(hX)
2097
-
                                            if (isDefined(hY))
2104
+
                                            let ia = cE(gV)
2105
+
                                            let ib = getString(ia)
2106
+
                                            if (isDefined(ib))
2098
2107
 
                                                then throw(("Name already registered: " + gV))
2099
2108
 
                                                else {
2100
-
                                                    let hZ = ba(aK)
2101
-
                                                    let ia = getString(hZ)
2102
-
                                                    let ib = if (isDefined(ia))
2103
-
                                                        then [DeleteEntry(cE(value(ia)))]
2109
+
                                                    let ic = ba(aK)
2110
+
                                                    let id = getString(ic)
2111
+
                                                    let ie = if (isDefined(id))
2112
+
                                                        then [DeleteEntry(cE(value(id)))]
2104
2113
 
                                                        else nil
2105
-
                                                    ((ib :+ StringEntry(hZ, gV)) :+ StringEntry(hX, aK))
2114
+
                                                    ((ie :+ StringEntry(ic, gV)) :+ StringEntry(ia, aK))
2106
2115
 
                                                    }
2107
2116
 
                                            }
2108
2117
 
                                        else if (("LAND" == c))
2109
2118
 
                                            then {
2110
2119
 
                                                let bW = value(assetInfo(fromBase58String(aM)))
2111
2120
 
                                                let gd = aO(aM)
2112
2121
 
                                                if (!(isDefined(getInteger(gd))))
2113
2122
 
                                                    then throw((bW.name + " is not staked"))
2114
2123
 
                                                    else {
2115
2124
 
                                                        let gf = valueOrErrorMessage(getString(aL(aM)), (("NFT " + bW.name) + " is orphaned"))
2116
2125
 
                                                        if ((gf != aK))
2117
2126
 
                                                            then throw((k + " is not yours"))
2118
2127
 
                                                            else {
2119
-
                                                                let hX = cy(gV)
2120
-
                                                                let hY = getString(hX)
2121
-
                                                                if (isDefined(hY))
2128
+
                                                                let ia = cy(gV)
2129
+
                                                                let ib = getString(ia)
2130
+
                                                                if (isDefined(ib))
2122
2131
 
                                                                    then throw(("Name already registered: " + gV))
2123
2132
 
                                                                    else {
2124
-
                                                                        let ic = aN(aM)
2125
-
                                                                        let ia = getString(ic)
2126
-
                                                                        let ib = if (isDefined(ia))
2127
-
                                                                            then [DeleteEntry(cy(value(ia)))]
2133
+
                                                                        let if = aN(aM)
2134
+
                                                                        let id = getString(if)
2135
+
                                                                        let ie = if (isDefined(id))
2136
+
                                                                            then [DeleteEntry(cy(value(id)))]
2128
2137
 
                                                                            else nil
2129
-
                                                                        ((ib :+ StringEntry(ic, gV)) :+ StringEntry(hX, aM))
2138
+
                                                                        ((ie :+ StringEntry(if, gV)) :+ StringEntry(ia, aM))
2130
2139
 
                                                                        }
2131
2140
 
                                                                }
2132
2141
 
                                                        }
2133
2142
 
                                                }
2134
2143
 
                                            else if (("DUCK" == c))
2135
2144
 
                                                then {
2136
2145
 
                                                    let bW = value(assetInfo(fromBase58String(aM)))
2137
2146
 
                                                    let gd = aO(aM)
2138
2147
 
                                                    if (if (!(isDefined(getInteger(gd))))
2139
2148
 
                                                        then true
2140
2149
 
                                                        else !(isDefined(getString(be(aK)))))
2141
2150
 
                                                        then throw((bW.name + " is not staked"))
2142
2151
 
                                                        else {
2143
2152
 
                                                            let gf = valueOrErrorMessage(getString(bd(aM)), (("NFT " + bW.name) + " is orphaned"))
2144
2153
 
                                                            if ((gf != aK))
2145
2154
 
                                                                then throw((l + " is not yours"))
2146
2155
 
                                                                else {
2147
-
                                                                    let hX = cD(gV)
2148
-
                                                                    let hY = getString(hX)
2149
-
                                                                    if (isDefined(hY))
2156
+
                                                                    let ia = cD(gV)
2157
+
                                                                    let ib = getString(ia)
2158
+
                                                                    if (isDefined(ib))
2150
2159
 
                                                                        then throw(("Name already registered: " + gV))
2151
2160
 
                                                                        else {
2152
-
                                                                            let ic = aZ(aM)
2153
-
                                                                            let ia = getString(ic)
2154
-
                                                                            let ib = if (isDefined(ia))
2155
-
                                                                                then [DeleteEntry(cD(value(ia)))]
2161
+
                                                                            let if = aZ(aM)
2162
+
                                                                            let id = getString(if)
2163
+
                                                                            let ie = if (isDefined(id))
2164
+
                                                                                then [DeleteEntry(cD(value(id)))]
2156
2165
 
                                                                                else nil
2157
-
                                                                            ((ib :+ StringEntry(ic, gV)) :+ StringEntry(hX, aM))
2166
+
                                                                            ((ie :+ StringEntry(if, gV)) :+ StringEntry(ia, aM))
2158
2167
 
                                                                            }
2159
2168
 
                                                                    }
2160
2169
 
                                                            }
2161
2170
 
                                                    }
2162
2171
 
                                                else throw("Unknown entity type")
2163
2172
 
                                    }
2164
-
                                $Tuple2(((hW :+ ScriptTransfer(aG, hn.amount, b)) :+ hm), 0)
2173
+
                                $Tuple2(((hZ :+ ScriptTransfer(aG, hn.amount, b)) :+ hm), 0)
2165
2174
 
                                }
2166
2175
 
            }
2167
2176
 
    }
2168
2177
 
2169
2178
 
2170
2179
 
2171
2180
 
@Callable(dB)
2172
-
func setReferrals (id,ie) = if ((dB.callerPublicKey != cg))
2181
+
func setReferrals (ig,ih) = if ((dB.callerPublicKey != cg))
2173
2182
 
    then throw("Permission denied")
2174
2183
 
    else {
2175
2184
 
        let hm = hj(dB)
2176
2185
 
        if ((size(dB.payments) != 0))
2177
2186
 
            then throw("No payments required")
2178
-
            else if (!(isDefined(addressFromString(id))))
2179
-
                then throw(("Invalid address: " + id))
2180
-
                else if (!(isDefined(addressFromString(ie))))
2181
-
                    then throw(("Invalid address: " + ie))
2187
+
            else if (!(isDefined(addressFromString(ig))))
2188
+
                then throw(("Invalid address: " + ig))
2189
+
                else if (!(isDefined(addressFromString(ih))))
2190
+
                    then throw(("Invalid address: " + ih))
2182
2191
 
                    else {
2183
-
                        let if = cF()
2184
-
                        let ig = getString(if)
2185
-
                        let ih = if (isDefined(ig))
2186
-
                            then split_4C(value(ig), "_")
2192
+
                        let ii = cF()
2193
+
                        let ij = getString(ii)
2194
+
                        let ik = if (isDefined(ij))
2195
+
                            then split_4C(value(ij), "_")
2187
2196
 
                            else nil
2188
-
                        if (containsElement(ih, ie))
2189
-
                            then throw((ie + " is not newbie (already has referrals)"))
2197
+
                        if (containsElement(ik, ih))
2198
+
                            then throw((ih + " is not newbie (already has referrals)"))
2190
2199
 
                            else {
2191
-
                                let ii = bb(ie)
2192
-
                                let ij = getString(ii)
2193
-
                                if (if (isDefined(ij))
2194
-
                                    then isDefined(addressFromString(value(ij)))
2200
+
                                let il = bb(ih)
2201
+
                                let im = getString(il)
2202
+
                                if (if (isDefined(im))
2203
+
                                    then isDefined(addressFromString(value(im)))
2195
2204
 
                                    else false)
2196
-
                                    then throw(((ie + " already has refBy: ") + value(ij)))
2205
+
                                    then throw(((ih + " already has refBy: ") + value(im)))
2197
2206
 
                                    else {
2198
-
                                        let ik = bc(id)
2199
-
                                        let il = getString(ik)
2200
-
                                        let im = if (isDefined(il))
2201
-
                                            then split_4C(value(il), "_")
2207
+
                                        let in = bc(ig)
2208
+
                                        let io = getString(in)
2209
+
                                        let ip = if (isDefined(io))
2210
+
                                            then split_4C(value(io), "_")
2202
2211
 
                                            else nil
2203
-
                                        if (containsElement(im, ie))
2204
-
                                            then throw((((id + " already contains ") + ie) + " within referrals"))
2212
+
                                        if (containsElement(ip, ih))
2213
+
                                            then throw((((ig + " already contains ") + ih) + " within referrals"))
2205
2214
 
                                            else {
2206
-
                                                let in = makeString_2C((im :+ ie), "_")
2207
-
                                                let io = if (containsElement(ih, id))
2208
-
                                                    then value(ig)
2209
-
                                                    else makeString_2C((ih :+ id), "_")
2210
-
                                                $Tuple2([StringEntry(ii, id), StringEntry(ik, in), StringEntry(if, io), hm], 0)
2215
+
                                                let iq = makeString_2C((ip :+ ih), "_")
2216
+
                                                let ir = if (containsElement(ik, ig))
2217
+
                                                    then value(ij)
2218
+
                                                    else makeString_2C((ik :+ ig), "_")
2219
+
                                                $Tuple2([StringEntry(il, ig), StringEntry(in, iq), StringEntry(ii, ir), hm], 0)
2211
2220
 
                                                }
2212
2221
 
                                        }
2213
2222
 
                                }
2214
2223
 
                        }
2215
2224
 
        }
2216
2225
 
2217
2226
 
2218
2227
 
2219
2228
 
@Callable(dB)
2220
2229
 
func splitByGlobalWeightsREADONLY (eP) = $Tuple2(nil, cZ(eP))
2221
2230
 
2222
2231
 
2223
2232
 
2224
2233
 
@Callable(dB)
2225
-
func splitByGlobalAndLocalWeightsREADONLY (ip,iq,dE) = {
2234
+
func splitByGlobalAndLocalWeightsREADONLY (is,it,dE) = {
2226
2235
 
    let dx = dD(dE)
2227
-
    $Tuple2(nil, $Tuple2(cZ(ip), cS(iq, dx)))
2236
+
    $Tuple2(nil, $Tuple2(cZ(is), cS(it, dx)))
2228
2237
 
    }
2229
2238
 
2230
2239
 
2231
2240
 
2232
2241
 
@Callable(dB)
2233
2242
 
func getBackpackREADONLY (bg) = $Tuple2(nil, makeString(ei(bf(bg)), ":"))
2234
2243
 
2235
2244
 
2236
2245
 
2237
2246
 
@Callable(dB)
2238
2247
 
func getWarehouseREADONLY (aW) = {
2239
2248
 
    let bW = value(assetInfo(fromBase58String(aW)))
2240
2249
 
    let eB = (bA(split(bW.description, "_")[W]) / o)
2241
2250
 
    let eC = valueOrElse(getInteger(aP(aW)), 0)
2242
2251
 
    $Tuple2(nil, makeString_2C(ez(aV(aW), eB, eC), ":"))
2243
2252
 
    }
2244
2253
 
2245
2254
 
2246
2255
 
2247
2256
 
@Callable(dB)
2248
2257
 
func saveLastTx () = if ((dB.caller != aI))
2249
2258
 
    then throw("Access denied")
2250
2259
 
    else $Tuple2([hj(dB)], 42)
2251
2260
 
2252
2261