tx · dS81iW1YZzryaVzWB129AqS8veufvhm6vKGgk5KpFaT

3N45khsjRq7bYfsvbxX1YBURhNRBBDRFNYV:  -0.03500000 Waves

2022.10.12 17:09 [2269238] smart account 3N45khsjRq7bYfsvbxX1YBURhNRBBDRFNYV > SELF 0.00000000 Waves

{ "type": 13, "id": "dS81iW1YZzryaVzWB129AqS8veufvhm6vKGgk5KpFaT", "fee": 3500000, "feeAssetId": null, "timestamp": 1665583723431, "version": 1, "sender": "3N45khsjRq7bYfsvbxX1YBURhNRBBDRFNYV", "senderPublicKey": "9QeKzbcXevL66Vm5v2GCmySfZ86o8jcD5y7pPmfRcRYE", "proofs": [ "sCrWfieZrmpa7xSCZfE1nE6W1SQUCccbd1f25FiHDPz16C64bHLXAcwN7xjqX8VquyQpBX56yAtmJnrdDZ3Zk99" ], "script": "base64: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", "chainId": 84, "height": 2269238, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: 4QwzqdBL2bftvFentQsxqYcU3eKEw3sDDiZxnRWQhUdy Next: J3qKAXU7RiQVGycHMnUQmKuCzwvMEpUaBNxbEmpfthV1 Diff:
OldNewDifferences
1010 let scale18 = toBigInt(1000000000000000000)
1111
1212 let zeroBigInt = toBigInt(0)
13+
14+let big0 = toBigInt(0)
15+
16+let big1 = toBigInt(1)
17+
18+let big2 = toBigInt(1)
19+
20+let wavesString = "WAVES"
1321
1422 let SEP = "__"
1523
125133 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
126134
127135
136+func throwErr (msg) = throw(makeString(["lp.ride:", msg], " "))
137+
138+
128139 let factoryContract = addressFromStringValue(getStringOrFail(this, fc()))
129140
130141 func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
142153 }
143154
144155
156+func parseAssetId (input) = if ((input == wavesString))
157+ then unit
158+ else fromBase58String(input)
159+
160+
161+func assetIdToString (input) = if ((input == unit))
162+ then wavesString
163+ else toBase58String(value(input))
164+
165+
166+func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolStatus]), fromBase58String(poolConfig[idxPoolLPAssetId]), parseAssetId(poolConfig[idxAmtAssetId]), parseAssetId(poolConfig[idxPriceAssetId]), parseIntValue(poolConfig[idxAmtAssetDcm]), parseIntValue(poolConfig[idxPriceAssetDcm]))
167+
168+
145169 func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
146170
171+
172+let stakingContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactoryStakingContract]), "incorrect staking address")
173+
174+let slippageContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactorySlippageContract]), "incorrect staking address")
147175
148176 func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
149177
380408 }
381409
382410
411+func emit (amount) = {
412+ let emitInv = invoke(factoryContract, "emit", [amount], nil)
413+ if ((emitInv == emitInv))
414+ then {
415+ let emitInvLegacy = match emitInv {
416+ case legacyFactoryContract: Address =>
417+ invoke(legacyFactoryContract, "emit", [amount], nil)
418+ case _ =>
419+ unit
420+ }
421+ if ((emitInvLegacy == emitInvLegacy))
422+ then amount
423+ else throw("Strict value is not equal to itself.")
424+ }
425+ else throw("Strict value is not equal to itself.")
426+ }
427+
428+
429+func calcPutOneToken (paymentAmountRaw,paymentAssetId,userAddress,txId) = {
430+ let isEval = (txId == unit)
431+ let $t02148521663 = parsePoolConfig(getPoolConfig())
432+ let poolAddress = $t02148521663._1
433+ let poolStatus = $t02148521663._2
434+ let lpAssetId = $t02148521663._3
435+ let amountAssetId = $t02148521663._4
436+ let priceAssetId = $t02148521663._5
437+ let amountAssetDecimals = $t02148521663._6
438+ let priceAssetDecimals = $t02148521663._7
439+ let paymentAmount = paymentAmountRaw
440+ let balanceRaw = if ((paymentAssetId == amountAssetId))
441+ then getAccBalance(assetIdToString(amountAssetId))
442+ else if ((paymentAssetId == priceAssetId))
443+ then getAccBalance(assetIdToString(priceAssetId))
444+ else throwErr("invalid asset")
445+ let amountToSubtract = if (isEval)
446+ then 0
447+ else paymentAmount
448+ let balance = (balanceRaw - amountToSubtract)
449+ let balanceBigInt = toBigInt(balance)
450+ let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(lpAssetId), (("asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity)
451+ let depositBigInt = toBigInt(paymentAmount)
452+ let issueAmount = ((supplyBigInt * (sqrtBigInt((scale8BigInt + ((depositBigInt * scale8BigInt) / balanceBigInt)), 8, 8, DOWN) - scale8BigInt)) / scale8BigInt)
453+ toInt(issueAmount)
454+ }
455+
456+
457+func calcGetOneToken (outAssetId,paymentAmount,paymentAssetId,userAddress,txId) = {
458+ let isEval = (txId == unit)
459+ let $t02267122849 = parsePoolConfig(getPoolConfig())
460+ let poolAddress = $t02267122849._1
461+ let poolStatus = $t02267122849._2
462+ let lpAssetId = $t02267122849._3
463+ let amountAssetId = $t02267122849._4
464+ let priceAssetId = $t02267122849._5
465+ let amountAssetDecimals = $t02267122849._6
466+ let priceAssetDecimals = $t02267122849._7
467+ let checks = [if ((paymentAssetId == lpAssetId))
468+ then true
469+ else throw("invalid lp asset")]
470+ if ((checks == checks))
471+ then {
472+ let balanceBigInt = if ((outAssetId == amountAssetId))
473+ then toBigInt(getAccBalance(assetIdToString(amountAssetId)))
474+ else if ((outAssetId == priceAssetId))
475+ then toBigInt(getAccBalance(assetIdToString(priceAssetId)))
476+ else throwErr("invalid asset")
477+ let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(lpAssetId), (("asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity)
478+ let redeemedBigInt = toBigInt(paymentAmount)
479+ let amount = ((balanceBigInt * (scale8BigInt - pow((scale8BigInt - ((redeemedBigInt * scale8BigInt) / supplyBigInt)), 8, big2, 0, 8, DOWN))) / scale8BigInt)
480+ toInt(amount)
481+ }
482+ else throw("Strict value is not equal to itself.")
483+ }
484+
485+
383486 func managerPublicKeyOrUnit () = match getString(mpk()) {
384487 case s: String =>
385488 fromBase58String(s)
418521
419522
420523 @Callable(i)
421-func constructor (factoryContract) = {
422- let checkCaller = mustManager(i)
423- if ((checkCaller == checkCaller))
424- then [StringEntry(fc(), factoryContract)]
425- else throw("Strict value is not equal to itself.")
426- }
427-
428-
429-
430-@Callable(i)
431524 func setManager (pendingManagerPublicKey) = {
432525 let checkCaller = mustManager(i)
433526 if ((checkCaller == checkCaller))
463556
464557
465558 @Callable(i)
466-func put (slippageTolerance,shouldAutoStake) = {
467- let factoryCfg = getFactoryConfig()
468- let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
469- let slippageContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactorySlippageContract]), "Error. Incorrect slippage contract address.")
470- if ((0 > slippageTolerance))
471- then throw("Invalid slippageTolerance passed")
472- else {
473- let estPut = commonPut(i, slippageTolerance, true)
474- let emitLpAmt = estPut._2
475- let lpAssetId = estPut._7
476- let state = estPut._9
477- let amDiff = estPut._10
478- let prDiff = estPut._11
479- let amId = estPut._12
480- let prId = estPut._13
481- let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
482- if ((emitInv == emitInv))
483- then {
484- let emitInvLegacy = match emitInv {
485- case legacyFactoryContract: Address =>
486- invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
487- case _ =>
488- unit
489- }
490- if ((emitInvLegacy == emitInvLegacy))
491- then {
492- let slippageAInv = if ((amDiff > 0))
493- then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
494- else nil
495- if ((slippageAInv == slippageAInv))
496- then {
497- let slippagePInv = if ((prDiff > 0))
498- then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
499- else nil
500- if ((slippagePInv == slippagePInv))
501- then {
502- let lpTransfer = if (shouldAutoStake)
503- then {
504- let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
505- if ((slpStakeInv == slpStakeInv))
506- then nil
507- else throw("Strict value is not equal to itself.")
508- }
509- else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
510- (state ++ lpTransfer)
511- }
512- else throw("Strict value is not equal to itself.")
513- }
514- else throw("Strict value is not equal to itself.")
515- }
516- else throw("Strict value is not equal to itself.")
517- }
518- else throw("Strict value is not equal to itself.")
519- }
520- }
559+func put (slippageTolerance,shouldAutoStake) = if ((0 > slippageTolerance))
560+ then throw("Invalid slippageTolerance passed")
561+ else {
562+ let estPut = commonPut(i, slippageTolerance, true)
563+ let emitLpAmt = estPut._2
564+ let lpAssetId = estPut._7
565+ let state = estPut._9
566+ let amDiff = estPut._10
567+ let prDiff = estPut._11
568+ let amId = estPut._12
569+ let prId = estPut._13
570+ let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
571+ if ((emitInv == emitInv))
572+ then {
573+ let emitInvLegacy = match emitInv {
574+ case legacyFactoryContract: Address =>
575+ invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
576+ case _ =>
577+ unit
578+ }
579+ if ((emitInvLegacy == emitInvLegacy))
580+ then {
581+ let slippageAInv = if ((amDiff > 0))
582+ then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
583+ else nil
584+ if ((slippageAInv == slippageAInv))
585+ then {
586+ let slippagePInv = if ((prDiff > 0))
587+ then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
588+ else nil
589+ if ((slippagePInv == slippagePInv))
590+ then {
591+ let lpTransfer = if (shouldAutoStake)
592+ then {
593+ let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
594+ if ((slpStakeInv == slpStakeInv))
595+ then nil
596+ else throw("Strict value is not equal to itself.")
597+ }
598+ else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
599+ (state ++ lpTransfer)
600+ }
601+ else throw("Strict value is not equal to itself.")
602+ }
603+ else throw("Strict value is not equal to itself.")
604+ }
605+ else throw("Strict value is not equal to itself.")
606+ }
607+ else throw("Strict value is not equal to itself.")
608+ }
521609
522610
523611
528616 let estPut = commonPut(i, maxSlippage, false)
529617 estPut._9
530618 }
619+
620+
621+
622+@Callable(i)
623+func putOneTkn (minOutAmount,autoStake) = {
624+ let $t02675626934 = parsePoolConfig(getPoolConfig())
625+ let poolAddress = $t02675626934._1
626+ let poolStatus = $t02675626934._2
627+ let lpAssetId = $t02675626934._3
628+ let amountAssetId = $t02675626934._4
629+ let priceAssetId = $t02675626934._5
630+ let amountAssetDecimals = $t02675626934._6
631+ let priceAssetDecimals = $t02675626934._7
632+ let isPutDisabled = if (if (isGlobalShutdown())
633+ then true
634+ else (poolStatus == PoolPutDisabled))
635+ then true
636+ else (poolStatus == PoolShutdown)
637+ let checks = [if (!(isPutDisabled))
638+ then true
639+ else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))
640+ then true
641+ else throwErr("exactly 1 payment are expected")]
642+ if ((checks == checks))
643+ then {
644+ let payment = i.payments[0]
645+ let paymentAssetId = payment.assetId
646+ let paymentAmountRaw = payment.amount
647+ let paymentAmount = paymentAmountRaw
648+ let userAddress = i.caller
649+ let txId = i.transactionId
650+ let emitAmount = {
651+ let emitAmountEstimated = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
652+ if (if ((minOutAmount > 0))
653+ then (minOutAmount > emitAmountEstimated)
654+ else false)
655+ then throw(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
656+ else emitAmountEstimated
657+ }
658+ let emitInv = emit(emitAmount)
659+ if ((emitInv == emitInv))
660+ then {
661+ let lpTransfer = if (autoStake)
662+ then {
663+ let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitAmount)])
664+ if ((stakeInv == stakeInv))
665+ then nil
666+ else throw("Strict value is not equal to itself.")
667+ }
668+ else [ScriptTransfer(i.caller, emitAmount, lpAssetId)]
669+ $Tuple2(lpTransfer, emitAmount)
670+ }
671+ else throw("Strict value is not equal to itself.")
672+ }
673+ else throw("Strict value is not equal to itself.")
674+ }
675+
676+
677+
678+@Callable(i)
679+func getOneTkn (outAssetId,minOutAmount,unstakeAmount) = {
680+ let $t02816728345 = parsePoolConfig(getPoolConfig())
681+ let poolAddress = $t02816728345._1
682+ let poolStatus = $t02816728345._2
683+ let lpAssetId = $t02816728345._3
684+ let amountAssetId = $t02816728345._4
685+ let priceAssetId = $t02816728345._5
686+ let amountAssetDecimals = $t02816728345._6
687+ let priceAssetDecimals = $t02816728345._7
688+ let isGetDisabled = if (isGlobalShutdown())
689+ then true
690+ else (poolStatus == PoolShutdown)
691+ let checks = [if (!(isGetDisabled))
692+ then true
693+ else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))
694+ then true
695+ else throwErr("exactly 1 payment are expected")]
696+ if ((checks == checks))
697+ then {
698+ let payment = i.payments[0]
699+ let paymentAssetId = payment.assetId
700+ let paymentAmount = payment.amount
701+ let userAddress = i.caller
702+ let txId = i.transactionId
703+ let amount = {
704+ let amountEstimated = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, paymentAssetId, userAddress, txId)
705+ if (if ((minOutAmount > 0))
706+ then (minOutAmount > amountEstimated)
707+ else false)
708+ then throw(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
709+ else amountEstimated
710+ }
711+ let burnInv = invoke(factoryContract, "burn", [paymentAmount], [AttachedPayment(paymentAssetId, paymentAmount)])
712+ if ((burnInv == burnInv))
713+ then {
714+ let assetTransfer = [ScriptTransfer(userAddress, amount, parseAssetId(outAssetId))]
715+ $Tuple2(assetTransfer, amount)
716+ }
717+ else throw("Strict value is not equal to itself.")
718+ }
719+ else throw("Strict value is not equal to itself.")
720+ }
531721
532722
533723
577767 if ((checkPayments == checkPayments))
578768 then {
579769 let cfg = getPoolConfig()
580- let factoryCfg = getFactoryConfig()
581770 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
582- let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
583771 let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
584772 if ((unstakeInv == unstakeInv))
585773 then {
Full:
OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let lPdecimals = 8
55
66 let scale8 = 100000000
77
88 let scale8BigInt = toBigInt(100000000)
99
1010 let scale18 = toBigInt(1000000000000000000)
1111
1212 let zeroBigInt = toBigInt(0)
13+
14+let big0 = toBigInt(0)
15+
16+let big1 = toBigInt(1)
17+
18+let big2 = toBigInt(1)
19+
20+let wavesString = "WAVES"
1321
1422 let SEP = "__"
1523
1624 let PoolActive = 1
1725
1826 let PoolPutDisabled = 2
1927
2028 let PoolMatcherDisabled = 3
2129
2230 let PoolShutdown = 4
2331
2432 let idxPoolAddress = 1
2533
2634 let idxPoolStatus = 2
2735
2836 let idxPoolLPAssetId = 3
2937
3038 let idxAmtAssetId = 4
3139
3240 let idxPriceAssetId = 5
3341
3442 let idxAmtAssetDcm = 6
3543
3644 let idxPriceAssetDcm = 7
3745
3846 let idxIAmtAssetId = 8
3947
4048 let idxIPriceAssetId = 9
4149
4250 let idxLPAssetDcm = 10
4351
4452 let idxPoolAmtAssetAmt = 1
4553
4654 let idxPoolPriceAssetAmt = 2
4755
4856 let idxPoolLPAssetAmt = 3
4957
5058 let idxFactoryStakingContract = 1
5159
5260 let idxFactorySlippageContract = 7
5361
5462 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
5563
5664
5765 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
5866
5967
6068 func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
6169
6270
6371 func abs (val) = if ((zeroBigInt > val))
6472 then -(val)
6573 else val
6674
6775
6876 func fc () = "%s__factoryContract"
6977
7078
7179 func mpk () = "%s__managerPublicKey"
7280
7381
7482 func pmpk () = "%s__pendingManagerPublicKey"
7583
7684
7785 func pl () = "%s%s__price__last"
7886
7987
8088 func ph (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
8189
8290
8391 func pau (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
8492
8593
8694 func gau (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
8795
8896
8997 func aa () = "%s__amountAsset"
9098
9199
92100 func pa () = "%s__priceAsset"
93101
94102
95103 func keyFactoryConfig () = "%s__factoryConfig"
96104
97105
98106 func keyMatcherPub () = "%s%s__matcher__publicKey"
99107
100108
101109 func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
102110
103111
104112 func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
105113
106114
107115 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
108116
109117
110118 func keyAllPoolsShutdown () = "%s__shutdown"
111119
112120
113121 func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
114122
115123
116124 func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
117125
118126
119127 func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
120128
121129
122130 func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
123131
124132
125133 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
126134
127135
136+func throwErr (msg) = throw(makeString(["lp.ride:", msg], " "))
137+
138+
128139 let factoryContract = addressFromStringValue(getStringOrFail(this, fc()))
129140
130141 func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
131142
132143
133144 func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
134145
135146
136147 func getPoolConfig () = {
137148 let amtAsset = getStringOrFail(this, aa())
138149 let priceAsset = getStringOrFail(this, pa())
139150 let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
140151 let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
141152 split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
142153 }
143154
144155
156+func parseAssetId (input) = if ((input == wavesString))
157+ then unit
158+ else fromBase58String(input)
159+
160+
161+func assetIdToString (input) = if ((input == unit))
162+ then wavesString
163+ else toBase58String(value(input))
164+
165+
166+func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolStatus]), fromBase58String(poolConfig[idxPoolLPAssetId]), parseAssetId(poolConfig[idxAmtAssetId]), parseAssetId(poolConfig[idxPriceAssetId]), parseIntValue(poolConfig[idxAmtAssetDcm]), parseIntValue(poolConfig[idxPriceAssetDcm]))
167+
168+
145169 func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
146170
171+
172+let stakingContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactoryStakingContract]), "incorrect staking address")
173+
174+let slippageContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactorySlippageContract]), "incorrect staking address")
147175
148176 func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
149177
150178
151179 func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
152180
153181
154182 func getAccBalance (assetId) = if ((assetId == "WAVES"))
155183 then wavesBalance(this).available
156184 else assetBalance(this, fromBase58String(assetId))
157185
158186
159187 func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
160188
161189
162190 func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
163191 let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
164192 let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
165193 calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
166194 }
167195
168196
169197 func calcPrices (amAmt,prAmt,lpAmt) = {
170198 let cfg = getPoolConfig()
171199 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
172200 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
173201 let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
174202 let amAmtX18 = toX18(amAmt, amtAssetDcm)
175203 let prAmtX18 = toX18(prAmt, priceAssetDcm)
176204 let lpAmtX18 = toX18(lpAmt, scale8)
177205 let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
178206 let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
179207 [priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
180208 }
181209
182210
183211 func calculatePrices (amAmt,prAmt,lpAmt) = {
184212 let prices = calcPrices(amAmt, prAmt, lpAmt)
185213 [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
186214 }
187215
188216
189217 func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
190218 let cfg = getPoolConfig()
191219 let lpAssetId = cfg[idxPoolLPAssetId]
192220 let amAssetId = cfg[idxAmtAssetId]
193221 let prAssetId = cfg[idxPriceAssetId]
194222 let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
195223 let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
196224 let poolStatus = cfg[idxPoolStatus]
197225 let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
198226 if ((lpAssetId != pmtAssetId))
199227 then throw("Invalid asset passed.")
200228 else {
201229 let amBalance = getAccBalance(amAssetId)
202230 let amBalanceX18 = toX18(amBalance, amAssetDcm)
203231 let prBalance = getAccBalance(prAssetId)
204232 let prBalanceX18 = toX18(prBalance, prAssetDcm)
205233 let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
206234 let curPrice = fromX18(curPriceX18, scale8)
207235 let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
208236 let lpEmissionX18 = toX18(lpEmission, scale8)
209237 let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
210238 let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
211239 let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
212240 let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
213241 let state = if ((txId58 == ""))
214242 then nil
215243 else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
216244 then unit
217245 else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
218246 then unit
219247 else fromBase58String(prAssetId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
220248 $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
221249 }
222250 }
223251
224252
225253 func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
226254 let cfg = getPoolConfig()
227255 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
228256 let amAssetIdStr = cfg[idxAmtAssetId]
229257 let prAssetIdStr = cfg[idxPriceAssetId]
230258 let iAmtAssetId = cfg[idxIAmtAssetId]
231259 let iPriceAssetId = cfg[idxIPriceAssetId]
232260 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
233261 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
234262 let poolStatus = cfg[idxPoolStatus]
235263 let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
236264 let inAmAssetIdStr = toBase58String(valueOrElse(inAmAssetId, fromBase58String("WAVES")))
237265 let inPrAssetIdStr = toBase58String(valueOrElse(inPrAssetId, fromBase58String("WAVES")))
238266 if (if ((amAssetIdStr != inAmAssetIdStr))
239267 then true
240268 else (prAssetIdStr != inPrAssetIdStr))
241269 then throw("Invalid amt or price asset passed.")
242270 else {
243271 let amBalance = if (isEvaluate)
244272 then getAccBalance(amAssetIdStr)
245273 else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
246274 let prBalance = if (isEvaluate)
247275 then getAccBalance(prAssetIdStr)
248276 else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
249277 let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
250278 let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
251279 let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
252280 let amBalanceX18 = toX18(amBalance, amtAssetDcm)
253281 let prBalanceX18 = toX18(prBalance, priceAssetDcm)
254282 let res = if ((lpEmission == 0))
255283 then {
256284 let curPriceX18 = zeroBigInt
257285 let slippageX18 = zeroBigInt
258286 let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
259287 $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
260288 }
261289 else {
262290 let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
263291 let slippageX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
264292 let slippageToleranceX18 = toX18(slippageTolerance, scale8)
265293 if (if ((curPriceX18 != zeroBigInt))
266294 then (slippageX18 > slippageToleranceX18)
267295 else false)
268296 then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
269297 else {
270298 let lpEmissionX18 = toX18(lpEmission, scale8)
271299 let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
272300 let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
273301 let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
274302 then $Tuple2(amViaPrX18, inPrAssetAmtX18)
275303 else $Tuple2(inAmAssetAmtX18, prViaAmX18)
276304 let expAmtAssetAmtX18 = expectedAmts._1
277305 let expPriceAssetAmtX18 = expectedAmts._2
278306 let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
279307 $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
280308 }
281309 }
282310 let calcLpAmt = res._1
283311 let calcAmAssetPmt = res._2
284312 let calcPrAssetPmt = res._3
285313 let curPrice = fromX18(res._4, scale8)
286314 let slippageCalc = fromX18(res._5, scale8)
287315 if ((0 >= calcLpAmt))
288316 then throw("Invalid calculations. LP calculated is less than zero.")
289317 else {
290318 let emitLpAmt = if (!(emitLp))
291319 then 0
292320 else calcLpAmt
293321 let amDiff = (inAmAssetAmt - calcAmAssetPmt)
294322 let prDiff = (inPrAssetAmt - calcPrAssetPmt)
295323 let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
296324 $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
297325 }
298326 }
299327 }
300328
301329
302330 func validateMatcherOrderAllowed (order) = {
303331 let cfg = getPoolConfig()
304332 let amtAssetId = cfg[idxAmtAssetId]
305333 let priceAssetId = cfg[idxPriceAssetId]
306334 let poolStatus = parseIntValue(cfg[idxPoolStatus])
307335 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
308336 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
309337 let accAmtAssetBalance = getAccBalance(amtAssetId)
310338 let accPriceAssetBalance = getAccBalance(priceAssetId)
311339 let curPriceX18 = if ((order.orderType == Buy))
312340 then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
313341 else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
314342 let curPrice = fromX18(curPriceX18, scale8)
315343 if (if (if (isGlobalShutdown())
316344 then true
317345 else (poolStatus == PoolMatcherDisabled))
318346 then true
319347 else (poolStatus == PoolShutdown))
320348 then throw("Exchange operations disabled")
321349 else {
322350 let orderAmtAsset = order.assetPair.amountAsset
323351 let orderAmtAssetStr = if ((orderAmtAsset == unit))
324352 then "WAVES"
325353 else toBase58String(value(orderAmtAsset))
326354 let orderPriceAsset = order.assetPair.priceAsset
327355 let orderPriceAssetStr = if ((orderPriceAsset == unit))
328356 then "WAVES"
329357 else toBase58String(value(orderPriceAsset))
330358 if (if ((orderAmtAssetStr != amtAssetId))
331359 then true
332360 else (orderPriceAssetStr != priceAssetId))
333361 then throw("Wrong order assets.")
334362 else {
335363 let orderPrice = order.price
336364 let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
337365 let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
338366 let isOrderPriceValid = if ((order.orderType == Buy))
339367 then (curPrice >= castedOrderPrice)
340368 else (castedOrderPrice >= curPrice)
341369 true
342370 }
343371 }
344372 }
345373
346374
347375 func commonGet (i) = if ((size(i.payments) != 1))
348376 then throw("exactly 1 payment is expected")
349377 else {
350378 let pmt = value(i.payments[0])
351379 let pmtAssetId = value(pmt.assetId)
352380 let pmtAmt = pmt.amount
353381 let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
354382 let outAmAmt = res._1
355383 let outPrAmt = res._2
356384 let poolStatus = parseIntValue(res._9)
357385 let state = res._10
358386 if (if (isGlobalShutdown())
359387 then true
360388 else (poolStatus == PoolShutdown))
361389 then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
362390 else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
363391 }
364392
365393
366394 func commonPut (i,slippageTolerance,emitLp) = if ((size(i.payments) != 2))
367395 then throw("exactly 2 payments are expected")
368396 else {
369397 let amAssetPmt = value(i.payments[0])
370398 let prAssetPmt = value(i.payments[1])
371399 let estPut = estimatePutOperation(toBase58String(i.transactionId), slippageTolerance, amAssetPmt.amount, amAssetPmt.assetId, prAssetPmt.amount, prAssetPmt.assetId, toString(i.caller), false, emitLp)
372400 let poolStatus = parseIntValue(estPut._8)
373401 if (if (if (isGlobalShutdown())
374402 then true
375403 else (poolStatus == PoolPutDisabled))
376404 then true
377405 else (poolStatus == PoolShutdown))
378406 then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
379407 else estPut
380408 }
381409
382410
411+func emit (amount) = {
412+ let emitInv = invoke(factoryContract, "emit", [amount], nil)
413+ if ((emitInv == emitInv))
414+ then {
415+ let emitInvLegacy = match emitInv {
416+ case legacyFactoryContract: Address =>
417+ invoke(legacyFactoryContract, "emit", [amount], nil)
418+ case _ =>
419+ unit
420+ }
421+ if ((emitInvLegacy == emitInvLegacy))
422+ then amount
423+ else throw("Strict value is not equal to itself.")
424+ }
425+ else throw("Strict value is not equal to itself.")
426+ }
427+
428+
429+func calcPutOneToken (paymentAmountRaw,paymentAssetId,userAddress,txId) = {
430+ let isEval = (txId == unit)
431+ let $t02148521663 = parsePoolConfig(getPoolConfig())
432+ let poolAddress = $t02148521663._1
433+ let poolStatus = $t02148521663._2
434+ let lpAssetId = $t02148521663._3
435+ let amountAssetId = $t02148521663._4
436+ let priceAssetId = $t02148521663._5
437+ let amountAssetDecimals = $t02148521663._6
438+ let priceAssetDecimals = $t02148521663._7
439+ let paymentAmount = paymentAmountRaw
440+ let balanceRaw = if ((paymentAssetId == amountAssetId))
441+ then getAccBalance(assetIdToString(amountAssetId))
442+ else if ((paymentAssetId == priceAssetId))
443+ then getAccBalance(assetIdToString(priceAssetId))
444+ else throwErr("invalid asset")
445+ let amountToSubtract = if (isEval)
446+ then 0
447+ else paymentAmount
448+ let balance = (balanceRaw - amountToSubtract)
449+ let balanceBigInt = toBigInt(balance)
450+ let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(lpAssetId), (("asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity)
451+ let depositBigInt = toBigInt(paymentAmount)
452+ let issueAmount = ((supplyBigInt * (sqrtBigInt((scale8BigInt + ((depositBigInt * scale8BigInt) / balanceBigInt)), 8, 8, DOWN) - scale8BigInt)) / scale8BigInt)
453+ toInt(issueAmount)
454+ }
455+
456+
457+func calcGetOneToken (outAssetId,paymentAmount,paymentAssetId,userAddress,txId) = {
458+ let isEval = (txId == unit)
459+ let $t02267122849 = parsePoolConfig(getPoolConfig())
460+ let poolAddress = $t02267122849._1
461+ let poolStatus = $t02267122849._2
462+ let lpAssetId = $t02267122849._3
463+ let amountAssetId = $t02267122849._4
464+ let priceAssetId = $t02267122849._5
465+ let amountAssetDecimals = $t02267122849._6
466+ let priceAssetDecimals = $t02267122849._7
467+ let checks = [if ((paymentAssetId == lpAssetId))
468+ then true
469+ else throw("invalid lp asset")]
470+ if ((checks == checks))
471+ then {
472+ let balanceBigInt = if ((outAssetId == amountAssetId))
473+ then toBigInt(getAccBalance(assetIdToString(amountAssetId)))
474+ else if ((outAssetId == priceAssetId))
475+ then toBigInt(getAccBalance(assetIdToString(priceAssetId)))
476+ else throwErr("invalid asset")
477+ let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(lpAssetId), (("asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity)
478+ let redeemedBigInt = toBigInt(paymentAmount)
479+ let amount = ((balanceBigInt * (scale8BigInt - pow((scale8BigInt - ((redeemedBigInt * scale8BigInt) / supplyBigInt)), 8, big2, 0, 8, DOWN))) / scale8BigInt)
480+ toInt(amount)
481+ }
482+ else throw("Strict value is not equal to itself.")
483+ }
484+
485+
383486 func managerPublicKeyOrUnit () = match getString(mpk()) {
384487 case s: String =>
385488 fromBase58String(s)
386489 case _: Unit =>
387490 unit
388491 case _ =>
389492 throw("Match error")
390493 }
391494
392495
393496 func pendingManagerPublicKeyOrUnit () = match getString(pmpk()) {
394497 case s: String =>
395498 fromBase58String(s)
396499 case _: Unit =>
397500 unit
398501 case _ =>
399502 throw("Match error")
400503 }
401504
402505
403506 func mustManager (i) = {
404507 let pd = throw("Permission denied")
405508 match managerPublicKeyOrUnit() {
406509 case pk: ByteVector =>
407510 if ((i.callerPublicKey == pk))
408511 then true
409512 else pd
410513 case _: Unit =>
411514 if ((i.caller == this))
412515 then true
413516 else pd
414517 case _ =>
415518 throw("Match error")
416519 }
417520 }
418521
419522
420523 @Callable(i)
421-func constructor (factoryContract) = {
422- let checkCaller = mustManager(i)
423- if ((checkCaller == checkCaller))
424- then [StringEntry(fc(), factoryContract)]
425- else throw("Strict value is not equal to itself.")
426- }
427-
428-
429-
430-@Callable(i)
431524 func setManager (pendingManagerPublicKey) = {
432525 let checkCaller = mustManager(i)
433526 if ((checkCaller == checkCaller))
434527 then {
435528 let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
436529 if ((checkManagerPublicKey == checkManagerPublicKey))
437530 then [StringEntry(pmpk(), pendingManagerPublicKey)]
438531 else throw("Strict value is not equal to itself.")
439532 }
440533 else throw("Strict value is not equal to itself.")
441534 }
442535
443536
444537
445538 @Callable(i)
446539 func confirmManager () = {
447540 let pm = pendingManagerPublicKeyOrUnit()
448541 let hasPM = if (isDefined(pm))
449542 then true
450543 else throw("No pending manager")
451544 if ((hasPM == hasPM))
452545 then {
453546 let checkPM = if ((i.callerPublicKey == value(pm)))
454547 then true
455548 else throw("You are not pending manager")
456549 if ((checkPM == checkPM))
457550 then [StringEntry(mpk(), toBase58String(value(pm))), DeleteEntry(pmpk())]
458551 else throw("Strict value is not equal to itself.")
459552 }
460553 else throw("Strict value is not equal to itself.")
461554 }
462555
463556
464557
465558 @Callable(i)
466-func put (slippageTolerance,shouldAutoStake) = {
467- let factoryCfg = getFactoryConfig()
468- let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
469- let slippageContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactorySlippageContract]), "Error. Incorrect slippage contract address.")
470- if ((0 > slippageTolerance))
471- then throw("Invalid slippageTolerance passed")
472- else {
473- let estPut = commonPut(i, slippageTolerance, true)
474- let emitLpAmt = estPut._2
475- let lpAssetId = estPut._7
476- let state = estPut._9
477- let amDiff = estPut._10
478- let prDiff = estPut._11
479- let amId = estPut._12
480- let prId = estPut._13
481- let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
482- if ((emitInv == emitInv))
483- then {
484- let emitInvLegacy = match emitInv {
485- case legacyFactoryContract: Address =>
486- invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
487- case _ =>
488- unit
489- }
490- if ((emitInvLegacy == emitInvLegacy))
491- then {
492- let slippageAInv = if ((amDiff > 0))
493- then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
494- else nil
495- if ((slippageAInv == slippageAInv))
496- then {
497- let slippagePInv = if ((prDiff > 0))
498- then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
499- else nil
500- if ((slippagePInv == slippagePInv))
501- then {
502- let lpTransfer = if (shouldAutoStake)
503- then {
504- let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
505- if ((slpStakeInv == slpStakeInv))
506- then nil
507- else throw("Strict value is not equal to itself.")
508- }
509- else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
510- (state ++ lpTransfer)
511- }
512- else throw("Strict value is not equal to itself.")
513- }
514- else throw("Strict value is not equal to itself.")
515- }
516- else throw("Strict value is not equal to itself.")
517- }
518- else throw("Strict value is not equal to itself.")
519- }
520- }
559+func put (slippageTolerance,shouldAutoStake) = if ((0 > slippageTolerance))
560+ then throw("Invalid slippageTolerance passed")
561+ else {
562+ let estPut = commonPut(i, slippageTolerance, true)
563+ let emitLpAmt = estPut._2
564+ let lpAssetId = estPut._7
565+ let state = estPut._9
566+ let amDiff = estPut._10
567+ let prDiff = estPut._11
568+ let amId = estPut._12
569+ let prId = estPut._13
570+ let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
571+ if ((emitInv == emitInv))
572+ then {
573+ let emitInvLegacy = match emitInv {
574+ case legacyFactoryContract: Address =>
575+ invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
576+ case _ =>
577+ unit
578+ }
579+ if ((emitInvLegacy == emitInvLegacy))
580+ then {
581+ let slippageAInv = if ((amDiff > 0))
582+ then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
583+ else nil
584+ if ((slippageAInv == slippageAInv))
585+ then {
586+ let slippagePInv = if ((prDiff > 0))
587+ then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
588+ else nil
589+ if ((slippagePInv == slippagePInv))
590+ then {
591+ let lpTransfer = if (shouldAutoStake)
592+ then {
593+ let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
594+ if ((slpStakeInv == slpStakeInv))
595+ then nil
596+ else throw("Strict value is not equal to itself.")
597+ }
598+ else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
599+ (state ++ lpTransfer)
600+ }
601+ else throw("Strict value is not equal to itself.")
602+ }
603+ else throw("Strict value is not equal to itself.")
604+ }
605+ else throw("Strict value is not equal to itself.")
606+ }
607+ else throw("Strict value is not equal to itself.")
608+ }
521609
522610
523611
524612 @Callable(i)
525613 func putForFree (maxSlippage) = if ((0 > maxSlippage))
526614 then throw("Invalid value passed")
527615 else {
528616 let estPut = commonPut(i, maxSlippage, false)
529617 estPut._9
530618 }
619+
620+
621+
622+@Callable(i)
623+func putOneTkn (minOutAmount,autoStake) = {
624+ let $t02675626934 = parsePoolConfig(getPoolConfig())
625+ let poolAddress = $t02675626934._1
626+ let poolStatus = $t02675626934._2
627+ let lpAssetId = $t02675626934._3
628+ let amountAssetId = $t02675626934._4
629+ let priceAssetId = $t02675626934._5
630+ let amountAssetDecimals = $t02675626934._6
631+ let priceAssetDecimals = $t02675626934._7
632+ let isPutDisabled = if (if (isGlobalShutdown())
633+ then true
634+ else (poolStatus == PoolPutDisabled))
635+ then true
636+ else (poolStatus == PoolShutdown)
637+ let checks = [if (!(isPutDisabled))
638+ then true
639+ else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))
640+ then true
641+ else throwErr("exactly 1 payment are expected")]
642+ if ((checks == checks))
643+ then {
644+ let payment = i.payments[0]
645+ let paymentAssetId = payment.assetId
646+ let paymentAmountRaw = payment.amount
647+ let paymentAmount = paymentAmountRaw
648+ let userAddress = i.caller
649+ let txId = i.transactionId
650+ let emitAmount = {
651+ let emitAmountEstimated = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
652+ if (if ((minOutAmount > 0))
653+ then (minOutAmount > emitAmountEstimated)
654+ else false)
655+ then throw(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
656+ else emitAmountEstimated
657+ }
658+ let emitInv = emit(emitAmount)
659+ if ((emitInv == emitInv))
660+ then {
661+ let lpTransfer = if (autoStake)
662+ then {
663+ let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitAmount)])
664+ if ((stakeInv == stakeInv))
665+ then nil
666+ else throw("Strict value is not equal to itself.")
667+ }
668+ else [ScriptTransfer(i.caller, emitAmount, lpAssetId)]
669+ $Tuple2(lpTransfer, emitAmount)
670+ }
671+ else throw("Strict value is not equal to itself.")
672+ }
673+ else throw("Strict value is not equal to itself.")
674+ }
675+
676+
677+
678+@Callable(i)
679+func getOneTkn (outAssetId,minOutAmount,unstakeAmount) = {
680+ let $t02816728345 = parsePoolConfig(getPoolConfig())
681+ let poolAddress = $t02816728345._1
682+ let poolStatus = $t02816728345._2
683+ let lpAssetId = $t02816728345._3
684+ let amountAssetId = $t02816728345._4
685+ let priceAssetId = $t02816728345._5
686+ let amountAssetDecimals = $t02816728345._6
687+ let priceAssetDecimals = $t02816728345._7
688+ let isGetDisabled = if (isGlobalShutdown())
689+ then true
690+ else (poolStatus == PoolShutdown)
691+ let checks = [if (!(isGetDisabled))
692+ then true
693+ else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))
694+ then true
695+ else throwErr("exactly 1 payment are expected")]
696+ if ((checks == checks))
697+ then {
698+ let payment = i.payments[0]
699+ let paymentAssetId = payment.assetId
700+ let paymentAmount = payment.amount
701+ let userAddress = i.caller
702+ let txId = i.transactionId
703+ let amount = {
704+ let amountEstimated = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, paymentAssetId, userAddress, txId)
705+ if (if ((minOutAmount > 0))
706+ then (minOutAmount > amountEstimated)
707+ else false)
708+ then throw(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
709+ else amountEstimated
710+ }
711+ let burnInv = invoke(factoryContract, "burn", [paymentAmount], [AttachedPayment(paymentAssetId, paymentAmount)])
712+ if ((burnInv == burnInv))
713+ then {
714+ let assetTransfer = [ScriptTransfer(userAddress, amount, parseAssetId(outAssetId))]
715+ $Tuple2(assetTransfer, amount)
716+ }
717+ else throw("Strict value is not equal to itself.")
718+ }
719+ else throw("Strict value is not equal to itself.")
720+ }
531721
532722
533723
534724 @Callable(i)
535725 func get () = {
536726 let res = commonGet(i)
537727 let outAmtAmt = res._1
538728 let outPrAmt = res._2
539729 let pmtAmt = res._3
540730 let pmtAssetId = res._4
541731 let state = res._5
542732 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
543733 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
544734 then state
545735 else throw("Strict value is not equal to itself.")
546736 }
547737
548738
549739
550740 @Callable(i)
551741 func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
552742 let res = commonGet(i)
553743 let outAmAmt = res._1
554744 let outPrAmt = res._2
555745 let pmtAmt = res._3
556746 let pmtAssetId = res._4
557747 let state = res._5
558748 if ((noLessThenAmtAsset > outAmAmt))
559749 then throw(((("noLessThenAmtAsset failed: " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
560750 else if ((noLessThenPriceAsset > outPrAmt))
561751 then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
562752 else {
563753 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
564754 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
565755 then state
566756 else throw("Strict value is not equal to itself.")
567757 }
568758 }
569759
570760
571761
572762 @Callable(i)
573763 func unstakeAndGet (amount) = {
574764 let checkPayments = if ((size(i.payments) != 0))
575765 then throw("No payments are expected")
576766 else true
577767 if ((checkPayments == checkPayments))
578768 then {
579769 let cfg = getPoolConfig()
580- let factoryCfg = getFactoryConfig()
581770 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
582- let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
583771 let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
584772 if ((unstakeInv == unstakeInv))
585773 then {
586774 let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
587775 let poolStatus = parseIntValue(res._9)
588776 let state = res._10
589777 let checkPoolStatus = if (if (isGlobalShutdown())
590778 then true
591779 else (poolStatus == PoolShutdown))
592780 then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
593781 else true
594782 if ((checkPoolStatus == checkPoolStatus))
595783 then {
596784 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
597785 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
598786 then state
599787 else throw("Strict value is not equal to itself.")
600788 }
601789 else throw("Strict value is not equal to itself.")
602790 }
603791 else throw("Strict value is not equal to itself.")
604792 }
605793 else throw("Strict value is not equal to itself.")
606794 }
607795
608796
609797
610798 @Callable(i)
611799 func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
612800 then throw("permissions denied")
613801 else $Tuple2([StringEntry(aa(), amtAssetStr), StringEntry(pa(), priceAssetStr)], "success")
614802
615803
616804
617805 @Callable(i)
618806 func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
619807
620808
621809
622810 @Callable(i)
623811 func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
624812
625813
626814
627815 @Callable(i)
628816 func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
629817 let prices = calcPrices(amAmt, prAmt, lpAmt)
630818 $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
631819 }
632820
633821
634822
635823 @Callable(i)
636824 func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
637825
638826
639827
640828 @Callable(i)
641829 func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
642830
643831
644832
645833 @Callable(i)
646834 func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
647835
648836
649837
650838 @Callable(i)
651839 func estimatePutOperationWrapperREADONLY (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp))
652840
653841
654842
655843 @Callable(i)
656844 func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
657845 let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
658846 $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
659847 }
660848
661849
662850
663851 @Callable(i)
664852 func statsREADONLY () = {
665853 let cfg = getPoolConfig()
666854 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
667855 let amtAssetId = cfg[idxAmtAssetId]
668856 let priceAssetId = cfg[idxPriceAssetId]
669857 let iAmtAssetId = cfg[idxIAmtAssetId]
670858 let iPriceAssetId = cfg[idxIPriceAssetId]
671859 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
672860 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
673861 let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
674862 let accAmtAssetBalance = getAccBalance(amtAssetId)
675863 let accPriceAssetBalance = getAccBalance(priceAssetId)
676864 let pricesList = if ((poolLPBalance == 0))
677865 then [zeroBigInt, zeroBigInt, zeroBigInt]
678866 else calcPrices(accAmtAssetBalance, accPriceAssetBalance, poolLPBalance)
679867 let curPrice = 0
680868 let lpAmtAssetShare = fromX18(pricesList[1], scale8)
681869 let lpPriceAssetShare = fromX18(pricesList[2], scale8)
682870 let poolWeight = value(getInteger(factoryContract, keyPoolWeight(toString(this))))
683871 $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
684872 }
685873
686874
687875
688876 @Callable(i)
689877 func evaluatePutByAmountAssetREADONLY (inAmAssetAmt) = {
690878 let cfg = getPoolConfig()
691879 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
692880 let amAssetIdStr = cfg[idxAmtAssetId]
693881 let amAssetId = fromBase58String(amAssetIdStr)
694882 let prAssetIdStr = cfg[idxPriceAssetId]
695883 let prAssetId = fromBase58String(prAssetIdStr)
696884 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
697885 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
698886 let poolStatus = cfg[idxPoolStatus]
699887 let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
700888 let accAmtAssetBalance = getAccBalance(amAssetIdStr)
701889 let accPriceAssetBalance = getAccBalance(prAssetIdStr)
702890 let amtAssetAmtX18 = toX18(accAmtAssetBalance, amtAssetDcm)
703891 let priceAssetAmtX18 = toX18(accPriceAssetBalance, priceAssetDcm)
704892 let curPriceX18 = if ((poolLPBalance == 0))
705893 then zeroBigInt
706894 else calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
707895 let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
708896 let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
709897 let inPrAssetAmt = fromX18(inPrAssetAmtX18, priceAssetDcm)
710898 let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
711899 let calcLpAmt = estPut._1
712900 let curPriceCalc = estPut._3
713901 let amBalance = estPut._4
714902 let prBalance = estPut._5
715903 let lpEmission = estPut._6
716904 $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
717905 }
718906
719907
720908
721909 @Callable(i)
722910 func evaluatePutByPriceAssetREADONLY (inPrAssetAmt) = {
723911 let cfg = getPoolConfig()
724912 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
725913 let amAssetIdStr = cfg[idxAmtAssetId]
726914 let amAssetId = fromBase58String(amAssetIdStr)
727915 let prAssetIdStr = cfg[idxPriceAssetId]
728916 let prAssetId = fromBase58String(prAssetIdStr)
729917 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
730918 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
731919 let poolStatus = cfg[idxPoolStatus]
732920 let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
733921 let amBalanceRaw = getAccBalance(amAssetIdStr)
734922 let prBalanceRaw = getAccBalance(prAssetIdStr)
735923 let amBalanceRawX18 = toX18(amBalanceRaw, amtAssetDcm)
736924 let prBalanceRawX18 = toX18(prBalanceRaw, priceAssetDcm)
737925 let curPriceX18 = if ((poolLPBalance == 0))
738926 then zeroBigInt
739927 else calcPriceBigInt(prBalanceRawX18, amBalanceRawX18)
740928 let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
741929 let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
742930 let inAmAssetAmt = fromX18(inAmAssetAmtX18, amtAssetDcm)
743931 let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
744932 let calcLpAmt = estPut._1
745933 let curPriceCalc = estPut._3
746934 let amBalance = estPut._4
747935 let prBalance = estPut._5
748936 let lpEmission = estPut._6
749937 $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
750938 }
751939
752940
753941
754942 @Callable(i)
755943 func evaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
756944 let res = estimateGetOperation("", paymentLpAssetId, paymentLpAmt, this)
757945 let outAmAmt = res._1
758946 let outPrAmt = res._2
759947 let amBalance = res._5
760948 let prBalance = res._6
761949 let lpEmission = res._7
762950 let curPrice = res._8
763951 let poolStatus = parseIntValue(res._9)
764952 $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), toString(curPrice), toString(poolStatus)], SEP))
765953 }
766954
767955
768956 @Verifier(tx)
769957 func verify () = {
770958 let targetPublicKey = match managerPublicKeyOrUnit() {
771959 case pk: ByteVector =>
772960 pk
773961 case _: Unit =>
774962 tx.senderPublicKey
775963 case _ =>
776964 throw("Match error")
777965 }
778966 match tx {
779967 case order: Order =>
780968 let matcherPub = getMatcherPubOrFail()
781969 let orderValid = validateMatcherOrderAllowed(order)
782970 let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
783971 let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
784972 if (if (if (orderValid)
785973 then senderValid
786974 else false)
787975 then matcherValid
788976 else false)
789977 then true
790978 else throwOrderError(orderValid, senderValid, matcherValid)
791979 case s: SetScriptTransaction =>
792980 let newHash = blake2b256(value(s.script))
793981 let allowedHash = fromBase64String(value(getString(factoryContract, keyAllowedLpScriptHash())))
794982 let currentHash = scriptHash(this)
795983 if (if ((allowedHash == newHash))
796984 then (currentHash != newHash)
797985 else false)
798986 then true
799987 else sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
800988 case _ =>
801989 sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
802990 }
803991 }
804992

github/deemru/w8io/169f3d6 
96.71 ms