tx · AU1Z3PQoMtyKfmycrDZNuYvjESVwfh2jrNrmDQ9Cmy1y

3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk:  -0.01200000 Waves

2022.07.19 11:56 [3211961] smart account 3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AU1Z3PQoMtyKfmycrDZNuYvjESVwfh2jrNrmDQ9Cmy1y",
    "fee": 1200000,
    "feeAssetId": null,
    "timestamp": 1658221056714,
    "version": 2,
    "chainId": 87,
    "sender": "3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk",
    "senderPublicKey": "8bMNZV1S5S2hfim2ZPy5hsSdC1AHBwPHUEXPBhdEF2Mk",
    "proofs": [
        "ffnCQxZFgKRnVvX2wmWnBXzoQnTarMDDxWCBYVq9mJedhzdLaSUeHaLEs1NdGwdM2jDJuYhviRZwa62sX4FaxXU"
    ],
    "script": "base64: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",
    "height": 3211961,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EroTK7gfLiEefzo7qtemZiPGv9apLFTEGESrBXuqGYmN
Next: AA9EwSwRWMdm5VjUeMZCFeEXxaJx7yJ6kVfboKvYAGJj

Diff: 
Old
New
Differences
24
24
 
let wxId = base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
25
25
 
26
26
 
let keySponsorship = "Sponsorship_in_lock"
27
-
28
-
let sponsored = 77900000000
29
27
 
30
28
 
let isStopped = false
31
29
 
352
350
 
    if ((pm.assetId != wxId))
353
351
 
        then throw("Error")
354
352
 
        else {
353
+
            let sponsored = valueOrElse(getInteger(this, keySponsorship), 0)
355
354
 
            let lock = invoke(Address(base58'3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP'), "increaseLock", [lockPeriod], [pm])
356
355
 
            if ((lock == lock))
357
356
 
                then {
358
-
                    let s = IntegerEntry(keySponsorship, sponsored)
357
+
                    let s = IntegerEntry(keySponsorship, (pm.amount + sponsored))
359
358
 
[s]
360
359
 
                    }
361
360
 
                else throw("Strict value is not equal to itself.")
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let usdtUsdnLP = base58'97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf'
5
5
 
6
6
 
let usdtUsdnLPTCI = base58'2CD44HANZzsdU7yqRsmz7L9eA2Foh4YYMC4azMbaZEj6'
7
7
 
8
8
 
let wxUsdnLP = base58'F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9'
9
9
 
10
10
 
let wxUsdnLPTCI = base58'FuUobp3DcfARzDLcvtVW37i7FvMPvCCpgdcvWke8sBuh'
11
11
 
12
12
 
let usdcUsdnLP = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
13
13
 
14
14
 
let usdcUsdnLPTCI = base58'HZKFpNfyPG5gt4D6Nfy1zQSg2Ptmqv932GjNTCyBEeKP'
15
15
 
16
16
 
let usdcUsdtLP = base58'EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH'
17
17
 
18
18
 
let usdcUsdtLPTCI = base58'BqPYkaiz7Le6fFu1rjZ54anrpT57EpvyugZCUqrsjXj'
19
19
 
20
20
 
let puzzleUsdnLP = base58'E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP'
21
21
 
22
22
 
let puzzleUsdnLPTCI = base58'Dh9QXSSABE5V6aRfu3mCbDAUokbpE7ER7pbZV6cvyg1A'
23
23
 
24
24
 
let wxId = base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
25
25
 
26
26
 
let keySponsorship = "Sponsorship_in_lock"
27
-
28
-
let sponsored = 77900000000
29
27
 
30
28
 
let isStopped = false
31
29
 
32
30
 
let keyStaked = "STAKED_LP"
33
31
 
34
32
 
let keyCompound = "From_Compound"
35
33
 
36
34
 
let keywxUsdnCompound = "WX_USDN_compound"
37
35
 
38
36
 
let keyWXUSDN = "WX_USDN"
39
37
 
40
38
 
let keyUsdcUsdnCompound = "USDC_USDN_compound"
41
39
 
42
40
 
let keyUSDCUSDN = "USDC_USDN"
43
41
 
44
42
 
let keyUsdcUsdtCompound = "USDC_USDT_compound"
45
43
 
46
44
 
let keyUSDCUSDT = "USDC_USDT"
47
45
 
48
46
 
let keyPuzzleUsdnCompound = "PUZZLE_USDN_compound"
49
47
 
50
48
 
let keyPUZZLEUSDN = "PUZZLE_USDN"
51
49
 
52
50
 
let oracle = base58'3P6phwFZFQtZFuc9dvdXsgvtg8JEFVgECPA'
53
51
 
54
52
 
func checkAddress (caller) = if ((caller != oracle))
55
53
 
    then false
56
54
 
    else true
57
55
 
58
56
 
59
57
 
@Callable(i)
60
58
 
func depositWxUsdnLP () = {
61
59
 
    let pmt = value(i.payments[0])
62
60
 
    let pmtAmount = pmt.amount
63
61
 
    if ((pmt.assetId != wxUsdnLP))
64
62
 
        then throw("attach WXUSDNLP tokens only")
65
63
 
        else if (isStopped)
66
64
 
            then throw("smart contract is on lock")
67
65
 
            else {
68
66
 
                let tkStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
69
67
 
                let totalIssued =                 match assetInfo(wxUsdnLPTCI) {
70
68
 
                    case asset: Asset => 
71
69
 
                        asset.quantity
72
70
 
                    case _ => 
73
71
 
                        throw("Can't find asset")
74
72
 
                }
75
73
 
                let one = fraction(totalIssued, 100000000, tkStaked)
76
74
 
                let toIssue = fraction(pmtAmount, one, 100000000)
77
75
 
                let updateState = IntegerEntry(keyWXUSDN, (tkStaked + pmtAmount))
78
76
 
                let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
79
77
 
                if ((LPstake == LPstake))
80
78
 
                    then {
81
79
 
                        let LPIssue = Reissue(wxUsdnLPTCI, toIssue, true)
82
80
 
                        let transfer = ScriptTransfer(i.caller, toIssue, wxUsdnLPTCI)
83
81
 
[LPIssue, transfer, updateState]
84
82
 
                        }
85
83
 
                    else throw("Strict value is not equal to itself.")
86
84
 
                }
87
85
 
    }
88
86
 
89
87
 
90
88
 
91
89
 
@Callable(i)
92
90
 
func depositUsdtUsdnLP () = {
93
91
 
    let pmt = value(i.payments[0])
94
92
 
    let pmtAmount = pmt.amount
95
93
 
    if ((pmt.assetId != usdtUsdnLP))
96
94
 
        then throw("attach USDTUSDNLP tokens only")
97
95
 
        else if (isStopped)
98
96
 
            then throw("smart contract is on lock")
99
97
 
            else {
100
98
 
                let tkStaked = valueOrElse(getInteger(this, keyStaked), 0)
101
99
 
                let totalIssued =                 match assetInfo(usdtUsdnLPTCI) {
102
100
 
                    case asset: Asset => 
103
101
 
                        asset.quantity
104
102
 
                    case _ => 
105
103
 
                        throw("Can't find asset")
106
104
 
                }
107
105
 
                let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
108
106
 
                let forOne = fraction(totalIssued, 100000000, tkStaked)
109
107
 
                let toIssue = fraction(pmtAmount, forOne, 100000000)
110
108
 
                let updateState = IntegerEntry(keyStaked, (tkStaked + pmtAmount))
111
109
 
                let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
112
110
 
                if ((LPstake == LPstake))
113
111
 
                    then {
114
112
 
                        let LPIssue = Reissue(usdtUsdnLPTCI, toIssue, true)
115
113
 
                        let transfer = ScriptTransfer(i.caller, toIssue, usdtUsdnLPTCI)
116
114
 
[LPIssue, transfer, updateState]
117
115
 
                        }
118
116
 
                    else throw("Strict value is not equal to itself.")
119
117
 
                }
120
118
 
    }
121
119
 
122
120
 
123
121
 
124
122
 
@Callable(i)
125
123
 
func depositUsdcUsdnLP () = {
126
124
 
    let pmt = value(i.payments[0])
127
125
 
    let pmtAmount = pmt.amount
128
126
 
    if ((pmt.assetId != usdcUsdnLP))
129
127
 
        then throw("attach USDCUSDNLP tokens only")
130
128
 
        else if (isStopped)
131
129
 
            then throw("smart contract is on lock")
132
130
 
            else {
133
131
 
                let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
134
132
 
                let totalIssued =                 match assetInfo(usdcUsdnLPTCI) {
135
133
 
                    case asset: Asset => 
136
134
 
                        asset.quantity
137
135
 
                    case _ => 
138
136
 
                        throw("Can't find asset")
139
137
 
                }
140
138
 
                let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
141
139
 
                let forOne = fraction(totalIssued, 100000000, tkStaked)
142
140
 
                let toIssue = fraction(pmtAmount, forOne, 100000000)
143
141
 
                let updateState = IntegerEntry(keyUSDCUSDN, (tkStaked + pmtAmount))
144
142
 
                let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
145
143
 
                if ((LPstake == LPstake))
146
144
 
                    then {
147
145
 
                        let LPIssue = Reissue(usdcUsdnLPTCI, toIssue, true)
148
146
 
                        let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdnLPTCI)
149
147
 
[LPIssue, transfer, updateState]
150
148
 
                        }
151
149
 
                    else throw("Strict value is not equal to itself.")
152
150
 
                }
153
151
 
    }
154
152
 
155
153
 
156
154
 
157
155
 
@Callable(i)
158
156
 
func depositUsdcUsdtLP () = {
159
157
 
    let pmt = value(i.payments[0])
160
158
 
    let pmtAmount = pmt.amount
161
159
 
    if ((pmt.assetId != usdcUsdtLP))
162
160
 
        then throw("attach USDCUSDTLP tokens only")
163
161
 
        else if (isStopped)
164
162
 
            then throw("smart contract is on lock")
165
163
 
            else {
166
164
 
                let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
167
165
 
                let totalIssued =                 match assetInfo(usdcUsdtLPTCI) {
168
166
 
                    case asset: Asset => 
169
167
 
                        asset.quantity
170
168
 
                    case _ => 
171
169
 
                        throw("Can't find asset")
172
170
 
                }
173
171
 
                let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
174
172
 
                let forOne = fraction(totalIssued, 100000000, tkStaked)
175
173
 
                let toIssue = fraction(pmtAmount, forOne, 100000000)
176
174
 
                let updateState = IntegerEntry(keyUSDCUSDT, (tkStaked + pmtAmount))
177
175
 
                let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
178
176
 
                if ((LPstake == LPstake))
179
177
 
                    then {
180
178
 
                        let LPIssue = Reissue(usdcUsdtLPTCI, toIssue, true)
181
179
 
                        let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdtLPTCI)
182
180
 
[LPIssue, transfer, updateState]
183
181
 
                        }
184
182
 
                    else throw("Strict value is not equal to itself.")
185
183
 
                }
186
184
 
    }
187
185
 
188
186
 
189
187
 
190
188
 
@Callable(i)
191
189
 
func depositPuzzleUsdnLP () = {
192
190
 
    let pmt = value(i.payments[0])
193
191
 
    let pmtAmount = pmt.amount
194
192
 
    if ((pmt.assetId != puzzleUsdnLP))
195
193
 
        then throw("attach PUZZLEUDSNLP tokens only")
196
194
 
        else if (isStopped)
197
195
 
            then throw("smart contract is on lock")
198
196
 
            else {
199
197
 
                let tkStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
200
198
 
                let totalIssued =                 match assetInfo(puzzleUsdnLPTCI) {
201
199
 
                    case asset: Asset => 
202
200
 
                        asset.quantity
203
201
 
                    case _ => 
204
202
 
                        throw("Can't find asset")
205
203
 
                }
206
204
 
                let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
207
205
 
                let forOne = fraction(totalIssued, 100000000, tkStaked)
208
206
 
                let toIssue = fraction(pmtAmount, forOne, 100000000)
209
207
 
                let updateState = IntegerEntry(keyPUZZLEUSDN, (tkStaked + pmtAmount))
210
208
 
                let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
211
209
 
                if ((LPstake == LPstake))
212
210
 
                    then {
213
211
 
                        let LPIssue = Reissue(puzzleUsdnLPTCI, toIssue, true)
214
212
 
                        let transfer = ScriptTransfer(i.caller, toIssue, puzzleUsdnLPTCI)
215
213
 
[LPIssue, transfer, updateState]
216
214
 
                        }
217
215
 
                    else throw("Strict value is not equal to itself.")
218
216
 
                }
219
217
 
    }
220
218
 
221
219
 
222
220
 
223
221
 
@Callable(i)
224
222
 
func compoundWxUsdnLP () = {
225
223
 
    let compound = value(i.payments[0])
226
224
 
    let ca = compound.amount
227
225
 
    let isOracle = checkAddress(i.caller.bytes)
228
226
 
    if ((compound.assetId != wxUsdnLP))
229
227
 
        then throw("attach WXUSDNLP tokens only")
230
228
 
        else if (!(isOracle))
231
229
 
            then throw("You are not authotized to call this function")
232
230
 
            else {
233
231
 
                let fromCompound = valueOrElse(getInteger(this, keywxUsdnCompound), 0)
234
232
 
                let totalStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
235
233
 
                let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
236
234
 
                if ((stakeC == stakeC))
237
235
 
                    then {
238
236
 
                        let updateState = IntegerEntry(keyWXUSDN, (totalStaked + ca))
239
237
 
                        let tc = IntegerEntry(keywxUsdnCompound, (fromCompound + ca))
240
238
 
[updateState, tc]
241
239
 
                        }
242
240
 
                    else throw("Strict value is not equal to itself.")
243
241
 
                }
244
242
 
    }
245
243
 
246
244
 
247
245
 
248
246
 
@Callable(i)
249
247
 
func compoundUsdtUsdnLP () = {
250
248
 
    let compound = value(i.payments[0])
251
249
 
    let ca = compound.amount
252
250
 
    let isOracle = checkAddress(i.caller.bytes)
253
251
 
    if ((compound.assetId != usdtUsdnLP))
254
252
 
        then throw("attach USDTUSDNLP tokens only")
255
253
 
        else if (!(isOracle))
256
254
 
            then throw("You are not authotized to call this function")
257
255
 
            else {
258
256
 
                let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
259
257
 
                let totalStaked = valueOrElse(getInteger(this, keyStaked), 0)
260
258
 
                let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
261
259
 
                if ((stakeC == stakeC))
262
260
 
                    then {
263
261
 
                        let updateState = IntegerEntry(keyStaked, (totalStaked + ca))
264
262
 
                        let tc = IntegerEntry(keyCompound, (fromCompound + ca))
265
263
 
[updateState, tc]
266
264
 
                        }
267
265
 
                    else throw("Strict value is not equal to itself.")
268
266
 
                }
269
267
 
    }
270
268
 
271
269
 
272
270
 
273
271
 
@Callable(i)
274
272
 
func compoundUsdcUsdnLP () = {
275
273
 
    let compound = value(i.payments[0])
276
274
 
    let ca = compound.amount
277
275
 
    let isOracle = checkAddress(i.caller.bytes)
278
276
 
    if ((compound.assetId != usdcUsdnLP))
279
277
 
        then throw("attach USDCUSDNLP tokens only")
280
278
 
        else if (!(isOracle))
281
279
 
            then throw("You are not authotized to call this function")
282
280
 
            else {
283
281
 
                let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
284
282
 
                let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
285
283
 
                let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
286
284
 
                if ((stakeC == stakeC))
287
285
 
                    then {
288
286
 
                        let updateState = IntegerEntry(keyUSDCUSDN, (totalStaked + ca))
289
287
 
                        let tc = IntegerEntry(keyUsdcUsdnCompound, (fromCompound + ca))
290
288
 
[updateState, tc]
291
289
 
                        }
292
290
 
                    else throw("Strict value is not equal to itself.")
293
291
 
                }
294
292
 
    }
295
293
 
296
294
 
297
295
 
298
296
 
@Callable(i)
299
297
 
func compoundUsdcUsdtLP () = {
300
298
 
    let compound = value(i.payments[0])
301
299
 
    let ca = compound.amount
302
300
 
    let isOracle = checkAddress(i.caller.bytes)
303
301
 
    if ((compound.assetId != usdcUsdtLP))
304
302
 
        then throw("attach USDCUSDTLP tokens only")
305
303
 
        else if (!(isOracle))
306
304
 
            then throw("You are not authotized to call this function")
307
305
 
            else {
308
306
 
                let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
309
307
 
                let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
310
308
 
                let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
311
309
 
                if ((stakeC == stakeC))
312
310
 
                    then {
313
311
 
                        let updateState = IntegerEntry(keyUSDCUSDT, (totalStaked + ca))
314
312
 
                        let tc = IntegerEntry(keyUsdcUsdtCompound, (fromCompound + ca))
315
313
 
[updateState, tc]
316
314
 
                        }
317
315
 
                    else throw("Strict value is not equal to itself.")
318
316
 
                }
319
317
 
    }
320
318
 
321
319
 
322
320
 
323
321
 
@Callable(i)
324
322
 
func compoundPuzzleUsdnLP () = {
325
323
 
    let compound = value(i.payments[0])
326
324
 
    let ca = compound.amount
327
325
 
    let isOracle = checkAddress(i.caller.bytes)
328
326
 
    if ((compound.assetId != puzzleUsdnLP))
329
327
 
        then throw("attach PUZZLEUSDNLP tokens only")
330
328
 
        else if (!(isOracle))
331
329
 
            then throw("You are not authotized to call this function")
332
330
 
            else {
333
331
 
                let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
334
332
 
                let totalStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
335
333
 
                let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
336
334
 
                if ((stakeC == stakeC))
337
335
 
                    then {
338
336
 
                        let updateState = IntegerEntry(keyPUZZLEUSDN, (totalStaked + ca))
339
337
 
                        let tc = IntegerEntry(keyPuzzleUsdnCompound, (fromCompound + ca))
340
338
 
[updateState, tc]
341
339
 
                        }
342
340
 
                    else throw("Strict value is not equal to itself.")
343
341
 
                }
344
342
 
    }
345
343
 
346
344
 
347
345
 
348
346
 
@Callable(i)
349
347
 
func sponsorBoost () = {
350
348
 
    let pm = value(i.payments[0])
351
349
 
    let lockPeriod = 100
352
350
 
    if ((pm.assetId != wxId))
353
351
 
        then throw("Error")
354
352
 
        else {
353
+
            let sponsored = valueOrElse(getInteger(this, keySponsorship), 0)
355
354
 
            let lock = invoke(Address(base58'3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP'), "increaseLock", [lockPeriod], [pm])
356
355
 
            if ((lock == lock))
357
356
 
                then {
358
-
                    let s = IntegerEntry(keySponsorship, sponsored)
357
+
                    let s = IntegerEntry(keySponsorship, (pm.amount + sponsored))
359
358
 
[s]
360
359
 
                    }
361
360
 
                else throw("Strict value is not equal to itself.")
362
361
 
            }
363
362
 
    }
364
363
 
365
364
 
366
365
 
@Verifier(tx)
367
366
 
func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
368
367
 

github/deemru/w8io/6500d08 
54.18 ms ◑