tx · 6AgQxz86eVmHBwqZZLnHe8YBZrhRsykRwoN2hbmwhQt7

3P7Uf5GF5feqnG39dTBEMqhGJzEq3T7MPUW:  -0.01400000 Waves

2020.12.09 19:53 [2365098] smart account 3P7Uf5GF5feqnG39dTBEMqhGJzEq3T7MPUW > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6AgQxz86eVmHBwqZZLnHe8YBZrhRsykRwoN2hbmwhQt7",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1607532847431,
    "version": 1,
    "sender": "3P7Uf5GF5feqnG39dTBEMqhGJzEq3T7MPUW",
    "senderPublicKey": "EpUMhYKYeQHgj4vTF27Kc9KkTbuhwgjV6xaP6Ce31JPz",
    "proofs": [
        "ipg5hBQPYmNZxj9uYoKSEUReLPWnG4gDCaBdETm5aNiZEA67amyaxUYcVW2rHWpKzrASFdYu4PyMqvfcFGetGnR"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2365098,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 7EvgUZ7kooQFXgxUj7UmDVSwnwamhnC3RVoVinv2J9B8
Next: 853diKDn6fQw8KeCMSiN8XPKo8RtzGy45aUj9oidQeDo

Diff: 

OldNewDifferences
133133 
134134 let IdxWeekendsPriceChangeCoefficient = 16
135135 
136+let IdxAssetAccountPublicStr = 17
137+
138+let IdxAssetStakingReferralPublicStr = 18
139+
140+let IdxCrossExchangeCoefficient = 19
141+
142+let IdxStakingMinAmtFromSellCoefficient = 20
143+
144+let IdxPoolStabilityFeePart = 21
145+
136146 let thisCfgArray = factoryReadAssetCfgByAddress(toString(this))
137147 
138148 let defoAssetCode = thisCfgArray[IdxDefoAssetCode]
164174 let sellFeePercent = parseIntValue(thisCfgArray[IdxSellFeePercent])
165175 
166176 let weekendsPriceChangeCoefficient = parseIntValue(thisCfgArray[IdxWeekendsPriceChangeCoefficient])
177+
178+let assetAccountPublicStr = thisCfgArray[IdxAssetAccountPublicStr]
179+
180+let assetStakingReferralPublicStr = thisCfgArray[IdxAssetStakingReferralPublicStr]
181+
182+let crossExchangeCoefficient = parseIntValue(thisCfgArray[IdxCrossExchangeCoefficient])
183+
184+let stakingMinAmtFromSellCoefficient = parseIntValue(thisCfgArray[IdxStakingMinAmtFromSellCoefficient])
185+
186+let poolStabilityFeePart = parseIntValue(thisCfgArray[IdxPoolStabilityFeePart])
167187 
168188 func keyIsBlocked () = "%s__isBlocked"
169189 
243263     else fraction((priceDecimals - changeCoeff), controlPrice, priceDecimals)
244264 
245265 
266+func getBuyFeeConsideringStakingReferral (callerPub58Str) = if ((assetStakingReferralPublicStr == callerPub58Str))
267+    then 0
268+    else buyFeePercent
269+
270+
271+func getBuyPriceConsideringStakingReferral (changeCoeff,callerPub58Str) = if ((assetStakingReferralPublicStr == callerPub58Str))
272+    then controlPrice
273+    else getBuyPrice(changeCoeff)
274+
275+
246276 func getSellPrice (changeCoeff) = if (isMarketOpened)
247277     then controlPrice
248278     else fraction((priceDecimals + changeCoeff), controlPrice, priceDecimals)
253283     else fraction((priceDecimals + changeCoeff), fromPrice, priceDecimals)
254284 
255285 
256-func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,feePercent) = {
286+func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,poolMakersFeePart) = {
257287     let defoAssetAmountGross = fraction(sellAmt, buy2sellPrice, priceDecimals)
258-    let defoAssetAmount = fraction((priceDecimals - feePercent), defoAssetAmountGross, priceDecimals)
259-    let feeAmount = (defoAssetAmountGross - defoAssetAmount)
288+    let stabilityFeeDefoAmount = fraction(poolStabilityFeePart, defoAssetAmountGross, priceDecimals)
289+    let poolMakersFeeDefoAmount = fraction(poolMakersFeePart, defoAssetAmountGross, priceDecimals)
290+    let defoAssetAmount = ((defoAssetAmountGross - stabilityFeeDefoAmount) - poolMakersFeeDefoAmount)
260291     let requiredBasicAssetAmount = fraction(defoAssetAmountGross, priceDecimals, buy2sellPrice)
261292     let change = (sellAmt - requiredBasicAssetAmount)
262293     if (if ((minSellAmt > sellAmt))
263294         then (toString(sellerAddr) != toString(defoStakingAcc))
264295         else false)
265296         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)
297+        else $Tuple2([IntegerEntry(keyUcollateral(), (ucollateral + requiredBasicAssetAmount)), StringEntry(keyAccountOperation(height, toString(sellerAddr), "FINISHED"), assetDataSwapOperation(sellAmt, toBase58String(sellAssetId), controlPrice, defoAssetAmount, toBase58String(defoAssetId), defoAssetAmountGross, poolMakersFeeDefoAmount)), Reissue(defoAssetId, (defoAssetAmount + poolMakersFeeDefoAmount), true), ScriptTransfer(sellerAddr, defoAssetAmount, defoAssetId), ScriptTransfer(sellerAddr, change, sellAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), poolMakersFeeDefoAmount, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + poolMakersFeeDefoAmount))], change)
267298     }
268299 
269300 
271302 func buyAsset () = {
272303     let pmt = value(i.payments[0])
273304     let pmtAssetId = value(pmt.assetId)
305+    let callerPub58Str = toBase58String(i.callerPublicKey)
274306     if (isBlocked)
275307         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
276308         else if (isBlockedByLastHeight)
277309             then throw(((("last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)))
278310             else if ((pmtAssetId != baseAssetId))
279311                 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
312+                else internalBuyAsset(i.caller, pmt.amount, pmtAssetId, minBasicBuyAmount, getBuyPriceConsideringStakingReferral(weekendsPriceChangeCoefficient, callerPub58Str), getBuyFeeConsideringStakingReferral(callerPub58Str))._1
281313     }
282314 
283315 
303335                             else baseAssetAmountNoBalanceLimit
304336                         let soldDefoAssetAmountGross = fraction(baseAssetAmountAvailable, sellPrice, priceDecimals)
305337                         let change = (pmt.amount - soldDefoAssetAmountGross)
306-                        let defoAmountFee = fraction(sellFeePercent, soldDefoAssetAmountGross, priceDecimals)
307-                        let soldDefoAssetAmount = (soldDefoAssetAmountGross - defoAmountFee)
338+                        let stabilityFeeDefoAmount = fraction(poolStabilityFeePart, soldDefoAssetAmountGross, priceDecimals)
339+                        let poolMakersFeeDefoAmount = fraction(sellFeePercent, soldDefoAssetAmountGross, priceDecimals)
340+                        let soldDefoAssetAmount = ((soldDefoAssetAmountGross - stabilityFeeDefoAmount) - poolMakersFeeDefoAmount)
308341                         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))]
342+[IntegerEntry(keyUcollateral(), (ucollateral - baseAssetAmountToSend)), StringEntry(keyAccountOperation(height, callerAddress, "FINISHED"), assetDataSwapOperation(pmt.amount, toBase58String(pmtAsset), sellPrice, baseAssetAmountToSend, baseAssetIdStr, soldDefoAssetAmountGross, poolMakersFeeDefoAmount)), Burn(defoAssetId, (soldDefoAssetAmount + stabilityFeeDefoAmount)), ScriptTransfer(i.caller, baseAssetAmountToSend, baseAssetId), ScriptTransfer(i.caller, change, defoAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), poolMakersFeeDefoAmount, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + poolMakersFeeDefoAmount))]
310343                         }
311344     }
312345 
349382                                     let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(sellAssetCodeConfirm)
350383                                     let lendedAmtByAssetCode = valueOrElse(getInteger(this, lendedAmountByAssetCodeKey), 0)
351384                                     let sellAssetSellFeePercent = parseIntValue(sellAssetCfg[IdxSellFeePercent])
352-                                    let buyAssetResult = internalBuyAsset(i.caller, pmtAmount, pmtAsset, minSellPmt, buy2sellPrice, fraction((buyFeePercent + sellAssetSellFeePercent), 50, 100))
385+                                    let crossFeePercent = fraction((buyFeePercent + sellAssetSellFeePercent), crossExchangeCoefficient, priceDecimals)
386+                                    let buyAssetResult = internalBuyAsset(i.caller, pmtAmount, pmtAsset, minSellPmt, buy2sellPrice, crossFeePercent)
353387                                     ((((buyAssetResult._1 :+ ScriptTransfer(sellAssetAccAddress, usdnDebt, debtAssetId)) :+ ScriptTransfer(sellAssetAccAddress, (pmtAmount - buyAssetResult._2), pmtAsset)) :+ IntegerEntry(lendedAmountByAssetCodeKey, (lendedAmtByAssetCode + usdnDebt))) :+ IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs + usdnDebt)))
354388                                     }
355389     }

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 4 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 func keyAccumulatedFee () = "%s__accumulatedFee"
55 
66 
77 func keyUcollateral () = "%s__ucollateral"
88 
99 
1010 func keyTotalLendedAtOtherAccs () = "%s__totalLendedAtOtherAccs"
1111 
1212 
1313 func keyAssetLockedTotal (assetId) = ("%s%s__assetLockedTotal__" + assetId)
1414 
1515 
1616 func keyAccountOperation (unlockHeight,address,status) = ((((("%s%s%d%s__defoAssetOperation__" + address) + "__") + toString(unlockHeight)) + "__") + status)
1717 
1818 
1919 func keyFactory () = "%s__factory"
2020 
2121 
2222 func keyLendedAmountByAssetCode (assetCode) = ("%s%s__lendedBaseAssetAmount__" + assetCode)
2323 
2424 
2525 func keyPrice (assetCode) = ("%s%s__price__" + assetCode)
2626 
2727 
2828 func keyControlLastHeight (assetCode) = ("%s%s__lastHeight__" + assetCode)
2929 
3030 
3131 let IdxOperationAmountIn = 1
3232 
3333 let IdxOperationAssetIn = 2
3434 
3535 let IdxOperationPrice = 3
3636 
3737 let IdxOperationAmountOut = 4
3838 
3939 let IdxOperationAssetOut = 5
4040 
4141 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)], "__")
4242 
4343 
4444 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)], "__")
4545 
4646 
4747 func assetReadSwapDataArrayOrFail (accOperationKey) = {
4848     let accOperationDataStr = valueOrErrorMessage(getString(this, accOperationKey), ("There is no request for passed arguments: " + accOperationKey))
4949     split(accOperationDataStr, "__")
5050     }
5151 
5252 
5353 let nullInt = -1
5454 
5555 let nullStr = "NULL"
5656 
5757 let factoryAcc = addressFromStringValue(valueOrErrorMessage(getString(this, keyFactory()), ((("No config at this=" + toString(this)) + " for key=") + keyFactory())))
5858 
5959 func keyFactoryDebtAssetId () = "%s%s__commonConfig__debtAssetId"
6060 
6161 
6262 func keyFactoryDebtAssetEtalonBalance () = "%s%s__commonConfig__debtAssetEtalonBalance"
6363 
6464 
6565 func keyFactoryAssetCfg (assetAddressStr) = (("%s%s%s__defoAsset__" + assetAddressStr) + "__config")
6666 
6767 
6868 func keyFactoryAssetCurrentPool (assetAccAddress) = (("%s%s%s__defoAsset__" + toString(assetAccAddress)) + "__currentPool")
6969 
7070 
7171 func keyFactoryDefoAddressByAssetCode (assetCode) = (("%s%s%s__defoAsset__" + assetCode) + "__addressByAssetCode")
7272 
7373 
7474 func keyFactoryAssetPoolMakers (assetAddress) = (("%s%s%s__defoAsset__" + assetAddress) + "__poolMakers")
7575 
7676 
7777 func keyFactoryDefoStakingPacemakerPub () = "%s%s__commonConfig__defoStakingPacemakerPub"
7878 
7979 
8080 func keyFactoryPoolMakerLiquidityRequest (assetAddress,poolMakerAddress,h) = makeString(["%s%s%s%d%s__pool", assetAddress, poolMakerAddress, toString(h), "liquidityRequest"], "__")
8181 
8282 
8383 func keyFactoryPoolMakerUnlockHeight (assetAddress,poolMakerAddress) = makeString(["%s%s%s%s__pool", assetAddress, poolMakerAddress, "unlockHeight"], "__")
8484 
8585 
8686 func factoryReadDebtAssetId () = valueOrErrorMessage(getString(factoryAcc, keyFactoryDebtAssetId()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDebtAssetId()))
8787 
8888 
8989 func factoryReadAssetCfgByAddress (assetAddressStr) = split(valueOrErrorMessage(getString(factoryAcc, keyFactoryAssetCfg(assetAddressStr)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryAssetCfg(assetAddressStr))), "__")
9090 
9191 
9292 func factoryReadAssetCfgByCode (assetCode) = {
9393     let assetAddressStr = valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoAddressByAssetCode(assetCode)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoAddressByAssetCode(assetCode)))
9494     $Tuple2(assetAddressStr, factoryReadAssetCfgByAddress(assetAddressStr))
9595     }
9696 
9797 
9898 func factoryReadNextPoolMakerToDistributeFee (assetAddressStr) = addressFromStringValue("3PEs19bv4qT4Gz5idjcWynkQyrH9psGipmw")
9999 
100100 
101101 func factoryReadDefoStakingPacemakerPub () = fromBase58String(valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoStakingPacemakerPub()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoStakingPacemakerPub())))
102102 
103103 
104104 let IdxDefoAssetCode = 1
105105 
106106 let IdxDefoAssetId = 2
107107 
108108 let IdxDefoAssetStatus = 3
109109 
110110 let IdxPriceDecimals = 4
111111 
112112 let IdxBaseAssetId = 5
113113 
114114 let IdxOverCollateralPercent = 6
115115 
116116 let IdxMinInitPool = 7
117117 
118118 let IdxPriceOracleAddress = 8
119119 
120120 let IdxMinBuyPayment = 9
121121 
122122 let IdxMinSellPayment = 10
123123 
124124 let IdxBuyLockInterval = 11
125125 
126126 let IdxSellLockInterval = 12
127127 
128128 let IdxBuyFeePercent = 13
129129 
130130 let IdxSellFeePercent = 14
131131 
132132 let IdxPoolRedemptionTimeout = 15
133133 
134134 let IdxWeekendsPriceChangeCoefficient = 16
135135 
136+let IdxAssetAccountPublicStr = 17
137+
138+let IdxAssetStakingReferralPublicStr = 18
139+
140+let IdxCrossExchangeCoefficient = 19
141+
142+let IdxStakingMinAmtFromSellCoefficient = 20
143+
144+let IdxPoolStabilityFeePart = 21
145+
136146 let thisCfgArray = factoryReadAssetCfgByAddress(toString(this))
137147 
138148 let defoAssetCode = thisCfgArray[IdxDefoAssetCode]
139149 
140150 let defoAssetIdStr = thisCfgArray[IdxDefoAssetId]
141151 
142152 let defoAssetId = fromBase58String(defoAssetIdStr)
143153 
144154 let priceOracleAcc = addressFromStringValue(thisCfgArray[IdxPriceOracleAddress])
145155 
146156 let overCollateralPercent = parseIntValue(thisCfgArray[IdxOverCollateralPercent])
147157 
148158 let baseAssetIdStr = thisCfgArray[IdxBaseAssetId]
149159 
150160 let baseAssetId = fromBase58String(baseAssetIdStr)
151161 
152162 let priceDecimals = parseIntValue(thisCfgArray[IdxPriceDecimals])
153163 
154164 let minBasicBuyAmount = parseIntValue(thisCfgArray[IdxMinBuyPayment])
155165 
156166 let minSynthSellAmount = parseIntValue(thisCfgArray[IdxMinSellPayment])
157167 
158168 let buyLockInterval = parseIntValue(thisCfgArray[IdxBuyLockInterval])
159169 
160170 let sellLockInterval = parseIntValue(thisCfgArray[IdxSellLockInterval])
161171 
162172 let buyFeePercent = parseIntValue(thisCfgArray[IdxBuyFeePercent])
163173 
164174 let sellFeePercent = parseIntValue(thisCfgArray[IdxSellFeePercent])
165175 
166176 let weekendsPriceChangeCoefficient = parseIntValue(thisCfgArray[IdxWeekendsPriceChangeCoefficient])
177+
178+let assetAccountPublicStr = thisCfgArray[IdxAssetAccountPublicStr]
179+
180+let assetStakingReferralPublicStr = thisCfgArray[IdxAssetStakingReferralPublicStr]
181+
182+let crossExchangeCoefficient = parseIntValue(thisCfgArray[IdxCrossExchangeCoefficient])
183+
184+let stakingMinAmtFromSellCoefficient = parseIntValue(thisCfgArray[IdxStakingMinAmtFromSellCoefficient])
185+
186+let poolStabilityFeePart = parseIntValue(thisCfgArray[IdxPoolStabilityFeePart])
167187 
168188 func keyIsBlocked () = "%s__isBlocked"
169189 
170190 
171191 func keyIsMarketOpened (assetCode) = ("%s%s__isMarketOpened__" + assetCode)
172192 
173193 
174194 let isBlocked = valueOrElse(getBoolean(priceOracleAcc, keyIsBlocked()), false)
175195 
176196 let isMarketOpened = valueOrElse(getBoolean(priceOracleAcc, keyIsMarketOpened(defoAssetCode)), false)
177197 
178198 func controlAccReadPrice (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyPrice(assetCode)), ((("No price at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyPrice(assetCode)))
179199 
180200 
181201 func controlAccReadLastHeight (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyControlLastHeight(assetCode)), ((("No lastHeight at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyControlLastHeight(assetCode)))
182202 
183203 
184204 func controlAccReadCurrIdxOrFail () = valueOrErrorMessage(getInteger(priceOracleAcc, "currIdx"), ("No currIdx at controlAcc=" + toString(priceOracleAcc)))
185205 
186206 
187207 func controlAccReadIdxHeight (idx) = {
188208     let idxHeightKey = ("idxHeight_" + toString(idx))
189209     valueOrElse(getInteger(priceOracleAcc, idxHeightKey), 0)
190210     }
191211 
192212 
193213 func controlAccReadPriceByHeight (priceHeight) = {
194214     let priceByHeightKey = ("price_" + toString(priceHeight))
195215     valueOrErrorMessage(getInteger(priceOracleAcc, priceByHeightKey), ((("No " + priceByHeightKey) + " at controlAcc=") + toString(priceOracleAcc)))
196216     }
197217 
198218 
199219 let priceLastHeight = controlAccReadLastHeight(defoAssetCode)
200220 
201221 let isBlockedByLastHeight = ((height - priceLastHeight) > 5)
202222 
203223 let keyDefoStakingAddress = "%s%s__commonConfig__defoStakingAddress"
204224 
205225 let keyNeutrinoStakingAddress = "%s%s__commonConfig__neutrinoStakingAddress"
206226 
207227 func keyDefoStakingAssetBalance (assetId) = ("%s%s__stakingBalance__" + assetId)
208228 
209229 
210230 func keyNeutrinoStakingBalance () = ((("rpd_balance_" + baseAssetIdStr) + "_") + toString(this))
211231 
212232 
213233 let defoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyDefoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyDefoStakingAddress))), ("address extraction error for key=" + keyDefoStakingAddress))
214234 
215235 let neutrinoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyNeutrinoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyNeutrinoStakingAddress))), ("address extraction error for key=" + keyNeutrinoStakingAddress))
216236 
217237 func getThisDefoStakingBalance () = valueOrElse(getInteger(defoStakingAcc, keyDefoStakingAssetBalance(defoAssetIdStr)), 0)
218238 
219239 
220240 func getThisNeutrinoStakingBalance () = valueOrElse(getInteger(neutrinoStakingAcc, keyNeutrinoStakingBalance()), 0)
221241 
222242 
223243 let ucollateral = valueOrElse(getInteger(this, keyUcollateral()), 0)
224244 
225245 let accumulatedFee = valueOrElse(getInteger(this, keyAccumulatedFee()), 0)
226246 
227247 let currPoolAmount = getIntegerValue(factoryAcc, keyFactoryAssetCurrentPool(this))
228248 
229249 let debtAssetId = fromBase58String(factoryReadDebtAssetId())
230250 
231251 let debtAssetEtalonBalance = getIntegerValue(factoryAcc, keyFactoryDebtAssetEtalonBalance())
232252 
233253 let lendedOrDebtAmount = (debtAssetEtalonBalance - assetBalance(this, debtAssetId))
234254 
235255 let currentBaseAssetBalance = ((assetBalance(this, baseAssetId) + getThisNeutrinoStakingBalance()) + lendedOrDebtAmount)
236256 
237257 let controlPrice = controlAccReadPrice(thisCfgArray[IdxDefoAssetCode])
238258 
239259 let emission = (value(assetInfo(defoAssetId)).quantity - assetBalance(this, defoAssetId))
240260 
241261 func getBuyPrice (changeCoeff) = if (isMarketOpened)
242262     then controlPrice
243263     else fraction((priceDecimals - changeCoeff), controlPrice, priceDecimals)
244264 
245265 
266+func getBuyFeeConsideringStakingReferral (callerPub58Str) = if ((assetStakingReferralPublicStr == callerPub58Str))
267+    then 0
268+    else buyFeePercent
269+
270+
271+func getBuyPriceConsideringStakingReferral (changeCoeff,callerPub58Str) = if ((assetStakingReferralPublicStr == callerPub58Str))
272+    then controlPrice
273+    else getBuyPrice(changeCoeff)
274+
275+
246276 func getSellPrice (changeCoeff) = if (isMarketOpened)
247277     then controlPrice
248278     else fraction((priceDecimals + changeCoeff), controlPrice, priceDecimals)
249279 
250280 
251281 func getSellPriceFrom (fromPrice,changeCoeff) = if (isMarketOpened)
252282     then fromPrice
253283     else fraction((priceDecimals + changeCoeff), fromPrice, priceDecimals)
254284 
255285 
256-func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,feePercent) = {
286+func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,poolMakersFeePart) = {
257287     let defoAssetAmountGross = fraction(sellAmt, buy2sellPrice, priceDecimals)
258-    let defoAssetAmount = fraction((priceDecimals - feePercent), defoAssetAmountGross, priceDecimals)
259-    let feeAmount = (defoAssetAmountGross - defoAssetAmount)
288+    let stabilityFeeDefoAmount = fraction(poolStabilityFeePart, defoAssetAmountGross, priceDecimals)
289+    let poolMakersFeeDefoAmount = fraction(poolMakersFeePart, defoAssetAmountGross, priceDecimals)
290+    let defoAssetAmount = ((defoAssetAmountGross - stabilityFeeDefoAmount) - poolMakersFeeDefoAmount)
260291     let requiredBasicAssetAmount = fraction(defoAssetAmountGross, priceDecimals, buy2sellPrice)
261292     let change = (sellAmt - requiredBasicAssetAmount)
262293     if (if ((minSellAmt > sellAmt))
263294         then (toString(sellerAddr) != toString(defoStakingAcc))
264295         else false)
265296         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)
297+        else $Tuple2([IntegerEntry(keyUcollateral(), (ucollateral + requiredBasicAssetAmount)), StringEntry(keyAccountOperation(height, toString(sellerAddr), "FINISHED"), assetDataSwapOperation(sellAmt, toBase58String(sellAssetId), controlPrice, defoAssetAmount, toBase58String(defoAssetId), defoAssetAmountGross, poolMakersFeeDefoAmount)), Reissue(defoAssetId, (defoAssetAmount + poolMakersFeeDefoAmount), true), ScriptTransfer(sellerAddr, defoAssetAmount, defoAssetId), ScriptTransfer(sellerAddr, change, sellAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), poolMakersFeeDefoAmount, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + poolMakersFeeDefoAmount))], change)
267298     }
268299 
269300 
270301 @Callable(i)
271302 func buyAsset () = {
272303     let pmt = value(i.payments[0])
273304     let pmtAssetId = value(pmt.assetId)
305+    let callerPub58Str = toBase58String(i.callerPublicKey)
274306     if (isBlocked)
275307         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
276308         else if (isBlockedByLastHeight)
277309             then throw(((("last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)))
278310             else if ((pmtAssetId != baseAssetId))
279311                 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
312+                else internalBuyAsset(i.caller, pmt.amount, pmtAssetId, minBasicBuyAmount, getBuyPriceConsideringStakingReferral(weekendsPriceChangeCoefficient, callerPub58Str), getBuyFeeConsideringStakingReferral(callerPub58Str))._1
281313     }
282314 
283315 
284316 
285317 @Callable(i)
286318 func sellAsset () = {
287319     let pmt = value(i.payments[0])
288320     let pmtAsset = value(pmt.assetId)
289321     let callerAddress = toString(i.caller)
290322     let sellPrice = getSellPrice(weekendsPriceChangeCoefficient)
291323     if (isBlocked)
292324         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
293325         else if (isBlockedByLastHeight)
294326             then throw(((("last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)))
295327             else if ((pmtAsset != defoAssetId))
296328                 then throw(((("Invalid payment asset id: expected=" + toBase58String(defoAssetId)) + " actual=") + toBase58String(pmtAsset)))
297329                 else if ((minSynthSellAmount > pmt.amount))
298330                     then throw(((("Payment amount less then mininimal allowed: paymentAmount=" + toString(pmt.amount)) + " minAmount=") + toString(minSynthSellAmount)))
299331                     else {
300332                         let baseAssetAmountNoBalanceLimit = fraction(pmt.amount, priceDecimals, sellPrice)
301333                         let baseAssetAmountAvailable = if ((baseAssetAmountNoBalanceLimit > currentBaseAssetBalance))
302334                             then currentBaseAssetBalance
303335                             else baseAssetAmountNoBalanceLimit
304336                         let soldDefoAssetAmountGross = fraction(baseAssetAmountAvailable, sellPrice, priceDecimals)
305337                         let change = (pmt.amount - soldDefoAssetAmountGross)
306-                        let defoAmountFee = fraction(sellFeePercent, soldDefoAssetAmountGross, priceDecimals)
307-                        let soldDefoAssetAmount = (soldDefoAssetAmountGross - defoAmountFee)
338+                        let stabilityFeeDefoAmount = fraction(poolStabilityFeePart, soldDefoAssetAmountGross, priceDecimals)
339+                        let poolMakersFeeDefoAmount = fraction(sellFeePercent, soldDefoAssetAmountGross, priceDecimals)
340+                        let soldDefoAssetAmount = ((soldDefoAssetAmountGross - stabilityFeeDefoAmount) - poolMakersFeeDefoAmount)
308341                         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))]
342+[IntegerEntry(keyUcollateral(), (ucollateral - baseAssetAmountToSend)), StringEntry(keyAccountOperation(height, callerAddress, "FINISHED"), assetDataSwapOperation(pmt.amount, toBase58String(pmtAsset), sellPrice, baseAssetAmountToSend, baseAssetIdStr, soldDefoAssetAmountGross, poolMakersFeeDefoAmount)), Burn(defoAssetId, (soldDefoAssetAmount + stabilityFeeDefoAmount)), ScriptTransfer(i.caller, baseAssetAmountToSend, baseAssetId), ScriptTransfer(i.caller, change, defoAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), poolMakersFeeDefoAmount, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + poolMakersFeeDefoAmount))]
310343                         }
311344     }
312345 
313346 
314347 
315348 @Callable(i)
316349 func crossExchange (buyAssetCodeConfirm,sellAssetCodeConfirm) = {
317350     let pmt = value(i.payments[0])
318351     let pmtAsset = value(pmt.assetId)
319352     let pmtAssetStr = toBase58String(pmtAsset)
320353     let pmtAmount = pmt.amount
321354     let callerAddress = toString(i.caller)
322355     let buyAssetCfg = thisCfgArray
323356     let sellAssetTuple = factoryReadAssetCfgByCode(sellAssetCodeConfirm)
324357     let sellAssetCfg = sellAssetTuple._2
325358     let sellAssetAccAddress = valueOrErrorMessage(addressFromString(sellAssetTuple._1), ("couldn't parse address from string for assetCode=" + sellAssetCodeConfirm))
326359     let minSellPmt = valueOrErrorMessage(parseInt(sellAssetCfg[IdxMinSellPayment]), ("minSellPmt parsing error: rawVal=" + sellAssetCfg[IdxMinSellPayment]))
327360     let sellPriceLastHeight = controlAccReadLastHeight(sellAssetCodeConfirm)
328361     let isSellBlockedByLastHeight = ((height - sellPriceLastHeight) > 5)
329362     if (isBlocked)
330363         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
331364         else if ((thisCfgArray[IdxDefoAssetCode] != buyAssetCodeConfirm))
332365             then throw(((("buyAsset confirmation failed: buyAssetIdConfirm=" + thisCfgArray[IdxDefoAssetCode]) + " BUT buyAssetId=") + buyAssetCodeConfirm))
333366             else if ((sellAssetCfg[IdxDefoAssetId] != pmtAssetStr))
334367                 then throw(((("sellAsset confirmation failed: sellAssetIdConfirm=" + sellAssetCfg[IdxDefoAssetId]) + "BUT pmtAsset=") + pmtAssetStr))
335368                 else if ((thisCfgArray[IdxDefoAssetStatus] != "ISSUED"))
336369                     then throw(((("toAsset has not been issued yet: buyAssetId=" + buyAssetCodeConfirm) + " BUT status=") + thisCfgArray[IdxDefoAssetStatus]))
337370                     else if ((sellAssetCfg[IdxDefoAssetStatus] != "ISSUED"))
338371                         then throw(((("fromAssetCfg has not been issued yet: sellAssetId=" + pmtAssetStr) + " BUT status=") + sellAssetCfg[IdxDefoAssetStatus]))
339372                         else if (isBlockedByLastHeight)
340373                             then throw(((((("buy last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)) + " buyCode=") + buyAssetCodeConfirm))
341374                             else if (isSellBlockedByLastHeight)
342375                                 then throw(((((("sell last price finalization has been more then 5 blocks ago: priceLastHeight=" + toString(priceLastHeight)) + " currHeight=") + toString(height)) + " sellCode=") + sellAssetCodeConfirm))
343376                                 else {
344377                                     let buyAssetUsdPrice = getBuyPrice((weekendsPriceChangeCoefficient / 2))
345378                                     let sellAssetUsdPrice = getSellPriceFrom(controlAccReadPrice(sellAssetCodeConfirm), (weekendsPriceChangeCoefficient / 2))
346379                                     let buy2sellPrice = fraction(buyAssetUsdPrice, priceDecimals, sellAssetUsdPrice)
347380                                     let usdnDebt = fraction(pmtAmount, priceDecimals, sellAssetUsdPrice)
348381                                     let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
349382                                     let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(sellAssetCodeConfirm)
350383                                     let lendedAmtByAssetCode = valueOrElse(getInteger(this, lendedAmountByAssetCodeKey), 0)
351384                                     let sellAssetSellFeePercent = parseIntValue(sellAssetCfg[IdxSellFeePercent])
352-                                    let buyAssetResult = internalBuyAsset(i.caller, pmtAmount, pmtAsset, minSellPmt, buy2sellPrice, fraction((buyFeePercent + sellAssetSellFeePercent), 50, 100))
385+                                    let crossFeePercent = fraction((buyFeePercent + sellAssetSellFeePercent), crossExchangeCoefficient, priceDecimals)
386+                                    let buyAssetResult = internalBuyAsset(i.caller, pmtAmount, pmtAsset, minSellPmt, buy2sellPrice, crossFeePercent)
353387                                     ((((buyAssetResult._1 :+ ScriptTransfer(sellAssetAccAddress, usdnDebt, debtAssetId)) :+ ScriptTransfer(sellAssetAccAddress, (pmtAmount - buyAssetResult._2), pmtAsset)) :+ IntegerEntry(lendedAmountByAssetCodeKey, (lendedAmtByAssetCode + usdnDebt))) :+ IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs + usdnDebt)))
354388                                     }
355389     }
356390 
357391 
358392 
359393 @Callable(i)
360394 func rebalanceDebts () = {
361395     let debtPmt0 = value(i.payments[0])
362396     let debtPmtAsset0 = value(debtPmt0.assetId)
363397     let basePmt1 = value(i.payments[1])
364398     let basePmtAsset1 = value(basePmt1.assetId)
365399     let debtorAddress = toString(i.caller)
366400     let debtorAssetCfg = factoryReadAssetCfgByAddress(debtorAddress)
367401     let debtorAssetCode = debtorAssetCfg[IdxDefoAssetCode]
368402     let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(debtorAssetCode)
369403     let lendedAmt = valueOrErrorMessage(getInteger(this, lendedAmountByAssetCodeKey), ("No debts for " + debtorAssetCode))
370404     if (isBlocked)
371405         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
372406         else if ((debtAssetId != debtPmtAsset0))
373407             then throw(((("invalid debt asset id in the first paymet: expected=" + toBase58String(debtAssetId)) + " actual=") + toBase58String(debtPmtAsset0)))
374408             else if ((baseAssetId != basePmtAsset1))
375409                 then throw(((("invalid base asset id in the second payment: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(basePmtAsset1)))
376410                 else if ((debtPmt0.amount != basePmt1.amount))
377411                     then throw("first payment amount doesn't match to the second payment amount")
378412                     else if ((0 >= lendedAmt))
379413                         then throw(("lendedAmt is less then zero: lendedAmt=" + toString(lendedAmt)))
380414                         else if (((100 * priceDecimals) >= debtPmt0.amount))
381415                             then throw(("attached payment must be greater then 100: pmt0.amount=" + toString(debtPmt0.amount)))
382416                             else if ((debtPmt0.amount > lendedAmt))
383417                                 then throw(((("attached payment is grater than required: pmtAmount=" + toString(debtPmt0.amount)) + " lendedAmt=") + toString(lendedAmt)))
384418                                 else {
385419                                     let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
386420                                     let lendedAmtAfter = (lendedAmt - debtPmt0.amount)
387421 [IntegerEntry(lendedAmountByAssetCodeKey, lendedAmtAfter), IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs - debtPmt0.amount)), StringEntry(("%s%s__rebalanceTrace__" + toBase58String(i.transactionId)), assetDataRebalanceTrace(debtorAssetCode, debtPmt0, basePmt1, lendedAmt, lendedAmtAfter))]
388422                                     }
389423     }
390424 
391425 
392426 
393427 @Callable(i)
394428 func fulfillRedeemRequest (poolMakerAddress) = {
395429     let thisAddressStr = toString(this)
396430     let poolMakerUnlockHeightKey = keyFactoryPoolMakerUnlockHeight(thisAddressStr, poolMakerAddress)
397431     let poolMakerUnlockHeight = valueOrElse(getInteger(factoryAcc, poolMakerUnlockHeightKey), 0)
398432     if ((0 >= poolMakerUnlockHeight))
399433         then throw("All liquidity request fulfilled")
400434         else {
401435             let poolMakerLiquidityRequestKey = keyFactoryPoolMakerLiquidityRequest(thisAddressStr, poolMakerAddress, poolMakerUnlockHeight)
402436             let poolMakerLiquidityRequestAmount = valueOrErrorMessage(getInteger(factoryAcc, poolMakerLiquidityRequestKey), "Empty poolMakerLiquidityRequestKey at factory acc")
403437             if (isDefined(getInteger(this, poolMakerLiquidityRequestKey)))
404438                 then throw("Liquidity request has been already fulfilled")
405439                 else [IntegerEntry(poolMakerLiquidityRequestKey, poolMakerLiquidityRequestAmount), ScriptTransfer(factoryAcc, poolMakerLiquidityRequestAmount, baseAssetId)]
406440             }
407441     }
408442 
409443 
410444 @Verifier(tx)
411445 func verify () = match tx {
412446     case inv: InvokeScriptTransaction => 
413447         if ((inv.fee > (900 * 1000)))
414448             then throw(("fee amount is greater than max allowed: " + toString(inv.fee)))
415449             else if (isDefined(inv.feeAssetId))
416450                 then throw("only Waves is allowed as feeAssetId")
417451                 else if ((inv.function == "rebalanceDebts"))
418452                     then {
419453                         let invDappAddress = toString(addressFromRecipient(inv.dApp))
420454                         if ((factoryReadAssetCfgByAddress(invDappAddress)[IdxDefoAssetStatus] != "ISSUED"))
421455                             then throw("only defo dapp is allowed")
422456                             else if ((invDappAddress == toString(this)))
423457                                 then throw("impossible to call self rebealnceDebt")
424458                                 else true
425459                         }
426460                     else if (if (if ((inv.function == "lockNeutrino"))
427461                         then true
428462                         else (inv.function == "lockNeutrinoSP"))
429463                         then true
430464                         else (inv.function == "unlockNeutrino"))
431465                         then if ((toString(neutrinoStakingAcc) != toString(addressFromRecipient(inv.dApp))))
432466                             then throw("invalid neutrino staking dapp address")
433467                             else sigVerify(tx.bodyBytes, tx.proofs[0], factoryReadDefoStakingPacemakerPub())
434468                         else throw("Not allowed invocation method calls")
435469     case _ => 
436470         sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
437471 }
438472 
github/deemru/w8io/6500d08 
106.92 ms ◑