tx · 67LEok1wtUUZ1pVsFhLwDCd9D5Bks9FVfpDLA5aNe31w

3N5RuBmyQfrVscykrusZD4AziNXQLn5Avj9:  -0.01000000 Waves

2020.11.03 17:13 [1249220] smart account 3N5RuBmyQfrVscykrusZD4AziNXQLn5Avj9 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "67LEok1wtUUZ1pVsFhLwDCd9D5Bks9FVfpDLA5aNe31w",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1604412827041,
    "version": 1,
    "sender": "3N5RuBmyQfrVscykrusZD4AziNXQLn5Avj9",
    "senderPublicKey": "JytPb3jEFVdTgBkDgrcyrgRSFwJAXVqA8UgrnF8aA5y",
    "proofs": [
        "22rtJhjgt2MTzaWMif6xMGNGGoZKjhdhVtjgyHGjXccJzAtY5MmhF36Dz9h3cek7w6aST9hhbLtjL26vthLtVtXX"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1249220,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 8LZw4akb7tGxcJr6inC5uU8cUwU6vtRZ2WiwDk4QHPKV

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+func keyControlLastHeight (assetCode) = ("%s%s__lastHeight__" + assetCode)
29+
30+
31+let IdxOperationAmountIn = 1
32+
33+let IdxOperationAssetIn = 2
34+
35+let IdxOperationPrice = 3
36+
37+let IdxOperationAmountOut = 4
38+
39+let IdxOperationAssetOut = 5
40+
41+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)], "__")
42+
43+
44+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)], "__")
45+
46+
47+func assetReadSwapDataArrayOrFail (accOperationKey) = {
48+    let accOperationDataStr = valueOrErrorMessage(getString(this, accOperationKey), ("There is no request for passed arguments: " + accOperationKey))
49+    split(accOperationDataStr, "__")
50+    }
51+
52+
53+let nullInt = -1
54+
55+let nullStr = "NULL"
56+
57+let factoryAcc = addressFromStringValue(valueOrErrorMessage(getString(this, keyFactory()), ((("No config at this=" + toString(this)) + " for key=") + keyFactory())))
58+
59+func keyFactoryDebtAssetId () = "%s%s__commonConfig__debtAssetId"
60+
61+
62+func keyFactoryDebtAssetEtalonBalance () = "%s%s__commonConfig__debtAssetEtalonBalance"
63+
64+
65+func keyFactoryAssetCfg (assetAddressStr) = (("%s%s%s__defoAsset__" + assetAddressStr) + "__config")
66+
67+
68+func keyFactoryAssetCurrentPool (assetAccAddress) = (("%s%s%s__defoAsset__" + toString(assetAccAddress)) + "__currentPool")
69+
70+
71+func keyFactoryDefoAddressByAssetCode (assetCode) = (("%s%s%s__defoAsset__" + assetCode) + "__addressByAssetCode")
72+
73+
74+func keyFactoryAssetPoolMakers (assetAddress) = (("%s%s%s__defoAsset__" + assetAddress) + "__poolMakers")
75+
76+
77+func keyFactoryDefoStakingPacemakerPub () = "%s%s__commonConfig__defoStakingPacemakerPub"
78+
79+
80+func keyFactoryPoolMakerLiquidityRequest (assetAddress,poolMakerAddress,h) = makeString(["%s%s%s%d%s__pool", assetAddress, poolMakerAddress, toString(h), "liquidityRequest"], "__")
81+
82+
83+func keyFactoryPoolMakerUnlockHeight (assetAddress,poolMakerAddress) = makeString(["%s%s%s%s__pool", assetAddress, poolMakerAddress, "unlockHeight"], "__")
84+
85+
86+func factoryReadDebtAssetId () = valueOrErrorMessage(getString(factoryAcc, keyFactoryDebtAssetId()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDebtAssetId()))
87+
88+
89+func factoryReadAssetCfgByAddress (assetAddressStr) = split(valueOrErrorMessage(getString(factoryAcc, keyFactoryAssetCfg(assetAddressStr)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryAssetCfg(assetAddressStr))), "__")
90+
91+
92+func factoryReadAssetCfgByCode (assetCode) = {
93+    let assetAddressStr = valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoAddressByAssetCode(assetCode)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoAddressByAssetCode(assetCode)))
94+    $Tuple2(assetAddressStr, factoryReadAssetCfgByAddress(assetAddressStr))
95+    }
96+
97+
98+func factoryReadNextPoolMakerToDistributeFee (assetAddressStr) = addressFromStringValue("3MsbFMstwm3FHPJXmMfTgyaw7zQrpZfkwnx")
99+
100+
101+func factoryReadDefoStakingPacemakerPub () = fromBase58String(valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoStakingPacemakerPub()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoStakingPacemakerPub())))
102+
103+
104+let IdxDefoAssetCode = 1
105+
106+let IdxDefoAssetId = 2
107+
108+let IdxDefoAssetStatus = 3
109+
110+let IdxPriceDecimals = 4
111+
112+let IdxBaseAssetId = 5
113+
114+let IdxOverCollateralPercent = 6
115+
116+let IdxMinInitPool = 7
117+
118+let IdxPriceOracleAddress = 8
119+
120+let IdxMinBuyPayment = 9
121+
122+let IdxMinSellPayment = 10
123+
124+let IdxBuyLockInterval = 11
125+
126+let IdxSellLockInterval = 12
127+
128+let IdxBuyFeePercent = 13
129+
130+let IdxSellFeePercent = 14
131+
132+let IdxPoolRedemptionTimeout = 15
133+
134+let IdxWeekendsPriceChangeCoefficient = 16
135+
136+let thisCfgArray = factoryReadAssetCfgByAddress(toString(this))
137+
138+let defoAssetCode = thisCfgArray[IdxDefoAssetCode]
139+
140+let defoAssetIdStr = thisCfgArray[IdxDefoAssetId]
141+
142+let defoAssetId = fromBase58String(defoAssetIdStr)
143+
144+let priceOracleAcc = addressFromStringValue(thisCfgArray[IdxPriceOracleAddress])
145+
146+let overCollateralPercent = parseIntValue(thisCfgArray[IdxOverCollateralPercent])
147+
148+let baseAssetIdStr = thisCfgArray[IdxBaseAssetId]
149+
150+let baseAssetId = fromBase58String(baseAssetIdStr)
151+
152+let priceDecimals = parseIntValue(thisCfgArray[IdxPriceDecimals])
153+
154+let minBasicBuyAmount = parseIntValue(thisCfgArray[IdxMinBuyPayment])
155+
156+let minSynthSellAmount = parseIntValue(thisCfgArray[IdxMinSellPayment])
157+
158+let buyLockInterval = parseIntValue(thisCfgArray[IdxBuyLockInterval])
159+
160+let sellLockInterval = parseIntValue(thisCfgArray[IdxSellLockInterval])
161+
162+let buyFeePercent = parseIntValue(thisCfgArray[IdxBuyFeePercent])
163+
164+let sellFeePercent = parseIntValue(thisCfgArray[IdxSellFeePercent])
165+
166+let weekendsPriceChangeCoefficient = parseIntValue(thisCfgArray[IdxWeekendsPriceChangeCoefficient])
167+
168+func keyIsBlocked () = "%s__isBlocked"
169+
170+
171+func keyIsMarketOpened (assetCode) = ("%s%s__isMarketOpened__" + assetCode)
172+
173+
174+let isBlocked = valueOrElse(getBoolean(priceOracleAcc, keyIsBlocked()), false)
175+
176+let isMarketOpened = valueOrElse(getBoolean(priceOracleAcc, keyIsMarketOpened(defoAssetCode)), false)
177+
178+func controlAccReadPrice (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyPrice(assetCode)), ((("No price at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyPrice(assetCode)))
179+
180+
181+func controlAccReadLastHeight (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyControlLastHeight(assetCode)), ((("No lastHeight at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyControlLastHeight(assetCode)))
182+
183+
184+func controlAccReadCurrIdxOrFail () = valueOrErrorMessage(getInteger(priceOracleAcc, "currIdx"), ("No currIdx at controlAcc=" + toString(priceOracleAcc)))
185+
186+
187+func controlAccReadIdxHeight (idx) = {
188+    let idxHeightKey = ("idxHeight_" + toString(idx))
189+    valueOrElse(getInteger(priceOracleAcc, idxHeightKey), 0)
190+    }
191+
192+
193+func controlAccReadPriceByHeight (priceHeight) = {
194+    let priceByHeightKey = ("price_" + toString(priceHeight))
195+    valueOrErrorMessage(getInteger(priceOracleAcc, priceByHeightKey), ((("No " + priceByHeightKey) + " at controlAcc=") + toString(priceOracleAcc)))
196+    }
197+
198+
199+let priceLastHeight = controlAccReadLastHeight(defoAssetCode)
200+
201+let isBlockedByLastHeight = ((priceLastHeight - priceLastHeight) > 5)
202+
203+let keyDefoStakingAddress = "%s%s__commonConfig__defoStakingAddress"
204+
205+let keyNeutrinoStakingAddress = "%s%s__commonConfig__neutrinoStakingAddress"
206+
207+func keyDefoStakingAssetBalance (assetId) = ("%s%s__stakingBalance__" + assetId)
208+
209+
210+func keyNeutrinoStakingBalance () = ((("rpd_balance_" + baseAssetIdStr) + "_") + toString(this))
211+
212+
213+let defoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyDefoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyDefoStakingAddress))), ("address extraction error for key=" + keyDefoStakingAddress))
214+
215+let neutrinoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyNeutrinoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyNeutrinoStakingAddress))), ("address extraction error for key=" + keyNeutrinoStakingAddress))
216+
217+func getThisDefoStakingBalance () = valueOrElse(getInteger(defoStakingAcc, keyDefoStakingAssetBalance(defoAssetIdStr)), 0)
218+
219+
220+func getThisNeutrinoStakingBalance () = valueOrElse(getInteger(neutrinoStakingAcc, keyNeutrinoStakingBalance()), 0)
221+
222+
223+let ucollateral = valueOrElse(getInteger(this, keyUcollateral()), 0)
224+
225+let accumulatedFee = valueOrElse(getInteger(this, keyAccumulatedFee()), 0)
226+
227+let currPoolAmount = getIntegerValue(factoryAcc, keyFactoryAssetCurrentPool(this))
228+
229+let debtAssetId = fromBase58String(factoryReadDebtAssetId())
230+
231+let debtAssetEtalonBalance = getIntegerValue(factoryAcc, keyFactoryDebtAssetEtalonBalance())
232+
233+let lendedOrDebtAmount = (debtAssetEtalonBalance - assetBalance(this, debtAssetId))
234+
235+let currentBaseAssetBalance = ((assetBalance(this, baseAssetId) + getThisNeutrinoStakingBalance()) + lendedOrDebtAmount)
236+
237+let controlPrice = controlAccReadPrice(thisCfgArray[IdxDefoAssetCode])
238+
239+let emission = (value(assetInfo(defoAssetId)).quantity - assetBalance(this, defoAssetId))
240+
241+func getBuyPrice (changeCoeff) = if (isMarketOpened)
242+    then controlPrice
243+    else fraction((priceDecimals - changeCoeff), controlPrice, priceDecimals)
244+
245+
246+func getSellPrice (changeCoeff) = if (isMarketOpened)
247+    then controlPrice
248+    else fraction((priceDecimals + changeCoeff), controlPrice, priceDecimals)
249+
250+
251+func getSellPriceFrom (fromPrice,changeCoeff) = if (isMarketOpened)
252+    then fromPrice
253+    else fraction((priceDecimals + changeCoeff), fromPrice, priceDecimals)
254+
255+
256+func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,feePercent) = {
257+    let defoAssetAmountGross = fraction(sellAmt, buy2sellPrice, priceDecimals)
258+    let defoAssetAmount = fraction((priceDecimals - feePercent), defoAssetAmountGross, priceDecimals)
259+    let feeAmount = (defoAssetAmountGross - defoAssetAmount)
260+    let requiredBasicAssetAmount = fraction(defoAssetAmountGross, priceDecimals, buy2sellPrice)
261+    let change = (sellAmt - requiredBasicAssetAmount)
262+    if (if ((minSellAmt > sellAmt))
263+        then (toString(sellerAddr) != toString(defoStakingAcc))
264+        else false)
265+        then throw(((((("impossible to issue new " + defoAssetCode) + ": payment=") + toString(sellAmt)) + "is less then min amount=") + toString(minSellAmt)))
266+        else $Tuple2([IntegerEntry(keyUcollateral(), (ucollateral + requiredBasicAssetAmount)), StringEntry(keyAccountOperation(height, toString(sellerAddr), "FINISHED"), assetDataSwapOperation(sellAmt, toBase58String(sellAssetId), controlPrice, 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)
267+    }
268+
269+
270+@Callable(i)
271+func buyAsset () = {
272+    let pmt = value(i.payments[0])
273+    let pmtAssetId = value(pmt.assetId)
274+    if (isBlocked)
275+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
276+        else if (isBlockedByLastHeight)
277+            then throw(((("last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)))
278+            else if ((pmtAssetId != baseAssetId))
279+                then throw(((("Payment asset id doesn't match basic asset: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(pmtAssetId)))
280+                else internalBuyAsset(i.caller, pmt.amount, pmtAssetId, minBasicBuyAmount, getBuyPrice(weekendsPriceChangeCoefficient), buyFeePercent)._1
281+    }
282+
283+
284+
285+@Callable(i)
286+func sellAsset () = {
287+    let pmt = value(i.payments[0])
288+    let pmtAsset = value(pmt.assetId)
289+    let callerAddress = toString(i.caller)
290+    let sellPrice = getSellPrice(weekendsPriceChangeCoefficient)
291+    if (isBlocked)
292+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
293+        else if (isBlockedByLastHeight)
294+            then throw(((("last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)))
295+            else if ((pmtAsset != defoAssetId))
296+                then throw(((("Invalid payment asset id: expected=" + toBase58String(defoAssetId)) + " actual=") + toBase58String(pmtAsset)))
297+                else if ((minSynthSellAmount > pmt.amount))
298+                    then throw(((("Payment amount less then mininimal allowed: paymentAmount=" + toString(pmt.amount)) + " minAmount=") + toString(minSynthSellAmount)))
299+                    else {
300+                        let baseAssetAmountNoBalanceLimit = fraction(pmt.amount, priceDecimals, sellPrice)
301+                        let baseAssetAmountAvailable = if ((baseAssetAmountNoBalanceLimit > currentBaseAssetBalance))
302+                            then currentBaseAssetBalance
303+                            else baseAssetAmountNoBalanceLimit
304+                        let soldDefoAssetAmountGross = fraction(baseAssetAmountAvailable, sellPrice, priceDecimals)
305+                        let change = (pmt.amount - soldDefoAssetAmountGross)
306+                        let defoAmountFee = fraction(sellFeePercent, soldDefoAssetAmountGross, priceDecimals)
307+                        let soldDefoAssetAmount = (soldDefoAssetAmountGross - defoAmountFee)
308+                        let baseAssetAmountToSend = fraction(soldDefoAssetAmount, priceDecimals, sellPrice)
309+[IntegerEntry(keyUcollateral(), (ucollateral - baseAssetAmountToSend)), StringEntry(keyAccountOperation(height, callerAddress, "FINISHED"), assetDataSwapOperation(pmt.amount, toBase58String(pmtAsset), sellPrice, 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))]
310+                        }
311+    }
312+
313+
314+
315+@Callable(i)
316+func crossExchange (buyAssetCodeConfirm,sellAssetCodeConfirm) = {
317+    let pmt = value(i.payments[0])
318+    let pmtAsset = value(pmt.assetId)
319+    let pmtAssetStr = toBase58String(pmtAsset)
320+    let pmtAmount = pmt.amount
321+    let callerAddress = toString(i.caller)
322+    let buyAssetCfg = thisCfgArray
323+    let sellAssetTuple = factoryReadAssetCfgByCode(sellAssetCodeConfirm)
324+    let sellAssetCfg = sellAssetTuple._2
325+    let sellAssetAccAddress = valueOrErrorMessage(addressFromString(sellAssetTuple._1), ("couldn't parse address from string for assetCode=" + sellAssetCodeConfirm))
326+    let minSellPmt = valueOrErrorMessage(parseInt(sellAssetCfg[IdxMinSellPayment]), ("minSellPmt parsing error: rawVal=" + sellAssetCfg[IdxMinSellPayment]))
327+    let sellPriceLastHeight = controlAccReadLastHeight(sellAssetCodeConfirm)
328+    let isSellBlockedByLastHeight = ((sellPriceLastHeight - sellPriceLastHeight) > 5)
329+    if (isBlocked)
330+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
331+        else if ((thisCfgArray[IdxDefoAssetCode] != buyAssetCodeConfirm))
332+            then throw(((("buyAsset confirmation failed: buyAssetIdConfirm=" + thisCfgArray[IdxDefoAssetCode]) + " BUT buyAssetId=") + buyAssetCodeConfirm))
333+            else if ((sellAssetCfg[IdxDefoAssetId] != pmtAssetStr))
334+                then throw(((("sellAsset confirmation failed: sellAssetIdConfirm=" + sellAssetCfg[IdxDefoAssetId]) + "BUT pmtAsset=") + pmtAssetStr))
335+                else if ((thisCfgArray[IdxDefoAssetStatus] != "ISSUED"))
336+                    then throw(((("toAsset has not been issued yet: buyAssetId=" + buyAssetCodeConfirm) + " BUT status=") + thisCfgArray[IdxDefoAssetStatus]))
337+                    else if ((sellAssetCfg[IdxDefoAssetStatus] != "ISSUED"))
338+                        then throw(((("fromAssetCfg has not been issued yet: sellAssetId=" + pmtAssetStr) + " BUT status=") + sellAssetCfg[IdxDefoAssetStatus]))
339+                        else if (isBlockedByLastHeight)
340+                            then throw(((((("buy last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)) + " buyCode=") + buyAssetCodeConfirm))
341+                            else if (isSellBlockedByLastHeight)
342+                                then throw(((((("sell last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)) + " sellCode=") + sellAssetCodeConfirm))
343+                                else {
344+                                    let buyAssetUsdPrice = getBuyPrice((weekendsPriceChangeCoefficient / 2))
345+                                    let sellAssetUsdPrice = getSellPriceFrom(controlAccReadPrice(sellAssetCodeConfirm), (weekendsPriceChangeCoefficient / 2))
346+                                    let buy2sellPrice = fraction(buyAssetUsdPrice, priceDecimals, sellAssetUsdPrice)
347+                                    let usdnDebt = fraction(pmtAmount, priceDecimals, sellAssetUsdPrice)
348+                                    let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
349+                                    let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(sellAssetCodeConfirm)
350+                                    let lendedAmtByAssetCode = valueOrElse(getInteger(this, lendedAmountByAssetCodeKey), 0)
351+                                    let sellAssetSellFeePercent = parseIntValue(sellAssetCfg[IdxSellFeePercent])
352+                                    let buyAssetResult = internalBuyAsset(i.caller, pmtAmount, pmtAsset, minSellPmt, buy2sellPrice, fraction((buyFeePercent + sellAssetSellFeePercent), 50, 100))
353+                                    ((((buyAssetResult._1 :+ ScriptTransfer(sellAssetAccAddress, usdnDebt, debtAssetId)) :+ ScriptTransfer(sellAssetAccAddress, (pmtAmount - buyAssetResult._2), pmtAsset)) :+ IntegerEntry(lendedAmountByAssetCodeKey, (lendedAmtByAssetCode + usdnDebt))) :+ IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs + usdnDebt)))
354+                                    }
355+    }
356+
357+
358+
359+@Callable(i)
360+func rebalanceDebts () = {
361+    let debtPmt0 = value(i.payments[0])
362+    let debtPmtAsset0 = value(debtPmt0.assetId)
363+    let basePmt1 = value(i.payments[1])
364+    let basePmtAsset1 = value(basePmt1.assetId)
365+    let debtorAddress = toString(i.caller)
366+    let debtorAssetCfg = factoryReadAssetCfgByAddress(debtorAddress)
367+    let debtorAssetCode = debtorAssetCfg[IdxDefoAssetCode]
368+    let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(debtorAssetCode)
369+    let lendedAmt = valueOrErrorMessage(getInteger(this, lendedAmountByAssetCodeKey), ("No debts for " + debtorAssetCode))
370+    if (isBlocked)
371+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
372+        else if ((debtAssetId != debtPmtAsset0))
373+            then throw(((("invalid debt asset id in the first paymet: expected=" + toBase58String(debtAssetId)) + " actual=") + toBase58String(debtPmtAsset0)))
374+            else if ((baseAssetId != basePmtAsset1))
375+                then throw(((("invalid base asset id in the second payment: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(basePmtAsset1)))
376+                else if ((debtPmt0.amount != basePmt1.amount))
377+                    then throw("first payment amount doesn't match to the second payment amount")
378+                    else if ((0 >= lendedAmt))
379+                        then throw(("lendedAmt is less then zero: lendedAmt=" + toString(lendedAmt)))
380+                        else if (((100 * priceDecimals) >= debtPmt0.amount))
381+                            then throw(("attached payment must be greater then 100: pmt0.amount=" + toString(debtPmt0.amount)))
382+                            else if ((debtPmt0.amount > lendedAmt))
383+                                then throw(((("attached payment is grater than required: pmtAmount=" + toString(debtPmt0.amount)) + " lendedAmt=") + toString(lendedAmt)))
384+                                else {
385+                                    let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
386+                                    let lendedAmtAfter = (lendedAmt - debtPmt0.amount)
387+[IntegerEntry(lendedAmountByAssetCodeKey, lendedAmtAfter), IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs - debtPmt0.amount)), StringEntry(("%s%s__rebalanceTrace__" + toBase58String(i.transactionId)), assetDataRebalanceTrace(debtorAssetCode, debtPmt0, basePmt1, lendedAmt, lendedAmtAfter))]
388+                                    }
389+    }
390+
391+
392+
393+@Callable(i)
394+func fulfillRedeemRequest (poolMakerAddress) = {
395+    let thisAddressStr = toString(this)
396+    let poolMakerUnlockHeightKey = keyFactoryPoolMakerUnlockHeight(thisAddressStr, poolMakerAddress)
397+    let poolMakerUnlockHeight = valueOrElse(getInteger(factoryAcc, poolMakerUnlockHeightKey), 0)
398+    if ((0 >= poolMakerUnlockHeight))
399+        then throw("All liquidity request fulfilled")
400+        else {
401+            let poolMakerLiquidityRequestKey = keyFactoryPoolMakerLiquidityRequest(thisAddressStr, poolMakerAddress, poolMakerUnlockHeight)
402+            let poolMakerLiquidityRequestAmount = valueOrErrorMessage(getInteger(factoryAcc, poolMakerLiquidityRequestKey), "Empty poolMakerLiquidityRequestKey at factory acc")
403+            if (isDefined(getInteger(this, poolMakerLiquidityRequestKey)))
404+                then throw("Liquidity request has been already fulfilled")
405+                else [IntegerEntry(poolMakerLiquidityRequestKey, poolMakerLiquidityRequestAmount), ScriptTransfer(factoryAcc, poolMakerLiquidityRequestAmount, baseAssetId)]
406+            }
407+    }
408+
409+
410+@Verifier(tx)
411+func verify () = match tx {
412+    case inv: InvokeScriptTransaction => 
413+        if ((inv.fee > (900 * 1000)))
414+            then throw(("fee amount is greater than max allowed: " + toString(inv.fee)))
415+            else if (isDefined(inv.feeAssetId))
416+                then throw("only Waves is allowed as feeAssetId")
417+                else if ((inv.function == "rebalanceDebts"))
418+                    then {
419+                        let invDappAddress = toString(addressFromRecipient(inv.dApp))
420+                        if ((factoryReadAssetCfgByAddress(invDappAddress)[IdxDefoAssetStatus] != "ISSUED"))
421+                            then throw("only defo dapp is allowed")
422+                            else if ((invDappAddress == toString(this)))
423+                                then throw("impossible to call self rebealnceDebt")
424+                                else true
425+                        }
426+                    else if (if (if ((inv.function == "lockNeutrino"))
427+                        then true
428+                        else (inv.function == "lockNeutrinoSP"))
429+                        then true
430+                        else (inv.function == "unlockNeutrino"))
431+                        then if ((toString(neutrinoStakingAcc) != toString(addressFromRecipient(inv.dApp))))
432+                            then throw("invalid neutrino staking dapp address")
433+                            else sigVerify(tx.bodyBytes, tx.proofs[0], factoryReadDefoStakingPacemakerPub())
434+                        else throw("Not allowed invocation method calls")
435+    case _ => 
436+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
437+}
438+
github/deemru/w8io/3ef1775 
44.59 ms ◑