tx · J7mXyipvW9xzX1ki7j3HHSw7kGsk6Z6zSD38wv5FUmY2

3MvvvqugsEM2Hkh6AikfEeY4h3U2gTG9rfd:  -0.01000000 Waves

2021.11.23 15:26 [1803666] smart account 3MvvvqugsEM2Hkh6AikfEeY4h3U2gTG9rfd > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "J7mXyipvW9xzX1ki7j3HHSw7kGsk6Z6zSD38wv5FUmY2",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1637670412748,
    "version": 1,
    "sender": "3MvvvqugsEM2Hkh6AikfEeY4h3U2gTG9rfd",
    "senderPublicKey": "HPjKySzXXzrNXeESGBkFWjazoizq1V5K7U8pz6hugrL1",
    "proofs": [
        "pqRubhYAAWVsFwvwNJKSpHNMKwZwcSUoyQ4yn8QQrwe1L6m6qorMgwZ3Zhp1NA8pu3bxmurDimyHEkfQ5YKHpkv"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1803666,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 31tBEmcZA6udo2MNkGg4PxoXhwykx3dVuP32Jb1EPGk2

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let SCALE8 = 8
7+
8+let MULT8 = 100000000
9+
10+func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
11+
12+
13+func getIntOrZero (key) = valueOrElse(getInteger(this, key), 0)
14+
15+
16+func getIntOrFail (key) = valueOrErrorMessage(getInteger(key), (("mandatory this." + key) + " is not defined"))
17+
18+
19+func asAnyList (val) = match val {
20+    case valAnyLyst: List[Any] => 
21+        valAnyLyst
22+    case _ => 
23+        throw("fail to cast into List[Any]")
24+}
25+
26+
27+func asInt (val) = match val {
28+    case valInt: Int => 
29+        valInt
30+    case _ => 
31+        throw("fail to cast into Int")
32+}
33+
34+
35+func keyFactoryAddress () = "%s%s__config__factoryAddress"
36+
37+
38+let IdxFactoryCfgStakingDapp = 1
39+
40+let IdxFactoryCfgBoostingDapp = 2
41+
42+let IdxFactoryCfgIdoDapp = 3
43+
44+let IdxFactoryCfgTeamDapp = 4
45+
46+let IdxFactoryCfgEmissionDapp = 5
47+
48+let IdxFactoryCfgRestDapp = 6
49+
50+let IdxFactoryCfgSlippageDapp = 7
51+
52+func keyFactoryCfg () = "%s__factoryConfig"
53+
54+
55+func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
56+
57+
58+func keyFactoryLpList () = "%s__lpTokensList"
59+
60+
61+func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
62+
63+
64+func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
65+
66+
67+func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(this, keyFactoryAddress()))
68+
69+
70+func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
71+
72+
73+func readFactoryCfgOrFail (factory) = split(getStringOrFail(factory, keyFactoryCfg()), SEP)
74+
75+
76+func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
77+
78+
79+func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
80+
81+
82+func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
83+
84+
85+let IdxCfgAssetId = 1
86+
87+let IdxCfgMinLockAmount = 2
88+
89+let IdxCfgMinLockDuration = 3
90+
91+let IdxCfgMaxLockDuration = 4
92+
93+let IdxCfgMathContract = 5
94+
95+func keyConfig () = "%s__config"
96+
97+
98+func readConfigArrayOrFail () = split(getStringOrFail(this, keyConfig()), SEP)
99+
100+
101+func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
102+
103+
104+func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
105+
106+
107+let IdxLockUserNum = 1
108+
109+let IdxLockAmount = 2
110+
111+let IdxLockStart = 3
112+
113+let IdxLockDuration = 4
114+
115+let IdxLockParamK = 5
116+
117+let IdxLockParamB = 6
118+
119+func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
120+
121+
122+func readLockParamsRecordOrFail (userAddress) = split(getStringOrFail(this, keyLockParamsRecord(userAddress)), SEP)
123+
124+
125+func formatLockParamsRecordS (userNum,amount,start,duration,paramK,paramB,lastUpdTimestamp,gwxAmount) = makeString(["%d%d%d%d%d%d%d%d", userNum, amount, start, duration, paramK, paramB, lastUpdTimestamp, gwxAmount], SEP)
126+
127+
128+func formatLockParamsRecord (userNum,amount,start,duration,paramK,paramB,gwxAmount) = formatLockParamsRecordS(userNum, toString(amount), toString(start), toString(duration), toString(paramK), toString(paramB), toString(lastBlock.timestamp), toString(gwxAmount))
129+
130+
131+func keyNextUserNum () = "%s__nextUserNum"
132+
133+
134+func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
135+
136+
137+func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
138+
139+
140+func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
141+
142+
143+func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
144+
145+
146+func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
147+
148+
149+func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
150+
151+
152+func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
153+
154+
155+func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
156+
157+
158+func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
159+
160+
161+func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
162+
163+
164+func keyStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
165+
166+
167+func keyStatsLocksCount () = "%s%s__stats__locksCount"
168+
169+
170+func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
171+
172+
173+func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
174+    let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
175+    let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(k), toString(b)], SEP)
176+    StringEntry(historyKEY, historyDATA)
177+    }
178+
179+
180+func StatsEntry (totalLockedInc,durationInc,lockCountInc,usersCountInc) = {
181+    let locksDurationSumInBlocksKEY = keyStatsLocksDurationSumInBlocks()
182+    let locksCountKEY = keyStatsLocksCount()
183+    let usersCountKEY = keyStatsUsersCount()
184+    let totalAmountKEY = keyLockParamTotalAmount()
185+    let locksDurationSumInBlocks = getIntOrZero(locksCountKEY)
186+    let locksCount = getIntOrZero(locksCountKEY)
187+    let usersCount = getIntOrZero(usersCountKEY)
188+    let totalAmount = getIntOrZero(totalAmountKEY)
189+[IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
190+    }
191+
192+
193+func calcGwxAmount (kRaw,bRaw,h) = {
194+    let SCALE = 1000
195+    (((kRaw * h) + bRaw) / SCALE)
196+    }
197+
198+
199+func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
200+    let userAmountKEY = keyLockParamUserAmount(userNum)
201+    let startBlockKEY = keyLockParamStartBlock(userNum)
202+    let durationKEY = keyLockParamDuration(userNum)
203+    let kKEY = keyLockParamK(userNum)
204+    let bKEY = keyLockParamB(userNum)
205+    let kByPerioKEY = keyLockParamByPeriodK(userNum, period)
206+    let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
207+    let gwxAmount = calcGwxAmount(k, b, height)
208+[IntegerEntry(userAmountKEY, amount), IntegerEntry(startBlockKEY, start), IntegerEntry(durationKEY, duration), IntegerEntry(kKEY, k), IntegerEntry(bKEY, b), IntegerEntry(kByPerioKEY, k), IntegerEntry(bByPeriodKEY, b), StringEntry(keyLockParamsRecord(userAddress), formatLockParamsRecord(userNum, amount, start, duration, k, b, gwxAmount))]
209+    }
210+
211+
212+func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
213+    then throw("only one payment is allowed")
214+    else if ((size(i.payments) == 0))
215+        then 0
216+        else {
217+            let pmt = i.payments[0]
218+            if ((value(pmt.assetId) != expectedAssetId))
219+                then throw("invalid asset id in payment")
220+                else pmt.amount
221+            }
222+
223+
224+@Callable(i)
225+func constructor (factoryAddressStr,lockAssetIdStr,minLockAmount,minDuration,maxDuration,mathContract) = if ((this != i.caller))
226+    then throw("not authorized")
227+    else ([IntegerEntry(keyNextUserNum(), 0), StringEntry(keyConfig(), formatConfig(lockAssetIdStr, minLockAmount, minDuration, maxDuration, mathContract)), StringEntry(keyFactoryAddress(), factoryAddressStr)] ++ StatsEntry(0, 0, 0, 0))
228+
229+
230+
231+@Callable(i)
232+func lock (duration) = {
233+    let cfgArray = readConfigArrayOrFail()
234+    let assetIdStr = cfgArray[IdxCfgAssetId]
235+    let assetId = fromBase58String(assetIdStr)
236+    let minLockAmount = parseIntValue(cfgArray[IdxCfgMinLockAmount])
237+    let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
238+    let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
239+    let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
240+    if ((size(i.payments) != 1))
241+        then throw("invalid payment - exact one payment must be attached")
242+        else {
243+            let pmt = i.payments[0]
244+            let pmtAmount = pmt.amount
245+            if ((assetId != value(pmt.assetId)))
246+                then throw((("invalid asset is in payment - " + assetIdStr) + " is expected"))
247+                else {
248+                    let nextUserNumKEY = keyNextUserNum()
249+                    let userAddressStr = toString(i.caller)
250+                    let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
251+                    let userNumStr = if (userIsExisting)
252+                        then value(getString(keyUser2NumMapping(userAddressStr)))
253+                        else toString(getIntOrFail(nextUserNumKEY))
254+                    let userNum = parseIntValue(userNumStr)
255+                    let lockStart = height
256+                    let startBlockKEY = keyLockParamStartBlock(userNumStr)
257+                    let durationKEY = keyLockParamDuration(userNumStr)
258+                    let userAmountKEY = keyLockParamUserAmount(userNumStr)
259+                    let userAmount = getIntOrZero(userAmountKEY)
260+                    if ((minLockDuration > duration))
261+                        then throw(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
262+                        else if ((duration > maxLockDuration))
263+                            then throw(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
264+                            else if (if (userIsExisting)
265+                                then ((getIntOrFail(startBlockKEY) + getIntOrFail(durationKEY)) >= lockStart)
266+                                else false)
267+                                then throw("there is an active lock - consider to use increaseLock")
268+                                else {
269+                                    let gWxParamsResultList = asAnyList(invoke(mathContract, "calcGwxParamsREADONLY", [pmtAmount, lockStart, duration], nil))
270+                                    let k = asInt(gWxParamsResultList[0])
271+                                    let b = asInt(gWxParamsResultList[1])
272+                                    let period = toString(asInt(gWxParamsResultList[2]))
273+                                    let arr = if (userIsExisting)
274+                                        then nil
275+                                        else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
276+                                    (((arr ++ LockParamsEntry(userAddressStr, userNumStr, pmtAmount, lockStart, duration, k, b, period)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
277+                                        then 0
278+                                        else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, k, b, i))
279+                                    }
280+                    }
281+            }
282+    }
283+
284+
285+
286+@Callable(i)
287+func increaseLock (deltaDuration) = {
288+    let cfgArray = readConfigArrayOrFail()
289+    let assetIdStr = cfgArray[IdxCfgAssetId]
290+    let assetId = fromBase58String(assetIdStr)
291+    let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
292+    let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
293+    let pmtAmount = extractOptionalPaymentAmountOrFail(i, assetId)
294+    let userAddressStr = toString(i.caller)
295+    let userRecordArray = readLockParamsRecordOrFail(userAddressStr)
296+    let userNumStr = userRecordArray[IdxLockUserNum]
297+    let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
298+    let lockStart = parseIntValue(userRecordArray[IdxLockStart])
299+    let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
300+    let lockEnd = (lockStart + lockDuration)
301+    let newAmount = (userAmount + pmtAmount)
302+    let newLockDuration = (lockDuration + deltaDuration)
303+    if ((0 > deltaDuration))
304+        then throw("duration is less then zero")
305+        else if ((newLockDuration > maxLockDuration))
306+            then throw(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
307+            else if (if ((height >= lockEnd))
308+                then (userAmount > 0)
309+                else false)
310+                then throw("there is an expired lock - need to unlock before new lock")
311+                else {
312+                    let gWxParamsResultList = asAnyList(invoke(mathContract, "calcGwxParamsREADONLY", [newAmount, height, newLockDuration], nil))
313+                    let k = asInt(gWxParamsResultList[0])
314+                    let b = asInt(gWxParamsResultList[1])
315+                    let period = toString(asInt(gWxParamsResultList[2]))
316+                    ((LockParamsEntry(userAddressStr, userNumStr, newAmount, lockStart, newLockDuration, k, b, period) ++ StatsEntry(pmtAmount, deltaDuration, 0, 0)) :+ HistoryEntry("lock", userAddressStr, newAmount, lockStart, newLockDuration, k, b, i))
317+                    }
318+    }
319+
320+
321+
322+@Callable(i)
323+func unlock (userAddress) = {
324+    let userRecordArray = readLockParamsRecordOrFail(userAddress)
325+    let userNumStr = userRecordArray[IdxLockUserNum]
326+    let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
327+    let lockStart = parseIntValue(userRecordArray[IdxLockStart])
328+    let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
329+    let lockEnd = (lockStart + lockDuration)
330+    let cfgArray = readConfigArrayOrFail()
331+    let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
332+    if ((lockEnd >= height))
333+        then throw((("wait " + toString(lockEnd)) + " to unlock"))
334+        else if ((0 >= userAmount))
335+            then throw("nothing to unlock")
336+            else {
337+                let period = "0"
338+                (((LockParamsEntry(userAddress, userNumStr, 0, lockStart, lockDuration, 0, 0, period) ++ StatsEntry(-(userAmount), 0, 0, -1)) :+ HistoryEntry("unlock", userAddress, userAmount, lockStart, lockDuration, 0, 0, i)) :+ ScriptTransfer(addressFromStringValue(userAddress), userAmount, assetId))
339+                }
340+    }
341+
342+
343+
344+@Callable(i)
345+func gwxUserInfoREADONLY (userAddress) = {
346+    let EMPTY = "empty"
347+    let user2NumMappingKEY = keyUser2NumMapping(userAddress)
348+    let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
349+    let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
350+    let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
351+    let gwxAmountCalc = calcGwxAmount(k, b, height)
352+    let gwxAmount = if ((0 > gwxAmountCalc))
353+        then 0
354+        else gwxAmountCalc
355+    $Tuple2(nil, [gwxAmount])
356+    }
357+
358+
github/deemru/w8io/169f3d6 
40.88 ms ◑