tx · HPfwiPJ9w9SUK82yV952ZqAcGjpZKUQydNo7dqCpudPB

3Mp3uUKsY4LnTo3j4N7dJAfqRfMJ6Rgr35Q:  -0.07500000 Waves

2023.01.30 10:00 [2427371] smart account 3Mp3uUKsY4LnTo3j4N7dJAfqRfMJ6Rgr35Q > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HPfwiPJ9w9SUK82yV952ZqAcGjpZKUQydNo7dqCpudPB",
    "fee": 7500000,
    "feeAssetId": null,
    "timestamp": 1675062145348,
    "version": 2,
    "chainId": 84,
    "sender": "3Mp3uUKsY4LnTo3j4N7dJAfqRfMJ6Rgr35Q",
    "senderPublicKey": "EiYReiiFX6CXEuz35wibBnvZ8LjJHZrgFwR73fomjgzy",
    "proofs": [
        "QQzq3QKUNB2v1ypjmbAqjvXLL6LjwX4ugAo1T7X1qzLyQqkyGJ7B13TiiZm1u3RkBxWT6enwuStMj9v2CoxoVc5"
    ],
    "script": "base64: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",
    "height": 2427371,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GTwMSEdf7N6vNo2AxkDG5tGP6xLDJMzwj6wEsdZCu96J
Next: 858z2JZZsF7GEpGKxhSwRxoJhjU3XzsbQmve6h1bZXd4

Diff: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
-
let a = "k_ora_key"
4
+
let a = "k_baseOracle"
5
5
 
6
-
let b = "k_ora_block_key"
6
+
let b = "k_quoteOracle"
7
7
 
8
-
let c = "k_ora_open_key"
8
+
let c = "k_balance"
9
9
 
10
-
let d = "k_ora"
10
+
let d = "k_sequence"
11
11
 
12
-
let e = "k_balance"
12
+
let e = "k_positionSize"
13
13
 
14
-
let f = "k_sequence"
14
+
let f = "k_positionMargin"
15
15
 
16
-
let g = "k_positionSize"
16
+
let g = "k_positionOpenNotional"
17
17
 
18
-
let h = "k_positionMargin"
18
+
let h = "k_positionFraction"
19
19
 
20
-
let i = "k_positionOpenNotional"
20
+
let i = "k_positionSequence"
21
21
 
22
-
let j = "k_positionFraction"
22
+
let j = "k_positionAsset"
23
23
 
24
-
let k = "k_positionSequence"
24
+
let k = "k_positionFee"
25
25
 
26
-
let l = "k_positionAsset"
26
+
let l = "k_positionTimestamp"
27
27
 
28
-
let m = "k_positionFee"
28
+
let m = "k_initialized"
29
29
 
30
-
let n = "k_initialized"
30
+
let n = "k_paused"
31
31
 
32
-
let o = "k_paused"
32
+
let o = "k_closeOnly"
33
33
 
34
-
let p = "k_closeOnly"
34
+
let p = "k_fee"
35
35
 
36
-
let q = "k_fee"
36
+
let q = "k_rollover_fee"
37
37
 
38
38
 
let r = "k_fundingPeriod"
39
39
 
97
97
 
98
98
 
let V = "k_openInterestLong"
99
99
 
100
-
let W = "k_coordinatorAddress"
100
+
let W = "k_lastTx"
101
101
 
102
-
let X = "k_vault_address"
102
+
let X = "k_coordinatorAddress"
103
103
 
104
-
let Y = "k_admin_address"
104
+
let Y = "k_vault_address"
105
105
 
106
-
let Z = "k_admin_public_key"
106
+
let Z = "k_admin_address"
107
107
 
108
-
let aa = "k_quote_asset"
108
+
let aa = "k_admin_public_key"
109
109
 
110
-
let ab = "k_quote_staking"
110
+
let ab = "k_quote_asset"
111
111
 
112
-
let ac = "k_staking_address"
112
+
let ac = "k_quote_staking"
113
113
 
114
-
let ad = "k_miner_address"
114
+
let ad = "k_staking_address"
115
115
 
116
-
let ae = "k_orders_address"
116
+
let ae = "k_miner_address"
117
117
 
118
-
let af = "k_referral_address"
118
+
let af = "k_orders_address"
119
119
 
120
-
let ag = "k_collateral_address"
120
+
let ag = "k_referral_address"
121
121
 
122
122
 
let ah = "k_exchange_address"
123
123
 
124
124
 
let ai = "k_nft_manager_address"
125
125
 
126
-
let aj = "k_trader_market_asset_collateral"
127
-
128
-
func ak (al,am) = ((al + "_") + am)
126
+
func aj (ak,al) = ((ak + "_") + al)
129
127
 
130
128
 
131
-
func an () = valueOrErrorMessage(addressFromString(getStringValue(this, W)), "Coordinator not set")
129
+
func am () = valueOrErrorMessage(addressFromString(getStringValue(this, X)), "Coordinator not set")
132
130
 
133
131
 
134
-
func ao () = addressFromString(getStringValue(an(), Y))
132
+
func an () = addressFromString(getStringValue(am(), Z))
135
133
 
136
134
 
137
-
func ap () = fromBase58String(getStringValue(an(), Z))
135
+
func ao () = fromBase58String(getStringValue(am(), aa))
138
136
 
139
137
 
140
-
func aq () = fromBase58String(getStringValue(an(), aa))
138
+
func ap () = fromBase58String(getStringValue(am(), ab))
141
139
 
142
140
 
143
-
func ar () = valueOrErrorMessage(addressFromString(getStringValue(an(), ab)), "Quote asset staking not set")
141
+
func aq () = valueOrErrorMessage(addressFromString(getStringValue(am(), ac)), "Quote asset staking not set")
144
142
 
145
143
 
146
-
func as () = valueOrErrorMessage(addressFromString(getStringValue(an(), ac)), "Staking not set")
144
+
func ar () = valueOrErrorMessage(addressFromString(getStringValue(am(), ad)), "Staking not set")
147
145
 
148
146
 
149
-
func at () = valueOrErrorMessage(addressFromString(getStringValue(an(), X)), "Vault not set")
147
+
func as () = valueOrErrorMessage(addressFromString(getStringValue(am(), Y)), "Vault not set")
150
148
 
151
149
 
152
-
func au () = valueOrErrorMessage(addressFromString(getStringValue(an(), ad)), "Miner not set")
150
+
func at () = valueOrErrorMessage(addressFromString(getStringValue(am(), ae)), "Miner not set")
153
151
 
154
152
 
155
-
func av () = valueOrErrorMessage(addressFromString(getStringValue(an(), ae)), "Orders not set")
153
+
func au () = valueOrErrorMessage(addressFromString(getStringValue(am(), af)), "Orders not set")
156
154
 
157
155
 
158
-
func aw () = valueOrErrorMessage(addressFromString(getStringValue(an(), af)), "Referral not set")
156
+
func av () = valueOrErrorMessage(addressFromString(getStringValue(am(), ag)), "Referral not set")
159
157
 
160
158
 
161
-
func ax () = valueOrErrorMessage(addressFromString(getStringValue(an(), ai)), "NFT Manager not set")
159
+
func aw () = valueOrErrorMessage(addressFromString(getStringValue(am(), ai)), "NFT Manager not set")
162
160
 
163
161
 
164
-
func ay () = valueOrErrorMessage(addressFromString(getStringValue(an(), ag)), "Collateral Manager not set")
162
+
let ax = "k_token_param"
163
+
164
+
let ay = "k_token_type"
165
+
166
+
let az = "fee_reduction"
167
+
168
+
let aA = 1
169
+
170
+
let aB = 2
171
+
172
+
let aC = 15
173
+
174
+
let aD = 1000
175
+
176
+
let aE = 6
177
+
178
+
let aF = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
179
+
180
+
let aG = (525600 * aF)
181
+
182
+
let aH = (86400 * aF)
183
+
184
+
let aI = 1
185
+
186
+
let aJ = 2
187
+
188
+
func aK (aL) = (toString(aL) + ",")
165
189
 
166
190
 
167
-
func az () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(an(), ah), "No swap address")), "Invalid swap address")
191
+
func aM (aL,aN) = fraction(aL, aF, aN, HALFEVEN)
168
192
 
169
193
 
170
-
let aA = "k_whitelist_asset"
171
-
172
-
func aB (aC) = valueOrElse(getBoolean(ay(), ak(aA, aC)), false)
194
+
func aO (aL,aN) = fraction(aL, aN, aF, HALFEVEN)
173
195
 
174
196
 
175
-
let aD = "k_token_param"
176
-
177
-
let aE = "k_token_type"
178
-
179
-
let aF = "fee_reduction"
180
-
181
-
let aG = 1
182
-
183
-
let aH = 2
184
-
185
-
let aI = 15
186
-
187
-
let aJ = 15
188
-
189
-
let aK = 1000
190
-
191
-
let aL = 6
192
-
193
-
let aM = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
194
-
195
-
let aN = (86400 * aM)
196
-
197
-
let aO = 100
198
-
199
-
let aP = 1
200
-
201
-
let aQ = 2
202
-
203
-
func aR (aS) = (toString(aS) + ",")
197
+
func aP (aL) = sqrt(aL, aE, aE, HALFEVEN)
204
198
 
205
199
 
206
-
func aT (aS,aU) = fraction(aS, aM, aU, HALFEVEN)
200
+
func aQ (aL,aN) = pow(aL, aE, aN, aE, aE, HALFEVEN)
207
201
 
208
202
 
209
-
func aV (aS,aU) = fraction(aS, aU, aM, HALFEVEN)
203
+
func aR (aL,aN) = fraction(aL, toBigInt(aF), aN, HALFEVEN)
210
204
 
211
205
 
212
-
func aW (aS) = sqrt(aS, aL, aL, HALFEVEN)
206
+
func aS (aL,aN) = fraction(aL, aN, toBigInt(aF), HALFEVEN)
213
207
 
214
208
 
215
-
func aX (aS,aU) = pow(aS, aL, aU, aL, aL, HALFEVEN)
209
+
func aT (aL) = sqrtBigInt(aL, aE, aE, HALFEVEN)
216
210
 
217
211
 
218
-
func aY (aS,aU) = fraction(aS, toBigInt(aM), aU, HALFEVEN)
212
+
func aU (aL,aN) = pow(aL, aE, aN, aE, aE, HALFEVEN)
219
213
 
220
214
 
221
-
func aZ (aS,aU) = fraction(aS, aU, toBigInt(aM), HALFEVEN)
215
+
func aV (aL) = if ((aL > 0))
216
+
    then aL
217
+
    else -(aL)
222
218
 
223
219
 
224
-
func ba (aS) = sqrtBigInt(aS, aL, aL, HALFEVEN)
220
+
func aW (aL,aN) = if ((aL >= aN))
221
+
    then aL
222
+
    else aN
225
223
 
226
224
 
227
-
func bb (aS,aU) = pow(aS, aL, aU, aL, aL, HALFEVEN)
225
+
func aX (aY) = if ((size(aY) == 0))
226
+
    then ""
227
+
    else makeString(aY, ",")
228
228
 
229
229
 
230
-
func bc (aS) = if ((aS > 0))
231
-
    then aS
232
-
    else -(aS)
230
+
func aZ (ba) = if ((ba == ""))
231
+
    then nil
232
+
    else split(ba, ",")
233
233
 
234
234
 
235
-
func bd (aS,aU) = if ((aS >= aU))
236
-
    then aS
237
-
    else aU
235
+
func bb (aY,bc,bd) = if ((size(aY) > bc))
236
+
    then (removeByIndex(aY, 0) :+ bd)
237
+
    else (aY :+ bd)
238
238
 
239
239
 
240
-
func be (bf) = {
241
-
    func bg (bh,bi) =     ((bh + bi) + ",")
240
+
func be (bf) = valueOrErrorMessage(getInteger(this, bf), ("no value for " + bf))
242
241
 
243
-
    let bj = {
244
-
        let bk = bf
245
-
        let bl = size(bk)
246
-
        let bm = ""
247
-
        func bn (bo,bp) =         if ((bp >= bl))
248
-
            then bo
249
-
            else bg(bo, bk[bp])
250
242
 
251
-
        func bq (bo,bp) =         if ((bp >= bl))
252
-
            then bo
253
-
            else throw("List size exceeds 20")
243
+
func bg (bf,bh) = valueOrElse(getInteger(this, bf), bh)
254
244
 
255
-
        bq(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bm, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
256
-
        }
257
-
    let br = dropRight(bj, 1)
258
-
    let bs = if ((take(br, 1) == ","))
259
-
        then drop(br, 1)
260
-
        else br
261
-
    bs
245
+
246
+
func bi (al,ak) = {
247
+
    let bj = valueOrErrorMessage(getString(al, ak), ("No value for key " + ak))
248
+
    bj
262
249
 
    }
263
250
 
264
251
 
265
-
func bt (bu) = split(bu, ",")
266
-
267
-
268
-
func bv (bf,bw,bx) = if ((size(bf) > bw))
269
-
    then (removeByIndex(bf, 0) :+ bx)
270
-
    else (bf :+ bx)
271
-
272
-
273
-
func by (bz) = valueOrErrorMessage(getInteger(this, bz), ("no value for " + bz))
274
-
275
-
276
-
func bA (bz,bB) = valueOrElse(getInteger(this, bz), bB)
277
-
278
-
279
-
func bC (am,al) = {
280
-
    let bi = valueOrErrorMessage(getString(am, al), ("No value for key " + al))
281
-
    bi
252
+
func bk (al,ak) = {
253
+
    let bj = valueOrErrorMessage(getInteger(al, ak), ("No value for key " + ak))
254
+
    bj
282
255
 
    }
283
256
 
284
257
 
285
-
func bD (am,al) = {
286
-
    let bi = valueOrErrorMessage(getInteger(am, al), ("No value for key " + al))
287
-
    bi
288
-
    }
258
+
func bl () = be(c)
289
259
 
290
260
 
291
-
func bE () = by(e)
261
+
func bm () = be(p)
292
262
 
293
263
 
294
-
func bF () = by(q)
264
+
func bn () = be(q)
295
265
 
296
266
 
297
-
func bG () = by(s)
267
+
func bo () = be(s)
298
268
 
299
269
 
300
-
func bH () = by(M)
270
+
func bp () = be(M)
301
271
 
302
272
 
303
-
func bI () = by(N)
273
+
func bq () = be(N)
304
274
 
305
275
 
306
-
func bJ () = bA(O, aM)
276
+
func br () = bg(O, aF)
307
277
 
308
278
 
309
-
func bK () = bA(P, aM)
279
+
func bs () = bg(P, aF)
310
280
 
311
281
 
312
-
func bL () = by(Q)
282
+
func bt () = be(Q)
313
283
 
314
284
 
315
-
func bM () = by(T)
285
+
func bu () = be(T)
316
286
 
317
287
 
318
-
func bN () = by(U)
288
+
func bv () = be(U)
319
289
 
320
290
 
321
-
func bO () = by(V)
291
+
func bw () = be(V)
322
292
 
323
293
 
324
-
func bP () = by(J)
294
+
func bx () = be(J)
325
295
 
326
296
 
327
-
func bQ () = by(r)
297
+
func by () = be(r)
328
298
 
329
299
 
330
-
func bR () = (bQ() * aM)
300
+
func bz () = (by() * aF)
331
301
 
332
302
 
333
-
func bS () = (bQ() * aK)
303
+
func bA () = (by() * aD)
334
304
 
335
305
 
336
-
func bT () = by(t)
306
+
func bB () = be(t)
337
307
 
338
308
 
339
-
func bU () = by(u)
309
+
func bC () = be(u)
340
310
 
341
311
 
342
-
func bV () = by(v)
312
+
func bD () = be(v)
343
313
 
344
314
 
345
-
func bW () = by(w)
315
+
func bE () = be(w)
346
316
 
347
317
 
348
-
func bX () = by(x)
318
+
func bF () = be(x)
349
319
 
350
320
 
351
-
func bY () = by(y)
321
+
func bG () = be(y)
352
322
 
353
323
 
354
-
func bZ () = by(z)
324
+
func bH () = be(z)
355
325
 
356
326
 
357
-
func ca () = by(H)
327
+
func bI () = be(H)
358
328
 
359
329
 
360
-
func cb () = by(I)
330
+
func bJ () = be(I)
361
331
 
362
332
 
363
-
func cc () = by(S)
333
+
func bK () = be(S)
364
334
 
365
335
 
366
-
func cd () = by(R)
336
+
func bL () = be(R)
367
337
 
368
338
 
369
-
func ce () = bA(f, 0)
339
+
func bM () = bg(d, 0)
370
340
 
371
341
 
372
-
func cf () = by(A)
342
+
func bN () = be(A)
373
343
 
374
344
 
375
-
func cg () = by(B)
345
+
func bO () = be(B)
376
346
 
377
347
 
378
-
func ch (ci) = valueOrElse(getString(av(), "k_sender"), toString(ci.caller))
348
+
func bP () = lastBlock.timestamp
379
349
 
380
350
 
381
-
func cj (ck,cl,cm) = {
382
-
    let cn = (ck - cl)
383
-
    if (if (cm)
384
-
        then (0 > cn)
351
+
func bQ (bR) = valueOrElse(getString(au(), "k_sender"), toString(bR.caller))
352
+
353
+
354
+
func bS (bT,bU,bV) = {
355
+
    let bW = (bT - bU)
356
+
    if (if (bV)
357
+
        then (0 > bW)
385
358
 
        else false)
386
-
        then throw(((("Invalid margin: " + toString(ck)) + " < ") + toString(cl)))
387
-
        else if (if (!(cm))
388
-
            then (cn >= 0)
359
+
        then throw(((("Invalid margin: " + toString(bT)) + " < ") + toString(bU)))
360
+
        else if (if (!(bV))
361
+
            then (bW >= 0)
389
362
 
            else false)
390
-
            then throw(((("Invalid margin: " + toString(ck)) + " > ") + toString(cl)))
363
+
            then throw(((("Invalid margin: " + toString(bT)) + " > ") + toString(bU)))
391
364
 
            else true
392
365
 
    }
393
366
 
394
367
 
395
-
func co (cp) = if ((cp == 0))
368
+
func bX (bY) = if ((bY == 0))
396
369
 
    then throw("Should not be called with _positionSize == 0")
397
-
    else if ((cp > 0))
398
-
        then ca()
399
-
        else cb()
370
+
    else if ((bY > 0))
371
+
        then bI()
372
+
        else bJ()
400
373
 
401
374
 
402
-
func cq (cr) = {
403
-
    let cs = getInteger(this, ak(g, cr))
404
-
    let ct = cs
405
-
    if ($isInstanceOf(ct, "Int"))
375
+
func bZ (ca) = {
376
+
    let cb = getInteger(this, aj(e, ca))
377
+
    let cc = cb
378
+
    if ($isInstanceOf(cc, "Int"))
406
379
 
        then {
407
-
            let cu = ct
408
-
            $Tuple4(cu, getIntegerValue(this, ak(h, cr)), getIntegerValue(this, ak(i, cr)), getIntegerValue(this, ak(j, cr)))
380
+
            let cd = cc
381
+
            $Tuple5(cd, getIntegerValue(this, aj(f, ca)), getIntegerValue(this, aj(g, ca)), getIntegerValue(this, aj(h, ca)), getIntegerValue(this, aj(l, ca)))
409
382
 
            }
410
-
        else $Tuple4(0, 0, 0, 0)
383
+
        else $Tuple5(0, 0, 0, 0, 0)
411
384
 
    }
412
385
 
413
386
 
414
-
func cv (cr) = {
415
-
    let cw = getString(this, ak(l, cr))
416
-
    let ct = cw
417
-
    if ($isInstanceOf(ct, "String"))
387
+
func ce (ca) = {
388
+
    let cf = getString(this, aj(j, ca))
389
+
    let cc = cf
390
+
    if ($isInstanceOf(cc, "String"))
418
391
 
        then {
419
-
            let cx = ct
420
-
            cx
392
+
            let cg = cc
393
+
            cg
421
394
 
            }
422
-
        else toBase58String(aq())
395
+
        else toBase58String(ap())
423
396
 
    }
424
397
 
425
398
 
426
-
func cy (cr) = {
427
-
    let cz = getInteger(this, ak(m, cr))
428
-
    let ct = cz
429
-
    if ($isInstanceOf(ct, "Int"))
399
+
func ch (ca) = {
400
+
    let ci = getInteger(this, aj(k, ca))
401
+
    let cc = ci
402
+
    if ($isInstanceOf(cc, "Int"))
430
403
 
        then {
431
-
            let cA = ct
432
-
            cA
404
+
            let cj = cc
405
+
            cj
433
406
 
            }
434
-
        else bF()
407
+
        else bm()
435
408
 
    }
436
409
 
437
410
 
438
-
func cB (cr) = if ((cq(cr)._1 == 0))
411
+
func ck (ca) = if ((bZ(ca)._1 == 0))
439
412
 
    then throw("No open position")
440
413
 
    else true
441
414
 
442
415
 
443
-
func cC () = valueOrElse(getBoolean(this, n), false)
416
+
func cl (cm) = {
417
+
    let cn = getString(this, cm)
418
+
    if (if (isDefined(cn))
419
+
        then (value(cn) != "")
420
+
        else false)
421
+
        then {
422
+
            let co = split(value(cn), ",")
423
+
            let cp = valueOrErrorMessage(addressFromString(co[0]), ("Invalid oracle address in: " + value(cn)))
424
+
            let cq = co[1]
425
+
            let cr = co[2]
426
+
            let cs = co[3]
427
+
            $Tuple4(cp, cq, cr, cs)
428
+
            }
429
+
        else unit
430
+
    }
444
431
 
445
432
 
446
-
func cD () = valueOrElse(getBoolean(this, o), false)
433
+
func ct () = valueOrElse(getBoolean(this, m), false)
447
434
 
448
435
 
449
-
func cE () = valueOrElse(getBoolean(this, p), false)
436
+
func cu () = valueOrElse(getBoolean(this, n), false)
450
437
 
451
438
 
452
-
func cF (cG,cH,cI) = if (cG)
439
+
func cv () = valueOrElse(getBoolean(this, o), false)
440
+
441
+
442
+
func cw (cx,cy,cz) = if (cx)
453
443
 
    then {
454
-
        let cJ = (bI() - cI)
455
-
        if ((0 >= cJ))
444
+
        let cA = (bq() - cz)
445
+
        if ((0 >= cA))
456
446
 
            then throw("Tx lead to base asset reserve <= 0, revert")
457
-
            else $Tuple3((bH() + cH), cJ, (bL() + cI))
447
+
            else $Tuple3((bp() + cy), cA, (bt() + cz))
458
448
 
        }
459
449
 
    else {
460
-
        let cK = (bH() - cH)
461
-
        if ((0 >= cK))
450
+
        let cB = (bp() - cy)
451
+
        if ((0 >= cB))
462
452
 
            then throw("Tx lead to base quote reserve <= 0, revert")
463
-
            else $Tuple3(cK, (bI() + cI), (bL() - cI))
453
+
            else $Tuple3(cB, (bq() + cz), (bt() - cz))
464
454
 
        }
465
455
 
466
456
 
467
-
func cL (cM,cN) = {
468
-
    let cO = toBigInt(cM)
469
-
    let cP = toBigInt(cN)
470
-
    aZ(cO, cP)
457
+
func cC (cD,cE) = {
458
+
    let cF = toBigInt(cD)
459
+
    let cG = toBigInt(cE)
460
+
    aS(cF, cG)
471
461
 
    }
472
462
 
473
463
 
474
-
func cQ (cG,cH) = {
475
-
    let cM = bH()
476
-
    let cN = bI()
477
-
    let cR = bJ()
478
-
    let cS = bK()
479
-
    let cT = aT(cH, cR)
480
-
    let bz = cL(cM, cN)
481
-
    let cU = if (cG)
482
-
        then (cM + cT)
483
-
        else (cM - cT)
484
-
    let cV = toInt(aY(bz, toBigInt(cU)))
485
-
    let cW = bc((cV - cN))
486
-
    let cX = if (cG)
487
-
        then cW
488
-
        else -(cW)
489
-
    let cY = cF(cG, cT, cW)
490
-
    let cZ = cY._1
491
-
    let da = cY._2
492
-
    let db = cY._3
493
-
    let dc = aT(aV(cM, cR), aV(cN, cS))
494
-
    let dd = aT(cH, cW)
495
-
    let de = bc((dc - dd))
496
-
    let df = (aM - aT(dc, (dc + de)))
497
-
    let dg = bX()
498
-
    if ((df > dg))
499
-
        then throw(((((((((((((("Price impact " + toString(df)) + " > max price impact ") + toString(dg)) + " before quote asset: ") + toString(cM)) + " before base asset: ") + toString(cN)) + " quote asset amount to exchange: ") + toString(cH)) + " price before: ") + toString(dc)) + " marketPrice: ") + toString(dd)))
500
-
        else $Tuple4(cX, cZ, da, db)
464
+
func cH (cx,cy) = {
465
+
    let cD = bp()
466
+
    let cE = bq()
467
+
    let cI = br()
468
+
    let cJ = bs()
469
+
    let cK = aM(cy, cI)
470
+
    let bf = cC(cD, cE)
471
+
    let cL = if (cx)
472
+
        then (cD + cK)
473
+
        else (cD - cK)
474
+
    let cM = toInt(aR(bf, toBigInt(cL)))
475
+
    let cN = aV((cM - cE))
476
+
    let cO = if (cx)
477
+
        then cN
478
+
        else -(cN)
479
+
    let cP = cw(cx, cK, cN)
480
+
    let cQ = cP._1
481
+
    let cR = cP._2
482
+
    let cS = cP._3
483
+
    let cT = aM(aO(cD, cI), aO(cE, cJ))
484
+
    let cU = aM(cy, cN)
485
+
    let cV = aV((cT - cU))
486
+
    let cW = (aF - aM(cT, (cT + cV)))
487
+
    let cX = bF()
488
+
    if ((cW > cX))
489
+
        then throw(((((((((((((("Price impact " + toString(cW)) + " > max price impact ") + toString(cX)) + " before quote asset: ") + toString(cD)) + " before base asset: ") + toString(cE)) + " quote asset amount to exchange: ") + toString(cy)) + " price before: ") + toString(cT)) + " marketPrice: ") + toString(cU)))
490
+
        else $Tuple4(cO, cQ, cR, cS)
501
491
 
    }
502
492
 
503
493
 
504
-
func dh (di,dj,dk,dl) = {
505
-
    let dm = if ((di != 0))
506
-
        then {
507
-
            let dn = co(di)
508
-
            aV((dn - dk), di)
509
-
            }
510
-
        else 0
511
-
    let do = ((dl - dm) + dj)
512
-
    let dp = if ((0 > do))
513
-
        then $Tuple2(0, bc(do))
514
-
        else $Tuple2(bc(do), 0)
515
-
    let dq = dp._1
516
-
    let dr = dp._2
517
-
    $Tuple3(dq, dr, dm)
494
+
func cY (cZ,da) = {
495
+
    let db = ((((bP() - da) / 1000) / 60) * aF)
496
+
    let dc = aM(aO(aO(cZ, db), bn()), aG)
497
+
    dc
518
498
 
    }
519
499
 
520
500
 
521
-
func ds (cG,cI,dt,du,dv,dw,dx) = {
522
-
    let dc = aT(aV(du, dv), aV(dw, dx))
523
-
    if ((cI == 0))
501
+
func dd (de,cZ,df,da,dg) = {
502
+
    let dh = if ((de != 0))
503
+
        then {
504
+
            let di = bX(de)
505
+
            aO((di - df), de)
506
+
            }
507
+
        else 0
508
+
    let dc = cY(cZ, da)
509
+
    let dj = (((dg - dc) - dh) + cZ)
510
+
    let dk = if ((0 > dj))
511
+
        then $Tuple2(0, aV(dj))
512
+
        else $Tuple2(aV(dj), 0)
513
+
    let dl = dk._1
514
+
    let dm = dk._2
515
+
    $Tuple4(dl, dm, dh, dc)
516
+
    }
517
+
518
+
519
+
func dn (cx,cz,do,dp,dq,dr,ds) = {
520
+
    let cT = aM(aO(dp, dq), aO(dr, ds))
521
+
    if ((cz == 0))
524
522
 
        then throw("Invalid base asset amount")
525
523
 
        else {
526
-
            let bz = cL(du, dw)
527
-
            let dy = if (cG)
528
-
                then (dw + cI)
529
-
                else (dw - cI)
530
-
            let dz = toInt(aY(bz, toBigInt(dy)))
531
-
            let dA = bc((dz - du))
532
-
            let dB = aV(dA, dv)
533
-
            let dg = bX()
534
-
            let dC = cF(!(cG), dA, cI)
535
-
            let cZ = dC._1
536
-
            let da = dC._2
537
-
            let db = dC._3
538
-
            let dd = aT(dB, cI)
539
-
            let de = bc((dc - dd))
540
-
            let df = (aM - aT(dc, (dc + de)))
541
-
            if (if ((df > dg))
542
-
                then dt
524
+
            let bf = cC(dp, dr)
525
+
            let dt = if (cx)
526
+
                then (dr + cz)
527
+
                else (dr - cz)
528
+
            let du = toInt(aR(bf, toBigInt(dt)))
529
+
            let dv = aV((du - dp))
530
+
            let dw = aO(dv, dq)
531
+
            let cX = bF()
532
+
            let dx = cw(!(cx), dv, cz)
533
+
            let cQ = dx._1
534
+
            let cR = dx._2
535
+
            let cS = dx._3
536
+
            let cU = aM(dw, cz)
537
+
            let cV = aV((cT - cU))
538
+
            let cW = (aF - aM(cT, (cT + cV)))
539
+
            if (if ((cW > cX))
540
+
                then do
543
541
 
                else false)
544
-
                then throw(((((((((((((("Price impact " + toString(df)) + " > max price impact ") + toString(dg)) + " before quote asset: ") + toString(du)) + " before base asset: ") + toString(dw)) + " base asset amount to exchange: ") + toString(cI)) + " price before: ") + toString(dc)) + " market price: ") + toString(dd)))
545
-
                else $Tuple7(dB, cZ, da, db, (cd() - (if (cG)
546
-
                    then bc(cI)
547
-
                    else 0)), (cc() - (if (!(cG))
548
-
                    then bc(cI)
549
-
                    else 0)), df)
542
+
                then throw(((((((((((((("Price impact " + toString(cW)) + " > max price impact ") + toString(cX)) + " before quote asset: ") + toString(dp)) + " before base asset: ") + toString(dr)) + " base asset amount to exchange: ") + toString(cz)) + " price before: ") + toString(cT)) + " market price: ") + toString(cU)))
543
+
                else $Tuple7(dw, cQ, cR, cS, (bL() - (if (cx)
544
+
                    then aV(cz)
545
+
                    else 0)), (bK() - (if (!(cx))
546
+
                    then aV(cz)
547
+
                    else 0)), cW)
550
548
 
            }
551
549
 
    }
552
550
 
553
551
 
554
-
func dD (cG,cI,dt) = ds(cG, cI, dt, bH(), bJ(), bI(), bK())
552
+
func dy (cx,cz,do) = dn(cx, cz, do, bp(), br(), bq(), bs())
553
+
554
+
555
+
func dz (dA,cq,cr) = {
556
+
    let dB = valueOrErrorMessage(getInteger(dA, cq), ((("Can not get oracle price. Oracle: " + toString(dA)) + " key: ") + cq))
557
+
    if ((cr != ""))
558
+
        then {
559
+
            let dC = lastBlock.height
560
+
            let dD = valueOrErrorMessage(getInteger(dA, cr), ((("Can not get oracle block. Oracle: " + toString(dA)) + " key: ") + cr))
561
+
            if (((dC - dD) > bO()))
562
+
                then throw(((("Oracle stale data. Last oracle block: " + toString(dD)) + " current block: ") + toString(dC)))
563
+
                else dB
564
+
            }
565
+
        else dB
566
+
    }
555
567
 
556
568
 
557
569
 
func dE () = {
558
-
    let dF = valueOrErrorMessage(addressFromString(getStringValue(this, d)), "")
559
-
    let dG = getStringValue(this, a)
560
-
    let dH = valueOrErrorMessage(getInteger(dF, dG), ((("Can not get oracle price. Oracle: " + toString(dF)) + " key: ") + dG))
561
-
    let dI = valueOrElse(getString(this, b), "")
562
-
    if ((dI != ""))
570
+
    let dF = valueOrErrorMessage(cl(a), "No base asset oracle data")
571
+
    let dG = dz(dF._1, dF._2, dF._3)
572
+
    let dH = cl(b)
573
+
    let dI = if (isDefined(dH))
563
574
 
        then {
564
-
            let dJ = lastBlock.height
565
-
            let dK = valueOrErrorMessage(getInteger(dF, dI), ((("Can not get oracle block. Oracle: " + toString(dF)) + " key: ") + dI))
566
-
            if (((dJ - dK) > cg()))
567
-
                then throw(((("Oracle stale data. Last oracle block: " + toString(dK)) + " current block: ") + toString(dJ)))
568
-
                else dH
575
+
            let dJ = value(dH)
576
+
            dz(dJ._1, dJ._2, dJ._3)
569
577
 
            }
570
-
        else dH
578
+
        else aF
579
+
    aM(dG, dI)
571
580
 
    }
572
581
 
573
582
 
574
-
func dL () = {
575
-
    let dF = valueOrErrorMessage(addressFromString(getStringValue(this, d)), "")
576
-
    let dM = valueOrElse(getString(this, c), "")
577
-
    if ((dM != ""))
583
+
func dK () = {
584
+
    let dF = valueOrErrorMessage(cl(a), "No base asset oracle data")
585
+
    let dA = dF._1
586
+
    let cs = dF._4
587
+
    if ((cs != ""))
578
588
 
        then {
579
-
            let dN = valueOrErrorMessage(getBoolean(dF, dM), ((("Can not get oracle is open/closed. Oracle: " + toString(dF)) + " key: ") + dM))
580
-
            !(dN)
589
+
            let dL = valueOrErrorMessage(getBoolean(dA, cs), ((("Can not get oracle is open/closed. Oracle: " + toString(dA)) + " key: ") + cs))
590
+
            !(dL)
581
591
 
            }
582
592
 
        else false
583
593
 
    }
584
594
 
585
595
 
586
-
func dO (dP,du,dw,cR,cS) = {
587
-
    let dQ = aT(aV(du, cR), aV(dw, cS))
588
-
    let dR = aT((dP + dQ), (2 * aM))
589
-
    let dO = aT(bc((dP - dQ)), dR)
590
-
    dO
596
+
func dM (dN,dp,dr,cI,cJ) = {
597
+
    let dO = aM(aO(dp, cI), aO(dr, cJ))
598
+
    let dP = aM((dN + dO), (2 * aF))
599
+
    let dM = aM(aV((dN - dO)), dP)
600
+
    dM
591
601
 
    }
592
602
 
593
603
 
594
-
func dS (du,dw) = {
595
-
    let dT = dE()
596
-
    let cR = bJ()
597
-
    let cS = bK()
598
-
    let dU = dO(dT, bH(), bI(), cR, cS)
599
-
    let dV = dO(dT, du, dw, cR, cS)
600
-
    if (if ((dV > bY()))
601
-
        then (dV > dU)
604
+
func dQ (dp,dr) = {
605
+
    let dR = dE()
606
+
    let cI = br()
607
+
    let cJ = bs()
608
+
    let dS = dM(dR, bp(), bq(), cI, cJ)
609
+
    let dT = dM(dR, dp, dr, cI, cJ)
610
+
    if (if ((dT > bG()))
611
+
        then (dT > dS)
602
612
 
        else false)
603
-
        then throw(((("Price spread " + toString(dV)) + " > max price spread ") + toString(bY())))
613
+
        then throw(((("Price spread " + toString(dT)) + " > max price spread ") + toString(bG())))
604
614
 
        else true
605
615
 
    }
606
616
 
607
617
 
608
-
func dW (dX,dY) = {
609
-
    let dZ = bZ()
610
-
    if ((dX > dZ))
611
-
        then throw(((("Long open notional " + toString(dX)) + " > max open notional ") + toString(dZ)))
612
-
        else if ((dY > dZ))
613
-
            then throw(((("Short open notional " + toString(dY)) + " > max open notional ") + toString(dZ)))
618
+
func dU (dV,dW) = {
619
+
    let dX = bH()
620
+
    if ((dV > dX))
621
+
        then throw(((("Long open notional " + toString(dV)) + " > max open notional ") + toString(dX)))
622
+
        else if ((dW > dX))
623
+
            then throw(((("Short open notional " + toString(dW)) + " > max open notional ") + toString(dX)))
614
624
 
            else true
615
625
 
    }
616
626
 
617
627
 
618
-
func ea () = {
619
-
    let du = bH()
620
-
    let dw = bI()
621
-
    let cR = bJ()
622
-
    let cS = bK()
623
-
    aT(aV(du, cR), aV(dw, cS))
628
+
func dY () = {
629
+
    let dp = bp()
630
+
    let dr = bq()
631
+
    let cI = br()
632
+
    let cJ = bs()
633
+
    aM(aO(dp, cI), aO(dr, cJ))
624
634
 
    }
625
635
 
626
636
 
627
-
func eb () = {
628
-
    let dT = dE()
629
-
    let ec = ea()
630
-
    (aT(bc((dT - ec)), dT) > bW())
637
+
func dZ () = {
638
+
    let dR = dE()
639
+
    let ea = dY()
640
+
    (aM(aV((dR - ea)), dR) > bE())
631
641
 
    }
632
642
 
633
643
 
634
-
func ed (cp,ee,du,dv,dw,dx) = {
635
-
    let ef = bc(cp)
636
-
    let eg = (0 > cp)
637
-
    let eh = if ((ee == aP))
644
+
func eb (bY,ec,dp,dq,dr,ds) = {
645
+
    let ed = aV(bY)
646
+
    let ee = (0 > bY)
647
+
    let ef = if ((ec == aI))
638
648
 
        then {
639
-
            let ei = ds(!(eg), ef, false, du, dv, dw, dx)
640
-
            let ej = ei._1
641
-
            let ek = ei._2
642
-
            let el = ei._3
643
-
            let em = ei._4
644
-
            ej
649
+
            let eg = dn(!(ee), ed, false, dp, dq, dr, ds)._1
650
+
            eg
645
651
 
            }
646
-
        else aV(ef, dE())
647
-
    eh
652
+
        else aO(ed, dE())
653
+
    ef
648
654
 
    }
649
655
 
650
656
 
651
-
func en (cp,eo,du,dv,dw,dx,ee) = if ((cp == 0))
657
+
func eh (bY,ei,dp,dq,dr,ds,ec) = if ((bY == 0))
652
658
 
    then throw("Invalid position size")
653
659
 
    else {
654
-
        let eg = (0 > cp)
655
-
        let eh = ed(cp, ee, du, dv, dw, dx)
656
-
        let ep = if (eg)
657
-
            then (eo - eh)
658
-
            else (eh - eo)
659
-
        $Tuple2(eh, ep)
660
+
        let ee = (0 > bY)
661
+
        let ef = eb(bY, ec, dp, dq, dr, ds)
662
+
        let ej = if (ee)
663
+
            then (ei - ef)
664
+
            else (ef - ei)
665
+
        $Tuple2(ef, ej)
660
666
 
        }
661
667
 
662
668
 
663
-
func eq (cr,ee) = {
664
-
    let er = cq(cr)
665
-
    let cu = er._1
666
-
    let es = er._2
667
-
    let et = er._3
668
-
    let eu = er._4
669
-
    en(cu, et, bH(), bJ(), bI(), bK(), ee)
669
+
func ek (ca,ec) = {
670
+
    let el = bZ(ca)
671
+
    let cd = el._1
672
+
    let em = el._2
673
+
    let en = el._3
674
+
    let eo = el._4
675
+
    eh(cd, en, bp(), br(), bq(), bs(), ec)
670
676
 
    }
671
677
 
672
678
 
673
-
func ev (ew,ex,ey) = aT((ew - ex), ey)
679
+
func ep (eq,er,es) = aM((eq - er), es)
674
680
 
675
681
 
676
-
func ez (cr,ee) = {
677
-
    let eA = cq(cr)
678
-
    let cu = eA._1
679
-
    let es = eA._2
680
-
    let eB = eA._3
681
-
    let eu = eA._4
682
-
    let eC = eq(cr, ee)
683
-
    let eh = eC._1
684
-
    let ep = eC._2
685
-
    let eD = dh(cu, es, eu, ep)
686
-
    let dq = eD._1
687
-
    let dr = eD._2
688
-
    ev(dq, dr, eh)
682
+
func et (ca,ec) = {
683
+
    let eu = bZ(ca)
684
+
    let cd = eu._1
685
+
    let em = eu._2
686
+
    let ev = eu._3
687
+
    let ew = eu._4
688
+
    let ex = eu._5
689
+
    let ey = ek(ca, ec)
690
+
    let ef = ey._1
691
+
    let ej = ey._2
692
+
    let ez = dd(cd, em, ew, ex, ej)
693
+
    let dl = ez._1
694
+
    let dm = ez._2
695
+
    ep(dl, dm, ef)
689
696
 
    }
690
697
 
691
698
 
692
-
func eE (cr) = ez(cr, aP)
699
+
func eA (ca) = et(ca, aI)
693
700
 
694
701
 
695
-
func eF (cr,cp) = {
696
-
    let eG = bd(bV(), (aM - aT(eE(cr), bT())))
697
-
    let eH = aV(bc(cp), eG)
698
-
    let eI = dD((cp > 0), eH, false)
699
-
    let eJ = eI._1
700
-
    let df = eI._7
701
-
    if ((bX() > df))
702
-
        then eJ
702
+
func eB (ca,bY) = {
703
+
    let eC = aW(bD(), (aF - aM(eA(ca), bB())))
704
+
    let eD = aO(aV(bY), eC)
705
+
    let eE = dy((bY > 0), eD, false)
706
+
    let eF = eE._1
707
+
    let cW = eE._7
708
+
    if ((bF() > cW))
709
+
        then eD
710
+
        else aO(aV(bY), bD())
711
+
    }
712
+
713
+
714
+
func eG (ca,eH,eI,eJ,eK,do) = {
715
+
    let eL = bZ(ca)
716
+
    let eM = eL._1
717
+
    let eN = eL._2
718
+
    let eO = eL._3
719
+
    let eP = eL._4
720
+
    let eQ = eL._5
721
+
    let eR = (eM > 0)
722
+
    let eS = aV(eM)
723
+
    if (if ((eS >= eH))
724
+
        then (eH > 0)
725
+
        else false)
726
+
        then {
727
+
            let eT = (eS > eH)
728
+
            let eU = dy((eM > 0), eH, do)
729
+
            let eV = eU._1
730
+
            let cL = eU._2
731
+
            let cM = eU._3
732
+
            let eW = eU._4
733
+
            let eX = if ((eM > 0))
734
+
                then -(eH)
735
+
                else eH
736
+
            let eY = ek(ca, aI)
737
+
            let eZ = eY._1
738
+
            let ej = eY._2
739
+
            let fa = aM(aV(eX), eS)
740
+
            let fb = aO(ej, fa)
741
+
            let fc = dd(eM, eN, eP, eQ, ej)
742
+
            let fd = fc._1
743
+
            let fe = fc._2
744
+
            let ff = fc._3
745
+
            let dc = fc._4
746
+
            let fg = dd(eM, eN, eP, eQ, fb)._2
747
+
            let fh = aO(aO(eZ, fa), eI)
748
+
            let fi = (ej - fb)
749
+
            let fj = if ((eM > 0))
750
+
                then ((eZ - eV) - fi)
751
+
                else ((fi + eZ) - eV)
752
+
            let fk = (eM + eX)
753
+
            let fl = if ((fk == 0))
754
+
                then $Tuple2(0, 0)
755
+
                else $Tuple2(aV(fj), bX(fk))
756
+
            let fm = fl._1
757
+
            let fn = fl._2
758
+
            let fo = (eO - fm)
759
+
            let fp = et(ca, aI)
760
+
            let fq = if ((eM > 0))
761
+
                then (aO((fm + fi), fp) - fi)
762
+
                else (aO((fm - fi), fp) - fi)
763
+
            let fr = ((fd - (fq + fi)) - fh)
764
+
            let fs = if ((0 > fr))
765
+
                then throw("Invalid internalClosePosition params: unable to pay fee")
766
+
                else fr
767
+
            let ft = if (eK)
768
+
                then (fq + fs)
769
+
                else fq
770
+
            if (if ((eJ != 0))
771
+
                then (eJ > eV)
772
+
                else false)
773
+
                then throw(((("Limit error: " + toString(eV)) + " < ") + toString(eJ)))
774
+
                else $Tuple17(fk, ft, fm, fn, fg, fb, if (if (eK)
775
+
                    then eT
776
+
                    else false)
777
+
                    then 0
778
+
                    else fs, cL, cM, eW, (bu() - fo), (bL() - (if (eR)
779
+
                    then aV(eX)
780
+
                    else 0)), (bK() - (if (!(eR))
781
+
                    then aV(eX)
782
+
                    else 0)), (bw() - (if (eR)
783
+
                    then fo
784
+
                    else 0)), (bv() - (if (!(eR))
785
+
                    then fo
786
+
                    else 0)), (fh + dc), eV)
787
+
            }
788
+
        else throw("Invalid internalClosePosition params: invalid position size")
789
+
    }
790
+
791
+
792
+
func fu () = {
793
+
    let fv = ((bP() / 1000) / 60)
794
+
    let fw = (fv - aC)
795
+
    let fx = valueOrElse(getString(this, C), "")
796
+
    let fy = split(fx, ",")
797
+
    func fz (fA,fB) =     if ((fw >= valueOrErrorMessage(parseInt(fB), ("getTwapSpotPrice: invalid int: " + fx))))
798
+
        then (fA :+ parseIntValue(fB))
799
+
        else fA
800
+
801
+
    let fC = {
802
+
        let fD = fy
803
+
        let fE = size(fD)
804
+
        let fF = nil
805
+
        func fG (fH,fI) =         if ((fI >= fE))
806
+
            then fH
807
+
            else fz(fH, fD[fI])
808
+
809
+
        func fJ (fH,fI) =         if ((fI >= fE))
810
+
            then fH
811
+
            else throw("List size exceeds 20")
812
+
813
+
        fJ(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fF, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
814
+
        }
815
+
    let fK = if ((size(fC) > 0))
816
+
        then max(fC)
817
+
        else valueOrErrorMessage(parseInt(fy[0]), ("getTwapSpotPrice: invalid int: " + fx))
818
+
    let fL = valueOrElse(getInteger(this, D), 0)
819
+
    let fM = valueOrElse(getInteger(this, ((E + "_") + toString(fL))), 0)
820
+
    let fN = valueOrElse(getInteger(this, ((F + "_") + toString(fL))), 0)
821
+
    let fO = (fM + ((fv - fL) * fN))
822
+
    let fP = valueOrElse(getInteger(this, ((E + "_") + toString(fK))), 0)
823
+
    let fQ = valueOrElse(getInteger(this, ((F + "_") + toString(fK))), 0)
824
+
    let fR = (fP + ((fw - fK) * fQ))
825
+
    ((fO - fR) / aC)
826
+
    }
827
+
828
+
829
+
func fS () = {
830
+
    let bY = bt()
831
+
    if ((bY == 0))
832
+
        then $Tuple2(bp(), bq())
703
833
 
        else {
704
-
            let eK = aV(bc(cp), bV())
705
-
            let eL = dD((cp > 0), eK, false)._1
706
-
            eL
834
+
            let fT = (bY > 0)
835
+
            let fU = dy(fT, aV(bY), false)
836
+
            let fV = fU._1
837
+
            let fW = fU._2
838
+
            let fX = fU._3
839
+
            $Tuple2(fW, fX)
707
840
 
            }
708
841
 
    }
709
842
 
710
843
 
711
-
func eM (cr,dt) = {
712
-
    let eN = cq(cr)
713
-
    let cu = eN._1
714
-
    let es = eN._2
715
-
    let et = eN._3
716
-
    let eu = eN._4
717
-
    let ep = eq(cr, aP)._2
718
-
    let eO = dh(cu, es, eu, ep)
719
-
    let dq = eO._1
720
-
    let dr = eO._2
721
-
    let eK = -(cu)
722
-
    let eP = ep
723
-
    let eQ = -(dq)
724
-
    let eR = dD((cu > 0), bc(cu), dt)
725
-
    let eL = eR._1
726
-
    let cU = eR._2
727
-
    let cV = eR._3
728
-
    let eS = eR._4
729
-
    let eT = eR._5
730
-
    let eU = eR._6
731
-
    let eV = (bM() - et)
732
-
    $Tuple13(eK, dr, eP, eQ, cU, cV, eS, eV, eL, eT, eU, (bO() - (if ((cu > 0))
733
-
        then et
734
-
        else 0)), (bN() - (if ((0 > cu))
735
-
        then et
736
-
        else 0)))
844
+
func fY (fZ,bt,ga,gb) = {
845
+
    let gc = toBigInt(fZ)
846
+
    let gd = toBigInt(bt)
847
+
    let ge = toBigInt(ga)
848
+
    let gf = toBigInt(gb)
849
+
    let bf = aS(ge, gc)
850
+
    let gg = (gc + gd)
851
+
    let gh = aR(bf, gg)
852
+
    let gi = aR(gh, gg)
853
+
    let gj = aR(gf, gi)
854
+
    toInt(gj)
737
855
 
    }
738
856
 
739
857
 
740
-
func eW () = {
741
-
    let eX = ((lastBlock.timestamp / 1000) / 60)
742
-
    let eY = (eX - aI)
743
-
    let eZ = valueOrElse(getString(this, C), "")
744
-
    let fa = split(eZ, ",")
745
-
    func fb (bh,fc) =     if ((eY >= parseIntValue(fc)))
746
-
        then (bh :+ parseIntValue(fc))
747
-
        else bh
748
-
749
-
    let fd = {
750
-
        let bk = fa
751
-
        let bl = size(bk)
752
-
        let bm = nil
753
-
        func bn (bo,bp) =         if ((bp >= bl))
754
-
            then bo
755
-
            else fb(bo, bk[bp])
756
-
757
-
        func bq (bo,bp) =         if ((bp >= bl))
758
-
            then bo
759
-
            else throw("List size exceeds 20")
760
-
761
-
        bq(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bm, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
762
-
        }
763
-
    let fe = if ((size(fd) > 0))
764
-
        then max(fd)
765
-
        else parseIntValue(fa[0])
766
-
    let ff = valueOrElse(getInteger(this, D), 0)
767
-
    let fg = valueOrElse(getInteger(this, ((E + "_") + toString(ff))), 0)
768
-
    let fh = valueOrElse(getInteger(this, ((F + "_") + toString(ff))), 0)
769
-
    let fi = (fg + ((eX - ff) * fh))
770
-
    let fj = valueOrElse(getInteger(this, ((E + "_") + toString(fe))), 0)
771
-
    let fk = valueOrElse(getInteger(this, ((F + "_") + toString(fe))), 0)
772
-
    let fl = (fj + ((eY - fe) * fk))
773
-
    ((fi - fl) / aI)
774
-
    }
775
-
776
-
777
-
func fm () = {
778
-
    let cp = bL()
779
-
    if ((cp == 0))
780
-
        then $Tuple2(bH(), bI())
858
+
func gk (gl,cD,cE) = {
859
+
    let bY = bt()
860
+
    if ((bY == 0))
861
+
        then {
862
+
            let gm = aM(aO(gl, cE), cD)
863
+
            $Tuple3(gm, aF, 0)
864
+
            }
781
865
 
        else {
782
-
            let fn = (cp > 0)
783
-
            let fo = dD(fn, bc(cp), false)
784
-
            let fp = fo._1
785
-
            let fq = fo._2
786
-
            let fr = fo._3
787
-
            $Tuple2(fq, fr)
866
+
            let fT = (bY > 0)
867
+
            let fV = dy(fT, aV(bY), false)._1
868
+
            let gm = fY(cE, bY, cD, gl)
869
+
            let gn = aF
870
+
            let go = eh(bY, fV, cD, gm, cE, gn, aI)._2
871
+
            $Tuple3(gm, gn, go)
788
872
 
            }
789
873
 
    }
790
874
 
791
875
 
792
-
func fs (ft,bL,fu,fv) = {
793
-
    let fw = toBigInt(ft)
794
-
    let fx = toBigInt(bL)
795
-
    let fy = toBigInt(fu)
796
-
    let fz = toBigInt(fv)
797
-
    let bz = aZ(fy, fw)
798
-
    let fA = (fw + fx)
799
-
    let fB = aY(bz, fA)
800
-
    let fC = aY(fB, fA)
801
-
    let fD = aY(fz, fC)
802
-
    toInt(fD)
803
-
    }
804
-
805
-
806
-
func fE (fF,cM,cN) = {
807
-
    let cp = bL()
808
-
    if ((cp == 0))
809
-
        then {
810
-
            let fG = aT(aV(fF, cN), cM)
811
-
            $Tuple3(fG, aM, 0)
812
-
            }
813
-
        else {
814
-
            let fn = (cp > 0)
815
-
            let fp = dD(fn, bc(cp), false)._1
816
-
            let fG = fs(cN, cp, cM, fF)
817
-
            let fH = aM
818
-
            let eQ = en(cp, fp, cM, fG, cN, fH, aP)._2
819
-
            $Tuple3(fG, fH, eQ)
820
-
            }
821
-
    }
822
-
823
-
824
-
func fI () = {
825
-
    let fJ = dE()
826
-
    let fK = eW()
827
-
    let fL = (fK - fJ)
828
-
    if (if (if ((cc() == 0))
876
+
func gp () = {
877
+
    let gq = dE()
878
+
    let gr = fu()
879
+
    let gs = (gr - gq)
880
+
    if (if (if ((bK() == 0))
829
881
 
        then true
830
-
        else (cd() == 0))
882
+
        else (bL() == 0))
831
883
 
        then true
832
-
        else dL())
884
+
        else dK())
833
885
 
        then $Tuple2(0, 0)
834
-
        else if ((0 > fL))
886
+
        else if ((0 > gs))
835
887
 
            then {
836
-
                let fM = aT(aV(fL, bR()), aN)
837
-
                let fN = aT(aV(fM, cc()), cd())
838
-
                $Tuple2(fM, fN)
888
+
                let gt = aM(aO(gs, bz()), aH)
889
+
                let gu = aM(aO(gt, bK()), bL())
890
+
                $Tuple2(gt, gu)
839
891
 
                }
840
892
 
            else {
841
-
                let fN = aT(aV(fL, bR()), aN)
842
-
                let fM = aT(aV(fN, cd()), cc())
843
-
                $Tuple2(fM, fN)
893
+
                let gu = aM(aO(gs, bz()), aH)
894
+
                let gt = aM(aO(gu, bL()), bK())
895
+
                $Tuple2(gt, gu)
844
896
 
                }
845
897
 
    }
846
898
 
847
899
 
848
-
func fO (fP,fQ) = {
849
-
    let fR = bF()
850
-
    let fS = aV(fR, fQ)
851
-
    let fT = if ((fP != ""))
900
+
func gv (gw,gx) = {
901
+
    let gy = bm()
902
+
    let gz = aO(gy, gx)
903
+
    let gA = if ((gw != ""))
852
904
 
        then {
853
-
            let fU = bC(ax(), ak(aE, fP))
854
-
            if ((fU == aF))
905
+
            let gB = bi(aw(), aj(ay, gw))
906
+
            if ((gB == az))
855
907
 
                then {
856
-
                    let fV = bD(ax(), ak(aD, fP))
857
-
                    let fW = aV(fS, fV)
858
-
                    $Tuple2(fW, true)
908
+
                    let gC = bk(aw(), aj(ax, gw))
909
+
                    let gD = aO(gz, gC)
910
+
                    $Tuple2(gD, true)
859
911
 
                    }
860
912
 
                else throw("Invalid attached artifact")
861
913
 
            }
862
-
        else $Tuple2(fS, false)
863
-
    let fW = fT._1
864
-
    let fX = fT._2
865
-
    $Tuple2(fW, fX)
914
+
        else $Tuple2(gz, false)
915
+
    let gD = gA._1
916
+
    let gE = gA._2
917
+
    $Tuple2(gD, gE)
866
918
 
    }
867
919
 
868
920
 
869
-
func fY (cr,aC) = {
870
-
    let fZ = cq(cr)._1
871
-
    if ((fZ == 0))
921
+
func gF (ca,gG) = {
922
+
    let eM = bZ(ca)._1
923
+
    if ((eM == 0))
872
924
 
        then true
873
-
        else (cv(cr) == aC)
925
+
        else (ce(ca) == gG)
874
926
 
    }
875
927
 
876
928
 
877
-
func ga (cr,aC) = (cv(cr) == aC)
929
+
func gH (ca,gG) = (ce(ca) == gG)
878
930
 
879
931
 
880
-
func gb (gc,aC,cr) = ((((((aj + "_") + gc) + "_") + aC) + "_") + cr)
881
-
882
-
883
-
func gd (cr) = {
884
-
    let cx = cv(cr)
885
-
    if ((cx == toBase58String(aq())))
886
-
        then $Tuple2(0, cx)
887
-
        else {
888
-
            let ge = gb(toString(this), cx, cr)
889
-
            let gf = valueOrElse(getInteger(ay(), ge), 0)
890
-
            $Tuple2(gf, cx)
891
-
            }
892
-
    }
893
-
894
-
895
-
func gg (cr,fP) = {
896
-
    let gh = invoke(au(), "computeFeeDiscount", [cr], nil)
897
-
    if ((gh == gh))
932
+
func gI (ca,gw) = {
933
+
    let gJ = invoke(at(), "computeFeeDiscount", [ca], nil)
934
+
    if ((gJ == gJ))
898
935
 
        then {
899
-
            let gi = {
900
-
                let ct = gh
901
-
                if ($isInstanceOf(ct, "Int"))
936
+
            let gK = {
937
+
                let cc = gJ
938
+
                if ($isInstanceOf(cc, "Int"))
902
939
 
                    then {
903
-
                        let gj = ct
904
-
                        gj
940
+
                        let gL = cc
941
+
                        gL
905
942
 
                        }
906
943
 
                    else throw("Invalid computeFeeDiscount result")
907
944
 
                }
908
-
            let gk = fO(fP, gi)
909
-
            let fW = gk._1
910
-
            let fX = gk._2
911
-
            $Tuple2(fW, fX)
945
+
            let gM = gv(gw, gK)
946
+
            let gD = gM._1
947
+
            let gE = gM._2
948
+
            $Tuple2(gD, gE)
912
949
 
            }
913
950
 
        else throw("Strict value is not equal to itself.")
914
951
 
    }
915
952
 
916
953
 
917
-
func gl (ci) = {
918
-
    let gm = if ((size(ci.payments) > 1))
919
-
        then toBase58String(valueOrErrorMessage(ci.payments[1].assetId, "Invalid artifactId"))
954
+
func gN (bR) = {
955
+
    let gO = if ((size(bR.payments) > 1))
956
+
        then toBase58String(valueOrErrorMessage(bR.payments[1].assetId, "Invalid artifactId"))
920
957
 
        else ""
921
-
    gm
958
+
    gO
922
959
 
    }
923
960
 
924
961
 
925
-
func gn (go) = {
926
-
    let gp = aV(go, cf())
927
-
    let gq = (go - gp)
928
-
    $Tuple2(gp, gq)
962
+
func gP (gQ) = {
963
+
    let gR = aO(gQ, bN())
964
+
    let gS = (gQ - gR)
965
+
    $Tuple2(gR, gS)
929
966
 
    }
930
967
 
931
968
 
932
-
func gr (gs,gt,gu,gv,gw,gx,gy,gz,gA,dZ,gB,gC) = [IntegerEntry(s, gs), IntegerEntry(t, gt), IntegerEntry(u, gu), IntegerEntry(r, gv), IntegerEntry(q, gw), IntegerEntry(w, gx), IntegerEntry(x, gy), IntegerEntry(v, gz), IntegerEntry(y, gA), IntegerEntry(z, dZ), IntegerEntry(A, gB), IntegerEntry(B, gB)]
969
+
func gT (gU,gV,gW,gX,eI,gY,gZ,ha,hb,dX,hc,hd,he) = [IntegerEntry(s, gU), IntegerEntry(t, gV), IntegerEntry(u, gW), IntegerEntry(r, gX), IntegerEntry(p, eI), IntegerEntry(w, gY), IntegerEntry(x, gZ), IntegerEntry(v, ha), IntegerEntry(y, hb), IntegerEntry(z, dX), IntegerEntry(A, hc), IntegerEntry(B, hc), IntegerEntry(q, he)]
933
970
 
934
971
 
935
-
func gD (gE,gF,gG,gH,gI) = [IntegerEntry(J, gE), IntegerEntry(H, gF), IntegerEntry(I, gG), IntegerEntry(K, gH), IntegerEntry(L, gI)]
972
+
func hf (hg,hh,hi,hj,hk) = [IntegerEntry(J, hg), IntegerEntry(H, hh), IntegerEntry(I, hi), IntegerEntry(K, hj), IntegerEntry(L, hk)]
936
973
 
937
974
 
938
-
func gJ (am,aC) = [StringEntry(ak(l, am), aC)]
939
-
940
-
941
-
func gK (gL,am) = if (gL)
975
+
func hl (hm,al) = if (hm)
942
976
 
    then {
943
-
        let gM = ce()
944
-
[IntegerEntry(ak(k, am), (gM + 1)), IntegerEntry(f, (gM + 1))]
977
+
        let hn = bM()
978
+
[IntegerEntry(aj(i, al), (hn + 1)), IntegerEntry(d, (hn + 1))]
945
979
 
        }
946
980
 
    else nil
947
981
 
948
982
 
949
-
func gN (gL,am,gw) = if (gL)
950
-
    then [IntegerEntry(ak(m, am), gw)]
983
+
func ho (hm,al,eI) = if (hm)
984
+
    then [IntegerEntry(aj(k, al), eI)]
951
985
 
    else nil
952
986
 
953
987
 
954
-
func gO (am,gP,gQ,gR,dn) = [IntegerEntry(ak(g, am), gP), IntegerEntry(ak(h, am), gQ), IntegerEntry(ak(i, am), gR), IntegerEntry(ak(j, am), dn)]
988
+
func hp (al,eH,hq,hr,di,hs) = [IntegerEntry(aj(e, al), eH), IntegerEntry(aj(f, al), hq), IntegerEntry(aj(g, al), hr), IntegerEntry(aj(h, al), di), IntegerEntry(aj(l, al), hs)]
955
989
 
956
990
 
957
-
func gS (gT) = {
958
-
    let eX = ((lastBlock.timestamp / 1000) / 60)
959
-
    let gU = valueOrElse(getInteger(this, D), 0)
960
-
    if ((gU > eX))
991
+
func ht (hu) = {
992
+
    let fv = ((bP() / 1000) / 60)
993
+
    let hv = valueOrElse(getInteger(this, D), 0)
994
+
    if ((hv > fv))
961
995
 
        then throw("TWAP out-of-order")
962
996
 
        else {
963
-
            let ff = if ((gU == 0))
964
-
                then eX
965
-
                else gU
966
-
            if ((eX > gU))
997
+
            let fL = if ((hv == 0))
998
+
                then fv
999
+
                else hv
1000
+
            if ((fv > hv))
967
1001
 
                then {
968
-
                    let gV = valueOrElse(getInteger(this, ((E + "_") + toString(gU))), 0)
969
-
                    let gW = valueOrElse(getInteger(this, ((F + "_") + toString(gU))), gT)
970
-
                    let gX = (gV + ((eX - ff) * gW))
971
-
                    let fa = bv(bt(valueOrElse(getString(this, C), "")), aI, toString(eX))
972
-
[IntegerEntry(ak(E, toString(eX)), gX), IntegerEntry(ak(F, toString(eX)), gT), IntegerEntry(ak(G, toString(eX)), gU), IntegerEntry(D, eX), StringEntry(C, be(fa))]
1002
+
                    let hw = valueOrElse(getInteger(this, ((E + "_") + toString(hv))), 0)
1003
+
                    let hx = valueOrElse(getInteger(this, ((F + "_") + toString(hv))), hu)
1004
+
                    let hy = (hw + ((fv - fL) * hx))
1005
+
                    let fy = bb(aZ(valueOrElse(getString(this, C), "")), aC, toString(fv))
1006
+
[IntegerEntry(aj(E, toString(fv)), hy), IntegerEntry(aj(F, toString(fv)), hu), IntegerEntry(aj(G, toString(fv)), hv), IntegerEntry(D, fv), StringEntry(C, aX(fy))]
973
1007
 
                    }
974
1008
 
                else {
975
-
                    let gY = valueOrElse(getInteger(this, ak(G, toString(eX))), 0)
976
-
                    let gV = valueOrElse(getInteger(this, ak(E, toString(gY))), 0)
977
-
                    let gW = valueOrElse(getInteger(this, ak(F, toString(gY))), gT)
978
-
                    let gX = (gV + ((eX - gY) * gW))
979
-
[IntegerEntry(ak(E, toString(eX)), gX), IntegerEntry(ak(F, toString(eX)), gT)]
1009
+
                    let hz = valueOrElse(getInteger(this, aj(G, toString(fv))), 0)
1010
+
                    let hw = valueOrElse(getInteger(this, aj(E, toString(hz))), 0)
1011
+
                    let hx = valueOrElse(getInteger(this, aj(F, toString(hz))), hu)
1012
+
                    let hy = (hw + ((fv - hz) * hx))
1013
+
[IntegerEntry(aj(E, toString(fv)), hy), IntegerEntry(aj(F, toString(fv)), hu)]
980
1014
 
                    }
981
1015
 
            }
982
1016
 
    }
983
1017
 
984
1018
 
985
-
func gZ (cM,cN) = [IntegerEntry(M, cM), IntegerEntry(N, cN)]
1019
+
func hA (cD,cE) = [IntegerEntry(M, cD), IntegerEntry(N, cE)]
986
1020
 
987
1021
 
988
-
func ha (cR,cS) = [IntegerEntry(O, cR), IntegerEntry(P, cS)]
1022
+
func hB (cI,cJ) = [IntegerEntry(O, cI), IntegerEntry(P, cJ)]
989
1023
 
990
1024
 
991
-
func hb (cM,cN,hc,hd,he,hf,hg,hh) = {
992
-
    let cR = bJ()
993
-
    let cS = bK()
994
-
    if (((he - hf) != hc))
995
-
        then throw(((((("Invalid AMM state data: " + toString(he)) + " +  ") + toString(hf)) + " != ") + toString(hc)))
996
-
        else ((gZ(cM, cN) ++ [IntegerEntry(Q, hc), IntegerEntry(T, hd), IntegerEntry(R, he), IntegerEntry(S, hf), IntegerEntry(V, hg), IntegerEntry(U, hh)]) ++ gS(aT(aV(cM, cR), aV(cN, cS))))
1025
+
func hC (cD,cE,hD,hE,hF,hG,hH,hI) = {
1026
+
    let cI = br()
1027
+
    let cJ = bs()
1028
+
    if (((hF - hG) != hD))
1029
+
        then throw(((((("Invalid AMM state data: " + toString(hF)) + " +  ") + toString(hG)) + " != ") + toString(hD)))
1030
+
        else ((hA(cD, cE) ++ [IntegerEntry(Q, hD), IntegerEntry(T, hE), IntegerEntry(R, hF), IntegerEntry(S, hG), IntegerEntry(V, hH), IntegerEntry(U, hI)]) ++ ht(aM(aO(cD, cI), aO(cE, cJ))))
997
1031
 
    }
998
1032
 
999
1033
 
1000
-
func hi (am) = [DeleteEntry(ak(g, am)), DeleteEntry(ak(h, am)), DeleteEntry(ak(i, am)), DeleteEntry(ak(j, am)), DeleteEntry(ak(l, am))]
1034
+
func hJ (al) = [DeleteEntry(aj(e, al)), DeleteEntry(aj(f, al)), DeleteEntry(aj(g, al)), DeleteEntry(aj(h, al)), DeleteEntry(aj(j, al)), DeleteEntry(aj(k, al)), DeleteEntry(aj(l, al))]
1001
1035
 
1002
1036
 
1003
-
func hj (am,hk) = {
1004
-
    let hl = assetBalance(this, aq())
1005
-
    if ((hk > hl))
1006
-
        then throw(((("Unable to withdraw " + toString(hk)) + " from contract balance ") + toString(hl)))
1007
-
        else [ScriptTransfer(am, hk, aq())]
1037
+
func hK (al,hL) = {
1038
+
    let hM = assetBalance(this, ap())
1039
+
    if ((hL > hM))
1040
+
        then throw(((("Unable to withdraw " + toString(hL)) + " from contract balance ") + toString(hM)))
1041
+
        else [ScriptTransfer(al, hL, ap())]
1008
1042
 
    }
1009
1043
 
1010
1044
 
1011
-
func hm (ci) = if ((0 > ci))
1045
+
func hN (bR) = if ((0 > bR))
1012
1046
 
    then throw("Balance")
1013
-
    else [IntegerEntry(e, ci)]
1047
+
    else [IntegerEntry(c, bR)]
1014
1048
 
1015
1049
 
1016
-
func hn (ci) = [ScriptTransfer(as(), ci, aq())]
1050
+
func hO (bR) = [ScriptTransfer(ar(), bR, ap())]
1017
1051
 
1018
1052
 
1019
-
func ho (hp,ci) = if (hp)
1020
-
    then [Burn(valueOrErrorMessage(ci.payments[1].assetId, "Invalid artifact"), 1)]
1053
+
func hP (hQ,bR) = if (hQ)
1054
+
    then [Burn(valueOrErrorMessage(bR.payments[1].assetId, "Invalid artifact"), 1)]
1021
1055
 
    else nil
1022
1056
 
1023
1057
 
1024
-
@Callable(ci)
1025
-
func pause () = if ((ci.caller != ao()))
1058
+
@Callable(bR)
1059
+
func pause () = if ((bR.caller != an()))
1026
1060
 
    then throw("Invalid pause params")
1061
+
    else [BooleanEntry(n, true)]
1062
+
1063
+
1064
+
1065
+
@Callable(bR)
1066
+
func unpause () = if ((bR.caller != an()))
1067
+
    then throw("Invalid unpause params")
1068
+
    else [BooleanEntry(n, false)]
1069
+
1070
+
1071
+
1072
+
@Callable(bR)
1073
+
func setCloseOnly () = if ((bR.caller != an()))
1074
+
    then throw("Invalid setCloseOnly params")
1027
1075
 
    else [BooleanEntry(o, true)]
1028
1076
 
1029
1077
 
1030
1078
 
1031
-
@Callable(ci)
1032
-
func unpause () = if ((ci.caller != ao()))
1033
-
    then throw("Invalid unpause params")
1079
+
@Callable(bR)
1080
+
func unsetCloseOnly () = if ((bR.caller != an()))
1081
+
    then throw("Invalid unsetCloseOnly params")
1034
1082
 
    else [BooleanEntry(o, false)]
1035
1083
 
1036
1084
 
1037
1085
 
1038
-
@Callable(ci)
1039
-
func setCloseOnly () = if ((ci.caller != ao()))
1040
-
    then throw("Invalid setCloseOnly params")
1041
-
    else [BooleanEntry(p, true)]
1042
-
1043
-
1044
-
1045
-
@Callable(ci)
1046
-
func unsetCloseOnly () = if ((ci.caller != ao()))
1047
-
    then throw("Invalid unsetCloseOnly params")
1048
-
    else [BooleanEntry(p, false)]
1049
-
1050
-
1051
-
1052
-
@Callable(ci)
1053
-
func addLiquidity (cH) = if (if ((ci.caller != ao()))
1086
+
@Callable(bR)
1087
+
func addLiquidity (cy) = if (if ((bR.caller != an()))
1054
1088
 
    then true
1055
-
    else (0 >= cH))
1089
+
    else (0 >= cy))
1056
1090
 
    then throw("Invalid addLiquidity params")
1057
1091
 
    else {
1058
-
        let cM = bH()
1059
-
        let cN = bI()
1060
-
        let cR = bJ()
1061
-
        let cS = bK()
1062
-
        let hq = aT(aV(cM, cR), aV(cN, cS))
1063
-
        let hr = (cM + cH)
1064
-
        let hs = (aT(aV(hr, cR), hq) - cN)
1065
-
        let ht = (cN + hs)
1066
-
        let hu = fE(dE(), hr, ht)
1067
-
        let hv = hu._1
1068
-
        let hw = hu._2
1069
-
        let eQ = hu._3
1070
-
        let hx = if ((eQ != 0))
1092
+
        let cD = bp()
1093
+
        let cE = bq()
1094
+
        let cI = br()
1095
+
        let cJ = bs()
1096
+
        let hR = aM(aO(cD, cI), aO(cE, cJ))
1097
+
        let hS = (cD + cy)
1098
+
        let hT = (aM(aO(hS, cI), hR) - cE)
1099
+
        let hU = (cE + hT)
1100
+
        let hV = gk(dE(), hS, hU)
1101
+
        let hW = hV._1
1102
+
        let hX = hV._2
1103
+
        let go = hV._3
1104
+
        let hY = if ((go != 0))
1071
1105
 
            then {
1072
-
                let hx = invoke(at(), "exchangeFreeAndLocked", [eQ], nil)
1073
-
                if ((hx == hx))
1106
+
                let hY = invoke(as(), "exchangeFreeAndLocked", [go], nil)
1107
+
                if ((hY == hY))
1074
1108
 
                    then nil
1075
1109
 
                    else throw("Strict value is not equal to itself.")
1076
1110
 
                }
1077
1111
 
            else nil
1078
-
        if ((hx == hx))
1079
-
            then (gZ(hr, ht) ++ ha(hv, hw))
1112
+
        if ((hY == hY))
1113
+
            then (hA(hS, hU) ++ hB(hW, hX))
1080
1114
 
            else throw("Strict value is not equal to itself.")
1081
1115
 
        }
1082
1116
 
1083
1117
 
1084
1118
 
1085
-
@Callable(ci)
1086
-
func removeLiquidity (cH) = if (if ((ci.caller != ao()))
1119
+
@Callable(bR)
1120
+
func removeLiquidity (cy) = if (if ((bR.caller != an()))
1087
1121
 
    then true
1088
-
    else (cH >= 0))
1122
+
    else (cy >= 0))
1089
1123
 
    then throw("Invalid removeLiquidity params")
1090
1124
 
    else {
1091
-
        let cM = bH()
1092
-
        let cN = bI()
1093
-
        let cR = bJ()
1094
-
        let cS = bK()
1095
-
        let hq = aT(aV(cM, cR), aV(cN, cS))
1096
-
        let hr = (cM - cH)
1097
-
        let hy = bc((aT(aV(hr, cR), hq) - cN))
1098
-
        let ht = (cN - hy)
1099
-
        let hz = fE(dE(), hr, ht)
1100
-
        let hv = hz._1
1101
-
        let hw = hz._2
1102
-
        let eQ = hz._3
1103
-
        let hx = if ((eQ != 0))
1125
+
        let cD = bp()
1126
+
        let cE = bq()
1127
+
        let cI = br()
1128
+
        let cJ = bs()
1129
+
        let hR = aM(aO(cD, cI), aO(cE, cJ))
1130
+
        let hS = (cD - cy)
1131
+
        let hZ = aV((aM(aO(hS, cI), hR) - cE))
1132
+
        let hU = (cE - hZ)
1133
+
        let ia = gk(dE(), hS, hU)
1134
+
        let hW = ia._1
1135
+
        let hX = ia._2
1136
+
        let go = ia._3
1137
+
        let hY = if ((go != 0))
1104
1138
 
            then {
1105
-
                let hx = invoke(at(), "exchangeFreeAndLocked", [eQ], nil)
1106
-
                if ((hx == hx))
1139
+
                let hY = invoke(as(), "exchangeFreeAndLocked", [go], nil)
1140
+
                if ((hY == hY))
1107
1141
 
                    then nil
1108
1142
 
                    else throw("Strict value is not equal to itself.")
1109
1143
 
                }
1110
1144
 
            else nil
1111
-
        if ((hx == hx))
1112
-
            then (gZ(hr, ht) ++ ha(hv, hw))
1145
+
        if ((hY == hY))
1146
+
            then (hA(hS, hU) ++ hB(hW, hX))
1113
1147
 
            else throw("Strict value is not equal to itself.")
1114
1148
 
        }
1115
1149
 
1116
1150
 
1117
1151
 
1118
-
@Callable(ci)
1119
-
func changeSettings (gs,gt,gu,gv,gw,gx,gy,gz,gA,dZ,gB,gC) = if ((ci.caller != ao()))
1152
+
@Callable(bR)
1153
+
func changeSettings (gU,gV,gW,gX,eI,gY,gZ,ha,hb,dX,hc,hd,he) = if ((bR.caller != an()))
1120
1154
 
    then throw("Invalid changeSettings params")
1121
-
    else gr(gs, gt, gu, gv, gw, gx, gy, gz, gA, dZ, gB, gC)
1155
+
    else gT(gU, gV, gW, gX, eI, gY, gZ, ha, hb, dX, hc, hd, he)
1122
1156
 
1123
1157
 
1124
1158
 
1125
-
@Callable(ci)
1126
-
func initialize (cM,cN,gv,gs,gt,gu,gw,hA,hB,hC,hD,gx,gy,gz,gA,dZ,gB,gC) = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if ((0 >= cM))
1159
+
@Callable(bR)
1160
+
func initialize (cD,cE,gX,gU,gV,gW,eI,ib,ic,id,gY,gZ,ha,hb,dX,hc,hd,he) = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if ((0 >= cD))
1127
1161
 
    then true
1128
-
    else (0 >= cN))
1162
+
    else (0 >= cE))
1129
1163
 
    then true
1130
-
    else (0 >= gv))
1164
+
    else (0 >= gX))
1131
1165
 
    then true
1132
-
    else (0 >= gs))
1166
+
    else (0 >= gU))
1133
1167
 
    then true
1134
-
    else (0 >= gt))
1168
+
    else (0 >= gV))
1135
1169
 
    then true
1136
-
    else (0 >= gu))
1170
+
    else (0 >= gW))
1137
1171
 
    then true
1138
-
    else (0 >= gw))
1172
+
    else (0 >= eI))
1139
1173
 
    then true
1140
-
    else (0 >= gx))
1174
+
    else (0 >= gY))
1141
1175
 
    then true
1142
-
    else (0 >= gy))
1176
+
    else (0 >= gZ))
1143
1177
 
    then true
1144
-
    else (0 >= gz))
1178
+
    else (0 >= ha))
1145
1179
 
    then true
1146
-
    else (0 >= gA))
1180
+
    else (0 >= hb))
1147
1181
 
    then true
1148
-
    else (0 >= dZ))
1182
+
    else (0 >= dX))
1149
1183
 
    then true
1150
-
    else (0 >= gB))
1184
+
    else (0 >= hc))
1151
1185
 
    then true
1152
-
    else (gB > aM))
1186
+
    else (hc > aF))
1153
1187
 
    then true
1154
-
    else (0 >= gC))
1188
+
    else (0 >= hd))
1155
1189
 
    then true
1156
-
    else cC())
1190
+
    else (0 >= he))
1191
+
    then true
1192
+
    else ct())
1157
1193
 
    then throw("Invalid initialize parameters")
1158
-
    else ((((hb(cM, cN, 0, 0, 0, 0, 0, 0) ++ gr(gs, gt, gu, gv, gw, gx, gy, gz, gA, dZ, gB, gC)) ++ gD((lastBlock.timestamp + gv), 0, 0, 0, 0)) ++ hm(0)) ++ [BooleanEntry(n, true), StringEntry(d, hA), StringEntry(a, hB), StringEntry(b, hC), StringEntry(W, hD)])
1194
+
    else ((((hC(cD, cE, 0, 0, 0, 0, 0, 0) ++ gT(gU, gV, gW, gX, eI, gY, gZ, ha, hb, dX, hc, hd, he)) ++ hf((bP() + gX), 0, 0, 0, 0)) ++ hN(0)) ++ [BooleanEntry(m, true), StringEntry(a, ib), StringEntry(b, ic), StringEntry(X, id)])
1159
1195
 
1160
1196
 
1161
1197
 
1162
-
@Callable(ci)
1163
-
func increasePosition (hE,hF,hG,hH) = {
1164
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1165
-
    if ((hI == hI))
1198
+
@Callable(bR)
1199
+
func increasePosition (ie,if,ig,ih) = {
1200
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1201
+
    if ((ii == ii))
1166
1202
 
        then {
1167
-
            let cr = ch(ci)
1168
-
            let hJ = ci.payments[0].amount
1169
-
            let aC = ci.payments[0].assetId
1170
-
            let hK = toBase58String(value(aC))
1171
-
            let hL = (aC == aq())
1172
-
            let hM = aB(hK)
1173
-
            if (if (if (if (if (if (if (if (if (if ((hE != aG))
1174
-
                then (hE != aH)
1175
-
                else false)
1176
-
                then true
1177
-
                else (0 >= hJ))
1178
-
                then true
1179
-
                else !(cC()))
1180
-
                then true
1181
-
                else if (!(hL))
1182
-
                    then !(hM)
1183
-
                    else false)
1184
-
                then true
1185
-
                else !(fY(cr, hK)))
1186
-
                then true
1187
-
                else !(cj(aT(aM, hF), bG(), true)))
1188
-
                then true
1189
-
                else cD())
1190
-
                then true
1191
-
                else cE())
1192
-
                then true
1193
-
                else dL())
1194
-
                then throw("Invalid increasePosition parameters")
1195
-
                else {
1196
-
                    let hN = gg(cr, gl(ci))
1197
-
                    let fW = hN._1
1198
-
                    let fX = hN._2
1199
-
                    let hk = aT(hJ, (aV(fW, hF) + aM))
1200
-
                    let hO = (hJ - hk)
1201
-
                    let hP = if (hM)
1202
-
                        then {
1203
-
                            let hQ = invoke(ay(), "borrow", [cr], [AttachedPayment(aC, hk)])
1204
-
                            if ((hQ == hQ))
1203
+
            let ij = invoke(this, "ensureCalledOnce", nil, nil)
1204
+
            if ((ij == ij))
1205
+
                then {
1206
+
                    let ca = bQ(bR)
1207
+
                    let ik = bR.payments[0].amount
1208
+
                    let gG = bR.payments[0].assetId
1209
+
                    let il = toBase58String(value(gG))
1210
+
                    let im = (gG == ap())
1211
+
                    if (if (if (if (if (if (if (if (if (if ((ie != aA))
1212
+
                        then (ie != aB)
1213
+
                        else false)
1214
+
                        then true
1215
+
                        else (0 >= ik))
1216
+
                        then true
1217
+
                        else !(ct()))
1218
+
                        then true
1219
+
                        else !(im))
1220
+
                        then true
1221
+
                        else !(gF(ca, il)))
1222
+
                        then true
1223
+
                        else !(bS(aM(aF, if), bo(), true)))
1224
+
                        then true
1225
+
                        else cu())
1226
+
                        then true
1227
+
                        else cv())
1228
+
                        then true
1229
+
                        else dK())
1230
+
                        then throw("Invalid increasePosition parameters")
1231
+
                        else {
1232
+
                            let in = gI(ca, gN(bR))
1233
+
                            let gD = in._1
1234
+
                            let gE = in._2
1235
+
                            let hL = aM(ik, (aO(gD, if) + aF))
1236
+
                            let io = (ik - hL)
1237
+
                            let ip = invoke(av(), "acceptPaymentWithLink", [ca, ih], [AttachedPayment(ap(), io)])
1238
+
                            if ((ip == ip))
1205
1239
 
                                then {
1206
-
                                    let hR = assetBalance(this, aq())
1207
-
                                    if ((hR == hR))
1240
+
                                    let iq = {
1241
+
                                        let cc = ip
1242
+
                                        if ($isInstanceOf(cc, "Int"))
1243
+
                                            then {
1244
+
                                                let gL = cc
1245
+
                                                gL
1246
+
                                                }
1247
+
                                            else throw("Invalid referrerFee")
1248
+
                                        }
1249
+
                                    let ir = (io - iq)
1250
+
                                    let is = bZ(ca)
1251
+
                                    let eM = is._1
1252
+
                                    let eN = is._2
1253
+
                                    let eO = is._3
1254
+
                                    let eP = is._4
1255
+
                                    let eQ = is._5
1256
+
                                    let it = (eM == 0)
1257
+
                                    let iu = if ((eM > 0))
1258
+
                                        then (ie == aA)
1259
+
                                        else (ie == aB)
1260
+
                                    let iv = if (!(it))
1261
+
                                        then iu
1262
+
                                        else false
1263
+
                                    let iw = (ie == aA)
1264
+
                                    let ix = if (if (it)
1265
+
                                        then true
1266
+
                                        else iv)
1208
1267
 
                                        then {
1209
-
                                            let hS = invoke(az(), "swap", [toBase58String(aq()), 0], [AttachedPayment(aC, hO)])
1210
-
                                            if ((hS == hS))
1268
+
                                            let iy = aO(hL, if)
1269
+
                                            let iz = cH(iw, iy)
1270
+
                                            let cO = iz._1
1271
+
                                            let cL = iz._2
1272
+
                                            let cM = iz._3
1273
+
                                            let eW = iz._4
1274
+
                                            if (if ((ig != 0))
1275
+
                                                then (ig > aV(cO))
1276
+
                                                else false)
1277
+
                                                then throw(((("Limit error: " + toString(aV(cO))) + " < ") + toString(ig)))
1278
+
                                                else {
1279
+
                                                    let fk = (eM + cO)
1280
+
                                                    let iA = (bw() + (if ((fk > 0))
1281
+
                                                        then iy
1282
+
                                                        else 0))
1283
+
                                                    let iB = (bv() + (if ((0 > fk))
1284
+
                                                        then iy
1285
+
                                                        else 0))
1286
+
                                                    let iC = dd(eM, eN, eP, eQ, hL)
1287
+
                                                    let dl = iC._1
1288
+
                                                    let fe = iC._2
1289
+
                                                    let ff = iC._3
1290
+
                                                    let dc = iC._4
1291
+
                                                    if (!(dQ(cL, cM)))
1292
+
                                                        then throw("Over max spread limit")
1293
+
                                                        else if (!(dU(iA, iB)))
1294
+
                                                            then throw("Over max open notional")
1295
+
                                                            else $Tuple14(fk, dl, (eO + iy), bX(fk), bP(), cM, cL, eW, (bu() + iy), (bL() + (if ((fk > 0))
1296
+
                                                                then aV(cO)
1297
+
                                                                else 0)), (bK() + (if ((0 > fk))
1298
+
                                                                then aV(cO)
1299
+
                                                                else 0)), iA, iB, dc)
1300
+
                                                    }
1301
+
                                            }
1302
+
                                        else {
1303
+
                                            let iy = aO(hL, if)
1304
+
                                            let iD = ek(toString(bR.caller), aI)
1305
+
                                            let eZ = iD._1
1306
+
                                            let ej = iD._2
1307
+
                                            if ((eZ > iy))
1308
+
                                                then throw("Use decreasePosition to decrease position size")
1309
+
                                                else throw("Close position first")
1310
+
                                            }
1311
+
                                    let fk = ix._1
1312
+
                                    let iE = ix._2
1313
+
                                    let fm = ix._3
1314
+
                                    let iF = ix._4
1315
+
                                    let iG = ix._5
1316
+
                                    let cM = ix._6
1317
+
                                    let cL = ix._7
1318
+
                                    let eW = ix._8
1319
+
                                    let iH = ix._9
1320
+
                                    let iI = ix._10
1321
+
                                    let iJ = ix._11
1322
+
                                    let iA = ix._12
1323
+
                                    let iB = ix._13
1324
+
                                    let dc = ix._14
1325
+
                                    let iK = gP((ir + dc))
1326
+
                                    let gR = iK._1
1327
+
                                    let gS = iK._2
1328
+
                                    let iL = if ((hL >= dc))
1329
+
                                        then invoke(as(), "addLocked", nil, [AttachedPayment(ap(), (hL - dc))])
1330
+
                                        else invoke(as(), "withdrawLocked", [(dc - hL)], nil)
1331
+
                                    if ((iL == iL))
1332
+
                                        then {
1333
+
                                            let iM = invoke(as(), "addFree", nil, [AttachedPayment(ap(), gS)])
1334
+
                                            if ((iM == iM))
1211
1335
 
                                                then {
1212
-
                                                    let hT = assetBalance(this, aq())
1213
-
                                                    if ((hT == hT))
1336
+
                                                    let iN = invoke(at(), "notifyFees", [ca, ir], nil)
1337
+
                                                    if ((iN == iN))
1214
1338
 
                                                        then {
1215
-
                                                            let hU = (hT - hR)
1216
-
                                                            if ((hU == hU))
1217
-
                                                                then hU
1339
+
                                                            let iO = invoke(at(), "notifyNotional", [ca, fm], nil)
1340
+
                                                            if ((iO == iO))
1341
+
                                                                then ((((((hp(ca, fk, iE, fm, iF, iG) ++ hl(it, ca)) ++ ho(it, ca, gD)) ++ hC(cL, cM, eW, iH, iI, iJ, iA, iB)) ++ hO(gR)) ++ hN(((bl() + hL) - dc))) ++ hP(gE, bR))
1218
1342
 
                                                                else throw("Strict value is not equal to itself.")
1219
1343
 
                                                            }
1220
1344
 
                                                        else throw("Strict value is not equal to itself.")
1225
1349
 
                                    }
1226
1350
 
                                else throw("Strict value is not equal to itself.")
1227
1351
 
                            }
1228
-
                        else hO
1229
-
                    if ((hP == hP))
1230
-
                        then {
1231
-
                            let hV = invoke(aw(), "acceptPaymentWithLink", [cr, hH], [AttachedPayment(aq(), hP)])
1232
-
                            if ((hV == hV))
1352
+
                    }
1353
+
                else throw("Strict value is not equal to itself.")
1354
+
            }
1355
+
        else throw("Strict value is not equal to itself.")
1356
+
    }
1357
+
1358
+
1359
+
1360
+
@Callable(bR)
1361
+
func addMargin () = {
1362
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1363
+
    if ((ii == ii))
1364
+
        then {
1365
+
            let ij = invoke(this, "ensureCalledOnce", nil, nil)
1366
+
            if ((ij == ij))
1367
+
                then {
1368
+
                    let ca = toString(bR.caller)
1369
+
                    let hL = bR.payments[0].amount
1370
+
                    let gG = bR.payments[0].assetId
1371
+
                    let il = toBase58String(value(gG))
1372
+
                    let im = (gG == ap())
1373
+
                    if (if (if (if (if (if (if (!(im))
1374
+
                        then true
1375
+
                        else !(ck(toString(bR.caller))))
1376
+
                        then true
1377
+
                        else !(gH(ca, il)))
1378
+
                        then true
1379
+
                        else !(ct()))
1380
+
                        then true
1381
+
                        else cu())
1382
+
                        then true
1383
+
                        else cv())
1384
+
                        then true
1385
+
                        else dK())
1386
+
                        then throw("Invalid addMargin parameters")
1387
+
                        else {
1388
+
                            let iP = bZ(ca)
1389
+
                            let eM = iP._1
1390
+
                            let eN = iP._2
1391
+
                            let eO = iP._3
1392
+
                            let eP = iP._4
1393
+
                            let eQ = iP._5
1394
+
                            let iL = invoke(as(), "addLocked", nil, [AttachedPayment(ap(), hL)])
1395
+
                            if ((iL == iL))
1233
1396
 
                                then {
1234
-
                                    let hW = {
1235
-
                                        let ct = hV
1236
-
                                        if ($isInstanceOf(ct, "Int"))
1237
-
                                            then {
1238
-
                                                let gj = ct
1239
-
                                                gj
1240
-
                                                }
1241
-
                                            else throw("Invalid referrerFee")
1242
-
                                        }
1243
-
                                    let hX = (hP - hW)
1244
-
                                    let hY = cq(cr)
1245
-
                                    let fZ = hY._1
1246
-
                                    let hZ = hY._2
1247
-
                                    let ia = hY._3
1248
-
                                    let ib = hY._4
1249
-
                                    let ic = (fZ == 0)
1250
-
                                    let id = if ((fZ > 0))
1251
-
                                        then (hE == aG)
1252
-
                                        else (hE == aH)
1253
-
                                    let ie = if (!(ic))
1254
-
                                        then id
1255
-
                                        else false
1256
-
                                    let if = (hE == aG)
1257
-
                                    let ig = if (if (ic)
1258
-
                                        then true
1259
-
                                        else ie)
1397
+
                                    let dc = cY(eN, eQ)
1398
+
                                    let iQ = if ((dc > 0))
1260
1399
 
                                        then {
1261
-
                                            let ih = aV(hk, hF)
1262
-
                                            let ii = cQ(if, ih)
1263
-
                                            let cX = ii._1
1264
-
                                            let cU = ii._2
1265
-
                                            let cV = ii._3
1266
-
                                            let eS = ii._4
1267
-
                                            if (if ((hG != 0))
1268
-
                                                then (hG > bc(cX))
1269
-
                                                else false)
1270
-
                                                then throw(((("Limit error: " + toString(bc(cX))) + " < ") + toString(hG)))
1271
-
                                                else {
1272
-
                                                    let ij = (fZ + cX)
1273
-
                                                    let ik = (bO() + (if ((ij > 0))
1274
-
                                                        then ih
1275
-
                                                        else 0))
1276
-
                                                    let il = (bN() + (if ((0 > ij))
1277
-
                                                        then ih
1278
-
                                                        else 0))
1279
-
                                                    let im = dh(fZ, hZ, ib, hk)
1280
-
                                                    let dq = im._1
1281
-
                                                    let ek = im._2
1282
-
                                                    let el = im._3
1283
-
                                                    if (!(dS(cU, cV)))
1284
-
                                                        then throw("Over max spread limit")
1285
-
                                                        else if (!(dW(ik, il)))
1286
-
                                                            then throw("Over max open notional")
1287
-
                                                            else $Tuple12(ij, dq, (ia + ih), co(ij), cV, cU, eS, (bM() + ih), (cd() + (if ((ij > 0))
1288
-
                                                                then bc(cX)
1289
-
                                                                else 0)), (cc() + (if ((0 > ij))
1290
-
                                                                then bc(cX)
1291
-
                                                                else 0)), ik, il)
1400
+
                                            let iR = gP(dc)
1401
+
                                            let gR = iR._1
1402
+
                                            let gS = iR._2
1403
+
                                            let iS = invoke(as(), "withdrawLocked", [gR], nil)
1404
+
                                            if ((iS == iS))
1405
+
                                                then {
1406
+
                                                    let iT = invoke(as(), "exchangeFreeAndLocked", [-(gS)], nil)
1407
+
                                                    if ((iT == iT))
1408
+
                                                        then hO(gR)
1409
+
                                                        else throw("Strict value is not equal to itself.")
1292
1410
 
                                                    }
1293
-
                                            }
1294
-
                                        else {
1295
-
                                            let ih = aV(hk, hF)
1296
-
                                            let in = eq(toString(ci.caller), aP)
1297
-
                                            let io = in._1
1298
-
                                            let ep = in._2
1299
-
                                            if ((io > ih))
1300
-
                                                then throw("Use decreasePosition to decrease position size")
1301
-
                                                else throw("Close position first")
1302
-
                                            }
1303
-
                                    let ij = ig._1
1304
-
                                    let ip = ig._2
1305
-
                                    let iq = ig._3
1306
-
                                    let ir = ig._4
1307
-
                                    let cV = ig._5
1308
-
                                    let cU = ig._6
1309
-
                                    let eS = ig._7
1310
-
                                    let eV = ig._8
1311
-
                                    let eT = ig._9
1312
-
                                    let eU = ig._10
1313
-
                                    let ik = ig._11
1314
-
                                    let il = ig._12
1315
-
                                    let is = gn(hX)
1316
-
                                    let gp = is._1
1317
-
                                    let gq = is._2
1318
-
                                    let it = if (hL)
1319
-
                                        then {
1320
-
                                            let it = invoke(at(), "addLocked", [false], [AttachedPayment(aq(), hk)])
1321
-
                                            if ((it == it))
1322
-
                                                then nil
1323
1411
 
                                                else throw("Strict value is not equal to itself.")
1324
1412
 
                                            }
1325
1413
 
                                        else nil
1326
-
                                    if ((it == it))
1327
-
                                        then {
1328
-
                                            let iu = invoke(at(), "addFree", nil, [AttachedPayment(aq(), gq)])
1329
-
                                            if ((iu == iu))
1414
+
                                    if ((iQ == iQ))
1415
+
                                        then ((hp(ca, eM, ((eN - dc) + hL), eO, eP, bP()) ++ hN(((bl() + hL) - dc))) ++ iQ)
1416
+
                                        else throw("Strict value is not equal to itself.")
1417
+
                                    }
1418
+
                                else throw("Strict value is not equal to itself.")
1419
+
                            }
1420
+
                    }
1421
+
                else throw("Strict value is not equal to itself.")
1422
+
            }
1423
+
        else throw("Strict value is not equal to itself.")
1424
+
    }
1425
+
1426
+
1427
+
1428
+
@Callable(bR)
1429
+
func removeMargin (hL) = {
1430
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1431
+
    if ((ii == ii))
1432
+
        then {
1433
+
            let ij = invoke(this, "ensureCalledOnce", nil, nil)
1434
+
            if ((ij == ij))
1435
+
                then {
1436
+
                    let ca = toString(bR.caller)
1437
+
                    if (if (if (if (if ((0 >= hL))
1438
+
                        then true
1439
+
                        else !(ck(ca)))
1440
+
                        then true
1441
+
                        else !(ct()))
1442
+
                        then true
1443
+
                        else cu())
1444
+
                        then true
1445
+
                        else dK())
1446
+
                        then throw("Invalid removeMargin parameters")
1447
+
                        else {
1448
+
                            let iU = bZ(ca)
1449
+
                            let eM = iU._1
1450
+
                            let eN = iU._2
1451
+
                            let eO = iU._3
1452
+
                            let eP = iU._4
1453
+
                            let eQ = iU._5
1454
+
                            let iV = dd(eM, eN, eP, eQ, -(hL))
1455
+
                            let dl = iV._1
1456
+
                            let dm = iV._2
1457
+
                            let dh = iV._3
1458
+
                            let dc = iV._4
1459
+
                            if ((dm != 0))
1460
+
                                then throw("Invalid removed margin amount")
1461
+
                                else {
1462
+
                                    let fp = ep(dl, dm, eO)
1463
+
                                    if (!(bS(fp, bo(), true)))
1464
+
                                        then throw(((("Too much margin removed: " + toString(fp)) + " < ") + toString(bo())))
1465
+
                                        else {
1466
+
                                            let iW = gP(dc)
1467
+
                                            let gR = iW._1
1468
+
                                            let gS = iW._2
1469
+
                                            let iQ = if ((dc > 0))
1330
1470
 
                                                then {
1331
-
                                                    let iv = invoke(au(), "notifyFees", [cr, hX], nil)
1332
-
                                                    if ((iv == iv))
1333
-
                                                        then {
1334
-
                                                            let iw = invoke(au(), "notifyNotional", [cr, iq], nil)
1335
-
                                                            if ((iw == iw))
1336
-
                                                                then (((((((gO(cr, ij, ip, iq, ir) ++ gK(ic, cr)) ++ gN(ic, cr, fW)) ++ gJ(cr, hK)) ++ hb(cU, cV, eS, eV, eT, eU, ik, il)) ++ hn(gp)) ++ hm((bE() + hk))) ++ ho(fX, ci))
1337
-
                                                                else throw("Strict value is not equal to itself.")
1338
-
                                                            }
1471
+
                                                    let iT = invoke(as(), "exchangeFreeAndLocked", [-(gS)], nil)
1472
+
                                                    if ((iT == iT))
1473
+
                                                        then hO(gR)
1339
1474
 
                                                        else throw("Strict value is not equal to itself.")
1340
1475
 
                                                    }
1476
+
                                                else nil
1477
+
                                            if ((iQ == iQ))
1478
+
                                                then {
1479
+
                                                    let iS = invoke(as(), "withdrawLocked", [(hL + gR)], nil)
1480
+
                                                    if ((iS == iS))
1481
+
                                                        then (((hp(ca, eM, dl, eO, bX(eM), bP()) ++ hK(bR.caller, hL)) ++ hN(((bl() - hL) - dc))) ++ iQ)
1482
+
                                                        else throw("Strict value is not equal to itself.")
1483
+
                                                    }
1484
+
                                                else throw("Strict value is not equal to itself.")
1485
+
                                            }
1486
+
                                    }
1487
+
                            }
1488
+
                    }
1489
+
                else throw("Strict value is not equal to itself.")
1490
+
            }
1491
+
        else throw("Strict value is not equal to itself.")
1492
+
    }
1493
+
1494
+
1495
+
1496
+
@Callable(bR)
1497
+
func closePosition (eH,eJ,eK) = {
1498
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1499
+
    if ((ii == ii))
1500
+
        then {
1501
+
            let ij = invoke(this, "ensureCalledOnce", nil, nil)
1502
+
            if ((ij == ij))
1503
+
                then {
1504
+
                    let ca = bQ(bR)
1505
+
                    let iX = valueOrErrorMessage(addressFromString(ca), "Invalid caller")
1506
+
                    let cj = ch(ca)
1507
+
                    if (if (if (if (if (if (!(ck(ca)))
1508
+
                        then true
1509
+
                        else !(ct()))
1510
+
                        then true
1511
+
                        else cu())
1512
+
                        then true
1513
+
                        else (0 >= eH))
1514
+
                        then true
1515
+
                        else (0 > eJ))
1516
+
                        then true
1517
+
                        else dK())
1518
+
                        then throw("Invalid closePosition parameters")
1519
+
                        else {
1520
+
                            let eQ = bZ(ca)._5
1521
+
                            let iY = eG(ca, eH, cj, eJ, eK, true)
1522
+
                            let fk = iY._1
1523
+
                            let ft = iY._2
1524
+
                            let fm = iY._3
1525
+
                            let fn = iY._4
1526
+
                            let fg = iY._5
1527
+
                            let fb = iY._6
1528
+
                            let fs = iY._7
1529
+
                            let cL = iY._8
1530
+
                            let cM = iY._9
1531
+
                            let eW = iY._10
1532
+
                            let iH = iY._11
1533
+
                            let iI = iY._12
1534
+
                            let iJ = iY._13
1535
+
                            let iA = iY._14
1536
+
                            let iB = iY._15
1537
+
                            let iZ = iY._16
1538
+
                            if ((fg > 0))
1539
+
                                then throw("Invalid closePosition parameters: bad debt")
1540
+
                                else if ((eQ >= bP()))
1541
+
                                    then throw("Invalid closePosition parameters: wait at least 1 block before closing the position")
1542
+
                                    else {
1543
+
                                        let eT = (fk != 0)
1544
+
                                        let ja = (fs + iZ)
1545
+
                                        let jb = (bl() - ja)
1546
+
                                        let jc = if ((0 > jb))
1547
+
                                            then 0
1548
+
                                            else jb
1549
+
                                        let iS = invoke(as(), "withdrawLocked", [ja], nil)
1550
+
                                        if ((iS == iS))
1551
+
                                            then {
1552
+
                                                let jd = gP(iZ)
1553
+
                                                let gR = jd._1
1554
+
                                                let gS = jd._2
1555
+
                                                let iM = invoke(as(), "addFree", nil, [AttachedPayment(ap(), gS)])
1556
+
                                                if ((iM == iM))
1557
+
                                                    then {
1558
+
                                                        let iN = invoke(at(), "notifyFees", [ca, iZ], nil)
1559
+
                                                        if ((iN == iN))
1560
+
                                                            then {
1561
+
                                                                let iO = invoke(at(), "notifyNotional", [ca, fm], nil)
1562
+
                                                                if ((iO == iO))
1563
+
                                                                    then (((((if (eT)
1564
+
                                                                        then hp(ca, fk, ft, fm, fn, bP())
1565
+
                                                                        else hJ(ca)) ++ hC(cL, cM, eW, iH, iI, iJ, iA, iB)) ++ (if ((fs > 0))
1566
+
                                                                        then hK(iX, fs)
1567
+
                                                                        else nil)) ++ hN(jc)) ++ hO(gR))
1568
+
                                                                    else throw("Strict value is not equal to itself.")
1569
+
                                                                }
1570
+
                                                            else throw("Strict value is not equal to itself.")
1571
+
                                                        }
1572
+
                                                    else throw("Strict value is not equal to itself.")
1573
+
                                                }
1574
+
                                            else throw("Strict value is not equal to itself.")
1575
+
                                        }
1576
+
                            }
1577
+
                    }
1578
+
                else throw("Strict value is not equal to itself.")
1579
+
            }
1580
+
        else throw("Strict value is not equal to itself.")
1581
+
    }
1582
+
1583
+
1584
+
1585
+
@Callable(bR)
1586
+
func liquidate (ca) = {
1587
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1588
+
    if ((ii == ii))
1589
+
        then {
1590
+
            let je = et(ca, aI)
1591
+
            let jf = if (dZ())
1592
+
                then {
1593
+
                    let jg = et(ca, aJ)
1594
+
                    aW(je, jg)
1595
+
                    }
1596
+
                else je
1597
+
            if (if (if (if (if (!(bS(jf, bB(), false)))
1598
+
                then true
1599
+
                else !(ck(ca)))
1600
+
                then true
1601
+
                else !(ct()))
1602
+
                then true
1603
+
                else cu())
1604
+
                then true
1605
+
                else dK())
1606
+
                then throw("Unable to liquidate")
1607
+
                else {
1608
+
                    let jh = if (if ((je > bC()))
1609
+
                        then true
1610
+
                        else (bD() > 0))
1611
+
                        then true
1612
+
                        else (aF > bD())
1613
+
                    let eM = bZ(ca)._1
1614
+
                    let ed = aV(eM)
1615
+
                    let ji = if (jh)
1616
+
                        then {
1617
+
                            let jj = eB(ca, eM)
1618
+
                            let jk = aM(aV(jj), ed)
1619
+
                            $Tuple2(jk, aV(jj))
1620
+
                            }
1621
+
                        else $Tuple2(0, ed)
1622
+
                    let jk = ji._1
1623
+
                    let jj = ji._2
1624
+
                    let jl = eG(ca, if (jh)
1625
+
                        then jj
1626
+
                        else ed, bC(), 0, true, false)
1627
+
                    let fk = jl._1
1628
+
                    let ft = jl._2
1629
+
                    let fm = jl._3
1630
+
                    let fn = jl._4
1631
+
                    let fg = jl._5
1632
+
                    let fb = jl._6
1633
+
                    let fs = jl._7
1634
+
                    let cL = jl._8
1635
+
                    let cM = jl._9
1636
+
                    let eW = jl._10
1637
+
                    let iH = jl._11
1638
+
                    let iI = jl._12
1639
+
                    let iJ = jl._13
1640
+
                    let iA = jl._14
1641
+
                    let iB = jl._15
1642
+
                    let jm = jl._16
1643
+
                    let jn = (jm / 2)
1644
+
                    let gS = (jm - jn)
1645
+
                    let jb = (bl() - jm)
1646
+
                    let jo = if ((0 > jb))
1647
+
                        then 0
1648
+
                        else jb
1649
+
                    let iT = if ((fg > 0))
1650
+
                        then {
1651
+
                            let iT = invoke(as(), "exchangeFreeAndLocked", [fg], nil)
1652
+
                            if ((iT == iT))
1653
+
                                then nil
1654
+
                                else throw("Strict value is not equal to itself.")
1655
+
                            }
1656
+
                        else nil
1657
+
                    if ((iT == iT))
1658
+
                        then {
1659
+
                            let iS = invoke(as(), "withdrawLocked", [jm], nil)
1660
+
                            if ((iS == iS))
1661
+
                                then {
1662
+
                                    let jp = invoke(as(), "addFree", nil, [AttachedPayment(ap(), gS)])
1663
+
                                    if ((jp == jp))
1664
+
                                        then {
1665
+
                                            let iO = invoke(at(), "notifyNotional", [ca, fm], nil)
1666
+
                                            if ((iO == iO))
1667
+
                                                then ((((if (jh)
1668
+
                                                    then hp(ca, fk, ft, fm, fn, bP())
1669
+
                                                    else hJ(ca)) ++ hC(cL, cM, eW, iH, iI, iJ, iA, iB)) ++ hK(bR.caller, jn)) ++ hN(jo))
1341
1670
 
                                                else throw("Strict value is not equal to itself.")
1342
1671
 
                                            }
1343
1672
 
                                        else throw("Strict value is not equal to itself.")
1352
1681
 
1353
1682
 
1354
1683
 
1355
-
@Callable(ci)
1356
-
func addMargin () = {
1357
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1358
-
    if ((hI == hI))
1684
+
@Callable(bR)
1685
+
func payFunding () = {
1686
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1687
+
    if ((ii == ii))
1359
1688
 
        then {
1360
-
            let cr = toString(ci.caller)
1361
-
            let hk = ci.payments[0].amount
1362
-
            let aC = ci.payments[0].assetId
1363
-
            let hK = toBase58String(value(aC))
1364
-
            let hL = (aC == aq())
1365
-
            let hM = aB(hK)
1366
-
            if (if (if (if (if (if (if (if (!(hL))
1367
-
                then !(hM)
1368
-
                else false)
1689
+
            let jq = bx()
1690
+
            if (if (if ((jq > bP()))
1369
1691
 
                then true
1370
-
                else !(cB(toString(ci.caller))))
1692
+
                else !(ct()))
1371
1693
 
                then true
1372
-
                else !(ga(cr, hK)))
1373
-
                then true
1374
-
                else !(cC()))
1375
-
                then true
1376
-
                else cD())
1377
-
                then true
1378
-
                else cE())
1379
-
                then true
1380
-
                else dL())
1381
-
                then throw("Invalid addMargin parameters")
1694
+
                else cu())
1695
+
                then throw(((("Invalid funding block timestamp: " + toString(bP())) + " < ") + toString(jq)))
1382
1696
 
                else {
1383
-
                    let ix = cq(cr)
1384
-
                    let fZ = ix._1
1385
-
                    let hZ = ix._2
1386
-
                    let ia = ix._3
1387
-
                    let ib = ix._4
1388
-
                    let it = if (hL)
1389
-
                        then {
1390
-
                            let it = invoke(at(), "addLocked", [false], [AttachedPayment(aq(), hk)])
1391
-
                            if ((it == it))
1392
-
                                then nil
1393
-
                                else throw("Strict value is not equal to itself.")
1394
-
                            }
1395
-
                        else nil
1396
-
                    if ((it == it))
1397
-
                        then (gO(cr, fZ, (hZ + hk), ia, ib) ++ hm((bE() + hk)))
1398
-
                        else throw("Strict value is not equal to itself.")
1697
+
                    let gq = dE()
1698
+
                    let jr = gp()
1699
+
                    let gt = jr._1
1700
+
                    let gu = jr._2
1701
+
                    hf((jq + bA()), (bI() + gu), (bJ() + gt), aM(gu, gq), aM(gt, gq))
1399
1702
 
                    }
1400
1703
 
            }
1401
1704
 
        else throw("Strict value is not equal to itself.")
1403
1706
 
1404
1707
 
1405
1708
 
1406
-
@Callable(ci)
1407
-
func removeMargin (hk) = {
1408
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1409
-
    if ((hI == hI))
1709
+
@Callable(bR)
1710
+
func syncTerminalPriceToOracle () = {
1711
+
    let cD = bp()
1712
+
    let cE = bq()
1713
+
    let js = gk(dE(), cD, cE)
1714
+
    let hW = js._1
1715
+
    let hX = js._2
1716
+
    let go = js._3
1717
+
    let hY = if ((go != 0))
1410
1718
 
        then {
1411
-
            let cr = toString(ci.caller)
1412
-
            if (if (if (if (if ((0 >= hk))
1413
-
                then true
1414
-
                else !(cB(cr)))
1415
-
                then true
1416
-
                else !(cC()))
1417
-
                then true
1418
-
                else cD())
1419
-
                then true
1420
-
                else dL())
1421
-
                then throw("Invalid removeMargin parameters")
1422
-
                else {
1423
-
                    let iy = cq(cr)
1424
-
                    let fZ = iy._1
1425
-
                    let hZ = iy._2
1426
-
                    let ia = iy._3
1427
-
                    let ib = iy._4
1428
-
                    let iz = -(hk)
1429
-
                    let iA = dh(fZ, hZ, ib, iz)
1430
-
                    let dq = iA._1
1431
-
                    let dr = iA._2
1432
-
                    if ((dr != 0))
1433
-
                        then throw("Invalid removed margin amount")
1434
-
                        else {
1435
-
                            let iB = ev(dq, dr, ia)
1436
-
                            if (!(cj(iB, bG(), true)))
1437
-
                                then throw(((("Too much margin removed: " + toString(iB)) + " < ") + toString(bG())))
1438
-
                                else {
1439
-
                                    let iC = toBase58String(aq())
1440
-
                                    let iD = gd(cr)
1441
-
                                    let iE = iD._1
1442
-
                                    let iF = iD._2
1443
-
                                    let iG = if ((hk > iE))
1444
-
                                        then iE
1445
-
                                        else hk
1446
-
                                    let iH = if ((iE > hk))
1447
-
                                        then 0
1448
-
                                        else (hk - iE)
1449
-
                                    let iI = (iE - iG)
1450
-
                                    let iJ = if ((iI > 0))
1451
-
                                        then nil
1452
-
                                        else gJ(cr, iC)
1453
-
                                    let iK = if (((iG + iH) != hk))
1454
-
                                        then throw(((((("toRepay=" + toString(iG)) + " + toWithdraw=") + toString(iH)) + " != ") + toString(hk)))
1455
-
                                        else nil
1456
-
                                    if ((iK == iK))
1457
-
                                        then {
1458
-
                                            let iL = if ((iH > 0))
1459
-
                                                then {
1460
-
                                                    let iL = invoke(at(), "withdrawLocked", [iH], nil)
1461
-
                                                    if ((iL == iL))
1462
-
                                                        then nil
1463
-
                                                        else throw("Strict value is not equal to itself.")
1464
-
                                                    }
1465
-
                                                else nil
1466
-
                                            if ((iL == iL))
1467
-
                                                then {
1468
-
                                                    let iM = if ((iG > 0))
1469
-
                                                        then {
1470
-
                                                            let iN = invoke(ay(), "repay", [cr, iG, iF], nil)
1471
-
                                                            if ((iN == iN))
1472
-
                                                                then [ScriptTransfer(ci.caller, iG, fromBase58String(iF))]
1473
-
                                                                else throw("Strict value is not equal to itself.")
1474
-
                                                            }
1475
-
                                                        else nil
1476
-
                                                    if ((iM == iM))
1477
-
                                                        then ((((gO(cr, fZ, dq, ia, co(fZ)) ++ (if ((iH > 0))
1478
-
                                                            then hj(ci.caller, iH)
1479
-
                                                            else nil)) ++ hm((bE() - hk))) ++ iJ) ++ iM)
1480
-
                                                        else throw("Strict value is not equal to itself.")
1481
-
                                                    }
1482
-
                                                else throw("Strict value is not equal to itself.")
1483
-
                                            }
1484
-
                                        else throw("Strict value is not equal to itself.")
1485
-
                                    }
1486
-
                            }
1487
-
                    }
1719
+
            let hY = invoke(as(), "exchangeFreeAndLocked", [go], nil)
1720
+
            if ((hY == hY))
1721
+
                then nil
1722
+
                else throw("Strict value is not equal to itself.")
1723
+
            }
1724
+
        else nil
1725
+
    if ((hY == hY))
1726
+
        then ((hN((bl() + go)) ++ hB(hW, hX)) ++ ht(aM(aO(cD, hW), aO(cE, hX))))
1727
+
        else throw("Strict value is not equal to itself.")
1728
+
    }
1729
+
1730
+
1731
+
1732
+
@Callable(bR)
1733
+
func ensureCalledOnce () = if ((bR.caller != this))
1734
+
    then throw("Invalid saveCurrentTxId parameters")
1735
+
    else {
1736
+
        let jt = valueOrElse(getString(this, W), "")
1737
+
        if ((jt != toBase58String(bR.transactionId)))
1738
+
            then [StringEntry(W, jt)]
1739
+
            else throw("Can not call vAMM methods twice in one tx")
1740
+
        }
1741
+
1742
+
1743
+
1744
+
@Callable(bR)
1745
+
func view_calcRemainMarginWithFundingPayment (ca) = {
1746
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1747
+
    if ((ii == ii))
1748
+
        then {
1749
+
            let ju = bZ(ca)
1750
+
            let cd = ju._1
1751
+
            let em = ju._2
1752
+
            let ev = ju._3
1753
+
            let eo = ju._4
1754
+
            let ex = ju._5
1755
+
            let jv = ek(ca, aI)
1756
+
            let ef = jv._1
1757
+
            let ej = jv._2
1758
+
            let jw = dd(cd, em, eo, ex, ej)
1759
+
            let dl = jw._1
1760
+
            let dm = jw._2
1761
+
            let dh = jw._3
1762
+
            let dc = jw._4
1763
+
            throw(((((((aK(dl) + aK(dh)) + aK(eA(ca))) + aK(ej)) + aK(dm)) + aK(ef)) + aK(dc)))
1488
1764
 
            }
1489
1765
 
        else throw("Strict value is not equal to itself.")
1490
1766
 
    }
1491
1767
 
1492
1768
 
1493
1769
 
1494
-
@Callable(ci)
1495
-
func closePosition (gP,iO,iP) = {
1496
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1497
-
    if ((hI == hI))
1770
+
@Callable(bR)
1771
+
func view_getPegAdjustCost (hu) = {
1772
+
    let cD = bp()
1773
+
    let cE = bq()
1774
+
    let gj = gk(hu, cD, cE)
1775
+
    throw(toString(gj._3))
1776
+
    }
1777
+
1778
+
1779
+
1780
+
@Callable(bR)
1781
+
func view_getTerminalAmmPrice () = {
1782
+
    let jx = fS()
1783
+
    let fW = jx._1
1784
+
    let fX = jx._2
1785
+
    let hR = aM(aO(fW, br()), aO(fX, bs()))
1786
+
    throw(toString(hR))
1787
+
    }
1788
+
1789
+
1790
+
1791
+
@Callable(bR)
1792
+
func view_getFunding () = {
1793
+
    let gq = dE()
1794
+
    let jy = gp()
1795
+
    let gt = jy._1
1796
+
    let gu = jy._2
1797
+
    let jz = aM(gu, gq)
1798
+
    let jA = aM(gt, gq)
1799
+
    throw((((aK(jz) + aK(jA)) + aK(fu())) + aK(dE())))
1800
+
    }
1801
+
1802
+
1803
+
1804
+
@Callable(bR)
1805
+
func computeSpotPrice () = {
1806
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1807
+
    if ((ii == ii))
1498
1808
 
        then {
1499
-
            let cr = ch(ci)
1500
-
            let iQ = valueOrErrorMessage(addressFromString(cr), "Invalid caller")
1501
-
            let cA = cy(cr)
1502
-
            if (if (if (if (if (if (!(cB(cr)))
1503
-
                then true
1504
-
                else !(cC()))
1505
-
                then true
1506
-
                else cD())
1507
-
                then true
1508
-
                else (0 >= gP))
1509
-
                then true
1510
-
                else (0 > iO))
1511
-
                then true
1512
-
                else dL())
1513
-
                then throw("Invalid closePosition parameters")
1514
-
                else {
1515
-
                    let iR = cq(cr)
1516
-
                    let fZ = iR._1
1517
-
                    let hZ = iR._2
1518
-
                    let ia = iR._3
1519
-
                    let ib = iR._4
1520
-
                    let iS = if ((bc(fZ) > gP))
1521
-
                        then {
1522
-
                            let hE = if ((fZ > 0))
1523
-
                                then aH
1524
-
                                else aG
1525
-
                            let if = (hE == aG)
1526
-
                            let iT = dD((fZ > 0), gP, true)
1527
-
                            let eL = iT._1
1528
-
                            let cU = iT._2
1529
-
                            let cV = iT._3
1530
-
                            let eS = iT._4
1531
-
                            let eK = if ((fZ > 0))
1532
-
                                then -(gP)
1533
-
                                else gP
1534
-
                            let iU = eq(cr, aP)
1535
-
                            let io = iU._1
1536
-
                            let ep = iU._2
1537
-
                            let iV = ez(cr, aP)
1538
-
                            let iW = aT(bc(eK), bc(fZ))
1539
-
                            let eP = aV(ep, iW)
1540
-
                            let iX = aV(aV(io, iW), cA)
1541
-
                            let iY = dh(fZ, hZ, ib, ep)._1
1542
-
                            let iZ = dh(fZ, hZ, ib, eP)._2
1543
-
                            let ja = (ep - eP)
1544
-
                            let jb = if ((fZ > 0))
1545
-
                                then ((io - eL) - ja)
1546
-
                                else ((ja + io) - eL)
1547
-
                            let iq = bc(jb)
1548
-
                            let ij = (fZ + eK)
1549
-
                            let jc = co(ij)
1550
-
                            let jd = (ia - iq)
1551
-
                            let eV = (bM() - jd)
1552
-
                            let je = if ((fZ > 0))
1553
-
                                then (aV((iq + ja), iV) - ja)
1554
-
                                else (aV((iq - ja), iV) - ja)
1555
-
                            let jf = ((iY - (je + ja)) - iX)
1556
-
                            let jg = if ((0 > jf))
1557
-
                                then throw("Margin error: unable to pay close fee")
1558
-
                                else jf
1559
-
                            if (if ((iO != 0))
1560
-
                                then (iO > eL)
1561
-
                                else false)
1562
-
                                then throw(((("Limit error: " + toString(eL)) + " < ") + toString(iO)))
1563
-
                                else $Tuple16(ij, if (iP)
1564
-
                                    then (je + jg)
1565
-
                                    else je, iq, jc, iZ, eP, if (iP)
1566
-
                                    then 0
1567
-
                                    else jg, cU, cV, eS, eV, (cd() - (if ((ij > 0))
1568
-
                                    then bc(eK)
1569
-
                                    else 0)), (cc() - (if ((0 > ij))
1570
-
                                    then bc(eK)
1571
-
                                    else 0)), (bO() - (if ((ij > 0))
1572
-
                                    then jd
1573
-
                                    else 0)), (bN() - (if ((0 > ij))
1574
-
                                    then jd
1575
-
                                    else 0)), iX)
1576
-
                            }
1577
-
                        else if ((gP > bc(fZ)))
1578
-
                            then throw("Invalid closePosition parameters")
1579
-
                            else {
1580
-
                                let jh = eM(cr, true)
1581
-
                                let el = jh._1
1582
-
                                let iZ = jh._2
1583
-
                                let eP = jh._3
1584
-
                                let ji = jh._4
1585
-
                                let cU = jh._5
1586
-
                                let cV = jh._6
1587
-
                                let eS = jh._7
1588
-
                                let eV = jh._8
1589
-
                                let eL = jh._9
1590
-
                                let eT = jh._10
1591
-
                                let eU = jh._11
1592
-
                                let ik = jh._12
1593
-
                                let il = jh._13
1594
-
                                let iX = aV(eL, cA)
1595
-
                                let jf = (bc(ji) - iX)
1596
-
                                let jg = if ((0 > jf))
1597
-
                                    then throw(((((((("Margin error: unable to pay close fee: " + toString(iX)) + " margin: ") + toString(ji)) + " fee percent: ") + toString(cA)) + " notional: ") + toString(eL)))
1598
-
                                    else jf
1599
-
                                if (if ((iO != 0))
1600
-
                                    then (iO > eL)
1601
-
                                    else false)
1602
-
                                    then throw(((("Limit error: " + toString(eL)) + " < ") + toString(iO)))
1603
-
                                    else $Tuple16(0, 0, 0, 0, iZ, eP, jg, cU, cV, eS, eV, eT, eU, ik, il, iX)
1604
-
                                }
1605
-
                    let ij = iS._1
1606
-
                    let je = iS._2
1607
-
                    let iq = iS._3
1608
-
                    let jc = iS._4
1609
-
                    let iZ = iS._5
1610
-
                    let eP = iS._6
1611
-
                    let jg = iS._7
1612
-
                    let cU = iS._8
1613
-
                    let cV = iS._9
1614
-
                    let eS = iS._10
1615
-
                    let eV = iS._11
1616
-
                    let eT = iS._12
1617
-
                    let eU = iS._13
1618
-
                    let ik = iS._14
1619
-
                    let il = iS._15
1620
-
                    let iX = iS._16
1621
-
                    if ((iZ > 0))
1622
-
                        then throw("Unable to close position with bad debt")
1623
-
                        else {
1624
-
                            let jj = (ij != 0)
1625
-
                            let jk = (jg + iX)
1626
-
                            let jl = (bE() - jk)
1627
-
                            let jm = if ((0 > jl))
1628
-
                                then $Tuple2(0, bc(jl))
1629
-
                                else $Tuple2(jl, 0)
1630
-
                            let jn = jm._1
1631
-
                            let jo = jm._2
1632
-
                            let jp = gd(cr)
1633
-
                            let iE = jp._1
1634
-
                            let iF = jp._2
1635
-
                            let jq = if ((iE > 0))
1636
-
                                then if ((jk >= iE))
1637
-
                                    then {
1638
-
                                        let iN = invoke(ay(), "repay", [cr, iE, iF], nil)
1639
-
                                        if ((iN == iN))
1640
-
                                            then $Tuple3(iE, (jk - iE), jj)
1641
-
                                            else throw("Strict value is not equal to itself.")
1642
-
                                        }
1643
-
                                    else {
1644
-
                                        let jr = invoke(ay(), if (jj)
1645
-
                                            then "repay"
1646
-
                                            else "realizePartiallyAndClose", [cr, jk, iF], nil)
1647
-
                                        if ((jr == jr))
1648
-
                                            then $Tuple3(jk, 0, false)
1649
-
                                            else throw("Strict value is not equal to itself.")
1650
-
                                        }
1651
-
                                else $Tuple3(0, jk, false)
1652
-
                            if ((jq == jq))
1653
-
                                then {
1654
-
                                    let js = jq._3
1655
-
                                    let jt = jq._2
1656
-
                                    let ju = jq._1
1657
-
                                    let jv = if ((jt >= iX))
1658
-
                                        then $Tuple3(ju, (jt - iX), iX)
1659
-
                                        else {
1660
-
                                            let jw = (iX - jt)
1661
-
                                            let jx = (ju - jw)
1662
-
                                            let hR = assetBalance(this, aq())
1663
-
                                            if ((hR == hR))
1664
-
                                                then {
1665
-
                                                    let hS = invoke(az(), "swap", [toBase58String(aq()), 0], [AttachedPayment(fromBase58String(iF), jw)])
1666
-
                                                    if ((hS == hS))
1667
-
                                                        then {
1668
-
                                                            let hT = assetBalance(this, aq())
1669
-
                                                            if ((hT == hT))
1670
-
                                                                then {
1671
-
                                                                    let hU = (hT - hR)
1672
-
                                                                    if ((hU == hU))
1673
-
                                                                        then $Tuple3(jx, 0, (jt + hU))
1674
-
                                                                        else throw("Strict value is not equal to itself.")
1675
-
                                                                    }
1676
-
                                                                else throw("Strict value is not equal to itself.")
1677
-
                                                            }
1678
-
                                                        else throw("Strict value is not equal to itself.")
1679
-
                                                    }
1680
-
                                                else throw("Strict value is not equal to itself.")
1681
-
                                            }
1682
-
                                    if ((jv == jv))
1683
-
                                        then {
1684
-
                                            let jy = jv._3
1685
-
                                            let jz = jv._2
1686
-
                                            let jx = jv._1
1687
-
                                            let jA = if ((jt > 0))
1688
-
                                                then {
1689
-
                                                    let jA = invoke(at(), "withdrawLocked", [jt], nil)
1690
-
                                                    if ((jA == jA))
1691
-
                                                        then nil
1692
-
                                                        else throw("Strict value is not equal to itself.")
1693
-
                                                    }
1694
-
                                                else nil
1695
-
                                            if ((jA == jA))
1696
-
                                                then {
1697
-
                                                    let jB = gn(jy)
1698
-
                                                    let gp = jB._1
1699
-
                                                    let gq = jB._2
1700
-
                                                    let iu = invoke(at(), "addFree", nil, [AttachedPayment(aq(), gq)])
1701
-
                                                    if ((iu == iu))
1702
-
                                                        then {
1703
-
                                                            let iv = invoke(au(), "notifyFees", [cr, iX], nil)
1704
-
                                                            if ((iv == iv))
1705
-
                                                                then {
1706
-
                                                                    let iw = invoke(au(), "notifyNotional", [cr, iq], nil)
1707
-
                                                                    if ((iw == iw))
1708
-
                                                                        then (((((((if (jj)
1709
-
                                                                            then gO(cr, ij, je, iq, jc)
1710
-
                                                                            else hi(cr)) ++ (if (js)
1711
-
                                                                            then {
1712
-
                                                                                let iC = toBase58String(aq())
1713
-
                                                                                gJ(cr, iC)
1714
-
                                                                                }
1715
-
                                                                            else nil)) ++ hb(cU, cV, eS, eV, eT, eU, ik, il)) ++ hn(gp)) ++ (if ((jz > 0))
1716
-
                                                                            then hj(iQ, jz)
1717
-
                                                                            else nil)) ++ hm(jn)) ++ (if ((jx > 0))
1718
-
                                                                            then [ScriptTransfer(iQ, jx, fromBase58String(iF))]
1719
-
                                                                            else nil))
1720
-
                                                                        else throw("Strict value is not equal to itself.")
1721
-
                                                                    }
1722
-
                                                                else throw("Strict value is not equal to itself.")
1723
-
                                                            }
1724
-
                                                        else throw("Strict value is not equal to itself.")
1725
-
                                                    }
1726
-
                                                else throw("Strict value is not equal to itself.")
1727
-
                                            }
1728
-
                                        else throw("Strict value is not equal to itself.")
1729
-
                                    }
1730
-
                                else throw("Strict value is not equal to itself.")
1731
-
                            }
1732
-
                    }
1809
+
            let gj = dY()
1810
+
            $Tuple2(nil, gj)
1733
1811
 
            }
1734
1812
 
        else throw("Strict value is not equal to itself.")
1735
1813
 
    }
1736
1814
 
1737
1815
 
1738
1816
 
1739
-
@Callable(ci)
1740
-
func liquidate (cr) = {
1741
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1742
-
    if ((hI == hI))
1743
-
        then {
1744
-
            let jC = ez(cr, aP)
1745
-
            let iB = if (eb())
1746
-
                then {
1747
-
                    let jD = ez(cr, aQ)
1748
-
                    bd(jC, jD)
1749
-
                    }
1750
-
                else jC
1751
-
            if (if (if (if (if (!(cj(iB, bT(), false)))
1752
-
                then true
1753
-
                else !(cB(cr)))
1754
-
                then true
1755
-
                else !(cC()))
1756
-
                then true
1757
-
                else cD())
1758
-
                then true
1759
-
                else dL())
1760
-
                then throw("Unable to liquidate")
1761
-
                else if (if (if ((jC > bU()))
1762
-
                    then (bV() > 0)
1763
-
                    else false)
1764
-
                    then (aM > bV())
1765
-
                    else false)
1766
-
                    then {
1767
-
                        let jE = cq(cr)
1768
-
                        let fZ = jE._1
1769
-
                        let hZ = jE._2
1770
-
                        let ia = jE._3
1771
-
                        let ib = jE._4
1772
-
                        let hE = if ((fZ > 0))
1773
-
                            then aH
1774
-
                            else aG
1775
-
                        let if = (hE == aG)
1776
-
                        let eL = eF(cr, fZ)
1777
-
                        let jF = eq(cr, aP)
1778
-
                        let io = jF._1
1779
-
                        let ep = jF._2
1780
-
                        let jG = cQ(if, eL)
1781
-
                        let eK = jG._1
1782
-
                        let cU = jG._2
1783
-
                        let cV = jG._3
1784
-
                        let eS = jG._4
1785
-
                        let jH = aT(bc(eK), bc(fZ))
1786
-
                        let eP = aV(ep, jH)
1787
-
                        let jI = dh(fZ, hZ, ib, eP)
1788
-
                        let dq = jI._1
1789
-
                        let dr = jI._2
1790
-
                        let dm = jI._3
1791
-
                        let ja = (ep - eP)
1792
-
                        let jb = if ((fZ > 0))
1793
-
                            then ((io - eL) - ja)
1794
-
                            else ((ja + io) - eL)
1795
-
                        let jJ = aV(eL, bU())
1796
-
                        let jK = (jJ / 2)
1797
-
                        let gq = (jJ - jK)
1798
-
                        let je = (dq - jJ)
1799
-
                        let ij = (fZ + eK)
1800
-
                        let iq = bc(jb)
1801
-
                        let jd = (ia - iq)
1802
-
                        let jc = co(ij)
1803
-
                        let eV = (bM() - jd)
1804
-
                        let jl = (bE() - jJ)
1805
-
                        let jL = if ((0 > jl))
1806
-
                            then $Tuple2(0, bc(jl))
1807
-
                            else $Tuple2(jl, 0)
1808
-
                        let jM = jL._1
1809
-
                        let jo = jL._2
1810
-
                        let jN = gd(cr)
1811
-
                        let iE = jN._1
1812
-
                        let iF = jN._2
1813
-
                        let jO = if ((iE > 0))
1814
-
                            then {
1815
-
                                let jP = aV(iE, jH)
1816
-
                                let jr = invoke(ay(), "realizePartially", [cr, iF, jP], nil)
1817
-
                                if ((jr == jr))
1818
-
                                    then nil
1819
-
                                    else throw("Strict value is not equal to itself.")
1820
-
                                }
1821
-
                            else nil
1822
-
                        if ((jO == jO))
1823
-
                            then {
1824
-
                                let jA = invoke(at(), "withdrawLocked", [jJ], nil)
1825
-
                                if ((jA == jA))
1826
-
                                    then {
1827
-
                                        let jQ = invoke(at(), "addFree", nil, [AttachedPayment(aq(), gq)])
1828
-
                                        if ((jQ == jQ))
1829
-
                                            then {
1830
-
                                                let iw = invoke(au(), "notifyNotional", [cr, iq], nil)
1831
-
                                                if ((iw == iw))
1832
-
                                                    then (((gO(cr, ij, je, iq, jc) ++ hb(cU, cV, eS, eV, (cd() - (if ((ij > 0))
1833
-
                                                        then bc(eK)
1834
-
                                                        else 0)), (cc() - (if ((0 > ij))
1835
-
                                                        then bc(eK)
1836
-
                                                        else 0)), (bO() - (if ((ij > 0))
1837
-
                                                        then jd
1838
-
                                                        else 0)), (bN() - (if ((0 > ij))
1839
-
                                                        then jd
1840
-
                                                        else 0)))) ++ hj(ci.caller, jK)) ++ hm(jM))
1841
-
                                                    else throw("Strict value is not equal to itself.")
1842
-
                                                }
1843
-
                                            else throw("Strict value is not equal to itself.")
1844
-
                                        }
1845
-
                                    else throw("Strict value is not equal to itself.")
1846
-
                                }
1847
-
                            else throw("Strict value is not equal to itself.")
1848
-
                        }
1849
-
                    else {
1850
-
                        let jR = eM(cr, false)
1851
-
                        let ek = jR._1
1852
-
                        let dr = jR._2
1853
-
                        let el = jR._3
1854
-
                        let em = jR._4
1855
-
                        let cU = jR._5
1856
-
                        let cV = jR._6
1857
-
                        let eS = jR._7
1858
-
                        let eV = jR._8
1859
-
                        let eL = jR._9
1860
-
                        let eT = jR._10
1861
-
                        let eU = jR._11
1862
-
                        let ik = jR._12
1863
-
                        let il = jR._13
1864
-
                        let jJ = aV(eL, bU())
1865
-
                        let jK = (jJ / 2)
1866
-
                        let gq = (jJ - jK)
1867
-
                        let jl = (bE() - jJ)
1868
-
                        let jS = if ((0 > jl))
1869
-
                            then $Tuple2(0, bc(jl))
1870
-
                            else $Tuple2(jl, 0)
1871
-
                        let jM = jS._1
1872
-
                        let jo = jS._2
1873
-
                        let jT = gd(cr)
1874
-
                        let iE = jT._1
1875
-
                        let iF = jT._2
1876
-
                        let jO = if ((iE > 0))
1877
-
                            then {
1878
-
                                let jr = invoke(ay(), "realizePartiallyAndClose", [cr, 0, iF], nil)
1879
-
                                if ((jr == jr))
1880
-
                                    then nil
1881
-
                                    else throw("Strict value is not equal to itself.")
1882
-
                                }
1883
-
                            else nil
1884
-
                        if ((jO == jO))
1885
-
                            then {
1886
-
                                let gj = if ((dr > 0))
1887
-
                                    then {
1888
-
                                        let jU = invoke(at(), "exchangeFreeAndLocked", [dr], nil)
1889
-
                                        if ((jU == jU))
1890
-
                                            then nil
1891
-
                                            else throw("Strict value is not equal to itself.")
1892
-
                                        }
1893
-
                                    else nil
1894
-
                                if ((gj == gj))
1895
-
                                    then {
1896
-
                                        let jA = invoke(at(), "withdrawLocked", [jJ], nil)
1897
-
                                        if ((jA == jA))
1898
-
                                            then {
1899
-
                                                let jQ = invoke(at(), "addFree", nil, [AttachedPayment(aq(), gq)])
1900
-
                                                if ((jQ == jQ))
1901
-
                                                    then {
1902
-
                                                        let iw = invoke(au(), "notifyNotional", [cr, 0], nil)
1903
-
                                                        if ((iw == iw))
1904
-
                                                            then (((hi(cr) ++ hb(cU, cV, eS, eV, eT, eU, ik, il)) ++ hj(ci.caller, jK)) ++ hm(jM))
1905
-
                                                            else throw("Strict value is not equal to itself.")
1906
-
                                                        }
1907
-
                                                    else throw("Strict value is not equal to itself.")
1908
-
                                                }
1909
-
                                            else throw("Strict value is not equal to itself.")
1910
-
                                        }
1911
-
                                    else throw("Strict value is not equal to itself.")
1912
-
                                }
1913
-
                            else throw("Strict value is not equal to itself.")
1914
-
                        }
1915
-
            }
1916
-
        else throw("Strict value is not equal to itself.")
1817
+
@Callable(bR)
1818
+
func computeFeeForTraderWithArtifact (ca,gw) = {
1819
+
    let gj = gI(ca, gw)
1820
+
    $Tuple2(nil, gj)
1917
1821
 
    }
1918
1822
 
1919
1823
 
1920
-
1921
-
@Callable(ci)
1922
-
func payFunding () = {
1923
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1924
-
    if ((hI == hI))
1925
-
        then {
1926
-
            let jV = bP()
1927
-
            if (if (if ((jV > lastBlock.timestamp))
1928
-
                then true
1929
-
                else !(cC()))
1930
-
                then true
1931
-
                else cD())
1932
-
                then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(jV)))
1933
-
                else {
1934
-
                    let fJ = dE()
1935
-
                    let jW = fI()
1936
-
                    let fM = jW._1
1937
-
                    let fN = jW._2
1938
-
                    gD((jV + bS()), (ca() + fN), (cb() + fM), aT(fN, fJ), aT(fM, fJ))
1939
-
                    }
1940
-
            }
1941
-
        else throw("Strict value is not equal to itself.")
1942
-
    }
1943
-
1944
-
1945
-
1946
-
@Callable(ci)
1947
-
func syncTerminalPriceToOracle () = {
1948
-
    let cM = bH()
1949
-
    let cN = bI()
1950
-
    let jX = fE(dE(), cM, cN)
1951
-
    let hv = jX._1
1952
-
    let hw = jX._2
1953
-
    let eQ = jX._3
1954
-
    let hx = if ((eQ != 0))
1955
-
        then {
1956
-
            let hx = invoke(at(), "exchangeFreeAndLocked", [eQ], nil)
1957
-
            if ((hx == hx))
1958
-
                then nil
1959
-
                else throw("Strict value is not equal to itself.")
1960
-
            }
1961
-
        else nil
1962
-
    if ((hx == hx))
1963
-
        then (ha(hv, hw) ++ gS(aT(aV(cM, hv), aV(cN, hw))))
1964
-
        else throw("Strict value is not equal to itself.")
1965
-
    }
1966
-
1967
-
1968
-
1969
-
@Callable(ci)
1970
-
func view_calcRemainMarginWithFundingPayment (cr) = {
1971
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1972
-
    if ((hI == hI))
1973
-
        then {
1974
-
            let jY = cq(cr)
1975
-
            let cu = jY._1
1976
-
            let es = jY._2
1977
-
            let eB = jY._3
1978
-
            let eu = jY._4
1979
-
            let jZ = eq(cr, aP)
1980
-
            let eh = jZ._1
1981
-
            let ep = jZ._2
1982
-
            let ka = dh(cu, es, eu, ep)
1983
-
            let dq = ka._1
1984
-
            let dr = ka._2
1985
-
            let dm = ka._3
1986
-
            throw((((((aR(dq) + aR(dm)) + aR(eE(cr))) + aR(ep)) + aR(dr)) + aR(eh)))
1987
-
            }
1988
-
        else throw("Strict value is not equal to itself.")
1989
-
    }
1990
-
1991
-
1992
-
1993
-
@Callable(ci)
1994
-
func view_getPegAdjustCost (gT) = {
1995
-
    let cM = bH()
1996
-
    let cN = bI()
1997
-
    let fD = fE(gT, cM, cN)
1998
-
    throw(toString(fD._3))
1999
-
    }
2000
-
2001
-
2002
-
2003
-
@Callable(ci)
2004
-
func view_getTerminalAmmPrice () = {
2005
-
    let kb = fm()
2006
-
    let fq = kb._1
2007
-
    let fr = kb._2
2008
-
    let hq = aT(aV(fq, bJ()), aV(fr, bK()))
2009
-
    throw(toString(hq))
2010
-
    }
2011
-
2012
-
2013
-
2014
-
@Callable(ci)
2015
-
func view_getFunding () = {
2016
-
    let fJ = dE()
2017
-
    let kc = fI()
2018
-
    let fM = kc._1
2019
-
    let fN = kc._2
2020
-
    let kd = aT(fN, fJ)
2021
-
    let ke = aT(fM, fJ)
2022
-
    throw((((aR(kd) + aR(ke)) + aR(eW())) + aR(dE())))
2023
-
    }
2024
-
2025
-
2026
-
2027
-
@Callable(ci)
2028
-
func view_getBorrowedByTrader (cr) = {
2029
-
    let kf = gd(cr)
2030
-
    let iE = kf._1
2031
-
    let iF = kf._2
2032
-
    throw((aR(iE) + iF))
2033
-
    }
2034
-
2035
-
2036
-
2037
-
@Callable(ci)
2038
-
func computeSpotPrice () = {
2039
-
    let fD = ea()
2040
-
    $Tuple2(nil, fD)
2041
-
    }
2042
-
2043
-
2044
-
2045
-
@Callable(ci)
2046
-
func computeFeeForTraderWithArtifact (cr,fP) = {
2047
-
    let fD = gg(cr, fP)
2048
-
    $Tuple2(nil, fD)
2049
-
    }
2050
-
2051
-
2052
-
@Verifier(kg)
2053
-
func kh () = sigVerify(kg.bodyBytes, kg.proofs[0], ap())
1824
+
@Verifier(jB)
1825
+
func jC () = sigVerify(jB.bodyBytes, jB.proofs[0], ao())
2054
1826
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
-
let a = "k_ora_key"
4
+
let a = "k_baseOracle"
5
5
 
6
-
let b = "k_ora_block_key"
6
+
let b = "k_quoteOracle"
7
7
 
8
-
let c = "k_ora_open_key"
8
+
let c = "k_balance"
9
9
 
10
-
let d = "k_ora"
10
+
let d = "k_sequence"
11
11
 
12
-
let e = "k_balance"
12
+
let e = "k_positionSize"
13
13
 
14
-
let f = "k_sequence"
14
+
let f = "k_positionMargin"
15
15
 
16
-
let g = "k_positionSize"
16
+
let g = "k_positionOpenNotional"
17
17
 
18
-
let h = "k_positionMargin"
18
+
let h = "k_positionFraction"
19
19
 
20
-
let i = "k_positionOpenNotional"
20
+
let i = "k_positionSequence"
21
21
 
22
-
let j = "k_positionFraction"
22
+
let j = "k_positionAsset"
23
23
 
24
-
let k = "k_positionSequence"
24
+
let k = "k_positionFee"
25
25
 
26
-
let l = "k_positionAsset"
26
+
let l = "k_positionTimestamp"
27
27
 
28
-
let m = "k_positionFee"
28
+
let m = "k_initialized"
29
29
 
30
-
let n = "k_initialized"
30
+
let n = "k_paused"
31
31
 
32
-
let o = "k_paused"
32
+
let o = "k_closeOnly"
33
33
 
34
-
let p = "k_closeOnly"
34
+
let p = "k_fee"
35
35
 
36
-
let q = "k_fee"
36
+
let q = "k_rollover_fee"
37
37
 
38
38
 
let r = "k_fundingPeriod"
39
39
 
40
40
 
let s = "k_initMarginRatio"
41
41
 
42
42
 
let t = "k_mmr"
43
43
 
44
44
 
let u = "k_liquidationFeeRatio"
45
45
 
46
46
 
let v = "k_partLiquidationRatio"
47
47
 
48
48
 
let w = "k_spreadLimit"
49
49
 
50
50
 
let x = "k_maxPriceImpact"
51
51
 
52
52
 
let y = "k_maxPriceSpread"
53
53
 
54
54
 
let z = "k_maxOpenNotional"
55
55
 
56
56
 
let A = "k_feeToStakersPercent"
57
57
 
58
58
 
let B = "k_maxOracleDelay"
59
59
 
60
60
 
let C = "k_lastDataStr"
61
61
 
62
62
 
let D = "k_lastMinuteId"
63
63
 
64
64
 
let E = "k_twapDataLastCumulativePrice"
65
65
 
66
66
 
let F = "k_twapDataLastPrice"
67
67
 
68
68
 
let G = "k_twapDataPreviousMinuteId"
69
69
 
70
70
 
let H = "k_latestLongPremiumFraction"
71
71
 
72
72
 
let I = "k_latestShortPremiumFraction"
73
73
 
74
74
 
let J = "k_nextFundingBlockMinTimestamp"
75
75
 
76
76
 
let K = "k_longFundingRate"
77
77
 
78
78
 
let L = "k_shortFundingRate"
79
79
 
80
80
 
let M = "k_qtAstR"
81
81
 
82
82
 
let N = "k_bsAstR"
83
83
 
84
84
 
let O = "k_qtAstW"
85
85
 
86
86
 
let P = "k_bsAstW"
87
87
 
88
88
 
let Q = "k_totalPositionSize"
89
89
 
90
90
 
let R = "k_totalLongPositionSize"
91
91
 
92
92
 
let S = "k_totalShortPositionSize"
93
93
 
94
94
 
let T = "k_openInterestNotional"
95
95
 
96
96
 
let U = "k_openInterestShort"
97
97
 
98
98
 
let V = "k_openInterestLong"
99
99
 
100
-
let W = "k_coordinatorAddress"
100
+
let W = "k_lastTx"
101
101
 
102
-
let X = "k_vault_address"
102
+
let X = "k_coordinatorAddress"
103
103
 
104
-
let Y = "k_admin_address"
104
+
let Y = "k_vault_address"
105
105
 
106
-
let Z = "k_admin_public_key"
106
+
let Z = "k_admin_address"
107
107
 
108
-
let aa = "k_quote_asset"
108
+
let aa = "k_admin_public_key"
109
109
 
110
-
let ab = "k_quote_staking"
110
+
let ab = "k_quote_asset"
111
111
 
112
-
let ac = "k_staking_address"
112
+
let ac = "k_quote_staking"
113
113
 
114
-
let ad = "k_miner_address"
114
+
let ad = "k_staking_address"
115
115
 
116
-
let ae = "k_orders_address"
116
+
let ae = "k_miner_address"
117
117
 
118
-
let af = "k_referral_address"
118
+
let af = "k_orders_address"
119
119
 
120
-
let ag = "k_collateral_address"
120
+
let ag = "k_referral_address"
121
121
 
122
122
 
let ah = "k_exchange_address"
123
123
 
124
124
 
let ai = "k_nft_manager_address"
125
125
 
126
-
let aj = "k_trader_market_asset_collateral"
127
-
128
-
func ak (al,am) = ((al + "_") + am)
126
+
func aj (ak,al) = ((ak + "_") + al)
129
127
 
130
128
 
131
-
func an () = valueOrErrorMessage(addressFromString(getStringValue(this, W)), "Coordinator not set")
129
+
func am () = valueOrErrorMessage(addressFromString(getStringValue(this, X)), "Coordinator not set")
132
130
 
133
131
 
134
-
func ao () = addressFromString(getStringValue(an(), Y))
132
+
func an () = addressFromString(getStringValue(am(), Z))
135
133
 
136
134
 
137
-
func ap () = fromBase58String(getStringValue(an(), Z))
135
+
func ao () = fromBase58String(getStringValue(am(), aa))
138
136
 
139
137
 
140
-
func aq () = fromBase58String(getStringValue(an(), aa))
138
+
func ap () = fromBase58String(getStringValue(am(), ab))
141
139
 
142
140
 
143
-
func ar () = valueOrErrorMessage(addressFromString(getStringValue(an(), ab)), "Quote asset staking not set")
141
+
func aq () = valueOrErrorMessage(addressFromString(getStringValue(am(), ac)), "Quote asset staking not set")
144
142
 
145
143
 
146
-
func as () = valueOrErrorMessage(addressFromString(getStringValue(an(), ac)), "Staking not set")
144
+
func ar () = valueOrErrorMessage(addressFromString(getStringValue(am(), ad)), "Staking not set")
147
145
 
148
146
 
149
-
func at () = valueOrErrorMessage(addressFromString(getStringValue(an(), X)), "Vault not set")
147
+
func as () = valueOrErrorMessage(addressFromString(getStringValue(am(), Y)), "Vault not set")
150
148
 
151
149
 
152
-
func au () = valueOrErrorMessage(addressFromString(getStringValue(an(), ad)), "Miner not set")
150
+
func at () = valueOrErrorMessage(addressFromString(getStringValue(am(), ae)), "Miner not set")
153
151
 
154
152
 
155
-
func av () = valueOrErrorMessage(addressFromString(getStringValue(an(), ae)), "Orders not set")
153
+
func au () = valueOrErrorMessage(addressFromString(getStringValue(am(), af)), "Orders not set")
156
154
 
157
155
 
158
-
func aw () = valueOrErrorMessage(addressFromString(getStringValue(an(), af)), "Referral not set")
156
+
func av () = valueOrErrorMessage(addressFromString(getStringValue(am(), ag)), "Referral not set")
159
157
 
160
158
 
161
-
func ax () = valueOrErrorMessage(addressFromString(getStringValue(an(), ai)), "NFT Manager not set")
159
+
func aw () = valueOrErrorMessage(addressFromString(getStringValue(am(), ai)), "NFT Manager not set")
162
160
 
163
161
 
164
-
func ay () = valueOrErrorMessage(addressFromString(getStringValue(an(), ag)), "Collateral Manager not set")
162
+
let ax = "k_token_param"
163
+
164
+
let ay = "k_token_type"
165
+
166
+
let az = "fee_reduction"
167
+
168
+
let aA = 1
169
+
170
+
let aB = 2
171
+
172
+
let aC = 15
173
+
174
+
let aD = 1000
175
+
176
+
let aE = 6
177
+
178
+
let aF = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
179
+
180
+
let aG = (525600 * aF)
181
+
182
+
let aH = (86400 * aF)
183
+
184
+
let aI = 1
185
+
186
+
let aJ = 2
187
+
188
+
func aK (aL) = (toString(aL) + ",")
165
189
 
166
190
 
167
-
func az () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(an(), ah), "No swap address")), "Invalid swap address")
191
+
func aM (aL,aN) = fraction(aL, aF, aN, HALFEVEN)
168
192
 
169
193
 
170
-
let aA = "k_whitelist_asset"
171
-
172
-
func aB (aC) = valueOrElse(getBoolean(ay(), ak(aA, aC)), false)
194
+
func aO (aL,aN) = fraction(aL, aN, aF, HALFEVEN)
173
195
 
174
196
 
175
-
let aD = "k_token_param"
176
-
177
-
let aE = "k_token_type"
178
-
179
-
let aF = "fee_reduction"
180
-
181
-
let aG = 1
182
-
183
-
let aH = 2
184
-
185
-
let aI = 15
186
-
187
-
let aJ = 15
188
-
189
-
let aK = 1000
190
-
191
-
let aL = 6
192
-
193
-
let aM = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
194
-
195
-
let aN = (86400 * aM)
196
-
197
-
let aO = 100
198
-
199
-
let aP = 1
200
-
201
-
let aQ = 2
202
-
203
-
func aR (aS) = (toString(aS) + ",")
197
+
func aP (aL) = sqrt(aL, aE, aE, HALFEVEN)
204
198
 
205
199
 
206
-
func aT (aS,aU) = fraction(aS, aM, aU, HALFEVEN)
200
+
func aQ (aL,aN) = pow(aL, aE, aN, aE, aE, HALFEVEN)
207
201
 
208
202
 
209
-
func aV (aS,aU) = fraction(aS, aU, aM, HALFEVEN)
203
+
func aR (aL,aN) = fraction(aL, toBigInt(aF), aN, HALFEVEN)
210
204
 
211
205
 
212
-
func aW (aS) = sqrt(aS, aL, aL, HALFEVEN)
206
+
func aS (aL,aN) = fraction(aL, aN, toBigInt(aF), HALFEVEN)
213
207
 
214
208
 
215
-
func aX (aS,aU) = pow(aS, aL, aU, aL, aL, HALFEVEN)
209
+
func aT (aL) = sqrtBigInt(aL, aE, aE, HALFEVEN)
216
210
 
217
211
 
218
-
func aY (aS,aU) = fraction(aS, toBigInt(aM), aU, HALFEVEN)
212
+
func aU (aL,aN) = pow(aL, aE, aN, aE, aE, HALFEVEN)
219
213
 
220
214
 
221
-
func aZ (aS,aU) = fraction(aS, aU, toBigInt(aM), HALFEVEN)
215
+
func aV (aL) = if ((aL > 0))
216
+
    then aL
217
+
    else -(aL)
222
218
 
223
219
 
224
-
func ba (aS) = sqrtBigInt(aS, aL, aL, HALFEVEN)
220
+
func aW (aL,aN) = if ((aL >= aN))
221
+
    then aL
222
+
    else aN
225
223
 
226
224
 
227
-
func bb (aS,aU) = pow(aS, aL, aU, aL, aL, HALFEVEN)
225
+
func aX (aY) = if ((size(aY) == 0))
226
+
    then ""
227
+
    else makeString(aY, ",")
228
228
 
229
229
 
230
-
func bc (aS) = if ((aS > 0))
231
-
    then aS
232
-
    else -(aS)
230
+
func aZ (ba) = if ((ba == ""))
231
+
    then nil
232
+
    else split(ba, ",")
233
233
 
234
234
 
235
-
func bd (aS,aU) = if ((aS >= aU))
236
-
    then aS
237
-
    else aU
235
+
func bb (aY,bc,bd) = if ((size(aY) > bc))
236
+
    then (removeByIndex(aY, 0) :+ bd)
237
+
    else (aY :+ bd)
238
238
 
239
239
 
240
-
func be (bf) = {
241
-
    func bg (bh,bi) =     ((bh + bi) + ",")
240
+
func be (bf) = valueOrErrorMessage(getInteger(this, bf), ("no value for " + bf))
242
241
 
243
-
    let bj = {
244
-
        let bk = bf
245
-
        let bl = size(bk)
246
-
        let bm = ""
247
-
        func bn (bo,bp) =         if ((bp >= bl))
248
-
            then bo
249
-
            else bg(bo, bk[bp])
250
242
 
251
-
        func bq (bo,bp) =         if ((bp >= bl))
252
-
            then bo
253
-
            else throw("List size exceeds 20")
243
+
func bg (bf,bh) = valueOrElse(getInteger(this, bf), bh)
254
244
 
255
-
        bq(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bm, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
256
-
        }
257
-
    let br = dropRight(bj, 1)
258
-
    let bs = if ((take(br, 1) == ","))
259
-
        then drop(br, 1)
260
-
        else br
261
-
    bs
245
+
246
+
func bi (al,ak) = {
247
+
    let bj = valueOrErrorMessage(getString(al, ak), ("No value for key " + ak))
248
+
    bj
262
249
 
    }
263
250
 
264
251
 
265
-
func bt (bu) = split(bu, ",")
266
-
267
-
268
-
func bv (bf,bw,bx) = if ((size(bf) > bw))
269
-
    then (removeByIndex(bf, 0) :+ bx)
270
-
    else (bf :+ bx)
271
-
272
-
273
-
func by (bz) = valueOrErrorMessage(getInteger(this, bz), ("no value for " + bz))
274
-
275
-
276
-
func bA (bz,bB) = valueOrElse(getInteger(this, bz), bB)
277
-
278
-
279
-
func bC (am,al) = {
280
-
    let bi = valueOrErrorMessage(getString(am, al), ("No value for key " + al))
281
-
    bi
252
+
func bk (al,ak) = {
253
+
    let bj = valueOrErrorMessage(getInteger(al, ak), ("No value for key " + ak))
254
+
    bj
282
255
 
    }
283
256
 
284
257
 
285
-
func bD (am,al) = {
286
-
    let bi = valueOrErrorMessage(getInteger(am, al), ("No value for key " + al))
287
-
    bi
288
-
    }
258
+
func bl () = be(c)
289
259
 
290
260
 
291
-
func bE () = by(e)
261
+
func bm () = be(p)
292
262
 
293
263
 
294
-
func bF () = by(q)
264
+
func bn () = be(q)
295
265
 
296
266
 
297
-
func bG () = by(s)
267
+
func bo () = be(s)
298
268
 
299
269
 
300
-
func bH () = by(M)
270
+
func bp () = be(M)
301
271
 
302
272
 
303
-
func bI () = by(N)
273
+
func bq () = be(N)
304
274
 
305
275
 
306
-
func bJ () = bA(O, aM)
276
+
func br () = bg(O, aF)
307
277
 
308
278
 
309
-
func bK () = bA(P, aM)
279
+
func bs () = bg(P, aF)
310
280
 
311
281
 
312
-
func bL () = by(Q)
282
+
func bt () = be(Q)
313
283
 
314
284
 
315
-
func bM () = by(T)
285
+
func bu () = be(T)
316
286
 
317
287
 
318
-
func bN () = by(U)
288
+
func bv () = be(U)
319
289
 
320
290
 
321
-
func bO () = by(V)
291
+
func bw () = be(V)
322
292
 
323
293
 
324
-
func bP () = by(J)
294
+
func bx () = be(J)
325
295
 
326
296
 
327
-
func bQ () = by(r)
297
+
func by () = be(r)
328
298
 
329
299
 
330
-
func bR () = (bQ() * aM)
300
+
func bz () = (by() * aF)
331
301
 
332
302
 
333
-
func bS () = (bQ() * aK)
303
+
func bA () = (by() * aD)
334
304
 
335
305
 
336
-
func bT () = by(t)
306
+
func bB () = be(t)
337
307
 
338
308
 
339
-
func bU () = by(u)
309
+
func bC () = be(u)
340
310
 
341
311
 
342
-
func bV () = by(v)
312
+
func bD () = be(v)
343
313
 
344
314
 
345
-
func bW () = by(w)
315
+
func bE () = be(w)
346
316
 
347
317
 
348
-
func bX () = by(x)
318
+
func bF () = be(x)
349
319
 
350
320
 
351
-
func bY () = by(y)
321
+
func bG () = be(y)
352
322
 
353
323
 
354
-
func bZ () = by(z)
324
+
func bH () = be(z)
355
325
 
356
326
 
357
-
func ca () = by(H)
327
+
func bI () = be(H)
358
328
 
359
329
 
360
-
func cb () = by(I)
330
+
func bJ () = be(I)
361
331
 
362
332
 
363
-
func cc () = by(S)
333
+
func bK () = be(S)
364
334
 
365
335
 
366
-
func cd () = by(R)
336
+
func bL () = be(R)
367
337
 
368
338
 
369
-
func ce () = bA(f, 0)
339
+
func bM () = bg(d, 0)
370
340
 
371
341
 
372
-
func cf () = by(A)
342
+
func bN () = be(A)
373
343
 
374
344
 
375
-
func cg () = by(B)
345
+
func bO () = be(B)
376
346
 
377
347
 
378
-
func ch (ci) = valueOrElse(getString(av(), "k_sender"), toString(ci.caller))
348
+
func bP () = lastBlock.timestamp
379
349
 
380
350
 
381
-
func cj (ck,cl,cm) = {
382
-
    let cn = (ck - cl)
383
-
    if (if (cm)
384
-
        then (0 > cn)
351
+
func bQ (bR) = valueOrElse(getString(au(), "k_sender"), toString(bR.caller))
352
+
353
+
354
+
func bS (bT,bU,bV) = {
355
+
    let bW = (bT - bU)
356
+
    if (if (bV)
357
+
        then (0 > bW)
385
358
 
        else false)
386
-
        then throw(((("Invalid margin: " + toString(ck)) + " < ") + toString(cl)))
387
-
        else if (if (!(cm))
388
-
            then (cn >= 0)
359
+
        then throw(((("Invalid margin: " + toString(bT)) + " < ") + toString(bU)))
360
+
        else if (if (!(bV))
361
+
            then (bW >= 0)
389
362
 
            else false)
390
-
            then throw(((("Invalid margin: " + toString(ck)) + " > ") + toString(cl)))
363
+
            then throw(((("Invalid margin: " + toString(bT)) + " > ") + toString(bU)))
391
364
 
            else true
392
365
 
    }
393
366
 
394
367
 
395
-
func co (cp) = if ((cp == 0))
368
+
func bX (bY) = if ((bY == 0))
396
369
 
    then throw("Should not be called with _positionSize == 0")
397
-
    else if ((cp > 0))
398
-
        then ca()
399
-
        else cb()
370
+
    else if ((bY > 0))
371
+
        then bI()
372
+
        else bJ()
400
373
 
401
374
 
402
-
func cq (cr) = {
403
-
    let cs = getInteger(this, ak(g, cr))
404
-
    let ct = cs
405
-
    if ($isInstanceOf(ct, "Int"))
375
+
func bZ (ca) = {
376
+
    let cb = getInteger(this, aj(e, ca))
377
+
    let cc = cb
378
+
    if ($isInstanceOf(cc, "Int"))
406
379
 
        then {
407
-
            let cu = ct
408
-
            $Tuple4(cu, getIntegerValue(this, ak(h, cr)), getIntegerValue(this, ak(i, cr)), getIntegerValue(this, ak(j, cr)))
380
+
            let cd = cc
381
+
            $Tuple5(cd, getIntegerValue(this, aj(f, ca)), getIntegerValue(this, aj(g, ca)), getIntegerValue(this, aj(h, ca)), getIntegerValue(this, aj(l, ca)))
409
382
 
            }
410
-
        else $Tuple4(0, 0, 0, 0)
383
+
        else $Tuple5(0, 0, 0, 0, 0)
411
384
 
    }
412
385
 
413
386
 
414
-
func cv (cr) = {
415
-
    let cw = getString(this, ak(l, cr))
416
-
    let ct = cw
417
-
    if ($isInstanceOf(ct, "String"))
387
+
func ce (ca) = {
388
+
    let cf = getString(this, aj(j, ca))
389
+
    let cc = cf
390
+
    if ($isInstanceOf(cc, "String"))
418
391
 
        then {
419
-
            let cx = ct
420
-
            cx
392
+
            let cg = cc
393
+
            cg
421
394
 
            }
422
-
        else toBase58String(aq())
395
+
        else toBase58String(ap())
423
396
 
    }
424
397
 
425
398
 
426
-
func cy (cr) = {
427
-
    let cz = getInteger(this, ak(m, cr))
428
-
    let ct = cz
429
-
    if ($isInstanceOf(ct, "Int"))
399
+
func ch (ca) = {
400
+
    let ci = getInteger(this, aj(k, ca))
401
+
    let cc = ci
402
+
    if ($isInstanceOf(cc, "Int"))
430
403
 
        then {
431
-
            let cA = ct
432
-
            cA
404
+
            let cj = cc
405
+
            cj
433
406
 
            }
434
-
        else bF()
407
+
        else bm()
435
408
 
    }
436
409
 
437
410
 
438
-
func cB (cr) = if ((cq(cr)._1 == 0))
411
+
func ck (ca) = if ((bZ(ca)._1 == 0))
439
412
 
    then throw("No open position")
440
413
 
    else true
441
414
 
442
415
 
443
-
func cC () = valueOrElse(getBoolean(this, n), false)
416
+
func cl (cm) = {
417
+
    let cn = getString(this, cm)
418
+
    if (if (isDefined(cn))
419
+
        then (value(cn) != "")
420
+
        else false)
421
+
        then {
422
+
            let co = split(value(cn), ",")
423
+
            let cp = valueOrErrorMessage(addressFromString(co[0]), ("Invalid oracle address in: " + value(cn)))
424
+
            let cq = co[1]
425
+
            let cr = co[2]
426
+
            let cs = co[3]
427
+
            $Tuple4(cp, cq, cr, cs)
428
+
            }
429
+
        else unit
430
+
    }
444
431
 
445
432
 
446
-
func cD () = valueOrElse(getBoolean(this, o), false)
433
+
func ct () = valueOrElse(getBoolean(this, m), false)
447
434
 
448
435
 
449
-
func cE () = valueOrElse(getBoolean(this, p), false)
436
+
func cu () = valueOrElse(getBoolean(this, n), false)
450
437
 
451
438
 
452
-
func cF (cG,cH,cI) = if (cG)
439
+
func cv () = valueOrElse(getBoolean(this, o), false)
440
+
441
+
442
+
func cw (cx,cy,cz) = if (cx)
453
443
 
    then {
454
-
        let cJ = (bI() - cI)
455
-
        if ((0 >= cJ))
444
+
        let cA = (bq() - cz)
445
+
        if ((0 >= cA))
456
446
 
            then throw("Tx lead to base asset reserve <= 0, revert")
457
-
            else $Tuple3((bH() + cH), cJ, (bL() + cI))
447
+
            else $Tuple3((bp() + cy), cA, (bt() + cz))
458
448
 
        }
459
449
 
    else {
460
-
        let cK = (bH() - cH)
461
-
        if ((0 >= cK))
450
+
        let cB = (bp() - cy)
451
+
        if ((0 >= cB))
462
452
 
            then throw("Tx lead to base quote reserve <= 0, revert")
463
-
            else $Tuple3(cK, (bI() + cI), (bL() - cI))
453
+
            else $Tuple3(cB, (bq() + cz), (bt() - cz))
464
454
 
        }
465
455
 
466
456
 
467
-
func cL (cM,cN) = {
468
-
    let cO = toBigInt(cM)
469
-
    let cP = toBigInt(cN)
470
-
    aZ(cO, cP)
457
+
func cC (cD,cE) = {
458
+
    let cF = toBigInt(cD)
459
+
    let cG = toBigInt(cE)
460
+
    aS(cF, cG)
471
461
 
    }
472
462
 
473
463
 
474
-
func cQ (cG,cH) = {
475
-
    let cM = bH()
476
-
    let cN = bI()
477
-
    let cR = bJ()
478
-
    let cS = bK()
479
-
    let cT = aT(cH, cR)
480
-
    let bz = cL(cM, cN)
481
-
    let cU = if (cG)
482
-
        then (cM + cT)
483
-
        else (cM - cT)
484
-
    let cV = toInt(aY(bz, toBigInt(cU)))
485
-
    let cW = bc((cV - cN))
486
-
    let cX = if (cG)
487
-
        then cW
488
-
        else -(cW)
489
-
    let cY = cF(cG, cT, cW)
490
-
    let cZ = cY._1
491
-
    let da = cY._2
492
-
    let db = cY._3
493
-
    let dc = aT(aV(cM, cR), aV(cN, cS))
494
-
    let dd = aT(cH, cW)
495
-
    let de = bc((dc - dd))
496
-
    let df = (aM - aT(dc, (dc + de)))
497
-
    let dg = bX()
498
-
    if ((df > dg))
499
-
        then throw(((((((((((((("Price impact " + toString(df)) + " > max price impact ") + toString(dg)) + " before quote asset: ") + toString(cM)) + " before base asset: ") + toString(cN)) + " quote asset amount to exchange: ") + toString(cH)) + " price before: ") + toString(dc)) + " marketPrice: ") + toString(dd)))
500
-
        else $Tuple4(cX, cZ, da, db)
464
+
func cH (cx,cy) = {
465
+
    let cD = bp()
466
+
    let cE = bq()
467
+
    let cI = br()
468
+
    let cJ = bs()
469
+
    let cK = aM(cy, cI)
470
+
    let bf = cC(cD, cE)
471
+
    let cL = if (cx)
472
+
        then (cD + cK)
473
+
        else (cD - cK)
474
+
    let cM = toInt(aR(bf, toBigInt(cL)))
475
+
    let cN = aV((cM - cE))
476
+
    let cO = if (cx)
477
+
        then cN
478
+
        else -(cN)
479
+
    let cP = cw(cx, cK, cN)
480
+
    let cQ = cP._1
481
+
    let cR = cP._2
482
+
    let cS = cP._3
483
+
    let cT = aM(aO(cD, cI), aO(cE, cJ))
484
+
    let cU = aM(cy, cN)
485
+
    let cV = aV((cT - cU))
486
+
    let cW = (aF - aM(cT, (cT + cV)))
487
+
    let cX = bF()
488
+
    if ((cW > cX))
489
+
        then throw(((((((((((((("Price impact " + toString(cW)) + " > max price impact ") + toString(cX)) + " before quote asset: ") + toString(cD)) + " before base asset: ") + toString(cE)) + " quote asset amount to exchange: ") + toString(cy)) + " price before: ") + toString(cT)) + " marketPrice: ") + toString(cU)))
490
+
        else $Tuple4(cO, cQ, cR, cS)
501
491
 
    }
502
492
 
503
493
 
504
-
func dh (di,dj,dk,dl) = {
505
-
    let dm = if ((di != 0))
506
-
        then {
507
-
            let dn = co(di)
508
-
            aV((dn - dk), di)
509
-
            }
510
-
        else 0
511
-
    let do = ((dl - dm) + dj)
512
-
    let dp = if ((0 > do))
513
-
        then $Tuple2(0, bc(do))
514
-
        else $Tuple2(bc(do), 0)
515
-
    let dq = dp._1
516
-
    let dr = dp._2
517
-
    $Tuple3(dq, dr, dm)
494
+
func cY (cZ,da) = {
495
+
    let db = ((((bP() - da) / 1000) / 60) * aF)
496
+
    let dc = aM(aO(aO(cZ, db), bn()), aG)
497
+
    dc
518
498
 
    }
519
499
 
520
500
 
521
-
func ds (cG,cI,dt,du,dv,dw,dx) = {
522
-
    let dc = aT(aV(du, dv), aV(dw, dx))
523
-
    if ((cI == 0))
501
+
func dd (de,cZ,df,da,dg) = {
502
+
    let dh = if ((de != 0))
503
+
        then {
504
+
            let di = bX(de)
505
+
            aO((di - df), de)
506
+
            }
507
+
        else 0
508
+
    let dc = cY(cZ, da)
509
+
    let dj = (((dg - dc) - dh) + cZ)
510
+
    let dk = if ((0 > dj))
511
+
        then $Tuple2(0, aV(dj))
512
+
        else $Tuple2(aV(dj), 0)
513
+
    let dl = dk._1
514
+
    let dm = dk._2
515
+
    $Tuple4(dl, dm, dh, dc)
516
+
    }
517
+
518
+
519
+
func dn (cx,cz,do,dp,dq,dr,ds) = {
520
+
    let cT = aM(aO(dp, dq), aO(dr, ds))
521
+
    if ((cz == 0))
524
522
 
        then throw("Invalid base asset amount")
525
523
 
        else {
526
-
            let bz = cL(du, dw)
527
-
            let dy = if (cG)
528
-
                then (dw + cI)
529
-
                else (dw - cI)
530
-
            let dz = toInt(aY(bz, toBigInt(dy)))
531
-
            let dA = bc((dz - du))
532
-
            let dB = aV(dA, dv)
533
-
            let dg = bX()
534
-
            let dC = cF(!(cG), dA, cI)
535
-
            let cZ = dC._1
536
-
            let da = dC._2
537
-
            let db = dC._3
538
-
            let dd = aT(dB, cI)
539
-
            let de = bc((dc - dd))
540
-
            let df = (aM - aT(dc, (dc + de)))
541
-
            if (if ((df > dg))
542
-
                then dt
524
+
            let bf = cC(dp, dr)
525
+
            let dt = if (cx)
526
+
                then (dr + cz)
527
+
                else (dr - cz)
528
+
            let du = toInt(aR(bf, toBigInt(dt)))
529
+
            let dv = aV((du - dp))
530
+
            let dw = aO(dv, dq)
531
+
            let cX = bF()
532
+
            let dx = cw(!(cx), dv, cz)
533
+
            let cQ = dx._1
534
+
            let cR = dx._2
535
+
            let cS = dx._3
536
+
            let cU = aM(dw, cz)
537
+
            let cV = aV((cT - cU))
538
+
            let cW = (aF - aM(cT, (cT + cV)))
539
+
            if (if ((cW > cX))
540
+
                then do
543
541
 
                else false)
544
-
                then throw(((((((((((((("Price impact " + toString(df)) + " > max price impact ") + toString(dg)) + " before quote asset: ") + toString(du)) + " before base asset: ") + toString(dw)) + " base asset amount to exchange: ") + toString(cI)) + " price before: ") + toString(dc)) + " market price: ") + toString(dd)))
545
-
                else $Tuple7(dB, cZ, da, db, (cd() - (if (cG)
546
-
                    then bc(cI)
547
-
                    else 0)), (cc() - (if (!(cG))
548
-
                    then bc(cI)
549
-
                    else 0)), df)
542
+
                then throw(((((((((((((("Price impact " + toString(cW)) + " > max price impact ") + toString(cX)) + " before quote asset: ") + toString(dp)) + " before base asset: ") + toString(dr)) + " base asset amount to exchange: ") + toString(cz)) + " price before: ") + toString(cT)) + " market price: ") + toString(cU)))
543
+
                else $Tuple7(dw, cQ, cR, cS, (bL() - (if (cx)
544
+
                    then aV(cz)
545
+
                    else 0)), (bK() - (if (!(cx))
546
+
                    then aV(cz)
547
+
                    else 0)), cW)
550
548
 
            }
551
549
 
    }
552
550
 
553
551
 
554
-
func dD (cG,cI,dt) = ds(cG, cI, dt, bH(), bJ(), bI(), bK())
552
+
func dy (cx,cz,do) = dn(cx, cz, do, bp(), br(), bq(), bs())
553
+
554
+
555
+
func dz (dA,cq,cr) = {
556
+
    let dB = valueOrErrorMessage(getInteger(dA, cq), ((("Can not get oracle price. Oracle: " + toString(dA)) + " key: ") + cq))
557
+
    if ((cr != ""))
558
+
        then {
559
+
            let dC = lastBlock.height
560
+
            let dD = valueOrErrorMessage(getInteger(dA, cr), ((("Can not get oracle block. Oracle: " + toString(dA)) + " key: ") + cr))
561
+
            if (((dC - dD) > bO()))
562
+
                then throw(((("Oracle stale data. Last oracle block: " + toString(dD)) + " current block: ") + toString(dC)))
563
+
                else dB
564
+
            }
565
+
        else dB
566
+
    }
555
567
 
556
568
 
557
569
 
func dE () = {
558
-
    let dF = valueOrErrorMessage(addressFromString(getStringValue(this, d)), "")
559
-
    let dG = getStringValue(this, a)
560
-
    let dH = valueOrErrorMessage(getInteger(dF, dG), ((("Can not get oracle price. Oracle: " + toString(dF)) + " key: ") + dG))
561
-
    let dI = valueOrElse(getString(this, b), "")
562
-
    if ((dI != ""))
570
+
    let dF = valueOrErrorMessage(cl(a), "No base asset oracle data")
571
+
    let dG = dz(dF._1, dF._2, dF._3)
572
+
    let dH = cl(b)
573
+
    let dI = if (isDefined(dH))
563
574
 
        then {
564
-
            let dJ = lastBlock.height
565
-
            let dK = valueOrErrorMessage(getInteger(dF, dI), ((("Can not get oracle block. Oracle: " + toString(dF)) + " key: ") + dI))
566
-
            if (((dJ - dK) > cg()))
567
-
                then throw(((("Oracle stale data. Last oracle block: " + toString(dK)) + " current block: ") + toString(dJ)))
568
-
                else dH
575
+
            let dJ = value(dH)
576
+
            dz(dJ._1, dJ._2, dJ._3)
569
577
 
            }
570
-
        else dH
578
+
        else aF
579
+
    aM(dG, dI)
571
580
 
    }
572
581
 
573
582
 
574
-
func dL () = {
575
-
    let dF = valueOrErrorMessage(addressFromString(getStringValue(this, d)), "")
576
-
    let dM = valueOrElse(getString(this, c), "")
577
-
    if ((dM != ""))
583
+
func dK () = {
584
+
    let dF = valueOrErrorMessage(cl(a), "No base asset oracle data")
585
+
    let dA = dF._1
586
+
    let cs = dF._4
587
+
    if ((cs != ""))
578
588
 
        then {
579
-
            let dN = valueOrErrorMessage(getBoolean(dF, dM), ((("Can not get oracle is open/closed. Oracle: " + toString(dF)) + " key: ") + dM))
580
-
            !(dN)
589
+
            let dL = valueOrErrorMessage(getBoolean(dA, cs), ((("Can not get oracle is open/closed. Oracle: " + toString(dA)) + " key: ") + cs))
590
+
            !(dL)
581
591
 
            }
582
592
 
        else false
583
593
 
    }
584
594
 
585
595
 
586
-
func dO (dP,du,dw,cR,cS) = {
587
-
    let dQ = aT(aV(du, cR), aV(dw, cS))
588
-
    let dR = aT((dP + dQ), (2 * aM))
589
-
    let dO = aT(bc((dP - dQ)), dR)
590
-
    dO
596
+
func dM (dN,dp,dr,cI,cJ) = {
597
+
    let dO = aM(aO(dp, cI), aO(dr, cJ))
598
+
    let dP = aM((dN + dO), (2 * aF))
599
+
    let dM = aM(aV((dN - dO)), dP)
600
+
    dM
591
601
 
    }
592
602
 
593
603
 
594
-
func dS (du,dw) = {
595
-
    let dT = dE()
596
-
    let cR = bJ()
597
-
    let cS = bK()
598
-
    let dU = dO(dT, bH(), bI(), cR, cS)
599
-
    let dV = dO(dT, du, dw, cR, cS)
600
-
    if (if ((dV > bY()))
601
-
        then (dV > dU)
604
+
func dQ (dp,dr) = {
605
+
    let dR = dE()
606
+
    let cI = br()
607
+
    let cJ = bs()
608
+
    let dS = dM(dR, bp(), bq(), cI, cJ)
609
+
    let dT = dM(dR, dp, dr, cI, cJ)
610
+
    if (if ((dT > bG()))
611
+
        then (dT > dS)
602
612
 
        else false)
603
-
        then throw(((("Price spread " + toString(dV)) + " > max price spread ") + toString(bY())))
613
+
        then throw(((("Price spread " + toString(dT)) + " > max price spread ") + toString(bG())))
604
614
 
        else true
605
615
 
    }
606
616
 
607
617
 
608
-
func dW (dX,dY) = {
609
-
    let dZ = bZ()
610
-
    if ((dX > dZ))
611
-
        then throw(((("Long open notional " + toString(dX)) + " > max open notional ") + toString(dZ)))
612
-
        else if ((dY > dZ))
613
-
            then throw(((("Short open notional " + toString(dY)) + " > max open notional ") + toString(dZ)))
618
+
func dU (dV,dW) = {
619
+
    let dX = bH()
620
+
    if ((dV > dX))
621
+
        then throw(((("Long open notional " + toString(dV)) + " > max open notional ") + toString(dX)))
622
+
        else if ((dW > dX))
623
+
            then throw(((("Short open notional " + toString(dW)) + " > max open notional ") + toString(dX)))
614
624
 
            else true
615
625
 
    }
616
626
 
617
627
 
618
-
func ea () = {
619
-
    let du = bH()
620
-
    let dw = bI()
621
-
    let cR = bJ()
622
-
    let cS = bK()
623
-
    aT(aV(du, cR), aV(dw, cS))
628
+
func dY () = {
629
+
    let dp = bp()
630
+
    let dr = bq()
631
+
    let cI = br()
632
+
    let cJ = bs()
633
+
    aM(aO(dp, cI), aO(dr, cJ))
624
634
 
    }
625
635
 
626
636
 
627
-
func eb () = {
628
-
    let dT = dE()
629
-
    let ec = ea()
630
-
    (aT(bc((dT - ec)), dT) > bW())
637
+
func dZ () = {
638
+
    let dR = dE()
639
+
    let ea = dY()
640
+
    (aM(aV((dR - ea)), dR) > bE())
631
641
 
    }
632
642
 
633
643
 
634
-
func ed (cp,ee,du,dv,dw,dx) = {
635
-
    let ef = bc(cp)
636
-
    let eg = (0 > cp)
637
-
    let eh = if ((ee == aP))
644
+
func eb (bY,ec,dp,dq,dr,ds) = {
645
+
    let ed = aV(bY)
646
+
    let ee = (0 > bY)
647
+
    let ef = if ((ec == aI))
638
648
 
        then {
639
-
            let ei = ds(!(eg), ef, false, du, dv, dw, dx)
640
-
            let ej = ei._1
641
-
            let ek = ei._2
642
-
            let el = ei._3
643
-
            let em = ei._4
644
-
            ej
649
+
            let eg = dn(!(ee), ed, false, dp, dq, dr, ds)._1
650
+
            eg
645
651
 
            }
646
-
        else aV(ef, dE())
647
-
    eh
652
+
        else aO(ed, dE())
653
+
    ef
648
654
 
    }
649
655
 
650
656
 
651
-
func en (cp,eo,du,dv,dw,dx,ee) = if ((cp == 0))
657
+
func eh (bY,ei,dp,dq,dr,ds,ec) = if ((bY == 0))
652
658
 
    then throw("Invalid position size")
653
659
 
    else {
654
-
        let eg = (0 > cp)
655
-
        let eh = ed(cp, ee, du, dv, dw, dx)
656
-
        let ep = if (eg)
657
-
            then (eo - eh)
658
-
            else (eh - eo)
659
-
        $Tuple2(eh, ep)
660
+
        let ee = (0 > bY)
661
+
        let ef = eb(bY, ec, dp, dq, dr, ds)
662
+
        let ej = if (ee)
663
+
            then (ei - ef)
664
+
            else (ef - ei)
665
+
        $Tuple2(ef, ej)
660
666
 
        }
661
667
 
662
668
 
663
-
func eq (cr,ee) = {
664
-
    let er = cq(cr)
665
-
    let cu = er._1
666
-
    let es = er._2
667
-
    let et = er._3
668
-
    let eu = er._4
669
-
    en(cu, et, bH(), bJ(), bI(), bK(), ee)
669
+
func ek (ca,ec) = {
670
+
    let el = bZ(ca)
671
+
    let cd = el._1
672
+
    let em = el._2
673
+
    let en = el._3
674
+
    let eo = el._4
675
+
    eh(cd, en, bp(), br(), bq(), bs(), ec)
670
676
 
    }
671
677
 
672
678
 
673
-
func ev (ew,ex,ey) = aT((ew - ex), ey)
679
+
func ep (eq,er,es) = aM((eq - er), es)
674
680
 
675
681
 
676
-
func ez (cr,ee) = {
677
-
    let eA = cq(cr)
678
-
    let cu = eA._1
679
-
    let es = eA._2
680
-
    let eB = eA._3
681
-
    let eu = eA._4
682
-
    let eC = eq(cr, ee)
683
-
    let eh = eC._1
684
-
    let ep = eC._2
685
-
    let eD = dh(cu, es, eu, ep)
686
-
    let dq = eD._1
687
-
    let dr = eD._2
688
-
    ev(dq, dr, eh)
682
+
func et (ca,ec) = {
683
+
    let eu = bZ(ca)
684
+
    let cd = eu._1
685
+
    let em = eu._2
686
+
    let ev = eu._3
687
+
    let ew = eu._4
688
+
    let ex = eu._5
689
+
    let ey = ek(ca, ec)
690
+
    let ef = ey._1
691
+
    let ej = ey._2
692
+
    let ez = dd(cd, em, ew, ex, ej)
693
+
    let dl = ez._1
694
+
    let dm = ez._2
695
+
    ep(dl, dm, ef)
689
696
 
    }
690
697
 
691
698
 
692
-
func eE (cr) = ez(cr, aP)
699
+
func eA (ca) = et(ca, aI)
693
700
 
694
701
 
695
-
func eF (cr,cp) = {
696
-
    let eG = bd(bV(), (aM - aT(eE(cr), bT())))
697
-
    let eH = aV(bc(cp), eG)
698
-
    let eI = dD((cp > 0), eH, false)
699
-
    let eJ = eI._1
700
-
    let df = eI._7
701
-
    if ((bX() > df))
702
-
        then eJ
702
+
func eB (ca,bY) = {
703
+
    let eC = aW(bD(), (aF - aM(eA(ca), bB())))
704
+
    let eD = aO(aV(bY), eC)
705
+
    let eE = dy((bY > 0), eD, false)
706
+
    let eF = eE._1
707
+
    let cW = eE._7
708
+
    if ((bF() > cW))
709
+
        then eD
710
+
        else aO(aV(bY), bD())
711
+
    }
712
+
713
+
714
+
func eG (ca,eH,eI,eJ,eK,do) = {
715
+
    let eL = bZ(ca)
716
+
    let eM = eL._1
717
+
    let eN = eL._2
718
+
    let eO = eL._3
719
+
    let eP = eL._4
720
+
    let eQ = eL._5
721
+
    let eR = (eM > 0)
722
+
    let eS = aV(eM)
723
+
    if (if ((eS >= eH))
724
+
        then (eH > 0)
725
+
        else false)
726
+
        then {
727
+
            let eT = (eS > eH)
728
+
            let eU = dy((eM > 0), eH, do)
729
+
            let eV = eU._1
730
+
            let cL = eU._2
731
+
            let cM = eU._3
732
+
            let eW = eU._4
733
+
            let eX = if ((eM > 0))
734
+
                then -(eH)
735
+
                else eH
736
+
            let eY = ek(ca, aI)
737
+
            let eZ = eY._1
738
+
            let ej = eY._2
739
+
            let fa = aM(aV(eX), eS)
740
+
            let fb = aO(ej, fa)
741
+
            let fc = dd(eM, eN, eP, eQ, ej)
742
+
            let fd = fc._1
743
+
            let fe = fc._2
744
+
            let ff = fc._3
745
+
            let dc = fc._4
746
+
            let fg = dd(eM, eN, eP, eQ, fb)._2
747
+
            let fh = aO(aO(eZ, fa), eI)
748
+
            let fi = (ej - fb)
749
+
            let fj = if ((eM > 0))
750
+
                then ((eZ - eV) - fi)
751
+
                else ((fi + eZ) - eV)
752
+
            let fk = (eM + eX)
753
+
            let fl = if ((fk == 0))
754
+
                then $Tuple2(0, 0)
755
+
                else $Tuple2(aV(fj), bX(fk))
756
+
            let fm = fl._1
757
+
            let fn = fl._2
758
+
            let fo = (eO - fm)
759
+
            let fp = et(ca, aI)
760
+
            let fq = if ((eM > 0))
761
+
                then (aO((fm + fi), fp) - fi)
762
+
                else (aO((fm - fi), fp) - fi)
763
+
            let fr = ((fd - (fq + fi)) - fh)
764
+
            let fs = if ((0 > fr))
765
+
                then throw("Invalid internalClosePosition params: unable to pay fee")
766
+
                else fr
767
+
            let ft = if (eK)
768
+
                then (fq + fs)
769
+
                else fq
770
+
            if (if ((eJ != 0))
771
+
                then (eJ > eV)
772
+
                else false)
773
+
                then throw(((("Limit error: " + toString(eV)) + " < ") + toString(eJ)))
774
+
                else $Tuple17(fk, ft, fm, fn, fg, fb, if (if (eK)
775
+
                    then eT
776
+
                    else false)
777
+
                    then 0
778
+
                    else fs, cL, cM, eW, (bu() - fo), (bL() - (if (eR)
779
+
                    then aV(eX)
780
+
                    else 0)), (bK() - (if (!(eR))
781
+
                    then aV(eX)
782
+
                    else 0)), (bw() - (if (eR)
783
+
                    then fo
784
+
                    else 0)), (bv() - (if (!(eR))
785
+
                    then fo
786
+
                    else 0)), (fh + dc), eV)
787
+
            }
788
+
        else throw("Invalid internalClosePosition params: invalid position size")
789
+
    }
790
+
791
+
792
+
func fu () = {
793
+
    let fv = ((bP() / 1000) / 60)
794
+
    let fw = (fv - aC)
795
+
    let fx = valueOrElse(getString(this, C), "")
796
+
    let fy = split(fx, ",")
797
+
    func fz (fA,fB) =     if ((fw >= valueOrErrorMessage(parseInt(fB), ("getTwapSpotPrice: invalid int: " + fx))))
798
+
        then (fA :+ parseIntValue(fB))
799
+
        else fA
800
+
801
+
    let fC = {
802
+
        let fD = fy
803
+
        let fE = size(fD)
804
+
        let fF = nil
805
+
        func fG (fH,fI) =         if ((fI >= fE))
806
+
            then fH
807
+
            else fz(fH, fD[fI])
808
+
809
+
        func fJ (fH,fI) =         if ((fI >= fE))
810
+
            then fH
811
+
            else throw("List size exceeds 20")
812
+
813
+
        fJ(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fG(fF, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
814
+
        }
815
+
    let fK = if ((size(fC) > 0))
816
+
        then max(fC)
817
+
        else valueOrErrorMessage(parseInt(fy[0]), ("getTwapSpotPrice: invalid int: " + fx))
818
+
    let fL = valueOrElse(getInteger(this, D), 0)
819
+
    let fM = valueOrElse(getInteger(this, ((E + "_") + toString(fL))), 0)
820
+
    let fN = valueOrElse(getInteger(this, ((F + "_") + toString(fL))), 0)
821
+
    let fO = (fM + ((fv - fL) * fN))
822
+
    let fP = valueOrElse(getInteger(this, ((E + "_") + toString(fK))), 0)
823
+
    let fQ = valueOrElse(getInteger(this, ((F + "_") + toString(fK))), 0)
824
+
    let fR = (fP + ((fw - fK) * fQ))
825
+
    ((fO - fR) / aC)
826
+
    }
827
+
828
+
829
+
func fS () = {
830
+
    let bY = bt()
831
+
    if ((bY == 0))
832
+
        then $Tuple2(bp(), bq())
703
833
 
        else {
704
-
            let eK = aV(bc(cp), bV())
705
-
            let eL = dD((cp > 0), eK, false)._1
706
-
            eL
834
+
            let fT = (bY > 0)
835
+
            let fU = dy(fT, aV(bY), false)
836
+
            let fV = fU._1
837
+
            let fW = fU._2
838
+
            let fX = fU._3
839
+
            $Tuple2(fW, fX)
707
840
 
            }
708
841
 
    }
709
842
 
710
843
 
711
-
func eM (cr,dt) = {
712
-
    let eN = cq(cr)
713
-
    let cu = eN._1
714
-
    let es = eN._2
715
-
    let et = eN._3
716
-
    let eu = eN._4
717
-
    let ep = eq(cr, aP)._2
718
-
    let eO = dh(cu, es, eu, ep)
719
-
    let dq = eO._1
720
-
    let dr = eO._2
721
-
    let eK = -(cu)
722
-
    let eP = ep
723
-
    let eQ = -(dq)
724
-
    let eR = dD((cu > 0), bc(cu), dt)
725
-
    let eL = eR._1
726
-
    let cU = eR._2
727
-
    let cV = eR._3
728
-
    let eS = eR._4
729
-
    let eT = eR._5
730
-
    let eU = eR._6
731
-
    let eV = (bM() - et)
732
-
    $Tuple13(eK, dr, eP, eQ, cU, cV, eS, eV, eL, eT, eU, (bO() - (if ((cu > 0))
733
-
        then et
734
-
        else 0)), (bN() - (if ((0 > cu))
735
-
        then et
736
-
        else 0)))
844
+
func fY (fZ,bt,ga,gb) = {
845
+
    let gc = toBigInt(fZ)
846
+
    let gd = toBigInt(bt)
847
+
    let ge = toBigInt(ga)
848
+
    let gf = toBigInt(gb)
849
+
    let bf = aS(ge, gc)
850
+
    let gg = (gc + gd)
851
+
    let gh = aR(bf, gg)
852
+
    let gi = aR(gh, gg)
853
+
    let gj = aR(gf, gi)
854
+
    toInt(gj)
737
855
 
    }
738
856
 
739
857
 
740
-
func eW () = {
741
-
    let eX = ((lastBlock.timestamp / 1000) / 60)
742
-
    let eY = (eX - aI)
743
-
    let eZ = valueOrElse(getString(this, C), "")
744
-
    let fa = split(eZ, ",")
745
-
    func fb (bh,fc) =     if ((eY >= parseIntValue(fc)))
746
-
        then (bh :+ parseIntValue(fc))
747
-
        else bh
748
-
749
-
    let fd = {
750
-
        let bk = fa
751
-
        let bl = size(bk)
752
-
        let bm = nil
753
-
        func bn (bo,bp) =         if ((bp >= bl))
754
-
            then bo
755
-
            else fb(bo, bk[bp])
756
-
757
-
        func bq (bo,bp) =         if ((bp >= bl))
758
-
            then bo
759
-
            else throw("List size exceeds 20")
760
-
761
-
        bq(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bm, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
762
-
        }
763
-
    let fe = if ((size(fd) > 0))
764
-
        then max(fd)
765
-
        else parseIntValue(fa[0])
766
-
    let ff = valueOrElse(getInteger(this, D), 0)
767
-
    let fg = valueOrElse(getInteger(this, ((E + "_") + toString(ff))), 0)
768
-
    let fh = valueOrElse(getInteger(this, ((F + "_") + toString(ff))), 0)
769
-
    let fi = (fg + ((eX - ff) * fh))
770
-
    let fj = valueOrElse(getInteger(this, ((E + "_") + toString(fe))), 0)
771
-
    let fk = valueOrElse(getInteger(this, ((F + "_") + toString(fe))), 0)
772
-
    let fl = (fj + ((eY - fe) * fk))
773
-
    ((fi - fl) / aI)
774
-
    }
775
-
776
-
777
-
func fm () = {
778
-
    let cp = bL()
779
-
    if ((cp == 0))
780
-
        then $Tuple2(bH(), bI())
858
+
func gk (gl,cD,cE) = {
859
+
    let bY = bt()
860
+
    if ((bY == 0))
861
+
        then {
862
+
            let gm = aM(aO(gl, cE), cD)
863
+
            $Tuple3(gm, aF, 0)
864
+
            }
781
865
 
        else {
782
-
            let fn = (cp > 0)
783
-
            let fo = dD(fn, bc(cp), false)
784
-
            let fp = fo._1
785
-
            let fq = fo._2
786
-
            let fr = fo._3
787
-
            $Tuple2(fq, fr)
866
+
            let fT = (bY > 0)
867
+
            let fV = dy(fT, aV(bY), false)._1
868
+
            let gm = fY(cE, bY, cD, gl)
869
+
            let gn = aF
870
+
            let go = eh(bY, fV, cD, gm, cE, gn, aI)._2
871
+
            $Tuple3(gm, gn, go)
788
872
 
            }
789
873
 
    }
790
874
 
791
875
 
792
-
func fs (ft,bL,fu,fv) = {
793
-
    let fw = toBigInt(ft)
794
-
    let fx = toBigInt(bL)
795
-
    let fy = toBigInt(fu)
796
-
    let fz = toBigInt(fv)
797
-
    let bz = aZ(fy, fw)
798
-
    let fA = (fw + fx)
799
-
    let fB = aY(bz, fA)
800
-
    let fC = aY(fB, fA)
801
-
    let fD = aY(fz, fC)
802
-
    toInt(fD)
803
-
    }
804
-
805
-
806
-
func fE (fF,cM,cN) = {
807
-
    let cp = bL()
808
-
    if ((cp == 0))
809
-
        then {
810
-
            let fG = aT(aV(fF, cN), cM)
811
-
            $Tuple3(fG, aM, 0)
812
-
            }
813
-
        else {
814
-
            let fn = (cp > 0)
815
-
            let fp = dD(fn, bc(cp), false)._1
816
-
            let fG = fs(cN, cp, cM, fF)
817
-
            let fH = aM
818
-
            let eQ = en(cp, fp, cM, fG, cN, fH, aP)._2
819
-
            $Tuple3(fG, fH, eQ)
820
-
            }
821
-
    }
822
-
823
-
824
-
func fI () = {
825
-
    let fJ = dE()
826
-
    let fK = eW()
827
-
    let fL = (fK - fJ)
828
-
    if (if (if ((cc() == 0))
876
+
func gp () = {
877
+
    let gq = dE()
878
+
    let gr = fu()
879
+
    let gs = (gr - gq)
880
+
    if (if (if ((bK() == 0))
829
881
 
        then true
830
-
        else (cd() == 0))
882
+
        else (bL() == 0))
831
883
 
        then true
832
-
        else dL())
884
+
        else dK())
833
885
 
        then $Tuple2(0, 0)
834
-
        else if ((0 > fL))
886
+
        else if ((0 > gs))
835
887
 
            then {
836
-
                let fM = aT(aV(fL, bR()), aN)
837
-
                let fN = aT(aV(fM, cc()), cd())
838
-
                $Tuple2(fM, fN)
888
+
                let gt = aM(aO(gs, bz()), aH)
889
+
                let gu = aM(aO(gt, bK()), bL())
890
+
                $Tuple2(gt, gu)
839
891
 
                }
840
892
 
            else {
841
-
                let fN = aT(aV(fL, bR()), aN)
842
-
                let fM = aT(aV(fN, cd()), cc())
843
-
                $Tuple2(fM, fN)
893
+
                let gu = aM(aO(gs, bz()), aH)
894
+
                let gt = aM(aO(gu, bL()), bK())
895
+
                $Tuple2(gt, gu)
844
896
 
                }
845
897
 
    }
846
898
 
847
899
 
848
-
func fO (fP,fQ) = {
849
-
    let fR = bF()
850
-
    let fS = aV(fR, fQ)
851
-
    let fT = if ((fP != ""))
900
+
func gv (gw,gx) = {
901
+
    let gy = bm()
902
+
    let gz = aO(gy, gx)
903
+
    let gA = if ((gw != ""))
852
904
 
        then {
853
-
            let fU = bC(ax(), ak(aE, fP))
854
-
            if ((fU == aF))
905
+
            let gB = bi(aw(), aj(ay, gw))
906
+
            if ((gB == az))
855
907
 
                then {
856
-
                    let fV = bD(ax(), ak(aD, fP))
857
-
                    let fW = aV(fS, fV)
858
-
                    $Tuple2(fW, true)
908
+
                    let gC = bk(aw(), aj(ax, gw))
909
+
                    let gD = aO(gz, gC)
910
+
                    $Tuple2(gD, true)
859
911
 
                    }
860
912
 
                else throw("Invalid attached artifact")
861
913
 
            }
862
-
        else $Tuple2(fS, false)
863
-
    let fW = fT._1
864
-
    let fX = fT._2
865
-
    $Tuple2(fW, fX)
914
+
        else $Tuple2(gz, false)
915
+
    let gD = gA._1
916
+
    let gE = gA._2
917
+
    $Tuple2(gD, gE)
866
918
 
    }
867
919
 
868
920
 
869
-
func fY (cr,aC) = {
870
-
    let fZ = cq(cr)._1
871
-
    if ((fZ == 0))
921
+
func gF (ca,gG) = {
922
+
    let eM = bZ(ca)._1
923
+
    if ((eM == 0))
872
924
 
        then true
873
-
        else (cv(cr) == aC)
925
+
        else (ce(ca) == gG)
874
926
 
    }
875
927
 
876
928
 
877
-
func ga (cr,aC) = (cv(cr) == aC)
929
+
func gH (ca,gG) = (ce(ca) == gG)
878
930
 
879
931
 
880
-
func gb (gc,aC,cr) = ((((((aj + "_") + gc) + "_") + aC) + "_") + cr)
881
-
882
-
883
-
func gd (cr) = {
884
-
    let cx = cv(cr)
885
-
    if ((cx == toBase58String(aq())))
886
-
        then $Tuple2(0, cx)
887
-
        else {
888
-
            let ge = gb(toString(this), cx, cr)
889
-
            let gf = valueOrElse(getInteger(ay(), ge), 0)
890
-
            $Tuple2(gf, cx)
891
-
            }
892
-
    }
893
-
894
-
895
-
func gg (cr,fP) = {
896
-
    let gh = invoke(au(), "computeFeeDiscount", [cr], nil)
897
-
    if ((gh == gh))
932
+
func gI (ca,gw) = {
933
+
    let gJ = invoke(at(), "computeFeeDiscount", [ca], nil)
934
+
    if ((gJ == gJ))
898
935
 
        then {
899
-
            let gi = {
900
-
                let ct = gh
901
-
                if ($isInstanceOf(ct, "Int"))
936
+
            let gK = {
937
+
                let cc = gJ
938
+
                if ($isInstanceOf(cc, "Int"))
902
939
 
                    then {
903
-
                        let gj = ct
904
-
                        gj
940
+
                        let gL = cc
941
+
                        gL
905
942
 
                        }
906
943
 
                    else throw("Invalid computeFeeDiscount result")
907
944
 
                }
908
-
            let gk = fO(fP, gi)
909
-
            let fW = gk._1
910
-
            let fX = gk._2
911
-
            $Tuple2(fW, fX)
945
+
            let gM = gv(gw, gK)
946
+
            let gD = gM._1
947
+
            let gE = gM._2
948
+
            $Tuple2(gD, gE)
912
949
 
            }
913
950
 
        else throw("Strict value is not equal to itself.")
914
951
 
    }
915
952
 
916
953
 
917
-
func gl (ci) = {
918
-
    let gm = if ((size(ci.payments) > 1))
919
-
        then toBase58String(valueOrErrorMessage(ci.payments[1].assetId, "Invalid artifactId"))
954
+
func gN (bR) = {
955
+
    let gO = if ((size(bR.payments) > 1))
956
+
        then toBase58String(valueOrErrorMessage(bR.payments[1].assetId, "Invalid artifactId"))
920
957
 
        else ""
921
-
    gm
958
+
    gO
922
959
 
    }
923
960
 
924
961
 
925
-
func gn (go) = {
926
-
    let gp = aV(go, cf())
927
-
    let gq = (go - gp)
928
-
    $Tuple2(gp, gq)
962
+
func gP (gQ) = {
963
+
    let gR = aO(gQ, bN())
964
+
    let gS = (gQ - gR)
965
+
    $Tuple2(gR, gS)
929
966
 
    }
930
967
 
931
968
 
932
-
func gr (gs,gt,gu,gv,gw,gx,gy,gz,gA,dZ,gB,gC) = [IntegerEntry(s, gs), IntegerEntry(t, gt), IntegerEntry(u, gu), IntegerEntry(r, gv), IntegerEntry(q, gw), IntegerEntry(w, gx), IntegerEntry(x, gy), IntegerEntry(v, gz), IntegerEntry(y, gA), IntegerEntry(z, dZ), IntegerEntry(A, gB), IntegerEntry(B, gB)]
969
+
func gT (gU,gV,gW,gX,eI,gY,gZ,ha,hb,dX,hc,hd,he) = [IntegerEntry(s, gU), IntegerEntry(t, gV), IntegerEntry(u, gW), IntegerEntry(r, gX), IntegerEntry(p, eI), IntegerEntry(w, gY), IntegerEntry(x, gZ), IntegerEntry(v, ha), IntegerEntry(y, hb), IntegerEntry(z, dX), IntegerEntry(A, hc), IntegerEntry(B, hc), IntegerEntry(q, he)]
933
970
 
934
971
 
935
-
func gD (gE,gF,gG,gH,gI) = [IntegerEntry(J, gE), IntegerEntry(H, gF), IntegerEntry(I, gG), IntegerEntry(K, gH), IntegerEntry(L, gI)]
972
+
func hf (hg,hh,hi,hj,hk) = [IntegerEntry(J, hg), IntegerEntry(H, hh), IntegerEntry(I, hi), IntegerEntry(K, hj), IntegerEntry(L, hk)]
936
973
 
937
974
 
938
-
func gJ (am,aC) = [StringEntry(ak(l, am), aC)]
939
-
940
-
941
-
func gK (gL,am) = if (gL)
975
+
func hl (hm,al) = if (hm)
942
976
 
    then {
943
-
        let gM = ce()
944
-
[IntegerEntry(ak(k, am), (gM + 1)), IntegerEntry(f, (gM + 1))]
977
+
        let hn = bM()
978
+
[IntegerEntry(aj(i, al), (hn + 1)), IntegerEntry(d, (hn + 1))]
945
979
 
        }
946
980
 
    else nil
947
981
 
948
982
 
949
-
func gN (gL,am,gw) = if (gL)
950
-
    then [IntegerEntry(ak(m, am), gw)]
983
+
func ho (hm,al,eI) = if (hm)
984
+
    then [IntegerEntry(aj(k, al), eI)]
951
985
 
    else nil
952
986
 
953
987
 
954
-
func gO (am,gP,gQ,gR,dn) = [IntegerEntry(ak(g, am), gP), IntegerEntry(ak(h, am), gQ), IntegerEntry(ak(i, am), gR), IntegerEntry(ak(j, am), dn)]
988
+
func hp (al,eH,hq,hr,di,hs) = [IntegerEntry(aj(e, al), eH), IntegerEntry(aj(f, al), hq), IntegerEntry(aj(g, al), hr), IntegerEntry(aj(h, al), di), IntegerEntry(aj(l, al), hs)]
955
989
 
956
990
 
957
-
func gS (gT) = {
958
-
    let eX = ((lastBlock.timestamp / 1000) / 60)
959
-
    let gU = valueOrElse(getInteger(this, D), 0)
960
-
    if ((gU > eX))
991
+
func ht (hu) = {
992
+
    let fv = ((bP() / 1000) / 60)
993
+
    let hv = valueOrElse(getInteger(this, D), 0)
994
+
    if ((hv > fv))
961
995
 
        then throw("TWAP out-of-order")
962
996
 
        else {
963
-
            let ff = if ((gU == 0))
964
-
                then eX
965
-
                else gU
966
-
            if ((eX > gU))
997
+
            let fL = if ((hv == 0))
998
+
                then fv
999
+
                else hv
1000
+
            if ((fv > hv))
967
1001
 
                then {
968
-
                    let gV = valueOrElse(getInteger(this, ((E + "_") + toString(gU))), 0)
969
-
                    let gW = valueOrElse(getInteger(this, ((F + "_") + toString(gU))), gT)
970
-
                    let gX = (gV + ((eX - ff) * gW))
971
-
                    let fa = bv(bt(valueOrElse(getString(this, C), "")), aI, toString(eX))
972
-
[IntegerEntry(ak(E, toString(eX)), gX), IntegerEntry(ak(F, toString(eX)), gT), IntegerEntry(ak(G, toString(eX)), gU), IntegerEntry(D, eX), StringEntry(C, be(fa))]
1002
+
                    let hw = valueOrElse(getInteger(this, ((E + "_") + toString(hv))), 0)
1003
+
                    let hx = valueOrElse(getInteger(this, ((F + "_") + toString(hv))), hu)
1004
+
                    let hy = (hw + ((fv - fL) * hx))
1005
+
                    let fy = bb(aZ(valueOrElse(getString(this, C), "")), aC, toString(fv))
1006
+
[IntegerEntry(aj(E, toString(fv)), hy), IntegerEntry(aj(F, toString(fv)), hu), IntegerEntry(aj(G, toString(fv)), hv), IntegerEntry(D, fv), StringEntry(C, aX(fy))]
973
1007
 
                    }
974
1008
 
                else {
975
-
                    let gY = valueOrElse(getInteger(this, ak(G, toString(eX))), 0)
976
-
                    let gV = valueOrElse(getInteger(this, ak(E, toString(gY))), 0)
977
-
                    let gW = valueOrElse(getInteger(this, ak(F, toString(gY))), gT)
978
-
                    let gX = (gV + ((eX - gY) * gW))
979
-
[IntegerEntry(ak(E, toString(eX)), gX), IntegerEntry(ak(F, toString(eX)), gT)]
1009
+
                    let hz = valueOrElse(getInteger(this, aj(G, toString(fv))), 0)
1010
+
                    let hw = valueOrElse(getInteger(this, aj(E, toString(hz))), 0)
1011
+
                    let hx = valueOrElse(getInteger(this, aj(F, toString(hz))), hu)
1012
+
                    let hy = (hw + ((fv - hz) * hx))
1013
+
[IntegerEntry(aj(E, toString(fv)), hy), IntegerEntry(aj(F, toString(fv)), hu)]
980
1014
 
                    }
981
1015
 
            }
982
1016
 
    }
983
1017
 
984
1018
 
985
-
func gZ (cM,cN) = [IntegerEntry(M, cM), IntegerEntry(N, cN)]
1019
+
func hA (cD,cE) = [IntegerEntry(M, cD), IntegerEntry(N, cE)]
986
1020
 
987
1021
 
988
-
func ha (cR,cS) = [IntegerEntry(O, cR), IntegerEntry(P, cS)]
1022
+
func hB (cI,cJ) = [IntegerEntry(O, cI), IntegerEntry(P, cJ)]
989
1023
 
990
1024
 
991
-
func hb (cM,cN,hc,hd,he,hf,hg,hh) = {
992
-
    let cR = bJ()
993
-
    let cS = bK()
994
-
    if (((he - hf) != hc))
995
-
        then throw(((((("Invalid AMM state data: " + toString(he)) + " +  ") + toString(hf)) + " != ") + toString(hc)))
996
-
        else ((gZ(cM, cN) ++ [IntegerEntry(Q, hc), IntegerEntry(T, hd), IntegerEntry(R, he), IntegerEntry(S, hf), IntegerEntry(V, hg), IntegerEntry(U, hh)]) ++ gS(aT(aV(cM, cR), aV(cN, cS))))
1025
+
func hC (cD,cE,hD,hE,hF,hG,hH,hI) = {
1026
+
    let cI = br()
1027
+
    let cJ = bs()
1028
+
    if (((hF - hG) != hD))
1029
+
        then throw(((((("Invalid AMM state data: " + toString(hF)) + " +  ") + toString(hG)) + " != ") + toString(hD)))
1030
+
        else ((hA(cD, cE) ++ [IntegerEntry(Q, hD), IntegerEntry(T, hE), IntegerEntry(R, hF), IntegerEntry(S, hG), IntegerEntry(V, hH), IntegerEntry(U, hI)]) ++ ht(aM(aO(cD, cI), aO(cE, cJ))))
997
1031
 
    }
998
1032
 
999
1033
 
1000
-
func hi (am) = [DeleteEntry(ak(g, am)), DeleteEntry(ak(h, am)), DeleteEntry(ak(i, am)), DeleteEntry(ak(j, am)), DeleteEntry(ak(l, am))]
1034
+
func hJ (al) = [DeleteEntry(aj(e, al)), DeleteEntry(aj(f, al)), DeleteEntry(aj(g, al)), DeleteEntry(aj(h, al)), DeleteEntry(aj(j, al)), DeleteEntry(aj(k, al)), DeleteEntry(aj(l, al))]
1001
1035
 
1002
1036
 
1003
-
func hj (am,hk) = {
1004
-
    let hl = assetBalance(this, aq())
1005
-
    if ((hk > hl))
1006
-
        then throw(((("Unable to withdraw " + toString(hk)) + " from contract balance ") + toString(hl)))
1007
-
        else [ScriptTransfer(am, hk, aq())]
1037
+
func hK (al,hL) = {
1038
+
    let hM = assetBalance(this, ap())
1039
+
    if ((hL > hM))
1040
+
        then throw(((("Unable to withdraw " + toString(hL)) + " from contract balance ") + toString(hM)))
1041
+
        else [ScriptTransfer(al, hL, ap())]
1008
1042
 
    }
1009
1043
 
1010
1044
 
1011
-
func hm (ci) = if ((0 > ci))
1045
+
func hN (bR) = if ((0 > bR))
1012
1046
 
    then throw("Balance")
1013
-
    else [IntegerEntry(e, ci)]
1047
+
    else [IntegerEntry(c, bR)]
1014
1048
 
1015
1049
 
1016
-
func hn (ci) = [ScriptTransfer(as(), ci, aq())]
1050
+
func hO (bR) = [ScriptTransfer(ar(), bR, ap())]
1017
1051
 
1018
1052
 
1019
-
func ho (hp,ci) = if (hp)
1020
-
    then [Burn(valueOrErrorMessage(ci.payments[1].assetId, "Invalid artifact"), 1)]
1053
+
func hP (hQ,bR) = if (hQ)
1054
+
    then [Burn(valueOrErrorMessage(bR.payments[1].assetId, "Invalid artifact"), 1)]
1021
1055
 
    else nil
1022
1056
 
1023
1057
 
1024
-
@Callable(ci)
1025
-
func pause () = if ((ci.caller != ao()))
1058
+
@Callable(bR)
1059
+
func pause () = if ((bR.caller != an()))
1026
1060
 
    then throw("Invalid pause params")
1061
+
    else [BooleanEntry(n, true)]
1062
+
1063
+
1064
+
1065
+
@Callable(bR)
1066
+
func unpause () = if ((bR.caller != an()))
1067
+
    then throw("Invalid unpause params")
1068
+
    else [BooleanEntry(n, false)]
1069
+
1070
+
1071
+
1072
+
@Callable(bR)
1073
+
func setCloseOnly () = if ((bR.caller != an()))
1074
+
    then throw("Invalid setCloseOnly params")
1027
1075
 
    else [BooleanEntry(o, true)]
1028
1076
 
1029
1077
 
1030
1078
 
1031
-
@Callable(ci)
1032
-
func unpause () = if ((ci.caller != ao()))
1033
-
    then throw("Invalid unpause params")
1079
+
@Callable(bR)
1080
+
func unsetCloseOnly () = if ((bR.caller != an()))
1081
+
    then throw("Invalid unsetCloseOnly params")
1034
1082
 
    else [BooleanEntry(o, false)]
1035
1083
 
1036
1084
 
1037
1085
 
1038
-
@Callable(ci)
1039
-
func setCloseOnly () = if ((ci.caller != ao()))
1040
-
    then throw("Invalid setCloseOnly params")
1041
-
    else [BooleanEntry(p, true)]
1042
-
1043
-
1044
-
1045
-
@Callable(ci)
1046
-
func unsetCloseOnly () = if ((ci.caller != ao()))
1047
-
    then throw("Invalid unsetCloseOnly params")
1048
-
    else [BooleanEntry(p, false)]
1049
-
1050
-
1051
-
1052
-
@Callable(ci)
1053
-
func addLiquidity (cH) = if (if ((ci.caller != ao()))
1086
+
@Callable(bR)
1087
+
func addLiquidity (cy) = if (if ((bR.caller != an()))
1054
1088
 
    then true
1055
-
    else (0 >= cH))
1089
+
    else (0 >= cy))
1056
1090
 
    then throw("Invalid addLiquidity params")
1057
1091
 
    else {
1058
-
        let cM = bH()
1059
-
        let cN = bI()
1060
-
        let cR = bJ()
1061
-
        let cS = bK()
1062
-
        let hq = aT(aV(cM, cR), aV(cN, cS))
1063
-
        let hr = (cM + cH)
1064
-
        let hs = (aT(aV(hr, cR), hq) - cN)
1065
-
        let ht = (cN + hs)
1066
-
        let hu = fE(dE(), hr, ht)
1067
-
        let hv = hu._1
1068
-
        let hw = hu._2
1069
-
        let eQ = hu._3
1070
-
        let hx = if ((eQ != 0))
1092
+
        let cD = bp()
1093
+
        let cE = bq()
1094
+
        let cI = br()
1095
+
        let cJ = bs()
1096
+
        let hR = aM(aO(cD, cI), aO(cE, cJ))
1097
+
        let hS = (cD + cy)
1098
+
        let hT = (aM(aO(hS, cI), hR) - cE)
1099
+
        let hU = (cE + hT)
1100
+
        let hV = gk(dE(), hS, hU)
1101
+
        let hW = hV._1
1102
+
        let hX = hV._2
1103
+
        let go = hV._3
1104
+
        let hY = if ((go != 0))
1071
1105
 
            then {
1072
-
                let hx = invoke(at(), "exchangeFreeAndLocked", [eQ], nil)
1073
-
                if ((hx == hx))
1106
+
                let hY = invoke(as(), "exchangeFreeAndLocked", [go], nil)
1107
+
                if ((hY == hY))
1074
1108
 
                    then nil
1075
1109
 
                    else throw("Strict value is not equal to itself.")
1076
1110
 
                }
1077
1111
 
            else nil
1078
-
        if ((hx == hx))
1079
-
            then (gZ(hr, ht) ++ ha(hv, hw))
1112
+
        if ((hY == hY))
1113
+
            then (hA(hS, hU) ++ hB(hW, hX))
1080
1114
 
            else throw("Strict value is not equal to itself.")
1081
1115
 
        }
1082
1116
 
1083
1117
 
1084
1118
 
1085
-
@Callable(ci)
1086
-
func removeLiquidity (cH) = if (if ((ci.caller != ao()))
1119
+
@Callable(bR)
1120
+
func removeLiquidity (cy) = if (if ((bR.caller != an()))
1087
1121
 
    then true
1088
-
    else (cH >= 0))
1122
+
    else (cy >= 0))
1089
1123
 
    then throw("Invalid removeLiquidity params")
1090
1124
 
    else {
1091
-
        let cM = bH()
1092
-
        let cN = bI()
1093
-
        let cR = bJ()
1094
-
        let cS = bK()
1095
-
        let hq = aT(aV(cM, cR), aV(cN, cS))
1096
-
        let hr = (cM - cH)
1097
-
        let hy = bc((aT(aV(hr, cR), hq) - cN))
1098
-
        let ht = (cN - hy)
1099
-
        let hz = fE(dE(), hr, ht)
1100
-
        let hv = hz._1
1101
-
        let hw = hz._2
1102
-
        let eQ = hz._3
1103
-
        let hx = if ((eQ != 0))
1125
+
        let cD = bp()
1126
+
        let cE = bq()
1127
+
        let cI = br()
1128
+
        let cJ = bs()
1129
+
        let hR = aM(aO(cD, cI), aO(cE, cJ))
1130
+
        let hS = (cD - cy)
1131
+
        let hZ = aV((aM(aO(hS, cI), hR) - cE))
1132
+
        let hU = (cE - hZ)
1133
+
        let ia = gk(dE(), hS, hU)
1134
+
        let hW = ia._1
1135
+
        let hX = ia._2
1136
+
        let go = ia._3
1137
+
        let hY = if ((go != 0))
1104
1138
 
            then {
1105
-
                let hx = invoke(at(), "exchangeFreeAndLocked", [eQ], nil)
1106
-
                if ((hx == hx))
1139
+
                let hY = invoke(as(), "exchangeFreeAndLocked", [go], nil)
1140
+
                if ((hY == hY))
1107
1141
 
                    then nil
1108
1142
 
                    else throw("Strict value is not equal to itself.")
1109
1143
 
                }
1110
1144
 
            else nil
1111
-
        if ((hx == hx))
1112
-
            then (gZ(hr, ht) ++ ha(hv, hw))
1145
+
        if ((hY == hY))
1146
+
            then (hA(hS, hU) ++ hB(hW, hX))
1113
1147
 
            else throw("Strict value is not equal to itself.")
1114
1148
 
        }
1115
1149
 
1116
1150
 
1117
1151
 
1118
-
@Callable(ci)
1119
-
func changeSettings (gs,gt,gu,gv,gw,gx,gy,gz,gA,dZ,gB,gC) = if ((ci.caller != ao()))
1152
+
@Callable(bR)
1153
+
func changeSettings (gU,gV,gW,gX,eI,gY,gZ,ha,hb,dX,hc,hd,he) = if ((bR.caller != an()))
1120
1154
 
    then throw("Invalid changeSettings params")
1121
-
    else gr(gs, gt, gu, gv, gw, gx, gy, gz, gA, dZ, gB, gC)
1155
+
    else gT(gU, gV, gW, gX, eI, gY, gZ, ha, hb, dX, hc, hd, he)
1122
1156
 
1123
1157
 
1124
1158
 
1125
-
@Callable(ci)
1126
-
func initialize (cM,cN,gv,gs,gt,gu,gw,hA,hB,hC,hD,gx,gy,gz,gA,dZ,gB,gC) = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if ((0 >= cM))
1159
+
@Callable(bR)
1160
+
func initialize (cD,cE,gX,gU,gV,gW,eI,ib,ic,id,gY,gZ,ha,hb,dX,hc,hd,he) = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if ((0 >= cD))
1127
1161
 
    then true
1128
-
    else (0 >= cN))
1162
+
    else (0 >= cE))
1129
1163
 
    then true
1130
-
    else (0 >= gv))
1164
+
    else (0 >= gX))
1131
1165
 
    then true
1132
-
    else (0 >= gs))
1166
+
    else (0 >= gU))
1133
1167
 
    then true
1134
-
    else (0 >= gt))
1168
+
    else (0 >= gV))
1135
1169
 
    then true
1136
-
    else (0 >= gu))
1170
+
    else (0 >= gW))
1137
1171
 
    then true
1138
-
    else (0 >= gw))
1172
+
    else (0 >= eI))
1139
1173
 
    then true
1140
-
    else (0 >= gx))
1174
+
    else (0 >= gY))
1141
1175
 
    then true
1142
-
    else (0 >= gy))
1176
+
    else (0 >= gZ))
1143
1177
 
    then true
1144
-
    else (0 >= gz))
1178
+
    else (0 >= ha))
1145
1179
 
    then true
1146
-
    else (0 >= gA))
1180
+
    else (0 >= hb))
1147
1181
 
    then true
1148
-
    else (0 >= dZ))
1182
+
    else (0 >= dX))
1149
1183
 
    then true
1150
-
    else (0 >= gB))
1184
+
    else (0 >= hc))
1151
1185
 
    then true
1152
-
    else (gB > aM))
1186
+
    else (hc > aF))
1153
1187
 
    then true
1154
-
    else (0 >= gC))
1188
+
    else (0 >= hd))
1155
1189
 
    then true
1156
-
    else cC())
1190
+
    else (0 >= he))
1191
+
    then true
1192
+
    else ct())
1157
1193
 
    then throw("Invalid initialize parameters")
1158
-
    else ((((hb(cM, cN, 0, 0, 0, 0, 0, 0) ++ gr(gs, gt, gu, gv, gw, gx, gy, gz, gA, dZ, gB, gC)) ++ gD((lastBlock.timestamp + gv), 0, 0, 0, 0)) ++ hm(0)) ++ [BooleanEntry(n, true), StringEntry(d, hA), StringEntry(a, hB), StringEntry(b, hC), StringEntry(W, hD)])
1194
+
    else ((((hC(cD, cE, 0, 0, 0, 0, 0, 0) ++ gT(gU, gV, gW, gX, eI, gY, gZ, ha, hb, dX, hc, hd, he)) ++ hf((bP() + gX), 0, 0, 0, 0)) ++ hN(0)) ++ [BooleanEntry(m, true), StringEntry(a, ib), StringEntry(b, ic), StringEntry(X, id)])
1159
1195
 
1160
1196
 
1161
1197
 
1162
-
@Callable(ci)
1163
-
func increasePosition (hE,hF,hG,hH) = {
1164
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1165
-
    if ((hI == hI))
1198
+
@Callable(bR)
1199
+
func increasePosition (ie,if,ig,ih) = {
1200
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1201
+
    if ((ii == ii))
1166
1202
 
        then {
1167
-
            let cr = ch(ci)
1168
-
            let hJ = ci.payments[0].amount
1169
-
            let aC = ci.payments[0].assetId
1170
-
            let hK = toBase58String(value(aC))
1171
-
            let hL = (aC == aq())
1172
-
            let hM = aB(hK)
1173
-
            if (if (if (if (if (if (if (if (if (if ((hE != aG))
1174
-
                then (hE != aH)
1175
-
                else false)
1176
-
                then true
1177
-
                else (0 >= hJ))
1178
-
                then true
1179
-
                else !(cC()))
1180
-
                then true
1181
-
                else if (!(hL))
1182
-
                    then !(hM)
1183
-
                    else false)
1184
-
                then true
1185
-
                else !(fY(cr, hK)))
1186
-
                then true
1187
-
                else !(cj(aT(aM, hF), bG(), true)))
1188
-
                then true
1189
-
                else cD())
1190
-
                then true
1191
-
                else cE())
1192
-
                then true
1193
-
                else dL())
1194
-
                then throw("Invalid increasePosition parameters")
1195
-
                else {
1196
-
                    let hN = gg(cr, gl(ci))
1197
-
                    let fW = hN._1
1198
-
                    let fX = hN._2
1199
-
                    let hk = aT(hJ, (aV(fW, hF) + aM))
1200
-
                    let hO = (hJ - hk)
1201
-
                    let hP = if (hM)
1202
-
                        then {
1203
-
                            let hQ = invoke(ay(), "borrow", [cr], [AttachedPayment(aC, hk)])
1204
-
                            if ((hQ == hQ))
1203
+
            let ij = invoke(this, "ensureCalledOnce", nil, nil)
1204
+
            if ((ij == ij))
1205
+
                then {
1206
+
                    let ca = bQ(bR)
1207
+
                    let ik = bR.payments[0].amount
1208
+
                    let gG = bR.payments[0].assetId
1209
+
                    let il = toBase58String(value(gG))
1210
+
                    let im = (gG == ap())
1211
+
                    if (if (if (if (if (if (if (if (if (if ((ie != aA))
1212
+
                        then (ie != aB)
1213
+
                        else false)
1214
+
                        then true
1215
+
                        else (0 >= ik))
1216
+
                        then true
1217
+
                        else !(ct()))
1218
+
                        then true
1219
+
                        else !(im))
1220
+
                        then true
1221
+
                        else !(gF(ca, il)))
1222
+
                        then true
1223
+
                        else !(bS(aM(aF, if), bo(), true)))
1224
+
                        then true
1225
+
                        else cu())
1226
+
                        then true
1227
+
                        else cv())
1228
+
                        then true
1229
+
                        else dK())
1230
+
                        then throw("Invalid increasePosition parameters")
1231
+
                        else {
1232
+
                            let in = gI(ca, gN(bR))
1233
+
                            let gD = in._1
1234
+
                            let gE = in._2
1235
+
                            let hL = aM(ik, (aO(gD, if) + aF))
1236
+
                            let io = (ik - hL)
1237
+
                            let ip = invoke(av(), "acceptPaymentWithLink", [ca, ih], [AttachedPayment(ap(), io)])
1238
+
                            if ((ip == ip))
1205
1239
 
                                then {
1206
-
                                    let hR = assetBalance(this, aq())
1207
-
                                    if ((hR == hR))
1240
+
                                    let iq = {
1241
+
                                        let cc = ip
1242
+
                                        if ($isInstanceOf(cc, "Int"))
1243
+
                                            then {
1244
+
                                                let gL = cc
1245
+
                                                gL
1246
+
                                                }
1247
+
                                            else throw("Invalid referrerFee")
1248
+
                                        }
1249
+
                                    let ir = (io - iq)
1250
+
                                    let is = bZ(ca)
1251
+
                                    let eM = is._1
1252
+
                                    let eN = is._2
1253
+
                                    let eO = is._3
1254
+
                                    let eP = is._4
1255
+
                                    let eQ = is._5
1256
+
                                    let it = (eM == 0)
1257
+
                                    let iu = if ((eM > 0))
1258
+
                                        then (ie == aA)
1259
+
                                        else (ie == aB)
1260
+
                                    let iv = if (!(it))
1261
+
                                        then iu
1262
+
                                        else false
1263
+
                                    let iw = (ie == aA)
1264
+
                                    let ix = if (if (it)
1265
+
                                        then true
1266
+
                                        else iv)
1208
1267
 
                                        then {
1209
-
                                            let hS = invoke(az(), "swap", [toBase58String(aq()), 0], [AttachedPayment(aC, hO)])
1210
-
                                            if ((hS == hS))
1268
+
                                            let iy = aO(hL, if)
1269
+
                                            let iz = cH(iw, iy)
1270
+
                                            let cO = iz._1
1271
+
                                            let cL = iz._2
1272
+
                                            let cM = iz._3
1273
+
                                            let eW = iz._4
1274
+
                                            if (if ((ig != 0))
1275
+
                                                then (ig > aV(cO))
1276
+
                                                else false)
1277
+
                                                then throw(((("Limit error: " + toString(aV(cO))) + " < ") + toString(ig)))
1278
+
                                                else {
1279
+
                                                    let fk = (eM + cO)
1280
+
                                                    let iA = (bw() + (if ((fk > 0))
1281
+
                                                        then iy
1282
+
                                                        else 0))
1283
+
                                                    let iB = (bv() + (if ((0 > fk))
1284
+
                                                        then iy
1285
+
                                                        else 0))
1286
+
                                                    let iC = dd(eM, eN, eP, eQ, hL)
1287
+
                                                    let dl = iC._1
1288
+
                                                    let fe = iC._2
1289
+
                                                    let ff = iC._3
1290
+
                                                    let dc = iC._4
1291
+
                                                    if (!(dQ(cL, cM)))
1292
+
                                                        then throw("Over max spread limit")
1293
+
                                                        else if (!(dU(iA, iB)))
1294
+
                                                            then throw("Over max open notional")
1295
+
                                                            else $Tuple14(fk, dl, (eO + iy), bX(fk), bP(), cM, cL, eW, (bu() + iy), (bL() + (if ((fk > 0))
1296
+
                                                                then aV(cO)
1297
+
                                                                else 0)), (bK() + (if ((0 > fk))
1298
+
                                                                then aV(cO)
1299
+
                                                                else 0)), iA, iB, dc)
1300
+
                                                    }
1301
+
                                            }
1302
+
                                        else {
1303
+
                                            let iy = aO(hL, if)
1304
+
                                            let iD = ek(toString(bR.caller), aI)
1305
+
                                            let eZ = iD._1
1306
+
                                            let ej = iD._2
1307
+
                                            if ((eZ > iy))
1308
+
                                                then throw("Use decreasePosition to decrease position size")
1309
+
                                                else throw("Close position first")
1310
+
                                            }
1311
+
                                    let fk = ix._1
1312
+
                                    let iE = ix._2
1313
+
                                    let fm = ix._3
1314
+
                                    let iF = ix._4
1315
+
                                    let iG = ix._5
1316
+
                                    let cM = ix._6
1317
+
                                    let cL = ix._7
1318
+
                                    let eW = ix._8
1319
+
                                    let iH = ix._9
1320
+
                                    let iI = ix._10
1321
+
                                    let iJ = ix._11
1322
+
                                    let iA = ix._12
1323
+
                                    let iB = ix._13
1324
+
                                    let dc = ix._14
1325
+
                                    let iK = gP((ir + dc))
1326
+
                                    let gR = iK._1
1327
+
                                    let gS = iK._2
1328
+
                                    let iL = if ((hL >= dc))
1329
+
                                        then invoke(as(), "addLocked", nil, [AttachedPayment(ap(), (hL - dc))])
1330
+
                                        else invoke(as(), "withdrawLocked", [(dc - hL)], nil)
1331
+
                                    if ((iL == iL))
1332
+
                                        then {
1333
+
                                            let iM = invoke(as(), "addFree", nil, [AttachedPayment(ap(), gS)])
1334
+
                                            if ((iM == iM))
1211
1335
 
                                                then {
1212
-
                                                    let hT = assetBalance(this, aq())
1213
-
                                                    if ((hT == hT))
1336
+
                                                    let iN = invoke(at(), "notifyFees", [ca, ir], nil)
1337
+
                                                    if ((iN == iN))
1214
1338
 
                                                        then {
1215
-
                                                            let hU = (hT - hR)
1216
-
                                                            if ((hU == hU))
1217
-
                                                                then hU
1339
+
                                                            let iO = invoke(at(), "notifyNotional", [ca, fm], nil)
1340
+
                                                            if ((iO == iO))
1341
+
                                                                then ((((((hp(ca, fk, iE, fm, iF, iG) ++ hl(it, ca)) ++ ho(it, ca, gD)) ++ hC(cL, cM, eW, iH, iI, iJ, iA, iB)) ++ hO(gR)) ++ hN(((bl() + hL) - dc))) ++ hP(gE, bR))
1218
1342
 
                                                                else throw("Strict value is not equal to itself.")
1219
1343
 
                                                            }
1220
1344
 
                                                        else throw("Strict value is not equal to itself.")
1221
1345
 
                                                    }
1222
1346
 
                                                else throw("Strict value is not equal to itself.")
1223
1347
 
                                            }
1224
1348
 
                                        else throw("Strict value is not equal to itself.")
1225
1349
 
                                    }
1226
1350
 
                                else throw("Strict value is not equal to itself.")
1227
1351
 
                            }
1228
-
                        else hO
1229
-
                    if ((hP == hP))
1230
-
                        then {
1231
-
                            let hV = invoke(aw(), "acceptPaymentWithLink", [cr, hH], [AttachedPayment(aq(), hP)])
1232
-
                            if ((hV == hV))
1352
+
                    }
1353
+
                else throw("Strict value is not equal to itself.")
1354
+
            }
1355
+
        else throw("Strict value is not equal to itself.")
1356
+
    }
1357
+
1358
+
1359
+
1360
+
@Callable(bR)
1361
+
func addMargin () = {
1362
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1363
+
    if ((ii == ii))
1364
+
        then {
1365
+
            let ij = invoke(this, "ensureCalledOnce", nil, nil)
1366
+
            if ((ij == ij))
1367
+
                then {
1368
+
                    let ca = toString(bR.caller)
1369
+
                    let hL = bR.payments[0].amount
1370
+
                    let gG = bR.payments[0].assetId
1371
+
                    let il = toBase58String(value(gG))
1372
+
                    let im = (gG == ap())
1373
+
                    if (if (if (if (if (if (if (!(im))
1374
+
                        then true
1375
+
                        else !(ck(toString(bR.caller))))
1376
+
                        then true
1377
+
                        else !(gH(ca, il)))
1378
+
                        then true
1379
+
                        else !(ct()))
1380
+
                        then true
1381
+
                        else cu())
1382
+
                        then true
1383
+
                        else cv())
1384
+
                        then true
1385
+
                        else dK())
1386
+
                        then throw("Invalid addMargin parameters")
1387
+
                        else {
1388
+
                            let iP = bZ(ca)
1389
+
                            let eM = iP._1
1390
+
                            let eN = iP._2
1391
+
                            let eO = iP._3
1392
+
                            let eP = iP._4
1393
+
                            let eQ = iP._5
1394
+
                            let iL = invoke(as(), "addLocked", nil, [AttachedPayment(ap(), hL)])
1395
+
                            if ((iL == iL))
1233
1396
 
                                then {
1234
-
                                    let hW = {
1235
-
                                        let ct = hV
1236
-
                                        if ($isInstanceOf(ct, "Int"))
1237
-
                                            then {
1238
-
                                                let gj = ct
1239
-
                                                gj
1240
-
                                                }
1241
-
                                            else throw("Invalid referrerFee")
1242
-
                                        }
1243
-
                                    let hX = (hP - hW)
1244
-
                                    let hY = cq(cr)
1245
-
                                    let fZ = hY._1
1246
-
                                    let hZ = hY._2
1247
-
                                    let ia = hY._3
1248
-
                                    let ib = hY._4
1249
-
                                    let ic = (fZ == 0)
1250
-
                                    let id = if ((fZ > 0))
1251
-
                                        then (hE == aG)
1252
-
                                        else (hE == aH)
1253
-
                                    let ie = if (!(ic))
1254
-
                                        then id
1255
-
                                        else false
1256
-
                                    let if = (hE == aG)
1257
-
                                    let ig = if (if (ic)
1258
-
                                        then true
1259
-
                                        else ie)
1397
+
                                    let dc = cY(eN, eQ)
1398
+
                                    let iQ = if ((dc > 0))
1260
1399
 
                                        then {
1261
-
                                            let ih = aV(hk, hF)
1262
-
                                            let ii = cQ(if, ih)
1263
-
                                            let cX = ii._1
1264
-
                                            let cU = ii._2
1265
-
                                            let cV = ii._3
1266
-
                                            let eS = ii._4
1267
-
                                            if (if ((hG != 0))
1268
-
                                                then (hG > bc(cX))
1269
-
                                                else false)
1270
-
                                                then throw(((("Limit error: " + toString(bc(cX))) + " < ") + toString(hG)))
1271
-
                                                else {
1272
-
                                                    let ij = (fZ + cX)
1273
-
                                                    let ik = (bO() + (if ((ij > 0))
1274
-
                                                        then ih
1275
-
                                                        else 0))
1276
-
                                                    let il = (bN() + (if ((0 > ij))
1277
-
                                                        then ih
1278
-
                                                        else 0))
1279
-
                                                    let im = dh(fZ, hZ, ib, hk)
1280
-
                                                    let dq = im._1
1281
-
                                                    let ek = im._2
1282
-
                                                    let el = im._3
1283
-
                                                    if (!(dS(cU, cV)))
1284
-
                                                        then throw("Over max spread limit")
1285
-
                                                        else if (!(dW(ik, il)))
1286
-
                                                            then throw("Over max open notional")
1287
-
                                                            else $Tuple12(ij, dq, (ia + ih), co(ij), cV, cU, eS, (bM() + ih), (cd() + (if ((ij > 0))
1288
-
                                                                then bc(cX)
1289
-
                                                                else 0)), (cc() + (if ((0 > ij))
1290
-
                                                                then bc(cX)
1291
-
                                                                else 0)), ik, il)
1400
+
                                            let iR = gP(dc)
1401
+
                                            let gR = iR._1
1402
+
                                            let gS = iR._2
1403
+
                                            let iS = invoke(as(), "withdrawLocked", [gR], nil)
1404
+
                                            if ((iS == iS))
1405
+
                                                then {
1406
+
                                                    let iT = invoke(as(), "exchangeFreeAndLocked", [-(gS)], nil)
1407
+
                                                    if ((iT == iT))
1408
+
                                                        then hO(gR)
1409
+
                                                        else throw("Strict value is not equal to itself.")
1292
1410
 
                                                    }
1293
-
                                            }
1294
-
                                        else {
1295
-
                                            let ih = aV(hk, hF)
1296
-
                                            let in = eq(toString(ci.caller), aP)
1297
-
                                            let io = in._1
1298
-
                                            let ep = in._2
1299
-
                                            if ((io > ih))
1300
-
                                                then throw("Use decreasePosition to decrease position size")
1301
-
                                                else throw("Close position first")
1302
-
                                            }
1303
-
                                    let ij = ig._1
1304
-
                                    let ip = ig._2
1305
-
                                    let iq = ig._3
1306
-
                                    let ir = ig._4
1307
-
                                    let cV = ig._5
1308
-
                                    let cU = ig._6
1309
-
                                    let eS = ig._7
1310
-
                                    let eV = ig._8
1311
-
                                    let eT = ig._9
1312
-
                                    let eU = ig._10
1313
-
                                    let ik = ig._11
1314
-
                                    let il = ig._12
1315
-
                                    let is = gn(hX)
1316
-
                                    let gp = is._1
1317
-
                                    let gq = is._2
1318
-
                                    let it = if (hL)
1319
-
                                        then {
1320
-
                                            let it = invoke(at(), "addLocked", [false], [AttachedPayment(aq(), hk)])
1321
-
                                            if ((it == it))
1322
-
                                                then nil
1323
1411
 
                                                else throw("Strict value is not equal to itself.")
1324
1412
 
                                            }
1325
1413
 
                                        else nil
1326
-
                                    if ((it == it))
1327
-
                                        then {
1328
-
                                            let iu = invoke(at(), "addFree", nil, [AttachedPayment(aq(), gq)])
1329
-
                                            if ((iu == iu))
1414
+
                                    if ((iQ == iQ))
1415
+
                                        then ((hp(ca, eM, ((eN - dc) + hL), eO, eP, bP()) ++ hN(((bl() + hL) - dc))) ++ iQ)
1416
+
                                        else throw("Strict value is not equal to itself.")
1417
+
                                    }
1418
+
                                else throw("Strict value is not equal to itself.")
1419
+
                            }
1420
+
                    }
1421
+
                else throw("Strict value is not equal to itself.")
1422
+
            }
1423
+
        else throw("Strict value is not equal to itself.")
1424
+
    }
1425
+
1426
+
1427
+
1428
+
@Callable(bR)
1429
+
func removeMargin (hL) = {
1430
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1431
+
    if ((ii == ii))
1432
+
        then {
1433
+
            let ij = invoke(this, "ensureCalledOnce", nil, nil)
1434
+
            if ((ij == ij))
1435
+
                then {
1436
+
                    let ca = toString(bR.caller)
1437
+
                    if (if (if (if (if ((0 >= hL))
1438
+
                        then true
1439
+
                        else !(ck(ca)))
1440
+
                        then true
1441
+
                        else !(ct()))
1442
+
                        then true
1443
+
                        else cu())
1444
+
                        then true
1445
+
                        else dK())
1446
+
                        then throw("Invalid removeMargin parameters")
1447
+
                        else {
1448
+
                            let iU = bZ(ca)
1449
+
                            let eM = iU._1
1450
+
                            let eN = iU._2
1451
+
                            let eO = iU._3
1452
+
                            let eP = iU._4
1453
+
                            let eQ = iU._5
1454
+
                            let iV = dd(eM, eN, eP, eQ, -(hL))
1455
+
                            let dl = iV._1
1456
+
                            let dm = iV._2
1457
+
                            let dh = iV._3
1458
+
                            let dc = iV._4
1459
+
                            if ((dm != 0))
1460
+
                                then throw("Invalid removed margin amount")
1461
+
                                else {
1462
+
                                    let fp = ep(dl, dm, eO)
1463
+
                                    if (!(bS(fp, bo(), true)))
1464
+
                                        then throw(((("Too much margin removed: " + toString(fp)) + " < ") + toString(bo())))
1465
+
                                        else {
1466
+
                                            let iW = gP(dc)
1467
+
                                            let gR = iW._1
1468
+
                                            let gS = iW._2
1469
+
                                            let iQ = if ((dc > 0))
1330
1470
 
                                                then {
1331
-
                                                    let iv = invoke(au(), "notifyFees", [cr, hX], nil)
1332
-
                                                    if ((iv == iv))
1333
-
                                                        then {
1334
-
                                                            let iw = invoke(au(), "notifyNotional", [cr, iq], nil)
1335
-
                                                            if ((iw == iw))
1336
-
                                                                then (((((((gO(cr, ij, ip, iq, ir) ++ gK(ic, cr)) ++ gN(ic, cr, fW)) ++ gJ(cr, hK)) ++ hb(cU, cV, eS, eV, eT, eU, ik, il)) ++ hn(gp)) ++ hm((bE() + hk))) ++ ho(fX, ci))
1337
-
                                                                else throw("Strict value is not equal to itself.")
1338
-
                                                            }
1471
+
                                                    let iT = invoke(as(), "exchangeFreeAndLocked", [-(gS)], nil)
1472
+
                                                    if ((iT == iT))
1473
+
                                                        then hO(gR)
1339
1474
 
                                                        else throw("Strict value is not equal to itself.")
1340
1475
 
                                                    }
1476
+
                                                else nil
1477
+
                                            if ((iQ == iQ))
1478
+
                                                then {
1479
+
                                                    let iS = invoke(as(), "withdrawLocked", [(hL + gR)], nil)
1480
+
                                                    if ((iS == iS))
1481
+
                                                        then (((hp(ca, eM, dl, eO, bX(eM), bP()) ++ hK(bR.caller, hL)) ++ hN(((bl() - hL) - dc))) ++ iQ)
1482
+
                                                        else throw("Strict value is not equal to itself.")
1483
+
                                                    }
1484
+
                                                else throw("Strict value is not equal to itself.")
1485
+
                                            }
1486
+
                                    }
1487
+
                            }
1488
+
                    }
1489
+
                else throw("Strict value is not equal to itself.")
1490
+
            }
1491
+
        else throw("Strict value is not equal to itself.")
1492
+
    }
1493
+
1494
+
1495
+
1496
+
@Callable(bR)
1497
+
func closePosition (eH,eJ,eK) = {
1498
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1499
+
    if ((ii == ii))
1500
+
        then {
1501
+
            let ij = invoke(this, "ensureCalledOnce", nil, nil)
1502
+
            if ((ij == ij))
1503
+
                then {
1504
+
                    let ca = bQ(bR)
1505
+
                    let iX = valueOrErrorMessage(addressFromString(ca), "Invalid caller")
1506
+
                    let cj = ch(ca)
1507
+
                    if (if (if (if (if (if (!(ck(ca)))
1508
+
                        then true
1509
+
                        else !(ct()))
1510
+
                        then true
1511
+
                        else cu())
1512
+
                        then true
1513
+
                        else (0 >= eH))
1514
+
                        then true
1515
+
                        else (0 > eJ))
1516
+
                        then true
1517
+
                        else dK())
1518
+
                        then throw("Invalid closePosition parameters")
1519
+
                        else {
1520
+
                            let eQ = bZ(ca)._5
1521
+
                            let iY = eG(ca, eH, cj, eJ, eK, true)
1522
+
                            let fk = iY._1
1523
+
                            let ft = iY._2
1524
+
                            let fm = iY._3
1525
+
                            let fn = iY._4
1526
+
                            let fg = iY._5
1527
+
                            let fb = iY._6
1528
+
                            let fs = iY._7
1529
+
                            let cL = iY._8
1530
+
                            let cM = iY._9
1531
+
                            let eW = iY._10
1532
+
                            let iH = iY._11
1533
+
                            let iI = iY._12
1534
+
                            let iJ = iY._13
1535
+
                            let iA = iY._14
1536
+
                            let iB = iY._15
1537
+
                            let iZ = iY._16
1538
+
                            if ((fg > 0))
1539
+
                                then throw("Invalid closePosition parameters: bad debt")
1540
+
                                else if ((eQ >= bP()))
1541
+
                                    then throw("Invalid closePosition parameters: wait at least 1 block before closing the position")
1542
+
                                    else {
1543
+
                                        let eT = (fk != 0)
1544
+
                                        let ja = (fs + iZ)
1545
+
                                        let jb = (bl() - ja)
1546
+
                                        let jc = if ((0 > jb))
1547
+
                                            then 0
1548
+
                                            else jb
1549
+
                                        let iS = invoke(as(), "withdrawLocked", [ja], nil)
1550
+
                                        if ((iS == iS))
1551
+
                                            then {
1552
+
                                                let jd = gP(iZ)
1553
+
                                                let gR = jd._1
1554
+
                                                let gS = jd._2
1555
+
                                                let iM = invoke(as(), "addFree", nil, [AttachedPayment(ap(), gS)])
1556
+
                                                if ((iM == iM))
1557
+
                                                    then {
1558
+
                                                        let iN = invoke(at(), "notifyFees", [ca, iZ], nil)
1559
+
                                                        if ((iN == iN))
1560
+
                                                            then {
1561
+
                                                                let iO = invoke(at(), "notifyNotional", [ca, fm], nil)
1562
+
                                                                if ((iO == iO))
1563
+
                                                                    then (((((if (eT)
1564
+
                                                                        then hp(ca, fk, ft, fm, fn, bP())
1565
+
                                                                        else hJ(ca)) ++ hC(cL, cM, eW, iH, iI, iJ, iA, iB)) ++ (if ((fs > 0))
1566
+
                                                                        then hK(iX, fs)
1567
+
                                                                        else nil)) ++ hN(jc)) ++ hO(gR))
1568
+
                                                                    else throw("Strict value is not equal to itself.")
1569
+
                                                                }
1570
+
                                                            else throw("Strict value is not equal to itself.")
1571
+
                                                        }
1572
+
                                                    else throw("Strict value is not equal to itself.")
1573
+
                                                }
1574
+
                                            else throw("Strict value is not equal to itself.")
1575
+
                                        }
1576
+
                            }
1577
+
                    }
1578
+
                else throw("Strict value is not equal to itself.")
1579
+
            }
1580
+
        else throw("Strict value is not equal to itself.")
1581
+
    }
1582
+
1583
+
1584
+
1585
+
@Callable(bR)
1586
+
func liquidate (ca) = {
1587
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1588
+
    if ((ii == ii))
1589
+
        then {
1590
+
            let je = et(ca, aI)
1591
+
            let jf = if (dZ())
1592
+
                then {
1593
+
                    let jg = et(ca, aJ)
1594
+
                    aW(je, jg)
1595
+
                    }
1596
+
                else je
1597
+
            if (if (if (if (if (!(bS(jf, bB(), false)))
1598
+
                then true
1599
+
                else !(ck(ca)))
1600
+
                then true
1601
+
                else !(ct()))
1602
+
                then true
1603
+
                else cu())
1604
+
                then true
1605
+
                else dK())
1606
+
                then throw("Unable to liquidate")
1607
+
                else {
1608
+
                    let jh = if (if ((je > bC()))
1609
+
                        then true
1610
+
                        else (bD() > 0))
1611
+
                        then true
1612
+
                        else (aF > bD())
1613
+
                    let eM = bZ(ca)._1
1614
+
                    let ed = aV(eM)
1615
+
                    let ji = if (jh)
1616
+
                        then {
1617
+
                            let jj = eB(ca, eM)
1618
+
                            let jk = aM(aV(jj), ed)
1619
+
                            $Tuple2(jk, aV(jj))
1620
+
                            }
1621
+
                        else $Tuple2(0, ed)
1622
+
                    let jk = ji._1
1623
+
                    let jj = ji._2
1624
+
                    let jl = eG(ca, if (jh)
1625
+
                        then jj
1626
+
                        else ed, bC(), 0, true, false)
1627
+
                    let fk = jl._1
1628
+
                    let ft = jl._2
1629
+
                    let fm = jl._3
1630
+
                    let fn = jl._4
1631
+
                    let fg = jl._5
1632
+
                    let fb = jl._6
1633
+
                    let fs = jl._7
1634
+
                    let cL = jl._8
1635
+
                    let cM = jl._9
1636
+
                    let eW = jl._10
1637
+
                    let iH = jl._11
1638
+
                    let iI = jl._12
1639
+
                    let iJ = jl._13
1640
+
                    let iA = jl._14
1641
+
                    let iB = jl._15
1642
+
                    let jm = jl._16
1643
+
                    let jn = (jm / 2)
1644
+
                    let gS = (jm - jn)
1645
+
                    let jb = (bl() - jm)
1646
+
                    let jo = if ((0 > jb))
1647
+
                        then 0
1648
+
                        else jb
1649
+
                    let iT = if ((fg > 0))
1650
+
                        then {
1651
+
                            let iT = invoke(as(), "exchangeFreeAndLocked", [fg], nil)
1652
+
                            if ((iT == iT))
1653
+
                                then nil
1654
+
                                else throw("Strict value is not equal to itself.")
1655
+
                            }
1656
+
                        else nil
1657
+
                    if ((iT == iT))
1658
+
                        then {
1659
+
                            let iS = invoke(as(), "withdrawLocked", [jm], nil)
1660
+
                            if ((iS == iS))
1661
+
                                then {
1662
+
                                    let jp = invoke(as(), "addFree", nil, [AttachedPayment(ap(), gS)])
1663
+
                                    if ((jp == jp))
1664
+
                                        then {
1665
+
                                            let iO = invoke(at(), "notifyNotional", [ca, fm], nil)
1666
+
                                            if ((iO == iO))
1667
+
                                                then ((((if (jh)
1668
+
                                                    then hp(ca, fk, ft, fm, fn, bP())
1669
+
                                                    else hJ(ca)) ++ hC(cL, cM, eW, iH, iI, iJ, iA, iB)) ++ hK(bR.caller, jn)) ++ hN(jo))
1341
1670
 
                                                else throw("Strict value is not equal to itself.")
1342
1671
 
                                            }
1343
1672
 
                                        else throw("Strict value is not equal to itself.")
1344
1673
 
                                    }
1345
1674
 
                                else throw("Strict value is not equal to itself.")
1346
1675
 
                            }
1347
1676
 
                        else throw("Strict value is not equal to itself.")
1348
1677
 
                    }
1349
1678
 
            }
1350
1679
 
        else throw("Strict value is not equal to itself.")
1351
1680
 
    }
1352
1681
 
1353
1682
 
1354
1683
 
1355
-
@Callable(ci)
1356
-
func addMargin () = {
1357
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1358
-
    if ((hI == hI))
1684
+
@Callable(bR)
1685
+
func payFunding () = {
1686
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1687
+
    if ((ii == ii))
1359
1688
 
        then {
1360
-
            let cr = toString(ci.caller)
1361
-
            let hk = ci.payments[0].amount
1362
-
            let aC = ci.payments[0].assetId
1363
-
            let hK = toBase58String(value(aC))
1364
-
            let hL = (aC == aq())
1365
-
            let hM = aB(hK)
1366
-
            if (if (if (if (if (if (if (if (!(hL))
1367
-
                then !(hM)
1368
-
                else false)
1689
+
            let jq = bx()
1690
+
            if (if (if ((jq > bP()))
1369
1691
 
                then true
1370
-
                else !(cB(toString(ci.caller))))
1692
+
                else !(ct()))
1371
1693
 
                then true
1372
-
                else !(ga(cr, hK)))
1373
-
                then true
1374
-
                else !(cC()))
1375
-
                then true
1376
-
                else cD())
1377
-
                then true
1378
-
                else cE())
1379
-
                then true
1380
-
                else dL())
1381
-
                then throw("Invalid addMargin parameters")
1694
+
                else cu())
1695
+
                then throw(((("Invalid funding block timestamp: " + toString(bP())) + " < ") + toString(jq)))
1382
1696
 
                else {
1383
-
                    let ix = cq(cr)
1384
-
                    let fZ = ix._1
1385
-
                    let hZ = ix._2
1386
-
                    let ia = ix._3
1387
-
                    let ib = ix._4
1388
-
                    let it = if (hL)
1389
-
                        then {
1390
-
                            let it = invoke(at(), "addLocked", [false], [AttachedPayment(aq(), hk)])
1391
-
                            if ((it == it))
1392
-
                                then nil
1393
-
                                else throw("Strict value is not equal to itself.")
1394
-
                            }
1395
-
                        else nil
1396
-
                    if ((it == it))
1397
-
                        then (gO(cr, fZ, (hZ + hk), ia, ib) ++ hm((bE() + hk)))
1398
-
                        else throw("Strict value is not equal to itself.")
1697
+
                    let gq = dE()
1698
+
                    let jr = gp()
1699
+
                    let gt = jr._1
1700
+
                    let gu = jr._2
1701
+
                    hf((jq + bA()), (bI() + gu), (bJ() + gt), aM(gu, gq), aM(gt, gq))
1399
1702
 
                    }
1400
1703
 
            }
1401
1704
 
        else throw("Strict value is not equal to itself.")
1402
1705
 
    }
1403
1706
 
1404
1707
 
1405
1708
 
1406
-
@Callable(ci)
1407
-
func removeMargin (hk) = {
1408
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1409
-
    if ((hI == hI))
1709
+
@Callable(bR)
1710
+
func syncTerminalPriceToOracle () = {
1711
+
    let cD = bp()
1712
+
    let cE = bq()
1713
+
    let js = gk(dE(), cD, cE)
1714
+
    let hW = js._1
1715
+
    let hX = js._2
1716
+
    let go = js._3
1717
+
    let hY = if ((go != 0))
1410
1718
 
        then {
1411
-
            let cr = toString(ci.caller)
1412
-
            if (if (if (if (if ((0 >= hk))
1413
-
                then true
1414
-
                else !(cB(cr)))
1415
-
                then true
1416
-
                else !(cC()))
1417
-
                then true
1418
-
                else cD())
1419
-
                then true
1420
-
                else dL())
1421
-
                then throw("Invalid removeMargin parameters")
1422
-
                else {
1423
-
                    let iy = cq(cr)
1424
-
                    let fZ = iy._1
1425
-
                    let hZ = iy._2
1426
-
                    let ia = iy._3
1427
-
                    let ib = iy._4
1428
-
                    let iz = -(hk)
1429
-
                    let iA = dh(fZ, hZ, ib, iz)
1430
-
                    let dq = iA._1
1431
-
                    let dr = iA._2
1432
-
                    if ((dr != 0))
1433
-
                        then throw("Invalid removed margin amount")
1434
-
                        else {
1435
-
                            let iB = ev(dq, dr, ia)
1436
-
                            if (!(cj(iB, bG(), true)))
1437
-
                                then throw(((("Too much margin removed: " + toString(iB)) + " < ") + toString(bG())))
1438
-
                                else {
1439
-
                                    let iC = toBase58String(aq())
1440
-
                                    let iD = gd(cr)
1441
-
                                    let iE = iD._1
1442
-
                                    let iF = iD._2
1443
-
                                    let iG = if ((hk > iE))
1444
-
                                        then iE
1445
-
                                        else hk
1446
-
                                    let iH = if ((iE > hk))
1447
-
                                        then 0
1448
-
                                        else (hk - iE)
1449
-
                                    let iI = (iE - iG)
1450
-
                                    let iJ = if ((iI > 0))
1451
-
                                        then nil
1452
-
                                        else gJ(cr, iC)
1453
-
                                    let iK = if (((iG + iH) != hk))
1454
-
                                        then throw(((((("toRepay=" + toString(iG)) + " + toWithdraw=") + toString(iH)) + " != ") + toString(hk)))
1455
-
                                        else nil
1456
-
                                    if ((iK == iK))
1457
-
                                        then {
1458
-
                                            let iL = if ((iH > 0))
1459
-
                                                then {
1460
-
                                                    let iL = invoke(at(), "withdrawLocked", [iH], nil)
1461
-
                                                    if ((iL == iL))
1462
-
                                                        then nil
1463
-
                                                        else throw("Strict value is not equal to itself.")
1464
-
                                                    }
1465
-
                                                else nil
1466
-
                                            if ((iL == iL))
1467
-
                                                then {
1468
-
                                                    let iM = if ((iG > 0))
1469
-
                                                        then {
1470
-
                                                            let iN = invoke(ay(), "repay", [cr, iG, iF], nil)
1471
-
                                                            if ((iN == iN))
1472
-
                                                                then [ScriptTransfer(ci.caller, iG, fromBase58String(iF))]
1473
-
                                                                else throw("Strict value is not equal to itself.")
1474
-
                                                            }
1475
-
                                                        else nil
1476
-
                                                    if ((iM == iM))
1477
-
                                                        then ((((gO(cr, fZ, dq, ia, co(fZ)) ++ (if ((iH > 0))
1478
-
                                                            then hj(ci.caller, iH)
1479
-
                                                            else nil)) ++ hm((bE() - hk))) ++ iJ) ++ iM)
1480
-
                                                        else throw("Strict value is not equal to itself.")
1481
-
                                                    }
1482
-
                                                else throw("Strict value is not equal to itself.")
1483
-
                                            }
1484
-
                                        else throw("Strict value is not equal to itself.")
1485
-
                                    }
1486
-
                            }
1487
-
                    }
1719
+
            let hY = invoke(as(), "exchangeFreeAndLocked", [go], nil)
1720
+
            if ((hY == hY))
1721
+
                then nil
1722
+
                else throw("Strict value is not equal to itself.")
1723
+
            }
1724
+
        else nil
1725
+
    if ((hY == hY))
1726
+
        then ((hN((bl() + go)) ++ hB(hW, hX)) ++ ht(aM(aO(cD, hW), aO(cE, hX))))
1727
+
        else throw("Strict value is not equal to itself.")
1728
+
    }
1729
+
1730
+
1731
+
1732
+
@Callable(bR)
1733
+
func ensureCalledOnce () = if ((bR.caller != this))
1734
+
    then throw("Invalid saveCurrentTxId parameters")
1735
+
    else {
1736
+
        let jt = valueOrElse(getString(this, W), "")
1737
+
        if ((jt != toBase58String(bR.transactionId)))
1738
+
            then [StringEntry(W, jt)]
1739
+
            else throw("Can not call vAMM methods twice in one tx")
1740
+
        }
1741
+
1742
+
1743
+
1744
+
@Callable(bR)
1745
+
func view_calcRemainMarginWithFundingPayment (ca) = {
1746
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1747
+
    if ((ii == ii))
1748
+
        then {
1749
+
            let ju = bZ(ca)
1750
+
            let cd = ju._1
1751
+
            let em = ju._2
1752
+
            let ev = ju._3
1753
+
            let eo = ju._4
1754
+
            let ex = ju._5
1755
+
            let jv = ek(ca, aI)
1756
+
            let ef = jv._1
1757
+
            let ej = jv._2
1758
+
            let jw = dd(cd, em, eo, ex, ej)
1759
+
            let dl = jw._1
1760
+
            let dm = jw._2
1761
+
            let dh = jw._3
1762
+
            let dc = jw._4
1763
+
            throw(((((((aK(dl) + aK(dh)) + aK(eA(ca))) + aK(ej)) + aK(dm)) + aK(ef)) + aK(dc)))
1488
1764
 
            }
1489
1765
 
        else throw("Strict value is not equal to itself.")
1490
1766
 
    }
1491
1767
 
1492
1768
 
1493
1769
 
1494
-
@Callable(ci)
1495
-
func closePosition (gP,iO,iP) = {
1496
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1497
-
    if ((hI == hI))
1770
+
@Callable(bR)
1771
+
func view_getPegAdjustCost (hu) = {
1772
+
    let cD = bp()
1773
+
    let cE = bq()
1774
+
    let gj = gk(hu, cD, cE)
1775
+
    throw(toString(gj._3))
1776
+
    }
1777
+
1778
+
1779
+
1780
+
@Callable(bR)
1781
+
func view_getTerminalAmmPrice () = {
1782
+
    let jx = fS()
1783
+
    let fW = jx._1
1784
+
    let fX = jx._2
1785
+
    let hR = aM(aO(fW, br()), aO(fX, bs()))
1786
+
    throw(toString(hR))
1787
+
    }
1788
+
1789
+
1790
+
1791
+
@Callable(bR)
1792
+
func view_getFunding () = {
1793
+
    let gq = dE()
1794
+
    let jy = gp()
1795
+
    let gt = jy._1
1796
+
    let gu = jy._2
1797
+
    let jz = aM(gu, gq)
1798
+
    let jA = aM(gt, gq)
1799
+
    throw((((aK(jz) + aK(jA)) + aK(fu())) + aK(dE())))
1800
+
    }
1801
+
1802
+
1803
+
1804
+
@Callable(bR)
1805
+
func computeSpotPrice () = {
1806
+
    let ii = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1807
+
    if ((ii == ii))
1498
1808
 
        then {
1499
-
            let cr = ch(ci)
1500
-
            let iQ = valueOrErrorMessage(addressFromString(cr), "Invalid caller")
1501
-
            let cA = cy(cr)
1502
-
            if (if (if (if (if (if (!(cB(cr)))
1503
-
                then true
1504
-
                else !(cC()))
1505
-
                then true
1506
-
                else cD())
1507
-
                then true
1508
-
                else (0 >= gP))
1509
-
                then true
1510
-
                else (0 > iO))
1511
-
                then true
1512
-
                else dL())
1513
-
                then throw("Invalid closePosition parameters")
1514
-
                else {
1515
-
                    let iR = cq(cr)
1516
-
                    let fZ = iR._1
1517
-
                    let hZ = iR._2
1518
-
                    let ia = iR._3
1519
-
                    let ib = iR._4
1520
-
                    let iS = if ((bc(fZ) > gP))
1521
-
                        then {
1522
-
                            let hE = if ((fZ > 0))
1523
-
                                then aH
1524
-
                                else aG
1525
-
                            let if = (hE == aG)
1526
-
                            let iT = dD((fZ > 0), gP, true)
1527
-
                            let eL = iT._1
1528
-
                            let cU = iT._2
1529
-
                            let cV = iT._3
1530
-
                            let eS = iT._4
1531
-
                            let eK = if ((fZ > 0))
1532
-
                                then -(gP)
1533
-
                                else gP
1534
-
                            let iU = eq(cr, aP)
1535
-
                            let io = iU._1
1536
-
                            let ep = iU._2
1537
-
                            let iV = ez(cr, aP)
1538
-
                            let iW = aT(bc(eK), bc(fZ))
1539
-
                            let eP = aV(ep, iW)
1540
-
                            let iX = aV(aV(io, iW), cA)
1541
-
                            let iY = dh(fZ, hZ, ib, ep)._1
1542
-
                            let iZ = dh(fZ, hZ, ib, eP)._2
1543
-
                            let ja = (ep - eP)
1544
-
                            let jb = if ((fZ > 0))
1545
-
                                then ((io - eL) - ja)
1546
-
                                else ((ja + io) - eL)
1547
-
                            let iq = bc(jb)
1548
-
                            let ij = (fZ + eK)
1549
-
                            let jc = co(ij)
1550
-
                            let jd = (ia - iq)
1551
-
                            let eV = (bM() - jd)
1552
-
                            let je = if ((fZ > 0))
1553
-
                                then (aV((iq + ja), iV) - ja)
1554
-
                                else (aV((iq - ja), iV) - ja)
1555
-
                            let jf = ((iY - (je + ja)) - iX)
1556
-
                            let jg = if ((0 > jf))
1557
-
                                then throw("Margin error: unable to pay close fee")
1558
-
                                else jf
1559
-
                            if (if ((iO != 0))
1560
-
                                then (iO > eL)
1561
-
                                else false)
1562
-
                                then throw(((("Limit error: " + toString(eL)) + " < ") + toString(iO)))
1563
-
                                else $Tuple16(ij, if (iP)
1564
-
                                    then (je + jg)
1565
-
                                    else je, iq, jc, iZ, eP, if (iP)
1566
-
                                    then 0
1567
-
                                    else jg, cU, cV, eS, eV, (cd() - (if ((ij > 0))
1568
-
                                    then bc(eK)
1569
-
                                    else 0)), (cc() - (if ((0 > ij))
1570
-
                                    then bc(eK)
1571
-
                                    else 0)), (bO() - (if ((ij > 0))
1572
-
                                    then jd
1573
-
                                    else 0)), (bN() - (if ((0 > ij))
1574
-
                                    then jd
1575
-
                                    else 0)), iX)
1576
-
                            }
1577
-
                        else if ((gP > bc(fZ)))
1578
-
                            then throw("Invalid closePosition parameters")
1579
-
                            else {
1580
-
                                let jh = eM(cr, true)
1581
-
                                let el = jh._1
1582
-
                                let iZ = jh._2
1583
-
                                let eP = jh._3
1584
-
                                let ji = jh._4
1585
-
                                let cU = jh._5
1586
-
                                let cV = jh._6
1587
-
                                let eS = jh._7
1588
-
                                let eV = jh._8
1589
-
                                let eL = jh._9
1590
-
                                let eT = jh._10
1591
-
                                let eU = jh._11
1592
-
                                let ik = jh._12
1593
-
                                let il = jh._13
1594
-
                                let iX = aV(eL, cA)
1595
-
                                let jf = (bc(ji) - iX)
1596
-
                                let jg = if ((0 > jf))
1597
-
                                    then throw(((((((("Margin error: unable to pay close fee: " + toString(iX)) + " margin: ") + toString(ji)) + " fee percent: ") + toString(cA)) + " notional: ") + toString(eL)))
1598
-
                                    else jf
1599
-
                                if (if ((iO != 0))
1600
-
                                    then (iO > eL)
1601
-
                                    else false)
1602
-
                                    then throw(((("Limit error: " + toString(eL)) + " < ") + toString(iO)))
1603
-
                                    else $Tuple16(0, 0, 0, 0, iZ, eP, jg, cU, cV, eS, eV, eT, eU, ik, il, iX)
1604
-
                                }
1605
-
                    let ij = iS._1
1606
-
                    let je = iS._2
1607
-
                    let iq = iS._3
1608
-
                    let jc = iS._4
1609
-
                    let iZ = iS._5
1610
-
                    let eP = iS._6
1611
-
                    let jg = iS._7
1612
-
                    let cU = iS._8
1613
-
                    let cV = iS._9
1614
-
                    let eS = iS._10
1615
-
                    let eV = iS._11
1616
-
                    let eT = iS._12
1617
-
                    let eU = iS._13
1618
-
                    let ik = iS._14
1619
-
                    let il = iS._15
1620
-
                    let iX = iS._16
1621
-
                    if ((iZ > 0))
1622
-
                        then throw("Unable to close position with bad debt")
1623
-
                        else {
1624
-
                            let jj = (ij != 0)
1625
-
                            let jk = (jg + iX)
1626
-
                            let jl = (bE() - jk)
1627
-
                            let jm = if ((0 > jl))
1628
-
                                then $Tuple2(0, bc(jl))
1629
-
                                else $Tuple2(jl, 0)
1630
-
                            let jn = jm._1
1631
-
                            let jo = jm._2
1632
-
                            let jp = gd(cr)
1633
-
                            let iE = jp._1
1634
-
                            let iF = jp._2
1635
-
                            let jq = if ((iE > 0))
1636
-
                                then if ((jk >= iE))
1637
-
                                    then {
1638
-
                                        let iN = invoke(ay(), "repay", [cr, iE, iF], nil)
1639
-
                                        if ((iN == iN))
1640
-
                                            then $Tuple3(iE, (jk - iE), jj)
1641
-
                                            else throw("Strict value is not equal to itself.")
1642
-
                                        }
1643
-
                                    else {
1644
-
                                        let jr = invoke(ay(), if (jj)
1645
-
                                            then "repay"
1646
-
                                            else "realizePartiallyAndClose", [cr, jk, iF], nil)
1647
-
                                        if ((jr == jr))
1648
-
                                            then $Tuple3(jk, 0, false)
1649
-
                                            else throw("Strict value is not equal to itself.")
1650
-
                                        }
1651
-
                                else $Tuple3(0, jk, false)
1652
-
                            if ((jq == jq))
1653
-
                                then {
1654
-
                                    let js = jq._3
1655
-
                                    let jt = jq._2
1656
-
                                    let ju = jq._1
1657
-
                                    let jv = if ((jt >= iX))
1658
-
                                        then $Tuple3(ju, (jt - iX), iX)
1659
-
                                        else {
1660
-
                                            let jw = (iX - jt)
1661
-
                                            let jx = (ju - jw)
1662
-
                                            let hR = assetBalance(this, aq())
1663
-
                                            if ((hR == hR))
1664
-
                                                then {
1665
-
                                                    let hS = invoke(az(), "swap", [toBase58String(aq()), 0], [AttachedPayment(fromBase58String(iF), jw)])
1666
-
                                                    if ((hS == hS))
1667
-
                                                        then {
1668
-
                                                            let hT = assetBalance(this, aq())
1669
-
                                                            if ((hT == hT))
1670
-
                                                                then {
1671
-
                                                                    let hU = (hT - hR)
1672
-
                                                                    if ((hU == hU))
1673
-
                                                                        then $Tuple3(jx, 0, (jt + hU))
1674
-
                                                                        else throw("Strict value is not equal to itself.")
1675
-
                                                                    }
1676
-
                                                                else throw("Strict value is not equal to itself.")
1677
-
                                                            }
1678
-
                                                        else throw("Strict value is not equal to itself.")
1679
-
                                                    }
1680
-
                                                else throw("Strict value is not equal to itself.")
1681
-
                                            }
1682
-
                                    if ((jv == jv))
1683
-
                                        then {
1684
-
                                            let jy = jv._3
1685
-
                                            let jz = jv._2
1686
-
                                            let jx = jv._1
1687
-
                                            let jA = if ((jt > 0))
1688
-
                                                then {
1689
-
                                                    let jA = invoke(at(), "withdrawLocked", [jt], nil)
1690
-
                                                    if ((jA == jA))
1691
-
                                                        then nil
1692
-
                                                        else throw("Strict value is not equal to itself.")
1693
-
                                                    }
1694
-
                                                else nil
1695
-
                                            if ((jA == jA))
1696
-
                                                then {
1697
-
                                                    let jB = gn(jy)
1698
-
                                                    let gp = jB._1
1699
-
                                                    let gq = jB._2
1700
-
                                                    let iu = invoke(at(), "addFree", nil, [AttachedPayment(aq(), gq)])
1701
-
                                                    if ((iu == iu))
1702
-
                                                        then {
1703
-
                                                            let iv = invoke(au(), "notifyFees", [cr, iX], nil)
1704
-
                                                            if ((iv == iv))
1705
-
                                                                then {
1706
-
                                                                    let iw = invoke(au(), "notifyNotional", [cr, iq], nil)
1707
-
                                                                    if ((iw == iw))
1708
-
                                                                        then (((((((if (jj)
1709
-
                                                                            then gO(cr, ij, je, iq, jc)
1710
-
                                                                            else hi(cr)) ++ (if (js)
1711
-
                                                                            then {
1712
-
                                                                                let iC = toBase58String(aq())
1713
-
                                                                                gJ(cr, iC)
1714
-
                                                                                }
1715
-
                                                                            else nil)) ++ hb(cU, cV, eS, eV, eT, eU, ik, il)) ++ hn(gp)) ++ (if ((jz > 0))
1716
-
                                                                            then hj(iQ, jz)
1717
-
                                                                            else nil)) ++ hm(jn)) ++ (if ((jx > 0))
1718
-
                                                                            then [ScriptTransfer(iQ, jx, fromBase58String(iF))]
1719
-
                                                                            else nil))
1720
-
                                                                        else throw("Strict value is not equal to itself.")
1721
-
                                                                    }
1722
-
                                                                else throw("Strict value is not equal to itself.")
1723
-
                                                            }
1724
-
                                                        else throw("Strict value is not equal to itself.")
1725
-
                                                    }
1726
-
                                                else throw("Strict value is not equal to itself.")
1727
-
                                            }
1728
-
                                        else throw("Strict value is not equal to itself.")
1729
-
                                    }
1730
-
                                else throw("Strict value is not equal to itself.")
1731
-
                            }
1732
-
                    }
1809
+
            let gj = dY()
1810
+
            $Tuple2(nil, gj)
1733
1811
 
            }
1734
1812
 
        else throw("Strict value is not equal to itself.")
1735
1813
 
    }
1736
1814
 
1737
1815
 
1738
1816
 
1739
-
@Callable(ci)
1740
-
func liquidate (cr) = {
1741
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1742
-
    if ((hI == hI))
1743
-
        then {
1744
-
            let jC = ez(cr, aP)
1745
-
            let iB = if (eb())
1746
-
                then {
1747
-
                    let jD = ez(cr, aQ)
1748
-
                    bd(jC, jD)
1749
-
                    }
1750
-
                else jC
1751
-
            if (if (if (if (if (!(cj(iB, bT(), false)))
1752
-
                then true
1753
-
                else !(cB(cr)))
1754
-
                then true
1755
-
                else !(cC()))
1756
-
                then true
1757
-
                else cD())
1758
-
                then true
1759
-
                else dL())
1760
-
                then throw("Unable to liquidate")
1761
-
                else if (if (if ((jC > bU()))
1762
-
                    then (bV() > 0)
1763
-
                    else false)
1764
-
                    then (aM > bV())
1765
-
                    else false)
1766
-
                    then {
1767
-
                        let jE = cq(cr)
1768
-
                        let fZ = jE._1
1769
-
                        let hZ = jE._2
1770
-
                        let ia = jE._3
1771
-
                        let ib = jE._4
1772
-
                        let hE = if ((fZ > 0))
1773
-
                            then aH
1774
-
                            else aG
1775
-
                        let if = (hE == aG)
1776
-
                        let eL = eF(cr, fZ)
1777
-
                        let jF = eq(cr, aP)
1778
-
                        let io = jF._1
1779
-
                        let ep = jF._2
1780
-
                        let jG = cQ(if, eL)
1781
-
                        let eK = jG._1
1782
-
                        let cU = jG._2
1783
-
                        let cV = jG._3
1784
-
                        let eS = jG._4
1785
-
                        let jH = aT(bc(eK), bc(fZ))
1786
-
                        let eP = aV(ep, jH)
1787
-
                        let jI = dh(fZ, hZ, ib, eP)
1788
-
                        let dq = jI._1
1789
-
                        let dr = jI._2
1790
-
                        let dm = jI._3
1791
-
                        let ja = (ep - eP)
1792
-
                        let jb = if ((fZ > 0))
1793
-
                            then ((io - eL) - ja)
1794
-
                            else ((ja + io) - eL)
1795
-
                        let jJ = aV(eL, bU())
1796
-
                        let jK = (jJ / 2)
1797
-
                        let gq = (jJ - jK)
1798
-
                        let je = (dq - jJ)
1799
-
                        let ij = (fZ + eK)
1800
-
                        let iq = bc(jb)
1801
-
                        let jd = (ia - iq)
1802
-
                        let jc = co(ij)
1803
-
                        let eV = (bM() - jd)
1804
-
                        let jl = (bE() - jJ)
1805
-
                        let jL = if ((0 > jl))
1806
-
                            then $Tuple2(0, bc(jl))
1807
-
                            else $Tuple2(jl, 0)
1808
-
                        let jM = jL._1
1809
-
                        let jo = jL._2
1810
-
                        let jN = gd(cr)
1811
-
                        let iE = jN._1
1812
-
                        let iF = jN._2
1813
-
                        let jO = if ((iE > 0))
1814
-
                            then {
1815
-
                                let jP = aV(iE, jH)
1816
-
                                let jr = invoke(ay(), "realizePartially", [cr, iF, jP], nil)
1817
-
                                if ((jr == jr))
1818
-
                                    then nil
1819
-
                                    else throw("Strict value is not equal to itself.")
1820
-
                                }
1821
-
                            else nil
1822
-
                        if ((jO == jO))
1823
-
                            then {
1824
-
                                let jA = invoke(at(), "withdrawLocked", [jJ], nil)
1825
-
                                if ((jA == jA))
1826
-
                                    then {
1827
-
                                        let jQ = invoke(at(), "addFree", nil, [AttachedPayment(aq(), gq)])
1828
-
                                        if ((jQ == jQ))
1829
-
                                            then {
1830
-
                                                let iw = invoke(au(), "notifyNotional", [cr, iq], nil)
1831
-
                                                if ((iw == iw))
1832
-
                                                    then (((gO(cr, ij, je, iq, jc) ++ hb(cU, cV, eS, eV, (cd() - (if ((ij > 0))
1833
-
                                                        then bc(eK)
1834
-
                                                        else 0)), (cc() - (if ((0 > ij))
1835
-
                                                        then bc(eK)
1836
-
                                                        else 0)), (bO() - (if ((ij > 0))
1837
-
                                                        then jd
1838
-
                                                        else 0)), (bN() - (if ((0 > ij))
1839
-
                                                        then jd
1840
-
                                                        else 0)))) ++ hj(ci.caller, jK)) ++ hm(jM))
1841
-
                                                    else throw("Strict value is not equal to itself.")
1842
-
                                                }
1843
-
                                            else throw("Strict value is not equal to itself.")
1844
-
                                        }
1845
-
                                    else throw("Strict value is not equal to itself.")
1846
-
                                }
1847
-
                            else throw("Strict value is not equal to itself.")
1848
-
                        }
1849
-
                    else {
1850
-
                        let jR = eM(cr, false)
1851
-
                        let ek = jR._1
1852
-
                        let dr = jR._2
1853
-
                        let el = jR._3
1854
-
                        let em = jR._4
1855
-
                        let cU = jR._5
1856
-
                        let cV = jR._6
1857
-
                        let eS = jR._7
1858
-
                        let eV = jR._8
1859
-
                        let eL = jR._9
1860
-
                        let eT = jR._10
1861
-
                        let eU = jR._11
1862
-
                        let ik = jR._12
1863
-
                        let il = jR._13
1864
-
                        let jJ = aV(eL, bU())
1865
-
                        let jK = (jJ / 2)
1866
-
                        let gq = (jJ - jK)
1867
-
                        let jl = (bE() - jJ)
1868
-
                        let jS = if ((0 > jl))
1869
-
                            then $Tuple2(0, bc(jl))
1870
-
                            else $Tuple2(jl, 0)
1871
-
                        let jM = jS._1
1872
-
                        let jo = jS._2
1873
-
                        let jT = gd(cr)
1874
-
                        let iE = jT._1
1875
-
                        let iF = jT._2
1876
-
                        let jO = if ((iE > 0))
1877
-
                            then {
1878
-
                                let jr = invoke(ay(), "realizePartiallyAndClose", [cr, 0, iF], nil)
1879
-
                                if ((jr == jr))
1880
-
                                    then nil
1881
-
                                    else throw("Strict value is not equal to itself.")
1882
-
                                }
1883
-
                            else nil
1884
-
                        if ((jO == jO))
1885
-
                            then {
1886
-
                                let gj = if ((dr > 0))
1887
-
                                    then {
1888
-
                                        let jU = invoke(at(), "exchangeFreeAndLocked", [dr], nil)
1889
-
                                        if ((jU == jU))
1890
-
                                            then nil
1891
-
                                            else throw("Strict value is not equal to itself.")
1892
-
                                        }
1893
-
                                    else nil
1894
-
                                if ((gj == gj))
1895
-
                                    then {
1896
-
                                        let jA = invoke(at(), "withdrawLocked", [jJ], nil)
1897
-
                                        if ((jA == jA))
1898
-
                                            then {
1899
-
                                                let jQ = invoke(at(), "addFree", nil, [AttachedPayment(aq(), gq)])
1900
-
                                                if ((jQ == jQ))
1901
-
                                                    then {
1902
-
                                                        let iw = invoke(au(), "notifyNotional", [cr, 0], nil)
1903
-
                                                        if ((iw == iw))
1904
-
                                                            then (((hi(cr) ++ hb(cU, cV, eS, eV, eT, eU, ik, il)) ++ hj(ci.caller, jK)) ++ hm(jM))
1905
-
                                                            else throw("Strict value is not equal to itself.")
1906
-
                                                        }
1907
-
                                                    else throw("Strict value is not equal to itself.")
1908
-
                                                }
1909
-
                                            else throw("Strict value is not equal to itself.")
1910
-
                                        }
1911
-
                                    else throw("Strict value is not equal to itself.")
1912
-
                                }
1913
-
                            else throw("Strict value is not equal to itself.")
1914
-
                        }
1915
-
            }
1916
-
        else throw("Strict value is not equal to itself.")
1817
+
@Callable(bR)
1818
+
func computeFeeForTraderWithArtifact (ca,gw) = {
1819
+
    let gj = gI(ca, gw)
1820
+
    $Tuple2(nil, gj)
1917
1821
 
    }
1918
1822
 
1919
1823
 
1920
-
1921
-
@Callable(ci)
1922
-
func payFunding () = {
1923
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1924
-
    if ((hI == hI))
1925
-
        then {
1926
-
            let jV = bP()
1927
-
            if (if (if ((jV > lastBlock.timestamp))
1928
-
                then true
1929
-
                else !(cC()))
1930
-
                then true
1931
-
                else cD())
1932
-
                then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(jV)))
1933
-
                else {
1934
-
                    let fJ = dE()
1935
-
                    let jW = fI()
1936
-
                    let fM = jW._1
1937
-
                    let fN = jW._2
1938
-
                    gD((jV + bS()), (ca() + fN), (cb() + fM), aT(fN, fJ), aT(fM, fJ))
1939
-
                    }
1940
-
            }
1941
-
        else throw("Strict value is not equal to itself.")
1942
-
    }
1943
-
1944
-
1945
-
1946
-
@Callable(ci)
1947
-
func syncTerminalPriceToOracle () = {
1948
-
    let cM = bH()
1949
-
    let cN = bI()
1950
-
    let jX = fE(dE(), cM, cN)
1951
-
    let hv = jX._1
1952
-
    let hw = jX._2
1953
-
    let eQ = jX._3
1954
-
    let hx = if ((eQ != 0))
1955
-
        then {
1956
-
            let hx = invoke(at(), "exchangeFreeAndLocked", [eQ], nil)
1957
-
            if ((hx == hx))
1958
-
                then nil
1959
-
                else throw("Strict value is not equal to itself.")
1960
-
            }
1961
-
        else nil
1962
-
    if ((hx == hx))
1963
-
        then (ha(hv, hw) ++ gS(aT(aV(cM, hv), aV(cN, hw))))
1964
-
        else throw("Strict value is not equal to itself.")
1965
-
    }
1966
-
1967
-
1968
-
1969
-
@Callable(ci)
1970
-
func view_calcRemainMarginWithFundingPayment (cr) = {
1971
-
    let hI = invoke(this, "syncTerminalPriceToOracle", nil, nil)
1972
-
    if ((hI == hI))
1973
-
        then {
1974
-
            let jY = cq(cr)
1975
-
            let cu = jY._1
1976
-
            let es = jY._2
1977
-
            let eB = jY._3
1978
-
            let eu = jY._4
1979
-
            let jZ = eq(cr, aP)
1980
-
            let eh = jZ._1
1981
-
            let ep = jZ._2
1982
-
            let ka = dh(cu, es, eu, ep)
1983
-
            let dq = ka._1
1984
-
            let dr = ka._2
1985
-
            let dm = ka._3
1986
-
            throw((((((aR(dq) + aR(dm)) + aR(eE(cr))) + aR(ep)) + aR(dr)) + aR(eh)))
1987
-
            }
1988
-
        else throw("Strict value is not equal to itself.")
1989
-
    }
1990
-
1991
-
1992
-
1993
-
@Callable(ci)
1994
-
func view_getPegAdjustCost (gT) = {
1995
-
    let cM = bH()
1996
-
    let cN = bI()
1997
-
    let fD = fE(gT, cM, cN)
1998
-
    throw(toString(fD._3))
1999
-
    }
2000
-
2001
-
2002
-
2003
-
@Callable(ci)
2004
-
func view_getTerminalAmmPrice () = {
2005
-
    let kb = fm()
2006
-
    let fq = kb._1
2007
-
    let fr = kb._2
2008
-
    let hq = aT(aV(fq, bJ()), aV(fr, bK()))
2009
-
    throw(toString(hq))
2010
-
    }
2011
-
2012
-
2013
-
2014
-
@Callable(ci)
2015
-
func view_getFunding () = {
2016
-
    let fJ = dE()
2017
-
    let kc = fI()
2018
-
    let fM = kc._1
2019
-
    let fN = kc._2
2020
-
    let kd = aT(fN, fJ)
2021
-
    let ke = aT(fM, fJ)
2022
-
    throw((((aR(kd) + aR(ke)) + aR(eW())) + aR(dE())))
2023
-
    }
2024
-
2025
-
2026
-
2027
-
@Callable(ci)
2028
-
func view_getBorrowedByTrader (cr) = {
2029
-
    let kf = gd(cr)
2030
-
    let iE = kf._1
2031
-
    let iF = kf._2
2032
-
    throw((aR(iE) + iF))
2033
-
    }
2034
-
2035
-
2036
-
2037
-
@Callable(ci)
2038
-
func computeSpotPrice () = {
2039
-
    let fD = ea()
2040
-
    $Tuple2(nil, fD)
2041
-
    }
2042
-
2043
-
2044
-
2045
-
@Callable(ci)
2046
-
func computeFeeForTraderWithArtifact (cr,fP) = {
2047
-
    let fD = gg(cr, fP)
2048
-
    $Tuple2(nil, fD)
2049
-
    }
2050
-
2051
-
2052
-
@Verifier(kg)
2053
-
func kh () = sigVerify(kg.bodyBytes, kg.proofs[0], ap())
1824
+
@Verifier(jB)
1825
+
func jC () = sigVerify(jB.bodyBytes, jB.proofs[0], ao())
2054
1826