tx · HHBv7JxqsXywDm63FDf429FKDtyhdzjMWyJqNqFYP6Fs

3My8v3Ev8Uy7RJqQ64c4rmvtWM48dyUUUWH:  -0.05000000 Waves

2023.07.18 16:28 [2671378] smart account 3My8v3Ev8Uy7RJqQ64c4rmvtWM48dyUUUWH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HHBv7JxqsXywDm63FDf429FKDtyhdzjMWyJqNqFYP6Fs",
    "fee": 5000000,
    "feeAssetId": null,
    "timestamp": 1689686928393,
    "version": 2,
    "chainId": 84,
    "sender": "3My8v3Ev8Uy7RJqQ64c4rmvtWM48dyUUUWH",
    "senderPublicKey": "DjdxYmdJZYpqYDAR87ZysJMV8nmTgK5CfeyV1trVHcb3",
    "proofs": [
        "2RWvLsvYBYaK4jbdE1JKcoyjUTjVtbdYwkY5XYcDu7yXUYuBzhx1xRVYBv3R3PMTqcX26Ezw2GdzA2gVCbPUPg1g"
    ],
    "script": "base64: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",
    "height": 2671378,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let PRECISION = 1000000000000
7+
8+let ENABLED = "ENABLED"
9+
10+let DISABLED = "DISABLED"
11+
12+func divp (_x,_y) = fraction(_x, PRECISION, _y, HALFEVEN)
13+
14+
15+func mulp (_x,_y) = fraction(_x, _y, PRECISION, HALFEVEN)
16+
17+
18+func conv6to8 (_v) = (_v * 100)
19+
20+
21+func conv8to6 (_v) = (_v / 100)
22+
23+
24+func join (ar) = makeString(ar, SEP)
25+
26+
27+func keyInitialized () = join(["%s", "initialized"])
28+
29+
30+func keyCoordinatorAddress () = join(["%s", "coordinatorAddress"])
31+
32+
33+func keyVerifierAddress () = join(["%s", "verifierAddress"])
34+
35+
36+func keyEastAsset () = join(["%s", "eastAsset"])
37+
38+
39+func keySigned (_address,_txId) = join(["%s%s%s", "signed", _address, _txId])
40+
41+
42+func keyProtocolActive () = join(["%s", "protocolActive"])
43+
44+
45+func isInitialized () = valueOrElse(getBoolean(this, keyInitialized()), false)
46+
47+
48+func mustInitialized () = if (!(isInitialized()))
49+    then throw("Not initialized")
50+    else unit
51+
52+
53+func mustNotInitialized () = if (isInitialized())
54+    then throw("Already initialized")
55+    else unit
56+
57+
58+func mustSelf (i) = if ((i.caller != this))
59+    then throw("Only self invocation allowed.")
60+    else unit
61+
62+
63+func coordinator () = addressFromStringValue(valueOrErrorMessage(getString(keyCoordinatorAddress()), "Coordinator is not set"))
64+
65+
66+func verifier () = match getString(keyCoordinatorAddress()) {
67+    case s: String => 
68+        getString(addressFromStringValue(s), keyVerifierAddress())
69+    case _: Unit => 
70+        unit
71+    case _ => 
72+        throw("Match error")
73+}
74+
75+
76+func getEastAssetStr () = valueOrErrorMessage(getString(coordinator(), keyEastAsset()), "East asset is not set")
77+
78+
79+func getEastAsset () = fromBase58String(getEastAssetStr())
80+
81+
82+func isActive () = valueOrElse(getBoolean(coordinator(), keyProtocolActive()), false)
83+
84+
85+func mustActive () = if (if (!(isActive()))
86+    then true
87+    else !(isInitialized()))
88+    then throw("Protocol is disabled. Please contact support.")
89+    else unit
90+
91+
92+func hasOnePayment (i) = (size(i.payments) == 1)
93+
94+
95+func getAssetIdFromString (assetId) = if ((assetId == "WAVES"))
96+    then unit
97+    else fromBase58String(assetId)
98+
99+
100+func isAsset (p,checkingAsset) = {
101+    let assetId =     match checkingAsset {
102+        case bv: ByteVector => 
103+            bv
104+        case s: String => 
105+            getAssetIdFromString(s)
106+        case _: Unit => 
107+            unit
108+        case _ => 
109+            throw("Match error")
110+    }
111+    match assetId {
112+        case bv: ByteVector => 
113+            let name =             match assetInfo(bv) {
114+                case asset: Asset => 
115+                    asset.name
116+                case _: Unit => 
117+                    throw(("Can't find asset " + toBase58String(bv)))
118+                case _ => 
119+                    throw("Match error")
120+            }
121+            let err = throw(("Attached payment asset is not " + name))
122+            match p.assetId {
123+                case paymentAsset: ByteVector => 
124+                    if ((paymentAsset != assetId))
125+                        then err
126+                        else unit
127+                case _: Unit => 
128+                    err
129+                case _ => 
130+                    throw("Match error")
131+            }
132+        case _: Unit => 
133+            if ((p.assetId != unit))
134+                then throw("Attached payment asset is not WAVES")
135+                else unit
136+        case _ => 
137+            throw("Match error")
138+    }
139+    }
140+
141+
142+func checkAddress (_address) = match addressFromString(_address) {
143+    case address: Address => 
144+        true
145+    case _: Unit => 
146+        throw("Invalid address")
147+    case _ => 
148+        throw("Match error")
149+}
150+
151+
152+func getCurrentTimestampSec () = (lastBlock.timestamp / 1000)
153+
154+
155+func keyBalance () = join(["%s", "balance"])
156+
157+
158+func keyRate () = join(["%s", "rate"])
159+
160+
161+func keyStEast () = join(["%s", "stEast"])
162+
163+
164+func getStEast () = fromBase58String(getStringValue(this, keyStEast()))
165+
166+
167+func getBalance () = valueOrElse(getInteger(keyBalance()), 0)
168+
169+
170+func getRate () = getIntegerValue(keyRate())
171+
172+
173+let IdxAssetPoolStatus = 1
174+
175+let IdxAssetPoolContractId = 2
176+
177+let IdxBalancesLastEastBalance = 1
178+
179+let IdxBalancesLastTimestamp = 2
180+
181+let IdxBalancesLastStEastBalance = 3
182+
183+func keyAssetsInPools () = join(["%s", "assetsInPools"])
184+
185+
186+func keyAssetPool (_assetId) = join(["%s%s", "assetPool", _assetId])
187+
188+
189+func keyAssetPoolBalances (_assetStr) = join(["%s%s", "assetPoolBalances", _assetStr])
190+
191+
192+func getAssetsInPools () = match getString(this, keyAssetsInPools()) {
193+    case s: String => 
194+        split(s, SEP)
195+    case _: Unit => 
196+        nil
197+    case _ => 
198+        throw("Match error")
199+}
200+
201+
202+func getAssetPool (_assetId) = {
203+    let poolArr = split(getStringValue(this, keyAssetPool(_assetId)), SEP)
204+    let pool = poolArr[IdxAssetPoolContractId]
205+    pool
206+    }
207+
208+
209+func getEastBalance (_address) = {
210+    let eastAsset = getEastAsset()
211+    let address = addressFromStringValue(_address)
212+    let balance = assetBalance(address, eastAsset)
213+    balance
214+    }
215+
216+
217+func getCurrentPoolEastBalance (_assetId) = {
218+    let pool = getAssetPool(_assetId)
219+    let balance = getEastBalance(pool)
220+    balance
221+    }
222+
223+
224+func isPoolEnabled (_assetStr) = {
225+    let poolCfg = getStringValue(keyAssetPool(_assetStr))
226+    let poolArr = split(poolCfg, SEP)
227+    if ((poolArr[IdxAssetPoolStatus] != ENABLED))
228+        then throw((("Asset " + _assetStr) + " is not enabled"))
229+        else unit
230+    }
231+
232+
233+func assetExist (_assetStr) = match getString(keyAssetPool(_assetStr)) {
234+    case s: String => 
235+        true
236+    case _: Unit => 
237+        false
238+    case _ => 
239+        throw("Match error")
240+}
241+
242+
243+func dataAssetPool (_status,_poolStr) = join(["%s%s", _status, _poolStr])
244+
245+
246+func getAssetPoolBalances (_assetStr) = {
247+    let balancesArr =     match getString(keyAssetPoolBalances(_assetStr)) {
248+        case s: String => 
249+            split(s, SEP)
250+        case _: Unit => 
251+["%d%d%d", "0", toString(getCurrentTimestampSec()), "0"]
252+        case _ => 
253+            throw("Match error")
254+    }
255+    let lastEastBalance = parseIntValue(balancesArr[IdxBalancesLastEastBalance])
256+    let lastTimestamp = parseIntValue(balancesArr[IdxBalancesLastTimestamp])
257+    let lastStEastBalance = parseIntValue(balancesArr[IdxBalancesLastStEastBalance])
258+    $Tuple3(lastEastBalance, lastTimestamp, lastStEastBalance)
259+    }
260+
261+
262+func updateAssetPoolBalances (_currentPoolEastBalance,_newStEastBalanceForPool) = makeString(["%d%d%d", toString(_currentPoolEastBalance), toString(getCurrentTimestampSec()), toString(_newStEastBalanceForPool)], SEP)
263+
264+
265+func updateBalance (_amount) = {
266+    let balance = (getBalance() + _amount)
267+[IntegerEntry(keyBalance(), balance)]
268+    }
269+
270+
271+func updateRate (_rate) = [IntegerEntry(keyRate(), _rate)]
272+
273+
274+func issueStEast (_amount) = {
275+    let stEast = getStEast()
276+[Reissue(stEast, _amount, true)]
277+    }
278+
279+
280+func burnStEast (_amount) = {
281+    let stEast = getStEast()
282+[Burn(stEast, _amount)]
283+    }
284+
285+
286+func sendStEast (_recipient,_amount) = {
287+    let stEast = getStEast()
288+[ScriptTransfer(_recipient, _amount, stEast)]
289+    }
290+
291+
292+func sendEast (_recipient,_amount) = {
293+    let eastAsset = getEastAsset()
294+[ScriptTransfer(_recipient, _amount, eastAsset)]
295+    }
296+
297+
298+func stEastQuantity () = {
299+    let stEast = getStEast()
300+    match assetInfo(stEast) {
301+        case asset: Asset => 
302+            asset.quantity
303+        case _ => 
304+            throw("Can't find stEAST asset")
305+    }
306+    }
307+
308+
309+@Callable(i)
310+func initialize (_coordinatorAddress) = {
311+    let checks = [mustSelf(i), mustNotInitialized(), checkAddress(_coordinatorAddress)]
312+    if ((checks == checks))
313+        then {
314+            let stEast = Issue("stEAST", "", 0, 8, true, unit, 0)
315+            let stEastId = calculateAssetId(stEast)
316+[BooleanEntry(keyInitialized(), true), StringEntry(keyCoordinatorAddress(), _coordinatorAddress), StringEntry(keyStEast(), toBase58String(stEastId)), IntegerEntry(keyRate(), PRECISION), stEast]
317+            }
318+        else throw("Strict value is not equal to itself.")
319+    }
320+
321+
322+
323+@Callable(i)
324+func updateLpPoolBalances () = {
325+    let checks = [mustInitialized(), mustSelf(i)]
326+    if ((checks == checks))
327+        then {
328+            let rate = getRate()
329+            let stAssetAmountBefore = stEastQuantity()
330+            func updateBalances (acc,next) =                         match next {
331+                case asset: String => 
332+                    let check = [isPoolEnabled(asset)]
333+                    if ((check == check))
334+                        then {
335+                            let currentPoolEastBalance = getCurrentPoolEastBalance(asset)
336+                            let $t01580115913 = {
337+                                let @ = getAssetPoolBalances(asset)
338+                                if ($isInstanceOf(@, "(Int, Int, Int)"))
339+                                    then @
340+                                    else throw(($getType(@) + " couldn't be cast to (Int, Int, Int)"))
341+                                }
342+                            let oldPoolEastBalance = $t01580115913._1
343+                            let lastTimestamp = $t01580115913._2
344+                            let oldStEastBalance = $t01580115913._3
345+                            let poolBalanceDiff = (currentPoolEastBalance - oldPoolEastBalance)
346+                            let stAssetDiff = conv6to8(divp(poolBalanceDiff, rate))
347+                            let newStEastBalanceForPool = (oldStEastBalance + stAssetDiff)
348+                            let actions = [StringEntry(keyAssetPoolBalances(asset), updateAssetPoolBalances(currentPoolEastBalance, newStEastBalanceForPool))]
349+                            $Tuple3((acc._1 ++ actions), (acc._2 + stAssetDiff), (acc._3 + poolBalanceDiff))
350+                            }
351+                        else throw("Strict value is not equal to itself.")
352+                case _: Unit => 
353+                    acc
354+                case _ => 
355+                    throw("Match error")
356+            }
357+
358+            let assets = getAssetsInPools()
359+            let $t01649416685 = if ((1 > size(assets)))
360+                then $Tuple3(nil, 0, 0)
361+                else {
362+                    let $l = assets
363+                    let $s = size($l)
364+                    let $acc0 = $Tuple3(nil, 0, 0)
365+                    func $f0_1 ($a,$i) =                     if (($i >= $s))
366+                        then $a
367+                        else updateBalances($a, $l[$i])
368+
369+                    func $f0_2 ($a,$i) =                     if (($i >= $s))
370+                        then $a
371+                        else throw("List size exceeds 10")
372+
373+                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
374+                    }
375+            let poolAssetBalancesActions = $t01649416685._1
376+            let totalStEastAmountChange = $t01649416685._2
377+            let totalEastBalancesChange = $t01649416685._3
378+            let stEast = getStEast()
379+            let stEastOp = if ((totalStEastAmountChange > 0))
380+                then issueStEast(totalStEastAmountChange)
381+                else burnStEast((totalStEastAmountChange * -1))
382+            let updatedBalance = updateBalance(totalEastBalancesChange)
383+            ((poolAssetBalancesActions ++ stEastOp) ++ updatedBalance)
384+            }
385+        else throw("Strict value is not equal to itself.")
386+    }
387+
388+
389+
390+@Callable(i)
391+func stake () = {
392+    let payment = i.payments[0]
393+    let eastAsset = getEastAsset()
394+    let checks = [mustActive(), hasOnePayment(i), isAsset(payment, eastAsset)]
395+    if ((checks == checks))
396+        then {
397+            let doUpdatePoolBalances = invoke(this, "updateLpPoolBalances", nil, nil)
398+            if ((doUpdatePoolBalances == doUpdatePoolBalances))
399+                then {
400+                    let rate = getRate()
401+                    let mainAssetAmount = conv6to8(payment.amount)
402+                    let toReissue = divp(mainAssetAmount, rate)
403+                    $Tuple2(((updateBalance(payment.amount) ++ issueStEast(toReissue)) ++ sendStEast(i.caller, toReissue)), toReissue)
404+                    }
405+                else throw("Strict value is not equal to itself.")
406+            }
407+        else throw("Strict value is not equal to itself.")
408+    }
409+
410+
411+
412+@Callable(i)
413+func unstake () = {
414+    let payment = i.payments[0]
415+    let stEast = getStEast()
416+    let checks = [mustActive(), hasOnePayment(i), isAsset(payment, stEast)]
417+    if ((checks == checks))
418+        then {
419+            let doUpdatePoolBalances = invoke(this, "updateLpPoolBalances", nil, nil)
420+            if ((doUpdatePoolBalances == doUpdatePoolBalances))
421+                then {
422+                    let rate = getRate()
423+                    let transferAmount = conv8to6(mulp(payment.amount, rate))
424+                    ((updateBalance(-(transferAmount)) ++ burnStEast(payment.amount)) ++ sendEast(i.caller, transferAmount))
425+                    }
426+                else throw("Strict value is not equal to itself.")
427+            }
428+        else throw("Strict value is not equal to itself.")
429+    }
430+
431+
432+
433+@Callable(i)
434+func addStakingRewards () = {
435+    let payment = i.payments[0]
436+    let eastAsset = getEastAsset()
437+    let checks = [mustActive(), hasOnePayment(i), isAsset(payment, eastAsset)]
438+    if ((checks == checks))
439+        then {
440+            let doUpdatePoolBalances = invoke(this, "updateLpPoolBalances", nil, nil)
441+            if ((doUpdatePoolBalances == doUpdatePoolBalances))
442+                then {
443+                    let balance = getBalance()
444+                    let newEastAmount = conv6to8((balance + payment.amount))
445+                    let stEastSupply = stEastQuantity()
446+                    let newRate = divp(newEastAmount, stEastSupply)
447+                    (updateBalance(payment.amount) ++ updateRate(newRate))
448+                    }
449+                else throw("Strict value is not equal to itself.")
450+            }
451+        else throw("Strict value is not equal to itself.")
452+    }
453+
454+
455+
456+@Callable(i)
457+func addAssetPool (_poolStr,_assetStr) = {
458+    let checks = [mustInitialized(), mustSelf(i)]
459+    if ((checks == checks))
460+        then if (!(checkAddress(_poolStr)))
461+            then throw("Address is not valid")
462+            else if (assetExist(_assetStr))
463+                then throw("Asset is already set")
464+                else {
465+                    let assetsInPools = makeString((getAssetsInPools() ++ [_assetStr]), SEP)
466+[StringEntry(keyAssetPool(_assetStr), dataAssetPool(ENABLED, _poolStr)), StringEntry(keyAssetsInPools(), assetsInPools)]
467+                    }
468+        else throw("Strict value is not equal to itself.")
469+    }
470+
471+
472+
473+@Callable(i)
474+func disableAssetPool (_assetStr) = {
475+    let check = [mustInitialized(), mustSelf(i)]
476+    if ((check == check))
477+        then {
478+            let poolData = split(valueOrErrorMessage(getString(keyAssetPool(_assetStr)), "Unknown asset"), SEP)
479+[StringEntry(keyAssetPool(_assetStr), dataAssetPool(DISABLED, poolData[IdxAssetPoolContractId]))]
480+            }
481+        else throw("Strict value is not equal to itself.")
482+    }
483+
484+
485+
486+@Callable(i)
487+func enableAssetPool (_assetStr) = {
488+    let check = [mustInitialized(), mustSelf(i)]
489+    if ((check == check))
490+        then {
491+            let poolData = split(valueOrErrorMessage(getString(keyAssetPool(_assetStr)), "Unknown asset"), SEP)
492+[StringEntry(keyAssetPool(_assetStr), dataAssetPool(ENABLED, poolData[IdxAssetPoolContractId]))]
493+            }
494+        else throw("Strict value is not equal to itself.")
495+    }
496+
497+
498+@Verifier(tx)
499+func verify () = match verifier() {
500+    case address: String => 
501+        valueOrElse(getBoolean(addressFromStringValue(address), keySigned(toString(this), toBase58String(tx.id))), false)
502+    case _ => 
503+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
504+}
505+
github/deemru/w8io/026f985 
30.74 ms ◑