tx · 8fd3MWgckmTjpXdX3FPHjUUYjs4Xnxzofz192FC7Fueu

3MxWJGTCWgdocKWm6HtaMmPK9XtQGq2Mvth:  -0.07500000 Waves

2023.05.15 12:59 [2578923] smart account 3MxWJGTCWgdocKWm6HtaMmPK9XtQGq2Mvth > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8fd3MWgckmTjpXdX3FPHjUUYjs4Xnxzofz192FC7Fueu",
    "fee": 7500000,
    "feeAssetId": null,
    "timestamp": 1684144767559,
    "version": 2,
    "chainId": 84,
    "sender": "3MxWJGTCWgdocKWm6HtaMmPK9XtQGq2Mvth",
    "senderPublicKey": "5NE1ZN16YK71DG5UJPwBwA7VxbPzgup2NwEDd6duMfkQ",
    "proofs": [
        "3EpzBfyk1xJFYTeRVBCzY3keoAEjmFMNPsqyLv28VZuH6vG5PBNT3sLyPRqRyH1ZWjm9yWhKDTib4sBNw56WXq5z"
    ],
    "script": "base64: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",
    "height": 2578923,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8KgRQT9eU8BrgAMFSUP9SAW131LWk8NARzA1Dom4A9cM
Next: 7xwux7NFEmYbyJSBJFhvEkTo39xfhJ93C9aeuZA5KsLn

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

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