w8 · tx · HrL···6AN

tx · HrL5TnfyTHyWT29Avd5GMq1zSMwSkZgStTCWEHUPJ6AN

3N4kXZHGke6yRq3Z57q7BTgCrT2SCvQCYER:  -0.01400000 Waves

2022.12.06 13:31 [2348364] smart account 3N4kXZHGke6yRq3Z57q7BTgCrT2SCvQCYER > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HrL5TnfyTHyWT29Avd5GMq1zSMwSkZgStTCWEHUPJ6AN",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1670322659957,
    "version": 2,
    "chainId": 84,
    "sender": "3N4kXZHGke6yRq3Z57q7BTgCrT2SCvQCYER",
    "senderPublicKey": "6sxdMr2xYPPACEJccwmgS7nWC2ez1c38Y1kDX49ne42b",
    "proofs": [
        "jSSZagR2maN8TqcSExKrPMmL9vCSkkHMZNQ61t9p25Fcdfb9zMm3gXrweZYrmU4KTwLmKJj9MYd4yETNdw9xzMk"
    ],
    "script": "base64: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",
    "height": 2348364,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6aPd2miLEVUVkJQjPyGTXHfkgHfeMY1TyXVE4AJUdr8v
Next: 8gijVd7Gv2Fnt3rZZMJ2tT7TMkJ7VEKsu6ZtEKs6xU4C

Diff: 
Old New Differences
420 420  @Callable(i)
421 421  func wxVotingSuggest (votingAddress_,wxAsset_,assetImage_) = {
422 422      let votingAddress = valueOrErrorMessage(addressFromString(votingAddress_), "wxVotingSuggest: invalid voting address")
423 +     let sponsorAssetStr = toBase58String(_loadAsset())
423 424      let wxAsset = _toAssetVector(wxAsset_)
424 425      let wxAssetInfo = valueOrErrorMessage(assetInfo(valueOrErrorMessage(wxAsset, "wxVotingSuggest: invalid wx asset")), "wxVotingSuggest: invalid wx asset info")
425 -     let invocation = invoke(votingAddress, "suggest", [_loadAsset(), assetImage_], [AttachedPayment(wxAsset, (100 * wxAssetInfo.decimals))])
426 +     let invocation = invoke(votingAddress, "suggest", [sponsorAssetStr, assetImage_], [AttachedPayment(wxAsset, (100 * wxAssetInfo.decimals))])
426 427      if ((invocation == invocation))
427 428          then $Tuple2(nil, unit)
428 429          else throw("Strict value is not equal to itself.")
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let SEPARATOR = "__"
5 5  
6 6  let WAVES = "WAVES"
7 7  
8 8  let KEY_MULTISIG = "MULTISIG"
9 9  
10 10  let KEY_STATUS = "STATUS"
11 11  
12 12  let KEY_BASE_ASSET = "BASE_ASSET"
13 13  
14 14  let KEY_ASSET = "ASSET"
15 15  
16 16  let KEY_STAKING_ADAPTER = "STAKING_ADAPTER"
17 17  
18 18  let KEY_STAKING_AMOUNT = "STAKING_AMOUNT"
19 19  
20 20  let KEY_LAST_RATE = "LAST_RATE"
21 21  
22 22  let KEY_CURRENT_RATE = "CURRENT_RATE"
23 23  
24 24  let KEY_LAST_HEIGHT = "LAST_HEIGHT"
25 25  
26 26  let KEY_TARGET_HEIGHT = "TARGET_HEIGHT"
27 27  
28 28  let KEY_SPONSORSHIP_MANAGER = "SPONSORSHIP_MANAGER"
29 29  
30 30  let FUNC_STAKE = "stake"
31 31  
32 32  let FUNC_UNSTAKE = "unstake"
33 33  
34 34  let FUNC_CLAIM_REWARD = "claimReward"
35 35  
36 36  let PERCENT_FACTOR = toBigInt(1000000000000)
37 37  
38 38  let ZERO_BIGINT = toBigInt(0)
39 39  
40 40  let ONE_BIGINT = toBigInt(1)
41 41  
42 42  let INIT_AMOUNT = 100000000
43 43  
44 44  func _validateAddress (address_) = match addressFromString(address_) {
45 45      case a: Address => 
46 46          true
47 47      case _ => 
48 48          false
49 49  }
50 50  
51 51  
52 52  func _validateAsset (asset_) = if ((asset_ == WAVES))
53 53      then true
54 54      else     match assetInfo(fromBase58String(asset_)) {
55 55          case a: Asset => 
56 56              true
57 57          case _ => 
58 58              false
59 59      }
60 60  
61 61  
62 62  func _toAssetVector (asset_) = if ((asset_ == WAVES))
63 63      then unit
64 64      else fromBase58String(asset_)
65 65  
66 66  
67 67  func _getAssetDecimals (asset_) = match asset_ {
68 68      case a: ByteVector => 
69 69          match assetInfo(a) {
70 70              case asset: Asset => 
71 71                  asset.decimals
72 72              case _ => 
73 73                  throw("_getAssetDecimals: no such asset")
74 74          }
75 75      case _ => 
76 76          8
77 77  }
78 78  
79 79  
80 80  func _getAssetQuantity (asset_) = match assetInfo(asset_) {
81 81      case a: Asset => 
82 82          a.quantity
83 83      case _ => 
84 84          throw("_getAssetQuantity: no such asset")
85 85  }
86 86  
87 87  
88 88  func _getAssetBalance (asset_,address) = match asset_ {
89 89      case a: ByteVector => 
90 90          assetBalance(address, a)
91 91      case _ => 
92 92          wavesBalance(address).regular
93 93  }
94 94  
95 95  
96 96  func _loadBaseAsset () = match getString(KEY_BASE_ASSET) {
97 97      case a: String => 
98 98          if ((a == WAVES))
99 99              then unit
100 100              else fromBase58String(a)
101 101      case _ => 
102 102          throw("_loadBaseAsset: no base asset")
103 103  }
104 104  
105 105  
106 106  func _loadStakingAdapter () = match getString(KEY_STAKING_ADAPTER) {
107 107      case a: String => 
108 108          addressFromStringValue(a)
109 109      case _ => 
110 110          throw("_loadStakingAdapter: no staking adapter")
111 111  }
112 112  
113 113  
114 114  func _loadSponsorshipManager () = match getString(KEY_SPONSORSHIP_MANAGER) {
115 115      case a: String => 
116 116          addressFromStringValue(a)
117 117      case _ => 
118 118          throw("_loadSponsorshipManager: no sponsorship manager")
119 119  }
120 120  
121 121  
122 122  func _loadInt (key_,default_) = match getInteger(key_) {
123 123      case a: Int => 
124 124          a
125 125      case _ => 
126 126          default_
127 127  }
128 128  
129 129  
130 130  func _loadBigInt (key_,default_) = match getBinary(key_) {
131 131      case a: ByteVector => 
132 132          toBigInt(a)
133 133      case _ => 
134 134          default_
135 135  }
136 136  
137 137  
138 138  func _loadAsset () = match getString(KEY_ASSET) {
139 139      case a: String => 
140 140          fromBase58String(a)
141 141      case _ => 
142 142          base58''
143 143  }
144 144  
145 145  
146 146  func _updateStaking (asset_,amount_,adapter_) = {
147 147      let stakingAmount = _loadInt(KEY_STAKING_AMOUNT, 0)
148 148      let newStakingAmount = (stakingAmount + amount_)
149 149      let invocation = if ((amount_ > 0))
150 150          then invoke(adapter_, FUNC_STAKE, nil, [AttachedPayment(asset_, amount_)])
151 151          else invoke(adapter_, FUNC_UNSTAKE, [(-1 * amount_)], nil)
152 152      if ((invocation == invocation))
153 153          then [IntegerEntry(KEY_STAKING_AMOUNT, newStakingAmount)]
154 154          else throw("Strict value is not equal to itself.")
155 155      }
156 156  
157 157  
158 158  func _checkpoint (compensation) = {
159 159      let invocation = invoke(_loadStakingAdapter(), FUNC_CLAIM_REWARD, nil, nil)
160 160      if ((invocation == invocation))
161 161          then         match invocation {
162 162              case reward: (Int, Int, Int) => 
163 163                  if (compensation)
164 164                      then {
165 165                          let stake = invoke(this, FUNC_STAKE, [reward._1, reward._3], nil)
166 166                          if ((stake == stake))
167 167                              then $Tuple2(true, reward._2)
168 168                              else throw("Strict value is not equal to itself.")
169 169                          }
170 170                      else {
171 171                          let stake = invoke(this, FUNC_STAKE, [(reward._1 + reward._2), reward._3], nil)
172 172                          if ((stake == stake))
173 173                              then $Tuple2(true, 0)
174 174                              else throw("Strict value is not equal to itself.")
175 175                          }
176 176              case _ => 
177 177                  $Tuple2(false, 0)
178 178          }
179 179          else throw("Strict value is not equal to itself.")
180 180      }
181 181  
182 182  
183 183  @Callable(i)
184 184  func init (tokenName_,tokenDescr_,baseAsset_,stakingAdapter_) = {
185 185      let multisig = valueOrErrorMessage(getString(KEY_MULTISIG), "init: no multisig set")
186 186      let asset = _loadAsset()
187 187      let baseAsset = _toAssetVector(baseAsset_)
188 188      let err = if ((i.caller != this))
189 189          then throw("init: permission denied")
190 190          else if ((asset != base58''))
191 191              then throw("init: already initialized")
192 192              else if (if ((4 > size(tokenName_)))
193 193                  then true
194 194                  else (size(tokenName_) > 16))
195 195                  then throw("init: invalid token name")
196 196                  else if ((size(tokenDescr_) > 1000))
197 197                      then throw("init: invalid token description")
198 198                      else if (!(_validateAsset(baseAsset_)))
199 199                          then throw("init: invalid base asset")
200 200                          else if (!(_validateAddress(stakingAdapter_)))
201 201                              then throw("init: invalid staking adapter")
202 202                              else unit
203 203      if ((err == err))
204 204          then {
205 205              let tokenDecimals = _getAssetDecimals(baseAsset)
206 206              let issue = Issue(tokenName_, tokenDescr_, INIT_AMOUNT, tokenDecimals, true)
207 207              let assetId = calculateAssetId(issue)
208 208              let stakeActions = _updateStaking(baseAsset, INIT_AMOUNT, addressFromStringValue(stakingAdapter_))
209 209              $Tuple2(([StringEntry(KEY_BASE_ASSET, baseAsset_), StringEntry(KEY_STAKING_ADAPTER, stakingAdapter_), StringEntry(KEY_ASSET, toBase58String(assetId)), issue] ++ stakeActions), unit)
210 210              }
211 211          else throw("Strict value is not equal to itself.")
212 212      }
213 213  
214 214  
215 215  
216 216  @Callable(i)
217 217  func getRate () = {
218 218      let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
219 219      let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
220 220      let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
221 221      let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
222 222      let rate = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
223 223      $Tuple2(nil, toString(rate))
224 224      }
225 225  
226 226  
227 227  
228 228  @Callable(i)
229 229  func checkpoint () = {
230 230      let checkpoint = _checkpoint(true)
231 231      if ((checkpoint == checkpoint))
232 232          then if (!(checkpoint._1))
233 233              then throw("checkpoint: no reward")
234 234              else if ((checkpoint._2 > 0))
235 235                  then $Tuple2([ScriptTransfer(i.originCaller, checkpoint._2, _loadBaseAsset())], unit)
236 236                  else $Tuple2(nil, unit)
237 237          else throw("Strict value is not equal to itself.")
238 238      }
239 239  
240 240  
241 241  
242 242  @Callable(i)
243 243  func deposit () = {
244 244      let caller = toString(i.caller)
245 245      let baseAsset = _loadBaseAsset()
246 246      let asset = _loadAsset()
247 247      let assetQuantity = toBigInt(_getAssetQuantity(asset))
248 248      let err = if ((size(i.payments) != 1))
249 249          then throw("deposit: no payments")
250 250          else if ((i.payments[0].assetId != baseAsset))
251 251              then throw("deposit: payment is not in base asset")
252 252              else if ((0 >= i.payments[0].amount))
253 253                  then throw("deposit: invalid payment amount")
254 254                  else unit
255 255      if ((err == err))
256 256          then {
257 257              let checkpoint = _checkpoint(false)
258 258              if ((checkpoint == checkpoint))
259 259                  then {
260 260                      let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
261 261                      let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
262 262                      let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
263 263                      let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
264 264                      let lastRateUpdated = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
265 265                      let issueAmount = toInt(fraction(toBigInt(i.payments[0].amount), PERCENT_FACTOR, lastRateUpdated, FLOOR))
266 266                      let currentRateUpdated = fraction(currentRate, assetQuantity, (assetQuantity + toBigInt(issueAmount)), FLOOR)
267 267                      let lastHeightUpdated = targetHeight
268 268                      let stakeActions = _updateStaking(baseAsset, i.payments[0].amount, _loadStakingAdapter())
269 269                      $Tuple2(([Reissue(asset, issueAmount, true), ScriptTransfer(i.caller, issueAmount, asset), BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated)] ++ stakeActions), unit)
270 270                      }
271 271                  else throw("Strict value is not equal to itself.")
272 272              }
273 273          else throw("Strict value is not equal to itself.")
274 274      }
275 275  
276 276  
277 277  
278 278  @Callable(i)
279 279  func stake (amount_,spreadBlocks_) = {
280 280      let caller = toString(i.caller)
281 281      let baseAsset = _loadBaseAsset()
282 282      let asset = _loadAsset()
283 283      let assetQuantity = toBigInt(_getAssetQuantity(asset))
284 284      let err = if ((i.caller != this))
285 285          then throw("stake: only this contract")
286 286          else if ((0 >= amount_))
287 287              then throw("stake: invalid stake amount")
288 288              else if ((amount_ > _getAssetBalance(baseAsset, this)))
289 289                  then throw("stake: insufficient stake amount")
290 290                  else if ((assetQuantity == ZERO_BIGINT))
291 291                      then throw("stake: no deposits to stake for")
292 292                      else unit
293 293      if ((err == err))
294 294          then {
295 295              let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
296 296              let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
297 297              let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
298 298              let targetHeight = _loadInt(KEY_TARGET_HEIGHT, 0)
299 299              let minTargetHeight = min([targetHeight, height])
300 300              let actions = if ((minTargetHeight == height))
301 301                  then {
302 302                      let lastRateUpdated = (lastRate + (toBigInt((minTargetHeight - lastHeight)) * currentRate))
303 303                      let remainingReward = (currentRate * toBigInt((targetHeight - minTargetHeight)))
304 304                      let currentRateUpdated = fraction(((toBigInt(amount_) * PERCENT_FACTOR) + remainingReward), ONE_BIGINT, (assetQuantity * toBigInt(spreadBlocks_)))
305 305                      let lastHeightUpdated = height
306 306                      let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
307 307  [BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
308 308                      }
309 309                  else if ((targetHeight > lastHeight))
310 310                      then {
311 311                          let lastRateUpdated = (lastRate + (toBigInt((targetHeight - lastHeight)) * currentRate))
312 312                          let currentRateUpdated = fraction(toBigInt(amount_), PERCENT_FACTOR, (assetQuantity * toBigInt(spreadBlocks_)))
313 313                          let lastHeightUpdated = height
314 314                          let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
315 315  [BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
316 316                          }
317 317                      else {
318 318                          let currentRateUpdated = fraction(toBigInt(amount_), PERCENT_FACTOR, (assetQuantity * toBigInt(spreadBlocks_)))
319 319                          let lastHeightUpdated = height
320 320                          let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
321 321  [BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
322 322                          }
323 323              let stakeActions = _updateStaking(baseAsset, amount_, _loadStakingAdapter())
324 324              $Tuple2((actions ++ stakeActions), unit)
325 325              }
326 326          else throw("Strict value is not equal to itself.")
327 327      }
328 328  
329 329  
330 330  
331 331  @Callable(i)
332 332  func withdraw () = {
333 333      let caller = toString(i.caller)
334 334      let baseAsset = _loadBaseAsset()
335 335      let asset = _loadAsset()
336 336      let assetQuantity = toBigInt(_getAssetQuantity(asset))
337 337      let err = if ((1 > size(i.payments)))
338 338          then throw("withdraw: no payments")
339 339          else if ((i.payments[0].assetId != asset))
340 340              then throw("withdraw: payment is not in correct asset")
341 341              else if ((0 >= i.payments[0].amount))
342 342                  then throw("withdraw: invalid payment amount")
343 343                  else unit
344 344      if ((err == err))
345 345          then {
346 346              let checkpoint = _checkpoint(false)
347 347              if ((checkpoint == checkpoint))
348 348                  then {
349 349                      let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
350 350                      let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
351 351                      let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
352 352                      let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
353 353                      let lastRateUpdated = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
354 354                      let baseAmount = toInt(fraction(toBigInt(i.payments[0].amount), lastRateUpdated, PERCENT_FACTOR, FLOOR))
355 355                      let currentRateUpdated = fraction(currentRate, assetQuantity, (assetQuantity - toBigInt(i.payments[0].amount)), FLOOR)
356 356                      let lastHeightUpdated = targetHeight
357 357                      let stakeActions = _updateStaking(baseAsset, (-1 * baseAmount), _loadStakingAdapter())
358 358                      $Tuple2((stakeActions ++ [Burn(asset, i.payments[0].amount), ScriptTransfer(i.caller, baseAmount, unit), BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated)]), unit)
359 359                      }
360 360                  else throw("Strict value is not equal to itself.")
361 361              }
362 362          else throw("Strict value is not equal to itself.")
363 363      }
364 364  
365 365  
366 366  
367 367  @Callable(i)
368 368  func setMultisig (multisig_) = {
369 369      let err = if ((i.caller != this))
370 370          then throw("setMultisig: permission denied")
371 371          else if (!(_validateAddress(multisig_)))
372 372              then throw("setMultisig: invalid multisig address")
373 373              else unit
374 374      if ((err == err))
375 375          then $Tuple2([StringEntry(KEY_MULTISIG, multisig_)], unit)
376 376          else throw("Strict value is not equal to itself.")
377 377      }
378 378  
379 379  
380 380  
381 381  @Callable(i)
382 382  func setSponsorshipManager (manager_) = {
383 383      let err = if ((i.caller != this))
384 384          then throw("setSponsorshipManager: permission denied")
385 385          else if (!(_validateAddress(manager_)))
386 386              then throw("setSponsorshipManager: invalid manager address")
387 387              else unit
388 388      if ((err == err))
389 389          then $Tuple2([StringEntry(KEY_SPONSORSHIP_MANAGER, manager_)], unit)
390 390          else throw("Strict value is not equal to itself.")
391 391      }
392 392  
393 393  
394 394  
395 395  @Callable(i)
396 396  func updateSponsorship (minSponsoredAssetFee_,wavesRequiredAmount_) = {
397 397      let err = if ((i.caller != _loadSponsorshipManager()))
398 398          then throw("updateSponsorship: permission denied")
399 399          else if ((0 > minSponsoredAssetFee_))
400 400              then throw("updateSponsorship: invalid sponsorship fee")
401 401              else if ((0 > wavesRequiredAmount_))
402 402                  then throw("updateSponsorship: invalid waves required amount")
403 403                  else unit
404 404      if ((err == err))
405 405          then {
406 406              let sponsorAsset = _loadAsset()
407 407              let minSponsoredAssetFee = if ((minSponsoredAssetFee_ == 0))
408 408                  then unit
409 409                  else minSponsoredAssetFee_
410 410              let actions = if ((wavesBalance(this).regular > wavesRequiredAmount_))
411 411                  then [ScriptTransfer(i.caller, (wavesBalance(this).regular - wavesRequiredAmount_), unit)]
412 412                  else nil
413 413              $Tuple2((actions ++ [ScriptTransfer(i.caller, assetBalance(this, sponsorAsset), sponsorAsset), SponsorFee(sponsorAsset, minSponsoredAssetFee)]), unit)
414 414              }
415 415          else throw("Strict value is not equal to itself.")
416 416      }
417 417  
418 418  
419 419  
420 420  @Callable(i)
421 421  func wxVotingSuggest (votingAddress_,wxAsset_,assetImage_) = {
422 422      let votingAddress = valueOrErrorMessage(addressFromString(votingAddress_), "wxVotingSuggest: invalid voting address")
423 +     let sponsorAssetStr = toBase58String(_loadAsset())
423 424      let wxAsset = _toAssetVector(wxAsset_)
424 425      let wxAssetInfo = valueOrErrorMessage(assetInfo(valueOrErrorMessage(wxAsset, "wxVotingSuggest: invalid wx asset")), "wxVotingSuggest: invalid wx asset info")
425 -     let invocation = invoke(votingAddress, "suggest", [_loadAsset(), assetImage_], [AttachedPayment(wxAsset, (100 * wxAssetInfo.decimals))])
426 +     let invocation = invoke(votingAddress, "suggest", [sponsorAssetStr, assetImage_], [AttachedPayment(wxAsset, (100 * wxAssetInfo.decimals))])
426 427      if ((invocation == invocation))
427 428          then $Tuple2(nil, unit)
428 429          else throw("Strict value is not equal to itself.")
429 430      }
430 431  
431 432  
432 433  @Verifier(tx)
433 434  func verify () = match getString(KEY_MULTISIG) {
434 435      case multisig: String => 
435 436          valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
436 437      case _ => 
437 438          sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
438 439  }
439 440

Old	New		Differences
420	420		@Callable(i)
421	421		func wxVotingSuggest (votingAddress_,wxAsset_,assetImage_) = {
422	422		let votingAddress = valueOrErrorMessage(addressFromString(votingAddress_), "wxVotingSuggest: invalid voting address")
	423	+	let sponsorAssetStr = toBase58String(_loadAsset())
423	424		let wxAsset = _toAssetVector(wxAsset_)
424	425		let wxAssetInfo = valueOrErrorMessage(assetInfo(valueOrErrorMessage(wxAsset, "wxVotingSuggest: invalid wx asset")), "wxVotingSuggest: invalid wx asset info")
425		-	let invocation = invoke(votingAddress, "suggest", [~~_loadAsset()~~, assetImage_], [AttachedPayment(wxAsset, (100 * wxAssetInfo.decimals))])
	426	+	let invocation = invoke(votingAddress, "suggest", [sponsorAssetStr, assetImage_], [AttachedPayment(wxAsset, (100 * wxAssetInfo.decimals))])
426	427		if ((invocation == invocation))
427	428		then $Tuple2(nil, unit)
428	429		else throw("Strict value is not equal to itself.")

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let SEPARATOR = "__"
5	5
6	6		let WAVES = "WAVES"
7	7
8	8		let KEY_MULTISIG = "MULTISIG"
9	9
10	10		let KEY_STATUS = "STATUS"
11	11
12	12		let KEY_BASE_ASSET = "BASE_ASSET"
13	13
14	14		let KEY_ASSET = "ASSET"
15	15
16	16		let KEY_STAKING_ADAPTER = "STAKING_ADAPTER"
17	17
18	18		let KEY_STAKING_AMOUNT = "STAKING_AMOUNT"
19	19
20	20		let KEY_LAST_RATE = "LAST_RATE"
21	21
22	22		let KEY_CURRENT_RATE = "CURRENT_RATE"
23	23
24	24		let KEY_LAST_HEIGHT = "LAST_HEIGHT"
25	25
26	26		let KEY_TARGET_HEIGHT = "TARGET_HEIGHT"
27	27
28	28		let KEY_SPONSORSHIP_MANAGER = "SPONSORSHIP_MANAGER"
29	29
30	30		let FUNC_STAKE = "stake"
31	31
32	32		let FUNC_UNSTAKE = "unstake"
33	33
34	34		let FUNC_CLAIM_REWARD = "claimReward"
35	35
36	36		let PERCENT_FACTOR = toBigInt(1000000000000)
37	37
38	38		let ZERO_BIGINT = toBigInt(0)
39	39
40	40		let ONE_BIGINT = toBigInt(1)
41	41
42	42		let INIT_AMOUNT = 100000000
43	43
44	44		func _validateAddress (address_) = match addressFromString(address_) {
45	45		case a: Address =>
46	46		true
47	47		case _ =>
48	48		false
49	49		}
50	50
51	51
52	52		func _validateAsset (asset_) = if ((asset_ == WAVES))
53	53		then true
54	54		else match assetInfo(fromBase58String(asset_)) {
55	55		case a: Asset =>
56	56		true
57	57		case _ =>
58	58		false
59	59		}
60	60
61	61
62	62		func _toAssetVector (asset_) = if ((asset_ == WAVES))
63	63		then unit
64	64		else fromBase58String(asset_)
65	65
66	66
67	67		func _getAssetDecimals (asset_) = match asset_ {
68	68		case a: ByteVector =>
69	69		match assetInfo(a) {
70	70		case asset: Asset =>
71	71		asset.decimals
72	72		case _ =>
73	73		throw("_getAssetDecimals: no such asset")
74	74		}
75	75		case _ =>
76	76		8
77	77		}
78	78
79	79
80	80		func _getAssetQuantity (asset_) = match assetInfo(asset_) {
81	81		case a: Asset =>
82	82		a.quantity
83	83		case _ =>
84	84		throw("_getAssetQuantity: no such asset")
85	85		}
86	86
87	87
88	88		func _getAssetBalance (asset_,address) = match asset_ {
89	89		case a: ByteVector =>
90	90		assetBalance(address, a)
91	91		case _ =>
92	92		wavesBalance(address).regular
93	93		}
94	94
95	95
96	96		func _loadBaseAsset () = match getString(KEY_BASE_ASSET) {
97	97		case a: String =>
98	98		if ((a == WAVES))
99	99		then unit
100	100		else fromBase58String(a)
101	101		case _ =>
102	102		throw("_loadBaseAsset: no base asset")
103	103		}
104	104
105	105
106	106		func _loadStakingAdapter () = match getString(KEY_STAKING_ADAPTER) {
107	107		case a: String =>
108	108		addressFromStringValue(a)
109	109		case _ =>
110	110		throw("_loadStakingAdapter: no staking adapter")
111	111		}
112	112
113	113
114	114		func _loadSponsorshipManager () = match getString(KEY_SPONSORSHIP_MANAGER) {
115	115		case a: String =>
116	116		addressFromStringValue(a)
117	117		case _ =>
118	118		throw("_loadSponsorshipManager: no sponsorship manager")
119	119		}
120	120
121	121
122	122		func _loadInt (key_,default_) = match getInteger(key_) {
123	123		case a: Int =>
124	124		a
125	125		case _ =>
126	126		default_
127	127		}
128	128
129	129
130	130		func _loadBigInt (key_,default_) = match getBinary(key_) {
131	131		case a: ByteVector =>
132	132		toBigInt(a)
133	133		case _ =>
134	134		default_
135	135		}
136	136
137	137
138	138		func _loadAsset () = match getString(KEY_ASSET) {
139	139		case a: String =>
140	140		fromBase58String(a)
141	141		case _ =>
142	142		base58''
143	143		}
144	144
145	145
146	146		func _updateStaking (asset_,amount_,adapter_) = {
147	147		let stakingAmount = _loadInt(KEY_STAKING_AMOUNT, 0)
148	148		let newStakingAmount = (stakingAmount + amount_)
149	149		let invocation = if ((amount_ > 0))
150	150		then invoke(adapter_, FUNC_STAKE, nil, [AttachedPayment(asset_, amount_)])
151	151		else invoke(adapter_, FUNC_UNSTAKE, [(-1 * amount_)], nil)
152	152		if ((invocation == invocation))
153	153		then [IntegerEntry(KEY_STAKING_AMOUNT, newStakingAmount)]
154	154		else throw("Strict value is not equal to itself.")
155	155		}
156	156
157	157
158	158		func _checkpoint (compensation) = {
159	159		let invocation = invoke(_loadStakingAdapter(), FUNC_CLAIM_REWARD, nil, nil)
160	160		if ((invocation == invocation))
161	161		then match invocation {
162	162		case reward: (Int, Int, Int) =>
163	163		if (compensation)
164	164		then {
165	165		let stake = invoke(this, FUNC_STAKE, [reward._1, reward._3], nil)
166	166		if ((stake == stake))
167	167		then $Tuple2(true, reward._2)
168	168		else throw("Strict value is not equal to itself.")
169	169		}
170	170		else {
171	171		let stake = invoke(this, FUNC_STAKE, [(reward._1 + reward._2), reward._3], nil)
172	172		if ((stake == stake))
173	173		then $Tuple2(true, 0)
174	174		else throw("Strict value is not equal to itself.")
175	175		}
176	176		case _ =>
177	177		$Tuple2(false, 0)
178	178		}
179	179		else throw("Strict value is not equal to itself.")
180	180		}
181	181
182	182
183	183		@Callable(i)
184	184		func init (tokenName_,tokenDescr_,baseAsset_,stakingAdapter_) = {
185	185		let multisig = valueOrErrorMessage(getString(KEY_MULTISIG), "init: no multisig set")
186	186		let asset = _loadAsset()
187	187		let baseAsset = _toAssetVector(baseAsset_)
188	188		let err = if ((i.caller != this))
189	189		then throw("init: permission denied")
190	190		else if ((asset != base58''))
191	191		then throw("init: already initialized")
192	192		else if (if ((4 > size(tokenName_)))
193	193		then true
194	194		else (size(tokenName_) > 16))
195	195		then throw("init: invalid token name")
196	196		else if ((size(tokenDescr_) > 1000))
197	197		then throw("init: invalid token description")
198	198		else if (!(_validateAsset(baseAsset_)))
199	199		then throw("init: invalid base asset")
200	200		else if (!(_validateAddress(stakingAdapter_)))
201	201		then throw("init: invalid staking adapter")
202	202		else unit
203	203		if ((err == err))
204	204		then {
205	205		let tokenDecimals = _getAssetDecimals(baseAsset)
206	206		let issue = Issue(tokenName_, tokenDescr_, INIT_AMOUNT, tokenDecimals, true)
207	207		let assetId = calculateAssetId(issue)
208	208		let stakeActions = _updateStaking(baseAsset, INIT_AMOUNT, addressFromStringValue(stakingAdapter_))
209	209		$Tuple2(([StringEntry(KEY_BASE_ASSET, baseAsset_), StringEntry(KEY_STAKING_ADAPTER, stakingAdapter_), StringEntry(KEY_ASSET, toBase58String(assetId)), issue] ++ stakeActions), unit)
210	210		}
211	211		else throw("Strict value is not equal to itself.")
212	212		}
213	213
214	214
215	215
216	216		@Callable(i)
217	217		func getRate () = {
218	218		let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
219	219		let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
220	220		let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
221	221		let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
222	222		let rate = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
223	223		$Tuple2(nil, toString(rate))
224	224		}
225	225
226	226
227	227
228	228		@Callable(i)
229	229		func checkpoint () = {
230	230		let checkpoint = _checkpoint(true)
231	231		if ((checkpoint == checkpoint))
232	232		then if (!(checkpoint._1))
233	233		then throw("checkpoint: no reward")
234	234		else if ((checkpoint._2 > 0))
235	235		then $Tuple2([ScriptTransfer(i.originCaller, checkpoint._2, _loadBaseAsset())], unit)
236	236		else $Tuple2(nil, unit)
237	237		else throw("Strict value is not equal to itself.")
238	238		}
239	239
240	240
241	241
242	242		@Callable(i)
243	243		func deposit () = {
244	244		let caller = toString(i.caller)
245	245		let baseAsset = _loadBaseAsset()
246	246		let asset = _loadAsset()
247	247		let assetQuantity = toBigInt(_getAssetQuantity(asset))
248	248		let err = if ((size(i.payments) != 1))
249	249		then throw("deposit: no payments")
250	250		else if ((i.payments[0].assetId != baseAsset))
251	251		then throw("deposit: payment is not in base asset")
252	252		else if ((0 >= i.payments[0].amount))
253	253		then throw("deposit: invalid payment amount")
254	254		else unit
255	255		if ((err == err))
256	256		then {
257	257		let checkpoint = _checkpoint(false)
258	258		if ((checkpoint == checkpoint))
259	259		then {
260	260		let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
261	261		let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
262	262		let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
263	263		let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
264	264		let lastRateUpdated = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
265	265		let issueAmount = toInt(fraction(toBigInt(i.payments[0].amount), PERCENT_FACTOR, lastRateUpdated, FLOOR))
266	266		let currentRateUpdated = fraction(currentRate, assetQuantity, (assetQuantity + toBigInt(issueAmount)), FLOOR)
267	267		let lastHeightUpdated = targetHeight
268	268		let stakeActions = _updateStaking(baseAsset, i.payments[0].amount, _loadStakingAdapter())
269	269		$Tuple2(([Reissue(asset, issueAmount, true), ScriptTransfer(i.caller, issueAmount, asset), BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated)] ++ stakeActions), unit)
270	270		}
271	271		else throw("Strict value is not equal to itself.")
272	272		}
273	273		else throw("Strict value is not equal to itself.")
274	274		}
275	275
276	276
277	277
278	278		@Callable(i)
279	279		func stake (amount_,spreadBlocks_) = {
280	280		let caller = toString(i.caller)
281	281		let baseAsset = _loadBaseAsset()
282	282		let asset = _loadAsset()
283	283		let assetQuantity = toBigInt(_getAssetQuantity(asset))
284	284		let err = if ((i.caller != this))
285	285		then throw("stake: only this contract")
286	286		else if ((0 >= amount_))
287	287		then throw("stake: invalid stake amount")
288	288		else if ((amount_ > _getAssetBalance(baseAsset, this)))
289	289		then throw("stake: insufficient stake amount")
290	290		else if ((assetQuantity == ZERO_BIGINT))
291	291		then throw("stake: no deposits to stake for")
292	292		else unit
293	293		if ((err == err))
294	294		then {
295	295		let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
296	296		let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
297	297		let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
298	298		let targetHeight = _loadInt(KEY_TARGET_HEIGHT, 0)
299	299		let minTargetHeight = min([targetHeight, height])
300	300		let actions = if ((minTargetHeight == height))
301	301		then {
302	302		let lastRateUpdated = (lastRate + (toBigInt((minTargetHeight - lastHeight)) * currentRate))
303	303		let remainingReward = (currentRate * toBigInt((targetHeight - minTargetHeight)))
304	304		let currentRateUpdated = fraction(((toBigInt(amount_) * PERCENT_FACTOR) + remainingReward), ONE_BIGINT, (assetQuantity * toBigInt(spreadBlocks_)))
305	305		let lastHeightUpdated = height
306	306		let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
307	307		[BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
308	308		}
309	309		else if ((targetHeight > lastHeight))
310	310		then {
311	311		let lastRateUpdated = (lastRate + (toBigInt((targetHeight - lastHeight)) * currentRate))
312	312		let currentRateUpdated = fraction(toBigInt(amount_), PERCENT_FACTOR, (assetQuantity * toBigInt(spreadBlocks_)))
313	313		let lastHeightUpdated = height
314	314		let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
315	315		[BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
316	316		}
317	317		else {
318	318		let currentRateUpdated = fraction(toBigInt(amount_), PERCENT_FACTOR, (assetQuantity * toBigInt(spreadBlocks_)))
319	319		let lastHeightUpdated = height
320	320		let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
321	321		[BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
322	322		}
323	323		let stakeActions = _updateStaking(baseAsset, amount_, _loadStakingAdapter())
324	324		$Tuple2((actions ++ stakeActions), unit)
325	325		}
326	326		else throw("Strict value is not equal to itself.")
327	327		}
328	328
329	329
330	330
331	331		@Callable(i)
332	332		func withdraw () = {
333	333		let caller = toString(i.caller)
334	334		let baseAsset = _loadBaseAsset()
335	335		let asset = _loadAsset()
336	336		let assetQuantity = toBigInt(_getAssetQuantity(asset))
337	337		let err = if ((1 > size(i.payments)))
338	338		then throw("withdraw: no payments")
339	339		else if ((i.payments[0].assetId != asset))
340	340		then throw("withdraw: payment is not in correct asset")
341	341		else if ((0 >= i.payments[0].amount))
342	342		then throw("withdraw: invalid payment amount")
343	343		else unit
344	344		if ((err == err))
345	345		then {
346	346		let checkpoint = _checkpoint(false)
347	347		if ((checkpoint == checkpoint))
348	348		then {
349	349		let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
350	350		let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
351	351		let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
352	352		let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
353	353		let lastRateUpdated = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
354	354		let baseAmount = toInt(fraction(toBigInt(i.payments[0].amount), lastRateUpdated, PERCENT_FACTOR, FLOOR))
355	355		let currentRateUpdated = fraction(currentRate, assetQuantity, (assetQuantity - toBigInt(i.payments[0].amount)), FLOOR)
356	356		let lastHeightUpdated = targetHeight
357	357		let stakeActions = _updateStaking(baseAsset, (-1 * baseAmount), _loadStakingAdapter())
358	358		$Tuple2((stakeActions ++ [Burn(asset, i.payments[0].amount), ScriptTransfer(i.caller, baseAmount, unit), BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated)]), unit)
359	359		}
360	360		else throw("Strict value is not equal to itself.")
361	361		}
362	362		else throw("Strict value is not equal to itself.")
363	363		}
364	364
365	365
366	366
367	367		@Callable(i)
368	368		func setMultisig (multisig_) = {
369	369		let err = if ((i.caller != this))
370	370		then throw("setMultisig: permission denied")
371	371		else if (!(_validateAddress(multisig_)))
372	372		then throw("setMultisig: invalid multisig address")
373	373		else unit
374	374		if ((err == err))
375	375		then $Tuple2([StringEntry(KEY_MULTISIG, multisig_)], unit)
376	376		else throw("Strict value is not equal to itself.")
377	377		}
378	378
379	379
380	380
381	381		@Callable(i)
382	382		func setSponsorshipManager (manager_) = {
383	383		let err = if ((i.caller != this))
384	384		then throw("setSponsorshipManager: permission denied")
385	385		else if (!(_validateAddress(manager_)))
386	386		then throw("setSponsorshipManager: invalid manager address")
387	387		else unit
388	388		if ((err == err))
389	389		then $Tuple2([StringEntry(KEY_SPONSORSHIP_MANAGER, manager_)], unit)
390	390		else throw("Strict value is not equal to itself.")
391	391		}
392	392
393	393
394	394
395	395		@Callable(i)
396	396		func updateSponsorship (minSponsoredAssetFee_,wavesRequiredAmount_) = {
397	397		let err = if ((i.caller != _loadSponsorshipManager()))
398	398		then throw("updateSponsorship: permission denied")
399	399		else if ((0 > minSponsoredAssetFee_))
400	400		then throw("updateSponsorship: invalid sponsorship fee")
401	401		else if ((0 > wavesRequiredAmount_))
402	402		then throw("updateSponsorship: invalid waves required amount")
403	403		else unit
404	404		if ((err == err))
405	405		then {
406	406		let sponsorAsset = _loadAsset()
407	407		let minSponsoredAssetFee = if ((minSponsoredAssetFee_ == 0))
408	408		then unit
409	409		else minSponsoredAssetFee_
410	410		let actions = if ((wavesBalance(this).regular > wavesRequiredAmount_))
411	411		then [ScriptTransfer(i.caller, (wavesBalance(this).regular - wavesRequiredAmount_), unit)]
412	412		else nil
413	413		$Tuple2((actions ++ [ScriptTransfer(i.caller, assetBalance(this, sponsorAsset), sponsorAsset), SponsorFee(sponsorAsset, minSponsoredAssetFee)]), unit)
414	414		}
415	415		else throw("Strict value is not equal to itself.")
416	416		}
417	417
418	418
419	419
420	420		@Callable(i)
421	421		func wxVotingSuggest (votingAddress_,wxAsset_,assetImage_) = {
422	422		let votingAddress = valueOrErrorMessage(addressFromString(votingAddress_), "wxVotingSuggest: invalid voting address")
	423	+	let sponsorAssetStr = toBase58String(_loadAsset())
423	424		let wxAsset = _toAssetVector(wxAsset_)
424	425		let wxAssetInfo = valueOrErrorMessage(assetInfo(valueOrErrorMessage(wxAsset, "wxVotingSuggest: invalid wx asset")), "wxVotingSuggest: invalid wx asset info")
425		-	let invocation = invoke(votingAddress, "suggest", [~~_loadAsset()~~, assetImage_], [AttachedPayment(wxAsset, (100 * wxAssetInfo.decimals))])
	426	+	let invocation = invoke(votingAddress, "suggest", [sponsorAssetStr, assetImage_], [AttachedPayment(wxAsset, (100 * wxAssetInfo.decimals))])
426	427		if ((invocation == invocation))
427	428		then $Tuple2(nil, unit)
428	429		else throw("Strict value is not equal to itself.")
429	430		}
430	431
431	432
432	433		@Verifier(tx)
433	434		func verify () = match getString(KEY_MULTISIG) {
434	435		case multisig: String =>
435	436		valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
436	437		case _ =>
437	438		sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
438	439		}
439	440

github/deemru/w8io/026f985 
47.39 ms ◑