w8 · tx · HXz···7so

tx · HXzVhsdKRxntrQdQQBz2pzi6PodpDPfGYu5y9oMJZ7so

3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH:  -0.01400000 Waves

2022.07.26 15:33 [2156766] smart account 3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 4ABGCuHMHzBwz51akeiM4wLbPUfgoyqhgnfjYZtfFGAW
Next: 9qjFVi6DSYZNwrMAjDkrs7pASQfNNYtAs2QybNvweq8t

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

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

github/deemru/w8io/3ef1775 
74.72 ms ◑