tx · HfJMuDyMmbbKywPzobke9UokeR2m9pcRkACZa1FowZfE

3N4kXZHGke6yRq3Z57q7BTgCrT2SCvQCYER:  -0.01400000 Waves

2022.11.23 17:41 [2329876] smart account 3N4kXZHGke6yRq3Z57q7BTgCrT2SCvQCYER > SELF 0.00000000 Waves

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

View: original | compacted
Prev: H2eEyE6XiF9WsSJSg7NrMnWLJVToPR5CEpwGJ84hc7KJ
Next: EsKWbvZopS9vYW7hTSmuSK5Dm2YD4LEYD7qnrSLWTXW1

Diff: 

OldNewDifferences
187187                         then throw("init: invalid base asset")
188188                         else if (!(_validateAddress(stakingAdapter_)))
189189                             then throw("init: invalid staking adapter")
190-                            else if ((size(i.payments) != 1))
191-                                then throw("init: payment is not present")
192-                                else if ((i.payments[0].assetId != baseAsset))
193-                                    then throw("init: payment is not in base asset")
194-                                    else if ((0 >= i.payments[0].amount))
195-                                        then throw("init: invalid payment amount")
196-                                        else unit
190+                            else if ((0 >= wavesBalance(this).regular))
191+                                then throw("init: no waves at this contract")
192+                                else unit
197193     if ((err == err))
198194         then {
199195             let tokenDecimals = _getAssetDecimals(baseAsset)
200-            let issue = Issue(tokenName_, tokenDescr_, i.payments[0].amount, tokenDecimals, true)
196+            let issue = Issue(tokenName_, tokenDescr_, wavesBalance(this).regular, tokenDecimals, true)
201197             let assetId = calculateAssetId(issue)
202-            let stakeActions = _updateStaking(baseAsset, i.payments[0].amount, addressFromStringValue(stakingAdapter_))
198+            let stakeActions = _updateStaking(baseAsset, wavesBalance(this).regular, addressFromStringValue(stakingAdapter_))
203199             $Tuple2(([StringEntry(KEY_BASE_ASSET, baseAsset_), StringEntry(KEY_STAKING_ADAPTER, stakingAdapter_), StringEntry(KEY_ASSET, toBase58String(assetId)), issue] ++ stakeActions), unit)
204200             }
205201         else throw("Strict value is not equal to itself.")

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEPARATOR = "__"
55 
66 let WAVES = "WAVES"
77 
88 let KEY_MULTISIG = "MULTISIG"
99 
1010 let KEY_STATUS = "STATUS"
1111 
1212 let KEY_BASE_ASSET = "BASE_ASSET"
1313 
1414 let KEY_ASSET = "ASSET"
1515 
1616 let KEY_STAKING_ADAPTER = "STAKING_ADAPTER"
1717 
1818 let KEY_STAKING_AMOUNT = "STAKING_AMOUNT"
1919 
2020 let KEY_LAST_RATE = "LAST_RATE"
2121 
2222 let KEY_CURRENT_RATE = "CURRENT_RATE"
2323 
2424 let KEY_LAST_HEIGHT = "LAST_HEIGHT"
2525 
2626 let KEY_TARGET_HEIGHT = "TARGET_HEIGHT"
2727 
2828 let FUNC_STAKE = "stake"
2929 
3030 let FUNC_UNSTAKE = "unstake"
3131 
3232 let FUNC_CLAIM_REWARD = "claimReward"
3333 
3434 let PERCENT_FACTOR = toBigInt(1000000000000)
3535 
3636 let ZERO_BIGINT = toBigInt(0)
3737 
3838 let ONE_BIGINT = toBigInt(1)
3939 
4040 func _validateAddress (address_) = match addressFromString(address_) {
4141     case a: Address => 
4242         true
4343     case _ => 
4444         false
4545 }
4646 
4747 
4848 func _validateAsset (asset_) = if ((asset_ == WAVES))
4949     then true
5050     else     match assetInfo(fromBase58String(asset_)) {
5151         case a: Asset => 
5252             true
5353         case _ => 
5454             false
5555     }
5656 
5757 
5858 func _toAssetVector (asset_) = if ((asset_ == WAVES))
5959     then unit
6060     else fromBase58String(asset_)
6161 
6262 
6363 func _getAssetDecimals (asset_) = match asset_ {
6464     case a: ByteVector => 
6565         match assetInfo(a) {
6666             case asset: Asset => 
6767                 asset.decimals
6868             case _ => 
6969                 throw("_getAssetDecimals: no such asset")
7070         }
7171     case _ => 
7272         8
7373 }
7474 
7575 
7676 func _getAssetQuantity (asset_) = match assetInfo(asset_) {
7777     case a: Asset => 
7878         a.quantity
7979     case _ => 
8080         throw("_getAssetQuantity: no such asset")
8181 }
8282 
8383 
8484 func _getAssetBalance (asset_,address) = match asset_ {
8585     case a: ByteVector => 
8686         assetBalance(address, a)
8787     case _ => 
8888         wavesBalance(address).regular
8989 }
9090 
9191 
9292 func _loadBaseAsset () = match getString(KEY_BASE_ASSET) {
9393     case a: String => 
9494         if ((a == WAVES))
9595             then unit
9696             else fromBase58String(a)
9797     case _ => 
9898         throw("_loadBaseAsset: no base asset")
9999 }
100100 
101101 
102102 func _loadStakingAdapter () = match getString(KEY_STAKING_ADAPTER) {
103103     case a: String => 
104104         addressFromStringValue(a)
105105     case _ => 
106106         throw("_loadStakingAdapter: no staking adapter")
107107 }
108108 
109109 
110110 func _loadInt (key_,default_) = match getInteger(key_) {
111111     case a: Int => 
112112         a
113113     case _ => 
114114         default_
115115 }
116116 
117117 
118118 func _loadBigInt (key_,default_) = match getBinary(key_) {
119119     case a: ByteVector => 
120120         toBigInt(a)
121121     case _ => 
122122         default_
123123 }
124124 
125125 
126126 func _loadAsset () = match getString(KEY_ASSET) {
127127     case a: String => 
128128         fromBase58String(a)
129129     case _ => 
130130         base58''
131131 }
132132 
133133 
134134 func _updateStaking (asset_,amount_,adapter_) = {
135135     let stakingAmount = _loadInt(KEY_STAKING_AMOUNT, 0)
136136     let newStakingAmount = (stakingAmount + amount_)
137137     let invocation = if ((amount_ > 0))
138138         then invoke(adapter_, FUNC_STAKE, nil, [AttachedPayment(asset_, amount_)])
139139         else invoke(adapter_, FUNC_UNSTAKE, [(-1 * amount_)], nil)
140140     if ((invocation == invocation))
141141         then [IntegerEntry(KEY_STAKING_AMOUNT, newStakingAmount)]
142142         else throw("Strict value is not equal to itself.")
143143     }
144144 
145145 
146146 func _checkpoint (compensation) = {
147147     let invocation = invoke(_loadStakingAdapter(), FUNC_CLAIM_REWARD, nil, nil)
148148     if ((invocation == invocation))
149149         then         match invocation {
150150             case reward: (Int, Int, Int) => 
151151                 if (compensation)
152152                     then {
153153                         let stake = invoke(this, FUNC_STAKE, [reward._1, reward._3], nil)
154154                         if ((stake == stake))
155155                             then $Tuple2(true, reward._2)
156156                             else throw("Strict value is not equal to itself.")
157157                         }
158158                     else {
159159                         let stake = invoke(this, FUNC_STAKE, [(reward._1 + reward._2), reward._3], nil)
160160                         if ((stake == stake))
161161                             then $Tuple2(true, 0)
162162                             else throw("Strict value is not equal to itself.")
163163                         }
164164             case _ => 
165165                 $Tuple2(false, 0)
166166         }
167167         else throw("Strict value is not equal to itself.")
168168     }
169169 
170170 
171171 @Callable(i)
172172 func init (tokenName_,tokenDescr_,baseAsset_,stakingAdapter_) = {
173173     let multisig = valueOrErrorMessage(getString(KEY_MULTISIG), "init: no multisig set")
174174     let asset = _loadAsset()
175175     let baseAsset = _toAssetVector(baseAsset_)
176176     let err = if ((i.caller != this))
177177         then throw("init: permission denied")
178178         else if ((asset != base58''))
179179             then throw("init: already initialized")
180180             else if (if ((4 > size(tokenName_)))
181181                 then true
182182                 else (size(tokenName_) > 16))
183183                 then throw("init: invalid token name")
184184                 else if ((size(tokenDescr_) > 1000))
185185                     then throw("init: invalid token description")
186186                     else if (!(_validateAsset(baseAsset_)))
187187                         then throw("init: invalid base asset")
188188                         else if (!(_validateAddress(stakingAdapter_)))
189189                             then throw("init: invalid staking adapter")
190-                            else if ((size(i.payments) != 1))
191-                                then throw("init: payment is not present")
192-                                else if ((i.payments[0].assetId != baseAsset))
193-                                    then throw("init: payment is not in base asset")
194-                                    else if ((0 >= i.payments[0].amount))
195-                                        then throw("init: invalid payment amount")
196-                                        else unit
190+                            else if ((0 >= wavesBalance(this).regular))
191+                                then throw("init: no waves at this contract")
192+                                else unit
197193     if ((err == err))
198194         then {
199195             let tokenDecimals = _getAssetDecimals(baseAsset)
200-            let issue = Issue(tokenName_, tokenDescr_, i.payments[0].amount, tokenDecimals, true)
196+            let issue = Issue(tokenName_, tokenDescr_, wavesBalance(this).regular, tokenDecimals, true)
201197             let assetId = calculateAssetId(issue)
202-            let stakeActions = _updateStaking(baseAsset, i.payments[0].amount, addressFromStringValue(stakingAdapter_))
198+            let stakeActions = _updateStaking(baseAsset, wavesBalance(this).regular, addressFromStringValue(stakingAdapter_))
203199             $Tuple2(([StringEntry(KEY_BASE_ASSET, baseAsset_), StringEntry(KEY_STAKING_ADAPTER, stakingAdapter_), StringEntry(KEY_ASSET, toBase58String(assetId)), issue] ++ stakeActions), unit)
204200             }
205201         else throw("Strict value is not equal to itself.")
206202     }
207203 
208204 
209205 
210206 @Callable(i)
211207 func getRate () = {
212208     let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
213209     let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
214210     let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
215211     let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
216212     let rate = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
217213     $Tuple2(nil, toString(rate))
218214     }
219215 
220216 
221217 
222218 @Callable(i)
223219 func checkpoint () = {
224220     let checkpoint = _checkpoint(true)
225221     if ((checkpoint == checkpoint))
226222         then if (!(checkpoint._1))
227223             then throw("checkpoint: no reward")
228224             else if ((checkpoint._2 > 0))
229225                 then $Tuple2([ScriptTransfer(i.originCaller, checkpoint._2, _loadBaseAsset())], unit)
230226                 else $Tuple2(nil, unit)
231227         else throw("Strict value is not equal to itself.")
232228     }
233229 
234230 
235231 
236232 @Callable(i)
237233 func deposit () = {
238234     let caller = toString(i.caller)
239235     let baseAsset = _loadBaseAsset()
240236     let asset = _loadAsset()
241237     let assetQuantity = toBigInt(_getAssetQuantity(asset))
242238     let err = if ((size(i.payments) != 1))
243239         then throw("deposit: no payments")
244240         else if ((i.payments[0].assetId != baseAsset))
245241             then throw("deposit: payment is not in base asset")
246242             else if ((0 >= i.payments[0].amount))
247243                 then throw("deposit: invalid payment amount")
248244                 else unit
249245     if ((err == err))
250246         then {
251247             let checkpoint = _checkpoint(false)
252248             if ((checkpoint == checkpoint))
253249                 then {
254250                     let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
255251                     let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
256252                     let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
257253                     let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
258254                     let lastRateUpdated = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
259255                     let issueAmount = toInt(fraction(toBigInt(i.payments[0].amount), PERCENT_FACTOR, lastRateUpdated, FLOOR))
260256                     let currentRateUpdated = fraction(currentRate, assetQuantity, (assetQuantity + toBigInt(issueAmount)), FLOOR)
261257                     let lastHeightUpdated = targetHeight
262258                     let stakeActions = _updateStaking(baseAsset, i.payments[0].amount, _loadStakingAdapter())
263259                     $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)
264260                     }
265261                 else throw("Strict value is not equal to itself.")
266262             }
267263         else throw("Strict value is not equal to itself.")
268264     }
269265 
270266 
271267 
272268 @Callable(i)
273269 func stake (amount_,spreadBlocks_) = {
274270     let caller = toString(i.caller)
275271     let baseAsset = _loadBaseAsset()
276272     let asset = _loadAsset()
277273     let assetQuantity = toBigInt(_getAssetQuantity(asset))
278274     let err = if ((i.caller != this))
279275         then throw("stake: only this contract")
280276         else if ((0 >= amount_))
281277             then throw("stake: invalid stake amount")
282278             else if ((amount_ > _getAssetBalance(baseAsset, this)))
283279                 then throw("stake: insufficient stake amount")
284280                 else if ((assetQuantity == ZERO_BIGINT))
285281                     then throw("stake: no deposits to stake for")
286282                     else unit
287283     if ((err == err))
288284         then {
289285             let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
290286             let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
291287             let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
292288             let targetHeight = _loadInt(KEY_TARGET_HEIGHT, 0)
293289             let minTargetHeight = min([targetHeight, height])
294290             let actions = if ((minTargetHeight == height))
295291                 then {
296292                     let lastRateUpdated = (lastRate + (toBigInt((minTargetHeight - lastHeight)) * currentRate))
297293                     let remainingReward = (currentRate * toBigInt((targetHeight - minTargetHeight)))
298294                     let currentRateUpdated = fraction(((toBigInt(amount_) * PERCENT_FACTOR) + remainingReward), ONE_BIGINT, (assetQuantity * toBigInt(spreadBlocks_)))
299295                     let lastHeightUpdated = height
300296                     let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
301297 [BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
302298                     }
303299                 else if ((targetHeight > lastHeight))
304300                     then {
305301                         let lastRateUpdated = (lastRate + (toBigInt((targetHeight - lastHeight)) * currentRate))
306302                         let currentRateUpdated = fraction(toBigInt(amount_), PERCENT_FACTOR, (assetQuantity * toBigInt(spreadBlocks_)))
307303                         let lastHeightUpdated = height
308304                         let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
309305 [BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
310306                         }
311307                     else {
312308                         let currentRateUpdated = fraction(toBigInt(amount_), PERCENT_FACTOR, (assetQuantity * toBigInt(spreadBlocks_)))
313309                         let lastHeightUpdated = height
314310                         let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
315311 [BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
316312                         }
317313             let stakeActions = _updateStaking(baseAsset, amount_, _loadStakingAdapter())
318314             $Tuple2((actions ++ stakeActions), unit)
319315             }
320316         else throw("Strict value is not equal to itself.")
321317     }
322318 
323319 
324320 
325321 @Callable(i)
326322 func withdraw () = {
327323     let caller = toString(i.caller)
328324     let baseAsset = _loadBaseAsset()
329325     let asset = _loadAsset()
330326     let assetQuantity = toBigInt(_getAssetQuantity(asset))
331327     let err = if ((1 > size(i.payments)))
332328         then throw("withdraw: no payments")
333329         else if ((i.payments[0].assetId != asset))
334330             then throw("withdraw: payment is not in correct asset")
335331             else if ((0 >= i.payments[0].amount))
336332                 then throw("withdraw: invalid payment amount")
337333                 else unit
338334     if ((err == err))
339335         then {
340336             let checkpoint = _checkpoint(false)
341337             if ((checkpoint == checkpoint))
342338                 then {
343339                     let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
344340                     let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
345341                     let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
346342                     let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), height])
347343                     let lastRateUpdated = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
348344                     let baseAmount = toInt(fraction(toBigInt(i.payments[0].amount), lastRateUpdated, PERCENT_FACTOR, FLOOR))
349345                     let currentRateUpdated = fraction(currentRate, assetQuantity, (assetQuantity - toBigInt(i.payments[0].amount)), FLOOR)
350346                     let lastHeightUpdated = targetHeight
351347                     let stakeActions = _updateStaking(baseAsset, (-1 * baseAmount), _loadStakingAdapter())
352348                     $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)
353349                     }
354350                 else throw("Strict value is not equal to itself.")
355351             }
356352         else throw("Strict value is not equal to itself.")
357353     }
358354 
359355 
360356 
361357 @Callable(i)
362358 func setMultisig (multisig_) = {
363359     let err = if ((i.caller != this))
364360         then throw("setMultisig: permission denied")
365361         else if (!(_validateAddress(multisig_)))
366362             then throw("setMultisig: invalid multisig address")
367363             else unit
368364     if ((err == err))
369365         then $Tuple2([StringEntry(KEY_MULTISIG, multisig_)], unit)
370366         else throw("Strict value is not equal to itself.")
371367     }
372368 
373369 
374370 @Verifier(tx)
375371 func verify () = match getString(KEY_MULTISIG) {
376372     case multisig: String => 
377373         valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
378374     case _ => 
379375         sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
380376 }
381377 
github/deemru/w8io/3ef1775 
58.51 ms ◑