tx · 6KcqeV8G4sEYqGE8qtXSSVL6yaEVgoV2ZkrACMZPC1zx

3NALXxmxYVBd15wvJ9nWUMVENz5CEnNKNLp:  -0.01000000 Waves

2020.01.17 23:37 [858655] smart account 3NALXxmxYVBd15wvJ9nWUMVENz5CEnNKNLp > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6KcqeV8G4sEYqGE8qtXSSVL6yaEVgoV2ZkrACMZPC1zx",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1579293482539,
    "version": 1,
    "sender": "3NALXxmxYVBd15wvJ9nWUMVENz5CEnNKNLp",
    "senderPublicKey": "e2VC4Us82V4ututiTL8FivPYnT9jpQn6TZFm4kXqbt7",
    "proofs": [
        "4uDNbsmn7EV4t7bwRPVuRodr99p4sFu6KiwES7CBpR5JbqvjVbTckXMNhxRwbzAjo87ncUL9Tza61e29sRp2WoGj"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 858655,
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

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 convertNeutrinoToBond (amount) = (amount / PAULI)
134+
135+
136+func convertBondToNeutrino (amount) = (amount * PAULI)
137+
138+
139+func convertWavesToBond (amount,price) = convertNeutrinoToBond(convertWavesToNeutrino(amount, price))
140+
141+
142+func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
143+
144+
145+let neutrinoLockedBalance = getNumberByKey(NeutrinoLockedBalanceKey)
146+
147+let wavesLockedBalance = getNumberByKey(WavesLockedBalanceKey)
148+
149+let liquidationContract = getStringByKey(LiquidationContractKey)
150+
151+let neutrinoAssetIdString = getStringByKey(NeutrinoAssetIdKey)
152+
153+let neutrinoAssetId = fromBase58String(neutrinoAssetIdString)
154+
155+let auctionContract = getStringByKey(AuctionContractKey)
156+
157+let rpdContract = getStringByKey(RPDContractKey)
158+
159+let controlContract = getStringByKey(ContolContractKey)
160+
161+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
162+
163+let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
164+
165+let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
166+
167+let nodeOracleProviderPubKey = fromBase58String(getStringByKey(NodeOracleProviderPubKeyKey))
168+
169+let balanceWavesLockInterval = getNumberByKey(BalanceWavesLockIntervalKey)
170+
171+let balanceNeutrinoLockInterval = getNumberByKey(BalanceNeutrinoLockIntervalKey)
172+
173+let minWavesSwapAmount = getNumberByKey(MinWavesSwapAmountKey)
174+
175+let minNeutrinoSwapAmount = getNumberByKey(MinNeutrinoSwapAmountKey)
176+
177+let reserve = (wavesBalance(this) - wavesLockedBalance)
178+
179+let bondAssetId = fromBase58String(getStringByKey(BondAssetIdKey))
180+
181+let bondSupply = (extract(assetInfo(bondAssetId)).quantity - assetBalance(this, bondAssetId))
182+
183+let neutrinoSupply = (((extract(assetInfo(neutrinoAssetId)).quantity - assetBalance(this, neutrinoAssetId)) + neutrinoLockedBalance) - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
184+
185+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
186+
187+let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve, currentPrice))
188+
189+func getRPDContractBalance (assetId) = getNumberByAddressAndKey(rpdContract, getRPDContractBalanceKey(assetId))
190+
191+
192+func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
193+
194+
195+func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
196+
197+
198+func getCancelLeaseTxReserveFee (hash) = getNumberByKey(getCancelLeaseTxReserveFeeKey(hash))
199+
200+
201+func getWavesLockedBalance (owner) = getNumberByKey(getWavesLockedBalanceKey(owner))
202+
203+
204+func getNeutrinoLockedBalance (owner) = getNumberByKey(getNeutrinoLockedBalanceKey(owner))
205+
206+
207+func getUnlockBalanceBlock (owner) = getNumberByKey(getBalanceUnlockBlockKey(owner))
208+
209+
210+func getRPDProfit (count) = getNumberByKey(getRPDProfitKey(count))
211+
212+
213+@Callable(i)
214+func swapWavesToNeutrino () = {
215+    let pmt = extract(i.payment)
216+    let account = toString(i.caller)
217+    if ((minWavesSwapAmount > pmt.amount))
218+        then throw((("The specified Waves amount is less than the required minimum of " + toString(minWavesSwapAmount)) + " wavelets."))
219+        else if (isDefined(pmt.assetId))
220+            then throw("Only Waves token is allowed for swapping.")
221+            else if (isBlocked)
222+                then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
223+                else if ((getUnlockBalanceBlock(account) > height))
224+                    then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
225+                    else if (if ((getNeutrinoLockedBalance(account) != 0))
226+                        then true
227+                        else (getWavesLockedBalance(account) != 0))
228+                        then throw("please withdraw locked funds first")
229+                        else WriteSet([DataEntry(getWavesLockedBalanceKey(account), pmt.amount), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceWavesLockInterval)), DataEntry(WavesLockedBalanceKey, (wavesLockedBalance + pmt.amount))])
230+    }
231+
232+
233+
234+@Callable(i)
235+func swapNeutrinoToWaves () = {
236+    let pmt = extract(i.payment)
237+    let account = toString(i.caller)
238+    if ((minNeutrinoSwapAmount > pmt.amount))
239+        then throw((("The specified Neutrino amount is less than the required minimum of " + toString(minNeutrinoSwapAmount)) + " Neutrino cents."))
240+        else if (isBlocked)
241+            then throw("The contract is blocked by EMERGENCY SHUTDOWN. Please wait for reactivation by emergency oracles.")
242+            else if ((pmt.assetId != neutrinoAssetId))
243+                then throw("Only appropriate Neutrino tokens are allowed for swapping.")
244+                else if ((getUnlockBalanceBlock(account) > height))
245+                    then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
246+                    else if (if ((getNeutrinoLockedBalance(account) != 0))
247+                        then true
248+                        else (getWavesLockedBalance(account) != 0))
249+                        then throw("please withdraw locked funds first")
250+                        else WriteSet([DataEntry(getNeutrinoLockedBalanceKey(account), pmt.amount), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceNeutrinoLockInterval)), DataEntry(NeutrinoLockedBalanceKey, (neutrinoLockedBalance + pmt.amount))])
251+    }
252+
253+
254+
255+@Callable(i)
256+func withdraw (account,index) = {
257+    let unlockHeight = getUnlockBalanceBlock(account)
258+    let userWavesLockedBalance = getWavesLockedBalance(account)
259+    let userNeutrinoLockedBalance = getNeutrinoLockedBalance(account)
260+    let indexHeight = getHeightPriceByIndex(index)
261+    let prevIndexHeight = getHeightPriceByIndex((index - 1))
262+    let priceByIndex = getPriceHistory(indexHeight)
263+    let neutrinoAmount = convertWavesToNeutrino(userWavesLockedBalance, priceByIndex)
264+    let wavesAmount = convertNeutrinoToWaves(userNeutrinoLockedBalance, priceByIndex)
265+    if (isBlocked)
266+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
267+        else if ((unlockHeight > height))
268+            then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw WAVES funds"))
269+            else if (if (if ((index > priceIndex))
270+                then true
271+                else (unlockHeight > indexHeight))
272+                then true
273+                else if ((prevIndexHeight != 0))
274+                    then (prevIndexHeight >= unlockHeight)
275+                    else false)
276+                then throw("invalid price history index")
277+                else if (if ((0 >= neutrinoAmount))
278+                    then (0 >= wavesAmount)
279+                    else false)
280+                    then throw("balance equals zero")
281+                    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)]))
282+    }
283+
284+
285+
286+@Callable(i)
287+func transferToAuction () = {
288+    let deficitBondAmount = (convertNeutrinoToBond(deficit) - assetBalance(addressFromStringValue(auctionContract), bondAssetId))
289+    let surplusBond = convertNeutrinoToBond(surplus)
290+    let minDeficit = ((convertNeutrinoToBond(neutrinoSupply) * DEFICITOFFSET) / 100)
291+    if (isBlocked)
292+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
293+        else if (if ((deficitBondAmount >= minDeficit))
294+            then (deficitBondAmount > 0)
295+            else false)
296+            then TransferSet([ScriptTransfer(addressFromStringValue(auctionContract), deficitBondAmount, bondAssetId)])
297+            else if ((surplusBond > 0))
298+                then TransferSet([ScriptTransfer(addressFromStringValue(liquidationContract), convertBondToNeutrino(surplusBond), neutrinoAssetId)])
299+                else throw(((((((("bond were generated or do not need it. Deficit:" + toString(deficitBondAmount)) + "|") + toString(minDeficit)) + ". Surplus:") + toString(surplusBond)) + "|") + toString(surplus)))
300+    }
301+
302+
303+
304+@Callable(i)
305+func transfer (account) = {
306+    let pmt = extract(i.payment)
307+    TransferSet([ScriptTransfer(addressFromStringValue(account), pmt.amount, pmt.assetId)])
308+    }
309+
310+
github/deemru/w8io/026f985 
63.13 ms ◑