w8 · tx · 5MR···Wm2

tx · 5MRDXB6MyN2YMzpNRdgjqiJDUWLSikAgD4wjetuWuWm2

3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH:  -0.01700000 Waves

2022.07.26 13:49 [2156669] smart account 3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "5MRDXB6MyN2YMzpNRdgjqiJDUWLSikAgD4wjetuWuWm2",
    "fee": 1700000,
    "feeAssetId": null,
    "timestamp": 1658832571841,
    "version": 2,
    "chainId": 84,
    "sender": "3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH",
    "senderPublicKey": "4hcnYaYoB2XaCzyJ7wfePpG7EfTd6st6aCAhkskJ9cQ5",
    "proofs": [
        "5HKQj6hyqGEYK6Dhq9AKRYB8Xfr2mBU8npf65ZZE1AmK1KRyRK32HgQCHYPaxMBBMHVucRgtQv1AbL74BEyEKY91"
    ],
    "script": "base64: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",
    "height": 2156669,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8v4rP1U7bWWFZpr3pPtTvZgzFhaAd6mUym715Gd6HGUS
Next: 7ndq3f9PL2eFWJqEJGgEa97C7z7RLNTMUpuWAQ1ZYbFC

Diff: 
Old New Differences
51 51  
52 52  let feePerc = 10000000000
53 53  
54 - let tw = base58'3P93R2GBkTGVehRPhytHr7sdxYww93jkbhm'
54 + let tw = base58'3Mv7nXq2V2Dnn9oSkB5feRt6RxtqnPiAXNH'
55 55  
56 56  let oracle = base58'3P6phwFZFQtZFuc9dvdXsgvtg8JEFVgECPA'
57 57  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let usdtUsdnLP = base58'Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS'
5 5  
6 6  let usdtUsdnLPTCI = base58'i1snzKxSEZVokh9TWj8hTJQEDBsocnL2hRWsSbsMPK7'
7 7  
8 8  let wxUsdnLP = base58'2sEBVcyDFK2LupCf7MeA4vzHhGK4DC1WjbKGQCLYDqib'
9 9  
10 10  let wxUsdnLPTCI = base58'DNy6WBfhPE4y82RonGdHhZEunNotEDzmNfrBomWnsyGi'
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 27  
28 28  let isStopped = false
29 29  
30 30  let keyStaked = "STAKED_LP"
31 31  
32 32  let keyCompound = "From_Compound"
33 33  
34 34  let keywxUsdnCompound = "WX_USDN_compound"
35 35  
36 36  let keyWXUSDN = "WX_USDN"
37 37  
38 38  let keyUsdcUsdnCompound = "USDC_USDN_compound"
39 39  
40 40  let keyUSDCUSDN = "USDC_USDN"
41 41  
42 42  let keyUsdcUsdtCompound = "USDC_USDT_compound"
43 43  
44 44  let keyUSDCUSDT = "USDC_USDT"
45 45  
46 46  let keyPuzzleUsdnCompound = "PUZZLE_USDN_compound"
47 47  
48 48  let keyPUZZLEUSDN = "PUZZLE_USDN"
49 49  
50 50  let def = 100000000
51 51  
52 52  let feePerc = 10000000000
53 53  
54 - let tw = base58'3P93R2GBkTGVehRPhytHr7sdxYww93jkbhm'
54 + let tw = base58'3Mv7nXq2V2Dnn9oSkB5feRt6RxtqnPiAXNH'
55 55  
56 56  let oracle = base58'3P6phwFZFQtZFuc9dvdXsgvtg8JEFVgECPA'
57 57  
58 58  func checkAddress (caller) = if ((caller != oracle))
59 59      then false
60 60      else true
61 61  
62 62  
63 63  @Callable(i)
64 64  func withdraw () = {
65 65      let payment = value(i.payments[0])
66 66      let am = payment.amount
67 67      let id = payment.assetId
68 68      if ((id == usdtUsdnLP))
69 69          then {
70 70              let TCIAmount =             match assetInfo(usdtUsdnLPTCI) {
71 71                  case q: Asset => 
72 72                      q.quantity
73 73                  case _ => 
74 74                      0
75 75              }
76 76              let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
77 77              let forSingleTCI = fraction(TCIAmount, def, usdnUsdtStaked)
78 78              let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
79 79              let fee = fraction(usdnLpToWithdraw, def, feePerc)
80 80              let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
81 81              let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
82 82              let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
83 83              let brn = Burn(usdtUsdnLPTCI, am)
84 84              if ((brn == brn))
85 85                  then [usdnLpfeeTransfer, transfer, updateUsdnLpStaked]
86 86                  else throw("Strict value is not equal to itself.")
87 87              }
88 88          else if ((id == wxUsdnLPTCI))
89 89              then {
90 90                  let wxTciAm =                 match assetInfo(wxUsdnLPTCI) {
91 91                      case q: Asset => 
92 92                          q.quantity
93 93                      case _ => 
94 94                          0
95 95                  }
96 96                  let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
97 97                  let singleWXLP = fraction(wxTciAm, def, wxUsdnStaked)
98 98                  let wxLpToWithdraw = fraction(singleWXLP, am, def)
99 99                  let fee = fraction(wxLpToWithdraw, def, feePerc)
100 100                  let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
101 101                  let wxLpTransfer = ScriptTransfer(i.caller, (am - fee), wxUsdnLP)
102 102                  let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
103 103                  let burnWxLpTci = Burn(wxUsdnLP, am)
104 104                  if ((burnWxLpTci == burnWxLpTci))
105 105                      then [wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked]
106 106                      else throw("Strict value is not equal to itself.")
107 107                  }
108 108              else if ((id == usdcUsdnLPTCI))
109 109                  then {
110 110                      let usdcUsdnTCI =                     match assetInfo(usdcUsdnLPTCI) {
111 111                          case q: Asset => 
112 112                              q.quantity
113 113                          case _ => 
114 114                              0
115 115                      }
116 116                      let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
117 117                      let singleUsdcLP = fraction(usdcUsdnTCI, def, usdcUsdnStaked)
118 118                      let usdcLpToWithdraw = fraction(singleUsdcLP, am, def)
119 119                      let fee = fraction(usdcLpToWithdraw, def, feePerc)
120 120                      let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
121 121                      let usdcUsdnTransfer = ScriptTransfer(i.caller, (am - fee), usdcUsdnLP)
122 122                      let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcLpToWithdraw))
123 123                      let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
124 124                      if ((burnUsdcUsdnLpTci == burnUsdcUsdnLpTci))
125 125                          then [usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked]
126 126                          else throw("Strict value is not equal to itself.")
127 127                      }
128 128                  else if ((id == usdcUsdtLPTCI))
129 129                      then {
130 130                          let usdcUsdtTci =                         match assetInfo(usdcUsdnLPTCI) {
131 131                              case q: Asset => 
132 132                                  q.quantity
133 133                              case _ => 
134 134                                  0
135 135                          }
136 136                          let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
137 137                          let singleUsdcUsdt = fraction(usdcUsdtTci, def, usdcUsdtStaked)
138 138                          let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
139 139                          let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
140 140                          let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
141 141                          let usdcUsdtTransfer = ScriptTransfer(i.caller, (am - fee), usdcUsdtLP)
142 142                          let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
143 143                          let burnWxLpTci = Burn(usdcUsdnLPTCI, am)
144 144                          if ((burnWxLpTci == burnWxLpTci))
145 145                              then [usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked]
146 146                              else throw("Strict value is not equal to itself.")
147 147                          }
148 148                      else if ((id == puzzleUsdnLPTCI))
149 149                          then {
150 150                              let puzzleUsdnTci =                             match assetInfo(puzzleUsdnLPTCI) {
151 151                                  case q: Asset => 
152 152                                      q.quantity
153 153                                  case _ => 
154 154                                      0
155 155                              }
156 156                              let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
157 157                              let singlePuzzleUsdn = fraction(puzzleUsdnTci, def, puzzleLPStaked)
158 158                              let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
159 159                              let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
160 160                              let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
161 161                              let puzzleUsdnTransfer = ScriptTransfer(i.caller, (am - fee), puzzleUsdnLP)
162 162                              let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
163 163                              let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
164 164                              if ((burnPuzzleTCI == burnPuzzleTCI))
165 165                                  then [puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked]
166 166                                  else throw("Strict value is not equal to itself.")
167 167                              }
168 168                          else throw("Invalid asset")
169 169      }
170 170  
171 171  
172 172  
173 173  @Callable(i)
174 174  func depositWxUsdnLP () = {
175 175      let pmt = value(i.payments[0])
176 176      let pmtAmount = pmt.amount
177 177      if ((pmt.assetId != wxUsdnLP))
178 178          then throw("attach WXUSDNLP tokens only")
179 179          else if (isStopped)
180 180              then throw("smart contract is on lock")
181 181              else {
182 182                  let tkStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
183 183                  let totalIssued =                 match assetInfo(wxUsdnLPTCI) {
184 184                      case asset: Asset => 
185 185                          asset.quantity
186 186                      case _ => 
187 187                          throw("Can't find asset")
188 188                  }
189 189                  let one = fraction(totalIssued, 100000000, tkStaked)
190 190                  let toIssue = fraction(pmtAmount, one, 100000000)
191 191                  let updateState = IntegerEntry(keyWXUSDN, (tkStaked + pmtAmount))
192 192                  let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
193 193                  if ((LPstake == LPstake))
194 194                      then {
195 195                          let LPIssue = Reissue(wxUsdnLPTCI, toIssue, true)
196 196                          let transfer = ScriptTransfer(i.caller, toIssue, wxUsdnLPTCI)
197 197  [LPIssue, transfer, updateState]
198 198                          }
199 199                      else throw("Strict value is not equal to itself.")
200 200                  }
201 201      }
202 202  
203 203  
204 204  
205 205  @Callable(i)
206 206  func depositUsdtUsdnLP () = {
207 207      let pmt = value(i.payments[0])
208 208      let pmtAmount = pmt.amount
209 209      if ((pmt.assetId != usdtUsdnLP))
210 210          then throw("attach USDTUSDNLP tokens only")
211 211          else if (isStopped)
212 212              then throw("smart contract is on lock")
213 213              else {
214 214                  let tkStaked = valueOrElse(getInteger(this, keyStaked), 0)
215 215                  let totalIssued =                 match assetInfo(usdtUsdnLPTCI) {
216 216                      case asset: Asset => 
217 217                          asset.quantity
218 218                      case _ => 
219 219                          throw("Can't find asset")
220 220                  }
221 221                  let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
222 222                  let forOne = fraction(totalIssued, 100000000, tkStaked)
223 223                  let toIssue = fraction(pmtAmount, forOne, 100000000)
224 224                  let updateState = IntegerEntry(keyStaked, (tkStaked + pmtAmount))
225 225                  let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
226 226                  if ((LPstake == LPstake))
227 227                      then {
228 228                          let LPIssue = Reissue(usdtUsdnLPTCI, toIssue, true)
229 229                          let transfer = ScriptTransfer(i.caller, toIssue, usdtUsdnLPTCI)
230 230  [LPIssue, transfer, updateState]
231 231                          }
232 232                      else throw("Strict value is not equal to itself.")
233 233                  }
234 234      }
235 235  
236 236  
237 237  
238 238  @Callable(i)
239 239  func depositUsdcUsdnLP () = {
240 240      let pmt = value(i.payments[0])
241 241      let pmtAmount = pmt.amount
242 242      if ((pmt.assetId != usdcUsdnLP))
243 243          then throw("attach USDCUSDNLP tokens only")
244 244          else if (isStopped)
245 245              then throw("smart contract is on lock")
246 246              else {
247 247                  let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
248 248                  let totalIssued =                 match assetInfo(usdcUsdnLPTCI) {
249 249                      case asset: Asset => 
250 250                          asset.quantity
251 251                      case _ => 
252 252                          throw("Can't find asset")
253 253                  }
254 254                  let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
255 255                  let forOne = fraction(totalIssued, 100000000, tkStaked)
256 256                  let toIssue = fraction(pmtAmount, forOne, 100000000)
257 257                  let updateState = IntegerEntry(keyUSDCUSDN, (tkStaked + pmtAmount))
258 258                  let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
259 259                  if ((LPstake == LPstake))
260 260                      then {
261 261                          let LPIssue = Reissue(usdcUsdnLPTCI, toIssue, true)
262 262                          let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdnLPTCI)
263 263  [LPIssue, transfer, updateState]
264 264                          }
265 265                      else throw("Strict value is not equal to itself.")
266 266                  }
267 267      }
268 268  
269 269  
270 270  
271 271  @Callable(i)
272 272  func depositUsdcUsdtLP () = {
273 273      let pmt = value(i.payments[0])
274 274      let pmtAmount = pmt.amount
275 275      if ((pmt.assetId != usdcUsdtLP))
276 276          then throw("attach USDCUSDTLP tokens only")
277 277          else if (isStopped)
278 278              then throw("smart contract is on lock")
279 279              else {
280 280                  let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
281 281                  let totalIssued =                 match assetInfo(usdcUsdtLPTCI) {
282 282                      case asset: Asset => 
283 283                          asset.quantity
284 284                      case _ => 
285 285                          throw("Can't find asset")
286 286                  }
287 287                  let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
288 288                  let forOne = fraction(totalIssued, 100000000, tkStaked)
289 289                  let toIssue = fraction(pmtAmount, forOne, 100000000)
290 290                  let updateState = IntegerEntry(keyUSDCUSDT, (tkStaked + pmtAmount))
291 291                  let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
292 292                  if ((LPstake == LPstake))
293 293                      then {
294 294                          let LPIssue = Reissue(usdcUsdtLPTCI, toIssue, true)
295 295                          let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdtLPTCI)
296 296  [LPIssue, transfer, updateState]
297 297                          }
298 298                      else throw("Strict value is not equal to itself.")
299 299                  }
300 300      }
301 301  
302 302  
303 303  
304 304  @Callable(i)
305 305  func depositPuzzleUsdnLP () = {
306 306      let pmt = value(i.payments[0])
307 307      let pmtAmount = pmt.amount
308 308      if ((pmt.assetId != puzzleUsdnLP))
309 309          then throw("attach PUZZLEUDSNLP tokens only")
310 310          else if (isStopped)
311 311              then throw("smart contract is on lock")
312 312              else {
313 313                  let tkStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
314 314                  let totalIssued =                 match assetInfo(puzzleUsdnLPTCI) {
315 315                      case asset: Asset => 
316 316                          asset.quantity
317 317                      case _ => 
318 318                          throw("Can't find asset")
319 319                  }
320 320                  let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
321 321                  let forOne = fraction(totalIssued, 100000000, tkStaked)
322 322                  let toIssue = fraction(pmtAmount, forOne, 100000000)
323 323                  let updateState = IntegerEntry(keyPUZZLEUSDN, (tkStaked + pmtAmount))
324 324                  let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
325 325                  if ((LPstake == LPstake))
326 326                      then {
327 327                          let LPIssue = Reissue(puzzleUsdnLPTCI, toIssue, true)
328 328                          let transfer = ScriptTransfer(i.caller, toIssue, puzzleUsdnLPTCI)
329 329  [LPIssue, transfer, updateState]
330 330                          }
331 331                      else throw("Strict value is not equal to itself.")
332 332                  }
333 333      }
334 334  
335 335  
336 336  
337 337  @Callable(i)
338 338  func compoundWxUsdnLP () = {
339 339      let compound = value(i.payments[0])
340 340      let ca = compound.amount
341 341      let isOracle = checkAddress(i.caller.bytes)
342 342      if ((compound.assetId != wxUsdnLP))
343 343          then throw("attach WXUSDNLP tokens only")
344 344          else if (!(isOracle))
345 345              then throw("You are not authotized to call this function")
346 346              else {
347 347                  let fromCompound = valueOrElse(getInteger(this, keywxUsdnCompound), 0)
348 348                  let totalStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
349 349                  let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
350 350                  if ((stakeC == stakeC))
351 351                      then {
352 352                          let updateState = IntegerEntry(keyWXUSDN, (totalStaked + ca))
353 353                          let tc = IntegerEntry(keywxUsdnCompound, (fromCompound + ca))
354 354  [updateState, tc]
355 355                          }
356 356                      else throw("Strict value is not equal to itself.")
357 357                  }
358 358      }
359 359  
360 360  
361 361  
362 362  @Callable(i)
363 363  func compoundUsdtUsdnLP () = {
364 364      let compound = value(i.payments[0])
365 365      let ca = compound.amount
366 366      let isOracle = checkAddress(i.caller.bytes)
367 367      if ((compound.assetId != usdtUsdnLP))
368 368          then throw("attach USDTUSDNLP tokens only")
369 369          else if (!(isOracle))
370 370              then throw("You are not authotized to call this function")
371 371              else {
372 372                  let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
373 373                  let totalStaked = valueOrElse(getInteger(this, keyStaked), 0)
374 374                  let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
375 375                  if ((stakeC == stakeC))
376 376                      then {
377 377                          let updateState = IntegerEntry(keyStaked, (totalStaked + ca))
378 378                          let tc = IntegerEntry(keyCompound, (fromCompound + ca))
379 379  [updateState, tc]
380 380                          }
381 381                      else throw("Strict value is not equal to itself.")
382 382                  }
383 383      }
384 384  
385 385  
386 386  
387 387  @Callable(i)
388 388  func compoundUsdcUsdnLP () = {
389 389      let compound = value(i.payments[0])
390 390      let ca = compound.amount
391 391      let isOracle = checkAddress(i.caller.bytes)
392 392      if ((compound.assetId != usdcUsdnLP))
393 393          then throw("attach USDCUSDNLP tokens only")
394 394          else if (!(isOracle))
395 395              then throw("You are not authotized to call this function")
396 396              else {
397 397                  let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
398 398                  let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
399 399                  let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
400 400                  if ((stakeC == stakeC))
401 401                      then {
402 402                          let updateState = IntegerEntry(keyUSDCUSDN, (totalStaked + ca))
403 403                          let tc = IntegerEntry(keyUsdcUsdnCompound, (fromCompound + ca))
404 404  [updateState, tc]
405 405                          }
406 406                      else throw("Strict value is not equal to itself.")
407 407                  }
408 408      }
409 409  
410 410  
411 411  
412 412  @Callable(i)
413 413  func compoundUsdcUsdtLP () = {
414 414      let compound = value(i.payments[0])
415 415      let ca = compound.amount
416 416      let isOracle = checkAddress(i.caller.bytes)
417 417      if ((compound.assetId != usdcUsdtLP))
418 418          then throw("attach USDCUSDTLP tokens only")
419 419          else if (!(isOracle))
420 420              then throw("You are not authotized to call this function")
421 421              else {
422 422                  let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
423 423                  let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
424 424                  let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
425 425                  if ((stakeC == stakeC))
426 426                      then {
427 427                          let updateState = IntegerEntry(keyUSDCUSDT, (totalStaked + ca))
428 428                          let tc = IntegerEntry(keyUsdcUsdtCompound, (fromCompound + ca))
429 429  [updateState, tc]
430 430                          }
431 431                      else throw("Strict value is not equal to itself.")
432 432                  }
433 433      }
434 434  
435 435  
436 436  
437 437  @Callable(i)
438 438  func compoundPuzzleUsdnLP () = {
439 439      let compound = value(i.payments[0])
440 440      let ca = compound.amount
441 441      let isOracle = checkAddress(i.caller.bytes)
442 442      if ((compound.assetId != puzzleUsdnLP))
443 443          then throw("attach PUZZLEUSDNLP tokens only")
444 444          else if (!(isOracle))
445 445              then throw("You are not authotized to call this function")
446 446              else {
447 447                  let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
448 448                  let totalStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
449 449                  let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
450 450                  if ((stakeC == stakeC))
451 451                      then {
452 452                          let updateState = IntegerEntry(keyPUZZLEUSDN, (totalStaked + ca))
453 453                          let tc = IntegerEntry(keyPuzzleUsdnCompound, (fromCompound + ca))
454 454  [updateState, tc]
455 455                          }
456 456                      else throw("Strict value is not equal to itself.")
457 457                  }
458 458      }
459 459  
460 460  
461 461  
462 462  @Callable(i)
463 463  func sponsorBoost () = {
464 464      let pm = value(i.payments[0])
465 465      let lockPeriod = 100
466 466      if ((pm.assetId != wxId))
467 467          then throw("Error")
468 468          else {
469 469              let sponsored = valueOrElse(getInteger(this, keySponsorship), 0)
470 470              let lock = invoke(Address(base58'3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP'), "increaseLock", [lockPeriod], [pm])
471 471              if ((lock == lock))
472 472                  then {
473 473                      let s = IntegerEntry(keySponsorship, (pm.amount + sponsored))
474 474  [s]
475 475                      }
476 476                  else throw("Strict value is not equal to itself.")
477 477              }
478 478      }
479 479  
480 480  
481 481  @Verifier(tx)
482 482  func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
483 483

Old	New		Differences
51	51
52	52		let feePerc = 10000000000
53	53
54		-	let tw = base58'~~3P93R2GBkTGVehRPhytHr7sdxYww93jkbhm~~'
	54	+	let tw = base58'3Mv7nXq2V2Dnn9oSkB5feRt6RxtqnPiAXNH'
55	55
56	56		let oracle = base58'3P6phwFZFQtZFuc9dvdXsgvtg8JEFVgECPA'
57	57

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let usdtUsdnLP = base58'Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS'
5	5
6	6		let usdtUsdnLPTCI = base58'i1snzKxSEZVokh9TWj8hTJQEDBsocnL2hRWsSbsMPK7'
7	7
8	8		let wxUsdnLP = base58'2sEBVcyDFK2LupCf7MeA4vzHhGK4DC1WjbKGQCLYDqib'
9	9
10	10		let wxUsdnLPTCI = base58'DNy6WBfhPE4y82RonGdHhZEunNotEDzmNfrBomWnsyGi'
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	27
28	28		let isStopped = false
29	29
30	30		let keyStaked = "STAKED_LP"
31	31
32	32		let keyCompound = "From_Compound"
33	33
34	34		let keywxUsdnCompound = "WX_USDN_compound"
35	35
36	36		let keyWXUSDN = "WX_USDN"
37	37
38	38		let keyUsdcUsdnCompound = "USDC_USDN_compound"
39	39
40	40		let keyUSDCUSDN = "USDC_USDN"
41	41
42	42		let keyUsdcUsdtCompound = "USDC_USDT_compound"
43	43
44	44		let keyUSDCUSDT = "USDC_USDT"
45	45
46	46		let keyPuzzleUsdnCompound = "PUZZLE_USDN_compound"
47	47
48	48		let keyPUZZLEUSDN = "PUZZLE_USDN"
49	49
50	50		let def = 100000000
51	51
52	52		let feePerc = 10000000000
53	53
54		-	let tw = base58'~~3P93R2GBkTGVehRPhytHr7sdxYww93jkbhm~~'
	54	+	let tw = base58'3Mv7nXq2V2Dnn9oSkB5feRt6RxtqnPiAXNH'
55	55
56	56		let oracle = base58'3P6phwFZFQtZFuc9dvdXsgvtg8JEFVgECPA'
57	57
58	58		func checkAddress (caller) = if ((caller != oracle))
59	59		then false
60	60		else true
61	61
62	62
63	63		@Callable(i)
64	64		func withdraw () = {
65	65		let payment = value(i.payments[0])
66	66		let am = payment.amount
67	67		let id = payment.assetId
68	68		if ((id == usdtUsdnLP))
69	69		then {
70	70		let TCIAmount = match assetInfo(usdtUsdnLPTCI) {
71	71		case q: Asset =>
72	72		q.quantity
73	73		case _ =>
74	74		0
75	75		}
76	76		let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
77	77		let forSingleTCI = fraction(TCIAmount, def, usdnUsdtStaked)
78	78		let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
79	79		let fee = fraction(usdnLpToWithdraw, def, feePerc)
80	80		let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
81	81		let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
82	82		let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
83	83		let brn = Burn(usdtUsdnLPTCI, am)
84	84		if ((brn == brn))
85	85		then [usdnLpfeeTransfer, transfer, updateUsdnLpStaked]
86	86		else throw("Strict value is not equal to itself.")
87	87		}
88	88		else if ((id == wxUsdnLPTCI))
89	89		then {
90	90		let wxTciAm = match assetInfo(wxUsdnLPTCI) {
91	91		case q: Asset =>
92	92		q.quantity
93	93		case _ =>
94	94		0
95	95		}
96	96		let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
97	97		let singleWXLP = fraction(wxTciAm, def, wxUsdnStaked)
98	98		let wxLpToWithdraw = fraction(singleWXLP, am, def)
99	99		let fee = fraction(wxLpToWithdraw, def, feePerc)
100	100		let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
101	101		let wxLpTransfer = ScriptTransfer(i.caller, (am - fee), wxUsdnLP)
102	102		let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
103	103		let burnWxLpTci = Burn(wxUsdnLP, am)
104	104		if ((burnWxLpTci == burnWxLpTci))
105	105		then [wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked]
106	106		else throw("Strict value is not equal to itself.")
107	107		}
108	108		else if ((id == usdcUsdnLPTCI))
109	109		then {
110	110		let usdcUsdnTCI = match assetInfo(usdcUsdnLPTCI) {
111	111		case q: Asset =>
112	112		q.quantity
113	113		case _ =>
114	114		0
115	115		}
116	116		let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
117	117		let singleUsdcLP = fraction(usdcUsdnTCI, def, usdcUsdnStaked)
118	118		let usdcLpToWithdraw = fraction(singleUsdcLP, am, def)
119	119		let fee = fraction(usdcLpToWithdraw, def, feePerc)
120	120		let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
121	121		let usdcUsdnTransfer = ScriptTransfer(i.caller, (am - fee), usdcUsdnLP)
122	122		let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcLpToWithdraw))
123	123		let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
124	124		if ((burnUsdcUsdnLpTci == burnUsdcUsdnLpTci))
125	125		then [usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked]
126	126		else throw("Strict value is not equal to itself.")
127	127		}
128	128		else if ((id == usdcUsdtLPTCI))
129	129		then {
130	130		let usdcUsdtTci = match assetInfo(usdcUsdnLPTCI) {
131	131		case q: Asset =>
132	132		q.quantity
133	133		case _ =>
134	134		0
135	135		}
136	136		let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
137	137		let singleUsdcUsdt = fraction(usdcUsdtTci, def, usdcUsdtStaked)
138	138		let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
139	139		let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
140	140		let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
141	141		let usdcUsdtTransfer = ScriptTransfer(i.caller, (am - fee), usdcUsdtLP)
142	142		let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
143	143		let burnWxLpTci = Burn(usdcUsdnLPTCI, am)
144	144		if ((burnWxLpTci == burnWxLpTci))
145	145		then [usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked]
146	146		else throw("Strict value is not equal to itself.")
147	147		}
148	148		else if ((id == puzzleUsdnLPTCI))
149	149		then {
150	150		let puzzleUsdnTci = match assetInfo(puzzleUsdnLPTCI) {
151	151		case q: Asset =>
152	152		q.quantity
153	153		case _ =>
154	154		0
155	155		}
156	156		let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
157	157		let singlePuzzleUsdn = fraction(puzzleUsdnTci, def, puzzleLPStaked)
158	158		let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
159	159		let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
160	160		let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
161	161		let puzzleUsdnTransfer = ScriptTransfer(i.caller, (am - fee), puzzleUsdnLP)
162	162		let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
163	163		let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
164	164		if ((burnPuzzleTCI == burnPuzzleTCI))
165	165		then [puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked]
166	166		else throw("Strict value is not equal to itself.")
167	167		}
168	168		else throw("Invalid asset")
169	169		}
170	170
171	171
172	172
173	173		@Callable(i)
174	174		func depositWxUsdnLP () = {
175	175		let pmt = value(i.payments[0])
176	176		let pmtAmount = pmt.amount
177	177		if ((pmt.assetId != wxUsdnLP))
178	178		then throw("attach WXUSDNLP tokens only")
179	179		else if (isStopped)
180	180		then throw("smart contract is on lock")
181	181		else {
182	182		let tkStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
183	183		let totalIssued = match assetInfo(wxUsdnLPTCI) {
184	184		case asset: Asset =>
185	185		asset.quantity
186	186		case _ =>
187	187		throw("Can't find asset")
188	188		}
189	189		let one = fraction(totalIssued, 100000000, tkStaked)
190	190		let toIssue = fraction(pmtAmount, one, 100000000)
191	191		let updateState = IntegerEntry(keyWXUSDN, (tkStaked + pmtAmount))
192	192		let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
193	193		if ((LPstake == LPstake))
194	194		then {
195	195		let LPIssue = Reissue(wxUsdnLPTCI, toIssue, true)
196	196		let transfer = ScriptTransfer(i.caller, toIssue, wxUsdnLPTCI)
197	197		[LPIssue, transfer, updateState]
198	198		}
199	199		else throw("Strict value is not equal to itself.")
200	200		}
201	201		}
202	202
203	203
204	204
205	205		@Callable(i)
206	206		func depositUsdtUsdnLP () = {
207	207		let pmt = value(i.payments[0])
208	208		let pmtAmount = pmt.amount
209	209		if ((pmt.assetId != usdtUsdnLP))
210	210		then throw("attach USDTUSDNLP tokens only")
211	211		else if (isStopped)
212	212		then throw("smart contract is on lock")
213	213		else {
214	214		let tkStaked = valueOrElse(getInteger(this, keyStaked), 0)
215	215		let totalIssued = match assetInfo(usdtUsdnLPTCI) {
216	216		case asset: Asset =>
217	217		asset.quantity
218	218		case _ =>
219	219		throw("Can't find asset")
220	220		}
221	221		let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
222	222		let forOne = fraction(totalIssued, 100000000, tkStaked)
223	223		let toIssue = fraction(pmtAmount, forOne, 100000000)
224	224		let updateState = IntegerEntry(keyStaked, (tkStaked + pmtAmount))
225	225		let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
226	226		if ((LPstake == LPstake))
227	227		then {
228	228		let LPIssue = Reissue(usdtUsdnLPTCI, toIssue, true)
229	229		let transfer = ScriptTransfer(i.caller, toIssue, usdtUsdnLPTCI)
230	230		[LPIssue, transfer, updateState]
231	231		}
232	232		else throw("Strict value is not equal to itself.")
233	233		}
234	234		}
235	235
236	236
237	237
238	238		@Callable(i)
239	239		func depositUsdcUsdnLP () = {
240	240		let pmt = value(i.payments[0])
241	241		let pmtAmount = pmt.amount
242	242		if ((pmt.assetId != usdcUsdnLP))
243	243		then throw("attach USDCUSDNLP tokens only")
244	244		else if (isStopped)
245	245		then throw("smart contract is on lock")
246	246		else {
247	247		let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
248	248		let totalIssued = match assetInfo(usdcUsdnLPTCI) {
249	249		case asset: Asset =>
250	250		asset.quantity
251	251		case _ =>
252	252		throw("Can't find asset")
253	253		}
254	254		let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
255	255		let forOne = fraction(totalIssued, 100000000, tkStaked)
256	256		let toIssue = fraction(pmtAmount, forOne, 100000000)
257	257		let updateState = IntegerEntry(keyUSDCUSDN, (tkStaked + pmtAmount))
258	258		let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
259	259		if ((LPstake == LPstake))
260	260		then {
261	261		let LPIssue = Reissue(usdcUsdnLPTCI, toIssue, true)
262	262		let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdnLPTCI)
263	263		[LPIssue, transfer, updateState]
264	264		}
265	265		else throw("Strict value is not equal to itself.")
266	266		}
267	267		}
268	268
269	269
270	270
271	271		@Callable(i)
272	272		func depositUsdcUsdtLP () = {
273	273		let pmt = value(i.payments[0])
274	274		let pmtAmount = pmt.amount
275	275		if ((pmt.assetId != usdcUsdtLP))
276	276		then throw("attach USDCUSDTLP tokens only")
277	277		else if (isStopped)
278	278		then throw("smart contract is on lock")
279	279		else {
280	280		let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
281	281		let totalIssued = match assetInfo(usdcUsdtLPTCI) {
282	282		case asset: Asset =>
283	283		asset.quantity
284	284		case _ =>
285	285		throw("Can't find asset")
286	286		}
287	287		let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
288	288		let forOne = fraction(totalIssued, 100000000, tkStaked)
289	289		let toIssue = fraction(pmtAmount, forOne, 100000000)
290	290		let updateState = IntegerEntry(keyUSDCUSDT, (tkStaked + pmtAmount))
291	291		let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
292	292		if ((LPstake == LPstake))
293	293		then {
294	294		let LPIssue = Reissue(usdcUsdtLPTCI, toIssue, true)
295	295		let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdtLPTCI)
296	296		[LPIssue, transfer, updateState]
297	297		}
298	298		else throw("Strict value is not equal to itself.")
299	299		}
300	300		}
301	301
302	302
303	303
304	304		@Callable(i)
305	305		func depositPuzzleUsdnLP () = {
306	306		let pmt = value(i.payments[0])
307	307		let pmtAmount = pmt.amount
308	308		if ((pmt.assetId != puzzleUsdnLP))
309	309		then throw("attach PUZZLEUDSNLP tokens only")
310	310		else if (isStopped)
311	311		then throw("smart contract is on lock")
312	312		else {
313	313		let tkStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
314	314		let totalIssued = match assetInfo(puzzleUsdnLPTCI) {
315	315		case asset: Asset =>
316	316		asset.quantity
317	317		case _ =>
318	318		throw("Can't find asset")
319	319		}
320	320		let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
321	321		let forOne = fraction(totalIssued, 100000000, tkStaked)
322	322		let toIssue = fraction(pmtAmount, forOne, 100000000)
323	323		let updateState = IntegerEntry(keyPUZZLEUSDN, (tkStaked + pmtAmount))
324	324		let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
325	325		if ((LPstake == LPstake))
326	326		then {
327	327		let LPIssue = Reissue(puzzleUsdnLPTCI, toIssue, true)
328	328		let transfer = ScriptTransfer(i.caller, toIssue, puzzleUsdnLPTCI)
329	329		[LPIssue, transfer, updateState]
330	330		}
331	331		else throw("Strict value is not equal to itself.")
332	332		}
333	333		}
334	334
335	335
336	336
337	337		@Callable(i)
338	338		func compoundWxUsdnLP () = {
339	339		let compound = value(i.payments[0])
340	340		let ca = compound.amount
341	341		let isOracle = checkAddress(i.caller.bytes)
342	342		if ((compound.assetId != wxUsdnLP))
343	343		then throw("attach WXUSDNLP tokens only")
344	344		else if (!(isOracle))
345	345		then throw("You are not authotized to call this function")
346	346		else {
347	347		let fromCompound = valueOrElse(getInteger(this, keywxUsdnCompound), 0)
348	348		let totalStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
349	349		let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
350	350		if ((stakeC == stakeC))
351	351		then {
352	352		let updateState = IntegerEntry(keyWXUSDN, (totalStaked + ca))
353	353		let tc = IntegerEntry(keywxUsdnCompound, (fromCompound + ca))
354	354		[updateState, tc]
355	355		}
356	356		else throw("Strict value is not equal to itself.")
357	357		}
358	358		}
359	359
360	360
361	361
362	362		@Callable(i)
363	363		func compoundUsdtUsdnLP () = {
364	364		let compound = value(i.payments[0])
365	365		let ca = compound.amount
366	366		let isOracle = checkAddress(i.caller.bytes)
367	367		if ((compound.assetId != usdtUsdnLP))
368	368		then throw("attach USDTUSDNLP tokens only")
369	369		else if (!(isOracle))
370	370		then throw("You are not authotized to call this function")
371	371		else {
372	372		let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
373	373		let totalStaked = valueOrElse(getInteger(this, keyStaked), 0)
374	374		let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
375	375		if ((stakeC == stakeC))
376	376		then {
377	377		let updateState = IntegerEntry(keyStaked, (totalStaked + ca))
378	378		let tc = IntegerEntry(keyCompound, (fromCompound + ca))
379	379		[updateState, tc]
380	380		}
381	381		else throw("Strict value is not equal to itself.")
382	382		}
383	383		}
384	384
385	385
386	386
387	387		@Callable(i)
388	388		func compoundUsdcUsdnLP () = {
389	389		let compound = value(i.payments[0])
390	390		let ca = compound.amount
391	391		let isOracle = checkAddress(i.caller.bytes)
392	392		if ((compound.assetId != usdcUsdnLP))
393	393		then throw("attach USDCUSDNLP tokens only")
394	394		else if (!(isOracle))
395	395		then throw("You are not authotized to call this function")
396	396		else {
397	397		let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
398	398		let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
399	399		let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
400	400		if ((stakeC == stakeC))
401	401		then {
402	402		let updateState = IntegerEntry(keyUSDCUSDN, (totalStaked + ca))
403	403		let tc = IntegerEntry(keyUsdcUsdnCompound, (fromCompound + ca))
404	404		[updateState, tc]
405	405		}
406	406		else throw("Strict value is not equal to itself.")
407	407		}
408	408		}
409	409
410	410
411	411
412	412		@Callable(i)
413	413		func compoundUsdcUsdtLP () = {
414	414		let compound = value(i.payments[0])
415	415		let ca = compound.amount
416	416		let isOracle = checkAddress(i.caller.bytes)
417	417		if ((compound.assetId != usdcUsdtLP))
418	418		then throw("attach USDCUSDTLP tokens only")
419	419		else if (!(isOracle))
420	420		then throw("You are not authotized to call this function")
421	421		else {
422	422		let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
423	423		let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
424	424		let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
425	425		if ((stakeC == stakeC))
426	426		then {
427	427		let updateState = IntegerEntry(keyUSDCUSDT, (totalStaked + ca))
428	428		let tc = IntegerEntry(keyUsdcUsdtCompound, (fromCompound + ca))
429	429		[updateState, tc]
430	430		}
431	431		else throw("Strict value is not equal to itself.")
432	432		}
433	433		}
434	434
435	435
436	436
437	437		@Callable(i)
438	438		func compoundPuzzleUsdnLP () = {
439	439		let compound = value(i.payments[0])
440	440		let ca = compound.amount
441	441		let isOracle = checkAddress(i.caller.bytes)
442	442		if ((compound.assetId != puzzleUsdnLP))
443	443		then throw("attach PUZZLEUSDNLP tokens only")
444	444		else if (!(isOracle))
445	445		then throw("You are not authotized to call this function")
446	446		else {
447	447		let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
448	448		let totalStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
449	449		let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
450	450		if ((stakeC == stakeC))
451	451		then {
452	452		let updateState = IntegerEntry(keyPUZZLEUSDN, (totalStaked + ca))
453	453		let tc = IntegerEntry(keyPuzzleUsdnCompound, (fromCompound + ca))
454	454		[updateState, tc]
455	455		}
456	456		else throw("Strict value is not equal to itself.")
457	457		}
458	458		}
459	459
460	460
461	461
462	462		@Callable(i)
463	463		func sponsorBoost () = {
464	464		let pm = value(i.payments[0])
465	465		let lockPeriod = 100
466	466		if ((pm.assetId != wxId))
467	467		then throw("Error")
468	468		else {
469	469		let sponsored = valueOrElse(getInteger(this, keySponsorship), 0)
470	470		let lock = invoke(Address(base58'3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP'), "increaseLock", [lockPeriod], [pm])
471	471		if ((lock == lock))
472	472		then {
473	473		let s = IntegerEntry(keySponsorship, (pm.amount + sponsored))
474	474		[s]
475	475		}
476	476		else throw("Strict value is not equal to itself.")
477	477		}
478	478		}
479	479
480	480
481	481		@Verifier(tx)
482	482		func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
483	483

github/deemru/w8io/026f985 
76.63 ms ◑