tx · FvekcXU8XFMVJWMUGspVG9MLYbxvY4skyYMxZViAFu2P

3NCCxt72qfGYBPUNx6zM49UDV9r4LvrtzeY:  -0.01500000 Waves

2024.04.01 18:32 [3043894] smart account 3NCCxt72qfGYBPUNx6zM49UDV9r4LvrtzeY > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FvekcXU8XFMVJWMUGspVG9MLYbxvY4skyYMxZViAFu2P",
    "fee": 1500000,
    "feeAssetId": null,
    "timestamp": 1711985605078,
    "version": 2,
    "chainId": 84,
    "sender": "3NCCxt72qfGYBPUNx6zM49UDV9r4LvrtzeY",
    "senderPublicKey": "D14bs2ieC42BPAapbooQT637A3iD7mXwJ9bgfDGXBHcX",
    "proofs": [
        "32sopN1xfdxaHXx5tnQshK9UuhWmpeazTuukzd8PctftUxPmPTRYnkoidnkfQKLXowc8dEcjZFGRpA2zCXYLtnYf"
    ],
    "script": "base64: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",
    "height": 3043894,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: GTLSsgejKNDrJR5wNYLL1vepT2AE9aNCegUhzpF2CpwT

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 7 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEPARATOR = "__"
5+
6+let KEY_MULTISIG = "MULTISIG"
7+
8+let KEY_STATUS = "STATUS"
9+
10+let KEY_INIT = "INIT"
11+
12+let KEY_SEQUENCER = "SEQUENCER"
13+
14+let KEY_ACCOUNT_STORAGE = "ACCOUNT_STORAGE"
15+
16+let KEY_FEE_RECIPIENT = "FEE_RECIPIENT"
17+
18+let KEY_SYMBOL = "SYMBOL"
19+
20+let KEY_ORDER_FILLED_AMOUNT = "ORDER_FILLED_AMOUNT"
21+
22+let FUNC_EXTERNAL_TRANSFER = "externalTransfer"
23+
24+let SPOT_WALLET = "SPOT"
25+
26+let ORDER_TYPE_LIMIT = 1
27+
28+let ORDER_TYPE_MARKET = 2
29+
30+let ORDER_VERSION_1 = 1
31+
32+let ORDER_SIDE_BUY = 1
33+
34+let ORDER_SIDE_SELL = 2
35+
36+let ZERO_BIGINT = toBigInt(0)
37+
38+let MULTIPLIER = toBigInt(100000000)
39+
40+let FEE_MAX_TOLERANCE = toBigInt(100000)
41+
42+func _validateAddress (address_,err_) = match addressFromString(address_) {
43+    case a: Address => 
44+        true
45+    case _ => 
46+        throw(err_)
47+}
48+
49+
50+func _validateBigInt (val_,lowerBoundary_,err_) = if ((lowerBoundary_ > val_))
51+    then throw(err_)
52+    else true
53+
54+
55+func _validateIntEqual (val1_,val2_,err_) = if ((val1_ != val2_))
56+    then throw(err_)
57+    else true
58+
59+
60+func _validateIntNotEqual (val1_,val2_,err_) = if ((val1_ == val2_))
61+    then throw(err_)
62+    else true
63+
64+
65+func _validateString (val_,err_) = if (if ((0 >= size(val_)))
66+    then true
67+    else contains(val_, SEPARATOR))
68+    then throw(err_)
69+    else true
70+
71+
72+func _validateStringEqual (val1_,val2_,err_) = if ((val1_ != val2_))
73+    then throw(err_)
74+    else true
75+
76+
77+func _loadInit () = match getBoolean(KEY_INIT) {
78+    case a: Boolean => 
79+        a
80+    case _ => 
81+        false
82+}
83+
84+
85+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
86+
87+
88+func _loadMultisig () = match getString(KEY_MULTISIG) {
89+    case a: String => 
90+        addressFromStringValue(a)
91+    case _ => 
92+        Address(base58'')
93+}
94+
95+
96+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
97+
98+
99+func _loadSequencer () = match getString(KEY_SEQUENCER) {
100+    case a: String => 
101+        addressFromStringValue(a)
102+    case _ => 
103+        Address(base58'')
104+}
105+
106+
107+func _saveSequencer (sequencer_) = [StringEntry(KEY_SEQUENCER, toString(sequencer_))]
108+
109+
110+func _loadAccountStorage () = match getString(KEY_ACCOUNT_STORAGE) {
111+    case a: String => 
112+        addressFromStringValue(a)
113+    case _ => 
114+        Address(base58'')
115+}
116+
117+
118+func _saveAccountStorage (accountStorage_) = [StringEntry(KEY_ACCOUNT_STORAGE, toString(accountStorage_))]
119+
120+
121+func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
122+    case a: String => 
123+        a
124+    case _ => 
125+        ""
126+}
127+
128+
129+func _saveFeeRecipient (feeRecipient_) = [StringEntry(KEY_FEE_RECIPIENT, feeRecipient_)]
130+
131+
132+func _loadSymbol (symbol_) = match getBoolean(makeString([KEY_SYMBOL, symbol_], SEPARATOR)) {
133+    case a: Boolean => 
134+        a
135+    case _ => 
136+        false
137+}
138+
139+
140+func _saveSymbol (symbol_,val_) = [BooleanEntry(makeString([KEY_SYMBOL, symbol_], SEPARATOR), val_)]
141+
142+
143+func _loadOrderFilledAmount (orderHash_) = match getString(makeString([KEY_ORDER_FILLED_AMOUNT, toBase58String(orderHash_)], SEPARATOR)) {
144+    case a: String => 
145+        parseBigIntValue(a)
146+    case _ => 
147+        ZERO_BIGINT
148+}
149+
150+
151+func _saveOrderFilledAmount (orderHash_,amount_) = [StringEntry(makeString([KEY_ORDER_FILLED_AMOUNT, toBase58String(orderHash_)], SEPARATOR), toString(amount_))]
152+
153+
154+func _onlyThisContract (caller_) = if ((caller_ != this))
155+    then throw("_onlyThisContract: revert")
156+    else true
157+
158+
159+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
160+    then throw("_whenMultisigSet: revert")
161+    else true
162+
163+
164+func _whenNotInitialized () = if (_loadInit())
165+    then throw("_whenNotInitialized: revert")
166+    else true
167+
168+
169+func _whenInitialized () = if (!(_loadInit()))
170+    then throw("_whenInitialized: revert")
171+    else true
172+
173+
174+func _validateSequencer (caller,err_) = if ((_loadSequencer() != caller))
175+    then throw(err_)
176+    else true
177+
178+
179+func _validateOrderType (type_,version_,err_) = if (if ((type_ != ORDER_TYPE_LIMIT))
180+    then (type_ != ORDER_TYPE_MARKET)
181+    else false)
182+    then throw(err_)
183+    else if ((version_ != ORDER_VERSION_1))
184+        then throw(err_)
185+        else true
186+
187+
188+func _validateOrderSymbol (symbol_,err_) = if (!(_loadSymbol(symbol_)))
189+    then throw(err_)
190+    else true
191+
192+
193+func _validateOrderSide (side_,err_) = if (if ((side_ != ORDER_SIDE_BUY))
194+    then (side_ != ORDER_SIDE_SELL)
195+    else false)
196+    then throw(err_)
197+    else true
198+
199+
200+func _validatePublicKey (publicKey_,err_) = if ((size(publicKey_) != 32))
201+    then throw(err_)
202+    else true
203+
204+
205+func _validateSignatureFormat (signature_,err_) = if ((size(signature_) != 32))
206+    then throw(err_)
207+    else true
208+
209+
210+func _validateOrderSignature (orderHash_,orderSignature_,orderPublicKey_,err_) = if (!(sigVerify(orderHash_, orderSignature_, orderPublicKey_)))
211+    then throw(err_)
212+    else true
213+
214+
215+func _validateFeeTolerance (amount_,fee_,err_) = if ((fee_ > fraction(amount_, FEE_MAX_TOLERANCE, MULTIPLIER, DOWN)))
216+    then throw(err_)
217+    else true
218+
219+
220+func _parseOrder (order_,err_) = {
221+    let fields = split(order_, SEPARATOR)
222+    let type = valueOrErrorMessage(parseInt(fields[0]), (err_ + ": inv type"))
223+    let version = valueOrErrorMessage(parseInt(fields[1]), (err_ + ": inv version"))
224+    let symbol = fields[2]
225+    let side = valueOrErrorMessage(parseInt(fields[3]), (err_ + ": inv side"))
226+    let ts = valueOrErrorMessage(parseInt(fields[4]), (err_ + ": inv ts"))
227+    let publicKey = fromBase58String(fields[5])
228+    let alg = valueOrErrorMessage(parseInt(fields[6]), (err_ + ": inv alg"))
229+    let signature = fromBase58String(fields[7])
230+    let $t062627268 = if (if ((type == ORDER_TYPE_LIMIT))
231+        then (version == ORDER_VERSION_1)
232+        else false)
233+        then {
234+            let price = valueOrErrorMessage(parseBigInt(fields[8]), (err_ + ": inv price"))
235+            let amount = valueOrErrorMessage(parseBigInt(fields[9]), (err_ + ": inv amount"))
236+            let orderDetailsBytes = (toBytes(price) + toBytes(amount))
237+            $Tuple4(price, amount, ZERO_BIGINT, orderDetailsBytes)
238+            }
239+        else if (if ((type == ORDER_TYPE_MARKET))
240+            then (version == ORDER_VERSION_1)
241+            else false)
242+            then {
243+                let amount = valueOrErrorMessage(parseBigInt(fields[8]), (err_ + ": inv amount"))
244+                let isBaseAmount = if ((valueOrErrorMessage(parseInt(fields[9]), (err_ + ": inv isBaseAmount")) == 0))
245+                    then false
246+                    else true
247+                if (isBaseAmount)
248+                    then $Tuple4(ZERO_BIGINT, amount, ZERO_BIGINT, (toBytes(amount) + toBytes(1)))
249+                    else $Tuple4(ZERO_BIGINT, ZERO_BIGINT, amount, (toBytes(amount) + toBytes(0)))
250+                }
251+            else throw((err_ + ": inv type & version"))
252+    let price = $t062627268._1
253+    let baseAmount = $t062627268._2
254+    let quoteAmount = $t062627268._3
255+    let orderDetailsBytes = $t062627268._4
256+    let orderBytes = ((((((((toBytes(type) + toBytes(version)) + toBytes(size(symbol))) + toBytes(symbol)) + toBytes(side)) + toBytes(ts)) + publicKey) + toBytes(alg)) + orderDetailsBytes)
257+    let orderHash = keccak256_32Kb(orderBytes)
258+    let err = if (if (if (if (if (if (if (_validateOrderType(type, version, (err_ + "inv order type")))
259+        then _validateOrderSymbol(symbol, (err_ + "inv order symbol"))
260+        else false)
261+        then _validateOrderSide(side, (err_ + "inv order side"))
262+        else false)
263+        then _validatePublicKey(publicKey, (err_ + "inv order public key"))
264+        else false)
265+        then _validateSignatureFormat(signature, (err_ + "inv sig format"))
266+        else false)
267+        then _validateBigInt(price, ZERO_BIGINT, (err_ + "neg price"))
268+        else false)
269+        then _validateBigInt(baseAmount, ZERO_BIGINT, (err_ + "neg base amount"))
270+        else false)
271+        then _validateBigInt(quoteAmount, ZERO_BIGINT, (err_ + "neg quote amount"))
272+        else false
273+    if ((err == err))
274+        then $Tuple10(type, symbol, side, price, baseAmount, quoteAmount, orderHash, publicKey, alg, signature)
275+        else throw("Strict value is not equal to itself.")
276+    }
277+
278+
279+@Callable(i)
280+func init (sequencer_,accountStorage_,feeRecipient_) = {
281+    let err = if (if (if (if (if (_onlyThisContract(i.caller))
282+        then _whenNotInitialized()
283+        else false)
284+        then _whenMultisigSet()
285+        else false)
286+        then _validateAddress(sequencer_, "init: invalid sequencer")
287+        else false)
288+        then _validateAddress(accountStorage_, "init: invalid accountStorage")
289+        else false)
290+        then _validateString(feeRecipient_, "init: invalid feeRecipient")
291+        else false
292+    if ((err == err))
293+        then $Tuple2((((_saveInit(true) ++ _saveSequencer(addressFromStringValue(sequencer_))) ++ _saveAccountStorage(addressFromStringValue(accountStorage_))) ++ _saveFeeRecipient(feeRecipient_)), unit)
294+        else throw("Strict value is not equal to itself.")
295+    }
296+
297+
298+
299+@Callable(i)
300+func trade (makerOrder_,takerOrder_,baseFee_,quoteFee_) = {
301+    let $t090749406 = _parseOrder(makerOrder_, "trade: invalid maker order")
302+    let makerOrderType = $t090749406._1
303+    let makerOrderSymbol = $t090749406._2
304+    let makerOrderSide = $t090749406._3
305+    let makerOrderPrice = $t090749406._4
306+    let makerOrderBaseAmount = $t090749406._5
307+    let makerOrderQuoteAmount = $t090749406._6
308+    let makerOrderHash = $t090749406._7
309+    let makerOrderPublicKey = $t090749406._8
310+    let makerOrderAlg = $t090749406._9
311+    let makerOrderSignature = $t090749406._10
312+    let $t094129744 = _parseOrder(takerOrder_, "trade: invalid taker order")
313+    let takerOrderType = $t094129744._1
314+    let takerOrderSymbol = $t094129744._2
315+    let takerOrderSide = $t094129744._3
316+    let takerOrderPrice = $t094129744._4
317+    let takerOrderBaseAmount = $t094129744._5
318+    let takerOrderQuoteAmount = $t094129744._6
319+    let takerOrderHash = $t094129744._7
320+    let takerOrderPublicKey = $t094129744._8
321+    let takerOrderAlg = $t094129744._9
322+    let takerOrderSignature = $t094129744._10
323+    let baseFee = valueOrErrorMessage(parseBigInt(baseFee_), "trade: baseFee not int")
324+    let quoteFee = valueOrErrorMessage(parseBigInt(quoteFee_), "trade: quoteFee not int")
325+    let tradePrice = makerOrderPrice
326+    let makerOrderFilledAmount = _loadOrderFilledAmount(makerOrderHash)
327+    let makerOrderBaseAmountFree = (makerOrderBaseAmount - makerOrderFilledAmount)
328+    let takerOrderFilledAmount = _loadOrderFilledAmount(takerOrderHash)
329+    let takerOrderBaseAmountFree = if ((takerOrderBaseAmount == ZERO_BIGINT))
330+        then fraction((takerOrderQuoteAmount - takerOrderFilledAmount), MULTIPLIER, tradePrice, DOWN)
331+        else (takerOrderBaseAmount - takerOrderFilledAmount)
332+    let tradeBaseAmount = min([makerOrderBaseAmountFree, takerOrderBaseAmountFree])
333+    let tradeQuoteAmount = fraction(tradeBaseAmount, tradePrice, MULTIPLIER, DOWN)
334+    let err = if (if (if (if (if (if (_validateSequencer(i.caller, "trade: invalid sequencer"))
335+        then _validateBigInt(tradeBaseAmount, ZERO_BIGINT, "trade: neg trade amount")
336+        else false)
337+        then _validateIntEqual(makerOrderType, ORDER_TYPE_LIMIT, "trade: maker is not limit")
338+        else false)
339+        then _validateStringEqual(makerOrderSymbol, takerOrderSymbol, "trade: symbol mismatch")
340+        else false)
341+        then _validateIntNotEqual(makerOrderSide, takerOrderSide, "trade: side mismatch")
342+        else false)
343+        then _validateOrderSignature(makerOrderHash, makerOrderSignature, makerOrderPublicKey, "trade: invalid maker sig")
344+        else false)
345+        then _validateOrderSignature(takerOrderHash, takerOrderSignature, takerOrderPublicKey, "trade: invalid taker sig")
346+        else false
347+    if ((err == err))
348+        then {
349+            let $t01141611867 = if ((makerOrderSide == ORDER_SIDE_BUY))
350+                then $Tuple2(makerOrderPublicKey, takerOrderPublicKey)
351+                else $Tuple2(takerOrderPublicKey, makerOrderPublicKey)
352+            let buyer = $t01141611867._1
353+            let seller = $t01141611867._2
354+            let err1 = if (_validateFeeTolerance(tradeBaseAmount, baseFee, "trade: base fee too much"))
355+                then _validateFeeTolerance(tradeQuoteAmount, quoteFee, "trade: quote fee too much")
356+                else false
357+            if ((err1 == err1))
358+                then {
359+                    let assets = split(makerOrderSymbol, "-")
360+                    let baseAsset = assets[0]
361+                    let quoteAsset = assets[1]
362+                    let feeRecipient = _loadFeeRecipient()
363+                    let storageInvocation = invoke(_loadAccountStorage(), FUNC_EXTERNAL_TRANSFER, [SPOT_WALLET, baseAsset, seller, buyer, tradeBaseAmount, baseFee, feeRecipient], nil)
364+                    if ((storageInvocation == storageInvocation))
365+                        then {
366+                            let storageInvocation1 = invoke(_loadAccountStorage(), FUNC_EXTERNAL_TRANSFER, [SPOT_WALLET, quoteAsset, buyer, seller, tradeQuoteAmount, quoteFee, feeRecipient], nil)
367+                            if ((storageInvocation1 == storageInvocation1))
368+                                then {
369+                                    let newMakerOrderFilledAmount = (makerOrderFilledAmount + tradeBaseAmount)
370+                                    let newTakerOrderFilledAmount = if ((takerOrderBaseAmount == ZERO_BIGINT))
371+                                        then (takerOrderFilledAmount + tradeQuoteAmount)
372+                                        else (takerOrderFilledAmount + tradeBaseAmount)
373+                                    $Tuple2((_saveOrderFilledAmount(makerOrderHash, newMakerOrderFilledAmount) ++ _saveOrderFilledAmount(takerOrderHash, newTakerOrderFilledAmount)), unit)
374+                                    }
375+                                else throw("Strict value is not equal to itself.")
376+                            }
377+                        else throw("Strict value is not equal to itself.")
378+                    }
379+                else throw("Strict value is not equal to itself.")
380+            }
381+        else throw("Strict value is not equal to itself.")
382+    }
383+
384+
385+
386+@Callable(i)
387+func updateSymbol (symbol_,allowance_) = {
388+    let err = if (_onlyThisContract(i.caller))
389+        then _validateString(symbol_, "updateSymbol: invalid symbol")
390+        else false
391+    if ((err == err))
392+        then $Tuple2(_saveSymbol(symbol_, allowance_), unit)
393+        else throw("Strict value is not equal to itself.")
394+    }
395+
396+
397+
398+@Callable(i)
399+func setMultisig (multisig_) = {
400+    let err = if (_onlyThisContract(i.caller))
401+        then _validateAddress(multisig_, "setMultisig: invalid multisig")
402+        else false
403+    if ((err == err))
404+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
405+        else throw("Strict value is not equal to itself.")
406+    }
407+
408+
409+@Verifier(tx)
410+func verify () = match getString(KEY_MULTISIG) {
411+    case multisig: String => 
412+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
413+    case _ => 
414+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
415+}
416+
github/deemru/w8io/169f3d6 
27.25 ms ◑