w8 · tx · 4p2···t4U

tx · 4p27Ei2LgoqxkPStNyzyNjY31RfgTN88R341B365bt4U

3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH:  -0.01400000 Waves

2022.07.26 15:53 [2156788] smart account 3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 8ALAcrMXj7qSSTopDNd3iJunXv7TVx9FRQ732fU8T6Sy
Next: 8jKD68yjCcXXkBQjusT8gMB6KnkQ6rJKhpUGzSTeziA6

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

Old	New		Differences
98	98		let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
99	99		let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
100	100		let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
101		-	let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS", usdnLpToWithdraw], ~~[payment]~~)
	101	+	let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS", usdnLpToWithdraw], nil)
102	102		let fee = fraction(usdnLpToWithdraw, def, feePerc)
103	103		let brn = Burn(usdtUsdnLPTCI, am)
104	104		if ((brn == brn))

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

github/deemru/w8io/026f985 
79.68 ms ◑