tx · EqEmydXQaTjWPfmRM6zVBbsZZk4vvHHvpba4pyQRAAhD

3Mwb8GE6NHaDxJTby35u2sNAEmDQMWYupCn:  -0.02700000 Waves

2023.06.27 16:48 [2641147] smart account 3Mwb8GE6NHaDxJTby35u2sNAEmDQMWYupCn > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EqEmydXQaTjWPfmRM6zVBbsZZk4vvHHvpba4pyQRAAhD",
    "fee": 2700000,
    "feeAssetId": null,
    "timestamp": 1687873716536,
    "version": 2,
    "chainId": 84,
    "sender": "3Mwb8GE6NHaDxJTby35u2sNAEmDQMWYupCn",
    "senderPublicKey": "6oJuynzr7rKRYRDWhDrENciDLidQuVGfe82pK7hr5nev",
    "proofs": [
        "3UgCS2PTe6VXqZMnSSZLD2Zxao9stnVSQWXPZzZaHuMMrYyfGMgBq3tWw4iHXYQa8USndJwpn3Nt75sm8bSUQ2GG"
    ],
    "script": "base64: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",
    "height": 2641147,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 85KozyrhNUPToRVEs9Hrh7iRvroUzXyr7JZeETzYHuAe
Next: HMJjWqZSL9A9HwZYTg3ZuL3QrUcttfVmy4H9EqBy2pLD

Diff: 
Old
New
Differences
7
7
 
8
8
 
let c = base58'34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ'
9
9
 
10
-
let d = base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
10
+
let d = base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
11
11
 
12
12
 
let e = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
13
13
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let a = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
5
5
 
6
6
 
let b = base58'HEB8Qaw9xrWpWs8tHsiATYGBWDBtP2S7kcPALrMu43AS'
7
7
 
8
8
 
let c = base58'34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ'
9
9
 
10
-
let d = base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
10
+
let d = base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
11
11
 
12
12
 
let e = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
13
13
 
14
14
 
let f = "HEB8Qaw9xrWpWs8tHsiATYGBWDBtP2S7kcPALrMu43AS"
15
15
 
16
16
 
let g = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
17
17
 
18
18
 
let h = "9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi"
19
19
 
20
20
 
let i = Address(base58'3PFDgzu1UtswAkCMxqqQjbTeHaX4cMab8Kh')
21
21
 
22
22
 
let j = Address(base58'3PLjwHcz9NEuaTo63NZR9B9okQiKQxZSbmf')
23
23
 
24
24
 
let k = base58'4z8CKSYQBKkzx7PBb5uBP1YPa6YAHRNTApW1sQVHT5eU'
25
25
 
26
26
 
func l (m) = {
27
27
 
    let n = getInteger(this, m)
28
28
 
    if ($isInstanceOf(n, "Int"))
29
29
 
        then {
30
30
 
            let o = n
31
31
 
            o
32
32
 
            }
33
33
 
        else 0
34
34
 
    }
35
35
 
36
36
 
37
37
 
func p (m) = {
38
38
 
    let n = getBinary(this, m)
39
39
 
    if ($isInstanceOf(n, "ByteVector"))
40
40
 
        then {
41
41
 
            let o = n
42
42
 
            o
43
43
 
            }
44
44
 
        else base58''
45
45
 
    }
46
46
 
47
47
 
48
48
 
func q (m) = {
49
49
 
    let n = getString(this, m)
50
50
 
    if ($isInstanceOf(n, "String"))
51
51
 
        then {
52
52
 
            let o = n
53
53
 
            o
54
54
 
            }
55
55
 
        else ""
56
56
 
    }
57
57
 
58
58
 
59
59
 
func r (s) = {
60
60
 
    let n = s
61
61
 
    if ($isInstanceOf(n, "ByteVector"))
62
62
 
        then {
63
63
 
            let o = n
64
64
 
            toBase58String(o)
65
65
 
            }
66
66
 
        else "WAVES"
67
67
 
    }
68
68
 
69
69
 
70
70
 
func t (u) = if ((u == "WAVES"))
71
71
 
    then unit
72
72
 
    else fromBase58String(u)
73
73
 
74
74
 
75
75
 
func v (w,x) = (w :+ t(x))
76
76
 
77
77
 
78
78
 
func y (w,x) = (w :+ l((("static_" + r(x)) + "_weight")))
79
79
 
80
80
 
81
81
 
func z (w,x) = (w :+ l((("static_" + r(x)) + "_decimals")))
82
82
 
83
83
 
84
84
 
func A (w,x) = (w :+ l((("static_" + r(x)) + "_scale")))
85
85
 
86
86
 
87
87
 
func B (w,x) = (w :+ parseIntValue(x))
88
88
 
89
89
 
90
90
 
let C = l("static_tokensAmount")
91
91
 
92
92
 
let D = {
93
93
 
    let E = split(q("static_tokenIds"), ",")
94
94
 
    let F = size(E)
95
95
 
    let G = nil
96
96
 
    func H (I,J) =     if ((J >= F))
97
97
 
        then I
98
98
 
        else v(I, E[J])
99
99
 
100
100
 
    func K (I,J) =     if ((J >= F))
101
101
 
        then I
102
102
 
        else throw("List size exceeds 10")
103
103
 
104
104
 
    K(H(H(H(H(H(H(H(H(H(H(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
105
105
 
    }
106
106
 
107
107
 
let L = {
108
108
 
    let E = D
109
109
 
    let F = size(E)
110
110
 
    let G = nil
111
111
 
    func M (I,J) =     if ((J >= F))
112
112
 
        then I
113
113
 
        else y(I, E[J])
114
114
 
115
115
 
    func N (I,J) =     if ((J >= F))
116
116
 
        then I
117
117
 
        else throw("List size exceeds 10")
118
118
 
119
119
 
    N(M(M(M(M(M(M(M(M(M(M(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
120
120
 
    }
121
121
 
122
122
 
let O = {
123
123
 
    let E = D
124
124
 
    let F = size(E)
125
125
 
    let G = nil
126
126
 
    func P (I,J) =     if ((J >= F))
127
127
 
        then I
128
128
 
        else z(I, E[J])
129
129
 
130
130
 
    func Q (I,J) =     if ((J >= F))
131
131
 
        then I
132
132
 
        else throw("List size exceeds 10")
133
133
 
134
134
 
    Q(P(P(P(P(P(P(P(P(P(P(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
135
135
 
    }
136
136
 
137
137
 
let R = {
138
138
 
    let E = D
139
139
 
    let F = size(E)
140
140
 
    let G = nil
141
141
 
    func S (I,J) =     if ((J >= F))
142
142
 
        then I
143
143
 
        else A(I, E[J])
144
144
 
145
145
 
    func T (I,J) =     if ((J >= F))
146
146
 
        then I
147
147
 
        else throw("List size exceeds 10")
148
148
 
149
149
 
    T(S(S(S(S(S(S(S(S(S(S(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
150
150
 
    }
151
151
 
152
152
 
let U = l("static_fee")
153
153
 
154
154
 
let V = 4
155
155
 
156
156
 
let W = 10000
157
157
 
158
158
 
let X = 100000000
159
159
 
160
160
 
let Y = 10000
161
161
 
162
162
 
let Z = 8
163
163
 
164
164
 
let aa = pow(10, 0, Z, 0, 0, HALFUP)
165
165
 
166
166
 
let ab = D
167
167
 
168
168
 
func ac () = {
169
169
 
    let n = getBoolean(Address(base58'3PEpv9hRFWEEBU22WRnLsw1bH4YGtcU728o'), "is_shutdown")
170
170
 
    if ($isInstanceOf(n, "Boolean"))
171
171
 
        then {
172
172
 
            let ad = n
173
173
 
            ad
174
174
 
            }
175
175
 
        else false
176
176
 
    }
177
177
 
178
178
 
179
179
 
func ae (af) = {
180
180
 
    let ag = r(D[af])
181
181
 
    l((("global_" + ag) + "_balance"))
182
182
 
    }
183
183
 
184
184
 
185
185
 
func ah (ai,ag) = {
186
186
 
    let aj = l("global_poolToken_amount")
187
187
 
    let ak = l((("global_" + r(ag)) + "_balance"))
188
188
 
    fraction(ai, aj, ak, DOWN)
189
189
 
    }
190
190
 
191
191
 
192
192
 
func al (am) = {
193
193
 
    func an (w,ao) =     {
194
194
 
        let ap = ah(ao.amount, ao.assetId)
195
195
 
        if ((ap == 0))
196
196
 
            then throw("one of the tokens amounts is too low")
197
197
 
            else if (if ((w == 0))
198
198
 
                then true
199
199
 
                else (w > ap))
200
200
 
                then ap
201
201
 
                else w
202
202
 
        }
203
203
 
204
204
 
    let E = am
205
205
 
    let F = size(E)
206
206
 
    let G = 0
207
207
 
    func aq (I,J) =     if ((J >= F))
208
208
 
        then I
209
209
 
        else an(I, E[J])
210
210
 
211
211
 
    func ar (I,J) =     if ((J >= F))
212
212
 
        then I
213
213
 
        else throw("List size exceeds 10")
214
214
 
215
215
 
    ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
216
216
 
    }
217
217
 
218
218
 
219
219
 
func as (s,ai,at,au) = {
220
220
 
    let av = indexOf(D, a)
221
221
 
    let aw = indexOf(D, b)
222
222
 
    let ax = indexOf(D, c)
223
223
 
    let ay = indexOf(D, unit)
224
224
 
    let az = l((("static_" + r(s)) + "_weight"))
225
225
 
    let aA = q("static_feeToken")
226
226
 
    if ((aA == f))
227
227
 
        then {
228
228
 
            let aB = L[value(indexOf(D, b))]
229
229
 
            let aC = l((("global_" + f) + "_balance"))
230
230
 
            let aD = fraction(ai, (aC / aB), (at / az))
231
231
 
            let aE = getIntegerValue(i, "global_lastPuzzlePrice")
232
232
 
            fraction((aD * aE), 1, X)
233
233
 
            }
234
234
 
        else if ((aA == g))
235
235
 
            then {
236
236
 
                let aF = L[value(ax)]
237
237
 
                let aG = l((("global_" + g) + "_balance"))
238
238
 
                fraction(ai, (aG / aF), (at / az))
239
239
 
                }
240
240
 
            else if ((aA == e))
241
241
 
                then {
242
242
 
                    let aH = L[value(indexOf(D, a))]
243
243
 
                    let aI = {
244
244
 
                        let n = au
245
245
 
                        if ($isInstanceOf(n, "Int"))
246
246
 
                            then {
247
247
 
                                let ad = n
248
248
 
                                au
249
249
 
                                }
250
250
 
                            else l((("global_" + r(a)) + "_balance"))
251
251
 
                        }
252
252
 
                    fraction(ai, (value(aI) / aH), (at / az))
253
253
 
                    }
254
254
 
                else {
255
255
 
                    let aJ = 3000
256
256
 
                    let aK = (l("global_WAVES_balance") / 50)
257
257
 
                    fraction(ai, (aK / aJ), (at / az))
258
258
 
                    }
259
259
 
    }
260
260
 
261
261
 
262
262
 
func aL (am) = {
263
263
 
    func aM (w,aN) =     (w :+ aN.assetId)
264
264
 
265
265
 
    let aO = {
266
266
 
        let E = am
267
267
 
        let F = size(E)
268
268
 
        let G = nil
269
269
 
        func aq (I,J) =         if ((J >= F))
270
270
 
            then I
271
271
 
            else aM(I, E[J])
272
272
 
273
273
 
        func ar (I,J) =         if ((J >= F))
274
274
 
            then I
275
275
 
            else throw("List size exceeds 10")
276
276
 
277
277
 
        ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
278
278
 
        }
279
279
 
    if ((aO == aO))
280
280
 
        then {
281
281
 
            func aP (w,s) =             if ((indexOf(aO, s) != unit))
282
282
 
                then (w + 1)
283
283
 
                else throw(("asset not attached: " + r(s)))
284
284
 
285
285
 
            let aQ = {
286
286
 
                let E = D
287
287
 
                let F = size(E)
288
288
 
                let G = 0
289
289
 
                func aR (I,J) =                 if ((J >= F))
290
290
 
                    then I
291
291
 
                    else aP(I, E[J])
292
292
 
293
293
 
                func aS (I,J) =                 if ((J >= F))
294
294
 
                    then I
295
295
 
                    else throw("List size exceeds 10")
296
296
 
297
297
 
                aS(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
298
298
 
                }
299
299
 
            if ((aQ == aQ))
300
300
 
                then true
301
301
 
                else throw("Strict value is not equal to itself.")
302
302
 
            }
303
303
 
        else throw("Strict value is not equal to itself.")
304
304
 
    }
305
305
 
306
306
 
307
307
 
func aT (ap,am,aU,aV) = {
308
308
 
    func aW (ag) =     {
309
309
 
        func an (w,aN) =         if ((aN.assetId == ag))
310
310
 
            then aN.amount
311
311
 
            else w
312
312
 
313
313
 
        let E = am
314
314
 
        let F = size(E)
315
315
 
        let G = 0
316
316
 
        func aq (I,J) =         if ((J >= F))
317
317
 
            then I
318
318
 
            else an(I, E[J])
319
319
 
320
320
 
        func ar (I,J) =         if ((J >= F))
321
321
 
            then I
322
322
 
            else throw("List size exceeds 10")
323
323
 
324
324
 
        ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
325
325
 
        }
326
326
 
327
327
 
    func aX (w,ag) =     {
328
328
 
        let aY = l((("global_" + r(ag)) + "_balance"))
329
329
 
        let aZ = l("global_poolToken_amount")
330
330
 
        let ba = l((("static_" + r(ag)) + "_scale"))
331
331
 
        let bb = fraction((fraction((aZ + ap), ba, aZ, CEILING) - ba), aY, ba, CEILING)
332
332
 
        let bc = aW(ag)
333
333
 
        let bd = ((if ((bc != 0))
334
334
 
            then bc
335
335
 
            else 0) - bb)
336
336
 
        let be = if (if (aV)
337
337
 
            then (bd > 0)
338
338
 
            else false)
339
339
 
            then [ScriptTransfer(aU, bd, ag)]
340
340
 
            else nil
341
341
 
        ((w ++ be) :+ IntegerEntry((("global_" + r(ag)) + "_balance"), (aY + bb)))
342
342
 
        }
343
343
 
344
344
 
    let E = D
345
345
 
    let F = size(E)
346
346
 
    let G = nil
347
347
 
    func aq (I,J) =     if ((J >= F))
348
348
 
        then I
349
349
 
        else aX(I, E[J])
350
350
 
351
351
 
    func ar (I,J) =     if ((J >= F))
352
352
 
        then I
353
353
 
        else throw("List size exceeds 10")
354
354
 
355
355
 
    ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
356
356
 
    }
357
357
 
358
358
 
359
359
 
func bf (bg,aU) = {
360
360
 
    func bh (w,ag) =     {
361
361
 
        let aY = l((("global_" + r(ag)) + "_balance"))
362
362
 
        let aZ = l("global_poolToken_amount")
363
363
 
        let ba = l((("static_" + r(ag)) + "_scale"))
364
364
 
        let ai = toInt(fraction((toBigInt(X) - fraction(toBigInt((aZ - bg)), toBigInt(X), toBigInt(aZ), CEILING)), toBigInt(aY), toBigInt(X), DOWN))
365
365
 
        ((w :+ IntegerEntry((("global_" + r(ag)) + "_balance"), (aY - ai))) :+ ScriptTransfer(aU, ai, ag))
366
366
 
        }
367
367
 
368
368
 
    let E = D
369
369
 
    let F = size(E)
370
370
 
    let G = nil
371
371
 
    func aq (I,J) =     if ((J >= F))
372
372
 
        then I
373
373
 
        else bh(I, E[J])
374
374
 
375
375
 
    func ar (I,J) =     if ((J >= F))
376
376
 
        then I
377
377
 
        else throw("List size exceeds 10")
378
378
 
379
379
 
    ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
380
380
 
    }
381
381
 
382
382
 
383
383
 
func bi (bj,bk,bl,bm,bn) = {
384
384
 
    let bo = value(indexOf(D, bk))
385
385
 
    let bp = value(indexOf(D, bl))
386
386
 
    if ((bo == bp))
387
387
 
        then throw("wrong tokens pair")
388
388
 
        else fraction(bn, ((X * X) - toInt(pow(fraction(toBigInt(bm), toBigInt((X * X)), toBigInt((bm + bj)), HALFUP), 16, toBigInt(fraction(L[bo], 10000, L[bp])), 4, 16, CEILING))), (X * X), DOWN)
389
389
 
    }
390
390
 
391
391
 
392
392
 
func bq (s) = {
393
393
 
    let n = s
394
394
 
    if ($isInstanceOf(n, "ByteVector"))
395
395
 
        then {
396
396
 
            let be = n
397
397
 
            assetBalance(this, be)
398
398
 
            }
399
399
 
        else wavesBalance(this).available
400
400
 
    }
401
401
 
402
402
 
403
403
 
func br (s,u,at,bs) = {
404
404
 
    let bt = l("global_indexStaked")
405
405
 
    let bu = bs
406
406
 
    let bv = (bq(s) - at)
407
407
 
    let bw = if ((bv > bu))
408
408
 
        then bv
409
409
 
        else bu
410
410
 
    let bx = (bw - bu)
411
411
 
    let by = if ((bt == 0))
412
412
 
        then 0
413
413
 
        else fraction(bx, X, bt)
414
414
 
    let bz = l((("global_lastCheck_" + u) + "_interest"))
415
415
 
    (bz + by)
416
416
 
    }
417
417
 
418
418
 
419
419
 
func bA (bB) = {
420
420
 
    let bC = toString(bB)
421
421
 
    let bD = l((bC + "_indexStaked"))
422
422
 
    func an (w,s) =     {
423
423
 
        let u = r(s)
424
424
 
        let at = l((("global_" + r(s)) + "_balance"))
425
425
 
        let bs = l((("global_lastCheck_" + u) + "_earnings"))
426
426
 
        let bE = br(s, u, at, bs)
427
427
 
        let bw = max([bs, (bq(s) - at)])
428
428
 
        let bF = fraction(bD, (bE - l((((bC + "_lastCheck_") + u) + "_interest"))), X)
429
429
 
        let bG = if ((bF == 0))
430
430
 
            then nil
431
431
 
            else [ScriptTransfer(bB, bF, s)]
432
432
 
        $Tuple2(((w._1 ++ bG) ++ [IntegerEntry((("global_lastCheck_" + u) + "_earnings"), (bw - bF)), IntegerEntry((("global_lastCheck_" + u) + "_interest"), bE), IntegerEntry((((bC + "_lastCheck_") + u) + "_interest"), bE)]), (w._2 + as(s, bF, at, unit)))
433
433
 
        }
434
434
 
435
435
 
    let w = {
436
436
 
        let E = ab
437
437
 
        let F = size(E)
438
438
 
        let G = $Tuple2(nil, 0)
439
439
 
        func aq (I,J) =         if ((J >= F))
440
440
 
            then I
441
441
 
            else an(I, E[J])
442
442
 
443
443
 
        func ar (I,J) =         if ((J >= F))
444
444
 
            then I
445
445
 
            else throw("List size exceeds 10")
446
446
 
447
447
 
        ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
448
448
 
        }
449
449
 
    $Tuple2((w._1 ++ [IntegerEntry((bC + "_claimedRewardValue"), (l((bC + "_claimedRewardValue")) + w._2)), IntegerEntry((bC + "_lastClaim"), lastBlock.timestamp)]), w._2)
450
450
 
    }
451
451
 
452
452
 
453
453
 
func bH (bC,ai) = {
454
454
 
    let bI = bA(addressFromStringValue(bC))._1
455
455
 
    (bI ++ [IntegerEntry((bC + "_indexStaked"), (l((bC + "_indexStaked")) + ai)), IntegerEntry("global_indexStaked", (l("global_indexStaked") + ai))])
456
456
 
    }
457
457
 
458
458
 
459
459
 
func bJ (w,bK) = (w + parseIntValue(bK))
460
460
 
461
461
 
462
462
 
@Callable(bL)
463
463
 
func preInit (bM,bN,bO,bP,bQ,bR) = {
464
464
 
    let bS = Address(fromBase58String(bQ))
465
465
 
    if (ac())
466
466
 
        then throw("contract is on stop")
467
467
 
        else if ((this != bL.caller))
468
468
 
            then throw("admin only")
469
469
 
            else if ((size(bP) > 13))
470
470
 
                then throw("too large pool domain")
471
471
 
                else if (if ((50 > bR))
472
472
 
                    then true
473
473
 
                    else (bR > 500))
474
474
 
                    then throw("fee value must be between 50 and 500 (0.5-5%)")
475
475
 
                    else if (if (if (if (if ((indexOf(bM, f) == unit))
476
476
 
                        then (indexOf(bM, e) == unit)
477
477
 
                        else false)
478
478
 
                        then (indexOf(bM, g) == unit)
479
479
 
                        else false)
480
480
 
                        then (indexOf(bM, "WAVES") == unit)
481
481
 
                        else false)
482
482
 
                        then (indexOf(bM, h) == unit)
483
483
 
                        else false)
484
484
 
                        then throw("pool must have USDT-WXG, USDT-PPT, USDN, WAVES or PUZZLE in the composition")
485
485
 
                        else {
486
486
 
                            let bT = split(bM, ",")
487
487
 
                            let bU = {
488
488
 
                                let E = bT
489
489
 
                                let F = size(E)
490
490
 
                                let G = nil
491
491
 
                                func aq (I,J) =                                 if ((J >= F))
492
492
 
                                    then I
493
493
 
                                    else v(I, E[J])
494
494
 
495
495
 
                                func ar (I,J) =                                 if ((J >= F))
496
496
 
                                    then I
497
497
 
                                    else throw("List size exceeds 10")
498
498
 
499
499
 
                                ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
500
500
 
                                }
501
501
 
                            let bV = split(bN, ",")
502
502
 
                            let bW = {
503
503
 
                                let E = bV
504
504
 
                                let F = size(E)
505
505
 
                                let G = 0
506
506
 
                                func aR (I,J) =                                 if ((J >= F))
507
507
 
                                    then I
508
508
 
                                    else bJ(I, E[J])
509
509
 
510
510
 
                                func aS (I,J) =                                 if ((J >= F))
511
511
 
                                    then I
512
512
 
                                    else throw("List size exceeds 10")
513
513
 
514
514
 
                                aS(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
515
515
 
                                }
516
516
 
                            let aA = if ((indexOf(bM, e) != unit))
517
517
 
                                then e
518
518
 
                                else if ((indexOf(bM, "WAVES") != unit))
519
519
 
                                    then "WAVES"
520
520
 
                                    else if ((indexOf(bM, g) != unit))
521
521
 
                                        then g
522
522
 
                                        else if ((indexOf(bM, f) != unit))
523
523
 
                                            then f
524
524
 
                                            else h
525
525
 
                            func bX (w,bY) =                             if ((bY >= size(bU)))
526
526
 
                                then w
527
527
 
                                else {
528
528
 
                                    let bZ = {
529
529
 
                                        let n = bU[bY]
530
530
 
                                        if ($isInstanceOf(n, "ByteVector"))
531
531
 
                                            then {
532
532
 
                                                let ad = n
533
533
 
                                                value(assetInfo(ad)).decimals
534
534
 
                                                }
535
535
 
                                            else 8
536
536
 
                                        }
537
537
 
                                    (w ++ [IntegerEntry((("static_" + bT[bY]) + "_scale"), pow(10, 0, bZ, 0, 0, DOWN)), IntegerEntry((("static_" + bT[bY]) + "_decimals"), bZ), IntegerEntry((("static_" + bT[bY]) + "_weight"), value(parseInt(bV[bY])))])
538
538
 
                                    }
539
539
 
540
540
 
                            if ((bW != 10000))
541
541
 
                                then throw("sum of token weights must be equal to 10000")
542
542
 
                                else ({
543
543
 
                                    let E = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
544
544
 
                                    let F = size(E)
545
545
 
                                    let G = nil
546
546
 
                                    func ca (I,J) =                                     if ((J >= F))
547
547
 
                                        then I
548
548
 
                                        else bX(I, E[J])
549
549
 
550
550
 
                                    func cb (I,J) =                                     if ((J >= F))
551
551
 
                                        then I
552
552
 
                                        else throw("List size exceeds 10")
553
553
 
554
554
 
                                    cb(ca(ca(ca(ca(ca(ca(ca(ca(ca(ca(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
555
555
 
                                    } ++ [StringEntry("static_tokenIds", bM), StringEntry("static_feeToken", aA), StringEntry("static_tokenWeights", bN), IntegerEntry("static_tokensAmount", size(bU)), StringEntry("static_poolDomain", bP), StringEntry("static_baseTokenId", bO), StringEntry("static_poolOwner", bQ), IntegerEntry("static_fee", bR)])
556
556
 
                            }
557
557
 
    }
558
558
 
559
559
 
560
560
 
561
561
 
@Callable(bL)
562
562
 
func deInit () = if ((bL.caller != this))
563
563
 
    then throw("admin only")
564
564
 
    else [IntegerEntry("global_wasInited", 0)]
565
565
 
566
566
 
567
567
 
568
568
 
@Callable(bL)
569
569
 
func init () = {
570
570
 
    func cc () =     {
571
571
 
        func an (w,bK) =         (w :+ IntegerEntry((("global_" + r(bK.assetId)) + "_balance"), bK.amount))
572
572
 
573
573
 
        let E = bL.payments
574
574
 
        let F = size(E)
575
575
 
        let G = nil
576
576
 
        func aq (I,J) =         if ((J >= F))
577
577
 
            then I
578
578
 
            else an(I, E[J])
579
579
 
580
580
 
        func ar (I,J) =         if ((J >= F))
581
581
 
            then I
582
582
 
            else throw("List size exceeds 10")
583
583
 
584
584
 
        ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
585
585
 
        }
586
586
 
587
587
 
    func cd (am) =     {
588
588
 
        func an (w,ce) =         {
589
589
 
            let s = ce.assetId
590
590
 
            func aP (w,bK) =             if ((bK == s))
591
591
 
                then value(indexOf(D, bK))
592
592
 
                else w
593
593
 
594
594
 
            let cf = {
595
595
 
                let E = D
596
596
 
                let F = size(E)
597
597
 
                let G = 1
598
598
 
                func aq (I,J) =                 if ((J >= F))
599
599
 
                    then I
600
600
 
                    else aP(I, E[J])
601
601
 
602
602
 
                func ar (I,J) =                 if ((J >= F))
603
603
 
                    then I
604
604
 
                    else throw("List size exceeds 10")
605
605
 
606
606
 
                ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
607
607
 
                }
608
608
 
            fraction(w, pow(ce.amount, O[cf], L[cf], V, 8, FLOOR), X)
609
609
 
            }
610
610
 
611
611
 
        let E = am
612
612
 
        let F = size(E)
613
613
 
        let G = aa
614
614
 
        func aq (I,J) =         if ((J >= F))
615
615
 
            then I
616
616
 
            else an(I, E[J])
617
617
 
618
618
 
        func ar (I,J) =         if ((J >= F))
619
619
 
            then I
620
620
 
            else throw("List size exceeds 10")
621
621
 
622
622
 
        ar(aq(aq(aq(aq(aq(aq(aq(aq(aq(aq(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
623
623
 
        }
624
624
 
625
625
 
    if (ac())
626
626
 
        then throw("contract is on stop")
627
627
 
        else if ((l("global_wasInited") > 0))
628
628
 
            then throw("pool already inited")
629
629
 
            else {
630
630
 
                let cg = cd(bL.payments)
631
631
 
                if ((cg == 0))
632
632
 
                    then throw("you need a bigger tokens amount to launch the pool")
633
633
 
                    else {
634
634
 
                        let ch = Issue(("PZ " + q("static_poolDomain")), "Puzzle Swap: pool index token", cg, Z, true, unit, 0)
635
635
 
                        let ci = calculateAssetId(ch)
636
636
 
                        (cc() ++ [ch, IntegerEntry("global_poolToken_amount", cg), IntegerEntry("global_wasInited", 1), BinaryEntry("global_poolToken_id", ci), StringEntry("static_poolToken_idStr", r(ci)), IntegerEntry((toString(bL.caller) + "_indexStaked"), cg), IntegerEntry("global_indexStaked", cg)])
637
637
 
                        }
638
638
 
                }
639
639
 
    }
640
640
 
641
641
 
642
642
 
643
643
 
@Callable(bL)
644
644
 
func generateIndex (aV) = if (ac())
645
645
 
    then throw("contract is on stop")
646
646
 
    else if ((size(bL.payments) != C))
647
647
 
        then throw(("you need to attach all pool tokens. amount of pool tokens: " + toString(C)))
648
648
 
        else if (!(aL(bL.payments)))
649
649
 
            then throw("wrong assets attached")
650
650
 
            else {
651
651
 
                let ap = al(bL.payments)
652
652
 
                let cj = Reissue(getBinaryValue("global_poolToken_id"), ap, true)
653
653
 
                let ck = aT(ap, bL.payments, bL.originCaller, aV)
654
654
 
                $Tuple2((ck ++ [cj, ScriptTransfer(bL.caller, ap, p("global_poolToken_id")), IntegerEntry("global_poolToken_amount", (l("global_poolToken_amount") + ap))]), ap)
655
655
 
                }
656
656
 
657
657
 
658
658
 
659
659
 
@Callable(bL)
660
660
 
func stakeIndex () = {
661
661
 
    let bC = toString(bL.originCaller)
662
662
 
    let ce = bL.payments[0]
663
663
 
    if (ac())
664
664
 
        then throw("contract is on stop")
665
665
 
        else if ((value(ce.assetId) != p("global_poolToken_id")))
666
666
 
            then throw("wrong asset attached")
667
667
 
            else bH(bC, ce.amount)
668
668
 
    }
669
669
 
670
670
 
671
671
 
672
672
 
@Callable(bL)
673
673
 
func unstakeIndex (bD) = {
674
674
 
    let bC = toString(bL.originCaller)
675
675
 
    let cl = l((bC + "_indexStaked"))
676
676
 
    if (ac())
677
677
 
        then throw("contract is on stop")
678
678
 
        else if ((bD > cl))
679
679
 
            then throw("you don't have index tokens available")
680
680
 
            else (bA(bL.originCaller)._1 ++ [IntegerEntry((bC + "_indexStaked"), (cl - bD)), IntegerEntry("global_indexStaked", (l("global_indexStaked") - bD)), ScriptTransfer(bL.caller, bD, getBinaryValue("global_poolToken_id"))])
681
681
 
    }
682
682
 
683
683
 
684
684
 
685
685
 
@Callable(bL)
686
686
 
func claimIndexRewards () = if (ac())
687
687
 
    then throw("contract is on stop")
688
688
 
    else bA(bL.caller)
689
689
 
690
690
 
691
691
 
692
692
 
@Callable(bL)
693
693
 
func evaluateClaim (cm) = $Tuple2(nil, bA(addressFromStringValue(cm))._2)
694
694
 
695
695
 
696
696
 
697
697
 
@Callable(bL)
698
698
 
func redeemIndex (cn) = {
699
699
 
    let ce = bL.payments[0]
700
700
 
    if ((ce.assetId != p("global_poolToken_id")))
701
701
 
        then throw("please attach pool share token")
702
702
 
        else if (ac())
703
703
 
            then throw("contract is on stop")
704
704
 
            else {
705
705
 
                let bg = ce.amount
706
706
 
                let ck = bf(bg, if (cn)
707
707
 
                    then bL.originCaller
708
708
 
                    else bL.caller)
709
709
 
                (ck ++ [Burn(p("global_poolToken_id"), bg), IntegerEntry("global_poolToken_amount", (l("global_poolToken_amount") - bg))])
710
710
 
                }
711
711
 
    }
712
712
 
713
713
 
714
714
 
715
715
 
@Callable(bL)
716
716
 
func swap (bl,co) = {
717
717
 
    let ce = if ((size(bL.payments) == 1))
718
718
 
        then value(bL.payments[0])
719
719
 
        else throw("please attach exactly one payment")
720
720
 
    let bj = value(bL.payments[0].amount)
721
721
 
    let cp = ce.assetId
722
722
 
    let cq = t(bl)
723
723
 
    let cr = q("static_feeToken")
724
724
 
    let cs = if ((cr == ""))
725
725
 
        then a
726
726
 
        else t(cr)
727
727
 
    let ct = l((("global_" + r(cp)) + "_balance"))
728
728
 
    let cu = l((("global_" + bl) + "_balance"))
729
729
 
    let cv = fraction(bj, U, Y)
730
730
 
    let cw = (bj - cv)
731
731
 
    let cx = bi(cw, cp, cq, ct, cu)
732
732
 
    let cy = (cu - cx)
733
733
 
    let cz = (ct + cw)
734
734
 
    let cA = if ((cs == cp))
735
735
 
        then cz
736
736
 
        else if ((cs == cq))
737
737
 
            then cy
738
738
 
            else l((("global_" + r(cs)) + "_balance"))
739
739
 
    let cB = bi(cv, cp, cs, ct, cA)
740
740
 
    if ((co > cx))
741
741
 
        then throw("amount to recieve is lower than given one")
742
742
 
        else if ((cq == cp))
743
743
 
            then throw("this swap is not allowed")
744
744
 
            else if ((0 > (cu - cx)))
745
745
 
                then throw("contract is out of reserves")
746
746
 
                else if (ac())
747
747
 
                    then throw("contract is on stop")
748
748
 
                    else {
749
749
 
                        let cC = fraction(cB, 1, 10)
750
750
 
                        let cD = fraction(cB, 4, 10)
751
751
 
                        let cE = if (if ((cs == a))
752
752
 
                            then true
753
753
 
                            else (cs == b))
754
754
 
                            then reentrantInvoke(Address(base58'3PFTbywqxtFfukX3HyT881g4iW5K4QL3FAS'), "topUpReward", nil, [AttachedPayment(cs, cD)])
755
755
 
                            else unit
756
756
 
                        if ((cE == cE))
757
757
 
                            then {
758
758
 
                                let cF = cz
759
759
 
                                let cG = (cy - (if ((cq == cs))
760
760
 
                                    then cB
761
761
 
                                    else 0))
762
762
 
                                let cH = if (if ((cs != cp))
763
763
 
                                    then (cs != cq)
764
764
 
                                    else false)
765
765
 
                                    then (cA - cB)
766
766
 
                                    else unit
767
767
 
                                let cI = IntegerEntry((("global_" + r(cp)) + "_balance"), cF)
768
768
 
                                let cJ = IntegerEntry((("global_" + bl) + "_balance"), cG)
769
769
 
                                let cK = if ((cH != unit))
770
770
 
                                    then IntegerEntry((("global_" + r(cs)) + "_balance"), value(cH))
771
771
 
                                    else StringEntry("hello", "world")
772
772
 
                                let cL = as(cp, bj, ct, cA)
773
773
 
                                $Tuple2(([cJ, cI, cK, ScriptTransfer(bL.caller, cx, cq), ScriptTransfer(addressFromStringValue(q("static_poolOwner")), cC, cs), IntegerEntry("global_earnedByOwner", (l("global_earnedByOwner") + cC)), IntegerEntry("global_volume", (l("global_volume") + cL))] ++ (if ((cE == unit))
774
774
 
                                    then [ScriptTransfer(Address(base58'3P4kBiU4wr2yV1S5gMfu3MdkVvy7kxXHsKe'), cD, cs)]
775
775
 
                                    else nil)), cx)
776
776
 
                                }
777
777
 
                            else throw("Strict value is not equal to itself.")
778
778
 
                        }
779
779
 
    }
780
780
 
781
781
 
782
782
 
@Verifier(cM)
783
783
 
func cN () = if (ac())
784
784
 
    then false
785
785
 
    else if (sigVerify(cM.bodyBytes, cM.proofs[0], cM.senderPublicKey))
786
786
 
        then true
787
787
 
        else sigVerify(cM.bodyBytes, cM.proofs[0], k)
788
788
 

github/deemru/w8io/169f3d6 
81.82 ms ◑