tx · ChcFNPh6hSKSxYZDcLGvGusWAkTbwbz22PKutdnhDyd3

3Mw46U8UTwuNYxMZzuRx6HeDHXaMdi5vTcA:  -0.01000000 Waves

2020.09.22 21:07 [1188851] smart account 3Mw46U8UTwuNYxMZzuRx6HeDHXaMdi5vTcA > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "ChcFNPh6hSKSxYZDcLGvGusWAkTbwbz22PKutdnhDyd3",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1600798089718,
    "version": 1,
    "sender": "3Mw46U8UTwuNYxMZzuRx6HeDHXaMdi5vTcA",
    "senderPublicKey": "4LF5BQ4mcDUcxxC3Lqt1UATPUDhMh4tpdidDCPzFmEvp",
    "proofs": [
        "5cmFL6XxNk5BKZceC8c5DBqfxdLJNQYMxijcB3cu6kX9PbYnrbrKHSbQaN51nRRUZ1MSw5TKsnupCjVX1rgVeBXm"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1188851,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 9ido9k9Hf1cKWSXbFnGR5r4RkFTjb4HkrefzjygmX7Qa

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 4 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func keyAccumulatedFee () = "%s__accumulatedFee"
5+
6+
7+func keyUcollateral () = "%s__ucollateral"
8+
9+
10+func keyTotalLendedAtOtherAccs () = "%s__totalLendedAtOtherAccs"
11+
12+
13+func keyAssetLockedTotal (assetId) = ("%s%s__assetLockedTotal__" + assetId)
14+
15+
16+func keyAccountOperation (unlockHeight,address,status) = ((((("%s%s%d%s__defoAssetOperation__" + address) + "__") + toString(unlockHeight)) + "__") + status)
17+
18+
19+func keyFactory () = "%s__factory"
20+
21+
22+func keyLendedAmountByAssetCode (assetCode) = ("%s%s__lendedBaseAssetAmount__" + assetCode)
23+
24+
25+func keyPrice (assetCode) = ("%s%s__price__" + assetCode)
26+
27+
28+let IdxOperationAmountIn = 1
29+
30+let IdxOperationAssetIn = 2
31+
32+let IdxOperationPrice = 3
33+
34+let IdxOperationAmountOut = 4
35+
36+let IdxOperationAssetOut = 5
37+
38+func assetDataSwapOperation (amountIn,assetIn,price,amountOut,assetOut,bruttoAmount,feeAmount) = ((((((((((((("%d%s%d%s%d%d%d__" + toString(amountIn)) + "__") + assetIn) + "__") + toString(amountOut)) + "__") + assetOut) + "__") + toString(price)) + "__") + toString(bruttoAmount)) + "__") + toString(feeAmount))
39+
40+
41+func assetDataRebalanceTrace (debtorAssetCode,debtPmt,basePmt,lendedAmtBefore,lendedAmtAfter) = ((((((((((((("%s%s%d%s%d%d%d__" + debtorAssetCode) + "__") + toBase58String(value(debtPmt.assetId))) + "__") + toString(debtPmt.amount)) + "__") + toBase58String(value(basePmt.assetId))) + "__") + toString(basePmt.amount)) + "__") + toString(lendedAmtBefore)) + "__") + toString(lendedAmtAfter))
42+
43+
44+func assetReadSwapDataArrayOrFail (accOperationKey) = {
45+    let accOperationDataStr = valueOrErrorMessage(getString(this, accOperationKey), ("There is no request for passed arguments: " + accOperationKey))
46+    split(accOperationDataStr, "__")
47+    }
48+
49+
50+let nullInt = -1
51+
52+let nullStr = "NULL"
53+
54+let factoryAcc = addressFromStringValue(valueOrErrorMessage(getString(this, keyFactory()), ((("No config at this=" + toString(this)) + " for key=") + keyFactory())))
55+
56+func keyFactoryDebtAssetId () = "%s%s__commonConfig__debtAssetId"
57+
58+
59+func keyFactoryAssetCfg (assetAddressStr) = (("%s%s%s__defoAsset__" + assetAddressStr) + "__config")
60+
61+
62+func keyFactoryAssetCurrentPool (assetAccAddress) = (("%s%s%s__defoAsset__" + toString(assetAccAddress)) + "__currentPool")
63+
64+
65+func keyFactoryDefoAddressByAssetCode (assetCode) = (("%s%s%s__defoAsset__" + assetCode) + "__addressByAssetCode")
66+
67+
68+func factoryReadDebtAssetId () = valueOrErrorMessage(getString(factoryAcc, keyFactoryDebtAssetId()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDebtAssetId()))
69+
70+
71+func factoryReadAssetCfgByAddress (assetAddressStr) = split(valueOrErrorMessage(getString(factoryAcc, keyFactoryAssetCfg(assetAddressStr)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryAssetCfg(assetAddressStr))), "__")
72+
73+
74+func factoryReadAssetCfgByCode (assetCode) = {
75+    let assetAddressStr = valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoAddressByAssetCode(assetCode)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoAddressByAssetCode(assetCode)))
76+    $Tuple2(assetAddressStr, factoryReadAssetCfgByAddress(assetAddressStr))
77+    }
78+
79+
80+let IdxDefoAssetCode = 1
81+
82+let IdxDefoAssetId = 2
83+
84+let IdxDefoAssetStatus = 3
85+
86+let IdxPriceDecimals = 4
87+
88+let IdxBaseAssetId = 5
89+
90+let IdxOverCollateralPercent = 6
91+
92+let IdxMinInitPool = 7
93+
94+let IdxPriceOracleAddress = 8
95+
96+let IdxMinBuyPayment = 9
97+
98+let IdxMinSellPayment = 10
99+
100+let IdxBuyLockInterval = 11
101+
102+let IdxSellLockInterval = 12
103+
104+let IdxBuyFeePercent = 13
105+
106+let IdxSellFeePercent = 14
107+
108+let thisCfgArray = factoryReadAssetCfgByAddress(toString(this))
109+
110+let defoAssetCode = thisCfgArray[IdxDefoAssetCode]
111+
112+let defoAssetId = fromBase58String(thisCfgArray[IdxDefoAssetId])
113+
114+let priceOracleAcc = addressFromStringValue(thisCfgArray[IdxPriceOracleAddress])
115+
116+let overCollateralPercent = parseIntValue(thisCfgArray[IdxOverCollateralPercent])
117+
118+let baseAssetIdStr = thisCfgArray[IdxBaseAssetId]
119+
120+let baseAssetId = fromBase58String(baseAssetIdStr)
121+
122+let priceDecimals = parseIntValue(thisCfgArray[IdxPriceDecimals])
123+
124+let minBasicBuyAmount = parseIntValue(thisCfgArray[IdxMinBuyPayment])
125+
126+let minSynthSellAmount = parseIntValue(thisCfgArray[IdxMinSellPayment])
127+
128+let buyLockInterval = parseIntValue(thisCfgArray[IdxBuyLockInterval])
129+
130+let sellLockInterval = parseIntValue(thisCfgArray[IdxSellLockInterval])
131+
132+let buyFeePercent = parseIntValue(thisCfgArray[IdxBuyFeePercent])
133+
134+let sellFeePercent = parseIntValue(thisCfgArray[IdxSellFeePercent])
135+
136+func controlAccReadPrice (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyPrice(assetCode)), ((("No price at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyPrice(assetCode)))
137+
138+
139+func controlAccReadCurrIdxOrFail () = valueOrErrorMessage(getInteger(priceOracleAcc, "currIdx"), ("No currIdx at controlAcc=" + toString(priceOracleAcc)))
140+
141+
142+func controlAccReadIdxHeight (idx) = {
143+    let idxHeightKey = ("idxHeight_" + toString(idx))
144+    valueOrElse(getInteger(priceOracleAcc, idxHeightKey), 0)
145+    }
146+
147+
148+func controlAccReadPriceByHeight (priceHeight) = {
149+    let priceByHeightKey = ("price_" + toString(priceHeight))
150+    valueOrErrorMessage(getInteger(priceOracleAcc, priceByHeightKey), ((("No " + priceByHeightKey) + " at controlAcc=") + toString(priceOracleAcc)))
151+    }
152+
153+
154+func getStakingBalance () = valueOrElse(getInteger(this, ((("rpd_balance_" + baseAssetIdStr) + "_") + toString(this))), 0)
155+
156+
157+let ucollateral = valueOrElse(getInteger(this, keyUcollateral()), 0)
158+
159+let accumulatedFee = valueOrElse(getInteger(this, keyAccumulatedFee()), 0)
160+
161+let currPoolAmount = getIntegerValue(factoryAcc, keyFactoryAssetCurrentPool(this))
162+
163+let doubleCheckBasicBalance = (assetBalance(this, baseAssetId) + getStakingBalance())
164+
165+let doubleCheckUcollateral = if ((0 > ucollateral))
166+    then 0
167+    else ucollateral
168+
169+let doubleCheckCurrPoolAmount = (doubleCheckBasicBalance - ucollateral)
170+
171+let price = controlAccReadPrice(thisCfgArray[IdxDefoAssetCode])
172+
173+let overPrice = (((priceDecimals + overCollateralPercent) * price) / priceDecimals)
174+
175+let emission = value(assetInfo(defoAssetId)).quantity
176+
177+let basicAssetLockedAmt = valueOrElse(getInteger(this, keyAssetLockedTotal(baseAssetIdStr)), 0)
178+
179+let availablePoolBalance = (currPoolAmount - basicAssetLockedAmt)
180+
181+func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,feePercent) = {
182+    let availableDefoAssetInPool = (fraction(availablePoolBalance, priceDecimals, overPrice) - emission)
183+    let fullDefoAssetAmountNoPoolLimit = fraction(sellAmt, priceDecimals, buy2sellPrice)
184+    let fullDefoAssetAmountBrutto = if ((fullDefoAssetAmountNoPoolLimit > availableDefoAssetInPool))
185+        then availableDefoAssetInPool
186+        else fullDefoAssetAmountNoPoolLimit
187+    let defoAssetAmount = fraction((priceDecimals - feePercent), fullDefoAssetAmountBrutto, priceDecimals)
188+    let feeAmount = (fullDefoAssetAmountBrutto - defoAssetAmount)
189+    let requiredBasicAssetAmount = fraction(fullDefoAssetAmountBrutto, buy2sellPrice, priceDecimals)
190+    let change = (sellAmt - requiredBasicAssetAmount)
191+    if ((0 >= availableDefoAssetInPool))
192+        then throw((("impossible to issue new " + defoAssetCode) + ": not enough collateral"))
193+        else if ((minSellAmt > sellAmt))
194+            then throw(((((("impossible to issue new " + defoAssetCode) + ": payment=") + toString(sellAmt)) + "is less then min amount=") + toString(minSellAmt)))
195+            else $Tuple2([IntegerEntry(keyUcollateral(), (ucollateral + requiredBasicAssetAmount)), StringEntry(keyAccountOperation(height, toString(sellerAddr), "FINISHED"), assetDataSwapOperation(sellAmt, toBase58String(sellAssetId), price, defoAssetAmount, toBase58String(defoAssetId), fullDefoAssetAmountBrutto, feeAmount)), Reissue(defoAssetId, (defoAssetAmount + feeAmount), true), ScriptTransfer(sellerAddr, defoAssetAmount, defoAssetId), ScriptTransfer(sellerAddr, change, sellAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + feeAmount))], change)
196+    }
197+
198+
199+@Callable(i)
200+func buyAsset () = {
201+    let pmt = value(i.payments[0])
202+    let pmtAssetId = value(pmt.assetId)
203+    if ((pmtAssetId != baseAssetId))
204+        then throw(((("Payment asset id doesn't match basic asset: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(pmtAssetId)))
205+        else internalBuyAsset(i.caller, pmt.amount, pmtAssetId, minBasicBuyAmount, price, buyFeePercent)._1
206+    }
207+
208+
209+
210+@Callable(i)
211+func sellAsset () = {
212+    let pmt = value(i.payments[0])
213+    let pmtAsset = value(pmt.assetId)
214+    let callerAddress = toString(i.caller)
215+    if ((pmtAsset != defoAssetId))
216+        then throw(((("Invalid payment asset id: expected=" + toBase58String(defoAssetId)) + " actual=") + toBase58String(pmtAsset)))
217+        else if ((minSynthSellAmount > pmt.amount))
218+            then throw(((("Payment amount less then mininimal allowed: paymentAmount=" + toString(pmt.amount)) + " minAmount=") + toString(minSynthSellAmount)))
219+            else {
220+                let pmtDefoAmountGross = pmt.amount
221+                let defoAmountFee = fraction((priceDecimals - sellFeePercent), pmtDefoAmountGross, priceDecimals)
222+                let pmtDefoAmountNoFee = (pmtDefoAmountGross - defoAmountFee)
223+                let baseAssetAmountNoBalanceLimit = fraction(pmtDefoAmountNoFee, price, priceDecimals)
224+                let baseAssetAmountNoFee = if ((baseAssetAmountNoBalanceLimit > doubleCheckCurrPoolAmount))
225+                    then doubleCheckCurrPoolAmount
226+                    else baseAssetAmountNoBalanceLimit
227+                let requiredDefoAssetAmount = fraction(baseAssetAmountNoFee, priceDecimals, price)
228+                let change = (pmtDefoAmountNoFee - requiredDefoAssetAmount)
229+[IntegerEntry(keyUcollateral(), (ucollateral - baseAssetAmountNoFee)), StringEntry(keyAccountOperation(height, callerAddress, "FINISHED"), assetDataSwapOperation(pmt.amount, toBase58String(pmtAsset), price, baseAssetAmountNoFee, baseAssetIdStr, pmtDefoAmountGross, defoAmountFee)), Burn(defoAssetId, requiredDefoAssetAmount), ScriptTransfer(i.caller, baseAssetAmountNoFee, baseAssetId), ScriptTransfer(i.caller, change, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + defoAmountFee))]
230+                }
231+    }
232+
233+
234+
235+@Callable(i)
236+func crossExchange (buyAssetCodeConfirm,sellAssetCodeConfirm) = {
237+    let pmt = value(i.payments[0])
238+    let pmtAsset = value(pmt.assetId)
239+    let pmtAssetStr = toBase58String(pmtAsset)
240+    let pmtAmount = pmt.amount
241+    let callerAddress = toString(i.caller)
242+    let buyAssetCfg = thisCfgArray
243+    let sellAssetTuple = factoryReadAssetCfgByCode(sellAssetCodeConfirm)
244+    let sellAssetCfg = sellAssetTuple._2
245+    let sellAssetAccAddress = valueOrErrorMessage(addressFromString(sellAssetTuple._1), ("couldn't parse address from string for assetCode=" + sellAssetCodeConfirm))
246+    let minSellPmt = valueOrErrorMessage(parseInt(sellAssetCfg[IdxMinSellPayment]), ("minSellPmt parsing error: rawVal=" + sellAssetCfg[IdxMinSellPayment]))
247+    if ((thisCfgArray[IdxDefoAssetCode] != buyAssetCodeConfirm))
248+        then throw(((("buyAsset confirmation failed: buyAssetIdConfirm=" + thisCfgArray[IdxDefoAssetCode]) + " BUT buyAssetId=") + buyAssetCodeConfirm))
249+        else if ((sellAssetCfg[IdxDefoAssetId] != pmtAssetStr))
250+            then throw(((("sellAsset confirmation failed: sellAssetIdConfirm=" + sellAssetCfg[IdxDefoAssetId]) + "BUT pmtAsset=") + pmtAssetStr))
251+            else if ((thisCfgArray[IdxDefoAssetStatus] != "ISSUED"))
252+                then throw(((("toAsset has not been issued yet: buyAssetId=" + buyAssetCodeConfirm) + " BUT status=") + thisCfgArray[IdxDefoAssetStatus]))
253+                else if ((sellAssetCfg[IdxDefoAssetStatus] != "ISSUED"))
254+                    then throw(((("fromAssetCfg has not been issued yet: sellAssetId=" + pmtAssetStr) + " BUT status=") + sellAssetCfg[IdxDefoAssetStatus]))
255+                    else {
256+                        let buyAssetUsdPrice = price
257+                        let sellAssetUsdPrice = controlAccReadPrice(sellAssetCodeConfirm)
258+                        let buy2sellPrice = fraction(buyAssetUsdPrice, priceDecimals, sellAssetUsdPrice)
259+                        let debtAssetId = fromBase58String(factoryReadDebtAssetId())
260+                        let usdnDebt = fraction(sellAssetUsdPrice, pmtAmount, priceDecimals)
261+                        let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
262+                        let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(sellAssetCodeConfirm)
263+                        let lendedAmtByAssetCode = valueOrElse(getInteger(this, lendedAmountByAssetCodeKey), 0)
264+                        let buyAssetResult = internalBuyAsset(i.caller, pmtAmount, pmtAsset, minSellPmt, buy2sellPrice, fraction(buyFeePercent, 150, 100))
265+                        ((((buyAssetResult._1 :+ ScriptTransfer(sellAssetAccAddress, usdnDebt, debtAssetId)) :+ ScriptTransfer(sellAssetAccAddress, (pmtAmount - buyAssetResult._2), pmtAsset)) :+ IntegerEntry(lendedAmountByAssetCodeKey, (lendedAmtByAssetCode + usdnDebt))) :+ IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs + usdnDebt)))
266+                        }
267+    }
268+
269+
270+
271+@Callable(i)
272+func rebalanceDebts () = {
273+    let debtAssetId = fromBase58String(factoryReadDebtAssetId())
274+    let debtPmt0 = value(i.payments[0])
275+    let debtPmtAsset0 = value(debtPmt0.assetId)
276+    let basePmt1 = value(i.payments[1])
277+    let basePmtAsset1 = value(basePmt1.assetId)
278+    let debtorAddress = toString(i.caller)
279+    let debtorAssetCfg = factoryReadAssetCfgByAddress(debtorAddress)
280+    let debtorAssetCode = debtorAssetCfg[IdxDefoAssetCode]
281+    let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(debtorAssetCode)
282+    let lendedAmt = valueOrErrorMessage(getInteger(this, lendedAmountByAssetCodeKey), ("No debts for " + debtorAssetCode))
283+    if ((debtAssetId != debtPmtAsset0))
284+        then throw(((("invalid debt asset id in the first paymet: expected=" + toBase58String(debtAssetId)) + " actual=") + toBase58String(debtPmtAsset0)))
285+        else if ((baseAssetId != basePmtAsset1))
286+            then throw(((("invalid base asset id in the second payment: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(basePmtAsset1)))
287+            else if ((debtPmt0.amount != basePmt1.amount))
288+                then throw("first payment amount doesn't match to the second payment amount")
289+                else if ((0 >= lendedAmt))
290+                    then throw(("lendedAmt is less then zero: lendedAmt=" + toString(lendedAmt)))
291+                    else if ((0 >= debtPmt0.amount))
292+                        then throw(("attached payment must be greater then 0: pmt0.amount=" + toString(debtPmt0.amount)))
293+                        else if ((debtPmt0.amount > lendedAmt))
294+                            then throw(((("attached payment is grater than required: pmtAmount=" + toString(debtPmt0.amount)) + " lendedAmt=") + toString(lendedAmt)))
295+                            else {
296+                                let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
297+                                let lendedAmtAfter = (lendedAmt - debtPmt0.amount)
298+[IntegerEntry(lendedAmountByAssetCodeKey, lendedAmtAfter), IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs - debtPmt0.amount)), StringEntry(("%s%s__rebalanceTrace__" + toBase58String(i.transactionId)), assetDataRebalanceTrace(debtorAssetCode, debtPmt0, basePmt1, lendedAmt, lendedAmtAfter))]
299+                                }
300+    }
301+
302+
303+
304+@Callable(i)
305+func withdraw (accountAddress,unlockHeight,idx) = {
306+    let accOperationKey = keyAccountOperation(unlockHeight, accountAddress, "PENDING")
307+    let accOperationDataArray = assetReadSwapDataArrayOrFail(accOperationKey)
308+    let amountIn = parseIntValue(accOperationDataArray[IdxOperationAmountIn])
309+    let assetIn = accOperationDataArray[IdxOperationAssetIn]
310+    let assetOut = accOperationDataArray[IdxOperationAssetOut]
311+    if ((unlockHeight > height))
312+        then throw((("Please wait " + toString(unlockHeight)) + " to withdraw your funds"))
313+        else {
314+            let accountLockedAmt = amountIn
315+            if ((0 >= accountLockedAmt))
316+                then throw("LockedAmount <= 0")
317+                else {
318+                    let assetLockedTotalKey = keyAssetLockedTotal(accOperationDataArray[IdxOperationAssetIn])
319+                    let currAssetLockedTotal = valueOrErrorMessage(getInteger(this, assetLockedTotalKey), (("State contains sellAssetRequest=" + accOperationKey) + " BUT no totalLocked"))
320+                    let idxHeight = controlAccReadIdxHeight(idx)
321+                    let prevIdxHeight = controlAccReadIdxHeight((idx - 1))
322+                    let currIdx = controlAccReadCurrIdxOrFail()
323+                    if (if (if ((idx > currIdx))
324+                        then true
325+                        else (unlockHeight > idxHeight))
326+                        then true
327+                        else if ((prevIdxHeight != 0))
328+                            then (prevIdxHeight >= unlockHeight)
329+                            else false)
330+                        then throw(((((((((("invalid price idx: idx=" + toString(idx)) + " currIdx=") + toString(currIdx)) + " idxHeight=") + toString(idxHeight)) + " unlockHeight=") + toString(unlockHeight)) + " prevIdxHeight=") + toString(prevIdxHeight)))
331+                        else {
332+                            let synth2basicPrice = controlAccReadPriceByHeight(idxHeight)
333+                            let assetInBytes = fromBase58String(assetIn)
334+                            let $t01863219502 = if ((assetInBytes == baseAssetId))
335+                                then {
336+                                    let synthAmt = fraction(amountIn, priceDecimals, synth2basicPrice)
337+                                    $Tuple4(synthAmt, Reissue(defoAssetId, synthAmt, true), ScriptTransfer(addressFromStringValue(accountAddress), synthAmt, defoAssetId), IntegerEntry(keyUcollateral(), (ucollateral + amountIn)))
338+                                    }
339+                                else if ((assetInBytes == defoAssetId))
340+                                    then {
341+                                        let basicAmt = fraction(amountIn, synth2basicPrice, priceDecimals)
342+                                        let newUcollateral = (ucollateral - basicAmt)
343+                                        $Tuple4(basicAmt, Burn(baseAssetId, basicAmt), ScriptTransfer(addressFromStringValue(accountAddress), basicAmt, baseAssetId), IntegerEntry(keyUcollateral(), (ucollateral - basicAmt)))
344+                                        }
345+                                    else throw(("Unsupported assetIn=" + assetIn))
346+                            let amountOut = $t01863219502._1
347+                            let burnOrIssue = $t01863219502._2
348+                            let transferSynthOrBasic = $t01863219502._3
349+                            let ucollateralEntry = $t01863219502._4
350+                            if ((0 > (currAssetLockedTotal - accountLockedAmt)))
351+                                then throw((("Invalid data state: " + assetLockedTotalKey) + " less then 0"))
352+                                else ((([IntegerEntry(assetLockedTotalKey, (currAssetLockedTotal - accountLockedAmt)), DeleteEntry(accOperationKey), StringEntry(keyAccountOperation(unlockHeight, accountAddress, "FINISHED"), assetDataSwapOperation(amountIn, assetIn, synth2basicPrice, amountOut, assetOut, 0, 0))] :+ burnOrIssue) :+ transferSynthOrBasic) :+ ucollateralEntry)
353+                            }
354+                    }
355+            }
356+    }
357+
358+
359+@Verifier(tx)
360+func verify () = match tx {
361+    case inv: InvokeScriptTransaction => 
362+        if ((inv.function != "rebalanceDebts"))
363+            then throw("only rebalanceDebts call is allowed")
364+            else if ((factoryReadAssetCfgByAddress(toString(addressFromRecipient(inv.dApp)))[IdxDefoAssetStatus] != "ISSUED"))
365+                then throw("only defo dapp is allowed")
366+                else if ((inv.fee > (900 * 1000)))
367+                    then throw(("fee amount is greater than max allowed: " + toString(inv.fee)))
368+                    else if (isDefined(inv.feeAssetId))
369+                        then throw("only Waves is allowed as feeAssetId")
370+                        else true
371+    case _ => 
372+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
373+}
374+
github/deemru/w8io/169f3d6 
45.03 ms ◑