tx · 7yPFiZudnRcoUjkKB91zXQ2YXtNoiw3gbDfPNdSsQisT

3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4:  -0.01800000 Waves

2024.12.17 13:18 [3418433] smart account 3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7yPFiZudnRcoUjkKB91zXQ2YXtNoiw3gbDfPNdSsQisT",
    "fee": 1800000,
    "feeAssetId": null,
    "timestamp": 1734430622827,
    "version": 2,
    "chainId": 84,
    "sender": "3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4",
    "senderPublicKey": "9eCupW2UoCBhmiF1N9qWACCzkWT885DVzb65b8zxcSii",
    "proofs": [
        "3wDj6Mvy5hFuAZCEAGXfN4gxcTeVMjT7bTVrEF6AhBmfyMVdHZW3Cm676sPwY8q1S75jSCaxfnnnG2erT8foiNrr"
    ],
    "script": "base64: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",
    "height": 3418433,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3uJdmYkbWwVbFaNh4BJLywXMi3vfWU4DmTqXD2xJPkvD
Next: none

Diff: 
Old
New
Differences
283
283
 
    }
284
284
 
285
285
 
286
-
func _validateFeeTolerance (amount_,fee_,err_) = if ((fee_ > fraction(amount_, FEE_MAX_TOLERANCE, MULTIPLIER, DOWN)))
286
+
func _validateFeeTolerance (amount_,fee_,err_) = if ((fee_ > fraction(amount_, FEE_MAX_TOLERANCE, MULTIPLIER, CEILING)))
287
287
 
    then throw(err_)
288
288
 
    else true
289
289
 
298
298
 
    let web3Id = fromBase58String(fields[5])
299
299
 
    let alg = valueOrErrorMessage(parseInt(fields[6]), (err_ + ": inv alg"))
300
300
 
    let signature = fromBase58String(fields[7])
301
-
    let $t084629500 = if (if ((type == ORDER_TYPE_LIMIT))
301
+
    let $t084659503 = if (if ((type == ORDER_TYPE_LIMIT))
302
302
 
        then (version == ORDER_VERSION_1)
303
303
 
        else false)
304
304
 
        then {
320
320
 
                    else $Tuple4(ZERO_BIGINT, ZERO_BIGINT, amount, (toBytes(amount) + toBytes(ZERO_BIGINT)))
321
321
 
                }
322
322
 
            else throw((err_ + ": inv type & version"))
323
-
    let price = $t084629500._1
324
-
    let baseAmount = $t084629500._2
325
-
    let quoteAmount = $t084629500._3
326
-
    let orderDetailsBytes = $t084629500._4
323
+
    let price = $t084659503._1
324
+
    let baseAmount = $t084659503._2
325
+
    let quoteAmount = $t084659503._3
326
+
    let orderDetailsBytes = $t084659503._4
327
327
 
    let orderBytes = ((((((((toBytes(type) + toBytes(version)) + toBytes(size(symbol))) + toBytes(symbol)) + toBytes(side)) + toBytes(ts)) + web3Id) + toBytes(alg)) + orderDetailsBytes)
328
328
 
    let orderHash = keccak256_32Kb(orderBytes)
329
329
 
    let err = if (if (if (if (if (if (if (_validateOrderType(type, version, (err_ + ": inv order type")))
369
369
 
370
370
 
@Callable(i)
371
371
 
func trade (makerOrder_,takerOrder_,baseFee_,quoteFee_) = {
372
-
    let $t01131611645 = _parseOrder(makerOrder_, "trade: invalid maker order")
373
-
    let makerOrderType = $t01131611645._1
374
-
    let makerOrderSymbol = $t01131611645._2
375
-
    let makerOrderSide = $t01131611645._3
376
-
    let makerOrderPrice = $t01131611645._4
377
-
    let makerOrderBaseAmount = $t01131611645._5
378
-
    let makerOrderQuoteAmount = $t01131611645._6
379
-
    let makerOrderHash = $t01131611645._7
380
-
    let makerOrderWeb3Id = $t01131611645._8
381
-
    let makerOrderAlg = $t01131611645._9
382
-
    let makerOrderSignature = $t01131611645._10
383
-
    let $t01165111980 = _parseOrder(takerOrder_, "trade: invalid taker order")
384
-
    let takerOrderType = $t01165111980._1
385
-
    let takerOrderSymbol = $t01165111980._2
386
-
    let takerOrderSide = $t01165111980._3
387
-
    let takerOrderPrice = $t01165111980._4
388
-
    let takerOrderBaseAmount = $t01165111980._5
389
-
    let takerOrderQuoteAmount = $t01165111980._6
390
-
    let takerOrderHash = $t01165111980._7
391
-
    let takerOrderWeb3Id = $t01165111980._8
392
-
    let takerOrderAlg = $t01165111980._9
393
-
    let takerOrderSignature = $t01165111980._10
372
+
    let $t01131911648 = _parseOrder(makerOrder_, "trade: invalid maker order")
373
+
    let makerOrderType = $t01131911648._1
374
+
    let makerOrderSymbol = $t01131911648._2
375
+
    let makerOrderSide = $t01131911648._3
376
+
    let makerOrderPrice = $t01131911648._4
377
+
    let makerOrderBaseAmount = $t01131911648._5
378
+
    let makerOrderQuoteAmount = $t01131911648._6
379
+
    let makerOrderHash = $t01131911648._7
380
+
    let makerOrderWeb3Id = $t01131911648._8
381
+
    let makerOrderAlg = $t01131911648._9
382
+
    let makerOrderSignature = $t01131911648._10
383
+
    let $t01165411983 = _parseOrder(takerOrder_, "trade: invalid taker order")
384
+
    let takerOrderType = $t01165411983._1
385
+
    let takerOrderSymbol = $t01165411983._2
386
+
    let takerOrderSide = $t01165411983._3
387
+
    let takerOrderPrice = $t01165411983._4
388
+
    let takerOrderBaseAmount = $t01165411983._5
389
+
    let takerOrderQuoteAmount = $t01165411983._6
390
+
    let takerOrderHash = $t01165411983._7
391
+
    let takerOrderWeb3Id = $t01165411983._8
392
+
    let takerOrderAlg = $t01165411983._9
393
+
    let takerOrderSignature = $t01165411983._10
394
394
 
    let baseFee = valueOrErrorMessage(parseBigInt(baseFee_), "trade: baseFee not int")
395
395
 
    let quoteFee = valueOrErrorMessage(parseBigInt(quoteFee_), "trade: quoteFee not int")
396
396
 
    let tradePrice = makerOrderPrice
425
425
 
        then {
426
426
 
            let makerAddress = _convertWeb3IdToAddress(makerOrderWeb3Id, makerOrderAlg)
427
427
 
            let takerAddress = _convertWeb3IdToAddress(takerOrderWeb3Id, takerOrderAlg)
428
-
            let $t01413714560 = if ((makerOrderSide == ORDER_SIDE_BUY))
428
+
            let $t01414014563 = if ((makerOrderSide == ORDER_SIDE_BUY))
429
429
 
                then $Tuple2(makerAddress, takerAddress)
430
430
 
                else $Tuple2(takerAddress, makerAddress)
431
-
            let buyer = $t01413714560._1
432
-
            let seller = $t01413714560._2
431
+
            let buyer = $t01414014563._1
432
+
            let seller = $t01414014563._2
433
433
 
            let assets = split(makerOrderSymbol, "-")
434
434
 
            let baseAsset = assets[0]
435
435
 
            let quoteAsset = assets[1]
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 7 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SEPARATOR = "__"
5
5
 
6
6
 
let KEY_MULTISIG = "MULTISIG"
7
7
 
8
8
 
let KEY_STATUS = "STATUS"
9
9
 
10
10
 
let KEY_INIT = "INIT"
11
11
 
12
12
 
let KEY_SEQUENCER = "SEQUENCER"
13
13
 
14
14
 
let KEY_ACCOUNT_STORAGE = "ACCOUNT_STORAGE"
15
15
 
16
16
 
let KEY_FEE_RECIPIENT = "FEE_RECIPIENT"
17
17
 
18
18
 
let KEY_SYMBOL = "SYMBOL"
19
19
 
20
20
 
let KEY_ORDER_FILLED_AMOUNT = "ORDER_FILLED_AMOUNT"
21
21
 
22
22
 
let KEY_REWARD_DISTRIBUTOR = "REWARD_DISTRIBUTOR"
23
23
 
24
24
 
let FUNC_EXTERNAL_TRANSFER = "externalTransfer"
25
25
 
26
26
 
let FUNC_CLAIM_REWARD = "claimReward"
27
27
 
28
28
 
let SPOT_WALLET = "SPOT"
29
29
 
30
30
 
let ORDER_TYPE_LIMIT = 1
31
31
 
32
32
 
let ORDER_TYPE_MARKET = 2
33
33
 
34
34
 
let ORDER_VERSION_1 = 1
35
35
 
36
36
 
let ORDER_SIDE_BUY = 1
37
37
 
38
38
 
let ORDER_SIDE_SELL = 2
39
39
 
40
40
 
let ALG_TYPE_WAVES = 1
41
41
 
42
42
 
let ALG_TYPE_EVM = 2
43
43
 
44
44
 
let ZERO_BIGINT = toBigInt(0)
45
45
 
46
46
 
let ONE_BIGINT = toBigInt(1)
47
47
 
48
48
 
let MULTIPLIER = toBigInt(100000000)
49
49
 
50
50
 
let FEE_MAX_TOLERANCE = toBigInt(100000)
51
51
 
52
52
 
let WAVES_PREFIX = base58'7YXq4t'
53
53
 
54
54
 
let EVM_PREFIX = base58'G5Nu92G2p7moXW9qjjN3na7gtq4dWCeVdaSjry'
55
55
 
56
56
 
func _validateAddress (address_,err_) = match addressFromString(address_) {
57
57
 
    case a: Address => 
58
58
 
        true
59
59
 
    case _ => 
60
60
 
        throw(err_)
61
61
 
}
62
62
 
63
63
 
64
64
 
func _validateBigInt (val_,lowerBoundary_,err_) = if ((lowerBoundary_ > val_))
65
65
 
    then throw(err_)
66
66
 
    else true
67
67
 
68
68
 
69
69
 
func _validateIntEqual (val1_,val2_,err_) = if ((val1_ != val2_))
70
70
 
    then throw(err_)
71
71
 
    else true
72
72
 
73
73
 
74
74
 
func _validateIntNotEqual (val1_,val2_,err_) = if ((val1_ == val2_))
75
75
 
    then throw(err_)
76
76
 
    else true
77
77
 
78
78
 
79
79
 
func _validateString (val_,err_) = if (if ((0 >= size(val_)))
80
80
 
    then true
81
81
 
    else contains(val_, SEPARATOR))
82
82
 
    then throw(err_)
83
83
 
    else true
84
84
 
85
85
 
86
86
 
func _validateStringEqual (val1_,val2_,err_) = if ((val1_ != val2_))
87
87
 
    then throw(err_)
88
88
 
    else true
89
89
 
90
90
 
91
91
 
func _loadInit () = match getBoolean(KEY_INIT) {
92
92
 
    case a: Boolean => 
93
93
 
        a
94
94
 
    case _ => 
95
95
 
        false
96
96
 
}
97
97
 
98
98
 
99
99
 
func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
100
100
 
101
101
 
102
102
 
func _loadMultisig () = match getString(KEY_MULTISIG) {
103
103
 
    case a: String => 
104
104
 
        addressFromStringValue(a)
105
105
 
    case _ => 
106
106
 
        Address(base58'')
107
107
 
}
108
108
 
109
109
 
110
110
 
func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
111
111
 
112
112
 
113
113
 
func _loadSequencer () = match getString(KEY_SEQUENCER) {
114
114
 
    case a: String => 
115
115
 
        addressFromStringValue(a)
116
116
 
    case _ => 
117
117
 
        Address(base58'')
118
118
 
}
119
119
 
120
120
 
121
121
 
func _saveSequencer (sequencer_) = [StringEntry(KEY_SEQUENCER, toString(sequencer_))]
122
122
 
123
123
 
124
124
 
func _loadAccountStorage () = match getString(KEY_ACCOUNT_STORAGE) {
125
125
 
    case a: String => 
126
126
 
        addressFromStringValue(a)
127
127
 
    case _ => 
128
128
 
        Address(base58'')
129
129
 
}
130
130
 
131
131
 
132
132
 
func _saveAccountStorage (accountStorage_) = [StringEntry(KEY_ACCOUNT_STORAGE, toString(accountStorage_))]
133
133
 
134
134
 
135
135
 
func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
136
136
 
    case a: String => 
137
137
 
        a
138
138
 
    case _ => 
139
139
 
        ""
140
140
 
}
141
141
 
142
142
 
143
143
 
func _saveFeeRecipient (feeRecipient_) = [StringEntry(KEY_FEE_RECIPIENT, feeRecipient_)]
144
144
 
145
145
 
146
146
 
func _loadRewardDistributor () = match getString(KEY_REWARD_DISTRIBUTOR) {
147
147
 
    case a: String => 
148
148
 
        a
149
149
 
    case _ => 
150
150
 
        ""
151
151
 
}
152
152
 
153
153
 
154
154
 
func _saveRewardDistributor (distributor_) = [StringEntry(KEY_REWARD_DISTRIBUTOR, distributor_)]
155
155
 
156
156
 
157
157
 
func _loadSymbol (symbol_) = match getBoolean(makeString([KEY_SYMBOL, symbol_], SEPARATOR)) {
158
158
 
    case a: Boolean => 
159
159
 
        a
160
160
 
    case _ => 
161
161
 
        false
162
162
 
}
163
163
 
164
164
 
165
165
 
func _saveSymbol (symbol_,val_) = [BooleanEntry(makeString([KEY_SYMBOL, symbol_], SEPARATOR), val_)]
166
166
 
167
167
 
168
168
 
func _loadOrderFilledAmount (orderHash_) = match getString(makeString([KEY_ORDER_FILLED_AMOUNT, toBase58String(orderHash_)], SEPARATOR)) {
169
169
 
    case a: String => 
170
170
 
        parseBigIntValue(a)
171
171
 
    case _ => 
172
172
 
        ZERO_BIGINT
173
173
 
}
174
174
 
175
175
 
176
176
 
func _saveOrderFilledAmount (orderHash_,amount_) = [StringEntry(makeString([KEY_ORDER_FILLED_AMOUNT, toBase58String(orderHash_)], SEPARATOR), toString(amount_))]
177
177
 
178
178
 
179
179
 
func _onlyThisContract (caller_) = if ((caller_ != this))
180
180
 
    then throw("_onlyThisContract: revert")
181
181
 
    else true
182
182
 
183
183
 
184
184
 
func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
185
185
 
    then throw("_whenMultisigSet: revert")
186
186
 
    else true
187
187
 
188
188
 
189
189
 
func _whenNotInitialized () = if (_loadInit())
190
190
 
    then throw("_whenNotInitialized: revert")
191
191
 
    else true
192
192
 
193
193
 
194
194
 
func _whenInitialized () = if (!(_loadInit()))
195
195
 
    then throw("_whenInitialized: revert")
196
196
 
    else true
197
197
 
198
198
 
199
199
 
func _validateSequencer (caller,err_) = if ((_loadSequencer() != caller))
200
200
 
    then throw(err_)
201
201
 
    else true
202
202
 
203
203
 
204
204
 
func _validateOrderType (type_,version_,err_) = if (if ((type_ != ORDER_TYPE_LIMIT))
205
205
 
    then (type_ != ORDER_TYPE_MARKET)
206
206
 
    else false)
207
207
 
    then throw(err_)
208
208
 
    else if ((version_ != ORDER_VERSION_1))
209
209
 
        then throw(err_)
210
210
 
        else true
211
211
 
212
212
 
213
213
 
func _validateOrderSymbol (symbol_,err_) = if (!(_loadSymbol(symbol_)))
214
214
 
    then throw(err_)
215
215
 
    else true
216
216
 
217
217
 
218
218
 
func _validateOrderSide (side_,err_) = if (if ((side_ != ORDER_SIDE_BUY))
219
219
 
    then (side_ != ORDER_SIDE_SELL)
220
220
 
    else false)
221
221
 
    then throw(err_)
222
222
 
    else true
223
223
 
224
224
 
225
225
 
func _validateOrderPrices (makerOrderPrice_,takerOrderPrice_,takerOrderSide_,takerOrderType_,err_) = {
226
226
 
    let result = if ((takerOrderType_ == ORDER_TYPE_MARKET))
227
227
 
        then true
228
228
 
        else if ((takerOrderSide_ == ORDER_SIDE_BUY))
229
229
 
            then (takerOrderPrice_ >= makerOrderPrice_)
230
230
 
            else if ((takerOrderSide_ == ORDER_SIDE_SELL))
231
231
 
                then (makerOrderPrice_ >= takerOrderPrice_)
232
232
 
                else false
233
233
 
    if (!(result))
234
234
 
        then throw(err_)
235
235
 
        else true
236
236
 
    }
237
237
 
238
238
 
239
239
 
func _validateSignatureFormat (signature_,alg_,err_) = if ((alg_ == ALG_TYPE_WAVES))
240
240
 
    then if ((size(signature_) != 64))
241
241
 
        then throw(err_)
242
242
 
        else true
243
243
 
    else if ((alg_ == ALG_TYPE_EVM))
244
244
 
        then if ((size(signature_) != 65))
245
245
 
            then throw(err_)
246
246
 
            else true
247
247
 
        else throw((err_ + ": inv alg"))
248
248
 
249
249
 
250
250
 
func _validateWeb3Id (web3Id_,alg_,err_) = if ((alg_ == ALG_TYPE_WAVES))
251
251
 
    then if ((size(web3Id_) != 32))
252
252
 
        then throw(err_)
253
253
 
        else true
254
254
 
    else if ((alg_ == ALG_TYPE_EVM))
255
255
 
        then if ((size(web3Id_) != 20))
256
256
 
            then throw(err_)
257
257
 
            else true
258
258
 
        else throw((err_ + ": inv alg"))
259
259
 
260
260
 
261
261
 
func _convertWeb3IdToAddress (web3Id_,alg_) = if ((alg_ == ALG_TYPE_WAVES))
262
262
 
    then toString(addressFromPublicKey(web3Id_))
263
263
 
    else if ((alg_ == ALG_TYPE_EVM))
264
264
 
        then ("0x" + toBase16String(web3Id_))
265
265
 
        else throw("_convertWeb3IdToAddress: revert")
266
266
 
267
267
 
268
268
 
func _validateOrderSignature (orderHash_,signature_,web3Id_,alg_,err_) = {
269
269
 
    let result = if ((alg_ == ALG_TYPE_WAVES))
270
270
 
        then {
271
271
 
            let msg = (WAVES_PREFIX + toBytes(toBase58String(orderHash_)))
272
272
 
            sigVerify(msg, signature_, web3Id_)
273
273
 
            }
274
274
 
        else if ((alg_ == ALG_TYPE_EVM))
275
275
 
            then {
276
276
 
                let hashWithPrefix = keccak256_16Kb((EVM_PREFIX + orderHash_))
277
277
 
                (takeRight(keccak256_16Kb(ecrecover(hashWithPrefix, signature_)), 20) == web3Id_)
278
278
 
                }
279
279
 
            else throw((err_ + ": inv alg"))
280
280
 
    if (!(result))
281
281
 
        then throw(err_)
282
282
 
        else true
283
283
 
    }
284
284
 
285
285
 
286
-
func _validateFeeTolerance (amount_,fee_,err_) = if ((fee_ > fraction(amount_, FEE_MAX_TOLERANCE, MULTIPLIER, DOWN)))
286
+
func _validateFeeTolerance (amount_,fee_,err_) = if ((fee_ > fraction(amount_, FEE_MAX_TOLERANCE, MULTIPLIER, CEILING)))
287
287
 
    then throw(err_)
288
288
 
    else true
289
289
 
290
290
 
291
291
 
func _parseOrder (order_,err_) = {
292
292
 
    let fields = split(order_, SEPARATOR)
293
293
 
    let type = valueOrErrorMessage(parseInt(fields[0]), (err_ + ": inv type"))
294
294
 
    let version = valueOrErrorMessage(parseInt(fields[1]), (err_ + ": inv version"))
295
295
 
    let symbol = fields[2]
296
296
 
    let side = valueOrErrorMessage(parseInt(fields[3]), (err_ + ": inv side"))
297
297
 
    let ts = valueOrErrorMessage(parseInt(fields[4]), (err_ + ": inv ts"))
298
298
 
    let web3Id = fromBase58String(fields[5])
299
299
 
    let alg = valueOrErrorMessage(parseInt(fields[6]), (err_ + ": inv alg"))
300
300
 
    let signature = fromBase58String(fields[7])
301
-
    let $t084629500 = if (if ((type == ORDER_TYPE_LIMIT))
301
+
    let $t084659503 = if (if ((type == ORDER_TYPE_LIMIT))
302
302
 
        then (version == ORDER_VERSION_1)
303
303
 
        else false)
304
304
 
        then {
305
305
 
            let price = valueOrErrorMessage(parseBigInt(fields[8]), (err_ + ": inv price"))
306
306
 
            let amount = valueOrErrorMessage(parseBigInt(fields[9]), (err_ + ": inv amount"))
307
307
 
            let orderDetailsBytes = (toBytes(price) + toBytes(amount))
308
308
 
            $Tuple4(price, amount, ZERO_BIGINT, orderDetailsBytes)
309
309
 
            }
310
310
 
        else if (if ((type == ORDER_TYPE_MARKET))
311
311
 
            then (version == ORDER_VERSION_1)
312
312
 
            else false)
313
313
 
            then {
314
314
 
                let amount = valueOrErrorMessage(parseBigInt(fields[8]), (err_ + ": inv amount"))
315
315
 
                let isBaseAmount = if ((valueOrErrorMessage(parseBigInt(fields[9]), (err_ + ": inv isBaseAmount")) == ZERO_BIGINT))
316
316
 
                    then false
317
317
 
                    else true
318
318
 
                if (isBaseAmount)
319
319
 
                    then $Tuple4(ZERO_BIGINT, amount, ZERO_BIGINT, (toBytes(amount) + toBytes(ONE_BIGINT)))
320
320
 
                    else $Tuple4(ZERO_BIGINT, ZERO_BIGINT, amount, (toBytes(amount) + toBytes(ZERO_BIGINT)))
321
321
 
                }
322
322
 
            else throw((err_ + ": inv type & version"))
323
-
    let price = $t084629500._1
324
-
    let baseAmount = $t084629500._2
325
-
    let quoteAmount = $t084629500._3
326
-
    let orderDetailsBytes = $t084629500._4
323
+
    let price = $t084659503._1
324
+
    let baseAmount = $t084659503._2
325
+
    let quoteAmount = $t084659503._3
326
+
    let orderDetailsBytes = $t084659503._4
327
327
 
    let orderBytes = ((((((((toBytes(type) + toBytes(version)) + toBytes(size(symbol))) + toBytes(symbol)) + toBytes(side)) + toBytes(ts)) + web3Id) + toBytes(alg)) + orderDetailsBytes)
328
328
 
    let orderHash = keccak256_32Kb(orderBytes)
329
329
 
    let err = if (if (if (if (if (if (if (_validateOrderType(type, version, (err_ + ": inv order type")))
330
330
 
        then _validateOrderSymbol(symbol, (err_ + ": inv order symbol"))
331
331
 
        else false)
332
332
 
        then _validateOrderSide(side, (err_ + ": inv order side"))
333
333
 
        else false)
334
334
 
        then _validateWeb3Id(web3Id, alg, (err_ + ": inv order web3Id"))
335
335
 
        else false)
336
336
 
        then _validateSignatureFormat(signature, alg, (err_ + ": inv sig format"))
337
337
 
        else false)
338
338
 
        then _validateBigInt(price, ZERO_BIGINT, (err_ + ": neg price"))
339
339
 
        else false)
340
340
 
        then _validateBigInt(baseAmount, ZERO_BIGINT, (err_ + ": neg base amount"))
341
341
 
        else false)
342
342
 
        then _validateBigInt(quoteAmount, ZERO_BIGINT, (err_ + ": neg quote amount"))
343
343
 
        else false
344
344
 
    if ((err == err))
345
345
 
        then $Tuple10(type, symbol, side, price, baseAmount, quoteAmount, orderHash, web3Id, alg, signature)
346
346
 
        else throw("Strict value is not equal to itself.")
347
347
 
    }
348
348
 
349
349
 
350
350
 
@Callable(i)
351
351
 
func init (sequencer_,accountStorage_,feeRecipient_) = {
352
352
 
    let err = if (if (if (if (if (_onlyThisContract(i.caller))
353
353
 
        then _whenNotInitialized()
354
354
 
        else false)
355
355
 
        then _whenMultisigSet()
356
356
 
        else false)
357
357
 
        then _validateAddress(sequencer_, "init: invalid sequencer")
358
358
 
        else false)
359
359
 
        then _validateAddress(accountStorage_, "init: invalid accountStorage")
360
360
 
        else false)
361
361
 
        then _validateString(feeRecipient_, "init: invalid feeRecipient")
362
362
 
        else false
363
363
 
    if ((err == err))
364
364
 
        then $Tuple2((((_saveInit(true) ++ _saveSequencer(addressFromStringValue(sequencer_))) ++ _saveAccountStorage(addressFromStringValue(accountStorage_))) ++ _saveFeeRecipient(feeRecipient_)), unit)
365
365
 
        else throw("Strict value is not equal to itself.")
366
366
 
    }
367
367
 
368
368
 
369
369
 
370
370
 
@Callable(i)
371
371
 
func trade (makerOrder_,takerOrder_,baseFee_,quoteFee_) = {
372
-
    let $t01131611645 = _parseOrder(makerOrder_, "trade: invalid maker order")
373
-
    let makerOrderType = $t01131611645._1
374
-
    let makerOrderSymbol = $t01131611645._2
375
-
    let makerOrderSide = $t01131611645._3
376
-
    let makerOrderPrice = $t01131611645._4
377
-
    let makerOrderBaseAmount = $t01131611645._5
378
-
    let makerOrderQuoteAmount = $t01131611645._6
379
-
    let makerOrderHash = $t01131611645._7
380
-
    let makerOrderWeb3Id = $t01131611645._8
381
-
    let makerOrderAlg = $t01131611645._9
382
-
    let makerOrderSignature = $t01131611645._10
383
-
    let $t01165111980 = _parseOrder(takerOrder_, "trade: invalid taker order")
384
-
    let takerOrderType = $t01165111980._1
385
-
    let takerOrderSymbol = $t01165111980._2
386
-
    let takerOrderSide = $t01165111980._3
387
-
    let takerOrderPrice = $t01165111980._4
388
-
    let takerOrderBaseAmount = $t01165111980._5
389
-
    let takerOrderQuoteAmount = $t01165111980._6
390
-
    let takerOrderHash = $t01165111980._7
391
-
    let takerOrderWeb3Id = $t01165111980._8
392
-
    let takerOrderAlg = $t01165111980._9
393
-
    let takerOrderSignature = $t01165111980._10
372
+
    let $t01131911648 = _parseOrder(makerOrder_, "trade: invalid maker order")
373
+
    let makerOrderType = $t01131911648._1
374
+
    let makerOrderSymbol = $t01131911648._2
375
+
    let makerOrderSide = $t01131911648._3
376
+
    let makerOrderPrice = $t01131911648._4
377
+
    let makerOrderBaseAmount = $t01131911648._5
378
+
    let makerOrderQuoteAmount = $t01131911648._6
379
+
    let makerOrderHash = $t01131911648._7
380
+
    let makerOrderWeb3Id = $t01131911648._8
381
+
    let makerOrderAlg = $t01131911648._9
382
+
    let makerOrderSignature = $t01131911648._10
383
+
    let $t01165411983 = _parseOrder(takerOrder_, "trade: invalid taker order")
384
+
    let takerOrderType = $t01165411983._1
385
+
    let takerOrderSymbol = $t01165411983._2
386
+
    let takerOrderSide = $t01165411983._3
387
+
    let takerOrderPrice = $t01165411983._4
388
+
    let takerOrderBaseAmount = $t01165411983._5
389
+
    let takerOrderQuoteAmount = $t01165411983._6
390
+
    let takerOrderHash = $t01165411983._7
391
+
    let takerOrderWeb3Id = $t01165411983._8
392
+
    let takerOrderAlg = $t01165411983._9
393
+
    let takerOrderSignature = $t01165411983._10
394
394
 
    let baseFee = valueOrErrorMessage(parseBigInt(baseFee_), "trade: baseFee not int")
395
395
 
    let quoteFee = valueOrErrorMessage(parseBigInt(quoteFee_), "trade: quoteFee not int")
396
396
 
    let tradePrice = makerOrderPrice
397
397
 
    let makerOrderFilledAmount = _loadOrderFilledAmount(makerOrderHash)
398
398
 
    let makerOrderBaseAmountFree = (makerOrderBaseAmount - makerOrderFilledAmount)
399
399
 
    let takerOrderFilledAmount = _loadOrderFilledAmount(takerOrderHash)
400
400
 
    let takerOrderBaseAmountFree = if ((takerOrderBaseAmount == ZERO_BIGINT))
401
401
 
        then fraction((takerOrderQuoteAmount - takerOrderFilledAmount), MULTIPLIER, tradePrice, DOWN)
402
402
 
        else (takerOrderBaseAmount - takerOrderFilledAmount)
403
403
 
    let tradeBaseAmount = min([makerOrderBaseAmountFree, takerOrderBaseAmountFree])
404
404
 
    let tradeQuoteAmount = fraction(tradeBaseAmount, tradePrice, MULTIPLIER, DOWN)
405
405
 
    let err = if (if (if (if (if (if (if (if (if (_validateSequencer(i.caller, "trade: invalid sequencer"))
406
406
 
        then _validateBigInt(tradeBaseAmount, ZERO_BIGINT, "trade: neg trade amount")
407
407
 
        else false)
408
408
 
        then _validateIntEqual(makerOrderType, ORDER_TYPE_LIMIT, "trade: maker is not limit")
409
409
 
        else false)
410
410
 
        then _validateStringEqual(makerOrderSymbol, takerOrderSymbol, "trade: symbol mismatch")
411
411
 
        else false)
412
412
 
        then _validateIntNotEqual(makerOrderSide, takerOrderSide, "trade: side mismatch")
413
413
 
        else false)
414
414
 
        then _validateOrderSignature(makerOrderHash, makerOrderSignature, makerOrderWeb3Id, makerOrderAlg, "trade: invalid maker sig")
415
415
 
        else false)
416
416
 
        then _validateOrderSignature(takerOrderHash, takerOrderSignature, takerOrderWeb3Id, takerOrderAlg, "trade: invalid taker sig")
417
417
 
        else false)
418
418
 
        then _validateFeeTolerance(tradeBaseAmount, baseFee, "trade: base fee too much")
419
419
 
        else false)
420
420
 
        then _validateFeeTolerance(tradeQuoteAmount, quoteFee, "trade: quote fee too much")
421
421
 
        else false)
422
422
 
        then _validateOrderPrices(makerOrderPrice, takerOrderPrice, takerOrderSide, takerOrderType, "trade: prices mismatch")
423
423
 
        else false
424
424
 
    if ((err == err))
425
425
 
        then {
426
426
 
            let makerAddress = _convertWeb3IdToAddress(makerOrderWeb3Id, makerOrderAlg)
427
427
 
            let takerAddress = _convertWeb3IdToAddress(takerOrderWeb3Id, takerOrderAlg)
428
-
            let $t01413714560 = if ((makerOrderSide == ORDER_SIDE_BUY))
428
+
            let $t01414014563 = if ((makerOrderSide == ORDER_SIDE_BUY))
429
429
 
                then $Tuple2(makerAddress, takerAddress)
430
430
 
                else $Tuple2(takerAddress, makerAddress)
431
-
            let buyer = $t01413714560._1
432
-
            let seller = $t01413714560._2
431
+
            let buyer = $t01414014563._1
432
+
            let seller = $t01414014563._2
433
433
 
            let assets = split(makerOrderSymbol, "-")
434
434
 
            let baseAsset = assets[0]
435
435
 
            let quoteAsset = assets[1]
436
436
 
            let feeRecipient = _loadFeeRecipient()
437
437
 
            let storageInvocation = invoke(_loadAccountStorage(), FUNC_EXTERNAL_TRANSFER, [SPOT_WALLET, baseAsset, seller, buyer, toString(tradeBaseAmount), toString(baseFee), feeRecipient], nil)
438
438
 
            if ((storageInvocation == storageInvocation))
439
439
 
                then {
440
440
 
                    let storageInvocation1 = invoke(_loadAccountStorage(), FUNC_EXTERNAL_TRANSFER, [SPOT_WALLET, quoteAsset, buyer, seller, toString(tradeQuoteAmount), toString(quoteFee), feeRecipient], nil)
441
441
 
                    if ((storageInvocation1 == storageInvocation1))
442
442
 
                        then {
443
443
 
                            let newMakerOrderFilledAmount = (makerOrderFilledAmount + tradeBaseAmount)
444
444
 
                            let newTakerOrderFilledAmount = if ((takerOrderBaseAmount == ZERO_BIGINT))
445
445
 
                                then (takerOrderFilledAmount + tradeQuoteAmount)
446
446
 
                                else (takerOrderFilledAmount + tradeBaseAmount)
447
447
 
                            $Tuple2((_saveOrderFilledAmount(makerOrderHash, newMakerOrderFilledAmount) ++ _saveOrderFilledAmount(takerOrderHash, newTakerOrderFilledAmount)), unit)
448
448
 
                            }
449
449
 
                        else throw("Strict value is not equal to itself.")
450
450
 
                    }
451
451
 
                else throw("Strict value is not equal to itself.")
452
452
 
            }
453
453
 
        else throw("Strict value is not equal to itself.")
454
454
 
    }
455
455
 
456
456
 
457
457
 
458
458
 
@Callable(i)
459
459
 
func claimReward (user_,currency_,amount_) = {
460
460
 
    let amount = valueOrErrorMessage(parseBigInt(amount_), "claimReward: amount not int")
461
461
 
    let err = if (if (if (_validateSequencer(i.caller, "claimReward: invalid sequencer"))
462
462
 
        then _validateString(user_, "claimReward: invalid user")
463
463
 
        else false)
464
464
 
        then _validateString(currency_, "claimReward: invalid currency")
465
465
 
        else false)
466
466
 
        then _validateBigInt(amount, ZERO_BIGINT, "claimReward: neg amount")
467
467
 
        else false
468
468
 
    if ((err == err))
469
469
 
        then {
470
470
 
            let storageInvocation = invoke(_loadAccountStorage(), FUNC_CLAIM_REWARD, [_loadRewardDistributor(), user_, currency_, amount_], nil)
471
471
 
            if ((storageInvocation == storageInvocation))
472
472
 
                then $Tuple2(nil, unit)
473
473
 
                else throw("Strict value is not equal to itself.")
474
474
 
            }
475
475
 
        else throw("Strict value is not equal to itself.")
476
476
 
    }
477
477
 
478
478
 
479
479
 
480
480
 
@Callable(i)
481
481
 
func updateSymbol (symbol_,allowance_) = {
482
482
 
    let err = if (_onlyThisContract(i.caller))
483
483
 
        then _validateString(symbol_, "updateSymbol: invalid symbol")
484
484
 
        else false
485
485
 
    if ((err == err))
486
486
 
        then $Tuple2(_saveSymbol(symbol_, allowance_), unit)
487
487
 
        else throw("Strict value is not equal to itself.")
488
488
 
    }
489
489
 
490
490
 
491
491
 
492
492
 
@Callable(i)
493
493
 
func updateFeeRecipient (feeRecipient_) = {
494
494
 
    let err = if (if (_onlyThisContract(i.caller))
495
495
 
        then _whenInitialized()
496
496
 
        else false)
497
497
 
        then _validateString(feeRecipient_, "updateFeeRecipient: invalid feeRecipient")
498
498
 
        else false
499
499
 
    if ((err == err))
500
500
 
        then $Tuple2(_saveFeeRecipient(feeRecipient_), unit)
501
501
 
        else throw("Strict value is not equal to itself.")
502
502
 
    }
503
503
 
504
504
 
505
505
 
506
506
 
@Callable(i)
507
507
 
func updateRewardDistributor (rewardDistributor_) = {
508
508
 
    let err = if (if (_onlyThisContract(i.caller))
509
509
 
        then _whenInitialized()
510
510
 
        else false)
511
511
 
        then _validateString(rewardDistributor_, "updateRewardDistributor: invalid rewardDistributor")
512
512
 
        else false
513
513
 
    if ((err == err))
514
514
 
        then $Tuple2(_saveRewardDistributor(rewardDistributor_), unit)
515
515
 
        else throw("Strict value is not equal to itself.")
516
516
 
    }
517
517
 
518
518
 
519
519
 
520
520
 
@Callable(i)
521
521
 
func setMultisig (multisig_) = {
522
522
 
    let err = if (_onlyThisContract(i.caller))
523
523
 
        then _validateAddress(multisig_, "setMultisig: invalid multisig")
524
524
 
        else false
525
525
 
    if ((err == err))
526
526
 
        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
527
527
 
        else throw("Strict value is not equal to itself.")
528
528
 
    }
529
529
 
530
530
 
531
531
 
@Verifier(tx)
532
532
 
func verify () = match getString(KEY_MULTISIG) {
533
533
 
    case multisig: String => 
534
534
 
        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
535
535
 
    case _ => 
536
536
 
        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
537
537
 
}
538
538
 

github/deemru/w8io/169f3d6 
60.24 ms ◑