tx · 4tqscPmhFsHn6z7Kz2KjwwPPiaUbhpWfMyGNVcoC6u6B

3N3mryVDo7iPueStrtaTrrJ1c25Vsdq66Av:  -0.01000000 Waves

2019.07.05 10:20 [571898] smart account 3N3mryVDo7iPueStrtaTrrJ1c25Vsdq66Av > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4tqscPmhFsHn6z7Kz2KjwwPPiaUbhpWfMyGNVcoC6u6B",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1562311275262,
    "version": 1,
    "sender": "3N3mryVDo7iPueStrtaTrrJ1c25Vsdq66Av",
    "senderPublicKey": "BpoafeAbf3d9vUchdQD2x6Jqmc9gDUGY6UNUzD7EueEc",
    "proofs": [
        "3HKnJgNLk44zwJMtdUdusDzydoKnjv9iy2j3BLUuVRPTgBjTYtAQ6CBXYDE3sWFRa1Rki2igN8jwXnZzLNSbAMrp"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 571898,
    "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 adminAddress = base58'3MrMYPCe7n2NhgeVpYP3SAR52nGfb7HrMkW'
5+
6+let IdxPrice = 0
7+
8+let IdxAmount = 1
9+
10+let IdxTradePair = 2
11+
12+let IdxOrderType = 3
13+
14+let IdxSender = 4
15+
16+let IdxAssetId = 5
17+
18+let BUY = "BUY"
19+
20+let SELL = "SELL"
21+
22+func retainMatcherFee (amount) = fraction(amount, 999, 1000)
23+
24+
25+func matcherFee (amount) = (amount - fraction(amount, 999, 1000))
26+
27+
28+func RemoveUnderscoreIfPresent (remaining) = if ((size(remaining) > 0))
29+    then drop(remaining, 1)
30+    else remaining
31+
32+
33+func FormatDataParam (p) = {
34+    let s = size(p)
35+    if ((s == 0))
36+        then throw("Parameter size must be greater then 0")
37+        else if ((s > 99))
38+            then throw("Parameter size must be less then 100")
39+            else if ((10 > s))
40+                then (("0" + toString(s)) + p)
41+                else (toString(s) + p)
42+    }
43+
44+
45+func ParseNextAttribute (remaining) = {
46+    let s = size(remaining)
47+    if ((s > 0))
48+        then {
49+            let nn = parseIntValue(take(remaining, 2))
50+            let v = take(drop(remaining, 2), nn)
51+            let tmpRemaining = drop(remaining, (nn + 2))
52+            let remainingState = RemoveUnderscoreIfPresent(tmpRemaining)
53+[v, remainingState]
54+            }
55+        else throw("Empty string was passed into parseNextAttribute func")
56+    }
57+
58+
59+func FormatOrderDataStr (traidPair,sender,orderType,price,amount,assetId) = {
60+    let fullStateStr = ((((((((((FormatDataParam(traidPair) + "_") + FormatDataParam(sender)) + "_") + FormatDataParam(orderType)) + "_") + FormatDataParam(toString(price))) + "_") + FormatDataParam(toString(amount))) + "_") + FormatDataParam(assetId))
61+    fullStateStr
62+    }
63+
64+
65+func ParseOrderRawDataStr (rawStateStr) = {
66+    let tradePair = ParseNextAttribute(rawStateStr)
67+    let sender = ParseNextAttribute(tradePair[1])
68+    let orderType = ParseNextAttribute(sender[1])
69+    let price = ParseNextAttribute(orderType[1])
70+    let amount = ParseNextAttribute(price[1])
71+    let assetId = ParseNextAttribute(amount[1])
72+[price[0], amount[0], tradePair[0], orderType[0], sender[0], assetId[0]]
73+    }
74+
75+
76+func pow10 (exp) = if ((exp == 0))
77+    then 1
78+    else if ((exp == 1))
79+        then 10
80+        else if ((exp == 2))
81+            then 100
82+            else if ((exp == 3))
83+                then 1000
84+                else if ((exp == 4))
85+                    then 10000
86+                    else if ((exp == 5))
87+                        then 100000
88+                        else if ((exp == 6))
89+                            then 1000000
90+                            else if ((exp == 7))
91+                                then 10000000
92+                                else if ((exp == 8))
93+                                    then 100000000
94+                                    else if ((exp == 9))
95+                                        then 1000000000
96+                                        else if ((exp == 10))
97+                                            then 10000000000
98+                                            else if ((exp == 11))
99+                                                then 100000000000
100+                                                else if ((exp == 12))
101+                                                    then 1000000000000
102+                                                    else throw("Pow10 more then 12 is not supported")
103+
104+
105+func assetIdFromString (assetId) = if (if ((assetId == "WAVES"))
106+    then true
107+    else (assetId == ""))
108+    then unit
109+    else fromBase58String(assetId)
110+
111+
112+@Callable(i)
113+func order (assetId,price) = {
114+    let pmt = extract(i.payment)
115+    let pmtAssetIdStr = if (isDefined(pmt.assetId))
116+        then toBase58String(value(pmt.assetId))
117+        else "WAVES"
118+    let possibleTraidPair1 = getString(this, ((assetId + "/") + pmtAssetIdStr))
119+    let possibleTraidPair2 = getString(this, ((pmtAssetIdStr + "/") + assetId))
120+    let traidPair = if (isDefined(possibleTraidPair1))
121+        then value(possibleTraidPair1)
122+        else if (isDefined(possibleTraidPair2))
123+            then value(possibleTraidPair2)
124+            else throw("Traiding for that assets is not supported")
125+    let orderType = if (isDefined(possibleTraidPair1))
126+        then BUY
127+        else SELL
128+    let orderStr = FormatOrderDataStr(traidPair, toBase58String(i.caller.bytes), orderType, price, pmt.amount, pmtAssetIdStr)
129+    WriteSet([DataEntry(toBase58String(i.transactionId), orderStr)])
130+    }
131+
132+
133+
134+@Callable(i)
135+func matchOrders (order1Id,order2Id) = {
136+    let order1 = ParseOrderRawDataStr(getStringValue(this, order1Id))
137+    let order2 = ParseOrderRawDataStr(getStringValue(this, order2Id))
138+    if ((order1[IdxTradePair] != order2[IdxTradePair]))
139+        then throw("Trying to match orders from different trading pairs")
140+        else if ((order1[IdxOrderType] == order2[IdxOrderType]))
141+            then throw("Trying to match orders of the same type")
142+            else {
143+                let order1isSell = (order1[IdxOrderType] == SELL)
144+                let sellOrder = if (order1isSell)
145+                    then order1
146+                    else order2
147+                let buyOrder = if (!(order1isSell))
148+                    then order1
149+                    else order2
150+                let sellPrice = parseIntValue(sellOrder[IdxPrice])
151+                let buyPrice = parseIntValue(buyOrder[IdxPrice])
152+                let sellOrderAmount = parseIntValue(sellOrder[IdxAmount])
153+                let buyOrderAmount = parseIntValue(buyOrder[IdxAmount])
154+                if ((sellPrice > buyPrice))
155+                    then throw("Orders are not match by price")
156+                    else {
157+                        let exchangePrice = sellPrice
158+                        let amountAssetDecimals = if ((sellOrder[IdxAssetId] == "WAVES"))
159+                            then 8
160+                            else value(assetInfo(value(assetIdFromString(sellOrder[IdxAssetId])))).decimals
161+                        let priceAssetDecimals = if ((buyOrder[IdxAssetId] == "WAVES"))
162+                            then 8
163+                            else value(assetInfo(value(assetIdFromString(buyOrder[IdxAssetId])))).decimals
164+                        let buyAmount = ((buyOrderAmount * pow10(amountAssetDecimals)) / exchangePrice)
165+                        let sellAmount = sellOrderAmount
166+                        let amountAssetAmount = if ((buyAmount >= sellAmount))
167+                            then sellAmount
168+                            else buyAmount
169+                        let priceAssetAmount = ((amountAssetAmount * exchangePrice) / pow10(amountAssetDecimals))
170+                        let updatedBuyStr = FormatOrderDataStr(buyOrder[IdxTradePair], buyOrder[IdxSender], buyOrder[IdxOrderType], buyPrice, (buyOrderAmount - priceAssetAmount), sellOrder[IdxAssetId])
171+                        let updatedSellStr = FormatOrderDataStr(sellOrder[IdxTradePair], sellOrder[IdxSender], sellOrder[IdxOrderType], sellPrice, (sellOrderAmount - amountAssetAmount), buyOrder[IdxAssetId])
172+                        ScriptResult(WriteSet([DataEntry(if (!(order1isSell))
173+                            then order1Id
174+                            else order2Id, updatedBuyStr), DataEntry(if (order1isSell)
175+                            then order1Id
176+                            else order2Id, updatedSellStr)]), TransferSet([ScriptTransfer(addressFromStringValue(buyOrder[IdxSender]), retainMatcherFee(amountAssetAmount), assetIdFromString(sellOrder[IdxAssetId])), ScriptTransfer(addressFromStringValue(sellOrder[IdxSender]), retainMatcherFee(priceAssetAmount), assetIdFromString(buyOrder[IdxAssetId])), ScriptTransfer(i.caller, matcherFee(amountAssetAmount), assetIdFromString(sellOrder[IdxAssetId])), ScriptTransfer(i.caller, matcherFee(priceAssetAmount), assetIdFromString(buyOrder[IdxAssetId]))]))
177+                        }
178+                }
179+    }
180+
181+
182+
183+@Callable(i)
184+func cancelOrder (orderId) = {
185+    let order = ParseOrderRawDataStr(getStringValue(this, orderId))
186+    if ((addressFromStringValue(order[IdxSender]) != i.caller))
187+        then throw("Only order owner can cancel it")
188+        else {
189+            let updatedOrderStr = FormatOrderDataStr(order[IdxTradePair], order[IdxSender], order[IdxOrderType], parseIntValue(order[IdxPrice]), 0, order[IdxAssetId])
190+            ScriptResult(WriteSet([DataEntry(orderId, updatedOrderStr)]), TransferSet([ScriptTransfer(i.caller, parseIntValue(order[IdxAmount]), assetIdFromString(order[IdxAssetId]))]))
191+            }
192+    }
193+
194+
195+
196+@Callable(i)
197+func registerTraidPair (asset1,priceAsset,traidPair) = if ((i.caller == addressFromStringValue(toBase58String(adminAddress))))
198+    then WriteSet([DataEntry(((asset1 + "/") + priceAsset), traidPair)])
199+    else throw("Only administrator can register traiding pair")
200+
201+
github/deemru/w8io/026f985 
22.06 ms ◑