tx · Hay3mzQPKpJss4oXn6dooYCBNKEGqQUunupHSgexsAUY

3MwMR1ZFfy712trHVLisizYmvRQwsg8z9Bn:  -0.01000000 Waves

2020.03.19 19:45 [916451] smart account 3MwMR1ZFfy712trHVLisizYmvRQwsg8z9Bn > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Hay3mzQPKpJss4oXn6dooYCBNKEGqQUunupHSgexsAUY",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1584636388493,
    "version": 1,
    "sender": "3MwMR1ZFfy712trHVLisizYmvRQwsg8z9Bn",
    "senderPublicKey": "97T1f7qUWzkowGZkQrhKdK7mb6NMiCypcdgw9AJkb7Lx",
    "proofs": [
        "5xGUJSEj2FBtTRXtncpeLS8emEuXU9uVqzTcUjrA8BUAJuxhGEzDvAwVvf8z1X7VCPYUApzDB7Rx9bFcx29waoFW"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 916451,
    "spentComplexity": 0
}

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

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 3 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func getNumberByKey (key) = match getInteger(this, key) {
5+    case a: Int => 
6+        a
7+    case _ => 
8+        0
9+}
10+
11+
12+func getStringByKey (key) = match getString(this, key) {
13+    case a: String => 
14+        a
15+    case _ => 
16+        ""
17+}
18+
19+
20+func getBoolByKey (key) = match getBoolean(this, key) {
21+    case a: Boolean => 
22+        a
23+    case _ => 
24+        false
25+}
26+
27+
28+func getNumberByAddressAndKey (address,key) = match getInteger(addressFromStringValue(address), key) {
29+    case a: Int => 
30+        a
31+    case _ => 
32+        0
33+}
34+
35+
36+func getStringByAddressAndKey (address,key) = match getString(addressFromStringValue(address), key) {
37+    case a: String => 
38+        a
39+    case _ => 
40+        ""
41+}
42+
43+
44+func getBoolByAddressAndKey (address,key) = match getBoolean(addressFromStringValue(address), key) {
45+    case a: Boolean => 
46+        a
47+    case _ => 
48+        false
49+}
50+
51+
52+let SENDTXEXPIRE = 30
53+
54+let LISTSPLITSYMBOL = "_"
55+
56+let LISTDATASYMBOL = "+"
57+
58+let WAVELET = 100000000
59+
60+let PAULI = 1000000
61+
62+let DEFICITOFFSET = 5
63+
64+let NeutrinoAssetIdKey = "neutrino_asset_id"
65+
66+let BondAssetIdKey = "bond_asset_id"
67+
68+let AuctionContractKey = "auction_contract"
69+
70+let LiquidationContractKey = "liquidation_contract"
71+
72+let RPDContractKey = "rpd_contract"
73+
74+let ContolContractKey = "control_contract"
75+
76+let BalanceWavesLockIntervalKey = "balance_waves_lock_interval"
77+
78+let BalanceNeutrinoLockIntervalKey = "balance_neutrino_lock_interval"
79+
80+let MinWavesSwapAmountKey = "min_waves_swap_amount"
81+
82+let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
83+
84+let NodeOracleProviderPubKeyKey = "node_oracle_provider"
85+
86+let RPDBalanceKey = "rpd_balance"
87+
88+func getRPDContractBalanceKey (assetId) = ((RPDBalanceKey + "_") + toBase58String(assetId))
89+
90+
91+let PriceKey = "price"
92+
93+let PriceIndexKey = "price_index"
94+
95+let IsBlockedKey = "is_blocked"
96+
97+func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
98+
99+
100+func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
101+
102+
103+let BalanceLockedkKey = "balance_lock_"
104+
105+let WavesLockedBalanceKey = (BalanceLockedkKey + "waves")
106+
107+let NeutrinoLockedBalanceKey = (BalanceLockedkKey + "neutrino")
108+
109+func getRPDSnapshotContractBalanceKey (count,assetId) = ((((RPDBalanceKey + "_") + toBase58String(assetId)) + "_") + toString(count))
110+
111+
112+func getCancelLeaseTxReserveFeeKey (hash) = (("cancel_lease_tx_reserve_fee" + "_") + hash)
113+
114+
115+func getWavesLockedBalanceKey (owner) = ((WavesLockedBalanceKey + "_") + owner)
116+
117+
118+func getNeutrinoLockedBalanceKey (owner) = ((NeutrinoLockedBalanceKey + "_") + owner)
119+
120+
121+func getBalanceUnlockBlockKey (owner) = ("balance_unlock_block_" + owner)
122+
123+
124+func getRPDProfitKey (count) = (("rpd_profit" + "_") + toString(count))
125+
126+
127+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, 100, price), WAVELET, PAULI)
128+
129+
130+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, 100), PAULI, WAVELET)
131+
132+
133+func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
134+
135+
136+func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
137+
138+
139+let liquidationContract = getStringByKey(LiquidationContractKey)
140+
141+let neutrinoAssetIdString = getStringByKey(NeutrinoAssetIdKey)
142+
143+let neutrinoAssetId = fromBase58String(neutrinoAssetIdString)
144+
145+let auctionContract = getStringByKey(AuctionContractKey)
146+
147+let rpdContract = getStringByKey(RPDContractKey)
148+
149+let controlContract = getStringByKey(ContolContractKey)
150+
151+let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
152+
153+let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
154+
155+let nodeOracleProviderPubKey = fromBase58String(getStringByKey(NodeOracleProviderPubKeyKey))
156+
157+let balanceWavesLockInterval = getNumberByKey(BalanceWavesLockIntervalKey)
158+
159+let balanceNeutrinoLockInterval = getNumberByKey(BalanceNeutrinoLockIntervalKey)
160+
161+let minWavesSwapAmount = getNumberByKey(MinWavesSwapAmountKey)
162+
163+let minNeutrinoSwapAmount = getNumberByKey(MinNeutrinoSwapAmountKey)
164+
165+let bondAssetId = fromBase58String("6nSpVyNH7yM69eg446wrQR94ipbbcmZMU1ENPwanC97g")
166+
167+let deprecatedBondAssetId = fromBase58String("975akZBfnMj513U7MZaHKzQrmsEx5aE3wdWKTrHBhbjF")
168+
169+let neutrinoContract = this
170+
171+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
172+
173+let neutrinoLockedBalance = getNumberByKey(NeutrinoLockedBalanceKey)
174+
175+let wavesLockedBalance = getNumberByKey(WavesLockedBalanceKey)
176+
177+let reserve = (wavesBalance(neutrinoContract) - wavesLockedBalance)
178+
179+let neutrinoSupply = (((neutrinoLockedBalance + extract(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
180+
181+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
182+
183+let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve, currentPrice))
184+
185+func getRPDContractBalance (assetId) = getNumberByAddressAndKey(rpdContract, getRPDContractBalanceKey(assetId))
186+
187+
188+func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
189+
190+
191+func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
192+
193+
194+func getCancelLeaseTxReserveFee (hash) = getNumberByKey(getCancelLeaseTxReserveFeeKey(hash))
195+
196+
197+func getWavesLockedBalance (owner) = getNumberByKey(getWavesLockedBalanceKey(owner))
198+
199+
200+func getNeutrinoLockedBalance (owner) = getNumberByKey(getNeutrinoLockedBalanceKey(owner))
201+
202+
203+func getUnlockBalanceBlock (owner) = getNumberByKey(getBalanceUnlockBlockKey(owner))
204+
205+
206+func getRPDProfit (count) = getNumberByKey(getRPDProfitKey(count))
207+
208+
209+@Callable(i)
210+func swapWavesToNeutrino () = {
211+    let pmt = extract(i.payment)
212+    let account = toString(i.caller)
213+    if ((minWavesSwapAmount > pmt.amount))
214+        then throw((("The specified Waves amount is less than the required minimum of " + toString(minWavesSwapAmount)) + " wavelets."))
215+        else if (isDefined(pmt.assetId))
216+            then throw("Only Waves token is allowed for swapping.")
217+            else if (isBlocked)
218+                then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
219+                else if ((getUnlockBalanceBlock(account) > height))
220+                    then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
221+                    else if (if ((getNeutrinoLockedBalance(account) != 0))
222+                        then true
223+                        else (getWavesLockedBalance(account) != 0))
224+                        then throw("please withdraw locked funds first")
225+                        else WriteSet([DataEntry(getWavesLockedBalanceKey(account), pmt.amount), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceWavesLockInterval)), DataEntry(WavesLockedBalanceKey, (wavesLockedBalance + pmt.amount))])
226+    }
227+
228+
229+
230+@Callable(i)
231+func swapNeutrinoToWaves () = {
232+    let pmt = extract(i.payment)
233+    let account = toString(i.caller)
234+    if ((minNeutrinoSwapAmount > pmt.amount))
235+        then throw((("The specified Neutrino amount is less than the required minimum of " + toString(minNeutrinoSwapAmount)) + " Neutrino cents."))
236+        else if (isBlocked)
237+            then throw("The contract is blocked by EMERGENCY SHUTDOWN. Please wait for reactivation by emergency oracles.")
238+            else if ((pmt.assetId != neutrinoAssetId))
239+                then throw("Only appropriate Neutrino tokens are allowed for swapping.")
240+                else if ((getUnlockBalanceBlock(account) > height))
241+                    then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
242+                    else if (if ((getNeutrinoLockedBalance(account) != 0))
243+                        then true
244+                        else (getWavesLockedBalance(account) != 0))
245+                        then throw("please withdraw locked funds first")
246+                        else WriteSet([DataEntry(getNeutrinoLockedBalanceKey(account), pmt.amount), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceNeutrinoLockInterval)), DataEntry(NeutrinoLockedBalanceKey, (neutrinoLockedBalance + pmt.amount))])
247+    }
248+
249+
250+
251+@Callable(i)
252+func withdraw (account,index) = {
253+    let unlockHeight = getUnlockBalanceBlock(account)
254+    let userWavesLockedBalance = getWavesLockedBalance(account)
255+    let userNeutrinoLockedBalance = getNeutrinoLockedBalance(account)
256+    let indexHeight = getHeightPriceByIndex(index)
257+    let prevIndexHeight = getHeightPriceByIndex((index - 1))
258+    let priceByIndex = getPriceHistory(indexHeight)
259+    let neutrinoAmount = convertWavesToNeutrino(userWavesLockedBalance, priceByIndex)
260+    let wavesAmount = convertNeutrinoToWaves(userNeutrinoLockedBalance, priceByIndex)
261+    if (isBlocked)
262+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
263+        else if ((unlockHeight > height))
264+            then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw WAVES funds"))
265+            else if (if (if ((index > priceIndex))
266+                then true
267+                else (unlockHeight > indexHeight))
268+                then true
269+                else if ((prevIndexHeight != 0))
270+                    then (prevIndexHeight >= unlockHeight)
271+                    else false)
272+                then throw(((((((((("invalid price history index: index=" + toString(index)) + " priceIndex=") + toString(priceIndex)) + " indexHeight=") + toString(indexHeight)) + " unlockHeight=") + toString(unlockHeight)) + " prevIndexHeight=") + toString(prevIndexHeight)))
273+                else if (if ((0 >= neutrinoAmount))
274+                    then (0 >= wavesAmount)
275+                    else false)
276+                    then throw("balance equals zero")
277+                    else ScriptResult(WriteSet([DataEntry(getWavesLockedBalanceKey(account), 0), DataEntry(getNeutrinoLockedBalanceKey(account), 0), DataEntry(WavesLockedBalanceKey, (wavesLockedBalance - userWavesLockedBalance)), DataEntry(NeutrinoLockedBalanceKey, (neutrinoLockedBalance - userNeutrinoLockedBalance))]), TransferSet([ScriptTransfer(addressFromStringValue(account), wavesAmount, unit), ScriptTransfer(addressFromStringValue(account), neutrinoAmount, neutrinoAssetId)]))
278+    }
279+
280+
281+
282+@Callable(i)
283+func transferToAuction () = {
284+    let deficitBondAmount = (deficit - assetBalance(addressFromStringValue(auctionContract), bondAssetId))
285+    let minDeficit = fraction(neutrinoSupply, DEFICITOFFSET, 100)
286+    let surplusWithLiquidation = (surplus - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
287+    if (isBlocked)
288+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
289+        else if (if ((deficitBondAmount > minDeficit))
290+            then (deficitBondAmount > 0)
291+            else false)
292+            then TransferSet([ScriptTransfer(addressFromStringValue(auctionContract), deficitBondAmount, bondAssetId)])
293+            else if ((surplusWithLiquidation >= (1 * PAULI)))
294+                then TransferSet([ScriptTransfer(addressFromStringValue(liquidationContract), surplusWithLiquidation, neutrinoAssetId)])
295+                else throw(((((((("bond were generated or do not need it. Deficit:" + toString(deficitBondAmount)) + "|") + toString(minDeficit)) + ". Surplus:") + toString(surplusWithLiquidation)) + "|") + toString(surplus)))
296+    }
297+
298+
299+
300+@Callable(i)
301+func transfer (account) = {
302+    let pmt = extract(i.payment)
303+    TransferSet([ScriptTransfer(addressFromStringValue(account), pmt.amount, pmt.assetId)])
304+    }
305+
306+
307+
308+@Callable(i)
309+func migrationUSDNB2NSBTSwap () = {
310+    let pmt = extract(i.payment)
311+    let account = i.caller
312+    if ((deprecatedBondAssetId != pmt.assetId))
313+        then throw("error: attempt to swap not USDNB tokens")
314+        else TransferSet([ScriptTransfer(account, (pmt.amount * PAULI), bondAssetId)])
315+    }
316+
317+
github/deemru/w8io/3ef1775 
43.36 ms ◑