w8 · tx · ECQ···9Wk

tx · ECQwCY3ErfF149tsgdaaaGTfoNqPjqr7eRqt375Ww9Wk

3P5fnEVxY8DFCNqfigRqFJRCjBAUbpP6Rr4:  -0.01000000 Waves

2020.09.28 21:16 [2261196] smart account 3P5fnEVxY8DFCNqfigRqFJRCjBAUbpP6Rr4 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "ECQwCY3ErfF149tsgdaaaGTfoNqPjqr7eRqt375Ww9Wk",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1601317031114,
    "version": 1,
    "sender": "3P5fnEVxY8DFCNqfigRqFJRCjBAUbpP6Rr4",
    "senderPublicKey": "3Bb6XrvrXqjKXcBrLrLXbbA95A1voNpDuejTkSrYGuQs",
    "proofs": [
        "wEiTWJcnsFoq7SuPXfGvbtgKByigxgvHmG7Q7DMptzQ8wZn1butCCPFDs6vAkpAqkq89nJqqksvurssRT8v99m2"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2261196,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 6ibe3i8atiswjqoHXCx7RceNSz1mGHUPHzjsNdzbL95H

Full: 
Old New Differences
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) = makeString(["%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) = makeString(["%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 keyFactoryDebtAssetEtalonBalance () = "%s%s__commonConfig__debtAssetEtalonBalance"
60 + 
61 + 
62 + func keyFactoryAssetCfg (assetAddressStr) = (("%s%s%s__defoAsset__" + assetAddressStr) + "__config")
63 + 
64 + 
65 + func keyFactoryAssetCurrentPool (assetAccAddress) = (("%s%s%s__defoAsset__" + toString(assetAccAddress)) + "__currentPool")
66 + 
67 + 
68 + func keyFactoryDefoAddressByAssetCode (assetCode) = (("%s%s%s__defoAsset__" + assetCode) + "__addressByAssetCode")
69 + 
70 + 
71 + func keyFactoryAssetPoolMakers (assetAddress) = (("%s%s%s__defoAsset__" + assetAddress) + "__poolMakers")
72 + 
73 + 
74 + func keyFactoryDefoStakingPacemakerPub () = "%s%s__commonConfig__defoStakingPacemakerPub"
75 + 
76 + 
77 + func factoryReadDebtAssetId () = valueOrErrorMessage(getString(factoryAcc, keyFactoryDebtAssetId()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDebtAssetId()))
78 + 
79 + 
80 + func factoryReadAssetCfgByAddress (assetAddressStr) = split(valueOrErrorMessage(getString(factoryAcc, keyFactoryAssetCfg(assetAddressStr)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryAssetCfg(assetAddressStr))), "__")
81 + 
82 + 
83 + func factoryReadAssetCfgByCode (assetCode) = {
84 +     let assetAddressStr = valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoAddressByAssetCode(assetCode)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoAddressByAssetCode(assetCode)))
85 +     $Tuple2(assetAddressStr, factoryReadAssetCfgByAddress(assetAddressStr))
86 +     }
87 + 
88 + 
89 + func factoryReadNextPoolMakerToDistributeFee (assetAddressStr) = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyFactoryAssetPoolMakers(assetAddressStr)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryAssetPoolMakers(assetAddressStr)))), ("address extraction error for key=" + keyFactoryAssetPoolMakers(assetAddressStr)))
90 + 
91 + 
92 + func factoryReadDefoStakingPacemakerPub () = fromBase58String(valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoStakingPacemakerPub()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoStakingPacemakerPub())))
93 + 
94 + 
95 + let IdxDefoAssetCode = 1
96 + 
97 + let IdxDefoAssetId = 2
98 + 
99 + let IdxDefoAssetStatus = 3
100 + 
101 + let IdxPriceDecimals = 4
102 + 
103 + let IdxBaseAssetId = 5
104 + 
105 + let IdxOverCollateralPercent = 6
106 + 
107 + let IdxMinInitPool = 7
108 + 
109 + let IdxPriceOracleAddress = 8
110 + 
111 + let IdxMinBuyPayment = 9
112 + 
113 + let IdxMinSellPayment = 10
114 + 
115 + let IdxBuyLockInterval = 11
116 + 
117 + let IdxSellLockInterval = 12
118 + 
119 + let IdxBuyFeePercent = 13
120 + 
121 + let IdxSellFeePercent = 14
122 + 
123 + let thisCfgArray = factoryReadAssetCfgByAddress(toString(this))
124 + 
125 + let defoAssetCode = thisCfgArray[IdxDefoAssetCode]
126 + 
127 + let defoAssetIdStr = thisCfgArray[IdxDefoAssetId]
128 + 
129 + let defoAssetId = fromBase58String(defoAssetIdStr)
130 + 
131 + let priceOracleAcc = addressFromStringValue(thisCfgArray[IdxPriceOracleAddress])
132 + 
133 + let overCollateralPercent = parseIntValue(thisCfgArray[IdxOverCollateralPercent])
134 + 
135 + let baseAssetIdStr = thisCfgArray[IdxBaseAssetId]
136 + 
137 + let baseAssetId = fromBase58String(baseAssetIdStr)
138 + 
139 + let priceDecimals = parseIntValue(thisCfgArray[IdxPriceDecimals])
140 + 
141 + let minBasicBuyAmount = parseIntValue(thisCfgArray[IdxMinBuyPayment])
142 + 
143 + let minSynthSellAmount = parseIntValue(thisCfgArray[IdxMinSellPayment])
144 + 
145 + let buyLockInterval = parseIntValue(thisCfgArray[IdxBuyLockInterval])
146 + 
147 + let sellLockInterval = parseIntValue(thisCfgArray[IdxSellLockInterval])
148 + 
149 + let buyFeePercent = parseIntValue(thisCfgArray[IdxBuyFeePercent])
150 + 
151 + let sellFeePercent = parseIntValue(thisCfgArray[IdxSellFeePercent])
152 + 
153 + func keyIsBlocked () = "%s__isBlocked"
154 + 
155 + 
156 + let isBlocked = valueOrElse(getBoolean(priceOracleAcc, keyIsBlocked()), false)
157 + 
158 + func controlAccReadPrice (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyPrice(assetCode)), ((("No price at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyPrice(assetCode)))
159 + 
160 + 
161 + func controlAccReadCurrIdxOrFail () = valueOrErrorMessage(getInteger(priceOracleAcc, "currIdx"), ("No currIdx at controlAcc=" + toString(priceOracleAcc)))
162 + 
163 + 
164 + func controlAccReadIdxHeight (idx) = {
165 +     let idxHeightKey = ("idxHeight_" + toString(idx))
166 +     valueOrElse(getInteger(priceOracleAcc, idxHeightKey), 0)
167 +     }
168 + 
169 + 
170 + func controlAccReadPriceByHeight (priceHeight) = {
171 +     let priceByHeightKey = ("price_" + toString(priceHeight))
172 +     valueOrErrorMessage(getInteger(priceOracleAcc, priceByHeightKey), ((("No " + priceByHeightKey) + " at controlAcc=") + toString(priceOracleAcc)))
173 +     }
174 + 
175 + 
176 + let keyDefoStakingAddress = "%s%s__commonConfig__defoStakingAddress"
177 + 
178 + let keyNeutrinoStakingAddress = "%s%s__commonConfig__neutrinoStakingAddress"
179 + 
180 + func keyDefoStakingAssetBalance (assetId) = ("%s%s__stakingBalance__" + assetId)
181 + 
182 + 
183 + func keyNeutrinoStakingBalance () = ((("rpd_balance_" + baseAssetIdStr) + "_") + toString(this))
184 + 
185 + 
186 + let defoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyDefoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyDefoStakingAddress))), ("address extraction error for key=" + keyDefoStakingAddress))
187 + 
188 + let neutrinoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyNeutrinoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyNeutrinoStakingAddress))), ("address extraction error for key=" + keyNeutrinoStakingAddress))
189 + 
190 + func getThisDefoStakingBalance () = valueOrElse(getInteger(defoStakingAcc, keyDefoStakingAssetBalance(defoAssetIdStr)), 0)
191 + 
192 + 
193 + func getThisNeutrinoStakingBalance () = valueOrElse(getInteger(neutrinoStakingAcc, keyNeutrinoStakingBalance()), 0)
194 + 
195 + 
196 + let ucollateral = valueOrElse(getInteger(this, keyUcollateral()), 0)
197 + 
198 + let accumulatedFee = valueOrElse(getInteger(this, keyAccumulatedFee()), 0)
199 + 
200 + let currPoolAmount = getIntegerValue(factoryAcc, keyFactoryAssetCurrentPool(this))
201 + 
202 + let debtAssetId = fromBase58String(factoryReadDebtAssetId())
203 + 
204 + let debtAssetEtalonBalance = getIntegerValue(factoryAcc, keyFactoryDebtAssetEtalonBalance())
205 + 
206 + let lendedOrDebtAmount = (debtAssetEtalonBalance - assetBalance(this, debtAssetId))
207 + 
208 + let currentBaseAssetBalance = ((assetBalance(this, baseAssetId) + getThisNeutrinoStakingBalance()) + lendedOrDebtAmount)
209 + 
210 + let price = controlAccReadPrice(thisCfgArray[IdxDefoAssetCode])
211 + 
212 + let overPrice = (((priceDecimals + overCollateralPercent) * price) / priceDecimals)
213 + 
214 + let emission = (value(assetInfo(defoAssetId)).quantity - assetBalance(this, defoAssetId))
215 + 
216 + func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,feePercent) = {
217 +     let defoAssetAmountGross = fraction(sellAmt, buy2sellPrice, priceDecimals)
218 +     let defoAssetAmount = fraction((priceDecimals - feePercent), defoAssetAmountGross, priceDecimals)
219 +     let feeAmount = (defoAssetAmountGross - defoAssetAmount)
220 +     let requiredBasicAssetAmount = fraction(defoAssetAmountGross, priceDecimals, buy2sellPrice)
221 +     let change = (sellAmt - requiredBasicAssetAmount)
222 +     if (if ((minSellAmt > sellAmt))
223 +         then (toString(sellerAddr) != toString(defoStakingAcc))
224 +         else false)
225 +         then throw(((((("impossible to issue new " + defoAssetCode) + ": payment=") + toString(sellAmt)) + "is less then min amount=") + toString(minSellAmt)))
226 +         else $Tuple2([IntegerEntry(keyUcollateral(), (ucollateral + requiredBasicAssetAmount)), StringEntry(keyAccountOperation(height, toString(sellerAddr), "FINISHED"), assetDataSwapOperation(sellAmt, toBase58String(sellAssetId), price, defoAssetAmount, toBase58String(defoAssetId), defoAssetAmountGross, feeAmount)), Reissue(defoAssetId, (defoAssetAmount + feeAmount), true), ScriptTransfer(sellerAddr, defoAssetAmount, defoAssetId), ScriptTransfer(sellerAddr, change, sellAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), feeAmount, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + feeAmount))], change)
227 +     }
228 + 
229 + 
230 + @Callable(i)
231 + func buyAsset () = {
232 +     let pmt = value(i.payments[0])
233 +     let pmtAssetId = value(pmt.assetId)
234 +     if (isBlocked)
235 +         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
236 +         else if ((pmtAssetId != baseAssetId))
237 +             then throw(((("Payment asset id doesn't match basic asset: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(pmtAssetId)))
238 +             else internalBuyAsset(i.caller, pmt.amount, pmtAssetId, minBasicBuyAmount, price, buyFeePercent)._1
239 +     }
240 + 
241 + 
242 + 
243 + @Callable(i)
244 + func sellAsset () = {
245 +     let pmt = value(i.payments[0])
246 +     let pmtAsset = value(pmt.assetId)
247 +     let callerAddress = toString(i.caller)
248 +     if (isBlocked)
249 +         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
250 +         else if ((pmtAsset != defoAssetId))
251 +             then throw(((("Invalid payment asset id: expected=" + toBase58String(defoAssetId)) + " actual=") + toBase58String(pmtAsset)))
252 +             else if ((minSynthSellAmount > pmt.amount))
253 +                 then throw(((("Payment amount less then mininimal allowed: paymentAmount=" + toString(pmt.amount)) + " minAmount=") + toString(minSynthSellAmount)))
254 +                 else {
255 +                     let baseAssetAmountNoBalanceLimit = fraction(pmt.amount, priceDecimals, price)
256 +                     let baseAssetAmountAvailable = if ((baseAssetAmountNoBalanceLimit > currentBaseAssetBalance))
257 +                         then currentBaseAssetBalance
258 +                         else baseAssetAmountNoBalanceLimit
259 +                     let soldDefoAssetAmountGross = fraction(baseAssetAmountAvailable, price, priceDecimals)
260 +                     let change = (pmt.amount - soldDefoAssetAmountGross)
261 +                     let defoAmountFee = fraction(sellFeePercent, soldDefoAssetAmountGross, priceDecimals)
262 +                     let soldDefoAssetAmount = (soldDefoAssetAmountGross - defoAmountFee)
263 +                     let baseAssetAmountToSend = fraction(soldDefoAssetAmount, priceDecimals, price)
264 + [IntegerEntry(keyUcollateral(), (ucollateral - baseAssetAmountToSend)), StringEntry(keyAccountOperation(height, callerAddress, "FINISHED"), assetDataSwapOperation(pmt.amount, toBase58String(pmtAsset), price, baseAssetAmountToSend, baseAssetIdStr, soldDefoAssetAmountGross, defoAmountFee)), Burn(defoAssetId, soldDefoAssetAmount), ScriptTransfer(i.caller, baseAssetAmountToSend, baseAssetId), ScriptTransfer(i.caller, change, defoAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), defoAmountFee, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + defoAmountFee))]
265 +                     }
266 +     }
267 + 
268 + 
269 + 
270 + @Callable(i)
271 + func crossExchange (buyAssetCodeConfirm,sellAssetCodeConfirm) = {
272 +     let pmt = value(i.payments[0])
273 +     let pmtAsset = value(pmt.assetId)
274 +     let pmtAssetStr = toBase58String(pmtAsset)
275 +     let pmtAmount = pmt.amount
276 +     let callerAddress = toString(i.caller)
277 +     let buyAssetCfg = thisCfgArray
278 +     let sellAssetTuple = factoryReadAssetCfgByCode(sellAssetCodeConfirm)
279 +     let sellAssetCfg = sellAssetTuple._2
280 +     let sellAssetAccAddress = valueOrErrorMessage(addressFromString(sellAssetTuple._1), ("couldn't parse address from string for assetCode=" + sellAssetCodeConfirm))
281 +     let minSellPmt = valueOrErrorMessage(parseInt(sellAssetCfg[IdxMinSellPayment]), ("minSellPmt parsing error: rawVal=" + sellAssetCfg[IdxMinSellPayment]))
282 +     if (isBlocked)
283 +         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
284 +         else if ((thisCfgArray[IdxDefoAssetCode] != buyAssetCodeConfirm))
285 +             then throw(((("buyAsset confirmation failed: buyAssetIdConfirm=" + thisCfgArray[IdxDefoAssetCode]) + " BUT buyAssetId=") + buyAssetCodeConfirm))
286 +             else if ((sellAssetCfg[IdxDefoAssetId] != pmtAssetStr))
287 +                 then throw(((("sellAsset confirmation failed: sellAssetIdConfirm=" + sellAssetCfg[IdxDefoAssetId]) + "BUT pmtAsset=") + pmtAssetStr))
288 +                 else if ((thisCfgArray[IdxDefoAssetStatus] != "ISSUED"))
289 +                     then throw(((("toAsset has not been issued yet: buyAssetId=" + buyAssetCodeConfirm) + " BUT status=") + thisCfgArray[IdxDefoAssetStatus]))
290 +                     else if ((sellAssetCfg[IdxDefoAssetStatus] != "ISSUED"))
291 +                         then throw(((("fromAssetCfg has not been issued yet: sellAssetId=" + pmtAssetStr) + " BUT status=") + sellAssetCfg[IdxDefoAssetStatus]))
292 +                         else {
293 +                             let buyAssetUsdPrice = price
294 +                             let sellAssetUsdPrice = controlAccReadPrice(sellAssetCodeConfirm)
295 +                             let buy2sellPrice = fraction(buyAssetUsdPrice, priceDecimals, sellAssetUsdPrice)
296 +                             let usdnDebt = fraction(pmtAmount, priceDecimals, sellAssetUsdPrice)
297 +                             let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
298 +                             let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(sellAssetCodeConfirm)
299 +                             let lendedAmtByAssetCode = valueOrElse(getInteger(this, lendedAmountByAssetCodeKey), 0)
300 +                             let sellAssetSellFeePercent = parseIntValue(sellAssetCfg[IdxSellFeePercent])
301 +                             let buyAssetResult = internalBuyAsset(i.caller, pmtAmount, pmtAsset, minSellPmt, buy2sellPrice, fraction((buyFeePercent + sellAssetSellFeePercent), 50, 100))
302 +                             ((((buyAssetResult._1 :+ ScriptTransfer(sellAssetAccAddress, usdnDebt, debtAssetId)) :+ ScriptTransfer(sellAssetAccAddress, (pmtAmount - buyAssetResult._2), pmtAsset)) :+ IntegerEntry(lendedAmountByAssetCodeKey, (lendedAmtByAssetCode + usdnDebt))) :+ IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs + usdnDebt)))
303 +                             }
304 +     }
305 + 
306 + 
307 + 
308 + @Callable(i)
309 + func rebalanceDebts () = {
310 +     let debtPmt0 = value(i.payments[0])
311 +     let debtPmtAsset0 = value(debtPmt0.assetId)
312 +     let basePmt1 = value(i.payments[1])
313 +     let basePmtAsset1 = value(basePmt1.assetId)
314 +     let debtorAddress = toString(i.caller)
315 +     let debtorAssetCfg = factoryReadAssetCfgByAddress(debtorAddress)
316 +     let debtorAssetCode = debtorAssetCfg[IdxDefoAssetCode]
317 +     let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(debtorAssetCode)
318 +     let lendedAmt = valueOrErrorMessage(getInteger(this, lendedAmountByAssetCodeKey), ("No debts for " + debtorAssetCode))
319 +     if (isBlocked)
320 +         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
321 +         else if ((debtAssetId != debtPmtAsset0))
322 +             then throw(((("invalid debt asset id in the first paymet: expected=" + toBase58String(debtAssetId)) + " actual=") + toBase58String(debtPmtAsset0)))
323 +             else if ((baseAssetId != basePmtAsset1))
324 +                 then throw(((("invalid base asset id in the second payment: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(basePmtAsset1)))
325 +                 else if ((debtPmt0.amount != basePmt1.amount))
326 +                     then throw("first payment amount doesn't match to the second payment amount")
327 +                     else if ((0 >= lendedAmt))
328 +                         then throw(("lendedAmt is less then zero: lendedAmt=" + toString(lendedAmt)))
329 +                         else if ((minBasicBuyAmount >= debtPmt0.amount))
330 +                             then throw(((("attached payment must be greater then minBasicBuyAmount: pmt0.amount=" + toString(debtPmt0.amount)) + " minBasicBuyAmount=") + toString(minBasicBuyAmount)))
331 +                             else if ((debtPmt0.amount > lendedAmt))
332 +                                 then throw(((("attached payment is grater than required: pmtAmount=" + toString(debtPmt0.amount)) + " lendedAmt=") + toString(lendedAmt)))
333 +                                 else {
334 +                                     let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
335 +                                     let lendedAmtAfter = (lendedAmt - debtPmt0.amount)
336 + [IntegerEntry(lendedAmountByAssetCodeKey, lendedAmtAfter), IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs - debtPmt0.amount)), StringEntry(("%s%s__rebalanceTrace__" + toBase58String(i.transactionId)), assetDataRebalanceTrace(debtorAssetCode, debtPmt0, basePmt1, lendedAmt, lendedAmtAfter))]
337 +                                     }
338 +     }
339 + 
340 + 
341 + @Verifier(tx)
342 + func verify () = match tx {
343 +     case inv: InvokeScriptTransaction => 
344 +         if ((inv.fee > (900 * 1000)))
345 +             then throw(("fee amount is greater than max allowed: " + toString(inv.fee)))
346 +             else if (isDefined(inv.feeAssetId))
347 +                 then throw("only Waves is allowed as feeAssetId")
348 +                 else if ((inv.function == "rebalanceDebts"))
349 +                     then {
350 +                         let invDappAddress = toString(addressFromRecipient(inv.dApp))
351 +                         if ((factoryReadAssetCfgByAddress(invDappAddress)[IdxDefoAssetStatus] != "ISSUED"))
352 +                             then throw("only defo dapp is allowed")
353 +                             else if ((invDappAddress == toString(this)))
354 +                                 then throw("impossible to call self rebealnceDebt")
355 +                                 else true
356 +                         }
357 +                     else if (if (if ((inv.function == "lockNeutrino"))
358 +                         then true
359 +                         else (inv.function == "lockNeutrinoSP"))
360 +                         then true
361 +                         else (inv.function == "unlockNeutrino"))
362 +                         then if ((toString(neutrinoStakingAcc) != toString(addressFromRecipient(inv.dApp))))
363 +                             then throw("invalid neutrino staking dapp address")
364 +                             else sigVerify(tx.bodyBytes, tx.proofs[0], factoryReadDefoStakingPacemakerPub())
365 +                         else throw("Not allowed invocation method calls")
366 +     case _ => 
367 +         sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
368 + }
369 +

Old	New		Differences
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) = makeString(["%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) = makeString(["%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 keyFactoryDebtAssetEtalonBalance () = "%s%s__commonConfig__debtAssetEtalonBalance"
	60	+
	61	+
	62	+	func keyFactoryAssetCfg (assetAddressStr) = (("%s%s%s__defoAsset__" + assetAddressStr) + "__config")
	63	+
	64	+
	65	+	func keyFactoryAssetCurrentPool (assetAccAddress) = (("%s%s%s__defoAsset__" + toString(assetAccAddress)) + "__currentPool")
	66	+
	67	+
	68	+	func keyFactoryDefoAddressByAssetCode (assetCode) = (("%s%s%s__defoAsset__" + assetCode) + "__addressByAssetCode")
	69	+
	70	+
	71	+	func keyFactoryAssetPoolMakers (assetAddress) = (("%s%s%s__defoAsset__" + assetAddress) + "__poolMakers")
	72	+
	73	+
	74	+	func keyFactoryDefoStakingPacemakerPub () = "%s%s__commonConfig__defoStakingPacemakerPub"
	75	+
	76	+
	77	+	func factoryReadDebtAssetId () = valueOrErrorMessage(getString(factoryAcc, keyFactoryDebtAssetId()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDebtAssetId()))
	78	+
	79	+
	80	+	func factoryReadAssetCfgByAddress (assetAddressStr) = split(valueOrErrorMessage(getString(factoryAcc, keyFactoryAssetCfg(assetAddressStr)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryAssetCfg(assetAddressStr))), "__")
	81	+
	82	+
	83	+	func factoryReadAssetCfgByCode (assetCode) = {
	84	+	let assetAddressStr = valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoAddressByAssetCode(assetCode)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoAddressByAssetCode(assetCode)))
	85	+	$Tuple2(assetAddressStr, factoryReadAssetCfgByAddress(assetAddressStr))
	86	+	}
	87	+
	88	+
	89	+	func factoryReadNextPoolMakerToDistributeFee (assetAddressStr) = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyFactoryAssetPoolMakers(assetAddressStr)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryAssetPoolMakers(assetAddressStr)))), ("address extraction error for key=" + keyFactoryAssetPoolMakers(assetAddressStr)))
	90	+
	91	+
	92	+	func factoryReadDefoStakingPacemakerPub () = fromBase58String(valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoStakingPacemakerPub()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoStakingPacemakerPub())))
	93	+
	94	+
	95	+	let IdxDefoAssetCode = 1
	96	+
	97	+	let IdxDefoAssetId = 2
	98	+
	99	+	let IdxDefoAssetStatus = 3
	100	+
	101	+	let IdxPriceDecimals = 4
	102	+
	103	+	let IdxBaseAssetId = 5
	104	+
	105	+	let IdxOverCollateralPercent = 6
	106	+
	107	+	let IdxMinInitPool = 7
	108	+
	109	+	let IdxPriceOracleAddress = 8
	110	+
	111	+	let IdxMinBuyPayment = 9
	112	+
	113	+	let IdxMinSellPayment = 10
	114	+
	115	+	let IdxBuyLockInterval = 11
	116	+
	117	+	let IdxSellLockInterval = 12
	118	+
	119	+	let IdxBuyFeePercent = 13
	120	+
	121	+	let IdxSellFeePercent = 14
	122	+
	123	+	let thisCfgArray = factoryReadAssetCfgByAddress(toString(this))
	124	+
	125	+	let defoAssetCode = thisCfgArray[IdxDefoAssetCode]
	126	+
	127	+	let defoAssetIdStr = thisCfgArray[IdxDefoAssetId]
	128	+
	129	+	let defoAssetId = fromBase58String(defoAssetIdStr)
	130	+
	131	+	let priceOracleAcc = addressFromStringValue(thisCfgArray[IdxPriceOracleAddress])
	132	+
	133	+	let overCollateralPercent = parseIntValue(thisCfgArray[IdxOverCollateralPercent])
	134	+
	135	+	let baseAssetIdStr = thisCfgArray[IdxBaseAssetId]
	136	+
	137	+	let baseAssetId = fromBase58String(baseAssetIdStr)
	138	+
	139	+	let priceDecimals = parseIntValue(thisCfgArray[IdxPriceDecimals])
	140	+
	141	+	let minBasicBuyAmount = parseIntValue(thisCfgArray[IdxMinBuyPayment])
	142	+
	143	+	let minSynthSellAmount = parseIntValue(thisCfgArray[IdxMinSellPayment])
	144	+
	145	+	let buyLockInterval = parseIntValue(thisCfgArray[IdxBuyLockInterval])
	146	+
	147	+	let sellLockInterval = parseIntValue(thisCfgArray[IdxSellLockInterval])
	148	+
	149	+	let buyFeePercent = parseIntValue(thisCfgArray[IdxBuyFeePercent])
	150	+
	151	+	let sellFeePercent = parseIntValue(thisCfgArray[IdxSellFeePercent])
	152	+
	153	+	func keyIsBlocked () = "%s__isBlocked"
	154	+
	155	+
	156	+	let isBlocked = valueOrElse(getBoolean(priceOracleAcc, keyIsBlocked()), false)
	157	+
	158	+	func controlAccReadPrice (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyPrice(assetCode)), ((("No price at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyPrice(assetCode)))
	159	+
	160	+
	161	+	func controlAccReadCurrIdxOrFail () = valueOrErrorMessage(getInteger(priceOracleAcc, "currIdx"), ("No currIdx at controlAcc=" + toString(priceOracleAcc)))
	162	+
	163	+
	164	+	func controlAccReadIdxHeight (idx) = {
	165	+	let idxHeightKey = ("idxHeight_" + toString(idx))
	166	+	valueOrElse(getInteger(priceOracleAcc, idxHeightKey), 0)
	167	+	}
	168	+
	169	+
	170	+	func controlAccReadPriceByHeight (priceHeight) = {
	171	+	let priceByHeightKey = ("price_" + toString(priceHeight))
	172	+	valueOrErrorMessage(getInteger(priceOracleAcc, priceByHeightKey), ((("No " + priceByHeightKey) + " at controlAcc=") + toString(priceOracleAcc)))
	173	+	}
	174	+
	175	+
	176	+	let keyDefoStakingAddress = "%s%s__commonConfig__defoStakingAddress"
	177	+
	178	+	let keyNeutrinoStakingAddress = "%s%s__commonConfig__neutrinoStakingAddress"
	179	+
	180	+	func keyDefoStakingAssetBalance (assetId) = ("%s%s__stakingBalance__" + assetId)
	181	+
	182	+
	183	+	func keyNeutrinoStakingBalance () = ((("rpd_balance_" + baseAssetIdStr) + "_") + toString(this))
	184	+
	185	+
	186	+	let defoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyDefoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyDefoStakingAddress))), ("address extraction error for key=" + keyDefoStakingAddress))
	187	+
	188	+	let neutrinoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyNeutrinoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyNeutrinoStakingAddress))), ("address extraction error for key=" + keyNeutrinoStakingAddress))
	189	+
	190	+	func getThisDefoStakingBalance () = valueOrElse(getInteger(defoStakingAcc, keyDefoStakingAssetBalance(defoAssetIdStr)), 0)
	191	+
	192	+
	193	+	func getThisNeutrinoStakingBalance () = valueOrElse(getInteger(neutrinoStakingAcc, keyNeutrinoStakingBalance()), 0)
	194	+
	195	+
	196	+	let ucollateral = valueOrElse(getInteger(this, keyUcollateral()), 0)
	197	+
	198	+	let accumulatedFee = valueOrElse(getInteger(this, keyAccumulatedFee()), 0)
	199	+
	200	+	let currPoolAmount = getIntegerValue(factoryAcc, keyFactoryAssetCurrentPool(this))
	201	+
	202	+	let debtAssetId = fromBase58String(factoryReadDebtAssetId())
	203	+
	204	+	let debtAssetEtalonBalance = getIntegerValue(factoryAcc, keyFactoryDebtAssetEtalonBalance())
	205	+
	206	+	let lendedOrDebtAmount = (debtAssetEtalonBalance - assetBalance(this, debtAssetId))
	207	+
	208	+	let currentBaseAssetBalance = ((assetBalance(this, baseAssetId) + getThisNeutrinoStakingBalance()) + lendedOrDebtAmount)
	209	+
	210	+	let price = controlAccReadPrice(thisCfgArray[IdxDefoAssetCode])
	211	+
	212	+	let overPrice = (((priceDecimals + overCollateralPercent) * price) / priceDecimals)
	213	+
	214	+	let emission = (value(assetInfo(defoAssetId)).quantity - assetBalance(this, defoAssetId))
	215	+
	216	+	func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,feePercent) = {
	217	+	let defoAssetAmountGross = fraction(sellAmt, buy2sellPrice, priceDecimals)
	218	+	let defoAssetAmount = fraction((priceDecimals - feePercent), defoAssetAmountGross, priceDecimals)
	219	+	let feeAmount = (defoAssetAmountGross - defoAssetAmount)
	220	+	let requiredBasicAssetAmount = fraction(defoAssetAmountGross, priceDecimals, buy2sellPrice)
	221	+	let change = (sellAmt - requiredBasicAssetAmount)
	222	+	if (if ((minSellAmt > sellAmt))
	223	+	then (toString(sellerAddr) != toString(defoStakingAcc))
	224	+	else false)
	225	+	then throw(((((("impossible to issue new " + defoAssetCode) + ": payment=") + toString(sellAmt)) + "is less then min amount=") + toString(minSellAmt)))
	226	+	else $Tuple2([IntegerEntry(keyUcollateral(), (ucollateral + requiredBasicAssetAmount)), StringEntry(keyAccountOperation(height, toString(sellerAddr), "FINISHED"), assetDataSwapOperation(sellAmt, toBase58String(sellAssetId), price, defoAssetAmount, toBase58String(defoAssetId), defoAssetAmountGross, feeAmount)), Reissue(defoAssetId, (defoAssetAmount + feeAmount), true), ScriptTransfer(sellerAddr, defoAssetAmount, defoAssetId), ScriptTransfer(sellerAddr, change, sellAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), feeAmount, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + feeAmount))], change)
	227	+	}
	228	+
	229	+
	230	+	@Callable(i)
	231	+	func buyAsset () = {
	232	+	let pmt = value(i.payments[0])
	233	+	let pmtAssetId = value(pmt.assetId)
	234	+	if (isBlocked)
	235	+	then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
	236	+	else if ((pmtAssetId != baseAssetId))
	237	+	then throw(((("Payment asset id doesn't match basic asset: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(pmtAssetId)))
	238	+	else internalBuyAsset(i.caller, pmt.amount, pmtAssetId, minBasicBuyAmount, price, buyFeePercent)._1
	239	+	}
	240	+
	241	+
	242	+
	243	+	@Callable(i)
	244	+	func sellAsset () = {
	245	+	let pmt = value(i.payments[0])
	246	+	let pmtAsset = value(pmt.assetId)
	247	+	let callerAddress = toString(i.caller)
	248	+	if (isBlocked)
	249	+	then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
	250	+	else if ((pmtAsset != defoAssetId))
	251	+	then throw(((("Invalid payment asset id: expected=" + toBase58String(defoAssetId)) + " actual=") + toBase58String(pmtAsset)))
	252	+	else if ((minSynthSellAmount > pmt.amount))
	253	+	then throw(((("Payment amount less then mininimal allowed: paymentAmount=" + toString(pmt.amount)) + " minAmount=") + toString(minSynthSellAmount)))
	254	+	else {
	255	+	let baseAssetAmountNoBalanceLimit = fraction(pmt.amount, priceDecimals, price)
	256	+	let baseAssetAmountAvailable = if ((baseAssetAmountNoBalanceLimit > currentBaseAssetBalance))
	257	+	then currentBaseAssetBalance
	258	+	else baseAssetAmountNoBalanceLimit
	259	+	let soldDefoAssetAmountGross = fraction(baseAssetAmountAvailable, price, priceDecimals)
	260	+	let change = (pmt.amount - soldDefoAssetAmountGross)
	261	+	let defoAmountFee = fraction(sellFeePercent, soldDefoAssetAmountGross, priceDecimals)
	262	+	let soldDefoAssetAmount = (soldDefoAssetAmountGross - defoAmountFee)
	263	+	let baseAssetAmountToSend = fraction(soldDefoAssetAmount, priceDecimals, price)
	264	+	[IntegerEntry(keyUcollateral(), (ucollateral - baseAssetAmountToSend)), StringEntry(keyAccountOperation(height, callerAddress, "FINISHED"), assetDataSwapOperation(pmt.amount, toBase58String(pmtAsset), price, baseAssetAmountToSend, baseAssetIdStr, soldDefoAssetAmountGross, defoAmountFee)), Burn(defoAssetId, soldDefoAssetAmount), ScriptTransfer(i.caller, baseAssetAmountToSend, baseAssetId), ScriptTransfer(i.caller, change, defoAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), defoAmountFee, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + defoAmountFee))]
	265	+	}
	266	+	}
	267	+
	268	+
	269	+
	270	+	@Callable(i)
	271	+	func crossExchange (buyAssetCodeConfirm,sellAssetCodeConfirm) = {
	272	+	let pmt = value(i.payments[0])
	273	+	let pmtAsset = value(pmt.assetId)
	274	+	let pmtAssetStr = toBase58String(pmtAsset)
	275	+	let pmtAmount = pmt.amount
	276	+	let callerAddress = toString(i.caller)
	277	+	let buyAssetCfg = thisCfgArray
	278	+	let sellAssetTuple = factoryReadAssetCfgByCode(sellAssetCodeConfirm)
	279	+	let sellAssetCfg = sellAssetTuple._2
	280	+	let sellAssetAccAddress = valueOrErrorMessage(addressFromString(sellAssetTuple._1), ("couldn't parse address from string for assetCode=" + sellAssetCodeConfirm))
	281	+	let minSellPmt = valueOrErrorMessage(parseInt(sellAssetCfg[IdxMinSellPayment]), ("minSellPmt parsing error: rawVal=" + sellAssetCfg[IdxMinSellPayment]))
	282	+	if (isBlocked)
	283	+	then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
	284	+	else if ((thisCfgArray[IdxDefoAssetCode] != buyAssetCodeConfirm))
	285	+	then throw(((("buyAsset confirmation failed: buyAssetIdConfirm=" + thisCfgArray[IdxDefoAssetCode]) + " BUT buyAssetId=") + buyAssetCodeConfirm))
	286	+	else if ((sellAssetCfg[IdxDefoAssetId] != pmtAssetStr))
	287	+	then throw(((("sellAsset confirmation failed: sellAssetIdConfirm=" + sellAssetCfg[IdxDefoAssetId]) + "BUT pmtAsset=") + pmtAssetStr))
	288	+	else if ((thisCfgArray[IdxDefoAssetStatus] != "ISSUED"))
	289	+	then throw(((("toAsset has not been issued yet: buyAssetId=" + buyAssetCodeConfirm) + " BUT status=") + thisCfgArray[IdxDefoAssetStatus]))
	290	+	else if ((sellAssetCfg[IdxDefoAssetStatus] != "ISSUED"))
	291	+	then throw(((("fromAssetCfg has not been issued yet: sellAssetId=" + pmtAssetStr) + " BUT status=") + sellAssetCfg[IdxDefoAssetStatus]))
	292	+	else {
	293	+	let buyAssetUsdPrice = price
	294	+	let sellAssetUsdPrice = controlAccReadPrice(sellAssetCodeConfirm)
	295	+	let buy2sellPrice = fraction(buyAssetUsdPrice, priceDecimals, sellAssetUsdPrice)
	296	+	let usdnDebt = fraction(pmtAmount, priceDecimals, sellAssetUsdPrice)
	297	+	let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
	298	+	let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(sellAssetCodeConfirm)
	299	+	let lendedAmtByAssetCode = valueOrElse(getInteger(this, lendedAmountByAssetCodeKey), 0)
	300	+	let sellAssetSellFeePercent = parseIntValue(sellAssetCfg[IdxSellFeePercent])
	301	+	let buyAssetResult = internalBuyAsset(i.caller, pmtAmount, pmtAsset, minSellPmt, buy2sellPrice, fraction((buyFeePercent + sellAssetSellFeePercent), 50, 100))
	302	+	((((buyAssetResult._1 :+ ScriptTransfer(sellAssetAccAddress, usdnDebt, debtAssetId)) :+ ScriptTransfer(sellAssetAccAddress, (pmtAmount - buyAssetResult._2), pmtAsset)) :+ IntegerEntry(lendedAmountByAssetCodeKey, (lendedAmtByAssetCode + usdnDebt))) :+ IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs + usdnDebt)))
	303	+	}
	304	+	}
	305	+
	306	+
	307	+
	308	+	@Callable(i)
	309	+	func rebalanceDebts () = {
	310	+	let debtPmt0 = value(i.payments[0])
	311	+	let debtPmtAsset0 = value(debtPmt0.assetId)
	312	+	let basePmt1 = value(i.payments[1])
	313	+	let basePmtAsset1 = value(basePmt1.assetId)
	314	+	let debtorAddress = toString(i.caller)
	315	+	let debtorAssetCfg = factoryReadAssetCfgByAddress(debtorAddress)
	316	+	let debtorAssetCode = debtorAssetCfg[IdxDefoAssetCode]
	317	+	let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(debtorAssetCode)
	318	+	let lendedAmt = valueOrErrorMessage(getInteger(this, lendedAmountByAssetCodeKey), ("No debts for " + debtorAssetCode))
	319	+	if (isBlocked)
	320	+	then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
	321	+	else if ((debtAssetId != debtPmtAsset0))
	322	+	then throw(((("invalid debt asset id in the first paymet: expected=" + toBase58String(debtAssetId)) + " actual=") + toBase58String(debtPmtAsset0)))
	323	+	else if ((baseAssetId != basePmtAsset1))
	324	+	then throw(((("invalid base asset id in the second payment: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(basePmtAsset1)))
	325	+	else if ((debtPmt0.amount != basePmt1.amount))
	326	+	then throw("first payment amount doesn't match to the second payment amount")
	327	+	else if ((0 >= lendedAmt))
	328	+	then throw(("lendedAmt is less then zero: lendedAmt=" + toString(lendedAmt)))
	329	+	else if ((minBasicBuyAmount >= debtPmt0.amount))
	330	+	then throw(((("attached payment must be greater then minBasicBuyAmount: pmt0.amount=" + toString(debtPmt0.amount)) + " minBasicBuyAmount=") + toString(minBasicBuyAmount)))
	331	+	else if ((debtPmt0.amount > lendedAmt))
	332	+	then throw(((("attached payment is grater than required: pmtAmount=" + toString(debtPmt0.amount)) + " lendedAmt=") + toString(lendedAmt)))
	333	+	else {
	334	+	let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
	335	+	let lendedAmtAfter = (lendedAmt - debtPmt0.amount)
	336	+	[IntegerEntry(lendedAmountByAssetCodeKey, lendedAmtAfter), IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs - debtPmt0.amount)), StringEntry(("%s%s__rebalanceTrace__" + toBase58String(i.transactionId)), assetDataRebalanceTrace(debtorAssetCode, debtPmt0, basePmt1, lendedAmt, lendedAmtAfter))]
	337	+	}
	338	+	}
	339	+
	340	+
	341	+	@Verifier(tx)
	342	+	func verify () = match tx {
	343	+	case inv: InvokeScriptTransaction =>
	344	+	if ((inv.fee > (900 * 1000)))
	345	+	then throw(("fee amount is greater than max allowed: " + toString(inv.fee)))
	346	+	else if (isDefined(inv.feeAssetId))
	347	+	then throw("only Waves is allowed as feeAssetId")
	348	+	else if ((inv.function == "rebalanceDebts"))
	349	+	then {
	350	+	let invDappAddress = toString(addressFromRecipient(inv.dApp))
	351	+	if ((factoryReadAssetCfgByAddress(invDappAddress)[IdxDefoAssetStatus] != "ISSUED"))
	352	+	then throw("only defo dapp is allowed")
	353	+	else if ((invDappAddress == toString(this)))
	354	+	then throw("impossible to call self rebealnceDebt")
	355	+	else true
	356	+	}
	357	+	else if (if (if ((inv.function == "lockNeutrino"))
	358	+	then true
	359	+	else (inv.function == "lockNeutrinoSP"))
	360	+	then true
	361	+	else (inv.function == "unlockNeutrino"))
	362	+	then if ((toString(neutrinoStakingAcc) != toString(addressFromRecipient(inv.dApp))))
	363	+	then throw("invalid neutrino staking dapp address")
	364	+	else sigVerify(tx.bodyBytes, tx.proofs[0], factoryReadDefoStakingPacemakerPub())
	365	+	else throw("Not allowed invocation method calls")
	366	+	case _ =>
	367	+	sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
	368	+	}
	369	+

github/deemru/w8io/6500d08 
43.88 ms ◑