tx · BoQFhvXxcDFC6HT6meRxoiq2Mn8VqVAP1UhTGCvLx69w

3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37:  -0.02900000 Waves

2024.07.25 16:11 [3209635] smart account 3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BoQFhvXxcDFC6HT6meRxoiq2Mn8VqVAP1UhTGCvLx69w",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1721913071738,
    "version": 1,
    "sender": "3N3kKNoJohjVQYNLTrYTGTesr3nq3PZNh37",
    "senderPublicKey": "vmMXxwQAMUAoisvL193ptPiTtaWQqL5YNu2zs1ouTbY",
    "proofs": [
        "3bXaoberfMm7eYNLVMTV5zP8vWFQig75MXk8XVBNLBYvEckw5h9Dk4gcNeCtmvFNBBaauYydwBtTo2CoCQ2rw37C"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 3209635,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 4nXj1QNCDqkbazwVwiK3g7BYJAx814Jmx574L4dBXxa9
Next: 8zzMcAZTqhdJkLuVs6TBUdssS2ha1THPrBPRfoma5arf

Diff: 

OldNewDifferences
2222 let queueItemSize = 32
2323 
2424 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]
2527 
2628 let kMultisig = "%s__multisig"
2729 
236238 func kPrice (assetId) = makeString(["%s", assetIdToString(assetId)], separator)
237239 
238240 
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%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), priceString, "settings"], separator)
253+
254+
239255 func getCurrentPrice (assetId) = {
240256     let matcherPublicKey = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kMatcherPublicKey), wrapErr("invalid matcher public key")))
241257     let matcherAddress = addressFromPublicKey(matcherPublicKey)
315331 
316332 
317333 func getAccountInfoInternal (accountAddress) = {
318-    let $t01038510453 = getAccountAssets(accountAddress)
319-    let amountAssetId = $t01038510453._1
320-    let priceAssetId = $t01038510453._2
334+    let $t01118711255 = getAccountAssets(accountAddress)
335+    let amountAssetId = $t01118711255._1
336+    let priceAssetId = $t01118711255._2
321337     let leverage = valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined"))
322338     let requestId = getRequestId(accountAddress)
323339     let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
326342     let creditA = valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0)
327343     let creditB = valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, priceAssetId)), 0)
328344     let status = valueOrErrorMessage(getInteger(factoryAddress, kRequestStatus(requestId)), ("status not found. RequestId = " + toBase58String(requestId)))
329-    $Tuple12(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), leverage, toBase58String(requestId), deposited, creditA, creditB, getAssetBalance(amountAssetId, accountAddress), getAssetBalance(priceAssetId, accountAddress), status)
345+    $Tuple12(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), leverage, toBase58String(requestId), deposited, creditA, creditB, getAssetBalance(parseAssetId(kSyntheticAssetId(amountAssetId)), accountAddress), getAssetBalance(parseAssetId(kSyntheticAssetId(priceAssetId)), accountAddress), status)
330346     }
331347 
332348 
370386                 else throwErr(("accounts limit is " + toString(accountsLimit())))]
371387             if ((checks == checks))
372388                 then {
373-                    let $t01328714820 = if ((size(accountsQueue()) == 0))
389+                    let $t01415715690 = if ((size(accountsQueue()) == 0))
374390                         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)])
375391                         else {
376392                             let accountPublicKey = take(accountsQueue(), queueItemSize)
378394                             let creatorAddress = addressFromPublicKey(valueOrErrorMessage(getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)), wrapErr("invalid creator public key")))
379395                             $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)])
380396                             }
381-                    let actions = $t01328714820._1
382-                    let factoryActions = $t01328714820._2
397+                    let actions = $t01415715690._1
398+                    let factoryActions = $t01415715690._2
383399                     $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)]))
384400                     }
385401                 else throw("Strict value is not equal to itself.")
412428                 else throwErr("invalid script")]
413429             if ((checks == checks))
414430                 then {
415-                    let $t01607517316 = if ((size(requestsQueue()) == 0))
431+                    let $t01694518186 = if ((size(requestsQueue()) == 0))
416432                         then $Tuple2(nil, [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), (accountsQueue() + accountPublicKey)], nil)])
417433                         else {
418434                             let requestId = take(requestsQueue(), queueItemSize)
419435                             let leverage = valueOrErrorMessage(getInteger(factoryAddress, kRequestLeverage(requestId)), wrapErr("request's leverage is undefined"))
420436                             $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)])
421437                             }
422-                    let actions = $t01607517316._1
423-                    let factoryActions = $t01607517316._2
438+                    let actions = $t01694518186._1
439+                    let factoryActions = $t01694518186._2
424440                     $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kAccountCreatorPublicKey(accountAddress), creatorPublicKey], nil)]))
425441                     }
426442                 else throw("Strict value is not equal to itself.")
601617             let userAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid user address"))
602618             let userRequests = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(userAddress)), base58'')
603619             let userRequestsNumber = (size(userRequests) / queueItemSize)
604-            let nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
605620             func getAccountsData (acc,count) =             {
606-                let $t02483724879 = acc
607-                let accDataList = $t02483724879._1
608-                let rawBytes = $t02483724879._2
609-                let maxSize = $t02483724879._3
621+                let $t02562225664 = acc
622+                let accDataList = $t02562225664._1
623+                let rawBytes = $t02562225664._2
624+                let maxSize = $t02562225664._3
610625                 if ((maxSize > count))
611626                     then {
612627                         let requestId = take(rawBytes, queueItemSize)
619634                     else acc
620635                 }
621636 
622-            let $t02538325482 = {
623-                let $l = nums
637+            let $t02616826273 = {
638+                let $l = INDEX_LIST
624639                 let $s = size($l)
625640                 let $acc0 = $Tuple3(nil, userRequests, userRequestsNumber)
626641                 func $f0_1 ($a,$i) =                 if (($i >= $s))
633648 
634649                 $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)
635650                 }
636-            let accDataList = $t02538325482._1
637-            let _a = $t02538325482._2
638-            let _b = $t02538325482._3
651+            let accDataList = $t02616826273._1
652+            let _a = $t02616826273._2
653+            let _b = $t02616826273._3
639654             $Tuple2(nil, accDataList)
655+            }
656+        else throw("Strict value is not equal to itself.")
657+    }
658+
659+
660+
661+@Callable(i)
662+func deletePairSetting (callerPublicKey,args) = {
663+    let checks = [mustFactory(i.caller), mustAdmin(callerPublicKey)]
664+    if ((checks == checks))
665+        then {
666+            let amountAsset = parseAssetId(args[0])
667+            let priceAsset = parseAssetId(args[1])
668+            let price = args[2]
669+            let settingsKey = kPairSettingsKey(amountAsset, priceAsset, price)
670+            let pairPricesListKey = kPairPricesListKey(amountAsset, priceAsset)
671+            let pricesList = getPairPricesList(amountAsset, priceAsset)
672+            let newList =             match indexOf(pricesList, price) {
673+                case ind: Int => 
674+                    removeByIndex(pricesList, ind)
675+                case _ => 
676+                    pricesList
677+            }
678+            let invocations = [invoke(factoryAddress, "deleteEntry", [settingsKey], nil), if ((size(newList) == 0))
679+                then invoke(factoryAddress, "deleteEntry", [kPairPricesListKey(amountAsset, priceAsset)], nil)
680+                else invoke(factoryAddress, "stringEntry", [kPairPricesListKey(amountAsset, priceAsset), makeString(newList, separator)], nil)]
681+            $Tuple2(nil, invocations)
640682             }
641683         else throw("Strict value is not equal to itself.")
642684     }

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)
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]
2527 
2628 let kMultisig = "%s__multisig"
2729 
2830 func kStatus (dapp,txId) = makeString(["%s__status", dapp, txId], separator)
2931 
3032 
3133 let kShutdown = "%s__shutdown"
3234 
3335 let kPublicKeys = "%s__publicKeys"
3436 
3537 let kMatcherPublicKey = "%s__matcherPublicKey"
3638 
3739 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), mult18BigInt, toBigInt(origScaleMult))
3840 
3941 
4042 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), mult18BigInt))
4143 
4244 
4345 func validateAddress (address) = isDefined(addressFromString(address))
4446 
4547 
4648 func wrapErr (s) = ((contractFilename + ": ") + s)
4749 
4850 
4951 func throwErr (s) = throw(wrapErr(s))
5052 
5153 
5254 func ensurePositive (v,s) = if ((v >= 0))
5355     then v
5456     else throwErr((s + " value should be positive"))
5557 
5658 
5759 func parseAssetId (input) = if ((input == wavesString))
5860     then unit
5961     else fromBase58String(input)
6062 
6163 
6264 func assetIdToString (input) = if ((input == unit))
6365     then wavesString
6466     else toBase58String(value(input))
6567 
6668 
6769 func getAssetInfoOrFail (assetId) = valueOrErrorMessage(assetInfo(assetId), wrapErr("invalid asset info"))
6870 
6971 
7072 func getAssetDecimalsOrFail (assetId) = match assetId {
7173     case _: Unit => 
7274         wavesDecimals
7375     case assetId: ByteVector => 
7476         getAssetInfoOrFail(assetId).decimals
7577     case _ => 
7678         throw("Match error")
7779 }
7880 
7981 
8082 func getAssetBalance (assetId,address) = match assetId {
8183     case _: Unit => 
8284         wavesBalance(address).available
8385     case assetId: ByteVector => 
8486         assetBalance(address, assetId)
8587     case _ => 
8688         throw("Match error")
8789 }
8890 
8991 
9092 func pow10 (n) = pow(10, 0, n, 0, 0, DOWN)
9193 
9294 
9395 func pow10Decimals (assetId) = pow10(getAssetDecimalsOrFail(assetId))
9496 
9597 
9698 let kFactoryAddress = "%s__factoryAddress"
9799 
98100 let factoryAddressOption = match getString(this, kFactoryAddress) {
99101     case s: String => 
100102         addressFromString(s)
101103     case _: Unit => 
102104         unit
103105     case _ => 
104106         throw("Match error")
105107 }
106108 
107109 let factoryAddress = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
108110 
109111 let kUsdtAssetId = "%s__usdtAssetId"
110112 
111113 let usdtAssetIdOption = match getString(factoryAddress, kUsdtAssetId) {
112114     case s: String => 
113115         parseAssetId(s)
114116     case _: Unit => 
115117         unit
116118     case _ => 
117119         throw("Match error")
118120 }
119121 
120122 let usdtAssetId = valueOrErrorMessage(usdtAssetIdOption, wrapErr("invalid usdt asset id"))
121123 
122124 let kPricesAddress = "%s__calculatorAddress"
123125 
124126 let shutdown = valueOrElse(getBoolean(factoryAddress, kShutdown), false)
125127 
126128 func mustAddress (caller,address) = if ((caller == address))
127129     then true
128130     else throwErr("permission denied")
129131 
130132 
131133 func mustThis (caller) = mustAddress(caller, this)
132134 
133135 
134136 func mustFactory (caller) = mustAddress(caller, factoryAddress)
135137 
136138 
137139 func mustAdmin (callerPublicKey) = {
138140     let multisig = addressFromStringValue(getStringValue(factoryAddress, kMultisig))
139141     let publicKeysList = split(getStringValue(multisig, kPublicKeys), separator)
140142     if (containsElement(publicKeysList, toBase58String(callerPublicKey)))
141143         then true
142144         else throwErr("not allowed")
143145     }
144146 
145147 
146148 let kAccountScript = "%s__accountScript"
147149 
148150 func accountScript () = valueOrErrorMessage(getBinary(factoryAddress, kAccountScript), wrapErr("account script is not set"))
149151 
150152 
151153 let kRewardAmount = "%s__rewardAmount"
152154 
153155 func rewardAmount () = valueOrErrorMessage(getInteger(factoryAddress, kRewardAmount), wrapErr("reward amount is not set"))
154156 
155157 
156158 let kAccountsLimit = "%s__accountsLimit"
157159 
158160 let accountsLimitDefault = 20
159161 
160162 func accountsLimit () = valueOrElse(getInteger(factoryAddress, kAccountsLimit), accountsLimitDefault)
161163 
162164 
163165 func kDeposited (accountAddress) = makeString(["%s%s", "deposited", toString(accountAddress)], separator)
164166 
165167 
166168 func depositedOption (accountAddress) = getInteger(factoryAddress, kDeposited(accountAddress))
167169 
168170 
169171 func kCredit (accountAddress,assetId) = makeString(["%s%s%s", "credit", toString(accountAddress), assetIdToString(assetId)], separator)
170172 
171173 
172174 func creditOption (accountAddress,assetId) = getInteger(factoryAddress, kCredit(accountAddress, assetId))
173175 
174176 
175177 func kLeverage (accountAddress) = makeString(["%s%s", "leverage", toString(accountAddress)], separator)
176178 
177179 
178180 func kRequestLeverage (requestId) = makeString(["%s%s", "requestLeverage", toBase58String(requestId)], separator)
179181 
180182 
181183 func kSyntheticAssetId (baseAssetId) = makeString(["%s%s", "syntheticAssetId", assetIdToString(baseAssetId)], separator)
182184 
183185 
184186 func kBaseAssetId (syntheticAssetId) = makeString(["%s%s", "baseAssetId", assetIdToString(syntheticAssetId)], separator)
185187 
186188 
187189 let REQUEST_STATUS_EMPTY = 0
188190 
189191 let REQUEST_STATUS_READY = 1
190192 
191193 func kRequestStatus (requestId) = makeString(["%s%s", toBase58String(requestId), "status"], separator)
192194 
193195 
194196 func kAccountCreatorPublicKey (accountAddress) = makeString(["%s%s", toString(accountAddress), "creatorPublicKey"], separator)
195197 
196198 
197199 func kRequestOwnerPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "ownerPublicKey"], separator)
198200 
199201 
200202 func kRequestAmountAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "amountAssetId"], separator)
201203 
202204 
203205 func kRequestPriceAssetId (requestId) = makeString(["%s%s", toBase58String(requestId), "priceAssetId"], separator)
204206 
205207 
206208 func kRequestIdToAccountPublicKey (requestId) = makeString(["%s%s", toBase58String(requestId), "requestIdToAccountPublicKey"], separator)
207209 
208210 
209211 func kAccountAddressToRequestId (accountAddress) = makeString(["%s%s", toString(accountAddress), "accountAddressToRequestId"], separator)
210212 
211213 
212214 func kRequestsQueue () = makeString(["%s", "requestsQueue"], separator)
213215 
214216 
215217 func requestsQueue () = valueOrElse(getBinary(factoryAddress, kRequestsQueue()), base58'')
216218 
217219 
218220 func kAccountsQueue () = makeString(["%s", "accountsQueue"], separator)
219221 
220222 
221223 func accountsQueue () = valueOrElse(getBinary(factoryAddress, kAccountsQueue()), base58'')
222224 
223225 
224226 func kRequestsByOwner (ownerAddress) = makeString(["%s%s", "requests", toString(ownerAddress)], separator)
225227 
226228 
227229 func requestsByOwner (ownerAddress) = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(ownerAddress)), base58'')
228230 
229231 
230232 func kPairAllowed (amountAssetId,priceAssetId) = makeString(["%s%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), "pairAllowed"], separator)
231233 
232234 
233235 func pairAllowed (amountAssetId,priceAssetId) = valueOrElse(getBoolean(factoryAddress, kPairAllowed(amountAssetId, priceAssetId)), false)
234236 
235237 
236238 func kPrice (assetId) = makeString(["%s", assetIdToString(assetId)], separator)
237239 
238240 
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%s%s", assetIdToString(amountAssetId), assetIdToString(priceAssetId), priceString, "settings"], separator)
253+
254+
239255 func getCurrentPrice (assetId) = {
240256     let matcherPublicKey = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kMatcherPublicKey), wrapErr("invalid matcher public key")))
241257     let matcherAddress = addressFromPublicKey(matcherPublicKey)
242258     let price = valueOrErrorMessage(getInteger(matcherAddress, kPrice(assetId)), wrapErr(("invalid price, assetId = " + assetIdToString(assetId))))
243259     price
244260     }
245261 
246262 
247263 func calcTotalCredit (creditA,creditB,currentPrice) = (fraction(creditA, currentPrice, mult18BigInt) + creditB)
248264 
249265 
250266 func calcTotalBalance (balanceA,balanceB,currentPrice) = (fraction(balanceA, currentPrice, mult18BigInt) + balanceB)
251267 
252268 
253269 func calcPnl (totalBalance,totalCredit) = (totalBalance - totalCredit)
254270 
255271 
256272 func calcCreditAvailable (deposit,leverage,totalCredit) = (fraction(deposit, leverage, mult18BigInt) - totalCredit)
257273 
258274 
259275 func calcRealInCredit (credit,balance) = if ((credit > big0))
260276     then (credit - balance)
261277     else big0
262278 
263279 
264280 func calcFree (credit,balance) = if ((credit > big0))
265281     then (balance - credit)
266282     else big0
267283 
268284 
269285 func calcShortPrice (free,realInCredit) = if ((realInCredit > big0))
270286     then max([big0, fraction(free, mult18BigInt, realInCredit)])
271287     else big0
272288 
273289 
274290 func calcLongPrice (free,realInCredit) = if ((realInCredit > big0))
275291     then max([big0, fraction(realInCredit, mult18BigInt, free)])
276292     else big0
277293 
278294 
279295 func calcStartMargin (realInCreditA,realInCreditB,currentPrice,settingsMargin) = fraction((fraction(realInCreditA, currentPrice, mult18BigInt) + realInCreditB), settingsMargin, mult18BigInt)
280296 
281297 
282298 func calcMarginSupply (settingsMarginSupply,settingsMargin,startMargin) = fraction(settingsMarginSupply, startMargin, settingsMargin)
283299 
284300 
285301 func calcLiquidationPrice (deposit,marginSupply,realInCreditA,realInCreditB,shortPrice,longPrice) = {
286302     let liquidationPriceA = if ((realInCreditA > big0))
287303         then (((deposit - marginSupply) / realInCreditA) + shortPrice)
288304         else big0
289305     let liquidationPriceB = if ((realInCreditB > big0))
290306         then (longPrice - ((deposit - marginSupply) / (realInCreditA / longPrice)))
291307         else big0
292308     (liquidationPriceA + liquidationPriceB)
293309     }
294310 
295311 
296312 func getRequestId (accountAddress) = {
297313     let requestId = fromBase58String(valueOrErrorMessage(getString(factoryAddress, kAccountAddressToRequestId(accountAddress)), wrapErr("invalid account address: request id is undefined")))
298314     requestId
299315     }
300316 
301317 
302318 func getAccountAssets (accountAddress) = {
303319     let requestId = getRequestId(accountAddress)
304320     let amountAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kRequestAmountAssetId(requestId)), wrapErr("invalid amount asset id")))
305321     let priceAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kRequestPriceAssetId(requestId)), wrapErr("invalid amount price id")))
306322     $Tuple2(amountAssetId, priceAssetId)
307323     }
308324 
309325 
310326 func getAccountOwnerPublicKey (accountAddress) = {
311327     let requestId = getRequestId(accountAddress)
312328     let requestOwnerPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestOwnerPublicKey(requestId)), wrapErr("invalid amount asset id"))
313329     requestOwnerPublicKey
314330     }
315331 
316332 
317333 func getAccountInfoInternal (accountAddress) = {
318-    let $t01038510453 = getAccountAssets(accountAddress)
319-    let amountAssetId = $t01038510453._1
320-    let priceAssetId = $t01038510453._2
334+    let $t01118711255 = getAccountAssets(accountAddress)
335+    let amountAssetId = $t01118711255._1
336+    let priceAssetId = $t01118711255._2
321337     let leverage = valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined"))
322338     let requestId = getRequestId(accountAddress)
323339     let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
324340     let deposited = valueOrElse(depositedOption(accountAddress), 0)
325341     let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(priceAssetId))
326342     let creditA = valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0)
327343     let creditB = valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, priceAssetId)), 0)
328344     let status = valueOrErrorMessage(getInteger(factoryAddress, kRequestStatus(requestId)), ("status not found. RequestId = " + toBase58String(requestId)))
329-    $Tuple12(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), leverage, toBase58String(requestId), deposited, creditA, creditB, getAssetBalance(amountAssetId, accountAddress), getAssetBalance(priceAssetId, accountAddress), status)
345+    $Tuple12(assetIdToString(amountAssetId), assetIdToString(priceAssetId), toString(accountAddress), toBase58String(accountPublicKey), leverage, toBase58String(requestId), deposited, creditA, creditB, getAssetBalance(parseAssetId(kSyntheticAssetId(amountAssetId)), accountAddress), getAssetBalance(parseAssetId(kSyntheticAssetId(priceAssetId)), accountAddress), status)
330346     }
331347 
332348 
333349 @Callable(i)
334350 func init (factoryAddressStr) = {
335351     let checkCaller = mustThis(i.caller)
336352     if ((checkCaller == checkCaller))
337353         then $Tuple2([StringEntry(kFactoryAddress, factoryAddressStr)], unit)
338354         else throw("Strict value is not equal to itself.")
339355     }
340356 
341357 
342358 
343359 @Callable(i)
344360 func requestAccount (callerPublicKey,args) = {
345361     let ckecks = [if (!(shutdown))
346362         then true
347363         else throwErr("not allowed"), mustFactory(i.caller)]
348364     if ((ckecks == ckecks))
349365         then {
350366             let amountAssetIdStr = args[0]
351367             let priceAssetIdStr = args[1]
352368             let leverage = valueOrErrorMessage(parseInt(args[2]), wrapErr("invalid leverage"))
353369             let userAddress = addressFromPublicKey(callerPublicKey)
354370             let requestId = sha256(((userAddress.bytes + fromBase58String(amountAssetIdStr)) + fromBase58String(priceAssetIdStr)))
355371             let amountAssetId = parseAssetId(amountAssetIdStr)
356372             let priceAssetId = parseAssetId(priceAssetIdStr)
357373             let userRequestsNumber = (size(kRequestsByOwner(userAddress)) / queueItemSize)
358374             let checks = [if ((size(i.payments) == 1))
359375                 then true
360376                 else throwErr("1 payment is required"), if ((i.payments[0].assetId == unit))
361377                 then true
362378                 else throwErr("invalid asset"), if ((i.payments[0].amount == rewardAmount()))
363379                 then true
364380                 else throwErr("invalid amount"), if (pairAllowed(amountAssetId, priceAssetId))
365381                 then true
366382                 else throwErr("pair is not allowed"), if ((getInteger(factoryAddress, kRequestStatus(requestId)) == unit))
367383                 then true
368384                 else throwErr("account is already exists"), if ((accountsLimit() > userRequestsNumber))
369385                 then true
370386                 else throwErr(("accounts limit is " + toString(accountsLimit())))]
371387             if ((checks == checks))
372388                 then {
373-                    let $t01328714820 = if ((size(accountsQueue()) == 0))
389+                    let $t01415715690 = if ((size(accountsQueue()) == 0))
374390                         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)])
375391                         else {
376392                             let accountPublicKey = take(accountsQueue(), queueItemSize)
377393                             let accountAddress = addressFromPublicKey(accountPublicKey)
378394                             let creatorAddress = addressFromPublicKey(valueOrErrorMessage(getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)), wrapErr("invalid creator public key")))
379395                             $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)])
380396                             }
381-                    let actions = $t01328714820._1
382-                    let factoryActions = $t01328714820._2
397+                    let actions = $t01415715690._1
398+                    let factoryActions = $t01415715690._2
383399                     $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)]))
384400                     }
385401                 else throw("Strict value is not equal to itself.")
386402             }
387403         else throw("Strict value is not equal to itself.")
388404     }
389405 
390406 
391407 
392408 @Callable(i)
393409 func addAccount (callerPublicKey,args) = {
394410     let ckecks = [if (!(shutdown))
395411         then true
396412         else throwErr("not allowed"), mustFactory(i.caller)]
397413     if ((ckecks == ckecks))
398414         then {
399415             let creatorPublicKey = fromBase58String(args[0])
400416             let accountPublicKey = callerPublicKey
401417             let accountAddress = addressFromPublicKey(callerPublicKey)
402418             let creatorAddress = addressFromPublicKey(creatorPublicKey)
403419             let checks = [if ((getBinary(factoryAddress, kAccountCreatorPublicKey(accountAddress)) == unit))
404420                 then true
405421                 else throwErr("account is already exists"), if (            match scriptHash(accountAddress) {
406422                 case b: ByteVector => 
407423                     (b == blake2b256_32Kb(accountScript()))
408424                 case _ => 
409425                     false
410426             })
411427                 then true
412428                 else throwErr("invalid script")]
413429             if ((checks == checks))
414430                 then {
415-                    let $t01607517316 = if ((size(requestsQueue()) == 0))
431+                    let $t01694518186 = if ((size(requestsQueue()) == 0))
416432                         then $Tuple2(nil, [invoke(factoryAddress, "binaryEntry", [kAccountsQueue(), (accountsQueue() + accountPublicKey)], nil)])
417433                         else {
418434                             let requestId = take(requestsQueue(), queueItemSize)
419435                             let leverage = valueOrErrorMessage(getInteger(factoryAddress, kRequestLeverage(requestId)), wrapErr("request's leverage is undefined"))
420436                             $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)])
421437                             }
422-                    let actions = $t01607517316._1
423-                    let factoryActions = $t01607517316._2
438+                    let actions = $t01694518186._1
439+                    let factoryActions = $t01694518186._2
424440                     $Tuple2(actions, (factoryActions ++ [invoke(factoryAddress, "binaryEntry", [kAccountCreatorPublicKey(accountAddress), creatorPublicKey], nil)]))
425441                     }
426442                 else throw("Strict value is not equal to itself.")
427443             }
428444         else throw("Strict value is not equal to itself.")
429445     }
430446 
431447 
432448 
433449 @Callable(i)
434450 func deposit (callerPublicKey,args) = {
435451     let payment = i.payments[0]
436452     let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
437453     let ckecks = [if (!(shutdown))
438454         then true
439455         else throwErr("not allowed"), mustFactory(i.caller), if ((size(i.payments) == 1))
440456         then true
441457         else throwErr("1 payment is required"), if ((payment.assetId == usdtAssetId))
442458         then true
443459         else throwErr("invalid asset"), if ((getInteger(factoryAddress, kRequestStatus(getRequestId(accountAddress))) == REQUEST_STATUS_READY))
444460         then true
445461         else throwErr("account is not ready")]
446462     if ((ckecks == ckecks))
447463         then {
448464             let actions = [ScriptTransfer(accountAddress, payment.amount, payment.assetId)]
449465             let factoryActions = [invoke(factoryAddress, "integerEntry", [kDeposited(accountAddress), (valueOrElse(depositedOption(accountAddress), 0) + payment.amount)], nil)]
450466             $Tuple2(actions, factoryActions)
451467             }
452468         else throw("Strict value is not equal to itself.")
453469     }
454470 
455471 
456472 
457473 @Callable(i)
458474 func withdraw (callerPublicKey,args) = {
459475     let ckecks = [if (!(shutdown))
460476         then true
461477         else throwErr("not allowed"), mustFactory(i.caller)]
462478     if ((ckecks == ckecks))
463479         then {
464480             let userAddress = addressFromPublicKey(callerPublicKey)
465481             let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
466482             let amount = valueOrErrorMessage(parseInt(args[1]), wrapErr("invalid amount"))
467483             let assetId = parseAssetId(args[2])
468484             let invocations = [invoke(accountAddress, "transferAsset", [userAddress.bytes, amount, assetId], nil)]
469485             $Tuple2(nil, invocations)
470486             }
471487         else throw("Strict value is not equal to itself.")
472488     }
473489 
474490 
475491 
476492 @Callable(i)
477493 func borrow (callerPublicKey,args) = {
478494     let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
479495     let assetIdRequested = parseAssetId(args[1])
480496     let amountRequested = ensurePositive(valueOrErrorMessage(parseInt(args[2]), wrapErr("invalid requested amount")), "requested amount")
481497     let accountOwnerPublicKey = getAccountOwnerPublicKey(accountAddress)
482498     let userAddress = addressFromPublicKey(callerPublicKey)
483499     let ckecks = [if (!(shutdown))
484500         then true
485501         else throwErr("not allowed"), mustFactory(i.caller), if ((callerPublicKey == accountOwnerPublicKey))
486502         then true
487503         else throwErr("can be called by account owner only")]
488504     if ((ckecks == ckecks))
489505         then {
490506             let amountAssetId = getAccountAssets(accountAddress)._1
491507             let deposited = toX18(valueOrElse(depositedOption(accountAddress), 0), pow10Decimals(usdtAssetId))
492508             let currentPrice = toX18(getCurrentPrice(amountAssetId), pow10Decimals(usdtAssetId))
493509             let creditA = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, amountAssetId)), 0), pow10Decimals(amountAssetId))
494510             let creditB = toX18(valueOrElse(getInteger(factoryAddress, kCredit(accountAddress, usdtAssetId)), 0), pow10Decimals(usdtAssetId))
495511             let totalCredit = calcTotalCredit(creditA, creditB, currentPrice)
496512             let leverage = toX18(valueOrErrorMessage(getInteger(factoryAddress, kLeverage(accountAddress)), wrapErr("leverage should be defined")), 1)
497513             let creditAvailableUsdt = calcCreditAvailable(deposited, leverage, totalCredit)
498514             let creditAvailable = if ((assetIdRequested == amountAssetId))
499515                 then fromX18(fraction(creditAvailableUsdt, mult18BigInt, currentPrice), pow10Decimals(amountAssetId))
500516                 else if ((assetIdRequested == usdtAssetId))
501517                     then fromX18(creditAvailableUsdt, pow10Decimals(usdtAssetId))
502518                     else throwErr("invalid requested asset id")
503519             let syntheticAssetId = parseAssetId(valueOrErrorMessage(getString(factoryAddress, kSyntheticAssetId(assetIdRequested)), wrapErr("synthetic asset for requested asset is undefined")))
504520             let amountToSend = if ((creditAvailable >= amountRequested))
505521                 then amountRequested
506522                 else throwErr(("credit available = " + toString(creditAvailable)))
507523             let factoryActions = [invoke(factoryAddress, "integerEntry", [kCredit(accountAddress, assetIdRequested), (valueOrElse(creditOption(accountAddress, assetIdRequested), 0) + amountToSend)], nil), invoke(factoryAddress, "transferAsset", [userAddress.bytes, amountToSend, syntheticAssetId], nil)]
508524             $Tuple2(nil, [factoryActions, creditAvailable])
509525             }
510526         else throw("Strict value is not equal to itself.")
511527     }
512528 
513529 
514530 
515531 @Callable(i)
516532 func repay (callerPublicKey,args) = {
517533     let ckecks = [if (!(shutdown))
518534         then true
519535         else throwErr("not allowed"), mustFactory(i.caller)]
520536     if ((ckecks == ckecks))
521537         then $Tuple2(nil, unit)
522538         else throw("Strict value is not equal to itself.")
523539     }
524540 
525541 
526542 
527543 @Callable(i)
528544 func setPairAllowance (callerPublicKey,args) = {
529545     let ckecks = [if (!(shutdown))
530546         then true
531547         else throwErr("not allowed"), mustFactory(i.caller), mustAdmin(callerPublicKey)]
532548     if ((ckecks == ckecks))
533549         then {
534550             let amountAssetIdStr = args[0]
535551             let priceAssetIdStr = args[1]
536552             let allowStr = args[2]
537553             let amountAssetId = parseAssetId(amountAssetIdStr)
538554             let priceAssetId = parseAssetId(priceAssetIdStr)
539555             let allow = (allowStr == "true")
540556             let invocations = [invoke(factoryAddress, "booleanEntry", [kPairAllowed(amountAssetId, priceAssetId), allow], nil)]
541557             $Tuple2(nil, invocations)
542558             }
543559         else throw("Strict value is not equal to itself.")
544560     }
545561 
546562 
547563 
548564 @Callable(i)
549565 func addSyntheticAsset (callerPublicKey,args) = {
550566     let baseAssetId = parseAssetId(args[0])
551567     let syntheticAssetId = parseAssetId(args[1])
552568     let ckecks = [if (!(shutdown))
553569         then true
554570         else throwErr("not allowed"), mustFactory(i.caller), mustAdmin(callerPublicKey), if ((getString(factoryAddress, kSyntheticAssetId(baseAssetId)) == unit))
555571         then true
556572         else throwErr("invalid base asset"), if ((getString(factoryAddress, kBaseAssetId(syntheticAssetId)) == unit))
557573         then true
558574         else throwErr("invalid synthetic asset")]
559575     if ((ckecks == ckecks))
560576         then {
561577             let invocations = [invoke(factoryAddress, "stringEntry", [kSyntheticAssetId(baseAssetId), assetIdToString(syntheticAssetId)], nil), invoke(factoryAddress, "stringEntry", [kBaseAssetId(syntheticAssetId), assetIdToString(baseAssetId)], nil)]
562578             $Tuple2(nil, invocations)
563579             }
564580         else throw("Strict value is not equal to itself.")
565581     }
566582 
567583 
568584 
569585 @Callable(i)
570586 func doShutdown (callerPublicKey,args) = {
571587     let checks = [mustFactory(i.caller), mustAdmin(callerPublicKey)]
572588     if ((checks == checks))
573589         then {
574590             let invocations = [invoke(factoryAddress, "booleanEntry", [kShutdown, true], nil)]
575591             $Tuple2(nil, invocations)
576592             }
577593         else throw("Strict value is not equal to itself.")
578594     }
579595 
580596 
581597 
582598 @Callable(i)
583599 func getAccountInfoREADONLY (callerPublicKey,args) = {
584600     let checks = [mustFactory(i.caller)]
585601     if ((checks == checks))
586602         then {
587603             let accountAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid account address"))
588604             let data = getAccountInfoInternal(accountAddress)
589605             $Tuple2(nil, data)
590606             }
591607         else throw("Strict value is not equal to itself.")
592608     }
593609 
594610 
595611 
596612 @Callable(i)
597613 func getUserInfoREADONLY (callerPublicKey,args) = {
598614     let checks = [mustFactory(i.caller)]
599615     if ((checks == checks))
600616         then {
601617             let userAddress = valueOrErrorMessage(addressFromString(args[0]), wrapErr("invalid user address"))
602618             let userRequests = valueOrElse(getBinary(factoryAddress, kRequestsByOwner(userAddress)), base58'')
603619             let userRequestsNumber = (size(userRequests) / queueItemSize)
604-            let nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
605620             func getAccountsData (acc,count) =             {
606-                let $t02483724879 = acc
607-                let accDataList = $t02483724879._1
608-                let rawBytes = $t02483724879._2
609-                let maxSize = $t02483724879._3
621+                let $t02562225664 = acc
622+                let accDataList = $t02562225664._1
623+                let rawBytes = $t02562225664._2
624+                let maxSize = $t02562225664._3
610625                 if ((maxSize > count))
611626                     then {
612627                         let requestId = take(rawBytes, queueItemSize)
613628                         let newRawBytes = drop(rawBytes, queueItemSize)
614629                         let accountPublicKey = valueOrErrorMessage(getBinary(factoryAddress, kRequestIdToAccountPublicKey(requestId)), "kRequestIdToAccountPublicKey not found")
615630                         let accountAddress = addressFromPublicKey(accountPublicKey)
616631                         let data = getAccountInfoInternal(accountAddress)
617632                         $Tuple3((accDataList :+ data), newRawBytes, maxSize)
618633                         }
619634                     else acc
620635                 }
621636 
622-            let $t02538325482 = {
623-                let $l = nums
637+            let $t02616826273 = {
638+                let $l = INDEX_LIST
624639                 let $s = size($l)
625640                 let $acc0 = $Tuple3(nil, userRequests, userRequestsNumber)
626641                 func $f0_1 ($a,$i) =                 if (($i >= $s))
627642                     then $a
628643                     else getAccountsData($a, $l[$i])
629644 
630645                 func $f0_2 ($a,$i) =                 if (($i >= $s))
631646                     then $a
632647                     else throw("List size exceeds 20")
633648 
634649                 $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)
635650                 }
636-            let accDataList = $t02538325482._1
637-            let _a = $t02538325482._2
638-            let _b = $t02538325482._3
651+            let accDataList = $t02616826273._1
652+            let _a = $t02616826273._2
653+            let _b = $t02616826273._3
639654             $Tuple2(nil, accDataList)
655+            }
656+        else throw("Strict value is not equal to itself.")
657+    }
658+
659+
660+
661+@Callable(i)
662+func deletePairSetting (callerPublicKey,args) = {
663+    let checks = [mustFactory(i.caller), mustAdmin(callerPublicKey)]
664+    if ((checks == checks))
665+        then {
666+            let amountAsset = parseAssetId(args[0])
667+            let priceAsset = parseAssetId(args[1])
668+            let price = args[2]
669+            let settingsKey = kPairSettingsKey(amountAsset, priceAsset, price)
670+            let pairPricesListKey = kPairPricesListKey(amountAsset, priceAsset)
671+            let pricesList = getPairPricesList(amountAsset, priceAsset)
672+            let newList =             match indexOf(pricesList, price) {
673+                case ind: Int => 
674+                    removeByIndex(pricesList, ind)
675+                case _ => 
676+                    pricesList
677+            }
678+            let invocations = [invoke(factoryAddress, "deleteEntry", [settingsKey], nil), if ((size(newList) == 0))
679+                then invoke(factoryAddress, "deleteEntry", [kPairPricesListKey(amountAsset, priceAsset)], nil)
680+                else invoke(factoryAddress, "stringEntry", [kPairPricesListKey(amountAsset, priceAsset), makeString(newList, separator)], nil)]
681+            $Tuple2(nil, invocations)
640682             }
641683         else throw("Strict value is not equal to itself.")
642684     }
643685 
644686 
645687 @Verifier(tx)
646688 func verify () = if (if (isDefined(factoryAddressOption))
647689     then isDefined(getString(factoryAddress, kMultisig))
648690     else false)
649691     then     match getString(factoryAddress, kMultisig) {
650692         case multisig: String => 
651693             let statusKey = kStatus(toString(this), toBase58String(tx.id))
652694             let status = valueOrElse(getBoolean(addressFromStringValue(multisig), statusKey), false)
653695             status
654696         case _ => 
655697             false
656698     }
657699     else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
658700 
github/deemru/w8io/169f3d6 
79.05 ms ◑