tx · 9R9bHgYLUM8y4VnDoLJWivceefE4eaeEZU5Gprj5UsgD

3N3c8hF3E1qiSZ27uH3XZvtWSso9QFckZUb:  -0.02800000 Waves

2024.08.05 15:40 [3225489] smart account 3N3c8hF3E1qiSZ27uH3XZvtWSso9QFckZUb > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9R9bHgYLUM8y4VnDoLJWivceefE4eaeEZU5Gprj5UsgD",
    "fee": 2800000,
    "feeAssetId": null,
    "timestamp": 1722861633000,
    "version": 1,
    "sender": "3N3c8hF3E1qiSZ27uH3XZvtWSso9QFckZUb",
    "senderPublicKey": "9Dkh2UiuYRqFTQrAXgJJbJuG3Q6VDPhiYHrsdfQx42Zx",
    "proofs": [
        "3FfFb41RXDDb3etpXW5Bqnf5A6ZLo7mxxigges49ppukBxFhqrfkHo5cyB49E3Evv5q4sdJcyGVescHTAUgWFdiF"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 3225489,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: DCFYBRJjig5dgHv27KYVfvuN9wBKLx6GNXvdj9We582b

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 7 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let separator = "__"
5+
6+let chainId = take(drop(this.bytes, 1), 1)
7+
8+let chainIdW = base58'2W'
9+
10+let contractFilename = "futures_calculator.ride"
11+
12+let mult8 = 100000000
13+
14+let mult18BigInt = toBigInt(1000000000000000000)
15+
16+let wavesDecimals = 8
17+
18+let usdtDecimals = 6
19+
20+let wavesString = "WAVES"
21+
22+let queueItemSize = 32
23+
24+let big0 = toBigInt(0)
25+
26+let INDEX_LIST = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
27+
28+let kMultisig = "%s__multisig"
29+
30+func kStatus (dapp,txId) = makeString(["%s__status", dapp, txId], separator)
31+
32+
33+let kShutdown = "%s__shutdown"
34+
35+let kPublicKeys = "%s__publicKeys"
36+
37+let kMatcherPublicKey = "%s__matcherPublicKey"
38+
39+func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), mult18BigInt, toBigInt(origScaleMult))
40+
41+
42+func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), mult18BigInt))
43+
44+
45+func validateAddress (address) = isDefined(addressFromString(address))
46+
47+
48+func wrapErr (s) = ((contractFilename + ": ") + s)
49+
50+
51+func throwErr (s) = throw(wrapErr(s))
52+
53+
54+func ensurePositive (v,s) = if ((v >= 0))
55+    then v
56+    else throwErr((s + " value should be positive"))
57+
58+
59+func parseAssetId (input) = if ((input == wavesString))
60+    then unit
61+    else fromBase58String(input)
62+
63+
64+func assetIdToString (input) = if ((input == unit))
65+    then wavesString
66+    else toBase58String(value(input))
67+
68+
69+func getAssetInfoOrFail (assetId) = valueOrErrorMessage(assetInfo(assetId), wrapErr("invalid asset info"))
70+
71+
72+func getAssetDecimalsOrFail (assetId) = match assetId {
73+    case _: Unit => 
74+        wavesDecimals
75+    case assetId: ByteVector => 
76+        getAssetInfoOrFail(assetId).decimals
77+    case _ => 
78+        throw("Match error")
79+}
80+
81+
82+func getAssetBalance (assetId,address) = match assetId {
83+    case _: Unit => 
84+        wavesBalance(address).available
85+    case assetId: ByteVector => 
86+        assetBalance(address, assetId)
87+    case _ => 
88+        throw("Match error")
89+}
90+
91+
92+func pow10 (n) = pow(10, 0, n, 0, 0, DOWN)
93+
94+
95+func pow10Decimals (assetId) = pow10(getAssetDecimalsOrFail(assetId))
96+
97+
98+let kFactoryAddress = "%s__factoryAddress"
99+
100+let factoryAddressOption = match getString(this, kFactoryAddress) {
101+    case s: String => 
102+        addressFromString(s)
103+    case _: Unit => 
104+        unit
105+    case _ => 
106+        throw("Match error")
107+}
108+
109+let factoryAddress = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
110+
111+let kUsdtAssetId = "%s__usdtAssetId"
112+
113+let usdtAssetIdOption = match getString(factoryAddress, kUsdtAssetId) {
114+    case s: String => 
115+        parseAssetId(s)
116+    case _: Unit => 
117+        unit
118+    case _ => 
119+        throw("Match error")
120+}
121+
122+let usdtAssetId = valueOrErrorMessage(usdtAssetIdOption, wrapErr("invalid usdt asset id"))
123+
124+let kPricesAddress = "%s__calculatorAddress"
125+
126+let shutdown = valueOrElse(getBoolean(factoryAddress, kShutdown), false)
127+
128+func mustAddress (caller,address) = if ((caller == address))
129+    then true
130+    else throwErr("permission denied")
131+
132+
133+func mustThis (caller) = mustAddress(caller, this)
134+
135+
136+func mustFactory (caller) = mustAddress(caller, factoryAddress)
137+
138+
139+func mustAdmin (callerPublicKey) = {
140+    let multisig = addressFromStringValue(getStringValue(factoryAddress, kMultisig))
141+    let publicKeysList = split(getStringValue(multisig, kPublicKeys), separator)
142+    if (containsElement(publicKeysList, toBase58String(callerPublicKey)))
143+        then true
144+        else throwErr("not allowed")
145+    }
146+
147+
148+let kAccountScript = "%s__accountScript"
149+
150+func accountScript () = valueOrErrorMessage(getBinary(factoryAddress, kAccountScript), wrapErr("account script is not set"))
151+
152+
153+let kRewardAmount = "%s__rewardAmount"
154+
155+func rewardAmount () = valueOrErrorMessage(getInteger(factoryAddress, kRewardAmount), wrapErr("reward amount is not set"))
156+
157+
158+let kAccountsLimit = "%s__accountsLimit"
159+
160+let accountsLimitDefault = 20
161+
162+func accountsLimit () = valueOrElse(getInteger(factoryAddress, kAccountsLimit), accountsLimitDefault)
163+
164+
165+func kDeposited (accountAddress) = makeString(["%s%s", "deposited", toString(accountAddress)], separator)
166+
167+
168+func depositedOption (accountAddress) = getInteger(factoryAddress, kDeposited(accountAddress))
169+
170+
171+func kCredit (accountAddress,assetId) = makeString(["%s%s%s", "credit", toString(accountAddress), assetIdToString(assetId)], separator)
172+
173+
174+func creditOption (accountAddress,assetId) = getInteger(factoryAddress, kCredit(accountAddress, assetId))
175+
176+
177+func kLeverage (accountAddress) = makeString(["%s%s", "leverage", toString(accountAddress)], separator)
178+
179+
180+func kRequestLeverage (requestId) = makeString(["%s%s", "requestLeverage", toBase58String(requestId)], separator)
181+
182+
183+func kSyntheticAssetId (baseAssetId) = makeString(["%s%s", "syntheticAssetId", assetIdToString(baseAssetId)], separator)
184+
185+
186+func kBaseAssetId (syntheticAssetId) = makeString(["%s%s", "baseAssetId", assetIdToString(syntheticAssetId)], separator)
187+
188+
189+let REQUEST_STATUS_EMPTY = 0
190+
191+let REQUEST_STATUS_READY = 1
192+
193+func kRequestStatus (requestId) = makeString(["%s%s", toBase58String(requestId), "status"], separator)
194+
195+
196+func kAccountCreatorPublicKey (accountAddress) = makeString(["%s%s", toString(accountAddress), "creatorPublicKey"], separator)
197+
198+
199+func kRequestOwnerPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "ownerPublicKey"], separator)
200+
201+
202+func kRequestAmountAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "amountAssetId"], separator)
203+
204+
205+func kRequestPriceAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "priceAssetId"], separator)
206+
207+
208+func kRequestIdToAccountPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "requestIdToAccountPublicKey"], separator)
209+
210+
211+func kAccountAddressToRequestId (accountAddress) = makeString(["%s%s", toString(accountAddress), "accountAddressToRequestId"], separator)
212+
213+
214+func kRequestsQueue () = makeString(["%s", "requestsQueue"], separator)
215+
216+
217+func requestsQueue () = valueOrElse(getBinary(factoryAddress, kRequestsQueue()), base58'')
218+
219+
220+func kAccountsQueue () = makeString(["%s", "accountsQueue"], separator)
221+
222+
223+func accountsQueue () = valueOrElse(getBinary(factoryAddress, kAccountsQueue()), base58'')
224+
225+
226+func kRequestsByOwner (ownerAddress) = makeString(["%s%s", "requests", toString(ownerAddress)], separator)
227+
228+
229+func requestsByOwner (ownerAddress) = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(ownerAddress)), base58'')
230+
231+
232+func kPairAllowed (amountAssetId,priceAssetId) = makeString(["%s%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), "pairAllowed"], separator)
233+
234+
235+func pairAllowed (amountAssetId,priceAssetId) = valueOrElse(getBoolean(factoryAddress, kPairAllowed(amountAssetId, priceAssetId)), false)
236+
237+
238+func kPrice (assetId) = makeString(["%s", assetIdToString(assetId)], separator)
239+
240+
241+func kPairPricesListKey (amountAssetId,priceAssetId) = makeString(["%s%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), "pairSettingPrices"], separator)
242+
243+
244+func getPairPricesList (amountAssetId,priceAssetId) = match getString(factoryAddress, kPairPricesListKey(amountAssetId, priceAssetId)) {
245+    case s: String => 
246+        split(s, separator)
247+    case _ => 
248+        nil
249+}
250+
251+
252+func kPairSettingsKey (amountAssetId,priceAssetId,priceString) = makeString(["%s%s%d%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), priceString, "settings"], separator)
253+
254+
255+func getCurrentPrice (assetId) = {
256+    let matcherPublicKey = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kMatcherPublicKey), wrapErr("invalid matcher public key")))
257+    let matcherAddress = addressFromPublicKey(matcherPublicKey)
258+    let price = valueOrErrorMessage(getInteger(matcherAddress, kPrice(assetId)), wrapErr(("invalid price, assetId = " + assetIdToString(assetId))))
259+    price
260+    }
261+
262+
263+func calcTotalCredit (creditA,creditB,currentPrice) = (fraction(creditA, currentPrice, mult18BigInt) + creditB)
264+
265+
266+func calcTotalBalance (balanceA,balanceB,currentPrice) = (fraction(balanceA, currentPrice, mult18BigInt) + balanceB)
267+
268+
269+func calcPnl (totalBalance,totalCredit) = (totalBalance - totalCredit)
270+
271+
272+func calcCreditAvailable (deposit,leverage,totalCredit) = (fraction(deposit, leverage, mult18BigInt) - totalCredit)
273+
274+
275+func calcRealInCredit (credit,balance) = if ((credit > big0))
276+    then (credit - balance)
277+    else big0
278+
279+
280+func calcFree (credit,balance) = if ((credit > big0))
281+    then (balance - credit)
282+    else big0
283+
284+
285+func calcShortPrice (free,realInCredit) = if ((realInCredit > big0))
286+    then max([big0, fraction(free, mult18BigInt, realInCredit)])
287+    else big0
288+
289+
290+func calcLongPrice (free,realInCredit) = if ((realInCredit > big0))
291+    then max([big0, fraction(realInCredit, mult18BigInt, free)])
292+    else big0
293+
294+
295+func calcStartMargin (realInCreditA,realInCreditB,currentPrice,settingsMargin) = fraction((fraction(realInCreditA, currentPrice, mult18BigInt) + realInCreditB), settingsMargin, mult18BigInt)
296+
297+
298+func calcMarginSupply (settingsMarginSupply,settingsMargin,startMargin) = fraction(settingsMarginSupply, startMargin, settingsMargin)
299+
300+
301+func calcLiquidationPrice (deposit,marginSupply,realInCreditA,realInCreditB,shortPrice,longPrice) = {
302+    let liquidationPriceA = if ((realInCreditA > big0))
303+        then (((deposit - marginSupply) / realInCreditA) + shortPrice)
304+        else big0
305+    let liquidationPriceB = if ((realInCreditB > big0))
306+        then (longPrice - ((deposit - marginSupply) / (realInCreditA / longPrice)))
307+        else big0
308+    (liquidationPriceA + liquidationPriceB)
309+    }
310+
311+
312+func getRequestId (accountAddress) = {
313+    let requestId = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kAccountAddressToRequestId(accountAddress)), wrapErr("invalid account address: request id is undefined")))
314+    requestId
315+    }
316+
317+
318+func getAccountAssets (accountAddress) = {
319+    let requestId = getRequestId(accountAddress)
320+    let amountAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kRequestAmountAssetId(requestId)), wrapErr("invalid amount asset id")))
321+    let priceAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kRequestPriceAssetId(requestId)), wrapErr("invalid amount price id")))
322+    $Tuple2(amountAssetId, priceAssetId)
323+    }
324+
325+
326+func getAccountOwnerPublicKey (accountAddress) = {
327+    let requestId = getRequestId(accountAddress)
328+    let requestOwnerPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestOwnerPublicKey(requestId)), wrapErr("invalid amount asset id"))
329+    requestOwnerPublicKey
330+    }
331+
332+
333+func getAccountInfoInternal (accountAddress) = {
334+    let $t01118711255 = getAccountAssets(accountAddress)
335+    let amountAssetId = $t01118711255._1
336+    let priceAssetId = $t01118711255._2
337+    let leverage = valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined"))
338+    let requestId = getRequestId(accountAddress)
339+    let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
340+    let deposited = valueOrElse(depositedOption(accountAddress), 0)
341+    let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(priceAssetId))
342+    let creditA = valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0)
343+    let creditB = valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, priceAssetId)), 0)
344+    let status = valueOrErrorMessage(getInteger(factoryAddress, kRequestStatus(requestId)), ("status not found. RequestId = " + toBase58String(requestId)))
345+    let synthAmountAssetId = getString(factoryAddress, kSyntheticAssetId(amountAssetId))
346+    let synthAmountAssetBalance =     match synthAmountAssetId {
347+        case s: String => 
348+            getAssetBalance(parseAssetId(s), accountAddress)
349+        case _ => 
350+            0
351+    }
352+    let synthPriceAssetId = getString(factoryAddress, kSyntheticAssetId(priceAssetId))
353+    let synthPriceAssetBalance =     match synthPriceAssetId {
354+        case s: String => 
355+            getAssetBalance(parseAssetId(s), accountAddress)
356+        case _ => 
357+            0
358+    }
359+    $Tuple12(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), leverage, toBase58String(requestId), deposited, creditA, creditB, synthAmountAssetBalance, synthPriceAssetBalance, status)
360+    }
361+
362+
363+func depositINTERNAL (callerPublicKey,args,i) = {
364+    let payment = i.payments[0]
365+    let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
366+    let ckecks = [if (!(shutdown))
367+        then true
368+        else throwErr("not allowed"), mustFactory(i.caller), if ((size(i.payments) == 1))
369+        then true
370+        else throwErr("1 payment is required"), if ((payment.assetId == usdtAssetId))
371+        then true
372+        else throwErr("invalid asset"), if ((getInteger(factoryAddress, kRequestStatus(getRequestId(accountAddress))) == REQUEST_STATUS_READY))
373+        then true
374+        else throwErr("account is not ready")]
375+    if ((ckecks == ckecks))
376+        then {
377+            let actions = [ScriptTransfer(accountAddress, payment.amount, payment.assetId)]
378+            let factoryActions = [invoke(factoryAddress, "integerEntry", [kDeposited(accountAddress), (valueOrElse(depositedOption(accountAddress), 0) + payment.amount)], nil)]
379+            $Tuple2(actions, factoryActions)
380+            }
381+        else throw("Strict value is not equal to itself.")
382+    }
383+
384+
385+func borrowINTERNAL (callerPublicKey,args,i) = {
386+    let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
387+    let assetIdRequested = parseAssetId(args[1])
388+    let amountRequested = ensurePositive(valueOrErrorMessage(parseInt(args[2]), wrapErr("invalid requested amount")), "requested amount")
389+    let accountOwnerPublicKey = getAccountOwnerPublicKey(accountAddress)
390+    let userAddress = addressFromPublicKey(callerPublicKey)
391+    let ckecks = [if (!(shutdown))
392+        then true
393+        else throwErr("not allowed"), mustFactory(i.caller), if ((callerPublicKey == accountOwnerPublicKey))
394+        then true
395+        else throwErr("can be called by account owner only")]
396+    if ((ckecks == ckecks))
397+        then {
398+            let amountAssetId = getAccountAssets(accountAddress)._1
399+            let deposited = toX18(valueOrElse(depositedOption(accountAddress), 0), pow10Decimals(usdtAssetId))
400+            let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(usdtAssetId))
401+            let creditA = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0), pow10Decimals(amountAssetId))
402+            let creditB = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, usdtAssetId)), 0), pow10Decimals(usdtAssetId))
403+            let totalCredit = calcTotalCredit(creditA, creditB, currentPrice)
404+            let leverage = toX18(valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined")), 1)
405+            let creditAvailableUsdt = calcCreditAvailable(deposited, leverage, totalCredit)
406+            let creditAvailable = if ((assetIdRequested == amountAssetId))
407+                then fromX18(fraction(creditAvailableUsdt, mult18BigInt, currentPrice), pow10Decimals(amountAssetId))
408+                else if ((assetIdRequested == usdtAssetId))
409+                    then fromX18(creditAvailableUsdt, pow10Decimals(usdtAssetId))
410+                    else throwErr("invalid requested asset id")
411+            let syntheticAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kSyntheticAssetId(assetIdRequested)), wrapErr("synthetic asset for requested asset is undefined")))
412+            let amountToSend = if ((creditAvailable >= amountRequested))
413+                then amountRequested
414+                else throwErr(("credit available = " + toString(creditAvailable)))
415+            let factoryActions = [invoke(factoryAddress, "integerEntry", [kCredit(accountAddress, assetIdRequested), (valueOrElse(creditOption(accountAddress, assetIdRequested), 0) + amountToSend)], nil), invoke(factoryAddress, "transferAsset", [accountAddress, amountToSend, syntheticAssetId], nil)]
416+            $Tuple2(nil, [factoryActions, creditAvailable])
417+            }
418+        else throw("Strict value is not equal to itself.")
419+    }
420+
421+
422+@Callable(i)
423+func init (factoryAddressStr) = {
424+    let checkCaller = mustThis(i.caller)
425+    if ((checkCaller == checkCaller))
426+        then $Tuple2([StringEntry(kFactoryAddress, factoryAddressStr)], unit)
427+        else throw("Strict value is not equal to itself.")
428+    }
429+
430+
431+
432+@Callable(i)
433+func requestAccount (callerPublicKey,args) = {
434+    let ckecks = [if (!(shutdown))
435+        then true
436+        else throwErr("not allowed"), mustFactory(i.caller)]
437+    if ((ckecks == ckecks))
438+        then {
439+            let amountAssetIdStr = args[0]
440+            let priceAssetIdStr = args[1]
441+            let leverage = valueOrErrorMessage(parseInt(args[2]), wrapErr("invalid leverage"))
442+            let userAddress = addressFromPublicKey(callerPublicKey)
443+            let requestId = sha256(((userAddress.bytes + fromBase58String(amountAssetIdStr)) + fromBase58String(priceAssetIdStr)))
444+            let amountAssetId = parseAssetId(amountAssetIdStr)
445+            let priceAssetId = parseAssetId(priceAssetIdStr)
446+            let userRequestsNumber = (size(kRequestsByOwner(userAddress)) / queueItemSize)
447+            let checks = [if ((size(i.payments) == 1))
448+                then true
449+                else throwErr("1 payment is required"), if ((i.payments[0].assetId == unit))
450+                then true
451+                else throwErr("invalid asset"), if ((i.payments[0].amount == rewardAmount()))
452+                then true
453+                else throwErr("invalid amount"), if (pairAllowed(amountAssetId, priceAssetId))
454+                then true
455+                else throwErr("pair is not allowed"), if ((getInteger(factoryAddress, kRequestStatus(requestId)) == unit))
456+                then true
457+                else throwErr("account is already exists"), if ((accountsLimit() > userRequestsNumber))
458+                then true
459+                else throwErr(("accounts limit is " + toString(accountsLimit())))]
460+            if ((checks == checks))
461+                then {
462+                    let $t01823719770 = if ((size(accountsQueue()) == 0))
463+                        then $Tuple2([ScriptTransfer(factoryAddress, rewardAmount(), unit)], [invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_EMPTY], nil), invoke(factoryAddress, "binaryEntry", [kRequestsQueue(), (requestsQueue() + requestId)], nil), invoke(factoryAddress, "integerEntry", [kRequestLeverage(requestId), leverage], nil)])
464+                        else {
465+                            let accountPublicKey = take(accountsQueue(), queueItemSize)
466+                            let accountAddress = addressFromPublicKey(accountPublicKey)
467+                            let creatorAddress = addressFromPublicKey(valueOrErrorMessage(getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)), wrapErr("invalid creator public key")))
468+                            $Tuple2([ScriptTransfer(creatorAddress, rewardAmount(), unit)], [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), drop(accountsQueue(), queueItemSize)], nil), invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_READY], nil), invoke(factoryAddress, "binaryEntry", [kRequestIdToAccountPublicKey(requestId), accountPublicKey], nil), invoke(factoryAddress, "stringEntry", [kAccountAddressToRequestId(accountAddress), toBase58String(requestId)], nil), invoke(factoryAddress, "integerEntry", [kLeverage(accountAddress), leverage], nil)])
469+                            }
470+                    let actions = $t01823719770._1
471+                    let factoryActions = $t01823719770._2
472+                    $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kRequestOwnerPublicKey(requestId), callerPublicKey], nil), invoke(factoryAddress, "binaryEntry", [kRequestsByOwner(userAddress), (requestsByOwner(userAddress) + requestId)], nil), invoke(factoryAddress, "stringEntry", [kRequestAmountAssetId(requestId), amountAssetIdStr], nil), invoke(factoryAddress, "stringEntry", [kRequestPriceAssetId(requestId), priceAssetIdStr], nil)]))
473+                    }
474+                else throw("Strict value is not equal to itself.")
475+            }
476+        else throw("Strict value is not equal to itself.")
477+    }
478+
479+
480+
481+@Callable(i)
482+func addAccount (callerPublicKey,args) = {
483+    let ckecks = [if (!(shutdown))
484+        then true
485+        else throwErr("not allowed"), mustFactory(i.caller)]
486+    if ((ckecks == ckecks))
487+        then {
488+            let creatorPublicKey = fromBase58String(args[0])
489+            let accountPublicKey = callerPublicKey
490+            let accountAddress = addressFromPublicKey(callerPublicKey)
491+            let creatorAddress = addressFromPublicKey(creatorPublicKey)
492+            let checks = [if ((getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)) == unit))
493+                then true
494+                else throwErr("account is already exists"), if (            match scriptHash(accountAddress) {
495+                case b: ByteVector => 
496+                    (b == blake2b256_32Kb(accountScript()))
497+                case _ => 
498+                    false
499+            })
500+                then true
501+                else throwErr("invalid script")]
502+            if ((checks == checks))
503+                then {
504+                    let $t02102522266 = if ((size(requestsQueue()) == 0))
505+                        then $Tuple2(nil, [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), (accountsQueue() + accountPublicKey)], nil)])
506+                        else {
507+                            let requestId = take(requestsQueue(), queueItemSize)
508+                            let leverage = valueOrErrorMessage(getInteger(factoryAddress, kRequestLeverage(requestId)), wrapErr("request's leverage is undefined"))
509+                            $Tuple2(nil, [invoke(factoryAddress, "integerEntry", [kRequestStatus(requestId), REQUEST_STATUS_READY], nil), invoke(factoryAddress, "binaryEntry", [kRequestIdToAccountPublicKey(requestId), accountPublicKey], nil), invoke(factoryAddress, "binaryEntry", [kRequestsQueue(), drop(requestsQueue(), queueItemSize)], nil), invoke(factoryAddress, "stringEntry", [kAccountAddressToRequestId(accountAddress), toBase58String(requestId)], nil), invoke(factoryAddress, "transferWaves", [creatorAddress.bytes, rewardAmount()], nil), invoke(factoryAddress, "integerEntry", [kLeverage(accountAddress), leverage], nil)])
510+                            }
511+                    let actions = $t02102522266._1
512+                    let factoryActions = $t02102522266._2
513+                    $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kAccountCreatorPublicKey(accountAddress), creatorPublicKey], nil)]))
514+                    }
515+                else throw("Strict value is not equal to itself.")
516+            }
517+        else throw("Strict value is not equal to itself.")
518+    }
519+
520+
521+
522+@Callable(i)
523+func withdraw (callerPublicKey,args) = {
524+    let checks = [if (!(shutdown))
525+        then true
526+        else throwErr("not allowed"), mustFactory(i.caller)]
527+    if ((checks == checks))
528+        then {
529+            let userAddress = addressFromPublicKey(callerPublicKey)
530+            let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
531+            let amount = valueOrErrorMessage(parseInt(args[1]), wrapErr("invalid amount"))
532+            let assetId = parseAssetId(args[2])
533+            let invocations = [invoke(accountAddress, "transferAsset", [userAddress.bytes, amount, assetId], nil)]
534+            $Tuple2(nil, invocations)
535+            }
536+        else throw("Strict value is not equal to itself.")
537+    }
538+
539+
540+
541+@Callable(i)
542+func deposit (callerPublicKey,args) = {
543+    let $t02328723360 = depositINTERNAL(callerPublicKey, args, i)
544+    let actions = $t02328723360._1
545+    let factoryActions = $t02328723360._2
546+    $Tuple2(actions, factoryActions)
547+    }
548+
549+
550+
551+@Callable(i)
552+func borrow (callerPublicKey,args) = {
553+    let $t02351523587 = borrowINTERNAL(callerPublicKey, args, i)
554+    let actions = $t02351523587._1
555+    let factoryActions = $t02351523587._2
556+    $Tuple2(actions, factoryActions)
557+    }
558+
559+
560+
561+@Callable(i)
562+func depositAndBorrow (callerPublicKey,args) = {
563+    let accountAddress = args[0]
564+    let $t02378323882 = depositINTERNAL(callerPublicKey, [accountAddress], i)
565+    let depositActions = $t02378323882._1
566+    let depositFactoryActions = $t02378323882._2
567+    let $t02388523969 = borrowINTERNAL(callerPublicKey, args, i)
568+    let borrowActions = $t02388523969._1
569+    let borrowFactoryActions = $t02388523969._2
570+    $Tuple2((depositActions ++ borrowActions), (depositFactoryActions ++ borrowFactoryActions))
571+    }
572+
573+
574+
575+@Callable(i)
576+func repay (callerPublicKey,args) = {
577+    let ckecks = [if (!(shutdown))
578+        then true
579+        else throwErr("not allowed"), mustFactory(i.caller)]
580+    if ((ckecks == ckecks))
581+        then $Tuple2(nil, unit)
582+        else throw("Strict value is not equal to itself.")
583+    }
584+
585+
586+
587+@Callable(i)
588+func setPairAllowance (callerPublicKey,args) = {
589+    let ckecks = [if (!(shutdown))
590+        then true
591+        else throwErr("not allowed"), mustFactory(i.caller), mustAdmin(callerPublicKey)]
592+    if ((ckecks == ckecks))
593+        then {
594+            let amountAssetIdStr = args[0]
595+            let priceAssetIdStr = args[1]
596+            let allowStr = args[2]
597+            let amountAssetId = parseAssetId(amountAssetIdStr)
598+            let priceAssetId = parseAssetId(priceAssetIdStr)
599+            let allow = (allowStr == "true")
600+            let invocations = [invoke(factoryAddress, "booleanEntry", [kPairAllowed(amountAssetId, priceAssetId), allow], nil)]
601+            $Tuple2(nil, invocations)
602+            }
603+        else throw("Strict value is not equal to itself.")
604+    }
605+
606+
607+
608+@Callable(i)
609+func addSyntheticAsset (callerPublicKey,args) = {
610+    let baseAssetId = parseAssetId(args[0])
611+    let syntheticAssetId = parseAssetId(args[1])
612+    let ckecks = [if (!(shutdown))
613+        then true
614+        else throwErr("not allowed"), mustFactory(i.caller), mustAdmin(callerPublicKey), if ((getString(factoryAddress, kSyntheticAssetId(baseAssetId)) == unit))
615+        then true
616+        else throwErr("invalid base asset"), if ((getString(factoryAddress, kBaseAssetId(syntheticAssetId)) == unit))
617+        then true
618+        else throwErr("invalid synthetic asset")]
619+    if ((ckecks == ckecks))
620+        then {
621+            let invocations = [invoke(factoryAddress, "stringEntry", [kSyntheticAssetId(baseAssetId), assetIdToString(syntheticAssetId)], nil), invoke(factoryAddress, "stringEntry", [kBaseAssetId(syntheticAssetId), assetIdToString(baseAssetId)], nil)]
622+            $Tuple2(nil, invocations)
623+            }
624+        else throw("Strict value is not equal to itself.")
625+    }
626+
627+
628+
629+@Callable(i)
630+func doShutdown (callerPublicKey,args) = {
631+    let checks = [mustFactory(i.caller), mustAdmin(callerPublicKey)]
632+    if ((checks == checks))
633+        then {
634+            let invocations = [invoke(factoryAddress, "booleanEntry", [kShutdown, true], nil)]
635+            $Tuple2(nil, invocations)
636+            }
637+        else throw("Strict value is not equal to itself.")
638+    }
639+
640+
641+
642+@Callable(i)
643+func getAccountInfoREADONLY (callerPublicKey,args) = {
644+    let checks = [mustFactory(i.caller)]
645+    if ((checks == checks))
646+        then {
647+            let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
648+            let data = getAccountInfoInternal(accountAddress)
649+            $Tuple2(nil, data)
650+            }
651+        else throw("Strict value is not equal to itself.")
652+    }
653+
654+
655+
656+@Callable(i)
657+func getUserInfoREADONLY (callerPublicKey,args) = {
658+    let checks = [mustFactory(i.caller)]
659+    if ((checks == checks))
660+        then {
661+            let userAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid user address"))
662+            let userRequests = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(userAddress)), base58'')
663+            let userRequestsNumber = (size(userRequests) / queueItemSize)
664+            func getAccountsData (acc,count) =             {
665+                let $t02690226944 = acc
666+                let accDataList = $t02690226944._1
667+                let rawBytes = $t02690226944._2
668+                let maxSize = $t02690226944._3
669+                if ((maxSize > count))
670+                    then {
671+                        let requestId = take(rawBytes, queueItemSize)
672+                        let newRawBytes = drop(rawBytes, queueItemSize)
673+                        let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
674+                        let accountAddress = addressFromPublicKey(accountPublicKey)
675+                        let data = getAccountInfoInternal(accountAddress)
676+                        $Tuple3((accDataList :+ data), newRawBytes, maxSize)
677+                        }
678+                    else acc
679+                }
680+
681+            let $t02744827553 = {
682+                let $l = INDEX_LIST
683+                let $s = size($l)
684+                let $acc0 = $Tuple3(nil, userRequests, userRequestsNumber)
685+                func $f0_1 ($a,$i) =                 if (($i >= $s))
686+                    then $a
687+                    else getAccountsData($a, $l[$i])
688+
689+                func $f0_2 ($a,$i) =                 if (($i >= $s))
690+                    then $a
691+                    else throw("List size exceeds 20")
692+
693+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
694+                }
695+            let accDataList = $t02744827553._1
696+            let _a = $t02744827553._2
697+            let _b = $t02744827553._3
698+            $Tuple2(nil, accDataList)
699+            }
700+        else throw("Strict value is not equal to itself.")
701+    }
702+
703+
704+
705+@Callable(i)
706+func getPairSettingsInfoREADONLY (callerPublicKey,args) = {
707+    let amountAsset = parseAssetId(args[0])
708+    let priceAsset = parseAssetId(args[1])
709+    let pricesList = getPairPricesList(amountAsset, priceAsset)
710+    func getPairSettings (acc,pricesString) =     {
711+        let settingsKey = kPairSettingsKey(amountAsset, priceAsset, pricesString)
712+        let settingsStringValue = getStringValue(factoryAddress, settingsKey)
713+        let sList = split(settingsStringValue, separator)
714+        let price = parseInt(pricesString)
715+        let maxLeverage = parseInt(sList[1])
716+        let initialMargin = parseInt(sList[2])
717+        let maintenanceMargin = parseInt(sList[3])
718+        (acc :+ $Tuple4(price, maxLeverage, initialMargin, maintenanceMargin))
719+        }
720+
721+    let data = {
722+        let $l = pricesList
723+        let $s = size($l)
724+        let $acc0 = nil
725+        func $f0_1 ($a,$i) =         if (($i >= $s))
726+            then $a
727+            else getPairSettings($a, $l[$i])
728+
729+        func $f0_2 ($a,$i) =         if (($i >= $s))
730+            then $a
731+            else throw("List size exceeds 20")
732+
733+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
734+        }
735+    $Tuple2(nil, data)
736+    }
737+
738+
739+
740+@Callable(i)
741+func editPairSettings (callerPublicKey,args) = {
742+    let checks = [mustFactory(i.caller)]
743+    if ((checks == checks))
744+        then {
745+            let amountAsset = parseAssetId(args[0])
746+            let priceAsset = parseAssetId(args[1])
747+            let price = args[2]
748+            let maxLeverage = args[3]
749+            let initialMargin = args[4]
750+            let maintenanceMargin = args[5]
751+            let pairPricesListKey = kPairPricesListKey(amountAsset, priceAsset)
752+            let settingsKey = kPairSettingsKey(amountAsset, priceAsset, price)
753+            let pricesList = getPairPricesList(amountAsset, priceAsset)
754+            let newList =             match indexOf(pricesList, price) {
755+                case ind: Int => 
756+                    pricesList
757+                case _ => 
758+                    (pricesList :+ price)
759+            }
760+            let check2 = [valueOrErrorMessage(parseInt(price), wrapErr("price value is not an Int")), valueOrErrorMessage(maxLeverage, wrapErr("maxLeverage value is not an Int")), valueOrErrorMessage(initialMargin, wrapErr("initialMargin value is not an Int")), valueOrErrorMessage(maintenanceMargin, wrapErr("maintenanceMargin value is not an Int")), if ((20 >= size(newList)))
761+                then true
762+                else throwErr("exceeded max prices list size (20)")]
763+            if ((check2 == check2))
764+                then {
765+                    let pairSettingValue = makeString(["%s%s%s", maxLeverage, initialMargin, maintenanceMargin], separator)
766+                    let invocations = [invoke(factoryAddress, "stringEntry", [kPairPricesListKey(amountAsset, priceAsset), makeString(newList, separator)], nil), invoke(factoryAddress, "stringEntry", [kPairSettingsKey(amountAsset, priceAsset, price), pairSettingValue], nil)]
767+                    $Tuple2(nil, invocations)
768+                    }
769+                else throw("Strict value is not equal to itself.")
770+            }
771+        else throw("Strict value is not equal to itself.")
772+    }
773+
774+
775+
776+@Callable(i)
777+func deletePairSettings (callerPublicKey,args) = {
778+    let checks = [mustFactory(i.caller)]
779+    if ((checks == checks))
780+        then {
781+            let amountAsset = parseAssetId(args[0])
782+            let priceAsset = parseAssetId(args[1])
783+            let price = args[2]
784+            let settingsKey = kPairSettingsKey(amountAsset, priceAsset, price)
785+            let pairPricesListKey = kPairPricesListKey(amountAsset, priceAsset)
786+            let pricesList = getPairPricesList(amountAsset, priceAsset)
787+            let newList =             match indexOf(pricesList, price) {
788+                case ind: Int => 
789+                    removeByIndex(pricesList, ind)
790+                case _ => 
791+                    pricesList
792+            }
793+            let invocations = [invoke(factoryAddress, "deleteEntry", [settingsKey], nil), if ((size(newList) == 0))
794+                then invoke(factoryAddress, "deleteEntry", [kPairPricesListKey(amountAsset, priceAsset)], nil)
795+                else invoke(factoryAddress, "stringEntry", [kPairPricesListKey(amountAsset, priceAsset), makeString(newList, separator)], nil)]
796+            $Tuple2(nil, invocations)
797+            }
798+        else throw("Strict value is not equal to itself.")
799+    }
800+
801+
802+@Verifier(tx)
803+func verify () = if (if (isDefined(factoryAddressOption))
804+    then isDefined(getString(factoryAddress, kMultisig))
805+    else false)
806+    then     match getString(factoryAddress, kMultisig) {
807+        case multisig: String => 
808+            let statusKey = kStatus(toString(this), toBase58String(tx.id))
809+            let status = valueOrElse(getBoolean(addressFromStringValue(multisig), statusKey), false)
810+            status
811+        case _ => 
812+            false
813+    }
814+    else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
815+
github/deemru/w8io/026f985 
41.06 ms ◑