tx · Cgbb5jm7zseBrf9nbdE4NeEp4D56H8hMFbZcjVCpjdrU

3Mt1KRk2dzQxMUSJQ9zz5sFhJ2wcHedqGgu:  -0.01400000 Waves

2019.10.01 17:52 [700787] smart account 3Mt1KRk2dzQxMUSJQ9zz5sFhJ2wcHedqGgu > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Cgbb5jm7zseBrf9nbdE4NeEp4D56H8hMFbZcjVCpjdrU",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1569941538021,
    "version": 1,
    "sender": "3Mt1KRk2dzQxMUSJQ9zz5sFhJ2wcHedqGgu",
    "senderPublicKey": "D8T252TYm94dN33P1jckAStjWQwSTtZt2FSnL9deiLp4",
    "proofs": [
        "5viXTqmHFs3ETfH1WktM9k7dYK7MSvTdFiEuxybMxSWQCGoo1bpYL7fr4dPEfzQp4Te6YZJu7iWmRtB5GuQR2sqS"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 700787,
    "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+let uTokenId = base58'9qh2MiJhfqNS1o3R5wcUrAAWpeqZs9R8SLwQvCx88Vaf'
5+
6+func checkStatus (address) = {
7+    let statusUnlimited =     match getBoolean(this, (address + "_unlimited")) {
8+        case bool: Boolean => 
9+            bool
10+        case _: Unit => 
11+            false
12+        case _ => 
13+            throw()
14+    }
15+    let statusTime =     match getInteger(this, (address + "_time")) {
16+        case int: Int => 
17+            int
18+        case _: Unit => 
19+            0
20+        case _ => 
21+            throw()
22+    }
23+    if (statusUnlimited)
24+        then true
25+        else (statusTime > lastBlock.timestamp)
26+    }
27+
28+
29+func checkDecimals (amountAsset,priceAsset) = {
30+    let amountAssetDecimals = if ((amountAsset == "WAVES"))
31+        then 8
32+        else value(assetInfo(fromBase58String(amountAsset))).decimals
33+    let priceAssetDecimals = if ((priceAsset == "WAVES"))
34+        then 8
35+        else value(assetInfo(fromBase58String(priceAsset))).decimals
36+    (priceAssetDecimals >= amountAssetDecimals)
37+    }
38+
39+
40+@Callable(i)
41+func addAsset (assetId) = {
42+    let addingPrice = (100 * 100000000)
43+    let addingPriceStr = "100"
44+    let payment = valueOrErrorMessage(i.payment, "Where is payment?")
45+    if (if (isDefined(payment.assetId))
46+        then (payment.assetId != uTokenId)
47+        else false)
48+        then throw("OTCu or WAVES only")
49+        else if ((payment.amount != addingPrice))
50+            then throw((("You have to pay " + addingPriceStr) + " OTCu or WAVES"))
51+            else if (!(isDefined(assetInfo(fromBase58String(assetId)))))
52+                then throw("There is no asset with specified id")
53+                else {
54+                    let assets =                     match getString(this, "assets") {
55+                        case str: String => 
56+                            str
57+                        case _: Unit => 
58+                            ""
59+                        case _ => 
60+                            throw()
61+                    }
62+                    if (isDefined(indexOf(assets, assetId)))
63+                        then throw("Asset is already available")
64+                        else WriteSet([DataEntry("assets", (assets + assetId))])
65+                    }
66+    }
67+
68+
69+
70+@Callable(i)
71+func pro (unlimited) = {
72+    let address = toBase58String(i.caller.bytes)
73+    let unlimitedPrice = (50 * 100000000)
74+    let unlimitedPriceStr = "50"
75+    let monthPrice = (10 * 100000000)
76+    let monthPriceStr = "10"
77+    let payment = valueOrErrorMessage(i.payment, "Where is payment?")
78+    if (if (isDefined(payment.assetId))
79+        then (payment.assetId != uTokenId)
80+        else false)
81+        then throw("OTCu or WAVES only")
82+        else if (if (unlimited)
83+            then (payment.amount != unlimitedPrice)
84+            else false)
85+            then throw((("You have to pay " + unlimitedPriceStr) + " OTCu or WAVES"))
86+            else if (if (!(unlimited))
87+                then (payment.amount != monthPrice)
88+                else false)
89+                then throw((("You have to pay " + monthPriceStr) + " OTCu or WAVES"))
90+                else {
91+                    let currentUnlimited =                     match getBoolean(this, (address + "_unlimited")) {
92+                        case bool: Boolean => 
93+                            bool
94+                        case _: Unit => 
95+                            false
96+                        case _ => 
97+                            throw()
98+                    }
99+                    let currentTime =                     match getInteger(this, (address + "_time")) {
100+                        case int: Int => 
101+                            int
102+                        case _: Unit => 
103+                            0
104+                        case _ => 
105+                            throw()
106+                    }
107+                    if (currentUnlimited)
108+                        then throw("You have unlimited PRO status already. What do you want?")
109+                        else {
110+                            let month = 2629743000
111+                            WriteSet([DataEntry((address + "_unlimited"), unlimited), DataEntry((address + "_time"), if (unlimited)
112+                                then 0
113+                                else (currentTime + month))])
114+                            }
115+                    }
116+    }
117+
118+
119+
120+@Callable(i)
121+func makeSell (priceAsset,priceAssetAmount,all,password) = if (if ((priceAsset != "WAVES"))
122+    then !(isDefined(assetInfo(fromBase58String(priceAsset))))
123+    else false)
124+    then throw("There is no asset with specified id")
125+    else if ((0 >= priceAssetAmount))
126+        then throw("Amount of price asset must be positive")
127+        else {
128+            let payment = valueOrErrorMessage(i.payment, "Where is payment?")
129+            if ((0 >= payment.amount))
130+                then throw("Amount must be positive")
131+                else {
132+                    let amountAsset =                     match payment.assetId {
133+                        case p: ByteVector => 
134+                            toBase58String(p)
135+                        case _ => 
136+                            "WAVES"
137+                    }
138+                    let assets = valueOrErrorMessage(getString(this, "assets"), "There are not available assets")
139+                    if (if (!(isDefined(indexOf(assets, priceAsset))))
140+                        then true
141+                        else !(isDefined(indexOf(assets, amountAsset))))
142+                        then throw("Asset are not available for trading")
143+                        else {
144+                            let address = toBase58String(i.caller.bytes)
145+                            if (if (!(checkStatus(address)))
146+                                then if (all)
147+                                    then true
148+                                    else (password != "")
149+                                else false)
150+                                then throw("You must have pro status to use these features")
151+                                else {
152+                                    let orderId = toBase58String(i.transactionId)
153+                                    let orders =                                     match getString(this, "orders") {
154+                                        case s: String => 
155+                                            s
156+                                        case _: Unit => 
157+                                            ""
158+                                        case _ => 
159+                                            throw()
160+                                    }
161+                                    let passwordValid = fromBase58String(password)
162+                                    let data = (((((((((((((((("sell" + "_") + toString(payment.amount)) + "_") + amountAsset) + "_") + toString(priceAssetAmount)) + "_") + priceAsset) + "_") + address) + "_") + toString(all)) + "_") + password) + "_") + toString(0))
163+                                    WriteSet([DataEntry("orders", (orders + orderId)), DataEntry(orderId, data)])
164+                                    }
165+                            }
166+                    }
167+            }
168+
169+
170+
171+@Callable(i)
172+func makeBuy (amountAsset,amount,all,password) = if (if ((amountAsset != "WAVES"))
173+    then !(isDefined(assetInfo(fromBase58String(amountAsset))))
174+    else false)
175+    then throw("There is no asset with specified id")
176+    else if ((0 >= amount))
177+        then throw("Amount must be positive")
178+        else {
179+            let payment = valueOrErrorMessage(i.payment, "where is payment?")
180+            let priceAssetAmount = payment.amount
181+            if ((0 >= priceAssetAmount))
182+                then throw("amount must be positive")
183+                else {
184+                    let priceAsset =                     match payment.assetId {
185+                        case p: ByteVector => 
186+                            toBase58String(p)
187+                        case _ => 
188+                            "WAVES"
189+                    }
190+                    let assets = valueOrErrorMessage(getString(this, "assets"), "There are not available assets")
191+                    if (if (!(isDefined(indexOf(assets, priceAsset))))
192+                        then true
193+                        else !(isDefined(indexOf(assets, amountAsset))))
194+                        then throw("Asset are not available for trading")
195+                        else {
196+                            let address = toBase58String(i.caller.bytes)
197+                            if (if (!(checkStatus(address)))
198+                                then if (all)
199+                                    then true
200+                                    else (password != "")
201+                                else false)
202+                                then throw("You must have pro status to use these features")
203+                                else {
204+                                    let orderId = toBase58String(i.transactionId)
205+                                    let orders =                                     match getString(this, "orders") {
206+                                        case s: String => 
207+                                            s
208+                                        case _: Unit => 
209+                                            ""
210+                                        case _ => 
211+                                            throw()
212+                                    }
213+                                    if ((amount == 0))
214+                                        then throw("invalid buy amount")
215+                                        else {
216+                                            let data = (((((((((((((((("buy" + "_") + toString(amount)) + "_") + amountAsset) + "_") + toString(priceAssetAmount)) + "_") + priceAsset) + "_") + address) + "_") + toString(all)) + "_") + password) + "_") + toString(0))
217+                                            WriteSet([DataEntry("orders", (orders + orderId)), DataEntry(("buy_" + orderId), data)])
218+                                            }
219+                                    }
220+                            }
221+                    }
222+            }
223+
224+
225+
226+@Callable(i)
227+func takeSell (orderId,sig) = {
228+    let payment = valueOrErrorMessage(i.payment, "Where is payment?")
229+    let priceAssetAmount = payment.amount
230+    if ((0 >= priceAssetAmount))
231+        then throw("Amount must be positive")
232+        else {
233+            let priceAsset =             match payment.assetId {
234+                case p: ByteVector => 
235+                    toBase58String(p)
236+                case _ => 
237+                    "WAVES"
238+            }
239+            let data = valueOrErrorMessage(getString(this, orderId), "Invalid order id")
240+            let orderType = split(data, "_")[0]
241+            let orderAmount = parseIntValue(split(data, "_")[1])
242+            let orderAmountAsset = split(data, "_")[2]
243+            let orderPriceAssetAmount = parseIntValue(split(data, "_")[3])
244+            let orderPriceAsset = split(data, "_")[4]
245+            let orderOwner = value(addressFromString(split(data, "_")[5]))
246+            let orderAll = if ((split(data, "_")[6] == "true"))
247+                then true
248+                else false
249+            let orderPassword = split(data, "_")[7]
250+            let orderSpent = parseIntValue(split(data, "_")[8])
251+            if ((orderType != "sell"))
252+                then throw("Invalid order type")
253+                else if ((orderPriceAsset != priceAsset))
254+                    then throw(("Payment asset must be " + orderPriceAsset))
255+                    else {
256+                        let valid = if ((orderPassword != ""))
257+                            then sigVerify(i.callerPublicKey, fromBase58String(sig), fromBase58String(orderPassword))
258+                            else true
259+                        if (!(valid))
260+                            then throw("The order is private")
261+                            else {
262+                                let amount = ((priceAssetAmount * orderAmount) / orderPriceAssetAmount)
263+                                if ((amount == 0))
264+                                    then throw("Invalid amount")
265+                                    else if (if (orderAll)
266+                                        then (orderAmount > amount)
267+                                        else false)
268+                                        then throw("You must take all or none")
269+                                        else if ((amount > (orderAmount - orderSpent)))
270+                                            then throw("Not enougth asset in order")
271+                                            else {
272+                                                let orders =                                                 match getString(this, "orders") {
273+                                                    case s: String => 
274+                                                        s
275+                                                    case _: Unit => 
276+                                                        ""
277+                                                    case _ => 
278+                                                        throw()
279+                                                }
280+                                                let newData = (dropRight(data, size(split(data, "_")[7])) + toString((orderSpent + amount)))
281+                                                let index = value(indexOf(orders, orderId))
282+                                                let newOrders = if ((orderAmount == (amount + orderSpent)))
283+                                                    then (take(orders, index) + drop(orders, (index + size(orderId))))
284+                                                    else orders
285+                                                ScriptResult(WriteSet([DataEntry("orders", newOrders), DataEntry(orderId, newData)]), TransferSet([ScriptTransfer(i.caller, amount, if ((orderAmountAsset == "WAVES"))
286+                                                    then unit
287+                                                    else fromBase58String(orderAmountAsset)), ScriptTransfer(orderOwner, priceAssetAmount, if ((orderPriceAsset == "WAVES"))
288+                                                    then unit
289+                                                    else fromBase58String(orderPriceAsset))]))
290+                                                }
291+                                }
292+                        }
293+            }
294+    }
295+
296+
297+
298+@Callable(i)
299+func takeBuy (orderId,sig) = {
300+    let payment = valueOrErrorMessage(i.payment, "where is payment?")
301+    let amount = payment.amount
302+    if ((0 >= amount))
303+        then throw("amount must be positive")
304+        else {
305+            let amountAsset =             match payment.assetId {
306+                case p: ByteVector => 
307+                    toBase58String(p)
308+                case _ => 
309+                    "WAVES"
310+            }
311+            let data = valueOrErrorMessage(getString(this, orderId), "Invalid order id")
312+            let orderType = split(data, "_")[0]
313+            let orderAmount = parseIntValue(split(data, "_")[1])
314+            let orderAmountAsset = split(data, "_")[2]
315+            let orderPriceAssetAmount = parseIntValue(split(data, "_")[3])
316+            let orderPriceAsset = split(data, "_")[4]
317+            let orderOwner = value(addressFromString(split(data, "_")[5]))
318+            let orderAll = if ((split(data, "_")[6] == "true"))
319+                then true
320+                else false
321+            let orderPassword = split(data, "_")[7]
322+            let orderSpent = parseIntValue(split(data, "_")[8])
323+            if ((orderType != "buy"))
324+                then throw("Invalid order type")
325+                else if ((orderAmountAsset != amountAsset))
326+                    then throw(("payment asset must be " + orderAmountAsset))
327+                    else {
328+                        let valid = if ((orderPassword != ""))
329+                            then sigVerify(i.callerPublicKey, fromBase58String(sig), fromBase58String(orderPassword))
330+                            else true
331+                        if (!(valid))
332+                            then throw("The order is private")
333+                            else {
334+                                let priceAssetAmount = ((amount * orderPriceAssetAmount) / orderAmount)
335+                                if ((priceAssetAmount == 0))
336+                                    then throw("Invalid amount")
337+                                    else if (if (orderAll)
338+                                        then (orderPriceAssetAmount > priceAssetAmount)
339+                                        else false)
340+                                        then throw("You must take all or none")
341+                                        else if ((priceAssetAmount > (orderPriceAssetAmount - orderSpent)))
342+                                            then throw("not enougth asset in order")
343+                                            else {
344+                                                let orders =                                                 match getString(this, "orders") {
345+                                                    case s: String => 
346+                                                        s
347+                                                    case _: Unit => 
348+                                                        ""
349+                                                    case _ => 
350+                                                        throw()
351+                                                }
352+                                                let newData = (dropRight(data, size(split(data, "_")[7])) + toString((orderSpent + priceAssetAmount)))
353+                                                let index = value(indexOf(orders, orderId))
354+                                                let newOrders = if ((orderPriceAssetAmount == (priceAssetAmount + orderSpent)))
355+                                                    then (take(orders, index) + drop(orders, (index + size(orderId))))
356+                                                    else orders
357+                                                ScriptResult(WriteSet([DataEntry("orders", newOrders), DataEntry(orderId, newData)]), TransferSet([ScriptTransfer(i.caller, priceAssetAmount, if ((orderPriceAsset == "WAVES"))
358+                                                    then unit
359+                                                    else fromBase58String(orderPriceAsset)), ScriptTransfer(orderOwner, amount, if ((orderAmountAsset == "WAVES"))
360+                                                    then unit
361+                                                    else fromBase58String(orderAmountAsset))]))
362+                                                }
363+                                }
364+                        }
365+            }
366+    }
367+
368+
369+
370+@Callable(i)
371+func returnSell (orderId) = {
372+    let data = valueOrErrorMessage(getString(this, ("sell_" + orderId)), "Invalid order id")
373+    let orderType = split(data, "_")[0]
374+    let orderAmount = parseIntValue(split(data, "_")[1])
375+    let orderAmountAsset = split(data, "_")[2]
376+    let orderPriceAssetAmount = parseIntValue(split(data, "_")[3])
377+    let orderPriceAsset = split(data, "_")[4]
378+    let orderOwner = value(addressFromString(split(data, "_")[5]))
379+    let orderAll = if ((split(data, "_")[6] == "true"))
380+        then true
381+        else false
382+    let orderPassword = split(data, "_")[7]
383+    let orderSpent = parseIntValue(split(data, "_")[8])
384+    if ((orderType != "sell"))
385+        then throw("Invalid order type")
386+        else if ((orderOwner != i.caller))
387+            then throw("return should be called by order owner")
388+            else {
389+                let returnAmount = (orderAmount - orderSpent)
390+                if ((0 >= returnAmount))
391+                    then throw("nothing to return")
392+                    else {
393+                        let orders =                         match getString(this, "orders") {
394+                            case s: String => 
395+                                s
396+                            case _: Unit => 
397+                                ""
398+                            case _ => 
399+                                throw()
400+                        }
401+                        let newData = (dropRight(data, size(split(data, "_")[7])) + toString(orderAmount))
402+                        let index = value(indexOf(orders, orderId))
403+                        let newOrders = (take(orders, index) + drop(orders, (index + size(orderId))))
404+                        ScriptResult(WriteSet([DataEntry("orders", newOrders), DataEntry(orderId, newData)]), TransferSet([ScriptTransfer(i.caller, returnAmount, if ((orderAmountAsset == "WAVES"))
405+                            then unit
406+                            else fromBase58String(orderAmountAsset))]))
407+                        }
408+                }
409+    }
410+
411+
412+
413+@Callable(i)
414+func returnBuy (orderId) = {
415+    let data = valueOrErrorMessage(getString(this, orderId), "Invalid order id")
416+    let orderType = split(data, "_")[0]
417+    let orderAmount = parseIntValue(split(data, "_")[1])
418+    let orderAmountAsset = split(data, "_")[2]
419+    let orderPriceAssetAmount = parseIntValue(split(data, "_")[3])
420+    let orderPriceAsset = split(data, "_")[4]
421+    let orderOwner = value(addressFromString(split(data, "_")[5]))
422+    let orderAll = if ((split(data, "_")[6] == "true"))
423+        then true
424+        else false
425+    let orderPassword = split(data, "_")[7]
426+    let orderSpent = parseIntValue(split(data, "_")[8])
427+    if ((orderType != "buy"))
428+        then throw("Invalid order type")
429+        else if ((orderOwner != i.caller))
430+            then throw("Return should be called by order owner")
431+            else {
432+                let returnAmount = (orderPriceAssetAmount - orderSpent)
433+                if ((0 >= returnAmount))
434+                    then throw("nothing to return")
435+                    else {
436+                        let orders =                         match getString(this, "orders") {
437+                            case s: String => 
438+                                s
439+                            case _: Unit => 
440+                                ""
441+                            case _ => 
442+                                throw()
443+                        }
444+                        let newData = (dropRight(data, size(split(data, "_")[7])) + toString(orderPriceAssetAmount))
445+                        let index = value(indexOf(orders, orderId))
446+                        let newOrders = (take(orders, index) + drop(orders, (index + size(orderId))))
447+                        ScriptResult(WriteSet([DataEntry("orders", newOrders), DataEntry(orderId, newData)]), TransferSet([ScriptTransfer(i.caller, returnAmount, if ((orderPriceAsset == "WAVES"))
448+                            then unit
449+                            else fromBase58String(orderPriceAsset))]))
450+                        }
451+                }
452+    }
453+
454+
github/deemru/w8io/c3f4982 
31.67 ms ◑