tx · 93nT4XMn6yUeFjoenyCCLCYHP5vNKtAW2NU6cesUwC5V

3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy:  -0.04700000 Waves

2023.11.14 16:58 [2843110] smart account 3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "93nT4XMn6yUeFjoenyCCLCYHP5vNKtAW2NU6cesUwC5V",
    "fee": 4700000,
    "feeAssetId": null,
    "timestamp": 1699970349801,
    "version": 2,
    "chainId": 84,
    "sender": "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy",
    "senderPublicKey": "C3PaRKeL8AUKbwUqdniMQtThgcTh5DYHV1777Hkxy7rp",
    "proofs": [
        "em3HZARge8YzzuVjVqZzYG6rAa1v6o4v7q3RmgMF9r6xgRt4RbZpL7s7hrQnV2zER6Gubnpr2gKo7LSzaeHkj9s"
    ],
    "script": "base64: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",
    "height": 2843110,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3otF6yM9q5kaCQo3hgJTSPKkMHb12Bjs8Ubc8BZFbbtw
Next: 8P1pEmSQqoJ92cFs3UFAwVwkgSo5Yi7fuxCRdpb8p4xK

Diff: 
Old
New
Differences
326
326
 
327
327
 
let cx = 10000000
328
328
 
329
-
let cy = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_011", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_10_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_20_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_30_0,0,0,0,0,0,0_201", "4_13_22_4_35_22_23_0_50,1,0_0,0,0,0,0,0,0_", "4_13_22_4_35_22_46_0_50,1,1_0,2,5,0,0,0,0_", "4_13_22_4_35_22_69_0_50,2,1_0,5,10,0,0,0,0_", "5_25_40_5_10_15_20_1_30,1,1_0,0,0,0,0,0,0_", "5_25_40_5_10_15_40_1_30,1,2_2,1,3,0,0,0,0_", "5_25_40_5_10_15_60_1_30,1,3_5,2,8,0,0,0,0_"]
329
+
let cy = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_011", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_10_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_20_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_30_0,0,0,0,0,0,0_201", "4_13_22_4_35_22_23_0_50,1,0_0,0,0,0,0,0,0_", "4_13_22_4_35_22_46_0_50,1,1_0,2,5,0,0,0,0_", "4_13_22_4_35_22_69_0_50,2,1_0,5,10,0,0,0,0_", "5_25_40_5_10_15_20_1_30,1,1_0,0,0,0,0,0,0_", "5_25_40_5_10_15_40_1_30,1,2_2,1,3,0,0,0,0_", "5_25_40_5_10_15_60_1_30,1,3_5,2,8,0,0,0,0_", "23_23_5_20_23_6_35_2_0_0,0,0,0,0,0,0_", "23_23_5_20_23_6_70_2_0_0,0,0,0,0,0,0_", "23_23_5_20_23_6_105_2_0_0,0,0,0,0,0,0_"]
330
330
 
331
331
 
let cz = 6
332
332
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let a = 1000000
5
5
 
6
6
 
let b = 100000000
7
7
 
8
8
 
let c = 100000000000000
9
9
 
10
10
 
let d = 100000
11
11
 
12
12
 
let e = 200000
13
13
 
14
14
 
let f = 100000
15
15
 
16
16
 
let g = 400000
17
17
 
18
18
 
let h = 31557600000
19
19
 
20
20
 
let i = 86400000
21
21
 
22
22
 
let j = "marketingAddr"
23
23
 
24
24
 
let k = "teamAddr"
25
25
 
26
26
 
let l = "lastClaimedTime_marketing"
27
27
 
28
28
 
let m = "marketingAmountLeft"
29
29
 
30
30
 
let n = "lastClaimedTime_team"
31
31
 
32
32
 
let o = "teamAmountLeft"
33
33
 
34
34
 
let p = "lastClaimedTime_activities"
35
35
 
36
36
 
let q = "activitiesAmountLeft"
37
37
 
38
38
 
let r = "stakersAmountLeft"
39
39
 
40
40
 
func s (t) = ("lastClaimedTimeUser_" + t)
41
41
 
42
42
 
43
43
 
func u (v) = fraction(c, (g * (v + 1)), (6 * a))
44
44
 
45
45
 
46
46
 
let w = "wlg_issueTime"
47
47
 
48
48
 
let x = "wlg_issuedAmount"
49
49
 
50
50
 
let y = "zbill_issuedAmount"
51
51
 
52
52
 
func z (t) = ("acresStakedAmountByUser_" + t)
53
53
 
54
54
 
55
55
 
func A (t) = ("acresLockedAmountByUser_" + t)
56
56
 
57
57
 
58
58
 
func B (t) = ("acresLockedEtaByUser_" + t)
59
59
 
60
60
 
61
61
 
let C = "acresStakedAmountTotal"
62
62
 
63
63
 
func D (t) = ("wlgStakedAmountByUser_" + t)
64
64
 
65
65
 
66
66
 
let E = 0
67
67
 
68
68
 
let F = 1
69
69
 
70
70
 
let G = 2
71
71
 
72
72
 
let H = 3
73
73
 
74
74
 
let I = 4
75
75
 
76
76
 
let J = 5
77
77
 
78
78
 
let K = 6
79
79
 
80
80
 
func L (M,N,O) = {
81
81
 
    let P = split(valueOrElse(getString(N, "resTypesProportions"), "0_0_0_0_0_0"), "_")
82
82
 
    func Q (R,S) =     (R + parseIntValue(S))
83
83
 
84
84
 
    let T = {
85
85
 
        let U = P
86
86
 
        let V = size(U)
87
87
 
        let W = 0
88
88
 
        func X (Y,Z) =         if ((Z >= V))
89
89
 
            then Y
90
90
 
            else Q(Y, U[Z])
91
91
 
92
92
 
        func aa (Y,Z) =         if ((Z >= V))
93
93
 
            then Y
94
94
 
            else throw("List size exceeds 6")
95
95
 
96
96
 
        aa(X(X(X(X(X(X(W, 0), 1), 2), 3), 4), 5), 6)
97
97
 
        }
98
98
 
    let ab = valueOrElse(getInteger(N, ("stakedPiecesByOwner_" + M)), 0)
99
99
 
    let ac = valueOrElse(getInteger(O, C), 0)
100
100
 
    let ad = valueOrElse(getInteger(O, z(M)), 0)
101
101
 
[T, ab, ac, ad]
102
102
 
    }
103
103
 
104
104
 
105
105
 
let ae = 0
106
106
 
107
107
 
let af = 1
108
108
 
109
109
 
let ag = 2
110
110
 
111
111
 
let ah = 3
112
112
 
113
113
 
func ai (aj,ak,al,am,an) = {
114
114
 
    let ao = valueOrErrorMessage(getInteger(ak[H], x), "WLGOLD is not issued yet")
115
115
 
    let ap = assetBalance(ak[G], al)
116
116
 
    let aq = assetBalance(ak[E], al)
117
117
 
    let ar = (assetBalance(ak[H], al) - am)
118
118
 
    let as = assetBalance(ak[I], al)
119
119
 
    let at = ak[J]
120
120
 
    let au = (assetBalance(at, al) + valueOrElse(getInteger(at, y), 0))
121
121
 
    let av = ((ap + ar) + au)
122
122
 
    let aw = valueOrErrorMessage(getBinary(ak[H], "wlg_assetId"), "Not initialized yet")
123
123
 
    let ax = lastBlock.timestamp
124
124
 
    let ay = valueOrErrorMessage(getInteger(ak[H], w), "Not initialized")
125
125
 
    let az = fraction(c, d, a)
126
126
 
    let aA = valueOrElse(getInteger(ak[H], m), az)
127
127
 
    let aB = valueOrElse(getInteger(ak[H], l), ay)
128
128
 
    let aC = addressFromStringValue(value(getString(ak[H], j)))
129
129
 
    let aD = min([fraction(az, (ax - aB), h), aA])
130
130
 
    let aE = assetBalance(aC, aw)
131
131
 
    let aF = fraction(c, e, a)
132
132
 
    let aG = valueOrElse(getInteger(ak[H], o), aF)
133
133
 
    let aH = valueOrElse(getInteger(ak[H], n), ay)
134
134
 
    let aI = addressFromStringValue(value(getString(ak[H], k)))
135
135
 
    let aJ = min([fraction(aF, (ax - aH), (3 * h)), aG])
136
136
 
    let aK = assetBalance(aI, aw)
137
137
 
    let aL = fraction(c, f, a)
138
138
 
    let aM = valueOrElse(getInteger(ak[H], q), aL)
139
139
 
    let aN = valueOrElse(getInteger(ak[H], p), ay)
140
140
 
    let aO = min([fraction(aL, (ax - aN), (3 * h)), aM])
141
141
 
    let aP = assetBalance(ak[E], aw)
142
142
 
    let aQ = valueOrElse(getInteger(ak[H], s(aj)), ay)
143
143
 
    let aR = ((aQ - ay) / h)
144
144
 
    let aS = min([ax, (ay + (3 * h))])
145
145
 
    let aT = min([((ax - ay) / h), 2])
146
146
 
    let aU = L(aj, ak[F], ak[K])
147
147
 
    let aV = u(aT)
148
148
 
    let aW = if ((aR == aT))
149
149
 
        then {
150
150
 
            let aX = fraction(aV, (aS - aQ), h)
151
151
 
            let aY = fraction(aX, an, a)
152
152
 
            let aZ = (aQ + fraction((aS - aQ), an, a))
153
153
 
            $Tuple3(aY, aX, aZ)
154
154
 
            }
155
155
 
        else if ((aR == (aT - 1)))
156
156
 
            then {
157
157
 
                let ba = fraction(u((aT - 1)), ((ay + (h * aT)) - aQ), h)
158
158
 
                let aX = fraction(aV, (aS - (ay + (h * aT))), h)
159
159
 
                let bb = (ba + aX)
160
160
 
                let aY = fraction(bb, an, a)
161
161
 
                let aZ = if ((ba >= aY))
162
162
 
                    then (aQ + fraction(h, aY, u((aT - 1))))
163
163
 
                    else ((ay + (h * aT)) + fraction(h, (aY - ba), aV))
164
164
 
                $Tuple3(aY, bb, aZ)
165
165
 
                }
166
166
 
            else {
167
167
 
                let bc = fraction(u((aT - 2)), ((ay + (h * (aT - 1))) - aQ), h)
168
168
 
                let ba = u((aT - 1))
169
169
 
                let aX = fraction(aV, (aS - (ay + (h * aT))), h)
170
170
 
                let bb = ((bc + ba) + aX)
171
171
 
                let aY = fraction(bb, an, a)
172
172
 
                let aZ = if ((bc >= aY))
173
173
 
                    then (aQ + fraction(h, aY, u((aT - 2))))
174
174
 
                    else if (((bc + ba) >= aY))
175
175
 
                        then ((ay + (h * (aT - 1))) + fraction(h, (aY - bc), u((aT - 1))))
176
176
 
                        else ((ay + (h * aT)) + fraction(h, ((aY - bc) - ba), aV))
177
177
 
                $Tuple3(aY, bb, aZ)
178
178
 
                }
179
179
 
    let bd = aW._1
180
180
 
    let be = aW._2
181
181
 
    let bf = aW._3
182
182
 
    let bg = fraction(fraction(aV, i, h), 25, aU[ae])
183
183
 
    let bh = valueOrElse(getInteger(ak[H], r), 0)
184
184
 
    let bi = fraction(bd, ((aU[af] * b) + aU[ah]), ((aU[ae] * b) + aU[ag]))
185
185
 
    let bj = fraction(be, ((aU[af] * b) + aU[ah]), ((aU[ae] * b) + aU[ag]))
186
186
 
[ao, fraction(av, b, ao), av, ap, aq, ar, as, ay, aB, az, aA, aD, aE, aF, aG, aJ, aK, aL, aM, aO, aP, aT, bh, aV, aQ, bi, bg, au, bj, bf]
187
187
 
    }
188
188
 
189
189
 
190
190
 
let bk = 100000000
191
191
 
192
192
 
let bl = 100000000
193
193
 
194
194
 
let bm = 400
195
195
 
196
196
 
let bn = 2
197
197
 
198
198
 
let bo = 3
199
199
 
200
200
 
let bp = 4
201
201
 
202
202
 
let bq = 1
203
203
 
204
204
 
let br = 2
205
205
 
206
206
 
let bs = ["free", "locked", "afterLockCooldown", "robbedCooldown", "defendedCooldown"]
207
207
 
208
208
 
let bt = ["free", "preparingRob"]
209
209
 
210
210
 
func bu (bv) = ("duckHealth_" + bv)
211
211
 
212
212
 
213
213
 
func bw (bv) = ("duckChars_" + bv)
214
214
 
215
215
 
216
216
 
func bx (bv) = ("duckXP_" + bv)
217
217
 
218
218
 
219
219
 
func by (bv) = ("duckLevel_" + bv)
220
220
 
221
221
 
222
222
 
func bz (bv) = ("duckFreePoints_" + bv)
223
223
 
224
224
 
225
225
 
func bA (bv) = ("duckEquipment_" + bv)
226
226
 
227
227
 
228
228
 
func bB (t) = ("userXP_" + t)
229
229
 
230
230
 
231
231
 
func bC (t) = ("userLevel_" + t)
232
232
 
233
233
 
234
234
 
func bD (t) = ("userFreePoints_" + t)
235
235
 
236
236
 
237
237
 
func bE (bv) = ("duckBuffs_" + bv)
238
238
 
239
239
 
240
240
 
func bF (bv) = ("lastRobberyTime_" + bv)
241
241
 
242
242
 
243
243
 
func bG (bv) = ("lastRobberyCost_" + bv)
244
244
 
245
245
 
246
246
 
func bH (bI) = ("landRobberyState_" + bI)
247
247
 
248
248
 
249
249
 
func bJ (bI) = ("landCooldownETA_" + bI)
250
250
 
251
251
 
252
252
 
func bK (bv) = ("duckRobberyState_" + bv)
253
253
 
254
254
 
255
255
 
func bL (bv) = ("lockedLandByDuck_" + bv)
256
256
 
257
257
 
258
258
 
func bM (bv) = ("deliveryDelayByDuck_" + bv)
259
259
 
260
260
 
261
261
 
func bN (t) = ("userDeliveryCount_" + t)
262
262
 
263
263
 
264
264
 
func bO (t) = ("userLastDeliveryDay_" + t)
265
265
 
266
266
 
267
267
 
func bP (bQ) = (100 + bQ)
268
268
 
269
269
 
270
270
 
func bR (N,bv) = {
271
271
 
    let bS = valueOrElse(getInteger(N, bG(bv)), 0)
272
272
 
    let bT = valueOrElse(getInteger(N, bF(bv)), 0)
273
273
 
    let ax = lastBlock.timestamp
274
274
 
    let bU = max([bl, (bS - (bm * (ax - bT)))])
275
275
 
    let bV = valueOrElse(getInteger(N, bK(bv)), 0)
276
276
 
    let bW = valueOrElse(getString(N, bL(bv)), "")
277
277
 
    let bX = valueOrElse(getInteger(N, bJ(bW)), 0)
278
278
 
    $Tuple5(bU, bT, bV, bW, bX)
279
279
 
    }
280
280
 
281
281
 
282
282
 
func bY (bZ) = {
283
283
 
    let ca = (2 * bZ)
284
284
 
    let cb = pow(271828183, 8, ca, 8, 8, HALFUP)
285
285
 
    fraction((cb - bk), bk, (cb + bk), HALFUP)
286
286
 
    }
287
287
 
288
288
 
289
289
 
func cc (cd,ce,cf) = {
290
290
 
    let cg = (parseIntValue(cd[bn]) + parseIntValue(ce[bn]))
291
291
 
    let ch = (parseIntValue(cd[bp]) + parseIntValue(ce[bp]))
292
292
 
    let ci = (bY(fraction(ch, bk, 200)) / 4)
293
293
 
    let cj = fraction(cf, (bk + fraction(7000000, cg, (1 + cg), HALFUP)), 100, HALFUP)
294
294
 
    (ci + cj)
295
295
 
    }
296
296
 
297
297
 
298
298
 
func ck (cd,ce,cl) = {
299
299
 
    let cg = (parseIntValue(cd[bn]) + parseIntValue(ce[bn]))
300
300
 
    let cm = (parseIntValue(cd[bo]) + parseIntValue(ce[bo]))
301
301
 
    let ch = (parseIntValue(cd[bp]) + parseIntValue(ce[bp]))
302
302
 
    let ci = (cl * (bk + fraction(14000000, cg, (1 + cg), HALFUP)))
303
303
 
    let cj = (sqrt(ch, 0, 8, HALFUP) / 10)
304
304
 
    let cn = ((bk / 5) * cm)
305
305
 
    ((ci + cj) + cn)
306
306
 
    }
307
307
 
308
308
 
309
309
 
let co = "PRESALE"
310
310
 
311
311
 
let cp = "ONBOARD"
312
312
 
313
313
 
let cq = 6
314
314
 
315
315
 
let cr = 3456000
316
316
 
317
317
 
let cs = 10000000000
318
318
 
319
319
 
let ct = 39637
320
320
 
321
321
 
let cu = 10
322
322
 
323
323
 
let cv = 4
324
324
 
325
325
 
let cw = 10
326
326
 
327
327
 
let cx = 10000000
328
328
 
329
-
let cy = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_011", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_10_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_20_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_30_0,0,0,0,0,0,0_201", "4_13_22_4_35_22_23_0_50,1,0_0,0,0,0,0,0,0_", "4_13_22_4_35_22_46_0_50,1,1_0,2,5,0,0,0,0_", "4_13_22_4_35_22_69_0_50,2,1_0,5,10,0,0,0,0_", "5_25_40_5_10_15_20_1_30,1,1_0,0,0,0,0,0,0_", "5_25_40_5_10_15_40_1_30,1,2_2,1,3,0,0,0,0_", "5_25_40_5_10_15_60_1_30,1,3_5,2,8,0,0,0,0_"]
329
+
let cy = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_011", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_10_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_20_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_30_0,0,0,0,0,0,0_201", "4_13_22_4_35_22_23_0_50,1,0_0,0,0,0,0,0,0_", "4_13_22_4_35_22_46_0_50,1,1_0,2,5,0,0,0,0_", "4_13_22_4_35_22_69_0_50,2,1_0,5,10,0,0,0,0_", "5_25_40_5_10_15_20_1_30,1,1_0,0,0,0,0,0,0_", "5_25_40_5_10_15_40_1_30,1,2_2,1,3,0,0,0,0_", "5_25_40_5_10_15_60_1_30,1,3_5,2,8,0,0,0,0_", "23_23_5_20_23_6_35_2_0_0,0,0,0,0,0,0_", "23_23_5_20_23_6_70_2_0_0,0,0,0,0,0,0_", "23_23_5_20_23_6_105_2_0_0,0,0,0,0,0,0_"]
330
330
 
331
331
 
let cz = 6
332
332
 
333
333
 
let cA = 8
334
334
 
335
335
 
let cB = 10
336
336
 
337
337
 
func cC (cD) = ("no_" + cD)
338
338
 
339
339
 
340
340
 
func cE (cD) = ("lcna_" + cD)
341
341
 
342
342
 
343
343
 
func cF (cD) = ("st_" + cD)
344
344
 
345
345
 
346
346
 
func cG (cH,cD) = makeString(["las", cH, cD], "_")
347
347
 
348
348
 
349
349
 
func cI (bI) = ("wh_" + bI)
350
350
 
351
351
 
352
352
 
func cJ (cD) = ("infraLevel_" + cD)
353
353
 
354
354
 
355
355
 
func cK (bI) = ("fortifications_" + bI)
356
356
 
357
357
 
358
358
 
func cL (cD) = ("duckCustomNameByAssetId_" + cD)
359
359
 
360
360
 
361
361
 
func cM (t) = ("accountCustomNameByAddr_" + t)
362
362
 
363
363
 
364
364
 
func cN (t) = ("accRefBy_" + t)
365
365
 
366
366
 
367
367
 
func cO (t) = ("onboardArtActivatedDuckBy_" + t)
368
368
 
369
369
 
370
370
 
func cP (t) = ("accReferrals_" + t)
371
371
 
372
372
 
373
373
 
func cQ (cD) = ("duckOwner_" + cD)
374
374
 
375
375
 
376
376
 
func cR (cS) = ("stakedDuckByOwner_" + cS)
377
377
 
378
378
 
379
379
 
func cT (bv) = ("duckLocation_" + bv)
380
380
 
381
381
 
382
382
 
func cU (bI) = ("landOrder_" + bI)
383
383
 
384
384
 
385
385
 
func cV () = "emergencyWarehouseProducts"
386
386
 
387
387
 
388
388
 
let cW = "%s__lastTourId"
389
389
 
390
390
 
func cX (cY) = ("%s%d__tourStaticData__" + toString(cY))
391
391
 
392
392
 
393
393
 
func cZ (cY) = ("%s%d__tourDynamicData__" + toString(cY))
394
394
 
395
395
 
396
396
 
func da (cY) = ("%s%d__scoreBoard__" + toString(cY))
397
397
 
398
398
 
399
399
 
func db (cY,bv) = makeString(["%s%d%s__isRegisteredByTourAndDuck", toString(cY), bv], "__")
400
400
 
401
401
 
402
402
 
func dc (cY,bv) = makeString(["%s%d%s__isAwardedByTourAndDuck", toString(cY), bv], "__")
403
403
 
404
404
 
405
405
 
func dd (cY,bv) = makeString(["%s%d%s__lastAttemptByTourAndDuck", toString(cY), bv], "__")
406
406
 
407
407
 
408
408
 
func de (cY,bv) = makeString(["%s%d%s__bestResultByTourAndDuck", toString(cY), bv], "__")
409
409
 
410
410
 
411
411
 
func df (cY,bv) = makeString(["%s%d%s__bestTxByTourAndDuck", toString(cY), bv], "__")
412
412
 
413
413
 
414
414
 
let dg = 0
415
415
 
416
416
 
let dh = 1
417
417
 
418
418
 
let di = 2
419
419
 
420
420
 
let dj = 3
421
421
 
422
422
 
let dk = 5
423
423
 
424
424
 
let dl = 6
425
425
 
426
426
 
let dm = 7
427
427
 
428
428
 
let dn = 8
429
429
 
430
430
 
let do = 9
431
431
 
432
432
 
let dp = 1
433
433
 
434
434
 
let dq = 2
435
435
 
436
436
 
let dr = 3
437
437
 
438
438
 
let ds = 4
439
439
 
440
440
 
let dt = 5
441
441
 
442
442
 
func du (dv,cY) = {
443
443
 
    let dw = split(valueOrErrorMessage(getString(dv, cX(cY)), (("Error reading tournament " + toString(cY)) + " data")), "__")
444
444
 
    let dx = split_4C(valueOrErrorMessage(getString(dv, cZ(cY)), (("Error reading tournament " + toString(cY)) + " data")), "__")
445
445
 
[dw, dx]
446
446
 
    }
447
447
 
448
448
 
449
449
 
func dy (dz) = (parseIntValue(dz[cz]) * cx)
450
450
 
451
451
 
452
452
 
let dA = take(drop(this.bytes, 1), 1)
453
453
 
454
454
 
let dB = {
455
455
 
    let dC = dA
456
456
 
    if ((base58'2W' == dC))
457
457
 
        then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
458
458
 
        else if ((base58'2T' == dC))
459
459
 
            then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
460
460
 
            else throw("Unknown chain")
461
461
 
    }
462
462
 
463
463
 
let dD = {
464
464
 
    let dC = dA
465
465
 
    if ((base58'2W' == dC))
466
466
 
        then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
467
467
 
        else if ((base58'2T' == dC))
468
468
 
            then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
469
469
 
            else throw("Unknown chain")
470
470
 
    }
471
471
 
472
472
 
let dE = {
473
473
 
    let dC = dA
474
474
 
    if ((base58'2W' == dC))
475
475
 
        then 10000000000
476
476
 
        else if ((base58'2T' == dC))
477
477
 
            then 100000000
478
478
 
            else throw("Unknown chain")
479
479
 
    }
480
480
 
481
481
 
let dF = "__"
482
482
 
483
483
 
let dG = 1000000
484
484
 
485
485
 
let dH = 100000000
486
486
 
487
487
 
let dI = 25
488
488
 
489
489
 
let dJ = 100
490
490
 
491
491
 
let dK = 225
492
492
 
493
493
 
let dL = 400
494
494
 
495
495
 
let dM = 625
496
496
 
497
497
 
func dN (dO,dP) = valueOrErrorMessage(getString(dO, dP), makeString(["mandatory ", toString(dO), ".", dP, " is not defined"], ""))
498
498
 
499
499
 
500
500
 
let dQ = 1
501
501
 
502
502
 
let dR = 2
503
503
 
504
504
 
let dS = 4
505
505
 
506
506
 
let dT = 5
507
507
 
508
508
 
let dU = 6
509
509
 
510
510
 
let dV = 7
511
511
 
512
512
 
let dW = 8
513
513
 
514
514
 
func dX () = "%s__restConfig"
515
515
 
516
516
 
517
517
 
func dY () = "%s__restAddr"
518
518
 
519
519
 
520
520
 
func dZ (ea) = split_4C(dN(ea, dX()), dF)
521
521
 
522
522
 
523
523
 
func eb (ec,ed) = valueOrErrorMessage(addressFromString(ec[ed]), ("Rest cfg doesn't contain address at index " + toString(ed)))
524
524
 
525
525
 
526
526
 
let ee = addressFromStringValue(valueOrElse(getString(this, dY()), dD))
527
527
 
528
528
 
let ec = dZ(ee)
529
529
 
530
530
 
let N = eb(ec, dQ)
531
531
 
532
532
 
let ef = eb(ec, dR)
533
533
 
534
534
 
let eg = eb(ec, dS)
535
535
 
536
536
 
let eh = eb(ec, dT)
537
537
 
538
538
 
let at = eb(ec, dU)
539
539
 
540
540
 
let ei = eb(ec, dV)
541
541
 
542
542
 
let O = eb(ec, dW)
543
543
 
544
544
 
let ej = 0
545
545
 
546
546
 
let ek = 1
547
547
 
548
548
 
let el = 2
549
549
 
550
550
 
let em = 3
551
551
 
552
552
 
let en = "wlg_assetId"
553
553
 
554
554
 
let eo = valueOrErrorMessage(getBinary(eg, en), "WLGOLD is not issued yet")
555
555
 
556
556
 
let ep = "acresIssuedAmount"
557
557
 
558
558
 
let eq = "acresAssetId"
559
559
 
560
560
 
let er = valueOrErrorMessage(getBinary(O, eq), "ACRES is not issued yet")
561
561
 
562
562
 
let es = 0
563
563
 
564
564
 
let et = 1
565
565
 
566
566
 
let eu = 2
567
567
 
568
568
 
let ev = 3
569
569
 
570
570
 
let ew = 4
571
571
 
572
572
 
let ex = 5
573
573
 
574
574
 
let ey = 6
575
575
 
576
576
 
let ez = 7
577
577
 
578
578
 
let eA = 8
579
579
 
580
580
 
let eB = 9
581
581
 
582
582
 
let eC = 10
583
583
 
584
584
 
let eD = 11
585
585
 
586
586
 
let eE = 12
587
587
 
588
588
 
let eF = 13
589
589
 
590
590
 
let eG = 14
591
591
 
592
592
 
let eH = 15
593
593
 
594
594
 
let eI = 16
595
595
 
596
596
 
let eJ = 17
597
597
 
598
598
 
let eK = 18
599
599
 
600
600
 
let eL = 19
601
601
 
602
602
 
let eM = 20
603
603
 
604
604
 
let eN = 21
605
605
 
606
606
 
let eO = 22
607
607
 
608
608
 
let eP = 23
609
609
 
610
610
 
let eQ = 24
611
611
 
612
612
 
let eR = 25
613
613
 
614
614
 
let eS = 26
615
615
 
616
616
 
let eT = 27
617
617
 
618
618
 
let eU = 28
619
619
 
620
620
 
let eV = 29
621
621
 
622
622
 
let eW = 1
623
623
 
624
624
 
func eX () = "resTypesProportions"
625
625
 
626
626
 
627
627
 
func eY (cS) = ("stakedLandsByOwner_" + cS)
628
628
 
629
629
 
630
630
 
func eZ (cS) = ("stakedPiecesByOwner_" + cS)
631
631
 
632
632
 
633
633
 
func fa (bZ) = {
634
634
 
    let dC = bZ
635
635
 
    if ($isInstanceOf(dC, "String"))
636
636
 
        then {
637
637
 
            let fb = dC
638
638
 
            fb
639
639
 
            }
640
640
 
        else throw("fail to cast into String")
641
641
 
    }
642
642
 
643
643
 
644
644
 
func fc (bZ) = {
645
645
 
    let dC = bZ
646
646
 
    if ($isInstanceOf(dC, "Int"))
647
647
 
        then {
648
648
 
            let fd = dC
649
649
 
            fd
650
650
 
            }
651
651
 
        else throw("fail to cast into Int")
652
652
 
    }
653
653
 
654
654
 
655
655
 
func fe (bZ) = {
656
656
 
    let dC = bZ
657
657
 
    if ($isInstanceOf(dC, "List[Any]"))
658
658
 
        then {
659
659
 
            let ff = dC
660
660
 
            ff
661
661
 
            }
662
662
 
        else throw("fail to cast into List[Any]")
663
663
 
    }
664
664
 
665
665
 
666
666
 
func fg (fh) = {
667
667
 
    let dC = fh
668
668
 
    if (("S" == dC))
669
669
 
        then dI
670
670
 
        else if (("M" == dC))
671
671
 
            then dJ
672
672
 
            else if (("L" == dC))
673
673
 
                then dK
674
674
 
                else if (("XL" == dC))
675
675
 
                    then dL
676
676
 
                    else if (("XXL" == dC))
677
677
 
                        then dM
678
678
 
                        else throw("Unknown land size")
679
679
 
    }
680
680
 
681
681
 
682
682
 
func fi () = "contractsBlocked"
683
683
 
684
684
 
685
685
 
func fj (t) = ("lastTxIdByUser_" + t)
686
686
 
687
687
 
688
688
 
func fk (M) = {
689
689
 
    let P = split(valueOrElse(getString(N, eX()), "0_0_0_0_0_0"), "_")
690
690
 
    func Q (R,S) =     (R + parseIntValue(S))
691
691
 
692
692
 
    let fl = {
693
693
 
        let U = P
694
694
 
        let V = size(U)
695
695
 
        let W = 0
696
696
 
        func X (Y,Z) =         if ((Z >= V))
697
697
 
            then Y
698
698
 
            else Q(Y, U[Z])
699
699
 
700
700
 
        func aa (Y,Z) =         if ((Z >= V))
701
701
 
            then Y
702
702
 
            else throw("List size exceeds 6")
703
703
 
704
704
 
        aa(X(X(X(X(X(X(W, 0), 1), 2), 3), 4), 5), 6)
705
705
 
        }
706
706
 
    let fm = valueOrElse(getInteger(N, eZ(M)), 0)
707
707
 
[fl, fm]
708
708
 
    }
709
709
 
710
710
 
711
711
 
let fn = 500000
712
712
 
713
713
 
func fo (fp) = {
714
714
 
    let dC = fp
715
715
 
    if ($isInstanceOf(dC, "List[Any]"))
716
716
 
        then {
717
717
 
            let fq = dC
718
718
 
            if ((size(fq) != cq))
719
719
 
                then throw(("Array size is " + toString(size(fq))))
720
720
 
                else {
721
721
 
                    func fr (R,S) =                     {
722
722
 
                        let fs = S
723
723
 
                        if ($isInstanceOf(fs, "Int"))
724
724
 
                            then {
725
725
 
                                let ft = fs
726
726
 
                                (R :+ toString(ft))
727
727
 
                                }
728
728
 
                            else throw("List type is not Int")
729
729
 
                        }
730
730
 
731
731
 
                    let fu = {
732
732
 
                        let U = fq
733
733
 
                        let V = size(U)
734
734
 
                        let W = nil
735
735
 
                        func X (Y,Z) =                         if ((Z >= V))
736
736
 
                            then Y
737
737
 
                            else fr(Y, U[Z])
738
738
 
739
739
 
                        func aa (Y,Z) =                         if ((Z >= V))
740
740
 
                            then Y
741
741
 
                            else throw("List size exceeds 6")
742
742
 
743
743
 
                        aa(X(X(X(X(X(X(W, 0), 1), 2), 3), 4), 5), 6)
744
744
 
                        }
745
745
 
                    makeString(fu, "_")
746
746
 
                    }
747
747
 
            }
748
748
 
        else throw("fail to cast into List")
749
749
 
    }
750
750
 
751
751
 
752
752
 
func fv (fp) = {
753
753
 
    let dC = fp
754
754
 
    if ($isInstanceOf(dC, "(List[Any], List[Any])"))
755
755
 
        then {
756
756
 
            let fw = dC
757
757
 
            $Tuple2(fo(fw._1), fo(fw._2))
758
758
 
            }
759
759
 
        else throw("fail to cast into (List, List)")
760
760
 
    }
761
761
 
762
762
 
763
763
 
func fx (fp) = {
764
764
 
    let dC = fp
765
765
 
    if ($isInstanceOf(dC, "(Boolean, String)"))
766
766
 
        then {
767
767
 
            let fw = dC
768
768
 
            fw
769
769
 
            }
770
770
 
        else throw("fail to cast into (Boolean, String)")
771
771
 
    }
772
772
 
773
773
 
774
774
 
func fy (fz) = {
775
775
 
    let t = addressFromString(fz)
776
776
 
    let fA = if (isDefined(t))
777
777
 
        then wavesBalance(value(t))
778
778
 
        else BalanceDetails(0, 0, 0, 0)
779
779
 
    let fB = if (isDefined(t))
780
780
 
        then assetBalance(value(t), dB)
781
781
 
        else 0
782
782
 
    let fC = if (isDefined(t))
783
783
 
        then assetBalance(value(t), eo)
784
784
 
        else 0
785
785
 
    let fD = valueOrElse(getString(N, cM(fz)), fz)
786
786
 
    let fE = cN(fz)
787
787
 
    let fF = getString(N, fE)
788
788
 
    let fG = valueOrElse(getString(N, cP(fz)), "")
789
789
 
    let fH = valueOrElse(getString(N, fj(fz)), "")
790
790
 
    let fI = fk(fz)[eW]
791
791
 
    let fJ = valueOrElse(getInteger(N, bB(fz)), 0)
792
792
 
    let fK = valueOrElse(getInteger(N, bC(fz)), 0)
793
793
 
    let fL = valueOrElse(getInteger(N, bD(fz)), 0)
794
794
 
    let fM = {
795
795
 
        let fN = invoke(eg, "checkWlgXpREADONLY", [fz], nil)
796
796
 
        if ($isInstanceOf(fN, "List[Any]"))
797
797
 
            then fN
798
798
 
            else throw(($getType(fN) + " couldn't be cast to List[Any]"))
799
799
 
        }
800
800
 
    let fO = valueOrElse(getInteger(eg, D(fz)), 0)
801
801
 
    let fP = if (isDefined(fF))
802
802
 
        then (cp + (if (if (isDefined(t))
803
803
 
            then isDefined(getString(N, cO(fz)))
804
804
 
            else false)
805
805
 
            then ":1"
806
806
 
            else ":0"))
807
807
 
        else ""
808
808
 
    let fQ = if (isDefined(t))
809
809
 
        then assetBalance(value(t), er)
810
810
 
        else 0
811
811
 
    let fR = valueOrElse(getInteger(O, z(fz)), 0)
812
812
 
    let fS = valueOrElse(getInteger(N, bN(fz)), 0)
813
813
 
    let fT = valueOrElse(getInteger(N, bO(fz)), 0)
814
814
 
[("%s%s__customName__" + fD), ("%s%s__referredBy__" + valueOrElse(fF, "")), ("%s%s__referrals__" + fG), ("%s%s__lastTxId__" + fH), ("%s%d__wavesBalance__" + toString(fA.available)), ("%s%d__wlgoldBalance__" + toString(fC)), ("%s%d__usdtBalance__" + toString(fB)), ("%s%d__stakedPieces__" + toString(fI)), ("%s%d__acresBalance__" + toString(fQ)), ("%s%d__stakedAcres__" + toString(fR)), ("%s%d__currentXp__" + toString(fJ)), ("%s%d__currentLvl__" + toString(fK)), ("%s%d__pointsToDistribute__" + toString(fL)), ("%s%s__walletArtefacts__" + fP), ("%s%d__stakedWlgold__" + toString(fO)), ("%s%d__virtLevel__" + toString({
815
815
 
        let fN = fM[0]
816
816
 
        if ($isInstanceOf(fN, "Int"))
817
817
 
            then fN
818
818
 
            else throw(($getType(fN) + " couldn't be cast to Int"))
819
819
 
        })), ("%s%d__virtPoints__" + toString({
820
820
 
        let fN = fM[1]
821
821
 
        if ($isInstanceOf(fN, "Int"))
822
822
 
            then fN
823
823
 
            else throw(($getType(fN) + " couldn't be cast to Int"))
824
824
 
        })), ("%s%d__virtXP__" + toString({
825
825
 
        let fN = fM[2]
826
826
 
        if ($isInstanceOf(fN, "Int"))
827
827
 
            then fN
828
828
 
            else throw(($getType(fN) + " couldn't be cast to Int"))
829
829
 
        })), ("%s%d__userDeliveryCount__" + toString(fS)), ("%s%d__userLastDeliveryDay__" + toString(fT)), ("%s%d__lockedAcres__" + toString(valueOrElse(getInteger(O, A(fz)), 0))), ("%s%d__ETALockedAcres__" + toString(valueOrElse(getInteger(O, B(fz)), 0)))]
830
830
 
    }
831
831
 
832
832
 
833
833
 
func fU (bI,fI) = {
834
834
 
    let fV = valueOrElse(getInteger(N, cJ(bI)), 0)
835
835
 
    let fW = valueOrElse(getInteger(N, cG(co, bI)), 0)
836
836
 
    let fX = (fV / 6)
837
837
 
    let fY = (fV / 7)
838
838
 
    $Tuple3(fV, fW, ((cr + fraction(cr, ((fV + fX) + (2 * fY)), 5)) + fraction(cr, fW, (fI * 5))))
839
839
 
    }
840
840
 
841
841
 
842
842
 
func fZ (ga) = {
843
843
 
    let gb = split(ga, "_")
844
844
 
    ((cs * (parseIntValue(gb[1]) + 1)) * parseIntValue(gb[0]))
845
845
 
    }
846
846
 
847
847
 
848
848
 
func gc (gd,ge,fV) = {
849
849
 
    let ga = ((toString(ge) + "_") + toString(fV))
850
850
 
    let gf = toString(fZ(ga))
851
851
 
    let gg = valueOrElse(getString(N, gd), ((((ga + ":0_0_0_0_0_0:0_0_0_0_0_0::0_0_") + gf) + "_") + gf))
852
852
 
    split(gg, ":")
853
853
 
    }
854
854
 
855
855
 
856
856
 
func gh (bv) = {
857
857
 
    let gi = bP(valueOrElse(getInteger(N, by(bv)), 0))
858
858
 
    $Tuple5(valueOrElse(getInteger(N, cF(bv)), -1), value(assetInfo(fromBase58String(bv))).name, valueOrElse(getString(N, cT(bv)), ""), valueOrElse(getInteger(N, bu(bv)), gi), fa(invoke(N, "getBackpackREADONLY", [bv], nil)))
859
859
 
    }
860
860
 
861
861
 
862
862
 
func gj (bv,gk,gl) = {
863
863
 
    let fD = valueOrElse(getString(N, cL(bv)), gl._2)
864
864
 
    let cd = valueOrElse(getString(N, bw(bv)), "0_0_0_0_0")
865
865
 
    let fJ = valueOrElse(getInteger(N, bx(bv)), 0)
866
866
 
    let fK = valueOrElse(getInteger(N, by(bv)), 0)
867
867
 
    let fL = valueOrElse(getInteger(N, bz(bv)), 0)
868
868
 
    let gm = valueOrElse(getString(N, bA(bv)), ";_;_;_;_;_;")
869
869
 
    let ce = valueOrElse(getString(N, bE(bv)), "0_0_0_0_0")
870
870
 
    let gn = bR(N, bv)
871
871
 
    let bU = gn._1
872
872
 
    let bT = gn._2
873
873
 
    let bV = gn._3
874
874
 
    let bW = gn._4
875
875
 
    let bX = gn._5
876
876
 
    let go = valueOrElse(getInteger(N, bM(bv)), 0)
877
877
 
[("%s%s__assetId__" + bv), ("%s%s__owner__" + gk), ("%s%s__customName__" + fD), ("%s%d__stakedTime__" + toString(gl._1)), ("%s%s__name__" + gl._2), ("%s%s__location__" + gl._3), ("%s%d__health__" + toString(gl._4)), ("%s%d__maxHealth__" + toString(bP(fK))), ("%s%s__characteristics__" + cd), ("%s%d__currentXp__" + toString(fJ)), ("%s%d__currentLvl__" + toString(fK)), ("%s%d__pointsToDistribute__" + toString(fL)), ("%s%s__backPack__" + gl._5), ("%s%s__equipment__" + gm), ("%s%s__buffs__" + ce), ("%s%d__robberyCost__" + toString(bU)), ("%s%d__robberyTime__" + toString(bT)), ("%s%s__robberyState__" + bt[bV]), ("%s%s__robberyLastLand__" + bW), ("%s%d__robberyLastLandReleaseTime__" + toString(bX)), ("%s%d__deliveryDelay__" + toString(go))]
878
878
 
    }
879
879
 
880
880
 
881
881
 
func gp (bI,gk,gq) = if ((bI == ""))
882
882
 
    then throw("landAssetId is required")
883
883
 
    else {
884
884
 
        let gr = value(assetInfo(fromBase58String(bI)))
885
885
 
        let gs = split(gr.description, "_")
886
886
 
        let gt = if ((gr.quantity > 0))
887
887
 
            then gs[ej]
888
888
 
            else ("-" + gs[ej])
889
889
 
        let fI = fg(gs[ek])
890
890
 
        let gu = fU(bI, fI)
891
891
 
        let gv = (lastBlock.timestamp - gq)
892
892
 
        let gw = if ((gq > 0))
893
893
 
            then fraction(gv, (gu._3 * fI), i)
894
894
 
            else 0
895
895
 
        let gx = fraction(dE, (fI * (gu._1 + 1)), dI)
896
896
 
        let gy = if ((gq > 0))
897
897
 
            then fv(invoke(N, "splitByGlobalAndLocalWeightsREADONLY", [gx, gw, gs[el]], nil))
898
898
 
            else $Tuple2(fo(invoke(N, "splitByGlobalWeightsREADONLY", [gx], nil)), "")
899
899
 
        let fD = valueOrElse(getString(N, cE(bI)), ((gs[em] + "-") + gs[ej]))
900
900
 
        let gz = valueOrElse(getString(N, cK(bI)), ":0_15:0_18:0")
901
901
 
        let gA = valueOrElse(getInteger(N, bH(bI)), 0)
902
902
 
        let gB = valueOrElse(getInteger(N, bJ(bI)), 0)
903
903
 
[("%s%s__assetId__" + bI), ("%s%s__owner__" + gk), ("%s%s__customName__" + fD), ("%s%d__stakedTime__" + toString(gq)), ("%s%s__description__" + makeString([gt, gs[ek], gs[el], gs[em]], "_")), ("%s%d__infraLevel__" + toString(gu._1)), ("%s%s__availResByType__" + gy._2), ("%s%d__availResTotal__" + toString(gw)), ("%s%s__needMaterial__" + gy._1), ("%s%s__landArtefacts__PRESALE:" + toString(gu._2)), ("%s%s__warehouse__" + makeString(gc(cI(bI), (fI / dI), gu._1), ":")), ("%s%s__landOrder__" + valueOrElse(getString(ef, cU(bI)), "0@0_0@0_0@0_0@0_0@0_0@0:0@0_0@0_0@0_0@0_0@0_0@0:")), ("%s%s__fortifications__" + gz), ("%s%s__robberyState__" + bs[gA]), ("%s%d__canBeRobbedAfter__" + toString(gB))]
904
904
 
        }
905
905
 
906
906
 
907
907
 
func gC (bI,gk) = if ((bI == ""))
908
908
 
    then throw("landAssetId is required")
909
909
 
    else {
910
910
 
        let gr = value(assetInfo(fromBase58String(bI)))
911
911
 
        let gs = split(gr.description, "_")
912
912
 
        let fI = fg(gs[ek])
913
913
 
        let gu = fU(bI, fI)
914
914
 
[("%s%s__assetId__" + bI), ("%s%s__owner__" + gk), ("%s%s__warehouse__" + makeString(gc(cI(bI), (fI / dI), gu._1), ":")), ("%s%s__landOrder__" + valueOrElse(getString(ef, cU(bI)), "0@0_0@0_0@0_0@0_0@0_0@0:0@0_0@0_0@0_0@0_0@0_0@0:"))]
915
915
 
        }
916
916
 
917
917
 
918
918
 
func gD (gE) = if ((gE == ""))
919
919
 
    then 0
920
920
 
    else {
921
921
 
        let gF = split(gE, ",")[0]
922
922
 
        if ((gF == ""))
923
923
 
            then 0
924
924
 
            else {
925
925
 
                let gG = split(gF, ":")
926
926
 
                if (if ((gG[1] == ""))
927
927
 
                    then true
928
928
 
                    else (parseIntValue(gG[1]) == 0))
929
929
 
                    then 0
930
930
 
                    else parseIntValue(split(cy[parseIntValue(gG[0])], "_")[cA])
931
931
 
                }
932
932
 
        }
933
933
 
934
934
 
935
935
 
func gH (gI) = {
936
936
 
    let gJ = du(ei, gI)
937
937
 
    let dw = gJ[dg]
938
938
 
    let dx = gJ[dh]
939
939
 
    let gK = if ((dx[dq] == ""))
940
940
 
        then " "
941
941
 
        else dx[dq]
942
942
 
    let gL = valueOrElse(getString(ei, da(gI)), "")
943
943
 
    let gM = if ((size(dw) > dm))
944
944
 
        then dw[dm]
945
945
 
        else "0"
946
946
 
    let gN = if ((size(dw) > dn))
947
947
 
        then dw[dn]
948
948
 
        else "0"
949
949
 
    let cD = if ((size(dw) > do))
950
950
 
        then fromBase58String(dw[do])
951
951
 
        else eo
952
952
 
    let gO = valueOrErrorMessage(assetInfo(cD), "No assetInfo available").name
953
953
 
[("%s%s__tournamentStaticData__" + makeString([dw[di], dw[dj], dw[dk], dw[dl], gM, gN, gO], "_")), ("%s%s__tournamentDynamicData__" + makeString_2C([dx[dp], gK, dx[dr], dx[ds], dx[dt]], "_")), ("%s%s__tournamentScoreBoard__" + gL)]
954
954
 
    }
955
955
 
956
956
 
957
957
 
func gP (t,dP) = {
958
958
 
    let gQ = getBoolean(t, dP)
959
959
 
    if (isDefined(gQ))
960
960
 
        then value(gQ)
961
961
 
        else {
962
962
 
            let gR = getBinary(t, dP)
963
963
 
            if (isDefined(gR))
964
964
 
                then value(gR)
965
965
 
                else {
966
966
 
                    let gS = getInteger(t, dP)
967
967
 
                    if (isDefined(gS))
968
968
 
                        then value(gS)
969
969
 
                        else getString(t, dP)
970
970
 
                    }
971
971
 
            }
972
972
 
    }
973
973
 
974
974
 
975
975
 
func gT (gU) = {
976
976
 
    func gV (R,gW) =     {
977
977
 
        let t = Address(fromBase58String(gW._1))
978
978
 
        let gX = gW._2
979
979
 
        let gY = {
980
980
 
            let dC = gW
981
981
 
            if ($isInstanceOf(dC, "(String, String, List[Any])"))
982
982
 
                then {
983
983
 
                    let gZ = dC
984
984
 
                    invoke(t, gX, gZ._3, nil)
985
985
 
                    }
986
986
 
                else gP(t, gX)
987
987
 
            }
988
988
 
        (R :+ gY)
989
989
 
        }
990
990
 
991
991
 
    let U = gU
992
992
 
    let V = size(U)
993
993
 
    let W = nil
994
994
 
    func X (Y,Z) =     if ((Z >= V))
995
995
 
        then Y
996
996
 
        else gV(Y, U[Z])
997
997
 
998
998
 
    func aa (Y,Z) =     if ((Z >= V))
999
999
 
        then Y
1000
1000
 
        else throw("List size exceeds 10")
1001
1001
 
1002
1002
 
    aa(X(X(X(X(X(X(X(X(X(X(W, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1003
1003
 
    }
1004
1004
 
1005
1005
 
1006
1006
 
@Callable(ha)
1007
1007
 
func constructorV1 (ak) = if ((ha.caller != this))
1008
1008
 
    then throw("permissions denied")
1009
1009
 
    else {
1010
1010
 
        func hb (R,hc) =         (R + "%s")
1011
1011
 
1012
1012
 
        let hd = {
1013
1013
 
            let U = ak
1014
1014
 
            let V = size(U)
1015
1015
 
            let W = ""
1016
1016
 
            func X (Y,Z) =             if ((Z >= V))
1017
1017
 
                then Y
1018
1018
 
                else hb(Y, U[Z])
1019
1019
 
1020
1020
 
            func aa (Y,Z) =             if ((Z >= V))
1021
1021
 
                then Y
1022
1022
 
                else throw("List size exceeds 10")
1023
1023
 
1024
1024
 
            aa(X(X(X(X(X(X(X(X(X(X(W, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1025
1025
 
            }
1026
1026
 
[StringEntry(dX(), makeString(hd :: ak, dF)), StringEntry(dY(), toString(this))]
1027
1027
 
        }
1028
1028
 
1029
1029
 
1030
1030
 
1031
1031
 
@Callable(ha)
1032
1032
 
func walletInfoREADONLY (fz) = $Tuple2(nil, fy(fz))
1033
1033
 
1034
1034
 
1035
1035
 
1036
1036
 
@Callable(ha)
1037
1037
 
func duckByOwnerInfoREADONLY (he) = {
1038
1038
 
    let hf = getString(N, cR(he))
1039
1039
 
    $Tuple2(nil, if (if (isDefined(addressFromString(he)))
1040
1040
 
        then isDefined(hf)
1041
1041
 
        else false)
1042
1042
 
        then {
1043
1043
 
            let bv = value(hf)
1044
1044
 
            gj(bv, he, gh(bv))
1045
1045
 
            }
1046
1046
 
        else gj("", he, $Tuple5(-1, "", "", -1, "")))
1047
1047
 
    }
1048
1048
 
1049
1049
 
1050
1050
 
1051
1051
 
@Callable(ha)
1052
1052
 
func duckByAssetIdInfoREADONLY (bv) = {
1053
1053
 
    let gk = getString(N, cQ(bv))
1054
1054
 
    $Tuple2(nil, gj(bv, if (isDefined(gk))
1055
1055
 
        then value(gk)
1056
1056
 
        else "", gh(bv)))
1057
1057
 
    }
1058
1058
 
1059
1059
 
1060
1060
 
1061
1061
 
@Callable(ha)
1062
1062
 
func ducksByIdsInfoREADONLY (hg) = {
1063
1063
 
    func hh (R,bv) =     if ((bv == ""))
1064
1064
 
        then throw("duckAssetId is required")
1065
1065
 
        else {
1066
1066
 
            let gq = valueOrElse(getInteger(N, cF(bv)), -1)
1067
1067
 
            let gk = if ((gq > 0))
1068
1068
 
                then value(getString(N, cQ(bv)))
1069
1069
 
                else ""
1070
1070
 
            (R :+ gj(bv, gk, gh(bv)))
1071
1071
 
            }
1072
1072
 
1073
1073
 
    let fu = {
1074
1074
 
        let U = hg
1075
1075
 
        let V = size(U)
1076
1076
 
        let W = nil
1077
1077
 
        func X (Y,Z) =         if ((Z >= V))
1078
1078
 
            then Y
1079
1079
 
            else hh(Y, U[Z])
1080
1080
 
1081
1081
 
        func aa (Y,Z) =         if ((Z >= V))
1082
1082
 
            then Y
1083
1083
 
            else throw("List size exceeds 100")
1084
1084
 
1085
1085
 
        aa(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(W, 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)
1086
1086
 
        }
1087
1087
 
    $Tuple2(nil, fu)
1088
1088
 
    }
1089
1089
 
1090
1090
 
1091
1091
 
1092
1092
 
@Callable(ha)
1093
1093
 
func landByAssetIdInfoREADONLY (bI) = if ((bI == ""))
1094
1094
 
    then throw("landAssetId is required")
1095
1095
 
    else {
1096
1096
 
        let gq = valueOrElse(getInteger(N, cF(bI)), -1)
1097
1097
 
        let gk = if ((gq > 0))
1098
1098
 
            then value(getString(N, cC(bI)))
1099
1099
 
            else ""
1100
1100
 
        $Tuple2(nil, gp(bI, gk, gq))
1101
1101
 
        }
1102
1102
 
1103
1103
 
1104
1104
 
1105
1105
 
@Callable(ha)
1106
1106
 
func stakedLandsByOwnerInfoREADONLY (hi) = if ((hi == ""))
1107
1107
 
    then throw("landOwnerAddress is required")
1108
1108
 
    else {
1109
1109
 
        let hj = getString(N, eY(hi))
1110
1110
 
        let hk = if (isDefined(hj))
1111
1111
 
            then split_51C(value(hj), "_")
1112
1112
 
            else nil
1113
1113
 
        func hl (R,bI) =         if ((bI == ""))
1114
1114
 
            then throw("landAssetId is required")
1115
1115
 
            else {
1116
1116
 
                let gq = valueOrElse(getInteger(N, cF(bI)), -1)
1117
1117
 
                (R :+ gp(bI, hi, gq))
1118
1118
 
                }
1119
1119
 
1120
1120
 
        let fu = {
1121
1121
 
            let U = hk
1122
1122
 
            let V = size(U)
1123
1123
 
            let W = nil
1124
1124
 
            func X (Y,Z) =             if ((Z >= V))
1125
1125
 
                then Y
1126
1126
 
                else hl(Y, U[Z])
1127
1127
 
1128
1128
 
            func aa (Y,Z) =             if ((Z >= V))
1129
1129
 
                then Y
1130
1130
 
                else throw("List size exceeds 100")
1131
1131
 
1132
1132
 
            aa(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(W, 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)
1133
1133
 
            }
1134
1134
 
        $Tuple2(nil, fu)
1135
1135
 
        }
1136
1136
 
1137
1137
 
1138
1138
 
1139
1139
 
@Callable(ha)
1140
1140
 
func landsByIdsInfoREADONLY (hm) = {
1141
1141
 
    func hl (R,bI) =     if ((bI == ""))
1142
1142
 
        then throw("landAssetId is required")
1143
1143
 
        else {
1144
1144
 
            let gq = valueOrElse(getInteger(N, cF(bI)), -1)
1145
1145
 
            let gk = if ((gq > 0))
1146
1146
 
                then value(getString(N, cC(bI)))
1147
1147
 
                else ""
1148
1148
 
            (R :+ gp(bI, gk, gq))
1149
1149
 
            }
1150
1150
 
1151
1151
 
    let fu = {
1152
1152
 
        let U = hm
1153
1153
 
        let V = size(U)
1154
1154
 
        let W = nil
1155
1155
 
        func X (Y,Z) =         if ((Z >= V))
1156
1156
 
            then Y
1157
1157
 
            else hl(Y, U[Z])
1158
1158
 
1159
1159
 
        func aa (Y,Z) =         if ((Z >= V))
1160
1160
 
            then Y
1161
1161
 
            else throw("List size exceeds 100")
1162
1162
 
1163
1163
 
        aa(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(W, 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)
1164
1164
 
        }
1165
1165
 
    $Tuple2(nil, fu)
1166
1166
 
    }
1167
1167
 
1168
1168
 
1169
1169
 
1170
1170
 
@Callable(ha)
1171
1171
 
func warehouseOrderByAssetIdInfoREADONLY (bI) = if ((bI == ""))
1172
1172
 
    then throw("landAssetId is required")
1173
1173
 
    else {
1174
1174
 
        let gq = valueOrElse(getInteger(N, cF(bI)), -1)
1175
1175
 
        let gk = if ((gq > 0))
1176
1176
 
            then value(getString(N, cC(bI)))
1177
1177
 
            else ""
1178
1178
 
        $Tuple2(nil, gC(bI, gk))
1179
1179
 
        }
1180
1180
 
1181
1181
 
1182
1182
 
1183
1183
 
@Callable(ha)
1184
1184
 
func ordersByLandIdsInfoREADONLY (hm) = {
1185
1185
 
    func hl (R,bI) =     if ((bI == ""))
1186
1186
 
        then throw("landAssetId is required")
1187
1187
 
        else {
1188
1188
 
            let gq = valueOrElse(getInteger(N, cF(bI)), -1)
1189
1189
 
            let gk = if ((gq > 0))
1190
1190
 
                then value(getString(N, cC(bI)))
1191
1191
 
                else ""
1192
1192
 
            (R :+ gC(bI, gk))
1193
1193
 
            }
1194
1194
 
1195
1195
 
    let fu = {
1196
1196
 
        let U = hm
1197
1197
 
        let V = size(U)
1198
1198
 
        let W = nil
1199
1199
 
        func X (Y,Z) =         if ((Z >= V))
1200
1200
 
            then Y
1201
1201
 
            else hl(Y, U[Z])
1202
1202
 
1203
1203
 
        func aa (Y,Z) =         if ((Z >= V))
1204
1204
 
            then Y
1205
1205
 
            else throw("List size exceeds 40")
1206
1206
 
1207
1207
 
        aa(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(W, 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)
1208
1208
 
        }
1209
1209
 
    $Tuple2(nil, fu)
1210
1210
 
    }
1211
1211
 
1212
1212
 
1213
1213
 
1214
1214
 
@Callable(ha)
1215
1215
 
func cancelWarehouseOrders (hm) = if ((ha.caller != this))
1216
1216
 
    then throw("permission denied")
1217
1217
 
    else {
1218
1218
 
        let hn = getBoolean(N, fi())
1219
1219
 
        if (if (!(isDefined(hn)))
1220
1220
 
            then true
1221
1221
 
            else (value(hn) == false))
1222
1222
 
            then throw("Contracts should be blocked before canceling orders")
1223
1223
 
            else {
1224
1224
 
                func hl (gr,bI) =                 if ((bI == ""))
1225
1225
 
                    then throw("landAssetId is required")
1226
1226
 
                    else {
1227
1227
 
                        let ho = fx(invoke(ef, "setWarehouseOrder", ["0@0_0@0_0@0_0@0_0@0_0@0:0@0_0@0_0@0_0@0_0@0_0@0:", bI], nil))._1
1228
1228
 
                        if (if (gr)
1229
1229
 
                            then true
1230
1230
 
                            else ho)
1231
1231
 
                            then !(if (gr)
1232
1232
 
                                then ho
1233
1233
 
                                else false)
1234
1234
 
                            else false
1235
1235
 
                        }
1236
1236
 
1237
1237
 
                let fu = {
1238
1238
 
                    let U = hm
1239
1239
 
                    let V = size(U)
1240
1240
 
                    let W = false
1241
1241
 
                    func X (Y,Z) =                     if ((Z >= V))
1242
1242
 
                        then Y
1243
1243
 
                        else hl(Y, U[Z])
1244
1244
 
1245
1245
 
                    func aa (Y,Z) =                     if ((Z >= V))
1246
1246
 
                        then Y
1247
1247
 
                        else throw("List size exceeds 30")
1248
1248
 
1249
1249
 
                    aa(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(W, 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)
1250
1250
 
                    }
1251
1251
 
                $Tuple2(nil, fu)
1252
1252
 
                }
1253
1253
 
        }
1254
1254
 
1255
1255
 
1256
1256
 
1257
1257
 
@Callable(ha)
1258
1258
 
func sendUsdtPrize (he) = if ((ha.caller != N))
1259
1259
 
    then throw("permission denied")
1260
1260
 
    else {
1261
1261
 
        let hp = fraction(assetBalance(this, dB), fn, dG)
1262
1262
 
        $Tuple2([ScriptTransfer(addressFromStringValue(he), hp, dB)], hp)
1263
1263
 
        }
1264
1264
 
1265
1265
 
1266
1266
 
1267
1267
 
@Callable(ha)
1268
1268
 
func getEmergencyServiceDataREADONLY () = {
1269
1269
 
    let hq = getString(ef, cV())
1270
1270
 
    let hr = if (isDefined(hq))
1271
1271
 
        then split_4C(value(hq), "_")
1272
1272
 
        else nil
1273
1273
 
    func hs (R,ht) =     {
1274
1274
 
        let fd = R._2
1275
1275
 
        let dz = split(ht, "_")
1276
1276
 
        let hu = if ((fd == 0))
1277
1277
 
            then (cu * cB)
1278
1278
 
            else 0
1279
1279
 
        let hv = if ((size(hr) > fd))
1280
1280
 
            then parseIntValue(hr[fd])
1281
1281
 
            else 0
1282
1282
 
        let hw = dy(dz)
1283
1283
 
        let hx = fraction((hw * cv), ct, (dH * cB))
1284
1284
 
        let hy = fraction((hw * cw), ct, (dH * cB))
1285
1285
 
        let hz = makeString([toString(hu), toString(hv), toString(hx), toString(hy)], "_")
1286
1286
 
        $Tuple2((R._1 :+ hz), (fd + 1))
1287
1287
 
        }
1288
1288
 
1289
1289
 
    let fb = makeString_2C((    let U = cy
1290
1290
 
    let V = size(U)
1291
1291
 
    let W = $Tuple2(nil, 0)
1292
1292
 
    func X (Y,Z) =     if ((Z >= V))
1293
1293
 
        then Y
1294
1294
 
        else hs(Y, U[Z])
1295
1295
 
1296
1296
 
    func aa (Y,Z) =     if ((Z >= V))
1297
1297
 
        then Y
1298
1298
 
        else throw("List size exceeds 50")
1299
1299
 
1300
1300
 
    aa(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(W, 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))._1, ":")
1301
1301
 
    let gY = ("%s%s__emergencyServiceData__" + fb)
1302
1302
 
    $Tuple2(nil, gY)
1303
1303
 
    }
1304
1304
 
1305
1305
 
1306
1306
 
1307
1307
 
@Callable(ha)
1308
1308
 
func wlgStatsREADONLY (aj) = {
1309
1309
 
    let hA = ai(aj, [ee, N, ef, eg, eh, at, O], dB, 0, dG)
1310
1310
 
    $Tuple2(nil, [("%s%d__wlgAmount__" + toString(hA[es])), ("%s%d__wlgPrice__" + toString(hA[et])), ("%s%d__usdtFunds__" + toString(hA[eu])), ("%s%d__usdtEconomy__" + toString(hA[ev])), ("%s%d__usdtActivity__" + toString(hA[ew])), ("%s%d__usdtArbitrage__" + toString(hA[ex])), ("%s%d__usdtPool__" + toString(hA[ey])), ("%s%d__wlgIssueTime__" + toString(hA[ez])), ("%s%d__wlgLastMarketingTeamActTime__" + toString(hA[eA])), ("%s%d__wlgMarketingTotal__" + toString(hA[eB])), ("%s%d__wlgMarketingAmLeft__" + toString(hA[eC])), ("%s%d__wlgMarketingAmAvailNow__" + toString(hA[eD])), ("%s%d__wlgMarketingWlgold__" + toString(hA[eE])), ("%s%d__wlgTeamTotal__" + toString(hA[eF])), ("%s%d__wlgTeamAmLeft__" + toString(hA[eG])), ("%s%d__wlgTeamAmAvailNow__" + toString(hA[eH])), ("%s%d__wlgTeamWlgold__" + toString(hA[eI])), ("%s%d__wlgActTotal__" + toString(hA[eJ])), ("%s%d__wlgActAmLeft__" + toString(hA[eK])), ("%s%d__wlgActAmAvailNow__" + toString(hA[eL])), ("%s%d__wlgActWlgold__" + toString(hA[eM])), ("%s%d__wlgCurPeriod__" + toString(hA[eN])), ("%s%d__wlgAmLeftTotal__" + toString(hA[eO])), ("%s%d__wlgCurPeriodDistribution__" + toString(hA[eP])), ("%s%d__wlgLastUserTime__" + toString(hA[eQ])), ("%s%d__wlgUserAmAvailNow__" + toString(hA[eR])), ("%s%d__wlgGuestSLandDaily__" + toString(hA[eS])), ("%s%d__wlgInvestFundTotal__" + toString(hA[eT])), ("%s%d__wlgUserTotalAvail__" + toString(hA[eU])), ("%s%d__wlgEffUserTime__" + toString(hA[eV]))])
1311
1311
 
    }
1312
1312
 
1313
1313
 
1314
1314
 
1315
1315
 
@Callable(ha)
1316
1316
 
func tournamentStatsREADONLY (gI) = $Tuple2(nil, gH(gI))
1317
1317
 
1318
1318
 
1319
1319
 
1320
1320
 
@Callable(ha)
1321
1321
 
func lastTournamentStatsREADONLY () = {
1322
1322
 
    let gI = valueOrElse(getInteger(ei, cW), 0)
1323
1323
 
    $Tuple2(nil, [("%s%s__lastTournamentId__" + toString(gI)), gH(gI)])
1324
1324
 
    }
1325
1325
 
1326
1326
 
1327
1327
 
1328
1328
 
@Callable(ha)
1329
1329
 
func tournamentDuckStatsREADONLY (cY,bv) = {
1330
1330
 
    let hB = valueOrElse(getBoolean(ei, db(cY, bv)), false)
1331
1331
 
    let hC = valueOrElse(getInteger(ei, dd(cY, bv)), -1)
1332
1332
 
    let hD = valueOrElse(getInteger(ei, de(cY, bv)), 0)
1333
1333
 
    let hE = valueOrElse(getString(ei, df(cY, bv)), "")
1334
1334
 
    let hF = valueOrElse(getBoolean(ei, dc(cY, bv)), false)
1335
1335
 
    $Tuple2(nil, [("%s%s__tournamentDuckStats__" + makeString([toString(hB), toString(hC), toString(hD), hE, toString(hF)], "_"))])
1336
1336
 
    }
1337
1337
 
1338
1338
 
1339
1339
 
1340
1340
 
@Callable(ha)
1341
1341
 
func duckStatsCalculatorREADONLY (bv) = {
1342
1342
 
    let cd = split(valueOrElse(getString(N, bw(bv)), "0_0_0_0_0"), "_")
1343
1343
 
    let ce = split(valueOrElse(getString(N, bE(bv)), "0_0_0_0_0"), "_")
1344
1344
 
    let gm = split(valueOrElse(getString(N, bA(bv)), ";_;_;_;_;_;"), "_")
1345
1345
 
    let cf = gD(split(gm[bq], ";")[1])
1346
1346
 
    let cl = gD(split(gm[br], ";")[0])
1347
1347
 
    let hG = cc(cd, ce, cf)
1348
1348
 
    let hH = ck(cd, ce, cl)
1349
1349
 
    $Tuple2(nil, [("%s%d__dodgeProbability__" + toString(hG)), ("%s%d__damageAbsorption__" + toString(hH))])
1350
1350
 
    }
1351
1351
 
1352
1352
 
1353
1353
 
1354
1354
 
@Callable(ha)
1355
1355
 
func customDuckStatsCalculatorREADONLY (cd,ce,cf,cl) = {
1356
1356
 
    let hG = cc(cd, ce, cf)
1357
1357
 
    let hH = ck(cd, ce, cl)
1358
1358
 
    $Tuple2(nil, [("%s%d__dodgeProbability__" + toString(hG)), ("%s%d__damageAbsorption__" + toString(hH))])
1359
1359
 
    }
1360
1360
 
1361
1361
 
1362
1362
 
1363
1363
 
@Callable(ha)
1364
1364
 
func acresStatsREADONLY (aj) = {
1365
1365
 
    let hI = fe(invoke(O, "claimAcresREADONLY", [aj], nil))
1366
1366
 
    let hJ = fc(hI[0])
1367
1367
 
    let hK = fc(hI[1])
1368
1368
 
    $Tuple2(nil, [("%s%d__acresIssuedTotal__" + toString(valueOrElse(getInteger(O, ep), 0))), ("%s%d__acresUnsold__" + toString(assetBalance(O, er))), ("%s%d__acresStakedTotal__" + toString(valueOrElse(getInteger(O, C), 0))), ("%s%d__acresStakedByUser__" + toString(valueOrElse(getInteger(O, z(aj)), 0))), ("%s%d__acresClaimableByUser__" + toString(hJ)), ("%s%d__acresLastClaimTimeByUser__" + toString(hK)), ("%s%d__acresLockedByUser__" + toString(valueOrElse(getInteger(O, A(aj)), 0))), ("%s%d__acresLockedEtaByUser__" + toString(valueOrElse(getInteger(O, B(aj)), 0)))])
1369
1369
 
    }
1370
1370
 
1371
1371
 
1372
1372
 
1373
1373
 
@Callable(ha)
1374
1374
 
func testV4 () = $Tuple2(nil, gT(nil))
1375
1375
 
1376
1376
 

github/deemru/w8io/026f985 
177.01 ms ◑