tx · 9hGMB5qPwWrXz1ZQSnRXpA3W8UZ6LRCeEdiqRwEHuEtd

3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37:  -0.02500000 Waves

2024.07.04 12:14 [3179081] smart account 3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9hGMB5qPwWrXz1ZQSnRXpA3W8UZ6LRCeEdiqRwEHuEtd",
    "fee": 2500000,
    "feeAssetId": null,
    "timestamp": 1720084473014,
    "version": 1,
    "sender": "3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37",
    "senderPublicKey": "vmMXxwQAMUAoisvL193ptPiTtaWQqL5YNu2zs1ouTbY",
    "proofs": [
        "2SdXc1qCrZQDRL2Wyv8aSWpZepRHRD4ek8L3PWZtRZVHfVW4FFDy37x2NBdEAahooA6ja895VJUFo2YShoPdjQSF"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 3179081,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: CSHHEiy4hufRGLfsvCUSWeQN2GXws651cVSAwUnmp1Ho
Next: HTfawEvDjXoyAAMqobWkMwKdrf1whxkMw35grEAo9vjY

Diff: 

OldNewDifferences
554554 
555555 
556556 @Callable(i)
557-func getInfoREADONLY (callerPublicKey,args) = {
557+func getAccountInfoREADONLY (callerPublicKey,args) = {
558558     let checks = [mustFactory(i.caller)]
559559     if ((checks == checks))
560560         then {
561561             let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
562-            let $t02260122669 = getAccountAssets(accountAddress)
563-            let amountAssetId = $t02260122669._1
564-            let priceAssetId = $t02260122669._2
565-            let leverage = toX18(valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined")), 1)
562+            let $t02263322701 = getAccountAssets(accountAddress)
563+            let amountAssetId = $t02263322701._1
564+            let priceAssetId = $t02263322701._2
565+            let leverage = valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined"))
566566             let userAddress = addressFromPublicKey(callerPublicKey)
567567             let requestId = getRequestId(accountAddress)
568568             let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
570570             let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(usdtAssetId))
571571             let creditA = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0), pow10Decimals(amountAssetId))
572572             let creditB = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, usdtAssetId)), 0), pow10Decimals(usdtAssetId))
573-            let data = $Tuple11(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), fromX18(leverage, 1), toBase58String(requestId), deposited, creditA, creditB, toX18(0, pow10Decimals(amountAssetId)), toX18(0, pow10Decimals(usdtAssetId)))
573+            let data = $Tuple11(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), leverage, toBase58String(requestId), deposited, creditA, creditB, toX18(0, pow10Decimals(amountAssetId)), toX18(0, pow10Decimals(usdtAssetId)))
574574             $Tuple2(nil, data)
575575             }
576576         else throw("Strict value is not equal to itself.")

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let separator = "__"
55 
66 let chainId = take(drop(this.bytes, 1), 1)
77 
88 let chainIdW = base58'2W'
99 
1010 let contractFilename = "futures_calculator.ride"
1111 
1212 let mult8 = 100000000
1313 
1414 let mult18BigInt = toBigInt(1000000000000000000)
1515 
1616 let wavesDecimals = 8
1717 
1818 let usdtDecimals = 6
1919 
2020 let wavesString = "WAVES"
2121 
2222 let queueItemSize = 32
2323 
2424 let big0 = toBigInt(0)
2525 
2626 let kMultisig = "%s__multisig"
2727 
2828 func kStatus (dapp,txId) = makeString(["%s__status", dapp, txId], separator)
2929 
3030 
3131 let kShutdown = "%s__shutdown"
3232 
3333 let kPublicKeys = "%s__publicKeys"
3434 
3535 let kMatcherPublicKey = "%s__matcherPublicKey"
3636 
3737 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), mult18BigInt, toBigInt(origScaleMult))
3838 
3939 
4040 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), mult18BigInt))
4141 
4242 
4343 func validateAddress (address) = isDefined(addressFromString(address))
4444 
4545 
4646 func wrapErr (s) = ((contractFilename + ": ") + s)
4747 
4848 
4949 func throwErr (s) = throw(wrapErr(s))
5050 
5151 
5252 func ensurePositive (v,s) = if ((v >= 0))
5353     then v
5454     else throwErr((s + " value should be positive"))
5555 
5656 
5757 func parseAssetId (input) = if ((input == wavesString))
5858     then unit
5959     else fromBase58String(input)
6060 
6161 
6262 func assetIdToString (input) = if ((input == unit))
6363     then wavesString
6464     else toBase58String(value(input))
6565 
6666 
6767 func getAssetInfoOrFail (assetId) = valueOrErrorMessage(assetInfo(assetId), wrapErr("invalid asset info"))
6868 
6969 
7070 func getAssetDecimalsOrFail (assetId) = match assetId {
7171     case _: Unit => 
7272         wavesDecimals
7373     case assetId: ByteVector => 
7474         getAssetInfoOrFail(assetId).decimals
7575     case _ => 
7676         throw("Match error")
7777 }
7878 
7979 
8080 func pow10 (n) = pow(10, 0, n, 0, 0, DOWN)
8181 
8282 
8383 func pow10Decimals (assetId) = pow10(getAssetDecimalsOrFail(assetId))
8484 
8585 
8686 let kFactoryAddress = "%s__factoryAddress"
8787 
8888 let factoryAddressOption = match getString(this, kFactoryAddress) {
8989     case s: String => 
9090         addressFromString(s)
9191     case _: Unit => 
9292         unit
9393     case _ => 
9494         throw("Match error")
9595 }
9696 
9797 let factoryAddress = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
9898 
9999 let kUsdtAssetId = "%s__usdtAssetId"
100100 
101101 let usdtAssetIdOption = match getString(factoryAddress, kUsdtAssetId) {
102102     case s: String => 
103103         parseAssetId(s)
104104     case _: Unit => 
105105         unit
106106     case _ => 
107107         throw("Match error")
108108 }
109109 
110110 let usdtAssetId = valueOrErrorMessage(usdtAssetIdOption, wrapErr("invalid usdt asset id"))
111111 
112112 let kPricesAddress = "%s__calculatorAddress"
113113 
114114 let shutdown = valueOrElse(getBoolean(factoryAddress, kShutdown), false)
115115 
116116 func mustAddress (caller,address) = if ((caller == address))
117117     then true
118118     else throwErr("permission denied")
119119 
120120 
121121 func mustThis (caller) = mustAddress(caller, this)
122122 
123123 
124124 func mustFactory (caller) = mustAddress(caller, factoryAddress)
125125 
126126 
127127 func mustAdmin (callerPublicKey) = {
128128     let multisig = addressFromStringValue(getStringValue(factoryAddress, kMultisig))
129129     let publicKeysList = split(getStringValue(multisig, kPublicKeys), separator)
130130     if (containsElement(publicKeysList, toBase58String(callerPublicKey)))
131131         then true
132132         else throwErr("not allowed")
133133     }
134134 
135135 
136136 let kAccountScript = "%s__accountScript"
137137 
138138 func accountScript () = valueOrErrorMessage(getBinary(factoryAddress, kAccountScript), wrapErr("account script is not set"))
139139 
140140 
141141 let kRewardAmount = "%s__rewardAmount"
142142 
143143 func rewardAmount () = valueOrErrorMessage(getInteger(factoryAddress, kRewardAmount), wrapErr("reward amount is not set"))
144144 
145145 
146146 let kAccountsLimit = "%s__accountsLimit"
147147 
148148 let accountsLimitDefault = 20
149149 
150150 func accountsLimit () = valueOrElse(getInteger(factoryAddress, kAccountsLimit), accountsLimitDefault)
151151 
152152 
153153 func kDeposited (accountAddress) = makeString(["%s%s", "deposited", toString(accountAddress)], separator)
154154 
155155 
156156 func depositedOption (accountAddress) = getInteger(factoryAddress, kDeposited(accountAddress))
157157 
158158 
159159 func kCredit (accountAddress,assetId) = makeString(["%s%s%s", "credit", toString(accountAddress), assetIdToString(assetId)], separator)
160160 
161161 
162162 func creditOption (accountAddress,assetId) = getInteger(factoryAddress, kCredit(accountAddress, assetId))
163163 
164164 
165165 func kLeverage (accountAddress) = makeString(["%s%s", "leverage", toString(accountAddress)], separator)
166166 
167167 
168168 func kRequestLeverage (requestId) = makeString(["%s%s", "requestLeverage", toBase58String(requestId)], separator)
169169 
170170 
171171 func kSyntheticAssetId (baseAssetId) = makeString(["%s%s", "syntheticAssetId", assetIdToString(baseAssetId)], separator)
172172 
173173 
174174 func kBaseAssetId (syntheticAssetId) = makeString(["%s%s", "baseAssetId", assetIdToString(syntheticAssetId)], separator)
175175 
176176 
177177 let REQUEST_STATUS_EMPTY = 0
178178 
179179 let REQUEST_STATUS_READY = 1
180180 
181181 func kRequestStatus (requestId) = makeString(["%s%s", toBase58String(requestId), "status"], separator)
182182 
183183 
184184 func kAccountCreatorPublicKey (accountAddress) = makeString(["%s%s", toString(accountAddress), "creatorPublicKey"], separator)
185185 
186186 
187187 func kRequestOwnerPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "ownerPublicKey"], separator)
188188 
189189 
190190 func kRequestAmountAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "amountAssetId"], separator)
191191 
192192 
193193 func kRequestPriceAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "priceAssetId"], separator)
194194 
195195 
196196 func kRequestIdToAccountPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "requestIdToAccountPublicKey"], separator)
197197 
198198 
199199 func kAccountAddressToRequestId (accountAddress) = makeString(["%s%s", toString(accountAddress), "accountAddressToRequestId"], separator)
200200 
201201 
202202 func kRequestsQueue () = makeString(["%s", "requestsQueue"], separator)
203203 
204204 
205205 func requestsQueue () = valueOrElse(getBinary(factoryAddress, kRequestsQueue()), base58'')
206206 
207207 
208208 func kAccountsQueue () = makeString(["%s", "accountsQueue"], separator)
209209 
210210 
211211 func accountsQueue () = valueOrElse(getBinary(factoryAddress, kAccountsQueue()), base58'')
212212 
213213 
214214 func kRequestsByOwner (ownerAddress) = makeString(["%s%s", "requests", toString(ownerAddress)], separator)
215215 
216216 
217217 func requestsByOwner (ownerAddress) = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(ownerAddress)), base58'')
218218 
219219 
220220 func kPairAllowed (amountAssetId,priceAssetId) = makeString(["%s%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), "pairAllowed"], separator)
221221 
222222 
223223 func pairAllowed (amountAssetId,priceAssetId) = valueOrElse(getBoolean(factoryAddress, kPairAllowed(amountAssetId, priceAssetId)), false)
224224 
225225 
226226 func kPrice (assetId) = makeString(["%s", assetIdToString(assetId)], separator)
227227 
228228 
229229 func getCurrentPrice (assetId) = {
230230     let matcherPublicKey = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kMatcherPublicKey), wrapErr("invalid matcher public key")))
231231     let matcherAddress = addressFromPublicKey(matcherPublicKey)
232232     let price = valueOrErrorMessage(getInteger(matcherAddress, kPrice(assetId)), wrapErr(("invalid price, assetId = " + assetIdToString(assetId))))
233233     price
234234     }
235235 
236236 
237237 func calcTotalCredit (creditA,creditB,currentPrice) = (fraction(creditA, currentPrice, mult18BigInt) + creditB)
238238 
239239 
240240 func calcTotalBalance (balanceA,balanceB,currentPrice) = (fraction(balanceA, currentPrice, mult18BigInt) + balanceB)
241241 
242242 
243243 func calcPnl (totalBalance,totalCredit) = (totalBalance - totalCredit)
244244 
245245 
246246 func calcCreditAvailable (deposit,leverage,totalCredit) = (fraction(deposit, leverage, mult18BigInt) - totalCredit)
247247 
248248 
249249 func calcRealInCredit (credit,balance) = if ((credit > big0))
250250     then (credit - balance)
251251     else big0
252252 
253253 
254254 func calcFree (credit,balance) = if ((credit > big0))
255255     then (balance - credit)
256256     else big0
257257 
258258 
259259 func calcShortPrice (free,realInCredit) = if ((realInCredit > big0))
260260     then max([big0, fraction(free, mult18BigInt, realInCredit)])
261261     else big0
262262 
263263 
264264 func calcLongPrice (free,realInCredit) = if ((realInCredit > big0))
265265     then max([big0, fraction(realInCredit, mult18BigInt, free)])
266266     else big0
267267 
268268 
269269 func calcStartMargin (realInCreditA,realInCreditB,currentPrice,settingsMargin) = fraction((fraction(realInCreditA, currentPrice, mult18BigInt) + realInCreditB), settingsMargin, mult18BigInt)
270270 
271271 
272272 func calcMarginSupply (settingsMarginSupply,settingsMargin,startMargin) = fraction(settingsMarginSupply, startMargin, settingsMargin)
273273 
274274 
275275 func calcLiquidationPrice (deposit,marginSupply,realInCreditA,realInCreditB,shortPrice,longPrice) = {
276276     let liquidationPriceA = if ((realInCreditA > big0))
277277         then (((deposit - marginSupply) / realInCreditA) + shortPrice)
278278         else big0
279279     let liquidationPriceB = if ((realInCreditB > big0))
280280         then (longPrice - ((deposit - marginSupply) / (realInCreditA / longPrice)))
281281         else big0
282282     (liquidationPriceA + liquidationPriceB)
283283     }
284284 
285285 
286286 func getRequestId (accountAddress) = {
287287     let requestId = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kAccountAddressToRequestId(accountAddress)), wrapErr("invalid account address: request id is undefined")))
288288     requestId
289289     }
290290 
291291 
292292 func getAccountAssets (accountAddress) = {
293293     let requestId = getRequestId(accountAddress)
294294     let amountAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kRequestAmountAssetId(requestId)), wrapErr("invalid amount asset id")))
295295     let priceAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kRequestPriceAssetId(requestId)), wrapErr("invalid amount price id")))
296296     $Tuple2(amountAssetId, priceAssetId)
297297     }
298298 
299299 
300300 func getAccountOwnerPublicKey (accountAddress) = {
301301     let requestId = getRequestId(accountAddress)
302302     let requestOwnerPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestOwnerPublicKey(requestId)), wrapErr("invalid amount asset id"))
303303     requestOwnerPublicKey
304304     }
305305 
306306 
307307 @Callable(i)
308308 func init (factoryAddressStr) = {
309309     let checkCaller = mustThis(i.caller)
310310     if ((checkCaller == checkCaller))
311311         then $Tuple2([StringEntry(kFactoryAddress, factoryAddressStr)], unit)
312312         else throw("Strict value is not equal to itself.")
313313     }
314314 
315315 
316316 
317317 @Callable(i)
318318 func requestAccount (callerPublicKey,args) = {
319319     let ckecks = [if (!(shutdown))
320320         then true
321321         else throwErr("not allowed"), mustFactory(i.caller)]
322322     if ((ckecks == ckecks))
323323         then {
324324             let amountAssetIdStr = args[0]
325325             let priceAssetIdStr = args[1]
326326             let leverage = valueOrErrorMessage(parseInt(args[2]), wrapErr("invalid leverage"))
327327             let userAddress = addressFromPublicKey(callerPublicKey)
328328             let requestId = sha256(((userAddress.bytes + fromBase58String(amountAssetIdStr)) + fromBase58String(priceAssetIdStr)))
329329             let amountAssetId = parseAssetId(amountAssetIdStr)
330330             let priceAssetId = parseAssetId(priceAssetIdStr)
331331             let userRequestsNumber = (size(kRequestsByOwner(userAddress)) / queueItemSize)
332332             let checks = [if ((size(i.payments) == 1))
333333                 then true
334334                 else throwErr("1 payment is required"), if ((i.payments[0].assetId == unit))
335335                 then true
336336                 else throwErr("invalid asset"), if ((i.payments[0].amount == rewardAmount()))
337337                 then true
338338                 else throwErr("invalid amount"), if (pairAllowed(amountAssetId, priceAssetId))
339339                 then true
340340                 else throwErr("pair is not allowed"), if ((getInteger(factoryAddress, kRequestStatus(requestId)) == unit))
341341                 then true
342342                 else throwErr("account is already exists"), if ((accountsLimit() > userRequestsNumber))
343343                 then true
344344                 else throwErr(("accounts limit is " + toString(accountsLimit())))]
345345             if ((checks == checks))
346346                 then {
347347                     let $t01176013293 = if ((size(accountsQueue()) == 0))
348348                         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)])
349349                         else {
350350                             let accountPublicKey = take(accountsQueue(), queueItemSize)
351351                             let accountAddress = addressFromPublicKey(accountPublicKey)
352352                             let creatorAddress = addressFromPublicKey(valueOrErrorMessage(getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)), wrapErr("invalid creator public key")))
353353                             $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)])
354354                             }
355355                     let actions = $t01176013293._1
356356                     let factoryActions = $t01176013293._2
357357                     $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)]))
358358                     }
359359                 else throw("Strict value is not equal to itself.")
360360             }
361361         else throw("Strict value is not equal to itself.")
362362     }
363363 
364364 
365365 
366366 @Callable(i)
367367 func addAccount (callerPublicKey,args) = {
368368     let ckecks = [if (!(shutdown))
369369         then true
370370         else throwErr("not allowed"), mustFactory(i.caller)]
371371     if ((ckecks == ckecks))
372372         then {
373373             let creatorPublicKey = fromBase58String(args[0])
374374             let accountPublicKey = callerPublicKey
375375             let accountAddress = addressFromPublicKey(callerPublicKey)
376376             let creatorAddress = addressFromPublicKey(creatorPublicKey)
377377             let checks = [if ((getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)) == unit))
378378                 then true
379379                 else throwErr("account is already exists"), if (            match scriptHash(accountAddress) {
380380                 case b: ByteVector => 
381381                     (b == blake2b256_32Kb(accountScript()))
382382                 case _ => 
383383                     false
384384             })
385385                 then true
386386                 else throwErr("invalid script")]
387387             if ((checks == checks))
388388                 then {
389389                     let $t01454815789 = if ((size(requestsQueue()) == 0))
390390                         then $Tuple2(nil, [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), (accountsQueue() + accountPublicKey)], nil)])
391391                         else {
392392                             let requestId = take(requestsQueue(), queueItemSize)
393393                             let leverage = valueOrErrorMessage(getInteger(factoryAddress, kRequestLeverage(requestId)), wrapErr("request's leverage is undefined"))
394394                             $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)])
395395                             }
396396                     let actions = $t01454815789._1
397397                     let factoryActions = $t01454815789._2
398398                     $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kAccountCreatorPublicKey(accountAddress), creatorPublicKey], nil)]))
399399                     }
400400                 else throw("Strict value is not equal to itself.")
401401             }
402402         else throw("Strict value is not equal to itself.")
403403     }
404404 
405405 
406406 
407407 @Callable(i)
408408 func deposit (callerPublicKey,args) = {
409409     let payment = i.payments[0]
410410     let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
411411     let ckecks = [if (!(shutdown))
412412         then true
413413         else throwErr("not allowed"), mustFactory(i.caller), if ((size(i.payments) == 1))
414414         then true
415415         else throwErr("1 payment is required"), if ((payment.assetId == usdtAssetId))
416416         then true
417417         else throwErr("invalid asset"), if ((getInteger(factoryAddress, kRequestStatus(getRequestId(accountAddress))) == REQUEST_STATUS_READY))
418418         then true
419419         else throwErr("account is not ready")]
420420     if ((ckecks == ckecks))
421421         then {
422422             let actions = [ScriptTransfer(accountAddress, payment.amount, payment.assetId)]
423423             let factoryActions = [invoke(factoryAddress, "integerEntry", [kDeposited(accountAddress), (valueOrElse(depositedOption(accountAddress), 0) + payment.amount)], nil)]
424424             $Tuple2(actions, factoryActions)
425425             }
426426         else throw("Strict value is not equal to itself.")
427427     }
428428 
429429 
430430 
431431 @Callable(i)
432432 func withdraw (callerPublicKey,args) = {
433433     let ckecks = [if (!(shutdown))
434434         then true
435435         else throwErr("not allowed"), mustFactory(i.caller)]
436436     if ((ckecks == ckecks))
437437         then {
438438             let userAddress = addressFromPublicKey(callerPublicKey)
439439             let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
440440             let amount = valueOrErrorMessage(parseInt(args[1]), wrapErr("invalid amount"))
441441             let assetId = parseAssetId(args[2])
442442             let invocations = [invoke(accountAddress, "transferAsset", [userAddress.bytes, amount, assetId], nil)]
443443             $Tuple2(nil, invocations)
444444             }
445445         else throw("Strict value is not equal to itself.")
446446     }
447447 
448448 
449449 
450450 @Callable(i)
451451 func borrow (callerPublicKey,args) = {
452452     let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
453453     let assetIdRequested = parseAssetId(args[1])
454454     let amountRequested = ensurePositive(valueOrErrorMessage(parseInt(args[2]), wrapErr("invalid requested amount")), "requested amount")
455455     let accountOwnerPublicKey = getAccountOwnerPublicKey(accountAddress)
456456     let userAddress = addressFromPublicKey(callerPublicKey)
457457     let ckecks = [if (!(shutdown))
458458         then true
459459         else throwErr("not allowed"), mustFactory(i.caller), if ((callerPublicKey == accountOwnerPublicKey))
460460         then true
461461         else throwErr("can be called by account owner only")]
462462     if ((ckecks == ckecks))
463463         then {
464464             let amountAssetId = getAccountAssets(accountAddress)._1
465465             let deposited = toX18(valueOrElse(depositedOption(accountAddress), 0), pow10Decimals(usdtAssetId))
466466             let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(usdtAssetId))
467467             let creditA = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0), pow10Decimals(amountAssetId))
468468             let creditB = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, usdtAssetId)), 0), pow10Decimals(usdtAssetId))
469469             let totalCredit = calcTotalCredit(creditA, creditB, currentPrice)
470470             let leverage = toX18(valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined")), 1)
471471             let creditAvailableUsdt = calcCreditAvailable(deposited, leverage, totalCredit)
472472             let creditAvailable = if ((assetIdRequested == amountAssetId))
473473                 then fromX18(fraction(creditAvailableUsdt, mult18BigInt, currentPrice), pow10Decimals(amountAssetId))
474474                 else if ((assetIdRequested == usdtAssetId))
475475                     then fromX18(creditAvailableUsdt, pow10Decimals(usdtAssetId))
476476                     else throwErr("invalid requested asset id")
477477             let syntheticAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kSyntheticAssetId(assetIdRequested)), wrapErr("synthetic asset for requested asset is undefined")))
478478             let amountToSend = if ((creditAvailable >= amountRequested))
479479                 then amountRequested
480480                 else throwErr(("credit available = " + toString(creditAvailable)))
481481             let factoryActions = [invoke(factoryAddress, "integerEntry", [kCredit(accountAddress, assetIdRequested), (valueOrElse(creditOption(accountAddress, assetIdRequested), 0) + amountToSend)], nil), invoke(factoryAddress, "transferAsset", [userAddress.bytes, amountToSend, syntheticAssetId], nil)]
482482             $Tuple2(nil, [factoryActions, creditAvailable])
483483             }
484484         else throw("Strict value is not equal to itself.")
485485     }
486486 
487487 
488488 
489489 @Callable(i)
490490 func repay (callerPublicKey,args) = {
491491     let ckecks = [if (!(shutdown))
492492         then true
493493         else throwErr("not allowed"), mustFactory(i.caller)]
494494     if ((ckecks == ckecks))
495495         then $Tuple2(nil, unit)
496496         else throw("Strict value is not equal to itself.")
497497     }
498498 
499499 
500500 
501501 @Callable(i)
502502 func setPairAllowance (callerPublicKey,args) = {
503503     let ckecks = [if (!(shutdown))
504504         then true
505505         else throwErr("not allowed"), mustFactory(i.caller), mustAdmin(callerPublicKey)]
506506     if ((ckecks == ckecks))
507507         then {
508508             let amountAssetIdStr = args[0]
509509             let priceAssetIdStr = args[1]
510510             let allowStr = args[2]
511511             let amountAssetId = parseAssetId(amountAssetIdStr)
512512             let priceAssetId = parseAssetId(priceAssetIdStr)
513513             let allow = (allowStr == "true")
514514             let invocations = [invoke(factoryAddress, "booleanEntry", [kPairAllowed(amountAssetId, priceAssetId), allow], nil)]
515515             $Tuple2(nil, invocations)
516516             }
517517         else throw("Strict value is not equal to itself.")
518518     }
519519 
520520 
521521 
522522 @Callable(i)
523523 func addSyntheticAsset (callerPublicKey,args) = {
524524     let baseAssetId = parseAssetId(args[0])
525525     let syntheticAssetId = parseAssetId(args[1])
526526     let ckecks = [if (!(shutdown))
527527         then true
528528         else throwErr("not allowed"), mustFactory(i.caller), mustAdmin(callerPublicKey), if ((getString(factoryAddress, kSyntheticAssetId(baseAssetId)) == unit))
529529         then true
530530         else throwErr("invalid base asset"), if ((getString(factoryAddress, kBaseAssetId(syntheticAssetId)) == unit))
531531         then true
532532         else throwErr("invalid synthetic asset")]
533533     if ((ckecks == ckecks))
534534         then {
535535             let invocations = [invoke(factoryAddress, "stringEntry", [kSyntheticAssetId(baseAssetId), assetIdToString(syntheticAssetId)], nil), invoke(factoryAddress, "stringEntry", [kBaseAssetId(syntheticAssetId), assetIdToString(baseAssetId)], nil)]
536536             $Tuple2(nil, invocations)
537537             }
538538         else throw("Strict value is not equal to itself.")
539539     }
540540 
541541 
542542 
543543 @Callable(i)
544544 func doShutdown (callerPublicKey,args) = {
545545     let checks = [mustFactory(i.caller), mustAdmin(callerPublicKey)]
546546     if ((checks == checks))
547547         then {
548548             let invocations = [invoke(factoryAddress, "booleanEntry", [kShutdown, true], nil)]
549549             $Tuple2(nil, invocations)
550550             }
551551         else throw("Strict value is not equal to itself.")
552552     }
553553 
554554 
555555 
556556 @Callable(i)
557-func getInfoREADONLY (callerPublicKey,args) = {
557+func getAccountInfoREADONLY (callerPublicKey,args) = {
558558     let checks = [mustFactory(i.caller)]
559559     if ((checks == checks))
560560         then {
561561             let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
562-            let $t02260122669 = getAccountAssets(accountAddress)
563-            let amountAssetId = $t02260122669._1
564-            let priceAssetId = $t02260122669._2
565-            let leverage = toX18(valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined")), 1)
562+            let $t02263322701 = getAccountAssets(accountAddress)
563+            let amountAssetId = $t02263322701._1
564+            let priceAssetId = $t02263322701._2
565+            let leverage = valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined"))
566566             let userAddress = addressFromPublicKey(callerPublicKey)
567567             let requestId = getRequestId(accountAddress)
568568             let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
569569             let deposited = toX18(valueOrElse(depositedOption(accountAddress), 0), pow10Decimals(usdtAssetId))
570570             let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(usdtAssetId))
571571             let creditA = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0), pow10Decimals(amountAssetId))
572572             let creditB = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, usdtAssetId)), 0), pow10Decimals(usdtAssetId))
573-            let data = $Tuple11(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), fromX18(leverage, 1), toBase58String(requestId), deposited, creditA, creditB, toX18(0, pow10Decimals(amountAssetId)), toX18(0, pow10Decimals(usdtAssetId)))
573+            let data = $Tuple11(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), leverage, toBase58String(requestId), deposited, creditA, creditB, toX18(0, pow10Decimals(amountAssetId)), toX18(0, pow10Decimals(usdtAssetId)))
574574             $Tuple2(nil, data)
575575             }
576576         else throw("Strict value is not equal to itself.")
577577     }
578578 
579579 
580580 @Verifier(tx)
581581 func verify () = if (if (isDefined(factoryAddressOption))
582582     then isDefined(getString(factoryAddress, kMultisig))
583583     else false)
584584     then     match getString(factoryAddress, kMultisig) {
585585         case multisig: String => 
586586             let statusKey = kStatus(toString(this), toBase58String(tx.id))
587587             let status = valueOrElse(getBoolean(addressFromStringValue(multisig), statusKey), false)
588588             status
589589         case _ => 
590590             false
591591     }
592592     else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
593593 
github/deemru/w8io/026f985 
84.67 ms ◑