tx · AyvJuj3Aak34yrPREwhjjQ7z5FhFqqxy96NczgxsjYg3

3MwaLXWor2GmhvHbwWBHHqTg8v64gAL3bNe:  -0.07500000 Waves

2023.07.11 14:46 [2661198] smart account 3MwaLXWor2GmhvHbwWBHHqTg8v64gAL3bNe > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AyvJuj3Aak34yrPREwhjjQ7z5FhFqqxy96NczgxsjYg3",
    "fee": 7500000,
    "feeAssetId": null,
    "timestamp": 1689076023140,
    "version": 2,
    "chainId": 84,
    "sender": "3MwaLXWor2GmhvHbwWBHHqTg8v64gAL3bNe",
    "senderPublicKey": "2tH4sdPziztoUGLjH9xnQP48CDqP5YNwLKv2WNZip3wp",
    "proofs": [
        "4rtscKjoif4jZAnwDk3cSWwh3Qw1j4bpQ64ykHDsvYeuLzYnWyYBpitFrCXLy1r3wGUg9UrcmsVp9APNTSLvB3vz"
    ],
    "script": "base64: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",
    "height": 2661198,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: BGi8KwhR9XmouLS5iP2EstmdEuMB6K2GTZeSXLqngyD
Next: 5Ls4zWP6keT4RGRTGnQ1Nx16VJD3NUiJGozQPAk6m8si

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

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