tx · BqfApDvCnsC3J3vPvKdmpVhaDYF8s3fr7wqoF24Fq8Bo

3Mxnm4wd25YMdQYKvdQ7NWf2zRoMkPrhLrN:  -0.01000000 Waves

2019.11.16 00:01 [766734] smart account 3Mxnm4wd25YMdQYKvdQ7NWf2zRoMkPrhLrN > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BqfApDvCnsC3J3vPvKdmpVhaDYF8s3fr7wqoF24Fq8Bo",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1573851679183,
    "version": 1,
    "sender": "3Mxnm4wd25YMdQYKvdQ7NWf2zRoMkPrhLrN",
    "senderPublicKey": "FpjmXEPHMFPsSMkoA7XTMmBU8bnxZFyD1aFSM4Az4fZ1",
    "proofs": [
        "UoGPYZyksqzks4Cs4HX1CwbC2pTRyBLP1qfnkuHkvx5oM3kucWsBUrqm4wuRjnJEuTdKoWZjtoRiEAMErfRmgU7"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 766734,
    "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 = 100
61+
62+let CRYTICALSHARE = 20
63+
64+let LEASINGSHARE = 90
65+
66+let LEASINTXCOUNT = 10
67+
68+let DEFICITOFFSET = 10
69+
70+let WAVESASSETID = "waves"
71+
72+let CANCELED = "canceled"
73+
74+let NEW = "new"
75+
76+let NeutrinoAssetIdKey = "neutrino_asset_id"
77+
78+let BondAssetIdKey = "bond_asset_id"
79+
80+let ReserveContractKey = "reserve_contract"
81+
82+let AuctionContractKey = "auction_contract"
83+
84+let LiquidationContractKey = "liquidation_contract"
85+
86+let RPDContractKey = "rpd_contract"
87+
88+let ContolContractKey = "control_contract"
89+
90+let BalanceLockIntervalKey = "balance_lock_interval"
91+
92+let MinWavesSwapAmountKey = "min_waves_swap_amount"
93+
94+let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
95+
96+let NodeAddressKey = "node_address"
97+
98+let NodeOracleProviderKey = "oracle_node_provider"
99+
100+let LeasingIntervalKey = "leasing_interval"
101+
102+let RPDBalanceKey = "rpd_balance"
103+
104+func getRPDContractBalanceKey (assetId) = ((RPDBalanceKey + "_") + toBase58String(assetId))
105+
106+
107+let TotalOrderbookKey = "total_orderbook"
108+
109+let TotalLiquidationOrderbookKey = "total_liquidation_orderbook"
110+
111+let PriceKey = "price"
112+
113+let PriceIndexKey = "price_index"
114+
115+let IsBlockedKey = "is_blocked"
116+
117+let LeasingExpireBlockKey = "leasing_expire_block"
118+
119+let IsRebalanceKey = "is_rebalance"
120+
121+let LeasingTxCountKey = "leasing_index"
122+
123+let LeasingAmountKey = "leasing_amount"
124+
125+func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
126+
127+
128+func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
129+
130+
131+let RPDSyncIndexKey = "rpd_sync_index"
132+
133+func getRPDSnapshotContractBalanceKey (count,assetId) = ((((RPDBalanceKey + "_") + toBase58String(assetId)) + "_") + toString(count))
134+
135+
136+func getCancelLeaseTxReserveFeeKey (hash) = (("cancel_lease_tx_reserve_fee" + "_") + hash)
137+
138+
139+func getAccountLockedBalanceKey (owner,assetId) = ((("balance_" + assetId) + "_") + owner)
140+
141+
142+func getBalanceUnlockBlockKey (owner) = ("balance_block_" + owner)
143+
144+
145+func getRPDProfitKey (count) = (("rpd_profit" + "_") + toString(count))
146+
147+
148+func getLockedBalanceKey (assetId) = ("balance_" + assetId)
149+
150+
151+func getLeaseTxStatusKey (hash) = (("lease_tx_status" + "_") + hash)
152+
153+
154+func getLeaseTxAmountByHashKey (hash) = ((LeasingAmountKey + "_") + hash)
155+
156+
157+func getLeaseTxBytesByHashKey (hash) = (("lease_tx" + "_") + hash)
158+
159+
160+func getLeaseTxExpireSendBlockKey (hash) = (("leasing_expire_send" + "_") + hash)
161+
162+
163+func convertNeutrinoToWaves (amount,price) = ((((amount * 100) / price) * WAVELET) / PAULI)
164+
165+
166+func convertWavesToNeutrino (amount,price) = ((((amount * price) / 100) * PAULI) / WAVELET)
167+
168+
169+func convertNeutrinoToBond (amount) = (amount / PAULI)
170+
171+
172+func convertBondToNeutrino (amount) = (amount * PAULI)
173+
174+
175+func convertWavesToBond (amount,price) = convertNeutrinoToBond(convertWavesToNeutrino(amount, price))
176+
177+
178+func getLockedBalance (assetId) = getNumberByKey(getLockedBalanceKey(assetId))
179+
180+
181+let liquidationContract = getStringByKey(LiquidationContractKey)
182+
183+let neutrinoAssetIdString = getStringByKey(NeutrinoAssetIdKey)
184+
185+let neutrinoAssetId = fromBase58String(neutrinoAssetIdString)
186+
187+let reserveContract = getStringByKey(ReserveContractKey)
188+
189+let auctionContract = getStringByKey(AuctionContractKey)
190+
191+let rpdContract = getStringByKey(RPDContractKey)
192+
193+let controlContract = getStringByKey(ContolContractKey)
194+
195+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
196+
197+let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
198+
199+let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
200+
201+let leasingTxCount = getNumberByKey(LeasingTxCountKey)
202+
203+let isRebalance = getBoolByKey(IsRebalanceKey)
204+
205+let leasingInterval = getNumberByKey(LeasingIntervalKey)
206+
207+let leasingExpireBlock = getNumberByKey(LeasingExpireBlockKey)
208+
209+let leasingAmount = getNumberByKey(LeasingAmountKey)
210+
211+let nodeAddress = getStringByKey(NodeAddressKey)
212+
213+let nodeOracleProviderKey = getStringByKey(NodeOracleProviderKey)
214+
215+let rpdSyncIndex = getNumberByKey(RPDSyncIndexKey)
216+
217+let balanceLockInterval = getNumberByKey(BalanceLockIntervalKey)
218+
219+let minWavesSwapAmount = getNumberByKey(MinWavesSwapAmountKey)
220+
221+let minNeutrinoSwapAmount = getNumberByKey(MinNeutrinoSwapAmountKey)
222+
223+let reserve = (wavesBalance(this) - getLockedBalance(WAVESASSETID))
224+
225+let reserveWithoutLeasing = (reserve - leasingAmount)
226+
227+let bondAssetId = fromBase58String(getStringByKey(BondAssetIdKey))
228+
229+let bondSupply = (extract(assetInfo(bondAssetId)).quantity - assetBalance(this, bondAssetId))
230+
231+let neutrinoSupply = ((extract(assetInfo(neutrinoAssetId)).quantity - assetBalance(this, neutrinoAssetId)) + getLockedBalance(neutrinoAssetIdString))
232+
233+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
234+
235+let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve, currentPrice))
236+
237+func getRPDContractBalance (assetId) = getNumberByAddressAndKey(rpdContract, getRPDContractBalanceKey(assetId))
238+
239+
240+let totalLiquidationOrderbook = getNumberByAddressAndKey(auctionContract, TotalLiquidationOrderbookKey)
241+
242+let totalOrderbook = getNumberByAddressAndKey(auctionContract, TotalOrderbookKey)
243+
244+func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
245+
246+
247+func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
248+
249+
250+func getCancelLeaseTxReserveFee (hash) = getNumberByKey(getCancelLeaseTxReserveFeeKey(hash))
251+
252+
253+func getAccountLockedBalance (owner,assetId) = getNumberByKey(getAccountLockedBalanceKey(owner, assetId))
254+
255+
256+func getUnlockBalanceBlock (owner) = getNumberByKey(getBalanceUnlockBlockKey(owner))
257+
258+
259+func getRPDProfit (count) = getNumberByKey(getRPDProfitKey(count))
260+
261+
262+func getLeaseTxStatus (hash) = getStringByKey(getLeaseTxStatusKey(hash))
263+
264+
265+func getLeaseTxAmountByHash (hash) = getNumberByKey(getLeaseTxAmountByHashKey(hash))
266+
267+
268+func getLeaseTxBytesByHash (hash) = getStringByKey(getLeaseTxBytesByHashKey(hash))
269+
270+
271+func getLeaseTxExpireSendBlock (hash) = getNumberByKey(getLeaseTxExpireSendBlockKey(hash))
272+
273+
274+@Callable(i)
275+func swapWavesToNeutrino () = {
276+    let pmt = extract(i.payment)
277+    let account = toString(i.caller)
278+    if ((minWavesSwapAmount > pmt.amount))
279+        then throw((("an amount is less than min available amount: " + toString(minWavesSwapAmount)) + " wavelets"))
280+        else if (isDefined(pmt.assetId))
281+            then throw("can use waves only")
282+            else if (isBlocked)
283+                then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
284+                else if ((getUnlockBalanceBlock(account) > height))
285+                    then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
286+                    else if ((getAccountLockedBalance(account, WAVESASSETID) != 0))
287+                        then throw("please withdraw locked funds first")
288+                        else WriteSet([DataEntry(getAccountLockedBalanceKey(account, WAVESASSETID), pmt.amount), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceLockInterval)), DataEntry(getLockedBalanceKey(WAVESASSETID), (getLockedBalance(WAVESASSETID) + pmt.amount))])
289+    }
290+
291+
292+
293+@Callable(i)
294+func swapNeutrinoToWaves () = {
295+    let pmt = extract(i.payment)
296+    let account = toString(i.caller)
297+    if ((minNeutrinoSwapAmount > pmt.amount))
298+        then throw((("an amount is less than min available amount: " + toString(minNeutrinoSwapAmount)) + " neutrino cents"))
299+        else if (isBlocked)
300+            then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
301+            else if ((pmt.assetId != neutrinoAssetId))
302+                then throw("can use appropriate neutrino tokens only")
303+                else if ((getUnlockBalanceBlock(account) > height))
304+                    then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
305+                    else if ((getAccountLockedBalance(account, neutrinoAssetIdString) != 0))
306+                        then throw("please withdraw locked funds first")
307+                        else {
308+                            let newLockedBalance = (getLockedBalance(neutrinoAssetIdString) + pmt.amount)
309+                            WriteSet([DataEntry(getAccountLockedBalanceKey(account, neutrinoAssetIdString), pmt.amount), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceLockInterval)), DataEntry(getLockedBalanceKey(neutrinoAssetIdString), newLockedBalance), DataEntry(IsRebalanceKey, if ((reserveWithoutLeasing >= convertNeutrinoToWaves(newLockedBalance, currentPrice)))
310+                                then false
311+                                else true)])
312+                            }
313+    }
314+
315+
316+
317+@Callable(i)
318+func withdraw (account,index,lockedAssetId) = {
319+    let unlockHeight = getUnlockBalanceBlock(account)
320+    let lockedBalance = getAccountLockedBalance(account, lockedAssetId)
321+    let indexHeight = getHeightPriceByIndex(index)
322+    let nextIndexHeight = getHeightPriceByIndex((index + 1))
323+    let priceByIndex = getPriceHistory(indexHeight)
324+    let amount = if ((lockedAssetId == neutrinoAssetIdString))
325+        then convertNeutrinoToWaves(lockedBalance, priceByIndex)
326+        else convertWavesToNeutrino(lockedBalance, priceByIndex)
327+    if (isBlocked)
328+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
329+        else if ((0 >= amount))
330+            then throw((("balance equals zero (" + lockedAssetId) + ")"))
331+            else if ((unlockHeight > height))
332+                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw WAVES funds"))
333+                else if (if (if ((index > priceIndex))
334+                    then true
335+                    else (indexHeight > unlockHeight))
336+                    then true
337+                    else if ((nextIndexHeight != 0))
338+                        then (unlockHeight >= nextIndexHeight)
339+                        else false)
340+                    then throw("invalid price history index")
341+                    else ScriptResult(WriteSet([DataEntry(getAccountLockedBalanceKey(account, lockedAssetId), 0), DataEntry(getLockedBalanceKey(lockedAssetId), (getLockedBalance(lockedAssetId) - lockedBalance))]), TransferSet([ScriptTransfer(addressFromStringValue(account), amount, if ((lockedAssetId == neutrinoAssetIdString))
342+                        then unit
343+                        else neutrinoAssetId)]))
344+    }
345+
346+
347+
348+@Callable(i)
349+func transferToAuction () = {
350+    let deficitBondAmount = ((convertNeutrinoToBond(deficit) - assetBalance(addressFromStringValue(auctionContract), bondAssetId)) - totalLiquidationOrderbook)
351+    let surplusBond = ((convertNeutrinoToBond(surplus) - assetBalance(addressFromStringValue(auctionContract), neutrinoAssetId)) - totalOrderbook)
352+    if (isBlocked)
353+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
354+        else if ((deficitBondAmount >= ((neutrinoSupply * DEFICITOFFSET) / 100)))
355+            then TransferSet([ScriptTransfer(addressFromStringValue(auctionContract), deficitBondAmount, bondAssetId)])
356+            else if ((surplusBond > 0))
357+                then TransferSet([ScriptTransfer(addressFromStringValue(liquidationContract), convertBondToNeutrino(surplusBond), neutrinoAssetId)])
358+                else throw("bond were generated or do not need it")
359+    }
360+
361+
362+
363+@Callable(i)
364+func transfer (account) = {
365+    let pmt = extract(i.payment)
366+    TransferSet([ScriptTransfer(addressFromStringValue(account), pmt.amount, pmt.assetId)])
367+    }
368+
369+
370+
371+@Callable(i)
372+func nodeReward () = {
373+    let pmt = value(i.payment)
374+    if ((i.caller != addressFromStringValue(nodeAddress)))
375+        then throw("only node account is able to transfer staking rewards from main account")
376+        else if (isDefined(pmt.assetId))
377+            then throw("waves tokens only allowed")
378+            else {
379+                let amount = convertWavesToNeutrino(pmt.amount, currentPrice)
380+                let newRpdSyncIndex = (rpdSyncIndex + 1)
381+                ScriptResult(WriteSet([DataEntry(RPDSyncIndexKey, newRpdSyncIndex), DataEntry(getRPDProfitKey(rpdSyncIndex), amount), DataEntry(getRPDSnapshotContractBalanceKey(rpdSyncIndex, neutrinoAssetId), getRPDContractBalance(neutrinoAssetId))]), TransferSet([ScriptTransfer(addressFromStringValue(rpdContract), amount, neutrinoAssetId)]))
382+                }
383+    }
384+
385+
386+
387+@Callable(i)
388+func registrationLeaseTx (senderPublicKey,fee,timestamp,leaseTxHash) = {
389+    let totalFreeReserve = (((reserve * LEASINGSHARE) / 100) - convertNeutrinoToWaves(getLockedBalance(neutrinoAssetIdString), currentPrice))
390+    let amount = (totalFreeReserve / LEASINTXCOUNT)
391+    let txBytes = (((((base58'3h1H' + fromBase58String(senderPublicKey)) + fromBase58String(nodeAddress)) + toBytes(amount)) + toBytes(fee)) + toBytes(timestamp))
392+    let txHashBytes = blake2b256(txBytes)
393+    let txHash = toBase58String(txHashBytes)
394+    let pmt = extract(i.payment)
395+    if ((toString(i.caller) == nodeOracleProviderKey))
396+        then throw("invalid caller")
397+        else if (isDefined(pmt.assetId))
398+            then throw("invalid paymtn asset")
399+            else if ((leaseTxHash != txHash))
400+                then throw((("invalid tx hash(amount:" + toString(amount)) + ")"))
401+                else if ((leasingTxCount >= LEASINTXCOUNT))
402+                    then throw("the number of leasing transactions is equal to the maximum")
403+                    else if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
404+                        then throw("invalid pubKey")
405+                        else if (if ((lastBlock.timestamp > timestamp))
406+                            then true
407+                            else (timestamp > (lastBlock.timestamp + 5400000)))
408+                            then throw((("invalid timestamp(lastBlock: " + toString(lastBlock.timestamp)) + ")"))
409+                            else if ((getLeaseTxStatus(txHash) != ""))
410+                                then throw("tx is exist")
411+                                else if ((pmt.amount != (fee * 2)))
412+                                    then throw("invalid payment amount")
413+                                    else if (if ((fee > 1000000))
414+                                        then true
415+                                        else (500000 > fee))
416+                                        then throw("invalid fee")
417+                                        else if (((totalFreeReserve - (leasingAmount + amount)) > reserveWithoutLeasing))
418+                                            then throw((("invalid amount(result:" + toString(((totalFreeReserve - (leasingAmount + amount)) > reserveWithoutLeasing))) + ")"))
419+                                            else WriteSet([DataEntry(getCancelLeaseTxReserveFeeKey(txHash), fee), DataEntry(LeasingTxCountKey, if ((getLeaseTxStatus(txHash) == ""))
420+                                                then (leasingTxCount + 1)
421+                                                else leasingTxCount), DataEntry(LeasingAmountKey, (leasingAmount + amount)), DataEntry(LeasingExpireBlockKey, if ((height > leasingExpireBlock))
422+                                                then (height + leasingInterval)
423+                                                else leasingExpireBlock), DataEntry(getLeaseTxStatusKey(txHash), NEW), DataEntry(getLeaseTxExpireSendBlockKey(txHash), (height + SENDTXEXPIRE)), DataEntry(getLeaseTxAmountByHashKey(txHash), amount), DataEntry(getLeaseTxBytesByHashKey(txHash), toBase64String(txBytes))])
424+    }
425+
426+
427+
428+@Callable(i)
429+func cancelStuckLeaseTx (txHash) = if (if (if ((getLeaseTxStatus(txHash) == NEW))
430+    then !(isDefined(transactionHeightById(fromBase58String(txHash))))
431+    else false)
432+    then (height > getLeaseTxExpireSendBlock(txHash))
433+    else false)
434+    then {
435+        let amount = getLeaseTxAmountByHash(txHash)
436+        WriteSet([DataEntry(LeasingTxCountKey, (leasingTxCount - 1)), DataEntry(LeasingAmountKey, (leasingAmount - amount)), DataEntry(getLeaseTxStatusKey(txHash), CANCELED), DataEntry(IsRebalanceKey, if (((reserveWithoutLeasing - amount) >= convertNeutrinoToWaves(getLockedBalance(neutrinoAssetIdString), currentPrice)))
437+            then false
438+            else true)])
439+        }
440+    else throw("invalid tx hash")
441+
442+
443+
444+@Callable(i)
445+func registrationUnleaseTx (chainIdString,senderPublicKey,fee,timestamp,leaseTxHash) = {
446+    let txBytes = (((((base58'gm' + toBytes(chainIdString)) + fromBase58String(senderPublicKey)) + toBytes(fee)) + toBytes(timestamp)) + fromBase58String(leaseTxHash))
447+    let txHash = blake2b256(txBytes)
448+    if ((getLeaseTxStatus(leaseTxHash) != NEW))
449+        then throw("invalid tx status")
450+        else if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
451+            then throw("invalid pubKey")
452+            else if (!(isDefined(transactionHeightById(txHash))))
453+                then throw("blockchain does not contain this transaction")
454+                else {
455+                    let amount = getLeaseTxAmountByHash(leaseTxHash)
456+                    WriteSet([DataEntry(LeasingTxCountKey, (leasingTxCount - 1)), DataEntry(LeasingAmountKey, (leasingAmount - amount)), DataEntry(getLeaseTxStatusKey(leaseTxHash), CANCELED), DataEntry(IsRebalanceKey, if (((reserveWithoutLeasing - amount) >= convertNeutrinoToWaves(getLockedBalance(neutrinoAssetIdString), currentPrice)))
457+                        then false
458+                        else true)])
459+                    }
460+    }
461+
462+
463+@Verifier(tx)
464+func verify () = {
465+    let id = toBase58String(tx.id)
466+    match tx {
467+        case leaseTx: LeaseTransaction => 
468+            if (if ((leasingExpireBlock >= height))
469+                then (getLeaseTxExpireSendBlock(id) >= height)
470+                else false)
471+                then (getLeaseTxStatus(id) == NEW)
472+                else false
473+        case unleaseTx: LeaseCancelTransaction => 
474+            let leaseId = toBase58String(unleaseTx.leaseId)
475+            if (if (if ((height > leasingExpireBlock))
476+                then true
477+                else isRebalance)
478+                then (unleaseTx.fee == getCancelLeaseTxReserveFee(leaseId))
479+                else false)
480+                then (getLeaseTxStatus(leaseId) == NEW)
481+                else false
482+        case _ => 
483+            sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
484+    }
485+    }
486+
github/deemru/w8io/c3f4982 
27.89 ms ◑