tx · HhfmRkz453JW3yqDuvoz7KYVAYeCLQzFkEZUU2YJpUu9 3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV: -0.02900000 Waves 2023.01.13 15:23 [2403175] smart account 3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV > SELF 0.00000000 Waves
{ "type": 13, "id": "HhfmRkz453JW3yqDuvoz7KYVAYeCLQzFkEZUU2YJpUu9", "fee": 2900000, "feeAssetId": null, "timestamp": 1673612651165, "version": 1, "sender": "3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV", "senderPublicKey": "F4oaTkX67vt2MEsXLJJ8a7gaURGjW7x8fkvGfdEiH5oy", "proofs": [ "5xZZgoMbRe127xyCzizQrhAGWQxsQXVK2PFGtFMmP7Rnfej7PcPFEtT4ZqaF3CRzHMixWfXqsGvbxAYYE8YtWfZN" ], "script": "base64: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", "chainId": 84, "height": 2403175, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: GRmwVoE47idkiEzX845B8XUnpK2vGHmmYvKx1CJ25ovy Next: 5mJnL12qG3jGgiAu2os6j9BGBmSQZkjTDQ8m76rvmhqh Diff:
Old | New | Differences | |
---|---|---|---|
655 | 655 | let shareAssetBurn = if ((shareAssetInfo.issuer == this)) | |
656 | 656 | then invoke(this, "burn", [shareAssetId, shareAssetAmountToConvert], nil) | |
657 | 657 | else if ((shareAssetInfo.issuer == lpStakingContract)) | |
658 | - | then invoke(lpStakingContract, "burn", [shareAssetId, shareAssetAmountToConvert], | |
658 | + | then invoke(lpStakingContract, "burn", [shareAssetId, shareAssetAmountToConvert], [AttachedPayment(shareAssetId, shareAssetAmountToConvert)]) | |
659 | 659 | else throwErr("invalid share asset issuer") | |
660 | 660 | if ((shareAssetBurn == shareAssetBurn)) | |
661 | 661 | then { |
Old | New | Differences | |
---|---|---|---|
1 | 1 | {-# STDLIB_VERSION 6 #-} | |
2 | 2 | {-# SCRIPT_TYPE ACCOUNT #-} | |
3 | 3 | {-# CONTENT_TYPE DAPP #-} | |
4 | 4 | let separator = "__" | |
5 | 5 | ||
6 | 6 | let shareAssetDecimals = 8 | |
7 | 7 | ||
8 | 8 | let wavesString = "WAVES" | |
9 | 9 | ||
10 | 10 | let scale18 = 1000000000000000000 | |
11 | 11 | ||
12 | 12 | let scale18BigInt = toBigInt(scale18) | |
13 | 13 | ||
14 | 14 | func wrapErr (msg) = makeString(["lp_staking_pools.ride:", msg], " ") | |
15 | 15 | ||
16 | 16 | ||
17 | 17 | func throwErr (msg) = throw(wrapErr(msg)) | |
18 | 18 | ||
19 | 19 | ||
20 | 20 | func errKeyIsNotDefined (address,key) = wrapErr(makeString(["mandatory ", toString(address), ".", key, " is not defined"], "")) | |
21 | 21 | ||
22 | 22 | ||
23 | 23 | func getStrOrFail (address,key) = valueOrErrorMessage(getString(address, key), errKeyIsNotDefined(address, key)) | |
24 | 24 | ||
25 | 25 | ||
26 | 26 | func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), errKeyIsNotDefined(address, key)) | |
27 | 27 | ||
28 | 28 | ||
29 | 29 | func parseAssetId (input) = if ((input == wavesString)) | |
30 | 30 | then unit | |
31 | 31 | else fromBase58String(input) | |
32 | 32 | ||
33 | 33 | ||
34 | 34 | func assetIdToString (input) = if ((input == unit)) | |
35 | 35 | then wavesString | |
36 | 36 | else toBase58String(value(input)) | |
37 | 37 | ||
38 | 38 | ||
39 | 39 | func ensurePositive (v) = if ((v >= 0)) | |
40 | 40 | then v | |
41 | 41 | else throwErr("value should be positive") | |
42 | 42 | ||
43 | 43 | ||
44 | 44 | func keyFactoryContract () = makeString(["%s", "factoryContract"], separator) | |
45 | 45 | ||
46 | 46 | ||
47 | 47 | func keyLpStakingContract () = makeString(["%s", "lpStakingContract"], separator) | |
48 | 48 | ||
49 | 49 | ||
50 | 50 | func keyStakingContract () = makeString(["%s", "stakingContract"], separator) | |
51 | 51 | ||
52 | 52 | ||
53 | 53 | func keyBoostingContract () = makeString(["%s", "boostingContract"], separator) | |
54 | 54 | ||
55 | 55 | ||
56 | 56 | func keySwapContract () = makeString(["%s", "swapContract"], separator) | |
57 | 57 | ||
58 | 58 | ||
59 | 59 | func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], separator) | |
60 | 60 | ||
61 | 61 | ||
62 | 62 | func keyUsdnAssetId () = makeString(["%s", "usdnAssetId"], separator) | |
63 | 63 | ||
64 | 64 | ||
65 | 65 | func keyWxAssetId () = makeString(["%s", "wxAssetId"], separator) | |
66 | 66 | ||
67 | 67 | ||
68 | 68 | func keyShutdown () = makeString(["%s", "shutdown"], separator) | |
69 | 69 | ||
70 | 70 | ||
71 | 71 | func keyMinDelay () = makeString(["%s", "minDelay"], separator) | |
72 | 72 | ||
73 | 73 | ||
74 | 74 | func keyLockFraction () = makeString(["%s", "lockFraction"], separator) | |
75 | 75 | ||
76 | 76 | ||
77 | 77 | func keyShareAssetId (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetId"], separator) | |
78 | 78 | ||
79 | 79 | ||
80 | 80 | func keyBaseAssetId (shareAssetId) = makeString(["%s%s", assetIdToString(shareAssetId), "baseAssetId"], separator) | |
81 | 81 | ||
82 | 82 | ||
83 | 83 | func keyPeriod (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "period"], separator) | |
84 | 84 | ||
85 | 85 | ||
86 | 86 | func keyPeriodStartHeight (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "periodStartHeight", toString(period)], separator) | |
87 | 87 | ||
88 | 88 | ||
89 | 89 | func keyBaseAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "baseAssetAmountToConvert"], separator) | |
90 | 90 | ||
91 | 91 | ||
92 | 92 | func keyShareAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetAmountToConvert"], separator) | |
93 | 93 | ||
94 | 94 | ||
95 | 95 | func keyUserBaseAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert"], separator) | |
96 | 96 | ||
97 | 97 | ||
98 | 98 | func keyUserBaseAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert", "period"], separator) | |
99 | 99 | ||
100 | 100 | ||
101 | 101 | func keyUserShareAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert"], separator) | |
102 | 102 | ||
103 | 103 | ||
104 | 104 | func keyUserShareAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert", "period"], separator) | |
105 | 105 | ||
106 | 106 | ||
107 | 107 | func keyPricePeriod (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "price", toString(period)], separator) | |
108 | 108 | ||
109 | 109 | ||
110 | 110 | func keyPriceHistory (baseAssetId) = makeString(["%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", toString(lastBlock.height), toString(lastBlock.timestamp)], separator) | |
111 | 111 | ||
112 | 112 | ||
113 | 113 | func keyPricePeriodPut (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "put"], separator) | |
114 | 114 | ||
115 | 115 | ||
116 | 116 | func keyPricePutHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "put", toString(lastBlock.height), toString(lastBlock.timestamp)], separator) | |
117 | 117 | ||
118 | 118 | ||
119 | 119 | func keyPricePeriodGet (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "get"], separator) | |
120 | 120 | ||
121 | 121 | ||
122 | 122 | func keyPriceGetHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "get", toString(lastBlock.height), toString(lastBlock.timestamp)], separator) | |
123 | 123 | ||
124 | 124 | ||
125 | 125 | func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", operation, toString(userAddress), toBase58String(txId), toString(height)], separator) | |
126 | 126 | ||
127 | 127 | ||
128 | 128 | func keyManagerPublicKey () = "%s__managerPublicKey" | |
129 | 129 | ||
130 | 130 | ||
131 | 131 | func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey" | |
132 | 132 | ||
133 | 133 | ||
134 | 134 | func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) { | |
135 | 135 | case s: String => | |
136 | 136 | fromBase58String(s) | |
137 | 137 | case _: Unit => | |
138 | 138 | unit | |
139 | 139 | case _ => | |
140 | 140 | throw("Match error") | |
141 | 141 | } | |
142 | 142 | ||
143 | 143 | ||
144 | 144 | func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) { | |
145 | 145 | case s: String => | |
146 | 146 | fromBase58String(s) | |
147 | 147 | case _: Unit => | |
148 | 148 | unit | |
149 | 149 | case _ => | |
150 | 150 | throw("Match error") | |
151 | 151 | } | |
152 | 152 | ||
153 | 153 | ||
154 | 154 | let permissionDeniedError = throw("Permission denied") | |
155 | 155 | ||
156 | 156 | func mustThis (i) = if ((i.caller == this)) | |
157 | 157 | then true | |
158 | 158 | else permissionDeniedError | |
159 | 159 | ||
160 | 160 | ||
161 | 161 | func mustManager (i) = match managerPublicKeyOrUnit() { | |
162 | 162 | case pk: ByteVector => | |
163 | 163 | if ((i.callerPublicKey == pk)) | |
164 | 164 | then true | |
165 | 165 | else permissionDeniedError | |
166 | 166 | case _: Unit => | |
167 | 167 | mustThis(i) | |
168 | 168 | case _ => | |
169 | 169 | throw("Match error") | |
170 | 170 | } | |
171 | 171 | ||
172 | 172 | ||
173 | 173 | let shutdown = valueOrElse(getBoolean(keyShutdown()), false) | |
174 | 174 | ||
175 | 175 | func shutdownCheck (i) = if (if (!(shutdown)) | |
176 | 176 | then true | |
177 | 177 | else mustManager(i)) | |
178 | 178 | then true | |
179 | 179 | else throw("operation is disabled") | |
180 | 180 | ||
181 | 181 | ||
182 | 182 | let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract())) | |
183 | 183 | ||
184 | 184 | let lpStakingContract = addressFromStringValue(getStrOrFail(this, keyLpStakingContract())) | |
185 | 185 | ||
186 | 186 | let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract())) | |
187 | 187 | ||
188 | 188 | let boostingContract = addressFromStringValue(getStrOrFail(this, keyBoostingContract())) | |
189 | 189 | ||
190 | 190 | let swapContract = addressFromStringValue(getStrOrFail(this, keySwapContract())) | |
191 | 191 | ||
192 | 192 | let assetsStoreContract = addressFromStringValue(getStrOrFail(this, keyAssetsStoreContract())) | |
193 | 193 | ||
194 | 194 | let usdnAssetId = parseAssetId(getStrOrFail(this, keyUsdnAssetId())) | |
195 | 195 | ||
196 | 196 | let wxAssetId = parseAssetId(getStrOrFail(this, keyWxAssetId())) | |
197 | 197 | ||
198 | 198 | let minDelayDefault = 1440 | |
199 | 199 | ||
200 | 200 | let minDelay = valueOrElse(getInteger(this, keyMinDelay()), minDelayDefault) | |
201 | 201 | ||
202 | 202 | let lockFractionMultiplier = 100000000 | |
203 | 203 | ||
204 | 204 | let lockFractionDefault = fraction(1, lockFractionMultiplier, 2) | |
205 | 205 | ||
206 | 206 | let lockFraction = valueOrElse(getInteger(this, keyLockFraction()), lockFractionDefault) | |
207 | 207 | ||
208 | 208 | func getPoolInfo (amountAssetId) = { | |
209 | 209 | let amountAssetIdStr = assetIdToString(amountAssetId) | |
210 | 210 | let priceAssetIdStr = assetIdToString(usdnAssetId) | |
211 | 211 | let poolInfoOption = { | |
212 | 212 | let @ = invoke(factoryContract, "poolInfoREADONLY", [amountAssetIdStr, priceAssetIdStr], nil) | |
213 | 213 | if ($isInstanceOf(@, "(Address, ByteVector)")) | |
214 | 214 | then @ | |
215 | 215 | else unit | |
216 | 216 | } | |
217 | 217 | poolInfoOption | |
218 | 218 | } | |
219 | 219 | ||
220 | 220 | ||
221 | 221 | func calcPrice (lpAssetId,shareAssetId) = { | |
222 | 222 | let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info") | |
223 | 223 | let shareAssetEmission = shareAssetInfo.quantity | |
224 | 224 | let stakedAmount = ensurePositive(valueOrErrorMessage({ | |
225 | 225 | let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil) | |
226 | 226 | if ($isInstanceOf(@, "Int")) | |
227 | 227 | then @ | |
228 | 228 | else unit | |
229 | 229 | }, wrapErr("invalid stakedByUserREADONLY result"))) | |
230 | 230 | let price = if ((shareAssetEmission == 0)) | |
231 | 231 | then scale18BigInt | |
232 | 232 | else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR) | |
233 | 233 | price | |
234 | 234 | } | |
235 | 235 | ||
236 | 236 | ||
237 | 237 | @Callable(i) | |
238 | 238 | func setManager (pendingManagerPublicKey) = { | |
239 | 239 | let checkCaller = mustManager(i) | |
240 | 240 | if ((checkCaller == checkCaller)) | |
241 | 241 | then { | |
242 | 242 | let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey) | |
243 | 243 | if ((checkManagerPublicKey == checkManagerPublicKey)) | |
244 | 244 | then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)] | |
245 | 245 | else throw("Strict value is not equal to itself.") | |
246 | 246 | } | |
247 | 247 | else throw("Strict value is not equal to itself.") | |
248 | 248 | } | |
249 | 249 | ||
250 | 250 | ||
251 | 251 | ||
252 | 252 | @Callable(i) | |
253 | 253 | func confirmManager () = { | |
254 | 254 | let pm = pendingManagerPublicKeyOrUnit() | |
255 | 255 | let hasPM = if (isDefined(pm)) | |
256 | 256 | then true | |
257 | 257 | else throwErr("no pending manager") | |
258 | 258 | if ((hasPM == hasPM)) | |
259 | 259 | then { | |
260 | 260 | let checkPM = if ((i.callerPublicKey == value(pm))) | |
261 | 261 | then true | |
262 | 262 | else throwErr("you are not pending manager") | |
263 | 263 | if ((checkPM == checkPM)) | |
264 | 264 | then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())] | |
265 | 265 | else throw("Strict value is not equal to itself.") | |
266 | 266 | } | |
267 | 267 | else throw("Strict value is not equal to itself.") | |
268 | 268 | } | |
269 | 269 | ||
270 | 270 | ||
271 | 271 | ||
272 | 272 | @Callable(i) | |
273 | 273 | func emit (assetId,amount) = { | |
274 | 274 | let checkCaller = mustThis(i) | |
275 | 275 | if ((checkCaller == checkCaller)) | |
276 | 276 | then { | |
277 | 277 | let isReissuable = true | |
278 | 278 | $Tuple2([Reissue(assetId, amount, isReissuable)], amount) | |
279 | 279 | } | |
280 | 280 | else throw("Strict value is not equal to itself.") | |
281 | 281 | } | |
282 | 282 | ||
283 | 283 | ||
284 | 284 | ||
285 | 285 | @Callable(i) | |
286 | 286 | func burn (assetId,amount) = { | |
287 | 287 | let checkCaller = mustThis(i) | |
288 | 288 | if ((checkCaller == checkCaller)) | |
289 | 289 | then $Tuple2([Burn(assetId, amount)], amount) | |
290 | 290 | else throw("Strict value is not equal to itself.") | |
291 | 291 | } | |
292 | 292 | ||
293 | 293 | ||
294 | 294 | ||
295 | 295 | @Callable(i) | |
296 | 296 | func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = { | |
297 | 297 | let shareAssetLabel = "LP_STAKING_POOLS" | |
298 | 298 | let baseAssetId = parseAssetId(baseAssetIdStr) | |
299 | 299 | let checks = [mustManager(i), if (isDefined(getPoolInfo(baseAssetId))) | |
300 | 300 | then true | |
301 | 301 | else throwErr("invalid base asset")] | |
302 | 302 | if ((checks == checks)) | |
303 | 303 | then { | |
304 | 304 | let commonState = [IntegerEntry(keyPeriod(baseAssetId), 0)] | |
305 | 305 | if ((shareAssetIdStr == "")) | |
306 | 306 | then { | |
307 | 307 | let shareAssetIssueAmount = 1 | |
308 | 308 | let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescription, shareAssetIssueAmount, shareAssetDecimals, true) | |
309 | 309 | let calculatedShareAssetId = calculateAssetId(shareAssetIssueAction) | |
310 | 310 | let shareAssetBurnAction = Burn(calculatedShareAssetId, shareAssetIssueAmount) | |
311 | 311 | let calculatedShareAssetIdStr = toBase58String(calculatedShareAssetId) | |
312 | 312 | let createOrUpdate = invoke(assetsStoreContract, "createOrUpdate", [calculatedShareAssetIdStr, shareAssetLogo, false], nil) | |
313 | 313 | if ((createOrUpdate == createOrUpdate)) | |
314 | 314 | then { | |
315 | 315 | let addLabel = invoke(assetsStoreContract, "addLabel", [calculatedShareAssetIdStr, shareAssetLabel], nil) | |
316 | 316 | if ((addLabel == addLabel)) | |
317 | 317 | then $Tuple2((commonState ++ [shareAssetIssueAction, shareAssetBurnAction, StringEntry(keyShareAssetId(baseAssetId), calculatedShareAssetIdStr), StringEntry(keyBaseAssetId(calculatedShareAssetId), baseAssetIdStr)]), calculatedShareAssetIdStr) | |
318 | 318 | else throw("Strict value is not equal to itself.") | |
319 | 319 | } | |
320 | 320 | else throw("Strict value is not equal to itself.") | |
321 | 321 | } | |
322 | 322 | else { | |
323 | 323 | let shareAssetId = fromBase58String(shareAssetIdStr) | |
324 | 324 | let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id")) | |
325 | 325 | let checkIssuer = if ((shareAssetInfo.issuer == lpStakingContract)) | |
326 | 326 | then true | |
327 | 327 | else throwErr("invalid share asset id issuer") | |
328 | 328 | if ((checkIssuer == checkIssuer)) | |
329 | 329 | then $Tuple2((commonState ++ [StringEntry(keyShareAssetId(baseAssetId), shareAssetIdStr), StringEntry(keyBaseAssetId(shareAssetId), baseAssetIdStr)]), shareAssetIdStr) | |
330 | 330 | else throw("Strict value is not equal to itself.") | |
331 | 331 | } | |
332 | 332 | } | |
333 | 333 | else throw("Strict value is not equal to itself.") | |
334 | 334 | } | |
335 | 335 | ||
336 | 336 | ||
337 | 337 | ||
338 | 338 | @Callable(i) | |
339 | 339 | func put () = { | |
340 | 340 | let pmt = if ((size(i.payments) == 1)) | |
341 | 341 | then i.payments[0] | |
342 | 342 | else throwErr("exactly 1 payment is expected") | |
343 | 343 | let baseAssetId = pmt.assetId | |
344 | 344 | let userAddress = i.caller | |
345 | 345 | let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId)))) | |
346 | 346 | then true | |
347 | 347 | else throwErr("invalid asset")] | |
348 | 348 | if ((checks == checks)) | |
349 | 349 | then { | |
350 | 350 | let $t01164511748 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset")) | |
351 | 351 | let poolAddress = $t01164511748._1 | |
352 | 352 | let lpAssetId = $t01164511748._2 | |
353 | 353 | let period = value(getInteger(keyPeriod(baseAssetId))) | |
354 | 354 | let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)) | |
355 | 355 | let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit)) | |
356 | 356 | then unit | |
357 | 357 | else { | |
358 | 358 | let userBaseAssetAmountToConvertPeriod = value(userBaseAssetAmountToConvertPeriodOption) | |
359 | 359 | if ((userBaseAssetAmountToConvertPeriod == period)) | |
360 | 360 | then unit | |
361 | 361 | else invoke(this, "claimShareAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil) | |
362 | 362 | } | |
363 | 363 | if ((claimShareAssetInvocation == claimShareAssetInvocation)) | |
364 | 364 | then { | |
365 | 365 | let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0) | |
366 | 366 | let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0) | |
367 | 367 | $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), (userBaseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), pmt.amount)], unit) | |
368 | 368 | } | |
369 | 369 | else throw("Strict value is not equal to itself.") | |
370 | 370 | } | |
371 | 371 | else throw("Strict value is not equal to itself.") | |
372 | 372 | } | |
373 | 373 | ||
374 | 374 | ||
375 | 375 | ||
376 | 376 | @Callable(i) | |
377 | 377 | func claimShareAsset (baseAssetIdStr,userAddressStr) = { | |
378 | 378 | let checks = [shutdownCheck(i)] | |
379 | 379 | if ((checks == checks)) | |
380 | 380 | then { | |
381 | 381 | let userAddress = if ((userAddressStr == "")) | |
382 | 382 | then i.caller | |
383 | 383 | else { | |
384 | 384 | let checkCaller = mustThis(i) | |
385 | 385 | if ((checkCaller == checkCaller)) | |
386 | 386 | then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address")) | |
387 | 387 | else throw("Strict value is not equal to itself.") | |
388 | 388 | } | |
389 | 389 | if ((userAddress == userAddress)) | |
390 | 390 | then { | |
391 | 391 | let baseAssetId = parseAssetId(baseAssetIdStr) | |
392 | 392 | let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id")))) | |
393 | 393 | if ((shareAssetId == shareAssetId)) | |
394 | 394 | then { | |
395 | 395 | let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period")) | |
396 | 396 | if ((period == period)) | |
397 | 397 | then { | |
398 | 398 | let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0) | |
399 | 399 | let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0)) | |
400 | 400 | then true | |
401 | 401 | else throwErr("nothing to claim") | |
402 | 402 | if ((checkAmountToConvert == checkAmountToConvert)) | |
403 | 403 | then { | |
404 | 404 | let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period")) | |
405 | 405 | let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod)) | |
406 | 406 | then true | |
407 | 407 | else throwErr("invalid period") | |
408 | 408 | if ((checkPeriod == checkPeriod)) | |
409 | 409 | then { | |
410 | 410 | let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price"))) | |
411 | 411 | let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price)) | |
412 | 412 | $Tuple2([IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), 0), DeleteEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), shareAssetAmount)], unit) | |
413 | 413 | } | |
414 | 414 | else throw("Strict value is not equal to itself.") | |
415 | 415 | } | |
416 | 416 | else throw("Strict value is not equal to itself.") | |
417 | 417 | } | |
418 | 418 | else throw("Strict value is not equal to itself.") | |
419 | 419 | } | |
420 | 420 | else throw("Strict value is not equal to itself.") | |
421 | 421 | } | |
422 | 422 | else throw("Strict value is not equal to itself.") | |
423 | 423 | } | |
424 | 424 | else throw("Strict value is not equal to itself.") | |
425 | 425 | } | |
426 | 426 | ||
427 | 427 | ||
428 | 428 | ||
429 | 429 | @Callable(i) | |
430 | 430 | func get () = { | |
431 | 431 | let checks = [shutdownCheck(i)] | |
432 | 432 | if ((checks == checks)) | |
433 | 433 | then { | |
434 | 434 | let pmt = if ((size(i.payments) == 1)) | |
435 | 435 | then i.payments[0] | |
436 | 436 | else throwErr("exactly 1 payment is expected") | |
437 | 437 | let shareAssetId = pmt.assetId | |
438 | 438 | let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id")))) | |
439 | 439 | if ((baseAssetId == baseAssetId)) | |
440 | 440 | then { | |
441 | 441 | let userAddress = i.caller | |
442 | 442 | let $t01553015633 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset")) | |
443 | 443 | let poolAddress = $t01553015633._1 | |
444 | 444 | let lpAssetId = $t01553015633._2 | |
445 | 445 | let period = value(getInteger(keyPeriod(baseAssetId))) | |
446 | 446 | let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)) | |
447 | 447 | let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit)) | |
448 | 448 | then unit | |
449 | 449 | else { | |
450 | 450 | let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption) | |
451 | 451 | if ((userShareAssetAmountToConvertPeriod == period)) | |
452 | 452 | then unit | |
453 | 453 | else invoke(this, "claimBaseAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil) | |
454 | 454 | } | |
455 | 455 | if ((claimBaseAssetInvocation == claimBaseAssetInvocation)) | |
456 | 456 | then { | |
457 | 457 | let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0) | |
458 | 458 | let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0) | |
459 | 459 | $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), (userShareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), pmt.amount)], unit) | |
460 | 460 | } | |
461 | 461 | else throw("Strict value is not equal to itself.") | |
462 | 462 | } | |
463 | 463 | else throw("Strict value is not equal to itself.") | |
464 | 464 | } | |
465 | 465 | else throw("Strict value is not equal to itself.") | |
466 | 466 | } | |
467 | 467 | ||
468 | 468 | ||
469 | 469 | ||
470 | 470 | @Callable(i) | |
471 | 471 | func claimBaseAsset (baseAssetIdStr,userAddressStr) = { | |
472 | 472 | let checks = [shutdownCheck(i)] | |
473 | 473 | if ((checks == checks)) | |
474 | 474 | then { | |
475 | 475 | let userAddress = if ((userAddressStr == "")) | |
476 | 476 | then i.caller | |
477 | 477 | else { | |
478 | 478 | let checkCaller = mustThis(i) | |
479 | 479 | if ((checkCaller == checkCaller)) | |
480 | 480 | then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address")) | |
481 | 481 | else throw("Strict value is not equal to itself.") | |
482 | 482 | } | |
483 | 483 | if ((userAddress == userAddress)) | |
484 | 484 | then { | |
485 | 485 | let baseAssetId = parseAssetId(baseAssetIdStr) | |
486 | 486 | let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id")))) | |
487 | 487 | if ((shareAssetId == shareAssetId)) | |
488 | 488 | then { | |
489 | 489 | let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period")) | |
490 | 490 | if ((period == period)) | |
491 | 491 | then { | |
492 | 492 | let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0) | |
493 | 493 | let checkAmountToConvert = if ((userShareAssetAmountToConvert > 0)) | |
494 | 494 | then true | |
495 | 495 | else throwErr("nothing to claim") | |
496 | 496 | if ((checkAmountToConvert == checkAmountToConvert)) | |
497 | 497 | then { | |
498 | 498 | let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period")) | |
499 | 499 | let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod)) | |
500 | 500 | then true | |
501 | 501 | else throwErr("invalid period") | |
502 | 502 | if ((checkPeriod == checkPeriod)) | |
503 | 503 | then { | |
504 | 504 | let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price"))) | |
505 | 505 | let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt)) | |
506 | 506 | $Tuple2([IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), 0), DeleteEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), baseAssetAmount)], unit) | |
507 | 507 | } | |
508 | 508 | else throw("Strict value is not equal to itself.") | |
509 | 509 | } | |
510 | 510 | else throw("Strict value is not equal to itself.") | |
511 | 511 | } | |
512 | 512 | else throw("Strict value is not equal to itself.") | |
513 | 513 | } | |
514 | 514 | else throw("Strict value is not equal to itself.") | |
515 | 515 | } | |
516 | 516 | else throw("Strict value is not equal to itself.") | |
517 | 517 | } | |
518 | 518 | else throw("Strict value is not equal to itself.") | |
519 | 519 | } | |
520 | 520 | ||
521 | 521 | ||
522 | 522 | ||
523 | 523 | @Callable(i) | |
524 | 524 | func finalize (baseAssetIdStr) = { | |
525 | 525 | let checks = [shutdownCheck(i)] | |
526 | 526 | if ((checks == checks)) | |
527 | 527 | then { | |
528 | 528 | let baseAssetId = parseAssetId(baseAssetIdStr) | |
529 | 529 | let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id")))) | |
530 | 530 | if ((shareAssetId == shareAssetId)) | |
531 | 531 | then { | |
532 | 532 | let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id")) | |
533 | 533 | let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period")) | |
534 | 534 | if ((period == period)) | |
535 | 535 | then { | |
536 | 536 | let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period)) | |
537 | 537 | let checkDelay = if ((periodStartHeightOption == unit)) | |
538 | 538 | then unit | |
539 | 539 | else { | |
540 | 540 | let delay = (height - value(periodStartHeightOption)) | |
541 | 541 | let blocksToWait = max([0, (minDelay - delay)]) | |
542 | 542 | if ((blocksToWait == 0)) | |
543 | 543 | then unit | |
544 | 544 | else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], "")) | |
545 | 545 | } | |
546 | 546 | if ((checkDelay == checkDelay)) | |
547 | 547 | then { | |
548 | 548 | let $t01980319984 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset")) | |
549 | 549 | let poolAddress = $t01980319984._1 | |
550 | 550 | let lpAssetId = $t01980319984._2 | |
551 | 551 | let stakingReward = valueOrErrorMessage({ | |
552 | 552 | let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil) | |
553 | 553 | if ($isInstanceOf(@, "Int")) | |
554 | 554 | then @ | |
555 | 555 | else unit | |
556 | 556 | }, wrapErr("invalid claimWx result")) | |
557 | 557 | if ((stakingReward == stakingReward)) | |
558 | 558 | then { | |
559 | 559 | let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0) | |
560 | 560 | let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0) | |
561 | 561 | let checkFinalizationIsRequired = { | |
562 | 562 | let isFinalizationRequired = if (if ((stakingReward > 0)) | |
563 | 563 | then true | |
564 | 564 | else (baseAssetAmountToConvert > 0)) | |
565 | 565 | then true | |
566 | 566 | else (shareAssetAmountToConvert > 0) | |
567 | 567 | if (isFinalizationRequired) | |
568 | 568 | then true | |
569 | 569 | else throwErr("nothing to finalize") | |
570 | 570 | } | |
571 | 571 | if ((checkFinalizationIsRequired == checkFinalizationIsRequired)) | |
572 | 572 | then { | |
573 | 573 | let useStakingReward = if ((stakingReward > 0)) | |
574 | 574 | then { | |
575 | 575 | let lockPart = fraction(stakingReward, lockFraction, lockFractionMultiplier) | |
576 | 576 | let convertPart = (stakingReward - lockPart) | |
577 | 577 | let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil) | |
578 | 578 | let lock = if ((lockPart > 0)) | |
579 | 579 | then match r { | |
580 | 580 | case _ => | |
581 | 581 | if (if (if ($isInstanceOf($match0._1, "String")) | |
582 | 582 | then $isInstanceOf($match0._2, "Int") | |
583 | 583 | else false) | |
584 | 584 | then $isInstanceOf($match0, "(String, Int)") | |
585 | 585 | else false) | |
586 | 586 | then { | |
587 | 587 | let function = $match0._1 | |
588 | 588 | let duration = $match0._2 | |
589 | 589 | if ((lockPart > 0)) | |
590 | 590 | then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)]) | |
591 | 591 | else unit | |
592 | 592 | } | |
593 | 593 | else throwErr("invalid lock params") | |
594 | 594 | } | |
595 | 595 | else unit | |
596 | 596 | if ((lock == lock)) | |
597 | 597 | then { | |
598 | 598 | let convertedAmount = if ((convertPart > 0)) | |
599 | 599 | then { | |
600 | 600 | let inAssetId = wxAssetId | |
601 | 601 | let minimumToReceive = 0 | |
602 | 602 | let outAssetIdStr = assetIdToString(usdnAssetId) | |
603 | 603 | let targetAddress = "" | |
604 | 604 | valueOrErrorMessage({ | |
605 | 605 | let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)]) | |
606 | 606 | if ($isInstanceOf(@, "Int")) | |
607 | 607 | then @ | |
608 | 608 | else unit | |
609 | 609 | }, wrapErr("invalid swap result")) | |
610 | 610 | } | |
611 | 611 | else 0 | |
612 | 612 | if ((convertedAmount == convertedAmount)) | |
613 | 613 | then { | |
614 | 614 | let lpAssetAmount = if ((convertedAmount > 0)) | |
615 | 615 | then { | |
616 | 616 | let minOutAmount = 0 | |
617 | 617 | let autoStake = true | |
618 | 618 | valueOrErrorMessage({ | |
619 | 619 | let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdnAssetId, convertedAmount)]) | |
620 | 620 | if ($isInstanceOf(@, "Int")) | |
621 | 621 | then @ | |
622 | 622 | else unit | |
623 | 623 | }, wrapErr("invalid putOneTknV2 result")) | |
624 | 624 | } | |
625 | 625 | else 0 | |
626 | 626 | if ((lpAssetAmount == lpAssetAmount)) | |
627 | 627 | then lpAssetAmount | |
628 | 628 | else throw("Strict value is not equal to itself.") | |
629 | 629 | } | |
630 | 630 | else throw("Strict value is not equal to itself.") | |
631 | 631 | } | |
632 | 632 | else throw("Strict value is not equal to itself.") | |
633 | 633 | } | |
634 | 634 | else unit | |
635 | 635 | if ((useStakingReward == useStakingReward)) | |
636 | 636 | then { | |
637 | 637 | let getActions = if ((shareAssetAmountToConvert > 0)) | |
638 | 638 | then { | |
639 | 639 | let price = calcPrice(lpAssetId, shareAssetId) | |
640 | 640 | if ((price == price)) | |
641 | 641 | then { | |
642 | 642 | let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR)) | |
643 | 643 | let baseAssetAmount = { | |
644 | 644 | let outAssetId = baseAssetId | |
645 | 645 | let minOutAmount = 0 | |
646 | 646 | valueOrErrorMessage({ | |
647 | 647 | let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil) | |
648 | 648 | if ($isInstanceOf(@, "Int")) | |
649 | 649 | then @ | |
650 | 650 | else unit | |
651 | 651 | }, wrapErr("invalid unstakeAndGetOneTknV2 result")) | |
652 | 652 | } | |
653 | 653 | if ((baseAssetAmount == baseAssetAmount)) | |
654 | 654 | then { | |
655 | 655 | let shareAssetBurn = if ((shareAssetInfo.issuer == this)) | |
656 | 656 | then invoke(this, "burn", [shareAssetId, shareAssetAmountToConvert], nil) | |
657 | 657 | else if ((shareAssetInfo.issuer == lpStakingContract)) | |
658 | - | then invoke(lpStakingContract, "burn", [shareAssetId, shareAssetAmountToConvert], | |
658 | + | then invoke(lpStakingContract, "burn", [shareAssetId, shareAssetAmountToConvert], [AttachedPayment(shareAssetId, shareAssetAmountToConvert)]) | |
659 | 659 | else throwErr("invalid share asset issuer") | |
660 | 660 | if ((shareAssetBurn == shareAssetBurn)) | |
661 | 661 | then { | |
662 | 662 | let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR) | |
663 | 663 | let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))] | |
664 | 664 | priceGetUpdateActions | |
665 | 665 | } | |
666 | 666 | else throw("Strict value is not equal to itself.") | |
667 | 667 | } | |
668 | 668 | else throw("Strict value is not equal to itself.") | |
669 | 669 | } | |
670 | 670 | else throw("Strict value is not equal to itself.") | |
671 | 671 | } | |
672 | 672 | else nil | |
673 | 673 | if ((getActions == getActions)) | |
674 | 674 | then { | |
675 | 675 | let putActions = if ((baseAssetAmountToConvert > 0)) | |
676 | 676 | then { | |
677 | 677 | let lpAssetAmount = { | |
678 | 678 | let minOutAmount = 0 | |
679 | 679 | let autoStake = true | |
680 | 680 | valueOrErrorMessage({ | |
681 | 681 | let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)]) | |
682 | 682 | if ($isInstanceOf(@, "Int")) | |
683 | 683 | then @ | |
684 | 684 | else unit | |
685 | 685 | }, wrapErr("invalid putOneTknV2 result")) | |
686 | 686 | } | |
687 | 687 | if ((lpAssetAmount == lpAssetAmount)) | |
688 | 688 | then { | |
689 | 689 | let price = calcPrice(lpAssetId, shareAssetId) | |
690 | 690 | if ((price == price)) | |
691 | 691 | then { | |
692 | 692 | let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR)) | |
693 | 693 | let shareAssetReissue = if ((shareAssetInfo.issuer == this)) | |
694 | 694 | then invoke(this, "emit", [shareAssetId, shareAssetAmount], nil) | |
695 | 695 | else if ((shareAssetInfo.issuer == lpStakingContract)) | |
696 | 696 | then invoke(lpStakingContract, "emit", [shareAssetId, shareAssetAmount], nil) | |
697 | 697 | else throwErr("invalid share asset issuer") | |
698 | 698 | if ((shareAssetReissue == shareAssetReissue)) | |
699 | 699 | then { | |
700 | 700 | let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount)) | |
701 | 701 | let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))] | |
702 | 702 | pricePutUpdateActions | |
703 | 703 | } | |
704 | 704 | else throw("Strict value is not equal to itself.") | |
705 | 705 | } | |
706 | 706 | else throw("Strict value is not equal to itself.") | |
707 | 707 | } | |
708 | 708 | else throw("Strict value is not equal to itself.") | |
709 | 709 | } | |
710 | 710 | else nil | |
711 | 711 | if ((putActions == putActions)) | |
712 | 712 | then { | |
713 | 713 | let newPeriod = (period + 1) | |
714 | 714 | let lastPrice = calcPrice(lpAssetId, shareAssetId) | |
715 | 715 | let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(lastPrice)), StringEntry(keyPriceHistory(baseAssetId), toString(lastPrice))] ++ putActions) ++ getActions) | |
716 | 716 | $Tuple2(actions, toBytes(lastPrice)) | |
717 | 717 | } | |
718 | 718 | else throw("Strict value is not equal to itself.") | |
719 | 719 | } | |
720 | 720 | else throw("Strict value is not equal to itself.") | |
721 | 721 | } | |
722 | 722 | else throw("Strict value is not equal to itself.") | |
723 | 723 | } | |
724 | 724 | else throw("Strict value is not equal to itself.") | |
725 | 725 | } | |
726 | 726 | else throw("Strict value is not equal to itself.") | |
727 | 727 | } | |
728 | 728 | else throw("Strict value is not equal to itself.") | |
729 | 729 | } | |
730 | 730 | else throw("Strict value is not equal to itself.") | |
731 | 731 | } | |
732 | 732 | else throw("Strict value is not equal to itself.") | |
733 | 733 | } | |
734 | 734 | else throw("Strict value is not equal to itself.") | |
735 | 735 | } | |
736 | 736 | ||
737 | 737 | ||
738 | 738 | @Verifier(tx) | |
739 | 739 | func verify () = { | |
740 | 740 | let targetPublicKey = match managerPublicKeyOrUnit() { | |
741 | 741 | case pk: ByteVector => | |
742 | 742 | pk | |
743 | 743 | case _: Unit => | |
744 | 744 | tx.senderPublicKey | |
745 | 745 | case _ => | |
746 | 746 | throw("Match error") | |
747 | 747 | } | |
748 | 748 | sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey) | |
749 | 749 | } | |
750 | 750 |
github/deemru/w8io/fabc49c 70.61 ms ◑