w8 · tx · 7JP···1Ui

tx · 7JPwZ6DNGW2EuzRLEDdcN2izgqwtc7DD8PHid8rYL1Ui

3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH:  -0.01400000 Waves

2022.07.26 15:29 [2156764] smart account 3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH > SELF 0.00000000 Waves

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

View: original | compacted
Prev: DZB78RqGgzkfkm6tsoCEG5d76MQn9bJi1pqxUiqTPzGW
Next: 4ABGCuHMHzBwz51akeiM4wLbPUfgoyqhgnfjYZtfFGAW

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

Old	New		Differences
99	99		let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
100	100		let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
101	101		let fee = fraction(usdnLpToWithdraw, def, feePerc)
102		-	let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS", am], ~~[payment]~~)
	102	+	let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS", am], nil)
103	103		let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
104	104		let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
105	105		let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))

120	120		let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
121	121		let wxLpToWithdraw = fraction(singleWXLP, am, def)
122	122		let fee = fraction(wxLpToWithdraw, def, feePerc)
123		-	let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["2sEBVcyDFK2LupCf7MeA4vzHhGK4DC1WjbKGQCLYDqib", am], ~~[payment]~~)
	123	+	let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["2sEBVcyDFK2LupCf7MeA4vzHhGK4DC1WjbKGQCLYDqib", am], nil)
124	124		if ((unstake == unstake))
125	125		then {
126	126		let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)

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

github/deemru/w8io/026f985 
72.92 ms ◑