tx · 3n1tmme3dsGeGxa3PYBQoExCmKwxuz9YiWYCmc75T8xs

3N4KhPZ9KNHRYvTMjWHez3QwqB19T2U8V6b:  -0.05000000 Waves

2023.04.25 16:41 [2550145] smart account 3N4KhPZ9KNHRYvTMjWHez3QwqB19T2U8V6b > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3n1tmme3dsGeGxa3PYBQoExCmKwxuz9YiWYCmc75T8xs",
    "fee": 5000000,
    "feeAssetId": null,
    "timestamp": 1682430122004,
    "version": 2,
    "chainId": 84,
    "sender": "3N4KhPZ9KNHRYvTMjWHez3QwqB19T2U8V6b",
    "senderPublicKey": "FQHYZ9kSbD7kNL5QvLmrjJsnWJVVJWt6RHcLZYxd7g2d",
    "proofs": [
        "3PvjpRvkqbFSYxYEBp9QmV4LjtaejNHqhry2UeGgT4PuZiafmNmszS6tjpEiv7WPXQBTUgpWG81ci6nsgs9n74dw"
    ],
    "script": "base64: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",
    "height": 2550145,
    "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 EMPTY = ""
7+
8+let PRECISION = 1000000000000
9+
10+let DECIMALS = 100000000
11+
12+let DEFAULT_MAX_SLIPPAGE = ((PRECISION / 20) * 19)
13+
14+let DAY = ((60 * 60) * 24)
15+
16+let YEAR = (DAY * 365)
17+
18+let ORACLE_DECIMALS = 1000000
19+
20+let INFINITY = 9223372036854775807
21+
22+let MIN_AMOUNT_DELTA = 1000
23+
24+let MAX_RATE_HEIGHT_DELTA = 5
25+
26+let LIQUIDATION_BONUS = ((PRECISION / 100) * 5)
27+
28+let LIQUIDATION_PROTOCOL_FEE = ((PRECISION / 100) * 2)
29+
30+let MAX_LIQUIDATION_PART = ((PRECISION / 100) * 50)
31+
32+let STABILITY_FEE = (PRECISION / 100)
33+
34+let ENABLED = "ENABLED"
35+
36+let DISABLED = "DISABLED"
37+
38+let IdxVaultAssetCount = 1
39+
40+let IdxVaultAssetAmount = 2
41+
42+let IdxVaultAssetRate = 3
43+
44+let IdxVaultCount = 1
45+
46+let IdxVaultEastAmount = 2
47+
48+let IdxVaultTimestamp = 3
49+
50+let IdxStabilityFee = 4
51+
52+let IdxLastFraction = 5
53+
54+let invocationError = "Invocation error"
55+
56+func divd (_x,_y) = fraction(_x, DECIMALS, _y, HALFEVEN)
57+
58+
59+func muld (_x,_y) = fraction(_x, _y, DECIMALS, HALFEVEN)
60+
61+
62+func divp (_x,_y) = fraction(_x, PRECISION, _y, HALFEVEN)
63+
64+
65+func mulp (_x,_y) = fraction(_x, _y, PRECISION, HALFEVEN)
66+
67+
68+func join (ar) = makeString(ar, SEP)
69+
70+
71+func keyInitialized () = join(["%s", "initialized"])
72+
73+
74+func keyCoordinatorAddress () = join(["%s", "coordinatorAddress"])
75+
76+
77+func keyVerifierAddress () = join(["%s", "verifierAddress"])
78+
79+
80+func keyServiceAddress () = join(["%s", "serviceAddress"])
81+
82+
83+func keyFrontendAddress () = join(["%s", "frontendAddress"])
84+
85+
86+func keyMinterAddress () = join(["%s", "minterAddress"])
87+
88+
89+func keyTreasuryAddress () = join(["%s", "treasuryAddress"])
90+
91+
92+func keyBackendAddress () = join(["%s", "backendAddress"])
93+
94+
95+func keyEastStakingAddress () = join(["%s", "eastStakingAddress"])
96+
97+
98+func keyOracleAddress () = join(["%s", "oracleAddress"])
99+
100+
101+func keyExchangeAddress () = join(["%s", "exchangeAddress"])
102+
103+
104+func keyEastAsset () = join(["%s", "eastAsset"])
105+
106+
107+func keyStEastAsset () = join(["%s", "stEastAsset"])
108+
109+
110+func keyAAssetBalance () = "A_asset_balance"
111+
112+
113+func keyBAssetBalance () = "B_asset_balance"
114+
115+
116+func keyVaultAsset (address,asset) = join(["%s%s%s", "vault", address, asset])
117+
118+
119+func keyVaultData (address) = join(["%s%s", "vault", address])
120+
121+
122+func keyPrecision () = join(["%s", "precision"])
123+
124+
125+func keyBackingRatio () = join(["%s", "backingRatio"])
126+
127+
128+func keyLiquidationRatio () = join(["%s", "liquidationRatio"])
129+
130+
131+func keyLiquidationBonus () = join(["%s", "liquidationBonus"])
132+
133+
134+func keyLiquidationProtocolFee () = join(["%s", "liquidationProtocolFee"])
135+
136+
137+func keyStabilityFee () = join(["%s", "stabilityFee"])
138+
139+
140+func keyMinAmountDelta () = join(["%s", "minAmountDelta"])
141+
142+
143+func keyTicker () = join(["%s", "ticker"])
144+
145+
146+func keyMaxRateHeightDelta () = join(["%s", "maxRateHeightDelta"])
147+
148+
149+func keyContractAssetId () = join(["%s", "contractAssetId"])
150+
151+
152+func keyOracleTickerPrice (ticker) = join(["%s%s", "price", ticker])
153+
154+
155+func keyOracleTickerPriceHeight (ticker) = join(["%s%s", "lastHeight", ticker])
156+
157+
158+func keySigned (_address,_txId) = join(["%s%s%s", "signed", _address, _txId])
159+
160+
161+func keyProtocolActive () = join(["%s", "protocolActive"])
162+
163+
164+func isInitialized () = valueOrElse(getBoolean(this, keyInitialized()), false)
165+
166+
167+func mustInitialized () = if (!(isInitialized()))
168+    then throw("Not initialized")
169+    else unit
170+
171+
172+func mustNotInitialized () = if (isInitialized())
173+    then throw("Already initialized")
174+    else unit
175+
176+
177+func mustSelf (i) = if ((i.caller != this))
178+    then throw("Only self invocation allowed.")
179+    else unit
180+
181+
182+func coordinator () = addressFromStringValue(valueOrErrorMessage(getString(keyCoordinatorAddress()), "Coordinator is not set"))
183+
184+
185+func verifier () = match getString(keyCoordinatorAddress()) {
186+    case s: String => 
187+        getString(addressFromStringValue(s), keyVerifierAddress())
188+    case _: Unit => 
189+        unit
190+    case _ => 
191+        throw("Match error")
192+}
193+
194+
195+func getAddress (key,err) = addressFromStringValue(valueOrErrorMessage(getString(coordinator(), key), err))
196+
197+
198+func getMinterAddress () = getAddress(keyMinterAddress(), "Minter is not set")
199+
200+
201+func getFrontendAddress () = getAddress(keyFrontendAddress(), "Frontend is not set")
202+
203+
204+func getTreasuryAddress () = getAddress(keyTreasuryAddress(), "Treasury is not set")
205+
206+
207+func getBackendAddress () = getAddress(keyBackendAddress(), "Backend is not set")
208+
209+
210+func getOracleAddress () = getAddress(keyOracleAddress(), "Oracle is not set")
211+
212+
213+func getEastStakingAddress () = getAddress(keyEastStakingAddress(), "East staking is not set")
214+
215+
216+func isNotTreasury (i) = (i.caller != getTreasuryAddress())
217+
218+
219+func getMinAmountDelta () = valueOrElse(getInteger(coordinator(), keyMinAmountDelta()), MIN_AMOUNT_DELTA)
220+
221+
222+func getMaxRateHeightDelta () = valueOrElse(getInteger(coordinator(), keyMaxRateHeightDelta()), MAX_RATE_HEIGHT_DELTA)
223+
224+
225+func getLiquidationBonus () = valueOrElse(getInteger(coordinator(), keyLiquidationBonus()), LIQUIDATION_BONUS)
226+
227+
228+func getLiquidationProtocolFee () = valueOrElse(getInteger(coordinator(), keyLiquidationProtocolFee()), LIQUIDATION_PROTOCOL_FEE)
229+
230+
231+func getStabilityFee () = valueOrElse(getInteger(coordinator(), keyStabilityFee()), STABILITY_FEE)
232+
233+
234+func getAssetId () = getStringValue(keyContractAssetId())
235+
236+
237+func getEastAssetStr () = valueOrErrorMessage(getString(coordinator(), keyEastAsset()), "East asset is not set")
238+
239+
240+func getEastAsset () = fromBase58String(getEastAssetStr())
241+
242+
243+func isActive () = valueOrElse(getBoolean(coordinator(), keyProtocolActive()), false)
244+
245+
246+func mustActive () = if (if (!(isActive()))
247+    then true
248+    else !(isInitialized()))
249+    then throw("Protocol is disabled. Please contact support.")
250+    else unit
251+
252+
253+func mustFrontend (i) = if ((i.caller != getFrontendAddress()))
254+    then throw("Not allowed")
255+    else unit
256+
257+
258+func mustBackend (i) = if ((i.caller != getBackendAddress()))
259+    then throw("Not allowed")
260+    else unit
261+
262+
263+func mustNotVaultOwner (i,address) = if ((toBase58String(i.caller.bytes) == address))
264+    then throw("Self invocation not allowed.")
265+    else unit
266+
267+
268+func mustHaveOnePayment (i) = if ((size(i.payments) != 1))
269+    then throw("Only one payment allowed.")
270+    else unit
271+
272+
273+func mustHaveNoPayment (i) = if ((size(i.payments) != 0))
274+    then throw("No payment allowed.")
275+    else unit
276+
277+
278+func hasOnePayment (i) = (size(i.payments) == 1)
279+
280+
281+func isPositive (number) = if ((0 >= number))
282+    then throw("Attribute should be positive or zero.")
283+    else unit
284+
285+
286+func isNotNegative (number) = if ((0 > number))
287+    then throw("Attribute should be positive.")
288+    else unit
289+
290+
291+func getSubvault (address,asset) = getString(keyVaultAsset(address, asset))
292+
293+
294+func isSubvaultExists (address,asset) = valueOrErrorMessage(getSubvault(address, asset), "Vault not exists")
295+
296+
297+func getAssetString (p) = match p.assetId {
298+    case assetId: ByteVector => 
299+        toBase58String(assetId)
300+    case _: Unit => 
301+        "WAVES"
302+    case _ => 
303+        throw("Match error")
304+}
305+
306+
307+func getAssetIdFromString (assetId) = if ((assetId == "WAVES"))
308+    then unit
309+    else fromBase58String(assetId)
310+
311+
312+func isAsset (p,checkingAsset) = {
313+    let assetId =     match checkingAsset {
314+        case bv: ByteVector => 
315+            bv
316+        case s: String => 
317+            getAssetIdFromString(s)
318+        case _: Unit => 
319+            unit
320+        case _ => 
321+            throw("Match error")
322+    }
323+    match assetId {
324+        case bv: ByteVector => 
325+            let name =             match assetInfo(bv) {
326+                case asset: Asset => 
327+                    asset.name
328+                case _: Unit => 
329+                    throw(("Can't find asset " + toBase58String(bv)))
330+                case _ => 
331+                    throw("Match error")
332+            }
333+            let err = throw(("Attached payment asset is not " + name))
334+            match p.assetId {
335+                case paymentAsset: ByteVector => 
336+                    if ((paymentAsset != assetId))
337+                        then err
338+                        else unit
339+                case _: Unit => 
340+                    err
341+                case _ => 
342+                    throw("Match error")
343+            }
344+        case _: Unit => 
345+            if ((p.assetId != unit))
346+                then throw("Attached payment asset is not WAVES")
347+                else unit
348+        case _ => 
349+            throw("Match error")
350+    }
351+    }
352+
353+
354+func getBackingRatio () = valueOrErrorMessage(getInteger(keyBackingRatio()), "Backing ratio is not set")
355+
356+
357+func getLiquidationRatio () = valueOrErrorMessage(getInteger(keyLiquidationRatio()), "Liquidation ratio is not set")
358+
359+
360+func checkAddress (_address) = match addressFromString(_address) {
361+    case address: Address => 
362+        true
363+    case _: Unit => 
364+        throw("Invalid address")
365+    case _ => 
366+        throw("Match error")
367+}
368+
369+
370+func checkTxId (_id) = (size(fromBase58String(_id)) == 32)
371+
372+
373+func getCurrentTimestampSec () = (lastBlock.timestamp / 1000)
374+
375+
376+func mustWavesPayment (i) = {
377+    let check = mustHaveOnePayment(i)
378+    if ((check == check))
379+        then {
380+            let pmtAssetId = i.payments[0].assetId
381+            match pmtAssetId {
382+                case a: Unit => 
383+                    unit
384+                case _ => 
385+                    throw("Only WAVES accepted")
386+            }
387+            }
388+        else throw("Strict value is not equal to itself.")
389+    }
390+
391+
392+func getAssetInfo (assetId) = match assetId {
393+    case id: ByteVector => 
394+        let stringId = toBase58String(id)
395+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
396+        $Tuple3(stringId, info.name, info.decimals)
397+    case waves: Unit => 
398+        $Tuple3("WAVES", "WAVES", 8)
399+    case _ => 
400+        throw("Match error")
401+}
402+
403+
404+func checkHeightDelta (priceHeight) = {
405+    let maxHeightDelta = getMaxRateHeightDelta()
406+    let currentDiff = (lastBlock.height - priceHeight)
407+    if ((maxHeightDelta >= currentDiff))
408+        then unit
409+        else throw("Large price delta.")
410+    }
411+
412+
413+func getAssetUsdPrice () = {
414+    let ticker = getStringValue(this, keyTicker())
415+    let oracleAddress = getOracleAddress()
416+    let priceHeight = getIntegerValue(oracleAddress, keyOracleTickerPriceHeight(ticker))
417+    let checkHeight = checkHeightDelta(priceHeight)
418+    if ((checkHeight == checkHeight))
419+        then {
420+            let price = getIntegerValue(oracleAddress, keyOracleTickerPrice(ticker))
421+            fraction(price, PRECISION, ORACLE_DECIMALS)
422+            }
423+        else throw("Strict value is not equal to itself.")
424+    }
425+
426+
427+func keyTotalAssetAccepted () = join(["%d", "totalAssetAccepted"])
428+
429+
430+func keyStakerAddress () = join(["%s", "stakerAddress"])
431+
432+
433+func getTotalAssetAccepted () = valueOrElse(getInteger(keyTotalAssetAccepted()), 0)
434+
435+
436+func getStakerAddress () = valueOrElse(getString(keyStakerAddress()), EMPTY)
437+
438+
439+func staker () = addressFromStringValue(getStakerAddress())
440+
441+
442+func isStaked () = (getStakerAddress() != EMPTY)
443+
444+
445+func checkBackingRatios (_br,_lr) = if (if ((0 > _lr))
446+    then true
447+    else (0 > _br))
448+    then throw("Backing ratio must be positive")
449+    else if (((1000 + mulp(LIQUIDATION_BONUS, 1000)) > _lr))
450+        then throw("Liquidation ratio must be higher than 105%")
451+        else if ((_lr >= _br))
452+            then throw("Backing ratio must be higher than liquidation ratio")
453+            else unit
454+
455+
456+func getVaultData (_address) = {
457+    let asset = getAssetId()
458+    let frontend = getFrontendAddress()
459+    let vault = getString(frontend, keyVaultAsset(_address, asset))
460+    match vault {
461+        case _: Unit => 
462+["%d%d%d", "0", "0", "0"]
463+        case s: String => 
464+            split(s, SEP)
465+        case _ => 
466+            throw("Match error")
467+    }
468+    }
469+
470+
471+func updateVault (_address,_amount) = {
472+    let v = getVaultData(_address)
473+    let count = (parseIntValue(v[IdxVaultAssetCount]) + 1)
474+    let newAssetAmount = (parseIntValue(v[IdxVaultAssetAmount]) + _amount)
475+    if ((0 > newAssetAmount))
476+        then throw("Something went wrong. Contact support.")
477+        else {
478+            let assetRate = getAssetUsdPrice()
479+            makeString(["%d%d%d", toString(count), toString(newAssetAmount), toString(assetRate)], SEP)
480+            }
481+    }
482+
483+
484+func countEquivalent (_amount) = {
485+    let backingRatio = getBackingRatio()
486+    let assetRate = getAssetUsdPrice()
487+    let assetInUsd = mulp(_amount, assetRate)
488+    let eastAmount = divp(assetInUsd, backingRatio)
489+    $Tuple2(eastAmount, assetInUsd)
490+    }
491+
492+
493+@Callable(i)
494+func initialize (_coordinatorAddress,_backingRatio,_liquidationRatio,_assetId,_ticker) = {
495+    let checks = [mustNotInitialized(), checkAddress(_coordinatorAddress), checkBackingRatios(_backingRatio, _liquidationRatio)]
496+    if ((checks == checks))
497+        then {
498+            let backingRatio = divp(_backingRatio, 1000)
499+            let liquidationRatio = divp(_liquidationRatio, 1000)
500+[IntegerEntry(keyBackingRatio(), backingRatio), IntegerEntry(keyLiquidationRatio(), liquidationRatio), StringEntry(keyCoordinatorAddress(), _coordinatorAddress), StringEntry(keyTicker(), _ticker), StringEntry(keyContractAssetId(), _assetId), BooleanEntry(keyInitialized(), true)]
501+            }
502+        else throw("Strict value is not equal to itself.")
503+    }
504+
505+
506+
507+@Callable(i)
508+func setRatios (_backingRatio,_liquidationRatio) = {
509+    let checks = [mustInitialized(), mustSelf(i), checkBackingRatios(_backingRatio, _liquidationRatio)]
510+    if ((checks == checks))
511+        then {
512+            let backingRatio = divp(_backingRatio, 1000)
513+            let liquidationRatio = divp(_liquidationRatio, 1000)
514+[IntegerEntry(keyBackingRatio(), backingRatio), IntegerEntry(keyLiquidationRatio(), liquidationRatio)]
515+            }
516+        else throw("Strict value is not equal to itself.")
517+    }
518+
519+
520+
521+@Callable(i)
522+func setStaker (_address) = {
523+    let checks = [mustInitialized(), mustSelf(i), checkAddress(_address)]
524+    if ((checks == checks))
525+        then if (isStaked())
526+            then throw("Unable to proceed. Staker is already set.")
527+            else [StringEntry(keyStakerAddress(), _address)]
528+        else throw("Strict value is not equal to itself.")
529+    }
530+
531+
532+
533+@Callable(i)
534+func mint (_address) = {
535+    let payment = i.payments[0]
536+    let vaultAsset = getAssetId()
537+    let check = [mustActive(), mustFrontend(i), mustHaveOnePayment(i), isAsset(payment, vaultAsset)]
538+    if ((check == check))
539+        then {
540+            let $t01320413257 = countEquivalent(payment.amount)
541+            let eastEq = $t01320413257._1
542+            let usdEq = $t01320413257._2
543+            let vault = updateVault(_address, payment.amount)
544+            let newTotalAssetAccepted = (getTotalAssetAccepted() + payment.amount)
545+            let doAction = if (isStaked())
546+                then invoke(staker(), "stake", nil, [payment])
547+                else unit
548+            if ((doAction == doAction))
549+                then $Tuple2([IntegerEntry(keyTotalAssetAccepted(), newTotalAssetAccepted)], $Tuple2(vault, eastEq))
550+                else throw("Strict value is not equal to itself.")
551+            }
552+        else throw("Strict value is not equal to itself.")
553+    }
554+
555+
556+
557+@Callable(i)
558+func supply (_address) = {
559+    let payment = i.payments[0]
560+    let vaultAsset = getAssetId()
561+    let check = [mustActive(), mustFrontend(i), mustHaveOnePayment(i), isAsset(payment, vaultAsset)]
562+    if ((check == check))
563+        then {
564+            let vault = updateVault(_address, payment.amount)
565+            let newTotalAssetAccepted = (getTotalAssetAccepted() + payment.amount)
566+            let doAction = if (isStaked())
567+                then invoke(staker(), "stake", nil, [payment])
568+                else unit
569+            if ((doAction == doAction))
570+                then $Tuple2([IntegerEntry(keyTotalAssetAccepted(), newTotalAssetAccepted)], vault)
571+                else throw("Strict value is not equal to itself.")
572+            }
573+        else throw("Strict value is not equal to itself.")
574+    }
575+
576+
577+
578+@Callable(i)
579+func close (_address,_amount) = {
580+    let check = [mustActive(), mustFrontend(i), checkAddress(_address), isPositive(_amount)]
581+    if ((check == check))
582+        then {
583+            let vaultData = getVaultData(_address)
584+            let assetAmount = parseIntValue(vaultData[IdxVaultAssetAmount])
585+            if ((_amount > assetAmount))
586+                then throw("Unable to proceed. Not enough asset in vault.")
587+                else if ((_amount > getTotalAssetAccepted()))
588+                    then throw("Unable to proceed. Not enough asset.")
589+                    else {
590+                        let updatedVault = updateVault(_address, -(_amount))
591+                        let $t01465614702 = countEquivalent(_amount)
592+                        let eastEq = $t01465614702._1
593+                        let usdEq = $t01465614702._2
594+                        let doAction = if (isStaked())
595+                            then invoke(staker(), "unstake", [_amount], nil)
596+                            else unit
597+                        if ((doAction == doAction))
598+                            then {
599+                                let assetId = getAssetIdFromString(getAssetId())
600+                                let address = addressFromStringValue(_address)
601+                                let newTotalAssetAccepted = (getTotalAssetAccepted() - _amount)
602+                                $Tuple2([IntegerEntry(keyTotalAssetAccepted(), newTotalAssetAccepted), ScriptTransfer(address, _amount, assetId)], $Tuple3(updatedVault, eastEq, usdEq))
603+                                }
604+                            else throw("Strict value is not equal to itself.")
605+                        }
606+            }
607+        else throw("Strict value is not equal to itself.")
608+    }
609+
610+
611+
612+@Callable(i)
613+func liquidate (_liquidatorAddress,_address,_ratio) = {
614+    let check = [mustActive(), mustFrontend(i)]
615+    if ((check == check))
616+        then {
617+            let vaultData = getVaultData(_address)
618+            let assetAmount = parseIntValue(vaultData[IdxVaultAssetAmount])
619+            let assetRequested = mulp(assetAmount, _ratio)
620+            if ((assetRequested > assetAmount))
621+                then throw("Unable to proceed. Not enough asset in vault.")
622+                else if ((assetRequested > getTotalAssetAccepted()))
623+                    then throw("Unable to proceed. Not enough asset.")
624+                    else {
625+                        let updatedVault = updateVault(_address, -(assetRequested))
626+                        let $t01573015783 = countEquivalent(assetRequested)
627+                        let eastEq = $t01573015783._1
628+                        let usdEq = $t01573015783._2
629+                        let doAction = if (isStaked())
630+                            then invoke(staker(), "unstake", [assetRequested], nil)
631+                            else unit
632+                        if ((doAction == doAction))
633+                            then {
634+                                let fee = mulp(assetRequested, getLiquidationProtocolFee())
635+                                let liquidated = (assetRequested - fee)
636+                                let newTotalAssetAccepted = (getTotalAssetAccepted() - assetRequested)
637+                                let treasuryAddress = getTreasuryAddress()
638+                                let liquidatorAddress = addressFromStringValue(_liquidatorAddress)
639+                                let assetId = getAssetIdFromString(getAssetId())
640+                                $Tuple2([IntegerEntry(keyTotalAssetAccepted(), newTotalAssetAccepted), ScriptTransfer(liquidatorAddress, liquidated, assetId), ScriptTransfer(treasuryAddress, fee, assetId)], $Tuple2(updatedVault, eastEq))
641+                                }
642+                            else throw("Strict value is not equal to itself.")
643+                        }
644+            }
645+        else throw("Strict value is not equal to itself.")
646+    }
647+
648+
649+
650+@Callable(i)
651+func getCurrentUsdPrice () = $Tuple2(nil, getAssetUsdPrice())
652+
653+
654+
655+@Callable(i)
656+func getSubvaultInfo (_address) = {
657+    let subvaultData = getVaultData(_address)
658+    let assetAmount = parseIntValue(subvaultData[IdxVaultAssetAmount])
659+    let rate = getAssetUsdPrice()
660+    let assetUsdPrice = mulp(assetAmount, rate)
661+    let backingRatio = getBackingRatio()
662+    let liquidationRatio = getLiquidationRatio()
663+    let eastEq = divp(assetUsdPrice, backingRatio)
664+    let threshold = mulp(assetUsdPrice, liquidationRatio)
665+    $Tuple2(nil, $Tuple3(assetUsdPrice, eastEq, threshold))
666+    }
667+
668+
669+@Verifier(tx)
670+func verify () = match verifier() {
671+    case address: String => 
672+        valueOrElse(getBoolean(addressFromStringValue(address), keySigned(toString(this), toBase58String(tx.id))), false)
673+    case _ => 
674+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
675+}
676+
github/deemru/w8io/026f985 
28.32 ms ◑